VN - Remove use of IO_DIRECT, Improve lock performance for reads
[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
357                 /*
358                  * Don't use IO_DIRECT here, it really gets in the way
359                  * due to typical blocksize differences between the
360                  * fs backing the VN device and whatever is running on
361                  * the VN device.
362                  */
363                 if (bp->b_cmd == BUF_CMD_READ) {
364                         vn_lock(vn->sc_vp, LK_SHARED | LK_RETRY);
365                         error = VOP_READ(vn->sc_vp, &auio, IO_RECURSE,
366                                          vn->sc_cred);
367                 } else {
368                         vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
369                         error = VOP_WRITE(vn->sc_vp, &auio, IO_RECURSE,
370                                           vn->sc_cred);
371                 }
372                 vn_unlock(vn->sc_vp);
373                 bp->b_resid = auio.uio_resid;
374                 if (error) {
375                         bp->b_error = error;
376                         bp->b_flags |= B_ERROR;
377                 }
378                 /* operation complete */
379         } else if (vn->sc_object) {
380                 /*
381                  * OBJT_SWAP I/O (handles read, write, freebuf)
382                  *
383                  * We have nothing to do if freeing  blocks on a reserved
384                  * swap area, othrewise execute the op.
385                  */
386                 if (bp->b_cmd == BUF_CMD_FREEBLKS && TESTOPT(vn, VN_RESERVE)) {
387                         bp->b_resid = 0;
388                         /* operation complete */
389                 } else {
390                         swap_pager_strategy(vn->sc_object, nbio);
391                         return(0);
392                         /* NOT REACHED */
393                 }
394         } else {
395                 bp->b_resid = bp->b_bcount;
396                 bp->b_flags |= B_ERROR | B_INVAL;
397                 bp->b_error = EINVAL;
398                 /* operation complete */
399         }
400         biodone(nbio);
401         return(0);
402 }
403
404 /* ARGSUSED */
405 static  int
406 vnioctl(struct dev_ioctl_args *ap)
407 {
408         cdev_t dev = ap->a_head.a_dev;
409         struct vn_softc *vn;
410         struct vn_ioctl *vio;
411         int error;
412         u_long *f;
413
414         vn = dev->si_drv1;
415         IFOPT(vn,VN_FOLLOW) {
416                 kprintf("vnioctl(%s, 0x%lx, %p, 0x%x): unit %d\n",
417                     devtoname(dev), ap->a_cmd, ap->a_data, ap->a_fflag,
418                     dkunit(dev));
419         }
420
421         switch (ap->a_cmd) {
422         case VNIOCATTACH:
423         case VNIOCDETACH:
424         case VNIOCGSET:
425         case VNIOCGCLEAR:
426         case VNIOCGET:
427         case VNIOCUSET:
428         case VNIOCUCLEAR:
429                 goto vn_specific;
430         }
431
432 #if 0
433         if (dkslice(dev) != WHOLE_DISK_SLICE ||
434                 dkpart(dev) != WHOLE_SLICE_PART)
435                 return (ENOTTY);
436 #endif
437
438     vn_specific:
439
440         error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
441         if (error)
442                 return (error);
443
444         vio = (struct vn_ioctl *)ap->a_data;
445         f = (u_long*)ap->a_data;
446
447         switch (ap->a_cmd) {
448         case VNIOCATTACH:
449                 if (vn->sc_flags & VNF_INITED)
450                         return(EBUSY);
451
452                 if (vio->vn_file == NULL)
453                         error = vniocattach_swap(vn, vio, dev, ap->a_fflag, ap->a_cred);
454                 else
455                         error = vniocattach_file(vn, vio, dev, ap->a_fflag, ap->a_cred);
456                 break;
457
458         case VNIOCDETACH:
459                 if ((vn->sc_flags & VNF_INITED) == 0)
460                         return(ENXIO);
461                 /*
462                  * XXX handle i/o in progress.  Return EBUSY, or wait, or
463                  * flush the i/o.
464                  * XXX handle multiple opens of the device.  Return EBUSY,
465                  * or revoke the fd's.
466                  * How are these problems handled for removable and failing
467                  * hardware devices? (Hint: They are not)
468                  */
469                 if (count_dev(vn->sc_devlist) > 1)
470                         return (EBUSY);
471
472                 vnclear(vn);
473                 IFOPT(vn, VN_FOLLOW)
474                         kprintf("vnioctl: CLRed\n");
475
476                 if (dkunit(dev) >= VN_PREALLOCATED_UNITS) {
477                         devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(vn), dkunit(dev));
478                         disk_destroy(&vn->sc_disk);
479                 }
480
481                 break;
482
483         case VNIOCGET:
484                 error = vnget(dev, vn, (struct vn_user *) ap->a_data);
485                 break;
486
487         case VNIOCGSET:
488                 vn_options |= *f;
489                 *f = vn_options;
490                 break;
491
492         case VNIOCGCLEAR:
493                 vn_options &= ~(*f);
494                 *f = vn_options;
495                 break;
496
497         case VNIOCUSET:
498                 vn->sc_options |= *f;
499                 *f = vn->sc_options;
500                 break;
501
502         case VNIOCUCLEAR:
503                 vn->sc_options &= ~(*f);
504                 *f = vn->sc_options;
505                 break;
506
507         default:
508                 error = ENOTTY;
509                 break;
510         }
511         return(error);
512 }
513
514 /*
515  *      vniocattach_file:
516  *
517  *      Attach a file to a VN partition.  Return the size in the vn_size
518  *      field.
519  */
520
521 static int
522 vniocattach_file(struct vn_softc *vn, struct vn_ioctl *vio, cdev_t dev,
523                  int flag, struct ucred *cred)
524 {
525         struct vattr vattr;
526         struct nlookupdata nd;
527         int error, flags;
528         struct vnode *vp;
529         struct disk_info info;
530
531         flags = FREAD|FWRITE;
532         error = nlookup_init(&nd, vio->vn_file, 
533                                 UIO_USERSPACE, NLC_FOLLOW|NLC_LOCKVP);
534         if (error)
535                 return (error);
536         if ((error = vn_open(&nd, NULL, flags, 0)) != 0) {
537                 if (error != EACCES && error != EPERM && error != EROFS)
538                         goto done;
539                 flags &= ~FWRITE;
540                 nlookup_done(&nd);
541                 error = nlookup_init(&nd, vio->vn_file, UIO_USERSPACE, NLC_FOLLOW|NLC_LOCKVP);
542                 if (error)
543                         return (error);
544                 if ((error = vn_open(&nd, NULL, flags, 0)) != 0)
545                         goto done;
546         }
547         vp = nd.nl_open_vp;
548         if (vp->v_type != VREG ||
549             (error = VOP_GETATTR(vp, &vattr))) {
550                 if (error == 0)
551                         error = EINVAL;
552                 goto done;
553         }
554         vn_unlock(vp);
555         vn->sc_secsize = DEV_BSIZE;
556         vn->sc_vp = vp;
557         nd.nl_open_vp = NULL;
558
559         /*
560          * If the size is specified, override the file attributes.  Note that
561          * the vn_size argument is in PAGE_SIZE sized blocks.
562          */
563         if (vio->vn_size)
564                 vn->sc_size = vio->vn_size * PAGE_SIZE / vn->sc_secsize;
565         else
566                 vn->sc_size = vattr.va_size / vn->sc_secsize;
567         error = vnsetcred(vn, cred);
568         if (error) {
569                 vn->sc_vp = NULL;
570                 vn_close(vp, flags);
571                 goto done;
572         }
573         vn->sc_flags |= VNF_INITED;
574         if (flags == FREAD)
575                 vn->sc_flags |= VNF_READONLY;
576
577         /*
578          * Set the disk info so that probing is triggered
579          */
580         bzero(&info, sizeof(struct disk_info));
581         info.d_media_blksize = vn->sc_secsize;
582         info.d_media_blocks = vn->sc_size;
583         /*
584          * reserve mbr sector for backwards compatibility
585          * when no slices exist.
586          */
587         info.d_dsflags = DSO_COMPATMBR;
588         info.d_secpertrack = 32;
589         info.d_nheads = 64 / (vn->sc_secsize / DEV_BSIZE);
590         info.d_secpercyl = info.d_secpertrack * info.d_nheads;
591         info.d_ncylinders = vn->sc_size / info.d_secpercyl;
592         disk_setdiskinfo_sync(&vn->sc_disk, &info);
593
594         error = dev_dopen(dev, flag, S_IFCHR, cred);
595         if (error)
596                 vnclear(vn);
597
598         IFOPT(vn, VN_FOLLOW)
599                 kprintf("vnioctl: SET vp %p size %llx blks\n",
600                        vn->sc_vp, (long long)vn->sc_size);
601 done:
602         nlookup_done(&nd);
603         return(error);
604 }
605
606 /*
607  *      vniocattach_swap:
608  *
609  *      Attach swap backing store to a VN partition of the size specified
610  *      in vn_size.
611  */
612
613 static int
614 vniocattach_swap(struct vn_softc *vn, struct vn_ioctl *vio, cdev_t dev,
615                  int flag, struct ucred *cred)
616 {
617         int error;
618         struct disk_info info;
619
620         /*
621          * Range check.  Disallow negative sizes or any size less then the
622          * size of a page.  Then round to a page.
623          */
624
625         if (vio->vn_size <= 0)
626                 return(EDOM);
627
628         /*
629          * Allocate an OBJT_SWAP object.
630          *
631          * sc_secsize is PAGE_SIZE'd
632          *
633          * vio->vn_size is in PAGE_SIZE'd chunks.
634          * sc_size must be in PAGE_SIZE'd chunks.  
635          * Note the truncation.
636          */
637
638         vn->sc_secsize = PAGE_SIZE;
639         vn->sc_size = vio->vn_size;
640         vn->sc_object = swap_pager_alloc(NULL,
641                                          vn->sc_secsize * (off_t)vio->vn_size,
642                                          VM_PROT_DEFAULT, 0);
643         IFOPT(vn, VN_RESERVE) {
644                 if (swap_pager_reserve(vn->sc_object, 0, vn->sc_size) < 0) {
645                         vm_pager_deallocate(vn->sc_object);
646                         vn->sc_object = NULL;
647                         return(EDOM);
648                 }
649         }
650         vn->sc_flags |= VNF_INITED;
651
652         error = vnsetcred(vn, cred);
653         if (error == 0) {
654                 /*
655                  * Set the disk info so that probing is triggered
656                  */
657                 bzero(&info, sizeof(struct disk_info));
658                 info.d_media_blksize = vn->sc_secsize;
659                 info.d_media_blocks = vn->sc_size;
660                 /*
661                  * reserve mbr sector for backwards compatibility
662                  * when no slices exist.
663                  */
664                 info.d_dsflags = DSO_COMPATMBR;
665                 info.d_secpertrack = 32;
666                 info.d_nheads = 64 / (vn->sc_secsize / DEV_BSIZE);
667                 info.d_secpercyl = info.d_secpertrack * info.d_nheads;
668                 info.d_ncylinders = vn->sc_size / info.d_secpercyl;
669                 disk_setdiskinfo_sync(&vn->sc_disk, &info);
670
671                 error = dev_dopen(dev, flag, S_IFCHR, cred);
672         }
673         if (error == 0) {
674                 IFOPT(vn, VN_FOLLOW) {
675                         kprintf("vnioctl: SET vp %p size %llx\n",
676                                vn->sc_vp, (long long)vn->sc_size);
677                 }
678         }
679         if (error)
680                 vnclear(vn);
681         return(error);
682 }
683
684 /*
685  * Duplicate the current processes' credentials.  Since we are called only
686  * as the result of a SET ioctl and only root can do that, any future access
687  * to this "disk" is essentially as root.  Note that credentials may change
688  * if some other uid can write directly to the mapped file (NFS).
689  */
690 int
691 vnsetcred(struct vn_softc *vn, struct ucred *cred)
692 {
693         char *tmpbuf;
694         int error = 0;
695
696         /*
697          * Set credits in our softc
698          */
699
700         if (vn->sc_cred)
701                 crfree(vn->sc_cred);
702         vn->sc_cred = crdup(cred);
703
704         /*
705          * Horrible kludge to establish credentials for NFS  XXX.
706          */
707
708         if (vn->sc_vp) {
709                 struct uio auio;
710                 struct iovec aiov;
711
712                 tmpbuf = kmalloc(vn->sc_secsize, M_TEMP, M_WAITOK);
713                 bzero(&auio, sizeof(auio));
714
715                 aiov.iov_base = tmpbuf;
716                 aiov.iov_len = vn->sc_secsize;
717                 auio.uio_iov = &aiov;
718                 auio.uio_iovcnt = 1;
719                 auio.uio_offset = 0;
720                 auio.uio_rw = UIO_READ;
721                 auio.uio_segflg = UIO_SYSSPACE;
722                 auio.uio_resid = aiov.iov_len;
723                 vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
724                 error = VOP_READ(vn->sc_vp, &auio, 0, vn->sc_cred);
725                 vn_unlock(vn->sc_vp);
726                 kfree(tmpbuf, M_TEMP);
727         }
728         return (error);
729 }
730
731 void
732 vnclear(struct vn_softc *vn)
733 {
734         IFOPT(vn, VN_FOLLOW)
735                 kprintf("vnclear(%p): vp=%p\n", vn, vn->sc_vp);
736         vn->sc_flags &= ~VNF_INITED;
737         if (vn->sc_vp != NULL) {
738                 vn_close(vn->sc_vp,
739                     (vn->sc_flags & VNF_READONLY) ?  FREAD : (FREAD|FWRITE));
740                 vn->sc_vp = NULL;
741         }
742         vn->sc_flags &= ~VNF_READONLY;
743         if (vn->sc_cred) {
744                 crfree(vn->sc_cred);
745                 vn->sc_cred = NULL;
746         }
747         if (vn->sc_object != NULL) {
748                 vm_pager_deallocate(vn->sc_object);
749                 vn->sc_object = NULL;
750         }
751
752         disk_unprobe(&vn->sc_disk);
753
754         vn->sc_size = 0;
755 }
756
757 /*
758  *      vnget:
759  *
760  *      populate a struct vn_user for the VNIOCGET ioctl.
761  *      interface conventions defined in sys/sys/vnioctl.h.
762  */
763
764 static int
765 vnget(cdev_t dev, struct vn_softc *vn, struct vn_user *vnu)
766 {
767         int error, found = 0; 
768         char *freepath, *fullpath;
769         struct vattr vattr;
770
771         if (vnu->vnu_unit == -1) {
772                 vnu->vnu_unit = dkunit(dev);
773         }
774         else if (vnu->vnu_unit < 0)
775                 return (EINVAL);
776
777         SLIST_FOREACH(vn, &vn_list, sc_list) {
778
779                 if(vn->sc_unit != vnu->vnu_unit)
780                         continue;
781
782                 found = 1;
783
784                 if (vn->sc_flags & VNF_INITED && vn->sc_vp != NULL) {
785
786                         /* note: u_cred checked in vnioctl above */
787                         error = VOP_GETATTR(vn->sc_vp, &vattr);
788                         if (error) {
789                                 kprintf("vnget: VOP_GETATTR for %p failed\n",
790                                         vn->sc_vp);
791                                 return (error);
792                         }
793
794                         error = vn_fullpath(curproc, vn->sc_vp,
795                                                 &fullpath, &freepath);
796
797                         if (error) {
798                                 kprintf("vnget: unable to resolve vp %p\n",
799                                         vn->sc_vp);
800                                 return(error);
801                         }
802                         
803                         strlcpy(vnu->vnu_file, fullpath,
804                                 sizeof(vnu->vnu_file));
805                         kfree(freepath, M_TEMP);
806                         vnu->vnu_dev = vattr.va_fsid;
807                         vnu->vnu_ino = vattr.va_fileid;
808
809                 } 
810                 else if (vn->sc_flags & VNF_INITED && vn->sc_object != NULL){
811
812                         strlcpy(vnu->vnu_file, _VN_USER_SWAP,
813                                 sizeof(vnu->vnu_file));
814                         vnu->vnu_size = vn->sc_size;
815                         vnu->vnu_secsize = vn->sc_secsize;
816
817                 } else {
818
819                         bzero(vnu->vnu_file, sizeof(vnu->vnu_file));
820                         vnu->vnu_dev = 0;
821                         vnu->vnu_ino = 0;
822
823                 }
824                 break;
825         }
826
827         if (!found)
828                 return(ENXIO);
829
830         return(0);
831 }
832
833 static int
834 vnsize(struct dev_psize_args *ap)
835 {
836         cdev_t dev = ap->a_head.a_dev;
837         struct vn_softc *vn;
838
839         vn = dev->si_drv1;
840         if (!vn)
841                 return(ENXIO);
842         if ((vn->sc_flags & VNF_INITED) == 0)
843                 return(ENXIO);
844         ap->a_result = (int64_t)vn->sc_size;
845         return(0);
846 }
847
848 static cdev_t
849 vn_create(int unit, struct devfs_bitmap *bitmap)
850 {
851         struct vn_softc *vn;
852         struct disk_info info;
853         cdev_t dev;
854
855         vn = vncreatevn();
856         dev = disk_create(unit, &vn->sc_disk, &vn_ops);
857         vninitvn(vn, dev);
858
859         bzero(&info, sizeof(struct disk_info));
860         info.d_media_blksize = 512;
861         info.d_media_blocks = 0;
862         info.d_dsflags = DSO_MBRQUIET;
863         info.d_secpertrack = 32;
864         info.d_nheads = 64;
865         info.d_secpercyl = info.d_secpertrack * info.d_nheads;
866         info.d_ncylinders = 0;
867         disk_setdiskinfo_sync(&vn->sc_disk, &info);
868
869         if (bitmap != NULL)
870                 devfs_clone_bitmap_set(bitmap, unit);
871
872         return dev;
873 }
874
875 static int 
876 vn_modevent(module_t mod, int type, void *data)
877 {
878         struct vn_softc *vn;
879         static cdev_t dev = NULL;
880         int i;
881
882         switch (type) {
883         case MOD_LOAD:
884                 dev = make_autoclone_dev(&vn_ops, &DEVFS_CLONE_BITMAP(vn), vnclone, UID_ROOT,
885                     GID_OPERATOR, 0640, "vn");
886
887                 for (i = 0; i < VN_PREALLOCATED_UNITS; i++) {
888                         vn_create(i, &DEVFS_CLONE_BITMAP(vn));
889                 }
890                 break;
891         case MOD_UNLOAD:
892                 destroy_autoclone_dev(dev, &DEVFS_CLONE_BITMAP(vn));
893                 /* fall through */
894         case MOD_SHUTDOWN:
895                 while ((vn = SLIST_FIRST(&vn_list)) != NULL) {
896                         SLIST_REMOVE_HEAD(&vn_list, sc_list);
897                         if (vn->sc_flags & VNF_INITED)
898                                 vnclear(vn);
899                         /* Cleanup all cdev_t's that refer to this unit */
900                         disk_destroy(&vn->sc_disk);
901                         while ((dev = vn->sc_devlist) != NULL) {
902                                 vn->sc_devlist = dev->si_drv2;
903                                 dev->si_drv1 = dev->si_drv2 = NULL;
904                                 destroy_dev(dev);
905                         }
906                         kfree(vn, M_DEVBUF);
907                 }
908                 dev_ops_remove_all(&vn_ops);
909                 break;
910         default:
911                 break;
912         }
913         return 0;
914 }
915
916 DEV_MODULE(vn, vn_modevent, 0);