![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spec_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / miscfs / specfs|
Return to spec_vnops.c CVS log | Up to [Apple XNU] / XNU / bsd / miscfs / specfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1989, 1993, 1995
25: * The Regents of the University of California. All rights reserved.
26: *
27: * Redistribution and use in source and binary forms, with or without
28: * modification, are permitted provided that the following conditions
29: * are met:
30: * 1. Redistributions of source code must retain the above copyright
31: * notice, this list of conditions and the following disclaimer.
32: * 2. Redistributions in binary form must reproduce the above copyright
33: * notice, this list of conditions and the following disclaimer in the
34: * documentation and/or other materials provided with the distribution.
35: * 3. All advertising materials mentioning features or use of this software
36: * must display the following acknowledgement:
37: * This product includes software developed by the University of
38: * California, Berkeley and its contributors.
39: * 4. Neither the name of the University nor the names of its contributors
40: * may be used to endorse or promote products derived from this software
41: * without specific prior written permission.
42: *
43: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
44: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
47: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53: * SUCH DAMAGE.
54: *
55: * @(#)spec_vnops.c 8.14 (Berkeley) 5/21/95
56: */
57:
58: #include <sys/param.h>
59: #include <sys/proc.h>
60: #include <sys/systm.h>
61: #include <sys/kernel.h>
62: #include <sys/conf.h>
63: #include <sys/buf.h>
64: #include <sys/mount.h>
65: #include <sys/namei.h>
66: #include <sys/vnode.h>
67: #include <sys/stat.h>
68: #include <sys/errno.h>
69: #include <sys/ioctl.h>
70: #include <sys/file.h>
71: #include <sys/malloc.h>
72: #include <bsd/dev/disk.h>
73: #include <miscfs/specfs/specdev.h>
74: #include <vfs/vfs_support.h>
75:
76: extern int doclusterread, doclusterwrite;
77:
78: struct vnode *speclisth[SPECHSZ];
79:
80: /* symbolic sleep message strings for devices */
81: char devopn[] = "devopn";
82: char devio[] = "devio";
83: char devwait[] = "devwait";
84: char devin[] = "devin";
85: char devout[] = "devout";
86: char devioc[] = "devioc";
87: char devcls[] = "devcls";
88:
89: int (**spec_vnodeop_p)();
90: struct vnodeopv_entry_desc spec_vnodeop_entries[] = {
91: { &vop_default_desc, vn_default_error },
92: { &vop_lookup_desc, spec_lookup }, /* lookup */
93: { &vop_create_desc, err_create }, /* create */
94: { &vop_mknod_desc, err_mknod }, /* mknod */
95: { &vop_open_desc, spec_open }, /* open */
96: { &vop_close_desc, spec_close }, /* close */
97: { &vop_access_desc, spec_access }, /* access */
98: { &vop_getattr_desc, spec_getattr }, /* getattr */
99: { &vop_setattr_desc, spec_setattr }, /* setattr */
100: { &vop_read_desc, spec_read }, /* read */
101: { &vop_write_desc, spec_write }, /* write */
102: { &vop_lease_desc, nop_lease }, /* lease */
103: { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
104: { &vop_select_desc, spec_select }, /* select */
105: { &vop_revoke_desc, nop_revoke }, /* revoke */
106: { &vop_mmap_desc, err_mmap }, /* mmap */
107: { &vop_fsync_desc, spec_fsync }, /* fsync */
108: { &vop_seek_desc, err_seek }, /* seek */
109: { &vop_remove_desc, err_remove }, /* remove */
110: { &vop_link_desc, err_link }, /* link */
111: { &vop_rename_desc, err_rename }, /* rename */
112: { &vop_mkdir_desc, err_mkdir }, /* mkdir */
113: { &vop_rmdir_desc, err_rmdir }, /* rmdir */
114: { &vop_symlink_desc, err_symlink }, /* symlink */
115: { &vop_readdir_desc, err_readdir }, /* readdir */
116: { &vop_readlink_desc, err_readlink }, /* readlink */
117: { &vop_abortop_desc, err_abortop }, /* abortop */
118: { &vop_inactive_desc, nop_inactive }, /* inactive */
119: { &vop_reclaim_desc, nop_reclaim }, /* reclaim */
120: { &vop_lock_desc, nop_lock }, /* lock */
121: { &vop_unlock_desc, nop_unlock }, /* unlock */
122: { &vop_bmap_desc, spec_bmap }, /* bmap */
123: { &vop_strategy_desc, spec_strategy }, /* strategy */
124: { &vop_print_desc, spec_print }, /* print */
125: { &vop_islocked_desc, nop_islocked }, /* islocked */
126: { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
127: { &vop_advlock_desc, err_advlock }, /* advlock */
128: { &vop_blkatoff_desc, err_blkatoff }, /* blkatoff */
129: { &vop_valloc_desc, err_valloc }, /* valloc */
130: { &vop_vfree_desc, err_vfree }, /* vfree */
131: { &vop_truncate_desc, nop_truncate }, /* truncate */
132: { &vop_update_desc, nop_update }, /* update */
133: { &vop_bwrite_desc, spec_bwrite }, /* bwrite */
134: { &vop_devblocksize_desc, spec_devblocksize }, /* devblocksize */
135: { &vop_pagein_desc, spec_pagein }, /* Pagein */
136: { &vop_pageout_desc, spec_pageout }, /* Pageout */
137: { &vop_copyfile_desc, err_copyfile }, /* Copyfile */
138: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
139: };
140: struct vnodeopv_desc spec_vnodeop_opv_desc =
141: { &spec_vnodeop_p, spec_vnodeop_entries };
142:
143: /*
144: * Trivial lookup routine that always fails.
145: */
146: int
147: spec_lookup(ap)
148: struct vop_lookup_args /* {
149: struct vnode *a_dvp;
150: struct vnode **a_vpp;
151: struct componentname *a_cnp;
152: } */ *ap;
153: {
154:
155: *ap->a_vpp = NULL;
156: return (ENOTDIR);
157: }
158:
159: void
160: set_blocksize(struct vnode *vp, dev_t dev)
161: {
162: int (*size)();
163: int rsize;
164:
165: if ((major(dev) < nblkdev) && (size = bdevsw[major(dev)].d_psize)) {
166: rsize = (*size)(dev);
167: if (rsize <= 0) /* did size fail? */
168: vp->v_specsize = DEV_BSIZE;
169: else
170: vp->v_specsize = rsize;
171: }
172: else
173: vp->v_specsize = DEV_BSIZE;
174: }
175:
176: void
177: set_fsblocksize(struct vnode *vp)
178: {
179:
180: if (vp->v_type == VBLK) {
181: dev_t dev = (dev_t)vp->v_rdev;
182: int maj = major(dev);
183:
184: if ((u_int)maj >= nblkdev)
185: return;
186:
187: set_blocksize(vp, dev);
188: }
189:
190: }
191:
192:
193: /*
194: * Open a special file.
195: */
196: /* ARGSUSED */
197: spec_open(ap)
198: struct vop_open_args /* {
199: struct vnode *a_vp;
200: int a_mode;
201: struct ucred *a_cred;
202: struct proc *a_p;
203: } */ *ap;
204: {
205: struct proc *p = ap->a_p;
206: struct vnode *bvp, *vp = ap->a_vp;
207: dev_t bdev, dev = (dev_t)vp->v_rdev;
208: int maj = major(dev);
209: int error;
210:
211: /*
212: * Don't allow open if fs is mounted -nodev.
213: */
214: if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV))
215: return (ENXIO);
216:
217: switch (vp->v_type) {
218:
219: case VCHR:
220: if ((u_int)maj >= nchrdev)
221: return (ENXIO);
222: if (ap->a_cred != FSCRED && (ap->a_mode & FWRITE)) {
223: /*
224: * When running in very secure mode, do not allow
225: * opens for writing of any disk character devices.
226: */
227: if (securelevel >= 2 && isdisk(dev, VCHR))
228: return (EPERM);
229: /*
230: * When running in secure mode, do not allow opens
231: * for writing of /dev/mem, /dev/kmem, or character
232: * devices whose corresponding block devices are
233: * currently mounted.
234: */
235: if (securelevel >= 1) {
236: if ((bdev = chrtoblk(dev)) != NODEV &&
237: vfinddev(bdev, VBLK, &bvp) &&
238: bvp->v_usecount > 0 &&
239: (error = vfs_mountedon(bvp)))
240: return (error);
241: if (iskmemdev(dev))
242: return (EPERM);
243: }
244: }
245: if (cdevsw[maj].d_type == D_TTY)
246: vp->v_flag |= VISTTY;
247: VOP_UNLOCK(vp, 0, p);
248: error = (*cdevsw[maj].d_open)(dev, ap->a_mode, S_IFCHR, p);
249: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
250: return (error);
251:
252: case VBLK:
253: if ((u_int)maj >= nblkdev)
254: return (ENXIO);
255: /*
256: * When running in very secure mode, do not allow
257: * opens for writing of any disk block devices.
258: */
259: if (securelevel >= 2 && ap->a_cred != FSCRED &&
260: (ap->a_mode & FWRITE) && bdevsw[maj].d_type == D_DISK)
261: return (EPERM);
262: /*
263: * Do not allow opens of block devices that are
264: * currently mounted.
265: */
266: if (error = vfs_mountedon(vp))
267: return (error);
268:
269: error = (*bdevsw[maj].d_open)(dev, ap->a_mode, S_IFBLK, p);
270: if (!error) {
271: set_blocksize(vp, dev);
272: }
273: return(error);
274: }
275: return (0);
276: }
277:
278: /*
279: * Vnode op for read
280: */
281: /* ARGSUSED */
282: spec_read(ap)
283: struct vop_read_args /* {
284: struct vnode *a_vp;
285: struct uio *a_uio;
286: int a_ioflag;
287: struct ucred *a_cred;
288: } */ *ap;
289: {
290: register struct vnode *vp = ap->a_vp;
291: register struct uio *uio = ap->a_uio;
292: struct proc *p = uio->uio_procp;
293: struct buf *bp;
294: daddr_t bn, nextbn;
295: long bsize, bscale;
296: int devBlockSize=0;
297: int firstpass, seq;
298: int n, on, majordev, (*ioctl)();
299: int error = 0;
300: dev_t dev;
301:
302: #if DIAGNOSTIC
303: if (uio->uio_rw != UIO_READ)
304: panic("spec_read mode");
305: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc())
306: panic("spec_read proc");
307: #endif
308: if (uio->uio_resid == 0)
309: return (0);
310:
311: switch (vp->v_type) {
312:
313: case VCHR:
314: VOP_UNLOCK(vp, 0, p);
315: error = (*cdevsw[major(vp->v_rdev)].d_read)
316: (vp->v_rdev, uio, ap->a_ioflag);
317: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
318: return (error);
319:
320: case VBLK:
321: if (uio->uio_offset < 0)
322: return (EINVAL);
323: bsize = PAGE_SIZE;
324: dev = vp->v_rdev;
325: devBlockSize = vp->v_specsize;
326: bscale = bsize / devBlockSize;
327: firstpass = TRUE;
328:
329: do {
330: on = uio->uio_offset % bsize;
331:
332: if (doclusterread && doclusterwrite) {
333: bn = uio->uio_offset / bsize;
334:
335: error = cluster_read(vp, (u_quad_t)0x7fffffffffffffff, bn, bsize, NOCRED,
336: &bp, devBlockSize, firstpass, uio->uio_resid+on, &seq);
337: } else {
338: bn = (uio->uio_offset / devBlockSize) &~ (bscale - 1);
339:
340: if (vp->v_lastr + bscale == bn) {
341: nextbn = bn + bscale;
342: error = breadn(vp, bn, (int)bsize, &nextbn,
343: (int *)&bsize, 1, NOCRED, &bp);
344: } else
345: error = bread(vp, bn, (int)bsize, NOCRED, &bp);
346: }
347: firstpass = FALSE;
348:
349: vp->v_lastr = bn;
350: n = bsize - bp->b_resid;
351: if ((on > n) || error) {
352: if (!error)
353: error = EINVAL;
354: brelse(bp);
355: return (error);
356: }
357: n = min((unsigned)(n - on), uio->uio_resid);
358:
359: error = uiomove((char *)bp->b_data + on, n, uio);
360: if (n + on == bsize)
361: bp->b_flags |= B_AGE;
362: brelse(bp);
363: } while (error == 0 && uio->uio_resid > 0 && n != 0);
364:
365: return (error);
366:
367: default:
368: panic("spec_read type");
369: }
370: /* NOTREACHED */
371: }
372:
373: /*
374: * Vnode op for write
375: */
376: /* ARGSUSED */
377: spec_write(ap)
378: struct vop_write_args /* {
379: struct vnode *a_vp;
380: struct uio *a_uio;
381: int a_ioflag;
382: struct ucred *a_cred;
383: } */ *ap;
384: {
385: register struct vnode *vp = ap->a_vp;
386: register struct uio *uio = ap->a_uio;
387: struct proc *p = uio->uio_procp;
388: struct buf *bp;
389: daddr_t bn;
390: int bsize, blkmask;
391: register int io_sync;
392: register int io_size;
393: register int forcewrite;
394: int devBlockSize=0;
395: register int n, on;
396: int error = 0;
397: dev_t dev;
398:
399: #if DIAGNOSTIC
400: if (uio->uio_rw != UIO_WRITE)
401: panic("spec_write mode");
402: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc())
403: panic("spec_write proc");
404: #endif
405:
406: switch (vp->v_type) {
407:
408: case VCHR:
409: VOP_UNLOCK(vp, 0, p);
410: error = (*cdevsw[major(vp->v_rdev)].d_write)
411: (vp->v_rdev, uio, ap->a_ioflag);
412: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
413: return (error);
414:
415: case VBLK:
416: if (uio->uio_resid == 0)
417: return (0);
418: if (uio->uio_offset < 0)
419: return (EINVAL);
420:
421: bsize = PAGE_SIZE;
422: io_sync = (ap->a_ioflag & IO_SYNC);
423: io_size = uio->uio_resid;
424: dev = (vp->v_rdev);
425: devBlockSize = vp->v_specsize;
426: blkmask = (bsize / devBlockSize) - 1;
427:
428: do {
429: forcewrite = 0;
430:
431: if (doclusterread && doclusterwrite)
432: bn = uio->uio_offset / bsize;
433: else
434: bn = (uio->uio_offset / devBlockSize) &~ blkmask;
435: on = uio->uio_offset % bsize;
436:
437: n = min((unsigned)(bsize - on), uio->uio_resid);
438:
439: if (doclusterread && doclusterwrite) {
440: bp = getblk(vp, bn, bsize, 0, 0);
441:
442: VOP_BMAP(vp, bn, NULL, &bp->b_blkno, NULL);
443:
444: if (n != bsize && !(bp->b_flags & (B_DONE|B_DELWRI))) {
445: if ((on % devBlockSize) || (n % devBlockSize)) {
446: bp->b_flags |= B_READ;
447: VOP_STRATEGY(bp);
448: error = biowait(bp);
449: } else {
450: if (on) {
451: bp->b_blkno += (on / devBlockSize);
452: on = 0;
453: }
454: forcewrite = 1;
455: bp->b_bcount = n;
456: bp->b_flags |= B_INVAL;
457: }
458: }
459: } else {
460: if (n == bsize)
461: bp = getblk(vp, bn, bsize, 0, 0);
462: else
463: error = bread(vp, bn, bsize, NOCRED, &bp);
464: }
465: if (error) {
466: brelse(bp);
467: return (error);
468: }
469: n = min(n, bsize - bp->b_resid);
470:
471: error = uiomove((char *)bp->b_data + on, n, uio);
472:
473: if (forcewrite) {
474: if (uio->uio_resid == 0)
475: bwrite(bp);
476: else
477: bawrite(bp);
478: } else if (((io_size >= bsize) || ((n + on) == bsize)) && doclusterread && doclusterwrite) {
479: if (io_sync) {
480: if (uio->uio_resid < bsize)
481: bp->b_flags |= (B_CLUST_SYNC | B_CLUST_COMMIT);
482: else
483: bp->b_flags |= B_CLUST_SYNC;
484:
485: error = cluster_write(bp, (u_quad_t)0x7fffffffffffffff, devBlockSize);
486: } else
487: cluster_write(bp, (u_quad_t)0x7fffffffffffffff, devBlockSize);
488: } else {
489: bp->b_flags |= B_AGE;
490:
491: if (io_sync)
492: bwrite(bp);
493: else {
494: if ((n + on) == bsize)
495: bawrite(bp);
496: else
497: bdwrite(bp);
498: }
499: }
500: } while (error == 0 && uio->uio_resid > 0 && n != 0);
501:
502: return (error);
503:
504: default:
505: panic("spec_write type");
506: }
507: /* NOTREACHED */
508: }
509:
510: /*
511: * Device ioctl operation.
512: */
513: /* ARGSUSED */
514: spec_ioctl(ap)
515: struct vop_ioctl_args /* {
516: struct vnode *a_vp;
517: int a_command;
518: caddr_t a_data;
519: int a_fflag;
520: struct ucred *a_cred;
521: struct proc *a_p;
522: } */ *ap;
523: {
524: dev_t dev = ap->a_vp->v_rdev;
525:
526: switch (ap->a_vp->v_type) {
527:
528: case VCHR:
529: return ((*cdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data,
530: ap->a_fflag, ap->a_p));
531:
532: case VBLK:
533: if (ap->a_command == 0 && (int)ap->a_data == B_TAPE)
534: if (bdevsw[major(dev)].d_type == D_TAPE)
535: return (0);
536: else
537: return (1);
538: return ((*bdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data,
539: ap->a_fflag, ap->a_p));
540:
541: default:
542: panic("spec_ioctl");
543: /* NOTREACHED */
544: }
545: }
546:
547: /* ARGSUSED */
548: spec_select(ap)
549: struct vop_select_args /* {
550: struct vnode *a_vp;
551: int a_which;
552: int a_fflags;
553: struct ucred *a_cred;
554: struct proc *a_p;
555: } */ *ap;
556: {
557: register dev_t dev;
558:
559: switch (ap->a_vp->v_type) {
560:
561: default:
562: return (1); /* XXX */
563:
564: case VCHR:
565: dev = ap->a_vp->v_rdev;
566: return (*cdevsw[major(dev)].d_select)(dev, ap->a_which, ap->a_p);
567: }
568: }
569: /*
570: * Synch buffers associated with a block device
571: */
572: /* ARGSUSED */
573: int
574: spec_fsync(ap)
575: struct vop_fsync_args /* {
576: struct vnode *a_vp;
577: struct ucred *a_cred;
578: int a_waitfor;
579: struct proc *a_p;
580: } */ *ap;
581: {
582: register struct vnode *vp = ap->a_vp;
583: register struct buf *bp;
584: struct buf *nbp;
585: int s;
586:
587: if (vp->v_type == VCHR)
588: return (0);
589: /*
590: * Flush all dirty buffers associated with a block device.
591: */
592: loop:
593: s = splbio();
594: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
595: nbp = bp->b_vnbufs.le_next;
596: if ((bp->b_flags & B_BUSY))
597: continue;
598: if ((bp->b_flags & B_DELWRI) == 0)
599: panic("spec_fsync: not dirty");
600: bremfree(bp);
601: bp->b_flags |= B_BUSY;
602: splx(s);
603: bawrite(bp);
604: goto loop;
605: }
606: if (ap->a_waitfor == MNT_WAIT) {
607: while (vp->v_numoutput) {
608: vp->v_flag |= VBWAIT;
609: tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "spec_fsync", 0);
610: }
611: #if DIAGNOSTIC
612: if (vp->v_dirtyblkhd.lh_first) {
613: vprint("spec_fsync: dirty", vp);
614: splx(s);
615: goto loop;
616: }
617: #endif
618: }
619: splx(s);
620: return (0);
621: }
622:
623: /*
624: * Just call the device strategy routine
625: */
626: spec_strategy(ap)
627: struct vop_strategy_args /* {
628: struct buf *a_bp;
629: } */ *ap;
630: {
631: (*bdevsw[major(ap->a_bp->b_dev)].d_strategy)(ap->a_bp);
632: return (0);
633: }
634:
635: /*
636: * This is a noop, simply returning what one has been given.
637: */
638: spec_bmap(ap)
639: struct vop_bmap_args /* {
640: struct vnode *a_vp;
641: daddr_t a_bn;
642: struct vnode **a_vpp;
643: daddr_t *a_bnp;
644: int *a_runp;
645: } */ *ap;
646: {
647:
648: if (ap->a_vpp != NULL)
649: *ap->a_vpp = ap->a_vp;
650: if (ap->a_bnp != NULL)
651: *ap->a_bnp = ap->a_bn * (PAGE_SIZE / ap->a_vp->v_specsize);
652: if (ap->a_runp != NULL)
653: *ap->a_runp = (MAXPHYSIO / PAGE_SIZE) - 1;
654: return (0);
655: }
656:
657: /*
658: * Device close routine
659: */
660: /* ARGSUSED */
661: spec_close(ap)
662: struct vop_close_args /* {
663: struct vnode *a_vp;
664: int a_fflag;
665: struct ucred *a_cred;
666: struct proc *a_p;
667: } */ *ap;
668: {
669: register struct vnode *vp = ap->a_vp;
670: dev_t dev = vp->v_rdev;
671: int (*devclose) __P((dev_t, int, int, struct proc *));
672: int mode, error;
673:
674: switch (vp->v_type) {
675:
676: case VCHR:
677: /*
678: * Hack: a tty device that is a controlling terminal
679: * has a reference from the session structure.
680: * We cannot easily tell that a character device is
681: * a controlling terminal, unless it is the closing
682: * process' controlling terminal. In that case,
683: * if the reference count is 2 (this last descriptor
684: * plus the session), release the reference from the session.
685: */
686: if (vcount(vp) == 2 && ap->a_p &&
687: vp == ap->a_p->p_session->s_ttyvp) {
688: vrele(vp);
689: ap->a_p->p_session->s_ttyvp = NULL;
690: }
691: /*
692: * If the vnode is locked, then we are in the midst
693: * of forcably closing the device, otherwise we only
694: * close on last reference.
695: */
696: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0)
697: return (0);
698: devclose = cdevsw[major(dev)].d_close;
699: mode = S_IFCHR;
700: break;
701:
702: case VBLK:
703: /*
704: * On last close of a block device (that isn't mounted)
705: * we must invalidate any in core blocks, so that
706: * we can, for instance, change floppy disks.
707: */
708: if (error = vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 0, 0))
709: return (error);
710: /*
711: * We do not want to really close the device if it
712: * is still in use unless we are trying to close it
713: * forcibly. Since every use (buffer, vnode, swap, cmap)
714: * holds a reference to the vnode, and because we mark
715: * any other vnodes that alias this device, when the
716: * sum of the reference counts on all the aliased
717: * vnodes descends to one, we are on last close.
718: */
719: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0)
720: return (0);
721: devclose = bdevsw[major(dev)].d_close;
722: mode = S_IFBLK;
723: break;
724:
725: default:
726: panic("spec_close: not special");
727: }
728:
729: return ((*devclose)(dev, ap->a_fflag, mode, ap->a_p));
730: }
731:
732: /*
733: * Print out the contents of a special device vnode.
734: */
735: spec_print(ap)
736: struct vop_print_args /* {
737: struct vnode *a_vp;
738: } */ *ap;
739: {
740:
741: printf("tag VT_NON, dev %d, %d\n", major(ap->a_vp->v_rdev),
742: minor(ap->a_vp->v_rdev));
743: }
744:
745: /*
746: * Return POSIX pathconf information applicable to special devices.
747: */
748: spec_pathconf(ap)
749: struct vop_pathconf_args /* {
750: struct vnode *a_vp;
751: int a_name;
752: int *a_retval;
753: } */ *ap;
754: {
755:
756: switch (ap->a_name) {
757: case _PC_LINK_MAX:
758: *ap->a_retval = LINK_MAX;
759: return (0);
760: case _PC_MAX_CANON:
761: *ap->a_retval = MAX_CANON;
762: return (0);
763: case _PC_MAX_INPUT:
764: *ap->a_retval = MAX_INPUT;
765: return (0);
766: case _PC_PIPE_BUF:
767: *ap->a_retval = PIPE_BUF;
768: return (0);
769: case _PC_CHOWN_RESTRICTED:
770: *ap->a_retval = 1;
771: return (0);
772: case _PC_VDISABLE:
773: *ap->a_retval = _POSIX_VDISABLE;
774: return (0);
775: default:
776: return (EINVAL);
777: }
778: /* NOTREACHED */
779: }
780:
781: int
782: spec_devblocksize(ap)
783: struct vop_devblocksize_args /* {
784: struct vnode *a_vp;
785: int *a_retval;
786: } */ *ap;
787: {
788: *ap->a_retval = (ap->a_vp->v_specsize);
789: return (0);
790: }
791:
792: /*
793: * Special device failed operation
794: */
795: spec_ebadf()
796: {
797:
798: return (EBADF);
799: }
800:
801: /*
802: * Special device bad operation
803: */
804: spec_badop()
805: {
806:
807: panic("spec_badop called");
808: /* NOTREACHED */
809: }
810: /* Pagein */
811: spec_pagein(ap)
812: struct vop_pagein_args /* {
813: struct vnode *a_vp;
814: struct uio *a_uio;
815: int a_ioflag;
816: struct ucred *a_cred;
817: } */ *ap;
818: {
819: /* pass thru to read */
820: return (VOP_READ(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
821: }
822:
823: /* Pageout */
824: spec_pageout(ap)
825: struct vop_pageout_args /* {
826: struct vnode *a_vp;
827: struct uio *a_uio;
828: int a_ioflag;
829: struct ucred *a_cred;
830: } */ *ap;
831: {
832: /* pass thru to write */
833: return (VOP_WRITE(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
834: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.