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