xref: /dragonfly/sys/vfs/mfs/mfs_vfsops.c (revision 23265324) 
1 /*
2  * Copyright (c) 1989, 1990, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	@(#)mfs_vfsops.c	8.11 (Berkeley) 6/19/95
34  * $FreeBSD: src/sys/ufs/mfs/mfs_vfsops.c,v 1.81.2.3 2001/07/04 17:35:21 tegge Exp $
35  * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.36 2007/02/03 17:05:59 corecode Exp $
36  */
37 
38 
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/conf.h>
42 #include <sys/device.h>
43 #include <sys/kernel.h>
44 #include <sys/proc.h>
45 #include <sys/buf.h>
46 #include <sys/mount.h>
47 #include <sys/signalvar.h>
48 #include <sys/vnode.h>
49 #include <sys/malloc.h>
50 #include <sys/linker.h>
51 #include <sys/fcntl.h>
52 
53 #include <vm/vm.h>
54 #include <vm/vm_object.h>
55 #include <vm/vm_page.h>
56 #include <vm/vm_pager.h>
57 #include <vm/vnode_pager.h>
58 
59 #include <sys/buf2.h>
60 #include <sys/thread2.h>
61 
62 #include <vfs/ufs/quota.h>
63 #include <vfs/ufs/inode.h>
64 #include <vfs/ufs/ufsmount.h>
65 #include <vfs/ufs/ufs_extern.h>
66 #include <vfs/ufs/fs.h>
67 #include <vfs/ufs/ffs_extern.h>
68 
69 #include "mfsnode.h"
70 #include "mfs_extern.h"
71 
72 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
73 
74 extern struct vop_ops *mfs_vnode_vops_p;
75 
76 static int	mfs_mount (struct mount *mp,
77 			char *path, caddr_t data, struct ucred *td);
78 static int	mfs_start (struct mount *mp, int flags);
79 static int	mfs_statfs (struct mount *mp, struct statfs *sbp,
80 			struct ucred *cred);
81 static int	mfs_init (struct vfsconf *);
82 
83 d_open_t	mfsopen;
84 d_close_t	mfsclose;
85 d_strategy_t	mfsstrategy;
86 
87 #define MFS_CDEV_MAJOR	253
88 
89 static struct dev_ops mfs_ops = {
90 	{ "MFS", MFS_CDEV_MAJOR, D_DISK },
91 	.d_open =	mfsopen,
92 	.d_close =	mfsclose,
93 	.d_read =	physread,
94 	.d_write =	physwrite,
95 	.d_strategy =	mfsstrategy,
96 };
97 
98 /*
99  * mfs vfs operations.
100  */
101 static struct vfsops mfs_vfsops = {
102 	.vfs_mount =     	mfs_mount,
103 	.vfs_start =    	mfs_start,
104 	.vfs_unmount =   	ffs_unmount,
105 	.vfs_root =     	ufs_root,
106 	.vfs_quotactl =  	ufs_quotactl,
107 	.vfs_statfs =   	mfs_statfs,
108 	.vfs_sync =     	ffs_sync,
109 	.vfs_vget =      	ffs_vget,
110 	.vfs_fhtovp =   	ffs_fhtovp,
111 	.vfs_checkexp =  	ufs_check_export,
112 	.vfs_vptofh =   	ffs_vptofh,
113 	.vfs_init =     	mfs_init
114 };
115 
116 VFS_SET(mfs_vfsops, mfs, 0);
117 
118 /*
119  * We allow the underlying MFS block device to be opened and read.
120  */
121 int
122 mfsopen(struct dev_open_args *ap)
123 {
124 	cdev_t dev = ap->a_head.a_dev;
125 
126 	if (ap->a_oflags & FWRITE)
127 		return(EROFS);
128 	if (dev->si_drv1)
129 		return(0);
130 	return(ENXIO);
131 }
132 
133 int
134 mfsclose(struct dev_close_args *ap)
135 {
136 	return(0);
137 }
138 
139 int
140 mfsstrategy(struct dev_strategy_args *ap)
141 {
142 	cdev_t dev = ap->a_head.a_dev;
143 	struct bio *bio = ap->a_bio;
144 	struct buf *bp = bio->bio_buf;
145 	off_t boff = bio->bio_offset;
146 	off_t eoff = boff + bp->b_bcount;
147 	struct mfsnode *mfsp;
148 
149 	if ((mfsp = dev->si_drv1) == NULL) {
150 		bp->b_error = ENXIO;
151 		goto error;
152 	}
153 	if (boff < 0)
154 		goto bad;
155 	if (eoff > mfsp->mfs_size) {
156 		if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
157 			goto bad;
158 		/*
159 		 * Return EOF by completing the I/O with 0 bytes transfered.
160 		 * Set B_INVAL to indicate that any data in the buffer is not
161 		 * valid.
162 		 */
163 		if (boff == mfsp->mfs_size) {
164 			bp->b_resid = bp->b_bcount;
165 			bp->b_flags |= B_INVAL;
166 			goto done;
167 		}
168 		bp->b_bcount = mfsp->mfs_size - boff;
169 	}
170 
171 	/*
172 	 * Initiate I/O
173 	 */
174 	bioq_insert_tail(&mfsp->bio_queue, bio);
175 	wakeup((caddr_t)mfsp);
176 	return(0);
177 
178 	/*
179 	 * Failure conditions on bio
180 	 */
181 bad:
182 	bp->b_error = EINVAL;
183 error:
184 	bp->b_flags |= B_ERROR | B_INVAL;
185 done:
186 	biodone(bio);
187 	return(0);
188 }
189 
190 /*
191  * mfs_mount
192  *
193  * Called when mounting local physical media
194  *
195  * PARAMETERS:
196  *		mountroot
197  *			mp	mount point structure
198  *			path	NULL (flag for root mount!!!)
199  *			data	<unused>
200  *			ndp	<unused>
201  *			p	process (user credentials check [statfs])
202  *
203  *		mount
204  *			mp	mount point structure
205  *			path	path to mount point
206  *			data	pointer to argument struct in user space
207  *			ndp	mount point namei() return (used for
208  *				credentials on reload), reused to look
209  *				up block device.
210  *			p	process (user credentials check)
211  *
212  * RETURNS:	0	Success
213  *		!0	error number (errno.h)
214  *
215  * LOCK STATE:
216  *
217  *		ENTRY
218  *			mount point is locked
219  *		EXIT
220  *			mount point is locked
221  *
222  * NOTES:
223  *		A NULL path can be used for a flag since the mount
224  *		system call will fail with EFAULT in copyinstr in
225  *		namei() if it is a genuine NULL from the user.
226  */
227 /* ARGSUSED */
228 static int
229 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
230 {
231 	struct vnode *devvp;
232 	struct mfs_args args;
233 	struct ufsmount *ump;
234 	struct fs *fs;
235 	struct mfsnode *mfsp;
236 	size_t size;
237 	int flags, err;
238 	int minnum;
239 	cdev_t dev;
240 
241 	/*
242 	 * Use NULL path to flag a root mount
243 	 */
244 	if( path == NULL) {
245 		/*
246 		 ***
247 		 * Mounting root file system
248 		 ***
249 		 */
250 
251 		/* you lose */
252 		panic("mfs_mount: mount MFS as root: not configured!");
253 	}
254 
255 	/*
256 	 ***
257 	 * Mounting non-root file system or updating a file system
258 	 ***
259 	 */
260 
261 	/* copy in user arguments*/
262 	if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
263 		goto error_1;
264 
265 	/*
266 	 * If updating, check whether changing from read-only to
267 	 * read/write; if there is no device name, that's all we do.
268 	 */
269 	if (mp->mnt_flag & MNT_UPDATE) {
270 		/*
271 		 ********************
272 		 * UPDATE
273 		 ********************
274 		 */
275 		ump = VFSTOUFS(mp);
276 		fs = ump->um_fs;
277 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
278 			flags = WRITECLOSE;
279 			if (mp->mnt_flag & MNT_FORCE)
280 				flags |= FORCECLOSE;
281 			err = ffs_flushfiles(mp, flags);
282 			if (err)
283 				goto error_1;
284 		}
285 		if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
286 			/* XXX reopen the device vnode read-write */
287 			fs->fs_ronly = 0;
288 		}
289 		/* if not updating name...*/
290 		if (args.fspec == 0) {
291 			/*
292 			 * Process export requests.  Jumping to "success"
293 			 * will return the vfs_export() error code.
294 			 */
295 			err = vfs_export(mp, &ump->um_export, &args.export);
296 			goto success;
297 		}
298 
299 		/* XXX MFS does not support name updating*/
300 		goto success;
301 	}
302 	/*
303 	 * Do the MALLOC before the getnewvnode since doing so afterward
304 	 * might cause a bogus v_data pointer to get dereferenced
305 	 * elsewhere if MALLOC should block.
306 	 */
307 	MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
308 
309 	err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops_p, &devvp, 0, 0);
310 	if (err) {
311 		FREE(mfsp, M_MFSNODE);
312 		goto error_1;
313 	}
314 
315 	minnum = (curproc->p_pid & 0xFF) |
316 		((curproc->p_pid & ~0xFF) << 8);
317 
318 	devvp->v_type = VCHR;
319 	dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
320 			"MFS%d", minnum >> 16);
321 	/* It is not clear that these will get initialized otherwise */
322 	dev->si_bsize_phys = DEV_BSIZE;
323 	dev->si_iosize_max = DFLTPHYS;
324 	dev->si_drv1 = mfsp;
325 	addaliasu(devvp, makeudev(MFS_CDEV_MAJOR, minnum));
326 	devvp->v_data = mfsp;
327 	mfsp->mfs_baseoff = args.base;
328 	mfsp->mfs_size = args.size;
329 	mfsp->mfs_vnode = devvp;
330 	mfsp->mfs_dev = reference_dev(dev);
331 	mfsp->mfs_td = curthread;
332 	mfsp->mfs_active = 1;
333 	bioq_init(&mfsp->bio_queue);
334 
335 	/*
336 	 * Our 'block' device must be backed by a VM object.  Theoretically
337 	 * we could use the anonymous memory VM object supplied by userland,
338 	 * but it would be somewhat of a complex task to deal with it
339 	 * that way since it would result in I/O requests which supply
340 	 * the VM pages from our own object.
341 	 *
342 	 * vnode_pager_alloc() is typically called when a VM object is
343 	 * being referenced externally.  We have to undo the refs for
344 	 * the self reference between vnode and object.
345 	 */
346 	vnode_pager_alloc(devvp, args.size, 0, 0);
347 	--devvp->v_usecount;
348 	--devvp->v_object->ref_count;
349 
350 	/* Save "mounted from" info for mount point (NULL pad)*/
351 	copyinstr(	args.fspec,			/* device name*/
352 			mp->mnt_stat.f_mntfromname,	/* save area*/
353 			MNAMELEN - 1,			/* max size*/
354 			&size);				/* real size*/
355 	bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
356 
357 	vx_unlock(devvp);
358 	if ((err = ffs_mountfs(devvp, mp, M_MFSNODE)) != 0) {
359 		mfsp->mfs_active = 0;
360 		goto error_2;
361 	}
362 
363 	/*
364 	 * Initialize FS stat information in mount struct; uses
365 	 * mp->mnt_stat.f_mntfromname.
366 	 *
367 	 * This code is common to root and non-root mounts
368 	 */
369 	VFS_STATFS(mp, &mp->mnt_stat, cred);
370 
371 	goto success;
372 
373 error_2:	/* error with devvp held*/
374 
375 	/* release devvp before failing*/
376 	vrele(devvp);
377 
378 error_1:	/* no state to back out*/
379 
380 success:
381 	return( err);
382 }
383 
384 /*
385  * Used to grab the process and keep it in the kernel to service
386  * memory filesystem I/O requests.
387  *
388  * Loop servicing I/O requests.
389  * Copy the requested data into or out of the memory filesystem
390  * address space.
391  */
392 /* ARGSUSED */
393 static int
394 mfs_start(struct mount *mp, int flags)
395 {
396 	struct vnode *vp = VFSTOUFS(mp)->um_devvp;
397 	struct mfsnode *mfsp = VTOMFS(vp);
398 	struct bio *bio;
399 	struct buf *bp;
400 	int gotsig = 0, sig;
401 	thread_t td = curthread;
402 
403 	/*
404 	 * We must prevent the system from trying to swap
405 	 * out or kill ( when swap space is low, see vm/pageout.c ) the
406 	 * process.  A deadlock can occur if the process is swapped out,
407 	 * and the system can loop trying to kill the unkillable ( while
408 	 * references exist ) MFS process when swap space is low.
409 	 */
410 	KKASSERT(curproc);
411 	PHOLD(curproc);
412 
413 	mfsp->mfs_td = td;
414 
415 	while (mfsp->mfs_active) {
416 		crit_enter();
417 
418 		while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) {
419 			bioq_remove(&mfsp->bio_queue, bio);
420 			crit_exit();
421 			bp = bio->bio_buf;
422 			mfs_doio(bio, mfsp);
423 			wakeup(bp);
424 			crit_enter();
425 		}
426 
427 		crit_exit();
428 
429 		/*
430 		 * If a non-ignored signal is received, try to unmount.
431 		 * If that fails, clear the signal (it has been "processed"),
432 		 * otherwise we will loop here, as tsleep will always return
433 		 * EINTR/ERESTART.
434 		 */
435 		/*
436 		 * Note that dounmount() may fail if work was queued after
437 		 * we slept. We have to jump hoops here to make sure that we
438 		 * process any buffers after the sleep, before we dounmount()
439 		 */
440 		if (gotsig) {
441 			gotsig = 0;
442 			if (dounmount(mp, 0) != 0) {
443 				KKASSERT(td->td_proc);
444 				sig = CURSIG(td->td_lwp);
445 				if (sig)
446 					SIGDELSET(td->td_proc->p_siglist, sig);
447 			}
448 		}
449 		else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
450 			gotsig++;	/* try to unmount in next pass */
451 	}
452 	PRELE(curproc);
453 	v_release_rdev(vp);	/* hack because we do not implement CLOSE */
454 	/* XXX destroy/release devvp */
455 	return (0);
456 }
457 
458 /*
459  * Get file system statistics.
460  */
461 static int
462 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
463 {
464 	int error;
465 
466 	error = ffs_statfs(mp, sbp, cred);
467 	sbp->f_type = mp->mnt_vfc->vfc_typenum;
468 	return (error);
469 }
470 
471 /*
472  * Memory based filesystem initialization.
473  */
474 static int
475 mfs_init(struct vfsconf *vfsp)
476 {
477 	dev_ops_add(&mfs_ops, 0, 0);
478 	return (0);
479 }
480