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