kernel -- vn: Implement BUF_CMD_FLUSH for vn(ode) 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. 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                 switch (bp->b_cmd) {
345                 case (BUF_CMD_READ):
346                         vn_lock(vn->sc_vp, LK_SHARED | LK_RETRY);
347                         error = VOP_READ(vn->sc_vp, &auio, IO_RECURSE,
348                                          vn->sc_cred);
349                         break;
350
351                 case (BUF_CMD_WRITE):
352                         vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
353                         error = VOP_WRITE(vn->sc_vp, &auio, IO_RECURSE,
354                                           vn->sc_cred);
355                         break;
356
357                 case (BUF_CMD_FLUSH):
358                         auio.uio_resid = 0;
359                         vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
360                         error = VOP_FSYNC(vn->sc_vp, MNT_WAIT, 0);
361                         break;
362                 default:
363                         auio.uio_resid = 0;
364                         error = 0;
365                         break;
366                 }
367                 vn_unlock(vn->sc_vp);
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);
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);
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         IFOPT(vn, VN_RESERVE) {
641                 if (swap_pager_reserve(vn->sc_object, 0, vn->sc_size) < 0) {
642                         vm_pager_deallocate(vn->sc_object);
643                         vn->sc_object = NULL;
644                         return(EDOM);
645                 }
646         }
647         vn->sc_flags |= VNF_INITED;
648
649         error = vnsetcred(vn, cred);
650         if (error == 0) {
651                 /*
652                  * Set the disk info so that probing is triggered
653                  */
654                 bzero(&info, sizeof(struct disk_info));
655                 info.d_media_blksize = vn->sc_secsize;
656                 info.d_media_blocks = vn->sc_size;
657                 /*
658                  * reserve mbr sector for backwards compatibility
659                  * when no slices exist.
660                  */
661                 info.d_dsflags = DSO_COMPATMBR | DSO_RAWPSIZE;
662                 info.d_secpertrack = 32;
663                 info.d_nheads = 64 / (vn->sc_secsize / DEV_BSIZE);
664                 info.d_secpercyl = info.d_secpertrack * info.d_nheads;
665                 info.d_ncylinders = vn->sc_size / info.d_secpercyl;
666                 disk_setdiskinfo_sync(&vn->sc_disk, &info);
667
668                 error = dev_dopen(dev, flag, S_IFCHR, cred);
669         }
670         if (error == 0) {
671                 IFOPT(vn, VN_FOLLOW) {
672                         kprintf("vnioctl: SET vp %p size %llx\n",
673                                vn->sc_vp, (long long)vn->sc_size);
674                 }
675         }
676         if (error)
677                 vnclear(vn);
678         return(error);
679 }
680
681 /*
682  * Duplicate the current processes' credentials.  Since we are called only
683  * as the result of a SET ioctl and only root can do that, any future access
684  * to this "disk" is essentially as root.  Note that credentials may change
685  * if some other uid can write directly to the mapped file (NFS).
686  */
687 int
688 vnsetcred(struct vn_softc *vn, struct ucred *cred)
689 {
690         char *tmpbuf;
691         int error = 0;
692
693         /*
694          * Set credits in our softc
695          */
696
697         if (vn->sc_cred)
698                 crfree(vn->sc_cred);
699         vn->sc_cred = crdup(cred);
700
701         /*
702          * Horrible kludge to establish credentials for NFS  XXX.
703          */
704
705         if (vn->sc_vp) {
706                 struct uio auio;
707                 struct iovec aiov;
708
709                 tmpbuf = kmalloc(vn->sc_secsize, M_TEMP, M_WAITOK);
710                 bzero(&auio, sizeof(auio));
711
712                 aiov.iov_base = tmpbuf;
713                 aiov.iov_len = vn->sc_secsize;
714                 auio.uio_iov = &aiov;
715                 auio.uio_iovcnt = 1;
716                 auio.uio_offset = 0;
717                 auio.uio_rw = UIO_READ;
718                 auio.uio_segflg = UIO_SYSSPACE;
719                 auio.uio_resid = aiov.iov_len;
720                 vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY);
721                 error = VOP_READ(vn->sc_vp, &auio, 0, vn->sc_cred);
722                 vn_unlock(vn->sc_vp);
723                 kfree(tmpbuf, M_TEMP);
724         }
725         return (error);
726 }
727
728 void
729 vnclear(struct vn_softc *vn)
730 {
731         IFOPT(vn, VN_FOLLOW)
732                 kprintf("vnclear(%p): vp=%p\n", vn, vn->sc_vp);
733         vn->sc_flags &= ~VNF_INITED;
734         if (vn->sc_vp != NULL) {
735                 vn_close(vn->sc_vp,
736                     (vn->sc_flags & VNF_READONLY) ?  FREAD : (FREAD|FWRITE));
737                 vn->sc_vp = NULL;
738         }
739         vn->sc_flags &= ~VNF_READONLY;
740         if (vn->sc_cred) {
741                 crfree(vn->sc_cred);
742                 vn->sc_cred = NULL;
743         }
744         if (vn->sc_object != NULL) {
745                 vm_pager_deallocate(vn->sc_object);
746                 vn->sc_object = NULL;
747         }
748
749         disk_unprobe(&vn->sc_disk);
750
751         vn->sc_size = 0;
752 }
753
754 /*
755  *      vnget:
756  *
757  *      populate a struct vn_user for the VNIOCGET ioctl.
758  *      interface conventions defined in sys/sys/vnioctl.h.
759  */
760
761 static int
762 vnget(cdev_t dev, struct vn_softc *vn, struct vn_user *vnu)
763 {
764         int error, found = 0; 
765         char *freepath, *fullpath;
766         struct vattr vattr;
767
768         if (vnu->vnu_unit == -1) {
769                 vnu->vnu_unit = dkunit(dev);
770         }
771         else if (vnu->vnu_unit < 0)
772                 return (EINVAL);
773
774         SLIST_FOREACH(vn, &vn_list, sc_list) {
775
776                 if(vn->sc_unit != vnu->vnu_unit)
777                         continue;
778
779                 found = 1;
780
781                 if (vn->sc_flags & VNF_INITED && vn->sc_vp != NULL) {
782
783                         /* note: u_cred checked in vnioctl above */
784                         error = VOP_GETATTR(vn->sc_vp, &vattr);
785                         if (error) {
786                                 kprintf("vnget: VOP_GETATTR for %p failed\n",
787                                         vn->sc_vp);
788                                 return (error);
789                         }
790
791                         error = vn_fullpath(curproc, vn->sc_vp,
792                                                 &fullpath, &freepath, 0);
793
794                         if (error) {
795                                 kprintf("vnget: unable to resolve vp %p\n",
796                                         vn->sc_vp);
797                                 return(error);
798                         }
799                         
800                         strlcpy(vnu->vnu_file, fullpath,
801                                 sizeof(vnu->vnu_file));
802                         kfree(freepath, M_TEMP);
803                         vnu->vnu_dev = vattr.va_fsid;
804                         vnu->vnu_ino = vattr.va_fileid;
805
806                 } 
807                 else if (vn->sc_flags & VNF_INITED && vn->sc_object != NULL){
808
809                         strlcpy(vnu->vnu_file, _VN_USER_SWAP,
810                                 sizeof(vnu->vnu_file));
811                         vnu->vnu_size = vn->sc_size;
812                         vnu->vnu_secsize = vn->sc_secsize;
813
814                 } else {
815
816                         bzero(vnu->vnu_file, sizeof(vnu->vnu_file));
817                         vnu->vnu_dev = 0;
818                         vnu->vnu_ino = 0;
819
820                 }
821                 break;
822         }
823
824         if (!found)
825                 return(ENXIO);
826
827         return(0);
828 }
829
830 static int
831 vnsize(struct dev_psize_args *ap)
832 {
833         cdev_t dev = ap->a_head.a_dev;
834         struct vn_softc *vn;
835
836         vn = dev->si_drv1;
837         if (!vn)
838                 return(ENXIO);
839         if ((vn->sc_flags & VNF_INITED) == 0)
840                 return(ENXIO);
841         ap->a_result = (int64_t)vn->sc_size;
842         return(0);
843 }
844
845 static cdev_t
846 vn_create(int unit, struct devfs_bitmap *bitmap, int clone)
847 {
848         struct vn_softc *vn;
849         struct disk_info info;
850         cdev_t dev, ret_dev;
851
852         vn = vncreatevn();
853         if (clone) {
854                 /*
855                  * For clone devices we need to return the top-level cdev,
856                  * not the raw dev we'd normally work with.
857                  */
858                 dev = disk_create_clone(unit, &vn->sc_disk, &vn_ops);
859                 ret_dev = vn->sc_disk.d_cdev;
860         } else {
861                 ret_dev = dev = disk_create(unit, &vn->sc_disk, &vn_ops);
862         }
863         vninitvn(vn, dev);
864
865         bzero(&info, sizeof(struct disk_info));
866         info.d_media_blksize = 512;
867         info.d_media_blocks = 0;
868         info.d_dsflags = DSO_MBRQUIET | DSO_RAWPSIZE;
869         info.d_secpertrack = 32;
870         info.d_nheads = 64;
871         info.d_secpercyl = info.d_secpertrack * info.d_nheads;
872         info.d_ncylinders = 0;
873         disk_setdiskinfo_sync(&vn->sc_disk, &info);
874
875         if (bitmap != NULL)
876                 devfs_clone_bitmap_set(bitmap, unit);
877
878         return ret_dev;
879 }
880
881 static int 
882 vn_modevent(module_t mod, int type, void *data)
883 {
884         struct vn_softc *vn;
885         static cdev_t dev = NULL;
886         int i;
887
888         switch (type) {
889         case MOD_LOAD:
890                 dev = make_autoclone_dev(&vn_ops, &DEVFS_CLONE_BITMAP(vn), vnclone, UID_ROOT,
891                     GID_OPERATOR, 0640, "vn");
892
893                 for (i = 0; i < VN_PREALLOCATED_UNITS; i++) {
894                         vn_create(i, &DEVFS_CLONE_BITMAP(vn), 0);
895                 }
896                 break;
897
898         case MOD_UNLOAD:
899         case MOD_SHUTDOWN:
900                 while ((vn = SLIST_FIRST(&vn_list)) != NULL) {
901                         /*
902                          * XXX: no idea if we can return EBUSY even in the
903                          *      shutdown case, so err on the side of caution
904                          *      and just rip stuff out on shutdown.
905                          */
906                         if (type != MOD_SHUTDOWN) {
907                                 if (vn->sc_flags & VNF_OPENED)
908                                         return (EBUSY);
909                         }
910
911                         disk_destroy(&vn->sc_disk);
912
913                         SLIST_REMOVE_HEAD(&vn_list, sc_list);
914
915                         if (vn->sc_flags & VNF_INITED)
916                                 vnclear(vn);
917
918                         kfree(vn, M_VN);
919                 }
920                 destroy_autoclone_dev(dev, &DEVFS_CLONE_BITMAP(vn));
921                 dev_ops_remove_all(&vn_ops);
922                 break;
923         default:
924                 break;
925         }
926         return 0;
927 }
928
929 DEV_MODULE(vn, vn_modevent, 0);