Merge from vendor branch GPERF:
[dragonfly.git] / sys / vfs / mfs / mfs_vfsops.c
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.21 2005/02/02 21:34:18 joerg Exp $
36  */
37
38
39 #include "opt_mfs.h"
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/conf.h>
44 #include <sys/kernel.h>
45 #include <sys/proc.h>
46 #include <sys/buf.h>
47 #include <sys/mount.h>
48 #include <sys/signalvar.h>
49 #include <sys/vnode.h>
50 #include <sys/malloc.h>
51 #include <sys/linker.h>
52 #include <sys/fcntl.h>
53
54 #include <sys/buf2.h>
55
56 #include <vfs/ufs/quota.h>
57 #include <vfs/ufs/inode.h>
58 #include <vfs/ufs/ufsmount.h>
59 #include <vfs/ufs/ufs_extern.h>
60 #include <vfs/ufs/fs.h>
61 #include <vfs/ufs/ffs_extern.h>
62
63 #include "mfsnode.h"
64 #include "mfs_extern.h"
65
66 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
67
68
69 extern struct vop_ops *mfs_vnode_vops;
70
71 static int      mfs_mount (struct mount *mp,
72                         char *path, caddr_t data, struct thread *td);
73 static int      mfs_start (struct mount *mp, int flags, struct thread *td);
74 static int      mfs_statfs (struct mount *mp, struct statfs *sbp, 
75                         struct thread *td);
76 static int      mfs_init (struct vfsconf *);
77
78 d_open_t        mfsopen;
79 d_close_t       mfsclose;
80 d_strategy_t    mfsstrategy;
81
82 #define MFS_CDEV_MAJOR  253
83
84 static struct cdevsw mfs_cdevsw = {
85         /* name */      "MFS",
86         /* maj */       MFS_CDEV_MAJOR,
87         /* flags */     D_DISK,
88         /* port */      NULL,
89         /* clone */     NULL,
90
91         /* open */      mfsopen,
92         /* close */     mfsclose,
93         /* read */      physread,
94         /* write */     physwrite,
95         /* ioctl */     noioctl,
96         /* poll */      nopoll,
97         /* mmap */      nommap,
98         /* strategy */  mfsstrategy,
99         /* dump */      nodump,
100         /* psize */     nopsize
101 };
102
103 /*
104  * mfs vfs operations.
105  */
106 static struct vfsops mfs_vfsops = {
107         mfs_mount,
108         mfs_start,
109         ffs_unmount,
110         ufs_root,
111         ufs_quotactl,
112         mfs_statfs,
113         ffs_sync,
114         ffs_vget,
115         ffs_fhtovp,
116         ufs_check_export,
117         ffs_vptofh,
118         mfs_init,
119         vfs_stduninit,
120         vfs_stdextattrctl,
121 };
122
123 VFS_SET(mfs_vfsops, mfs, 0);
124
125 /*
126  * We allow the underlying MFS block device to be opened and read.
127  */
128 int
129 mfsopen(dev_t dev, int flags, int mode, struct thread *td)
130 {
131         if (flags & FWRITE)
132                 return(EROFS);
133         if (dev->si_drv1)
134                 return(0);
135         return(ENXIO);
136 }
137
138 int
139 mfsclose(dev_t dev, int flags, int mode, struct thread *td)
140 {
141         return(0);
142 }
143
144 void
145 mfsstrategy(struct buf *bp)
146 {
147         struct mfsnode *mfsp;
148
149         if ((mfsp = bp->b_dev->si_drv1) != NULL) {
150                 off_t boff = (off_t)bp->b_blkno << DEV_BSHIFT;
151                 off_t eoff = boff + bp->b_bcount;
152
153                 if (eoff <= mfsp->mfs_size) {
154                         bufq_insert_tail(&mfsp->buf_queue, bp);
155                         wakeup((caddr_t)mfsp);
156                 } else if (boff < mfsp->mfs_size) {
157                         bp->b_bcount = mfsp->mfs_size - boff;
158                         bufq_insert_tail(&mfsp->buf_queue, bp);
159                         wakeup((caddr_t)mfsp);
160                 } else if (boff == mfsp->mfs_size) {
161                         bp->b_resid = bp->b_bcount;
162                         biodone(bp);
163                 } else {
164                         bp->b_error = EINVAL;
165                         biodone(bp);
166                 }
167         } else {
168                 bp->b_error = ENXIO;
169                 bp->b_flags |= B_ERROR;
170                 biodone(bp);
171         }
172 }
173
174 /*
175  * mfs_mount
176  *
177  * Called when mounting local physical media
178  *
179  * PARAMETERS:
180  *              mountroot
181  *                      mp      mount point structure
182  *                      path    NULL (flag for root mount!!!)
183  *                      data    <unused>
184  *                      ndp     <unused>
185  *                      p       process (user credentials check [statfs])
186  *
187  *              mount
188  *                      mp      mount point structure
189  *                      path    path to mount point
190  *                      data    pointer to argument struct in user space
191  *                      ndp     mount point namei() return (used for
192  *                              credentials on reload), reused to look
193  *                              up block device.
194  *                      p       process (user credentials check)
195  *
196  * RETURNS:     0       Success
197  *              !0      error number (errno.h)
198  *
199  * LOCK STATE:
200  *
201  *              ENTRY
202  *                      mount point is locked
203  *              EXIT
204  *                      mount point is locked
205  *
206  * NOTES:
207  *              A NULL path can be used for a flag since the mount
208  *              system call will fail with EFAULT in copyinstr in
209  *              namei() if it is a genuine NULL from the user.
210  */
211 /* ARGSUSED */
212 static int
213 mfs_mount(struct mount *mp, char *path, caddr_t data, struct thread *td)
214 {
215         struct vnode *devvp;
216         struct mfs_args args;
217         struct ufsmount *ump;
218         struct fs *fs;
219         struct mfsnode *mfsp;
220         size_t size;
221         int flags, err;
222         int minnum;
223         dev_t dev;
224
225         /*
226          * Use NULL path to flag a root mount
227          */
228         if( path == NULL) {
229                 /*
230                  ***
231                  * Mounting root file system
232                  ***
233                  */
234
235                 /* you lose */
236                 panic("mfs_mount: mount MFS as root: not configured!");
237         }
238
239         /*
240          ***
241          * Mounting non-root file system or updating a file system
242          ***
243          */
244
245         /* copy in user arguments*/
246         if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
247                 goto error_1;
248
249         /*
250          * If updating, check whether changing from read-only to
251          * read/write; if there is no device name, that's all we do.
252          */
253         if (mp->mnt_flag & MNT_UPDATE) {
254                 /*
255                  ********************
256                  * UPDATE
257                  ********************
258                  */
259                 ump = VFSTOUFS(mp);
260                 fs = ump->um_fs;
261                 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
262                         flags = WRITECLOSE;
263                         if (mp->mnt_flag & MNT_FORCE)
264                                 flags |= FORCECLOSE;
265                         err = ffs_flushfiles(mp, flags, td);
266                         if (err)
267                                 goto error_1;
268                 }
269                 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR))
270                         fs->fs_ronly = 0;
271                 /* if not updating name...*/
272                 if (args.fspec == 0) {
273                         /*
274                          * Process export requests.  Jumping to "success"
275                          * will return the vfs_export() error code. 
276                          */
277                         err = vfs_export(mp, &ump->um_export, &args.export);
278                         goto success;
279                 }
280
281                 /* XXX MFS does not support name updating*/
282                 goto success;
283         }
284         /*
285          * Do the MALLOC before the getnewvnode since doing so afterward
286          * might cause a bogus v_data pointer to get dereferenced
287          * elsewhere if MALLOC should block.
288          */
289         MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
290
291         err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops, &devvp, 0, 0);
292         if (err) {
293                 FREE(mfsp, M_MFSNODE);
294                 goto error_1;
295         }
296
297         minnum = (curproc->p_pid & 0xFF) |
298                 ((curproc->p_pid & ~0xFF) << 8);
299
300         devvp->v_type = VCHR;
301         dev = make_dev(&mfs_cdevsw, minnum, UID_ROOT, GID_WHEEL, 0600,
302                         "MFS%d", minnum >> 16);
303         /* It is not clear that these will get initialized otherwise */
304         dev->si_bsize_phys = DEV_BSIZE;
305         dev->si_iosize_max = DFLTPHYS;
306         dev->si_drv1 = mfsp;
307         addaliasu(devvp, makeudev(MFS_CDEV_MAJOR, minnum));
308         devvp->v_data = mfsp;
309         mfsp->mfs_baseoff = args.base;
310         mfsp->mfs_size = args.size;
311         mfsp->mfs_vnode = devvp;
312         mfsp->mfs_dev = reference_dev(dev);
313         mfsp->mfs_td = td;
314         mfsp->mfs_active = 1;
315         bufq_init(&mfsp->buf_queue);
316
317         /* Save "mounted from" info for mount point (NULL pad)*/
318         copyinstr(      args.fspec,                     /* device name*/
319                         mp->mnt_stat.f_mntfromname,     /* save area*/
320                         MNAMELEN - 1,                   /* max size*/
321                         &size);                         /* real size*/
322         bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
323
324         vx_unlock(devvp);
325         if ((err = ffs_mountfs(devvp, mp, td, M_MFSNODE)) != 0) { 
326                 mfsp->mfs_active = 0;
327                 goto error_2;
328         }
329
330         /*
331          * Initialize FS stat information in mount struct; uses
332          * mp->mnt_stat.f_mntfromname.
333          *
334          * This code is common to root and non-root mounts
335          */
336         (void) VFS_STATFS(mp, &mp->mnt_stat, td);
337
338         goto success;
339
340 error_2:        /* error with devvp held*/
341
342         /* release devvp before failing*/
343         vrele(devvp);
344
345 error_1:        /* no state to back out*/
346
347 success:
348         return( err);
349 }
350
351 /*
352  * Used to grab the process and keep it in the kernel to service
353  * memory filesystem I/O requests.
354  *
355  * Loop servicing I/O requests.
356  * Copy the requested data into or out of the memory filesystem
357  * address space.
358  */
359 /* ARGSUSED */
360 static int
361 mfs_start(struct mount *mp, int flags, struct thread *td)
362 {
363         struct vnode *vp = VFSTOUFS(mp)->um_devvp;
364         struct mfsnode *mfsp = VTOMFS(vp);
365         struct buf *bp;
366         int gotsig = 0, sig;
367
368         /*
369          * We must prevent the system from trying to swap
370          * out or kill ( when swap space is low, see vm/pageout.c ) the
371          * process.  A deadlock can occur if the process is swapped out,
372          * and the system can loop trying to kill the unkillable ( while
373          * references exist ) MFS process when swap space is low.
374          */
375         KKASSERT(curproc);
376         PHOLD(curproc);
377
378         while (mfsp->mfs_active) {
379                 int s;
380
381                 s = splbio();
382
383                 while ((bp = bufq_first(&mfsp->buf_queue)) != NULL) {
384                         bufq_remove(&mfsp->buf_queue, bp);
385                         splx(s);
386                         mfs_doio(bp, mfsp);
387                         wakeup((caddr_t)bp);
388                         s = splbio();
389                 }
390
391                 splx(s);
392
393                 /*
394                  * If a non-ignored signal is received, try to unmount.
395                  * If that fails, clear the signal (it has been "processed"),
396                  * otherwise we will loop here, as tsleep will always return
397                  * EINTR/ERESTART.
398                  */
399                 /*
400                  * Note that dounmount() may fail if work was queued after
401                  * we slept. We have to jump hoops here to make sure that we
402                  * process any buffers after the sleep, before we dounmount()
403                  */
404                 if (gotsig) {
405                         gotsig = 0;
406                         if (dounmount(mp, 0, td) != 0) {
407                                 KKASSERT(td->td_proc);
408                                 sig = CURSIG(td->td_proc);
409                                 if (sig)
410                                         SIGDELSET(td->td_proc->p_siglist, sig);
411                         }
412                 }
413                 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
414                         gotsig++;       /* try to unmount in next pass */
415         }
416         PRELE(curproc);
417         v_release_rdev(vp);     /* hack because we do not implement CLOSE */
418         /* XXX destroy/release devvp */
419         return (0);
420 }
421
422 /*
423  * Get file system statistics.
424  */
425 static int
426 mfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
427 {
428         int error;
429
430         error = ffs_statfs(mp, sbp, td);
431         sbp->f_type = mp->mnt_vfc->vfc_typenum;
432         return (error);
433 }
434
435 /*
436  * Memory based filesystem initialization.
437  */
438 static int
439 mfs_init(struct vfsconf *vfsp)
440 {
441         cdevsw_add(&mfs_cdevsw, 0, 0);
442         return (0);
443 }