xref: /titanic_52/usr/src/uts/common/fs/bootfs/bootfs_vfsops.c (revision 263f549e5da8b32c4922f586afb365b8ae388a6c)
1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright (c) 2015 Joyent, Inc.
14  */
15 
16 #include <sys/errno.h>
17 #include <sys/modctl.h>
18 #include <sys/types.h>
19 #include <sys/mkdev.h>
20 #include <sys/ddi.h>
21 #include <sys/sunddi.h>
22 #include <sys/vfs.h>
23 #include <sys/vfs_opreg.h>
24 #include <sys/systm.h>
25 #include <sys/id_space.h>
26 #include <sys/cmn_err.h>
27 #include <sys/ksynch.h>
28 #include <sys/policy.h>
29 #include <sys/mount.h>
30 #include <sys/sysmacros.h>
31 
32 #include <sys/fs/bootfs_impl.h>
33 
34 /*
35  * While booting, additional types of modules and files can be passed in to the
36  * loader. These include the familiar boot archive, as well as, a module hash
37  * and additional modules that are interpreted as files. As part of the handoff
38  * in early boot, information about these modules are saved as properties on the
39  * root of the devinfo tree, similar to other boot-time properties.
40  *
41  * This file system provides a read-only view of those additional files. Due to
42  * its limited scope, it has a slightly simpler construction than several other
43  * file systems. When mounted, it looks for the corresponding properties and
44  * creates bootfs_node_t's and vnodes for all of the corresponding files and
45  * directories that exist along the way. At this time, there are currently a
46  * rather small number of files passed in this way.
47  *
48  * This does lead to one behavior that folks used to other file systems might
49  * find peculiar. Because we are not always actively creating and destroying the
50  * required vnodes on demand, the count on the root vnode will not be going up
51  * accordingly with the existence of other vnodes. This means that a bootfs file
52  * system that is not in use will have all of its vnodes exist with a v_count of
53  * one.
54  */
55 
56 major_t bootfs_major;
57 static int bootfs_fstype;
58 static id_space_t *bootfs_idspace;
59 static uint64_t bootfs_nactive;
60 static kmutex_t bootfs_lock;
61 
62 static const char *bootfs_name = "bootfs";
63 
64 static int
65 bootfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
66 {
67 	int ret;
68 	bootfs_t *bfs;
69 	struct pathname dpn;
70 	dev_t fsdev;
71 
72 	if ((ret = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
73 		return (ret);
74 
75 	if (mvp->v_type != VDIR)
76 		return (ENOTDIR);
77 
78 	if (uap->flags & MS_REMOUNT)
79 		return (EBUSY);
80 
81 	mutex_enter(&mvp->v_lock);
82 	if ((uap->flags & MS_OVERLAY) == 0 &&
83 	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
84 		mutex_exit(&mvp->v_lock);
85 		return (EBUSY);
86 	}
87 	mutex_exit(&mvp->v_lock);
88 
89 	/*
90 	 * We indicate that the backing store is bootfs. We don't want to use
91 	 * swap, because folks might think that this is putting all the data
92 	 * into memory ala tmpfs. Rather these modules are always in memory and
93 	 * there's nothing to be done about that.
94 	 */
95 	vfs_setresource(vfsp, bootfs_name, 0);
96 	bfs = kmem_zalloc(sizeof (bootfs_t), KM_NOSLEEP | KM_NORMALPRI);
97 	if (bfs == NULL)
98 		return (ENOMEM);
99 
100 	ret = pn_get(uap->dir,
101 	    (uap->flags & MS_SYSSPACE) ? UIO_SYSSPACE : UIO_USERSPACE, &dpn);
102 	if (ret != 0) {
103 		kmem_free(bfs, sizeof (bfs));
104 		return (ret);
105 	}
106 
107 	bfs->bfs_minor = id_alloc(bootfs_idspace);
108 	bfs->bfs_kstat = kstat_create_zone("bootfs", bfs->bfs_minor, "bootfs",
109 	    "fs", KSTAT_TYPE_NAMED,
110 	    sizeof (bootfs_stat_t) / sizeof (kstat_named_t),
111 	    KSTAT_FLAG_VIRTUAL, GLOBAL_ZONEID);
112 	if (bfs->bfs_kstat == NULL) {
113 		id_free(bootfs_idspace, bfs->bfs_minor);
114 		pn_free(&dpn);
115 		kmem_free(bfs, sizeof (bfs));
116 		return (ENOMEM);
117 	}
118 	bfs->bfs_kstat->ks_data = &bfs->bfs_stat;
119 
120 	fsdev = makedevice(bootfs_major, bfs->bfs_minor);
121 	bfs->bfs_vfsp = vfsp;
122 
123 	vfsp->vfs_data = (caddr_t)bfs;
124 	vfsp->vfs_fstype = bootfs_fstype;
125 	vfsp->vfs_dev = fsdev;
126 	vfsp->vfs_bsize = PAGESIZE;
127 	vfsp->vfs_flag |= VFS_RDONLY | VFS_NOSETUID | VFS_NOTRUNC |
128 	    VFS_UNLINKABLE;
129 	vfs_make_fsid(&vfsp->vfs_fsid, fsdev, bootfs_fstype);
130 	bfs->bfs_mntpath = kmem_alloc(dpn.pn_pathlen + 1, KM_SLEEP);
131 	bcopy(dpn.pn_path, bfs->bfs_mntpath, dpn.pn_pathlen);
132 	bfs->bfs_mntpath[dpn.pn_pathlen] = '\0';
133 	pn_free(&dpn);
134 	list_create(&bfs->bfs_nodes, sizeof (bootfs_node_t),
135 	    offsetof(bootfs_node_t, bvn_alink));
136 
137 	kstat_named_init(&bfs->bfs_stat.bfss_nfiles, "nfiles",
138 	    KSTAT_DATA_UINT32);
139 	kstat_named_init(&bfs->bfs_stat.bfss_ndirs, "ndirs",
140 	    KSTAT_DATA_UINT32);
141 	kstat_named_init(&bfs->bfs_stat.bfss_nbytes, "nbytes",
142 	    KSTAT_DATA_UINT64);
143 	kstat_named_init(&bfs->bfs_stat.bfss_ndups, "ndup",
144 	    KSTAT_DATA_UINT32);
145 	kstat_named_init(&bfs->bfs_stat.bfss_ndiscards, "ndiscard",
146 	    KSTAT_DATA_UINT32);
147 
148 	bootfs_construct(bfs);
149 
150 	kstat_install(bfs->bfs_kstat);
151 
152 	return (0);
153 }
154 
155 static int
156 bootfs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
157 {
158 	int ret;
159 	bootfs_t *bfs = vfsp->vfs_data;
160 	bootfs_node_t *bnp;
161 
162 	if ((ret = secpolicy_fs_unmount(cr, vfsp)) != 0)
163 		return (ret);
164 
165 	if (flag & MS_FORCE)
166 		return (ENOTSUP);
167 
168 	for (bnp = list_head(&bfs->bfs_nodes); bnp != NULL;
169 	    bnp = list_next(&bfs->bfs_nodes, bnp)) {
170 		mutex_enter(&bnp->bvn_vnp->v_lock);
171 		if (bnp->bvn_vnp->v_count > 1) {
172 			mutex_exit(&bnp->bvn_vnp->v_lock);
173 			return (EBUSY);
174 		}
175 		mutex_exit(&bnp->bvn_vnp->v_lock);
176 	}
177 
178 	kstat_delete(bfs->bfs_kstat);
179 	bootfs_destruct(bfs);
180 	list_destroy(&bfs->bfs_nodes);
181 	kmem_free(bfs->bfs_mntpath, strlen(bfs->bfs_mntpath) + 1);
182 	id_free(bootfs_idspace, bfs->bfs_minor);
183 	kmem_free(bfs, sizeof (bootfs_t));
184 	return (0);
185 }
186 
187 static int
188 bootfs_root(vfs_t *vfsp, vnode_t **vpp)
189 {
190 	bootfs_t *bfs;
191 
192 	bfs = (bootfs_t *)vfsp->vfs_data;
193 	*vpp = bfs->bfs_rootvn->bvn_vnp;
194 	VN_HOLD(*vpp)
195 
196 	return (0);
197 }
198 
199 static int
200 bootfs_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
201 {
202 	const bootfs_t *bfs = (bootfs_t *)vfsp;
203 	dev32_t d32;
204 
205 	sbp->f_bsize = PAGESIZE;
206 	sbp->f_frsize = PAGESIZE;
207 
208 	sbp->f_blocks = bfs->bfs_stat.bfss_nbytes.value.ui64 >> PAGESHIFT;
209 	sbp->f_bfree = 0;
210 	sbp->f_bavail = 0;
211 
212 	sbp->f_files = bfs->bfs_stat.bfss_nfiles.value.ui32 +
213 	    bfs->bfs_stat.bfss_ndirs.value.ui32;
214 	sbp->f_ffree = 0;
215 	sbp->f_favail = 0;
216 
217 	(void) cmpldev(&d32, vfsp->vfs_dev);
218 	sbp->f_fsid = d32;
219 	(void) strlcpy(sbp->f_basetype, bootfs_name, FSTYPSZ);
220 	bzero(sbp->f_fstr, sizeof (sbp->f_fstr));
221 
222 	return (0);
223 }
224 
225 static const fs_operation_def_t bootfs_vfsops_tmpl[] = {
226 	VFSNAME_MOUNT,		{ .vfs_mount = bootfs_mount },
227 	VFSNAME_UNMOUNT,	{ .vfs_unmount = bootfs_unmount },
228 	VFSNAME_ROOT,		{ .vfs_root = bootfs_root },
229 	VFSNAME_STATVFS,	{ .vfs_statvfs = bootfs_statvfs },
230 	NULL,			NULL
231 };
232 
233 static int
234 bootfs_init(int fstype, char *name)
235 {
236 	int ret;
237 
238 	bootfs_fstype = fstype;
239 	ASSERT(bootfs_fstype != 0);
240 
241 	ret = vfs_setfsops(fstype, bootfs_vfsops_tmpl, NULL);
242 	if (ret != 0)
243 		return (ret);
244 
245 	ret = vn_make_ops(name, bootfs_vnodeops_template, &bootfs_vnodeops);
246 	if (ret != 0) {
247 		(void) vfs_freevfsops_by_type(bootfs_fstype);
248 		return (ret);
249 	}
250 
251 	bootfs_major = getudev();
252 	if (bootfs_major == (major_t)-1) {
253 		cmn_err(CE_WARN, "bootfs_init: Can't get unique device number");
254 		bootfs_major = 0;
255 	}
256 
257 	bootfs_nactive = 0;
258 	return (0);
259 }
260 
261 static mntopts_t bootfs_mntopts = {
262 	0, NULL
263 };
264 
265 static vfsdef_t bootfs_vfsdef = {
266 	VFSDEF_VERSION,
267 	"bootfs",
268 	bootfs_init,
269 	VSW_HASPROTO|VSW_STATS,
270 	&bootfs_mntopts
271 };
272 
273 static struct modlfs bootfs_modlfs = {
274 	&mod_fsops, "boot-time modules file system", &bootfs_vfsdef
275 };
276 
277 static struct modlinkage bootfs_modlinkage = {
278 	MODREV_1, &bootfs_modlfs, NULL
279 };
280 
281 int
282 _init(void)
283 {
284 	bootfs_node_cache = kmem_cache_create("bootfs_node_cache",
285 	    sizeof (bootfs_node_t), 0, bootfs_node_constructor,
286 	    bootfs_node_destructor, NULL, NULL, NULL, 0);
287 	bootfs_idspace = id_space_create("bootfs_minors", 1, INT32_MAX);
288 	mutex_init(&bootfs_lock, NULL, MUTEX_DEFAULT, NULL);
289 
290 	return (mod_install(&bootfs_modlinkage));
291 }
292 
293 int
294 _info(struct modinfo *modinfop)
295 {
296 	return (mod_info(&bootfs_modlinkage, modinfop));
297 }
298 
299 int
300 _fini(void)
301 {
302 	int err;
303 
304 	mutex_enter(&bootfs_lock);
305 	if (bootfs_nactive > 0) {
306 		mutex_exit(&bootfs_lock);
307 		return (EBUSY);
308 	}
309 	mutex_exit(&bootfs_lock);
310 
311 	err = mod_remove(&bootfs_modlinkage);
312 	if (err != 0)
313 		return (err);
314 
315 	(void) vfs_freevfsops_by_type(bootfs_fstype);
316 	vn_freevnodeops(bootfs_vnodeops);
317 	id_space_destroy(bootfs_idspace);
318 	mutex_destroy(&bootfs_lock);
319 	kmem_cache_destroy(bootfs_node_cache);
320 	return (err);
321 }
322