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