fs/read_write.c

   1 /*
   2  *  linux/fs/read_write.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/slab.h>
   8 #include <linux/stat.h>
   9 #include <linux/fcntl.h>
  10 #include <linux/file.h>
  11 #include <linux/uio.h>
  12 #include <linux/aio.h>
  13 #include <linux/fsnotify.h>
  14 #include <linux/security.h>
  15 #include <linux/export.h>
  16 #include <linux/syscalls.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/splice.h>
  19 #include <linux/compat.h>
  20 #include "internal.h"
  21
  22 #include <asm/uaccess.h>
  23 #include <asm/unistd.h>
  24
  25 typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
  26 typedef ssize_t (*iov_fn_t)(struct kiocb *, const struct iovec *,
  27                 unsigned long, loff_t);
  28 typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *);
  29
  30 const struct file_operations generic_ro_fops = {
  31         .llseek         = generic_file_llseek,
  32         .read           = new_sync_read,
  33         .read_iter      = generic_file_read_iter,
  34         .mmap           = generic_file_readonly_mmap,
  35         .splice_read    = generic_file_splice_read,
  36 };
  37
  38 EXPORT_SYMBOL(generic_ro_fops);
  39
  40 static inline int unsigned_offsets(struct file *file)
  41 {
  42         return file->f_mode & FMODE_UNSIGNED_OFFSET;
  43 }
  44
  45 /**
  46  * vfs_setpos - update the file offset for lseek
  47  * @file:       file structure in question
  48  * @offset:     file offset to seek to
  49  * @maxsize:    maximum file size
  50  *
  51  * This is a low-level filesystem helper for updating the file offset to
  52  * the value specified by @offset if the given offset is valid and it is
  53  * not equal to the current file offset.
  54  *
  55  * Return the specified offset on success and -EINVAL on invalid offset.
  56  */
  57 loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize)
  58 {
  59         if (offset < 0 && !unsigned_offsets(file))
  60                 return -EINVAL;
  61         if (offset > maxsize)
  62                 return -EINVAL;
  63
  64         if (offset != file->f_pos) {
  65                 file->f_pos = offset;
  66                 file->f_version = 0;
  67         }
  68         return offset;
  69 }
  70 EXPORT_SYMBOL(vfs_setpos);
  71
  72 /**
  73  * generic_file_llseek_size - generic llseek implementation for regular files
  74  * @file:       file structure to seek on
  75  * @offset:     file offset to seek to
  76  * @whence:     type of seek
  77  * @size:       max size of this file in file system
  78  * @eof:        offset used for SEEK_END position
  79  *
  80  * This is a variant of generic_file_llseek that allows passing in a custom
  81  * maximum file size and a custom EOF position, for e.g. hashed directories
  82  *
  83  * Synchronization:
  84  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
  85  * SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
  86  * read/writes behave like SEEK_SET against seeks.
  87  */
  88 loff_t
  89 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
  90                 loff_t maxsize, loff_t eof)
  91 {
  92         switch (whence) {
  93         case SEEK_END:
  94                 offset += eof;
  95                 break;
  96         case SEEK_CUR:
  97                 /*
  98                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
  99                  * position-querying operation.  Avoid rewriting the "same"
 100                  * f_pos value back to the file because a concurrent read(),
 101                  * write() or lseek() might have altered it
 102                  */
 103                 if (offset == 0)
 104                         return file->f_pos;
 105                 /*
 106                  * f_lock protects against read/modify/write race with other
 107                  * SEEK_CURs. Note that parallel writes and reads behave
 108                  * like SEEK_SET.
 109                  */
 110                 spin_lock(&file->f_lock);
 111                 offset = vfs_setpos(file, file->f_pos + offset, maxsize);
 112                 spin_unlock(&file->f_lock);
 113                 return offset;
 114         case SEEK_DATA:
 115                 /*
 116                  * In the generic case the entire file is data, so as long as
 117                  * offset isn't at the end of the file then the offset is data.
 118                  */
 119                 if (offset >= eof)
 120                         return -ENXIO;
 121                 break;
 122         case SEEK_HOLE:
 123                 /*
 124                  * There is a virtual hole at the end of the file, so as long as
 125                  * offset isn't i_size or larger, return i_size.
 126                  */
 127                 if (offset >= eof)
 128                         return -ENXIO;
 129                 offset = eof;
 130                 break;
 131         }
 132
 133         return vfs_setpos(file, offset, maxsize);
 134 }
 135 EXPORT_SYMBOL(generic_file_llseek_size);
 136
 137 /**
 138  * generic_file_llseek - generic llseek implementation for regular files
 139  * @file:       file structure to seek on
 140  * @offset:     file offset to seek to
 141  * @whence:     type of seek
 142  *
 143  * This is a generic implemenation of ->llseek useable for all normal local
 144  * filesystems.  It just updates the file offset to the value specified by
 145  * @offset and @whence.
 146  */
 147 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
 148 {
 149         struct inode *inode = file->f_mapping->host;
 150
 151         return generic_file_llseek_size(file, offset, whence,
 152                                         inode->i_sb->s_maxbytes,
 153                                         i_size_read(inode));
 154 }
 155 EXPORT_SYMBOL(generic_file_llseek);
 156
 157 /**
 158  * fixed_size_llseek - llseek implementation for fixed-sized devices
 159  * @file:       file structure to seek on
 160  * @offset:     file offset to seek to
 161  * @whence:     type of seek
 162  * @size:       size of the file
 163  *
 164  */
 165 loff_t fixed_size_llseek(struct file *file, loff_t offset, int whence, loff_t size)
 166 {
 167         switch (whence) {
 168         case SEEK_SET: case SEEK_CUR: case SEEK_END:
 169                 return generic_file_llseek_size(file, offset, whence,
 170                                                 size, size);
 171         default:
 172                 return -EINVAL;
 173         }
 174 }
 175 EXPORT_SYMBOL(fixed_size_llseek);
 176
 177 /**
 178  * noop_llseek - No Operation Performed llseek implementation
 179  * @file:       file structure to seek on
 180  * @offset:     file offset to seek to
 181  * @whence:     type of seek
 182  *
 183  * This is an implementation of ->llseek useable for the rare special case when
 184  * userspace expects the seek to succeed but the (device) file is actually not
 185  * able to perform the seek. In this case you use noop_llseek() instead of
 186  * falling back to the default implementation of ->llseek.
 187  */
 188 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
 189 {
 190         return file->f_pos;
 191 }
 192 EXPORT_SYMBOL(noop_llseek);
 193
 194 loff_t no_llseek(struct file *file, loff_t offset, int whence)
 195 {
 196         return -ESPIPE;
 197 }
 198 EXPORT_SYMBOL(no_llseek);
 199
 200 loff_t default_llseek(struct file *file, loff_t offset, int whence)
 201 {
 202         struct inode *inode = file_inode(file);
 203         loff_t retval;
 204
 205         mutex_lock(&inode->i_mutex);
 206         switch (whence) {
 207                 case SEEK_END:
 208                         offset += i_size_read(inode);
 209                         break;
 210                 case SEEK_CUR:
 211                         if (offset == 0) {
 212                                 retval = file->f_pos;
 213                                 goto out;
 214                         }
 215                         offset += file->f_pos;
 216                         break;
 217                 case SEEK_DATA:
 218                         /*
 219                          * In the generic case the entire file is data, so as
 220                          * long as offset isn't at the end of the file then the
 221                          * offset is data.
 222                          */
 223                         if (offset >= inode->i_size) {
 224                                 retval = -ENXIO;
 225                                 goto out;
 226                         }
 227                         break;
 228                 case SEEK_HOLE:
 229                         /*
 230                          * There is a virtual hole at the end of the file, so
 231                          * as long as offset isn't i_size or larger, return
 232                          * i_size.
 233                          */
 234                         if (offset >= inode->i_size) {
 235                                 retval = -ENXIO;
 236                                 goto out;
 237                         }
 238                         offset = inode->i_size;
 239                         break;
 240         }
 241         retval = -EINVAL;
 242         if (offset >= 0 || unsigned_offsets(file)) {
 243                 if (offset != file->f_pos) {
 244                         file->f_pos = offset;
 245                         file->f_version = 0;
 246                 }
 247                 retval = offset;
 248         }
 249 out:
 250         mutex_unlock(&inode->i_mutex);
 251         return retval;
 252 }
 253 EXPORT_SYMBOL(default_llseek);
 254
 255 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
 256 {
 257         loff_t (*fn)(struct file *, loff_t, int);
 258
 259         fn = no_llseek;
 260         if (file->f_mode & FMODE_LSEEK) {
 261                 if (file->f_op->llseek)
 262                         fn = file->f_op->llseek;
 263         }
 264         return fn(file, offset, whence);
 265 }
 266 EXPORT_SYMBOL(vfs_llseek);
 267
 268 static inline struct fd fdget_pos(int fd)
 269 {
 270         return __to_fd(__fdget_pos(fd));
 271 }
 272
 273 static inline void fdput_pos(struct fd f)
 274 {
 275         if (f.flags & FDPUT_POS_UNLOCK)
 276                 mutex_unlock(&f.file->f_pos_lock);
 277         fdput(f);
 278 }
 279
 280 SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
 281 {
 282         off_t retval;
 283         struct fd f = fdget_pos(fd);
 284         if (!f.file)
 285                 return -EBADF;
 286
 287         retval = -EINVAL;
 288         if (whence <= SEEK_MAX) {
 289                 loff_t res = vfs_llseek(f.file, offset, whence);
 290                 retval = res;
 291                 if (res != (loff_t)retval)
 292                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
 293         }
 294         fdput_pos(f);
 295         return retval;
 296 }
 297
 298 #ifdef CONFIG_COMPAT
 299 COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
 300 {
 301         return sys_lseek(fd, offset, whence);
 302 }
 303 #endif
 304
 305 #ifdef __ARCH_WANT_SYS_LLSEEK
 306 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
 307                 unsigned long, offset_low, loff_t __user *, result,
 308                 unsigned int, whence)
 309 {
 310         int retval;
 311         struct fd f = fdget_pos(fd);
 312         loff_t offset;
 313
 314         if (!f.file)
 315                 return -EBADF;
 316
 317         retval = -EINVAL;
 318         if (whence > SEEK_MAX)
 319                 goto out_putf;
 320
 321         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
 322                         whence);
 323
 324         retval = (int)offset;
 325         if (offset >= 0) {
 326                 retval = -EFAULT;
 327                 if (!copy_to_user(result, &offset, sizeof(offset)))
 328                         retval = 0;
 329         }
 330 out_putf:
 331         fdput_pos(f);
 332         return retval;
 333 }
 334 #endif
 335
 336 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos)
 337 {
 338         struct kiocb kiocb;
 339         ssize_t ret;
 340
 341         if (!file->f_op->read_iter)
 342                 return -EINVAL;
 343
 344         init_sync_kiocb(&kiocb, file);
 345         kiocb.ki_pos = *ppos;
 346
 347         iter->type |= READ;
 348         ret = file->f_op->read_iter(&kiocb, iter);
 349         BUG_ON(ret == -EIOCBQUEUED);
 350         if (ret > 0)
 351                 *ppos = kiocb.ki_pos;
 352         return ret;
 353 }
 354 EXPORT_SYMBOL(vfs_iter_read);
 355
 356 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos)
 357 {
 358         struct kiocb kiocb;
 359         ssize_t ret;
 360
 361         if (!file->f_op->write_iter)
 362                 return -EINVAL;
 363
 364         init_sync_kiocb(&kiocb, file);
 365         kiocb.ki_pos = *ppos;
 366
 367         iter->type |= WRITE;
 368         ret = file->f_op->write_iter(&kiocb, iter);
 369         BUG_ON(ret == -EIOCBQUEUED);
 370         if (ret > 0)
 371                 *ppos = kiocb.ki_pos;
 372         return ret;
 373 }
 374 EXPORT_SYMBOL(vfs_iter_write);
 375
 376 /*
 377  * rw_verify_area doesn't like huge counts. We limit
 378  * them to something that fits in "int" so that others
 379  * won't have to do range checks all the time.
 380  */
 381 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
 382 {
 383         struct inode *inode;
 384         loff_t pos;
 385         int retval = -EINVAL;
 386
 387         inode = file_inode(file);
 388         if (unlikely((ssize_t) count < 0))
 389                 return retval;
 390         pos = *ppos;
 391         if (unlikely(pos < 0)) {
 392                 if (!unsigned_offsets(file))
 393                         return retval;
 394                 if (count >= -pos) /* both values are in 0..LLONG_MAX */
 395                         return -EOVERFLOW;
 396         } else if (unlikely((loff_t) (pos + count) < 0)) {
 397                 if (!unsigned_offsets(file))
 398                         return retval;
 399         }
 400
 401         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
 402                 retval = locks_mandatory_area(
 403                         read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
 404                         inode, file, pos, count);
 405                 if (retval < 0)
 406                         return retval;
 407         }
 408         retval = security_file_permission(file,
 409                                 read_write == READ ? MAY_READ : MAY_WRITE);
 410         if (retval)
 411                 return retval;
 412         return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
 413 }
 414
 415 ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 416 {
 417         struct iovec iov = { .iov_base = buf, .iov_len = len };
 418         struct kiocb kiocb;
 419         ssize_t ret;
 420
 421         init_sync_kiocb(&kiocb, filp);
 422         kiocb.ki_pos = *ppos;
 423
 424         ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
 425         BUG_ON(ret == -EIOCBQUEUED);
 426         *ppos = kiocb.ki_pos;
 427         return ret;
 428 }
 429
 430 EXPORT_SYMBOL(do_sync_read);
 431
 432 ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 433 {
 434         struct iovec iov = { .iov_base = buf, .iov_len = len };
 435         struct kiocb kiocb;
 436         struct iov_iter iter;
 437         ssize_t ret;
 438
 439         init_sync_kiocb(&kiocb, filp);
 440         kiocb.ki_pos = *ppos;
 441         iov_iter_init(&iter, READ, &iov, 1, len);
 442
 443         ret = filp->f_op->read_iter(&kiocb, &iter);
 444         BUG_ON(ret == -EIOCBQUEUED);
 445         *ppos = kiocb.ki_pos;
 446         return ret;
 447 }
 448
 449 EXPORT_SYMBOL(new_sync_read);
 450
 451 ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
 452                    loff_t *pos)
 453 {
 454         ssize_t ret;
 455
 456         if (file->f_op->read)
 457                 ret = file->f_op->read(file, buf, count, pos);
 458         else if (file->f_op->aio_read)
 459                 ret = do_sync_read(file, buf, count, pos);
 460         else if (file->f_op->read_iter)
 461                 ret = new_sync_read(file, buf, count, pos);
 462         else
 463                 ret = -EINVAL;
 464
 465         return ret;
 466 }
 467
 468 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 469 {
 470         ssize_t ret;
 471
 472         if (!(file->f_mode & FMODE_READ))
 473                 return -EBADF;
 474         if (!(file->f_mode & FMODE_CAN_READ))
 475                 return -EINVAL;
 476         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
 477                 return -EFAULT;
 478
 479         ret = rw_verify_area(READ, file, pos, count);
 480         if (ret >= 0) {
 481                 count = ret;
 482                 ret = __vfs_read(file, buf, count, pos);
 483                 if (ret > 0) {
 484                         fsnotify_access(file);
 485                         add_rchar(current, ret);
 486                 }
 487                 inc_syscr(current);
 488         }
 489
 490         return ret;
 491 }
 492
 493 EXPORT_SYMBOL(vfs_read);
 494
 495 ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 496 {
 497         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
 498         struct kiocb kiocb;
 499         ssize_t ret;
 500
 501         init_sync_kiocb(&kiocb, filp);
 502         kiocb.ki_pos = *ppos;
 503
 504         ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
 505         BUG_ON(ret == -EIOCBQUEUED);
 506         *ppos = kiocb.ki_pos;
 507         return ret;
 508 }
 509
 510 EXPORT_SYMBOL(do_sync_write);
 511
 512 ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 513 {
 514         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
 515         struct kiocb kiocb;
 516         struct iov_iter iter;
 517         ssize_t ret;
 518
 519         init_sync_kiocb(&kiocb, filp);
 520         kiocb.ki_pos = *ppos;
 521         iov_iter_init(&iter, WRITE, &iov, 1, len);
 522
 523         ret = filp->f_op->write_iter(&kiocb, &iter);
 524         BUG_ON(ret == -EIOCBQUEUED);
 525         *ppos = kiocb.ki_pos;
 526         return ret;
 527 }
 528
 529 EXPORT_SYMBOL(new_sync_write);
 530
 531 ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
 532 {
 533         mm_segment_t old_fs;
 534         const char __user *p;
 535         ssize_t ret;
 536
 537         if (!(file->f_mode & FMODE_CAN_WRITE))
 538                 return -EINVAL;
 539
 540         old_fs = get_fs();
 541         set_fs(get_ds());
 542         p = (__force const char __user *)buf;
 543         if (count > MAX_RW_COUNT)
 544                 count =  MAX_RW_COUNT;
 545         if (file->f_op->write)
 546                 ret = file->f_op->write(file, p, count, pos);
 547         else if (file->f_op->aio_write)
 548                 ret = do_sync_write(file, p, count, pos);
 549         else
 550                 ret = new_sync_write(file, p, count, pos);
 551         set_fs(old_fs);
 552         if (ret > 0) {
 553                 fsnotify_modify(file);
 554                 add_wchar(current, ret);
 555         }
 556         inc_syscw(current);
 557         return ret;
 558 }
 559
 560 EXPORT_SYMBOL(__kernel_write);
 561
 562 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
 563 {
 564         ssize_t ret;
 565
 566         if (!(file->f_mode & FMODE_WRITE))
 567                 return -EBADF;
 568         if (!(file->f_mode & FMODE_CAN_WRITE))
 569                 return -EINVAL;
 570         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
 571                 return -EFAULT;
 572
 573         ret = rw_verify_area(WRITE, file, pos, count);
 574         if (ret >= 0) {
 575                 count = ret;
 576                 file_start_write(file);
 577                 if (file->f_op->write)
 578                         ret = file->f_op->write(file, buf, count, pos);
 579                 else if (file->f_op->aio_write)
 580                         ret = do_sync_write(file, buf, count, pos);
 581                 else
 582                         ret = new_sync_write(file, buf, count, pos);
 583                 if (ret > 0) {
 584                         fsnotify_modify(file);
 585                         add_wchar(current, ret);
 586                 }
 587                 inc_syscw(current);
 588                 file_end_write(file);
 589         }
 590
 591         return ret;
 592 }
 593
 594 EXPORT_SYMBOL(vfs_write);
 595
 596 static inline loff_t file_pos_read(struct file *file)
 597 {
 598         return file->f_pos;
 599 }
 600
 601 static inline void file_pos_write(struct file *file, loff_t pos)
 602 {
 603         file->f_pos = pos;
 604 }
 605
 606 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
 607 {
 608         struct fd f = fdget_pos(fd);
 609         ssize_t ret = -EBADF;
 610
 611         if (f.file) {
 612                 loff_t pos = file_pos_read(f.file);
 613                 ret = vfs_read(f.file, buf, count, &pos);
 614                 if (ret >= 0)
 615                         file_pos_write(f.file, pos);
 616                 fdput_pos(f);
 617         }
 618         return ret;
 619 }
 620
 621 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
 622                 size_t, count)
 623 {
 624         struct fd f = fdget_pos(fd);
 625         ssize_t ret = -EBADF;
 626
 627         if (f.file) {
 628                 loff_t pos = file_pos_read(f.file);
 629                 ret = vfs_write(f.file, buf, count, &pos);
 630                 if (ret >= 0)
 631                         file_pos_write(f.file, pos);
 632                 fdput_pos(f);
 633         }
 634
 635         return ret;
 636 }
 637
 638 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
 639                         size_t, count, loff_t, pos)
 640 {
 641         struct fd f;
 642         ssize_t ret = -EBADF;
 643
 644         if (pos < 0)
 645                 return -EINVAL;
 646
 647         f = fdget(fd);
 648         if (f.file) {
 649                 ret = -ESPIPE;
 650                 if (f.file->f_mode & FMODE_PREAD)
 651                         ret = vfs_read(f.file, buf, count, &pos);
 652                 fdput(f);
 653         }
 654
 655         return ret;
 656 }
 657
 658 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
 659                          size_t, count, loff_t, pos)
 660 {
 661         struct fd f;
 662         ssize_t ret = -EBADF;
 663
 664         if (pos < 0)
 665                 return -EINVAL;
 666
 667         f = fdget(fd);
 668         if (f.file) {
 669                 ret = -ESPIPE;
 670                 if (f.file->f_mode & FMODE_PWRITE)
 671                         ret = vfs_write(f.file, buf, count, &pos);
 672                 fdput(f);
 673         }
 674
 675         return ret;
 676 }
 677
 678 /*
 679  * Reduce an iovec's length in-place.  Return the resulting number of segments
 680  */
 681 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 682 {
 683         unsigned long seg = 0;
 684         size_t len = 0;
 685
 686         while (seg < nr_segs) {
 687                 seg++;
 688                 if (len + iov->iov_len >= to) {
 689                         iov->iov_len = to - len;
 690                         break;
 691                 }
 692                 len += iov->iov_len;
 693                 iov++;
 694         }
 695         return seg;
 696 }
 697 EXPORT_SYMBOL(iov_shorten);
 698
 699 static ssize_t do_iter_readv_writev(struct file *filp, int rw, const struct iovec *iov,
 700                 unsigned long nr_segs, size_t len, loff_t *ppos, iter_fn_t fn)
 701 {
 702         struct kiocb kiocb;
 703         struct iov_iter iter;
 704         ssize_t ret;
 705
 706         init_sync_kiocb(&kiocb, filp);
 707         kiocb.ki_pos = *ppos;
 708
 709         iov_iter_init(&iter, rw, iov, nr_segs, len);
 710         ret = fn(&kiocb, &iter);
 711         BUG_ON(ret == -EIOCBQUEUED);
 712         *ppos = kiocb.ki_pos;
 713         return ret;
 714 }
 715
 716 static ssize_t do_sync_readv_writev(struct file *filp, const struct iovec *iov,
 717                 unsigned long nr_segs, size_t len, loff_t *ppos, iov_fn_t fn)
 718 {
 719         struct kiocb kiocb;
 720         ssize_t ret;
 721
 722         init_sync_kiocb(&kiocb, filp);
 723         kiocb.ki_pos = *ppos;
 724
 725         ret = fn(&kiocb, iov, nr_segs, kiocb.ki_pos);
 726         BUG_ON(ret == -EIOCBQUEUED);
 727         *ppos = kiocb.ki_pos;
 728         return ret;
 729 }
 730
 731 /* Do it by hand, with file-ops */
 732 static ssize_t do_loop_readv_writev(struct file *filp, struct iovec *iov,
 733                 unsigned long nr_segs, loff_t *ppos, io_fn_t fn)
 734 {
 735         struct iovec *vector = iov;
 736         ssize_t ret = 0;
 737
 738         while (nr_segs > 0) {
 739                 void __user *base;
 740                 size_t len;
 741                 ssize_t nr;
 742
 743                 base = vector->iov_base;
 744                 len = vector->iov_len;
 745                 vector++;
 746                 nr_segs--;
 747
 748                 nr = fn(filp, base, len, ppos);
 749
 750                 if (nr < 0) {
 751                         if (!ret)
 752                                 ret = nr;
 753                         break;
 754                 }
 755                 ret += nr;
 756                 if (nr != len)
 757                         break;
 758         }
 759
 760         return ret;
 761 }
 762
 763 /* A write operation does a read from user space and vice versa */
 764 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
 765
 766 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 767                               unsigned long nr_segs, unsigned long fast_segs,
 768                               struct iovec *fast_pointer,
 769                               struct iovec **ret_pointer)
 770 {
 771         unsigned long seg;
 772         ssize_t ret;
 773         struct iovec *iov = fast_pointer;
 774
 775         /*
 776          * SuS says "The readv() function *may* fail if the iovcnt argument
 777          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 778          * traditionally returned zero for zero segments, so...
 779          */
 780         if (nr_segs == 0) {
 781                 ret = 0;
 782                 goto out;
 783         }
 784
 785         /*
 786          * First get the "struct iovec" from user memory and
 787          * verify all the pointers
 788          */
 789         if (nr_segs > UIO_MAXIOV) {
 790                 ret = -EINVAL;
 791                 goto out;
 792         }
 793         if (nr_segs > fast_segs) {
 794                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
 795                 if (iov == NULL) {
 796                         ret = -ENOMEM;
 797                         goto out;
 798                 }
 799         }
 800         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
 801                 ret = -EFAULT;
 802                 goto out;
 803         }
 804
 805         /*
 806          * According to the Single Unix Specification we should return EINVAL
 807          * if an element length is < 0 when cast to ssize_t or if the
 808          * total length would overflow the ssize_t return value of the
 809          * system call.
 810          *
 811          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
 812          * overflow case.
 813          */
 814         ret = 0;
 815         for (seg = 0; seg < nr_segs; seg++) {
 816                 void __user *buf = iov[seg].iov_base;
 817                 ssize_t len = (ssize_t)iov[seg].iov_len;
 818
 819                 /* see if we we're about to use an invalid len or if
 820                  * it's about to overflow ssize_t */
 821                 if (len < 0) {
 822                         ret = -EINVAL;
 823                         goto out;
 824                 }
 825                 if (type >= 0
 826                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
 827                         ret = -EFAULT;
 828                         goto out;
 829                 }
 830                 if (len > MAX_RW_COUNT - ret) {
 831                         len = MAX_RW_COUNT - ret;
 832                         iov[seg].iov_len = len;
 833                 }
 834                 ret += len;
 835         }
 836 out:
 837         *ret_pointer = iov;
 838         return ret;
 839 }
 840
 841 static ssize_t do_readv_writev(int type, struct file *file,
 842                                const struct iovec __user * uvector,
 843                                unsigned long nr_segs, loff_t *pos)
 844 {
 845         size_t tot_len;
 846         struct iovec iovstack[UIO_FASTIOV];
 847         struct iovec *iov = iovstack;
 848         ssize_t ret;
 849         io_fn_t fn;
 850         iov_fn_t fnv;
 851         iter_fn_t iter_fn;
 852
 853         ret = rw_copy_check_uvector(type, uvector, nr_segs,
 854                                     ARRAY_SIZE(iovstack), iovstack, &iov);
 855         if (ret <= 0)
 856                 goto out;
 857
 858         tot_len = ret;
 859         ret = rw_verify_area(type, file, pos, tot_len);
 860         if (ret < 0)
 861                 goto out;
 862
 863         fnv = NULL;
 864         if (type == READ) {
 865                 fn = file->f_op->read;
 866                 fnv = file->f_op->aio_read;
 867                 iter_fn = file->f_op->read_iter;
 868         } else {
 869                 fn = (io_fn_t)file->f_op->write;
 870                 fnv = file->f_op->aio_write;
 871                 iter_fn = file->f_op->write_iter;
 872                 file_start_write(file);
 873         }
 874
 875         if (iter_fn)
 876                 ret = do_iter_readv_writev(file, type, iov, nr_segs, tot_len,
 877                                                 pos, iter_fn);
 878         else if (fnv)
 879                 ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
 880                                                 pos, fnv);
 881         else
 882                 ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
 883
 884         if (type != READ)
 885                 file_end_write(file);
 886
 887 out:
 888         if (iov != iovstack)
 889                 kfree(iov);
 890         if ((ret + (type == READ)) > 0) {
 891                 if (type == READ)
 892                         fsnotify_access(file);
 893                 else
 894                         fsnotify_modify(file);
 895         }
 896         return ret;
 897 }
 898
 899 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 900                   unsigned long vlen, loff_t *pos)
 901 {
 902         if (!(file->f_mode & FMODE_READ))
 903                 return -EBADF;
 904         if (!(file->f_mode & FMODE_CAN_READ))
 905                 return -EINVAL;
 906
 907         return do_readv_writev(READ, file, vec, vlen, pos);
 908 }
 909
 910 EXPORT_SYMBOL(vfs_readv);
 911
 912 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 913                    unsigned long vlen, loff_t *pos)
 914 {
 915         if (!(file->f_mode & FMODE_WRITE))
 916                 return -EBADF;
 917         if (!(file->f_mode & FMODE_CAN_WRITE))
 918                 return -EINVAL;
 919
 920         return do_readv_writev(WRITE, file, vec, vlen, pos);
 921 }
 922
 923 EXPORT_SYMBOL(vfs_writev);
 924
 925 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
 926                 unsigned long, vlen)
 927 {
 928         struct fd f = fdget_pos(fd);
 929         ssize_t ret = -EBADF;
 930
 931         if (f.file) {
 932                 loff_t pos = file_pos_read(f.file);
 933                 ret = vfs_readv(f.file, vec, vlen, &pos);
 934                 if (ret >= 0)
 935                         file_pos_write(f.file, pos);
 936                 fdput_pos(f);
 937         }
 938
 939         if (ret > 0)
 940                 add_rchar(current, ret);
 941         inc_syscr(current);
 942         return ret;
 943 }
 944
 945 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
 946                 unsigned long, vlen)
 947 {
 948         struct fd f = fdget_pos(fd);
 949         ssize_t ret = -EBADF;
 950
 951         if (f.file) {
 952                 loff_t pos = file_pos_read(f.file);
 953                 ret = vfs_writev(f.file, vec, vlen, &pos);
 954                 if (ret >= 0)
 955                         file_pos_write(f.file, pos);
 956                 fdput_pos(f);
 957         }
 958
 959         if (ret > 0)
 960                 add_wchar(current, ret);
 961         inc_syscw(current);
 962         return ret;
 963 }
 964
 965 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
 966 {
 967 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
 968         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
 969 }
 970
 971 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
 972                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
 973 {
 974         loff_t pos = pos_from_hilo(pos_h, pos_l);
 975         struct fd f;
 976         ssize_t ret = -EBADF;
 977
 978         if (pos < 0)
 979                 return -EINVAL;
 980
 981         f = fdget(fd);
 982         if (f.file) {
 983                 ret = -ESPIPE;
 984                 if (f.file->f_mode & FMODE_PREAD)
 985                         ret = vfs_readv(f.file, vec, vlen, &pos);
 986                 fdput(f);
 987         }
 988
 989         if (ret > 0)
 990                 add_rchar(current, ret);
 991         inc_syscr(current);
 992         return ret;
 993 }
 994
 995 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
 996                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
 997 {
 998         loff_t pos = pos_from_hilo(pos_h, pos_l);
 999         struct fd f;
1000         ssize_t ret = -EBADF;
1001
1002         if (pos < 0)
1003                 return -EINVAL;
1004
1005         f = fdget(fd);
1006         if (f.file) {
1007                 ret = -ESPIPE;
1008                 if (f.file->f_mode & FMODE_PWRITE)
1009                         ret = vfs_writev(f.file, vec, vlen, &pos);
1010                 fdput(f);
1011         }
1012
1013         if (ret > 0)
1014                 add_wchar(current, ret);
1015         inc_syscw(current);
1016         return ret;
1017 }
1018
1019 #ifdef CONFIG_COMPAT
1020
1021 static ssize_t compat_do_readv_writev(int type, struct file *file,
1022                                const struct compat_iovec __user *uvector,
1023                                unsigned long nr_segs, loff_t *pos)
1024 {
1025         compat_ssize_t tot_len;
1026         struct iovec iovstack[UIO_FASTIOV];
1027         struct iovec *iov = iovstack;
1028         ssize_t ret;
1029         io_fn_t fn;
1030         iov_fn_t fnv;
1031         iter_fn_t iter_fn;
1032
1033         ret = compat_rw_copy_check_uvector(type, uvector, nr_segs,
1034                                                UIO_FASTIOV, iovstack, &iov);
1035         if (ret <= 0)
1036                 goto out;
1037
1038         tot_len = ret;
1039         ret = rw_verify_area(type, file, pos, tot_len);
1040         if (ret < 0)
1041                 goto out;
1042
1043         fnv = NULL;
1044         if (type == READ) {
1045                 fn = file->f_op->read;
1046                 fnv = file->f_op->aio_read;
1047                 iter_fn = file->f_op->read_iter;
1048         } else {
1049                 fn = (io_fn_t)file->f_op->write;
1050                 fnv = file->f_op->aio_write;
1051                 iter_fn = file->f_op->write_iter;
1052                 file_start_write(file);
1053         }
1054
1055         if (iter_fn)
1056                 ret = do_iter_readv_writev(file, type, iov, nr_segs, tot_len,
1057                                                 pos, iter_fn);
1058         else if (fnv)
1059                 ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
1060                                                 pos, fnv);
1061         else
1062                 ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
1063
1064         if (type != READ)
1065                 file_end_write(file);
1066
1067 out:
1068         if (iov != iovstack)
1069                 kfree(iov);
1070         if ((ret + (type == READ)) > 0) {
1071                 if (type == READ)
1072                         fsnotify_access(file);
1073                 else
1074                         fsnotify_modify(file);
1075         }
1076         return ret;
1077 }
1078
1079 static size_t compat_readv(struct file *file,
1080                            const struct compat_iovec __user *vec,
1081                            unsigned long vlen, loff_t *pos)
1082 {
1083         ssize_t ret = -EBADF;
1084
1085         if (!(file->f_mode & FMODE_READ))
1086                 goto out;
1087
1088         ret = -EINVAL;
1089         if (!(file->f_mode & FMODE_CAN_READ))
1090                 goto out;
1091
1092         ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
1093
1094 out:
1095         if (ret > 0)
1096                 add_rchar(current, ret);
1097         inc_syscr(current);
1098         return ret;
1099 }
1100
1101 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1102                 const struct compat_iovec __user *,vec,
1103                 compat_ulong_t, vlen)
1104 {
1105         struct fd f = fdget_pos(fd);
1106         ssize_t ret;
1107         loff_t pos;
1108
1109         if (!f.file)
1110                 return -EBADF;
1111         pos = f.file->f_pos;
1112         ret = compat_readv(f.file, vec, vlen, &pos);
1113         if (ret >= 0)
1114                 f.file->f_pos = pos;
1115         fdput_pos(f);
1116         return ret;
1117 }
1118
1119 static long __compat_sys_preadv64(unsigned long fd,
1120                                   const struct compat_iovec __user *vec,
1121                                   unsigned long vlen, loff_t pos)
1122 {
1123         struct fd f;
1124         ssize_t ret;
1125
1126         if (pos < 0)
1127                 return -EINVAL;
1128         f = fdget(fd);
1129         if (!f.file)
1130                 return -EBADF;
1131         ret = -ESPIPE;
1132         if (f.file->f_mode & FMODE_PREAD)
1133                 ret = compat_readv(f.file, vec, vlen, &pos);
1134         fdput(f);
1135         return ret;
1136 }
1137
1138 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1139 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1140                 const struct compat_iovec __user *,vec,
1141                 unsigned long, vlen, loff_t, pos)
1142 {
1143         return __compat_sys_preadv64(fd, vec, vlen, pos);
1144 }
1145 #endif
1146
1147 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1148                 const struct compat_iovec __user *,vec,
1149                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1150 {
1151         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1152
1153         return __compat_sys_preadv64(fd, vec, vlen, pos);
1154 }
1155
1156 static size_t compat_writev(struct file *file,
1157                             const struct compat_iovec __user *vec,
1158                             unsigned long vlen, loff_t *pos)
1159 {
1160         ssize_t ret = -EBADF;
1161
1162         if (!(file->f_mode & FMODE_WRITE))
1163                 goto out;
1164
1165         ret = -EINVAL;
1166         if (!(file->f_mode & FMODE_CAN_WRITE))
1167                 goto out;
1168
1169         ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
1170
1171 out:
1172         if (ret > 0)
1173                 add_wchar(current, ret);
1174         inc_syscw(current);
1175         return ret;
1176 }
1177
1178 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1179                 const struct compat_iovec __user *, vec,
1180                 compat_ulong_t, vlen)
1181 {
1182         struct fd f = fdget_pos(fd);
1183         ssize_t ret;
1184         loff_t pos;
1185
1186         if (!f.file)
1187                 return -EBADF;
1188         pos = f.file->f_pos;
1189         ret = compat_writev(f.file, vec, vlen, &pos);
1190         if (ret >= 0)
1191                 f.file->f_pos = pos;
1192         fdput_pos(f);
1193         return ret;
1194 }
1195
1196 static long __compat_sys_pwritev64(unsigned long fd,
1197                                    const struct compat_iovec __user *vec,
1198                                    unsigned long vlen, loff_t pos)
1199 {
1200         struct fd f;
1201         ssize_t ret;
1202
1203         if (pos < 0)
1204                 return -EINVAL;
1205         f = fdget(fd);
1206         if (!f.file)
1207                 return -EBADF;
1208         ret = -ESPIPE;
1209         if (f.file->f_mode & FMODE_PWRITE)
1210                 ret = compat_writev(f.file, vec, vlen, &pos);
1211         fdput(f);
1212         return ret;
1213 }
1214
1215 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1216 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1217                 const struct compat_iovec __user *,vec,
1218                 unsigned long, vlen, loff_t, pos)
1219 {
1220         return __compat_sys_pwritev64(fd, vec, vlen, pos);
1221 }
1222 #endif
1223
1224 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1225                 const struct compat_iovec __user *,vec,
1226                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1227 {
1228         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1229
1230         return __compat_sys_pwritev64(fd, vec, vlen, pos);
1231 }
1232 #endif
1233
1234 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1235                            size_t count, loff_t max)
1236 {
1237         struct fd in, out;
1238         struct inode *in_inode, *out_inode;
1239         loff_t pos;
1240         loff_t out_pos;
1241         ssize_t retval;
1242         int fl;
1243
1244         /*
1245          * Get input file, and verify that it is ok..
1246          */
1247         retval = -EBADF;
1248         in = fdget(in_fd);
1249         if (!in.file)
1250                 goto out;
1251         if (!(in.file->f_mode & FMODE_READ))
1252                 goto fput_in;
1253         retval = -ESPIPE;
1254         if (!ppos) {
1255                 pos = in.file->f_pos;
1256         } else {
1257                 pos = *ppos;
1258                 if (!(in.file->f_mode & FMODE_PREAD))
1259                         goto fput_in;
1260         }
1261         retval = rw_verify_area(READ, in.file, &pos, count);
1262         if (retval < 0)
1263                 goto fput_in;
1264         count = retval;
1265
1266         /*
1267          * Get output file, and verify that it is ok..
1268          */
1269         retval = -EBADF;
1270         out = fdget(out_fd);
1271         if (!out.file)
1272                 goto fput_in;
1273         if (!(out.file->f_mode & FMODE_WRITE))
1274                 goto fput_out;
1275         retval = -EINVAL;
1276         in_inode = file_inode(in.file);
1277         out_inode = file_inode(out.file);
1278         out_pos = out.file->f_pos;
1279         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1280         if (retval < 0)
1281                 goto fput_out;
1282         count = retval;
1283
1284         if (!max)
1285                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1286
1287         if (unlikely(pos + count > max)) {
1288                 retval = -EOVERFLOW;
1289                 if (pos >= max)
1290                         goto fput_out;
1291                 count = max - pos;
1292         }
1293
1294         fl = 0;
1295 #if 0
1296         /*
1297          * We need to debate whether we can enable this or not. The
1298          * man page documents EAGAIN return for the output at least,
1299          * and the application is arguably buggy if it doesn't expect
1300          * EAGAIN on a non-blocking file descriptor.
1301          */
1302         if (in.file->f_flags & O_NONBLOCK)
1303                 fl = SPLICE_F_NONBLOCK;
1304 #endif
1305         file_start_write(out.file);
1306         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1307         file_end_write(out.file);
1308
1309         if (retval > 0) {
1310                 add_rchar(current, retval);
1311                 add_wchar(current, retval);
1312                 fsnotify_access(in.file);
1313                 fsnotify_modify(out.file);
1314                 out.file->f_pos = out_pos;
1315                 if (ppos)
1316                         *ppos = pos;
1317                 else
1318                         in.file->f_pos = pos;
1319         }
1320
1321         inc_syscr(current);
1322         inc_syscw(current);
1323         if (pos > max)
1324                 retval = -EOVERFLOW;
1325
1326 fput_out:
1327         fdput(out);
1328 fput_in:
1329         fdput(in);
1330 out:
1331         return retval;
1332 }
1333
1334 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1335 {
1336         loff_t pos;
1337         off_t off;
1338         ssize_t ret;
1339
1340         if (offset) {
1341                 if (unlikely(get_user(off, offset)))
1342                         return -EFAULT;
1343                 pos = off;
1344                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1345                 if (unlikely(put_user(pos, offset)))
1346                         return -EFAULT;
1347                 return ret;
1348         }
1349
1350         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1351 }
1352
1353 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1354 {
1355         loff_t pos;
1356         ssize_t ret;
1357
1358         if (offset) {
1359                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1360                         return -EFAULT;
1361                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1362                 if (unlikely(put_user(pos, offset)))
1363                         return -EFAULT;
1364                 return ret;
1365         }
1366
1367         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1368 }
1369
1370 #ifdef CONFIG_COMPAT
1371 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1372                 compat_off_t __user *, offset, compat_size_t, count)
1373 {
1374         loff_t pos;
1375         off_t off;
1376         ssize_t ret;
1377
1378         if (offset) {
1379                 if (unlikely(get_user(off, offset)))
1380                         return -EFAULT;
1381                 pos = off;
1382                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1383                 if (unlikely(put_user(pos, offset)))
1384                         return -EFAULT;
1385                 return ret;
1386         }
1387
1388         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1389 }
1390
1391 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1392                 compat_loff_t __user *, offset, compat_size_t, count)
1393 {
1394         loff_t pos;
1395         ssize_t ret;
1396
1397         if (offset) {
1398                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1399                         return -EFAULT;
1400                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1401                 if (unlikely(put_user(pos, offset)))
1402                         return -EFAULT;
1403                 return ret;
1404         }
1405
1406         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1407 }
1408 #endif