sys/fs/tmpfs/tmpfs_vnops.c

   1 /*      $NetBSD: tmpfs_vnops.c,v 1.39 2007/07/23 15:41:01 jmmv Exp $    */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-2-Clause-NetBSD
   5  *
   6  * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
  11  * 2005 program.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * tmpfs vnode interface.
  37  */
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/dirent.h>
  44 #include <sys/extattr.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/file.h>
  47 #include <sys/filio.h>
  48 #include <sys/limits.h>
  49 #include <sys/lockf.h>
  50 #include <sys/lock.h>
  51 #include <sys/mount.h>
  52 #include <sys/namei.h>
  53 #include <sys/priv.h>
  54 #include <sys/proc.h>
  55 #include <sys/rwlock.h>
  56 #include <sys/sched.h>
  57 #include <sys/smr.h>
  58 #include <sys/stat.h>
  59 #include <sys/sysctl.h>
  60 #include <sys/unistd.h>
  61 #include <sys/vnode.h>
  62 #include <security/audit/audit.h>
  63 #include <security/mac/mac_framework.h>
  64
  65 #include <vm/vm.h>
  66 #include <vm/vm_param.h>
  67 #include <vm/vm_object.h>
  68 #include <vm/vm_page.h>
  69 #include <vm/vm_pager.h>
  70 #include <vm/swap_pager.h>
  71
  72 #include <fs/tmpfs/tmpfs_vnops.h>
  73 #include <fs/tmpfs/tmpfs.h>
  74
  75 SYSCTL_DECL(_vfs_tmpfs);
  76 VFS_SMR_DECLARE;
  77
  78 static volatile int tmpfs_rename_restarts;
  79 SYSCTL_INT(_vfs_tmpfs, OID_AUTO, rename_restarts, CTLFLAG_RD,
  80     __DEVOLATILE(int *, &tmpfs_rename_restarts), 0,
  81     "Times rename had to restart due to lock contention");
  82
  83 MALLOC_DEFINE(M_TMPFSEA, "tmpfs extattr", "tmpfs extattr structure");
  84
  85 static int
  86 tmpfs_vn_get_ino_alloc(struct mount *mp, void *arg, int lkflags,
  87     struct vnode **rvp)
  88 {
  89
  90         return (tmpfs_alloc_vp(mp, arg, lkflags, rvp));
  91 }
  92
  93 static int
  94 tmpfs_lookup1(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
  95 {
  96         struct tmpfs_dirent *de;
  97         struct tmpfs_node *dnode, *pnode;
  98         struct tmpfs_mount *tm;
  99         int error;
 100
 101         /* Caller assumes responsibility for ensuring access (VEXEC). */
 102         dnode = VP_TO_TMPFS_DIR(dvp);
 103         *vpp = NULLVP;
 104
 105         /* We cannot be requesting the parent directory of the root node. */
 106         MPASS(IMPLIES(dnode->tn_type == VDIR &&
 107             dnode->tn_dir.tn_parent == dnode,
 108             !(cnp->cn_flags & ISDOTDOT)));
 109
 110         TMPFS_ASSERT_LOCKED(dnode);
 111         if (dnode->tn_dir.tn_parent == NULL) {
 112                 error = ENOENT;
 113                 goto out;
 114         }
 115         if (cnp->cn_flags & ISDOTDOT) {
 116                 tm = VFS_TO_TMPFS(dvp->v_mount);
 117                 pnode = dnode->tn_dir.tn_parent;
 118                 tmpfs_ref_node(pnode);
 119                 error = vn_vget_ino_gen(dvp, tmpfs_vn_get_ino_alloc,
 120                     pnode, cnp->cn_lkflags, vpp);
 121                 tmpfs_free_node(tm, pnode);
 122                 if (error != 0)
 123                         goto out;
 124         } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
 125                 VREF(dvp);
 126                 *vpp = dvp;
 127                 error = 0;
 128         } else {
 129                 de = tmpfs_dir_lookup(dnode, NULL, cnp);
 130                 if (de != NULL && de->td_node == NULL)
 131                         cnp->cn_flags |= ISWHITEOUT;
 132                 if (de == NULL || de->td_node == NULL) {
 133                         /*
 134                          * The entry was not found in the directory.
 135                          * This is OK if we are creating or renaming an
 136                          * entry and are working on the last component of
 137                          * the path name.
 138                          */
 139                         if ((cnp->cn_flags & ISLASTCN) &&
 140                             (cnp->cn_nameiop == CREATE || \
 141                             cnp->cn_nameiop == RENAME ||
 142                             (cnp->cn_nameiop == DELETE &&
 143                             cnp->cn_flags & DOWHITEOUT &&
 144                             cnp->cn_flags & ISWHITEOUT))) {
 145                                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
 146                                     curthread);
 147                                 if (error != 0)
 148                                         goto out;
 149
 150                                 error = EJUSTRETURN;
 151                         } else
 152                                 error = ENOENT;
 153                 } else {
 154                         struct tmpfs_node *tnode;
 155
 156                         /*
 157                          * The entry was found, so get its associated
 158                          * tmpfs_node.
 159                          */
 160                         tnode = de->td_node;
 161
 162                         /*
 163                          * If we are not at the last path component and
 164                          * found a non-directory or non-link entry (which
 165                          * may itself be pointing to a directory), raise
 166                          * an error.
 167                          */
 168                         if ((tnode->tn_type != VDIR &&
 169                             tnode->tn_type != VLNK) &&
 170                             !(cnp->cn_flags & ISLASTCN)) {
 171                                 error = ENOTDIR;
 172                                 goto out;
 173                         }
 174
 175                         /*
 176                          * If we are deleting or renaming the entry, keep
 177                          * track of its tmpfs_dirent so that it can be
 178                          * easily deleted later.
 179                          */
 180                         if ((cnp->cn_flags & ISLASTCN) &&
 181                             (cnp->cn_nameiop == DELETE ||
 182                             cnp->cn_nameiop == RENAME)) {
 183                                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
 184                                     curthread);
 185                                 if (error != 0)
 186                                         goto out;
 187
 188                                 /* Allocate a new vnode on the matching entry. */
 189                                 error = tmpfs_alloc_vp(dvp->v_mount, tnode,
 190                                     cnp->cn_lkflags, vpp);
 191                                 if (error != 0)
 192                                         goto out;
 193
 194                                 if ((dnode->tn_mode & S_ISTXT) &&
 195                                   VOP_ACCESS(dvp, VADMIN, cnp->cn_cred,
 196                                   curthread) && VOP_ACCESS(*vpp, VADMIN,
 197                                   cnp->cn_cred, curthread)) {
 198                                         error = EPERM;
 199                                         vput(*vpp);
 200                                         *vpp = NULL;
 201                                         goto out;
 202                                 }
 203                         } else {
 204                                 error = tmpfs_alloc_vp(dvp->v_mount, tnode,
 205                                     cnp->cn_lkflags, vpp);
 206                                 if (error != 0)
 207                                         goto out;
 208                         }
 209                 }
 210         }
 211
 212         /*
 213          * Store the result of this lookup in the cache.  Avoid this if the
 214          * request was for creation, as it does not improve timings on
 215          * emprical tests.
 216          */
 217         if ((cnp->cn_flags & MAKEENTRY) != 0 && tmpfs_use_nc(dvp))
 218                 cache_enter(dvp, *vpp, cnp);
 219
 220 out:
 221         /*
 222          * If there were no errors, *vpp cannot be null and it must be
 223          * locked.
 224          */
 225         MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));
 226
 227         return (error);
 228 }
 229
 230 static int
 231 tmpfs_cached_lookup(struct vop_cachedlookup_args *v)
 232 {
 233
 234         return (tmpfs_lookup1(v->a_dvp, v->a_vpp, v->a_cnp));
 235 }
 236
 237 static int
 238 tmpfs_lookup(struct vop_lookup_args *v)
 239 {
 240         struct vnode *dvp = v->a_dvp;
 241         struct vnode **vpp = v->a_vpp;
 242         struct componentname *cnp = v->a_cnp;
 243         int error;
 244
 245         /* Check accessibility of requested node as a first step. */
 246         error = vn_dir_check_exec(dvp, cnp);
 247         if (error != 0)
 248                 return (error);
 249
 250         return (tmpfs_lookup1(dvp, vpp, cnp));
 251 }
 252
 253 static int
 254 tmpfs_create(struct vop_create_args *v)
 255 {
 256         struct vnode *dvp = v->a_dvp;
 257         struct vnode **vpp = v->a_vpp;
 258         struct componentname *cnp = v->a_cnp;
 259         struct vattr *vap = v->a_vap;
 260         int error;
 261
 262         MPASS(vap->va_type == VREG || vap->va_type == VSOCK);
 263
 264         error = tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
 265         if (error == 0 && (cnp->cn_flags & MAKEENTRY) != 0 && tmpfs_use_nc(dvp))
 266                 cache_enter(dvp, *vpp, cnp);
 267         return (error);
 268 }
 269
 270 static int
 271 tmpfs_mknod(struct vop_mknod_args *v)
 272 {
 273         struct vnode *dvp = v->a_dvp;
 274         struct vnode **vpp = v->a_vpp;
 275         struct componentname *cnp = v->a_cnp;
 276         struct vattr *vap = v->a_vap;
 277
 278         if (vap->va_type != VBLK && vap->va_type != VCHR &&
 279             vap->va_type != VFIFO)
 280                 return (EINVAL);
 281
 282         return (tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL));
 283 }
 284
 285 struct fileops tmpfs_fnops;
 286
 287 static int
 288 tmpfs_open(struct vop_open_args *v)
 289 {
 290         struct vnode *vp;
 291         struct tmpfs_node *node;
 292         struct file *fp;
 293         int error, mode;
 294
 295         vp = v->a_vp;
 296         mode = v->a_mode;
 297         node = VP_TO_TMPFS_NODE(vp);
 298
 299         /*
 300          * The file is still active but all its names have been removed
 301          * (e.g. by a "rmdir $(pwd)").  It cannot be opened any more as
 302          * it is about to die.
 303          */
 304         if (node->tn_links < 1)
 305                 return (ENOENT);
 306
 307         /* If the file is marked append-only, deny write requests. */
 308         if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
 309                 error = EPERM;
 310         else {
 311                 error = 0;
 312                 /* For regular files, the call below is nop. */
 313                 KASSERT(vp->v_type != VREG || (node->tn_reg.tn_aobj->flags &
 314                     OBJ_DEAD) == 0, ("dead object"));
 315                 vnode_create_vobject(vp, node->tn_size, v->a_td);
 316         }
 317
 318         fp = v->a_fp;
 319         MPASS(fp == NULL || fp->f_data == NULL);
 320         if (error == 0 && fp != NULL && vp->v_type == VREG) {
 321                 tmpfs_ref_node(node);
 322                 finit_vnode(fp, mode, node, &tmpfs_fnops);
 323         }
 324
 325         return (error);
 326 }
 327
 328 static int
 329 tmpfs_close(struct vop_close_args *v)
 330 {
 331         struct vnode *vp = v->a_vp;
 332
 333         /* Update node times. */
 334         tmpfs_update(vp);
 335
 336         return (0);
 337 }
 338
 339 int
 340 tmpfs_fo_close(struct file *fp, struct thread *td)
 341 {
 342         struct tmpfs_node *node;
 343
 344         node = fp->f_data;
 345         if (node != NULL) {
 346                 MPASS(node->tn_type == VREG);
 347                 tmpfs_free_node(node->tn_reg.tn_tmp, node);
 348         }
 349         return (vnops.fo_close(fp, td));
 350 }
 351
 352 /*
 353  * VOP_FPLOOKUP_VEXEC routines are subject to special circumstances, see
 354  * the comment above cache_fplookup for details.
 355  */
 356 int
 357 tmpfs_fplookup_vexec(struct vop_fplookup_vexec_args *v)
 358 {
 359         struct vnode *vp;
 360         struct tmpfs_node *node;
 361         struct ucred *cred;
 362         mode_t all_x, mode;
 363
 364         vp = v->a_vp;
 365         node = VP_TO_TMPFS_NODE_SMR(vp);
 366         if (__predict_false(node == NULL))
 367                 return (EAGAIN);
 368
 369         all_x = S_IXUSR | S_IXGRP | S_IXOTH;
 370         mode = atomic_load_short(&node->tn_mode);
 371         if (__predict_true((mode & all_x) == all_x))
 372                 return (0);
 373
 374         cred = v->a_cred;
 375         return (vaccess_vexec_smr(mode, node->tn_uid, node->tn_gid, cred));
 376 }
 377
 378 int
 379 tmpfs_access(struct vop_access_args *v)
 380 {
 381         struct vnode *vp = v->a_vp;
 382         accmode_t accmode = v->a_accmode;
 383         struct ucred *cred = v->a_cred;
 384         mode_t all_x = S_IXUSR | S_IXGRP | S_IXOTH;
 385         int error;
 386         struct tmpfs_node *node;
 387
 388         MPASS(VOP_ISLOCKED(vp));
 389
 390         node = VP_TO_TMPFS_NODE(vp);
 391
 392         /*
 393          * Common case path lookup.
 394          */
 395         if (__predict_true(accmode == VEXEC && (node->tn_mode & all_x) == all_x))
 396                 return (0);
 397
 398         switch (vp->v_type) {
 399         case VDIR:
 400                 /* FALLTHROUGH */
 401         case VLNK:
 402                 /* FALLTHROUGH */
 403         case VREG:
 404                 if (accmode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
 405                         error = EROFS;
 406                         goto out;
 407                 }
 408                 break;
 409
 410         case VBLK:
 411                 /* FALLTHROUGH */
 412         case VCHR:
 413                 /* FALLTHROUGH */
 414         case VSOCK:
 415                 /* FALLTHROUGH */
 416         case VFIFO:
 417                 break;
 418
 419         default:
 420                 error = EINVAL;
 421                 goto out;
 422         }
 423
 424         if (accmode & VWRITE && node->tn_flags & IMMUTABLE) {
 425                 error = EPERM;
 426                 goto out;
 427         }
 428
 429         error = vaccess(vp->v_type, node->tn_mode, node->tn_uid, node->tn_gid,
 430             accmode, cred);
 431
 432 out:
 433         MPASS(VOP_ISLOCKED(vp));
 434
 435         return (error);
 436 }
 437
 438 int
 439 tmpfs_stat(struct vop_stat_args *v)
 440 {
 441         struct vnode *vp = v->a_vp;
 442         struct stat *sb = v->a_sb;
 443         struct tmpfs_node *node;
 444         int error;
 445
 446         node = VP_TO_TMPFS_NODE(vp);
 447
 448         tmpfs_update_getattr(vp);
 449
 450         error = vop_stat_helper_pre(v);
 451         if (__predict_false(error))
 452                 return (error);
 453
 454         sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
 455         sb->st_ino = node->tn_id;
 456         sb->st_mode = node->tn_mode | VTTOIF(vp->v_type);
 457         sb->st_nlink = node->tn_links;
 458         sb->st_uid = node->tn_uid;
 459         sb->st_gid = node->tn_gid;
 460         sb->st_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
 461                 node->tn_rdev : NODEV;
 462         sb->st_size = node->tn_size;
 463         sb->st_atim.tv_sec = node->tn_atime.tv_sec;
 464         sb->st_atim.tv_nsec = node->tn_atime.tv_nsec;
 465         sb->st_mtim.tv_sec = node->tn_mtime.tv_sec;
 466         sb->st_mtim.tv_nsec = node->tn_mtime.tv_nsec;
 467         sb->st_ctim.tv_sec = node->tn_ctime.tv_sec;
 468         sb->st_ctim.tv_nsec = node->tn_ctime.tv_nsec;
 469         sb->st_birthtim.tv_sec = node->tn_birthtime.tv_sec;
 470         sb->st_birthtim.tv_nsec = node->tn_birthtime.tv_nsec;
 471         sb->st_blksize = PAGE_SIZE;
 472         sb->st_flags = node->tn_flags;
 473         sb->st_gen = node->tn_gen;
 474         if (vp->v_type == VREG) {
 475 #ifdef __ILP32__
 476                 vm_object_t obj = node->tn_reg.tn_aobj;
 477
 478                 /* Handle torn read */
 479                 VM_OBJECT_RLOCK(obj);
 480 #endif
 481                 sb->st_blocks = ptoa(node->tn_reg.tn_pages);
 482 #ifdef __ILP32__
 483                 VM_OBJECT_RUNLOCK(obj);
 484 #endif
 485         } else {
 486                 sb->st_blocks = node->tn_size;
 487         }
 488         sb->st_blocks /= S_BLKSIZE;
 489         return (vop_stat_helper_post(v, error));
 490 }
 491
 492 int
 493 tmpfs_getattr(struct vop_getattr_args *v)
 494 {
 495         struct vnode *vp = v->a_vp;
 496         struct vattr *vap = v->a_vap;
 497         struct tmpfs_node *node;
 498
 499         node = VP_TO_TMPFS_NODE(vp);
 500
 501         tmpfs_update_getattr(vp);
 502
 503         vap->va_type = vp->v_type;
 504         vap->va_mode = node->tn_mode;
 505         vap->va_nlink = node->tn_links;
 506         vap->va_uid = node->tn_uid;
 507         vap->va_gid = node->tn_gid;
 508         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
 509         vap->va_fileid = node->tn_id;
 510         vap->va_size = node->tn_size;
 511         vap->va_blocksize = PAGE_SIZE;
 512         vap->va_atime = node->tn_atime;
 513         vap->va_mtime = node->tn_mtime;
 514         vap->va_ctime = node->tn_ctime;
 515         vap->va_birthtime = node->tn_birthtime;
 516         vap->va_gen = node->tn_gen;
 517         vap->va_flags = node->tn_flags;
 518         vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
 519             node->tn_rdev : NODEV;
 520         if (vp->v_type == VREG) {
 521 #ifdef __ILP32__
 522                 vm_object_t obj = node->tn_reg.tn_aobj;
 523
 524                 VM_OBJECT_RLOCK(obj);
 525 #endif
 526                 vap->va_bytes = ptoa(node->tn_reg.tn_pages);
 527 #ifdef __ILP32__
 528                 VM_OBJECT_RUNLOCK(obj);
 529 #endif
 530         } else {
 531                 vap->va_bytes = node->tn_size;
 532         }
 533         vap->va_filerev = 0;
 534
 535         return (0);
 536 }
 537
 538 int
 539 tmpfs_setattr(struct vop_setattr_args *v)
 540 {
 541         struct vnode *vp = v->a_vp;
 542         struct vattr *vap = v->a_vap;
 543         struct ucred *cred = v->a_cred;
 544         struct thread *td = curthread;
 545
 546         int error;
 547
 548         MPASS(VOP_ISLOCKED(vp));
 549         ASSERT_VOP_IN_SEQC(vp);
 550
 551         error = 0;
 552
 553         /* Abort if any unsettable attribute is given. */
 554         if (vap->va_type != VNON ||
 555             vap->va_nlink != VNOVAL ||
 556             vap->va_fsid != VNOVAL ||
 557             vap->va_fileid != VNOVAL ||
 558             vap->va_blocksize != VNOVAL ||
 559             vap->va_gen != VNOVAL ||
 560             vap->va_rdev != VNOVAL ||
 561             vap->va_bytes != VNOVAL)
 562                 error = EINVAL;
 563
 564         if (error == 0 && (vap->va_flags != VNOVAL))
 565                 error = tmpfs_chflags(vp, vap->va_flags, cred, td);
 566
 567         if (error == 0 && (vap->va_size != VNOVAL))
 568                 error = tmpfs_chsize(vp, vap->va_size, cred, td);
 569
 570         if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
 571                 error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, td);
 572
 573         if (error == 0 && (vap->va_mode != (mode_t)VNOVAL))
 574                 error = tmpfs_chmod(vp, vap->va_mode, cred, td);
 575
 576         if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL &&
 577             vap->va_atime.tv_nsec != VNOVAL) ||
 578             (vap->va_mtime.tv_sec != VNOVAL &&
 579             vap->va_mtime.tv_nsec != VNOVAL) ||
 580             (vap->va_birthtime.tv_sec != VNOVAL &&
 581             vap->va_birthtime.tv_nsec != VNOVAL)))
 582                 error = tmpfs_chtimes(vp, vap, cred, td);
 583
 584         /*
 585          * Update the node times.  We give preference to the error codes
 586          * generated by this function rather than the ones that may arise
 587          * from tmpfs_update.
 588          */
 589         tmpfs_update(vp);
 590
 591         MPASS(VOP_ISLOCKED(vp));
 592
 593         return (error);
 594 }
 595
 596 static int
 597 tmpfs_read(struct vop_read_args *v)
 598 {
 599         struct vnode *vp;
 600         struct uio *uio;
 601         struct tmpfs_node *node;
 602
 603         vp = v->a_vp;
 604         if (vp->v_type != VREG)
 605                 return (EISDIR);
 606         uio = v->a_uio;
 607         if (uio->uio_offset < 0)
 608                 return (EINVAL);
 609         node = VP_TO_TMPFS_NODE(vp);
 610         tmpfs_set_accessed(VFS_TO_TMPFS(vp->v_mount), node);
 611         return (uiomove_object(node->tn_reg.tn_aobj, node->tn_size, uio));
 612 }
 613
 614 static int
 615 tmpfs_read_pgcache(struct vop_read_pgcache_args *v)
 616 {
 617         struct vnode *vp;
 618         struct tmpfs_node *node;
 619         vm_object_t object;
 620         off_t size;
 621         int error;
 622
 623         vp = v->a_vp;
 624         VNPASS((vn_irflag_read(vp) & VIRF_PGREAD) != 0, vp);
 625
 626         if (v->a_uio->uio_offset < 0)
 627                 return (EINVAL);
 628
 629         error = EJUSTRETURN;
 630         vfs_smr_enter();
 631
 632         node = VP_TO_TMPFS_NODE_SMR(vp);
 633         if (node == NULL)
 634                 goto out_smr;
 635         MPASS(node->tn_type == VREG);
 636         MPASS(node->tn_refcount >= 1);
 637         object = node->tn_reg.tn_aobj;
 638         if (object == NULL)
 639                 goto out_smr;
 640
 641         MPASS(object->type == tmpfs_pager_type);
 642         MPASS((object->flags & (OBJ_ANON | OBJ_DEAD | OBJ_SWAP)) ==
 643             OBJ_SWAP);
 644         if (!VN_IS_DOOMED(vp)) {
 645                 /* size cannot become shorter due to rangelock. */
 646                 size = node->tn_size;
 647                 tmpfs_set_accessed(node->tn_reg.tn_tmp, node);
 648                 vfs_smr_exit();
 649                 error = uiomove_object(object, size, v->a_uio);
 650                 return (error);
 651         }
 652 out_smr:
 653         vfs_smr_exit();
 654         return (error);
 655 }
 656
 657 static int
 658 tmpfs_write(struct vop_write_args *v)
 659 {
 660         struct vnode *vp;
 661         struct uio *uio;
 662         struct tmpfs_node *node;
 663         off_t oldsize;
 664         ssize_t r;
 665         int error, ioflag;
 666         mode_t newmode;
 667
 668         vp = v->a_vp;
 669         uio = v->a_uio;
 670         ioflag = v->a_ioflag;
 671         error = 0;
 672         node = VP_TO_TMPFS_NODE(vp);
 673         oldsize = node->tn_size;
 674
 675         if (uio->uio_offset < 0 || vp->v_type != VREG)
 676                 return (EINVAL);
 677         if (uio->uio_resid == 0)
 678                 return (0);
 679         if (ioflag & IO_APPEND)
 680                 uio->uio_offset = node->tn_size;
 681         error = vn_rlimit_fsizex(vp, uio, VFS_TO_TMPFS(vp->v_mount)->
 682             tm_maxfilesize, &r, uio->uio_td);
 683         if (error != 0) {
 684                 vn_rlimit_fsizex_res(uio, r);
 685                 return (error);
 686         }
 687
 688         if (uio->uio_offset + uio->uio_resid > node->tn_size) {
 689                 error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid,
 690                     FALSE);
 691                 if (error != 0)
 692                         goto out;
 693         }
 694
 695         error = uiomove_object(node->tn_reg.tn_aobj, node->tn_size, uio);
 696         node->tn_status |= TMPFS_NODE_MODIFIED | TMPFS_NODE_CHANGED;
 697         node->tn_accessed = true;
 698         if (node->tn_mode & (S_ISUID | S_ISGID)) {
 699                 if (priv_check_cred(v->a_cred, PRIV_VFS_RETAINSUGID)) {
 700                         newmode = node->tn_mode & ~(S_ISUID | S_ISGID);
 701                         vn_seqc_write_begin(vp);
 702                         atomic_store_short(&node->tn_mode, newmode);
 703                         vn_seqc_write_end(vp);
 704                 }
 705         }
 706         if (error != 0)
 707                 (void)tmpfs_reg_resize(vp, oldsize, TRUE);
 708
 709 out:
 710         MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
 711         MPASS(IMPLIES(error != 0, oldsize == node->tn_size));
 712
 713         vn_rlimit_fsizex_res(uio, r);
 714         return (error);
 715 }
 716
 717 static int
 718 tmpfs_deallocate(struct vop_deallocate_args *v)
 719 {
 720         return (tmpfs_reg_punch_hole(v->a_vp, v->a_offset, v->a_len));
 721 }
 722
 723 static int
 724 tmpfs_fsync(struct vop_fsync_args *v)
 725 {
 726         struct vnode *vp = v->a_vp;
 727
 728         MPASS(VOP_ISLOCKED(vp));
 729
 730         tmpfs_check_mtime(vp);
 731         tmpfs_update(vp);
 732
 733         return (0);
 734 }
 735
 736 static int
 737 tmpfs_remove(struct vop_remove_args *v)
 738 {
 739         struct vnode *dvp = v->a_dvp;
 740         struct vnode *vp = v->a_vp;
 741
 742         int error;
 743         struct tmpfs_dirent *de;
 744         struct tmpfs_mount *tmp;
 745         struct tmpfs_node *dnode;
 746         struct tmpfs_node *node;
 747
 748         MPASS(VOP_ISLOCKED(dvp));
 749         MPASS(VOP_ISLOCKED(vp));
 750
 751         if (vp->v_type == VDIR) {
 752                 error = EISDIR;
 753                 goto out;
 754         }
 755
 756         dnode = VP_TO_TMPFS_DIR(dvp);
 757         node = VP_TO_TMPFS_NODE(vp);
 758         tmp = VFS_TO_TMPFS(vp->v_mount);
 759         de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
 760         MPASS(de != NULL);
 761
 762         /* Files marked as immutable or append-only cannot be deleted. */
 763         if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
 764             (dnode->tn_flags & APPEND)) {
 765                 error = EPERM;
 766                 goto out;
 767         }
 768
 769         /* Remove the entry from the directory; as it is a file, we do not
 770          * have to change the number of hard links of the directory. */
 771         tmpfs_dir_detach(dvp, de);
 772         if (v->a_cnp->cn_flags & DOWHITEOUT)
 773                 tmpfs_dir_whiteout_add(dvp, v->a_cnp);
 774
 775         /* Free the directory entry we just deleted.  Note that the node
 776          * referred by it will not be removed until the vnode is really
 777          * reclaimed. */
 778         tmpfs_free_dirent(tmp, de);
 779
 780         node->tn_status |= TMPFS_NODE_CHANGED;
 781         node->tn_accessed = true;
 782         error = 0;
 783
 784 out:
 785         return (error);
 786 }
 787
 788 static int
 789 tmpfs_link(struct vop_link_args *v)
 790 {
 791         struct vnode *dvp = v->a_tdvp;
 792         struct vnode *vp = v->a_vp;
 793         struct componentname *cnp = v->a_cnp;
 794
 795         int error;
 796         struct tmpfs_dirent *de;
 797         struct tmpfs_node *node;
 798
 799         MPASS(VOP_ISLOCKED(dvp));
 800         MPASS(dvp != vp); /* XXX When can this be false? */
 801         node = VP_TO_TMPFS_NODE(vp);
 802
 803         /* Ensure that we do not overflow the maximum number of links imposed
 804          * by the system. */
 805         MPASS(node->tn_links <= TMPFS_LINK_MAX);
 806         if (node->tn_links == TMPFS_LINK_MAX) {
 807                 error = EMLINK;
 808                 goto out;
 809         }
 810
 811         /* We cannot create links of files marked immutable or append-only. */
 812         if (node->tn_flags & (IMMUTABLE | APPEND)) {
 813                 error = EPERM;
 814                 goto out;
 815         }
 816
 817         /* Allocate a new directory entry to represent the node. */
 818         error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
 819             cnp->cn_nameptr, cnp->cn_namelen, &de);
 820         if (error != 0)
 821                 goto out;
 822
 823         /* Insert the new directory entry into the appropriate directory. */
 824         if (cnp->cn_flags & ISWHITEOUT)
 825                 tmpfs_dir_whiteout_remove(dvp, cnp);
 826         tmpfs_dir_attach(dvp, de);
 827
 828         /* vp link count has changed, so update node times. */
 829         node->tn_status |= TMPFS_NODE_CHANGED;
 830         tmpfs_update(vp);
 831
 832         error = 0;
 833
 834 out:
 835         return (error);
 836 }
 837
 838 /*
 839  * We acquire all but fdvp locks using non-blocking acquisitions.  If we
 840  * fail to acquire any lock in the path we will drop all held locks,
 841  * acquire the new lock in a blocking fashion, and then release it and
 842  * restart the rename.  This acquire/release step ensures that we do not
 843  * spin on a lock waiting for release.  On error release all vnode locks
 844  * and decrement references the way tmpfs_rename() would do.
 845  */
 846 static int
 847 tmpfs_rename_relock(struct vnode *fdvp, struct vnode **fvpp,
 848     struct vnode *tdvp, struct vnode **tvpp,
 849     struct componentname *fcnp, struct componentname *tcnp)
 850 {
 851         struct vnode *nvp;
 852         struct mount *mp;
 853         struct tmpfs_dirent *de;
 854         int error, restarts = 0;
 855
 856         VOP_UNLOCK(tdvp);
 857         if (*tvpp != NULL && *tvpp != tdvp)
 858                 VOP_UNLOCK(*tvpp);
 859         mp = fdvp->v_mount;
 860
 861 relock:
 862         restarts += 1;
 863         error = vn_lock(fdvp, LK_EXCLUSIVE);
 864         if (error)
 865                 goto releout;
 866         if (vn_lock(tdvp, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
 867                 VOP_UNLOCK(fdvp);
 868                 error = vn_lock(tdvp, LK_EXCLUSIVE);
 869                 if (error)
 870                         goto releout;
 871                 VOP_UNLOCK(tdvp);
 872                 goto relock;
 873         }
 874         /*
 875          * Re-resolve fvp to be certain it still exists and fetch the
 876          * correct vnode.
 877          */
 878         de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(fdvp), NULL, fcnp);
 879         if (de == NULL) {
 880                 VOP_UNLOCK(fdvp);
 881                 VOP_UNLOCK(tdvp);
 882                 if ((fcnp->cn_flags & ISDOTDOT) != 0 ||
 883                     (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.'))
 884                         error = EINVAL;
 885                 else
 886                         error = ENOENT;
 887                 goto releout;
 888         }
 889         error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE | LK_NOWAIT, &nvp);
 890         if (error != 0) {
 891                 VOP_UNLOCK(fdvp);
 892                 VOP_UNLOCK(tdvp);
 893                 if (error != EBUSY)
 894                         goto releout;
 895                 error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE, &nvp);
 896                 if (error != 0)
 897                         goto releout;
 898                 VOP_UNLOCK(nvp);
 899                 /*
 900                  * Concurrent rename race.
 901                  */
 902                 if (nvp == tdvp) {
 903                         vrele(nvp);
 904                         error = EINVAL;
 905                         goto releout;
 906                 }
 907                 vrele(*fvpp);
 908                 *fvpp = nvp;
 909                 goto relock;
 910         }
 911         vrele(*fvpp);
 912         *fvpp = nvp;
 913         VOP_UNLOCK(*fvpp);
 914         /*
 915          * Re-resolve tvp and acquire the vnode lock if present.
 916          */
 917         de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(tdvp), NULL, tcnp);
 918         /*
 919          * If tvp disappeared we just carry on.
 920          */
 921         if (de == NULL && *tvpp != NULL) {
 922                 vrele(*tvpp);
 923                 *tvpp = NULL;
 924         }
 925         /*
 926          * Get the tvp ino if the lookup succeeded.  We may have to restart
 927          * if the non-blocking acquire fails.
 928          */
 929         if (de != NULL) {
 930                 nvp = NULL;
 931                 error = tmpfs_alloc_vp(mp, de->td_node,
 932                     LK_EXCLUSIVE | LK_NOWAIT, &nvp);
 933                 if (*tvpp != NULL)
 934                         vrele(*tvpp);
 935                 *tvpp = nvp;
 936                 if (error != 0) {
 937                         VOP_UNLOCK(fdvp);
 938                         VOP_UNLOCK(tdvp);
 939                         if (error != EBUSY)
 940                                 goto releout;
 941                         error = tmpfs_alloc_vp(mp, de->td_node, LK_EXCLUSIVE,
 942                             &nvp);
 943                         if (error != 0)
 944                                 goto releout;
 945                         VOP_UNLOCK(nvp);
 946                         /*
 947                          * fdvp contains fvp, thus tvp (=fdvp) is not empty.
 948                          */
 949                         if (nvp == fdvp) {
 950                                 error = ENOTEMPTY;
 951                                 goto releout;
 952                         }
 953                         goto relock;
 954                 }
 955         }
 956         tmpfs_rename_restarts += restarts;
 957
 958         return (0);
 959
 960 releout:
 961         vrele(fdvp);
 962         vrele(*fvpp);
 963         vrele(tdvp);
 964         if (*tvpp != NULL)
 965                 vrele(*tvpp);
 966         tmpfs_rename_restarts += restarts;
 967
 968         return (error);
 969 }
 970
 971 static int
 972 tmpfs_rename(struct vop_rename_args *v)
 973 {
 974         struct vnode *fdvp = v->a_fdvp;
 975         struct vnode *fvp = v->a_fvp;
 976         struct componentname *fcnp = v->a_fcnp;
 977         struct vnode *tdvp = v->a_tdvp;
 978         struct vnode *tvp = v->a_tvp;
 979         struct componentname *tcnp = v->a_tcnp;
 980         char *newname;
 981         struct tmpfs_dirent *de;
 982         struct tmpfs_mount *tmp;
 983         struct tmpfs_node *fdnode;
 984         struct tmpfs_node *fnode;
 985         struct tmpfs_node *tnode;
 986         struct tmpfs_node *tdnode;
 987         int error;
 988         bool want_seqc_end;
 989
 990         MPASS(VOP_ISLOCKED(tdvp));
 991         MPASS(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp)));
 992
 993         want_seqc_end = false;
 994
 995         /*
 996          * Disallow cross-device renames.
 997          * XXX Why isn't this done by the caller?
 998          */
 999         if (fvp->v_mount != tdvp->v_mount ||
1000             (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
1001                 error = EXDEV;
1002                 goto out;
1003         }
1004
1005         /* If source and target are the same file, there is nothing to do. */
1006         if (fvp == tvp) {
1007                 error = 0;
1008                 goto out;
1009         }
1010
1011         /*
1012          * If we need to move the directory between entries, lock the
1013          * source so that we can safely operate on it.
1014          */
1015         if (fdvp != tdvp && fdvp != tvp) {
1016                 if (vn_lock(fdvp, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
1017                         error = tmpfs_rename_relock(fdvp, &fvp, tdvp, &tvp,
1018                             fcnp, tcnp);
1019                         if (error != 0)
1020                                 return (error);
1021                         ASSERT_VOP_ELOCKED(fdvp,
1022                             "tmpfs_rename: fdvp not locked");
1023                         ASSERT_VOP_ELOCKED(tdvp,
1024                             "tmpfs_rename: tdvp not locked");
1025                         if (tvp != NULL)
1026                                 ASSERT_VOP_ELOCKED(tvp,
1027                                     "tmpfs_rename: tvp not locked");
1028                         if (fvp == tvp) {
1029                                 error = 0;
1030                                 goto out_locked;
1031                         }
1032                 }
1033         }
1034
1035         /*
1036          * Avoid manipulating '.' and '..' entries.
1037          */
1038         if ((fcnp->cn_flags & ISDOTDOT) != 0 ||
1039             (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.')) {
1040                 error = EINVAL;
1041                 goto out_locked;
1042         }
1043
1044         if (tvp != NULL)
1045                 vn_seqc_write_begin(tvp);
1046         vn_seqc_write_begin(tdvp);
1047         vn_seqc_write_begin(fvp);
1048         vn_seqc_write_begin(fdvp);
1049         want_seqc_end = true;
1050
1051         tmp = VFS_TO_TMPFS(tdvp->v_mount);
1052         tdnode = VP_TO_TMPFS_DIR(tdvp);
1053         tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
1054         fdnode = VP_TO_TMPFS_DIR(fdvp);
1055         fnode = VP_TO_TMPFS_NODE(fvp);
1056         de = tmpfs_dir_lookup(fdnode, fnode, fcnp);
1057
1058         /*
1059          * Entry can disappear before we lock fdvp.
1060          */
1061         if (de == NULL) {
1062                 if ((fcnp->cn_flags & ISDOTDOT) != 0 ||
1063                     (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.'))
1064                         error = EINVAL;
1065                 else
1066                         error = ENOENT;
1067                 goto out_locked;
1068         }
1069         MPASS(de->td_node == fnode);
1070
1071         /*
1072          * If re-naming a directory to another preexisting directory
1073          * ensure that the target directory is empty so that its
1074          * removal causes no side effects.
1075          * Kern_rename guarantees the destination to be a directory
1076          * if the source is one.
1077          */
1078         if (tvp != NULL) {
1079                 MPASS(tnode != NULL);
1080
1081                 if ((tnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
1082                     (tdnode->tn_flags & (APPEND | IMMUTABLE))) {
1083                         error = EPERM;
1084                         goto out_locked;
1085                 }
1086
1087                 if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
1088                         if (tnode->tn_size > 0) {
1089                                 error = ENOTEMPTY;
1090                                 goto out_locked;
1091                         }
1092                 } else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
1093                         error = ENOTDIR;
1094                         goto out_locked;
1095                 } else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
1096                         error = EISDIR;
1097                         goto out_locked;
1098                 } else {
1099                         MPASS(fnode->tn_type != VDIR &&
1100                                 tnode->tn_type != VDIR);
1101                 }
1102         }
1103
1104         if ((fnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))
1105             || (fdnode->tn_flags & (APPEND | IMMUTABLE))) {
1106                 error = EPERM;
1107                 goto out_locked;
1108         }
1109
1110         /*
1111          * Ensure that we have enough memory to hold the new name, if it
1112          * has to be changed.
1113          */
1114         if (fcnp->cn_namelen != tcnp->cn_namelen ||
1115             bcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
1116                 newname = malloc(tcnp->cn_namelen, M_TMPFSNAME, M_WAITOK);
1117         } else
1118                 newname = NULL;
1119
1120         /*
1121          * If the node is being moved to another directory, we have to do
1122          * the move.
1123          */
1124         if (fdnode != tdnode) {
1125                 /*
1126                  * In case we are moving a directory, we have to adjust its
1127                  * parent to point to the new parent.
1128                  */
1129                 if (de->td_node->tn_type == VDIR) {
1130                         struct tmpfs_node *n;
1131
1132                         /*
1133                          * Ensure the target directory is not a child of the
1134                          * directory being moved.  Otherwise, we'd end up
1135                          * with stale nodes.
1136                          */
1137                         n = tdnode;
1138                         /*
1139                          * TMPFS_LOCK guaranties that no nodes are freed while
1140                          * traversing the list. Nodes can only be marked as
1141                          * removed: tn_parent == NULL.
1142                          */
1143                         TMPFS_LOCK(tmp);
1144                         TMPFS_NODE_LOCK(n);
1145                         while (n != n->tn_dir.tn_parent) {
1146                                 struct tmpfs_node *parent;
1147
1148                                 if (n == fnode) {
1149                                         TMPFS_NODE_UNLOCK(n);
1150                                         TMPFS_UNLOCK(tmp);
1151                                         error = EINVAL;
1152                                         if (newname != NULL)
1153                                                     free(newname, M_TMPFSNAME);
1154                                         goto out_locked;
1155                                 }
1156                                 parent = n->tn_dir.tn_parent;
1157                                 TMPFS_NODE_UNLOCK(n);
1158                                 if (parent == NULL) {
1159                                         n = NULL;
1160                                         break;
1161                                 }
1162                                 TMPFS_NODE_LOCK(parent);
1163                                 if (parent->tn_dir.tn_parent == NULL) {
1164                                         TMPFS_NODE_UNLOCK(parent);
1165                                         n = NULL;
1166                                         break;
1167                                 }
1168                                 n = parent;
1169                         }
1170                         TMPFS_UNLOCK(tmp);
1171                         if (n == NULL) {
1172                                 error = EINVAL;
1173                                 if (newname != NULL)
1174                                             free(newname, M_TMPFSNAME);
1175                                 goto out_locked;
1176                         }
1177                         TMPFS_NODE_UNLOCK(n);
1178
1179                         /* Adjust the parent pointer. */
1180                         TMPFS_VALIDATE_DIR(fnode);
1181                         TMPFS_NODE_LOCK(de->td_node);
1182                         de->td_node->tn_dir.tn_parent = tdnode;
1183                         TMPFS_NODE_UNLOCK(de->td_node);
1184
1185                         /*
1186                          * As a result of changing the target of the '..'
1187                          * entry, the link count of the source and target
1188                          * directories has to be adjusted.
1189                          */
1190                         TMPFS_NODE_LOCK(tdnode);
1191                         TMPFS_ASSERT_LOCKED(tdnode);
1192                         tdnode->tn_links++;
1193                         TMPFS_NODE_UNLOCK(tdnode);
1194
1195                         TMPFS_NODE_LOCK(fdnode);
1196                         TMPFS_ASSERT_LOCKED(fdnode);
1197                         fdnode->tn_links--;
1198                         TMPFS_NODE_UNLOCK(fdnode);
1199                 }
1200         }
1201
1202         /*
1203          * Do the move: just remove the entry from the source directory
1204          * and insert it into the target one.
1205          */
1206         tmpfs_dir_detach(fdvp, de);
1207
1208         if (fcnp->cn_flags & DOWHITEOUT)
1209                 tmpfs_dir_whiteout_add(fdvp, fcnp);
1210         if (tcnp->cn_flags & ISWHITEOUT)
1211                 tmpfs_dir_whiteout_remove(tdvp, tcnp);
1212
1213         /*
1214          * If the name has changed, we need to make it effective by changing
1215          * it in the directory entry.
1216          */
1217         if (newname != NULL) {
1218                 MPASS(tcnp->cn_namelen <= MAXNAMLEN);
1219
1220                 free(de->ud.td_name, M_TMPFSNAME);
1221                 de->ud.td_name = newname;
1222                 tmpfs_dirent_init(de, tcnp->cn_nameptr, tcnp->cn_namelen);
1223
1224                 fnode->tn_status |= TMPFS_NODE_CHANGED;
1225                 tdnode->tn_status |= TMPFS_NODE_MODIFIED;
1226         }
1227
1228         /*
1229          * If we are overwriting an entry, we have to remove the old one
1230          * from the target directory.
1231          */
1232         if (tvp != NULL) {
1233                 struct tmpfs_dirent *tde;
1234
1235                 /* Remove the old entry from the target directory. */
1236                 tde = tmpfs_dir_lookup(tdnode, tnode, tcnp);
1237                 tmpfs_dir_detach(tdvp, tde);
1238
1239                 /* Update node's ctime because of possible hardlinks. */
1240                 tnode->tn_status |= TMPFS_NODE_CHANGED;
1241                 tmpfs_update(tvp);
1242
1243                 /*
1244                  * Free the directory entry we just deleted.  Note that the
1245                  * node referred by it will not be removed until the vnode is
1246                  * really reclaimed.
1247                  */
1248                 tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), tde);
1249         }
1250
1251         tmpfs_dir_attach(tdvp, de);
1252
1253         if (tmpfs_use_nc(fvp)) {
1254                 cache_vop_rename(fdvp, fvp, tdvp, tvp, fcnp, tcnp);
1255         }
1256
1257         error = 0;
1258
1259 out_locked:
1260         if (fdvp != tdvp && fdvp != tvp)
1261                 VOP_UNLOCK(fdvp);
1262
1263 out:
1264         if (want_seqc_end) {
1265                 if (tvp != NULL)
1266                         vn_seqc_write_end(tvp);
1267                 vn_seqc_write_end(tdvp);
1268                 vn_seqc_write_end(fvp);
1269                 vn_seqc_write_end(fdvp);
1270         }
1271
1272         /*
1273          * Release target nodes.
1274          * XXX: I don't understand when tdvp can be the same as tvp, but
1275          * other code takes care of this...
1276          */
1277         if (tdvp == tvp)
1278                 vrele(tdvp);
1279         else
1280                 vput(tdvp);
1281         if (tvp != NULL)
1282                 vput(tvp);
1283
1284         /* Release source nodes. */
1285         vrele(fdvp);
1286         vrele(fvp);
1287
1288         return (error);
1289 }
1290
1291 static int
1292 tmpfs_mkdir(struct vop_mkdir_args *v)
1293 {
1294         struct vnode *dvp = v->a_dvp;
1295         struct vnode **vpp = v->a_vpp;
1296         struct componentname *cnp = v->a_cnp;
1297         struct vattr *vap = v->a_vap;
1298
1299         MPASS(vap->va_type == VDIR);
1300
1301         return (tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL));
1302 }
1303
1304 static int
1305 tmpfs_rmdir(struct vop_rmdir_args *v)
1306 {
1307         struct vnode *dvp = v->a_dvp;
1308         struct vnode *vp = v->a_vp;
1309
1310         int error;
1311         struct tmpfs_dirent *de;
1312         struct tmpfs_mount *tmp;
1313         struct tmpfs_node *dnode;
1314         struct tmpfs_node *node;
1315
1316         MPASS(VOP_ISLOCKED(dvp));
1317         MPASS(VOP_ISLOCKED(vp));
1318
1319         tmp = VFS_TO_TMPFS(dvp->v_mount);
1320         dnode = VP_TO_TMPFS_DIR(dvp);
1321         node = VP_TO_TMPFS_DIR(vp);
1322
1323         /* Directories with more than two entries ('.' and '..') cannot be
1324          * removed. */
1325          if (node->tn_size > 0) {
1326                  error = ENOTEMPTY;
1327                  goto out;
1328          }
1329
1330         if ((dnode->tn_flags & APPEND)
1331             || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
1332                 error = EPERM;
1333                 goto out;
1334         }
1335
1336         /* This invariant holds only if we are not trying to remove "..".
1337           * We checked for that above so this is safe now. */
1338         MPASS(node->tn_dir.tn_parent == dnode);
1339
1340         /* Get the directory entry associated with node (vp).  This was
1341          * filled by tmpfs_lookup while looking up the entry. */
1342         de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
1343         MPASS(TMPFS_DIRENT_MATCHES(de,
1344             v->a_cnp->cn_nameptr,
1345             v->a_cnp->cn_namelen));
1346
1347         /* Check flags to see if we are allowed to remove the directory. */
1348         if ((dnode->tn_flags & APPEND) != 0 ||
1349             (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) != 0) {
1350                 error = EPERM;
1351                 goto out;
1352         }
1353
1354         /* Detach the directory entry from the directory (dnode). */
1355         tmpfs_dir_detach(dvp, de);
1356         if (v->a_cnp->cn_flags & DOWHITEOUT)
1357                 tmpfs_dir_whiteout_add(dvp, v->a_cnp);
1358
1359         /* No vnode should be allocated for this entry from this point */
1360         TMPFS_NODE_LOCK(node);
1361         node->tn_links--;
1362         node->tn_dir.tn_parent = NULL;
1363         node->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1364         node->tn_accessed = true;
1365
1366         TMPFS_NODE_UNLOCK(node);
1367
1368         TMPFS_NODE_LOCK(dnode);
1369         dnode->tn_links--;
1370         dnode->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1371         dnode->tn_accessed = true;
1372         TMPFS_NODE_UNLOCK(dnode);
1373
1374         if (tmpfs_use_nc(dvp)) {
1375                 cache_vop_rmdir(dvp, vp);
1376         }
1377
1378         /* Free the directory entry we just deleted.  Note that the node
1379          * referred by it will not be removed until the vnode is really
1380          * reclaimed. */
1381         tmpfs_free_dirent(tmp, de);
1382
1383         /* Release the deleted vnode (will destroy the node, notify
1384          * interested parties and clean it from the cache). */
1385
1386         dnode->tn_status |= TMPFS_NODE_CHANGED;
1387         tmpfs_update(dvp);
1388
1389         error = 0;
1390
1391 out:
1392         return (error);
1393 }
1394
1395 static int
1396 tmpfs_symlink(struct vop_symlink_args *v)
1397 {
1398         struct vnode *dvp = v->a_dvp;
1399         struct vnode **vpp = v->a_vpp;
1400         struct componentname *cnp = v->a_cnp;
1401         struct vattr *vap = v->a_vap;
1402         const char *target = v->a_target;
1403
1404 #ifdef notyet /* XXX FreeBSD BUG: kern_symlink is not setting VLNK */
1405         MPASS(vap->va_type == VLNK);
1406 #else
1407         vap->va_type = VLNK;
1408 #endif
1409
1410         return (tmpfs_alloc_file(dvp, vpp, vap, cnp, target));
1411 }
1412
1413 static int
1414 tmpfs_readdir(struct vop_readdir_args *va)
1415 {
1416         struct vnode *vp;
1417         struct uio *uio;
1418         struct tmpfs_mount *tm;
1419         struct tmpfs_node *node;
1420         uint64_t **cookies;
1421         int *eofflag, *ncookies;
1422         ssize_t startresid;
1423         int error, maxcookies;
1424
1425         vp = va->a_vp;
1426         uio = va->a_uio;
1427         eofflag = va->a_eofflag;
1428         cookies = va->a_cookies;
1429         ncookies = va->a_ncookies;
1430
1431         /* This operation only makes sense on directory nodes. */
1432         if (vp->v_type != VDIR)
1433                 return (ENOTDIR);
1434
1435         maxcookies = 0;
1436         node = VP_TO_TMPFS_DIR(vp);
1437         tm = VFS_TO_TMPFS(vp->v_mount);
1438
1439         startresid = uio->uio_resid;
1440
1441         /* Allocate cookies for NFS and compat modules. */
1442         if (cookies != NULL && ncookies != NULL) {
1443                 maxcookies = howmany(node->tn_size,
1444                     sizeof(struct tmpfs_dirent)) + 2;
1445                 *cookies = malloc(maxcookies * sizeof(**cookies), M_TEMP,
1446                     M_WAITOK);
1447                 *ncookies = 0;
1448         }
1449
1450         if (cookies == NULL)
1451                 error = tmpfs_dir_getdents(tm, node, uio, 0, NULL, NULL);
1452         else
1453                 error = tmpfs_dir_getdents(tm, node, uio, maxcookies, *cookies,
1454                     ncookies);
1455
1456         /* Buffer was filled without hitting EOF. */
1457         if (error == EJUSTRETURN)
1458                 error = (uio->uio_resid != startresid) ? 0 : EINVAL;
1459
1460         if (error != 0 && cookies != NULL && ncookies != NULL) {
1461                 free(*cookies, M_TEMP);
1462                 *cookies = NULL;
1463                 *ncookies = 0;
1464         }
1465
1466         if (eofflag != NULL)
1467                 *eofflag =
1468                     (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
1469
1470         return (error);
1471 }
1472
1473 static int
1474 tmpfs_readlink(struct vop_readlink_args *v)
1475 {
1476         struct vnode *vp = v->a_vp;
1477         struct uio *uio = v->a_uio;
1478
1479         int error;
1480         struct tmpfs_node *node;
1481
1482         MPASS(uio->uio_offset == 0);
1483         MPASS(vp->v_type == VLNK);
1484
1485         node = VP_TO_TMPFS_NODE(vp);
1486
1487         error = uiomove(node->tn_link_target, MIN(node->tn_size, uio->uio_resid),
1488             uio);
1489         tmpfs_set_accessed(VFS_TO_TMPFS(vp->v_mount), node);
1490
1491         return (error);
1492 }
1493
1494 /*
1495  * VOP_FPLOOKUP_SYMLINK routines are subject to special circumstances, see
1496  * the comment above cache_fplookup for details.
1497  *
1498  * Check tmpfs_alloc_node for tmpfs-specific synchronisation notes.
1499  */
1500 static int
1501 tmpfs_fplookup_symlink(struct vop_fplookup_symlink_args *v)
1502 {
1503         struct vnode *vp;
1504         struct tmpfs_node *node;
1505         char *symlink;
1506
1507         vp = v->a_vp;
1508         node = VP_TO_TMPFS_NODE_SMR(vp);
1509         if (__predict_false(node == NULL))
1510                 return (EAGAIN);
1511         if (!atomic_load_char(&node->tn_link_smr))
1512                 return (EAGAIN);
1513         symlink = atomic_load_ptr(&node->tn_link_target);
1514         if (symlink == NULL)
1515                 return (EAGAIN);
1516
1517         return (cache_symlink_resolve(v->a_fpl, symlink, node->tn_size));
1518 }
1519
1520 static int
1521 tmpfs_inactive(struct vop_inactive_args *v)
1522 {
1523         struct vnode *vp;
1524         struct tmpfs_node *node;
1525
1526         vp = v->a_vp;
1527         node = VP_TO_TMPFS_NODE(vp);
1528         if (node->tn_links == 0)
1529                 vrecycle(vp);
1530         else
1531                 tmpfs_check_mtime(vp);
1532         return (0);
1533 }
1534
1535 static int
1536 tmpfs_need_inactive(struct vop_need_inactive_args *ap)
1537 {
1538         struct vnode *vp;
1539         struct tmpfs_node *node;
1540         struct vm_object *obj;
1541
1542         vp = ap->a_vp;
1543         node = VP_TO_TMPFS_NODE(vp);
1544         if (node->tn_links == 0)
1545                 goto need;
1546         if (vp->v_type == VREG) {
1547                 obj = vp->v_object;
1548                 if (obj->generation != obj->cleangeneration)
1549                         goto need;
1550         }
1551         return (0);
1552 need:
1553         return (1);
1554 }
1555
1556 int
1557 tmpfs_reclaim(struct vop_reclaim_args *v)
1558 {
1559         struct vnode *vp;
1560         struct tmpfs_mount *tmp;
1561         struct tmpfs_node *node;
1562         bool unlock;
1563
1564         vp = v->a_vp;
1565         node = VP_TO_TMPFS_NODE(vp);
1566         tmp = VFS_TO_TMPFS(vp->v_mount);
1567
1568         if (vp->v_type == VREG)
1569                 tmpfs_destroy_vobject(vp, node->tn_reg.tn_aobj);
1570         vp->v_object = NULL;
1571
1572         TMPFS_LOCK(tmp);
1573         TMPFS_NODE_LOCK(node);
1574         tmpfs_free_vp(vp);
1575
1576         /*
1577          * If the node referenced by this vnode was deleted by the user,
1578          * we must free its associated data structures (now that the vnode
1579          * is being reclaimed).
1580          */
1581         unlock = true;
1582         if (node->tn_links == 0 &&
1583             (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) == 0) {
1584                 node->tn_vpstate = TMPFS_VNODE_DOOMED;
1585                 unlock = !tmpfs_free_node_locked(tmp, node, true);
1586         }
1587
1588         if (unlock) {
1589                 TMPFS_NODE_UNLOCK(node);
1590                 TMPFS_UNLOCK(tmp);
1591         }
1592
1593         MPASS(vp->v_data == NULL);
1594         return (0);
1595 }
1596
1597 int
1598 tmpfs_print(struct vop_print_args *v)
1599 {
1600         struct vnode *vp = v->a_vp;
1601
1602         struct tmpfs_node *node;
1603
1604         node = VP_TO_TMPFS_NODE(vp);
1605
1606         printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%lx, links %jd\n",
1607             node, node->tn_flags, (uintmax_t)node->tn_links);
1608         printf("\tmode 0%o, owner %d, group %d, size %jd, status 0x%x\n",
1609             node->tn_mode, node->tn_uid, node->tn_gid,
1610             (intmax_t)node->tn_size, node->tn_status);
1611
1612         if (vp->v_type == VFIFO)
1613                 fifo_printinfo(vp);
1614
1615         printf("\n");
1616
1617         return (0);
1618 }
1619
1620 int
1621 tmpfs_pathconf(struct vop_pathconf_args *v)
1622 {
1623         struct vnode *vp = v->a_vp;
1624         int name = v->a_name;
1625         long *retval = v->a_retval;
1626
1627         int error;
1628
1629         error = 0;
1630
1631         switch (name) {
1632         case _PC_LINK_MAX:
1633                 *retval = TMPFS_LINK_MAX;
1634                 break;
1635
1636         case _PC_SYMLINK_MAX:
1637                 *retval = MAXPATHLEN;
1638                 break;
1639
1640         case _PC_NAME_MAX:
1641                 *retval = NAME_MAX;
1642                 break;
1643
1644         case _PC_PIPE_BUF:
1645                 if (vp->v_type == VDIR || vp->v_type == VFIFO)
1646                         *retval = PIPE_BUF;
1647                 else
1648                         error = EINVAL;
1649                 break;
1650
1651         case _PC_CHOWN_RESTRICTED:
1652                 *retval = 1;
1653                 break;
1654
1655         case _PC_NO_TRUNC:
1656                 *retval = 1;
1657                 break;
1658
1659         case _PC_SYNC_IO:
1660                 *retval = 1;
1661                 break;
1662
1663         case _PC_FILESIZEBITS:
1664                 *retval = 64;
1665                 break;
1666
1667         case _PC_MIN_HOLE_SIZE:
1668                 *retval = PAGE_SIZE;
1669                 break;
1670
1671         default:
1672                 error = vop_stdpathconf(v);
1673         }
1674
1675         return (error);
1676 }
1677
1678 static int
1679 tmpfs_vptofh(struct vop_vptofh_args *ap)
1680 /*
1681 vop_vptofh {
1682         IN struct vnode *a_vp;
1683         IN struct fid *a_fhp;
1684 };
1685 */
1686 {
1687         struct tmpfs_fid_data tfd;
1688         struct tmpfs_node *node;
1689         struct fid *fhp;
1690
1691         node = VP_TO_TMPFS_NODE(ap->a_vp);
1692         fhp = ap->a_fhp;
1693         fhp->fid_len = sizeof(tfd);
1694
1695         /*
1696          * Copy into fid_data from the stack to avoid unaligned pointer use.
1697          * See the comment in sys/mount.h on struct fid for details.
1698          */
1699         tfd.tfd_id = node->tn_id;
1700         tfd.tfd_gen = node->tn_gen;
1701         memcpy(fhp->fid_data, &tfd, fhp->fid_len);
1702
1703         return (0);
1704 }
1705
1706 static int
1707 tmpfs_whiteout(struct vop_whiteout_args *ap)
1708 {
1709         struct vnode *dvp = ap->a_dvp;
1710         struct componentname *cnp = ap->a_cnp;
1711         struct tmpfs_dirent *de;
1712
1713         switch (ap->a_flags) {
1714         case LOOKUP:
1715                 return (0);
1716         case CREATE:
1717                 de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(dvp), NULL, cnp);
1718                 if (de != NULL)
1719                         return (de->td_node == NULL ? 0 : EEXIST);
1720                 return (tmpfs_dir_whiteout_add(dvp, cnp));
1721         case DELETE:
1722                 tmpfs_dir_whiteout_remove(dvp, cnp);
1723                 return (0);
1724         default:
1725                 panic("tmpfs_whiteout: unknown op");
1726         }
1727 }
1728
1729 static int
1730 tmpfs_vptocnp_dir(struct tmpfs_node *tn, struct tmpfs_node *tnp,
1731     struct tmpfs_dirent **pde)
1732 {
1733         struct tmpfs_dir_cursor dc;
1734         struct tmpfs_dirent *de;
1735
1736         for (de = tmpfs_dir_first(tnp, &dc); de != NULL;
1737              de = tmpfs_dir_next(tnp, &dc)) {
1738                 if (de->td_node == tn) {
1739                         *pde = de;
1740                         return (0);
1741                 }
1742         }
1743         return (ENOENT);
1744 }
1745
1746 static int
1747 tmpfs_vptocnp_fill(struct vnode *vp, struct tmpfs_node *tn,
1748     struct tmpfs_node *tnp, char *buf, size_t *buflen, struct vnode **dvp)
1749 {
1750         struct tmpfs_dirent *de;
1751         int error, i;
1752
1753         error = vn_vget_ino_gen(vp, tmpfs_vn_get_ino_alloc, tnp, LK_SHARED,
1754             dvp);
1755         if (error != 0)
1756                 return (error);
1757         error = tmpfs_vptocnp_dir(tn, tnp, &de);
1758         if (error == 0) {
1759                 i = *buflen;
1760                 i -= de->td_namelen;
1761                 if (i < 0) {
1762                         error = ENOMEM;
1763                 } else {
1764                         bcopy(de->ud.td_name, buf + i, de->td_namelen);
1765                         *buflen = i;
1766                 }
1767         }
1768         if (error == 0) {
1769                 if (vp != *dvp)
1770                         VOP_UNLOCK(*dvp);
1771         } else {
1772                 if (vp != *dvp)
1773                         vput(*dvp);
1774                 else
1775                         vrele(vp);
1776         }
1777         return (error);
1778 }
1779
1780 static int
1781 tmpfs_vptocnp(struct vop_vptocnp_args *ap)
1782 {
1783         struct vnode *vp, **dvp;
1784         struct tmpfs_node *tn, *tnp, *tnp1;
1785         struct tmpfs_dirent *de;
1786         struct tmpfs_mount *tm;
1787         char *buf;
1788         size_t *buflen;
1789         int error;
1790
1791         vp = ap->a_vp;
1792         dvp = ap->a_vpp;
1793         buf = ap->a_buf;
1794         buflen = ap->a_buflen;
1795
1796         tm = VFS_TO_TMPFS(vp->v_mount);
1797         tn = VP_TO_TMPFS_NODE(vp);
1798         if (tn->tn_type == VDIR) {
1799                 tnp = tn->tn_dir.tn_parent;
1800                 if (tnp == NULL)
1801                         return (ENOENT);
1802                 tmpfs_ref_node(tnp);
1803                 error = tmpfs_vptocnp_fill(vp, tn, tn->tn_dir.tn_parent, buf,
1804                     buflen, dvp);
1805                 tmpfs_free_node(tm, tnp);
1806                 return (error);
1807         }
1808 restart:
1809         TMPFS_LOCK(tm);
1810 restart_locked:
1811         LIST_FOREACH_SAFE(tnp, &tm->tm_nodes_used, tn_entries, tnp1) {
1812                 if (tnp->tn_type != VDIR)
1813                         continue;
1814                 TMPFS_NODE_LOCK(tnp);
1815                 tmpfs_ref_node(tnp);
1816
1817                 /*
1818                  * tn_vnode cannot be instantiated while we hold the
1819                  * node lock, so the directory cannot be changed while
1820                  * we iterate over it.  Do this to avoid instantiating
1821                  * vnode for directories which cannot point to our
1822                  * node.
1823                  */
1824                 error = tnp->tn_vnode == NULL ? tmpfs_vptocnp_dir(tn, tnp,
1825                     &de) : 0;
1826
1827                 if (error == 0) {
1828                         TMPFS_NODE_UNLOCK(tnp);
1829                         TMPFS_UNLOCK(tm);
1830                         error = tmpfs_vptocnp_fill(vp, tn, tnp, buf, buflen,
1831                             dvp);
1832                         if (error == 0) {
1833                                 tmpfs_free_node(tm, tnp);
1834                                 return (0);
1835                         }
1836                         if (VN_IS_DOOMED(vp)) {
1837                                 tmpfs_free_node(tm, tnp);
1838                                 return (ENOENT);
1839                         }
1840                         TMPFS_LOCK(tm);
1841                         TMPFS_NODE_LOCK(tnp);
1842                 }
1843                 if (tmpfs_free_node_locked(tm, tnp, false)) {
1844                         goto restart;
1845                 } else {
1846                         KASSERT(tnp->tn_refcount > 0,
1847                             ("node %p refcount zero", tnp));
1848                         if (tnp->tn_attached) {
1849                                 tnp1 = LIST_NEXT(tnp, tn_entries);
1850                                 TMPFS_NODE_UNLOCK(tnp);
1851                         } else {
1852                                 TMPFS_NODE_UNLOCK(tnp);
1853                                 goto restart_locked;
1854                         }
1855                 }
1856         }
1857         TMPFS_UNLOCK(tm);
1858         return (ENOENT);
1859 }
1860
1861 void
1862 tmpfs_extattr_free(struct tmpfs_extattr *ea)
1863 {
1864         free(ea->ea_name, M_TMPFSEA);
1865         free(ea->ea_value, M_TMPFSEA);
1866         free(ea, M_TMPFSEA);
1867 }
1868
1869 static bool
1870 tmpfs_extattr_update_mem(struct tmpfs_mount *tmp, ssize_t size)
1871 {
1872         TMPFS_LOCK(tmp);
1873         if (size > 0 &&
1874             !tmpfs_pages_check_avail(tmp, howmany(size, PAGE_SIZE))) {
1875                 TMPFS_UNLOCK(tmp);
1876                 return (false);
1877         }
1878         if (tmp->tm_ea_memory_inuse + size > tmp->tm_ea_memory_max) {
1879                 TMPFS_UNLOCK(tmp);
1880                 return (false);
1881         }
1882         tmp->tm_ea_memory_inuse += size;
1883         TMPFS_UNLOCK(tmp);
1884         return (true);
1885 }
1886
1887 static int
1888 tmpfs_deleteextattr(struct vop_deleteextattr_args *ap)
1889 {
1890         struct vnode *vp = ap->a_vp;
1891         struct tmpfs_mount *tmp;
1892         struct tmpfs_node *node;
1893         struct tmpfs_extattr *ea;
1894         size_t namelen;
1895         ssize_t diff;
1896         int error;
1897
1898         node = VP_TO_TMPFS_NODE(vp);
1899         tmp = VFS_TO_TMPFS(vp->v_mount);
1900         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1901                 return (EOPNOTSUPP);
1902         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1903             ap->a_cred, ap->a_td, VWRITE);
1904         if (error != 0)
1905                 return (error);
1906         if (ap->a_name == NULL || ap->a_name[0] == '\0')
1907                 return (EINVAL);
1908         namelen = strlen(ap->a_name);
1909         if (namelen > EXTATTR_MAXNAMELEN)
1910                 return (EINVAL);
1911
1912         LIST_FOREACH(ea, &node->tn_extattrs, ea_extattrs) {
1913                 if (ea->ea_namespace == ap->a_attrnamespace &&
1914                     namelen == ea->ea_namelen &&
1915                     memcmp(ap->a_name, ea->ea_name, namelen) == 0)
1916                         break;
1917         }
1918
1919         if (ea == NULL)
1920                 return (ENOATTR);
1921         LIST_REMOVE(ea, ea_extattrs);
1922         diff = -(sizeof(struct tmpfs_extattr) + namelen + ea->ea_size);
1923         tmpfs_extattr_update_mem(tmp, diff);
1924         tmpfs_extattr_free(ea);
1925         return (0);
1926 }
1927
1928 static int
1929 tmpfs_getextattr(struct vop_getextattr_args *ap)
1930 {
1931         struct vnode *vp = ap->a_vp;
1932         struct tmpfs_node *node;
1933         struct tmpfs_extattr *ea;
1934         size_t namelen;
1935         int error;
1936
1937         node = VP_TO_TMPFS_NODE(vp);
1938         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1939                 return (EOPNOTSUPP);
1940         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1941             ap->a_cred, ap->a_td, VREAD);
1942         if (error != 0)
1943                 return (error);
1944         if (ap->a_name == NULL || ap->a_name[0] == '\0')
1945                 return (EINVAL);
1946         namelen = strlen(ap->a_name);
1947         if (namelen > EXTATTR_MAXNAMELEN)
1948                 return (EINVAL);
1949
1950         LIST_FOREACH(ea, &node->tn_extattrs, ea_extattrs) {
1951                 if (ea->ea_namespace == ap->a_attrnamespace &&
1952                     namelen == ea->ea_namelen &&
1953                     memcmp(ap->a_name, ea->ea_name, namelen) == 0)
1954                         break;
1955         }
1956
1957         if (ea == NULL)
1958                 return (ENOATTR);
1959         if (ap->a_size != NULL)
1960                 *ap->a_size = ea->ea_size;
1961         if (ap->a_uio != NULL && ea->ea_size != 0)
1962                 error = uiomove(ea->ea_value, ea->ea_size, ap->a_uio);
1963         return (error);
1964 }
1965
1966 static int
1967 tmpfs_listextattr(struct vop_listextattr_args *ap)
1968 {
1969         struct vnode *vp = ap->a_vp;
1970         struct tmpfs_node *node;
1971         struct tmpfs_extattr *ea;
1972         int error;
1973
1974         node = VP_TO_TMPFS_NODE(vp);
1975         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1976                 return (EOPNOTSUPP);
1977         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1978             ap->a_cred, ap->a_td, VREAD);
1979         if (error != 0)
1980                 return (error);
1981         if (ap->a_size != NULL)
1982                 *ap->a_size = 0;
1983
1984         LIST_FOREACH(ea, &node->tn_extattrs, ea_extattrs) {
1985                 if (ea->ea_namespace != ap->a_attrnamespace)
1986                         continue;
1987                 if (ap->a_size != NULL)
1988                         *ap->a_size += ea->ea_namelen + 1;
1989                 if (ap->a_uio != NULL) {
1990                         error = uiomove(&ea->ea_namelen, 1, ap->a_uio);
1991                         if (error != 0)
1992                                 break;
1993                         error = uiomove(ea->ea_name, ea->ea_namelen, ap->a_uio);
1994                         if (error != 0)
1995                                 break;
1996                 }
1997         }
1998
1999         return (error);
2000 }
2001
2002 static int
2003 tmpfs_setextattr(struct vop_setextattr_args *ap)
2004 {
2005         struct vnode *vp = ap->a_vp;
2006         struct tmpfs_mount *tmp;
2007         struct tmpfs_node *node;
2008         struct tmpfs_extattr *ea;
2009         struct tmpfs_extattr *new_ea;
2010         size_t attr_size;
2011         size_t namelen;
2012         ssize_t diff;
2013         int error;
2014
2015         node = VP_TO_TMPFS_NODE(vp);
2016         tmp = VFS_TO_TMPFS(vp->v_mount);
2017         attr_size = ap->a_uio->uio_resid;
2018         diff = 0;
2019         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
2020                 return (EOPNOTSUPP);
2021         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
2022             ap->a_cred, ap->a_td, VWRITE);
2023         if (error != 0)
2024                 return (error);
2025         if (ap->a_name == NULL || ap->a_name[0] == '\0')
2026                 return (EINVAL);
2027         namelen = strlen(ap->a_name);
2028         if (namelen > EXTATTR_MAXNAMELEN)
2029                 return (EINVAL);
2030
2031         LIST_FOREACH(ea, &node->tn_extattrs, ea_extattrs) {
2032                 if (ea->ea_namespace == ap->a_attrnamespace &&
2033                     namelen == ea->ea_namelen &&
2034                     memcmp(ap->a_name, ea->ea_name, namelen) == 0) {
2035                         diff -= sizeof(struct tmpfs_extattr) + ea->ea_namelen +
2036                             ea->ea_size;
2037                         break;
2038                 }
2039         }
2040
2041         diff += sizeof(struct tmpfs_extattr) + namelen + attr_size;
2042         if (!tmpfs_extattr_update_mem(tmp, diff))
2043                 return (ENOSPC);
2044         new_ea = malloc(sizeof(struct tmpfs_extattr), M_TMPFSEA, M_WAITOK);
2045         new_ea->ea_namespace = ap->a_attrnamespace;
2046         new_ea->ea_name = malloc(namelen, M_TMPFSEA, M_WAITOK);
2047         new_ea->ea_namelen = namelen;
2048         memcpy(new_ea->ea_name, ap->a_name, namelen);
2049         if (attr_size != 0) {
2050                 new_ea->ea_value = malloc(attr_size, M_TMPFSEA, M_WAITOK);
2051                 new_ea->ea_size = attr_size;
2052                 error = uiomove(new_ea->ea_value, attr_size, ap->a_uio);
2053         } else {
2054                 new_ea->ea_value = NULL;
2055                 new_ea->ea_size = 0;
2056         }
2057         if (error != 0) {
2058                 tmpfs_extattr_update_mem(tmp, -diff);
2059                 tmpfs_extattr_free(new_ea);
2060                 return (error);
2061         }
2062         if (ea != NULL) {
2063                 LIST_REMOVE(ea, ea_extattrs);
2064                 tmpfs_extattr_free(ea);
2065         }
2066         LIST_INSERT_HEAD(&node->tn_extattrs, new_ea, ea_extattrs);
2067         return (0);
2068 }
2069
2070 static off_t
2071 tmpfs_seek_data_locked(vm_object_t obj, off_t noff)
2072 {
2073         vm_page_t m;
2074         vm_pindex_t p, p_m, p_swp;
2075
2076         p = OFF_TO_IDX(noff);
2077         m = vm_page_find_least(obj, p);
2078
2079         /*
2080          * Microoptimize the most common case for SEEK_DATA, where
2081          * there is no hole and the page is resident.
2082          */
2083         if (m != NULL && vm_page_any_valid(m) && m->pindex == p)
2084                 return (noff);
2085
2086         p_swp = swap_pager_find_least(obj, p);
2087         if (p_swp == p)
2088                 return (noff);
2089
2090         p_m = m == NULL ? obj->size : m->pindex;
2091         return (IDX_TO_OFF(MIN(p_m, p_swp)));
2092 }
2093
2094 static off_t
2095 tmpfs_seek_next(off_t noff)
2096 {
2097         return (noff + PAGE_SIZE - (noff & PAGE_MASK));
2098 }
2099
2100 static int
2101 tmpfs_seek_clamp(struct tmpfs_node *tn, off_t *noff, bool seekdata)
2102 {
2103         if (*noff < tn->tn_size)
2104                 return (0);
2105         if (seekdata)
2106                 return (ENXIO);
2107         *noff = tn->tn_size;
2108         return (0);
2109 }
2110
2111 static off_t
2112 tmpfs_seek_hole_locked(vm_object_t obj, off_t noff)
2113 {
2114         vm_page_t m;
2115         vm_pindex_t p, p_swp;
2116
2117         for (;; noff = tmpfs_seek_next(noff)) {
2118                 /*
2119                  * Walk over the largest sequential run of the valid pages.
2120                  */
2121                 for (m = vm_page_lookup(obj, OFF_TO_IDX(noff));
2122                     m != NULL && vm_page_any_valid(m);
2123                     m = vm_page_next(m), noff = tmpfs_seek_next(noff))
2124                         ;
2125
2126                 /*
2127                  * Found a hole in the object's page queue.  Check if
2128                  * there is a hole in the swap at the same place.
2129                  */
2130                 p = OFF_TO_IDX(noff);
2131                 p_swp = swap_pager_find_least(obj, p);
2132                 if (p_swp != p) {
2133                         noff = IDX_TO_OFF(p);
2134                         break;
2135                 }
2136         }
2137         return (noff);
2138 }
2139
2140 static int
2141 tmpfs_seek_datahole(struct vnode *vp, off_t *off, bool seekdata)
2142 {
2143         struct tmpfs_node *tn;
2144         vm_object_t obj;
2145         off_t noff;
2146         int error;
2147
2148         if (vp->v_type != VREG)
2149                 return (ENOTTY);
2150         tn = VP_TO_TMPFS_NODE(vp);
2151         noff = *off;
2152         if (noff < 0)
2153                 return (ENXIO);
2154         error = tmpfs_seek_clamp(tn, &noff, seekdata);
2155         if (error != 0)
2156                 return (error);
2157         obj = tn->tn_reg.tn_aobj;
2158
2159         VM_OBJECT_RLOCK(obj);
2160         noff = seekdata ? tmpfs_seek_data_locked(obj, noff) :
2161             tmpfs_seek_hole_locked(obj, noff);
2162         VM_OBJECT_RUNLOCK(obj);
2163
2164         error = tmpfs_seek_clamp(tn, &noff, seekdata);
2165         if (error == 0)
2166                 *off = noff;
2167         return (error);
2168 }
2169
2170 static int
2171 tmpfs_ioctl(struct vop_ioctl_args *ap)
2172 {
2173         struct vnode *vp = ap->a_vp;
2174         int error = 0;
2175
2176         switch (ap->a_command) {
2177         case FIOSEEKDATA:
2178         case FIOSEEKHOLE:
2179                 error = vn_lock(vp, LK_SHARED);
2180                 if (error != 0) {
2181                         error = EBADF;
2182                         break;
2183                 }
2184                 error = tmpfs_seek_datahole(vp, (off_t *)ap->a_data,
2185                     ap->a_command == FIOSEEKDATA);
2186                 VOP_UNLOCK(vp);
2187                 break;
2188         default:
2189                 error = ENOTTY;
2190                 break;
2191         }
2192         return (error);
2193 }
2194
2195 /*
2196  * Vnode operations vector used for files stored in a tmpfs file system.
2197  */
2198 struct vop_vector tmpfs_vnodeop_entries = {
2199         .vop_default =                  &default_vnodeops,
2200         .vop_lookup =                   vfs_cache_lookup,
2201         .vop_cachedlookup =             tmpfs_cached_lookup,
2202         .vop_create =                   tmpfs_create,
2203         .vop_mknod =                    tmpfs_mknod,
2204         .vop_open =                     tmpfs_open,
2205         .vop_close =                    tmpfs_close,
2206         .vop_fplookup_vexec =           tmpfs_fplookup_vexec,
2207         .vop_fplookup_symlink =         tmpfs_fplookup_symlink,
2208         .vop_access =                   tmpfs_access,
2209         .vop_stat =                     tmpfs_stat,
2210         .vop_getattr =                  tmpfs_getattr,
2211         .vop_setattr =                  tmpfs_setattr,
2212         .vop_read =                     tmpfs_read,
2213         .vop_read_pgcache =             tmpfs_read_pgcache,
2214         .vop_write =                    tmpfs_write,
2215         .vop_deallocate =               tmpfs_deallocate,
2216         .vop_fsync =                    tmpfs_fsync,
2217         .vop_remove =                   tmpfs_remove,
2218         .vop_link =                     tmpfs_link,
2219         .vop_rename =                   tmpfs_rename,
2220         .vop_mkdir =                    tmpfs_mkdir,
2221         .vop_rmdir =                    tmpfs_rmdir,
2222         .vop_symlink =                  tmpfs_symlink,
2223         .vop_readdir =                  tmpfs_readdir,
2224         .vop_readlink =                 tmpfs_readlink,
2225         .vop_inactive =                 tmpfs_inactive,
2226         .vop_need_inactive =            tmpfs_need_inactive,
2227         .vop_reclaim =                  tmpfs_reclaim,
2228         .vop_print =                    tmpfs_print,
2229         .vop_pathconf =                 tmpfs_pathconf,
2230         .vop_vptofh =                   tmpfs_vptofh,
2231         .vop_whiteout =                 tmpfs_whiteout,
2232         .vop_bmap =                     VOP_EOPNOTSUPP,
2233         .vop_vptocnp =                  tmpfs_vptocnp,
2234         .vop_lock1 =                    vop_lock,
2235         .vop_unlock =                   vop_unlock,
2236         .vop_islocked =                 vop_islocked,
2237         .vop_deleteextattr =            tmpfs_deleteextattr,
2238         .vop_getextattr =               tmpfs_getextattr,
2239         .vop_listextattr =              tmpfs_listextattr,
2240         .vop_setextattr =               tmpfs_setextattr,
2241         .vop_add_writecount =           vop_stdadd_writecount_nomsync,
2242         .vop_ioctl =                    tmpfs_ioctl,
2243 };
2244 VFS_VOP_VECTOR_REGISTER(tmpfs_vnodeop_entries);
2245
2246 /*
2247  * Same vector for mounts which do not use namecache.
2248  */
2249 struct vop_vector tmpfs_vnodeop_nonc_entries = {
2250         .vop_default =                  &tmpfs_vnodeop_entries,
2251         .vop_lookup =                   tmpfs_lookup,
2252 };
2253 VFS_VOP_VECTOR_REGISTER(tmpfs_vnodeop_nonc_entries);