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