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