xref: /dragonfly/sys/vfs/mfs/mfs_vfsops.c (revision dc71b7ab)
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. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *	@(#)mfs_vfsops.c	8.11 (Berkeley) 6/19/95
30  * $FreeBSD: src/sys/ufs/mfs/mfs_vfsops.c,v 1.81.2.3 2001/07/04 17:35:21 tegge Exp $
31  */
32 
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/conf.h>
37 #include <sys/device.h>
38 #include <sys/kernel.h>
39 #include <sys/proc.h>
40 #include <sys/buf.h>
41 #include <sys/mount.h>
42 #include <sys/signalvar.h>
43 #include <sys/signal2.h>
44 #include <sys/vnode.h>
45 #include <sys/malloc.h>
46 #include <sys/sysproto.h>
47 #include <sys/mman.h>
48 #include <sys/linker.h>
49 #include <sys/fcntl.h>
50 #include <sys/nlookup.h>
51 #include <sys/devfs.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 #include <vm/vm_extern.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 static int	mfs_mount (struct mount *mp,
76 			char *path, caddr_t data, struct ucred *td);
77 static int	mfs_start (struct mount *mp, int flags);
78 static int	mfs_statfs (struct mount *mp, struct statfs *sbp,
79 			struct ucred *cred);
80 static int	mfs_init (struct vfsconf *);
81 static void	mfs_doio(struct bio *bio, struct mfsnode *mfsp);
82 
83 d_open_t	mfsopen;
84 d_close_t	mfsclose;
85 d_strategy_t	mfsstrategy;
86 
87 static struct dev_ops mfs_ops = {
88 	{ "MFS", -1, D_DISK },
89 	.d_open =	mfsopen,
90 	.d_close =	mfsclose,
91 	.d_read =	physread,
92 	.d_write =	physwrite,
93 	.d_strategy =	mfsstrategy,
94 };
95 
96 /*
97  * mfs vfs operations.
98  */
99 static struct vfsops mfs_vfsops = {
100 	.vfs_mount =     	mfs_mount,
101 	.vfs_start =    	mfs_start,
102 	.vfs_unmount =   	ffs_unmount,
103 	.vfs_root =     	ufs_root,
104 	.vfs_quotactl =  	ufs_quotactl,
105 	.vfs_statfs =   	mfs_statfs,
106 	.vfs_sync =     	ffs_sync,
107 	.vfs_vget =      	ffs_vget,
108 	.vfs_fhtovp =   	ffs_fhtovp,
109 	.vfs_checkexp =  	ufs_check_export,
110 	.vfs_vptofh =   	ffs_vptofh,
111 	.vfs_init =     	mfs_init
112 };
113 
114 VFS_SET(mfs_vfsops, mfs, 0);
115 MODULE_VERSION(mfs, 1);
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 0
126 	if (ap->a_oflags & FWRITE)
127 		return(EROFS);
128 #endif
129 	if (dev->si_drv1)
130 		return(0);
131 	return(ENXIO);
132 }
133 
134 int
135 mfsclose(struct dev_close_args *ap)
136 {
137 	cdev_t dev = ap->a_head.a_dev;
138 	struct mfsnode *mfsp;
139 
140 	if ((mfsp = dev->si_drv1) == NULL)
141 		return(0);
142         mfsp->mfs_active = 0;
143         wakeup((caddr_t)mfsp);
144 	return(0);
145 }
146 
147 int
148 mfsstrategy(struct dev_strategy_args *ap)
149 {
150 	cdev_t dev = ap->a_head.a_dev;
151 	struct bio *bio = ap->a_bio;
152 	struct buf *bp = bio->bio_buf;
153 	off_t boff = bio->bio_offset;
154 	off_t eoff = boff + bp->b_bcount;
155 	struct mfsnode *mfsp;
156 
157 	if ((mfsp = dev->si_drv1) == NULL) {
158 		bp->b_error = ENXIO;
159 		goto error;
160 	}
161 	if (boff < 0)
162 		goto bad;
163 	if (eoff > mfsp->mfs_size) {
164 		if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
165 			goto bad;
166 		/*
167 		 * Return EOF by completing the I/O with 0 bytes transfered.
168 		 * Set B_INVAL to indicate that any data in the buffer is not
169 		 * valid.
170 		 */
171 		if (boff == mfsp->mfs_size) {
172 			bp->b_resid = bp->b_bcount;
173 			bp->b_flags |= B_INVAL;
174 			goto done;
175 		}
176 		bp->b_bcount = mfsp->mfs_size - boff;
177 	}
178 
179 	/*
180 	 * Initiate I/O
181 	 */
182 	if (mfsp->mfs_td == curthread) {
183 		mfs_doio(bio, mfsp);
184 	} else {
185 		bioq_insert_tail(&mfsp->bio_queue, bio);
186 		wakeup((caddr_t)mfsp);
187 	}
188 	return(0);
189 
190 	/*
191 	 * Failure conditions on bio
192 	 */
193 bad:
194 	bp->b_error = EINVAL;
195 error:
196 	bp->b_flags |= B_ERROR | B_INVAL;
197 done:
198 	biodone(bio);
199 	return(0);
200 }
201 
202 /*
203  * mfs_mount
204  *
205  * Called when mounting local physical media
206  *
207  * PARAMETERS:
208  *		mountroot
209  *			mp	mount point structure
210  *			path	NULL (flag for root mount!!!)
211  *			data	<unused>
212  *			ndp	<unused>
213  *			p	process (user credentials check [statfs])
214  *
215  *		mount
216  *			mp	mount point structure
217  *			path	path to mount point
218  *			data	pointer to argument struct in user space
219  *			ndp	mount point namei() return (used for
220  *				credentials on reload), reused to look
221  *				up block device.
222  *			p	process (user credentials check)
223  *
224  * RETURNS:	0	Success
225  *		!0	error number (errno.h)
226  *
227  * LOCK STATE:
228  *
229  *		ENTRY
230  *			mount point is locked
231  *		EXIT
232  *			mount point is locked
233  *
234  * NOTES:
235  *		A NULL path can be used for a flag since the mount
236  *		system call will fail with EFAULT in copyinstr in
237  *		namei() if it is a genuine NULL from the user.
238  */
239 /* ARGSUSED */
240 static int
241 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
242 {
243 	struct vnode *devvp;
244 	struct mfs_args args;
245 	struct ufsmount *ump;
246 	struct fs *fs;
247 	struct mfsnode *mfsp;
248 	struct nlookupdata nd;
249 	size_t size;
250 	char devname[16];
251 	int flags;
252 	int minnum;
253 	int error;
254 	cdev_t dev;
255 
256 	/*
257 	 * Use NULL path to flag a root mount
258 	 */
259 	if (path == NULL) {
260 		/*
261 		 ***
262 		 * Mounting root file system
263 		 ***
264 		 */
265 
266 		/* you lose */
267 		panic("mfs_mount: mount MFS as root: not configured!");
268 	}
269 
270 	mfsp = NULL;
271 
272 	/*
273 	 ***
274 	 * Mounting non-root file system or updating a file system
275 	 ***
276 	 */
277 
278 	/* copy in user arguments*/
279 	error = copyin(data, (caddr_t)&args, sizeof (struct mfs_args));
280 	if (error)
281 		goto error_1;
282 
283 	/*
284 	 * If updating, check whether changing from read-only to
285 	 * read/write; if there is no device name, that's all we do.
286 	 */
287 	if (mp->mnt_flag & MNT_UPDATE) {
288 		/*
289 		 ********************
290 		 * UPDATE
291 		 ********************
292 		 */
293 		ump = VFSTOUFS(mp);
294 		fs = ump->um_fs;
295 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
296 			flags = WRITECLOSE;
297 			if (mp->mnt_flag & MNT_FORCE)
298 				flags |= FORCECLOSE;
299 			error = ffs_flushfiles(mp, flags);
300 			if (error)
301 				goto error_1;
302 		}
303 		if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
304 			/* XXX reopen the device vnode read-write */
305 			fs->fs_ronly = 0;
306 		}
307 		/* if not updating name...*/
308 		if (args.fspec == 0) {
309 			/*
310 			 * Process export requests.  Jumping to "success"
311 			 * will return the vfs_export() error code.
312 			 */
313 			error = vfs_export(mp, &ump->um_export, &args.export);
314 			goto success;
315 		}
316 
317 		/* XXX MFS does not support name updating*/
318 		goto success;
319 	}
320 
321 	/*
322 	 * Do the MALLOC before the make_dev since doing so afterward
323 	 * might cause a bogus v_data pointer to get dereferenced
324 	 * elsewhere if MALLOC should block.
325 	 */
326 	mfsp = kmalloc(sizeof *mfsp, M_MFSNODE, M_WAITOK | M_ZERO);
327 
328 	minnum = (int)curproc->p_pid;
329 
330 	dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
331 		       "mfs%d", minnum);
332 	/* It is not clear that these will get initialized otherwise */
333 	dev->si_bsize_phys = DEV_BSIZE;
334 	dev->si_iosize_max = MAXPHYS;
335 	dev->si_drv1 = mfsp;
336 	mfsp->mfs_baseoff = args.base;
337 	mfsp->mfs_size = args.size;
338 	mfsp->mfs_dev = dev;
339 	mfsp->mfs_td = curthread;
340 	mfsp->mfs_active = 1;
341 	bioq_init(&mfsp->bio_queue);
342 
343 	devfs_config();	/* sync devfs work */
344 	ksnprintf(devname, sizeof(devname), "/dev/mfs%d", minnum);
345 	nlookup_init(&nd, devname, UIO_SYSSPACE, 0);
346 	devvp = NULL;
347 	error = nlookup(&nd);
348 	if (error == 0) {
349 		devvp = nd.nl_nch.ncp->nc_vp;
350 		if (devvp == NULL)
351 			error = ENOENT;
352 		error = vget(devvp, LK_SHARED);
353 	}
354 	nlookup_done(&nd);
355 
356 	if (error)
357 		goto error_1;
358 	vn_unlock(devvp);
359 
360 	/*
361 	 * Our 'block' device must be backed by a VM object.  Theoretically
362 	 * we could use the anonymous memory VM object supplied by userland,
363 	 * but it would be somewhat of a complex task to deal with it
364 	 * that way since it would result in I/O requests which supply
365 	 * the VM pages from our own object.
366 	 *
367 	 * vnode_pager_alloc() is typically called when a VM object is
368 	 * being referenced externally.  We have to undo the refs for
369 	 * the self reference between vnode and object.
370 	 */
371 	vnode_pager_setsize(devvp, args.size);
372 
373 	/* Save "mounted from" info for mount point (NULL pad)*/
374 	copyinstr(args.fspec,			/* device name*/
375 		  mp->mnt_stat.f_mntfromname,	/* save area*/
376 		  MNAMELEN - 1,			/* max size*/
377 		  &size);			/* real size*/
378 	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
379 	/* vref is eaten by mount? */
380 
381 	error = ffs_mountfs(devvp, mp, M_MFSNODE);
382 	if (error) {
383 		mfsp->mfs_active = 0;
384 		goto error_2;
385 	}
386 
387 	/*
388 	 * Initialize FS stat information in mount struct; uses
389 	 * mp->mnt_stat.f_mntfromname.
390 	 *
391 	 * This code is common to root and non-root mounts
392 	 */
393 	VFS_STATFS(mp, &mp->mnt_stat, cred);
394 
395 	/*
396 	 * Mark VFS_START MPSAFE; this is to avoid accessing
397 	 * per-mount token after VFS_START exits
398 	 */
399 	mp->mnt_kern_flag |= MNTK_ST_MPSAFE;
400 
401 	goto success;
402 
403 error_2:	/* error with devvp held*/
404 	vrele(devvp);
405 
406 error_1:	/* no state to back out*/
407 	if (mfsp) {
408 		if (mfsp->mfs_dev) {
409 			destroy_dev(mfsp->mfs_dev);
410 			mfsp->mfs_dev = NULL;
411 		}
412 		kfree(mfsp, M_MFSNODE);
413 	}
414 
415 success:
416 	return(error);
417 }
418 
419 /*
420  * Used to grab the process and keep it in the kernel to service
421  * memory filesystem I/O requests.
422  *
423  * Loop servicing I/O requests.
424  * Copy the requested data into or out of the memory filesystem
425  * address space.
426  */
427 /* ARGSUSED */
428 static int
429 mfs_start(struct mount *mp, int flags)
430 {
431 	struct vnode *vp = VFSTOUFS(mp)->um_devvp;
432 	struct mfsnode *mfsp = vp->v_rdev->si_drv1;
433 	struct bio *bio;
434 	struct buf *bp;
435 	int gotsig = 0, sig;
436 	thread_t td = curthread;
437 
438 	/*
439 	 * We must prevent the system from trying to swap
440 	 * out or kill ( when swap space is low, see vm/pageout.c ) the
441 	 * process.  A deadlock can occur if the process is swapped out,
442 	 * and the system can loop trying to kill the unkillable ( while
443 	 * references exist ) MFS process when swap space is low.
444 	 */
445 	KKASSERT(curproc);
446 	PHOLD(curproc);
447 
448 	mfsp->mfs_td = td;
449 
450 	while (mfsp->mfs_active) {
451 		crit_enter();
452 
453 		while ((bio = bioq_takefirst(&mfsp->bio_queue)) != NULL) {
454 			crit_exit();
455 			bp = bio->bio_buf;
456 			mfs_doio(bio, mfsp);
457 			wakeup(bp);
458 			crit_enter();
459 		}
460 
461 		crit_exit();
462 
463 		/*
464 		 * If a non-ignored signal is received, try to unmount.
465 		 * If that fails, clear the signal (it has been "processed"),
466 		 * otherwise we will loop here, as tsleep will always return
467 		 * EINTR/ERESTART.
468 		 */
469 		/*
470 		 * Note that dounmount() may fail if work was queued after
471 		 * we slept. We have to jump hoops here to make sure that we
472 		 * process any buffers after the sleep, before we dounmount()
473 		 */
474 		if (gotsig) {
475 			gotsig = 0;
476 			if (dounmount(mp, 0) != 0) {
477 				KKASSERT(td->td_proc);
478 				sig = CURSIG(td->td_lwp);
479 				if (sig) {
480 					spin_lock(&td->td_lwp->lwp_spin);
481 					lwp_delsig(td->td_lwp, sig);
482 					spin_unlock(&td->td_lwp->lwp_spin);
483 				}
484 			}
485 		}
486 		else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
487 			gotsig++;	/* try to unmount in next pass */
488 	}
489 	PRELE(curproc);
490         if (mfsp->mfs_dev) {
491                 destroy_dev(mfsp->mfs_dev);
492                 mfsp->mfs_dev = NULL;
493         }
494 	kfree(mfsp, M_MFSNODE);
495 	return (EMOUNTEXIT);
496 }
497 
498 /*
499  * Get file system statistics.
500  */
501 static int
502 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
503 {
504 	int error;
505 
506 	error = ffs_statfs(mp, sbp, cred);
507 	sbp->f_type = mp->mnt_vfc->vfc_typenum;
508 	return (error);
509 }
510 
511 /*
512  * Memory based filesystem initialization.
513  */
514 static int
515 mfs_init(struct vfsconf *vfsp)
516 {
517 	return (0);
518 }
519 
520 /*
521  * Memory file system I/O.
522  *
523  * Trivial on the HP since buffer has already been mapping into KVA space.
524  *
525  * Read and Write are handled with a simple copyin and copyout.
526  *
527  * We also partially support VOP_FREEBLKS().  We can't implement
528  * completely -- for example, on fragments or inode metadata, but we can
529  * implement it for page-aligned requests.
530  */
531 static void
532 mfs_doio(struct bio *bio, struct mfsnode *mfsp)
533 {
534 	struct buf *bp = bio->bio_buf;
535 	caddr_t base = mfsp->mfs_baseoff + bio->bio_offset;
536 	int bytes;
537 
538 	switch(bp->b_cmd) {
539 	case BUF_CMD_FREEBLKS:
540 		/*
541 		 * Implement FREEBLKS, which allows the filesystem to tell
542 		 * a block device when blocks are no longer needed (like when
543 		 * a file is deleted).  We use the hook to MADV_FREE the VM.
544 		 * This makes an MFS filesystem work as well or better then
545 		 * a sun-style swap-mounted filesystem.
546 		 */
547 		bytes = bp->b_bcount;
548 
549 		if ((vm_offset_t)base & PAGE_MASK) {
550 			int n = PAGE_SIZE - ((vm_offset_t)base & PAGE_MASK);
551 			bytes -= n;
552 			base += n;
553 		}
554                 if (bytes > 0) {
555                         struct madvise_args uap;
556 
557 			bytes &= ~PAGE_MASK;
558 			if (bytes != 0) {
559 				bzero(&uap, sizeof(uap));
560 				uap.addr  = base;
561 				uap.len   = bytes;
562 				uap.behav = MADV_FREE;
563 				sys_madvise(&uap);
564 			}
565                 }
566 		bp->b_error = 0;
567 		break;
568 	case BUF_CMD_READ:
569 		/*
570 		 * Read data from our 'memory' disk
571 		 */
572 		bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
573 		break;
574 	case BUF_CMD_WRITE:
575 		/*
576 		 * Write data to our 'memory' disk
577 		 */
578 		bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
579 		break;
580 	default:
581 		panic("mfs: bad b_cmd %d", bp->b_cmd);
582 	}
583 	if (bp->b_error)
584 		bp->b_flags |= B_ERROR;
585 	biodone(bio);
586 }
587