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