![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fdesc_vnops.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 / miscfs / fdesc|
Return to fdesc_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / miscfs / fdesc |
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) 1992, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software donated to Berkeley by
31: * Jan-Simon Pendry.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)fdesc_vnops.c 8.17 (Berkeley) 5/22/95
62: *
63: */
64:
65: /*
66: * /dev/fd Filesystem
67: */
68:
69: #include <sys/param.h>
70: #include <sys/systm.h>
71: #include <sys/types.h>
72: #include <sys/time.h>
73: #include <sys/proc.h>
74: #include <sys/kernel.h> /* boottime */
75: #include <sys/resourcevar.h>
76: #include <sys/filedesc.h>
77: #include <sys/vnode.h>
78: #include <sys/malloc.h>
79: #include <sys/file.h>
80: #include <sys/stat.h>
81: #include <sys/mount.h>
82: #include <sys/namei.h>
83: #include <sys/buf.h>
84: #include <sys/dirent.h>
85: #include <miscfs/fdesc/fdesc.h>
86:
87: #define cttyvp(p) ((p)->p_flag & P_CONTROLT ? (p)->p_session->s_ttyvp : NULL)
88:
89: #define FDL_WANT 0x01
90: #define FDL_LOCKED 0x02
91: static int fdcache_lock;
92:
93: dev_t devctty;
94:
95: #if (FD_STDIN != FD_STDOUT-1) || (FD_STDOUT != FD_STDERR-1)
96: FD_STDIN, FD_STDOUT, FD_STDERR must be a sequence n, n+1, n+2
97: #endif
98:
99: #define NFDCACHE 4
100:
101: #define FD_NHASH(ix) \
102: (&fdhashtbl[(ix) & fdhash])
103: LIST_HEAD(fdhashhead, fdescnode) *fdhashtbl;
104: u_long fdhash;
105:
106: /*
107: * Initialise cache headers
108: */
109: fdesc_init(vfsp)
110: struct vfsconf *vfsp;
111: {
112:
113: devctty = makedev(nchrdev, 0);
114: fdhashtbl = hashinit(NFDCACHE, M_CACHE, &fdhash);
115: }
116:
117: int
118: fdesc_allocvp(ftype, ix, mp, vpp)
119: fdntype ftype;
120: int ix;
121: struct mount *mp;
122: struct vnode **vpp;
123: {
124: struct proc *p = current_proc(); /* XXX */
125: struct fdhashhead *fc;
126: struct fdescnode *fd;
127: int error = 0;
128:
129: fc = FD_NHASH(ix);
130: loop:
131: for (fd = fc->lh_first; fd != 0; fd = fd->fd_hash.le_next) {
132: if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) {
133: if (vget(fd->fd_vnode, 0, p))
134: goto loop;
135: *vpp = fd->fd_vnode;
136: return (error);
137: }
138: }
139:
140: /*
141: * otherwise lock the array while we call getnewvnode
142: * since that can block.
143: */
144: if (fdcache_lock & FDL_LOCKED) {
145: fdcache_lock |= FDL_WANT;
146: sleep((caddr_t) &fdcache_lock, PINOD);
147: goto loop;
148: }
149: fdcache_lock |= FDL_LOCKED;
150:
151: error = getnewvnode(VT_FDESC, mp, fdesc_vnodeop_p, vpp);
152: if (error)
153: goto out;
154: MALLOC(fd, void *, sizeof(struct fdescnode), M_TEMP, M_WAITOK);
155: (*vpp)->v_data = fd;
156: fd->fd_vnode = *vpp;
157: fd->fd_type = ftype;
158: fd->fd_fd = -1;
159: fd->fd_link = 0;
160: fd->fd_ix = ix;
161: LIST_INSERT_HEAD(fc, fd, fd_hash);
162:
163: out:;
164: fdcache_lock &= ~FDL_LOCKED;
165:
166: if (fdcache_lock & FDL_WANT) {
167: fdcache_lock &= ~FDL_WANT;
168: wakeup((caddr_t) &fdcache_lock);
169: }
170:
171: return (error);
172: }
173:
174: /*
175: * vp is the current namei directory
176: * ndp is the name to locate in that directory...
177: */
178: int
179: fdesc_lookup(ap)
180: struct vop_lookup_args /* {
181: struct vnode * a_dvp;
182: struct vnode ** a_vpp;
183: struct componentname * a_cnp;
184: } */ *ap;
185: {
186: struct vnode **vpp = ap->a_vpp;
187: struct vnode *dvp = ap->a_dvp;
188: struct componentname *cnp = ap->a_cnp;
189: char *pname = cnp->cn_nameptr;
190: struct proc *p = cnp->cn_proc;
191: int nfiles = p->p_fd->fd_nfiles;
192: unsigned fd;
193: int error;
194: struct vnode *fvp;
195: char *ln;
196:
197: VOP_UNLOCK(dvp, 0, p);
198: if (cnp->cn_namelen == 1 && *pname == '.') {
199: *vpp = dvp;
200: VREF(dvp);
201: vn_lock(dvp, LK_SHARED | LK_RETRY, p);
202: return (0);
203: }
204:
205: switch (VTOFDESC(dvp)->fd_type) {
206: default:
207: case Flink:
208: case Fdesc:
209: case Fctty:
210: error = ENOTDIR;
211: goto bad;
212:
213: case Froot:
214: if (cnp->cn_namelen == 2 && bcmp(pname, "fd", 2) == 0) {
215: error = fdesc_allocvp(Fdevfd, FD_DEVFD, dvp->v_mount, &fvp);
216: if (error)
217: goto bad;
218: *vpp = fvp;
219: fvp->v_type = VDIR;
220: vn_lock(fvp, LK_SHARED | LK_RETRY, p);
221: return (0);
222: }
223:
224: if (cnp->cn_namelen == 3 && bcmp(pname, "tty", 3) == 0) {
225: struct vnode *ttyvp = cttyvp(p);
226: if (ttyvp == NULL) {
227: error = ENXIO;
228: goto bad;
229: }
230: error = fdesc_allocvp(Fctty, FD_CTTY, dvp->v_mount, &fvp);
231: if (error)
232: goto bad;
233: *vpp = fvp;
234: fvp->v_type = VFIFO;
235: vn_lock(fvp, LK_SHARED | LK_RETRY, p);
236: return (0);
237: }
238:
239: ln = 0;
240: switch (cnp->cn_namelen) {
241: case 5:
242: if (bcmp(pname, "stdin", 5) == 0) {
243: ln = "fd/0";
244: fd = FD_STDIN;
245: }
246: break;
247: case 6:
248: if (bcmp(pname, "stdout", 6) == 0) {
249: ln = "fd/1";
250: fd = FD_STDOUT;
251: } else
252: if (bcmp(pname, "stderr", 6) == 0) {
253: ln = "fd/2";
254: fd = FD_STDERR;
255: }
256: break;
257: }
258:
259: if (ln) {
260: error = fdesc_allocvp(Flink, fd, dvp->v_mount, &fvp);
261: if (error)
262: goto bad;
263: VTOFDESC(fvp)->fd_link = ln;
264: *vpp = fvp;
265: fvp->v_type = VLNK;
266: vn_lock(fvp, LK_SHARED | LK_RETRY, p);
267: return (0);
268: } else {
269: error = ENOENT;
270: goto bad;
271: }
272:
273: /* FALL THROUGH */
274:
275: case Fdevfd:
276: if (cnp->cn_namelen == 2 && bcmp(pname, "..", 2) == 0) {
277: if (error = fdesc_root(dvp->v_mount, vpp))
278: goto bad;
279: return (0);
280: }
281:
282: fd = 0;
283: while (*pname >= '0' && *pname <= '9') {
284: fd = 10 * fd + *pname++ - '0';
285: if (fd >= nfiles)
286: break;
287: }
288:
289: if (*pname != '\0') {
290: error = ENOENT;
291: goto bad;
292: }
293:
294: if (fd >= nfiles ||
295: *fdfile(p, fd) == NULL ||
296: (*fdflags(p, fd) & UF_RESERVED)) {
297: error = EBADF;
298: goto bad;
299: }
300:
301: error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp);
302: if (error)
303: goto bad;
304: VTOFDESC(fvp)->fd_fd = fd;
305: vn_lock(fvp, LK_SHARED | LK_RETRY, p);
306: *vpp = fvp;
307: return (0);
308: }
309:
310: bad:;
311: vn_lock(dvp, LK_SHARED | LK_RETRY, p);
312: *vpp = NULL;
313: return (error);
314: }
315:
316: int
317: fdesc_open(ap)
318: struct vop_open_args /* {
319: struct vnode *a_vp;
320: int a_mode;
321: struct ucred *a_cred;
322: struct proc *a_p;
323: } */ *ap;
324: {
325: struct vnode *vp = ap->a_vp;
326: int error = 0;
327:
328: switch (VTOFDESC(vp)->fd_type) {
329: case Fdesc:
330: /*
331: * XXX Kludge: set p->p_dupfd to contain the value of the
332: * the file descriptor being sought for duplication. The error
333: * return ensures that the vnode for this device will be
334: * released by vn_open. Open will detect this special error and
335: * take the actions in dupfdopen. Other callers of vn_open or
336: * VOP_OPEN will simply report the error.
337: */
338: ap->a_p->p_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */
339: error = ENODEV;
340: break;
341:
342: case Fctty:
343: error = cttyopen(devctty, ap->a_mode, 0, ap->a_p);
344: break;
345: }
346:
347: return (error);
348: }
349:
350: static int
351: fdesc_attr(fd, vap, cred, p)
352: int fd;
353: struct vattr *vap;
354: struct ucred *cred;
355: struct proc *p;
356: {
357: struct file *fp;
358: struct stat stb;
359: int error;
360:
361: if (error = fdgetf(p, fd, &fp))
362: return (error);
363: switch (fp->f_type) {
364: case DTYPE_VNODE:
365: error = VOP_GETATTR((struct vnode *) fp->f_data, vap, cred, p);
366: if (error == 0 && vap->va_type == VDIR) {
367: /*
368: * directories can cause loops in the namespace,
369: * so turn off the 'x' bits to avoid trouble.
370: */
371: vap->va_mode &= ~((VEXEC)|(VEXEC>>3)|(VEXEC>>6));
372: }
373: break;
374:
375: case DTYPE_SOCKET:
376: error = soo_stat((struct socket *)fp->f_data, &stb);
377: if (error == 0) {
378: vattr_null(vap);
379: vap->va_type = VSOCK;
380: vap->va_mode = stb.st_mode;
381: vap->va_nlink = stb.st_nlink;
382: vap->va_uid = stb.st_uid;
383: vap->va_gid = stb.st_gid;
384: vap->va_fsid = stb.st_dev;
385: vap->va_fileid = stb.st_ino;
386: vap->va_size = stb.st_size;
387: vap->va_blocksize = stb.st_blksize;
388: vap->va_atime = stb.st_atimespec;
389: vap->va_mtime = stb.st_mtimespec;
390: vap->va_ctime = stb.st_ctimespec;
391: vap->va_gen = stb.st_gen;
392: vap->va_flags = stb.st_flags;
393: vap->va_rdev = stb.st_rdev;
394: vap->va_bytes = stb.st_blocks * stb.st_blksize;
395: }
396: break;
397:
398: default:
399: panic("fdesc attr");
400: break;
401: }
402:
403: return (error);
404: }
405:
406: int
407: fdesc_getattr(ap)
408: struct vop_getattr_args /* {
409: struct vnode *a_vp;
410: struct vattr *a_vap;
411: struct ucred *a_cred;
412: struct proc *a_p;
413: } */ *ap;
414: {
415: struct vnode *vp = ap->a_vp;
416: struct vattr *vap = ap->a_vap;
417: unsigned fd;
418: int error = 0;
419:
420: switch (VTOFDESC(vp)->fd_type) {
421: case Froot:
422: case Fdevfd:
423: case Flink:
424: case Fctty:
425: bzero((caddr_t) vap, sizeof(*vap));
426: vattr_null(vap);
427: vap->va_fileid = VTOFDESC(vp)->fd_ix;
428:
429: switch (VTOFDESC(vp)->fd_type) {
430: case Flink:
431: vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
432: vap->va_type = VLNK;
433: vap->va_nlink = 1;
434: vap->va_size = strlen(VTOFDESC(vp)->fd_link);
435: break;
436:
437: case Fctty:
438: vap->va_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
439: vap->va_type = VFIFO;
440: vap->va_nlink = 1;
441: vap->va_size = 0;
442: break;
443:
444: default:
445: vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
446: vap->va_type = VDIR;
447: vap->va_nlink = 2;
448: vap->va_size = DEV_BSIZE;
449: break;
450: }
451: vap->va_uid = 0;
452: vap->va_gid = 0;
453: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
454: vap->va_blocksize = DEV_BSIZE;
455: vap->va_atime.tv_sec = boottime.tv_sec;
456: vap->va_atime.tv_nsec = 0;
457: vap->va_mtime = vap->va_atime;
458: vap->va_ctime = vap->va_mtime;
459: vap->va_gen = 0;
460: vap->va_flags = 0;
461: vap->va_rdev = 0;
462: vap->va_bytes = 0;
463: break;
464:
465: case Fdesc:
466: fd = VTOFDESC(vp)->fd_fd;
467: error = fdesc_attr(fd, vap, ap->a_cred, ap->a_p);
468: break;
469:
470: default:
471: panic("fdesc_getattr");
472: break;
473: }
474:
475: if (error == 0)
476: vp->v_type = vap->va_type;
477:
478: return (error);
479: }
480:
481: int
482: fdesc_setattr(ap)
483: struct vop_setattr_args /* {
484: struct vnode *a_vp;
485: struct vattr *a_vap;
486: struct ucred *a_cred;
487: struct proc *a_p;
488: } */ *ap;
489: {
490: struct file *fp;
491: unsigned fd;
492: int error;
493:
494: /*
495: * Can't mess with the root vnode
496: */
497: switch (VTOFDESC(ap->a_vp)->fd_type) {
498: case Fdesc:
499: break;
500:
501: case Fctty:
502: return (0);
503:
504: default:
505: return (EACCES);
506: }
507:
508: fd = VTOFDESC(ap->a_vp)->fd_fd;
509: if (error = fdgetf(ap->a_p, fd, &fp))
510: return (error);
511:
512: /*
513: * Can setattr the underlying vnode, but not sockets!
514: */
515: switch (fp->f_type) {
516: case DTYPE_VNODE:
517: error = VOP_SETATTR((struct vnode *) fp->f_data, ap->a_vap, ap->a_cred, ap->a_p);
518: break;
519:
520: case DTYPE_SOCKET:
521: error = 0;
522: break;
523:
524: default:
525: kprintf("fp->f_type = %d\n", fp->f_type);
526: error = EBADF;
527: break;
528: }
529:
530: return (error);
531: }
532:
533: #define UIO_MX 16
534:
535: static struct dirtmp {
536: u_long d_fileno;
537: u_short d_reclen;
538: u_short d_namlen;
539: char d_name[8];
540: } rootent[] = {
541: { FD_DEVFD, UIO_MX, 2, "fd" },
542: { FD_STDIN, UIO_MX, 5, "stdin" },
543: { FD_STDOUT, UIO_MX, 6, "stdout" },
544: { FD_STDERR, UIO_MX, 6, "stderr" },
545: { FD_CTTY, UIO_MX, 3, "tty" },
546: { 0 }
547: };
548:
549: int
550: fdesc_readdir(ap)
551: struct vop_readdir_args /* {
552: struct vnode *a_vp;
553: struct uio *a_uio;
554: struct ucred *a_cred;
555: int *a_eofflag;
556: u_long *a_cookies;
557: int a_ncookies;
558: } */ *ap;
559: {
560: struct uio *uio = ap->a_uio;
561: struct proc *p = uio->uio_procp;
562: int i, error;
563:
564: /*
565: * We don't allow exporting fdesc mounts, and currently local
566: * requests do not need cookies.
567: */
568: if (ap->a_ncookies)
569: panic("fdesc_readdir: not hungry");
570:
571: switch (VTOFDESC(ap->a_vp)->fd_type) {
572: case Fctty:
573: return (0);
574:
575: case Fdesc:
576: return (ENOTDIR);
577:
578: default:
579: break;
580: }
581:
582: if (VTOFDESC(ap->a_vp)->fd_type == Froot) {
583: struct dirent d;
584: struct dirent *dp = &d;
585: struct dirtmp *dt;
586: int fd;
587:
588: i = uio->uio_offset / UIO_MX;
589: error = 0;
590:
591: while (uio->uio_resid > 0) {
592: dt = &rootent[i];
593: if (dt->d_fileno == 0) {
594: /**eofflagp = 1;*/
595: break;
596: }
597: i++;
598:
599: switch (dt->d_fileno) {
600: case FD_CTTY:
601: if (cttyvp(uio->uio_procp) == NULL)
602: continue;
603: break;
604:
605: case FD_STDIN:
606: case FD_STDOUT:
607: case FD_STDERR:
608: fd = dt->d_fileno - FD_STDIN;
609: if (fd >= p->p_fd->fd_nfiles)
610: continue;
611: if (*fdfile(p, fd) == NULL &&
612: !(*fdflags(p, fd) &
613: UF_RESERVED))
614: continue;
615: break;
616: }
617: bzero((caddr_t) dp, UIO_MX);
618: dp->d_fileno = dt->d_fileno;
619: dp->d_namlen = dt->d_namlen;
620: dp->d_type = DT_UNKNOWN;
621: dp->d_reclen = dt->d_reclen;
622: bcopy(dt->d_name, dp->d_name, dp->d_namlen+1);
623: error = uiomove((caddr_t) dp, UIO_MX, uio);
624: if (error)
625: break;
626: }
627: uio->uio_offset = i * UIO_MX;
628: return (error);
629: }
630:
631: i = uio->uio_offset / UIO_MX;
632: error = 0;
633: while (uio->uio_resid > 0) {
634: if (i >= p->p_fd->fd_nfiles)
635: break;
636:
637: if (*fdfile(p, i) != NULL && !(*fdflags(p, i) & UF_RESERVED)) {
638: struct dirent d;
639: struct dirent *dp = &d;
640:
641: bzero((caddr_t) dp, UIO_MX);
642:
643: dp->d_namlen = sprintf(dp->d_name, "%d", i);
644: dp->d_reclen = UIO_MX;
645: dp->d_type = DT_UNKNOWN;
646: dp->d_fileno = i + FD_STDIN;
647: /*
648: * And ship to userland
649: */
650: error = uiomove((caddr_t) dp, UIO_MX, uio);
651: if (error)
652: break;
653: }
654: i++;
655: }
656:
657: uio->uio_offset = i * UIO_MX;
658: return (error);
659: }
660:
661: int
662: fdesc_readlink(ap)
663: struct vop_readlink_args /* {
664: struct vnode *a_vp;
665: struct uio *a_uio;
666: struct ucred *a_cred;
667: } */ *ap;
668: {
669: struct vnode *vp = ap->a_vp;
670: int error;
671:
672: if (vp->v_type != VLNK)
673: return (EPERM);
674:
675: if (VTOFDESC(vp)->fd_type == Flink) {
676: char *ln = VTOFDESC(vp)->fd_link;
677: error = uiomove(ln, strlen(ln), ap->a_uio);
678: } else {
679: error = EOPNOTSUPP;
680: }
681:
682: return (error);
683: }
684:
685: int
686: fdesc_read(ap)
687: struct vop_read_args /* {
688: struct vnode *a_vp;
689: struct uio *a_uio;
690: int a_ioflag;
691: struct ucred *a_cred;
692: } */ *ap;
693: {
694: int error = EOPNOTSUPP;
695:
696: switch (VTOFDESC(ap->a_vp)->fd_type) {
697: case Fctty:
698: error = cttyread(devctty, ap->a_uio, ap->a_ioflag);
699: break;
700:
701: default:
702: error = EOPNOTSUPP;
703: break;
704: }
705:
706: return (error);
707: }
708:
709: int
710: fdesc_write(ap)
711: struct vop_write_args /* {
712: struct vnode *a_vp;
713: struct uio *a_uio;
714: int a_ioflag;
715: struct ucred *a_cred;
716: } */ *ap;
717: {
718: int error = EOPNOTSUPP;
719:
720: switch (VTOFDESC(ap->a_vp)->fd_type) {
721: case Fctty:
722: error = cttywrite(devctty, ap->a_uio, ap->a_ioflag);
723: break;
724:
725: default:
726: error = EOPNOTSUPP;
727: break;
728: }
729:
730: return (error);
731: }
732:
733: int
734: fdesc_ioctl(ap)
735: struct vop_ioctl_args /* {
736: struct vnode *a_vp;
737: int a_command;
738: caddr_t a_data;
739: int a_fflag;
740: struct ucred *a_cred;
741: struct proc *a_p;
742: } */ *ap;
743: {
744: int error = EOPNOTSUPP;
745:
746: switch (VTOFDESC(ap->a_vp)->fd_type) {
747: case Fctty:
748: error = cttyioctl(devctty, ap->a_command, ap->a_data,
749: ap->a_fflag, ap->a_p);
750: break;
751:
752: default:
753: error = EOPNOTSUPP;
754: break;
755: }
756:
757: return (error);
758: }
759:
760: int
761: fdesc_select(ap)
762: struct vop_select_args /* {
763: struct vnode *a_vp;
764: int a_which;
765: int a_fflags;
766: struct ucred *a_cred;
767: struct proc *a_p;
768: } */ *ap;
769: {
770: int error = EOPNOTSUPP;
771:
772: switch (VTOFDESC(ap->a_vp)->fd_type) {
773: case Fctty:
774: error = cttyselect(devctty, ap->a_fflags, ap->a_p);
775: break;
776:
777: default:
778: error = EOPNOTSUPP;
779: break;
780: }
781:
782: return (error);
783: }
784:
785: int
786: fdesc_inactive(ap)
787: struct vop_inactive_args /* {
788: struct vnode *a_vp;
789: struct proc *a_p;
790: } */ *ap;
791: {
792: struct vnode *vp = ap->a_vp;
793:
794: /*
795: * Clear out the v_type field to avoid
796: * nasty things happening in vgone().
797: */
798: VOP_UNLOCK(vp, 0, ap->a_p);
799: vp->v_type = VNON;
800: return (0);
801: }
802:
803: int
804: fdesc_reclaim(ap)
805: struct vop_reclaim_args /* {
806: struct vnode *a_vp;
807: } */ *ap;
808: {
809: struct vnode *vp = ap->a_vp;
810: struct fdescnode *fd = VTOFDESC(vp);
811:
812: LIST_REMOVE(fd, fd_hash);
813: FREE(vp->v_data, M_TEMP);
814: vp->v_data = 0;
815:
816: return (0);
817: }
818:
819: /*
820: * Return POSIX pathconf information applicable to special devices.
821: */
822: fdesc_pathconf(ap)
823: struct vop_pathconf_args /* {
824: struct vnode *a_vp;
825: int a_name;
826: int *a_retval;
827: } */ *ap;
828: {
829:
830: switch (ap->a_name) {
831: case _PC_LINK_MAX:
832: *ap->a_retval = LINK_MAX;
833: return (0);
834: case _PC_MAX_CANON:
835: *ap->a_retval = MAX_CANON;
836: return (0);
837: case _PC_MAX_INPUT:
838: *ap->a_retval = MAX_INPUT;
839: return (0);
840: case _PC_PIPE_BUF:
841: *ap->a_retval = PIPE_BUF;
842: return (0);
843: case _PC_CHOWN_RESTRICTED:
844: *ap->a_retval = 1;
845: return (0);
846: case _PC_VDISABLE:
847: *ap->a_retval = _POSIX_VDISABLE;
848: return (0);
849: default:
850: return (EINVAL);
851: }
852: /* NOTREACHED */
853: }
854:
855: /*
856: * Print out the contents of a /dev/fd vnode.
857: */
858: /* ARGSUSED */
859: int
860: fdesc_print(ap)
861: struct vop_print_args /* {
862: struct vnode *a_vp;
863: } */ *ap;
864: {
865:
866: printf("tag VT_NON, fdesc vnode\n");
867: return (0);
868: }
869:
870: /*void*/
871: int
872: fdesc_vfree(ap)
873: struct vop_vfree_args /* {
874: struct vnode *a_pvp;
875: ino_t a_ino;
876: int a_mode;
877: } */ *ap;
878: {
879:
880: return (0);
881: }
882:
883: /*
884: * /dev/fd "should never get here" operation
885: */
886: int
887: fdesc_badop()
888: {
889:
890: panic("fdesc: bad op");
891: /* NOTREACHED */
892: }
893:
894: /* Pagein */
895: fdesc_pagein(ap)
896: struct vop_pagein_args /* {
897: struct vnode *a_vp;
898: struct uio *a_uio;
899: int a_ioflag;
900: struct ucred *a_cred;
901: } */ *ap;
902: {
903: /* pass thru to read */
904: return (VOP_READ(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
905: }
906:
907: /* Pageout */
908: fdesc_pageout(ap)
909: struct vop_pageout_args /* {
910: struct vnode *a_vp;
911: struct uio *a_uio;
912: int a_ioflag;
913: struct ucred *a_cred;
914: } */ *ap;
915: {
916: /* pass thru to write */
917: return (VOP_WRITE(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
918: }
919:
920: #define fdesc_create ((int (*) __P((struct vop_create_args *)))eopnotsupp)
921: #define fdesc_mknod ((int (*) __P((struct vop_mknod_args *)))eopnotsupp)
922: #define fdesc_close ((int (*) __P((struct vop_close_args *)))nullop)
923: #define fdesc_access ((int (*) __P((struct vop_access_args *)))nullop)
924: #define fdesc_mmap ((int (*) __P((struct vop_mmap_args *)))eopnotsupp)
925: #define fdesc_revoke vop_revoke
926: #define fdesc_fsync ((int (*) __P((struct vop_fsync_args *)))nullop)
927: #define fdesc_seek ((int (*) __P((struct vop_seek_args *)))nullop)
928: #define fdesc_remove ((int (*) __P((struct vop_remove_args *)))eopnotsupp)
929: #define fdesc_link ((int (*) __P((struct vop_link_args *)))eopnotsupp)
930: #define fdesc_rename ((int (*) __P((struct vop_rename_args *)))eopnotsupp)
931: #define fdesc_mkdir ((int (*) __P((struct vop_mkdir_args *)))eopnotsupp)
932: #define fdesc_rmdir ((int (*) __P((struct vop_rmdir_args *)))eopnotsupp)
933: #define fdesc_symlink ((int (*) __P((struct vop_symlink_args *)))eopnotsupp)
934: #define fdesc_abortop ((int (*) __P((struct vop_abortop_args *)))nullop)
935: #define fdesc_lock ((int (*) __P((struct vop_lock_args *)))vop_nolock)
936: #define fdesc_unlock ((int (*) __P((struct vop_unlock_args *)))vop_nounlock)
937: #define fdesc_bmap ((int (*) __P((struct vop_bmap_args *)))fdesc_badop)
938: #define fdesc_strategy ((int (*) __P((struct vop_strategy_args *)))fdesc_badop)
939: #define fdesc_islocked \
940: ((int (*) __P((struct vop_islocked_args *)))vop_noislocked)
941: #define fdesc_advlock ((int (*) __P((struct vop_advlock_args *)))eopnotsupp)
942: #define fdesc_blkatoff \
943: ((int (*) __P((struct vop_blkatoff_args *)))eopnotsupp)
944: #define fdesc_valloc ((int(*) __P(( \
945: struct vnode *pvp, \
946: int mode, \
947: struct ucred *cred, \
948: struct vnode **vpp))) eopnotsupp)
949: #define fdesc_truncate \
950: ((int (*) __P((struct vop_truncate_args *)))eopnotsupp)
951: #define fdesc_update ((int (*) __P((struct vop_update_args *)))eopnotsupp)
952: #define fdesc_bwrite ((int (*) __P((struct vop_bwrite_args *)))eopnotsupp)
953:
954: int (**fdesc_vnodeop_p)();
955: struct vnodeopv_entry_desc fdesc_vnodeop_entries[] = {
956: { &vop_default_desc, vn_default_error },
957: { &vop_lookup_desc, fdesc_lookup }, /* lookup */
958: { &vop_create_desc, fdesc_create }, /* create */
959: { &vop_mknod_desc, fdesc_mknod }, /* mknod */
960: { &vop_open_desc, fdesc_open }, /* open */
961: { &vop_close_desc, fdesc_close }, /* close */
962: { &vop_access_desc, fdesc_access }, /* access */
963: { &vop_getattr_desc, fdesc_getattr }, /* getattr */
964: { &vop_setattr_desc, fdesc_setattr }, /* setattr */
965: { &vop_read_desc, fdesc_read }, /* read */
966: { &vop_write_desc, fdesc_write }, /* write */
967: { &vop_ioctl_desc, fdesc_ioctl }, /* ioctl */
968: { &vop_select_desc, fdesc_select }, /* select */
969: { &vop_revoke_desc, fdesc_revoke }, /* revoke */
970: { &vop_mmap_desc, fdesc_mmap }, /* mmap */
971: { &vop_fsync_desc, fdesc_fsync }, /* fsync */
972: { &vop_seek_desc, fdesc_seek }, /* seek */
973: { &vop_remove_desc, fdesc_remove }, /* remove */
974: { &vop_link_desc, fdesc_link }, /* link */
975: { &vop_rename_desc, fdesc_rename }, /* rename */
976: { &vop_mkdir_desc, fdesc_mkdir }, /* mkdir */
977: { &vop_rmdir_desc, fdesc_rmdir }, /* rmdir */
978: { &vop_symlink_desc, fdesc_symlink }, /* symlink */
979: { &vop_readdir_desc, fdesc_readdir }, /* readdir */
980: { &vop_readlink_desc, fdesc_readlink }, /* readlink */
981: { &vop_abortop_desc, fdesc_abortop }, /* abortop */
982: { &vop_inactive_desc, fdesc_inactive }, /* inactive */
983: { &vop_reclaim_desc, fdesc_reclaim }, /* reclaim */
984: { &vop_lock_desc, fdesc_lock }, /* lock */
985: { &vop_unlock_desc, fdesc_unlock }, /* unlock */
986: { &vop_bmap_desc, fdesc_bmap }, /* bmap */
987: { &vop_strategy_desc, fdesc_strategy }, /* strategy */
988: { &vop_print_desc, fdesc_print }, /* print */
989: { &vop_islocked_desc, fdesc_islocked }, /* islocked */
990: { &vop_pathconf_desc, fdesc_pathconf }, /* pathconf */
991: { &vop_advlock_desc, fdesc_advlock }, /* advlock */
992: { &vop_blkatoff_desc, fdesc_blkatoff }, /* blkatoff */
993: { &vop_valloc_desc, fdesc_valloc }, /* valloc */
994: { &vop_vfree_desc, fdesc_vfree }, /* vfree */
995: { &vop_truncate_desc, fdesc_truncate }, /* truncate */
996: { &vop_update_desc, fdesc_update }, /* update */
997: { &vop_bwrite_desc, fdesc_bwrite }, /* bwrite */
998: { &vop_bwrite_desc, fdesc_pagein }, /* pagein */
999: { &vop_bwrite_desc, fdesc_pageout }, /* pageout */
1000: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
1001: };
1002: struct vnodeopv_desc fdesc_vnodeop_opv_desc =
1003: { &fdesc_vnodeop_p, fdesc_vnodeop_entries };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.