xref: /titanic_52/usr/src/uts/common/fs/mntfs/mntvfsops.c (revision f38cb554a534c6df738be3f4d23327e69888e634)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 #include <sys/types.h>
26 #include <sys/param.h>
27 #include <sys/cmn_err.h>
28 #include <sys/cred.h>
29 #include <sys/debug.h>
30 #include <sys/errno.h>
31 #include <sys/proc.h>
32 #include <sys/procfs.h>
33 #include <sys/stat.h>
34 #include <sys/statvfs.h>
35 #include <sys/sysmacros.h>
36 #include <sys/systm.h>
37 #include <sys/var.h>
38 #include <sys/vfs.h>
39 #include <sys/vfs_opreg.h>
40 #include <sys/vnode.h>
41 #include <sys/mode.h>
42 #include <sys/signal.h>
43 #include <sys/user.h>
44 #include <sys/mount.h>
45 #include <sys/bitmap.h>
46 #include <sys/kmem.h>
47 #include <sys/policy.h>
48 #include <fs/fs_subr.h>
49 #include <sys/fs/mntdata.h>
50 #include <sys/zone.h>
51 
52 /*
53  * This is the loadable module wrapper.
54  */
55 #include <sys/modctl.h>
56 
57 static int mntinit(int, char *);
58 
59 static mntopts_t mnt_mntopts = {
60 	0,
61 	NULL
62 };
63 
64 static vfsdef_t vfw = {
65 	VFSDEF_VERSION,
66 	"mntfs",
67 	mntinit,
68 	VSW_HASPROTO|VSW_STATS|VSW_ZMOUNT,
69 	&mnt_mntopts
70 };
71 
72 /*
73  * Module linkage information for the kernel.
74  */
75 extern struct mod_ops mod_fsops;
76 
77 static struct modlfs modlfs = {
78 	&mod_fsops, "mount information file system", &vfw
79 };
80 
81 static struct modlinkage modlinkage = {
82 	MODREV_1, (void *)&modlfs, NULL
83 };
84 
85 int
86 _init(void)
87 {
88 	return (mod_install(&modlinkage));
89 }
90 
91 int
92 _info(struct modinfo *modinfop)
93 {
94 	return (mod_info(&modlinkage, modinfop));
95 }
96 
97 /*
98  * N.B.
99  * No _fini routine. The module cannot be unloaded once loaded.
100  * The NO_UNLOAD_STUB in modstubs.s must change if this module
101  * is ever modified to become unloadable.
102  */
103 
104 extern int	mntfstype;
105 static major_t	mnt_major;
106 static minor_t	mnt_minor;
107 static kmutex_t	mnt_minor_lock;
108 
109 /*
110  * /mnttab VFS operations vector.
111  */
112 static int	mntmount(), mntunmount(), mntroot(), mntstatvfs();
113 
114 static void
115 mntinitrootnode(mntnode_t *mnp)
116 {
117 	struct vnode *vp;
118 
119 	bzero((caddr_t)mnp, sizeof (*mnp));
120 
121 	mnp->mnt_vnode = vn_alloc(KM_SLEEP);
122 
123 	vp = MTOV(mnp);
124 
125 	vp->v_flag = VROOT|VNOCACHE|VNOMAP|VNOSWAP|VNOMOUNT;
126 	vn_setops(vp, mntvnodeops);
127 	vp->v_type = VREG;
128 	vp->v_data = (caddr_t)mnp;
129 }
130 
131 static int
132 mntinit(int fstype, char *name)
133 {
134 	static const fs_operation_def_t mnt_vfsops_template[] = {
135 		VFSNAME_MOUNT,		{ .vfs_mount = mntmount },
136 		VFSNAME_UNMOUNT,	{ .vfs_unmount = mntunmount },
137 		VFSNAME_ROOT,		{ .vfs_root = mntroot },
138 		VFSNAME_STATVFS,	{ .vfs_statvfs = mntstatvfs },
139 		NULL,			NULL
140 	};
141 	extern const fs_operation_def_t mnt_vnodeops_template[];
142 	int error;
143 
144 	mntfstype = fstype;
145 	ASSERT(mntfstype != 0);
146 	/*
147 	 * Associate VFS ops vector with this fstype.
148 	 */
149 	error = vfs_setfsops(fstype, mnt_vfsops_template, NULL);
150 	if (error != 0) {
151 		cmn_err(CE_WARN, "mntinit: bad vfs ops template");
152 		return (error);
153 	}
154 
155 	/* Vnode ops too. */
156 
157 	error = vn_make_ops(name, mnt_vnodeops_template, &mntvnodeops);
158 	if (error != 0) {
159 		(void) vfs_freevfsops_by_type(fstype);
160 		cmn_err(CE_WARN, "mntinit: bad vnode ops template");
161 		return (error);
162 	}
163 
164 	/*
165 	 * Assign a unique "device" number (used by stat(2)).
166 	 */
167 	if ((mnt_major = getudev()) == (major_t)-1) {
168 		cmn_err(CE_WARN, "mntinit: can't get unique device number");
169 		mnt_major = 0;
170 	}
171 	mutex_init(&mnt_minor_lock, NULL, MUTEX_DEFAULT, NULL);
172 
173 	return (0);
174 }
175 
176 /* ARGSUSED */
177 static int
178 mntmount(struct vfs *vfsp, struct vnode *mvp,
179 	struct mounta *uap, struct cred *cr)
180 {
181 	mntdata_t *mnt;
182 	mntnode_t *mnp;
183 	zone_t *zone = curproc->p_zone;
184 
185 	if (secpolicy_fs_mount(cr, mvp, vfsp) != 0)
186 		return (EPERM);
187 
188 	/*
189 	 * You can only mount mnttab in your current zone.
190 	 */
191 	if (zone == global_zone) {
192 		zone_t *mntzone;
193 
194 		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
195 		ASSERT(mntzone != NULL);
196 		zone_rele(mntzone);
197 		if (mntzone != zone)
198 			return (EBUSY);
199 	}
200 
201 	/*
202 	 * Having the resource be anything but "mnttab" doesn't make sense
203 	 */
204 	vfs_setresource(vfsp, "mnttab", 0);
205 
206 	mnt = kmem_zalloc(sizeof (*mnt), KM_SLEEP);
207 	mutex_enter(&mvp->v_lock);
208 	if ((uap->flags & MS_OVERLAY) == 0 &&
209 	    (mvp->v_count > 1 || (mvp->v_flag & VROOT))) {
210 		mutex_exit(&mvp->v_lock);
211 		kmem_free(mnt, sizeof (*mnt));
212 		return (EBUSY);
213 	}
214 	mutex_exit(&mvp->v_lock);
215 
216 	zone_init_ref(&mnt->mnt_zone_ref);
217 	zone_hold_ref(zone, &mnt->mnt_zone_ref, ZONE_REF_MNTFS);
218 	mnp = &mnt->mnt_node;
219 
220 	vfsp->vfs_fstype = mntfstype;
221 	vfsp->vfs_data = (caddr_t)mnt;
222 	/*
223 	 * find an available minor device number for this mount.
224 	 */
225 	mutex_enter(&mnt_minor_lock);
226 	do {
227 		mnt_minor = (mnt_minor + 1) & L_MAXMIN32;
228 		vfsp->vfs_dev = makedevice(mnt_major, mnt_minor);
229 	} while (vfs_devismounted(vfsp->vfs_dev));
230 	mutex_exit(&mnt_minor_lock);
231 	vfs_make_fsid(&vfsp->vfs_fsid, vfsp->vfs_dev, mntfstype);
232 	vfsp->vfs_bsize = DEV_BSIZE;
233 	mntinitrootnode(mnp);
234 	MTOV(mnp)->v_vfsp = vfsp;
235 	mnp->mnt_mountvp = mvp;
236 	vn_exists(MTOV(mnp));
237 	return (0);
238 }
239 
240 /* ARGSUSED */
241 static int
242 mntunmount(struct vfs *vfsp, int flag, struct cred *cr)
243 {
244 	mntdata_t *mnt = (mntdata_t *)vfsp->vfs_data;
245 	vnode_t *vp = MTOV(&mnt->mnt_node);
246 
247 	if (secpolicy_fs_unmount(cr, vfsp) != 0)
248 		return (EPERM);
249 
250 	/*
251 	 * Ensure that no /mnttab vnodes are in use on this mount point.
252 	 */
253 	mutex_enter(&vp->v_lock);
254 	if (vp->v_count > 1 || mnt->mnt_nopen > 0) {
255 		mutex_exit(&vp->v_lock);
256 		return (EBUSY);
257 	}
258 
259 	mutex_exit(&vp->v_lock);
260 	zone_rele_ref(&mnt->mnt_zone_ref, ZONE_REF_MNTFS);
261 	vn_invalid(vp);
262 	vn_free(vp);
263 	kmem_free(mnt, sizeof (*mnt));
264 	return (0);
265 }
266 
267 /* ARGSUSED */
268 static int
269 mntroot(struct vfs *vfsp, struct vnode **vpp)
270 {
271 	mntnode_t *mnp = &((mntdata_t *)vfsp->vfs_data)->mnt_node;
272 	struct vnode *vp = MTOV(mnp);
273 
274 	VN_HOLD(vp);
275 	*vpp = vp;
276 	return (0);
277 }
278 
279 static int
280 mntstatvfs(struct vfs *vfsp, struct statvfs64 *sp)
281 {
282 	dev32_t d32;
283 
284 	bzero((caddr_t)sp, sizeof (*sp));
285 	sp->f_bsize	= DEV_BSIZE;
286 	sp->f_frsize	= DEV_BSIZE;
287 	sp->f_blocks	= (fsblkcnt64_t)0;
288 	sp->f_bfree	= (fsblkcnt64_t)0;
289 	sp->f_bavail	= (fsblkcnt64_t)0;
290 	sp->f_files	= (fsfilcnt64_t)1;
291 	sp->f_ffree	= (fsfilcnt64_t)0;
292 	sp->f_favail	= (fsfilcnt64_t)0;
293 	(void) cmpldev(&d32, vfsp->vfs_dev);
294 	sp->f_fsid	= d32;
295 	(void) strcpy(sp->f_basetype, vfssw[mntfstype].vsw_name);
296 	sp->f_flag = vf_to_stf(vfsp->vfs_flag);
297 	sp->f_namemax = 64;		/* quite arbitrary */
298 	bzero(sp->f_fstr, sizeof (sp->f_fstr));
299 	(void) strcpy(sp->f_fstr, "/mnttab");
300 	(void) strcpy(&sp->f_fstr[8], "/mnttab");
301 	return (0);
302 }
303