1 /* $NetBSD: tmpfs_subr.c,v 1.117 2023/04/29 08:15:13 riastradh Exp $ */ 2 3 /* 4 * Copyright (c) 2005-2020 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, and by Mindaugas Rasiukevicius. 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: interfaces for inode and directory entry 35 * construction, destruction and manipulation. 36 * 37 * Reference counting 38 * 39 * The link count of inode (tmpfs_node_t::tn_links) is used as a 40 * reference counter. However, it has slightly different semantics. 41 * 42 * For directories - link count represents directory entries, which 43 * refer to the directories. In other words, it represents the count 44 * of sub-directories. It also takes into account the virtual '.' 45 * entry (which has no real entry in the list). For files - link count 46 * represents the hard links. Since only empty directories can be 47 * removed - link count aligns the reference counting requirements 48 * enough. Note: to check whether directory is not empty, the inode 49 * size (tmpfs_node_t::tn_size) can be used. 50 * 51 * The inode itself, as an object, gathers its first reference when 52 * directory entry is attached via tmpfs_dir_attach(9). For instance, 53 * after regular tmpfs_create(), a file would have a link count of 1, 54 * while directory after tmpfs_mkdir() would have 2 (due to '.'). 55 * 56 * Reclamation 57 * 58 * It should be noted that tmpfs inodes rely on a combination of vnode 59 * reference counting and link counting. That is, an inode can only be 60 * destroyed if its associated vnode is inactive. The destruction is 61 * done on vnode reclamation i.e. tmpfs_reclaim(). It should be noted 62 * that tmpfs_node_t::tn_links being 0 is a destruction criterion. 63 * 64 * If an inode has references within the file system (tn_links > 0) and 65 * its inactive vnode gets reclaimed/recycled - then the association is 66 * broken in tmpfs_reclaim(). In such case, an inode will always pass 67 * tmpfs_lookup() and thus vcache_get() to associate a new vnode. 68 * 69 * Lock order 70 * 71 * vnode_t::v_vlock -> 72 * vnode_t::v_interlock 73 */ 74 75 #include <sys/cdefs.h> 76 __KERNEL_RCSID(0, "$NetBSD: tmpfs_subr.c,v 1.117 2023/04/29 08:15:13 riastradh Exp $"); 77 78 #include <sys/param.h> 79 #include <sys/cprng.h> 80 #include <sys/dirent.h> 81 #include <sys/event.h> 82 #include <sys/kmem.h> 83 #include <sys/mount.h> 84 #include <sys/namei.h> 85 #include <sys/time.h> 86 #include <sys/stat.h> 87 #include <sys/systm.h> 88 #include <sys/vnode.h> 89 #include <sys/kauth.h> 90 #include <sys/atomic.h> 91 92 #include <uvm/uvm_aobj.h> 93 #include <uvm/uvm_extern.h> 94 #include <uvm/uvm_object.h> 95 96 #include <miscfs/specfs/specdev.h> 97 #include <miscfs/genfs/genfs.h> 98 #include <fs/tmpfs/tmpfs.h> 99 #include <fs/tmpfs/tmpfs_fifoops.h> 100 #include <fs/tmpfs/tmpfs_specops.h> 101 #include <fs/tmpfs/tmpfs_vnops.h> 102 103 static void tmpfs_dir_putseq(tmpfs_node_t *, tmpfs_dirent_t *); 104 105 /* 106 * Initialize vnode with tmpfs node. 107 */ 108 static void 109 tmpfs_init_vnode(struct vnode *vp, tmpfs_node_t *node) 110 { 111 krwlock_t *slock; 112 113 KASSERT(node->tn_vnode == NULL); 114 115 /* Share the interlock with the node. */ 116 if (node->tn_type == VREG) { 117 slock = node->tn_spec.tn_reg.tn_aobj->vmobjlock; 118 rw_obj_hold(slock); 119 uvm_obj_setlock(&vp->v_uobj, slock); 120 } 121 122 vp->v_tag = VT_TMPFS; 123 vp->v_type = node->tn_type; 124 125 /* Type-specific initialization. */ 126 switch (vp->v_type) { 127 case VBLK: 128 case VCHR: 129 vp->v_op = tmpfs_specop_p; 130 spec_node_init(vp, node->tn_spec.tn_dev.tn_rdev); 131 break; 132 case VFIFO: 133 vp->v_op = tmpfs_fifoop_p; 134 break; 135 case VDIR: 136 if (node->tn_spec.tn_dir.tn_parent == node) 137 vp->v_vflag |= VV_ROOT; 138 /* FALLTHROUGH */ 139 case VLNK: 140 case VREG: 141 case VSOCK: 142 vp->v_op = tmpfs_vnodeop_p; 143 break; 144 default: 145 panic("bad node type %d", vp->v_type); 146 break; 147 } 148 149 vp->v_data = node; 150 node->tn_vnode = vp; 151 uvm_vnp_setsize(vp, node->tn_size); 152 KASSERT(node->tn_mode != VNOVAL); 153 cache_enter_id(vp, node->tn_mode, node->tn_uid, node->tn_gid, true); 154 } 155 156 /* 157 * tmpfs_loadvnode: initialise a vnode for a specified inode. 158 */ 159 int 160 tmpfs_loadvnode(struct mount *mp, struct vnode *vp, 161 const void *key, size_t key_len, const void **new_key) 162 { 163 tmpfs_node_t *node; 164 165 KASSERT(key_len == sizeof(node)); 166 memcpy(&node, key, key_len); 167 168 if (node->tn_links == 0) 169 return ENOENT; 170 171 tmpfs_init_vnode(vp, node); 172 173 *new_key = &vp->v_data; 174 175 return 0; 176 } 177 178 /* 179 * tmpfs_newvnode: allocate a new inode of a specified type and 180 * attach the vonode. 181 */ 182 int 183 tmpfs_newvnode(struct mount *mp, struct vnode *dvp, struct vnode *vp, 184 struct vattr *vap, kauth_cred_t cred, void *extra, 185 size_t *key_len, const void **new_key) 186 { 187 tmpfs_mount_t *tmp = VFS_TO_TMPFS(mp); 188 tmpfs_node_t *node, *dnode; 189 190 if (dvp != NULL) { 191 KASSERT(VOP_ISLOCKED(dvp)); 192 dnode = VP_TO_TMPFS_DIR(dvp); 193 if (dnode->tn_links == 0) 194 return ENOENT; 195 if (vap->va_type == VDIR) { 196 /* Check for maximum links limit. */ 197 if (dnode->tn_links == LINK_MAX) 198 return EMLINK; 199 KASSERT(dnode->tn_links < LINK_MAX); 200 } 201 } else 202 dnode = NULL; 203 204 node = tmpfs_node_get(tmp); 205 if (node == NULL) 206 return ENOSPC; 207 208 /* Initially, no references and no associations. */ 209 node->tn_links = 0; 210 node->tn_vnode = NULL; 211 node->tn_holdcount = 0; 212 node->tn_dirent_hint = NULL; 213 214 /* 215 * XXX Where the pool is backed by a map larger than (4GB * 216 * sizeof(*node)), this may produce duplicate inode numbers 217 * for applications that do not understand 64-bit ino_t. 218 */ 219 node->tn_id = (ino_t)((uintptr_t)node / sizeof(*node)); 220 /* 221 * Make sure the generation number is not zero. 222 * tmpfs_inactive() uses generation zero to mark dead nodes. 223 */ 224 do { 225 node->tn_gen = TMPFS_NODE_GEN_MASK & cprng_fast32(); 226 } while (node->tn_gen == 0); 227 228 /* Generic initialization. */ 229 KASSERT((int)vap->va_type != VNOVAL); 230 node->tn_type = vap->va_type; 231 node->tn_size = 0; 232 node->tn_flags = 0; 233 node->tn_lockf = NULL; 234 235 node->tn_tflags = 0; 236 vfs_timestamp(&node->tn_atime); 237 node->tn_birthtime = node->tn_atime; 238 node->tn_ctime = node->tn_atime; 239 node->tn_mtime = node->tn_atime; 240 mutex_init(&node->tn_timelock, MUTEX_DEFAULT, IPL_NONE); 241 242 if (dvp == NULL) { 243 KASSERT(vap->va_uid != VNOVAL && vap->va_gid != VNOVAL); 244 node->tn_uid = vap->va_uid; 245 node->tn_gid = vap->va_gid; 246 vp->v_vflag |= VV_ROOT; 247 } else { 248 KASSERT(dnode != NULL); 249 node->tn_uid = kauth_cred_geteuid(cred); 250 node->tn_gid = dnode->tn_gid; 251 } 252 KASSERT(vap->va_mode != VNOVAL); 253 node->tn_mode = vap->va_mode; 254 255 /* Type-specific initialization. */ 256 switch (node->tn_type) { 257 case VBLK: 258 case VCHR: 259 /* Character/block special device. */ 260 KASSERT(vap->va_rdev != VNOVAL); 261 node->tn_spec.tn_dev.tn_rdev = vap->va_rdev; 262 break; 263 case VDIR: 264 /* Directory. */ 265 TAILQ_INIT(&node->tn_spec.tn_dir.tn_dir); 266 node->tn_spec.tn_dir.tn_parent = NULL; 267 node->tn_spec.tn_dir.tn_seq_arena = NULL; 268 node->tn_spec.tn_dir.tn_next_seq = TMPFS_DIRSEQ_START; 269 node->tn_spec.tn_dir.tn_readdir_lastp = NULL; 270 271 /* Extra link count for the virtual '.' entry. */ 272 node->tn_links++; 273 break; 274 case VFIFO: 275 case VSOCK: 276 break; 277 case VLNK: 278 node->tn_size = 0; 279 node->tn_spec.tn_lnk.tn_link = NULL; 280 break; 281 case VREG: 282 /* Regular file. Create an underlying UVM object. */ 283 node->tn_spec.tn_reg.tn_aobj = 284 uao_create(INT64_MAX - PAGE_SIZE, 0); 285 node->tn_spec.tn_reg.tn_aobj_pages = 0; 286 break; 287 default: 288 panic("bad node type %d", vp->v_type); 289 break; 290 } 291 292 tmpfs_init_vnode(vp, node); 293 294 mutex_enter(&tmp->tm_lock); 295 LIST_INSERT_HEAD(&tmp->tm_nodes, node, tn_entries); 296 mutex_exit(&tmp->tm_lock); 297 298 *key_len = sizeof(vp->v_data); 299 *new_key = &vp->v_data; 300 301 return 0; 302 } 303 304 /* 305 * tmpfs_free_node: remove the inode from a list in the mount point and 306 * destroy the inode structures. 307 */ 308 void 309 tmpfs_free_node(tmpfs_mount_t *tmp, tmpfs_node_t *node) 310 { 311 size_t objsz; 312 uint32_t hold; 313 314 mutex_enter(&tmp->tm_lock); 315 hold = atomic_or_32_nv(&node->tn_holdcount, TMPFS_NODE_RECLAIMED); 316 /* Defer destruction to last thread holding this node. */ 317 if (hold != TMPFS_NODE_RECLAIMED) { 318 mutex_exit(&tmp->tm_lock); 319 return; 320 } 321 LIST_REMOVE(node, tn_entries); 322 mutex_exit(&tmp->tm_lock); 323 324 switch (node->tn_type) { 325 case VLNK: 326 if (node->tn_size > 0) { 327 tmpfs_strname_free(tmp, node->tn_spec.tn_lnk.tn_link, 328 node->tn_size); 329 } 330 break; 331 case VREG: 332 /* 333 * Calculate the size of inode data, decrease the used-memory 334 * counter, and destroy the unerlying UVM object (if any). 335 */ 336 objsz = PAGE_SIZE * node->tn_spec.tn_reg.tn_aobj_pages; 337 if (objsz != 0) { 338 tmpfs_mem_decr(tmp, objsz); 339 } 340 if (node->tn_spec.tn_reg.tn_aobj != NULL) { 341 uao_detach(node->tn_spec.tn_reg.tn_aobj); 342 } 343 break; 344 case VDIR: 345 KASSERT(node->tn_size == 0); 346 KASSERT(node->tn_spec.tn_dir.tn_seq_arena == NULL); 347 KASSERT(TAILQ_EMPTY(&node->tn_spec.tn_dir.tn_dir)); 348 KASSERT(node->tn_spec.tn_dir.tn_parent == NULL || 349 node == tmp->tm_root); 350 break; 351 default: 352 break; 353 } 354 KASSERT(node->tn_vnode == NULL); 355 KASSERT(node->tn_links == 0); 356 357 mutex_destroy(&node->tn_timelock); 358 tmpfs_node_put(tmp, node); 359 } 360 361 /* 362 * tmpfs_construct_node: allocate a new file of specified type and adds it 363 * into the parent directory. 364 * 365 * => Credentials of the caller are used. 366 */ 367 int 368 tmpfs_construct_node(vnode_t *dvp, vnode_t **vpp, struct vattr *vap, 369 struct componentname *cnp, char *target) 370 { 371 tmpfs_mount_t *tmp = VFS_TO_TMPFS(dvp->v_mount); 372 tmpfs_node_t *dnode = VP_TO_TMPFS_DIR(dvp), *node; 373 tmpfs_dirent_t *de, *wde; 374 char *slink = NULL; 375 int ssize = 0; 376 int error; 377 378 /* Allocate symlink target. */ 379 if (target != NULL) { 380 KASSERT(vap->va_type == VLNK); 381 ssize = strlen(target); 382 KASSERT(ssize < MAXPATHLEN); 383 if (ssize > 0) { 384 slink = tmpfs_strname_alloc(tmp, ssize); 385 if (slink == NULL) 386 return ENOSPC; 387 memcpy(slink, target, ssize); 388 } 389 } 390 391 /* Allocate a directory entry that points to the new file. */ 392 error = tmpfs_alloc_dirent(tmp, cnp->cn_nameptr, cnp->cn_namelen, &de); 393 if (error) { 394 if (slink != NULL) 395 tmpfs_strname_free(tmp, slink, ssize); 396 return error; 397 } 398 399 /* Allocate a vnode that represents the new file. */ 400 error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, NULL, vpp); 401 if (error) { 402 if (slink != NULL) 403 tmpfs_strname_free(tmp, slink, ssize); 404 tmpfs_free_dirent(tmp, de); 405 return error; 406 } 407 error = vn_lock(*vpp, LK_EXCLUSIVE); 408 if (error) { 409 vrele(*vpp); 410 *vpp = NULL; 411 if (slink != NULL) 412 tmpfs_strname_free(tmp, slink, ssize); 413 tmpfs_free_dirent(tmp, de); 414 return error; 415 } 416 417 node = VP_TO_TMPFS_NODE(*vpp); 418 419 if (slink != NULL) { 420 node->tn_spec.tn_lnk.tn_link = slink; 421 node->tn_size = ssize; 422 } 423 424 /* Remove whiteout before adding the new entry. */ 425 if (cnp->cn_flags & ISWHITEOUT) { 426 wde = tmpfs_dir_lookup(dnode, cnp); 427 KASSERT(wde != NULL && wde->td_node == TMPFS_NODE_WHITEOUT); 428 tmpfs_dir_detach(dnode, wde); 429 tmpfs_free_dirent(tmp, wde); 430 } 431 432 /* Associate inode and attach the entry into the directory. */ 433 tmpfs_dir_attach(dnode, de, node); 434 435 /* Make node opaque if requested. */ 436 if (cnp->cn_flags & ISWHITEOUT) 437 node->tn_flags |= UF_OPAQUE; 438 439 /* Update the parent's timestamps. */ 440 tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 441 442 VOP_UNLOCK(*vpp); 443 444 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags); 445 return 0; 446 } 447 448 /* 449 * tmpfs_alloc_dirent: allocates a new directory entry for the inode. 450 * The directory entry contains a path name component. 451 */ 452 int 453 tmpfs_alloc_dirent(tmpfs_mount_t *tmp, const char *name, uint16_t len, 454 tmpfs_dirent_t **de) 455 { 456 tmpfs_dirent_t *nde; 457 458 nde = tmpfs_dirent_get(tmp); 459 if (nde == NULL) 460 return ENOSPC; 461 462 nde->td_name = tmpfs_strname_alloc(tmp, len); 463 if (nde->td_name == NULL) { 464 tmpfs_dirent_put(tmp, nde); 465 return ENOSPC; 466 } 467 nde->td_namelen = len; 468 memcpy(nde->td_name, name, len); 469 nde->td_seq = TMPFS_DIRSEQ_NONE; 470 nde->td_node = NULL; /* for asserts */ 471 472 *de = nde; 473 return 0; 474 } 475 476 /* 477 * tmpfs_free_dirent: free a directory entry. 478 */ 479 void 480 tmpfs_free_dirent(tmpfs_mount_t *tmp, tmpfs_dirent_t *de) 481 { 482 KASSERT(de->td_node == NULL); 483 KASSERT(de->td_seq == TMPFS_DIRSEQ_NONE); 484 tmpfs_strname_free(tmp, de->td_name, de->td_namelen); 485 tmpfs_dirent_put(tmp, de); 486 } 487 488 /* 489 * tmpfs_dir_attach: associate directory entry with a specified inode, 490 * and attach the entry into the directory, specified by vnode. 491 * 492 * => Increases link count on the associated node. 493 * => Increases link count on directory node if our node is VDIR. 494 * => It is caller's responsibility to check for the LINK_MAX limit. 495 * => Triggers kqueue events here. 496 */ 497 void 498 tmpfs_dir_attach(tmpfs_node_t *dnode, tmpfs_dirent_t *de, tmpfs_node_t *node) 499 { 500 vnode_t *dvp = dnode->tn_vnode; 501 int events = NOTE_WRITE; 502 503 KASSERT(dvp != NULL); 504 KASSERT(VOP_ISLOCKED(dvp)); 505 506 /* Get a new sequence number. */ 507 KASSERT(de->td_seq == TMPFS_DIRSEQ_NONE); 508 de->td_seq = tmpfs_dir_getseq(dnode, de); 509 510 /* Associate directory entry and the inode. */ 511 de->td_node = node; 512 if (node != TMPFS_NODE_WHITEOUT) { 513 KASSERT(node->tn_links < LINK_MAX); 514 node->tn_links++; 515 516 /* Save the hint (might overwrite). */ 517 node->tn_dirent_hint = de; 518 } else if ((dnode->tn_gen & TMPFS_WHITEOUT_BIT) == 0) { 519 /* Flag that there are whiteout entries. */ 520 atomic_or_32(&dnode->tn_gen, TMPFS_WHITEOUT_BIT); 521 } 522 523 /* Insert the entry to the directory (parent of inode). */ 524 TAILQ_INSERT_TAIL(&dnode->tn_spec.tn_dir.tn_dir, de, td_entries); 525 KASSERT(dnode->tn_size <= __type_max(off_t) - sizeof(tmpfs_dirent_t)); 526 dnode->tn_size += sizeof(tmpfs_dirent_t); 527 uvm_vnp_setsize(dvp, dnode->tn_size); 528 529 if (node != TMPFS_NODE_WHITEOUT && node->tn_type == VDIR) { 530 /* Set parent. */ 531 KASSERT(node->tn_spec.tn_dir.tn_parent == NULL); 532 node->tn_spec.tn_dir.tn_parent = dnode; 533 534 /* Increase the link count of parent. */ 535 KASSERT(dnode->tn_links < LINK_MAX); 536 dnode->tn_links++; 537 events |= NOTE_LINK; 538 539 TMPFS_VALIDATE_DIR(node); 540 } 541 } 542 543 /* 544 * tmpfs_dir_detach: disassociate directory entry and its inode, 545 * and detach the entry from the directory, specified by vnode. 546 * 547 * => Decreases link count on the associated node. 548 * => Decreases the link count on directory node, if our node is VDIR. 549 * => Triggers kqueue events here. 550 * 551 * => Note: dvp and vp may be NULL only if called by tmpfs_unmount(). 552 */ 553 void 554 tmpfs_dir_detach(tmpfs_node_t *dnode, tmpfs_dirent_t *de) 555 { 556 tmpfs_node_t *node = de->td_node; 557 vnode_t *dvp = dnode->tn_vnode; 558 559 KASSERT(dvp == NULL || VOP_ISLOCKED(dvp)); 560 561 if (__predict_true(node != TMPFS_NODE_WHITEOUT)) { 562 /* Deassociate the inode and entry. */ 563 node->tn_dirent_hint = NULL; 564 565 KASSERT(node->tn_links > 0); 566 node->tn_links--; 567 568 /* If directory - decrease the link count of parent. */ 569 if (node->tn_type == VDIR) { 570 KASSERT(node->tn_spec.tn_dir.tn_parent == dnode); 571 node->tn_spec.tn_dir.tn_parent = NULL; 572 573 KASSERT(dnode->tn_links > 0); 574 dnode->tn_links--; 575 } 576 } 577 de->td_node = NULL; 578 579 /* Remove the entry from the directory. */ 580 if (dnode->tn_spec.tn_dir.tn_readdir_lastp == de) { 581 dnode->tn_spec.tn_dir.tn_readdir_lastp = NULL; 582 } 583 TAILQ_REMOVE(&dnode->tn_spec.tn_dir.tn_dir, de, td_entries); 584 KASSERT(dnode->tn_size >= sizeof(tmpfs_dirent_t)); 585 dnode->tn_size -= sizeof(tmpfs_dirent_t); 586 tmpfs_dir_putseq(dnode, de); 587 588 if (dvp) { 589 uvm_vnp_setsize(dvp, dnode->tn_size); 590 } 591 } 592 593 /* 594 * tmpfs_dir_lookup: find a directory entry in the specified inode. 595 * 596 * Note that the . and .. components are not allowed as they do not 597 * physically exist within directories. 598 */ 599 tmpfs_dirent_t * 600 tmpfs_dir_lookup(tmpfs_node_t *node, struct componentname *cnp) 601 { 602 const char *name = cnp->cn_nameptr; 603 const uint16_t nlen = cnp->cn_namelen; 604 tmpfs_dirent_t *de; 605 606 KASSERT(VOP_ISLOCKED(node->tn_vnode)); 607 KASSERT(nlen != 1 || !(name[0] == '.')); 608 KASSERT(nlen != 2 || !(name[0] == '.' && name[1] == '.')); 609 TMPFS_VALIDATE_DIR(node); 610 611 TAILQ_FOREACH(de, &node->tn_spec.tn_dir.tn_dir, td_entries) { 612 if (de->td_namelen != nlen) 613 continue; 614 if (memcmp(de->td_name, name, nlen) != 0) 615 continue; 616 break; 617 } 618 return de; 619 } 620 621 /* 622 * tmpfs_dir_cached: get a cached directory entry if it is valid. Used to 623 * avoid unnecessary tmpfs_dir_lookup(). 624 * 625 * => The vnode must be locked. 626 */ 627 tmpfs_dirent_t * 628 tmpfs_dir_cached(tmpfs_node_t *node) 629 { 630 tmpfs_dirent_t *de = node->tn_dirent_hint; 631 632 KASSERT(VOP_ISLOCKED(node->tn_vnode)); 633 634 if (de == NULL) { 635 return NULL; 636 } 637 KASSERT(de->td_node == node); 638 639 /* 640 * Directories always have a valid hint. For files, check if there 641 * are any hard links. If there are - hint might be invalid. 642 */ 643 return (node->tn_type != VDIR && node->tn_links > 1) ? NULL : de; 644 } 645 646 /* 647 * tmpfs_dir_getseq: get a per-directory sequence number for the entry. 648 * 649 * => Shall not be larger than 2^31 for linux32 compatibility. 650 */ 651 uint32_t 652 tmpfs_dir_getseq(tmpfs_node_t *dnode, tmpfs_dirent_t *de) 653 { 654 uint32_t seq = de->td_seq; 655 vmem_t *seq_arena; 656 vmem_addr_t off; 657 int error __diagused; 658 659 TMPFS_VALIDATE_DIR(dnode); 660 661 if (__predict_true(seq != TMPFS_DIRSEQ_NONE)) { 662 /* Already set. */ 663 KASSERT(seq >= TMPFS_DIRSEQ_START); 664 return seq; 665 } 666 667 /* 668 * The "." and ".." and the end-of-directory have reserved numbers. 669 * The other sequence numbers are allocated as following: 670 * 671 * - The first half of the 2^31 is assigned incrementally. 672 * 673 * - If that range is exceeded, then the second half of 2^31 674 * is used, but managed by vmem(9). 675 */ 676 677 seq = dnode->tn_spec.tn_dir.tn_next_seq; 678 KASSERT(seq >= TMPFS_DIRSEQ_START); 679 680 if (__predict_true(seq < TMPFS_DIRSEQ_END)) { 681 /* First half: just increment and return. */ 682 dnode->tn_spec.tn_dir.tn_next_seq++; 683 return seq; 684 } 685 686 /* 687 * First half exceeded, use the second half. May need to create 688 * vmem(9) arena for the directory first. 689 */ 690 if ((seq_arena = dnode->tn_spec.tn_dir.tn_seq_arena) == NULL) { 691 seq_arena = vmem_create("tmpfscoo", 0, 692 TMPFS_DIRSEQ_END - 1, 1, NULL, NULL, NULL, 0, 693 VM_SLEEP, IPL_NONE); 694 dnode->tn_spec.tn_dir.tn_seq_arena = seq_arena; 695 KASSERT(seq_arena != NULL); 696 } 697 error = vmem_alloc(seq_arena, 1, VM_SLEEP | VM_BESTFIT, &off); 698 KASSERT(error == 0); 699 700 KASSERT(off < TMPFS_DIRSEQ_END); 701 seq = off | TMPFS_DIRSEQ_END; 702 return seq; 703 } 704 705 static void 706 tmpfs_dir_putseq(tmpfs_node_t *dnode, tmpfs_dirent_t *de) 707 { 708 vmem_t *seq_arena = dnode->tn_spec.tn_dir.tn_seq_arena; 709 uint32_t seq = de->td_seq; 710 711 TMPFS_VALIDATE_DIR(dnode); 712 713 if (seq == TMPFS_DIRSEQ_NONE || seq < TMPFS_DIRSEQ_END) { 714 /* First half (or no sequence number set yet). */ 715 KASSERT(de->td_seq >= TMPFS_DIRSEQ_START); 716 } else { 717 /* Second half. */ 718 KASSERT(seq_arena != NULL); 719 KASSERT(seq >= TMPFS_DIRSEQ_END); 720 seq &= ~TMPFS_DIRSEQ_END; 721 vmem_free(seq_arena, seq, 1); 722 } 723 de->td_seq = TMPFS_DIRSEQ_NONE; 724 725 /* Empty? We can reset. */ 726 if (seq_arena && dnode->tn_size == 0) { 727 dnode->tn_spec.tn_dir.tn_seq_arena = NULL; 728 dnode->tn_spec.tn_dir.tn_next_seq = TMPFS_DIRSEQ_START; 729 vmem_destroy(seq_arena); 730 } 731 } 732 733 /* 734 * tmpfs_dir_lookupbyseq: lookup a directory entry by the sequence number. 735 */ 736 tmpfs_dirent_t * 737 tmpfs_dir_lookupbyseq(tmpfs_node_t *node, off_t seq) 738 { 739 tmpfs_dirent_t *de = node->tn_spec.tn_dir.tn_readdir_lastp; 740 741 TMPFS_VALIDATE_DIR(node); 742 743 /* 744 * First, check the cache. If does not match - perform a lookup. 745 */ 746 if (de && de->td_seq == seq) { 747 KASSERT(de->td_seq >= TMPFS_DIRSEQ_START); 748 KASSERT(de->td_seq != TMPFS_DIRSEQ_NONE); 749 return de; 750 } 751 TAILQ_FOREACH(de, &node->tn_spec.tn_dir.tn_dir, td_entries) { 752 KASSERT(de->td_seq >= TMPFS_DIRSEQ_START); 753 KASSERT(de->td_seq != TMPFS_DIRSEQ_NONE); 754 if (de->td_seq == seq) 755 return de; 756 } 757 return NULL; 758 } 759 760 /* 761 * tmpfs_dir_getdotents: helper function for tmpfs_readdir() to get the 762 * dot meta entries, that is, "." or "..". Copy it to the UIO space. 763 */ 764 static int 765 tmpfs_dir_getdotents(tmpfs_node_t *node, struct dirent *dp, struct uio *uio) 766 { 767 tmpfs_dirent_t *de; 768 off_t next = 0; 769 int error; 770 771 switch (uio->uio_offset) { 772 case TMPFS_DIRSEQ_DOT: 773 dp->d_fileno = node->tn_id; 774 strlcpy(dp->d_name, ".", sizeof(dp->d_name)); 775 next = TMPFS_DIRSEQ_DOTDOT; 776 break; 777 case TMPFS_DIRSEQ_DOTDOT: 778 dp->d_fileno = node->tn_spec.tn_dir.tn_parent->tn_id; 779 strlcpy(dp->d_name, "..", sizeof(dp->d_name)); 780 de = TAILQ_FIRST(&node->tn_spec.tn_dir.tn_dir); 781 next = de ? tmpfs_dir_getseq(node, de) : TMPFS_DIRSEQ_EOF; 782 break; 783 default: 784 KASSERT(false); 785 } 786 dp->d_type = DT_DIR; 787 dp->d_namlen = strlen(dp->d_name); 788 dp->d_reclen = _DIRENT_SIZE(dp); 789 790 if (dp->d_reclen > uio->uio_resid) { 791 return EJUSTRETURN; 792 } 793 if ((error = uiomove(dp, dp->d_reclen, uio)) != 0) { 794 return error; 795 } 796 797 uio->uio_offset = next; 798 return error; 799 } 800 801 /* 802 * tmpfs_dir_getdents: helper function for tmpfs_readdir. 803 * 804 * => Returns as much directory entries as can fit in the uio space. 805 * => The read starts at uio->uio_offset. 806 */ 807 int 808 tmpfs_dir_getdents(tmpfs_node_t *node, struct uio *uio, off_t *cntp) 809 { 810 tmpfs_dirent_t *de; 811 struct dirent dent; 812 int error = 0; 813 814 KASSERT(VOP_ISLOCKED(node->tn_vnode)); 815 TMPFS_VALIDATE_DIR(node); 816 817 /* 818 * First check for the "." and ".." cases. 819 * Note: tmpfs_dir_getdotents() will "seek" for us. 820 */ 821 memset(&dent, 0, sizeof(dent)); 822 823 if (uio->uio_offset == TMPFS_DIRSEQ_DOT) { 824 if ((error = tmpfs_dir_getdotents(node, &dent, uio)) != 0) { 825 goto done; 826 } 827 (*cntp)++; 828 } 829 if (uio->uio_offset == TMPFS_DIRSEQ_DOTDOT) { 830 if ((error = tmpfs_dir_getdotents(node, &dent, uio)) != 0) { 831 goto done; 832 } 833 (*cntp)++; 834 } 835 836 /* Done if we reached the end. */ 837 if (uio->uio_offset == TMPFS_DIRSEQ_EOF) { 838 goto done; 839 } 840 841 /* Locate the directory entry given by the given sequence number. */ 842 de = tmpfs_dir_lookupbyseq(node, uio->uio_offset); 843 if (de == NULL) { 844 error = EINVAL; 845 goto done; 846 } 847 848 /* 849 * Read as many entries as possible; i.e., until we reach the end 850 * of the directory or we exhaust UIO space. 851 */ 852 do { 853 if (de->td_node == TMPFS_NODE_WHITEOUT) { 854 dent.d_fileno = 1; 855 dent.d_type = DT_WHT; 856 } else { 857 dent.d_fileno = de->td_node->tn_id; 858 dent.d_type = vtype2dt(de->td_node->tn_type); 859 } 860 dent.d_namlen = de->td_namelen; 861 KASSERT(de->td_namelen < sizeof(dent.d_name)); 862 memcpy(dent.d_name, de->td_name, de->td_namelen); 863 dent.d_name[de->td_namelen] = '\0'; 864 dent.d_reclen = _DIRENT_SIZE(&dent); 865 866 if (dent.d_reclen > uio->uio_resid) { 867 /* Exhausted UIO space. */ 868 error = EJUSTRETURN; 869 break; 870 } 871 872 /* Copy out the directory entry and continue. */ 873 error = uiomove(&dent, dent.d_reclen, uio); 874 if (error) { 875 break; 876 } 877 (*cntp)++; 878 de = TAILQ_NEXT(de, td_entries); 879 880 } while (uio->uio_resid > 0 && de); 881 882 /* Cache the last entry or clear and mark EOF. */ 883 uio->uio_offset = de ? tmpfs_dir_getseq(node, de) : TMPFS_DIRSEQ_EOF; 884 node->tn_spec.tn_dir.tn_readdir_lastp = de; 885 done: 886 tmpfs_update(node->tn_vnode, TMPFS_UPDATE_ATIME); 887 888 if (error == EJUSTRETURN) { 889 /* Exhausted UIO space - just return. */ 890 error = 0; 891 } 892 KASSERT(error >= 0); 893 return error; 894 } 895 896 /* 897 * tmpfs_reg_resize: resize the underlying UVM object associated with the 898 * specified regular file. 899 */ 900 int 901 tmpfs_reg_resize(struct vnode *vp, off_t newsize) 902 { 903 tmpfs_mount_t *tmp = VFS_TO_TMPFS(vp->v_mount); 904 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 905 struct uvm_object *uobj = node->tn_spec.tn_reg.tn_aobj; 906 size_t newpages, oldpages; 907 off_t oldsize; 908 909 KASSERT(vp->v_type == VREG); 910 KASSERT(newsize >= 0); 911 912 if (newsize > __type_max(off_t) - PAGE_SIZE + 1) 913 return EFBIG; 914 915 oldsize = node->tn_size; 916 oldpages = round_page(oldsize) >> PAGE_SHIFT; 917 newpages = round_page(newsize) >> PAGE_SHIFT; 918 KASSERT(oldpages == node->tn_spec.tn_reg.tn_aobj_pages); 919 920 if (newsize == oldsize) { 921 return 0; 922 } 923 924 if (newpages > oldpages) { 925 /* Increase the used-memory counter if getting extra pages. */ 926 if (!tmpfs_mem_incr(tmp, (newpages - oldpages) << PAGE_SHIFT)) { 927 return ENOSPC; 928 } 929 } else if (newsize < oldsize) { 930 size_t zerolen; 931 932 zerolen = MIN(round_page(newsize), node->tn_size) - newsize; 933 ubc_zerorange(uobj, newsize, zerolen, UBC_VNODE_FLAGS(vp)); 934 } 935 936 node->tn_spec.tn_reg.tn_aobj_pages = newpages; 937 node->tn_size = newsize; 938 uvm_vnp_setsize(vp, newsize); 939 940 /* 941 * Free "backing store". 942 */ 943 if (newpages < oldpages) { 944 rw_enter(uobj->vmobjlock, RW_WRITER); 945 uao_dropswap_range(uobj, newpages, oldpages); 946 rw_exit(uobj->vmobjlock); 947 948 /* Decrease the used-memory counter. */ 949 tmpfs_mem_decr(tmp, (oldpages - newpages) << PAGE_SHIFT); 950 } 951 return 0; 952 } 953 954 /* 955 * tmpfs_chflags: change flags of the given vnode. 956 */ 957 int 958 tmpfs_chflags(vnode_t *vp, int flags, kauth_cred_t cred, lwp_t *l) 959 { 960 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 961 kauth_action_t action = KAUTH_VNODE_WRITE_FLAGS; 962 int error; 963 bool changing_sysflags = false; 964 965 KASSERT(VOP_ISLOCKED(vp)); 966 967 /* Disallow this operation if the file system is mounted read-only. */ 968 if (vp->v_mount->mnt_flag & MNT_RDONLY) 969 return EROFS; 970 971 /* 972 * If the new flags have non-user flags that are different than 973 * those on the node, we need special permission to change them. 974 */ 975 if ((flags & SF_SETTABLE) != (node->tn_flags & SF_SETTABLE)) { 976 action |= KAUTH_VNODE_WRITE_SYSFLAGS; 977 changing_sysflags = true; 978 } 979 980 /* 981 * Indicate that this node's flags have system attributes in them if 982 * that's the case. 983 */ 984 if (node->tn_flags & (SF_IMMUTABLE | SF_APPEND)) { 985 action |= KAUTH_VNODE_HAS_SYSFLAGS; 986 } 987 988 error = kauth_authorize_vnode(cred, action, vp, NULL, 989 genfs_can_chflags(vp, cred, node->tn_uid, changing_sysflags)); 990 if (error) 991 return error; 992 993 /* 994 * Set the flags. If we're not setting non-user flags, be careful not 995 * to overwrite them. 996 * 997 * XXX: Can't we always assign here? if the system flags are different, 998 * the code above should catch attempts to change them without 999 * proper permissions, and if we're here it means it's okay to 1000 * change them... 1001 */ 1002 if (!changing_sysflags) { 1003 /* Clear all user-settable flags and re-set them. */ 1004 node->tn_flags &= SF_SETTABLE; 1005 node->tn_flags |= (flags & UF_SETTABLE); 1006 } else { 1007 node->tn_flags = flags; 1008 } 1009 tmpfs_update(vp, TMPFS_UPDATE_CTIME); 1010 return 0; 1011 } 1012 1013 /* 1014 * tmpfs_chmod: change access mode on the given vnode. 1015 */ 1016 int 1017 tmpfs_chmod(vnode_t *vp, mode_t mode, kauth_cred_t cred, lwp_t *l) 1018 { 1019 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1020 int error; 1021 1022 KASSERT(VOP_ISLOCKED(vp)); 1023 1024 /* Disallow this operation if the file system is mounted read-only. */ 1025 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1026 return EROFS; 1027 1028 /* Immutable or append-only files cannot be modified, either. */ 1029 if (node->tn_flags & (IMMUTABLE | APPEND)) 1030 return EPERM; 1031 1032 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY, vp, 1033 NULL, genfs_can_chmod(vp, cred, node->tn_uid, node->tn_gid, mode)); 1034 if (error) { 1035 return error; 1036 } 1037 node->tn_mode = (mode & ALLPERMS); 1038 tmpfs_update(vp, TMPFS_UPDATE_CTIME); 1039 cache_enter_id(vp, node->tn_mode, node->tn_uid, node->tn_gid, true); 1040 return 0; 1041 } 1042 1043 /* 1044 * tmpfs_chown: change ownership of the given vnode. 1045 * 1046 * => At least one of uid or gid must be different than VNOVAL. 1047 * => Attribute is unchanged for VNOVAL case. 1048 */ 1049 int 1050 tmpfs_chown(vnode_t *vp, uid_t uid, gid_t gid, kauth_cred_t cred, lwp_t *l) 1051 { 1052 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1053 int error; 1054 1055 KASSERT(VOP_ISLOCKED(vp)); 1056 1057 /* Assign default values if they are unknown. */ 1058 KASSERT(uid != VNOVAL || gid != VNOVAL); 1059 if (uid == VNOVAL) { 1060 uid = node->tn_uid; 1061 } 1062 if (gid == VNOVAL) { 1063 gid = node->tn_gid; 1064 } 1065 1066 /* Disallow this operation if the file system is mounted read-only. */ 1067 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1068 return EROFS; 1069 1070 /* Immutable or append-only files cannot be modified, either. */ 1071 if (node->tn_flags & (IMMUTABLE | APPEND)) 1072 return EPERM; 1073 1074 error = kauth_authorize_vnode(cred, KAUTH_VNODE_CHANGE_OWNERSHIP, vp, 1075 NULL, genfs_can_chown(vp, cred, node->tn_uid, node->tn_gid, uid, 1076 gid)); 1077 if (error) { 1078 return error; 1079 } 1080 node->tn_uid = uid; 1081 node->tn_gid = gid; 1082 tmpfs_update(vp, TMPFS_UPDATE_CTIME); 1083 cache_enter_id(vp, node->tn_mode, node->tn_uid, node->tn_gid, true); 1084 return 0; 1085 } 1086 1087 /* 1088 * tmpfs_chsize: change size of the given vnode. 1089 */ 1090 int 1091 tmpfs_chsize(vnode_t *vp, u_quad_t size, kauth_cred_t cred, lwp_t *l) 1092 { 1093 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1094 const off_t length = size; 1095 int error; 1096 1097 KASSERT(VOP_ISLOCKED(vp)); 1098 1099 /* Decide whether this is a valid operation based on the file type. */ 1100 switch (vp->v_type) { 1101 case VDIR: 1102 return EISDIR; 1103 case VREG: 1104 if (vp->v_mount->mnt_flag & MNT_RDONLY) { 1105 return EROFS; 1106 } 1107 break; 1108 case VBLK: 1109 case VCHR: 1110 case VFIFO: 1111 /* 1112 * Allow modifications of special files even if in the file 1113 * system is mounted read-only (we are not modifying the 1114 * files themselves, but the objects they represent). 1115 */ 1116 return 0; 1117 default: 1118 return EOPNOTSUPP; 1119 } 1120 1121 /* Immutable or append-only files cannot be modified, either. */ 1122 if (node->tn_flags & (IMMUTABLE | APPEND)) { 1123 return EPERM; 1124 } 1125 1126 if (length < 0) { 1127 return EINVAL; 1128 } 1129 1130 /* Note: tmpfs_reg_resize() will raise NOTE_EXTEND and NOTE_ATTRIB. */ 1131 if (node->tn_size != length && 1132 (error = tmpfs_reg_resize(vp, length)) != 0) { 1133 return error; 1134 } 1135 tmpfs_update(vp, TMPFS_UPDATE_CTIME | TMPFS_UPDATE_MTIME); 1136 return 0; 1137 } 1138 1139 /* 1140 * tmpfs_chtimes: change access and modification times for vnode. 1141 */ 1142 int 1143 tmpfs_chtimes(vnode_t *vp, const struct timespec *atime, 1144 const struct timespec *mtime, const struct timespec *btime, 1145 int vaflags, kauth_cred_t cred, lwp_t *l) 1146 { 1147 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1148 int error; 1149 1150 KASSERT(VOP_ISLOCKED(vp)); 1151 1152 /* Disallow this operation if the file system is mounted read-only. */ 1153 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1154 return EROFS; 1155 1156 /* Immutable or append-only files cannot be modified, either. */ 1157 if (node->tn_flags & (IMMUTABLE | APPEND)) 1158 return EPERM; 1159 1160 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp, NULL, 1161 genfs_can_chtimes(vp, cred, node->tn_uid, vaflags)); 1162 if (error) 1163 return error; 1164 1165 mutex_enter(&node->tn_timelock); 1166 if (atime->tv_sec != VNOVAL) { 1167 atomic_and_uint(&node->tn_tflags, ~TMPFS_UPDATE_ATIME); 1168 node->tn_atime = *atime; 1169 } 1170 if (mtime->tv_sec != VNOVAL) { 1171 atomic_and_uint(&node->tn_tflags, ~TMPFS_UPDATE_MTIME); 1172 node->tn_mtime = *mtime; 1173 } 1174 if (btime->tv_sec != VNOVAL) { 1175 node->tn_birthtime = *btime; 1176 } 1177 mutex_exit(&node->tn_timelock); 1178 return 0; 1179 } 1180 1181 /* 1182 * tmpfs_update_locked: update the timestamps as indicated by the flags. 1183 */ 1184 void 1185 tmpfs_update_locked(vnode_t *vp, unsigned tflags) 1186 { 1187 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1188 struct timespec nowtm; 1189 1190 KASSERT(mutex_owned(&node->tn_timelock)); 1191 1192 if ((tflags |= atomic_swap_uint(&node->tn_tflags, 0)) == 0) { 1193 return; 1194 } 1195 vfs_timestamp(&nowtm); 1196 1197 if (tflags & TMPFS_UPDATE_ATIME) { 1198 node->tn_atime = nowtm; 1199 } 1200 if (tflags & TMPFS_UPDATE_MTIME) { 1201 node->tn_mtime = nowtm; 1202 } 1203 if (tflags & TMPFS_UPDATE_CTIME) { 1204 node->tn_ctime = nowtm; 1205 } 1206 } 1207 1208 /* 1209 * tmpfs_update: update the timestamps as indicated by the flags. 1210 */ 1211 void 1212 tmpfs_update(vnode_t *vp, unsigned tflags) 1213 { 1214 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1215 1216 if ((tflags | atomic_load_relaxed(&node->tn_tflags)) == 0) { 1217 return; 1218 } 1219 1220 mutex_enter(&node->tn_timelock); 1221 tmpfs_update_locked(vp, tflags); 1222 mutex_exit(&node->tn_timelock); 1223 } 1224 1225 /* 1226 * tmpfs_update_lazily: schedule a deferred timestamp update. 1227 */ 1228 void 1229 tmpfs_update_lazily(vnode_t *vp, unsigned tflags) 1230 { 1231 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1232 unsigned cur; 1233 1234 cur = atomic_load_relaxed(&node->tn_tflags); 1235 if ((cur & tflags) != tflags) { 1236 atomic_or_uint(&node->tn_tflags, tflags); 1237 return; 1238 } 1239 } 1240
Indexes created Sun Sep 21 20:09:37 GMT 2025