Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/tmpfs/tmpfs_subr.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: tmpfs_subr.c,v 1.35 2007/07/09 21:10:50 ad Exp $ */ 2 3 /*- 4 * SPDX-License-Identifier: BSD-2-Clause-NetBSD 5 * 6 * Copyright (c) 2005 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code 11 * 2005 program. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * Efficient memory file system supporting functions. 37 */ 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/dirent.h> 44 #include <sys/fnv_hash.h> 45 #include <sys/lock.h> 46 #include <sys/limits.h> 47 #include <sys/mount.h> 48 #include <sys/namei.h> 49 #include <sys/priv.h> 50 #include <sys/proc.h> 51 #include <sys/random.h> 52 #include <sys/refcount.h> 53 #include <sys/rwlock.h> 54 #include <sys/smr.h> 55 #include <sys/stat.h> 56 #include <sys/sysctl.h> 57 #include <sys/user.h> 58 #include <sys/vnode.h> 59 #include <sys/vmmeter.h> 60 61 #include <vm/vm.h> 62 #include <vm/vm_param.h> 63 #include <vm/vm_object.h> 64 #include <vm/vm_page.h> 65 #include <vm/vm_pageout.h> 66 #include <vm/vm_pager.h> 67 #include <vm/vm_extern.h> 68 #include <vm/swap_pager.h> 69 70 #include <fs/tmpfs/tmpfs.h> 71 #include <fs/tmpfs/tmpfs_fifoops.h> 72 #include <fs/tmpfs/tmpfs_vnops.h> 73 74 SYSCTL_NODE(_vfs, OID_AUTO, tmpfs, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 75 "tmpfs file system"); 76 77 static long tmpfs_pages_reserved = TMPFS_PAGES_MINRESERVED; 78 79 MALLOC_DEFINE(M_TMPFSDIR, "tmpfs dir", "tmpfs dirent structure"); 80 static uma_zone_t tmpfs_node_pool; 81 VFS_SMR_DECLARE; 82 83 int tmpfs_pager_type = -1; 84 85 static vm_object_t 86 tmpfs_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot, 87 vm_ooffset_t offset, struct ucred *cred) 88 { 89 vm_object_t object; 90 91 MPASS(handle == NULL); 92 MPASS(offset == 0); 93 object = vm_object_allocate_dyn(tmpfs_pager_type, size, 94 OBJ_COLORED | OBJ_SWAP); 95 if (!swap_pager_init_object(object, NULL, NULL, size, 0)) { 96 vm_object_deallocate(object); 97 object = NULL; 98 } 99 return (object); 100 } 101 102 /* 103 * Make sure tmpfs vnodes with writable mappings can be found on the lazy list. 104 * 105 * This allows for periodic mtime updates while only scanning vnodes which are 106 * plausibly dirty, see tmpfs_update_mtime_lazy. 107 */ 108 static void 109 tmpfs_pager_writecount_recalc(vm_object_t object, vm_offset_t old, 110 vm_offset_t new) 111 { 112 struct vnode *vp; 113 114 VM_OBJECT_ASSERT_WLOCKED(object); 115 116 vp = object->un_pager.swp.swp_tmpfs; 117 118 /* 119 * Forced unmount? 120 */ 121 if (vp == NULL) { 122 KASSERT((object->flags & OBJ_TMPFS_VREF) == 0, 123 ("object %p with OBJ_TMPFS_VREF but without vnode", object)); 124 VM_OBJECT_WUNLOCK(object); 125 return; 126 } 127 128 if (old == 0) { 129 VNASSERT((object->flags & OBJ_TMPFS_VREF) == 0, vp, 130 ("object without writable mappings has a reference")); 131 VNPASS(vp->v_usecount > 0, vp); 132 } else { 133 VNASSERT((object->flags & OBJ_TMPFS_VREF) != 0, vp, 134 ("object with writable mappings does not have a reference")); 135 } 136 137 if (old == new) { 138 VM_OBJECT_WUNLOCK(object); 139 return; 140 } 141 142 if (new == 0) { 143 vm_object_clear_flag(object, OBJ_TMPFS_VREF); 144 VM_OBJECT_WUNLOCK(object); 145 vrele(vp); 146 } else { 147 if ((object->flags & OBJ_TMPFS_VREF) == 0) { 148 vref(vp); 149 vlazy(vp); 150 vm_object_set_flag(object, OBJ_TMPFS_VREF); 151 } 152 VM_OBJECT_WUNLOCK(object); 153 } 154 } 155 156 static void 157 tmpfs_pager_update_writecount(vm_object_t object, vm_offset_t start, 158 vm_offset_t end) 159 { 160 vm_offset_t new, old; 161 162 VM_OBJECT_WLOCK(object); 163 KASSERT((object->flags & OBJ_ANON) == 0, 164 ("%s: object %p with OBJ_ANON", __func__, object)); 165 old = object->un_pager.swp.writemappings; 166 object->un_pager.swp.writemappings += (vm_ooffset_t)end - start; 167 new = object->un_pager.swp.writemappings; 168 tmpfs_pager_writecount_recalc(object, old, new); 169 VM_OBJECT_ASSERT_UNLOCKED(object); 170 } 171 172 static void 173 tmpfs_pager_release_writecount(vm_object_t object, vm_offset_t start, 174 vm_offset_t end) 175 { 176 vm_offset_t new, old; 177 178 VM_OBJECT_WLOCK(object); 179 KASSERT((object->flags & OBJ_ANON) == 0, 180 ("%s: object %p with OBJ_ANON", __func__, object)); 181 old = object->un_pager.swp.writemappings; 182 object->un_pager.swp.writemappings -= (vm_ooffset_t)end - start; 183 new = object->un_pager.swp.writemappings; 184 tmpfs_pager_writecount_recalc(object, old, new); 185 VM_OBJECT_ASSERT_UNLOCKED(object); 186 } 187 188 static void 189 tmpfs_pager_getvp(vm_object_t object, struct vnode **vpp, bool *vp_heldp) 190 { 191 struct vnode *vp; 192 193 /* 194 * Tmpfs VREG node, which was reclaimed, has tmpfs_pager_type 195 * type, but not OBJ_TMPFS flag. In this case there is no 196 * v_writecount to adjust. 197 */ 198 if (vp_heldp != NULL) 199 VM_OBJECT_RLOCK(object); 200 else 201 VM_OBJECT_ASSERT_LOCKED(object); 202 if ((object->flags & OBJ_TMPFS) != 0) { 203 vp = object->un_pager.swp.swp_tmpfs; 204 if (vp != NULL) { 205 *vpp = vp; 206 if (vp_heldp != NULL) { 207 vhold(vp); 208 *vp_heldp = true; 209 } 210 } 211 } 212 if (vp_heldp != NULL) 213 VM_OBJECT_RUNLOCK(object); 214 } 215 216 struct pagerops tmpfs_pager_ops = { 217 .pgo_kvme_type = KVME_TYPE_VNODE, 218 .pgo_alloc = tmpfs_pager_alloc, 219 .pgo_set_writeable_dirty = vm_object_set_writeable_dirty_, 220 .pgo_update_writecount = tmpfs_pager_update_writecount, 221 .pgo_release_writecount = tmpfs_pager_release_writecount, 222 .pgo_mightbedirty = vm_object_mightbedirty_, 223 .pgo_getvp = tmpfs_pager_getvp, 224 }; 225 226 static int 227 tmpfs_node_ctor(void *mem, int size, void *arg, int flags) 228 { 229 struct tmpfs_node *node; 230 231 node = mem; 232 node->tn_gen++; 233 node->tn_size = 0; 234 node->tn_status = 0; 235 node->tn_accessed = false; 236 node->tn_flags = 0; 237 node->tn_links = 0; 238 node->tn_vnode = NULL; 239 node->tn_vpstate = 0; 240 return (0); 241 } 242 243 static void 244 tmpfs_node_dtor(void *mem, int size, void *arg) 245 { 246 struct tmpfs_node *node; 247 248 node = mem; 249 node->tn_type = VNON; 250 } 251 252 static int 253 tmpfs_node_init(void *mem, int size, int flags) 254 { 255 struct tmpfs_node *node; 256 257 node = mem; 258 node->tn_id = 0; 259 mtx_init(&node->tn_interlock, "tmpfsni", NULL, MTX_DEF); 260 node->tn_gen = arc4random(); 261 return (0); 262 } 263 264 static void 265 tmpfs_node_fini(void *mem, int size) 266 { 267 struct tmpfs_node *node; 268 269 node = mem; 270 mtx_destroy(&node->tn_interlock); 271 } 272 273 int 274 tmpfs_subr_init(void) 275 { 276 tmpfs_pager_type = vm_pager_alloc_dyn_type(&tmpfs_pager_ops, 277 OBJT_SWAP); 278 if (tmpfs_pager_type == -1) 279 return (EINVAL); 280 tmpfs_node_pool = uma_zcreate("TMPFS node", 281 sizeof(struct tmpfs_node), tmpfs_node_ctor, tmpfs_node_dtor, 282 tmpfs_node_init, tmpfs_node_fini, UMA_ALIGN_PTR, 0); 283 VFS_SMR_ZONE_SET(tmpfs_node_pool); 284 return (0); 285 } 286 287 void 288 tmpfs_subr_uninit(void) 289 { 290 if (tmpfs_pager_type != -1) 291 vm_pager_free_dyn_type(tmpfs_pager_type); 292 tmpfs_pager_type = -1; 293 uma_zdestroy(tmpfs_node_pool); 294 } 295 296 static int 297 sysctl_mem_reserved(SYSCTL_HANDLER_ARGS) 298 { 299 int error; 300 long pages, bytes; 301 302 pages = *(long *)arg1; 303 bytes = pages * PAGE_SIZE; 304 305 error = sysctl_handle_long(oidp, &bytes, 0, req); 306 if (error || !req->newptr) 307 return (error); 308 309 pages = bytes / PAGE_SIZE; 310 if (pages < TMPFS_PAGES_MINRESERVED) 311 return (EINVAL); 312 313 *(long *)arg1 = pages; 314 return (0); 315 } 316 317 SYSCTL_PROC(_vfs_tmpfs, OID_AUTO, memory_reserved, 318 CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RW, &tmpfs_pages_reserved, 0, 319 sysctl_mem_reserved, "L", 320 "Amount of available memory and swap below which tmpfs growth stops"); 321 322 static __inline int tmpfs_dirtree_cmp(struct tmpfs_dirent *a, 323 struct tmpfs_dirent *b); 324 RB_PROTOTYPE_STATIC(tmpfs_dir, tmpfs_dirent, uh.td_entries, tmpfs_dirtree_cmp); 325 326 size_t 327 tmpfs_mem_avail(void) 328 { 329 size_t avail; 330 long reserved; 331 332 avail = swap_pager_avail + vm_free_count(); 333 reserved = atomic_load_long(&tmpfs_pages_reserved); 334 if (__predict_false(avail < reserved)) 335 return (0); 336 return (avail - reserved); 337 } 338 339 size_t 340 tmpfs_pages_used(struct tmpfs_mount *tmp) 341 { 342 const size_t node_size = sizeof(struct tmpfs_node) + 343 sizeof(struct tmpfs_dirent); 344 size_t meta_pages; 345 346 meta_pages = howmany((uintmax_t)tmp->tm_nodes_inuse * node_size, 347 PAGE_SIZE); 348 return (meta_pages + tmp->tm_pages_used); 349 } 350 351 static size_t 352 tmpfs_pages_check_avail(struct tmpfs_mount *tmp, size_t req_pages) 353 { 354 if (tmpfs_mem_avail() < req_pages) 355 return (0); 356 357 if (tmp->tm_pages_max != ULONG_MAX && 358 tmp->tm_pages_max < req_pages + tmpfs_pages_used(tmp)) 359 return (0); 360 361 return (1); 362 } 363 364 static int 365 tmpfs_partial_page_invalidate(vm_object_t object, vm_pindex_t idx, int base, 366 int end, boolean_t ignerr) 367 { 368 vm_page_t m; 369 int rv, error; 370 371 VM_OBJECT_ASSERT_WLOCKED(object); 372 KASSERT(base >= 0, ("%s: base %d", __func__, base)); 373 KASSERT(end - base <= PAGE_SIZE, ("%s: base %d end %d", __func__, base, 374 end)); 375 error = 0; 376 377 retry: 378 m = vm_page_grab(object, idx, VM_ALLOC_NOCREAT); 379 if (m != NULL) { 380 MPASS(vm_page_all_valid(m)); 381 } else if (vm_pager_has_page(object, idx, NULL, NULL)) { 382 m = vm_page_alloc(object, idx, VM_ALLOC_NORMAL | 383 VM_ALLOC_WAITFAIL); 384 if (m == NULL) 385 goto retry; 386 vm_object_pip_add(object, 1); 387 VM_OBJECT_WUNLOCK(object); 388 rv = vm_pager_get_pages(object, &m, 1, NULL, NULL); 389 VM_OBJECT_WLOCK(object); 390 vm_object_pip_wakeup(object); 391 if (rv == VM_PAGER_OK) { 392 /* 393 * Since the page was not resident, and therefore not 394 * recently accessed, immediately enqueue it for 395 * asynchronous laundering. The current operation is 396 * not regarded as an access. 397 */ 398 vm_page_launder(m); 399 } else { 400 vm_page_free(m); 401 m = NULL; 402 if (!ignerr) 403 error = EIO; 404 } 405 } 406 if (m != NULL) { 407 pmap_zero_page_area(m, base, end - base); 408 vm_page_set_dirty(m); 409 vm_page_xunbusy(m); 410 } 411 412 return (error); 413 } 414 415 void 416 tmpfs_ref_node(struct tmpfs_node *node) 417 { 418 #ifdef INVARIANTS 419 u_int old; 420 421 old = 422 #endif 423 refcount_acquire(&node->tn_refcount); 424 #ifdef INVARIANTS 425 KASSERT(old > 0, ("node %p zero refcount", node)); 426 #endif 427 } 428 429 /* 430 * Allocates a new node of type 'type' inside the 'tmp' mount point, with 431 * its owner set to 'uid', its group to 'gid' and its mode set to 'mode', 432 * using the credentials of the process 'p'. 433 * 434 * If the node type is set to 'VDIR', then the parent parameter must point 435 * to the parent directory of the node being created. It may only be NULL 436 * while allocating the root node. 437 * 438 * If the node type is set to 'VBLK' or 'VCHR', then the rdev parameter 439 * specifies the device the node represents. 440 * 441 * If the node type is set to 'VLNK', then the parameter target specifies 442 * the file name of the target file for the symbolic link that is being 443 * created. 444 * 445 * Note that new nodes are retrieved from the available list if it has 446 * items or, if it is empty, from the node pool as long as there is enough 447 * space to create them. 448 * 449 * Returns zero on success or an appropriate error code on failure. 450 */ 451 int 452 tmpfs_alloc_node(struct mount *mp, struct tmpfs_mount *tmp, enum vtype type, 453 uid_t uid, gid_t gid, mode_t mode, struct tmpfs_node *parent, 454 const char *target, dev_t rdev, struct tmpfs_node **node) 455 { 456 struct tmpfs_node *nnode; 457 char *symlink; 458 char symlink_smr; 459 460 /* If the root directory of the 'tmp' file system is not yet 461 * allocated, this must be the request to do it. */ 462 MPASS(IMPLIES(tmp->tm_root == NULL, parent == NULL && type == VDIR)); 463 464 MPASS(IFF(type == VLNK, target != NULL)); 465 MPASS(IFF(type == VBLK || type == VCHR, rdev != VNOVAL)); 466 467 if (tmp->tm_nodes_inuse >= tmp->tm_nodes_max) 468 return (ENOSPC); 469 if (tmpfs_pages_check_avail(tmp, 1) == 0) 470 return (ENOSPC); 471 472 if ((mp->mnt_kern_flag & MNTK_UNMOUNT) != 0) { 473 /* 474 * When a new tmpfs node is created for fully 475 * constructed mount point, there must be a parent 476 * node, which vnode is locked exclusively. As 477 * consequence, if the unmount is executing in 478 * parallel, vflush() cannot reclaim the parent vnode. 479 * Due to this, the check for MNTK_UNMOUNT flag is not 480 * racy: if we did not see MNTK_UNMOUNT flag, then tmp 481 * cannot be destroyed until node construction is 482 * finished and the parent vnode unlocked. 483 * 484 * Tmpfs does not need to instantiate new nodes during 485 * unmount. 486 */ 487 return (EBUSY); 488 } 489 if ((mp->mnt_kern_flag & MNT_RDONLY) != 0) 490 return (EROFS); 491 492 nnode = uma_zalloc_smr(tmpfs_node_pool, M_WAITOK); 493 494 /* Generic initialization. */ 495 nnode->tn_type = type; 496 vfs_timestamp(&nnode->tn_atime); 497 nnode->tn_birthtime = nnode->tn_ctime = nnode->tn_mtime = 498 nnode->tn_atime; 499 nnode->tn_uid = uid; 500 nnode->tn_gid = gid; 501 nnode->tn_mode = mode; 502 nnode->tn_id = alloc_unr64(&tmp->tm_ino_unr); 503 nnode->tn_refcount = 1; 504 505 /* Type-specific initialization. */ 506 switch (nnode->tn_type) { 507 case VBLK: 508 case VCHR: 509 nnode->tn_rdev = rdev; 510 break; 511 512 case VDIR: 513 RB_INIT(&nnode->tn_dir.tn_dirhead); 514 LIST_INIT(&nnode->tn_dir.tn_dupindex); 515 MPASS(parent != nnode); 516 MPASS(IMPLIES(parent == NULL, tmp->tm_root == NULL)); 517 nnode->tn_dir.tn_parent = (parent == NULL) ? nnode : parent; 518 nnode->tn_dir.tn_readdir_lastn = 0; 519 nnode->tn_dir.tn_readdir_lastp = NULL; 520 nnode->tn_links++; 521 TMPFS_NODE_LOCK(nnode->tn_dir.tn_parent); 522 nnode->tn_dir.tn_parent->tn_links++; 523 TMPFS_NODE_UNLOCK(nnode->tn_dir.tn_parent); 524 break; 525 526 case VFIFO: 527 /* FALLTHROUGH */ 528 case VSOCK: 529 break; 530 531 case VLNK: 532 MPASS(strlen(target) < MAXPATHLEN); 533 nnode->tn_size = strlen(target); 534 535 symlink = NULL; 536 if (!tmp->tm_nonc) { 537 symlink = cache_symlink_alloc(nnode->tn_size + 1, M_WAITOK); 538 symlink_smr = true; 539 } 540 if (symlink == NULL) { 541 symlink = malloc(nnode->tn_size + 1, M_TMPFSNAME, M_WAITOK); 542 symlink_smr = false; 543 } 544 memcpy(symlink, target, nnode->tn_size + 1); 545 546 /* 547 * Allow safe symlink resolving for lockless lookup. 548 * tmpfs_fplookup_symlink references this comment. 549 * 550 * 1. nnode is not yet visible to the world 551 * 2. both tn_link_target and tn_link_smr get populated 552 * 3. release fence publishes their content 553 * 4. tn_link_target content is immutable until node destruction, 554 * where the pointer gets set to NULL 555 * 5. tn_link_smr is never changed once set 556 * 557 * As a result it is sufficient to issue load consume on the node 558 * pointer to also get the above content in a stable manner. 559 * Worst case tn_link_smr flag may be set to true despite being stale, 560 * while the target buffer is already cleared out. 561 */ 562 atomic_store_ptr(&nnode->tn_link_target, symlink); 563 atomic_store_char((char *)&nnode->tn_link_smr, symlink_smr); 564 atomic_thread_fence_rel(); 565 break; 566 567 case VREG: 568 nnode->tn_reg.tn_aobj = 569 vm_pager_allocate(tmpfs_pager_type, NULL, 0, 570 VM_PROT_DEFAULT, 0, 571 NULL /* XXXKIB - tmpfs needs swap reservation */); 572 /* OBJ_TMPFS is set together with the setting of vp->v_object */ 573 nnode->tn_reg.tn_tmp = tmp; 574 break; 575 576 default: 577 panic("tmpfs_alloc_node: type %p %d", nnode, 578 (int)nnode->tn_type); 579 } 580 581 TMPFS_LOCK(tmp); 582 LIST_INSERT_HEAD(&tmp->tm_nodes_used, nnode, tn_entries); 583 nnode->tn_attached = true; 584 tmp->tm_nodes_inuse++; 585 tmp->tm_refcount++; 586 TMPFS_UNLOCK(tmp); 587 588 *node = nnode; 589 return (0); 590 } 591 592 /* 593 * Destroys the node pointed to by node from the file system 'tmp'. 594 * If the node references a directory, no entries are allowed. 595 */ 596 void 597 tmpfs_free_node(struct tmpfs_mount *tmp, struct tmpfs_node *node) 598 { 599 if (refcount_release_if_not_last(&node->tn_refcount)) 600 return; 601 602 TMPFS_LOCK(tmp); 603 TMPFS_NODE_LOCK(node); 604 if (!tmpfs_free_node_locked(tmp, node, false)) { 605 TMPFS_NODE_UNLOCK(node); 606 TMPFS_UNLOCK(tmp); 607 } 608 } 609 610 bool 611 tmpfs_free_node_locked(struct tmpfs_mount *tmp, struct tmpfs_node *node, 612 bool detach) 613 { 614 vm_object_t uobj; 615 char *symlink; 616 bool last; 617 618 TMPFS_MP_ASSERT_LOCKED(tmp); 619 TMPFS_NODE_ASSERT_LOCKED(node); 620 621 last = refcount_release(&node->tn_refcount); 622 if (node->tn_attached && (detach || last)) { 623 MPASS(tmp->tm_nodes_inuse > 0); 624 tmp->tm_nodes_inuse--; 625 LIST_REMOVE(node, tn_entries); 626 node->tn_attached = false; 627 } 628 if (!last) 629 return (false); 630 631 TMPFS_NODE_UNLOCK(node); 632 633 #ifdef INVARIANTS 634 MPASS(node->tn_vnode == NULL); 635 MPASS((node->tn_vpstate & TMPFS_VNODE_ALLOCATING) == 0); 636 637 /* 638 * Make sure this is a node type we can deal with. Everything is explicitly 639 * enumerated without the 'default' clause so the the compiler can throw an 640 * error in case a new type is added. 641 */ 642 switch (node->tn_type) { 643 case VBLK: 644 case VCHR: 645 case VDIR: 646 case VFIFO: 647 case VSOCK: 648 case VLNK: 649 case VREG: 650 break; 651 case VNON: 652 case VBAD: 653 case VMARKER: 654 panic("%s: bad type %d for node %p", __func__, (int)node->tn_type, node); 655 } 656 #endif 657 658 switch (node->tn_type) { 659 case VREG: 660 uobj = node->tn_reg.tn_aobj; 661 if (uobj != NULL) { 662 if (uobj->size != 0) 663 atomic_subtract_long(&tmp->tm_pages_used, uobj->size); 664 } 665 666 tmpfs_free_tmp(tmp); 667 668 if (uobj != NULL) { 669 KASSERT((uobj->flags & OBJ_TMPFS) == 0, 670 ("leaked OBJ_TMPFS node %p vm_obj %p", node, uobj)); 671 vm_object_deallocate(uobj); 672 } 673 break; 674 case VLNK: 675 tmpfs_free_tmp(tmp); 676 677 symlink = node->tn_link_target; 678 atomic_store_ptr(&node->tn_link_target, NULL); 679 if (atomic_load_char(&node->tn_link_smr)) { 680 cache_symlink_free(symlink, node->tn_size + 1); 681 } else { 682 free(symlink, M_TMPFSNAME); 683 } 684 break; 685 default: 686 tmpfs_free_tmp(tmp); 687 break; 688 } 689 690 uma_zfree_smr(tmpfs_node_pool, node); 691 return (true); 692 } 693 694 static __inline uint32_t 695 tmpfs_dirent_hash(const char *name, u_int len) 696 { 697 uint32_t hash; 698 699 hash = fnv_32_buf(name, len, FNV1_32_INIT + len) & TMPFS_DIRCOOKIE_MASK; 700 #ifdef TMPFS_DEBUG_DIRCOOKIE_DUP 701 hash &= 0xf; 702 #endif 703 if (hash < TMPFS_DIRCOOKIE_MIN) 704 hash += TMPFS_DIRCOOKIE_MIN; 705 706 return (hash); 707 } 708 709 static __inline off_t 710 tmpfs_dirent_cookie(struct tmpfs_dirent *de) 711 { 712 if (de == NULL) 713 return (TMPFS_DIRCOOKIE_EOF); 714 715 MPASS(de->td_cookie >= TMPFS_DIRCOOKIE_MIN); 716 717 return (de->td_cookie); 718 } 719 720 static __inline boolean_t 721 tmpfs_dirent_dup(struct tmpfs_dirent *de) 722 { 723 return ((de->td_cookie & TMPFS_DIRCOOKIE_DUP) != 0); 724 } 725 726 static __inline boolean_t 727 tmpfs_dirent_duphead(struct tmpfs_dirent *de) 728 { 729 return ((de->td_cookie & TMPFS_DIRCOOKIE_DUPHEAD) != 0); 730 } 731 732 void 733 tmpfs_dirent_init(struct tmpfs_dirent *de, const char *name, u_int namelen) 734 { 735 de->td_hash = de->td_cookie = tmpfs_dirent_hash(name, namelen); 736 memcpy(de->ud.td_name, name, namelen); 737 de->td_namelen = namelen; 738 } 739 740 /* 741 * Allocates a new directory entry for the node node with a name of name. 742 * The new directory entry is returned in *de. 743 * 744 * The link count of node is increased by one to reflect the new object 745 * referencing it. 746 * 747 * Returns zero on success or an appropriate error code on failure. 748 */ 749 int 750 tmpfs_alloc_dirent(struct tmpfs_mount *tmp, struct tmpfs_node *node, 751 const char *name, u_int len, struct tmpfs_dirent **de) 752 { 753 struct tmpfs_dirent *nde; 754 755 nde = malloc(sizeof(*nde), M_TMPFSDIR, M_WAITOK); 756 nde->td_node = node; 757 if (name != NULL) { 758 nde->ud.td_name = malloc(len, M_TMPFSNAME, M_WAITOK); 759 tmpfs_dirent_init(nde, name, len); 760 } else 761 nde->td_namelen = 0; 762 if (node != NULL) 763 node->tn_links++; 764 765 *de = nde; 766 767 return (0); 768 } 769 770 /* 771 * Frees a directory entry. It is the caller's responsibility to destroy 772 * the node referenced by it if needed. 773 * 774 * The link count of node is decreased by one to reflect the removal of an 775 * object that referenced it. This only happens if 'node_exists' is true; 776 * otherwise the function will not access the node referred to by the 777 * directory entry, as it may already have been released from the outside. 778 */ 779 void 780 tmpfs_free_dirent(struct tmpfs_mount *tmp, struct tmpfs_dirent *de) 781 { 782 struct tmpfs_node *node; 783 784 node = de->td_node; 785 if (node != NULL) { 786 MPASS(node->tn_links > 0); 787 node->tn_links--; 788 } 789 if (!tmpfs_dirent_duphead(de) && de->ud.td_name != NULL) 790 free(de->ud.td_name, M_TMPFSNAME); 791 free(de, M_TMPFSDIR); 792 } 793 794 void 795 tmpfs_destroy_vobject(struct vnode *vp, vm_object_t obj) 796 { 797 bool want_vrele; 798 799 ASSERT_VOP_ELOCKED(vp, "tmpfs_destroy_vobject"); 800 if (vp->v_type != VREG || obj == NULL) 801 return; 802 803 VM_OBJECT_WLOCK(obj); 804 VI_LOCK(vp); 805 /* 806 * May be going through forced unmount. 807 */ 808 want_vrele = false; 809 if ((obj->flags & OBJ_TMPFS_VREF) != 0) { 810 vm_object_clear_flag(obj, OBJ_TMPFS_VREF); 811 want_vrele = true; 812 } 813 814 vm_object_clear_flag(obj, OBJ_TMPFS); 815 obj->un_pager.swp.swp_tmpfs = NULL; 816 if (vp->v_writecount < 0) 817 vp->v_writecount = 0; 818 VI_UNLOCK(vp); 819 VM_OBJECT_WUNLOCK(obj); 820 if (want_vrele) { 821 vrele(vp); 822 } 823 } 824 825 /* 826 * Need to clear v_object for insmntque failure. 827 */ 828 static void 829 tmpfs_insmntque_dtr(struct vnode *vp, void *dtr_arg) 830 { 831 832 tmpfs_destroy_vobject(vp, vp->v_object); 833 vp->v_object = NULL; 834 vp->v_data = NULL; 835 vp->v_op = &dead_vnodeops; 836 vgone(vp); 837 vput(vp); 838 } 839 840 /* 841 * Allocates a new vnode for the node node or returns a new reference to 842 * an existing one if the node had already a vnode referencing it. The 843 * resulting locked vnode is returned in *vpp. 844 * 845 * Returns zero on success or an appropriate error code on failure. 846 */ 847 int 848 tmpfs_alloc_vp(struct mount *mp, struct tmpfs_node *node, int lkflag, 849 struct vnode **vpp) 850 { 851 struct vnode *vp; 852 enum vgetstate vs; 853 struct tmpfs_mount *tm; 854 vm_object_t object; 855 int error; 856 857 error = 0; 858 tm = VFS_TO_TMPFS(mp); 859 TMPFS_NODE_LOCK(node); 860 tmpfs_ref_node(node); 861 loop: 862 TMPFS_NODE_ASSERT_LOCKED(node); 863 if ((vp = node->tn_vnode) != NULL) { 864 MPASS((node->tn_vpstate & TMPFS_VNODE_DOOMED) == 0); 865 if ((node->tn_type == VDIR && node->tn_dir.tn_parent == NULL) || 866 (VN_IS_DOOMED(vp) && 867 (lkflag & LK_NOWAIT) != 0)) { 868 TMPFS_NODE_UNLOCK(node); 869 error = ENOENT; 870 vp = NULL; 871 goto out; 872 } 873 if (VN_IS_DOOMED(vp)) { 874 node->tn_vpstate |= TMPFS_VNODE_WRECLAIM; 875 while ((node->tn_vpstate & TMPFS_VNODE_WRECLAIM) != 0) { 876 msleep(&node->tn_vnode, TMPFS_NODE_MTX(node), 877 0, "tmpfsE", 0); 878 } 879 goto loop; 880 } 881 vs = vget_prep(vp); 882 TMPFS_NODE_UNLOCK(node); 883 error = vget_finish(vp, lkflag, vs); 884 if (error == ENOENT) { 885 TMPFS_NODE_LOCK(node); 886 goto loop; 887 } 888 if (error != 0) { 889 vp = NULL; 890 goto out; 891 } 892 893 /* 894 * Make sure the vnode is still there after 895 * getting the interlock to avoid racing a free. 896 */ 897 if (node->tn_vnode != vp) { 898 vput(vp); 899 TMPFS_NODE_LOCK(node); 900 goto loop; 901 } 902 903 goto out; 904 } 905 906 if ((node->tn_vpstate & TMPFS_VNODE_DOOMED) || 907 (node->tn_type == VDIR && node->tn_dir.tn_parent == NULL)) { 908 TMPFS_NODE_UNLOCK(node); 909 error = ENOENT; 910 vp = NULL; 911 goto out; 912 } 913 914 /* 915 * otherwise lock the vp list while we call getnewvnode 916 * since that can block. 917 */ 918 if (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) { 919 node->tn_vpstate |= TMPFS_VNODE_WANT; 920 error = msleep((caddr_t) &node->tn_vpstate, 921 TMPFS_NODE_MTX(node), 0, "tmpfs_alloc_vp", 0); 922 if (error != 0) 923 goto out; 924 goto loop; 925 } else 926 node->tn_vpstate |= TMPFS_VNODE_ALLOCATING; 927 928 TMPFS_NODE_UNLOCK(node); 929 930 /* Get a new vnode and associate it with our node. */ 931 error = getnewvnode("tmpfs", mp, VFS_TO_TMPFS(mp)->tm_nonc ? 932 &tmpfs_vnodeop_nonc_entries : &tmpfs_vnodeop_entries, &vp); 933 if (error != 0) 934 goto unlock; 935 MPASS(vp != NULL); 936 937 /* lkflag is ignored, the lock is exclusive */ 938 (void) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 939 940 vp->v_data = node; 941 vp->v_type = node->tn_type; 942 943 /* Type-specific initialization. */ 944 switch (node->tn_type) { 945 case VBLK: 946 /* FALLTHROUGH */ 947 case VCHR: 948 /* FALLTHROUGH */ 949 case VLNK: 950 /* FALLTHROUGH */ 951 case VSOCK: 952 break; 953 case VFIFO: 954 vp->v_op = &tmpfs_fifoop_entries; 955 break; 956 case VREG: 957 object = node->tn_reg.tn_aobj; 958 VM_OBJECT_WLOCK(object); 959 KASSERT((object->flags & OBJ_TMPFS_VREF) == 0, 960 ("%s: object %p with OBJ_TMPFS_VREF but without vnode", 961 __func__, object)); 962 KASSERT(object->un_pager.swp.writemappings == 0, 963 ("%s: object %p has writemappings", 964 __func__, object)); 965 VI_LOCK(vp); 966 KASSERT(vp->v_object == NULL, ("Not NULL v_object in tmpfs")); 967 vp->v_object = object; 968 object->un_pager.swp.swp_tmpfs = vp; 969 vm_object_set_flag(object, OBJ_TMPFS); 970 vn_irflag_set_locked(vp, VIRF_PGREAD); 971 VI_UNLOCK(vp); 972 VM_OBJECT_WUNLOCK(object); 973 break; 974 case VDIR: 975 MPASS(node->tn_dir.tn_parent != NULL); 976 if (node->tn_dir.tn_parent == node) 977 vp->v_vflag |= VV_ROOT; 978 break; 979 980 default: 981 panic("tmpfs_alloc_vp: type %p %d", node, (int)node->tn_type); 982 } 983 if (vp->v_type != VFIFO) 984 VN_LOCK_ASHARE(vp); 985 986 error = insmntque1(vp, mp, tmpfs_insmntque_dtr, NULL); 987 if (error != 0) 988 vp = NULL; 989 990 unlock: 991 TMPFS_NODE_LOCK(node); 992 993 MPASS(node->tn_vpstate & TMPFS_VNODE_ALLOCATING); 994 node->tn_vpstate &= ~TMPFS_VNODE_ALLOCATING; 995 node->tn_vnode = vp; 996 997 if (node->tn_vpstate & TMPFS_VNODE_WANT) { 998 node->tn_vpstate &= ~TMPFS_VNODE_WANT; 999 TMPFS_NODE_UNLOCK(node); 1000 wakeup((caddr_t) &node->tn_vpstate); 1001 } else 1002 TMPFS_NODE_UNLOCK(node); 1003 1004 out: 1005 if (error == 0) { 1006 *vpp = vp; 1007 1008 #ifdef INVARIANTS 1009 MPASS(*vpp != NULL && VOP_ISLOCKED(*vpp)); 1010 TMPFS_NODE_LOCK(node); 1011 MPASS(*vpp == node->tn_vnode); 1012 TMPFS_NODE_UNLOCK(node); 1013 #endif 1014 } 1015 tmpfs_free_node(tm, node); 1016 1017 return (error); 1018 } 1019 1020 /* 1021 * Destroys the association between the vnode vp and the node it 1022 * references. 1023 */ 1024 void 1025 tmpfs_free_vp(struct vnode *vp) 1026 { 1027 struct tmpfs_node *node; 1028 1029 node = VP_TO_TMPFS_NODE(vp); 1030 1031 TMPFS_NODE_ASSERT_LOCKED(node); 1032 node->tn_vnode = NULL; 1033 if ((node->tn_vpstate & TMPFS_VNODE_WRECLAIM) != 0) 1034 wakeup(&node->tn_vnode); 1035 node->tn_vpstate &= ~TMPFS_VNODE_WRECLAIM; 1036 vp->v_data = NULL; 1037 } 1038 1039 /* 1040 * Allocates a new file of type 'type' and adds it to the parent directory 1041 * 'dvp'; this addition is done using the component name given in 'cnp'. 1042 * The ownership of the new file is automatically assigned based on the 1043 * credentials of the caller (through 'cnp'), the group is set based on 1044 * the parent directory and the mode is determined from the 'vap' argument. 1045 * If successful, *vpp holds a vnode to the newly created file and zero 1046 * is returned. Otherwise *vpp is NULL and the function returns an 1047 * appropriate error code. 1048 */ 1049 int 1050 tmpfs_alloc_file(struct vnode *dvp, struct vnode **vpp, struct vattr *vap, 1051 struct componentname *cnp, const char *target) 1052 { 1053 int error; 1054 struct tmpfs_dirent *de; 1055 struct tmpfs_mount *tmp; 1056 struct tmpfs_node *dnode; 1057 struct tmpfs_node *node; 1058 struct tmpfs_node *parent; 1059 1060 ASSERT_VOP_ELOCKED(dvp, "tmpfs_alloc_file"); 1061 MPASS(cnp->cn_flags & HASBUF); 1062 1063 tmp = VFS_TO_TMPFS(dvp->v_mount); 1064 dnode = VP_TO_TMPFS_DIR(dvp); 1065 *vpp = NULL; 1066 1067 /* If the entry we are creating is a directory, we cannot overflow 1068 * the number of links of its parent, because it will get a new 1069 * link. */ 1070 if (vap->va_type == VDIR) { 1071 /* Ensure that we do not overflow the maximum number of links 1072 * imposed by the system. */ 1073 MPASS(dnode->tn_links <= TMPFS_LINK_MAX); 1074 if (dnode->tn_links == TMPFS_LINK_MAX) { 1075 return (EMLINK); 1076 } 1077 1078 parent = dnode; 1079 MPASS(parent != NULL); 1080 } else 1081 parent = NULL; 1082 1083 /* Allocate a node that represents the new file. */ 1084 error = tmpfs_alloc_node(dvp->v_mount, tmp, vap->va_type, 1085 cnp->cn_cred->cr_uid, dnode->tn_gid, vap->va_mode, parent, 1086 target, vap->va_rdev, &node); 1087 if (error != 0) 1088 return (error); 1089 1090 /* Allocate a directory entry that points to the new file. */ 1091 error = tmpfs_alloc_dirent(tmp, node, cnp->cn_nameptr, cnp->cn_namelen, 1092 &de); 1093 if (error != 0) { 1094 tmpfs_free_node(tmp, node); 1095 return (error); 1096 } 1097 1098 /* Allocate a vnode for the new file. */ 1099 error = tmpfs_alloc_vp(dvp->v_mount, node, LK_EXCLUSIVE, vpp); 1100 if (error != 0) { 1101 tmpfs_free_dirent(tmp, de); 1102 tmpfs_free_node(tmp, node); 1103 return (error); 1104 } 1105 1106 /* Now that all required items are allocated, we can proceed to 1107 * insert the new node into the directory, an operation that 1108 * cannot fail. */ 1109 if (cnp->cn_flags & ISWHITEOUT) 1110 tmpfs_dir_whiteout_remove(dvp, cnp); 1111 tmpfs_dir_attach(dvp, de); 1112 return (0); 1113 } 1114 1115 struct tmpfs_dirent * 1116 tmpfs_dir_first(struct tmpfs_node *dnode, struct tmpfs_dir_cursor *dc) 1117 { 1118 struct tmpfs_dirent *de; 1119 1120 de = RB_MIN(tmpfs_dir, &dnode->tn_dir.tn_dirhead); 1121 dc->tdc_tree = de; 1122 if (de != NULL && tmpfs_dirent_duphead(de)) 1123 de = LIST_FIRST(&de->ud.td_duphead); 1124 dc->tdc_current = de; 1125 1126 return (dc->tdc_current); 1127 } 1128 1129 struct tmpfs_dirent * 1130 tmpfs_dir_next(struct tmpfs_node *dnode, struct tmpfs_dir_cursor *dc) 1131 { 1132 struct tmpfs_dirent *de; 1133 1134 MPASS(dc->tdc_tree != NULL); 1135 if (tmpfs_dirent_dup(dc->tdc_current)) { 1136 dc->tdc_current = LIST_NEXT(dc->tdc_current, uh.td_dup.entries); 1137 if (dc->tdc_current != NULL) 1138 return (dc->tdc_current); 1139 } 1140 dc->tdc_tree = dc->tdc_current = RB_NEXT(tmpfs_dir, 1141 &dnode->tn_dir.tn_dirhead, dc->tdc_tree); 1142 if ((de = dc->tdc_current) != NULL && tmpfs_dirent_duphead(de)) { 1143 dc->tdc_current = LIST_FIRST(&de->ud.td_duphead); 1144 MPASS(dc->tdc_current != NULL); 1145 } 1146 1147 return (dc->tdc_current); 1148 } 1149 1150 /* Lookup directory entry in RB-Tree. Function may return duphead entry. */ 1151 static struct tmpfs_dirent * 1152 tmpfs_dir_xlookup_hash(struct tmpfs_node *dnode, uint32_t hash) 1153 { 1154 struct tmpfs_dirent *de, dekey; 1155 1156 dekey.td_hash = hash; 1157 de = RB_FIND(tmpfs_dir, &dnode->tn_dir.tn_dirhead, &dekey); 1158 return (de); 1159 } 1160 1161 /* Lookup directory entry by cookie, initialize directory cursor accordingly. */ 1162 static struct tmpfs_dirent * 1163 tmpfs_dir_lookup_cookie(struct tmpfs_node *node, off_t cookie, 1164 struct tmpfs_dir_cursor *dc) 1165 { 1166 struct tmpfs_dir *dirhead = &node->tn_dir.tn_dirhead; 1167 struct tmpfs_dirent *de, dekey; 1168 1169 MPASS(cookie >= TMPFS_DIRCOOKIE_MIN); 1170 1171 if (cookie == node->tn_dir.tn_readdir_lastn && 1172 (de = node->tn_dir.tn_readdir_lastp) != NULL) { 1173 /* Protect against possible race, tn_readdir_last[pn] 1174 * may be updated with only shared vnode lock held. */ 1175 if (cookie == tmpfs_dirent_cookie(de)) 1176 goto out; 1177 } 1178 1179 if ((cookie & TMPFS_DIRCOOKIE_DUP) != 0) { 1180 LIST_FOREACH(de, &node->tn_dir.tn_dupindex, 1181 uh.td_dup.index_entries) { 1182 MPASS(tmpfs_dirent_dup(de)); 1183 if (de->td_cookie == cookie) 1184 goto out; 1185 /* dupindex list is sorted. */ 1186 if (de->td_cookie < cookie) { 1187 de = NULL; 1188 goto out; 1189 } 1190 } 1191 MPASS(de == NULL); 1192 goto out; 1193 } 1194 1195 if ((cookie & TMPFS_DIRCOOKIE_MASK) != cookie) { 1196 de = NULL; 1197 } else { 1198 dekey.td_hash = cookie; 1199 /* Recover if direntry for cookie was removed */ 1200 de = RB_NFIND(tmpfs_dir, dirhead, &dekey); 1201 } 1202 dc->tdc_tree = de; 1203 dc->tdc_current = de; 1204 if (de != NULL && tmpfs_dirent_duphead(de)) { 1205 dc->tdc_current = LIST_FIRST(&de->ud.td_duphead); 1206 MPASS(dc->tdc_current != NULL); 1207 } 1208 return (dc->tdc_current); 1209 1210 out: 1211 dc->tdc_tree = de; 1212 dc->tdc_current = de; 1213 if (de != NULL && tmpfs_dirent_dup(de)) 1214 dc->tdc_tree = tmpfs_dir_xlookup_hash(node, 1215 de->td_hash); 1216 return (dc->tdc_current); 1217 } 1218 1219 /* 1220 * Looks for a directory entry in the directory represented by node. 1221 * 'cnp' describes the name of the entry to look for. Note that the . 1222 * and .. components are not allowed as they do not physically exist 1223 * within directories. 1224 * 1225 * Returns a pointer to the entry when found, otherwise NULL. 1226 */ 1227 struct tmpfs_dirent * 1228 tmpfs_dir_lookup(struct tmpfs_node *node, struct tmpfs_node *f, 1229 struct componentname *cnp) 1230 { 1231 struct tmpfs_dir_duphead *duphead; 1232 struct tmpfs_dirent *de; 1233 uint32_t hash; 1234 1235 MPASS(IMPLIES(cnp->cn_namelen == 1, cnp->cn_nameptr[0] != '.')); 1236 MPASS(IMPLIES(cnp->cn_namelen == 2, !(cnp->cn_nameptr[0] == '.' && 1237 cnp->cn_nameptr[1] == '.'))); 1238 TMPFS_VALIDATE_DIR(node); 1239 1240 hash = tmpfs_dirent_hash(cnp->cn_nameptr, cnp->cn_namelen); 1241 de = tmpfs_dir_xlookup_hash(node, hash); 1242 if (de != NULL && tmpfs_dirent_duphead(de)) { 1243 duphead = &de->ud.td_duphead; 1244 LIST_FOREACH(de, duphead, uh.td_dup.entries) { 1245 if (TMPFS_DIRENT_MATCHES(de, cnp->cn_nameptr, 1246 cnp->cn_namelen)) 1247 break; 1248 } 1249 } else if (de != NULL) { 1250 if (!TMPFS_DIRENT_MATCHES(de, cnp->cn_nameptr, 1251 cnp->cn_namelen)) 1252 de = NULL; 1253 } 1254 if (de != NULL && f != NULL && de->td_node != f) 1255 de = NULL; 1256 1257 return (de); 1258 } 1259 1260 /* 1261 * Attach duplicate-cookie directory entry nde to dnode and insert to dupindex 1262 * list, allocate new cookie value. 1263 */ 1264 static void 1265 tmpfs_dir_attach_dup(struct tmpfs_node *dnode, 1266 struct tmpfs_dir_duphead *duphead, struct tmpfs_dirent *nde) 1267 { 1268 struct tmpfs_dir_duphead *dupindex; 1269 struct tmpfs_dirent *de, *pde; 1270 1271 dupindex = &dnode->tn_dir.tn_dupindex; 1272 de = LIST_FIRST(dupindex); 1273 if (de == NULL || de->td_cookie < TMPFS_DIRCOOKIE_DUP_MAX) { 1274 if (de == NULL) 1275 nde->td_cookie = TMPFS_DIRCOOKIE_DUP_MIN; 1276 else 1277 nde->td_cookie = de->td_cookie + 1; 1278 MPASS(tmpfs_dirent_dup(nde)); 1279 LIST_INSERT_HEAD(dupindex, nde, uh.td_dup.index_entries); 1280 LIST_INSERT_HEAD(duphead, nde, uh.td_dup.entries); 1281 return; 1282 } 1283 1284 /* 1285 * Cookie numbers are near exhaustion. Scan dupindex list for unused 1286 * numbers. dupindex list is sorted in descending order. Keep it so 1287 * after inserting nde. 1288 */ 1289 while (1) { 1290 pde = de; 1291 de = LIST_NEXT(de, uh.td_dup.index_entries); 1292 if (de == NULL && pde->td_cookie != TMPFS_DIRCOOKIE_DUP_MIN) { 1293 /* 1294 * Last element of the index doesn't have minimal cookie 1295 * value, use it. 1296 */ 1297 nde->td_cookie = TMPFS_DIRCOOKIE_DUP_MIN; 1298 LIST_INSERT_AFTER(pde, nde, uh.td_dup.index_entries); 1299 LIST_INSERT_HEAD(duphead, nde, uh.td_dup.entries); 1300 return; 1301 } else if (de == NULL) { 1302 /* 1303 * We are so lucky have 2^30 hash duplicates in single 1304 * directory :) Return largest possible cookie value. 1305 * It should be fine except possible issues with 1306 * VOP_READDIR restart. 1307 */ 1308 nde->td_cookie = TMPFS_DIRCOOKIE_DUP_MAX; 1309 LIST_INSERT_HEAD(dupindex, nde, 1310 uh.td_dup.index_entries); 1311 LIST_INSERT_HEAD(duphead, nde, uh.td_dup.entries); 1312 return; 1313 } 1314 if (de->td_cookie + 1 == pde->td_cookie || 1315 de->td_cookie >= TMPFS_DIRCOOKIE_DUP_MAX) 1316 continue; /* No hole or invalid cookie. */ 1317 nde->td_cookie = de->td_cookie + 1; 1318 MPASS(tmpfs_dirent_dup(nde)); 1319 MPASS(pde->td_cookie > nde->td_cookie); 1320 MPASS(nde->td_cookie > de->td_cookie); 1321 LIST_INSERT_BEFORE(de, nde, uh.td_dup.index_entries); 1322 LIST_INSERT_HEAD(duphead, nde, uh.td_dup.entries); 1323 return; 1324 } 1325 } 1326 1327 /* 1328 * Attaches the directory entry de to the directory represented by vp. 1329 * Note that this does not change the link count of the node pointed by 1330 * the directory entry, as this is done by tmpfs_alloc_dirent. 1331 */ 1332 void 1333 tmpfs_dir_attach(struct vnode *vp, struct tmpfs_dirent *de) 1334 { 1335 struct tmpfs_node *dnode; 1336 struct tmpfs_dirent *xde, *nde; 1337 1338 ASSERT_VOP_ELOCKED(vp, __func__); 1339 MPASS(de->td_namelen > 0); 1340 MPASS(de->td_hash >= TMPFS_DIRCOOKIE_MIN); 1341 MPASS(de->td_cookie == de->td_hash); 1342 1343 dnode = VP_TO_TMPFS_DIR(vp); 1344 dnode->tn_dir.tn_readdir_lastn = 0; 1345 dnode->tn_dir.tn_readdir_lastp = NULL; 1346 1347 MPASS(!tmpfs_dirent_dup(de)); 1348 xde = RB_INSERT(tmpfs_dir, &dnode->tn_dir.tn_dirhead, de); 1349 if (xde != NULL && tmpfs_dirent_duphead(xde)) 1350 tmpfs_dir_attach_dup(dnode, &xde->ud.td_duphead, de); 1351 else if (xde != NULL) { 1352 /* 1353 * Allocate new duphead. Swap xde with duphead to avoid 1354 * adding/removing elements with the same hash. 1355 */ 1356 MPASS(!tmpfs_dirent_dup(xde)); 1357 tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), NULL, NULL, 0, 1358 &nde); 1359 /* *nde = *xde; XXX gcc 4.2.1 may generate invalid code. */ 1360 memcpy(nde, xde, sizeof(*xde)); 1361 xde->td_cookie |= TMPFS_DIRCOOKIE_DUPHEAD; 1362 LIST_INIT(&xde->ud.td_duphead); 1363 xde->td_namelen = 0; 1364 xde->td_node = NULL; 1365 tmpfs_dir_attach_dup(dnode, &xde->ud.td_duphead, nde); 1366 tmpfs_dir_attach_dup(dnode, &xde->ud.td_duphead, de); 1367 } 1368 dnode->tn_size += sizeof(struct tmpfs_dirent); 1369 dnode->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED; 1370 dnode->tn_accessed = true; 1371 tmpfs_update(vp); 1372 } 1373 1374 /* 1375 * Detaches the directory entry de from the directory represented by vp. 1376 * Note that this does not change the link count of the node pointed by 1377 * the directory entry, as this is done by tmpfs_free_dirent. 1378 */ 1379 void 1380 tmpfs_dir_detach(struct vnode *vp, struct tmpfs_dirent *de) 1381 { 1382 struct tmpfs_mount *tmp; 1383 struct tmpfs_dir *head; 1384 struct tmpfs_node *dnode; 1385 struct tmpfs_dirent *xde; 1386 1387 ASSERT_VOP_ELOCKED(vp, __func__); 1388 1389 dnode = VP_TO_TMPFS_DIR(vp); 1390 head = &dnode->tn_dir.tn_dirhead; 1391 dnode->tn_dir.tn_readdir_lastn = 0; 1392 dnode->tn_dir.tn_readdir_lastp = NULL; 1393 1394 if (tmpfs_dirent_dup(de)) { 1395 /* Remove duphead if de was last entry. */ 1396 if (LIST_NEXT(de, uh.td_dup.entries) == NULL) { 1397 xde = tmpfs_dir_xlookup_hash(dnode, de->td_hash); 1398 MPASS(tmpfs_dirent_duphead(xde)); 1399 } else 1400 xde = NULL; 1401 LIST_REMOVE(de, uh.td_dup.entries); 1402 LIST_REMOVE(de, uh.td_dup.index_entries); 1403 if (xde != NULL) { 1404 if (LIST_EMPTY(&xde->ud.td_duphead)) { 1405 RB_REMOVE(tmpfs_dir, head, xde); 1406 tmp = VFS_TO_TMPFS(vp->v_mount); 1407 MPASS(xde->td_node == NULL); 1408 tmpfs_free_dirent(tmp, xde); 1409 } 1410 } 1411 de->td_cookie = de->td_hash; 1412 } else 1413 RB_REMOVE(tmpfs_dir, head, de); 1414 1415 dnode->tn_size -= sizeof(struct tmpfs_dirent); 1416 dnode->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED; 1417 dnode->tn_accessed = true; 1418 tmpfs_update(vp); 1419 } 1420 1421 void 1422 tmpfs_dir_destroy(struct tmpfs_mount *tmp, struct tmpfs_node *dnode) 1423 { 1424 struct tmpfs_dirent *de, *dde, *nde; 1425 1426 RB_FOREACH_SAFE(de, tmpfs_dir, &dnode->tn_dir.tn_dirhead, nde) { 1427 RB_REMOVE(tmpfs_dir, &dnode->tn_dir.tn_dirhead, de); 1428 /* Node may already be destroyed. */ 1429 de->td_node = NULL; 1430 if (tmpfs_dirent_duphead(de)) { 1431 while ((dde = LIST_FIRST(&de->ud.td_duphead)) != NULL) { 1432 LIST_REMOVE(dde, uh.td_dup.entries); 1433 dde->td_node = NULL; 1434 tmpfs_free_dirent(tmp, dde); 1435 } 1436 } 1437 tmpfs_free_dirent(tmp, de); 1438 } 1439 } 1440 1441 /* 1442 * Helper function for tmpfs_readdir. Creates a '.' entry for the given 1443 * directory and returns it in the uio space. The function returns 0 1444 * on success, -1 if there was not enough space in the uio structure to 1445 * hold the directory entry or an appropriate error code if another 1446 * error happens. 1447 */ 1448 static int 1449 tmpfs_dir_getdotdent(struct tmpfs_mount *tm, struct tmpfs_node *node, 1450 struct uio *uio) 1451 { 1452 int error; 1453 struct dirent dent; 1454 1455 TMPFS_VALIDATE_DIR(node); 1456 MPASS(uio->uio_offset == TMPFS_DIRCOOKIE_DOT); 1457 1458 dent.d_fileno = node->tn_id; 1459 dent.d_off = TMPFS_DIRCOOKIE_DOTDOT; 1460 dent.d_type = DT_DIR; 1461 dent.d_namlen = 1; 1462 dent.d_name[0] = '.'; 1463 dent.d_reclen = GENERIC_DIRSIZ(&dent); 1464 dirent_terminate(&dent); 1465 1466 if (dent.d_reclen > uio->uio_resid) 1467 error = EJUSTRETURN; 1468 else 1469 error = uiomove(&dent, dent.d_reclen, uio); 1470 1471 tmpfs_set_accessed(tm, node); 1472 1473 return (error); 1474 } 1475 1476 /* 1477 * Helper function for tmpfs_readdir. Creates a '..' entry for the given 1478 * directory and returns it in the uio space. The function returns 0 1479 * on success, -1 if there was not enough space in the uio structure to 1480 * hold the directory entry or an appropriate error code if another 1481 * error happens. 1482 */ 1483 static int 1484 tmpfs_dir_getdotdotdent(struct tmpfs_mount *tm, struct tmpfs_node *node, 1485 struct uio *uio, off_t next) 1486 { 1487 struct tmpfs_node *parent; 1488 struct dirent dent; 1489 int error; 1490 1491 TMPFS_VALIDATE_DIR(node); 1492 MPASS(uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT); 1493 1494 /* 1495 * Return ENOENT if the current node is already removed. 1496 */ 1497 TMPFS_ASSERT_LOCKED(node); 1498 parent = node->tn_dir.tn_parent; 1499 if (parent == NULL) 1500 return (ENOENT); 1501 1502 dent.d_fileno = parent->tn_id; 1503 dent.d_off = next; 1504 dent.d_type = DT_DIR; 1505 dent.d_namlen = 2; 1506 dent.d_name[0] = '.'; 1507 dent.d_name[1] = '.'; 1508 dent.d_reclen = GENERIC_DIRSIZ(&dent); 1509 dirent_terminate(&dent); 1510 1511 if (dent.d_reclen > uio->uio_resid) 1512 error = EJUSTRETURN; 1513 else 1514 error = uiomove(&dent, dent.d_reclen, uio); 1515 1516 tmpfs_set_accessed(tm, node); 1517 1518 return (error); 1519 } 1520 1521 /* 1522 * Helper function for tmpfs_readdir. Returns as much directory entries 1523 * as can fit in the uio space. The read starts at uio->uio_offset. 1524 * The function returns 0 on success, -1 if there was not enough space 1525 * in the uio structure to hold the directory entry or an appropriate 1526 * error code if another error happens. 1527 */ 1528 int 1529 tmpfs_dir_getdents(struct tmpfs_mount *tm, struct tmpfs_node *node, 1530 struct uio *uio, int maxcookies, u_long *cookies, int *ncookies) 1531 { 1532 struct tmpfs_dir_cursor dc; 1533 struct tmpfs_dirent *de, *nde; 1534 off_t off; 1535 int error; 1536 1537 TMPFS_VALIDATE_DIR(node); 1538 1539 off = 0; 1540 1541 /* 1542 * Lookup the node from the current offset. The starting offset of 1543 * 0 will lookup both '.' and '..', and then the first real entry, 1544 * or EOF if there are none. Then find all entries for the dir that 1545 * fit into the buffer. Once no more entries are found (de == NULL), 1546 * the offset is set to TMPFS_DIRCOOKIE_EOF, which will cause the next 1547 * call to return 0. 1548 */ 1549 switch (uio->uio_offset) { 1550 case TMPFS_DIRCOOKIE_DOT: 1551 error = tmpfs_dir_getdotdent(tm, node, uio); 1552 if (error != 0) 1553 return (error); 1554 uio->uio_offset = off = TMPFS_DIRCOOKIE_DOTDOT; 1555 if (cookies != NULL) 1556 cookies[(*ncookies)++] = off; 1557 /* FALLTHROUGH */ 1558 case TMPFS_DIRCOOKIE_DOTDOT: 1559 de = tmpfs_dir_first(node, &dc); 1560 off = tmpfs_dirent_cookie(de); 1561 error = tmpfs_dir_getdotdotdent(tm, node, uio, off); 1562 if (error != 0) 1563 return (error); 1564 uio->uio_offset = off; 1565 if (cookies != NULL) 1566 cookies[(*ncookies)++] = off; 1567 /* EOF. */ 1568 if (de == NULL) 1569 return (0); 1570 break; 1571 case TMPFS_DIRCOOKIE_EOF: 1572 return (0); 1573 default: 1574 de = tmpfs_dir_lookup_cookie(node, uio->uio_offset, &dc); 1575 if (de == NULL) 1576 return (EINVAL); 1577 if (cookies != NULL) 1578 off = tmpfs_dirent_cookie(de); 1579 } 1580 1581 /* 1582 * Read as much entries as possible; i.e., until we reach the end of the 1583 * directory or we exhaust uio space. 1584 */ 1585 do { 1586 struct dirent d; 1587 1588 /* 1589 * Create a dirent structure representing the current tmpfs_node 1590 * and fill it. 1591 */ 1592 if (de->td_node == NULL) { 1593 d.d_fileno = 1; 1594 d.d_type = DT_WHT; 1595 } else { 1596 d.d_fileno = de->td_node->tn_id; 1597 switch (de->td_node->tn_type) { 1598 case VBLK: 1599 d.d_type = DT_BLK; 1600 break; 1601 1602 case VCHR: 1603 d.d_type = DT_CHR; 1604 break; 1605 1606 case VDIR: 1607 d.d_type = DT_DIR; 1608 break; 1609 1610 case VFIFO: 1611 d.d_type = DT_FIFO; 1612 break; 1613 1614 case VLNK: 1615 d.d_type = DT_LNK; 1616 break; 1617 1618 case VREG: 1619 d.d_type = DT_REG; 1620 break; 1621 1622 case VSOCK: 1623 d.d_type = DT_SOCK; 1624 break; 1625 1626 default: 1627 panic("tmpfs_dir_getdents: type %p %d", 1628 de->td_node, (int)de->td_node->tn_type); 1629 } 1630 } 1631 d.d_namlen = de->td_namelen; 1632 MPASS(de->td_namelen < sizeof(d.d_name)); 1633 (void)memcpy(d.d_name, de->ud.td_name, de->td_namelen); 1634 d.d_reclen = GENERIC_DIRSIZ(&d); 1635 1636 /* 1637 * Stop reading if the directory entry we are treating is bigger 1638 * than the amount of data that can be returned. 1639 */ 1640 if (d.d_reclen > uio->uio_resid) { 1641 error = EJUSTRETURN; 1642 break; 1643 } 1644 1645 nde = tmpfs_dir_next(node, &dc); 1646 d.d_off = tmpfs_dirent_cookie(nde); 1647 dirent_terminate(&d); 1648 1649 /* 1650 * Copy the new dirent structure into the output buffer and 1651 * advance pointers. 1652 */ 1653 error = uiomove(&d, d.d_reclen, uio); 1654 if (error == 0) { 1655 de = nde; 1656 if (cookies != NULL) { 1657 off = tmpfs_dirent_cookie(de); 1658 MPASS(*ncookies < maxcookies); 1659 cookies[(*ncookies)++] = off; 1660 } 1661 } 1662 } while (error == 0 && uio->uio_resid > 0 && de != NULL); 1663 1664 /* Skip setting off when using cookies as it is already done above. */ 1665 if (cookies == NULL) 1666 off = tmpfs_dirent_cookie(de); 1667 1668 /* Update the offset and cache. */ 1669 uio->uio_offset = off; 1670 node->tn_dir.tn_readdir_lastn = off; 1671 node->tn_dir.tn_readdir_lastp = de; 1672 1673 tmpfs_set_accessed(tm, node); 1674 return (error); 1675 } 1676 1677 int 1678 tmpfs_dir_whiteout_add(struct vnode *dvp, struct componentname *cnp) 1679 { 1680 struct tmpfs_dirent *de; 1681 int error; 1682 1683 error = tmpfs_alloc_dirent(VFS_TO_TMPFS(dvp->v_mount), NULL, 1684 cnp->cn_nameptr, cnp->cn_namelen, &de); 1685 if (error != 0) 1686 return (error); 1687 tmpfs_dir_attach(dvp, de); 1688 return (0); 1689 } 1690 1691 void 1692 tmpfs_dir_whiteout_remove(struct vnode *dvp, struct componentname *cnp) 1693 { 1694 struct tmpfs_dirent *de; 1695 1696 de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(dvp), NULL, cnp); 1697 MPASS(de != NULL && de->td_node == NULL); 1698 tmpfs_dir_detach(dvp, de); 1699 tmpfs_free_dirent(VFS_TO_TMPFS(dvp->v_mount), de); 1700 } 1701 1702 /* 1703 * Resizes the aobj associated with the regular file pointed to by 'vp' to the 1704 * size 'newsize'. 'vp' must point to a vnode that represents a regular file. 1705 * 'newsize' must be positive. 1706 * 1707 * Returns zero on success or an appropriate error code on failure. 1708 */ 1709 int 1710 tmpfs_reg_resize(struct vnode *vp, off_t newsize, boolean_t ignerr) 1711 { 1712 struct tmpfs_mount *tmp; 1713 struct tmpfs_node *node; 1714 vm_object_t uobj; 1715 vm_pindex_t idx, newpages, oldpages; 1716 off_t oldsize; 1717 int base, error; 1718 1719 MPASS(vp->v_type == VREG); 1720 MPASS(newsize >= 0); 1721 1722 node = VP_TO_TMPFS_NODE(vp); 1723 uobj = node->tn_reg.tn_aobj; 1724 tmp = VFS_TO_TMPFS(vp->v_mount); 1725 1726 /* 1727 * Convert the old and new sizes to the number of pages needed to 1728 * store them. It may happen that we do not need to do anything 1729 * because the last allocated page can accommodate the change on 1730 * its own. 1731 */ 1732 oldsize = node->tn_size; 1733 oldpages = OFF_TO_IDX(oldsize + PAGE_MASK); 1734 MPASS(oldpages == uobj->size); 1735 newpages = OFF_TO_IDX(newsize + PAGE_MASK); 1736 1737 if (__predict_true(newpages == oldpages && newsize >= oldsize)) { 1738 node->tn_size = newsize; 1739 return (0); 1740 } 1741 1742 if (newpages > oldpages && 1743 tmpfs_pages_check_avail(tmp, newpages - oldpages) == 0) 1744 return (ENOSPC); 1745 1746 VM_OBJECT_WLOCK(uobj); 1747 if (newsize < oldsize) { 1748 /* 1749 * Zero the truncated part of the last page. 1750 */ 1751 base = newsize & PAGE_MASK; 1752 if (base != 0) { 1753 idx = OFF_TO_IDX(newsize); 1754 error = tmpfs_partial_page_invalidate(uobj, idx, base, 1755 PAGE_SIZE, ignerr); 1756 if (error != 0) { 1757 VM_OBJECT_WUNLOCK(uobj); 1758 return (error); 1759 } 1760 } 1761 1762 /* 1763 * Release any swap space and free any whole pages. 1764 */ 1765 if (newpages < oldpages) 1766 vm_object_page_remove(uobj, newpages, 0, 0); 1767 } 1768 uobj->size = newpages; 1769 VM_OBJECT_WUNLOCK(uobj); 1770 1771 atomic_add_long(&tmp->tm_pages_used, newpages - oldpages); 1772 1773 node->tn_size = newsize; 1774 return (0); 1775 } 1776 1777 void 1778 tmpfs_check_mtime(struct vnode *vp) 1779 { 1780 struct tmpfs_node *node; 1781 struct vm_object *obj; 1782 1783 ASSERT_VOP_ELOCKED(vp, "check_mtime"); 1784 if (vp->v_type != VREG) 1785 return; 1786 obj = vp->v_object; 1787 KASSERT(obj->type == tmpfs_pager_type && 1788 (obj->flags & (OBJ_SWAP | OBJ_TMPFS)) == 1789 (OBJ_SWAP | OBJ_TMPFS), ("non-tmpfs obj")); 1790 /* unlocked read */ 1791 if (obj->generation != obj->cleangeneration) { 1792 VM_OBJECT_WLOCK(obj); 1793 if (obj->generation != obj->cleangeneration) { 1794 obj->cleangeneration = obj->generation; 1795 node = VP_TO_TMPFS_NODE(vp); 1796 node->tn_status |= TMPFS_NODE_MODIFIED | 1797 TMPFS_NODE_CHANGED; 1798 } 1799 VM_OBJECT_WUNLOCK(obj); 1800 } 1801 } 1802 1803 /* 1804 * Change flags of the given vnode. 1805 * Caller should execute tmpfs_update on vp after a successful execution. 1806 * The vnode must be locked on entry and remain locked on exit. 1807 */ 1808 int 1809 tmpfs_chflags(struct vnode *vp, u_long flags, struct ucred *cred, 1810 struct thread *p) 1811 { 1812 int error; 1813 struct tmpfs_node *node; 1814 1815 ASSERT_VOP_ELOCKED(vp, "chflags"); 1816 1817 node = VP_TO_TMPFS_NODE(vp); 1818 1819 if ((flags & ~(SF_APPEND | SF_ARCHIVED | SF_IMMUTABLE | SF_NOUNLINK | 1820 UF_APPEND | UF_ARCHIVE | UF_HIDDEN | UF_IMMUTABLE | UF_NODUMP | 1821 UF_NOUNLINK | UF_OFFLINE | UF_OPAQUE | UF_READONLY | UF_REPARSE | 1822 UF_SPARSE | UF_SYSTEM)) != 0) 1823 return (EOPNOTSUPP); 1824 1825 /* Disallow this operation if the file system is mounted read-only. */ 1826 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1827 return (EROFS); 1828 1829 /* 1830 * Callers may only modify the file flags on objects they 1831 * have VADMIN rights for. 1832 */ 1833 if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) 1834 return (error); 1835 /* 1836 * Unprivileged processes are not permitted to unset system 1837 * flags, or modify flags if any system flags are set. 1838 */ 1839 if (!priv_check_cred(cred, PRIV_VFS_SYSFLAGS)) { 1840 if (node->tn_flags & 1841 (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) { 1842 error = securelevel_gt(cred, 0); 1843 if (error) 1844 return (error); 1845 } 1846 } else { 1847 if (node->tn_flags & 1848 (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) || 1849 ((flags ^ node->tn_flags) & SF_SETTABLE)) 1850 return (EPERM); 1851 } 1852 node->tn_flags = flags; 1853 node->tn_status |= TMPFS_NODE_CHANGED; 1854 1855 ASSERT_VOP_ELOCKED(vp, "chflags2"); 1856 1857 return (0); 1858 } 1859 1860 /* 1861 * Change access mode on the given vnode. 1862 * Caller should execute tmpfs_update on vp after a successful execution. 1863 * The vnode must be locked on entry and remain locked on exit. 1864 */ 1865 int 1866 tmpfs_chmod(struct vnode *vp, mode_t mode, struct ucred *cred, struct thread *p) 1867 { 1868 int error; 1869 struct tmpfs_node *node; 1870 mode_t newmode; 1871 1872 ASSERT_VOP_ELOCKED(vp, "chmod"); 1873 ASSERT_VOP_IN_SEQC(vp); 1874 1875 node = VP_TO_TMPFS_NODE(vp); 1876 1877 /* Disallow this operation if the file system is mounted read-only. */ 1878 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1879 return (EROFS); 1880 1881 /* Immutable or append-only files cannot be modified, either. */ 1882 if (node->tn_flags & (IMMUTABLE | APPEND)) 1883 return (EPERM); 1884 1885 /* 1886 * To modify the permissions on a file, must possess VADMIN 1887 * for that file. 1888 */ 1889 if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) 1890 return (error); 1891 1892 /* 1893 * Privileged processes may set the sticky bit on non-directories, 1894 * as well as set the setgid bit on a file with a group that the 1895 * process is not a member of. 1896 */ 1897 if (vp->v_type != VDIR && (mode & S_ISTXT)) { 1898 if (priv_check_cred(cred, PRIV_VFS_STICKYFILE)) 1899 return (EFTYPE); 1900 } 1901 if (!groupmember(node->tn_gid, cred) && (mode & S_ISGID)) { 1902 error = priv_check_cred(cred, PRIV_VFS_SETGID); 1903 if (error) 1904 return (error); 1905 } 1906 1907 newmode = node->tn_mode & ~ALLPERMS; 1908 newmode |= mode & ALLPERMS; 1909 atomic_store_short(&node->tn_mode, newmode); 1910 1911 node->tn_status |= TMPFS_NODE_CHANGED; 1912 1913 ASSERT_VOP_ELOCKED(vp, "chmod2"); 1914 1915 return (0); 1916 } 1917 1918 /* 1919 * Change ownership of the given vnode. At least one of uid or gid must 1920 * be different than VNOVAL. If one is set to that value, the attribute 1921 * is unchanged. 1922 * Caller should execute tmpfs_update on vp after a successful execution. 1923 * The vnode must be locked on entry and remain locked on exit. 1924 */ 1925 int 1926 tmpfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, 1927 struct thread *p) 1928 { 1929 int error; 1930 struct tmpfs_node *node; 1931 uid_t ouid; 1932 gid_t ogid; 1933 mode_t newmode; 1934 1935 ASSERT_VOP_ELOCKED(vp, "chown"); 1936 ASSERT_VOP_IN_SEQC(vp); 1937 1938 node = VP_TO_TMPFS_NODE(vp); 1939 1940 /* Assign default values if they are unknown. */ 1941 MPASS(uid != VNOVAL || gid != VNOVAL); 1942 if (uid == VNOVAL) 1943 uid = node->tn_uid; 1944 if (gid == VNOVAL) 1945 gid = node->tn_gid; 1946 MPASS(uid != VNOVAL && gid != VNOVAL); 1947 1948 /* Disallow this operation if the file system is mounted read-only. */ 1949 if (vp->v_mount->mnt_flag & MNT_RDONLY) 1950 return (EROFS); 1951 1952 /* Immutable or append-only files cannot be modified, either. */ 1953 if (node->tn_flags & (IMMUTABLE | APPEND)) 1954 return (EPERM); 1955 1956 /* 1957 * To modify the ownership of a file, must possess VADMIN for that 1958 * file. 1959 */ 1960 if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) 1961 return (error); 1962 1963 /* 1964 * To change the owner of a file, or change the group of a file to a 1965 * group of which we are not a member, the caller must have 1966 * privilege. 1967 */ 1968 if ((uid != node->tn_uid || 1969 (gid != node->tn_gid && !groupmember(gid, cred))) && 1970 (error = priv_check_cred(cred, PRIV_VFS_CHOWN))) 1971 return (error); 1972 1973 ogid = node->tn_gid; 1974 ouid = node->tn_uid; 1975 1976 node->tn_uid = uid; 1977 node->tn_gid = gid; 1978 1979 node->tn_status |= TMPFS_NODE_CHANGED; 1980 1981 if ((node->tn_mode & (S_ISUID | S_ISGID)) && (ouid != uid || ogid != gid)) { 1982 if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID)) { 1983 newmode = node->tn_mode & ~(S_ISUID | S_ISGID); 1984 atomic_store_short(&node->tn_mode, newmode); 1985 } 1986 } 1987 1988 ASSERT_VOP_ELOCKED(vp, "chown2"); 1989 1990 return (0); 1991 } 1992 1993 /* 1994 * Change size of the given vnode. 1995 * Caller should execute tmpfs_update on vp after a successful execution. 1996 * The vnode must be locked on entry and remain locked on exit. 1997 */ 1998 int 1999 tmpfs_chsize(struct vnode *vp, u_quad_t size, struct ucred *cred, 2000 struct thread *p) 2001 { 2002 int error; 2003 struct tmpfs_node *node; 2004 2005 ASSERT_VOP_ELOCKED(vp, "chsize"); 2006 2007 node = VP_TO_TMPFS_NODE(vp); 2008 2009 /* Decide whether this is a valid operation based on the file type. */ 2010 error = 0; 2011 switch (vp->v_type) { 2012 case VDIR: 2013 return (EISDIR); 2014 2015 case VREG: 2016 if (vp->v_mount->mnt_flag & MNT_RDONLY) 2017 return (EROFS); 2018 break; 2019 2020 case VBLK: 2021 /* FALLTHROUGH */ 2022 case VCHR: 2023 /* FALLTHROUGH */ 2024 case VFIFO: 2025 /* 2026 * Allow modifications of special files even if in the file 2027 * system is mounted read-only (we are not modifying the 2028 * files themselves, but the objects they represent). 2029 */ 2030 return (0); 2031 2032 default: 2033 /* Anything else is unsupported. */ 2034 return (EOPNOTSUPP); 2035 } 2036 2037 /* Immutable or append-only files cannot be modified, either. */ 2038 if (node->tn_flags & (IMMUTABLE | APPEND)) 2039 return (EPERM); 2040 2041 error = tmpfs_truncate(vp, size); 2042 /* 2043 * tmpfs_truncate will raise the NOTE_EXTEND and NOTE_ATTRIB kevents 2044 * for us, as will update tn_status; no need to do that here. 2045 */ 2046 2047 ASSERT_VOP_ELOCKED(vp, "chsize2"); 2048 2049 return (error); 2050 } 2051 2052 /* 2053 * Change access and modification times of the given vnode. 2054 * Caller should execute tmpfs_update on vp after a successful execution. 2055 * The vnode must be locked on entry and remain locked on exit. 2056 */ 2057 int 2058 tmpfs_chtimes(struct vnode *vp, struct vattr *vap, 2059 struct ucred *cred, struct thread *l) 2060 { 2061 int error; 2062 struct tmpfs_node *node; 2063 2064 ASSERT_VOP_ELOCKED(vp, "chtimes"); 2065 2066 node = VP_TO_TMPFS_NODE(vp); 2067 2068 /* Disallow this operation if the file system is mounted read-only. */ 2069 if (vp->v_mount->mnt_flag & MNT_RDONLY) 2070 return (EROFS); 2071 2072 /* Immutable or append-only files cannot be modified, either. */ 2073 if (node->tn_flags & (IMMUTABLE | APPEND)) 2074 return (EPERM); 2075 2076 error = vn_utimes_perm(vp, vap, cred, l); 2077 if (error != 0) 2078 return (error); 2079 2080 if (vap->va_atime.tv_sec != VNOVAL) 2081 node->tn_accessed = true; 2082 2083 if (vap->va_mtime.tv_sec != VNOVAL) 2084 node->tn_status |= TMPFS_NODE_MODIFIED; 2085 2086 if (vap->va_birthtime.tv_sec != VNOVAL) 2087 node->tn_status |= TMPFS_NODE_MODIFIED; 2088 2089 tmpfs_itimes(vp, &vap->va_atime, &vap->va_mtime); 2090 2091 if (vap->va_birthtime.tv_sec != VNOVAL) 2092 node->tn_birthtime = vap->va_birthtime; 2093 ASSERT_VOP_ELOCKED(vp, "chtimes2"); 2094 2095 return (0); 2096 } 2097 2098 void 2099 tmpfs_set_status(struct tmpfs_mount *tm, struct tmpfs_node *node, int status) 2100 { 2101 2102 if ((node->tn_status & status) == status || tm->tm_ronly) 2103 return; 2104 TMPFS_NODE_LOCK(node); 2105 node->tn_status |= status; 2106 TMPFS_NODE_UNLOCK(node); 2107 } 2108 2109 void 2110 tmpfs_set_accessed(struct tmpfs_mount *tm, struct tmpfs_node *node) 2111 { 2112 if (node->tn_accessed || tm->tm_ronly) 2113 return; 2114 atomic_store_8(&node->tn_accessed, true); 2115 } 2116 2117 /* Sync timestamps */ 2118 void 2119 tmpfs_itimes(struct vnode *vp, const struct timespec *acc, 2120 const struct timespec *mod) 2121 { 2122 struct tmpfs_node *node; 2123 struct timespec now; 2124 2125 ASSERT_VOP_LOCKED(vp, "tmpfs_itimes"); 2126 node = VP_TO_TMPFS_NODE(vp); 2127 2128 if (!node->tn_accessed && 2129 (node->tn_status & (TMPFS_NODE_MODIFIED | TMPFS_NODE_CHANGED)) == 0) 2130 return; 2131 2132 vfs_timestamp(&now); 2133 TMPFS_NODE_LOCK(node); 2134 if (node->tn_accessed) { 2135 if (acc == NULL) 2136 acc = &now; 2137 node->tn_atime = *acc; 2138 } 2139 if (node->tn_status & TMPFS_NODE_MODIFIED) { 2140 if (mod == NULL) 2141 mod = &now; 2142 node->tn_mtime = *mod; 2143 } 2144 if (node->tn_status & TMPFS_NODE_CHANGED) 2145 node->tn_ctime = now; 2146 node->tn_status &= ~(TMPFS_NODE_MODIFIED | TMPFS_NODE_CHANGED); 2147 node->tn_accessed = false; 2148 TMPFS_NODE_UNLOCK(node); 2149 2150 /* XXX: FIX? The entropy here is desirable, but the harvesting may be expensive */ 2151 random_harvest_queue(node, sizeof(*node), RANDOM_FS_ATIME); 2152 } 2153 2154 int 2155 tmpfs_truncate(struct vnode *vp, off_t length) 2156 { 2157 int error; 2158 struct tmpfs_node *node; 2159 2160 node = VP_TO_TMPFS_NODE(vp); 2161 2162 if (length < 0) { 2163 error = EINVAL; 2164 goto out; 2165 } 2166 2167 if (node->tn_size == length) { 2168 error = 0; 2169 goto out; 2170 } 2171 2172 if (length > VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize) 2173 return (EFBIG); 2174 2175 error = tmpfs_reg_resize(vp, length, FALSE); 2176 if (error == 0) 2177 node->tn_status |= TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED; 2178 2179 out: 2180 tmpfs_update(vp); 2181 2182 return (error); 2183 } 2184 2185 static __inline int 2186 tmpfs_dirtree_cmp(struct tmpfs_dirent *a, struct tmpfs_dirent *b) 2187 { 2188 if (a->td_hash > b->td_hash) 2189 return (1); 2190 else if (a->td_hash < b->td_hash) 2191 return (-1); 2192 return (0); 2193 } 2194 2195 RB_GENERATE_STATIC(tmpfs_dir, tmpfs_dirent, uh.td_entries, tmpfs_dirtree_cmp);
Cache object: b7c921eaa360fec2ae70e931d944383f
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]