sys/vfs/tmpfs/tmpfs_subr.c

   1 /*      $NetBSD: tmpfs_subr.c,v 1.35 2007/07/09 21:10:50 ad Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2005 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
   9  * 2005 program.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Efficient memory file system supporting functions.
  35  */
  36
  37 #include <sys/kernel.h>
  38 #include <sys/param.h>
  39 #include <sys/priv.h>
  40 #include <sys/proc.h>
  41 #include <sys/stat.h>
  42 #include <sys/systm.h>
  43 #include <sys/vnode.h>
  44 #include <sys/vmmeter.h>
  45
  46 #include <vm/vm.h>
  47 #include <vm/vm_object.h>
  48 #include <vm/vm_page.h>
  49 #include <vm/vm_pager.h>
  50 #include <vm/vm_extern.h>
  51 #include <vm/vm_pageout.h>
  52 #include <vm/vm_page2.h>
  53
  54 #include <vfs/tmpfs/tmpfs.h>
  55 #include <vfs/tmpfs/tmpfs_vnops.h>
  56
  57 static ino_t tmpfs_fetch_ino(struct tmpfs_mount *);
  58
  59 static int tmpfs_dirtree_compare(struct tmpfs_dirent *a,
  60         struct tmpfs_dirent *b);
  61 RB_GENERATE(tmpfs_dirtree, tmpfs_dirent, rb_node, tmpfs_dirtree_compare);
  62
  63 static int tmpfs_dirtree_compare_cookie(struct tmpfs_dirent *a,
  64         struct tmpfs_dirent *b);
  65 RB_GENERATE(tmpfs_dirtree_cookie, tmpfs_dirent,
  66         rb_cookienode, tmpfs_dirtree_compare_cookie);
  67
  68
  69 /* --------------------------------------------------------------------- */
  70
  71 /*
  72  * Allocates a new node of type 'type' inside the 'tmp' mount point, with
  73  * its owner set to 'uid', its group to 'gid' and its mode set to 'mode',
  74  * using the credentials of the process 'p'.
  75  *
  76  * If the node type is set to 'VDIR', then the parent parameter must point
  77  * to the parent directory of the node being created.  It may only be NULL
  78  * while allocating the root node.
  79  *
  80  * If the node type is set to 'VBLK' or 'VCHR', then the rdev parameter
  81  * specifies the device the node represents.
  82  *
  83  * If the node type is set to 'VLNK', then the parameter target specifies
  84  * the file name of the target file for the symbolic link that is being
  85  * created.
  86  *
  87  * Note that new nodes are retrieved from the available list if it has
  88  * items or, if it is empty, from the node pool as long as there is enough
  89  * space to create them.
  90  *
  91  * Returns zero on success or an appropriate error code on failure.
  92  */
  93 int
  94 tmpfs_alloc_node(struct tmpfs_mount *tmp, enum vtype type,
  95                  uid_t uid, gid_t gid, mode_t mode,
  96                  char *target, int rmajor, int rminor,
  97                  struct tmpfs_node **node)
  98 {
  99         struct tmpfs_node *nnode;
 100         struct timespec ts;
 101         dev_t rdev;
 102
 103         KKASSERT(IFF(type == VLNK, target != NULL));
 104         KKASSERT(IFF(type == VBLK || type == VCHR, rmajor != VNOVAL));
 105
 106         if (tmp->tm_nodes_inuse >= tmp->tm_nodes_max)
 107                 return (ENOSPC);
 108
 109         nnode = objcache_get(tmp->tm_node_pool, M_WAITOK | M_NULLOK);
 110         if (nnode == NULL)
 111                 return (ENOSPC);
 112
 113         /* Generic initialization. */
 114         nnode->tn_type = type;
 115         vfs_timestamp(&ts);
 116         nnode->tn_ctime = nnode->tn_mtime = nnode->tn_atime
 117                 = ts.tv_sec;
 118         nnode->tn_ctimensec = nnode->tn_mtimensec = nnode->tn_atimensec
 119                 = ts.tv_nsec;
 120         nnode->tn_uid = uid;
 121         nnode->tn_gid = gid;
 122         nnode->tn_mode = mode;
 123         nnode->tn_id = tmpfs_fetch_ino(tmp);
 124         nnode->tn_advlock.init_done = 0;
 125         KKASSERT(nnode->tn_links == 0);
 126
 127         /* Type-specific initialization. */
 128         switch (nnode->tn_type) {
 129         case VBLK:
 130         case VCHR:
 131                 rdev = makeudev(rmajor, rminor);
 132                 if (rdev == NOUDEV) {
 133                         objcache_put(tmp->tm_node_pool, nnode);
 134                         return(EINVAL);
 135                 }
 136                 nnode->tn_rdev = rdev;
 137                 break;
 138
 139         case VDIR:
 140                 RB_INIT(&nnode->tn_dir.tn_dirtree);
 141                 RB_INIT(&nnode->tn_dir.tn_cookietree);
 142                 nnode->tn_dir.tn_parent = NULL;
 143                 nnode->tn_size = 0;
 144                 break;
 145
 146         case VFIFO:
 147                 /* FALLTHROUGH */
 148         case VSOCK:
 149                 break;
 150
 151         case VLNK:
 152                 nnode->tn_size = strlen(target);
 153                 nnode->tn_link = kmalloc(nnode->tn_size + 1, tmp->tm_name_zone,
 154                                          M_WAITOK | M_NULLOK);
 155                 if (nnode->tn_link == NULL) {
 156                         objcache_put(tmp->tm_node_pool, nnode);
 157                         return (ENOSPC);
 158                 }
 159                 bcopy(target, nnode->tn_link, nnode->tn_size);
 160                 nnode->tn_link[nnode->tn_size] = '\0';
 161                 break;
 162
 163         case VREG:
 164                 nnode->tn_reg.tn_aobj = swap_pager_alloc(NULL, 0,
 165                                                          VM_PROT_DEFAULT, 0);
 166                 nnode->tn_reg.tn_aobj_pages = 0;
 167                 nnode->tn_size = 0;
 168                 vm_object_set_flag(nnode->tn_reg.tn_aobj, OBJ_NOPAGEIN);
 169                 break;
 170
 171         default:
 172                 panic("tmpfs_alloc_node: type %p %d", nnode, (int)nnode->tn_type);
 173         }
 174
 175         TMPFS_NODE_LOCK(nnode);
 176         TMPFS_LOCK(tmp);
 177         LIST_INSERT_HEAD(&tmp->tm_nodes_used, nnode, tn_entries);
 178         tmp->tm_nodes_inuse++;
 179         TMPFS_UNLOCK(tmp);
 180         TMPFS_NODE_UNLOCK(nnode);
 181
 182         *node = nnode;
 183         return 0;
 184 }
 185
 186 /* --------------------------------------------------------------------- */
 187
 188 /*
 189  * Destroys the node pointed to by node from the file system 'tmp'.
 190  * If the node does not belong to the given mount point, the results are
 191  * unpredicted.
 192  *
 193  * If the node references a directory; no entries are allowed because
 194  * their removal could need a recursive algorithm, something forbidden in
 195  * kernel space.  Furthermore, there is not need to provide such
 196  * functionality (recursive removal) because the only primitives offered
 197  * to the user are the removal of empty directories and the deletion of
 198  * individual files.
 199  *
 200  * Note that nodes are not really deleted; in fact, when a node has been
 201  * allocated, it cannot be deleted during the whole life of the file
 202  * system.  Instead, they are moved to the available list and remain there
 203  * until reused.
 204  *
 205  * A caller must have TMPFS_NODE_LOCK(node) and this function unlocks it.
 206  */
 207 void
 208 tmpfs_free_node(struct tmpfs_mount *tmp, struct tmpfs_node *node)
 209 {
 210         vm_pindex_t pages = 0;
 211
 212 #ifdef INVARIANTS
 213         TMPFS_ASSERT_ELOCKED(node);
 214         KKASSERT(node->tn_vnode == NULL);
 215 #endif
 216
 217         TMPFS_LOCK(tmp);
 218         LIST_REMOVE(node, tn_entries);
 219         tmp->tm_nodes_inuse--;
 220         TMPFS_UNLOCK(tmp);
 221         TMPFS_NODE_UNLOCK(node);  /* Caller has this lock */
 222
 223         switch (node->tn_type) {
 224         case VNON:
 225                 /* Do not do anything.  VNON is provided to let the
 226                  * allocation routine clean itself easily by avoiding
 227                  * duplicating code in it. */
 228                 /* FALLTHROUGH */
 229         case VBLK:
 230                 /* FALLTHROUGH */
 231         case VCHR:
 232                 /* FALLTHROUGH */
 233                 break;
 234         case VDIR:
 235                 /*
 236                  * The parent link can be NULL if this is the root
 237                  * node or if it is a directory node that was rmdir'd.
 238                  *
 239                  * XXX what if node is a directory which still contains
 240                  * directory entries (e.g. due to a forced umount) ?
 241                  */
 242                 node->tn_size = 0;
 243                 KKASSERT(node->tn_dir.tn_parent == NULL);
 244
 245                 /*
 246                  * If the root node is being destroyed don't leave a
 247                  * dangling pointer in tmpfs_mount.
 248                  */
 249                 if (node == tmp->tm_root)
 250                         tmp->tm_root = NULL;
 251                 break;
 252         case VFIFO:
 253                 /* FALLTHROUGH */
 254         case VSOCK:
 255                 break;
 256
 257         case VLNK:
 258                 kfree(node->tn_link, tmp->tm_name_zone);
 259                 node->tn_link = NULL;
 260                 node->tn_size = 0;
 261                 break;
 262
 263         case VREG:
 264                 if (node->tn_reg.tn_aobj != NULL)
 265                         vm_object_deallocate(node->tn_reg.tn_aobj);
 266                 node->tn_reg.tn_aobj = NULL;
 267                 pages = node->tn_reg.tn_aobj_pages;
 268                 break;
 269
 270         default:
 271                 panic("tmpfs_free_node: type %p %d", node, (int)node->tn_type);
 272         }
 273
 274         /*
 275          * Clean up fields for the next allocation.  The objcache only ctors
 276          * new allocations.
 277          */
 278         tmpfs_node_ctor(node, NULL, 0);
 279         objcache_put(tmp->tm_node_pool, node);
 280         /* node is now invalid */
 281
 282         if (pages)
 283                 atomic_add_long(&tmp->tm_pages_used, -(long)pages);
 284 }
 285
 286 /* --------------------------------------------------------------------- */
 287
 288 /*
 289  * Allocates a new directory entry for the node node with a name of name.
 290  * The new directory entry is returned in *de.
 291  *
 292  * The link count of node is increased by one to reflect the new object
 293  * referencing it.
 294  *
 295  * Returns zero on success or an appropriate error code on failure.
 296  */
 297 int
 298 tmpfs_alloc_dirent(struct tmpfs_mount *tmp, struct tmpfs_node *node,
 299                    const char *name, uint16_t len, struct tmpfs_dirent **de)
 300 {
 301         struct tmpfs_dirent *nde;
 302
 303         nde = objcache_get(tmp->tm_dirent_pool, M_WAITOK);
 304         nde->td_name = kmalloc(len + 1, tmp->tm_name_zone, M_WAITOK | M_NULLOK);
 305         if (nde->td_name == NULL) {
 306                 objcache_put(tmp->tm_dirent_pool, nde);
 307                 *de = NULL;
 308                 return (ENOSPC);
 309         }
 310         nde->td_namelen = len;
 311         bcopy(name, nde->td_name, len);
 312         nde->td_name[len] = '\0';
 313
 314         nde->td_node = node;
 315
 316         atomic_add_int(&node->tn_links, 1);
 317
 318         *de = nde;
 319
 320         return 0;
 321 }
 322
 323 /* --------------------------------------------------------------------- */
 324
 325 /*
 326  * Frees a directory entry.  It is the caller's responsibility to destroy
 327  * the node referenced by it if needed.
 328  *
 329  * The link count of node is decreased by one to reflect the removal of an
 330  * object that referenced it.  This only happens if 'node_exists' is true;
 331  * otherwise the function will not access the node referred to by the
 332  * directory entry, as it may already have been released from the outside.
 333  */
 334 void
 335 tmpfs_free_dirent(struct tmpfs_mount *tmp, struct tmpfs_dirent *de)
 336 {
 337         struct tmpfs_node *node;
 338
 339         node = de->td_node;
 340
 341         KKASSERT(node->tn_links > 0);
 342         atomic_add_int(&node->tn_links, -1);
 343
 344         kfree(de->td_name, tmp->tm_name_zone);
 345         de->td_namelen = 0;
 346         de->td_name = NULL;
 347         de->td_node = NULL;
 348         objcache_put(tmp->tm_dirent_pool, de);
 349 }
 350
 351 /* --------------------------------------------------------------------- */
 352
 353 /*
 354  * Allocates a new vnode for the node node or returns a new reference to
 355  * an existing one if the node had already a vnode referencing it.  The
 356  * resulting locked vnode is returned in *vpp.
 357  *
 358  * Returns zero on success or an appropriate error code on failure.
 359  *
 360  * The caller must ensure that node cannot go away (usually by holding
 361  * the related directory entry).
 362  *
 363  * If dnode is non-NULL this routine avoids deadlocking against it but
 364  * can return EAGAIN.  Caller must try again.  The dnode lock will cycle
 365  * in this case, it remains locked on return in all cases.  dnode must
 366  * be shared-locked.
 367  */
 368 int
 369 tmpfs_alloc_vp(struct mount *mp,
 370                struct tmpfs_node *dnode, struct tmpfs_node *node, int lkflag,
 371                struct vnode **vpp)
 372 {
 373         int error = 0;
 374         struct vnode *vp;
 375
 376 loop:
 377         vp = NULL;
 378         if (node->tn_vnode == NULL) {
 379                 error = getnewvnode(VT_TMPFS, mp, &vp,
 380                                     VLKTIMEOUT, LK_CANRECURSE);
 381                 if (error)
 382                         goto out;
 383         }
 384
 385         /*
 386          * Interlocked extraction from node.  This can race many things.
 387          * We have to get a soft reference on the vnode while we hold
 388          * the node locked, then acquire it properly and check for races.
 389          */
 390         TMPFS_NODE_LOCK(node);
 391         if (node->tn_vnode) {
 392                 if (vp) {
 393                         vp->v_type = VBAD;
 394                         vx_put(vp);
 395                 }
 396                 vp = node->tn_vnode;
 397
 398                 KKASSERT((node->tn_vpstate & TMPFS_VNODE_DOOMED) == 0);
 399                 vhold(vp);
 400                 TMPFS_NODE_UNLOCK(node);
 401
 402                 if (dnode) {
 403                         /*
 404                          * Special-case handling to avoid deadlocking against
 405                          * dnode.  This case has been validated and occurs
 406                          * every so often during synth builds.
 407                          */
 408                         if (vget(vp, (lkflag & ~LK_RETRY) |
 409                                      LK_NOWAIT |
 410                                      LK_EXCLUSIVE) != 0) {
 411                                 TMPFS_NODE_UNLOCK(dnode);
 412                                 if (vget(vp, (lkflag & ~LK_RETRY) |
 413                                              LK_SLEEPFAIL |
 414                                              LK_EXCLUSIVE) == 0) {
 415                                         vn_unlock(vp);
 416                                 }
 417                                 vdrop(vp);
 418                                 TMPFS_NODE_LOCK_SH(dnode);
 419
 420                                 return EAGAIN;
 421                         }
 422                 } else {
 423                         /*
 424                          * Normal path
 425                          */
 426                         if (vget(vp, lkflag | LK_EXCLUSIVE) != 0) {
 427                                 vdrop(vp);
 428                                 goto loop;
 429                         }
 430                 }
 431                 if (node->tn_vnode != vp) {
 432                         vput(vp);
 433                         vdrop(vp);
 434                         goto loop;
 435                 }
 436                 vdrop(vp);
 437                 goto out;
 438         }
 439
 440         /*
 441          * We need to assign node->tn_vnode.  If vp is NULL, loop up to
 442          * allocate the vp.  This can happen due to SMP races.
 443          */
 444         if (vp == NULL) {
 445                 TMPFS_NODE_UNLOCK(node);
 446                 goto loop;
 447         }
 448
 449         /*
 450          * This should never happen.
 451          */
 452         if (node->tn_vpstate & TMPFS_VNODE_DOOMED) {
 453                 TMPFS_NODE_UNLOCK(node);
 454                 vp->v_type = VBAD;
 455                 vx_put(vp);
 456                 error = ENOENT;
 457                 goto out;
 458         }
 459
 460         KKASSERT(node->tn_vnode == NULL);
 461         KKASSERT(vp != NULL);
 462         vp->v_data = node;
 463         vp->v_type = node->tn_type;
 464
 465         /* Type-specific initialization. */
 466         switch (node->tn_type) {
 467         case VBLK:
 468                 /* FALLTHROUGH */
 469         case VCHR:
 470                 /* FALLTHROUGH */
 471         case VSOCK:
 472                 break;
 473         case VREG:
 474                 /*
 475                  * VMIO is mandatory.  Tmpfs also supports KVABIO
 476                  * for its tmpfs_strategy().
 477                  */
 478                 vsetflags(vp, VKVABIO);
 479                 vinitvmio(vp, node->tn_size, node->tn_blksize, -1);
 480                 break;
 481         case VLNK:
 482                 break;
 483         case VFIFO:
 484                 vp->v_ops = &mp->mnt_vn_fifo_ops;
 485                 break;
 486         case VDIR:
 487                 break;
 488
 489         default:
 490                 panic("tmpfs_alloc_vp: type %p %d", node, (int)node->tn_type);
 491         }
 492
 493         node->tn_vnode = vp;
 494         TMPFS_NODE_UNLOCK(node);
 495
 496         vx_downgrade(vp);
 497 out:
 498         *vpp = vp;
 499         KKASSERT(IFF(error == 0, *vpp != NULL && vn_islocked(*vpp)));
 500
 501         return error;
 502 }
 503
 504 /* --------------------------------------------------------------------- */
 505
 506 /*
 507  * Allocates a new file of type 'type' and adds it to the parent directory
 508  * 'dvp'; this addition is done using the component name given in 'cnp'.
 509  * The ownership of the new file is automatically assigned based on the
 510  * credentials of the caller (through 'cnp'), the group is set based on
 511  * the parent directory and the mode is determined from the 'vap' argument.
 512  * If successful, *vpp holds a vnode to the newly created file and zero
 513  * is returned.  Otherwise *vpp is NULL and the function returns an
 514  * appropriate error code.
 515  */
 516 int
 517 tmpfs_alloc_file(struct vnode *dvp, struct vnode **vpp, struct vattr *vap,
 518                  struct namecache *ncp, struct ucred *cred, char *target)
 519 {
 520         int error;
 521         struct tmpfs_dirent *de;
 522         struct tmpfs_mount *tmp;
 523         struct tmpfs_node *dnode;
 524         struct tmpfs_node *node;
 525
 526         tmp = VFS_TO_TMPFS(dvp->v_mount);
 527         dnode = VP_TO_TMPFS_DIR(dvp);
 528         *vpp = NULL;
 529
 530         TMPFS_NODE_LOCK(dnode);
 531
 532         /*
 533          * If the directory was removed but a process was CD'd into it,
 534          * we do not allow any more file/dir creation within it.  Otherwise
 535          * we will lose track of it.
 536          */
 537         KKASSERT(dnode->tn_type == VDIR);
 538         if (dnode != tmp->tm_root && dnode->tn_dir.tn_parent == NULL) {
 539                 TMPFS_NODE_UNLOCK(dnode);
 540                 return ENOENT;
 541         }
 542
 543         /*
 544          * Make sure the link count does not overflow.
 545          */
 546         if (vap->va_type == VDIR && dnode->tn_links >= LINK_MAX) {
 547                 TMPFS_NODE_UNLOCK(dnode);
 548                 return EMLINK;
 549         }
 550
 551         /* Allocate a node that represents the new file. */
 552         error = tmpfs_alloc_node(tmp, vap->va_type, cred->cr_uid,
 553                                  dnode->tn_gid, vap->va_mode, target,
 554                                  vap->va_rmajor, vap->va_rminor, &node);
 555         if (error != 0) {
 556                 TMPFS_NODE_UNLOCK(dnode);
 557                 return error;
 558         }
 559         TMPFS_NODE_LOCK(node);
 560
 561         /* Allocate a directory entry that points to the new file. */
 562         error = tmpfs_alloc_dirent(tmp, node, ncp->nc_name, ncp->nc_nlen, &de);
 563         if (error != 0) {
 564                 TMPFS_NODE_UNLOCK(dnode);
 565                 tmpfs_free_node(tmp, node);
 566                 /* eats node lock */
 567                 return error;
 568         }
 569
 570         /* Allocate a vnode for the new file. */
 571         error = tmpfs_alloc_vp(dvp->v_mount, NULL, node, LK_EXCLUSIVE, vpp);
 572         if (error != 0) {
 573                 TMPFS_NODE_UNLOCK(dnode);
 574                 tmpfs_free_dirent(tmp, de);
 575                 tmpfs_free_node(tmp, node);
 576                 /* eats node lock */
 577                 return error;
 578         }
 579
 580         /*
 581          * Now that all required items are allocated, we can proceed to
 582          * insert the new node into the directory, an operation that
 583          * cannot fail.
 584          */
 585         tmpfs_dir_attach_locked(dnode, de);
 586         TMPFS_NODE_UNLOCK(dnode);
 587         TMPFS_NODE_UNLOCK(node);
 588
 589         return error;
 590 }
 591
 592 /* --------------------------------------------------------------------- */
 593
 594 /*
 595  * Attaches the directory entry de to the directory represented by dnode.
 596  * Note that this does not change the link count of the node pointed by
 597  * the directory entry, as this is done by tmpfs_alloc_dirent.
 598  *
 599  * dnode must be locked.
 600  */
 601 void
 602 tmpfs_dir_attach_locked(struct tmpfs_node *dnode, struct tmpfs_dirent *de)
 603 {
 604         struct tmpfs_node *node = de->td_node;
 605         struct tmpfs_dirent *de2;
 606
 607         if (node && node->tn_type == VDIR) {
 608                 TMPFS_NODE_LOCK(node);
 609                 atomic_add_int(&node->tn_links, 1);
 610                 node->tn_status |= TMPFS_NODE_CHANGED;
 611                 node->tn_dir.tn_parent = dnode;
 612                 atomic_add_int(&dnode->tn_links, 1);
 613                 TMPFS_NODE_UNLOCK(node);
 614         }
 615         de2 = RB_INSERT(tmpfs_dirtree, &dnode->tn_dir.tn_dirtree, de);
 616         KASSERT(de2 == NULL,
 617                 ("tmpfs_dir_attach_lockedA: duplicate insertion of %p, has %p\n",
 618                 de, de2));
 619         de2 = RB_INSERT(tmpfs_dirtree_cookie, &dnode->tn_dir.tn_cookietree, de);
 620         KASSERT(de2 == NULL,
 621                 ("tmpfs_dir_attach_lockedB: duplicate insertion of %p, has %p\n",
 622                 de, de2));
 623         dnode->tn_size += sizeof(struct tmpfs_dirent);
 624         dnode->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED |
 625                             TMPFS_NODE_MODIFIED;
 626 }
 627
 628 /* --------------------------------------------------------------------- */
 629
 630 /*
 631  * Detaches the directory entry de from the directory represented by dnode.
 632  * Note that this does not change the link count of the node pointed by
 633  * the directory entry, as this is done by tmpfs_free_dirent.
 634  *
 635  * dnode must be locked.
 636  */
 637 void
 638 tmpfs_dir_detach_locked(struct tmpfs_node *dnode, struct tmpfs_dirent *de)
 639 {
 640         struct tmpfs_node *node = de->td_node;
 641
 642         RB_REMOVE(tmpfs_dirtree, &dnode->tn_dir.tn_dirtree, de);
 643         RB_REMOVE(tmpfs_dirtree_cookie, &dnode->tn_dir.tn_cookietree, de);
 644         dnode->tn_size -= sizeof(struct tmpfs_dirent);
 645         dnode->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED |
 646                             TMPFS_NODE_MODIFIED;
 647
 648         /*
 649          * Clean out the tn_parent pointer immediately when removing a
 650          * directory.
 651          *
 652          * Removal of the parent linkage also cleans out the extra tn_links
 653          * count we had on both node and dnode.
 654          *
 655          * node can be NULL (typ during a forced umount), in which case
 656          * the mount code is dealing with the linkages from a linked list
 657          * scan.
 658          */
 659         if (node && node->tn_type == VDIR && node->tn_dir.tn_parent) {
 660                 TMPFS_NODE_LOCK(node);
 661                 KKASSERT(node->tn_dir.tn_parent == dnode);
 662                 atomic_add_int(&dnode->tn_links, -1);
 663                 atomic_add_int(&node->tn_links, -1);
 664                 node->tn_dir.tn_parent = NULL;
 665                 TMPFS_NODE_UNLOCK(node);
 666         }
 667 }
 668
 669 /* --------------------------------------------------------------------- */
 670
 671 /*
 672  * Looks for a directory entry in the directory represented by node.
 673  * 'ncp' describes the name of the entry to look for.  Note that the .
 674  * and .. components are not allowed as they do not physically exist
 675  * within directories.
 676  *
 677  * Returns a pointer to the entry when found, otherwise NULL.
 678  *
 679  * Caller must hold the node locked (shared ok)
 680  */
 681 struct tmpfs_dirent *
 682 tmpfs_dir_lookup(struct tmpfs_node *node, struct tmpfs_node *f,
 683                  struct namecache *ncp)
 684 {
 685         struct tmpfs_dirent *de;
 686         int len = ncp->nc_nlen;
 687         struct tmpfs_dirent wanted;
 688
 689         wanted.td_namelen = len;
 690         wanted.td_name = ncp->nc_name;
 691
 692         TMPFS_VALIDATE_DIR(node);
 693
 694         de = RB_FIND(tmpfs_dirtree, &node->tn_dir.tn_dirtree, &wanted);
 695
 696         KASSERT((f == NULL || de == NULL || f == de->td_node),
 697                 ("tmpfs_dir_lookup: Incorrect node %p %p %p",
 698                  f, de, (de ? de->td_node : NULL)));
 699
 700         return de;
 701 }
 702
 703 /* --------------------------------------------------------------------- */
 704
 705 /*
 706  * Helper function for tmpfs_readdir.  Creates a '.' entry for the given
 707  * directory and returns it in the uio space.  The function returns 0
 708  * on success, -1 if there was not enough space in the uio structure to
 709  * hold the directory entry or an appropriate error code if another
 710  * error happens.
 711  */
 712 int
 713 tmpfs_dir_getdotdent(struct tmpfs_node *node, struct uio *uio)
 714 {
 715         int error;
 716
 717         TMPFS_VALIDATE_DIR(node);
 718         KKASSERT(uio->uio_offset == TMPFS_DIRCOOKIE_DOT);
 719
 720         if (vop_write_dirent(&error, uio, node->tn_id, DT_DIR, 1, "."))
 721                 return -1;
 722         if (error == 0)
 723                 uio->uio_offset = TMPFS_DIRCOOKIE_DOTDOT;
 724         return error;
 725 }
 726
 727 /* --------------------------------------------------------------------- */
 728
 729 /*
 730  * Helper function for tmpfs_readdir.  Creates a '..' entry for the given
 731  * directory and returns it in the uio space.  The function returns 0
 732  * on success, -1 if there was not enough space in the uio structure to
 733  * hold the directory entry or an appropriate error code if another
 734  * error happens.
 735  */
 736 int
 737 tmpfs_dir_getdotdotdent(struct tmpfs_mount *tmp, struct tmpfs_node *node,
 738                         struct uio *uio)
 739 {
 740         int error;
 741         ino_t d_ino;
 742
 743         TMPFS_VALIDATE_DIR(node);
 744         KKASSERT(uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT);
 745
 746         if (node->tn_dir.tn_parent) {
 747                 TMPFS_NODE_LOCK(node);
 748                 if (node->tn_dir.tn_parent)
 749                         d_ino = node->tn_dir.tn_parent->tn_id;
 750                 else
 751                         d_ino = tmp->tm_root->tn_id;
 752                 TMPFS_NODE_UNLOCK(node);
 753         } else {
 754                 d_ino = tmp->tm_root->tn_id;
 755         }
 756
 757         if (vop_write_dirent(&error, uio, d_ino, DT_DIR, 2, ".."))
 758                 return -1;
 759         if (error == 0) {
 760                 struct tmpfs_dirent *de;
 761                 de = RB_MIN(tmpfs_dirtree_cookie, &node->tn_dir.tn_cookietree);
 762                 if (de == NULL)
 763                         uio->uio_offset = TMPFS_DIRCOOKIE_EOF;
 764                 else
 765                         uio->uio_offset = tmpfs_dircookie(de);
 766         }
 767         return error;
 768 }
 769
 770 /* --------------------------------------------------------------------- */
 771
 772 /*
 773  * Lookup a directory entry by its associated cookie.
 774  *
 775  * Must be called with the directory node locked (shared ok)
 776  */
 777 struct lubycookie_info {
 778         off_t   cookie;
 779         struct tmpfs_dirent *de;
 780 };
 781
 782 static int
 783 lubycookie_cmp(struct tmpfs_dirent *de, void *arg)
 784 {
 785         struct lubycookie_info *info = arg;
 786         off_t cookie = tmpfs_dircookie(de);
 787
 788         if (cookie < info->cookie)
 789                 return(-1);
 790         if (cookie > info->cookie)
 791                 return(1);
 792         return(0);
 793 }
 794
 795 static int
 796 lubycookie_callback(struct tmpfs_dirent *de, void *arg)
 797 {
 798         struct lubycookie_info *info = arg;
 799
 800         if (tmpfs_dircookie(de) == info->cookie) {
 801                 info->de = de;
 802                 return(-1);
 803         }
 804         return(0);
 805 }
 806
 807 struct tmpfs_dirent *
 808 tmpfs_dir_lookupbycookie(struct tmpfs_node *node, off_t cookie)
 809 {
 810         struct lubycookie_info info;
 811
 812         info.cookie = cookie;
 813         info.de = NULL;
 814         RB_SCAN(tmpfs_dirtree_cookie, &node->tn_dir.tn_cookietree,
 815                 lubycookie_cmp, lubycookie_callback, &info);
 816         return (info.de);
 817 }
 818
 819 /* --------------------------------------------------------------------- */
 820
 821 /*
 822  * Helper function for tmpfs_readdir.  Returns as much directory entries
 823  * as can fit in the uio space.  The read starts at uio->uio_offset.
 824  * The function returns 0 on success, -1 if there was not enough space
 825  * in the uio structure to hold the directory entry or an appropriate
 826  * error code if another error happens.
 827  *
 828  * Caller must hold the node locked (shared ok)
 829  */
 830 int
 831 tmpfs_dir_getdents(struct tmpfs_node *node, struct uio *uio, off_t *cntp)
 832 {
 833         int error;
 834         off_t startcookie;
 835         struct tmpfs_dirent *de;
 836
 837         TMPFS_VALIDATE_DIR(node);
 838
 839         /*
 840          * Locate the first directory entry we have to return.  We have cached
 841          * the last readdir in the node, so use those values if appropriate.
 842          * Otherwise do a linear scan to find the requested entry.
 843          */
 844         startcookie = uio->uio_offset;
 845         KKASSERT(startcookie != TMPFS_DIRCOOKIE_DOT);
 846         KKASSERT(startcookie != TMPFS_DIRCOOKIE_DOTDOT);
 847
 848         if (startcookie == TMPFS_DIRCOOKIE_EOF)
 849                 return 0;
 850
 851         de = tmpfs_dir_lookupbycookie(node, startcookie);
 852         if (de == NULL)
 853                 return EINVAL;
 854
 855         /*
 856          * Read as much entries as possible; i.e., until we reach the end of
 857          * the directory or we exhaust uio space.
 858          */
 859         do {
 860                 ino_t d_ino;
 861                 uint8_t d_type;
 862
 863                 /* Create a dirent structure representing the current
 864                  * tmpfs_node and fill it. */
 865                 d_ino = de->td_node->tn_id;
 866                 switch (de->td_node->tn_type) {
 867                 case VBLK:
 868                         d_type = DT_BLK;
 869                         break;
 870
 871                 case VCHR:
 872                         d_type = DT_CHR;
 873                         break;
 874
 875                 case VDIR:
 876                         d_type = DT_DIR;
 877                         break;
 878
 879                 case VFIFO:
 880                         d_type = DT_FIFO;
 881                         break;
 882
 883                 case VLNK:
 884                         d_type = DT_LNK;
 885                         break;
 886
 887                 case VREG:
 888                         d_type = DT_REG;
 889                         break;
 890
 891                 case VSOCK:
 892                         d_type = DT_SOCK;
 893                         break;
 894
 895                 default:
 896                         panic("tmpfs_dir_getdents: type %p %d",
 897                             de->td_node, (int)de->td_node->tn_type);
 898                 }
 899                 KKASSERT(de->td_namelen < 256); /* 255 + 1 */
 900
 901                 if (vop_write_dirent(&error, uio, d_ino, d_type,
 902                     de->td_namelen, de->td_name)) {
 903                         error = -1;
 904                         break;
 905                 }
 906
 907                 (*cntp)++;
 908                 de = RB_NEXT(tmpfs_dirtree_cookie,
 909                              node->tn_dir.tn_cookietree, de);
 910         } while (error == 0 && uio->uio_resid > 0 && de != NULL);
 911
 912         /* Update the offset and cache. */
 913         if (de == NULL) {
 914                 uio->uio_offset = TMPFS_DIRCOOKIE_EOF;
 915         } else {
 916                 uio->uio_offset = tmpfs_dircookie(de);
 917         }
 918
 919         return error;
 920 }
 921
 922 /* --------------------------------------------------------------------- */
 923
 924 /*
 925  * Resizes the aobj associated to the regular file pointed to by vp to
 926  * the size newsize.  'vp' must point to a vnode that represents a regular
 927  * file.  'newsize' must be positive.
 928  *
 929  * pass NVEXTF_TRIVIAL when buf content will be overwritten, otherwise set 0
 930  * to be zero filled.
 931  *
 932  * Returns zero on success or an appropriate error code on failure.
 933  *
 934  * Caller must hold the node exclusively locked.
 935  */
 936 int
 937 tmpfs_reg_resize(struct vnode *vp, off_t newsize, int trivial)
 938 {
 939         int error;
 940         vm_pindex_t newpages, oldpages;
 941         struct tmpfs_mount *tmp;
 942         struct tmpfs_node *node;
 943         off_t oldsize;
 944         int nvextflags;
 945
 946 #ifdef INVARIANTS
 947         KKASSERT(vp->v_type == VREG);
 948         KKASSERT(newsize >= 0);
 949 #endif
 950
 951         node = VP_TO_TMPFS_NODE(vp);
 952         tmp = VFS_TO_TMPFS(vp->v_mount);
 953
 954         /*
 955          * Convert the old and new sizes to the number of pages needed to
 956          * store them.  It may happen that we do not need to do anything
 957          * because the last allocated page can accommodate the change on
 958          * its own.
 959          */
 960         oldsize = node->tn_size;
 961         oldpages = round_page64(oldsize) / PAGE_SIZE;
 962         KKASSERT(oldpages == node->tn_reg.tn_aobj_pages);
 963         newpages = round_page64(newsize) / PAGE_SIZE;
 964
 965         if (newpages > oldpages &&
 966            tmp->tm_pages_used + newpages - oldpages > tmp->tm_pages_max) {
 967                 error = ENOSPC;
 968                 goto out;
 969         }
 970         node->tn_reg.tn_aobj_pages = newpages;
 971         node->tn_size = newsize;
 972
 973         if (newpages != oldpages)
 974                 atomic_add_long(&tmp->tm_pages_used, (newpages - oldpages));
 975
 976         /*
 977          * nvextflags to pass along for bdwrite() vs buwrite()
 978          */
 979         if (vm_pages_needed || vm_paging_needed(0) ||
 980             tmpfs_bufcache_mode >= 2) {
 981                 nvextflags = 0;
 982         } else {
 983                 nvextflags = NVEXTF_BUWRITE;
 984         }
 985
 986
 987         /*
 988          * When adjusting the vnode filesize and its VM object we must
 989          * also adjust our backing VM object (aobj).  The blocksize
 990          * used must match the block sized we use for the buffer cache.
 991          *
 992          * The backing VM object may contain VM pages as well as swap
 993          * assignments if we previously renamed main object pages into
 994          * it during deactivation.
 995          *
 996          * To make things easier tmpfs uses a blksize in multiples of
 997          * PAGE_SIZE, and will only increase the blksize as a small file
 998          * increases in size.  Once a file has exceeded TMPFS_BLKSIZE (16KB),
 999          * the blksize is maxed out.  Truncating the file does not reduce
1000          * the blksize.
1001          */
1002         if (newsize < oldsize) {
1003                 vm_pindex_t osize;
1004                 vm_pindex_t nsize;
1005                 vm_object_t aobj;
1006
1007                 error = nvtruncbuf(vp, newsize, node->tn_blksize,
1008                                    -1, nvextflags);
1009                 aobj = node->tn_reg.tn_aobj;
1010                 if (aobj) {
1011                         osize = aobj->size;
1012                         nsize = vp->v_object->size;
1013                         if (nsize < osize) {
1014                                 aobj->size = osize;
1015                                 swap_pager_freespace(aobj, nsize,
1016                                                      osize - nsize);
1017                                 vm_object_page_remove(aobj, nsize, osize,
1018                                                       FALSE);
1019                         }
1020                 }
1021         } else {
1022                 vm_object_t aobj;
1023                 int nblksize;
1024
1025                 /*
1026                  * The first (and only the first) buffer in the file is resized
1027                  * in multiples of PAGE_SIZE, up to TMPFS_BLKSIZE.
1028                  */
1029                 nblksize = node->tn_blksize;
1030                 while (nblksize < TMPFS_BLKSIZE &&
1031                        nblksize < newsize) {
1032                         nblksize += PAGE_SIZE;
1033                 }
1034
1035                 if (trivial)
1036                         nvextflags |= NVEXTF_TRIVIAL;
1037
1038                 error = nvextendbuf(vp, oldsize, newsize,
1039                                     node->tn_blksize, nblksize,
1040                                     -1, -1, nvextflags);
1041                 node->tn_blksize = nblksize;
1042                 aobj = node->tn_reg.tn_aobj;
1043                 if (aobj)
1044                         aobj->size = vp->v_object->size;
1045         }
1046
1047 out:
1048         return error;
1049 }
1050
1051 /* --------------------------------------------------------------------- */
1052
1053 /*
1054  * Change flags of the given vnode.
1055  * Caller should execute tmpfs_update on vp after a successful execution.
1056  * The vnode must be locked on entry and remain locked on exit.
1057  */
1058 int
1059 tmpfs_chflags(struct vnode *vp, u_long vaflags, struct ucred *cred)
1060 {
1061         int error;
1062         struct tmpfs_node *node;
1063         int flags;
1064
1065         KKASSERT(vn_islocked(vp));
1066
1067         node = VP_TO_TMPFS_NODE(vp);
1068         flags = node->tn_flags;
1069
1070         /* Disallow this operation if the file system is mounted read-only. */
1071         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1072                 return EROFS;
1073         error = vop_helper_setattr_flags(&flags, vaflags, node->tn_uid, cred);
1074
1075         /* Actually change the flags on the node itself */
1076         if (error == 0) {
1077                 TMPFS_NODE_LOCK(node);
1078                 node->tn_flags = flags;
1079                 node->tn_status |= TMPFS_NODE_CHANGED;
1080                 TMPFS_NODE_UNLOCK(node);
1081         }
1082
1083         KKASSERT(vn_islocked(vp));
1084
1085         return error;
1086 }
1087
1088 /* --------------------------------------------------------------------- */
1089
1090 /*
1091  * Change access mode on the given vnode.
1092  * Caller should execute tmpfs_update on vp after a successful execution.
1093  * The vnode must be locked on entry and remain locked on exit.
1094  */
1095 int
1096 tmpfs_chmod(struct vnode *vp, mode_t vamode, struct ucred *cred)
1097 {
1098         struct tmpfs_node *node;
1099         mode_t cur_mode;
1100         int error;
1101
1102         KKASSERT(vn_islocked(vp));
1103
1104         node = VP_TO_TMPFS_NODE(vp);
1105
1106         /* Disallow this operation if the file system is mounted read-only. */
1107         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1108                 return EROFS;
1109
1110         /* Immutable or append-only files cannot be modified, either. */
1111         if (node->tn_flags & (IMMUTABLE | APPEND))
1112                 return EPERM;
1113
1114         cur_mode = node->tn_mode;
1115         error = vop_helper_chmod(vp, vamode, cred, node->tn_uid, node->tn_gid,
1116                                  &cur_mode);
1117
1118         if (error == 0 &&
1119             (node->tn_mode & ALLPERMS) != (cur_mode & ALLPERMS)) {
1120                 TMPFS_NODE_LOCK(node);
1121                 node->tn_mode &= ~ALLPERMS;
1122                 node->tn_mode |= cur_mode & ALLPERMS;
1123
1124                 node->tn_status |= TMPFS_NODE_CHANGED;
1125                 TMPFS_NODE_UNLOCK(node);
1126         }
1127
1128         KKASSERT(vn_islocked(vp));
1129
1130         return 0;
1131 }
1132
1133 /* --------------------------------------------------------------------- */
1134
1135 /*
1136  * Change ownership of the given vnode.  At least one of uid or gid must
1137  * be different than VNOVAL.  If one is set to that value, the attribute
1138  * is unchanged.
1139  * Caller should execute tmpfs_update on vp after a successful execution.
1140  * The vnode must be locked on entry and remain locked on exit.
1141  */
1142 int
1143 tmpfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred)
1144 {
1145         mode_t cur_mode;
1146         uid_t cur_uid;
1147         gid_t cur_gid;
1148         struct tmpfs_node *node;
1149         int error;
1150
1151         KKASSERT(vn_islocked(vp));
1152         node = VP_TO_TMPFS_NODE(vp);
1153
1154         /* Disallow this operation if the file system is mounted read-only. */
1155         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1156                 return EROFS;
1157
1158         /* Immutable or append-only files cannot be modified, either. */
1159         if (node->tn_flags & (IMMUTABLE | APPEND))
1160                 return EPERM;
1161
1162         cur_uid = node->tn_uid;
1163         cur_gid = node->tn_gid;
1164         cur_mode = node->tn_mode;
1165         error = vop_helper_chown(vp, uid, gid, cred,
1166                                  &cur_uid, &cur_gid, &cur_mode);
1167
1168         if (error == 0) {
1169                 TMPFS_NODE_LOCK(node);
1170                 if (cur_uid != node->tn_uid ||
1171                     cur_gid != node->tn_gid ||
1172                     cur_mode != node->tn_mode) {
1173                         node->tn_uid = cur_uid;
1174                         node->tn_gid = cur_gid;
1175                         node->tn_mode = cur_mode;
1176                         node->tn_status |= TMPFS_NODE_CHANGED;
1177                 }
1178                 TMPFS_NODE_UNLOCK(node);
1179         }
1180
1181         return error;
1182 }
1183
1184 /* --------------------------------------------------------------------- */
1185
1186 /*
1187  * Change size of the given vnode.
1188  * Caller should execute tmpfs_update on vp after a successful execution.
1189  * The vnode must be locked on entry and remain locked on exit.
1190  */
1191 int
1192 tmpfs_chsize(struct vnode *vp, u_quad_t size, struct ucred *cred)
1193 {
1194         int error;
1195         struct tmpfs_node *node;
1196
1197         KKASSERT(vn_islocked(vp));
1198
1199         node = VP_TO_TMPFS_NODE(vp);
1200
1201         /* Decide whether this is a valid operation based on the file type. */
1202         error = 0;
1203         switch (vp->v_type) {
1204         case VDIR:
1205                 return EISDIR;
1206
1207         case VREG:
1208                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1209                         return EROFS;
1210                 break;
1211
1212         case VBLK:
1213                 /* FALLTHROUGH */
1214         case VCHR:
1215                 /* FALLTHROUGH */
1216         case VFIFO:
1217                 /* Allow modifications of special files even if in the file
1218                  * system is mounted read-only (we are not modifying the
1219                  * files themselves, but the objects they represent). */
1220                 return 0;
1221
1222         default:
1223                 /* Anything else is unsupported. */
1224                 return EOPNOTSUPP;
1225         }
1226
1227         /* Immutable or append-only files cannot be modified, either. */
1228         if (node->tn_flags & (IMMUTABLE | APPEND))
1229                 return EPERM;
1230
1231         error = tmpfs_truncate(vp, size);
1232         /* tmpfs_truncate will raise the NOTE_EXTEND and NOTE_ATTRIB kevents
1233          * for us, as will update tn_status; no need to do that here. */
1234
1235         KKASSERT(vn_islocked(vp));
1236
1237         return error;
1238 }
1239
1240 /* --------------------------------------------------------------------- */
1241
1242 /*
1243  * Change access and modification times of the given vnode.
1244  * Caller should execute tmpfs_update on vp after a successful execution.
1245  * The vnode must be locked on entry and remain locked on exit.
1246  */
1247 int
1248 tmpfs_chtimes(struct vnode *vp, struct timespec *atime, struct timespec *mtime,
1249               int vaflags, struct ucred *cred)
1250 {
1251         struct tmpfs_node *node;
1252
1253         KKASSERT(vn_islocked(vp));
1254
1255         node = VP_TO_TMPFS_NODE(vp);
1256
1257         /* Disallow this operation if the file system is mounted read-only. */
1258         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1259                 return EROFS;
1260
1261         /* Immutable or append-only files cannot be modified, either. */
1262         if (node->tn_flags & (IMMUTABLE | APPEND))
1263                 return EPERM;
1264
1265         TMPFS_NODE_LOCK(node);
1266         if (atime->tv_sec != VNOVAL && atime->tv_nsec != VNOVAL)
1267                 node->tn_status |= TMPFS_NODE_ACCESSED;
1268
1269         if (mtime->tv_sec != VNOVAL && mtime->tv_nsec != VNOVAL) {
1270                 node->tn_status |= TMPFS_NODE_MODIFIED;
1271                 vclrflags(vp, VLASTWRITETS);
1272         }
1273
1274         TMPFS_NODE_UNLOCK(node);
1275
1276         tmpfs_itimes(vp, atime, mtime);
1277
1278         KKASSERT(vn_islocked(vp));
1279
1280         return 0;
1281 }
1282
1283 /* --------------------------------------------------------------------- */
1284 /* Sync timestamps */
1285 void
1286 tmpfs_itimes(struct vnode *vp, const struct timespec *acc,
1287              const struct timespec *mod)
1288 {
1289         struct tmpfs_node *node;
1290         struct timespec now;
1291
1292         node = VP_TO_TMPFS_NODE(vp);
1293
1294         if ((node->tn_status & (TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
1295             TMPFS_NODE_CHANGED)) == 0) {
1296                 return;
1297         }
1298
1299         vfs_timestamp(&now);
1300
1301         TMPFS_NODE_LOCK(node);
1302         if (node->tn_status & TMPFS_NODE_ACCESSED) {
1303                 if (acc == NULL)
1304                          acc = &now;
1305                 node->tn_atime = acc->tv_sec;
1306                 node->tn_atimensec = acc->tv_nsec;
1307         }
1308         if (node->tn_status & TMPFS_NODE_MODIFIED) {
1309                 if (mod == NULL)
1310                         mod = &now;
1311                 node->tn_mtime = mod->tv_sec;
1312                 node->tn_mtimensec = mod->tv_nsec;
1313         }
1314         if (node->tn_status & TMPFS_NODE_CHANGED) {
1315                 node->tn_ctime = now.tv_sec;
1316                 node->tn_ctimensec = now.tv_nsec;
1317         }
1318
1319         node->tn_status &= ~(TMPFS_NODE_ACCESSED |
1320                              TMPFS_NODE_MODIFIED |
1321                              TMPFS_NODE_CHANGED);
1322         TMPFS_NODE_UNLOCK(node);
1323 }
1324
1325 /* --------------------------------------------------------------------- */
1326
1327 void
1328 tmpfs_update(struct vnode *vp)
1329 {
1330         tmpfs_itimes(vp, NULL, NULL);
1331 }
1332
1333 /* --------------------------------------------------------------------- */
1334
1335 /*
1336  * Caller must hold an exclusive node lock.
1337  */
1338 int
1339 tmpfs_truncate(struct vnode *vp, off_t length)
1340 {
1341         int error;
1342         struct tmpfs_node *node;
1343
1344         node = VP_TO_TMPFS_NODE(vp);
1345
1346         if (length < 0) {
1347                 error = EINVAL;
1348                 goto out;
1349         }
1350
1351         if (node->tn_size == length) {
1352                 error = 0;
1353                 goto out;
1354         }
1355
1356         if (length > VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
1357                 return (EFBIG);
1358
1359
1360         error = tmpfs_reg_resize(vp, length, 1);
1361
1362         if (error == 0)
1363                 node->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1364
1365 out:
1366         tmpfs_update(vp);
1367
1368         return error;
1369 }
1370
1371 /* --------------------------------------------------------------------- */
1372
1373 static ino_t
1374 tmpfs_fetch_ino(struct tmpfs_mount *tmp)
1375 {
1376         ino_t ret;
1377
1378         ret = atomic_fetchadd_64(&tmp->tm_ino, 1);
1379
1380         return (ret);
1381 }
1382
1383 static int
1384 tmpfs_dirtree_compare(struct tmpfs_dirent *a, struct tmpfs_dirent *b)
1385 {
1386         if (a->td_namelen > b->td_namelen)
1387                 return 1;
1388         else if (a->td_namelen < b->td_namelen)
1389                 return -1;
1390         else
1391                 return strncmp(a->td_name, b->td_name, a->td_namelen);
1392 }
1393
1394 static int
1395 tmpfs_dirtree_compare_cookie(struct tmpfs_dirent *a, struct tmpfs_dirent *b)
1396 {
1397         if (a < b)
1398                 return(-1);
1399         if (a > b)
1400                 return(1);
1401         return 0;
1402 }
1403
1404 /*
1405  * Lock for rename.  The namecache entries for the related terminal files
1406  * are already locked but the directories are not.  A directory lock order
1407  * reversal is possible so use a deterministic order.
1408  *
1409  * Generally order path parent-to-child or using a simple pointer comparison.
1410  * Probably not perfect but it should catch most of the cases.
1411  *
1412  * Underlying files must be locked after the related directory.
1413  */
1414 void
1415 tmpfs_lock4(struct tmpfs_node *node1, struct tmpfs_node *node2,
1416             struct tmpfs_node *node3, struct tmpfs_node *node4)
1417 {
1418         if (node1->tn_dir.tn_parent != node2 &&
1419             (node1 < node2 || node2->tn_dir.tn_parent == node1)) {
1420                 TMPFS_NODE_LOCK(node1);         /* fdir */
1421                 TMPFS_NODE_LOCK(node3);         /* ffile */
1422                 TMPFS_NODE_LOCK(node2);         /* tdir */
1423                 if (node4)
1424                         TMPFS_NODE_LOCK(node4); /* tfile */
1425         } else {
1426                 TMPFS_NODE_LOCK(node2);         /* tdir */
1427                 if (node4)
1428                         TMPFS_NODE_LOCK(node4); /* tfile */
1429                 TMPFS_NODE_LOCK(node1);         /* fdir */
1430                 TMPFS_NODE_LOCK(node3);         /* ffile */
1431         }
1432 }
1433
1434 void
1435 tmpfs_unlock4(struct tmpfs_node *node1, struct tmpfs_node *node2,
1436               struct tmpfs_node *node3, struct tmpfs_node *node4)
1437 {
1438         if (node4)
1439                 TMPFS_NODE_UNLOCK(node4);
1440         TMPFS_NODE_UNLOCK(node2);
1441         TMPFS_NODE_UNLOCK(node3);
1442         TMPFS_NODE_UNLOCK(node1);
1443 }