20ba9046b81c7d617175090499aa1b94581d553b
[dragonfly.git] / sys / dev / disk / vn / vn.c
1 /*
2  * Copyright (c) 1988 University of Utah.
3  * Copyright (c) 1990, 1993
4  *      The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * the Systems Programming Group of the University of Utah Computer
8  * Science Department.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * from: Utah Hdr: vn.c 1.13 94/04/02
39  *
40  *      from: @(#)vn.c  8.6 (Berkeley) 4/1/94
41  * $FreeBSD: src/sys/dev/vn/vn.c,v 1.105.2.4 2001/11/18 07:11:00 dillon Exp $
42  * $DragonFly: src/sys/dev/disk/vn/vn.c,v 1.38 2008/07/01 02:02:53 dillon Exp $
43  */
44
45 /*
46  * Vnode disk driver.
47  *
48  * Block/character interface to a vnode.  Allows one to treat a file
49  * as a disk (e.g. build a filesystem in it, mount it, etc.).
50  *
51  * NOTE 1: There is a security issue involved with this driver.
52  * Once mounted all access to the contents of the "mapped" file via
53  * the special file is controlled by the permissions on the special
54  * file, the protection of the mapped file is ignored (effectively,
55  * by using root credentials in all transactions).
56  *
57  * NOTE 2: Doesn't interact with leases, should it?
58  */
59
60 #include "use_vn.h"
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/kernel.h>
64 #include <sys/proc.h>
65 #include <sys/priv.h>
66 #include <sys/nlookup.h>
67 #include <sys/buf.h>
68 #include <sys/malloc.h>
69 #include <sys/mount.h>
70 #include <sys/vnode.h>
71 #include <sys/fcntl.h>
72 #include <sys/conf.h>
73 #include <sys/diskslice.h>
74 #include <sys/disk.h>
75 #include <sys/stat.h>
76 #include <sys/module.h>
77 #include <sys/vnioctl.h>
78
79 #include <vm/vm.h>
80 #include <vm/vm_object.h>
81 #include <vm/vm_page.h>
82 #include <vm/vm_pager.h>
83 #include <vm/vm_pageout.h>
84 #include <vm/swap_pager.h>
85 #include <vm/vm_extern.h>
86 #include <vm/vm_zone.h>
87 #include <sys/devfs.h>
88
89 static  d_ioctl_t       vnioctl;
90 static  d_open_t        vnopen;
91 static  d_close_t       vnclose;
92 static  d_psize_t       vnsize;
93 static  d_strategy_t    vnstrategy;
94 static  d_clone_t       vnclone;
95
96 DEVFS_DECLARE_CLONE_BITMAP(vn);
97
98 #if NVN <= 1
99 #define VN_PREALLOCATED_UNITS   4
100 #else
101 #define VN_PREALLOCATED_UNITS   NVN
102 #endif
103
104 #define CDEV_MAJOR 43
105
106 #define VN_BSIZE_BEST   8192
107
108 /*
109  * dev_ops
110  *      D_DISK          we want to look like a disk
111  *      D_CANFREE       We support BUF_CMD_FREEBLKS
112  */
113
114 static struct dev_ops vn_ops = {
115         { "vn", CDEV_MAJOR, D_DISK | D_CANFREE },
116         .d_open =       vnopen,
117         .d_close =      vnclose,
118         .d_read =       physread,
119         .d_write =      physwrite,
120         .d_ioctl =      vnioctl,
121         .d_strategy =   vnstrategy,
122         .d_psize =      vnsize
123 };
124
125 struct vn_softc {
126         int             sc_unit;
127         int             sc_flags;       /* flags                        */
128         u_int64_t       sc_size;        /* size of vn, sc_secsize scale */
129         int             sc_secsize;     /* sector size                  */
130         struct disk     sc_disk;
131         struct vnode    *sc_vp;         /* vnode if not NULL            */
132         vm_object_t     sc_object;      /* backing object if not NULL   */
133         struct ucred    *sc_cred;       /* credentials                  */
134         int              sc_maxactive;  /* max # of active requests     */
135         struct buf       sc_tab;        /* transfer queue               */
136         u_long           sc_options;    /* options                      */
137         cdev_t           sc_devlist;    /* devices that refer to this unit */
138         SLIST_ENTRY(vn_softc) sc_list;
139 };
140
141 static SLIST_HEAD(, vn_softc) vn_list;
142
143 /* sc_flags */
144 #define VNF_INITED      0x01
145 #define VNF_READONLY    0x02
146
147 static u_long   vn_options;
148
149 #define IFOPT(vn,opt) if (((vn)->sc_options|vn_options) & (opt))
150 #define TESTOPT(vn,opt) (((vn)->sc_options|vn_options) & (opt))
151
152 static int      vnsetcred (struct vn_softc *vn, struct ucred *cred);
153 static void     vnclear (struct vn_softc *vn);
154 static int      vnget (cdev_t dev, struct vn_softc *vn , struct vn_user *vnu);
155 static int      vn_modevent (module_t, int, void *);
156 static int      vniocattach_file (struct vn_softc *, struct vn_ioctl *, cdev_t dev, int flag, struct ucred *cred);
157 static int      vniocattach_swap (struct vn_softc *, struct vn_ioctl *, cdev_t dev, int flag, struct ucred *cred);
158 static cdev_t   vn_create(int unit, struct devfs_bitmap *bitmap);
159
160 static int
161 vnclone(struct dev_clone_args *ap)
162 {
163         int unit;
164
165         unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(vn), 0);
166         ap->a_dev = vn_create(unit, &DEVFS_CLONE_BITMAP(vn));
167
168         return 0;
169 }
170
171 static  int
172 vnclose(struct dev_close_args *ap)
173 {
174         return (0);
175 }
176
177 static struct vn_softc *
178 vncreatevn(void)
179 {
180         struct vn_softc *vn;
181
182         vn = kmalloc(sizeof *vn, M_DEVBUF, M_WAITOK | M_ZERO);
183         return vn;
184 }
185
186 static void
187 vninitvn(struct vn_softc *vn, cdev_t dev)
188 {
189         int unit;
190
191         KKASSERT(vn != NULL);
192         KKASSERT(dev != NULL);
193         unit = dkunit(dev);
194
195         vn->sc_unit = unit;
196         dev->si_drv1 = vn;
197         vn->sc_devlist = dev;
198         if (vn->sc_devlist->si_drv1 == NULL) {
199                 reference_dev(vn->sc_devlist);
200                 vn->sc_devlist->si_drv1 = vn;
201                 vn->sc_devlist->si_drv2 = NULL;
202         }
203         if (vn->sc_devlist != dev) {
204                 dev->si_drv1 = vn;
205                 dev->si_drv2 = vn->sc_devlist;
206                 vn->sc_devlist = dev;
207                 reference_dev(dev);
208         }
209         SLIST_INSERT_HEAD(&vn_list, vn, sc_list);
210 }
211
212 /*
213  * Called only when si_drv1 is NULL.  Locate the associated vn node and
214  * attach the device to it.
215  */
216 static struct vn_softc *
217 vnfindvn(cdev_t dev)
218 {
219         int unit;
220         struct vn_softc *vn;
221
222         unit = dkunit(dev);
223         SLIST_FOREACH(vn, &vn_list, sc_list) {
224                 if (vn->sc_unit == unit) {
225                         dev->si_drv1 = vn;
226                         dev->si_drv2 = vn->sc_devlist;
227                         vn->sc_devlist = dev;
228                         reference_dev(dev);
229                         break;
230                 }
231         }
232
233         KKASSERT(vn != NULL);
234
235         return vn;
236 }
237
238 static  int
239 vnopen(struct dev_open_args *ap)
240 {
241         cdev_t dev = ap->a_head.a_dev;
242         struct vn_softc *vn;
243
244         /*
245          * Locate preexisting device
246          */
247
248         if ((vn = dev->si_drv1) == NULL)
249                 vn = vnfindvn(dev);
250
251         /*
252          * Update si_bsize fields for device.  This data will be overriden by
253          * the slice/parition code for vn accesses through partitions, and
254          * used directly if you open the 'whole disk' device.
255          *
256          * si_bsize_best must be reinitialized in case VN has been 
257          * reconfigured, plus make it at least VN_BSIZE_BEST for efficiency.
258          */
259         dev->si_bsize_phys = vn->sc_secsize;
260         dev->si_bsize_best = vn->sc_secsize;
261         if (dev->si_bsize_best < VN_BSIZE_BEST)
262                 dev->si_bsize_best = VN_BSIZE_BEST;
263
264         if ((ap->a_oflags & FWRITE) && (vn->sc_flags & VNF_READONLY))
265                 return (EACCES);
266
267         IFOPT(vn, VN_FOLLOW)
268                 kprintf("vnopen(%s, 0x%x, 0x%x)\n",
269                     devtoname(dev), ap->a_oflags, ap->a_devtype);
270
271         return(0);
272 }
273
274 /*
275  *      vnstrategy:
276  *
277  *      Run strategy routine for VN device.  We use VOP_READ/VOP_WRITE calls
278  *      for vnode-backed vn's, and the swap_pager_strategy() call for
279  *      vm_object-backed vn's.
280  */
281 static int
282 vnstrategy(struct dev_strategy_args *ap)
283 {
284         cdev_t dev = ap->a_head.a_dev;
285         struct bio *bio = ap->a_bio;
286         struct buf *bp;
287         struct bio *nbio;
288         int unit;
289         struct vn_softc *vn;
290         int error;
291
292         unit = dkunit(dev);
293         if ((vn = dev->si_drv1) == NULL)
294                 vn = vnfindvn(dev);
295
296         bp = bio->bio_buf;
297
298         IFOPT(vn, VN_DEBUG)
299                 kprintf("vnstrategy(%p): unit %d\n", bp, unit);
300
301         if ((vn->sc_flags & VNF_INITED) == 0) {
302                 bp->b_error = ENXIO;
303                 bp->b_flags |= B_ERROR;
304                 biodone(bio);
305                 return(0);
306         }
307
308         bp->b_resid = bp->b_bcount;
309
310         /*
311          * The vnode device is using disk/slice label support.
312          *
313          * The dscheck() function is called for validating the
314          * slices that exist ON the vnode device itself, and
315          * translate the "slice-relative" block number, again.
316          * dscheck() will call biodone() and return NULL if
317          * we are at EOF or beyond the device size.
318          */
319
320         nbio = bio;
321
322         /*
323          * Use the translated nbio from this point on
324          */
325         if (vn->sc_vp && bp->b_cmd == BUF_CMD_FREEBLKS) {
326                 /*
327                  * Freeblks is not handled for vnode-backed elements yet.
328                  */
329                 bp->b_resid = 0;
330                 /* operation complete */
331         } else if (vn->sc_vp) {
332                 /*
333                  * VNODE I/O
334                  *
335                  * If an error occurs, we set B_ERROR but we do not set 
336                  * B_INVAL because (for a write anyway), the buffer is 
337                  * still valid.
338                  */
339                 struct uio auio;
340                 struct iovec aiov;
341
342                 bzero(&auio, sizeof(auio));
343
344                 aiov.iov_base = bp->b_data;
345                 aiov.iov_len = bp->b_bcount;
346                 auio.uio_iov = &aiov;
347                 auio.uio_iovcnt = 1;
348                 auio.uio_offset = nbio->bio_offset;
349                 auio.uio_segflg = UIO_SYSSPACE;
350                 if (bp->b_cmd == BUF_CMD_READ)
351                         auio.uio_rw = UIO_READ;
352                 else
353                         auio.uio_rw = UIO_WRITE;
354                 auio.uio_resid = bp->b_bcount;
355                 auio.uio_td = curthread;
356                 vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
357                 if (bp->b_cmd == BUF_CMD_READ)
358                         error = VOP_READ(vn->sc_vp, &auio, IO_DIRECT | IO_RECURSE, vn->sc_cred);
359                 else
360                         error = VOP_WRITE(vn->sc_vp, &auio, IO_DIRECT | IO_RECURSE, vn->sc_cred);
361                 vn_unlock(vn->sc_vp);
362                 bp->b_resid = auio.uio_resid;
363                 if (error) {
364                         bp->b_error = error;
365                         bp->b_flags |= B_ERROR;
366                 }
367                 /* operation complete */
368         } else if (vn->sc_object) {
369                 /*
370                  * OBJT_SWAP I/O (handles read, write, freebuf)
371                  *
372                  * We have nothing to do if freeing  blocks on a reserved
373                  * swap area, othrewise execute the op.
374                  */
375                 if (bp->b_cmd == BUF_CMD_FREEBLKS && TESTOPT(vn, VN_RESERVE)) {
376                         bp->b_resid = 0;
377                         /* operation complete */
378                 } else {
379                         swap_pager_strategy(vn->sc_object, nbio);
380                         return(0);
381                         /* NOT REACHED */
382                 }
383         } else {
384                 bp->b_resid = bp->b_bcount;
385                 bp->b_flags |= B_ERROR | B_INVAL;
386                 bp->b_error = EINVAL;
387                 /* operation complete */
388         }
389         biodone(nbio);
390         return(0);
391 }
392
393 /* ARGSUSED */
394 static  int
395 vnioctl(struct dev_ioctl_args *ap)
396 {
397         cdev_t dev = ap->a_head.a_dev;
398         struct vn_softc *vn;
399         struct vn_ioctl *vio;
400         int error;
401         u_long *f;
402
403         vn = dev->si_drv1;
404         IFOPT(vn,VN_FOLLOW) {
405                 kprintf("vnioctl(%s, 0x%lx, %p, 0x%x): unit %d\n",
406                     devtoname(dev), ap->a_cmd, ap->a_data, ap->a_fflag,
407                     dkunit(dev));
408         }
409
410         switch (ap->a_cmd) {
411         case VNIOCATTACH:
412         case VNIOCDETACH:
413         case VNIOCGSET:
414         case VNIOCGCLEAR:
415         case VNIOCGET:
416         case VNIOCUSET:
417         case VNIOCUCLEAR:
418                 goto vn_specific;
419         }
420
421 #if 0
422         if (dkslice(dev) != WHOLE_DISK_SLICE ||
423                 dkpart(dev) != WHOLE_SLICE_PART)
424                 return (ENOTTY);
425 #endif
426
427     vn_specific:
428
429         error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
430         if (error)
431                 return (error);
432
433         vio = (struct vn_ioctl *)ap->a_data;
434         f = (u_long*)ap->a_data;
435
436         switch (ap->a_cmd) {
437         case VNIOCATTACH:
438                 if (vn->sc_flags & VNF_INITED)
439                         return(EBUSY);
440
441                 if (vio->vn_file == NULL)
442                         error = vniocattach_swap(vn, vio, dev, ap->a_fflag, ap->a_cred);
443                 else
444                         error = vniocattach_file(vn, vio, dev, ap->a_fflag, ap->a_cred);
445                 break;
446
447         case VNIOCDETACH:
448                 if ((vn->sc_flags & VNF_INITED) == 0)
449                         return(ENXIO);
450                 /*
451                  * XXX handle i/o in progress.  Return EBUSY, or wait, or
452                  * flush the i/o.
453                  * XXX handle multiple opens of the device.  Return EBUSY,
454                  * or revoke the fd's.
455                  * How are these problems handled for removable and failing
456                  * hardware devices? (Hint: They are not)
457                  */
458                 if (count_dev(vn->sc_devlist) > 1)
459                         return (EBUSY);
460
461                 vnclear(vn);
462                 IFOPT(vn, VN_FOLLOW)
463                         kprintf("vnioctl: CLRed\n");
464
465                 if (dkunit(dev) >= VN_PREALLOCATED_UNITS) {
466                         devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(vn), dkunit(dev));
467                         disk_destroy(&vn->sc_disk);
468                 }
469
470                 break;
471
472         case VNIOCGET:
473                 error = vnget(dev, vn, (struct vn_user *) ap->a_data);
474                 break;
475
476         case VNIOCGSET:
477                 vn_options |= *f;
478                 *f = vn_options;
479                 break;
480
481         case VNIOCGCLEAR:
482                 vn_options &= ~(*f);
483                 *f = vn_options;
484                 break;
485
486         case VNIOCUSET:
487                 vn->sc_options |= *f;
488                 *f = vn->sc_options;
489                 break;
490
491         case VNIOCUCLEAR:
492                 vn->sc_options &= ~(*f);
493                 *f = vn->sc_options;
494                 break;
495
496         default:
497                 error = ENOTTY;
498                 break;
499         }
500         return(error);
501 }
502
503 /*
504  *      vniocattach_file:
505  *
506  *      Attach a file to a VN partition.  Return the size in the vn_size
507  *      field.
508  */
509
510 static int
511 vniocattach_file(struct vn_softc *vn, struct vn_ioctl *vio, cdev_t dev,
512                  int flag, struct ucred *cred)
513 {
514         struct vattr vattr;
515         struct nlookupdata nd;
516         int error, flags;
517         struct vnode *vp;
518         struct disk_info info;
519
520         flags = FREAD|FWRITE;
521         error = nlookup_init(&nd, vio->vn_file, 
522                                 UIO_USERSPACE, NLC_FOLLOW|NLC_LOCKVP);
523         if (error)
524                 return (error);
525         if ((error = vn_open(&nd, NULL, flags, 0)) != 0) {
526                 if (error != EACCES && error != EPERM && error != EROFS)
527                         goto done;
528                 flags &= ~FWRITE;
529                 nlookup_done(&nd);
530                 error = nlookup_init(&nd, vio->vn_file, UIO_USERSPACE, NLC_FOLLOW|NLC_LOCKVP);
531                 if (error)
532                         return (error);
533                 if ((error = vn_open(&nd, NULL, flags, 0)) != 0)
534                         goto done;
535         }
536         vp = nd.nl_open_vp;
537         if (vp->v_type != VREG ||
538             (error = VOP_GETATTR(vp, &vattr))) {
539                 if (error == 0)
540                         error = EINVAL;
541                 goto done;
542         }
543         vn_unlock(vp);
544         vn->sc_secsize = DEV_BSIZE;
545         vn->sc_vp = vp;
546         nd.nl_open_vp = NULL;
547
548         /*
549          * If the size is specified, override the file attributes.  Note that
550          * the vn_size argument is in PAGE_SIZE sized blocks.
551          */
552         if (vio->vn_size)
553                 vn->sc_size = vio->vn_size * PAGE_SIZE / vn->sc_secsize;
554         else
555                 vn->sc_size = vattr.va_size / vn->sc_secsize;
556         error = vnsetcred(vn, cred);
557         if (error) {
558                 vn->sc_vp = NULL;
559                 vn_close(vp, flags);
560                 goto done;
561         }
562         vn->sc_flags |= VNF_INITED;
563         if (flags == FREAD)
564                 vn->sc_flags |= VNF_READONLY;
565
566         /*
567          * Set the disk info so that probing is triggered
568          */
569         bzero(&info, sizeof(struct disk_info));
570         info.d_media_blksize = vn->sc_secsize;
571         info.d_media_blocks = vn->sc_size;
572         /*
573          * reserve mbr sector for backwards compatibility
574          * when no slices exist.
575          */
576         info.d_dsflags = DSO_COMPATMBR;
577         info.d_secpertrack = 32;
578         info.d_nheads = 64 / (vn->sc_secsize / DEV_BSIZE);
579         info.d_secpercyl = info.d_secpertrack * info.d_nheads;
580         info.d_ncylinders = vn->sc_size / info.d_secpercyl;
581         disk_setdiskinfo_sync(&vn->sc_disk, &info);
582
583         error = dev_dopen(dev, flag, S_IFCHR, cred);
584         if (error)
585                 vnclear(vn);
586
587         IFOPT(vn, VN_FOLLOW)
588                 kprintf("vnioctl: SET vp %p size %llx blks\n",
589                        vn->sc_vp, (long long)vn->sc_size);
590 done:
591         nlookup_done(&nd);
592         return(error);
593 }
594
595 /*
596  *      vniocattach_swap:
597  *
598  *      Attach swap backing store to a VN partition of the size specified
599  *      in vn_size.
600  */
601
602 static int
603 vniocattach_swap(struct vn_softc *vn, struct vn_ioctl *vio, cdev_t dev,
604                  int flag, struct ucred *cred)
605 {
606         int error;
607         struct disk_info info;
608
609         /*
610          * Range check.  Disallow negative sizes or any size less then the
611          * size of a page.  Then round to a page.
612          */
613
614         if (vio->vn_size <= 0)
615                 return(EDOM);
616
617         /*
618          * Allocate an OBJT_SWAP object.
619          *
620          * sc_secsize is PAGE_SIZE'd
621          *
622          * vio->vn_size is in PAGE_SIZE'd chunks.
623          * sc_size must be in PAGE_SIZE'd chunks.  
624          * Note the truncation.
625          */
626
627         vn->sc_secsize = PAGE_SIZE;
628         vn->sc_size = vio->vn_size;
629         vn->sc_object = swap_pager_alloc(NULL,
630                                          vn->sc_secsize * (off_t)vio->vn_size,
631                                          VM_PROT_DEFAULT, 0);
632         IFOPT(vn, VN_RESERVE) {
633                 if (swap_pager_reserve(vn->sc_object, 0, vn->sc_size) < 0) {
634                         vm_pager_deallocate(vn->sc_object);
635                         vn->sc_object = NULL;
636                         return(EDOM);
637                 }
638         }
639         vn->sc_flags |= VNF_INITED;
640
641         error = vnsetcred(vn, cred);
642         if (error == 0) {
643                 /*
644                  * Set the disk info so that probing is triggered
645                  */
646                 bzero(&info, sizeof(struct disk_info));
647                 info.d_media_blksize = vn->sc_secsize;
648                 info.d_media_blocks = vn->sc_size;
649                 /*
650                  * reserve mbr sector for backwards compatibility
651                  * when no slices exist.
652                  */
653                 info.d_dsflags = DSO_COMPATMBR;
654                 info.d_secpertrack = 32;
655                 info.d_nheads = 64 / (vn->sc_secsize / DEV_BSIZE);
656                 info.d_secpercyl = info.d_secpertrack * info.d_nheads;
657                 info.d_ncylinders = vn->sc_size / info.d_secpercyl;
658                 disk_setdiskinfo_sync(&vn->sc_disk, &info);
659
660                 error = dev_dopen(dev, flag, S_IFCHR, cred);
661         }
662         if (error == 0) {
663                 IFOPT(vn, VN_FOLLOW) {
664                         kprintf("vnioctl: SET vp %p size %llx\n",
665                                vn->sc_vp, (long long)vn->sc_size);
666                 }
667         }
668         if (error)
669                 vnclear(vn);
670         return(error);
671 }
672
673 /*
674  * Duplicate the current processes' credentials.  Since we are called only
675  * as the result of a SET ioctl and only root can do that, any future access
676  * to this "disk" is essentially as root.  Note that credentials may change
677  * if some other uid can write directly to the mapped file (NFS).
678  */
679 int
680 vnsetcred(struct vn_softc *vn, struct ucred *cred)
681 {
682         char *tmpbuf;
683         int error = 0;
684
685         /*
686          * Set credits in our softc
687          */
688
689         if (vn->sc_cred)
690                 crfree(vn->sc_cred);
691         vn->sc_cred = crdup(cred);
692
693         /*
694          * Horrible kludge to establish credentials for NFS  XXX.
695          */
696
697         if (vn->sc_vp) {
698                 struct uio auio;
699                 struct iovec aiov;
700
701                 tmpbuf = kmalloc(vn->sc_secsize, M_TEMP, M_WAITOK);
702                 bzero(&auio, sizeof(auio));
703
704                 aiov.iov_base = tmpbuf;
705                 aiov.iov_len = vn->sc_secsize;
706                 auio.uio_iov = &aiov;
707                 auio.uio_iovcnt = 1;
708                 auio.uio_offset = 0;
709                 auio.uio_rw = UIO_READ;
710                 auio.uio_segflg = UIO_SYSSPACE;
711                 auio.uio_resid = aiov.iov_len;
712                 vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
713                 error = VOP_READ(vn->sc_vp, &auio, 0, vn->sc_cred);
714                 vn_unlock(vn->sc_vp);
715                 kfree(tmpbuf, M_TEMP);
716         }
717         return (error);
718 }
719
720 void
721 vnclear(struct vn_softc *vn)
722 {
723         IFOPT(vn, VN_FOLLOW)
724                 kprintf("vnclear(%p): vp=%p\n", vn, vn->sc_vp);
725         vn->sc_flags &= ~VNF_INITED;
726         if (vn->sc_vp != NULL) {
727                 vn_close(vn->sc_vp,
728                     (vn->sc_flags & VNF_READONLY) ?  FREAD : (FREAD|FWRITE));
729                 vn->sc_vp = NULL;
730         }
731         vn->sc_flags &= ~VNF_READONLY;
732         if (vn->sc_cred) {
733                 crfree(vn->sc_cred);
734                 vn->sc_cred = NULL;
735         }
736         if (vn->sc_object != NULL) {
737                 vm_pager_deallocate(vn->sc_object);
738                 vn->sc_object = NULL;
739         }
740
741         disk_unprobe(&vn->sc_disk);
742
743         vn->sc_size = 0;
744 }
745
746 /*
747  *      vnget:
748  *
749  *      populate a struct vn_user for the VNIOCGET ioctl.
750  *      interface conventions defined in sys/sys/vnioctl.h.
751  */
752
753 static int
754 vnget(cdev_t dev, struct vn_softc *vn, struct vn_user *vnu)
755 {
756         int error, found = 0; 
757         char *freepath, *fullpath;
758         struct vattr vattr;
759
760         if (vnu->vnu_unit == -1) {
761                 vnu->vnu_unit = dkunit(dev);
762         }
763         else if (vnu->vnu_unit < 0)
764                 return (EINVAL);
765
766         SLIST_FOREACH(vn, &vn_list, sc_list) {
767
768                 if(vn->sc_unit != vnu->vnu_unit)
769                         continue;
770
771                 found = 1;
772
773                 if (vn->sc_flags & VNF_INITED && vn->sc_vp != NULL) {
774
775                         /* note: u_cred checked in vnioctl above */
776                         error = VOP_GETATTR(vn->sc_vp, &vattr);
777                         if (error) {
778                                 kprintf("vnget: VOP_GETATTR for %p failed\n",
779                                         vn->sc_vp);
780                                 return (error);
781                         }
782
783                         error = vn_fullpath(curproc, vn->sc_vp,
784                                                 &fullpath, &freepath);
785
786                         if (error) {
787                                 kprintf("vnget: unable to resolve vp %p\n",
788                                         vn->sc_vp);
789                                 return(error);
790                         }
791                         
792                         strlcpy(vnu->vnu_file, fullpath,
793                                 sizeof(vnu->vnu_file));
794                         kfree(freepath, M_TEMP);
795                         vnu->vnu_dev = vattr.va_fsid;
796                         vnu->vnu_ino = vattr.va_fileid;
797
798                 } 
799                 else if (vn->sc_flags & VNF_INITED && vn->sc_object != NULL){
800
801                         strlcpy(vnu->vnu_file, _VN_USER_SWAP,
802                                 sizeof(vnu->vnu_file));
803                         vnu->vnu_size = vn->sc_size;
804                         vnu->vnu_secsize = vn->sc_secsize;
805
806                 } else {
807
808                         bzero(vnu->vnu_file, sizeof(vnu->vnu_file));
809                         vnu->vnu_dev = 0;
810                         vnu->vnu_ino = 0;
811
812                 }
813                 break;
814         }
815
816         if (!found)
817                 return(ENXIO);
818
819         return(0);
820 }
821
822 static int
823 vnsize(struct dev_psize_args *ap)
824 {
825         cdev_t dev = ap->a_head.a_dev;
826         struct vn_softc *vn;
827
828         vn = dev->si_drv1;
829         if (!vn)
830                 return(ENXIO);
831         if ((vn->sc_flags & VNF_INITED) == 0)
832                 return(ENXIO);
833         ap->a_result = (int64_t)vn->sc_size;
834         return(0);
835 }
836
837 static cdev_t
838 vn_create(int unit, struct devfs_bitmap *bitmap)
839 {
840         struct vn_softc *vn;
841         struct disk_info info;
842         cdev_t dev;
843
844         vn = vncreatevn();
845         dev = disk_create(unit, &vn->sc_disk, &vn_ops);
846         vninitvn(vn, dev);
847
848         bzero(&info, sizeof(struct disk_info));
849         info.d_media_blksize = 512;
850         info.d_media_blocks = 0;
851         info.d_dsflags = DSO_MBRQUIET;
852         info.d_secpertrack = 32;
853         info.d_nheads = 64;
854         info.d_secpercyl = info.d_secpertrack * info.d_nheads;
855         info.d_ncylinders = 0;
856         disk_setdiskinfo_sync(&vn->sc_disk, &info);
857
858         if (bitmap != NULL)
859                 devfs_clone_bitmap_set(bitmap, unit);
860
861         return dev;
862 }
863
864 static int 
865 vn_modevent(module_t mod, int type, void *data)
866 {
867         struct vn_softc *vn;
868         static cdev_t dev = NULL;
869         int i;
870
871         switch (type) {
872         case MOD_LOAD:
873                 dev = make_autoclone_dev(&vn_ops, &DEVFS_CLONE_BITMAP(vn), vnclone, UID_ROOT,
874                     GID_OPERATOR, 0640, "vn");
875
876                 for (i = 0; i < VN_PREALLOCATED_UNITS; i++) {
877                         vn_create(i, &DEVFS_CLONE_BITMAP(vn));
878                 }
879                 break;
880         case MOD_UNLOAD:
881                 destroy_autoclone_dev(dev, &DEVFS_CLONE_BITMAP(vn));
882                 /* fall through */
883         case MOD_SHUTDOWN:
884                 while ((vn = SLIST_FIRST(&vn_list)) != NULL) {
885                         SLIST_REMOVE_HEAD(&vn_list, sc_list);
886                         if (vn->sc_flags & VNF_INITED)
887                                 vnclear(vn);
888                         /* Cleanup all cdev_t's that refer to this unit */
889                         disk_destroy(&vn->sc_disk);
890                         while ((dev = vn->sc_devlist) != NULL) {
891                                 vn->sc_devlist = dev->si_drv2;
892                                 dev->si_drv1 = dev->si_drv2 = NULL;
893                                 destroy_dev(dev);
894                         }
895                         kfree(vn, M_DEVBUF);
896                 }
897                 dev_ops_remove_all(&vn_ops);
898                 break;
899         default:
900                 break;
901         }
902         return 0;
903 }
904
905 DEV_MODULE(vn, vn_modevent, 0);