![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to procfs_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 / procfs|
Return to procfs_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / miscfs / procfs |
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: /* $NetBSD: procfs_vnops.c,v 1.32 1995/02/03 16:18:55 mycroft Exp $ */
26:
27: /*
28: * Copyright (c) 1993 Jan-Simon Pendry
29: * Copyright (c) 1993
30: * The Regents of the University of California. All rights reserved.
31: *
32: * This code is derived from software contributed to Berkeley by
33: * Jan-Simon Pendry.
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: * @(#)procfs_vnops.c 8.8 (Berkeley) 6/15/94
64: */
65:
66: /*
67: * procfs vnode interface
68: */
69:
70: #include <sys/param.h>
71: #include <sys/systm.h>
72: #include <sys/time.h>
73: #include <sys/kernel.h>
74: #include <sys/file.h>
75: #include <sys/proc.h>
76: #include <sys/vnode.h>
77: #include <sys/namei.h>
78: #include <sys/malloc.h>
79: #include <sys/dirent.h>
80: #include <sys/resourcevar.h>
81: #include <sys/ptrace.h>
82: #include <vm/vm.h> /* for PAGE_SIZE */
83: #include <machine/reg.h>
84: #include <miscfs/procfs/procfs.h>
85:
86: /*
87: * Vnode Operations.
88: *
89: */
90:
91: /*
92: * This is a list of the valid names in the
93: * process-specific sub-directories. It is
94: * used in procfs_lookup and procfs_readdir
95: */
96: struct proc_target {
97: u_char pt_type;
98: u_char pt_namlen;
99: char *pt_name;
100: pfstype pt_pfstype;
101: int (*pt_valid) __P((struct proc *p));
102: } proc_targets[] = {
103: #define N(s) sizeof(s)-1, s
104: /* name type validp */
105: { DT_DIR, N("."), Pproc, NULL },
106: { DT_DIR, N(".."), Proot, NULL },
107: { DT_REG, N("file"), Pfile, procfs_validfile },
108: { DT_REG, N("mem"), Pmem, NULL },
109: { DT_REG, N("regs"), Pregs, procfs_validregs },
110: { DT_REG, N("fpregs"), Pfpregs, procfs_validfpregs },
111: { DT_REG, N("ctl"), Pctl, NULL },
112: { DT_REG, N("status"), Pstatus, NULL },
113: { DT_REG, N("note"), Pnote, NULL },
114: { DT_REG, N("notepg"), Pnotepg, NULL },
115: #undef N
116: };
117: static int nproc_targets = sizeof(proc_targets) / sizeof(proc_targets[0]);
118:
119: static pid_t atopid __P((const char *, u_int));
120:
121: /*
122: * set things up for doing i/o on
123: * the pfsnode (vp). (vp) is locked
124: * on entry, and should be left locked
125: * on exit.
126: *
127: * for procfs we don't need to do anything
128: * in particular for i/o. all that is done
129: * is to support exclusive open on process
130: * memory images.
131: */
132: procfs_open(ap)
133: struct vop_open_args /* {
134: struct vnode *a_vp;
135: int a_mode;
136: struct ucred *a_cred;
137: struct proc *a_p;
138: } */ *ap;
139: {
140: struct pfsnode *pfs = VTOPFS(ap->a_vp);
141:
142: switch (pfs->pfs_type) {
143: case Pmem:
144: if (PFIND(pfs->pfs_pid) == 0)
145: return (ENOENT); /* was ESRCH, jsp */
146:
147: if ((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL) ||
148: (pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE))
149: return (EBUSY);
150:
151: if (ap->a_mode & FWRITE)
152: pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL);
153:
154: return (0);
155:
156: default:
157: break;
158: }
159:
160: return (0);
161: }
162:
163: /*
164: * close the pfsnode (vp) after doing i/o.
165: * (vp) is not locked on entry or exit.
166: *
167: * nothing to do for procfs other than undo
168: * any exclusive open flag (see _open above).
169: */
170: procfs_close(ap)
171: struct vop_close_args /* {
172: struct vnode *a_vp;
173: int a_fflag;
174: struct ucred *a_cred;
175: struct proc *a_p;
176: } */ *ap;
177: {
178: struct pfsnode *pfs = VTOPFS(ap->a_vp);
179:
180: switch (pfs->pfs_type) {
181: case Pmem:
182: if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL))
183: pfs->pfs_flags &= ~(FWRITE|O_EXCL);
184: break;
185: }
186:
187: return (0);
188: }
189:
190: /*
191: * do an ioctl operation on pfsnode (vp).
192: * (vp) is not locked on entry or exit.
193: */
194: procfs_ioctl(ap)
195: struct vop_ioctl_args /* {
196: struct vnode *a_vp;
197: u_long a_command;
198: caddr_t a_data;
199: int a_fflag;
200: struct ucred *a_cred;
201: struct proc *a_p;
202: } */ *ap;
203: {
204:
205: return (ENOTTY);
206: }
207:
208: /*
209: * do block mapping for pfsnode (vp).
210: * since we don't use the buffer cache
211: * for procfs this function should never
212: * be called. in any case, it's not clear
213: * what part of the kernel ever makes use
214: * of this function. for sanity, this is the
215: * usual no-op bmap, although returning
216: * (EIO) would be a reasonable alternative.
217: */
218: procfs_bmap(ap)
219: struct vop_bmap_args /* {
220: struct vnode *a_vp;
221: daddr_t a_bn;
222: struct vnode **a_vpp;
223: daddr_t *a_bnp;
224: } */ *ap;
225: {
226:
227: if (ap->a_vpp != NULL)
228: *ap->a_vpp = ap->a_vp;
229: if (ap->a_bnp != NULL)
230: *ap->a_bnp = ap->a_bn;
231: return (0);
232: }
233:
234: /*
235: * _inactive is called when the pfsnode
236: * is vrele'd and the reference count goes
237: * to zero. (vp) will be on the vnode free
238: * list, so to get it back vget() must be
239: * used.
240: *
241: * for procfs, check if the process is still
242: * alive and if it isn't then just throw away
243: * the vnode by calling vgone(). this may
244: * be overkill and a waste of time since the
245: * chances are that the process will still be
246: * there and PFIND is not free.
247: *
248: * (vp) is not locked on entry or exit.
249: */
250: procfs_inactive(ap)
251: struct vop_inactive_args /* {
252: struct vnode *a_vp;
253: } */ *ap;
254: {
255: struct pfsnode *pfs = VTOPFS(ap->a_vp);
256:
257: if (PFIND(pfs->pfs_pid) == 0)
258: vgone(ap->a_vp);
259:
260: return (0);
261: }
262:
263: /*
264: * _reclaim is called when getnewvnode()
265: * wants to make use of an entry on the vnode
266: * free list. at this time the filesystem needs
267: * to free any private data and remove the node
268: * from any private lists.
269: */
270: procfs_reclaim(ap)
271: struct vop_reclaim_args /* {
272: struct vnode *a_vp;
273: } */ *ap;
274: {
275:
276: return (procfs_freevp(ap->a_vp));
277: }
278:
279: /*
280: * Return POSIX pathconf information applicable to special devices.
281: */
282: procfs_pathconf(ap)
283: struct vop_pathconf_args /* {
284: struct vnode *a_vp;
285: int a_name;
286: register_t *a_retval;
287: } */ *ap;
288: {
289:
290: switch (ap->a_name) {
291: case _PC_LINK_MAX:
292: *ap->a_retval = LINK_MAX;
293: return (0);
294: case _PC_MAX_CANON:
295: *ap->a_retval = MAX_CANON;
296: return (0);
297: case _PC_MAX_INPUT:
298: *ap->a_retval = MAX_INPUT;
299: return (0);
300: case _PC_PIPE_BUF:
301: *ap->a_retval = PIPE_BUF;
302: return (0);
303: case _PC_CHOWN_RESTRICTED:
304: *ap->a_retval = 1;
305: return (0);
306: case _PC_VDISABLE:
307: *ap->a_retval = _POSIX_VDISABLE;
308: return (0);
309: default:
310: return (EINVAL);
311: }
312: /* NOTREACHED */
313: }
314:
315: /*
316: * _print is used for debugging.
317: * just print a readable description
318: * of (vp).
319: */
320: procfs_print(ap)
321: struct vop_print_args /* {
322: struct vnode *a_vp;
323: } */ *ap;
324: {
325: struct pfsnode *pfs = VTOPFS(ap->a_vp);
326:
327: printf("tag VT_PROCFS, type %s, pid %d, mode %x, flags %x\n",
328: pfs->pfs_type, pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags);
329: }
330:
331: /*
332: * _abortop is called when operations such as
333: * rename and create fail. this entry is responsible
334: * for undoing any side-effects caused by the lookup.
335: * this will always include freeing the pathname buffer.
336: */
337: procfs_abortop(ap)
338: struct vop_abortop_args /* {
339: struct vnode *a_dvp;
340: struct componentname *a_cnp;
341: } */ *ap;
342: {
343:
344: if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF)
345: FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
346: return (0);
347: }
348:
349: /*
350: * generic entry point for unsupported operations
351: */
352: procfs_badop()
353: {
354:
355: return (EIO);
356: }
357:
358: /*
359: * Invent attributes for pfsnode (vp) and store
360: * them in (vap).
361: * Directories lengths are returned as zero since
362: * any real length would require the genuine size
363: * to be computed, and nothing cares anyway.
364: *
365: * this is relatively minimal for procfs.
366: */
367: procfs_getattr(ap)
368: struct vop_getattr_args /* {
369: struct vnode *a_vp;
370: struct vattr *a_vap;
371: struct ucred *a_cred;
372: struct proc *a_p;
373: } */ *ap;
374: {
375: struct pfsnode *pfs = VTOPFS(ap->a_vp);
376: struct vattr *vap = ap->a_vap;
377: struct proc *procp;
378: int error;
379:
380: /* first check the process still exists */
381: switch (pfs->pfs_type) {
382: case Proot:
383: case Pcurproc:
384: procp = 0;
385: break;
386:
387: default:
388: procp = PFIND(pfs->pfs_pid);
389: if (procp == 0)
390: return (ENOENT);
391: }
392:
393: error = 0;
394:
395: /* start by zeroing out the attributes */
396: VATTR_NULL(vap);
397:
398: /* next do all the common fields */
399: vap->va_type = ap->a_vp->v_type;
400: vap->va_mode = pfs->pfs_mode;
401: vap->va_fileid = pfs->pfs_fileno;
402: vap->va_flags = 0;
403: vap->va_blocksize = PAGE_SIZE;
404: vap->va_bytes = vap->va_size = 0;
405:
406: /*
407: * Make all times be current TOD.
408: * It would be possible to get the process start
409: * time from the p_stat structure, but there's
410: * no "file creation" time stamp anyway, and the
411: * p_stat structure is not addressible if u. gets
412: * swapped out for that process.
413: *
414: * XXX
415: * Note that microtime() returns a timeval, not a timespec.
416: */
417: microtime(&vap->va_ctime);
418: vap->va_atime = vap->va_mtime = vap->va_ctime;
419:
420: /*
421: * If the process has exercised some setuid or setgid
422: * privilege, then rip away read/write permission so
423: * that only root can gain access.
424: */
425: switch (pfs->pfs_type) {
426: case Pmem:
427: case Pregs:
428: case Pfpregs:
429: if (procp->p_flag & P_SUGID)
430: vap->va_mode &= ~((VREAD|VWRITE)|
431: ((VREAD|VWRITE)>>3)|
432: ((VREAD|VWRITE)>>6));
433: case Pctl:
434: case Pstatus:
435: case Pnote:
436: case Pnotepg:
437: vap->va_nlink = 1;
438: vap->va_uid = procp->p_ucred->cr_uid;
439: vap->va_gid = procp->p_ucred->cr_gid;
440: break;
441: }
442:
443: /*
444: * now do the object specific fields
445: *
446: * The size could be set from struct reg, but it's hardly
447: * worth the trouble, and it puts some (potentially) machine
448: * dependent data into this machine-independent code. If it
449: * becomes important then this function should break out into
450: * a per-file stat function in the corresponding .c file.
451: */
452:
453: switch (pfs->pfs_type) {
454: case Proot:
455: /*
456: * Set nlink to 1 to tell fts(3) we don't actually know.
457: */
458: vap->va_nlink = 1;
459: vap->va_uid = 0;
460: vap->va_gid = 0;
461: vap->va_size = vap->va_bytes = DEV_BSIZE;
462: break;
463:
464: case Pcurproc: {
465: char buf[16]; /* should be enough */
466: vap->va_nlink = 1;
467: vap->va_uid = 0;
468: vap->va_gid = 0;
469: vap->va_size = vap->va_bytes =
470: sprintf(buf, "%ld", (long)curproc->p_pid);
471: break;
472: }
473:
474: case Pproc:
475: vap->va_nlink = 2;
476: vap->va_uid = procp->p_ucred->cr_uid;
477: vap->va_gid = procp->p_ucred->cr_gid;
478: vap->va_size = vap->va_bytes = DEV_BSIZE;
479: break;
480:
481: case Pfile:
482: error = EOPNOTSUPP;
483: break;
484:
485: case Pmem:
486: vap->va_bytes = vap->va_size =
487: ctob(procp->p_vmspace->vm_tsize +
488: procp->p_vmspace->vm_dsize +
489: procp->p_vmspace->vm_ssize);
490: break;
491:
492: #if defined(PT_GETREGS) || defined(PT_SETREGS)
493: case Pregs:
494: vap->va_bytes = vap->va_size = sizeof(struct reg);
495: break;
496: #endif
497:
498: #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS)
499: case Pfpregs:
500: vap->va_bytes = vap->va_size = sizeof(struct fpreg);
501: break;
502: #endif
503:
504: case Pctl:
505: case Pstatus:
506: case Pnote:
507: case Pnotepg:
508: break;
509:
510: default:
511: panic("procfs_getattr");
512: }
513:
514: return (error);
515: }
516:
517: procfs_setattr(ap)
518: struct vop_setattr_args /* {
519: struct vnode *a_vp;
520: struct vattr *a_vap;
521: struct ucred *a_cred;
522: struct proc *a_p;
523: } */ *ap;
524: {
525: /*
526: * just fake out attribute setting
527: * it's not good to generate an error
528: * return, otherwise things like creat()
529: * will fail when they try to set the
530: * file length to 0. worse, this means
531: * that echo $note > /proc/$pid/note will fail.
532: */
533:
534: return (0);
535: }
536:
537: /*
538: * implement access checking.
539: *
540: * actually, the check for super-user is slightly
541: * broken since it will allow read access to write-only
542: * objects. this doesn't cause any particular trouble
543: * but does mean that the i/o entry points need to check
544: * that the operation really does make sense.
545: */
546: procfs_access(ap)
547: struct vop_access_args /* {
548: struct vnode *a_vp;
549: int a_mode;
550: struct ucred *a_cred;
551: struct proc *a_p;
552: } */ *ap;
553: {
554: struct vattr va;
555: int error;
556:
557: if (error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p))
558: return (error);
559:
560: return (vaccess(va.va_mode, va.va_uid, va.va_gid, ap->a_mode,
561: ap->a_cred));
562: }
563:
564: /*
565: * lookup. this is incredibly complicated in the
566: * general case, however for most pseudo-filesystems
567: * very little needs to be done.
568: *
569: * unless you want to get a migraine, just make sure your
570: * filesystem doesn't do any locking of its own. otherwise
571: * read and inwardly digest ufs_lookup().
572: */
573: procfs_lookup(ap)
574: struct vop_lookup_args /* {
575: struct vnode * a_dvp;
576: struct vnode ** a_vpp;
577: struct componentname * a_cnp;
578: } */ *ap;
579: {
580: struct componentname *cnp = ap->a_cnp;
581: struct vnode **vpp = ap->a_vpp;
582: struct vnode *dvp = ap->a_dvp;
583: char *pname = cnp->cn_nameptr;
584: struct proc_target *pt;
585: struct vnode *fvp;
586: pid_t pid;
587: struct pfsnode *pfs;
588: struct proc *p;
589: int i;
590:
591: *vpp = NULL;
592:
593: if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
594: return (EROFS);
595:
596: if (cnp->cn_namelen == 1 && *pname == '.') {
597: *vpp = dvp;
598: VREF(dvp);
599: /*VOP_LOCK(dvp);*/
600: return (0);
601: }
602:
603: pfs = VTOPFS(dvp);
604: switch (pfs->pfs_type) {
605: case Proot:
606: if (cnp->cn_flags & ISDOTDOT)
607: return (EIO);
608:
609: if (CNEQ(cnp, "curproc", 7))
610: return (procfs_allocvp(dvp->v_mount, vpp, 0, Pcurproc));
611:
612: pid = atopid(pname, cnp->cn_namelen);
613: if (pid == NO_PID)
614: break;
615:
616: p = PFIND(pid);
617: if (p == 0)
618: break;
619:
620: return (procfs_allocvp(dvp->v_mount, vpp, pid, Pproc));
621:
622: case Pproc:
623: if (cnp->cn_flags & ISDOTDOT)
624: return (procfs_root(dvp->v_mount, vpp));
625:
626: p = PFIND(pfs->pfs_pid);
627: if (p == 0)
628: break;
629:
630: for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) {
631: if (cnp->cn_namelen == pt->pt_namlen &&
632: bcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
633: (pt->pt_valid == NULL || (*pt->pt_valid)(p)))
634: goto found;
635: }
636: break;
637:
638: found:
639: if (pt->pt_pfstype == Pfile) {
640: fvp = procfs_findtextvp(p);
641: /* We already checked that it exists. */
642: VREF(fvp);
643: VOP_LOCK(fvp);
644: *vpp = fvp;
645: return (0);
646: }
647:
648: return (procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
649: pt->pt_pfstype));
650:
651: default:
652: return (ENOTDIR);
653: }
654:
655: return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
656: }
657:
658: int
659: procfs_validfile(p)
660: struct proc *p;
661: {
662:
663: return (procfs_findtextvp(p) != NULLVP);
664: }
665:
666: /*
667: * readdir returns directory entries from pfsnode (vp).
668: *
669: * the strategy here with procfs is to generate a single
670: * directory entry at a time (struct pfsdent) and then
671: * copy that out to userland using uiomove. a more efficent
672: * though more complex implementation, would try to minimize
673: * the number of calls to uiomove(). for procfs, this is
674: * hardly worth the added code complexity.
675: *
676: * this should just be done through read()
677: */
678: procfs_readdir(ap)
679: struct vop_readdir_args /* {
680: struct vnode *a_vp;
681: struct uio *a_uio;
682: struct ucred *a_cred;
683: int *a_eofflag;
684: u_long *a_cookies;
685: int a_ncookies;
686: } */ *ap;
687: {
688: struct uio *uio = ap->a_uio;
689: struct pfsdent d;
690: struct pfsdent *dp = &d;
691: struct pfsnode *pfs;
692: int error;
693: int count;
694: int i;
695:
696: /*
697: * We don't allow exporting procfs mounts, and currently local
698: * requests do not need cookies.
699: */
700: if (ap->a_ncookies)
701: panic("procfs_readdir: not hungry");
702:
703: pfs = VTOPFS(ap->a_vp);
704:
705: if (uio->uio_resid < UIO_MX)
706: return (EINVAL);
707: if (uio->uio_offset & (UIO_MX-1))
708: return (EINVAL);
709: if (uio->uio_offset < 0)
710: return (EINVAL);
711:
712: error = 0;
713: count = 0;
714: i = uio->uio_offset / UIO_MX;
715:
716: switch (pfs->pfs_type) {
717: /*
718: * this is for the process-specific sub-directories.
719: * all that is needed to is copy out all the entries
720: * from the procent[] table (top of this file).
721: */
722: case Pproc: {
723: struct proc *p;
724: struct proc_target *pt;
725:
726: p = PFIND(pfs->pfs_pid);
727: if (p == NULL)
728: break;
729:
730: for (pt = &proc_targets[i];
731: uio->uio_resid >= UIO_MX && i < nproc_targets; pt++, i++) {
732: if (pt->pt_valid && (*pt->pt_valid)(p) == 0)
733: continue;
734:
735: dp->d_reclen = UIO_MX;
736: dp->d_fileno = PROCFS_FILENO(pfs->pfs_pid, pt->pt_pfstype);
737: dp->d_namlen = pt->pt_namlen;
738: bcopy(pt->pt_name, dp->d_name, pt->pt_namlen + 1);
739: dp->d_type = pt->pt_type;
740:
741: if (error = uiomove((caddr_t)dp, UIO_MX, uio))
742: break;
743: }
744:
745: break;
746: }
747:
748: /*
749: * this is for the root of the procfs filesystem
750: * what is needed is a special entry for "curproc"
751: * followed by an entry for each process on allproc
752: #ifdef PROCFS_ZOMBIE
753: * and zombproc.
754: #endif
755: */
756:
757: case Proot: {
758: #ifdef PROCFS_ZOMBIE
759: int doingzomb = 0;
760: #endif
761: int pcnt = 0;
762: volatile struct proc *p = allproc.lh_first;
763:
764: again:
765: for (; p && uio->uio_resid >= UIO_MX; i++, pcnt++) {
766: bzero((char *) dp, UIO_MX);
767: dp->d_reclen = UIO_MX;
768:
769: switch (i) {
770: case 0: /* `.' */
771: case 1: /* `..' */
772: dp->d_fileno = PROCFS_FILENO(0, Proot);
773: dp->d_namlen = i + 1;
774: bcopy("..", dp->d_name, dp->d_namlen);
775: dp->d_name[i + 1] = '\0';
776: dp->d_type = DT_DIR;
777: break;
778:
779: case 2:
780: dp->d_fileno = PROCFS_FILENO(0, Pcurproc);
781: dp->d_namlen = 7;
782: bcopy("curproc", dp->d_name, 8);
783: dp->d_type = DT_LNK;
784: break;
785:
786: default:
787: while (pcnt < i) {
788: pcnt++;
789: p = p->p_list.le_next;
790: if (!p)
791: goto done;
792: }
793: dp->d_fileno = PROCFS_FILENO(p->p_pid, Pproc);
794: dp->d_namlen = sprintf(dp->d_name, "%ld",
795: (long)p->p_pid);
796: dp->d_type = DT_REG;
797: p = p->p_list.le_next;
798: break;
799: }
800:
801: if (error = uiomove((caddr_t)dp, UIO_MX, uio))
802: break;
803: }
804: done:
805:
806: #ifdef PROCFS_ZOMBIE
807: if (p == 0 && doingzomb == 0) {
808: doingzomb = 1;
809: p = zombproc.lh_first;
810: goto again;
811: }
812: #endif
813:
814: break;
815:
816: }
817:
818: default:
819: error = ENOTDIR;
820: break;
821: }
822:
823: uio->uio_offset = i * UIO_MX;
824:
825: return (error);
826: }
827:
828: /*
829: * readlink reads the link of `curproc'
830: */
831: procfs_readlink(ap)
832: struct vop_readlink_args *ap;
833: {
834: struct uio *uio = ap->a_uio;
835: char buf[16]; /* should be enough */
836: int len;
837:
838: if (VTOPFS(ap->a_vp)->pfs_fileno != PROCFS_FILENO(0, Pcurproc))
839: return (EINVAL);
840:
841: len = sprintf(buf, "%ld", (long)curproc->p_pid);
842:
843: return (uiomove((caddr_t)buf, len, ap->a_uio));
844: }
845:
846: /*
847: * convert decimal ascii to pid_t
848: */
849: static pid_t
850: atopid(b, len)
851: const char *b;
852: u_int len;
853: {
854: pid_t p = 0;
855:
856: while (len--) {
857: char c = *b++;
858: if (c < '0' || c > '9')
859: return (NO_PID);
860: p = 10 * p + (c - '0');
861: if (p > PID_MAX)
862: return (NO_PID);
863: }
864:
865: return (p);
866: }
867:
868: /*
869: * procfs vnode operations.
870: */
871: int (**procfs_vnodeop_p)();
872: struct vnodeopv_entry_desc procfs_vnodeop_entries[] = {
873: { &vop_default_desc, vn_default_error },
874: { &vop_lookup_desc, procfs_lookup }, /* lookup */
875: { &vop_create_desc, procfs_create }, /* create */
876: { &vop_mknod_desc, procfs_mknod }, /* mknod */
877: { &vop_open_desc, procfs_open }, /* open */
878: { &vop_close_desc, procfs_close }, /* close */
879: { &vop_access_desc, procfs_access }, /* access */
880: { &vop_getattr_desc, procfs_getattr }, /* getattr */
881: { &vop_setattr_desc, procfs_setattr }, /* setattr */
882: { &vop_read_desc, procfs_read }, /* read */
883: { &vop_write_desc, procfs_write }, /* write */
884: { &vop_ioctl_desc, procfs_ioctl }, /* ioctl */
885: { &vop_select_desc, procfs_select }, /* select */
886: { &vop_mmap_desc, procfs_mmap }, /* mmap */
887: { &vop_fsync_desc, procfs_fsync }, /* fsync */
888: { &vop_seek_desc, procfs_seek }, /* seek */
889: { &vop_remove_desc, procfs_remove }, /* remove */
890: { &vop_link_desc, procfs_link }, /* link */
891: { &vop_rename_desc, procfs_rename }, /* rename */
892: { &vop_mkdir_desc, procfs_mkdir }, /* mkdir */
893: { &vop_rmdir_desc, procfs_rmdir }, /* rmdir */
894: { &vop_symlink_desc, procfs_symlink }, /* symlink */
895: { &vop_readdir_desc, procfs_readdir }, /* readdir */
896: { &vop_readlink_desc, procfs_readlink }, /* readlink */
897: { &vop_abortop_desc, procfs_abortop }, /* abortop */
898: { &vop_inactive_desc, procfs_inactive }, /* inactive */
899: { &vop_reclaim_desc, procfs_reclaim }, /* reclaim */
900: { &vop_lock_desc, procfs_lock }, /* lock */
901: { &vop_unlock_desc, procfs_unlock }, /* unlock */
902: { &vop_bmap_desc, procfs_bmap }, /* bmap */
903: { &vop_strategy_desc, procfs_strategy }, /* strategy */
904: { &vop_print_desc, procfs_print }, /* print */
905: { &vop_islocked_desc, procfs_islocked }, /* islocked */
906: { &vop_pathconf_desc, procfs_pathconf }, /* pathconf */
907: { &vop_advlock_desc, procfs_advlock }, /* advlock */
908: { &vop_blkatoff_desc, procfs_blkatoff }, /* blkatoff */
909: { &vop_valloc_desc, procfs_valloc }, /* valloc */
910: { &vop_vfree_desc, procfs_vfree }, /* vfree */
911: { &vop_truncate_desc, procfs_truncate }, /* truncate */
912: { &vop_update_desc, procfs_update }, /* update */
913: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
914: };
915: struct vnodeopv_desc procfs_vnodeop_opv_desc =
916: { &procfs_vnodeop_p, procfs_vnodeop_entries };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.