module/spl/spl-vnode.c

   1 /*****************************************************************************\
   2  *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
   3  *  Copyright (C) 2007 The Regents of the University of California.
   4  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
   5  *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
   6  *  UCRL-CODE-235197
   7  *
   8  *  This file is part of the SPL, Solaris Porting Layer.
   9  *  For details, see <http://github.com/behlendorf/spl/>.
  10  *
  11  *  The SPL is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License as published by the
  13  *  Free Software Foundation; either version 2 of the License, or (at your
  14  *  option) any later version.
  15  *
  16  *  The SPL is distributed in the hope that it will be useful, but WITHOUT
  17  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19  *  for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
  23  *****************************************************************************
  24  *  Solaris Porting Layer (SPL) Vnode Implementation.
  25 \*****************************************************************************/
  26
  27 #include <sys/vnode.h>
  28 #include <linux/falloc.h>
  29 #include <spl-debug.h>
  30
  31 #ifdef SS_DEBUG_SUBSYS
  32 #undef SS_DEBUG_SUBSYS
  33 #endif
  34
  35 #define SS_DEBUG_SUBSYS SS_VNODE
  36
  37 vnode_t *rootdir = (vnode_t *)0xabcd1234;
  38 EXPORT_SYMBOL(rootdir);
  39
  40 static spl_kmem_cache_t *vn_cache;
  41 static spl_kmem_cache_t *vn_file_cache;
  42
  43 static DEFINE_SPINLOCK(vn_file_lock);
  44 static LIST_HEAD(vn_file_list);
  45
  46 #ifdef HAVE_KERN_PATH_PARENT_HEADER
  47 #ifndef HAVE_KERN_PATH_PARENT_SYMBOL
  48 kern_path_parent_t kern_path_parent_fn = SYMBOL_POISON;
  49 EXPORT_SYMBOL(kern_path_parent_fn);
  50 #endif /* HAVE_KERN_PATH_PARENT_SYMBOL */
  51 #endif /* HAVE_KERN_PATH_PARENT_HEADER */
  52
  53 #ifdef HAVE_KERN_PATH_LOCKED
  54 kern_path_locked_t kern_path_locked_fn = SYMBOL_POISON;
  55 #endif /* HAVE_KERN_PATH_LOCKED */
  56
  57 vtype_t
  58 vn_mode_to_vtype(mode_t mode)
  59 {
  60         if (S_ISREG(mode))
  61                 return VREG;
  62
  63         if (S_ISDIR(mode))
  64                 return VDIR;
  65
  66         if (S_ISCHR(mode))
  67                 return VCHR;
  68
  69         if (S_ISBLK(mode))
  70                 return VBLK;
  71
  72         if (S_ISFIFO(mode))
  73                 return VFIFO;
  74
  75         if (S_ISLNK(mode))
  76                 return VLNK;
  77
  78         if (S_ISSOCK(mode))
  79                 return VSOCK;
  80
  81         if (S_ISCHR(mode))
  82                 return VCHR;
  83
  84         return VNON;
  85 } /* vn_mode_to_vtype() */
  86 EXPORT_SYMBOL(vn_mode_to_vtype);
  87
  88 mode_t
  89 vn_vtype_to_mode(vtype_t vtype)
  90 {
  91         if (vtype == VREG)
  92                 return S_IFREG;
  93
  94         if (vtype == VDIR)
  95                 return S_IFDIR;
  96
  97         if (vtype == VCHR)
  98                 return S_IFCHR;
  99
 100         if (vtype == VBLK)
 101                 return S_IFBLK;
 102
 103         if (vtype == VFIFO)
 104                 return S_IFIFO;
 105
 106         if (vtype == VLNK)
 107                 return S_IFLNK;
 108
 109         if (vtype == VSOCK)
 110                 return S_IFSOCK;
 111
 112         return VNON;
 113 } /* vn_vtype_to_mode() */
 114 EXPORT_SYMBOL(vn_vtype_to_mode);
 115
 116 vnode_t *
 117 vn_alloc(int flag)
 118 {
 119         vnode_t *vp;
 120         SENTRY;
 121
 122         vp = kmem_cache_alloc(vn_cache, flag);
 123         if (vp != NULL) {
 124                 vp->v_file = NULL;
 125                 vp->v_type = 0;
 126         }
 127
 128         SRETURN(vp);
 129 } /* vn_alloc() */
 130 EXPORT_SYMBOL(vn_alloc);
 131
 132 void
 133 vn_free(vnode_t *vp)
 134 {
 135         SENTRY;
 136         kmem_cache_free(vn_cache, vp);
 137         SEXIT;
 138 } /* vn_free() */
 139 EXPORT_SYMBOL(vn_free);
 140
 141 int
 142 vn_open(const char *path, uio_seg_t seg, int flags, int mode,
 143         vnode_t **vpp, int x1, void *x2)
 144 {
 145         struct file *fp;
 146         struct kstat stat;
 147         int rc, saved_umask = 0;
 148         gfp_t saved_gfp;
 149         vnode_t *vp;
 150         SENTRY;
 151
 152         ASSERT(flags & (FWRITE | FREAD));
 153         ASSERT(seg == UIO_SYSSPACE);
 154         ASSERT(vpp);
 155         *vpp = NULL;
 156
 157         if (!(flags & FCREAT) && (flags & FWRITE))
 158                 flags |= FEXCL;
 159
 160         /* Note for filp_open() the two low bits must be remapped to mean:
 161          * 01 - read-only  -> 00 read-only
 162          * 10 - write-only -> 01 write-only
 163          * 11 - read-write -> 10 read-write
 164          */
 165         flags--;
 166
 167         if (flags & FCREAT)
 168                 saved_umask = xchg(&current->fs->umask, 0);
 169
 170         fp = filp_open(path, flags, mode);
 171
 172         if (flags & FCREAT)
 173                 (void)xchg(&current->fs->umask, saved_umask);
 174
 175         if (IS_ERR(fp))
 176                 SRETURN(-PTR_ERR(fp));
 177
 178         rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
 179         if (rc) {
 180                 filp_close(fp, 0);
 181                 SRETURN(-rc);
 182         }
 183
 184         vp = vn_alloc(KM_SLEEP);
 185         if (!vp) {
 186                 filp_close(fp, 0);
 187                 SRETURN(ENOMEM);
 188         }
 189
 190         saved_gfp = mapping_gfp_mask(fp->f_mapping);
 191         mapping_set_gfp_mask(fp->f_mapping, saved_gfp & ~(__GFP_IO|__GFP_FS));
 192
 193         mutex_enter(&vp->v_lock);
 194         vp->v_type = vn_mode_to_vtype(stat.mode);
 195         vp->v_file = fp;
 196         vp->v_gfp_mask = saved_gfp;
 197         *vpp = vp;
 198         mutex_exit(&vp->v_lock);
 199
 200         SRETURN(0);
 201 } /* vn_open() */
 202 EXPORT_SYMBOL(vn_open);
 203
 204 int
 205 vn_openat(const char *path, uio_seg_t seg, int flags, int mode,
 206           vnode_t **vpp, int x1, void *x2, vnode_t *vp, int fd)
 207 {
 208         char *realpath;
 209         int len, rc;
 210         SENTRY;
 211
 212         ASSERT(vp == rootdir);
 213
 214         len = strlen(path) + 2;
 215         realpath = kmalloc(len, GFP_KERNEL);
 216         if (!realpath)
 217                 SRETURN(ENOMEM);
 218
 219         (void)snprintf(realpath, len, "/%s", path);
 220         rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);
 221         kfree(realpath);
 222
 223         SRETURN(rc);
 224 } /* vn_openat() */
 225 EXPORT_SYMBOL(vn_openat);
 226
 227 int
 228 vn_rdwr(uio_rw_t uio, vnode_t *vp, void *addr, ssize_t len, offset_t off,
 229         uio_seg_t seg, int ioflag, rlim64_t x2, void *x3, ssize_t *residp)
 230 {
 231         loff_t offset;
 232         mm_segment_t saved_fs;
 233         struct file *fp;
 234         int rc;
 235         SENTRY;
 236
 237         ASSERT(uio == UIO_WRITE || uio == UIO_READ);
 238         ASSERT(vp);
 239         ASSERT(vp->v_file);
 240         ASSERT(seg == UIO_SYSSPACE);
 241         ASSERT((ioflag & ~FAPPEND) == 0);
 242         ASSERT(x2 == RLIM64_INFINITY);
 243
 244         fp = vp->v_file;
 245
 246         offset = off;
 247         if (ioflag & FAPPEND)
 248                 offset = fp->f_pos;
 249
 250         /* Writable user data segment must be briefly increased for this
 251          * process so we can use the user space read call paths to write
 252          * in to memory allocated by the kernel. */
 253         saved_fs = get_fs();
 254         set_fs(get_ds());
 255
 256         if (uio & UIO_WRITE)
 257                 rc = vfs_write(fp, addr, len, &offset);
 258         else
 259                 rc = vfs_read(fp, addr, len, &offset);
 260
 261         set_fs(saved_fs);
 262         fp->f_pos = offset;
 263
 264         if (rc < 0)
 265                 SRETURN(-rc);
 266
 267         if (residp) {
 268                 *residp = len - rc;
 269         } else {
 270                 if (rc != len)
 271                         SRETURN(EIO);
 272         }
 273
 274         SRETURN(0);
 275 } /* vn_rdwr() */
 276 EXPORT_SYMBOL(vn_rdwr);
 277
 278 int
 279 vn_close(vnode_t *vp, int flags, int x1, int x2, void *x3, void *x4)
 280 {
 281         int rc;
 282         SENTRY;
 283
 284         ASSERT(vp);
 285         ASSERT(vp->v_file);
 286
 287         mapping_set_gfp_mask(vp->v_file->f_mapping, vp->v_gfp_mask);
 288         rc = filp_close(vp->v_file, 0);
 289         vn_free(vp);
 290
 291         SRETURN(-rc);
 292 } /* vn_close() */
 293 EXPORT_SYMBOL(vn_close);
 294
 295 /* vn_seek() does not actually seek it only performs bounds checking on the
 296  * proposed seek.  We perform minimal checking and allow vn_rdwr() to catch
 297  * anything more serious. */
 298 int
 299 vn_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, void *ct)
 300 {
 301         return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
 302 }
 303 EXPORT_SYMBOL(vn_seek);
 304
 305 #ifdef HAVE_KERN_PATH_LOCKED
 306 /* Based on do_unlinkat() from linux/fs/namei.c */
 307 int
 308 vn_remove(const char *path, uio_seg_t seg, int flags)
 309 {
 310         struct dentry *dentry;
 311         struct path parent;
 312         struct inode *inode = NULL;
 313         int rc = 0;
 314         SENTRY;
 315
 316         ASSERT(seg == UIO_SYSSPACE);
 317         ASSERT(flags == RMFILE);
 318
 319         dentry = spl_kern_path_locked(path, &parent);
 320         rc = PTR_ERR(dentry);
 321         if (!IS_ERR(dentry)) {
 322                 if (parent.dentry->d_name.name[parent.dentry->d_name.len])
 323                         SGOTO(slashes, rc = 0);
 324
 325                 inode = dentry->d_inode;
 326                 if (!inode)
 327                         SGOTO(slashes, rc = 0);
 328
 329                 if (inode)
 330                         ihold(inode);
 331
 332                 rc = vfs_unlink(parent.dentry->d_inode, dentry);
 333 exit1:
 334                 dput(dentry);
 335         } else {
 336                 return (-rc);
 337         }
 338
 339         spl_inode_unlock(parent.dentry->d_inode);
 340         if (inode)
 341                 iput(inode);    /* truncate the inode here */
 342
 343         path_put(&parent);
 344         SRETURN(-rc);
 345
 346 slashes:
 347         rc = !dentry->d_inode ? -ENOENT :
 348             S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
 349         SGOTO(exit1, rc);
 350 } /* vn_remove() */
 351 EXPORT_SYMBOL(vn_remove);
 352
 353 /* Based on do_rename() from linux/fs/namei.c */
 354 int
 355 vn_rename(const char *oldname, const char *newname, int x1)
 356 {
 357         struct dentry *old_dir, *new_dir;
 358         struct dentry *old_dentry, *new_dentry;
 359         struct dentry *trap;
 360         struct path old_parent, new_parent;
 361         int rc = 0;
 362         SENTRY;
 363
 364         old_dentry = spl_kern_path_locked(oldname, &old_parent);
 365         if (IS_ERR(old_dentry))
 366                 SGOTO(exit, rc = PTR_ERR(old_dentry));
 367
 368         spl_inode_unlock(old_parent.dentry->d_inode);
 369
 370         new_dentry = spl_kern_path_locked(newname, &new_parent);
 371         if (IS_ERR(new_dentry))
 372                 SGOTO(exit2, rc = PTR_ERR(new_dentry));
 373
 374         spl_inode_unlock(new_parent.dentry->d_inode);
 375
 376         rc = -EXDEV;
 377         if (old_parent.mnt != new_parent.mnt)
 378                 SGOTO(exit3, rc);
 379
 380         old_dir = old_parent.dentry;
 381         new_dir = new_parent.dentry;
 382         trap = lock_rename(new_dir, old_dir);
 383
 384         /* source should not be ancestor of target */
 385         rc = -EINVAL;
 386         if (old_dentry == trap)
 387                 SGOTO(exit4, rc);
 388
 389         /* target should not be an ancestor of source */
 390         rc = -ENOTEMPTY;
 391         if (new_dentry == trap)
 392                 SGOTO(exit4, rc);
 393
 394         /* source must exist */
 395         rc = -ENOENT;
 396         if (!old_dentry->d_inode)
 397                 SGOTO(exit4, rc);
 398
 399         /* unless the source is a directory trailing slashes give -ENOTDIR */
 400         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
 401                 rc = -ENOTDIR;
 402                 if (old_dentry->d_name.name[old_dentry->d_name.len])
 403                         SGOTO(exit4, rc);
 404                 if (new_dentry->d_name.name[new_dentry->d_name.len])
 405                         SGOTO(exit4, rc);
 406         }
 407
 408 #ifdef HAVE_4ARGS_VFS_RENAME
 409         rc = vfs_rename(old_dir->d_inode, old_dentry,
 410                         new_dir->d_inode, new_dentry);
 411 #else
 412         rc = vfs_rename(old_dir->d_inode, old_dentry, oldnd.nd_mnt,
 413                         new_dir->d_inode, new_dentry, newnd.nd_mnt);
 414 #endif /* HAVE_4ARGS_VFS_RENAME */
 415 exit4:
 416         unlock_rename(new_dir, old_dir);
 417 exit3:
 418         dput(new_dentry);
 419         path_put(&new_parent);
 420 exit2:
 421         dput(old_dentry);
 422         path_put(&old_parent);
 423 exit:
 424         SRETURN(-rc);
 425 }
 426 EXPORT_SYMBOL(vn_rename);
 427
 428 #else
 429 static struct dentry *
 430 vn_lookup_hash(struct nameidata *nd)
 431 {
 432         return lookup_one_len((const char *)nd->last.name,
 433                               nd->nd_dentry, nd->last.len);
 434 } /* lookup_hash() */
 435
 436 static void
 437 vn_path_release(struct nameidata *nd)
 438 {
 439         dput(nd->nd_dentry);
 440         mntput(nd->nd_mnt);
 441 }
 442
 443 /* Modified do_unlinkat() from linux/fs/namei.c, only uses exported symbols */
 444 int
 445 vn_remove(const char *path, uio_seg_t seg, int flags)
 446 {
 447         struct dentry *dentry;
 448         struct nameidata nd;
 449         struct inode *inode = NULL;
 450         int rc = 0;
 451         SENTRY;
 452
 453         ASSERT(seg == UIO_SYSSPACE);
 454         ASSERT(flags == RMFILE);
 455
 456         rc = spl_kern_path_parent(path, &nd);
 457         if (rc)
 458                 SGOTO(exit, rc);
 459
 460         rc = -EISDIR;
 461         if (nd.last_type != LAST_NORM)
 462                 SGOTO(exit1, rc);
 463
 464         spl_inode_lock_nested(nd.nd_dentry->d_inode, I_MUTEX_PARENT);
 465         dentry = vn_lookup_hash(&nd);
 466         rc = PTR_ERR(dentry);
 467         if (!IS_ERR(dentry)) {
 468                 /* Why not before? Because we want correct rc value */
 469                 if (nd.last.name[nd.last.len])
 470                         SGOTO(slashes, rc);
 471
 472                 inode = dentry->d_inode;
 473                 if (inode)
 474                         atomic_inc(&inode->i_count);
 475 #ifdef HAVE_2ARGS_VFS_UNLINK
 476                 rc = vfs_unlink(nd.nd_dentry->d_inode, dentry);
 477 #else
 478                 rc = vfs_unlink(nd.nd_dentry->d_inode, dentry, nd.nd_mnt);
 479 #endif /* HAVE_2ARGS_VFS_UNLINK */
 480 exit2:
 481                 dput(dentry);
 482         }
 483
 484         spl_inode_unlock(nd.nd_dentry->d_inode);
 485         if (inode)
 486                 iput(inode);    /* truncate the inode here */
 487 exit1:
 488         vn_path_release(&nd);
 489 exit:
 490         SRETURN(-rc);
 491
 492 slashes:
 493         rc = !dentry->d_inode ? -ENOENT :
 494                 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
 495         SGOTO(exit2, rc);
 496 } /* vn_remove() */
 497 EXPORT_SYMBOL(vn_remove);
 498
 499 /* Modified do_rename() from linux/fs/namei.c, only uses exported symbols */
 500 int
 501 vn_rename(const char *oldname, const char *newname, int x1)
 502 {
 503         struct dentry *old_dir, *new_dir;
 504         struct dentry *old_dentry, *new_dentry;
 505         struct dentry *trap;
 506         struct nameidata oldnd, newnd;
 507         int rc = 0;
 508         SENTRY;
 509
 510         rc = spl_kern_path_parent(oldname, &oldnd);
 511         if (rc)
 512                 SGOTO(exit, rc);
 513
 514         rc = spl_kern_path_parent(newname, &newnd);
 515         if (rc)
 516                 SGOTO(exit1, rc);
 517
 518         rc = -EXDEV;
 519         if (oldnd.nd_mnt != newnd.nd_mnt)
 520                 SGOTO(exit2, rc);
 521
 522         old_dir = oldnd.nd_dentry;
 523         rc = -EBUSY;
 524         if (oldnd.last_type != LAST_NORM)
 525                 SGOTO(exit2, rc);
 526
 527         new_dir = newnd.nd_dentry;
 528         if (newnd.last_type != LAST_NORM)
 529                 SGOTO(exit2, rc);
 530
 531         trap = lock_rename(new_dir, old_dir);
 532
 533         old_dentry = vn_lookup_hash(&oldnd);
 534
 535         rc = PTR_ERR(old_dentry);
 536         if (IS_ERR(old_dentry))
 537                 SGOTO(exit3, rc);
 538
 539         /* source must exist */
 540         rc = -ENOENT;
 541         if (!old_dentry->d_inode)
 542                 SGOTO(exit4, rc);
 543
 544         /* unless the source is a directory trailing slashes give -ENOTDIR */
 545         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
 546                 rc = -ENOTDIR;
 547                 if (oldnd.last.name[oldnd.last.len])
 548                         SGOTO(exit4, rc);
 549                 if (newnd.last.name[newnd.last.len])
 550                         SGOTO(exit4, rc);
 551         }
 552
 553         /* source should not be ancestor of target */
 554         rc = -EINVAL;
 555         if (old_dentry == trap)
 556                 SGOTO(exit4, rc);
 557
 558         new_dentry = vn_lookup_hash(&newnd);
 559         rc = PTR_ERR(new_dentry);
 560         if (IS_ERR(new_dentry))
 561                 SGOTO(exit4, rc);
 562
 563         /* target should not be an ancestor of source */
 564         rc = -ENOTEMPTY;
 565         if (new_dentry == trap)
 566                 SGOTO(exit5, rc);
 567
 568 #ifdef HAVE_4ARGS_VFS_RENAME
 569         rc = vfs_rename(old_dir->d_inode, old_dentry,
 570                         new_dir->d_inode, new_dentry);
 571 #else
 572         rc = vfs_rename(old_dir->d_inode, old_dentry, oldnd.nd_mnt,
 573                         new_dir->d_inode, new_dentry, newnd.nd_mnt);
 574 #endif /* HAVE_4ARGS_VFS_RENAME */
 575 exit5:
 576         dput(new_dentry);
 577 exit4:
 578         dput(old_dentry);
 579 exit3:
 580         unlock_rename(new_dir, old_dir);
 581 exit2:
 582         vn_path_release(&newnd);
 583 exit1:
 584         vn_path_release(&oldnd);
 585 exit:
 586         SRETURN(-rc);
 587 }
 588 EXPORT_SYMBOL(vn_rename);
 589 #endif /* HAVE_KERN_PATH_LOCKED */
 590
 591 int
 592 vn_getattr(vnode_t *vp, vattr_t *vap, int flags, void *x3, void *x4)
 593 {
 594         struct file *fp;
 595         struct kstat stat;
 596         int rc;
 597         SENTRY;
 598
 599         ASSERT(vp);
 600         ASSERT(vp->v_file);
 601         ASSERT(vap);
 602
 603         fp = vp->v_file;
 604
 605         rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
 606         if (rc)
 607                 SRETURN(-rc);
 608
 609         vap->va_type          = vn_mode_to_vtype(stat.mode);
 610         vap->va_mode          = stat.mode;
 611         vap->va_uid           = stat.uid;
 612         vap->va_gid           = stat.gid;
 613         vap->va_fsid          = 0;
 614         vap->va_nodeid        = stat.ino;
 615         vap->va_nlink         = stat.nlink;
 616         vap->va_size          = stat.size;
 617         vap->va_blksize       = stat.blksize;
 618         vap->va_atime         = stat.atime;
 619         vap->va_mtime         = stat.mtime;
 620         vap->va_ctime         = stat.ctime;
 621         vap->va_rdev          = stat.rdev;
 622         vap->va_nblocks       = stat.blocks;
 623
 624         SRETURN(0);
 625 }
 626 EXPORT_SYMBOL(vn_getattr);
 627
 628 int vn_fsync(vnode_t *vp, int flags, void *x3, void *x4)
 629 {
 630         int datasync = 0;
 631         SENTRY;
 632
 633         ASSERT(vp);
 634         ASSERT(vp->v_file);
 635
 636         if (flags & FDSYNC)
 637                 datasync = 1;
 638
 639         SRETURN(-spl_filp_fsync(vp->v_file, datasync));
 640 } /* vn_fsync() */
 641 EXPORT_SYMBOL(vn_fsync);
 642
 643 int vn_space(vnode_t *vp, int cmd, struct flock *bfp, int flag,
 644     offset_t offset, void *x6, void *x7)
 645 {
 646         int error = EOPNOTSUPP;
 647         SENTRY;
 648
 649         if (cmd != F_FREESP || bfp->l_whence != 0)
 650                 SRETURN(EOPNOTSUPP);
 651
 652         ASSERT(vp);
 653         ASSERT(vp->v_file);
 654         ASSERT(bfp->l_start >= 0 && bfp->l_len > 0);
 655
 656 #ifdef FALLOC_FL_PUNCH_HOLE
 657         /*
 658          * When supported by the underlying file system preferentially
 659          * use the fallocate() callback to preallocate the space.
 660          */
 661         error = -spl_filp_fallocate(vp->v_file,
 662             FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,
 663             bfp->l_start, bfp->l_len);
 664         if (error == 0)
 665                 SRETURN(0);
 666 #endif
 667
 668 #ifdef HAVE_INODE_TRUNCATE_RANGE
 669         if (vp->v_file->f_dentry && vp->v_file->f_dentry->d_inode &&
 670             vp->v_file->f_dentry->d_inode->i_op &&
 671             vp->v_file->f_dentry->d_inode->i_op->truncate_range) {
 672                 off_t end = bfp->l_start + bfp->l_len;
 673                 /*
 674                  * Judging from the code in shmem_truncate_range(),
 675                  * it seems the kernel expects the end offset to be
 676                  * inclusive and aligned to the end of a page.
 677                  */
 678                 if (end % PAGE_SIZE != 0) {
 679                         end &= ~(off_t)(PAGE_SIZE - 1);
 680                         if (end <= bfp->l_start)
 681                                 SRETURN(0);
 682                 }
 683                 --end;
 684
 685                 vp->v_file->f_dentry->d_inode->i_op->truncate_range(
 686                         vp->v_file->f_dentry->d_inode,
 687                         bfp->l_start, end
 688                 );
 689                 SRETURN(0);
 690         }
 691 #endif
 692
 693         SRETURN(error);
 694 }
 695 EXPORT_SYMBOL(vn_space);
 696
 697 /* Function must be called while holding the vn_file_lock */
 698 static file_t *
 699 file_find(int fd)
 700 {
 701         file_t *fp;
 702
 703         ASSERT(spin_is_locked(&vn_file_lock));
 704
 705         list_for_each_entry(fp, &vn_file_list,  f_list) {
 706                 if (fd == fp->f_fd && fp->f_task == current) {
 707                         ASSERT(atomic_read(&fp->f_ref) != 0);
 708                         return fp;
 709                 }
 710         }
 711
 712         return NULL;
 713 } /* file_find() */
 714
 715 file_t *
 716 vn_getf(int fd)
 717 {
 718         struct kstat stat;
 719         struct file *lfp;
 720         file_t *fp;
 721         vnode_t *vp;
 722         int rc = 0;
 723         SENTRY;
 724
 725         /* Already open just take an extra reference */
 726         spin_lock(&vn_file_lock);
 727
 728         fp = file_find(fd);
 729         if (fp) {
 730                 atomic_inc(&fp->f_ref);
 731                 spin_unlock(&vn_file_lock);
 732                 SRETURN(fp);
 733         }
 734
 735         spin_unlock(&vn_file_lock);
 736
 737         /* File was not yet opened create the object and setup */
 738         fp = kmem_cache_alloc(vn_file_cache, KM_SLEEP);
 739         if (fp == NULL)
 740                 SGOTO(out, rc);
 741
 742         mutex_enter(&fp->f_lock);
 743
 744         fp->f_fd = fd;
 745         fp->f_task = current;
 746         fp->f_offset = 0;
 747         atomic_inc(&fp->f_ref);
 748
 749         lfp = fget(fd);
 750         if (lfp == NULL)
 751                 SGOTO(out_mutex, rc);
 752
 753         vp = vn_alloc(KM_SLEEP);
 754         if (vp == NULL)
 755                 SGOTO(out_fget, rc);
 756
 757         if (vfs_getattr(lfp->f_vfsmnt, lfp->f_dentry, &stat))
 758                 SGOTO(out_vnode, rc);
 759
 760         mutex_enter(&vp->v_lock);
 761         vp->v_type = vn_mode_to_vtype(stat.mode);
 762         vp->v_file = lfp;
 763         mutex_exit(&vp->v_lock);
 764
 765         fp->f_vnode = vp;
 766         fp->f_file = lfp;
 767
 768         /* Put it on the tracking list */
 769         spin_lock(&vn_file_lock);
 770         list_add(&fp->f_list, &vn_file_list);
 771         spin_unlock(&vn_file_lock);
 772
 773         mutex_exit(&fp->f_lock);
 774         SRETURN(fp);
 775
 776 out_vnode:
 777         vn_free(vp);
 778 out_fget:
 779         fput(lfp);
 780 out_mutex:
 781         mutex_exit(&fp->f_lock);
 782         kmem_cache_free(vn_file_cache, fp);
 783 out:
 784         SRETURN(NULL);
 785 } /* getf() */
 786 EXPORT_SYMBOL(getf);
 787
 788 static void releasef_locked(file_t *fp)
 789 {
 790         ASSERT(fp->f_file);
 791         ASSERT(fp->f_vnode);
 792
 793         /* Unlinked from list, no refs, safe to free outside mutex */
 794         fput(fp->f_file);
 795         vn_free(fp->f_vnode);
 796
 797         kmem_cache_free(vn_file_cache, fp);
 798 }
 799
 800 void
 801 vn_releasef(int fd)
 802 {
 803         file_t *fp;
 804         SENTRY;
 805
 806         spin_lock(&vn_file_lock);
 807         fp = file_find(fd);
 808         if (fp) {
 809                 atomic_dec(&fp->f_ref);
 810                 if (atomic_read(&fp->f_ref) > 0) {
 811                         spin_unlock(&vn_file_lock);
 812                         SEXIT;
 813                         return;
 814                 }
 815
 816                 list_del(&fp->f_list);
 817                 releasef_locked(fp);
 818         }
 819         spin_unlock(&vn_file_lock);
 820
 821         SEXIT;
 822         return;
 823 } /* releasef() */
 824 EXPORT_SYMBOL(releasef);
 825
 826 #ifndef HAVE_SET_FS_PWD
 827 # ifdef HAVE_2ARGS_SET_FS_PWD
 828 /* Used from 2.6.25 - 2.6.31+ */
 829 void
 830 set_fs_pwd(struct fs_struct *fs, struct path *path)
 831 {
 832         struct path old_pwd;
 833
 834 #  ifdef HAVE_FS_STRUCT_SPINLOCK
 835         spin_lock(&fs->lock);
 836         old_pwd = fs->pwd;
 837         fs->pwd = *path;
 838         path_get(path);
 839         spin_unlock(&fs->lock);
 840 #  else
 841         write_lock(&fs->lock);
 842         old_pwd = fs->pwd;
 843         fs->pwd = *path;
 844         path_get(path);
 845         write_unlock(&fs->lock);
 846 #  endif /* HAVE_FS_STRUCT_SPINLOCK */
 847
 848         if (old_pwd.dentry)
 849                 path_put(&old_pwd);
 850 }
 851 # else
 852 /* Used from 2.6.11 - 2.6.24 */
 853 void
 854 set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt, struct dentry *dentry)
 855 {
 856         struct dentry *old_pwd;
 857         struct vfsmount *old_pwdmnt;
 858
 859         write_lock(&fs->lock);
 860         old_pwd = fs->pwd;
 861         old_pwdmnt = fs->pwdmnt;
 862         fs->pwdmnt = mntget(mnt);
 863         fs->pwd = dget(dentry);
 864         write_unlock(&fs->lock);
 865
 866         if (old_pwd) {
 867                 dput(old_pwd);
 868                 mntput(old_pwdmnt);
 869         }
 870 }
 871 # endif /* HAVE_2ARGS_SET_FS_PWD */
 872 #endif /* HAVE_SET_FS_PWD */
 873
 874 int
 875 vn_set_pwd(const char *filename)
 876 {
 877 #if defined(HAVE_2ARGS_SET_FS_PWD) && defined(HAVE_USER_PATH_DIR)
 878         struct path path;
 879 #else
 880         struct nameidata nd;
 881 #endif /* HAVE_2ARGS_SET_FS_PWD */
 882         mm_segment_t saved_fs;
 883         int rc;
 884         SENTRY;
 885
 886         /*
 887          * user_path_dir() and __user_walk() both expect 'filename' to be
 888          * a user space address so we must briefly increase the data segment
 889          * size to ensure strncpy_from_user() does not fail with -EFAULT.
 890          */
 891         saved_fs = get_fs();
 892         set_fs(get_ds());
 893
 894 #ifdef HAVE_2ARGS_SET_FS_PWD
 895 # ifdef HAVE_USER_PATH_DIR
 896         rc = user_path_dir(filename, &path);
 897         if (rc)
 898                 SGOTO(out, rc);
 899
 900         rc = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
 901         if (rc)
 902                 SGOTO(dput_and_out, rc);
 903
 904         set_fs_pwd(current->fs, &path);
 905
 906 dput_and_out:
 907         path_put(&path);
 908 # else
 909         rc = __user_walk(filename,
 910                          LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_CHDIR, &nd);
 911         if (rc)
 912                 SGOTO(out, rc);
 913
 914         rc = vfs_permission(&nd, MAY_EXEC);
 915         if (rc)
 916                 SGOTO(dput_and_out, rc);
 917
 918         set_fs_pwd(current->fs, &nd.path);
 919
 920 dput_and_out:
 921         path_put(&nd.path);
 922 # endif /* HAVE_USER_PATH_DIR */
 923 #else
 924         rc = __user_walk(filename,
 925                          LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_CHDIR, &nd);
 926         if (rc)
 927                 SGOTO(out, rc);
 928
 929         rc = vfs_permission(&nd, MAY_EXEC);
 930         if (rc)
 931                 SGOTO(dput_and_out, rc);
 932
 933         set_fs_pwd(current->fs, nd.nd_mnt, nd.nd_dentry);
 934
 935 dput_and_out:
 936         vn_path_release(&nd);
 937 #endif /* HAVE_2ARGS_SET_FS_PWD */
 938 out:
 939         set_fs(saved_fs);
 940
 941         SRETURN(-rc);
 942 } /* vn_set_pwd() */
 943 EXPORT_SYMBOL(vn_set_pwd);
 944
 945 static int
 946 vn_cache_constructor(void *buf, void *cdrarg, int kmflags)
 947 {
 948         struct vnode *vp = buf;
 949
 950         mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);
 951
 952         return (0);
 953 } /* vn_cache_constructor() */
 954
 955 static void
 956 vn_cache_destructor(void *buf, void *cdrarg)
 957 {
 958         struct vnode *vp = buf;
 959
 960         mutex_destroy(&vp->v_lock);
 961 } /* vn_cache_destructor() */
 962
 963 static int
 964 vn_file_cache_constructor(void *buf, void *cdrarg, int kmflags)
 965 {
 966         file_t *fp = buf;
 967
 968         atomic_set(&fp->f_ref, 0);
 969         mutex_init(&fp->f_lock, NULL, MUTEX_DEFAULT, NULL);
 970         INIT_LIST_HEAD(&fp->f_list);
 971
 972         return (0);
 973 } /* file_cache_constructor() */
 974
 975 static void
 976 vn_file_cache_destructor(void *buf, void *cdrarg)
 977 {
 978         file_t *fp = buf;
 979
 980         mutex_destroy(&fp->f_lock);
 981 } /* vn_file_cache_destructor() */
 982
 983 int spl_vn_init_kallsyms_lookup(void)
 984 {
 985 #ifdef HAVE_KERN_PATH_PARENT_HEADER
 986 #ifndef HAVE_KERN_PATH_PARENT_SYMBOL
 987         kern_path_parent_fn = (kern_path_parent_t)
 988                 spl_kallsyms_lookup_name("kern_path_parent");
 989         if (!kern_path_parent_fn) {
 990                 printk(KERN_ERR "Error: Unknown symbol kern_path_parent\n");
 991                 return -EFAULT;
 992         }
 993 #endif /* HAVE_KERN_PATH_PARENT_SYMBOL */
 994 #endif /* HAVE_KERN_PATH_PARENT_HEADER */
 995
 996 #ifdef HAVE_KERN_PATH_LOCKED
 997         kern_path_locked_fn = (kern_path_locked_t)
 998                 spl_kallsyms_lookup_name("kern_path_locked");
 999         if (!kern_path_locked_fn) {
1000                 printk(KERN_ERR "Error: Unknown symbol kern_path_locked\n");
1001                 return -EFAULT;
1002         }
1003 #endif
1004
1005         return (0);
1006 }
1007
1008 int
1009 spl_vn_init(void)
1010 {
1011         SENTRY;
1012         vn_cache = kmem_cache_create("spl_vn_cache",
1013                                      sizeof(struct vnode), 64,
1014                                      vn_cache_constructor,
1015                                      vn_cache_destructor,
1016                                      NULL, NULL, NULL, KMC_KMEM);
1017
1018         vn_file_cache = kmem_cache_create("spl_vn_file_cache",
1019                                           sizeof(file_t), 64,
1020                                           vn_file_cache_constructor,
1021                                           vn_file_cache_destructor,
1022                                           NULL, NULL, NULL, KMC_KMEM);
1023         SRETURN(0);
1024 } /* vn_init() */
1025
1026 void
1027 spl_vn_fini(void)
1028 {
1029         file_t *fp, *next_fp;
1030         int leaked = 0;
1031         SENTRY;
1032
1033         spin_lock(&vn_file_lock);
1034
1035         list_for_each_entry_safe(fp, next_fp, &vn_file_list,  f_list) {
1036                 list_del(&fp->f_list);
1037                 releasef_locked(fp);
1038                 leaked++;
1039         }
1040
1041         spin_unlock(&vn_file_lock);
1042
1043         if (leaked > 0)
1044                 SWARN("Warning %d files leaked\n", leaked);
1045
1046         kmem_cache_destroy(vn_file_cache);
1047         kmem_cache_destroy(vn_cache);
1048
1049         SEXIT;
1050         return;
1051 } /* vn_fini() */