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;       /* also requires mnt_token protection */
 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--;       /* also requires mnt_token protection */
 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, TMPFS_BLKMASK, -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
 454 unlock:
 455         TMPFS_NODE_LOCK(node);
 456
 457         KKASSERT(node->tn_vpstate & TMPFS_VNODE_ALLOCATING);
 458         node->tn_vpstate &= ~TMPFS_VNODE_ALLOCATING;
 459         node->tn_vnode = vp;
 460
 461         if (node->tn_vpstate & TMPFS_VNODE_WANT) {
 462                 node->tn_vpstate &= ~TMPFS_VNODE_WANT;
 463                 TMPFS_NODE_UNLOCK(node);
 464                 wakeup(&node->tn_vpstate);
 465         } else {
 466                 TMPFS_NODE_UNLOCK(node);
 467         }
 468
 469 out:
 470         *vpp = vp;
 471
 472         KKASSERT(IFF(error == 0, *vpp != NULL && vn_islocked(*vpp)));
 473 #ifdef INVARIANTS
 474         TMPFS_NODE_LOCK(node);
 475         KKASSERT(*vpp == node->tn_vnode);
 476         TMPFS_NODE_UNLOCK(node);
 477 #endif
 478
 479         return error;
 480 }
 481
 482 /* --------------------------------------------------------------------- */
 483
 484 /*
 485  * Destroys the association between the vnode vp and the node it
 486  * references.
 487  */
 488 void
 489 tmpfs_free_vp(struct vnode *vp)
 490 {
 491         struct tmpfs_node *node;
 492
 493         node = VP_TO_TMPFS_NODE(vp);
 494
 495         TMPFS_NODE_LOCK(node);
 496         KKASSERT(lockcount(TMPFS_NODE_MTX(node)) > 0);
 497         node->tn_vnode = NULL;
 498         vp->v_data = NULL;
 499         TMPFS_NODE_UNLOCK(node);
 500 }
 501
 502 /* --------------------------------------------------------------------- */
 503
 504 /*
 505  * Allocates a new file of type 'type' and adds it to the parent directory
 506  * 'dvp'; this addition is done using the component name given in 'cnp'.
 507  * The ownership of the new file is automatically assigned based on the
 508  * credentials of the caller (through 'cnp'), the group is set based on
 509  * the parent directory and the mode is determined from the 'vap' argument.
 510  * If successful, *vpp holds a vnode to the newly created file and zero
 511  * is returned.  Otherwise *vpp is NULL and the function returns an
 512  * appropriate error code.
 513  */
 514 int
 515 tmpfs_alloc_file(struct vnode *dvp, struct vnode **vpp, struct vattr *vap,
 516                  struct namecache *ncp, struct ucred *cred, char *target)
 517 {
 518         int error;
 519         struct tmpfs_dirent *de;
 520         struct tmpfs_mount *tmp;
 521         struct tmpfs_node *dnode;
 522         struct tmpfs_node *node;
 523
 524         tmp = VFS_TO_TMPFS(dvp->v_mount);
 525         dnode = VP_TO_TMPFS_DIR(dvp);
 526         *vpp = NULL;
 527
 528         /*
 529          * If the directory was removed but a process was CD'd into it,
 530          * we do not allow any more file/dir creation within it.  Otherwise
 531          * we will lose track of it.
 532          */
 533         KKASSERT(dnode->tn_type == VDIR);
 534         if (dnode != tmp->tm_root && dnode->tn_dir.tn_parent == NULL)
 535                 return ENOENT;
 536
 537         /*
 538          * Make sure the link count does not overflow.
 539          */
 540         if (vap->va_type == VDIR && dnode->tn_links >= LINK_MAX)
 541                 return EMLINK;
 542
 543         /* Allocate a node that represents the new file. */
 544         error = tmpfs_alloc_node(tmp, vap->va_type, cred->cr_uid,
 545                                  dnode->tn_gid, vap->va_mode, target,
 546                                  vap->va_rmajor, vap->va_rminor, &node);
 547         if (error != 0)
 548                 return error;
 549         TMPFS_NODE_LOCK(node);
 550
 551         /* Allocate a directory entry that points to the new file. */
 552         error = tmpfs_alloc_dirent(tmp, node, ncp->nc_name, ncp->nc_nlen, &de);
 553         if (error != 0) {
 554                 tmpfs_free_node(tmp, node);
 555                 /* eats node lock */
 556                 return error;
 557         }
 558
 559         /* Allocate a vnode for the new file. */
 560         error = tmpfs_alloc_vp(dvp->v_mount, node, LK_EXCLUSIVE, vpp);
 561         if (error != 0) {
 562                 tmpfs_free_dirent(tmp, de);
 563                 tmpfs_free_node(tmp, node);
 564                 /* eats node lock */
 565                 return error;
 566         }
 567
 568         /*
 569          * Now that all required items are allocated, we can proceed to
 570          * insert the new node into the directory, an operation that
 571          * cannot fail.
 572          */
 573         tmpfs_dir_attach(dnode, de);
 574         TMPFS_NODE_UNLOCK(node);
 575
 576         return error;
 577 }
 578
 579 /* --------------------------------------------------------------------- */
 580
 581 /*
 582  * Attaches the directory entry de to the directory represented by vp.
 583  * Note that this does not change the link count of the node pointed by
 584  * the directory entry, as this is done by tmpfs_alloc_dirent.
 585  */
 586 void
 587 tmpfs_dir_attach(struct tmpfs_node *dnode, struct tmpfs_dirent *de)
 588 {
 589         struct tmpfs_node *node = de->td_node;
 590
 591         TMPFS_NODE_LOCK(dnode);
 592         if (node && node->tn_type == VDIR) {
 593                 TMPFS_NODE_LOCK(node);
 594                 ++node->tn_links;       /* also requires mnt_token protection */
 595                 node->tn_status |= TMPFS_NODE_CHANGED;
 596                 node->tn_dir.tn_parent = dnode;
 597                 ++dnode->tn_links;      /* also requires mnt_token protection */
 598                 TMPFS_NODE_UNLOCK(node);
 599         }
 600         RB_INSERT(tmpfs_dirtree, &dnode->tn_dir.tn_dirtree, de);
 601         dnode->tn_size += sizeof(struct tmpfs_dirent);
 602         dnode->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED |
 603                             TMPFS_NODE_MODIFIED;
 604         TMPFS_NODE_UNLOCK(dnode);
 605 }
 606
 607 /* --------------------------------------------------------------------- */
 608
 609 /*
 610  * Detaches the directory entry de from the directory represented by vp.
 611  * Note that this does not change the link count of the node pointed by
 612  * the directory entry, as this is done by tmpfs_free_dirent.
 613  */
 614 void
 615 tmpfs_dir_detach(struct tmpfs_node *dnode, struct tmpfs_dirent *de)
 616 {
 617         struct tmpfs_node *node = de->td_node;
 618
 619         TMPFS_NODE_LOCK(dnode);
 620         if (dnode->tn_dir.tn_readdir_lastp == de) {
 621                 dnode->tn_dir.tn_readdir_lastn = 0;
 622                 dnode->tn_dir.tn_readdir_lastp = NULL;
 623         }
 624         RB_REMOVE(tmpfs_dirtree, &dnode->tn_dir.tn_dirtree, de);
 625         dnode->tn_size -= sizeof(struct tmpfs_dirent);
 626         dnode->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED |
 627                             TMPFS_NODE_MODIFIED;
 628         TMPFS_NODE_UNLOCK(dnode);
 629
 630         /*
 631          * Clean out the tn_parent pointer immediately when removing a
 632          * directory.
 633          *
 634          * Removal of the parent linkage also cleans out the extra tn_links
 635          * count we had on both node and dnode.
 636          *
 637          * node can be NULL (typ during a forced umount), in which case
 638          * the mount code is dealing with the linkages from a linked list
 639          * scan.
 640          */
 641         if (node && node->tn_type == VDIR && node->tn_dir.tn_parent) {
 642                 TMPFS_NODE_LOCK(dnode);
 643                 TMPFS_NODE_LOCK(node);
 644                 KKASSERT(node->tn_dir.tn_parent == dnode);
 645                 dnode->tn_links--;      /* also requires mnt_token protection */
 646                 node->tn_links--;       /* also requires mnt_token protection */
 647                 node->tn_dir.tn_parent = NULL;
 648                 TMPFS_NODE_UNLOCK(node);
 649                 TMPFS_NODE_UNLOCK(dnode);
 650         }
 651 }
 652
 653 /* --------------------------------------------------------------------- */
 654
 655 /*
 656  * Looks for a directory entry in the directory represented by node.
 657  * 'ncp' describes the name of the entry to look for.  Note that the .
 658  * and .. components are not allowed as they do not physically exist
 659  * within directories.
 660  *
 661  * Returns a pointer to the entry when found, otherwise NULL.
 662  */
 663 struct tmpfs_dirent *
 664 tmpfs_dir_lookup(struct tmpfs_node *node, struct tmpfs_node *f,
 665                  struct namecache *ncp)
 666 {
 667         struct tmpfs_dirent *de;
 668         int len = ncp->nc_nlen;
 669         struct tmpfs_dirent wanted;
 670
 671         wanted.td_namelen = len;
 672         wanted.td_name = ncp->nc_name;
 673
 674         TMPFS_VALIDATE_DIR(node);
 675
 676         de = RB_FIND(tmpfs_dirtree, &node->tn_dir.tn_dirtree, &wanted);
 677
 678         KKASSERT(f == NULL || f == de->td_node);
 679
 680         TMPFS_NODE_LOCK(node);
 681         node->tn_status |= TMPFS_NODE_ACCESSED;
 682         TMPFS_NODE_UNLOCK(node);
 683
 684         return de;
 685 }
 686
 687 /* --------------------------------------------------------------------- */
 688
 689 /*
 690  * Helper function for tmpfs_readdir.  Creates a '.' entry for the given
 691  * directory and returns it in the uio space.  The function returns 0
 692  * on success, -1 if there was not enough space in the uio structure to
 693  * hold the directory entry or an appropriate error code if another
 694  * error happens.
 695  */
 696 int
 697 tmpfs_dir_getdotdent(struct tmpfs_node *node, struct uio *uio)
 698 {
 699         int error;
 700         struct dirent dent;
 701         int dirsize;
 702
 703         TMPFS_VALIDATE_DIR(node);
 704         KKASSERT(uio->uio_offset == TMPFS_DIRCOOKIE_DOT);
 705
 706         dent.d_ino = node->tn_id;
 707         dent.d_type = DT_DIR;
 708         dent.d_namlen = 1;
 709         dent.d_name[0] = '.';
 710         dent.d_name[1] = '\0';
 711         dirsize = _DIRENT_DIRSIZ(&dent);
 712
 713         if (dirsize > uio->uio_resid)
 714                 error = -1;
 715         else {
 716                 error = uiomove((caddr_t)&dent, dirsize, uio);
 717                 if (error == 0)
 718                         uio->uio_offset = TMPFS_DIRCOOKIE_DOTDOT;
 719         }
 720
 721         TMPFS_NODE_LOCK(node);
 722         node->tn_status |= TMPFS_NODE_ACCESSED;
 723         TMPFS_NODE_UNLOCK(node);
 724
 725         return error;
 726 }
 727
 728 /* --------------------------------------------------------------------- */
 729
 730 /*
 731  * Helper function for tmpfs_readdir.  Creates a '..' entry for the given
 732  * directory and returns it in the uio space.  The function returns 0
 733  * on success, -1 if there was not enough space in the uio structure to
 734  * hold the directory entry or an appropriate error code if another
 735  * error happens.
 736  */
 737 int
 738 tmpfs_dir_getdotdotdent(struct tmpfs_mount *tmp, struct tmpfs_node *node,
 739                         struct uio *uio)
 740 {
 741         int error;
 742         struct dirent dent;
 743         int dirsize;
 744
 745         TMPFS_VALIDATE_DIR(node);
 746         KKASSERT(uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT);
 747
 748         if (node->tn_dir.tn_parent) {
 749                 TMPFS_NODE_LOCK(node->tn_dir.tn_parent);
 750                 dent.d_ino = node->tn_dir.tn_parent->tn_id;
 751                 TMPFS_NODE_UNLOCK(node->tn_dir.tn_parent);
 752         } else {
 753                 dent.d_ino = tmp->tm_root->tn_id;
 754         }
 755
 756         dent.d_type = DT_DIR;
 757         dent.d_namlen = 2;
 758         dent.d_name[0] = '.';
 759         dent.d_name[1] = '.';
 760         dent.d_name[2] = '\0';
 761         dirsize = _DIRENT_DIRSIZ(&dent);
 762
 763         if (dirsize > uio->uio_resid)
 764                 error = -1;
 765         else {
 766                 error = uiomove((caddr_t)&dent, dirsize, uio);
 767                 if (error == 0) {
 768                         struct tmpfs_dirent *de;
 769
 770                         de = RB_MIN(tmpfs_dirtree, &node->tn_dir.tn_dirtree);
 771                         if (de == NULL)
 772                                 uio->uio_offset = TMPFS_DIRCOOKIE_EOF;
 773                         else
 774                                 uio->uio_offset = tmpfs_dircookie(de);
 775                 }
 776         }
 777
 778         TMPFS_NODE_LOCK(node);
 779         node->tn_status |= TMPFS_NODE_ACCESSED;
 780         TMPFS_NODE_UNLOCK(node);
 781
 782         return error;
 783 }
 784
 785 /* --------------------------------------------------------------------- */
 786
 787 /*
 788  * Lookup a directory entry by its associated cookie.
 789  */
 790 struct tmpfs_dirent *
 791 tmpfs_dir_lookupbycookie(struct tmpfs_node *node, off_t cookie)
 792 {
 793         struct tmpfs_dirent *de;
 794
 795         if (cookie == node->tn_dir.tn_readdir_lastn &&
 796             node->tn_dir.tn_readdir_lastp != NULL) {
 797                 return node->tn_dir.tn_readdir_lastp;
 798         }
 799
 800         RB_FOREACH(de, tmpfs_dirtree, &node->tn_dir.tn_dirtree) {
 801                 if (tmpfs_dircookie(de) == cookie) {
 802                         break;
 803                 }
 804         }
 805
 806         return de;
 807 }
 808
 809 /* --------------------------------------------------------------------- */
 810
 811 /*
 812  * Helper function for tmpfs_readdir.  Returns as much directory entries
 813  * as can fit in the uio space.  The read starts at uio->uio_offset.
 814  * The function returns 0 on success, -1 if there was not enough space
 815  * in the uio structure to hold the directory entry or an appropriate
 816  * error code if another error happens.
 817  */
 818 int
 819 tmpfs_dir_getdents(struct tmpfs_node *node, struct uio *uio, off_t *cntp)
 820 {
 821         int error;
 822         off_t startcookie;
 823         struct tmpfs_dirent *de;
 824
 825         TMPFS_VALIDATE_DIR(node);
 826
 827         /* Locate the first directory entry we have to return.  We have cached
 828          * the last readdir in the node, so use those values if appropriate.
 829          * Otherwise do a linear scan to find the requested entry. */
 830         startcookie = uio->uio_offset;
 831         KKASSERT(startcookie != TMPFS_DIRCOOKIE_DOT);
 832         KKASSERT(startcookie != TMPFS_DIRCOOKIE_DOTDOT);
 833         if (startcookie == TMPFS_DIRCOOKIE_EOF) {
 834                 return 0;
 835         } else {
 836                 de = tmpfs_dir_lookupbycookie(node, startcookie);
 837         }
 838         if (de == NULL) {
 839                 return EINVAL;
 840         }
 841
 842         /* Read as much entries as possible; i.e., until we reach the end of
 843          * the directory or we exhaust uio space. */
 844         do {
 845                 struct dirent d;
 846                 int reclen;
 847
 848                 /* Create a dirent structure representing the current
 849                  * tmpfs_node and fill it. */
 850                 d.d_ino = de->td_node->tn_id;
 851                 switch (de->td_node->tn_type) {
 852                 case VBLK:
 853                         d.d_type = DT_BLK;
 854                         break;
 855
 856                 case VCHR:
 857                         d.d_type = DT_CHR;
 858                         break;
 859
 860                 case VDIR:
 861                         d.d_type = DT_DIR;
 862                         break;
 863
 864                 case VFIFO:
 865                         d.d_type = DT_FIFO;
 866                         break;
 867
 868                 case VLNK:
 869                         d.d_type = DT_LNK;
 870                         break;
 871
 872                 case VREG:
 873                         d.d_type = DT_REG;
 874                         break;
 875
 876                 case VSOCK:
 877                         d.d_type = DT_SOCK;
 878                         break;
 879
 880                 default:
 881                         panic("tmpfs_dir_getdents: type %p %d",
 882                             de->td_node, (int)de->td_node->tn_type);
 883                 }
 884                 d.d_namlen = de->td_namelen;
 885                 KKASSERT(de->td_namelen < sizeof(d.d_name));
 886                 bcopy(de->td_name, d.d_name, d.d_namlen);
 887                 d.d_name[d.d_namlen] = '\0';
 888                 reclen = _DIRENT_RECLEN(d.d_namlen);
 889
 890                 /* Stop reading if the directory entry we are treating is
 891                  * bigger than the amount of data that can be returned. */
 892                 if (reclen > uio->uio_resid) {
 893                         error = -1;
 894                         break;
 895                 }
 896
 897                 /* Copy the new dirent structure into the output buffer and
 898                  * advance pointers. */
 899                 error = uiomove((caddr_t)&d, reclen, uio);
 900
 901                 (*cntp)++;
 902                 de = RB_NEXT(tmpfs_dirtree, node->tn_dir.tn_dirtree, de);
 903         } while (error == 0 && uio->uio_resid > 0 && de != NULL);
 904
 905         /* Update the offset and cache. */
 906         if (de == NULL) {
 907                 uio->uio_offset = TMPFS_DIRCOOKIE_EOF;
 908                 node->tn_dir.tn_readdir_lastn = 0;
 909                 node->tn_dir.tn_readdir_lastp = NULL;
 910         } else {
 911                 node->tn_dir.tn_readdir_lastn = uio->uio_offset = tmpfs_dircookie(de);
 912                 node->tn_dir.tn_readdir_lastp = de;
 913         }
 914         node->tn_status |= TMPFS_NODE_ACCESSED;
 915
 916         return error;
 917 }
 918
 919 /* --------------------------------------------------------------------- */
 920
 921 /*
 922  * Resizes the aobj associated to the regular file pointed to by vp to
 923  * the size newsize.  'vp' must point to a vnode that represents a regular
 924  * file.  'newsize' must be positive.
 925  *
 926  * pass trivial as 1 when buf content will be overwritten, otherwise set 0
 927  * to be zero filled.
 928  *
 929  * Returns zero on success or an appropriate error code on failure.
 930  */
 931 int
 932 tmpfs_reg_resize(struct vnode *vp, off_t newsize, int trivial)
 933 {
 934         int error;
 935         vm_pindex_t newpages, oldpages;
 936         struct tmpfs_mount *tmp;
 937         struct tmpfs_node *node;
 938         off_t oldsize;
 939
 940 #ifdef INVARIANTS
 941         KKASSERT(vp->v_type == VREG);
 942         KKASSERT(newsize >= 0);
 943 #endif
 944
 945         node = VP_TO_TMPFS_NODE(vp);
 946         tmp = VFS_TO_TMPFS(vp->v_mount);
 947
 948         /* Convert the old and new sizes to the number of pages needed to
 949          * store them.  It may happen that we do not need to do anything
 950          * because the last allocated page can accommodate the change on
 951          * its own. */
 952         oldsize = node->tn_size;
 953         oldpages = round_page64(oldsize) / PAGE_SIZE;
 954         KKASSERT(oldpages == node->tn_reg.tn_aobj_pages);
 955         newpages = round_page64(newsize) / PAGE_SIZE;
 956
 957         if (newpages > oldpages &&
 958            tmp->tm_pages_used + newpages - oldpages > tmp->tm_pages_max) {
 959                 error = ENOSPC;
 960                 goto out;
 961         }
 962
 963         TMPFS_LOCK(tmp);
 964         tmp->tm_pages_used += (newpages - oldpages);
 965         TMPFS_UNLOCK(tmp);
 966
 967         TMPFS_NODE_LOCK(node);
 968         node->tn_reg.tn_aobj_pages = newpages;
 969         node->tn_size = newsize;
 970         TMPFS_NODE_UNLOCK(node);
 971
 972         /*
 973          * When adjusting the vnode filesize and its VM object we must
 974          * also adjust our backing VM object (aobj).  The blocksize
 975          * used must match the block sized we use for the buffer cache.
 976          *
 977          * The backing VM object contains no VM pages, only swap
 978          * assignments.
 979          */
 980         if (newsize < oldsize) {
 981                 vm_pindex_t osize;
 982                 vm_pindex_t nsize;
 983                 vm_object_t aobj;
 984
 985                 error = nvtruncbuf(vp, newsize, TMPFS_BLKSIZE, -1, 0);
 986                 aobj = node->tn_reg.tn_aobj;
 987                 if (aobj) {
 988                         osize = aobj->size;
 989                         nsize = vp->v_object->size;
 990                         if (nsize < osize) {
 991                                 aobj->size = osize;
 992                                 swap_pager_freespace(aobj, nsize,
 993                                                      osize - nsize);
 994                         }
 995                 }
 996         } else {
 997                 vm_object_t aobj;
 998
 999                 error = nvextendbuf(vp, oldsize, newsize,
1000                                     TMPFS_BLKSIZE, TMPFS_BLKSIZE,
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         /* Actually change the flags on the node itself */
1036         if (error == 0) {
1037                 TMPFS_NODE_LOCK(node);
1038                 node->tn_flags = flags;
1039                 node->tn_status |= TMPFS_NODE_CHANGED;
1040                 TMPFS_NODE_UNLOCK(node);
1041         }
1042
1043         KKASSERT(vn_islocked(vp));
1044
1045         return error;
1046 }
1047
1048 /* --------------------------------------------------------------------- */
1049
1050 /*
1051  * Change access mode on the given vnode.
1052  * Caller should execute tmpfs_update on vp after a successful execution.
1053  * The vnode must be locked on entry and remain locked on exit.
1054  */
1055 int
1056 tmpfs_chmod(struct vnode *vp, mode_t vamode, struct ucred *cred)
1057 {
1058         struct tmpfs_node *node;
1059         mode_t cur_mode;
1060         int error;
1061
1062         KKASSERT(vn_islocked(vp));
1063
1064         node = VP_TO_TMPFS_NODE(vp);
1065
1066         /* Disallow this operation if the file system is mounted read-only. */
1067         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1068                 return EROFS;
1069
1070         /* Immutable or append-only files cannot be modified, either. */
1071         if (node->tn_flags & (IMMUTABLE | APPEND))
1072                 return EPERM;
1073
1074         cur_mode = node->tn_mode;
1075         error = vop_helper_chmod(vp, vamode, cred, node->tn_uid, node->tn_gid,
1076                                  &cur_mode);
1077
1078         if (error == 0 &&
1079             (node->tn_mode & ALLPERMS) != (cur_mode & ALLPERMS)) {
1080                 TMPFS_NODE_LOCK(node);
1081                 node->tn_mode &= ~ALLPERMS;
1082                 node->tn_mode |= cur_mode & ALLPERMS;
1083
1084                 node->tn_status |= TMPFS_NODE_CHANGED;
1085                 TMPFS_NODE_UNLOCK(node);
1086         }
1087
1088         KKASSERT(vn_islocked(vp));
1089
1090         return 0;
1091 }
1092
1093 /* --------------------------------------------------------------------- */
1094
1095 /*
1096  * Change ownership of the given vnode.  At least one of uid or gid must
1097  * be different than VNOVAL.  If one is set to that value, the attribute
1098  * is unchanged.
1099  * Caller should execute tmpfs_update on vp after a successful execution.
1100  * The vnode must be locked on entry and remain locked on exit.
1101  */
1102 int
1103 tmpfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred)
1104 {
1105         mode_t cur_mode;
1106         uid_t cur_uid;
1107         gid_t cur_gid;
1108         struct tmpfs_node *node;
1109         int error;
1110
1111         KKASSERT(vn_islocked(vp));
1112         node = VP_TO_TMPFS_NODE(vp);
1113
1114         /* Disallow this operation if the file system is mounted read-only. */
1115         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1116                 return EROFS;
1117
1118         /* Immutable or append-only files cannot be modified, either. */
1119         if (node->tn_flags & (IMMUTABLE | APPEND))
1120                 return EPERM;
1121
1122         cur_uid = node->tn_uid;
1123         cur_gid = node->tn_gid;
1124         cur_mode = node->tn_mode;
1125         error = vop_helper_chown(vp, uid, gid, cred,
1126                                  &cur_uid, &cur_gid, &cur_mode);
1127
1128         if (error == 0) {
1129                 TMPFS_NODE_LOCK(node);
1130                 if (cur_uid != node->tn_uid ||
1131                     cur_gid != node->tn_gid ||
1132                     cur_mode != node->tn_mode) {
1133                         node->tn_uid = cur_uid;
1134                         node->tn_gid = cur_gid;
1135                         node->tn_mode = cur_mode;
1136                         node->tn_status |= TMPFS_NODE_CHANGED;
1137                 }
1138                 TMPFS_NODE_UNLOCK(node);
1139         }
1140
1141         return error;
1142 }
1143
1144 /* --------------------------------------------------------------------- */
1145
1146 /*
1147  * Change size of the given vnode.
1148  * Caller should execute tmpfs_update on vp after a successful execution.
1149  * The vnode must be locked on entry and remain locked on exit.
1150  */
1151 int
1152 tmpfs_chsize(struct vnode *vp, u_quad_t size, struct ucred *cred)
1153 {
1154         int error;
1155         struct tmpfs_node *node;
1156
1157         KKASSERT(vn_islocked(vp));
1158
1159         node = VP_TO_TMPFS_NODE(vp);
1160
1161         /* Decide whether this is a valid operation based on the file type. */
1162         error = 0;
1163         switch (vp->v_type) {
1164         case VDIR:
1165                 return EISDIR;
1166
1167         case VREG:
1168                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1169                         return EROFS;
1170                 break;
1171
1172         case VBLK:
1173                 /* FALLTHROUGH */
1174         case VCHR:
1175                 /* FALLTHROUGH */
1176         case VFIFO:
1177                 /* Allow modifications of special files even if in the file
1178                  * system is mounted read-only (we are not modifying the
1179                  * files themselves, but the objects they represent). */
1180                 return 0;
1181
1182         default:
1183                 /* Anything else is unsupported. */
1184                 return EOPNOTSUPP;
1185         }
1186
1187         /* Immutable or append-only files cannot be modified, either. */
1188         if (node->tn_flags & (IMMUTABLE | APPEND))
1189                 return EPERM;
1190
1191         error = tmpfs_truncate(vp, size);
1192         /* tmpfs_truncate will raise the NOTE_EXTEND and NOTE_ATTRIB kevents
1193          * for us, as will update tn_status; no need to do that here. */
1194
1195         KKASSERT(vn_islocked(vp));
1196
1197         return error;
1198 }
1199
1200 /* --------------------------------------------------------------------- */
1201
1202 /*
1203  * Change access and modification times of the given vnode.
1204  * Caller should execute tmpfs_update on vp after a successful execution.
1205  * The vnode must be locked on entry and remain locked on exit.
1206  */
1207 int
1208 tmpfs_chtimes(struct vnode *vp, struct timespec *atime, struct timespec *mtime,
1209               int vaflags, struct ucred *cred)
1210 {
1211         struct tmpfs_node *node;
1212
1213         KKASSERT(vn_islocked(vp));
1214
1215         node = VP_TO_TMPFS_NODE(vp);
1216
1217         /* Disallow this operation if the file system is mounted read-only. */
1218         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1219                 return EROFS;
1220
1221         /* Immutable or append-only files cannot be modified, either. */
1222         if (node->tn_flags & (IMMUTABLE | APPEND))
1223                 return EPERM;
1224
1225         TMPFS_NODE_LOCK(node);
1226         if (atime->tv_sec != VNOVAL && atime->tv_nsec != VNOVAL)
1227                 node->tn_status |= TMPFS_NODE_ACCESSED;
1228
1229         if (mtime->tv_sec != VNOVAL && mtime->tv_nsec != VNOVAL)
1230                 node->tn_status |= TMPFS_NODE_MODIFIED;
1231
1232         TMPFS_NODE_UNLOCK(node);
1233
1234         tmpfs_itimes(vp, atime, mtime);
1235
1236         KKASSERT(vn_islocked(vp));
1237
1238         return 0;
1239 }
1240
1241 /* --------------------------------------------------------------------- */
1242 /* Sync timestamps */
1243 void
1244 tmpfs_itimes(struct vnode *vp, const struct timespec *acc,
1245              const struct timespec *mod)
1246 {
1247         struct tmpfs_node *node;
1248         struct timespec now;
1249
1250         node = VP_TO_TMPFS_NODE(vp);
1251
1252         if ((node->tn_status & (TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
1253             TMPFS_NODE_CHANGED)) == 0)
1254                 return;
1255
1256         vfs_timestamp(&now);
1257
1258         TMPFS_NODE_LOCK(node);
1259         if (node->tn_status & TMPFS_NODE_ACCESSED) {
1260                 if (acc == NULL)
1261                          acc = &now;
1262                 node->tn_atime = acc->tv_sec;
1263                 node->tn_atimensec = acc->tv_nsec;
1264         }
1265         if (node->tn_status & TMPFS_NODE_MODIFIED) {
1266                 if (mod == NULL)
1267                         mod = &now;
1268                 node->tn_mtime = mod->tv_sec;
1269                 node->tn_mtimensec = mod->tv_nsec;
1270         }
1271         if (node->tn_status & TMPFS_NODE_CHANGED) {
1272                 node->tn_ctime = now.tv_sec;
1273                 node->tn_ctimensec = now.tv_nsec;
1274         }
1275         node->tn_status &=
1276             ~(TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED | TMPFS_NODE_CHANGED);
1277         TMPFS_NODE_UNLOCK(node);
1278 }
1279
1280 /* --------------------------------------------------------------------- */
1281
1282 void
1283 tmpfs_update(struct vnode *vp)
1284 {
1285
1286         tmpfs_itimes(vp, NULL, NULL);
1287 }
1288
1289 /* --------------------------------------------------------------------- */
1290
1291 int
1292 tmpfs_truncate(struct vnode *vp, off_t length)
1293 {
1294         int error;
1295         struct tmpfs_node *node;
1296
1297         node = VP_TO_TMPFS_NODE(vp);
1298
1299         if (length < 0) {
1300                 error = EINVAL;
1301                 goto out;
1302         }
1303
1304         if (node->tn_size == length) {
1305                 error = 0;
1306                 goto out;
1307         }
1308
1309         if (length > VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
1310                 return (EFBIG);
1311
1312
1313         error = tmpfs_reg_resize(vp, length, 1);
1314
1315         if (error == 0) {
1316                 TMPFS_NODE_LOCK(node);
1317                 node->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1318                 TMPFS_NODE_UNLOCK(node);
1319         }
1320
1321 out:
1322         tmpfs_update(vp);
1323
1324         return error;
1325 }
1326
1327 /* --------------------------------------------------------------------- */
1328
1329 static ino_t
1330 tmpfs_fetch_ino(struct tmpfs_mount *tmp)
1331 {
1332         ino_t ret;
1333
1334         ret = tmp->tm_ino++;
1335
1336         return (ret);
1337 }
1338
1339 static int
1340 tmpfs_dirtree_compare(struct tmpfs_dirent *a, struct tmpfs_dirent *b)
1341 {
1342         if (a->td_namelen > b->td_namelen)
1343                 return 1;
1344         else if (a->td_namelen < b->td_namelen)
1345                 return -1;
1346         else
1347                 return strncmp(a->td_name, b->td_name, a->td_namelen);
1348 }