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/smp_lock.h>
  13 #include <linux/dnotify.h>
  14 #include <linux/security.h>
  15 #include <linux/module.h>
  16
  17 #include <asm/uaccess.h>
  18 #include <asm/unistd.h>
  19
  20 struct file_operations generic_ro_fops = {
  21         .llseek         = generic_file_llseek,
  22         .read           = generic_file_read,
  23         .mmap           = generic_file_readonly_mmap,
  24         .sendfile       = generic_file_sendfile,
  25 };
  26
  27 EXPORT_SYMBOL(generic_ro_fops);
  28
  29 loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
  30 {
  31         long long retval;
  32         struct inode *inode = file->f_mapping->host;
  33
  34         down(&inode->i_sem);
  35         switch (origin) {
  36                 case 2:
  37                         offset += inode->i_size;
  38                         break;
  39                 case 1:
  40                         offset += file->f_pos;
  41         }
  42         retval = -EINVAL;
  43         if (offset>=0 && offset<=inode->i_sb->s_maxbytes) {
  44                 if (offset != file->f_pos) {
  45                         file->f_pos = offset;
  46                         file->f_version = 0;
  47                 }
  48                 retval = offset;
  49         }
  50         up(&inode->i_sem);
  51         return retval;
  52 }
  53
  54 EXPORT_SYMBOL(generic_file_llseek);
  55
  56 loff_t remote_llseek(struct file *file, loff_t offset, int origin)
  57 {
  58         long long retval;
  59
  60         lock_kernel();
  61         switch (origin) {
  62                 case 2:
  63                         offset += i_size_read(file->f_dentry->d_inode);
  64                         break;
  65                 case 1:
  66                         offset += file->f_pos;
  67         }
  68         retval = -EINVAL;
  69         if (offset>=0 && offset<=file->f_dentry->d_inode->i_sb->s_maxbytes) {
  70                 if (offset != file->f_pos) {
  71                         file->f_pos = offset;
  72                         file->f_version = 0;
  73                 }
  74                 retval = offset;
  75         }
  76         unlock_kernel();
  77         return retval;
  78 }
  79 EXPORT_SYMBOL(remote_llseek);
  80
  81 loff_t no_llseek(struct file *file, loff_t offset, int origin)
  82 {
  83         return -ESPIPE;
  84 }
  85 EXPORT_SYMBOL(no_llseek);
  86
  87 loff_t default_llseek(struct file *file, loff_t offset, int origin)
  88 {
  89         long long retval;
  90
  91         lock_kernel();
  92         switch (origin) {
  93                 case 2:
  94                         offset += i_size_read(file->f_dentry->d_inode);
  95                         break;
  96                 case 1:
  97                         offset += file->f_pos;
  98         }
  99         retval = -EINVAL;
 100         if (offset >= 0) {
 101                 if (offset != file->f_pos) {
 102                         file->f_pos = offset;
 103                         file->f_version = 0;
 104                 }
 105                 retval = offset;
 106         }
 107         unlock_kernel();
 108         return retval;
 109 }
 110 EXPORT_SYMBOL(default_llseek);
 111
 112 loff_t vfs_llseek(struct file *file, loff_t offset, int origin)
 113 {
 114         loff_t (*fn)(struct file *, loff_t, int);
 115
 116         fn = default_llseek;
 117         if (file->f_op && file->f_op->llseek)
 118                 fn = file->f_op->llseek;
 119         return fn(file, offset, origin);
 120 }
 121 EXPORT_SYMBOL(vfs_llseek);
 122
 123 asmlinkage off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
 124 {
 125         off_t retval;
 126         struct file * file;
 127         int fput_needed;
 128
 129         retval = -EBADF;
 130         file = fget_light(fd, &fput_needed);
 131         if (!file)
 132                 goto bad;
 133
 134         retval = -EINVAL;
 135         if (origin <= 2) {
 136                 loff_t res = vfs_llseek(file, offset, origin);
 137                 retval = res;
 138                 if (res != (loff_t)retval)
 139                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
 140         }
 141         fput_light(file, fput_needed);
 142 bad:
 143         return retval;
 144 }
 145
 146 #ifdef __ARCH_WANT_SYS_LLSEEK
 147 asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high,
 148                            unsigned long offset_low, loff_t __user * result,
 149                            unsigned int origin)
 150 {
 151         int retval;
 152         struct file * file;
 153         loff_t offset;
 154         int fput_needed;
 155
 156         retval = -EBADF;
 157         file = fget_light(fd, &fput_needed);
 158         if (!file)
 159                 goto bad;
 160
 161         retval = -EINVAL;
 162         if (origin > 2)
 163                 goto out_putf;
 164
 165         offset = vfs_llseek(file, ((loff_t) offset_high << 32) | offset_low,
 166                         origin);
 167
 168         retval = (int)offset;
 169         if (offset >= 0) {
 170                 retval = -EFAULT;
 171                 if (!copy_to_user(result, &offset, sizeof(offset)))
 172                         retval = 0;
 173         }
 174 out_putf:
 175         fput_light(file, fput_needed);
 176 bad:
 177         return retval;
 178 }
 179 #endif
 180
 181 ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 182 {
 183         struct kiocb kiocb;
 184         ssize_t ret;
 185
 186         init_sync_kiocb(&kiocb, filp);
 187         kiocb.ki_pos = *ppos;
 188         ret = filp->f_op->aio_read(&kiocb, buf, len, kiocb.ki_pos);
 189         if (-EIOCBQUEUED == ret)
 190                 ret = wait_on_sync_kiocb(&kiocb);
 191         *ppos = kiocb.ki_pos;
 192         return ret;
 193 }
 194
 195 EXPORT_SYMBOL(do_sync_read);
 196
 197 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 198 {
 199         struct inode *inode = file->f_dentry->d_inode;
 200         ssize_t ret;
 201
 202         if (!(file->f_mode & FMODE_READ))
 203                 return -EBADF;
 204         if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
 205                 return -EINVAL;
 206
 207         ret = locks_verify_area(FLOCK_VERIFY_READ, inode, file, *pos, count);
 208         if (!ret) {
 209                 ret = security_file_permission (file, MAY_READ);
 210                 if (!ret) {
 211                         if (file->f_op->read)
 212                                 ret = file->f_op->read(file, buf, count, pos);
 213                         else
 214                                 ret = do_sync_read(file, buf, count, pos);
 215                         if (ret > 0)
 216                                 dnotify_parent(file->f_dentry, DN_ACCESS);
 217                 }
 218         }
 219
 220         return ret;
 221 }
 222
 223 EXPORT_SYMBOL(vfs_read);
 224
 225 ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 226 {
 227         struct kiocb kiocb;
 228         ssize_t ret;
 229
 230         init_sync_kiocb(&kiocb, filp);
 231         kiocb.ki_pos = *ppos;
 232         ret = filp->f_op->aio_write(&kiocb, buf, len, kiocb.ki_pos);
 233         if (-EIOCBQUEUED == ret)
 234                 ret = wait_on_sync_kiocb(&kiocb);
 235         *ppos = kiocb.ki_pos;
 236         return ret;
 237 }
 238
 239 EXPORT_SYMBOL(do_sync_write);
 240
 241 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
 242 {
 243         struct inode *inode = file->f_dentry->d_inode;
 244         ssize_t ret;
 245
 246         if (!(file->f_mode & FMODE_WRITE))
 247                 return -EBADF;
 248         if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
 249                 return -EINVAL;
 250
 251         ret = locks_verify_area(FLOCK_VERIFY_WRITE, inode, file, *pos, count);
 252         if (!ret) {
 253                 ret = security_file_permission (file, MAY_WRITE);
 254                 if (!ret) {
 255                         if (file->f_op->write)
 256                                 ret = file->f_op->write(file, buf, count, pos);
 257                         else
 258                                 ret = do_sync_write(file, buf, count, pos);
 259                         if (ret > 0)
 260                                 dnotify_parent(file->f_dentry, DN_MODIFY);
 261                 }
 262         }
 263
 264         return ret;
 265 }
 266
 267 EXPORT_SYMBOL(vfs_write);
 268
 269 asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
 270 {
 271         struct file *file;
 272         ssize_t ret = -EBADF;
 273         int fput_needed;
 274
 275         file = fget_light(fd, &fput_needed);
 276         if (file) {
 277                 ret = vfs_read(file, buf, count, &file->f_pos);
 278                 fput_light(file, fput_needed);
 279         }
 280
 281         return ret;
 282 }
 283
 284 asmlinkage ssize_t sys_write(unsigned int fd, const char __user * buf, size_t count)
 285 {
 286         struct file *file;
 287         ssize_t ret = -EBADF;
 288         int fput_needed;
 289
 290         file = fget_light(fd, &fput_needed);
 291         if (file) {
 292                 ret = vfs_write(file, buf, count, &file->f_pos);
 293                 fput_light(file, fput_needed);
 294         }
 295
 296         return ret;
 297 }
 298
 299 asmlinkage ssize_t sys_pread64(unsigned int fd, char __user *buf,
 300                              size_t count, loff_t pos)
 301 {
 302         struct file *file;
 303         ssize_t ret = -EBADF;
 304         int fput_needed;
 305
 306         if (pos < 0)
 307                 return -EINVAL;
 308
 309         file = fget_light(fd, &fput_needed);
 310         if (file) {
 311                 ret = vfs_read(file, buf, count, &pos);
 312                 fput_light(file, fput_needed);
 313         }
 314
 315         return ret;
 316 }
 317
 318 asmlinkage ssize_t sys_pwrite64(unsigned int fd, const char __user *buf,
 319                               size_t count, loff_t pos)
 320 {
 321         struct file *file;
 322         ssize_t ret = -EBADF;
 323         int fput_needed;
 324
 325         if (pos < 0)
 326                 return -EINVAL;
 327
 328         file = fget_light(fd, &fput_needed);
 329         if (file) {
 330                 ret = vfs_write(file, buf, count, &pos);
 331                 fput_light(file, fput_needed);
 332         }
 333
 334         return ret;
 335 }
 336
 337 /*
 338  * Reduce an iovec's length in-place.  Return the resulting number of segments
 339  */
 340 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 341 {
 342         unsigned long seg = 0;
 343         size_t len = 0;
 344
 345         while (seg < nr_segs) {
 346                 seg++;
 347                 if (len + iov->iov_len >= to) {
 348                         iov->iov_len = to - len;
 349                         break;
 350                 }
 351                 len += iov->iov_len;
 352                 iov++;
 353         }
 354         return seg;
 355 }
 356
 357 EXPORT_SYMBOL(iov_shorten);
 358
 359 static ssize_t do_readv_writev(int type, struct file *file,
 360                                const struct iovec __user * uvector,
 361                                unsigned long nr_segs, loff_t *pos)
 362 {
 363         typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
 364         typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
 365
 366         size_t tot_len;
 367         struct iovec iovstack[UIO_FASTIOV];
 368         struct iovec *iov=iovstack, *vector;
 369         ssize_t ret;
 370         int seg;
 371         io_fn_t fn;
 372         iov_fn_t fnv;
 373         struct inode *inode;
 374
 375         /*
 376          * SuS says "The readv() function *may* fail if the iovcnt argument
 377          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 378          * traditionally returned zero for zero segments, so...
 379          */
 380         ret = 0;
 381         if (nr_segs == 0)
 382                 goto out;
 383
 384         /*
 385          * First get the "struct iovec" from user memory and
 386          * verify all the pointers
 387          */
 388         ret = -EINVAL;
 389         if ((nr_segs > UIO_MAXIOV) || (nr_segs <= 0))
 390                 goto out;
 391         if (!file->f_op)
 392                 goto out;
 393         if (nr_segs > UIO_FASTIOV) {
 394                 ret = -ENOMEM;
 395                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
 396                 if (!iov)
 397                         goto out;
 398         }
 399         ret = -EFAULT;
 400         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector)))
 401                 goto out;
 402
 403         /*
 404          * Single unix specification:
 405          * We should -EINVAL if an element length is not >= 0 and fitting an
 406          * ssize_t.  The total length is fitting an ssize_t
 407          *
 408          * Be careful here because iov_len is a size_t not an ssize_t
 409          */
 410         tot_len = 0;
 411         ret = -EINVAL;
 412         for (seg = 0; seg < nr_segs; seg++) {
 413                 ssize_t len = (ssize_t)iov[seg].iov_len;
 414
 415                 if (len < 0)    /* size_t not fitting an ssize_t .. */
 416                         goto out;
 417                 tot_len += len;
 418                 if ((ssize_t)tot_len < 0) /* maths overflow on the ssize_t */
 419                         goto out;
 420         }
 421         if (tot_len == 0) {
 422                 ret = 0;
 423                 goto out;
 424         }
 425
 426         inode = file->f_dentry->d_inode;
 427         /* VERIFY_WRITE actually means a read, as we write to user space */
 428         ret = locks_verify_area((type == READ
 429                                  ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
 430                                 inode, file, *pos, tot_len);
 431         if (ret)
 432                 goto out;
 433
 434         fnv = NULL;
 435         if (type == READ) {
 436                 fn = file->f_op->read;
 437                 fnv = file->f_op->readv;
 438         } else {
 439                 fn = (io_fn_t)file->f_op->write;
 440                 fnv = file->f_op->writev;
 441         }
 442         if (fnv) {
 443                 ret = fnv(file, iov, nr_segs, pos);
 444                 goto out;
 445         }
 446
 447         /* Do it by hand, with file-ops */
 448         ret = 0;
 449         vector = iov;
 450         while (nr_segs > 0) {
 451                 void __user * base;
 452                 size_t len;
 453                 ssize_t nr;
 454
 455                 base = vector->iov_base;
 456                 len = vector->iov_len;
 457                 vector++;
 458                 nr_segs--;
 459
 460                 nr = fn(file, base, len, pos);
 461
 462                 if (nr < 0) {
 463                         if (!ret) ret = nr;
 464                         break;
 465                 }
 466                 ret += nr;
 467                 if (nr != len)
 468                         break;
 469         }
 470 out:
 471         if (iov != iovstack)
 472                 kfree(iov);
 473         if ((ret + (type == READ)) > 0)
 474                 dnotify_parent(file->f_dentry,
 475                                 (type == READ) ? DN_ACCESS : DN_MODIFY);
 476         return ret;
 477 }
 478
 479 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 480                   unsigned long vlen, loff_t *pos)
 481 {
 482         if (!(file->f_mode & FMODE_READ))
 483                 return -EBADF;
 484         if (!file->f_op || (!file->f_op->readv && !file->f_op->read))
 485                 return -EINVAL;
 486
 487         return do_readv_writev(READ, file, vec, vlen, pos);
 488 }
 489
 490 EXPORT_SYMBOL(vfs_readv);
 491
 492 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 493                    unsigned long vlen, loff_t *pos)
 494 {
 495         if (!(file->f_mode & FMODE_WRITE))
 496                 return -EBADF;
 497         if (!file->f_op || (!file->f_op->writev && !file->f_op->write))
 498                 return -EINVAL;
 499
 500         return do_readv_writev(WRITE, file, vec, vlen, pos);
 501 }
 502
 503 EXPORT_SYMBOL(vfs_writev);
 504
 505 asmlinkage ssize_t
 506 sys_readv(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
 507 {
 508         struct file *file;
 509         ssize_t ret = -EBADF;
 510         int fput_needed;
 511
 512         file = fget_light(fd, &fput_needed);
 513         if (file) {
 514                 ret = vfs_readv(file, vec, vlen, &file->f_pos);
 515                 fput_light(file, fput_needed);
 516         }
 517
 518         return ret;
 519 }
 520
 521 asmlinkage ssize_t
 522 sys_writev(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
 523 {
 524         struct file *file;
 525         ssize_t ret = -EBADF;
 526         int fput_needed;
 527
 528         file = fget_light(fd, &fput_needed);
 529         if (file) {
 530                 ret = vfs_writev(file, vec, vlen, &file->f_pos);
 531                 fput_light(file, fput_needed);
 532         }
 533
 534         return ret;
 535 }
 536
 537 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
 538                            size_t count, loff_t max)
 539 {
 540         struct file * in_file, * out_file;
 541         struct inode * in_inode, * out_inode;
 542         loff_t pos;
 543         ssize_t retval;
 544         int fput_needed_in, fput_needed_out;
 545
 546         /*
 547          * Get input file, and verify that it is ok..
 548          */
 549         retval = -EBADF;
 550         in_file = fget_light(in_fd, &fput_needed_in);
 551         if (!in_file)
 552                 goto out;
 553         if (!(in_file->f_mode & FMODE_READ))
 554                 goto fput_in;
 555         retval = -EINVAL;
 556         in_inode = in_file->f_dentry->d_inode;
 557         if (!in_inode)
 558                 goto fput_in;
 559         if (!in_file->f_op || !in_file->f_op->sendfile)
 560                 goto fput_in;
 561         if (!ppos)
 562                 ppos = &in_file->f_pos;
 563         retval = locks_verify_area(FLOCK_VERIFY_READ, in_inode, in_file, *ppos, count);
 564         if (retval)
 565                 goto fput_in;
 566
 567         retval = security_file_permission (in_file, MAY_READ);
 568         if (retval)
 569                 goto fput_in;
 570
 571         /*
 572          * Get output file, and verify that it is ok..
 573          */
 574         retval = -EBADF;
 575         out_file = fget_light(out_fd, &fput_needed_out);
 576         if (!out_file)
 577                 goto fput_in;
 578         if (!(out_file->f_mode & FMODE_WRITE))
 579                 goto fput_out;
 580         retval = -EINVAL;
 581         if (!out_file->f_op || !out_file->f_op->sendpage)
 582                 goto fput_out;
 583         out_inode = out_file->f_dentry->d_inode;
 584         retval = locks_verify_area(FLOCK_VERIFY_WRITE, out_inode, out_file, out_file->f_pos, count);
 585         if (retval)
 586                 goto fput_out;
 587
 588         retval = security_file_permission (out_file, MAY_WRITE);
 589         if (retval)
 590                 goto fput_out;
 591
 592         if (!max)
 593                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
 594
 595         pos = *ppos;
 596         retval = -EINVAL;
 597         if (unlikely(pos < 0))
 598                 goto fput_out;
 599         if (unlikely(pos + count > max)) {
 600                 retval = -EOVERFLOW;
 601                 if (pos >= max)
 602                         goto fput_out;
 603                 count = max - pos;
 604         }
 605
 606         retval = in_file->f_op->sendfile(in_file, ppos, count, file_send_actor, out_file);
 607
 608         if (*ppos > max)
 609                 retval = -EOVERFLOW;
 610
 611 fput_out:
 612         fput_light(out_file, fput_needed_out);
 613 fput_in:
 614         fput_light(in_file, fput_needed_in);
 615 out:
 616         return retval;
 617 }
 618
 619 asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd, off_t __user *offset, size_t count)
 620 {
 621         loff_t pos;
 622         off_t off;
 623         ssize_t ret;
 624
 625         if (offset) {
 626                 if (unlikely(get_user(off, offset)))
 627                         return -EFAULT;
 628                 pos = off;
 629                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
 630                 if (unlikely(put_user(pos, offset)))
 631                         return -EFAULT;
 632                 return ret;
 633         }
 634
 635         return do_sendfile(out_fd, in_fd, NULL, count, 0);
 636 }
 637
 638 asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd, loff_t __user *offset, size_t count)
 639 {
 640         loff_t pos;
 641         ssize_t ret;
 642
 643         if (offset) {
 644                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
 645                         return -EFAULT;
 646                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
 647                 if (unlikely(put_user(pos, offset)))
 648                         return -EFAULT;
 649                 return ret;
 650         }
 651
 652         return do_sendfile(out_fd, in_fd, NULL, count, 0);
 653 }