![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vnd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev|
Return to vnd.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1988 University of Utah.
28: * Copyright (c) 1990, 1993
29: * The Regents of the University of California. All rights reserved.
30: *
31: * This code is derived from software contributed to Berkeley by
32: * the Systems Programming Group of the University of Utah Computer
33: * Science Department.
34: *
35: * Redistribution and use in source and binary forms, with or without
36: * modification, are permitted provided that the following conditions
37: * are met:
38: * 1. Redistributions of source code must retain the above copyright
39: * notice, this list of conditions and the following disclaimer.
40: * 2. Redistributions in binary form must reproduce the above copyright
41: * notice, this list of conditions and the following disclaimer in the
42: * documentation and/or other materials provided with the distribution.
43: * 3. All advertising materials mentioning features or use of this software
44: * must display the following acknowledgement:
45: * This product includes software developed by the University of
46: * California, Berkeley and its contributors.
47: * 4. Neither the name of the University nor the names of its contributors
48: * may be used to endorse or promote products derived from this software
49: * without specific prior written permission.
50: *
51: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
52: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
55: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
56: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
57: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
59: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
60: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61: * SUCH DAMAGE.
62: *
63: * from: Utah $Hdr: vn.c 1.13 94/04/02$
64: *
65: * @(#)vn.c 8.9 (Berkeley) 5/14/95
66: */
67:
68: /*
69: * Vnode disk driver.
70: *
71: * Block/character interface to a vnode. Allows one to treat a file
72: * as a disk (e.g. build a filesystem in it, mount it, etc.).
73: *
74: * NOTE 1: This uses the VOP_BMAP/VOP_STRATEGY interface to the vnode
75: * instead of a simple VOP_RDWR. We do this to avoid distorting the
76: * local buffer cache.
77: *
78: * NOTE 2: There is a security issue involved with this driver.
79: * Once mounted all access to the contents of the "mapped" file via
80: * the special file is controlled by the permissions on the special
81: * file, the protection of the mapped file is ignored (effectively,
82: * by using root credentials in all transactions).
83: *
84: * NOTE 3: Doesn't interact with leases, should it?
85: */
86: #include "vnd.h"
87: #if NVND > 0
88:
89: #include <sys/param.h>
90: #include <sys/systm.h>
91: #include <sys/namei.h>
92: #include <sys/proc.h>
93: #include <sys/errno.h>
94: #include <sys/dkstat.h>
95: #include <sys/buf.h>
96: #include <sys/malloc.h>
97: #include <sys/ioctl.h>
98: #include <sys/disklabel.h>
99: #include <sys/mount.h>
100: #include <sys/vnode.h>
101: #include <sys/file.h>
102: #include <sys/uio.h>
103:
104: #include <miscfs/specfs/specdev.h>
105:
106: #include <dev/vndioctl.h>
107:
108: #ifdef DEBUG
109: int dovndcluster = 1;
110: int vnddebug = 0x00;
111: #define VDB_FOLLOW 0x01
112: #define VDB_INIT 0x02
113: #define VDB_IO 0x04
114: #endif
115:
116: #define b_cylin b_resid
117:
118: #define vndunit(x) DISKUNIT(x)
119:
120: struct vndbuf {
121: struct buf vb_buf;
122: struct buf *vb_obp;
123: };
124:
125: //#define getvndbuf() \
126: // ((struct vndbuf *)malloc(sizeof(struct vndbuf), M_DEVBUF, M_WAITOK))
127: #define putvndbuf(vbp) \
128: free((caddr_t)(vbp), M_DEVBUF)
129:
130: struct vnd_softc {
131: int sc_flags; /* flags */
132: size_t sc_size; /* size of vnd */
133: struct vnode *sc_vp; /* vnode */
134: struct ucred *sc_cred; /* credentials */
135: int sc_maxactive; /* max # of active requests */
136: struct buf sc_tab; /* transfer queue */
137: };
138:
139: /* sc_flags */
140: #define VNF_ALIVE 0x01
141: #define VNF_INITED 0x02
142:
143: #if 0 /* if you need static allocation */
144: struct vnd_softc vn_softc[NVND];
145: int numvnd = NVND;
146: #else
147: struct vnd_softc *vnd_softc;
148: int numvnd;
149: #endif
150:
151: void vndclear __P((struct vnd_softc *));
152: void vndstart __P((struct vnd_softc *));
153: int vndsetcred __P((struct vnd_softc *, struct ucred *));
154: void vndthrottle __P((struct vnd_softc *, struct vnode *));
155:
156: void
157: vndattach(num)
158: int num;
159: {
160: char *mem;
161: register u_long size;
162:
163: if (num <= 0)
164: return;
165: size = num * sizeof(struct vnd_softc);
166: // mem = malloc(size, M_DEVBUF, M_NOWAIT);
167: MALLOC(mem, char *, size, M_DEVBUF, M_NOWAIT);
168: if (mem == NULL) {
169: printf("WARNING: no memory for vnode disks\n");
170: return;
171: }
172: bzero(mem, size);
173: vnd_softc = (struct vnd_softc *)mem;
174: numvnd = num;
175: }
176:
177: int
178: vndopen(dev, flags, mode, p)
179: dev_t dev;
180: int flags, mode;
181: struct proc *p;
182: {
183: int unit = vndunit(dev);
184:
185: #ifdef DEBUG
186: if (vnddebug & VDB_FOLLOW)
187: printf("vndopen(%x, %x, %x, %x)\n", dev, flags, mode, p);
188: #endif
189: if (unit >= numvnd)
190: return(ENXIO);
191: return(0);
192: }
193:
194: int
195: vndclose(dev, flags, mode, p)
196: dev_t dev;
197: int flags, mode;
198: struct proc *p;
199: {
200: #ifdef DEBUG
201: if (vnddebug & VDB_FOLLOW)
202: printf("vndclose(%x, %x, %x, %x)\n", dev, flags, mode, p);
203: #endif
204: return 0;
205: }
206:
207: /*
208: * Break the request into bsize pieces and submit using VOP_BMAP/VOP_STRATEGY.
209: * Note that this driver can only be used for swapping over NFS on the hp
210: * since nfs_strategy on the vax cannot handle u-areas and page tables.
211: */
212: void
213: vndstrategy(bp)
214: register struct buf *bp;
215: {
216: int unit = vndunit(bp->b_dev);
217: register struct vnd_softc *vnd = &vnd_softc[unit];
218: register struct vndbuf *nbp;
219: register int bn, bsize, resid;
220: register caddr_t addr;
221: int sz, flags, error;
222: extern void vndiodone();
223:
224: #ifdef DEBUG
225: if (vnddebug & VDB_FOLLOW)
226: printf("vndstrategy(%x): unit %d\n", bp, unit);
227: #endif
228: if ((vnd->sc_flags & VNF_INITED) == 0) {
229: bp->b_error = ENXIO;
230: bp->b_flags |= B_ERROR;
231: biodone(bp);
232: return;
233: }
234: bn = bp->b_blkno;
235: sz = howmany(bp->b_bcount, DEV_BSIZE);
236: bp->b_resid = bp->b_bcount;
237: if (bn < 0 || bn + sz > vnd->sc_size) {
238: if (bn != vnd->sc_size) {
239: bp->b_error = EINVAL;
240: bp->b_flags |= B_ERROR;
241: }
242: biodone(bp);
243: return;
244: }
245: bn = dbtob(bn);
246: bsize = vnd->sc_vp->v_mount->mnt_stat.f_iosize;
247: addr = bp->b_data;
248: flags = bp->b_flags | B_CALL;
249: for (resid = bp->b_resid; resid; resid -= sz) {
250: struct vnode *vp;
251: daddr_t nbn;
252: int off, s, nra;
253:
254: nra = 0;
255: error = VOP_BMAP(vnd->sc_vp, bn / bsize, &vp, &nbn, &nra);
256: if (error == 0 && (long)nbn == -1)
257: error = EIO;
258: #ifdef DEBUG
259: if (!dovndcluster)
260: nra = 0;
261: #endif
262:
263: if (off = bn % bsize)
264: sz = bsize - off;
265: else
266: sz = (1 + nra) * bsize;
267: if (resid < sz)
268: sz = resid;
269: #ifdef DEBUG
270: if (vnddebug & VDB_IO)
271: printf("vndstrategy: vp %x/%x bn %x/%x sz %x\n",
272: vnd->sc_vp, vp, bn, nbn, sz);
273: #endif
274:
275: // nbp = getvndbuf();
276: MALLOC(nbp, struct vndbuf *, sizeof(struct vndbuf),M_DEVBUF, M_WAITOK);
277: nbp->vb_buf.b_flags = flags;
278: nbp->vb_buf.b_bcount = sz;
279: nbp->vb_buf.b_bufsize = bp->b_bufsize;
280: nbp->vb_buf.b_error = 0;
281: if (vp->v_type == VBLK || vp->v_type == VCHR)
282: nbp->vb_buf.b_dev = vp->v_rdev;
283: else
284: nbp->vb_buf.b_dev = NODEV;
285: nbp->vb_buf.b_data = addr;
286: nbp->vb_buf.b_blkno = nbn + btodb(off);
287: nbp->vb_buf.b_proc = bp->b_proc;
288: nbp->vb_buf.b_iodone = vndiodone;
289: nbp->vb_buf.b_vp = vp;
290: nbp->vb_buf.b_rcred = vnd->sc_cred; /* XXX crdup? */
291: nbp->vb_buf.b_wcred = vnd->sc_cred; /* XXX crdup? */
292: nbp->vb_buf.b_dirtyoff = bp->b_dirtyoff;
293: nbp->vb_buf.b_dirtyend = bp->b_dirtyend;
294: nbp->vb_buf.b_validoff = bp->b_validoff;
295: nbp->vb_buf.b_validend = bp->b_validend;
296:
297: /* save a reference to the old buffer */
298: nbp->vb_obp = bp;
299:
300: /*
301: * If there was an error or a hole in the file...punt.
302: * Note that we deal with this after the nbp allocation.
303: * This ensures that we properly clean up any operations
304: * that we have already fired off.
305: *
306: * XXX we could deal with holes here but it would be
307: * a hassle (in the write case).
308: */
309: if (error) {
310: nbp->vb_buf.b_error = error;
311: nbp->vb_buf.b_flags |= B_ERROR;
312: bp->b_resid -= (resid - sz);
313: biodone(&nbp->vb_buf);
314: return;
315: }
316: /*
317: * Just sort by block number
318: */
319: nbp->vb_buf.b_cylin = nbp->vb_buf.b_blkno;
320: s = splbio();
321: disksort(&vnd->sc_tab, &nbp->vb_buf);
322: if (vnd->sc_tab.b_active < vnd->sc_maxactive) {
323: vnd->sc_tab.b_active++;
324: vndstart(vnd);
325: }
326: splx(s);
327: bn += sz;
328: addr += sz;
329: }
330: }
331:
332: /*
333: * Feed requests sequentially.
334: * We do it this way to keep from flooding NFS servers if we are connected
335: * to an NFS file. This places the burden on the client rather than the
336: * server.
337: */
338: void
339: vndstart(vnd)
340: register struct vnd_softc *vnd;
341: {
342: register struct buf *bp;
343:
344: /*
345: * Dequeue now since lower level strategy routine might
346: * queue using same links
347: */
348: bp = vnd->sc_tab.b_actf;
349: vnd->sc_tab.b_actf = bp->b_actf;
350: #ifdef DEBUG
351: if (vnddebug & VDB_IO)
352: printf("vndstart(%d): bp %x vp %x blkno %x addr %x cnt %x\n",
353: vnd-vnd_softc, bp, bp->b_vp, bp->b_blkno, bp->b_data,
354: bp->b_bcount);
355: #endif
356: if ((bp->b_flags & B_READ) == 0)
357: bp->b_vp->v_numoutput++;
358: VOP_STRATEGY(bp);
359: }
360:
361: void
362: vndiodone(vbp)
363: register struct vndbuf *vbp;
364: {
365: register struct buf *pbp = vbp->vb_obp;
366: register struct vnd_softc *vnd = &vnd_softc[vndunit(pbp->b_dev)];
367: int s;
368:
369: s = splbio();
370: #ifdef DEBUG
371: if (vnddebug & VDB_IO)
372: printf("vndiodone(%d): vbp %x vp %x blkno %x addr %x cnt %x\n",
373: vnd-vnd_softc, vbp, vbp->vb_buf.b_vp, vbp->vb_buf.b_blkno,
374: vbp->vb_buf.b_data, vbp->vb_buf.b_bcount);
375: #endif
376: if (vbp->vb_buf.b_error) {
377: #ifdef DEBUG
378: if (vnddebug & VDB_IO)
379: printf("vndiodone: vbp %x error %d\n", vbp,
380: vbp->vb_buf.b_error);
381: #endif
382: pbp->b_flags |= B_ERROR;
383: pbp->b_error = biowait(&vbp->vb_buf);
384: }
385: pbp->b_resid -= vbp->vb_buf.b_bcount;
386: putvndbuf(vbp);
387: if (pbp->b_resid == 0) {
388: #ifdef DEBUG
389: if (vnddebug & VDB_IO)
390: printf("vndiodone: pbp %x iodone\n", pbp);
391: #endif
392: biodone(pbp);
393: }
394: if (vnd->sc_tab.b_actf)
395: vndstart(vnd);
396: else
397: vnd->sc_tab.b_active--;
398: splx(s);
399: }
400:
401: /* ARGSUSED */
402: int
403: vndioctl(dev, cmd, data, flag, p)
404: dev_t dev;
405: u_long cmd;
406: caddr_t data;
407: int flag;
408: struct proc *p;
409: {
410: int unit = vndunit(dev);
411: register struct vnd_softc *vnd;
412: struct vnd_ioctl *vio;
413: struct vattr vattr;
414: struct nameidata nd;
415: int error;
416:
417: #ifdef DEBUG
418: if (vnddebug & VDB_FOLLOW)
419: printf("vndioctl(%x, %lx, %x, %x, %x): unit %d\n",
420: dev, cmd, data, flag, p, unit);
421: #endif
422: error = suser(p->p_ucred, &p->p_acflag);
423: if (error)
424: return (error);
425: if (unit >= numvnd)
426: return (ENXIO);
427:
428: vnd = &vnd_softc[unit];
429: vio = (struct vnd_ioctl *)data;
430: switch (cmd) {
431:
432: case VNDIOCSET:
433: if (vnd->sc_flags & VNF_INITED)
434: return(EBUSY);
435: /*
436: * Always open for read and write.
437: * This is probably bogus, but it lets vn_open()
438: * weed out directories, sockets, etc. so we don't
439: * have to worry about them.
440: */
441: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, vio->vnd_file, p);
442: if (error = vn_open(&nd, FREAD|FWRITE, 0))
443: return(error);
444: if (error = VOP_GETATTR(nd.ni_vp, &vattr, p->p_ucred, p)) {
445: VOP_UNLOCK(nd.ni_vp);
446: (void) vn_close(nd.ni_vp, FREAD|FWRITE, p->p_ucred, p);
447: return(error);
448: }
449: VOP_UNLOCK(nd.ni_vp);
450: vnd->sc_vp = nd.ni_vp;
451: vnd->sc_size = btodb(vattr.va_size); /* note truncation */
452: if (error = vndsetcred(vnd, p->p_ucred)) {
453: (void) vn_close(nd.ni_vp, FREAD|FWRITE, p->p_ucred, p);
454: return(error);
455: }
456: vndthrottle(vnd, vnd->sc_vp);
457: vio->vnd_size = dbtob(vnd->sc_size);
458: vnd->sc_flags |= VNF_INITED;
459: #ifdef DEBUG
460: if (vnddebug & VDB_INIT)
461: printf("vndioctl: SET vp %x size %x\n",
462: vnd->sc_vp, vnd->sc_size);
463: #endif
464: break;
465:
466: case VNDIOCCLR:
467: if ((vnd->sc_flags & VNF_INITED) == 0)
468: return(ENXIO);
469: vndclear(vnd);
470: #ifdef DEBUG
471: if (vnddebug & VDB_INIT)
472: printf("vndioctl: CLRed\n");
473: #endif
474: break;
475:
476: default:
477: return(ENOTTY);
478: }
479: return(0);
480: }
481:
482: /*
483: * Duplicate the current processes' credentials. Since we are called only
484: * as the result of a SET ioctl and only root can do that, any future access
485: * to this "disk" is essentially as root. Note that credentials may change
486: * if some other uid can write directly to the mapped file (NFS).
487: */
488: int
489: vndsetcred(vnd, cred)
490: register struct vnd_softc *vnd;
491: struct ucred *cred;
492: {
493: struct uio auio;
494: struct iovec aiov;
495: char *tmpbuf;
496: int error;
497:
498: vnd->sc_cred = crdup(cred);
499: // tmpbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);
500: MALLOC(tmpbuf, char *, DEV_BSIZE, M_TEMP, M_WAITOK);
501:
502: /* XXX: Horrible kludge to establish credentials for NFS */
503: aiov.iov_base = tmpbuf;
504: aiov.iov_len = min(DEV_BSIZE, dbtob(vnd->sc_size));
505: auio.uio_iov = &aiov;
506: auio.uio_iovcnt = 1;
507: auio.uio_offset = 0;
508: auio.uio_rw = UIO_READ;
509: auio.uio_segflg = UIO_SYSSPACE;
510: auio.uio_resid = aiov.iov_len;
511: error = VOP_READ(vnd->sc_vp, &auio, 0, vnd->sc_cred);
512:
513: free(tmpbuf, M_TEMP);
514: return (error);
515: }
516:
517: /*
518: * Set maxactive based on FS type
519: */
520: void
521: vndthrottle(vnd, vp)
522: register struct vnd_softc *vnd;
523: struct vnode *vp;
524: {
525: #ifdef NFSCLIENT
526: extern int (**nfsv2_vnodeop_p)();
527:
528: if (vp->v_op == nfsv2_vnodeop_p)
529: vnd->sc_maxactive = 2;
530: else
531: #endif
532: vnd->sc_maxactive = 8;
533:
534: if (vnd->sc_maxactive < 1)
535: vnd->sc_maxactive = 1;
536: }
537:
538: void
539: vndshutdown()
540: {
541: register struct vnd_softc *vnd;
542:
543: for (vnd = &vnd_softc[0]; vnd < &vnd_softc[numvnd]; vnd++)
544: if (vnd->sc_flags & VNF_INITED)
545: vndclear(vnd);
546: }
547:
548: void
549: vndclear(vnd)
550: register struct vnd_softc *vnd;
551: {
552: register struct vnode *vp = vnd->sc_vp;
553: struct proc *p = curproc; /* XXX */
554: struct ucred *cred;
555:
556: #ifdef DEBUG
557: if (vnddebug & VDB_FOLLOW)
558: printf("vndclear(%x): vp %x\n", vp);
559: #endif
560: vnd->sc_flags &= ~VNF_INITED;
561: if (vp == (struct vnode *)0)
562: panic("vndioctl: null vp");
563: (void) vn_close(vp, FREAD|FWRITE, vnd->sc_cred, p);
564: cred = vnd->sc_cred;
565: if (cred != NOCRED) {
566: vnd->sc_cred = NOCRED;
567: crfree(cred);
568: }
569: vnd->sc_vp = (struct vnode *)0;
570: vnd->sc_size = 0;
571: }
572:
573: int
574: vndsize(dev)
575: dev_t dev;
576: {
577: int unit = vndunit(dev);
578: register struct vnd_softc *vnd = &vnd_softc[unit];
579:
580: if (unit >= numvnd || (vnd->sc_flags & VNF_INITED) == 0)
581: return(-1);
582: return(vnd->sc_size);
583: }
584:
585: int
586: vnddump(dev)
587: dev_t dev;
588: {
589:
590: return(ENXIO);
591: }
592: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.