drm: Fix debug messages issues introduced by the Linux 4.9 update
[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. 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/spinlock2.h>
45 #include <sys/vnode.h>
46 #include <sys/malloc.h>
47 #include <sys/sysproto.h>
48 #include <sys/mman.h>
49 #include <sys/linker.h>
50 #include <sys/fcntl.h>
51 #include <sys/nlookup.h>
52 #include <sys/devfs.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 #include <vm/vm_extern.h>
60
61 #include <sys/buf2.h>
62 #include <sys/thread2.h>
63
64 #include <vfs/ufs/quota.h>
65 #include <vfs/ufs/inode.h>
66 #include <vfs/ufs/ufsmount.h>
67 #include <vfs/ufs/ufs_extern.h>
68 #include <vfs/ufs/fs.h>
69 #include <vfs/ufs/ffs_extern.h>
70
71 #include "mfsnode.h"
72 #include "mfs_extern.h"
73
74 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
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 static void     mfs_doio(struct bio *bio, struct mfsnode *mfsp);
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 | D_NOEMERGPGR },
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 MODULE_VERSION(mfs, 1);
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 0
127         if (ap->a_oflags & FWRITE)
128                 return(EROFS);
129 #endif
130         if (dev->si_drv1)
131                 return(0);
132         return(ENXIO);
133 }
134
135 int
136 mfsclose(struct dev_close_args *ap)
137 {
138         cdev_t dev = ap->a_head.a_dev;
139         struct mfsnode *mfsp;
140
141         if ((mfsp = dev->si_drv1) == NULL)
142                 return(0);
143         mfsp->mfs_active = 0;
144         wakeup((caddr_t)mfsp);
145         return(0);
146 }
147
148 int
149 mfsstrategy(struct dev_strategy_args *ap)
150 {
151         cdev_t dev = ap->a_head.a_dev;
152         struct bio *bio = ap->a_bio;
153         struct buf *bp = bio->bio_buf;
154         off_t boff = bio->bio_offset;
155         off_t eoff = boff + bp->b_bcount;
156         struct mfsnode *mfsp;
157
158         if ((mfsp = dev->si_drv1) == NULL) {
159                 bp->b_error = ENXIO;
160                 goto error;
161         }
162         if (boff < 0)
163                 goto bad;
164         if (eoff > mfsp->mfs_size) {
165                 if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
166                         goto bad;
167                 /*
168                  * Return EOF by completing the I/O with 0 bytes transfered.
169                  * Set B_INVAL to indicate that any data in the buffer is not
170                  * valid.
171                  */
172                 if (boff == mfsp->mfs_size) {
173                         bp->b_resid = bp->b_bcount;
174                         bp->b_flags |= B_INVAL;
175                         goto done;
176                 }
177                 bp->b_bcount = mfsp->mfs_size - boff;
178         }
179
180         /*
181          * Initiate I/O
182          */
183         if (mfsp->mfs_td == curthread) {
184                 mfs_doio(bio, mfsp);
185         } else {
186                 bioq_insert_tail(&mfsp->bio_queue, bio);
187                 wakeup((caddr_t)mfsp);
188         }
189         return(0);
190
191         /*
192          * Failure conditions on bio
193          */
194 bad:
195         bp->b_error = EINVAL;
196 error:
197         bp->b_flags |= B_ERROR | B_INVAL;
198 done:
199         biodone(bio);
200         return(0);
201 }
202
203 /*
204  * mfs_mount
205  *
206  * Called when mounting local physical media
207  *
208  * PARAMETERS:
209  *              mountroot
210  *                      mp      mount point structure
211  *                      path    NULL (flag for root mount!!!)
212  *                      data    <unused>
213  *                      ndp     <unused>
214  *                      p       process (user credentials check [statfs])
215  *
216  *              mount
217  *                      mp      mount point structure
218  *                      path    path to mount point
219  *                      data    pointer to argument struct in user space
220  *                      ndp     mount point namei() return (used for
221  *                              credentials on reload), reused to look
222  *                              up block device.
223  *                      p       process (user credentials check)
224  *
225  * RETURNS:     0       Success
226  *              !0      error number (errno.h)
227  *
228  * LOCK STATE:
229  *
230  *              ENTRY
231  *                      mount point is locked
232  *              EXIT
233  *                      mount point is locked
234  *
235  * NOTES:
236  *              A NULL path can be used for a flag since the mount
237  *              system call will fail with EFAULT in copyinstr in
238  *              namei() if it is a genuine NULL from the user.
239  */
240 /* ARGSUSED */
241 static int
242 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
243 {
244         struct vnode *devvp;
245         struct mfs_args args;
246         struct ufsmount *ump;
247         struct fs *fs;
248         struct mfsnode *mfsp;
249         struct nlookupdata nd;
250         size_t size;
251         char devname[16];
252         int flags;
253         int minnum;
254         int error;
255         cdev_t dev;
256
257         /*
258          * Use NULL path to flag a root mount
259          */
260         if (path == NULL) {
261                 /*
262                  ***
263                  * Mounting root file system
264                  ***
265                  */
266
267                 /* you lose */
268                 panic("mfs_mount: mount MFS as root: not configured!");
269         }
270
271         mfsp = NULL;
272
273         /*
274          ***
275          * Mounting non-root file system or updating a file system
276          ***
277          */
278
279         /* copy in user arguments*/
280         error = copyin(data, (caddr_t)&args, sizeof (struct mfs_args));
281         if (error)
282                 goto error_1;
283
284         /*
285          * If updating, check whether changing from read-only to
286          * read/write; if there is no device name, that's all we do.
287          */
288         if (mp->mnt_flag & MNT_UPDATE) {
289                 /*
290                  ********************
291                  * UPDATE
292                  ********************
293                  */
294                 ump = VFSTOUFS(mp);
295                 fs = ump->um_fs;
296                 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
297                         flags = WRITECLOSE;
298                         if (mp->mnt_flag & MNT_FORCE)
299                                 flags |= FORCECLOSE;
300                         error = ffs_flushfiles(mp, flags);
301                         if (error)
302                                 goto error_1;
303                 }
304                 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
305                         /* XXX reopen the device vnode read-write */
306                         fs->fs_ronly = 0;
307                 }
308                 /* if not updating name...*/
309                 if (args.fspec == 0) {
310                         /*
311                          * Process export requests.  Jumping to "success"
312                          * will return the vfs_export() error code. 
313                          */
314                         error = vfs_export(mp, &ump->um_export, &args.export);
315                         goto success;
316                 }
317
318                 /* XXX MFS does not support name updating*/
319                 goto success;
320         }
321
322         /*
323          * Do the MALLOC before the make_dev since doing so afterward
324          * might cause a bogus v_data pointer to get dereferenced
325          * elsewhere if MALLOC should block.
326          */
327         mfsp = kmalloc(sizeof *mfsp, M_MFSNODE, M_WAITOK | M_ZERO);
328
329         minnum = (int)curproc->p_pid;
330
331         dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
332                        "mfs%d", minnum);
333         /* It is not clear that these will get initialized otherwise */
334         dev->si_bsize_phys = DEV_BSIZE;
335         dev->si_iosize_max = MAXPHYS;
336         dev->si_drv1 = mfsp;
337         mfsp->mfs_baseoff = args.base;
338         mfsp->mfs_size = args.size;
339         mfsp->mfs_dev = dev;
340         mfsp->mfs_td = curthread;
341         mfsp->mfs_active = 1;
342         bioq_init(&mfsp->bio_queue);
343
344         devfs_config(); /* sync devfs work */
345         ksnprintf(devname, sizeof(devname), "/dev/mfs%d", minnum);
346         nlookup_init(&nd, devname, UIO_SYSSPACE, 0);
347         devvp = NULL;
348         error = nlookup(&nd);
349         if (error == 0) {
350                 devvp = nd.nl_nch.ncp->nc_vp;
351                 if (devvp == NULL)
352                         error = ENOENT;
353                 error = vget(devvp, LK_SHARED);
354         }
355         nlookup_done(&nd);
356
357         if (error)
358                 goto error_1;
359         vn_unlock(devvp);
360
361         /*
362          * Our 'block' device must be backed by a VM object.  Theoretically
363          * we could use the anonymous memory VM object supplied by userland,
364          * but it would be somewhat of a complex task to deal with it
365          * that way since it would result in I/O requests which supply
366          * the VM pages from our own object.
367          *
368          * vnode_pager_alloc() is typically called when a VM object is
369          * being referenced externally.  We have to undo the refs for
370          * the self reference between vnode and object.
371          */
372         vnode_pager_setsize(devvp, args.size);
373
374         /* Save "mounted from" info for mount point (NULL pad)*/
375         copyinstr(args.fspec,                   /* device name*/
376                   mp->mnt_stat.f_mntfromname,   /* save area*/
377                   MNAMELEN - 1,                 /* max size*/
378                   &size);                       /* real size*/
379         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
380         /* vref is eaten by mount? */
381
382         error = ffs_mountfs(devvp, mp, M_MFSNODE);
383         if (error) {
384                 mfsp->mfs_active = 0;
385                 goto error_2;
386         }
387
388         /*
389          * Initialize FS stat information in mount struct; uses
390          * mp->mnt_stat.f_mntfromname.
391          *
392          * This code is common to root and non-root mounts
393          */
394         VFS_STATFS(mp, &mp->mnt_stat, cred);
395
396         /*
397          * Mark VFS_START MPSAFE; this is to avoid accessing
398          * per-mount token after VFS_START exits
399          */
400         mp->mnt_kern_flag |= MNTK_ST_MPSAFE;
401
402         goto success;
403
404 error_2:        /* error with devvp held*/
405         vrele(devvp);
406
407 error_1:        /* no state to back out*/
408         if (mfsp) {
409                 if (mfsp->mfs_dev) {
410                         destroy_dev(mfsp->mfs_dev);
411                         mfsp->mfs_dev = NULL;
412                 }
413                 kfree(mfsp, M_MFSNODE);
414         }
415
416 success:
417         return(error);
418 }
419
420 /*
421  * Used to grab the process and keep it in the kernel to service
422  * memory filesystem I/O requests.
423  *
424  * Loop servicing I/O requests.
425  * Copy the requested data into or out of the memory filesystem
426  * address space.
427  */
428 /* ARGSUSED */
429 static int
430 mfs_start(struct mount *mp, int flags)
431 {
432         struct vnode *vp = VFSTOUFS(mp)->um_devvp;
433         struct mfsnode *mfsp = vp->v_rdev->si_drv1;
434         struct bio *bio;
435         struct buf *bp;
436         int gotsig = 0, sig;
437         thread_t td = curthread;
438
439         /*
440          * We must prevent the system from trying to swap
441          * out or kill ( when swap space is low, see vm/pageout.c ) the
442          * process.  A deadlock can occur if the process is swapped out,
443          * and the system can loop trying to kill the unkillable ( while
444          * references exist ) MFS process when swap space is low.
445          */
446         KKASSERT(curproc);
447         PHOLD(curproc);
448
449         mfsp->mfs_td = td;
450
451         while (mfsp->mfs_active) {
452                 crit_enter();
453
454                 while ((bio = bioq_takefirst(&mfsp->bio_queue)) != NULL) {
455                         crit_exit();
456                         bp = bio->bio_buf;
457                         mfs_doio(bio, mfsp);
458                         wakeup(bp);
459                         crit_enter();
460                 }
461
462                 crit_exit();
463
464                 /*
465                  * If a non-ignored signal is received, try to unmount.
466                  * If that fails, clear the signal (it has been "processed"),
467                  * otherwise we will loop here, as tsleep will always return
468                  * EINTR/ERESTART.
469                  */
470                 /*
471                  * Note that dounmount() may fail if work was queued after
472                  * we slept. We have to jump hoops here to make sure that we
473                  * process any buffers after the sleep, before we dounmount()
474                  */
475                 if (gotsig) {
476                         gotsig = 0;
477                         if (dounmount(mp, 0, 0) != 0) {
478                                 KKASSERT(td->td_proc);
479                                 lwkt_gettoken(&td->td_proc->p_token);
480                                 sig = CURSIG(td->td_lwp);
481                                 if (sig) {
482                                         spin_lock(&td->td_lwp->lwp_spin);
483                                         lwp_delsig(td->td_lwp, sig, 1);
484                                         spin_unlock(&td->td_lwp->lwp_spin);
485                                 }
486                                 lwkt_reltoken(&td->td_proc->p_token);
487                         }
488                 }
489                 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
490                         gotsig++;       /* try to unmount in next pass */
491         }
492         PRELE(curproc);
493         if (mfsp->mfs_dev) {
494                 destroy_dev(mfsp->mfs_dev);
495                 mfsp->mfs_dev = NULL;
496         }
497         kfree(mfsp, M_MFSNODE);
498         return (EMOUNTEXIT);
499 }
500
501 /*
502  * Get file system statistics.
503  */
504 static int
505 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
506 {
507         int error;
508
509         error = ffs_statfs(mp, sbp, cred);
510         sbp->f_type = mp->mnt_vfc->vfc_typenum;
511         return (error);
512 }
513
514 /*
515  * Memory based filesystem initialization.
516  */
517 static int
518 mfs_init(struct vfsconf *vfsp)
519 {
520         return (0);
521 }
522
523 /*
524  * Memory file system I/O.
525  *
526  * Trivial on the HP since buffer has already been mapping into KVA space.
527  *
528  * Read and Write are handled with a simple copyin and copyout.
529  *
530  * We also partially support VOP_FREEBLKS().  We can't implement
531  * completely -- for example, on fragments or inode metadata, but we can
532  * implement it for page-aligned requests.
533  */
534 static void
535 mfs_doio(struct bio *bio, struct mfsnode *mfsp)
536 {
537         struct buf *bp = bio->bio_buf;
538         caddr_t base = mfsp->mfs_baseoff + bio->bio_offset;
539         int bytes;
540
541         switch(bp->b_cmd) {
542         case BUF_CMD_FREEBLKS:
543                 /*
544                  * Implement FREEBLKS, which allows the filesystem to tell
545                  * a block device when blocks are no longer needed (like when
546                  * a file is deleted).  We use the hook to MADV_FREE the VM.
547                  * This makes an MFS filesystem work as well or better then
548                  * a sun-style swap-mounted filesystem.
549                  */
550                 bytes = bp->b_bcount;
551
552                 if ((vm_offset_t)base & PAGE_MASK) {
553                         int n = PAGE_SIZE - ((vm_offset_t)base & PAGE_MASK);
554                         bytes -= n;
555                         base += n;
556                 }
557                 if (bytes > 0) {
558                         struct madvise_args uap;
559
560                         bytes &= ~PAGE_MASK;
561                         if (bytes != 0) {
562                                 bzero(&uap, sizeof(uap));
563                                 uap.addr  = base;
564                                 uap.len   = bytes;
565                                 uap.behav = MADV_FREE;
566                                 sys_madvise(&uap);
567                         }
568                 }
569                 bp->b_error = 0;
570                 break;
571         case BUF_CMD_READ:
572                 /*
573                  * Read data from our 'memory' disk
574                  */
575                 bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
576                 break;
577         case BUF_CMD_WRITE:
578                 /*
579                  * Write data to our 'memory' disk
580                  */
581                 bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
582                 break;
583         default:
584                 panic("mfs: bad b_cmd %d", bp->b_cmd);
585         }
586         if (bp->b_error)
587                 bp->b_flags |= B_ERROR;
588         biodone(bio);
589 }