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