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