Cleanup cdevsw and dev reference counting ops to fix a warning that occurs
[dragonfly.git] / sys / dev / disk / vn / vn.c
1 /*
2  * Copyright (c) 1988 University of Utah.
3  * Copyright (c) 1990, 1993
4  *      The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * the Systems Programming Group of the University of Utah Computer
8  * Science Department.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * from: Utah Hdr: vn.c 1.13 94/04/02
39  *
40  *      from: @(#)vn.c  8.6 (Berkeley) 4/1/94
41  * $FreeBSD: src/sys/dev/vn/vn.c,v 1.105.2.4 2001/11/18 07:11:00 dillon Exp $
42  * $DragonFly: src/sys/dev/disk/vn/vn.c,v 1.11 2004/05/26 01:14:36 dillon Exp $
43  */
44
45 /*
46  * Vnode disk driver.
47  *
48  * Block/character interface to a vnode.  Allows one to treat a file
49  * as a disk (e.g. build a filesystem in it, mount it, etc.).
50  *
51  * NOTE 1: This uses the VOP_BMAP/VOP_STRATEGY interface to the vnode
52  * instead of a simple VOP_RDWR.  We do this to avoid distorting the
53  * local buffer cache.
54  *
55  * NOTE 2: There is a security issue involved with this driver.
56  * Once mounted all access to the contents of the "mapped" file via
57  * the special file is controlled by the permissions on the special
58  * file, the protection of the mapped file is ignored (effectively,
59  * by using root credentials in all transactions).
60  *
61  * NOTE 3: Doesn't interact with leases, should it?
62  */
63
64 #include <sys/param.h>
65 #include <sys/systm.h>
66 #include <sys/kernel.h>
67 #include <sys/proc.h>
68 #include <sys/namei.h>
69 #include <sys/buf.h>
70 #include <sys/malloc.h>
71 #include <sys/mount.h>
72 #include <sys/vnode.h>
73 #include <sys/fcntl.h>
74 #include <sys/conf.h>
75 #include <sys/disklabel.h>
76 #include <sys/diskslice.h>
77 #include <sys/stat.h>
78 #include <sys/conf.h>
79 #include <sys/module.h>
80 #include <sys/vnioctl.h>
81
82 #include <vm/vm.h>
83 #include <vm/vm_object.h>
84 #include <vm/vm_page.h>
85 #include <vm/vm_pager.h>
86 #include <vm/vm_pageout.h>
87 #include <vm/swap_pager.h>
88 #include <vm/vm_extern.h>
89 #include <vm/vm_zone.h>
90
91 static  d_ioctl_t       vnioctl;
92 static  d_open_t        vnopen;
93 static  d_close_t       vnclose;
94 static  d_psize_t       vnsize;
95 static  d_strategy_t    vnstrategy;
96
97 #define CDEV_MAJOR 43
98
99 #define VN_BSIZE_BEST   8192
100
101 /*
102  * cdevsw
103  *      D_DISK          we want to look like a disk
104  *      D_CANFREE       We support B_FREEBUF
105  */
106
107 static struct cdevsw vn_cdevsw = {
108         /* name */      "vn",
109         /* maj */       CDEV_MAJOR,
110         /* flags */     D_DISK|D_CANFREE,
111         /* port */      NULL,
112         /* clone */     NULL,
113
114         /* open */      vnopen,
115         /* close */     vnclose,
116         /* read */      physread,
117         /* write */     physwrite,
118         /* ioctl */     vnioctl,
119         /* poll */      nopoll,
120         /* mmap */      nommap,
121         /* strategy */  vnstrategy,
122         /* dump */      nodump,
123         /* psize */     vnsize
124 };
125
126 #define getvnbuf()      \
127         ((struct buf *)malloc(sizeof(struct buf), M_DEVBUF, M_WAITOK))
128
129 #define putvnbuf(bp)    \
130         free((caddr_t)(bp), M_DEVBUF)
131
132 struct vn_softc {
133         int             sc_unit;
134         int             sc_flags;       /* flags                        */
135         int             sc_size;        /* size of vn, sc_secsize scale */
136         int             sc_secsize;     /* sector size                  */
137         struct diskslices *sc_slices;
138         struct vnode    *sc_vp;         /* vnode if not NULL            */
139         vm_object_t     sc_object;      /* backing object if not NULL   */
140         struct ucred    *sc_cred;       /* credentials                  */
141         int              sc_maxactive;  /* max # of active requests     */
142         struct buf       sc_tab;        /* transfer queue               */
143         u_long           sc_options;    /* options                      */
144         dev_t            sc_devlist;    /* devices that refer to this unit */
145         SLIST_ENTRY(vn_softc) sc_list;
146 };
147
148 static SLIST_HEAD(, vn_softc) vn_list;
149
150 /* sc_flags */
151 #define VNF_INITED      0x01
152 #define VNF_READONLY    0x02
153
154 static u_long   vn_options;
155
156 #define IFOPT(vn,opt) if (((vn)->sc_options|vn_options) & (opt))
157 #define TESTOPT(vn,opt) (((vn)->sc_options|vn_options) & (opt))
158
159 static int      vnsetcred (struct vn_softc *vn, struct ucred *cred);
160 static void     vnclear (struct vn_softc *vn);
161 static int      vn_modevent (module_t, int, void *);
162 static int      vniocattach_file (struct vn_softc *, struct vn_ioctl *, dev_t dev, int flag, struct thread *p);
163 static int      vniocattach_swap (struct vn_softc *, struct vn_ioctl *, dev_t dev, int flag, struct thread *p);
164
165 static  int
166 vnclose(dev_t dev, int flags, int mode, struct thread *td)
167 {
168         struct vn_softc *vn = dev->si_drv1;
169
170         IFOPT(vn, VN_LABELS)
171                 if (vn->sc_slices != NULL)
172                         dsclose(dev, mode, vn->sc_slices);
173         return (0);
174 }
175
176 /*
177  * Called only when si_drv1 is NULL.  Locate the associated vn node and
178  * attach the device to it.
179  */
180 static struct vn_softc *
181 vnfindvn(dev_t dev)
182 {
183         int unit;
184         struct vn_softc *vn;
185
186         unit = dkunit(dev);
187         SLIST_FOREACH(vn, &vn_list, sc_list) {
188                 if (vn->sc_unit == unit) {
189                         dev->si_drv1 = vn;
190                         dev->si_drv2 = vn->sc_devlist;
191                         vn->sc_devlist = dev;
192                         reference_dev(dev);
193                         break;
194                 }
195         }
196         if (vn == NULL) {
197                 vn = malloc(sizeof *vn, M_DEVBUF, M_WAITOK | M_ZERO);
198                 vn->sc_unit = unit;
199                 dev->si_drv1 = vn;
200                 vn->sc_devlist = make_dev(&vn_cdevsw, 0, UID_ROOT,
201                                         GID_OPERATOR, 0640, "vn%d", unit);
202                 if (vn->sc_devlist->si_drv1 == NULL) {
203                         reference_dev(vn->sc_devlist);
204                         vn->sc_devlist->si_drv1 = vn;
205                         vn->sc_devlist->si_drv2 = NULL;
206                 }
207                 if (vn->sc_devlist != dev) {
208                         dev->si_drv1 = vn;
209                         dev->si_drv2 = vn->sc_devlist;
210                         vn->sc_devlist = dev;
211                         reference_dev(dev);
212                 }
213                 SLIST_INSERT_HEAD(&vn_list, vn, sc_list);
214         }
215         return (vn);
216 }
217
218 static  int
219 vnopen(dev_t dev, int flags, int mode, struct thread *td)
220 {
221         struct vn_softc *vn;
222
223         /*
224          * Locate preexisting device
225          */
226
227         if ((vn = dev->si_drv1) == NULL)
228                 vn = vnfindvn(dev);
229
230         /*
231          * Update si_bsize fields for device.  This data will be overriden 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 ((flags & FWRITE) && (vn->sc_flags & VNF_READONLY))
244                 return (EACCES);
245
246         IFOPT(vn, VN_FOLLOW)
247                 printf("vnopen(%s, 0x%x, 0x%x, %p)\n",
248                     devtoname(dev), flags, mode, (void *)td);
249
250         /*
251          * Initialize label
252          */
253
254         IFOPT(vn, VN_LABELS) {
255                 if (vn->sc_flags & VNF_INITED) {
256                         struct disklabel label;
257
258                         /* Build label for whole disk. */
259                         bzero(&label, sizeof label);
260                         label.d_secsize = vn->sc_secsize;
261                         label.d_nsectors = 32;
262                         label.d_ntracks = 64 / (vn->sc_secsize / DEV_BSIZE);
263                         label.d_secpercyl = label.d_nsectors * label.d_ntracks;
264                         label.d_ncylinders = vn->sc_size / label.d_secpercyl;
265                         label.d_secperunit = vn->sc_size;
266                         label.d_partitions[RAW_PART].p_size = vn->sc_size;
267
268                         return (dsopen(dev, mode, 0, &vn->sc_slices, &label));
269                 }
270                 if (dkslice(dev) != WHOLE_DISK_SLICE ||
271                     dkpart(dev) != RAW_PART ||
272                     mode != S_IFCHR) {
273                         return (ENXIO);
274                 }
275         }
276         return(0);
277 }
278
279 /*
280  *      vnstrategy:
281  *
282  *      Run strategy routine for VN device.  We use VOP_READ/VOP_WRITE calls
283  *      for vnode-backed vn's, and the new vm_pager_strategy() call for
284  *      vm_object-backed vn's.
285  *
286  *      Currently B_ASYNC is only partially handled - for OBJT_SWAP I/O only.
287  *
288  *      NOTE: bp->b_blkno is DEV_BSIZE'd.  We must generate bp->b_pblkno for
289  *      our uio or vn_pager_strategy() call that is vn->sc_secsize'd
290  */
291
292 static  void
293 vnstrategy(struct buf *bp)
294 {
295         int unit;
296         struct vn_softc *vn;
297         int error;
298
299         unit = dkunit(bp->b_dev);
300         if ((vn = bp->b_dev->si_drv1) == NULL)
301                 vn = vnfindvn(bp->b_dev);
302
303         IFOPT(vn, VN_DEBUG)
304                 printf("vnstrategy(%p): unit %d\n", bp, unit);
305
306         if ((vn->sc_flags & VNF_INITED) == 0) {
307                 bp->b_error = ENXIO;
308                 bp->b_flags |= B_ERROR;
309                 biodone(bp);
310                 return;
311         }
312
313         bp->b_resid = bp->b_bcount;
314
315         IFOPT(vn, VN_LABELS) {
316                 if (vn->sc_slices != NULL && dscheck(bp, vn->sc_slices) <= 0) {
317                         bp->b_flags |= B_INVAL;
318                         biodone(bp);
319                         return;
320                 }
321         } else {
322                 int pbn;        /* in sc_secsize chunks */
323                 long sz;        /* in sc_secsize chunks */
324
325                 /*
326                  * Check for required alignment.  Transfers must be a valid
327                  * multiple of the sector size.
328                  */
329                 if (bp->b_bcount % vn->sc_secsize != 0 ||
330                     bp->b_blkno % (vn->sc_secsize / DEV_BSIZE) != 0) {
331                         bp->b_error = EINVAL;
332                         bp->b_flags |= B_ERROR | B_INVAL;
333                         biodone(bp);
334                         return;
335                 }
336
337                 pbn = bp->b_blkno / (vn->sc_secsize / DEV_BSIZE);
338                 sz = howmany(bp->b_bcount, vn->sc_secsize);
339
340                 /*
341                  * If out of bounds return an error.  If at the EOF point,
342                  * simply read or write less.
343                  */
344                 if (pbn < 0 || pbn >= vn->sc_size) {
345                         if (pbn != vn->sc_size) {
346                                 bp->b_error = EINVAL;
347                                 bp->b_flags |= B_ERROR | B_INVAL;
348                         }
349                         biodone(bp);
350                         return;
351                 }
352
353                 /*
354                  * If the request crosses EOF, truncate the request.
355                  */
356                 if (pbn + sz > vn->sc_size) {
357                         bp->b_bcount = (vn->sc_size - pbn) * vn->sc_secsize;
358                         bp->b_resid = bp->b_bcount;
359                 }
360                 bp->b_pblkno = pbn;
361         }
362
363         if (vn->sc_vp && (bp->b_flags & B_FREEBUF)) {
364                 /*
365                  * Not handled for vnode-backed element yet.
366                  */
367                 biodone(bp);
368         } else if (vn->sc_vp) {
369                 /*
370                  * VNODE I/O
371                  *
372                  * If an error occurs, we set B_ERROR but we do not set 
373                  * B_INVAL because (for a write anyway), the buffer is 
374                  * still valid.
375                  */
376                 struct uio auio;
377                 struct iovec aiov;
378
379                 bzero(&auio, sizeof(auio));
380
381                 aiov.iov_base = bp->b_data;
382                 aiov.iov_len = bp->b_bcount;
383                 auio.uio_iov = &aiov;
384                 auio.uio_iovcnt = 1;
385                 auio.uio_offset = (vm_ooffset_t)bp->b_pblkno * vn->sc_secsize;
386                 auio.uio_segflg = UIO_SYSSPACE;
387                 if( bp->b_flags & B_READ)
388                         auio.uio_rw = UIO_READ;
389                 else
390                         auio.uio_rw = UIO_WRITE;
391                 auio.uio_resid = bp->b_bcount;
392                 auio.uio_td = curthread;
393                 vn_lock(vn->sc_vp, NULL, LK_EXCLUSIVE | LK_RETRY, curthread);
394                 if (bp->b_flags & B_READ)
395                         error = VOP_READ(vn->sc_vp, &auio, IO_DIRECT, vn->sc_cred);
396                 else
397                         error = VOP_WRITE(vn->sc_vp, &auio, IO_NOWDRAIN, vn->sc_cred);
398                 VOP_UNLOCK(vn->sc_vp, NULL, 0, curthread);
399                 bp->b_resid = auio.uio_resid;
400
401                 if (error) {
402                         bp->b_error = error;
403                         bp->b_flags |= B_ERROR;
404                 }
405                 biodone(bp);
406         } else if (vn->sc_object) {
407                 /*
408                  * OBJT_SWAP I/O
409                  *
410                  * ( handles read, write, freebuf )
411                  *
412                  * Note: if we pre-reserved swap, B_FREEBUF is disabled
413                  */
414                 KASSERT((bp->b_bufsize & (vn->sc_secsize - 1)) == 0,
415                     ("vnstrategy: buffer %p too small for physio", bp));
416
417                 if ((bp->b_flags & B_FREEBUF) && TESTOPT(vn, VN_RESERVE)) {
418                         biodone(bp);
419                 } else {
420                         vm_pager_strategy(vn->sc_object, bp);
421                 }
422         } else {
423                 bp->b_flags |= B_ERROR;
424                 bp->b_error = EINVAL;
425                 biodone(bp);
426         }
427 }
428
429 /* ARGSUSED */
430 static  int
431 vnioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
432 {
433         struct vn_softc *vn;
434         struct vn_ioctl *vio;
435         int error;
436         u_long *f;
437
438         vn = dev->si_drv1;
439         IFOPT(vn,VN_FOLLOW)
440                 printf("vnioctl(%s, 0x%lx, %p, 0x%x, %p): unit %d\n",
441                     devtoname(dev), cmd, (void *)data, flag, (void *)td,
442                     dkunit(dev));
443
444         switch (cmd) {
445         case VNIOCATTACH:
446         case VNIOCDETACH:
447         case VNIOCGSET:
448         case VNIOCGCLEAR:
449         case VNIOCUSET:
450         case VNIOCUCLEAR:
451                 goto vn_specific;
452         }
453
454         IFOPT(vn,VN_LABELS) {
455                 if (vn->sc_slices != NULL) {
456                         error = dsioctl(dev, cmd, data, flag, &vn->sc_slices);
457                         if (error != ENOIOCTL)
458                                 return (error);
459                 }
460                 if (dkslice(dev) != WHOLE_DISK_SLICE ||
461                     dkpart(dev) != RAW_PART)
462                         return (ENOTTY);
463         }
464
465     vn_specific:
466
467         error = suser(td);
468         if (error)
469                 return (error);
470
471         vio = (struct vn_ioctl *)data;
472         f = (u_long*)data;
473         switch (cmd) {
474
475         case VNIOCATTACH:
476                 if (vn->sc_flags & VNF_INITED)
477                         return(EBUSY);
478
479                 if (vio->vn_file == NULL)
480                         error = vniocattach_swap(vn, vio, dev, flag, td);
481                 else
482                         error = vniocattach_file(vn, vio, dev, flag, td);
483                 break;
484
485         case VNIOCDETACH:
486                 if ((vn->sc_flags & VNF_INITED) == 0)
487                         return(ENXIO);
488                 /*
489                  * XXX handle i/o in progress.  Return EBUSY, or wait, or
490                  * flush the i/o.
491                  * XXX handle multiple opens of the device.  Return EBUSY,
492                  * or revoke the fd's.
493                  * How are these problems handled for removable and failing
494                  * hardware devices? (Hint: They are not)
495                  */
496                 vnclear(vn);
497                 IFOPT(vn, VN_FOLLOW)
498                         printf("vnioctl: CLRed\n");
499                 break;
500
501         case VNIOCGSET:
502                 vn_options |= *f;
503                 *f = vn_options;
504                 break;
505
506         case VNIOCGCLEAR:
507                 vn_options &= ~(*f);
508                 *f = vn_options;
509                 break;
510
511         case VNIOCUSET:
512                 vn->sc_options |= *f;
513                 *f = vn->sc_options;
514                 break;
515
516         case VNIOCUCLEAR:
517                 vn->sc_options &= ~(*f);
518                 *f = vn->sc_options;
519                 break;
520
521         default:
522                 error = ENOTTY;
523                 break;
524         }
525         return(error);
526 }
527
528 /*
529  *      vniocattach_file:
530  *
531  *      Attach a file to a VN partition.  Return the size in the vn_size
532  *      field.
533  */
534
535 static int
536 vniocattach_file(vn, vio, dev, flag, td)
537         struct vn_softc *vn;
538         struct vn_ioctl *vio;
539         dev_t dev;
540         int flag;
541         struct thread *td;
542 {
543         struct vattr vattr;
544         struct nameidata nd;
545         int error, flags;
546         struct proc *p = td->td_proc;
547
548         KKASSERT(p != NULL);
549
550         flags = FREAD|FWRITE;
551         NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_USERSPACE, vio->vn_file, td);
552         error = vn_open(&nd, flags, 0);
553         if (error) {
554                 if (error != EACCES && error != EPERM && error != EROFS)
555                         return (error);
556                 flags &= ~FWRITE;
557                 NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW,
558                         UIO_USERSPACE, vio->vn_file, td);
559                 error = vn_open(&nd, flags, 0);
560                 if (error)
561                         return (error);
562         }
563         NDFREE(&nd, NDF_ONLY_PNBUF);
564         if (nd.ni_vp->v_type != VREG ||
565             (error = VOP_GETATTR(nd.ni_vp, &vattr, td))) {
566                 VOP_UNLOCK(nd.ni_vp, NULL, 0, td);
567                 (void) vn_close(nd.ni_vp, flags, td);
568                 return (error ? error : EINVAL);
569         }
570         VOP_UNLOCK(nd.ni_vp, NULL, 0, td);
571         vn->sc_secsize = DEV_BSIZE;
572         vn->sc_vp = nd.ni_vp;
573
574         /*
575          * If the size is specified, override the file attributes.  Note that
576          * the vn_size argument is in PAGE_SIZE sized blocks.
577          */
578         if (vio->vn_size)
579                 vn->sc_size = (quad_t)vio->vn_size * PAGE_SIZE / vn->sc_secsize;
580         else
581                 vn->sc_size = vattr.va_size / vn->sc_secsize;
582         error = vnsetcred(vn, p->p_ucred);
583         if (error) {
584                 (void) vn_close(nd.ni_vp, flags, td);
585                 return(error);
586         }
587         vn->sc_flags |= VNF_INITED;
588         if (flags == FREAD)
589                 vn->sc_flags |= VNF_READONLY;
590         IFOPT(vn, VN_LABELS) {
591                 /*
592                  * Reopen so that `ds' knows which devices are open.
593                  * If this is the first VNIOCSET, then we've
594                  * guaranteed that the device is the cdev and that
595                  * no other slices or labels are open.  Otherwise,
596                  * we rely on VNIOCCLR not being abused.
597                  */
598                 error = vnopen(dev, flag, S_IFCHR, td);
599                 if (error)
600                         vnclear(vn);
601         }
602         IFOPT(vn, VN_FOLLOW)
603                 printf("vnioctl: SET vp %p size %x blks\n",
604                        vn->sc_vp, vn->sc_size);
605         return(0);
606 }
607
608 /*
609  *      vniocattach_swap:
610  *
611  *      Attach swap backing store to a VN partition of the size specified
612  *      in vn_size.
613  */
614
615 static int
616 vniocattach_swap(vn, vio, dev, flag, td)
617         struct vn_softc *vn;
618         struct vn_ioctl *vio;
619         dev_t dev;
620         int flag;
621         struct thread *td;
622 {
623         int error;
624         struct proc *p = td->td_proc;
625
626         KKASSERT(p != NULL);
627         /*
628          * Range check.  Disallow negative sizes or any size less then the
629          * size of a page.  Then round to a page.
630          */
631
632         if (vio->vn_size <= 0)
633                 return(EDOM);
634
635         /*
636          * Allocate an OBJT_SWAP object.
637          *
638          * sc_secsize is PAGE_SIZE'd
639          *
640          * vio->vn_size is in PAGE_SIZE'd chunks.
641          * sc_size must be in PAGE_SIZE'd chunks.  
642          * Note the truncation.
643          */
644
645         vn->sc_secsize = PAGE_SIZE;
646         vn->sc_size = vio->vn_size;
647         vn->sc_object = 
648          vm_pager_allocate(OBJT_SWAP, NULL, vn->sc_secsize * (vm_ooffset_t)vio->vn_size, VM_PROT_DEFAULT, 0);
649         IFOPT(vn, VN_RESERVE) {
650                 if (swap_pager_reserve(vn->sc_object, 0, vn->sc_size) < 0) {
651                         vm_pager_deallocate(vn->sc_object);
652                         vn->sc_object = NULL;
653                         return(EDOM);
654                 }
655         }
656         vn->sc_flags |= VNF_INITED;
657
658         error = vnsetcred(vn, p->p_ucred);
659         if (error == 0) {
660                 IFOPT(vn, VN_LABELS) {
661                         /*
662                          * Reopen so that `ds' knows which devices are open.
663                          * If this is the first VNIOCSET, then we've
664                          * guaranteed that the device is the cdev and that
665                          * no other slices or labels are open.  Otherwise,
666                          * we rely on VNIOCCLR not being abused.
667                          */
668                         error = vnopen(dev, flag, S_IFCHR, td);
669                 }
670         }
671         if (error == 0) {
672                 IFOPT(vn, VN_FOLLOW) {
673                         printf("vnioctl: SET vp %p size %x\n",
674                                vn->sc_vp, vn->sc_size);
675                 }
676         }
677         if (error)
678                 vnclear(vn);
679         return(error);
680 }
681
682 /*
683  * Duplicate the current processes' credentials.  Since we are called only
684  * as the result of a SET ioctl and only root can do that, any future access
685  * to this "disk" is essentially as root.  Note that credentials may change
686  * if some other uid can write directly to the mapped file (NFS).
687  */
688 int
689 vnsetcred(struct vn_softc *vn, struct ucred *cred)
690 {
691         char *tmpbuf;
692         int error = 0;
693
694         /*
695          * Set credits in our softc
696          */
697
698         if (vn->sc_cred)
699                 crfree(vn->sc_cred);
700         vn->sc_cred = crdup(cred);
701
702         /*
703          * Horrible kludge to establish credentials for NFS  XXX.
704          */
705
706         if (vn->sc_vp) {
707                 struct uio auio;
708                 struct iovec aiov;
709
710                 tmpbuf = malloc(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, NULL, LK_EXCLUSIVE | LK_RETRY, curthread);
722                 error = VOP_READ(vn->sc_vp, &auio, 0, vn->sc_cred);
723                 VOP_UNLOCK(vn->sc_vp, NULL, 0, curthread);
724                 free(tmpbuf, M_TEMP);
725         }
726         return (error);
727 }
728
729 void
730 vnclear(struct vn_softc *vn)
731 {
732         struct thread *td = curthread;          /* XXX */
733
734         IFOPT(vn, VN_FOLLOW)
735                 printf("vnclear(%p): vp=%p\n", vn, vn->sc_vp);
736         if (vn->sc_slices != NULL)
737                 dsgone(&vn->sc_slices);
738         vn->sc_flags &= ~VNF_INITED;
739         if (vn->sc_vp != NULL) {
740                 (void)vn_close(vn->sc_vp, vn->sc_flags & VNF_READONLY ?
741                     FREAD : (FREAD|FWRITE), td);
742                 vn->sc_vp = NULL;
743         }
744         vn->sc_flags &= ~VNF_READONLY;
745         if (vn->sc_cred) {
746                 crfree(vn->sc_cred);
747                 vn->sc_cred = NULL;
748         }
749         if (vn->sc_object != NULL) {
750                 vm_pager_deallocate(vn->sc_object);
751                 vn->sc_object = NULL;
752         }
753         vn->sc_size = 0;
754 }
755
756 static  int
757 vnsize(dev_t dev)
758 {
759         struct vn_softc *vn;
760
761         vn = dev->si_drv1;
762         if (!vn)
763                 return(-1);
764         if ((vn->sc_flags & VNF_INITED) == 0)
765                 return(-1);
766
767         return(vn->sc_size);
768 }
769
770 static int 
771 vn_modevent(module_t mod, int type, void *data)
772 {
773         struct vn_softc *vn;
774         dev_t dev;
775
776         switch (type) {
777         case MOD_LOAD:
778                 cdevsw_add(&vn_cdevsw, 0, 0);
779                 break;
780         case MOD_UNLOAD:
781                 /* fall through */
782         case MOD_SHUTDOWN:
783                 while ((vn = SLIST_FIRST(&vn_list)) != NULL) {
784                         SLIST_REMOVE_HEAD(&vn_list, sc_list);
785                         if (vn->sc_flags & VNF_INITED)
786                                 vnclear(vn);
787                         /* Cleanup all dev_t's that refer to this unit */
788                         while ((dev = vn->sc_devlist) != NULL) {
789                                 vn->sc_devlist = dev->si_drv2;
790                                 dev->si_drv1 = dev->si_drv2 = NULL;
791                                 destroy_dev(dev);
792                         }
793                         free(vn, M_DEVBUF);
794                 }
795                 cdevsw_remove(&vn_cdevsw, 0, 0);
796                 break;
797         default:
798                 break;
799         }
800         return 0;
801 }
802
803 DEV_MODULE(vn, vn_modevent, 0);