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/sysmacros.h>
  28 #include <sys/vnode.h>
  29
  30
  31 #ifdef DEBUG_SUBSYSTEM
  32 #undef DEBUG_SUBSYSTEM
  33 #endif
  34
  35 #define DEBUG_SUBSYSTEM S_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 spinlock_t vn_file_lock = SPIN_LOCK_UNLOCKED;
  44 static LIST_HEAD(vn_file_list);
  45
  46 static vtype_t
  47 vn_get_sol_type(umode_t mode)
  48 {
  49         if (S_ISREG(mode))
  50                 return VREG;
  51
  52         if (S_ISDIR(mode))
  53                 return VDIR;
  54
  55         if (S_ISCHR(mode))
  56                 return VCHR;
  57
  58         if (S_ISBLK(mode))
  59                 return VBLK;
  60
  61         if (S_ISFIFO(mode))
  62                 return VFIFO;
  63
  64         if (S_ISLNK(mode))
  65                 return VLNK;
  66
  67         if (S_ISSOCK(mode))
  68                 return VSOCK;
  69
  70         if (S_ISCHR(mode))
  71                 return VCHR;
  72
  73         return VNON;
  74 } /* vn_get_sol_type() */
  75
  76 vnode_t *
  77 vn_alloc(int flag)
  78 {
  79         vnode_t *vp;
  80         ENTRY;
  81
  82         vp = kmem_cache_alloc(vn_cache, flag);
  83         if (vp != NULL) {
  84                 vp->v_file = NULL;
  85                 vp->v_type = 0;
  86         }
  87
  88         RETURN(vp);
  89 } /* vn_alloc() */
  90 EXPORT_SYMBOL(vn_alloc);
  91
  92 void
  93 vn_free(vnode_t *vp)
  94 {
  95         ENTRY;
  96         kmem_cache_free(vn_cache, vp);
  97         EXIT;
  98 } /* vn_free() */
  99 EXPORT_SYMBOL(vn_free);
 100
 101 int
 102 vn_open(const char *path, uio_seg_t seg, int flags, int mode,
 103         vnode_t **vpp, int x1, void *x2)
 104 {
 105         struct file *fp;
 106         struct kstat stat;
 107         int rc, saved_umask = 0;
 108         vnode_t *vp;
 109         ENTRY;
 110
 111         ASSERT(flags & (FWRITE | FREAD));
 112         ASSERT(seg == UIO_SYSSPACE);
 113         ASSERT(vpp);
 114         *vpp = NULL;
 115
 116         if (!(flags & FCREAT) && (flags & FWRITE))
 117                 flags |= FEXCL;
 118
 119         /* Note for filp_open() the two low bits must be remapped to mean:
 120          * 01 - read-only  -> 00 read-only
 121          * 10 - write-only -> 01 write-only
 122          * 11 - read-write -> 10 read-write
 123          */
 124         flags--;
 125
 126         if (flags & FCREAT)
 127                 saved_umask = xchg(&current->fs->umask, 0);
 128
 129         fp = filp_open(path, flags, mode);
 130
 131         if (flags & FCREAT)
 132                 (void)xchg(&current->fs->umask, saved_umask);
 133
 134         if (IS_ERR(fp))
 135                 RETURN(-PTR_ERR(fp));
 136
 137         rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
 138         if (rc) {
 139                 filp_close(fp, 0);
 140                 RETURN(-rc);
 141         }
 142
 143         vp = vn_alloc(KM_SLEEP);
 144         if (!vp) {
 145                 filp_close(fp, 0);
 146                 RETURN(ENOMEM);
 147         }
 148
 149         mutex_enter(&vp->v_lock);
 150         vp->v_type = vn_get_sol_type(stat.mode);
 151         vp->v_file = fp;
 152         *vpp = vp;
 153         mutex_exit(&vp->v_lock);
 154
 155         RETURN(0);
 156 } /* vn_open() */
 157 EXPORT_SYMBOL(vn_open);
 158
 159 int
 160 vn_openat(const char *path, uio_seg_t seg, int flags, int mode,
 161           vnode_t **vpp, int x1, void *x2, vnode_t *vp, int fd)
 162 {
 163         char *realpath;
 164         int len, rc;
 165         ENTRY;
 166
 167         ASSERT(vp == rootdir);
 168
 169         len = strlen(path) + 2;
 170         realpath = kmalloc(len, GFP_KERNEL);
 171         if (!realpath)
 172                 RETURN(ENOMEM);
 173
 174         (void)snprintf(realpath, len, "/%s", path);
 175         rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);
 176         kfree(realpath);
 177
 178         RETURN(rc);
 179 } /* vn_openat() */
 180 EXPORT_SYMBOL(vn_openat);
 181
 182 int
 183 vn_rdwr(uio_rw_t uio, vnode_t *vp, void *addr, ssize_t len, offset_t off,
 184         uio_seg_t seg, int ioflag, rlim64_t x2, void *x3, ssize_t *residp)
 185 {
 186         loff_t offset;
 187         mm_segment_t saved_fs;
 188         struct file *fp;
 189         int rc;
 190         ENTRY;
 191
 192         ASSERT(uio == UIO_WRITE || uio == UIO_READ);
 193         ASSERT(vp);
 194         ASSERT(vp->v_file);
 195         ASSERT(seg == UIO_SYSSPACE);
 196         ASSERT((ioflag & ~FAPPEND) == 0);
 197         ASSERT(x2 == RLIM64_INFINITY);
 198
 199         fp = vp->v_file;
 200
 201         offset = off;
 202         if (ioflag & FAPPEND)
 203                 offset = fp->f_pos;
 204
 205         /* Writable user data segment must be briefly increased for this
 206          * process so we can use the user space read call paths to write
 207          * in to memory allocated by the kernel. */
 208         saved_fs = get_fs();
 209         set_fs(get_ds());
 210
 211         if (uio & UIO_WRITE)
 212                 rc = vfs_write(fp, addr, len, &offset);
 213         else
 214                 rc = vfs_read(fp, addr, len, &offset);
 215
 216         set_fs(saved_fs);
 217
 218         if (rc < 0)
 219                 RETURN(-rc);
 220
 221         if (residp) {
 222                 *residp = len - rc;
 223         } else {
 224                 if (rc != len)
 225                         RETURN(EIO);
 226         }
 227
 228         RETURN(0);
 229 } /* vn_rdwr() */
 230 EXPORT_SYMBOL(vn_rdwr);
 231
 232 int
 233 vn_close(vnode_t *vp, int flags, int x1, int x2, void *x3, void *x4)
 234 {
 235         int rc;
 236         ENTRY;
 237
 238         ASSERT(vp);
 239         ASSERT(vp->v_file);
 240
 241         rc = filp_close(vp->v_file, 0);
 242         vn_free(vp);
 243
 244         RETURN(-rc);
 245 } /* vn_close() */
 246 EXPORT_SYMBOL(vn_close);
 247
 248 /* vn_seek() does not actually seek it only performs bounds checking on the
 249  * proposed seek.  We perform minimal checking and allow vn_rdwr() to catch
 250  * anything more serious. */
 251 int
 252 vn_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
 253 {
 254         return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
 255 }
 256 EXPORT_SYMBOL(vn_seek);
 257
 258 static struct dentry *
 259 vn_lookup_hash(struct nameidata *nd)
 260 {
 261         return lookup_one_len(nd->last.name, nd->nd_dentry, nd->last.len);
 262 } /* lookup_hash() */
 263
 264 static void
 265 vn_path_release(struct nameidata *nd)
 266 {
 267         dput(nd->nd_dentry);
 268         mntput(nd->nd_mnt);
 269 }
 270
 271 /* Modified do_unlinkat() from linux/fs/namei.c, only uses exported symbols */
 272 int
 273 vn_remove(const char *path, uio_seg_t seg, int flags)
 274 {
 275         struct dentry *dentry;
 276         struct nameidata nd;
 277         struct inode *inode = NULL;
 278         int rc = 0;
 279         ENTRY;
 280
 281         ASSERT(seg == UIO_SYSSPACE);
 282         ASSERT(flags == RMFILE);
 283
 284         rc = path_lookup(path, LOOKUP_PARENT, &nd);
 285         if (rc)
 286                 GOTO(exit, rc);
 287
 288         rc = -EISDIR;
 289         if (nd.last_type != LAST_NORM)
 290                 GOTO(exit1, rc);
 291
 292 #ifdef HAVE_INODE_I_MUTEX
 293         mutex_lock_nested(&nd.nd_dentry->d_inode->i_mutex, I_MUTEX_PARENT);
 294 #else
 295         down(&nd.nd_dentry->d_inode->i_sem);
 296 #endif /* HAVE_INODE_I_MUTEX */
 297         dentry = vn_lookup_hash(&nd);
 298         rc = PTR_ERR(dentry);
 299         if (!IS_ERR(dentry)) {
 300                 /* Why not before? Because we want correct rc value */
 301                 if (nd.last.name[nd.last.len])
 302                         GOTO(slashes, rc);
 303
 304                 inode = dentry->d_inode;
 305                 if (inode)
 306                         atomic_inc(&inode->i_count);
 307 #ifdef HAVE_2ARGS_VFS_UNLINK
 308                 rc = vfs_unlink(nd.nd_dentry->d_inode, dentry);
 309 #else
 310                 rc = vfs_unlink(nd.nd_dentry->d_inode, dentry, nd.nd_mnt);
 311 #endif /* HAVE_2ARGS_VFS_UNLINK */
 312 exit2:
 313                 dput(dentry);
 314         }
 315 #ifdef HAVE_INODE_I_MUTEX
 316         mutex_unlock(&nd.nd_dentry->d_inode->i_mutex);
 317 #else
 318         up(&nd.nd_dentry->d_inode->i_sem);
 319 #endif /* HAVE_INODE_I_MUTEX */
 320         if (inode)
 321                 iput(inode);    /* truncate the inode here */
 322 exit1:
 323         vn_path_release(&nd);
 324 exit:
 325         RETURN(-rc);
 326
 327 slashes:
 328         rc = !dentry->d_inode ? -ENOENT :
 329                 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
 330         GOTO(exit2, rc);
 331 } /* vn_remove() */
 332 EXPORT_SYMBOL(vn_remove);
 333
 334 /* Modified do_rename() from linux/fs/namei.c, only uses exported symbols */
 335 int
 336 vn_rename(const char *oldname, const char *newname, int x1)
 337 {
 338         struct dentry *old_dir, *new_dir;
 339         struct dentry *old_dentry, *new_dentry;
 340         struct dentry *trap;
 341         struct nameidata oldnd, newnd;
 342         int rc = 0;
 343         ENTRY;
 344
 345         rc = path_lookup(oldname, LOOKUP_PARENT, &oldnd);
 346         if (rc)
 347                 GOTO(exit, rc);
 348
 349         rc = path_lookup(newname, LOOKUP_PARENT, &newnd);
 350         if (rc)
 351                 GOTO(exit1, rc);
 352
 353         rc = -EXDEV;
 354         if (oldnd.nd_mnt != newnd.nd_mnt)
 355                 GOTO(exit2, rc);
 356
 357         old_dir = oldnd.nd_dentry;
 358         rc = -EBUSY;
 359         if (oldnd.last_type != LAST_NORM)
 360                 GOTO(exit2, rc);
 361
 362         new_dir = newnd.nd_dentry;
 363         if (newnd.last_type != LAST_NORM)
 364                 GOTO(exit2, rc);
 365
 366         trap = lock_rename(new_dir, old_dir);
 367
 368         old_dentry = vn_lookup_hash(&oldnd);
 369
 370         rc = PTR_ERR(old_dentry);
 371         if (IS_ERR(old_dentry))
 372                 GOTO(exit3, rc);
 373
 374         /* source must exist */
 375         rc = -ENOENT;
 376         if (!old_dentry->d_inode)
 377                 GOTO(exit4, rc);
 378
 379         /* unless the source is a directory trailing slashes give -ENOTDIR */
 380         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
 381                 rc = -ENOTDIR;
 382                 if (oldnd.last.name[oldnd.last.len])
 383                         GOTO(exit4, rc);
 384                 if (newnd.last.name[newnd.last.len])
 385                         GOTO(exit4, rc);
 386         }
 387
 388         /* source should not be ancestor of target */
 389         rc = -EINVAL;
 390         if (old_dentry == trap)
 391                 GOTO(exit4, rc);
 392
 393         new_dentry = vn_lookup_hash(&newnd);
 394         rc = PTR_ERR(new_dentry);
 395         if (IS_ERR(new_dentry))
 396                 GOTO(exit4, rc);
 397
 398         /* target should not be an ancestor of source */
 399         rc = -ENOTEMPTY;
 400         if (new_dentry == trap)
 401                 GOTO(exit5, rc);
 402
 403 #ifdef HAVE_4ARGS_VFS_RENAME
 404         rc = vfs_rename(old_dir->d_inode, old_dentry,
 405                         new_dir->d_inode, new_dentry);
 406 #else
 407         rc = vfs_rename(old_dir->d_inode, old_dentry, oldnd.nd_mnt,
 408                         new_dir->d_inode, new_dentry, newnd.nd_mnt);
 409 #endif /* HAVE_4ARGS_VFS_RENAME */
 410 exit5:
 411         dput(new_dentry);
 412 exit4:
 413         dput(old_dentry);
 414 exit3:
 415         unlock_rename(new_dir, old_dir);
 416 exit2:
 417         vn_path_release(&newnd);
 418 exit1:
 419         vn_path_release(&oldnd);
 420 exit:
 421         RETURN(-rc);
 422 }
 423 EXPORT_SYMBOL(vn_rename);
 424
 425 int
 426 vn_getattr(vnode_t *vp, vattr_t *vap, int flags, void *x3, void *x4)
 427 {
 428         struct file *fp;
 429         struct kstat stat;
 430         int rc;
 431         ENTRY;
 432
 433         ASSERT(vp);
 434         ASSERT(vp->v_file);
 435         ASSERT(vap);
 436
 437         fp = vp->v_file;
 438
 439         rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
 440         if (rc)
 441                 RETURN(-rc);
 442
 443         vap->va_type          = vn_get_sol_type(stat.mode);
 444         vap->va_mode          = stat.mode;
 445         vap->va_uid           = stat.uid;
 446         vap->va_gid           = stat.gid;
 447         vap->va_fsid          = 0;
 448         vap->va_nodeid        = stat.ino;
 449         vap->va_nlink         = stat.nlink;
 450         vap->va_size          = stat.size;
 451         vap->va_blocksize     = stat.blksize;
 452         vap->va_atime.tv_sec  = stat.atime.tv_sec;
 453         vap->va_atime.tv_usec = stat.atime.tv_nsec / NSEC_PER_USEC;
 454         vap->va_mtime.tv_sec  = stat.mtime.tv_sec;
 455         vap->va_mtime.tv_usec = stat.mtime.tv_nsec / NSEC_PER_USEC;
 456         vap->va_ctime.tv_sec  = stat.ctime.tv_sec;
 457         vap->va_ctime.tv_usec = stat.ctime.tv_nsec / NSEC_PER_USEC;
 458         vap->va_rdev          = stat.rdev;
 459         vap->va_blocks        = stat.blocks;
 460
 461         RETURN(0);
 462 }
 463 EXPORT_SYMBOL(vn_getattr);
 464
 465 int vn_fsync(vnode_t *vp, int flags, void *x3, void *x4)
 466 {
 467         int datasync = 0;
 468         ENTRY;
 469
 470         ASSERT(vp);
 471         ASSERT(vp->v_file);
 472
 473         if (flags & FDSYNC)
 474                 datasync = 1;
 475
 476         RETURN(-file_fsync(vp->v_file, vp->v_file->f_dentry, datasync));
 477 } /* vn_fsync() */
 478 EXPORT_SYMBOL(vn_fsync);
 479
 480 /* Function must be called while holding the vn_file_lock */
 481 static file_t *
 482 file_find(int fd)
 483 {
 484         file_t *fp;
 485
 486         ASSERT(spin_is_locked(&vn_file_lock));
 487
 488         list_for_each_entry(fp, &vn_file_list,  f_list) {
 489                 if (fd == fp->f_fd) {
 490                         ASSERT(atomic_read(&fp->f_ref) != 0);
 491                         return fp;
 492                 }
 493         }
 494
 495         return NULL;
 496 } /* file_find() */
 497
 498 file_t *
 499 vn_getf(int fd)
 500 {
 501         struct kstat stat;
 502         struct file *lfp;
 503         file_t *fp;
 504         vnode_t *vp;
 505         int rc = 0;
 506         ENTRY;
 507
 508         /* Already open just take an extra reference */
 509         spin_lock(&vn_file_lock);
 510
 511         fp = file_find(fd);
 512         if (fp) {
 513                 atomic_inc(&fp->f_ref);
 514                 spin_unlock(&vn_file_lock);
 515                 RETURN(fp);
 516         }
 517
 518         spin_unlock(&vn_file_lock);
 519
 520         /* File was not yet opened create the object and setup */
 521         fp = kmem_cache_alloc(vn_file_cache, KM_SLEEP);
 522         if (fp == NULL)
 523                 GOTO(out, rc);
 524
 525         mutex_enter(&fp->f_lock);
 526
 527         fp->f_fd = fd;
 528         fp->f_offset = 0;
 529         atomic_inc(&fp->f_ref);
 530
 531         lfp = fget(fd);
 532         if (lfp == NULL)
 533                 GOTO(out_mutex, rc);
 534
 535         vp = vn_alloc(KM_SLEEP);
 536         if (vp == NULL)
 537                 GOTO(out_fget, rc);
 538
 539         if (vfs_getattr(lfp->f_vfsmnt, lfp->f_dentry, &stat))
 540                 GOTO(out_vnode, rc);
 541
 542         mutex_enter(&vp->v_lock);
 543         vp->v_type = vn_get_sol_type(stat.mode);
 544         vp->v_file = lfp;
 545         mutex_exit(&vp->v_lock);
 546
 547         fp->f_vnode = vp;
 548         fp->f_file = lfp;
 549
 550         /* Put it on the tracking list */
 551         spin_lock(&vn_file_lock);
 552         list_add(&fp->f_list, &vn_file_list);
 553         spin_unlock(&vn_file_lock);
 554
 555         mutex_exit(&fp->f_lock);
 556         RETURN(fp);
 557
 558 out_vnode:
 559         vn_free(vp);
 560 out_fget:
 561         fput(lfp);
 562 out_mutex:
 563         mutex_exit(&fp->f_lock);
 564         kmem_cache_free(vn_file_cache, fp);
 565 out:
 566         RETURN(NULL);
 567 } /* getf() */
 568 EXPORT_SYMBOL(getf);
 569
 570 static void releasef_locked(file_t *fp)
 571 {
 572         ASSERT(fp->f_file);
 573         ASSERT(fp->f_vnode);
 574
 575         /* Unlinked from list, no refs, safe to free outside mutex */
 576         fput(fp->f_file);
 577         vn_free(fp->f_vnode);
 578
 579         kmem_cache_free(vn_file_cache, fp);
 580 }
 581
 582 void
 583 vn_releasef(int fd)
 584 {
 585         file_t *fp;
 586         ENTRY;
 587
 588         spin_lock(&vn_file_lock);
 589         fp = file_find(fd);
 590         if (fp) {
 591                 atomic_dec(&fp->f_ref);
 592                 if (atomic_read(&fp->f_ref) > 0) {
 593                         spin_unlock(&vn_file_lock);
 594                         EXIT;
 595                         return;
 596                 }
 597
 598                 list_del(&fp->f_list);
 599                 releasef_locked(fp);
 600         }
 601         spin_unlock(&vn_file_lock);
 602
 603         EXIT;
 604         return;
 605 } /* releasef() */
 606 EXPORT_SYMBOL(releasef);
 607
 608 #ifndef HAVE_SET_FS_PWD
 609 # ifdef HAVE_2ARGS_SET_FS_PWD
 610 /* Used from 2.6.25 - 2.6.31+ */
 611 void
 612 set_fs_pwd(struct fs_struct *fs, struct path *path)
 613 {
 614         struct path old_pwd;
 615
 616         write_lock(&fs->lock);
 617         old_pwd = fs->pwd;
 618         fs->pwd = *path;
 619         path_get(path);
 620         write_unlock(&fs->lock);
 621
 622         if (old_pwd.dentry)
 623                 path_put(&old_pwd);
 624 }
 625 # else
 626 /* Used from 2.6.11 - 2.6.24 */
 627 void
 628 set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt, struct dentry *dentry)
 629 {
 630         struct dentry *old_pwd;
 631         struct vfsmount *old_pwdmnt;
 632
 633         write_lock(&fs->lock);
 634         old_pwd = fs->pwd;
 635         old_pwdmnt = fs->pwdmnt;
 636         fs->pwdmnt = mntget(mnt);
 637         fs->pwd = dget(dentry);
 638         write_unlock(&fs->lock);
 639
 640         if (old_pwd) {
 641                 dput(old_pwd);
 642                 mntput(old_pwdmnt);
 643         }
 644 }
 645 # endif /* HAVE_2ARGS_SET_FS_PWD */
 646 #endif /* HAVE_SET_FS_PWD */
 647
 648 int
 649 vn_set_pwd(const char *filename)
 650 {
 651 #ifdef HAVE_2ARGS_SET_FS_PWD
 652         struct path path;
 653 #else
 654         struct nameidata nd;
 655 #endif /* HAVE_2ARGS_SET_FS_PWD */
 656         mm_segment_t saved_fs;
 657         int rc;
 658         ENTRY;
 659
 660         /*
 661          * user_path_dir() and __user_walk() both expect 'filename' to be
 662          * a user space address so we must briefly increase the data segment
 663          * size to ensure strncpy_from_user() does not fail with -EFAULT.
 664          */
 665         saved_fs = get_fs();
 666         set_fs(get_ds());
 667
 668 #ifdef HAVE_2ARGS_SET_FS_PWD
 669         rc = user_path_dir(filename, &path);
 670         if (rc)
 671                 GOTO(out, rc);
 672
 673         rc = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
 674         if (rc)
 675                 GOTO(dput_and_out, rc);
 676
 677         set_fs_pwd(current->fs, &path);
 678
 679 dput_and_out:
 680         path_put(&path);
 681 #else
 682         rc = __user_walk(filename,
 683                          LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_CHDIR, &nd);
 684         if (rc)
 685                 GOTO(out, rc);
 686
 687         rc = vfs_permission(&nd, MAY_EXEC);
 688         if (rc)
 689                 GOTO(dput_and_out, rc);
 690
 691         set_fs_pwd(current->fs, nd.nd_mnt, nd.nd_dentry);
 692
 693 dput_and_out:
 694         vn_path_release(&nd);
 695 #endif /* HAVE_2ARGS_SET_FS_PWD */
 696 out:
 697         set_fs(saved_fs);
 698
 699         RETURN(-rc);
 700 } /* vn_set_pwd() */
 701 EXPORT_SYMBOL(vn_set_pwd);
 702
 703 static int
 704 vn_cache_constructor(void *buf, void *cdrarg, int kmflags)
 705 {
 706         struct vnode *vp = buf;
 707
 708         mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);
 709
 710         return (0);
 711 } /* vn_cache_constructor() */
 712
 713 static void
 714 vn_cache_destructor(void *buf, void *cdrarg)
 715 {
 716         struct vnode *vp = buf;
 717
 718         mutex_destroy(&vp->v_lock);
 719 } /* vn_cache_destructor() */
 720
 721 static int
 722 vn_file_cache_constructor(void *buf, void *cdrarg, int kmflags)
 723 {
 724         file_t *fp = buf;
 725
 726         atomic_set(&fp->f_ref, 0);
 727         mutex_init(&fp->f_lock, NULL, MUTEX_DEFAULT, NULL);
 728         INIT_LIST_HEAD(&fp->f_list);
 729
 730         return (0);
 731 } /* file_cache_constructor() */
 732
 733 static void
 734 vn_file_cache_destructor(void *buf, void *cdrarg)
 735 {
 736         file_t *fp = buf;
 737
 738         mutex_destroy(&fp->f_lock);
 739 } /* vn_file_cache_destructor() */
 740
 741 int
 742 vn_init(void)
 743 {
 744         ENTRY;
 745         vn_cache = kmem_cache_create("spl_vn_cache",
 746                                      sizeof(struct vnode), 64,
 747                                      vn_cache_constructor,
 748                                      vn_cache_destructor,
 749                                      NULL, NULL, NULL, 0);
 750
 751         vn_file_cache = kmem_cache_create("spl_vn_file_cache",
 752                                           sizeof(file_t), 64,
 753                                           vn_file_cache_constructor,
 754                                           vn_file_cache_destructor,
 755                                           NULL, NULL, NULL, 0);
 756         RETURN(0);
 757 } /* vn_init() */
 758
 759 void
 760 vn_fini(void)
 761 {
 762         file_t *fp, *next_fp;
 763         int leaked = 0;
 764         ENTRY;
 765
 766         spin_lock(&vn_file_lock);
 767
 768         list_for_each_entry_safe(fp, next_fp, &vn_file_list,  f_list) {
 769                 list_del(&fp->f_list);
 770                 releasef_locked(fp);
 771                 leaked++;
 772         }
 773
 774         kmem_cache_destroy(vn_file_cache);
 775         vn_file_cache = NULL;
 776         spin_unlock(&vn_file_lock);
 777
 778         if (leaked > 0)
 779                 CWARN("Warning %d files leaked\n", leaked);
 780
 781         kmem_cache_destroy(vn_cache);
 782
 783         EXIT;
 784         return;
 785 } /* vn_fini() */