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_vfsops.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_vfsops.c,v 1.10 2005/12/11 12:24:29 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code 9 * 2005 program. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Efficient memory file system. 35 * 36 * tmpfs is a file system that uses FreeBSD's virtual memory 37 * sub-system to store file data and metadata in an efficient way. 38 * This means that it does not follow the structure of an on-disk file 39 * system because it simply does not need to. Instead, it uses 40 * memory-specific data structures and algorithms to automatically 41 * allocate and release resources. 42 */ 43 #include <sys/cdefs.h> 44 __FBSDID("$FreeBSD: releng/10.4/sys/fs/tmpfs/tmpfs_vfsops.c 313095 2017-02-02 13:39:11Z kib $"); 45 46 #include <sys/param.h> 47 #include <sys/limits.h> 48 #include <sys/lock.h> 49 #include <sys/mutex.h> 50 #include <sys/proc.h> 51 #include <sys/jail.h> 52 #include <sys/kernel.h> 53 #include <sys/rwlock.h> 54 #include <sys/stat.h> 55 #include <sys/systm.h> 56 #include <sys/sysctl.h> 57 58 #include <vm/vm.h> 59 #include <vm/vm_object.h> 60 #include <vm/vm_param.h> 61 62 #include <fs/tmpfs/tmpfs.h> 63 64 /* 65 * Default permission for root node 66 */ 67 #define TMPFS_DEFAULT_ROOT_MODE (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 68 69 MALLOC_DEFINE(M_TMPFSMNT, "tmpfs mount", "tmpfs mount structures"); 70 MALLOC_DEFINE(M_TMPFSNAME, "tmpfs name", "tmpfs file names"); 71 72 static int tmpfs_mount(struct mount *); 73 static int tmpfs_unmount(struct mount *, int); 74 static int tmpfs_root(struct mount *, int flags, struct vnode **); 75 static int tmpfs_fhtovp(struct mount *, struct fid *, int, 76 struct vnode **); 77 static int tmpfs_statfs(struct mount *, struct statfs *); 78 79 static const char *tmpfs_opts[] = { 80 "from", "size", "maxfilesize", "inodes", "uid", "gid", "mode", "export", 81 "union", "nonc", NULL 82 }; 83 84 static const char *tmpfs_updateopts[] = { 85 "from", "export", NULL 86 }; 87 88 static int 89 tmpfs_node_ctor(void *mem, int size, void *arg, int flags) 90 { 91 struct tmpfs_node *node = (struct tmpfs_node *)mem; 92 93 node->tn_gen++; 94 node->tn_size = 0; 95 node->tn_status = 0; 96 node->tn_flags = 0; 97 node->tn_links = 0; 98 node->tn_vnode = NULL; 99 node->tn_vpstate = 0; 100 101 return (0); 102 } 103 104 static void 105 tmpfs_node_dtor(void *mem, int size, void *arg) 106 { 107 struct tmpfs_node *node = (struct tmpfs_node *)mem; 108 node->tn_type = VNON; 109 } 110 111 static int 112 tmpfs_node_init(void *mem, int size, int flags) 113 { 114 struct tmpfs_node *node = (struct tmpfs_node *)mem; 115 node->tn_id = 0; 116 117 mtx_init(&node->tn_interlock, "tmpfs node interlock", NULL, MTX_DEF); 118 node->tn_gen = arc4random(); 119 120 return (0); 121 } 122 123 static void 124 tmpfs_node_fini(void *mem, int size) 125 { 126 struct tmpfs_node *node = (struct tmpfs_node *)mem; 127 128 mtx_destroy(&node->tn_interlock); 129 } 130 131 static int 132 tmpfs_mount(struct mount *mp) 133 { 134 const size_t nodes_per_page = howmany(PAGE_SIZE, 135 sizeof(struct tmpfs_dirent) + sizeof(struct tmpfs_node)); 136 struct tmpfs_mount *tmp; 137 struct tmpfs_node *root; 138 struct thread *td = curthread; 139 int error; 140 bool nonc; 141 /* Size counters. */ 142 u_quad_t pages; 143 off_t nodes_max, size_max, maxfilesize; 144 145 /* Root node attributes. */ 146 uid_t root_uid; 147 gid_t root_gid; 148 mode_t root_mode; 149 150 struct vattr va; 151 152 if (!prison_allow(td->td_ucred, PR_ALLOW_MOUNT_TMPFS)) 153 return (EPERM); 154 155 if (vfs_filteropt(mp->mnt_optnew, tmpfs_opts)) 156 return (EINVAL); 157 158 if (mp->mnt_flag & MNT_UPDATE) { 159 /* Only support update mounts for certain options. */ 160 if (vfs_filteropt(mp->mnt_optnew, tmpfs_updateopts) != 0) 161 return (EOPNOTSUPP); 162 if (vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) != 163 ((struct tmpfs_mount *)mp->mnt_data)->tm_ronly) 164 return (EOPNOTSUPP); 165 return (0); 166 } 167 168 vn_lock(mp->mnt_vnodecovered, LK_SHARED | LK_RETRY); 169 error = VOP_GETATTR(mp->mnt_vnodecovered, &va, mp->mnt_cred); 170 VOP_UNLOCK(mp->mnt_vnodecovered, 0); 171 if (error) 172 return (error); 173 174 if (mp->mnt_cred->cr_ruid != 0 || 175 vfs_scanopt(mp->mnt_optnew, "gid", "%d", &root_gid) != 1) 176 root_gid = va.va_gid; 177 if (mp->mnt_cred->cr_ruid != 0 || 178 vfs_scanopt(mp->mnt_optnew, "uid", "%d", &root_uid) != 1) 179 root_uid = va.va_uid; 180 if (mp->mnt_cred->cr_ruid != 0 || 181 vfs_scanopt(mp->mnt_optnew, "mode", "%ho", &root_mode) != 1) 182 root_mode = va.va_mode; 183 if (vfs_getopt_size(mp->mnt_optnew, "inodes", &nodes_max) != 0) 184 nodes_max = 0; 185 if (vfs_getopt_size(mp->mnt_optnew, "size", &size_max) != 0) 186 size_max = 0; 187 if (vfs_getopt_size(mp->mnt_optnew, "maxfilesize", &maxfilesize) != 0) 188 maxfilesize = 0; 189 nonc = vfs_getopt(mp->mnt_optnew, "nonc", NULL, NULL) == 0; 190 191 /* Do not allow mounts if we do not have enough memory to preserve 192 * the minimum reserved pages. */ 193 if (tmpfs_mem_avail() < TMPFS_PAGES_MINRESERVED) 194 return (ENOSPC); 195 196 /* Get the maximum number of memory pages this file system is 197 * allowed to use, based on the maximum size the user passed in 198 * the mount structure. A value of zero is treated as if the 199 * maximum available space was requested. */ 200 if (size_max == 0 || size_max > OFF_MAX - PAGE_SIZE || 201 (SIZE_MAX < OFF_MAX && size_max / PAGE_SIZE >= SIZE_MAX)) 202 pages = SIZE_MAX; 203 else { 204 size_max = roundup(size_max, PAGE_SIZE); 205 pages = howmany(size_max, PAGE_SIZE); 206 } 207 MPASS(pages > 0); 208 209 if (nodes_max <= 3) { 210 if (pages < INT_MAX / nodes_per_page) 211 nodes_max = pages * nodes_per_page; 212 else 213 nodes_max = INT_MAX; 214 } 215 if (nodes_max > INT_MAX) 216 nodes_max = INT_MAX; 217 MPASS(nodes_max >= 3); 218 219 /* Allocate the tmpfs mount structure and fill it. */ 220 tmp = (struct tmpfs_mount *)malloc(sizeof(struct tmpfs_mount), 221 M_TMPFSMNT, M_WAITOK | M_ZERO); 222 223 mtx_init(&tmp->tm_allnode_lock, "tmpfs allnode lock", NULL, MTX_DEF); 224 tmp->tm_nodes_max = nodes_max; 225 tmp->tm_nodes_inuse = 0; 226 tmp->tm_refcount = 1; 227 tmp->tm_maxfilesize = maxfilesize > 0 ? maxfilesize : OFF_MAX; 228 LIST_INIT(&tmp->tm_nodes_used); 229 230 tmp->tm_pages_max = pages; 231 tmp->tm_pages_used = 0; 232 tmp->tm_ino_unr = new_unrhdr(2, INT_MAX, &tmp->tm_allnode_lock); 233 tmp->tm_dirent_pool = uma_zcreate("TMPFS dirent", 234 sizeof(struct tmpfs_dirent), NULL, NULL, NULL, NULL, 235 UMA_ALIGN_PTR, 0); 236 tmp->tm_node_pool = uma_zcreate("TMPFS node", 237 sizeof(struct tmpfs_node), tmpfs_node_ctor, tmpfs_node_dtor, 238 tmpfs_node_init, tmpfs_node_fini, UMA_ALIGN_PTR, 0); 239 tmp->tm_ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 240 tmp->tm_nonc = nonc; 241 242 /* Allocate the root node. */ 243 error = tmpfs_alloc_node(mp, tmp, VDIR, root_uid, root_gid, 244 root_mode & ALLPERMS, NULL, NULL, VNOVAL, &root); 245 246 if (error != 0 || root == NULL) { 247 uma_zdestroy(tmp->tm_node_pool); 248 uma_zdestroy(tmp->tm_dirent_pool); 249 delete_unrhdr(tmp->tm_ino_unr); 250 free(tmp, M_TMPFSMNT); 251 return (error); 252 } 253 KASSERT(root->tn_id == 2, 254 ("tmpfs root with invalid ino: %ju", (uintmax_t)root->tn_id)); 255 tmp->tm_root = root; 256 257 MNT_ILOCK(mp); 258 mp->mnt_flag |= MNT_LOCAL; 259 MNT_IUNLOCK(mp); 260 261 mp->mnt_data = tmp; 262 mp->mnt_stat.f_namemax = MAXNAMLEN; 263 vfs_getnewfsid(mp); 264 vfs_mountedfrom(mp, "tmpfs"); 265 266 return 0; 267 } 268 269 /* ARGSUSED2 */ 270 static int 271 tmpfs_unmount(struct mount *mp, int mntflags) 272 { 273 struct tmpfs_mount *tmp; 274 struct tmpfs_node *node; 275 int error, flags; 276 277 flags = (mntflags & MNT_FORCE) != 0 ? FORCECLOSE : 0; 278 tmp = VFS_TO_TMPFS(mp); 279 280 /* Stop writers */ 281 error = vfs_write_suspend_umnt(mp); 282 if (error != 0) 283 return (error); 284 /* 285 * At this point, nodes cannot be destroyed by any other 286 * thread because write suspension is started. 287 */ 288 289 for (;;) { 290 error = vflush(mp, 0, flags, curthread); 291 if (error != 0) { 292 vfs_write_resume(mp, VR_START_WRITE); 293 return (error); 294 } 295 MNT_ILOCK(mp); 296 if (mp->mnt_nvnodelistsize == 0) { 297 MNT_IUNLOCK(mp); 298 break; 299 } 300 MNT_IUNLOCK(mp); 301 if ((mntflags & MNT_FORCE) == 0) { 302 vfs_write_resume(mp, VR_START_WRITE); 303 return (EBUSY); 304 } 305 } 306 307 TMPFS_LOCK(tmp); 308 while ((node = LIST_FIRST(&tmp->tm_nodes_used)) != NULL) { 309 TMPFS_NODE_LOCK(node); 310 if (node->tn_type == VDIR) 311 tmpfs_dir_destroy(tmp, node); 312 if (tmpfs_free_node_locked(tmp, node, true)) 313 TMPFS_LOCK(tmp); 314 else 315 TMPFS_NODE_UNLOCK(node); 316 } 317 318 mp->mnt_data = NULL; 319 tmpfs_free_tmp(tmp); 320 vfs_write_resume(mp, VR_START_WRITE); 321 322 MNT_ILOCK(mp); 323 mp->mnt_flag &= ~MNT_LOCAL; 324 MNT_IUNLOCK(mp); 325 326 return (0); 327 } 328 329 void 330 tmpfs_free_tmp(struct tmpfs_mount *tmp) 331 { 332 333 MPASS(tmp->tm_refcount > 0); 334 tmp->tm_refcount--; 335 if (tmp->tm_refcount > 0) { 336 TMPFS_UNLOCK(tmp); 337 return; 338 } 339 TMPFS_UNLOCK(tmp); 340 341 uma_zdestroy(tmp->tm_dirent_pool); 342 uma_zdestroy(tmp->tm_node_pool); 343 delete_unrhdr(tmp->tm_ino_unr); 344 345 mtx_destroy(&tmp->tm_allnode_lock); 346 MPASS(tmp->tm_pages_used == 0); 347 MPASS(tmp->tm_nodes_inuse == 0); 348 349 free(tmp, M_TMPFSMNT); 350 } 351 352 static int 353 tmpfs_root(struct mount *mp, int flags, struct vnode **vpp) 354 { 355 int error; 356 357 error = tmpfs_alloc_vp(mp, VFS_TO_TMPFS(mp)->tm_root, flags, vpp); 358 if (error == 0) 359 (*vpp)->v_vflag |= VV_ROOT; 360 return (error); 361 } 362 363 static int 364 tmpfs_fhtovp(struct mount *mp, struct fid *fhp, int flags, 365 struct vnode **vpp) 366 { 367 struct tmpfs_fid *tfhp; 368 struct tmpfs_mount *tmp; 369 struct tmpfs_node *node; 370 int error; 371 372 tmp = VFS_TO_TMPFS(mp); 373 374 tfhp = (struct tmpfs_fid *)fhp; 375 if (tfhp->tf_len != sizeof(struct tmpfs_fid)) 376 return (EINVAL); 377 378 if (tfhp->tf_id >= tmp->tm_nodes_max) 379 return (EINVAL); 380 381 TMPFS_LOCK(tmp); 382 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) { 383 if (node->tn_id == tfhp->tf_id && 384 node->tn_gen == tfhp->tf_gen) { 385 tmpfs_ref_node(node); 386 break; 387 } 388 } 389 TMPFS_UNLOCK(tmp); 390 391 if (node != NULL) { 392 error = tmpfs_alloc_vp(mp, node, LK_EXCLUSIVE, vpp); 393 tmpfs_free_node(tmp, node); 394 } else 395 error = EINVAL; 396 return (error); 397 } 398 399 /* ARGSUSED2 */ 400 static int 401 tmpfs_statfs(struct mount *mp, struct statfs *sbp) 402 { 403 struct tmpfs_mount *tmp; 404 size_t used; 405 406 tmp = VFS_TO_TMPFS(mp); 407 408 sbp->f_iosize = PAGE_SIZE; 409 sbp->f_bsize = PAGE_SIZE; 410 411 used = tmpfs_pages_used(tmp); 412 if (tmp->tm_pages_max != ULONG_MAX) 413 sbp->f_blocks = tmp->tm_pages_max; 414 else 415 sbp->f_blocks = used + tmpfs_mem_avail(); 416 if (sbp->f_blocks <= used) 417 sbp->f_bavail = 0; 418 else 419 sbp->f_bavail = sbp->f_blocks - used; 420 sbp->f_bfree = sbp->f_bavail; 421 used = tmp->tm_nodes_inuse; 422 sbp->f_files = tmp->tm_nodes_max; 423 if (sbp->f_files <= used) 424 sbp->f_ffree = 0; 425 else 426 sbp->f_ffree = sbp->f_files - used; 427 /* sbp->f_owner = tmp->tn_uid; */ 428 429 return 0; 430 } 431 432 static int 433 tmpfs_sync(struct mount *mp, int waitfor) 434 { 435 struct vnode *vp, *mvp; 436 struct vm_object *obj; 437 438 if (waitfor == MNT_SUSPEND) { 439 MNT_ILOCK(mp); 440 mp->mnt_kern_flag |= MNTK_SUSPEND2 | MNTK_SUSPENDED; 441 MNT_IUNLOCK(mp); 442 } else if (waitfor == MNT_LAZY) { 443 /* 444 * Handle lazy updates of mtime from writes to mmaped 445 * regions. Use MNT_VNODE_FOREACH_ALL instead of 446 * MNT_VNODE_FOREACH_ACTIVE, since unmap of the 447 * tmpfs-backed vnode does not call vinactive(), due 448 * to vm object type is OBJT_SWAP. 449 */ 450 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) { 451 if (vp->v_type != VREG) { 452 VI_UNLOCK(vp); 453 continue; 454 } 455 obj = vp->v_object; 456 KASSERT((obj->flags & (OBJ_TMPFS_NODE | OBJ_TMPFS)) == 457 (OBJ_TMPFS_NODE | OBJ_TMPFS), ("non-tmpfs obj")); 458 459 /* 460 * Unlocked read, avoid taking vnode lock if 461 * not needed. Lost update will be handled on 462 * the next call. 463 */ 464 if ((obj->flags & OBJ_TMPFS_DIRTY) == 0) { 465 VI_UNLOCK(vp); 466 continue; 467 } 468 if (vget(vp, LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK, 469 curthread) != 0) 470 continue; 471 tmpfs_check_mtime(vp); 472 vput(vp); 473 } 474 } 475 return (0); 476 } 477 478 /* 479 * tmpfs vfs operations. 480 */ 481 482 struct vfsops tmpfs_vfsops = { 483 .vfs_mount = tmpfs_mount, 484 .vfs_unmount = tmpfs_unmount, 485 .vfs_root = tmpfs_root, 486 .vfs_statfs = tmpfs_statfs, 487 .vfs_fhtovp = tmpfs_fhtovp, 488 .vfs_sync = tmpfs_sync, 489 }; 490 VFS_SET(tmpfs_vfsops, tmpfs, VFCF_JAIL);
Cache object: ffacdff0fcfcaf07d20c2dd63e160e9d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]