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