1 /* $NetBSD: tmpfs_vfsops.c,v 1.10 2005/12/11 12:24:29 christos Exp $ */
4 * Copyright (c) 2005 The NetBSD Foundation, Inc.
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
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
34 * Efficient memory file system.
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.
43 #include <sys/cdefs.h>
45 #include <sys/param.h>
46 #include <sys/limits.h>
48 #include <sys/mutex.h>
49 #include <sys/kernel.h>
51 #include <sys/systm.h>
52 #include <sys/sysctl.h>
53 #include <sys/objcache.h>
56 #include <vm/vm_object.h>
57 #include <vm/vm_param.h>
59 #include <vfs/tmpfs/tmpfs.h>
60 #include <vfs/tmpfs/tmpfs_vnops.h>
61 #include <vfs/tmpfs/tmpfs_args.h>
64 * Default permission for root node
66 #define TMPFS_DEFAULT_ROOT_MODE (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
68 MALLOC_DEFINE(M_TMPFSMNT, "tmpfs mount", "tmpfs mount structures");
70 /* --------------------------------------------------------------------- */
72 static int tmpfs_mount(struct mount *, char *, caddr_t, struct ucred *);
73 static int tmpfs_unmount(struct mount *, int);
74 static int tmpfs_root(struct mount *, struct vnode **);
75 static int tmpfs_fhtovp(struct mount *, struct vnode *, struct fid *, struct vnode **);
76 static int tmpfs_statfs(struct mount *, struct statfs *, struct ucred *cred);
78 /* --------------------------------------------------------------------- */
80 tmpfs_node_ctor(void *obj, void *privdata, int flags)
82 struct tmpfs_node *node = (struct tmpfs_node *)obj;
89 node->tn_vnode = NULL;
90 node->tn_vpstate = TMPFS_VNODE_WANT;
91 bzero(&node->tn_spec, sizeof(node->tn_spec));
97 tmpfs_node_dtor(void *obj, void *privdata)
99 struct tmpfs_node *node = (struct tmpfs_node *)obj;
100 node->tn_type = VNON;
101 node->tn_vpstate = TMPFS_VNODE_DOOMED;
105 tmpfs_node_init(void *args, int flags)
107 struct tmpfs_node *node = (struct tmpfs_node *)objcache_malloc_alloc(args, flags);
112 lockinit(&node->tn_interlock, "tmpfs node interlock", 0, LK_CANRECURSE);
113 node->tn_gen = karc4random();
119 tmpfs_node_fini(void *obj, void *args)
121 struct tmpfs_node *node = (struct tmpfs_node *)obj;
122 lockuninit(&node->tn_interlock);
123 objcache_malloc_free(obj, args);
127 tmpfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
129 struct tmpfs_mount *tmp;
130 struct tmpfs_node *root;
131 struct tmpfs_args args;
133 vm_pindex_t pages_limit;
143 /* Root node attributes. */
144 uid_t root_uid = cred->cr_uid;
145 gid_t root_gid = cred->cr_gid;
146 mode_t root_mode = (VREAD | VWRITE);
148 if (mp->mnt_flag & MNT_UPDATE) {
149 /* XXX: There is no support yet to update file system
150 * settings. Should be added. */
158 bzero(&args, sizeof(args));
165 error = copyin(data, &args, sizeof(args));
169 size_max = args.ta_size_max;
170 nodes_max = args.ta_nodes_max;
171 maxfsize_max = args.ta_maxfsize_max;
172 root_uid = args.ta_root_uid;
173 root_gid = args.ta_root_gid;
174 root_mode = args.ta_root_mode;
178 * If mount by non-root, then verify that user has necessary
179 * permissions on the device.
181 if (cred->cr_uid != 0) {
183 if ((mp->mnt_flag & MNT_RDONLY) == 0)
187 pages_limit = vm_swap_max + vmstats.v_page_count / 2;
190 pages = pages_limit / 2;
191 else if (size_max < PAGE_SIZE)
193 else if (OFF_TO_IDX(size_max) > pages_limit)
196 pages = OFF_TO_IDX(size_max);
199 nodes = 3 + pages * PAGE_SIZE / 1024;
200 else if (nodes_max < 3)
202 else if (nodes_max > pages)
207 maxfsize = IDX_TO_OFF(pages_limit);
208 if (maxfsize_max != 0 && maxfsize > maxfsize_max)
209 maxfsize = maxfsize_max;
211 /* Allocate the tmpfs mount structure and fill it. */
212 tmp = kmalloc(sizeof(*tmp), M_TMPFSMNT, M_WAITOK | M_ZERO);
214 lockinit(&(tmp->allnode_lock), "tmpfs allnode lock", 0, LK_CANRECURSE);
215 tmp->tm_nodes_max = nodes;
216 tmp->tm_nodes_inuse = 0;
217 tmp->tm_maxfilesize = maxfsize;
218 LIST_INIT(&tmp->tm_nodes_used);
220 tmp->tm_pages_max = pages;
221 tmp->tm_pages_used = 0;
223 kmalloc_create(&tmp->tm_node_zone, "tmpfs node");
224 kmalloc_create(&tmp->tm_dirent_zone, "tmpfs dirent");
225 kmalloc_create(&tmp->tm_name_zone, "tmpfs name zone");
227 kmalloc_raise_limit(tmp->tm_node_zone, sizeof(struct tmpfs_node) *
230 tmp->tm_node_zone_malloc_args.objsize = sizeof(struct tmpfs_node);
231 tmp->tm_node_zone_malloc_args.mtype = tmp->tm_node_zone;
233 tmp->tm_dirent_zone_malloc_args.objsize = sizeof(struct tmpfs_dirent);
234 tmp->tm_dirent_zone_malloc_args.mtype = tmp->tm_dirent_zone;
236 tmp->tm_dirent_pool = objcache_create( "tmpfs dirent cache",
239 objcache_malloc_alloc, objcache_malloc_free,
240 &tmp->tm_dirent_zone_malloc_args);
241 tmp->tm_node_pool = objcache_create( "tmpfs node cache",
243 tmpfs_node_ctor, tmpfs_node_dtor, NULL,
244 tmpfs_node_init, tmpfs_node_fini,
245 &tmp->tm_node_zone_malloc_args);
247 /* Allocate the root node. */
248 error = tmpfs_alloc_node(tmp, VDIR, root_uid, root_gid,
249 root_mode & ALLPERMS, NULL, NULL,
250 VNOVAL, VNOVAL, &root);
253 * We are backed by swap, set snocache chflags flag so we
254 * don't trip over swapcache.
256 root->tn_flags = SF_NOCACHE;
258 if (error != 0 || root == NULL) {
259 objcache_destroy(tmp->tm_node_pool);
260 objcache_destroy(tmp->tm_dirent_pool);
261 kfree(tmp, M_TMPFSMNT);
264 KASSERT(root->tn_id >= 0, ("tmpfs root with invalid ino: %d", (int)root->tn_id));
267 mp->mnt_flag |= MNT_LOCAL;
269 mp->mnt_kern_flag |= MNTK_RD_MPSAFE | MNTK_WR_MPSAFE | MNTK_GA_MPSAFE |
270 MNTK_IN_MPSAFE | MNTK_SG_MPSAFE;
272 mp->mnt_kern_flag |= MNTK_NOMSYNC;
273 mp->mnt_data = (qaddr_t)tmp;
277 vfs_add_vnodeops(mp, &tmpfs_vnode_vops, &mp->mnt_vn_norm_ops);
278 vfs_add_vnodeops(mp, &tmpfs_fifo_vops, &mp->mnt_vn_fifo_ops);
280 copystr("tmpfs", mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
281 bzero(mp->mnt_stat.f_mntfromname +size, MNAMELEN - size);
282 bzero(mp->mnt_stat.f_mntonname, sizeof(mp->mnt_stat.f_mntonname));
283 copyinstr(path, mp->mnt_stat.f_mntonname,
284 sizeof(mp->mnt_stat.f_mntonname) -1,
287 tmpfs_statfs(mp, &mp->mnt_stat, cred);
292 /* --------------------------------------------------------------------- */
296 tmpfs_unmount(struct mount *mp, int mntflags)
301 struct tmpfs_mount *tmp;
302 struct tmpfs_node *node;
304 /* Handle forced unmounts. */
305 if (mntflags & MNT_FORCE)
308 tmp = VFS_TO_TMPFS(mp);
311 * Finalize all pending I/O. In the case of tmpfs we want
312 * to throw all the data away so clean out the buffer cache
313 * and vm objects before calling vflush().
315 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
316 if (node->tn_type == VREG && node->tn_vnode) {
318 TMPFS_NODE_LOCK(node);
319 vx_get(node->tn_vnode);
320 tmpfs_truncate(node->tn_vnode, 0);
321 vx_put(node->tn_vnode);
322 TMPFS_NODE_UNLOCK(node);
326 error = vflush(mp, 0, flags);
331 * First pass get rid of all the directory entries and
332 * vnode associations. The directory structure will
333 * remain via the extra link count representing tn_dir.tn_parent.
335 * No vnodes should remain after the vflush above.
337 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
339 TMPFS_NODE_LOCK(node);
340 if (node->tn_type == VDIR) {
341 struct tmpfs_dirent *de;
343 while (!TAILQ_EMPTY(&node->tn_dir.tn_dirhead)) {
344 de = TAILQ_FIRST(&node->tn_dir.tn_dirhead);
345 tmpfs_dir_detach(node, de);
346 tmpfs_free_dirent(tmp, de);
347 node->tn_size -= sizeof(struct tmpfs_dirent);
350 KKASSERT(node->tn_vnode == NULL);
356 node->tn_vnode = NULL;
359 TMPFS_NODE_UNLOCK(node);
364 * Now get rid of all nodes. We can remove any node with a
365 * link count of 0 or any directory node with a link count of
366 * 1. The parents will not be destroyed until all their children
367 * have been destroyed.
369 * Recursion in tmpfs_free_node() can further modify the list so
370 * we cannot use a next pointer here.
372 * The root node will be destroyed by this loop (it will be last).
374 while (!LIST_EMPTY(&tmp->tm_nodes_used)) {
376 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
377 if (node->tn_links == 0 ||
378 (node->tn_links == 1 && node->tn_type == VDIR)) {
379 TMPFS_NODE_LOCK(node);
380 tmpfs_free_node(tmp, node);
387 kprintf("tmpfs: Cannot free entire node tree!");
392 KKASSERT(tmp->tm_root == NULL);
394 objcache_destroy(tmp->tm_dirent_pool);
395 objcache_destroy(tmp->tm_node_pool);
397 kmalloc_destroy(&tmp->tm_name_zone);
398 kmalloc_destroy(&tmp->tm_dirent_zone);
399 kmalloc_destroy(&tmp->tm_node_zone);
401 tmp->tm_node_zone = tmp->tm_dirent_zone = NULL;
403 lockuninit(&tmp->allnode_lock);
404 KKASSERT(tmp->tm_pages_used == 0);
405 KKASSERT(tmp->tm_nodes_inuse == 0);
407 /* Throw away the tmpfs_mount structure. */
408 kfree(tmp, M_TMPFSMNT);
411 mp->mnt_flag &= ~MNT_LOCAL;
415 /* --------------------------------------------------------------------- */
418 tmpfs_root(struct mount *mp, struct vnode **vpp)
420 struct tmpfs_mount *tmp;
423 tmp = VFS_TO_TMPFS(mp);
424 if (tmp->tm_root == NULL) {
425 kprintf("tmpfs_root: called without root node %p\n", mp);
430 error = tmpfs_alloc_vp(mp, tmp->tm_root, LK_EXCLUSIVE, vpp);
431 (*vpp)->v_flag |= VROOT;
432 (*vpp)->v_type = VDIR;
437 /* --------------------------------------------------------------------- */
440 tmpfs_fhtovp(struct mount *mp, struct vnode *rootvp, struct fid *fhp, struct vnode **vpp)
443 struct tmpfs_fid *tfhp;
444 struct tmpfs_mount *tmp;
445 struct tmpfs_node *node;
447 tmp = VFS_TO_TMPFS(mp);
449 tfhp = (struct tmpfs_fid *)fhp;
450 if (tfhp->tf_len != sizeof(struct tmpfs_fid))
453 if (tfhp->tf_id >= tmp->tm_nodes_max)
459 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
460 if (node->tn_id == tfhp->tf_id &&
461 node->tn_gen == tfhp->tf_gen) {
469 return (tmpfs_alloc_vp(mp, node, LK_EXCLUSIVE, vpp));
474 /* --------------------------------------------------------------------- */
478 tmpfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
480 fsfilcnt_t freenodes;
481 struct tmpfs_mount *tmp;
483 tmp = VFS_TO_TMPFS(mp);
485 sbp->f_iosize = PAGE_SIZE;
486 sbp->f_bsize = PAGE_SIZE;
488 sbp->f_blocks = tmp->tm_pages_max;
489 sbp->f_bavail = tmp->tm_pages_max - tmp->tm_pages_used;
490 sbp->f_bfree = sbp->f_bavail;
492 freenodes = tmp->tm_nodes_max - tmp->tm_nodes_inuse;
494 sbp->f_files = freenodes + tmp->tm_nodes_inuse;
495 sbp->f_ffree = freenodes;
496 sbp->f_owner = tmp->tm_root->tn_uid;
501 /* --------------------------------------------------------------------- */
504 * tmpfs vfs operations.
507 static struct vfsops tmpfs_vfsops = {
508 .vfs_mount = tmpfs_mount,
509 .vfs_unmount = tmpfs_unmount,
510 .vfs_root = tmpfs_root,
511 .vfs_statfs = tmpfs_statfs,
512 .vfs_fhtovp = tmpfs_fhtovp,
513 .vfs_sync = vfs_stdsync
516 VFS_SET(tmpfs_vfsops, tmpfs, 0);