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 virtual memory to store file data and
37 * metadata efficiently. It does not follow the structure of an on-disk
38 * file system because it simply does not need to. Instead, it uses
39 * memory-specific data structures and algorithms to automatically
40 * allocate and release resources.
44 #include <sys/param.h>
45 #include <sys/limits.h>
47 #include <sys/kernel.h>
49 #include <sys/systm.h>
50 #include <sys/sysctl.h>
51 #include <sys/objcache.h>
54 #include <vm/vm_object.h>
55 #include <vm/vm_param.h>
58 #include <vfs/tmpfs/tmpfs.h>
61 #include <vfs/tmpfs/tmpfs_vnops.h>
62 #include <vfs/tmpfs/tmpfs_mount.h>
65 * Default permission for root node
67 #define TMPFS_DEFAULT_ROOT_MODE (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
69 MALLOC_DEFINE(M_TMPFSMNT, "tmpfs mount", "tmpfs mount structures");
71 /* --------------------------------------------------------------------- */
73 static int tmpfs_mount(struct mount *, char *, caddr_t, struct ucred *);
74 static int tmpfs_unmount(struct mount *, int);
75 static int tmpfs_root(struct mount *, struct vnode **);
76 static int tmpfs_fhtovp(struct mount *, struct vnode *, struct fid *, struct vnode **);
77 static int tmpfs_statfs(struct mount *, struct statfs *, struct ucred *cred);
79 /* --------------------------------------------------------------------- */
81 tmpfs_node_ctor(void *obj, void *privdata, int flags)
83 struct tmpfs_node *node = obj;
90 node->tn_vnode = NULL;
92 bzero(&node->tn_spec, sizeof(node->tn_spec));
98 tmpfs_node_dtor(void *obj, void *privdata)
100 struct tmpfs_node *node = (struct tmpfs_node *)obj;
101 node->tn_type = VNON;
102 node->tn_vpstate = TMPFS_VNODE_DOOMED;
106 tmpfs_node_init(void *args, int flags)
108 struct tmpfs_node *node;
110 node = objcache_malloc_alloc(args, flags);
114 node->tn_blksize = PAGE_SIZE; /* start small */
116 lockinit(&node->tn_interlock, "tmpfs node interlock", 0, LK_CANRECURSE);
117 node->tn_gen = karc4random();
123 tmpfs_node_fini(void *obj, void *args)
125 struct tmpfs_node *node = (struct tmpfs_node *)obj;
126 lockuninit(&node->tn_interlock);
127 objcache_malloc_free(obj, args);
131 tmpfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
133 struct tmpfs_mount *tmp;
134 struct tmpfs_node *root;
135 struct tmpfs_mount_info args;
137 vm_pindex_t pages_limit;
147 /* Root node attributes. */
148 uid_t root_uid = cred->cr_uid;
149 gid_t root_gid = cred->cr_gid;
150 mode_t root_mode = (VREAD | VWRITE);
152 if (mp->mnt_flag & MNT_UPDATE) {
153 /* XXX: There is no support yet to update file system
154 * settings. Should be added. */
162 bzero(&args, sizeof(args));
169 error = copyin(data, &args, sizeof(args));
173 size_max = args.ta_size_max;
174 nodes_max = args.ta_nodes_max;
175 maxfsize_max = args.ta_maxfsize_max;
176 root_uid = args.ta_root_uid;
177 root_gid = args.ta_root_gid;
178 root_mode = args.ta_root_mode;
182 * If mount by non-root, then verify that user has necessary
183 * permissions on the device.
185 if (cred->cr_uid != 0) {
187 if ((mp->mnt_flag & MNT_RDONLY) == 0)
191 pages_limit = vm_swap_max + vmstats.v_page_count / 2;
194 pages = pages_limit / 2;
195 } else if (size_max < PAGE_SIZE) {
197 } else if (OFF_TO_IDX(size_max) > pages_limit) {
199 * do not force pages = pages_limit for this case, otherwise
200 * we might not honor tmpfs size requests from /etc/fstab
201 * during boot because they are mounted prior to swap being
204 pages = OFF_TO_IDX(size_max);
206 pages = OFF_TO_IDX(size_max);
210 nodes = 3 + pages * PAGE_SIZE / 1024;
211 else if (nodes_max < 3)
213 else if (nodes_max > pages)
218 maxfsize = 0x7FFFFFFFFFFFFFFFLLU - TMPFS_BLKSIZE;
219 if (maxfsize_max != 0 && maxfsize > maxfsize_max)
220 maxfsize = maxfsize_max;
222 /* Allocate the tmpfs mount structure and fill it. */
223 tmp = kmalloc(sizeof(*tmp), M_TMPFSMNT, M_WAITOK | M_ZERO);
226 tmp->tm_nodes_max = nodes;
227 tmp->tm_nodes_inuse = 0;
228 tmp->tm_maxfilesize = maxfsize;
229 LIST_INIT(&tmp->tm_nodes_used);
231 tmp->tm_pages_max = pages;
232 tmp->tm_pages_used = 0;
234 kmalloc_create(&tmp->tm_node_zone, "tmpfs node");
235 kmalloc_create(&tmp->tm_dirent_zone, "tmpfs dirent");
236 kmalloc_create(&tmp->tm_name_zone, "tmpfs name zone");
238 kmalloc_raise_limit(tmp->tm_node_zone, sizeof(struct tmpfs_node) *
241 tmp->tm_node_zone_malloc_args.objsize = sizeof(struct tmpfs_node);
242 tmp->tm_node_zone_malloc_args.mtype = tmp->tm_node_zone;
244 tmp->tm_dirent_zone_malloc_args.objsize = sizeof(struct tmpfs_dirent);
245 tmp->tm_dirent_zone_malloc_args.mtype = tmp->tm_dirent_zone;
247 tmp->tm_dirent_pool = objcache_create( "tmpfs dirent cache",
250 objcache_malloc_alloc, objcache_malloc_free,
251 &tmp->tm_dirent_zone_malloc_args);
252 tmp->tm_node_pool = objcache_create( "tmpfs node cache",
254 tmpfs_node_ctor, tmpfs_node_dtor, NULL,
255 tmpfs_node_init, tmpfs_node_fini,
256 &tmp->tm_node_zone_malloc_args);
258 tmp->tm_ino = TMPFS_ROOTINO;
260 /* Allocate the root node. */
261 error = tmpfs_alloc_node(tmp, VDIR, root_uid, root_gid,
262 root_mode & ALLPERMS, NULL,
263 VNOVAL, VNOVAL, &root);
266 * We are backed by swap, set snocache chflags flag so we
267 * don't trip over swapcache.
269 root->tn_flags = SF_NOCACHE;
271 if (error != 0 || root == NULL) {
272 objcache_destroy(tmp->tm_node_pool);
273 objcache_destroy(tmp->tm_dirent_pool);
274 kfree(tmp, M_TMPFSMNT);
277 KASSERT(root->tn_id == TMPFS_ROOTINO,
278 ("tmpfs root with invalid ino: %ju", (uintmax_t)root->tn_id));
280 atomic_add_int(&root->tn_links, 1); /* keep around */
283 mp->mnt_flag |= MNT_LOCAL;
284 mp->mnt_kern_flag |= MNTK_ALL_MPSAFE;
285 mp->mnt_kern_flag |= MNTK_NOMSYNC;
286 mp->mnt_kern_flag |= MNTK_THR_SYNC; /* new vsyncscan semantics */
287 mp->mnt_kern_flag |= MNTK_QUICKHALT; /* no teardown needed on halt */
288 mp->mnt_data = (qaddr_t)tmp;
289 mp->mnt_iosize_max = MAXBSIZE;
292 vfs_add_vnodeops(mp, &tmpfs_vnode_vops, &mp->mnt_vn_norm_ops);
293 vfs_add_vnodeops(mp, &tmpfs_fifo_vops, &mp->mnt_vn_fifo_ops);
295 copystr("tmpfs", mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
296 bzero(mp->mnt_stat.f_mntfromname +size, MNAMELEN - size);
297 bzero(mp->mnt_stat.f_mntonname, sizeof(mp->mnt_stat.f_mntonname));
298 copyinstr(path, mp->mnt_stat.f_mntonname,
299 sizeof(mp->mnt_stat.f_mntonname) -1,
302 tmpfs_statfs(mp, &mp->mnt_stat, cred);
307 /* --------------------------------------------------------------------- */
311 tmpfs_unmount(struct mount *mp, int mntflags)
315 struct tmpfs_mount *tmp;
316 struct tmpfs_node *node;
320 tmp = VFS_TO_TMPFS(mp);
323 /* Handle forced unmounts. */
324 if (mntflags & MNT_FORCE)
328 * Finalize all pending I/O. In the case of tmpfs we want
329 * to throw all the data away so clean out the buffer cache
330 * and vm objects before calling vflush().
332 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
334 * tn_links is mnt_token protected
336 atomic_add_int(&node->tn_links, 1);
337 TMPFS_NODE_LOCK(node);
339 while (node->tn_type == VREG && node->tn_vnode) {
342 TMPFS_NODE_UNLOCK(node);
346 * vx_get/vx_put and tmpfs_truncate may block,
347 * releasing the tmpfs mountpoint token.
349 * Make sure the lock order is correct.
351 vx_get(vp); /* held vnode */
352 TMPFS_NODE_LOCK(node);
353 if (node->tn_vnode == vp) {
354 tmpfs_truncate(vp, 0);
359 TMPFS_NODE_UNLOCK(node);
362 TMPFS_NODE_LOCK(node);
368 TMPFS_NODE_UNLOCK(node);
369 atomic_add_int(&node->tn_links, -1);
373 * Flush all vnodes on the unmount.
375 * If we fail to flush, we cannot unmount, but all the nodes have
376 * already been truncated. Erroring out is the best we can do.
378 error = vflush(mp, 0, flags);
385 * First pass get rid of all the directory entries and
386 * vnode associations. This will also destroy the
387 * directory topology and should drop all link counts
388 * to 0 except for the root.
390 * No vnodes should remain after the vflush above.
392 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
395 atomic_add_int(&node->tn_links, 1);
396 TMPFS_NODE_LOCK(node);
397 if (node->tn_type == VDIR) {
398 struct tmpfs_dirent *de;
400 while ((de = RB_ROOT(&node->tn_dir.tn_dirtree)) != NULL) {
401 tmpfs_dir_detach_locked(node, de);
402 tmpfs_free_dirent(tmp, de);
405 KKASSERT(node->tn_vnode == NULL);
407 TMPFS_NODE_UNLOCK(node);
408 atomic_add_int(&node->tn_links, -1);
412 * Allow the root node to be destroyed by dropping the link count
413 * we bumped in the mount code.
415 KKASSERT(tmp->tm_root);
416 TMPFS_NODE_LOCK(tmp->tm_root);
417 atomic_add_int(&tmp->tm_root->tn_links, -1);
418 TMPFS_NODE_UNLOCK(tmp->tm_root);
421 * At this point all nodes, including the root node, should have a
422 * link count of 0. The root is not necessarily going to be last.
424 while ((node = LIST_FIRST(&tmp->tm_nodes_used)) != NULL) {
426 panic("tmpfs: Dangling nodes during umount (%p)!\n",
429 TMPFS_NODE_LOCK(node);
430 tmpfs_free_node(tmp, node);
434 KKASSERT(tmp->tm_root == NULL);
436 objcache_destroy(tmp->tm_dirent_pool);
437 objcache_destroy(tmp->tm_node_pool);
439 kmalloc_destroy(&tmp->tm_name_zone);
440 kmalloc_destroy(&tmp->tm_dirent_zone);
441 kmalloc_destroy(&tmp->tm_node_zone);
443 tmp->tm_node_zone = tmp->tm_dirent_zone = NULL;
445 KKASSERT(tmp->tm_pages_used == 0);
446 KKASSERT(tmp->tm_nodes_inuse == 0);
450 /* Throw away the tmpfs_mount structure. */
451 kfree(tmp, M_TMPFSMNT);
454 mp->mnt_flag &= ~MNT_LOCAL;
458 /* --------------------------------------------------------------------- */
461 tmpfs_root(struct mount *mp, struct vnode **vpp)
463 struct tmpfs_mount *tmp;
466 tmp = VFS_TO_TMPFS(mp);
467 if (tmp->tm_root == NULL) {
468 kprintf("tmpfs_root: called without root node %p\n", mp);
473 error = tmpfs_alloc_vp(mp, NULL, tmp->tm_root,
475 (*vpp)->v_flag |= VROOT;
476 (*vpp)->v_type = VDIR;
481 /* --------------------------------------------------------------------- */
484 tmpfs_fhtovp(struct mount *mp, struct vnode *rootvp, struct fid *fhp,
488 struct tmpfs_fid *tfhp;
489 struct tmpfs_mount *tmp;
490 struct tmpfs_node *node;
493 tmp = VFS_TO_TMPFS(mp);
495 tfhp = (struct tmpfs_fid *) fhp;
496 if (tfhp->tf_len != sizeof(struct tmpfs_fid))
503 LIST_FOREACH(node, &tmp->tm_nodes_used, tn_entries) {
504 if (node->tn_id == tfhp->tf_id &&
505 node->tn_gen == tfhp->tf_gen) {
512 rc = tmpfs_alloc_vp(mp, NULL, node, LK_EXCLUSIVE, vpp);
519 /* --------------------------------------------------------------------- */
523 tmpfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
525 fsfilcnt_t freenodes;
526 struct tmpfs_mount *tmp;
528 tmp = VFS_TO_TMPFS(mp);
530 /* TMPFS_LOCK(tmp); not really needed */
532 sbp->f_iosize = PAGE_SIZE;
533 sbp->f_bsize = PAGE_SIZE;
535 sbp->f_blocks = tmp->tm_pages_max;
536 sbp->f_bavail = tmp->tm_pages_max - tmp->tm_pages_used;
537 sbp->f_bfree = sbp->f_bavail;
539 freenodes = tmp->tm_nodes_max - tmp->tm_nodes_inuse;
541 sbp->f_files = freenodes + tmp->tm_nodes_inuse;
542 sbp->f_ffree = freenodes;
543 sbp->f_owner = tmp->tm_root->tn_uid;
545 /* TMPFS_UNLOCK(tmp); */
550 /* --------------------------------------------------------------------- */
553 tmpfs_vptofh(struct vnode *vp, struct fid *fhp)
555 struct tmpfs_node *node;
556 struct tmpfs_fid tfh;
557 node = VP_TO_TMPFS_NODE(vp);
558 memset(&tfh, 0, sizeof(tfh));
559 tfh.tf_len = sizeof(struct tmpfs_fid);
560 tfh.tf_gen = node->tn_gen;
561 tfh.tf_id = node->tn_id;
562 memcpy(fhp, &tfh, sizeof(tfh));
566 /* --------------------------------------------------------------------- */
569 tmpfs_checkexp(struct mount *mp, struct sockaddr *nam, int *exflagsp,
570 struct ucred **credanonp)
572 struct tmpfs_mount *tmp;
575 tmp = (struct tmpfs_mount *) mp->mnt_data;
576 nc = vfs_export_lookup(mp, &tmp->tm_export, nam);
580 *exflagsp = nc->netc_exflags;
581 *credanonp = &nc->netc_anon;
586 /* --------------------------------------------------------------------- */
589 * tmpfs vfs operations.
592 static struct vfsops tmpfs_vfsops = {
594 .vfs_mount = tmpfs_mount,
595 .vfs_unmount = tmpfs_unmount,
596 .vfs_root = tmpfs_root,
597 .vfs_statfs = tmpfs_statfs,
598 .vfs_fhtovp = tmpfs_fhtovp,
599 .vfs_vptofh = tmpfs_vptofh,
600 .vfs_checkexp = tmpfs_checkexp,
603 VFS_SET(tmpfs_vfsops, tmpfs, VFCF_MPSAFE);
604 MODULE_VERSION(tmpfs, 1);