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