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 NetBSD's virtual memory sub-system 37 * (the well-known UVM) to store file data and metadata in an efficient 38 * way. This means that it does not follow the structure of an on-disk 39 * file 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$"); 45 46 #include <sys/param.h> 47 #include <sys/limits.h> 48 #include <sys/lock.h> 49 #include <sys/mutex.h> 50 #include <sys/kernel.h> 51 #include <sys/stat.h> 52 #include <sys/systm.h> 53 #include <sys/sysctl.h> 54 55 #include <vm/vm.h> 56 #include <vm/vm_object.h> 57 #include <vm/vm_param.h> 58 59 #include <fs/tmpfs/tmpfs.h> 60 61 /* 62 * Default permission for root node 63 */ 64 #define TMPFS_DEFAULT_ROOT_MODE (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 65 66 MALLOC_DEFINE(M_TMPFSMNT, "tmpfs mount", "tmpfs mount structures"); 67 MALLOC_DEFINE(M_TMPFSNAME, "tmpfs name", "tmpfs file names"); 68 69 /* --------------------------------------------------------------------- */ 70 71 static int tmpfs_mount(struct mount *); 72 static int tmpfs_unmount(struct mount *, int); 73 static int tmpfs_root(struct mount *, int flags, struct vnode **); 74 static int tmpfs_fhtovp(struct mount *, struct fid *, int, 75 struct vnode **); 76 static int tmpfs_statfs(struct mount *, struct statfs *); 77 78 /* --------------------------------------------------------------------- */ 79 80 static const char *tmpfs_opts[] = { 81 "from", "size", "maxfilesize", "inodes", "uid", "gid", "mode", "export", 82 NULL 83 }; 84 85 /* --------------------------------------------------------------------- */ 86 87 static int 88 tmpfs_node_ctor(void *mem, int size, void *arg, int flags) 89 { 90 struct tmpfs_node *node = (struct tmpfs_node *)mem; 91 92 node->tn_gen++; 93 node->tn_size = 0; 94 node->tn_status = 0; 95 node->tn_flags = 0; 96 node->tn_links = 0; 97 node->tn_vnode = NULL; 98 node->tn_vpstate = 0; 99 100 return (0); 101 } 102 103 static void 104 tmpfs_node_dtor(void *mem, int size, void *arg) 105 { 106 struct tmpfs_node *node = (struct tmpfs_node *)mem; 107 node->tn_type = VNON; 108 } 109 110 static int 111 tmpfs_node_init(void *mem, int size, int flags) 112 { 113 struct tmpfs_node *node = (struct tmpfs_node *)mem; 114 node->tn_id = 0; 115 116 mtx_init(&node->tn_interlock, "tmpfs node interlock", NULL, MTX_DEF); 117 node->tn_gen = arc4random(); 118 119 return (0); 120 } 121 122 static void 123 tmpfs_node_fini(void *mem, int size) 124 { 125 struct tmpfs_node *node = (struct tmpfs_node *)mem; 126 127 mtx_destroy(&node->tn_interlock); 128 } 129 130 static int 131 tmpfs_mount(struct mount *mp) 132 { 133 const size_t nodes_per_page = howmany(PAGE_SIZE, 134 sizeof(struct tmpfs_dirent) + sizeof(struct tmpfs_node)); 135 struct tmpfs_mount *tmp; 136 struct tmpfs_node *root; 137 int error; 138 /* Size counters. */ 139 u_quad_t pages; 140 off_t nodes_max, size_max, maxfilesize; 141 142 /* Root node attributes. */ 143 uid_t root_uid; 144 gid_t root_gid; 145 mode_t root_mode; 146 147 struct vattr va; 148 149 if (vfs_filteropt(mp->mnt_optnew, tmpfs_opts)) 150 return (EINVAL); 151 152 if (mp->mnt_flag & MNT_UPDATE) { 153 /* 154 * Only support update mounts for NFS export. 155 */ 156 if (vfs_flagopt(mp->mnt_optnew, "export", NULL, 0)) 157 return (0); 158 return (EOPNOTSUPP); 159 } 160 161 vn_lock(mp->mnt_vnodecovered, LK_SHARED | LK_RETRY); 162 error = VOP_GETATTR(mp->mnt_vnodecovered, &va, mp->mnt_cred); 163 VOP_UNLOCK(mp->mnt_vnodecovered, 0); 164 if (error) 165 return (error); 166 167 if (mp->mnt_cred->cr_ruid != 0 || 168 vfs_scanopt(mp->mnt_optnew, "gid", "%d", &root_gid) != 1) 169 root_gid = va.va_gid; 170 if (mp->mnt_cred->cr_ruid != 0 || 171 vfs_scanopt(mp->mnt_optnew, "uid", "%d", &root_uid) != 1) 172 root_uid = va.va_uid; 173 if (mp->mnt_cred->cr_ruid != 0 || 174 vfs_scanopt(mp->mnt_optnew, "mode", "%ho", &root_mode) != 1) 175 root_mode = va.va_mode; 176 if (vfs_getopt_size(mp->mnt_optnew, "inodes", &nodes_max) != 0) 177 nodes_max = 0; 178 if (vfs_getopt_size(mp->mnt_optnew, "size", &size_max) != 0) 179 size_max = 0; 180 if (vfs_getopt_size(mp->mnt_optnew, "maxfilesize", &maxfilesize) != 0) 181 maxfilesize = 0; 182 183 /* Do not allow mounts if we do not have enough memory to preserve 184 * the minimum reserved pages. */ 185 if (tmpfs_mem_avail() < TMPFS_PAGES_MINRESERVED) 186 return ENOSPC; 187 188 /* Get the maximum number of memory pages this file system is 189 * allowed to use, based on the maximum size the user passed in 190 * the mount structure. A value of zero is treated as if the 191 * maximum available space was requested. */ 192 if (size_max < PAGE_SIZE || size_max > OFF_MAX - PAGE_SIZE || 193 (SIZE_MAX < OFF_MAX && size_max / PAGE_SIZE >= SIZE_MAX)) 194 pages = SIZE_MAX; 195 else 196 pages = howmany(size_max, PAGE_SIZE); 197 MPASS(pages > 0); 198 199 if (nodes_max <= 3) { 200 if (pages < INT_MAX / nodes_per_page) 201 nodes_max = pages * nodes_per_page; 202 else 203 nodes_max = INT_MAX; 204 } 205 if (nodes_max > INT_MAX) 206 nodes_max = INT_MAX; 207 MPASS(nodes_max >= 3); 208 209 /* Allocate the tmpfs mount structure and fill it. */ 210 tmp = (struct tmpfs_mount *)malloc(sizeof(struct tmpfs_mount), 211 M_TMPFSMNT, M_WAITOK | M_ZERO); 212 213 mtx_init(&tmp->allnode_lock, "tmpfs allnode lock", NULL, MTX_DEF); 214 tmp->tm_nodes_max = nodes_max; 215 tmp->tm_nodes_inuse = 0; 216 tmp->tm_maxfilesize = maxfilesize > 0 ? maxfilesize : OFF_MAX; 217 LIST_INIT(&tmp->tm_nodes_used); 218 219 tmp->tm_pages_max = pages; 220 tmp->tm_pages_used = 0; 221 tmp->tm_ino_unr = new_unrhdr(2, INT_MAX, &tmp->allnode_lock); 222 tmp->tm_dirent_pool = uma_zcreate("TMPFS dirent", 223 sizeof(struct tmpfs_dirent), 224 NULL, NULL, NULL, NULL, 225 UMA_ALIGN_PTR, 0); 226 tmp->tm_node_pool = uma_zcreate("TMPFS node", 227 sizeof(struct tmpfs_node), 228 tmpfs_node_ctor, tmpfs_node_dtor, 229 tmpfs_node_init, tmpfs_node_fini, 230 UMA_ALIGN_PTR, 0); 231 232 /* Allocate the root node. */ 233 error = tmpfs_alloc_node(tmp, VDIR, root_uid, 234 root_gid, root_mode & ALLPERMS, NULL, NULL, 235 VNOVAL, &root); 236 237 if (error != 0 || root == NULL) { 238 uma_zdestroy(tmp->tm_node_pool); 239 uma_zdestroy(tmp->tm_dirent_pool); 240 delete_unrhdr(tmp->tm_ino_unr); 241 free(tmp, M_TMPFSMNT); 242 return error; 243 } 244 KASSERT(root->tn_id == 2, ("tmpfs root with invalid ino: %d", root->tn_id)); 245 tmp->tm_root = root; 246 247 MNT_ILOCK(mp); 248 mp->mnt_flag |= MNT_LOCAL; 249 mp->mnt_kern_flag |= MNTK_MPSAFE; 250 MNT_IUNLOCK(mp); 251 252 mp->mnt_data = tmp; 253 mp->mnt_stat.f_namemax = MAXNAMLEN; 254 vfs_getnewfsid(mp); 255 vfs_mountedfrom(mp, "tmpfs"); 256 257 return 0; 258 } 259 260 /* --------------------------------------------------------------------- */ 261 262 /* ARGSUSED2 */ 263 static int 264 tmpfs_unmount(struct mount *mp, int mntflags) 265 { 266 int error; 267 int flags = 0; 268 struct tmpfs_mount *tmp; 269 struct tmpfs_node *node; 270 271 /* Handle forced unmounts. */ 272 if (mntflags & MNT_FORCE) 273 flags |= FORCECLOSE; 274 275 /* Finalize all pending I/O. */ 276 error = vflush(mp, 0, flags, curthread); 277 if (error != 0) 278 return error; 279 280 tmp = VFS_TO_TMPFS(mp); 281 282 /* Free all associated data. The loop iterates over the linked list 283 * we have containing all used nodes. For each of them that is 284 * a directory, we free all its directory entries. Note that after 285 * freeing a node, it will automatically go to the available list, 286 * so we will later have to iterate over it to release its items. */ 287 node = LIST_FIRST(&tmp->tm_nodes_used); 288 while (node != NULL) { 289 struct tmpfs_node *next; 290 291 if (node->tn_type == VDIR) { 292 struct tmpfs_dirent *de; 293 294 de = TAILQ_FIRST(&node->tn_dir.tn_dirhead); 295 while (de != NULL) { 296 struct tmpfs_dirent *nde; 297 298 nde = TAILQ_NEXT(de, td_entries); 299 tmpfs_free_dirent(tmp, de, FALSE); 300 de = nde; 301 node->tn_size -= sizeof(struct tmpfs_dirent); 302 } 303 } 304 305 next = LIST_NEXT(node, tn_entries); 306 tmpfs_free_node(tmp, node); 307 node = next; 308 } 309 310 uma_zdestroy(tmp->tm_dirent_pool); 311 uma_zdestroy(tmp->tm_node_pool); 312 delete_unrhdr(tmp->tm_ino_unr); 313 314 mtx_destroy(&tmp->allnode_lock); 315 MPASS(tmp->tm_pages_used == 0); 316 MPASS(tmp->tm_nodes_inuse == 0); 317 318 /* Throw away the tmpfs_mount structure. */ 319 free(mp->mnt_data, M_TMPFSMNT); 320 mp->mnt_data = NULL; 321 322 MNT_ILOCK(mp); 323 mp->mnt_flag &= ~MNT_LOCAL; 324 MNT_IUNLOCK(mp); 325 return 0; 326 } 327 328 /* --------------------------------------------------------------------- */ 329 330 static int 331 tmpfs_root(struct mount *mp, int flags, struct vnode **vpp) 332 { 333 int error; 334 error = tmpfs_alloc_vp(mp, VFS_TO_TMPFS(mp)->tm_root, flags, vpp); 335 336 if (!error) 337 (*vpp)->v_vflag |= VV_ROOT; 338 339 return error; 340 } 341 342 /* --------------------------------------------------------------------- */ 343 344 static int 345 tmpfs_fhtovp(struct mount *mp, struct fid *fhp, int flags, 346 struct vnode **vpp) 347 { 348 boolean_t found; 349 struct tmpfs_fid *tfhp; 350 struct tmpfs_mount *tmp; 351 struct tmpfs_node *node; 352 353 tmp = VFS_TO_TMPFS(mp); 354 355 tfhp = (struct tmpfs_fid *)fhp; 356 if (tfhp->tf_len != sizeof(struct tmpfs_fid)) 357 return EINVAL; 358 359 if (tfhp->tf_id >= tmp->tm_nodes_max) 360 return EINVAL; 361 362 found = FALSE; 363 364 TMPFS_LOCK(tmp); 365 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) { 366 if (node->tn_id == tfhp->tf_id && 367 node->tn_gen == tfhp->tf_gen) { 368 found = TRUE; 369 break; 370 } 371 } 372 TMPFS_UNLOCK(tmp); 373 374 if (found) 375 return (tmpfs_alloc_vp(mp, node, LK_EXCLUSIVE, vpp)); 376 377 return (EINVAL); 378 } 379 380 /* --------------------------------------------------------------------- */ 381 382 /* ARGSUSED2 */ 383 static int 384 tmpfs_statfs(struct mount *mp, struct statfs *sbp) 385 { 386 struct tmpfs_mount *tmp; 387 size_t used; 388 389 tmp = VFS_TO_TMPFS(mp); 390 391 sbp->f_iosize = PAGE_SIZE; 392 sbp->f_bsize = PAGE_SIZE; 393 394 used = tmpfs_pages_used(tmp); 395 if (tmp->tm_pages_max != SIZE_MAX) 396 sbp->f_blocks = tmp->tm_pages_max; 397 else 398 sbp->f_blocks = used + tmpfs_mem_avail(); 399 if (sbp->f_blocks <= used) 400 sbp->f_bavail = 0; 401 else 402 sbp->f_bavail = sbp->f_blocks - used; 403 sbp->f_bfree = sbp->f_bavail; 404 used = tmp->tm_nodes_inuse; 405 sbp->f_files = tmp->tm_nodes_max; 406 if (sbp->f_files <= used) 407 sbp->f_ffree = 0; 408 else 409 sbp->f_ffree = sbp->f_files - used; 410 /* sbp->f_owner = tmp->tn_uid; */ 411 412 return 0; 413 } 414 415 /* --------------------------------------------------------------------- */ 416 417 /* 418 * tmpfs vfs operations. 419 */ 420 421 struct vfsops tmpfs_vfsops = { 422 .vfs_mount = tmpfs_mount, 423 .vfs_unmount = tmpfs_unmount, 424 .vfs_root = tmpfs_root, 425 .vfs_statfs = tmpfs_statfs, 426 .vfs_fhtovp = tmpfs_fhtovp, 427 }; 428 VFS_SET(tmpfs_vfsops, tmpfs, 0); 429