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