xref: /netbsd-src/sys/miscfs/procfs/procfs_vnops.c (revision f3cfa6f6ce31685c6c4a758bc430e69eb99f50a4)
1 /*	$NetBSD: procfs_vnops.c,v 1.206 2019/03/30 23:28:30 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Andrew Doran.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /*
33  * Copyright (c) 1993, 1995
34  *	The Regents of the University of California.  All rights reserved.
35  *
36  * This code is derived from software contributed to Berkeley by
37  * Jan-Simon Pendry.
38  *
39  * Redistribution and use in source and binary forms, with or without
40  * modification, are permitted provided that the following conditions
41  * are met:
42  * 1. Redistributions of source code must retain the above copyright
43  *    notice, this list of conditions and the following disclaimer.
44  * 2. Redistributions in binary form must reproduce the above copyright
45  *    notice, this list of conditions and the following disclaimer in the
46  *    documentation and/or other materials provided with the distribution.
47  * 3. 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.18 (Berkeley) 5/21/95
64  */
65 
66 /*
67  * Copyright (c) 1993 Jan-Simon Pendry
68  *
69  * This code is derived from software contributed to Berkeley by
70  * Jan-Simon Pendry.
71  *
72  * Redistribution and use in source and binary forms, with or without
73  * modification, are permitted provided that the following conditions
74  * are met:
75  * 1. Redistributions of source code must retain the above copyright
76  *    notice, this list of conditions and the following disclaimer.
77  * 2. Redistributions in binary form must reproduce the above copyright
78  *    notice, this list of conditions and the following disclaimer in the
79  *    documentation and/or other materials provided with the distribution.
80  * 3. All advertising materials mentioning features or use of this software
81  *    must display the following acknowledgement:
82  *	This product includes software developed by the University of
83  *	California, Berkeley and its contributors.
84  * 4. Neither the name of the University nor the names of its contributors
85  *    may be used to endorse or promote products derived from this software
86  *    without specific prior written permission.
87  *
88  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
89  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
90  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
91  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
92  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
93  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
94  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
95  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
96  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
97  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
98  * SUCH DAMAGE.
99  *
100  *	@(#)procfs_vnops.c	8.18 (Berkeley) 5/21/95
101  */
102 
103 /*
104  * procfs vnode interface
105  */
106 
107 #include <sys/cdefs.h>
108 __KERNEL_RCSID(0, "$NetBSD: procfs_vnops.c,v 1.206 2019/03/30 23:28:30 christos Exp $");
109 
110 #include <sys/param.h>
111 #include <sys/systm.h>
112 #include <sys/time.h>
113 #include <sys/kernel.h>
114 #include <sys/file.h>
115 #include <sys/filedesc.h>
116 #include <sys/proc.h>
117 #include <sys/vnode.h>
118 #include <sys/namei.h>
119 #include <sys/malloc.h>
120 #include <sys/mount.h>
121 #include <sys/dirent.h>
122 #include <sys/resourcevar.h>
123 #include <sys/stat.h>
124 #include <sys/ptrace.h>
125 #include <sys/kauth.h>
126 #include <sys/exec.h>
127 
128 #include <uvm/uvm_extern.h>	/* for PAGE_SIZE */
129 
130 #include <machine/reg.h>
131 
132 #include <miscfs/genfs/genfs.h>
133 #include <miscfs/procfs/procfs.h>
134 
135 /*
136  * Vnode Operations.
137  *
138  */
139 
140 static int procfs_validfile_linux(struct lwp *, struct mount *);
141 static int procfs_root_readdir_callback(struct proc *, void *);
142 static void procfs_dir(pfstype, struct lwp *, struct proc *, char **, char *,
143     size_t);
144 
145 /*
146  * This is a list of the valid names in the
147  * process-specific sub-directories.  It is
148  * used in procfs_lookup and procfs_readdir
149  */
150 static const struct proc_target {
151 	u_char	pt_type;
152 	u_char	pt_namlen;
153 	const char	*pt_name;
154 	pfstype	pt_pfstype;
155 	int	(*pt_valid)(struct lwp *, struct mount *);
156 } proc_targets[] = {
157 #define N(s) sizeof(s)-1, s
158 	/*	  name		type		validp */
159 	{ DT_DIR, N("."),	PFSproc,	NULL },
160 	{ DT_DIR, N(".."),	PFSroot,	NULL },
161 	{ DT_DIR, N("fd"),	PFSfd,		NULL },
162 	{ DT_DIR, N("task"),	PFStask,	procfs_validfile_linux },
163 	{ DT_LNK, N("cwd"),	PFScwd,		NULL },
164 	{ DT_LNK, N("emul"),	PFSemul,	NULL },
165 	{ DT_LNK, N("root"),	PFSchroot,	NULL },
166 	{ DT_REG, N("auxv"),	PFSauxv,	procfs_validauxv },
167 	{ DT_REG, N("cmdline"), PFScmdline,	NULL },
168 	{ DT_REG, N("environ"), PFSenviron,	NULL },
169 	{ DT_REG, N("exe"),	PFSexe,		procfs_validfile },
170 	{ DT_REG, N("file"),	PFSfile,	procfs_validfile },
171 	{ DT_REG, N("fpregs"),	PFSfpregs,	procfs_validfpregs },
172 	{ DT_REG, N("limit"),	PFSlimit,	NULL },
173 	{ DT_REG, N("map"),	PFSmap,		procfs_validmap },
174 	{ DT_REG, N("maps"),	PFSmaps,	procfs_validmap },
175 	{ DT_REG, N("mem"),	PFSmem,		NULL },
176 	{ DT_REG, N("note"),	PFSnote,	NULL },
177 	{ DT_REG, N("notepg"),	PFSnotepg,	NULL },
178 	{ DT_REG, N("regs"),	PFSregs,	procfs_validregs },
179 	{ DT_REG, N("stat"),	PFSstat,	procfs_validfile_linux },
180 	{ DT_REG, N("statm"),	PFSstatm,	procfs_validfile_linux },
181 	{ DT_REG, N("status"),	PFSstatus,	NULL },
182 #ifdef __HAVE_PROCFS_MACHDEP
183 	PROCFS_MACHDEP_NODETYPE_DEFNS
184 #endif
185 #undef N
186 };
187 static const int nproc_targets = sizeof(proc_targets) / sizeof(proc_targets[0]);
188 
189 /*
190  * List of files in the root directory. Note: the validate function will
191  * be called with p == NULL for these ones.
192  */
193 static const struct proc_target proc_root_targets[] = {
194 #define N(s) sizeof(s)-1, s
195 	/*	  name		    type	    validp */
196 	{ DT_REG, N("meminfo"),     PFSmeminfo,        procfs_validfile_linux },
197 	{ DT_REG, N("cpuinfo"),     PFScpuinfo,        procfs_validfile_linux },
198 	{ DT_REG, N("uptime"),      PFSuptime,         procfs_validfile_linux },
199 	{ DT_REG, N("mounts"),	    PFSmounts,	       procfs_validfile_linux },
200 	{ DT_REG, N("devices"),     PFSdevices,        procfs_validfile_linux },
201 	{ DT_REG, N("stat"),	    PFScpustat,        procfs_validfile_linux },
202 	{ DT_REG, N("loadavg"),	    PFSloadavg,        procfs_validfile_linux },
203 	{ DT_REG, N("version"),     PFSversion,        procfs_validfile_linux },
204 #undef N
205 };
206 static const int nproc_root_targets =
207     sizeof(proc_root_targets) / sizeof(proc_root_targets[0]);
208 
209 int	procfs_lookup(void *);
210 #define	procfs_create	genfs_eopnotsupp
211 #define	procfs_mknod	genfs_eopnotsupp
212 int	procfs_open(void *);
213 int	procfs_close(void *);
214 int	procfs_access(void *);
215 int	procfs_getattr(void *);
216 int	procfs_setattr(void *);
217 #define	procfs_read	procfs_rw
218 #define	procfs_write	procfs_rw
219 #define	procfs_fcntl	genfs_fcntl
220 #define	procfs_ioctl	genfs_enoioctl
221 #define	procfs_poll	genfs_poll
222 #define	procfs_kqfilter	genfs_kqfilter
223 #define	procfs_revoke	genfs_revoke
224 #define	procfs_fsync	genfs_nullop
225 #define	procfs_seek	genfs_nullop
226 #define	procfs_remove	genfs_eopnotsupp
227 int	procfs_link(void *);
228 #define	procfs_rename	genfs_eopnotsupp
229 #define	procfs_mkdir	genfs_eopnotsupp
230 #define	procfs_rmdir	genfs_eopnotsupp
231 int	procfs_symlink(void *);
232 int	procfs_readdir(void *);
233 int	procfs_readlink(void *);
234 #define	procfs_abortop	genfs_abortop
235 int	procfs_inactive(void *);
236 int	procfs_reclaim(void *);
237 #define	procfs_lock	genfs_lock
238 #define	procfs_unlock	genfs_unlock
239 #define	procfs_bmap	genfs_badop
240 #define	procfs_strategy	genfs_badop
241 int	procfs_print(void *);
242 int	procfs_pathconf(void *);
243 #define	procfs_islocked	genfs_islocked
244 #define	procfs_advlock	genfs_einval
245 #define	procfs_bwrite	genfs_eopnotsupp
246 #define procfs_putpages	genfs_null_putpages
247 
248 static int atoi(const char *, size_t);
249 
250 /*
251  * procfs vnode operations.
252  */
253 int (**procfs_vnodeop_p)(void *);
254 const struct vnodeopv_entry_desc procfs_vnodeop_entries[] = {
255 	{ &vop_default_desc, vn_default_error },
256 	{ &vop_lookup_desc, procfs_lookup },		/* lookup */
257 	{ &vop_create_desc, procfs_create },		/* create */
258 	{ &vop_mknod_desc, procfs_mknod },		/* mknod */
259 	{ &vop_open_desc, procfs_open },		/* open */
260 	{ &vop_close_desc, procfs_close },		/* close */
261 	{ &vop_access_desc, procfs_access },		/* access */
262 	{ &vop_getattr_desc, procfs_getattr },		/* getattr */
263 	{ &vop_setattr_desc, procfs_setattr },		/* setattr */
264 	{ &vop_read_desc, procfs_read },		/* read */
265 	{ &vop_write_desc, procfs_write },		/* write */
266 	{ &vop_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
267 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
268 	{ &vop_fcntl_desc, procfs_fcntl },		/* fcntl */
269 	{ &vop_ioctl_desc, procfs_ioctl },		/* ioctl */
270 	{ &vop_poll_desc, procfs_poll },		/* poll */
271 	{ &vop_kqfilter_desc, procfs_kqfilter },	/* kqfilter */
272 	{ &vop_revoke_desc, procfs_revoke },		/* revoke */
273 	{ &vop_fsync_desc, procfs_fsync },		/* fsync */
274 	{ &vop_seek_desc, procfs_seek },		/* seek */
275 	{ &vop_remove_desc, procfs_remove },		/* remove */
276 	{ &vop_link_desc, procfs_link },		/* link */
277 	{ &vop_rename_desc, procfs_rename },		/* rename */
278 	{ &vop_mkdir_desc, procfs_mkdir },		/* mkdir */
279 	{ &vop_rmdir_desc, procfs_rmdir },		/* rmdir */
280 	{ &vop_symlink_desc, procfs_symlink },		/* symlink */
281 	{ &vop_readdir_desc, procfs_readdir },		/* readdir */
282 	{ &vop_readlink_desc, procfs_readlink },	/* readlink */
283 	{ &vop_abortop_desc, procfs_abortop },		/* abortop */
284 	{ &vop_inactive_desc, procfs_inactive },	/* inactive */
285 	{ &vop_reclaim_desc, procfs_reclaim },		/* reclaim */
286 	{ &vop_lock_desc, procfs_lock },		/* lock */
287 	{ &vop_unlock_desc, procfs_unlock },		/* unlock */
288 	{ &vop_bmap_desc, procfs_bmap },		/* bmap */
289 	{ &vop_strategy_desc, procfs_strategy },	/* strategy */
290 	{ &vop_print_desc, procfs_print },		/* print */
291 	{ &vop_islocked_desc, procfs_islocked },	/* islocked */
292 	{ &vop_pathconf_desc, procfs_pathconf },	/* pathconf */
293 	{ &vop_advlock_desc, procfs_advlock },		/* advlock */
294 	{ &vop_putpages_desc, procfs_putpages },	/* putpages */
295 	{ NULL, NULL }
296 };
297 const struct vnodeopv_desc procfs_vnodeop_opv_desc =
298 	{ &procfs_vnodeop_p, procfs_vnodeop_entries };
299 /*
300  * set things up for doing i/o on
301  * the pfsnode (vp).  (vp) is locked
302  * on entry, and should be left locked
303  * on exit.
304  *
305  * for procfs we don't need to do anything
306  * in particular for i/o.  all that is done
307  * is to support exclusive open on process
308  * memory images.
309  */
310 int
311 procfs_open(void *v)
312 {
313 	struct vop_open_args /* {
314 		struct vnode *a_vp;
315 		int  a_mode;
316 		kauth_cred_t a_cred;
317 	} */ *ap = v;
318 	struct pfsnode *pfs = VTOPFS(ap->a_vp);
319 	struct lwp *l1;
320 	struct proc *p2;
321 	int error;
322 
323 	if ((error = procfs_proc_lock(pfs->pfs_pid, &p2, ENOENT)) != 0)
324 		return error;
325 
326 	l1 = curlwp;				/* tracer */
327 
328 #define	M2K(m)	(((m) & FREAD) && ((m) & FWRITE) ? \
329 		 KAUTH_REQ_PROCESS_PROCFS_RW : \
330 		 (m) & FWRITE ? KAUTH_REQ_PROCESS_PROCFS_WRITE : \
331 		 KAUTH_REQ_PROCESS_PROCFS_READ)
332 
333 	mutex_enter(p2->p_lock);
334 	error = kauth_authorize_process(l1->l_cred, KAUTH_PROCESS_PROCFS,
335 	    p2, pfs, KAUTH_ARG(M2K(ap->a_mode)), NULL);
336 	mutex_exit(p2->p_lock);
337 	if (error) {
338 		procfs_proc_unlock(p2);
339 		return (error);
340 	}
341 
342 #undef M2K
343 
344 	switch (pfs->pfs_type) {
345 	case PFSmem:
346 		if (((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL)) ||
347 		    ((pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE))) {
348 			error = EBUSY;
349 			break;
350 		}
351 
352 		if (!proc_isunder(p2, l1)) {
353 			error = EPERM;
354 			break;
355 		}
356 
357 		if (ap->a_mode & FWRITE)
358 			pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL);
359 
360 		break;
361 
362 	case PFSregs:
363 	case PFSfpregs:
364 		if (!proc_isunder(p2, l1)) {
365 			error = EPERM;
366 			break;
367 		}
368 		break;
369 
370 	default:
371 		break;
372 	}
373 
374 	procfs_proc_unlock(p2);
375 	return (error);
376 }
377 
378 /*
379  * close the pfsnode (vp) after doing i/o.
380  * (vp) is not locked on entry or exit.
381  *
382  * nothing to do for procfs other than undo
383  * any exclusive open flag (see _open above).
384  */
385 int
386 procfs_close(void *v)
387 {
388 	struct vop_close_args /* {
389 		struct vnode *a_vp;
390 		int  a_fflag;
391 		kauth_cred_t a_cred;
392 	} */ *ap = v;
393 	struct pfsnode *pfs = VTOPFS(ap->a_vp);
394 
395 	switch (pfs->pfs_type) {
396 	case PFSmem:
397 		if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL))
398 			pfs->pfs_flags &= ~(FWRITE|O_EXCL);
399 		break;
400 
401 	default:
402 		break;
403 	}
404 
405 	return (0);
406 }
407 
408 /*
409  * _inactive is called when the pfsnode
410  * is vrele'd and the reference count goes
411  * to zero.  (vp) will be on the vnode free
412  * list, so to get it back vget() must be
413  * used.
414  *
415  * (vp) is locked on entry, but must be unlocked on exit.
416  */
417 int
418 procfs_inactive(void *v)
419 {
420 	struct vop_inactive_v2_args /* {
421 		struct vnode *a_vp;
422 		bool *a_recycle;
423 	} */ *ap = v;
424 	struct vnode *vp = ap->a_vp;
425 	struct pfsnode *pfs = VTOPFS(vp);
426 
427 	mutex_enter(proc_lock);
428 	*ap->a_recycle = (proc_find(pfs->pfs_pid) == NULL);
429 	mutex_exit(proc_lock);
430 
431 	return (0);
432 }
433 
434 /*
435  * _reclaim is called when getnewvnode()
436  * wants to make use of an entry on the vnode
437  * free list.  at this time the filesystem needs
438  * to free any private data and remove the node
439  * from any private lists.
440  */
441 int
442 procfs_reclaim(void *v)
443 {
444 	struct vop_reclaim_v2_args /* {
445 		struct vnode *a_vp;
446 	} */ *ap = v;
447 	struct vnode *vp = ap->a_vp;
448 	struct pfsnode *pfs = VTOPFS(vp);
449 
450 	VOP_UNLOCK(vp);
451 
452 	/*
453 	 * To interlock with procfs_revoke_vnodes().
454 	 */
455 	mutex_enter(vp->v_interlock);
456 	vp->v_data = NULL;
457 	mutex_exit(vp->v_interlock);
458 	kmem_free(pfs, sizeof(*pfs));
459 	return 0;
460 }
461 
462 /*
463  * Return POSIX pathconf information applicable to special devices.
464  */
465 int
466 procfs_pathconf(void *v)
467 {
468 	struct vop_pathconf_args /* {
469 		struct vnode *a_vp;
470 		int a_name;
471 		register_t *a_retval;
472 	} */ *ap = v;
473 
474 	switch (ap->a_name) {
475 	case _PC_LINK_MAX:
476 		*ap->a_retval = LINK_MAX;
477 		return (0);
478 	case _PC_MAX_CANON:
479 		*ap->a_retval = MAX_CANON;
480 		return (0);
481 	case _PC_MAX_INPUT:
482 		*ap->a_retval = MAX_INPUT;
483 		return (0);
484 	case _PC_PIPE_BUF:
485 		*ap->a_retval = PIPE_BUF;
486 		return (0);
487 	case _PC_CHOWN_RESTRICTED:
488 		*ap->a_retval = 1;
489 		return (0);
490 	case _PC_VDISABLE:
491 		*ap->a_retval = _POSIX_VDISABLE;
492 		return (0);
493 	case _PC_SYNC_IO:
494 		*ap->a_retval = 1;
495 		return (0);
496 	default:
497 		return (EINVAL);
498 	}
499 	/* NOTREACHED */
500 }
501 
502 /*
503  * _print is used for debugging.
504  * just print a readable description
505  * of (vp).
506  */
507 int
508 procfs_print(void *v)
509 {
510 	struct vop_print_args /* {
511 		struct vnode *a_vp;
512 	} */ *ap = v;
513 	struct pfsnode *pfs = VTOPFS(ap->a_vp);
514 
515 	printf("tag VT_PROCFS, type %d, pid %d, mode %x, flags %lx\n",
516 	    pfs->pfs_type, pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags);
517 	return 0;
518 }
519 
520 int
521 procfs_link(void *v)
522 {
523 	struct vop_link_v2_args /* {
524 		struct vnode *a_dvp;
525 		struct vnode *a_vp;
526 		struct componentname *a_cnp;
527 	} */ *ap = v;
528 
529 	VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
530 	return (EROFS);
531 }
532 
533 int
534 procfs_symlink(void *v)
535 {
536 	struct vop_symlink_v3_args /* {
537 		struct vnode *a_dvp;
538 		struct vnode **a_vpp;
539 		struct componentname *a_cnp;
540 		struct vattr *a_vap;
541 		char *a_target;
542 	} */ *ap = v;
543 
544 	VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
545 	return (EROFS);
546 }
547 
548 /*
549  * Works out the path to the target process's current
550  * working directory or chroot.  If the caller is in a chroot and
551  * can't "reach" the target's cwd or root (or some other error
552  * occurs), a "/" is returned for the path.
553  */
554 static void
555 procfs_dir(pfstype t, struct lwp *caller, struct proc *target, char **bpp,
556     char *path, size_t len)
557 {
558 	struct cwdinfo *cwdi;
559 	struct vnode *vp, *rvp;
560 	char *bp;
561 
562 	/*
563 	 * Lock target cwdi and take a reference to the vnode
564 	 * we are interested in to prevent it from disappearing
565 	 * before getcwd_common() below.
566 	 */
567 	rw_enter(&target->p_cwdi->cwdi_lock, RW_READER);
568 	switch (t) {
569 	case PFScwd:
570 		vp = target->p_cwdi->cwdi_cdir;
571 		break;
572 	case PFSchroot:
573 		vp = target->p_cwdi->cwdi_rdir;
574 		break;
575 	default:
576 		rw_exit(&target->p_cwdi->cwdi_lock);
577 		return;
578 	}
579 	if (vp != NULL)
580 		vref(vp);
581 	rw_exit(&target->p_cwdi->cwdi_lock);
582 
583 	cwdi = caller->l_proc->p_cwdi;
584 	rw_enter(&cwdi->cwdi_lock, RW_READER);
585 
586 	rvp = cwdi->cwdi_rdir;
587 	bp = bpp ? *bpp : NULL;
588 
589 	/*
590 	 * XXX: this horrible kludge avoids locking panics when
591 	 * attempting to lookup links that point to within procfs
592 	 */
593 	if (vp != NULL && vp->v_tag == VT_PROCFS) {
594 		if (bpp) {
595 			*--bp = '/';
596 			*bpp = bp;
597 		}
598 		vrele(vp);
599 		rw_exit(&cwdi->cwdi_lock);
600 		return;
601 	}
602 
603 	if (rvp == NULL)
604 		rvp = rootvnode;
605 	if (vp == NULL || getcwd_common(vp, rvp, bp ? &bp : NULL, path,
606 	    len / 2, 0, caller) != 0) {
607 		if (bpp) {
608 			bp = *bpp;
609 			*--bp = '/';
610 		}
611 	}
612 
613 	if (bpp)
614 		*bpp = bp;
615 
616 	if (vp != NULL)
617 		vrele(vp);
618 	rw_exit(&cwdi->cwdi_lock);
619 }
620 
621 /*
622  * Invent attributes for pfsnode (vp) and store
623  * them in (vap).
624  * Directories lengths are returned as zero since
625  * any real length would require the genuine size
626  * to be computed, and nothing cares anyway.
627  *
628  * this is relatively minimal for procfs.
629  */
630 int
631 procfs_getattr(void *v)
632 {
633 	struct vop_getattr_args /* {
634 		struct vnode *a_vp;
635 		struct vattr *a_vap;
636 		kauth_cred_t a_cred;
637 	} */ *ap = v;
638 	struct pfsnode *pfs = VTOPFS(ap->a_vp);
639 	struct vattr *vap = ap->a_vap;
640 	struct proc *procp;
641 	char *path, *bp, bf[16];
642 	int error;
643 
644 	/* first check the process still exists */
645 	switch (pfs->pfs_type) {
646 	case PFSroot:
647 	case PFScurproc:
648 	case PFSself:
649 		procp = NULL;
650 		break;
651 
652 	default:
653 		error = procfs_proc_lock(pfs->pfs_pid, &procp, ENOENT);
654 		if (error != 0)
655 			return (error);
656 		break;
657 	}
658 
659 	switch (pfs->pfs_type) {
660 	case PFStask:
661 		if (pfs->pfs_fd == -1) {
662 			path = NULL;
663 			break;
664 		}
665 		/*FALLTHROUGH*/
666 	case PFScwd:
667 	case PFSchroot:
668 		path = malloc(MAXPATHLEN + 4, M_TEMP, M_WAITOK);
669 		if (path == NULL && procp != NULL) {
670 			procfs_proc_unlock(procp);
671 			return (ENOMEM);
672 		}
673 		break;
674 
675 	default:
676 		path = NULL;
677 		break;
678 	}
679 
680 	if (procp != NULL) {
681 		mutex_enter(procp->p_lock);
682 		error = kauth_authorize_process(kauth_cred_get(),
683 		    KAUTH_PROCESS_CANSEE, procp,
684 		    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
685 		mutex_exit(procp->p_lock);
686 		if (error != 0) {
687 		    	procfs_proc_unlock(procp);
688 		    	if (path != NULL)
689 		    		free(path, M_TEMP);
690 			return (ENOENT);
691 		}
692 	}
693 
694 	error = 0;
695 
696 	/* start by zeroing out the attributes */
697 	vattr_null(vap);
698 
699 	/* next do all the common fields */
700 	vap->va_type = ap->a_vp->v_type;
701 	vap->va_mode = pfs->pfs_mode;
702 	vap->va_fileid = pfs->pfs_fileno;
703 	vap->va_flags = 0;
704 	vap->va_blocksize = PAGE_SIZE;
705 
706 	/*
707 	 * Make all times be current TOD.
708 	 *
709 	 * It would be possible to get the process start
710 	 * time from the p_stats structure, but there's
711 	 * no "file creation" time stamp anyway, and the
712 	 * p_stats structure is not addressable if u. gets
713 	 * swapped out for that process.
714 	 */
715 	getnanotime(&vap->va_ctime);
716 	vap->va_atime = vap->va_mtime = vap->va_ctime;
717 	if (procp)
718 		TIMEVAL_TO_TIMESPEC(&procp->p_stats->p_start,
719 		    &vap->va_birthtime);
720 	else
721 		getnanotime(&vap->va_birthtime);
722 
723 	switch (pfs->pfs_type) {
724 	case PFSmem:
725 	case PFSregs:
726 	case PFSfpregs:
727 #if defined(__HAVE_PROCFS_MACHDEP) && defined(PROCFS_MACHDEP_PROTECT_CASES)
728 	PROCFS_MACHDEP_PROTECT_CASES
729 #endif
730 		/*
731 		 * If the process has exercised some setuid or setgid
732 		 * privilege, then rip away read/write permission so
733 		 * that only root can gain access.
734 		 */
735 		if (procp->p_flag & PK_SUGID)
736 			vap->va_mode &= ~(S_IRUSR|S_IWUSR);
737 		/* FALLTHROUGH */
738 	case PFSstatus:
739 	case PFSstat:
740 	case PFSnote:
741 	case PFSnotepg:
742 	case PFScmdline:
743 	case PFSenviron:
744 	case PFSemul:
745 	case PFSstatm:
746 
747 	case PFSmap:
748 	case PFSmaps:
749 	case PFSlimit:
750 	case PFSauxv:
751 		vap->va_nlink = 1;
752 		vap->va_uid = kauth_cred_geteuid(procp->p_cred);
753 		vap->va_gid = kauth_cred_getegid(procp->p_cred);
754 		break;
755 	case PFScwd:
756 	case PFSchroot:
757 	case PFSmeminfo:
758 	case PFSdevices:
759 	case PFScpuinfo:
760 	case PFSuptime:
761 	case PFSmounts:
762 	case PFScpustat:
763 	case PFSloadavg:
764 	case PFSversion:
765 	case PFSexe:
766 	case PFSself:
767 	case PFScurproc:
768 	case PFSroot:
769 		vap->va_nlink = 1;
770 		vap->va_uid = vap->va_gid = 0;
771 		break;
772 
773 	case PFSproc:
774 	case PFStask:
775 	case PFSfile:
776 	case PFSfd:
777 		break;
778 
779 	default:
780 		panic("%s: %d/1", __func__, pfs->pfs_type);
781 	}
782 
783 	/*
784 	 * now do the object specific fields
785 	 *
786 	 * The size could be set from struct reg, but it's hardly
787 	 * worth the trouble, and it puts some (potentially) machine
788 	 * dependent data into this machine-independent code.  If it
789 	 * becomes important then this function should break out into
790 	 * a per-file stat function in the corresponding .c file.
791 	 */
792 
793 	switch (pfs->pfs_type) {
794 	case PFSroot:
795 		vap->va_bytes = vap->va_size = DEV_BSIZE;
796 		break;
797 
798 	case PFSself:
799 	case PFScurproc:
800 		vap->va_bytes = vap->va_size =
801 		    snprintf(bf, sizeof(bf), "%ld", (long)curproc->p_pid);
802 		break;
803 	case PFStask:
804 		if (pfs->pfs_fd != -1) {
805 			vap->va_nlink = 1;
806 			vap->va_uid = 0;
807 			vap->va_gid = 0;
808 			vap->va_bytes = vap->va_size =
809 			    snprintf(bf, sizeof(bf), "..");
810 			break;
811 		}
812 		/*FALLTHROUGH*/
813 	case PFSfd:
814 		if (pfs->pfs_fd != -1) {
815 			file_t *fp;
816 
817 			fp = fd_getfile2(procp, pfs->pfs_fd);
818 			if (fp == NULL) {
819 				error = EBADF;
820 				break;
821 			}
822 			vap->va_nlink = 1;
823 			vap->va_uid = kauth_cred_geteuid(fp->f_cred);
824 			vap->va_gid = kauth_cred_getegid(fp->f_cred);
825 			switch (fp->f_type) {
826 			case DTYPE_VNODE:
827 				vap->va_bytes = vap->va_size =
828 				    fp->f_vnode->v_size;
829 				break;
830 			default:
831 				vap->va_bytes = vap->va_size = 0;
832 				break;
833 			}
834 			closef(fp);
835 			break;
836 		}
837 		/*FALLTHROUGH*/
838 	case PFSproc:
839 		vap->va_nlink = 2;
840 		vap->va_uid = kauth_cred_geteuid(procp->p_cred);
841 		vap->va_gid = kauth_cred_getegid(procp->p_cred);
842 		vap->va_bytes = vap->va_size = DEV_BSIZE;
843 		break;
844 
845 	case PFSfile:
846 		error = EOPNOTSUPP;
847 		break;
848 
849 	case PFSmem:
850 		vap->va_bytes = vap->va_size =
851 			ctob(procp->p_vmspace->vm_tsize +
852 				    procp->p_vmspace->vm_dsize +
853 				    procp->p_vmspace->vm_ssize);
854 		break;
855 
856 	case PFSauxv:
857 		vap->va_bytes = vap->va_size = procp->p_execsw->es_arglen;
858 		break;
859 
860 #if defined(PT_GETREGS) || defined(PT_SETREGS)
861 	case PFSregs:
862 		vap->va_bytes = vap->va_size = sizeof(struct reg);
863 		break;
864 #endif
865 
866 #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS)
867 	case PFSfpregs:
868 		vap->va_bytes = vap->va_size = sizeof(struct fpreg);
869 		break;
870 #endif
871 
872 	case PFSstatus:
873 	case PFSstat:
874 	case PFSnote:
875 	case PFSnotepg:
876 	case PFScmdline:
877 	case PFSenviron:
878 	case PFSmeminfo:
879 	case PFSdevices:
880 	case PFScpuinfo:
881 	case PFSuptime:
882 	case PFSmounts:
883 	case PFScpustat:
884 	case PFSloadavg:
885 	case PFSstatm:
886 	case PFSversion:
887 		vap->va_bytes = vap->va_size = 0;
888 		break;
889 	case PFSlimit:
890 	case PFSmap:
891 	case PFSmaps:
892 		/*
893 		 * Advise a larger blocksize for the map files, so that
894 		 * they may be read in one pass.
895 		 */
896 		vap->va_blocksize = 4 * PAGE_SIZE;
897 		vap->va_bytes = vap->va_size = 0;
898 		break;
899 
900 	case PFScwd:
901 	case PFSchroot:
902 		bp = path + MAXPATHLEN;
903 		*--bp = '\0';
904 		procfs_dir(pfs->pfs_type, curlwp, procp, &bp, path,
905 		     MAXPATHLEN);
906 		vap->va_bytes = vap->va_size = strlen(bp);
907 		break;
908 
909 	case PFSexe:
910 		vap->va_bytes = vap->va_size = strlen(procp->p_path);
911 		break;
912 
913 	case PFSemul:
914 		vap->va_bytes = vap->va_size = strlen(procp->p_emul->e_name);
915 		break;
916 
917 #ifdef __HAVE_PROCFS_MACHDEP
918 	PROCFS_MACHDEP_NODETYPE_CASES
919 		error = procfs_machdep_getattr(ap->a_vp, vap, procp);
920 		break;
921 #endif
922 
923 	default:
924 		panic("%s: %d/2", __func__, pfs->pfs_type);
925 	}
926 
927 	if (procp != NULL)
928 		procfs_proc_unlock(procp);
929 	if (path != NULL)
930 		free(path, M_TEMP);
931 
932 	return (error);
933 }
934 
935 /*ARGSUSED*/
936 int
937 procfs_setattr(void *v)
938 {
939 	/*
940 	 * just fake out attribute setting
941 	 * it's not good to generate an error
942 	 * return, otherwise things like creat()
943 	 * will fail when they try to set the
944 	 * file length to 0.  worse, this means
945 	 * that echo $note > /proc/$pid/note will fail.
946 	 */
947 
948 	return (0);
949 }
950 
951 /*
952  * implement access checking.
953  *
954  * actually, the check for super-user is slightly
955  * broken since it will allow read access to write-only
956  * objects.  this doesn't cause any particular trouble
957  * but does mean that the i/o entry points need to check
958  * that the operation really does make sense.
959  */
960 int
961 procfs_access(void *v)
962 {
963 	struct vop_access_args /* {
964 		struct vnode *a_vp;
965 		int a_mode;
966 		kauth_cred_t a_cred;
967 	} */ *ap = v;
968 	struct vattr va;
969 	int error;
970 
971 	if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
972 		return (error);
973 
974 	return kauth_authorize_vnode(ap->a_cred,
975 	    KAUTH_ACCESS_ACTION(ap->a_mode, ap->a_vp->v_type, va.va_mode),
976 	    ap->a_vp, NULL, genfs_can_access(va.va_type, va.va_mode,
977 	    va.va_uid, va.va_gid, ap->a_mode, ap->a_cred));
978 }
979 
980 /*
981  * lookup.  this is incredibly complicated in the
982  * general case, however for most pseudo-filesystems
983  * very little needs to be done.
984  *
985  * Locking isn't hard here, just poorly documented.
986  *
987  * If we're looking up ".", just vref the parent & return it.
988  *
989  * If we're looking up "..", unlock the parent, and lock "..". If everything
990  * went ok, and we're on the last component and the caller requested the
991  * parent locked, try to re-lock the parent. We do this to prevent lock
992  * races.
993  *
994  * For anything else, get the needed node. Then unlock the parent if not
995  * the last component or not LOCKPARENT (i.e. if we wouldn't re-lock the
996  * parent in the .. case).
997  *
998  * We try to exit with the parent locked in error cases.
999  */
1000 int
1001 procfs_lookup(void *v)
1002 {
1003 	struct vop_lookup_v2_args /* {
1004 		struct vnode * a_dvp;
1005 		struct vnode ** a_vpp;
1006 		struct componentname * a_cnp;
1007 	} */ *ap = v;
1008 	struct componentname *cnp = ap->a_cnp;
1009 	struct vnode **vpp = ap->a_vpp;
1010 	struct vnode *dvp = ap->a_dvp;
1011 	const char *pname = cnp->cn_nameptr;
1012 	const struct proc_target *pt = NULL;
1013 	struct vnode *fvp;
1014 	pid_t pid, vnpid;
1015 	struct pfsnode *pfs;
1016 	struct proc *p = NULL;
1017 	struct lwp *plwp;
1018 	int i, error;
1019 	pfstype type;
1020 
1021 	*vpp = NULL;
1022 
1023 	if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
1024 		return (EROFS);
1025 
1026 	if (cnp->cn_namelen == 1 && *pname == '.') {
1027 		*vpp = dvp;
1028 		vref(dvp);
1029 		return (0);
1030 	}
1031 
1032 	pfs = VTOPFS(dvp);
1033 	switch (pfs->pfs_type) {
1034 	case PFSroot:
1035 		/*
1036 		 * Shouldn't get here with .. in the root node.
1037 		 */
1038 		if (cnp->cn_flags & ISDOTDOT)
1039 			return (EIO);
1040 
1041 		for (i = 0; i < nproc_root_targets; i++) {
1042 			pt = &proc_root_targets[i];
1043 			/*
1044 			 * check for node match.  proc is always NULL here,
1045 			 * so call pt_valid with constant NULL lwp.
1046 			 */
1047 			if (cnp->cn_namelen == pt->pt_namlen &&
1048 			    memcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
1049 			    (pt->pt_valid == NULL ||
1050 			     (*pt->pt_valid)(NULL, dvp->v_mount)))
1051 				break;
1052 		}
1053 
1054 		if (i != nproc_root_targets) {
1055 			error = procfs_allocvp(dvp->v_mount, vpp, 0,
1056 			    pt->pt_pfstype, -1);
1057 			return (error);
1058 		}
1059 
1060 		if (CNEQ(cnp, "curproc", 7)) {
1061 			pid = curproc->p_pid;
1062 			vnpid = 0;
1063 			type = PFScurproc;
1064 		} else if (CNEQ(cnp, "self", 4)) {
1065 			pid = curproc->p_pid;
1066 			vnpid = 0;
1067 			type = PFSself;
1068 		} else {
1069 			pid = (pid_t)atoi(pname, cnp->cn_namelen);
1070 			vnpid = pid;
1071 			type = PFSproc;
1072 		}
1073 
1074 		if (procfs_proc_lock(pid, &p, ESRCH) != 0)
1075 			break;
1076 		error = procfs_allocvp(dvp->v_mount, vpp, vnpid, type, -1);
1077 		procfs_proc_unlock(p);
1078 		return (error);
1079 
1080 	case PFSproc:
1081 		if (cnp->cn_flags & ISDOTDOT) {
1082 			error = procfs_allocvp(dvp->v_mount, vpp, 0, PFSroot,
1083 			    -1);
1084 			return (error);
1085 		}
1086 
1087 		if (procfs_proc_lock(pfs->pfs_pid, &p, ESRCH) != 0)
1088 			break;
1089 
1090 		mutex_enter(p->p_lock);
1091 		LIST_FOREACH(plwp, &p->p_lwps, l_sibling) {
1092 			if (plwp->l_stat != LSZOMB)
1093 				break;
1094 		}
1095 		/* Process is exiting if no-LWPS or all LWPs are LSZOMB */
1096 		if (plwp == NULL) {
1097 			mutex_exit(p->p_lock);
1098 			procfs_proc_unlock(p);
1099 			return ESRCH;
1100 		}
1101 
1102 		lwp_addref(plwp);
1103 		mutex_exit(p->p_lock);
1104 
1105 		for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) {
1106 			int found;
1107 
1108 			found = cnp->cn_namelen == pt->pt_namlen &&
1109 			    memcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
1110 			    (pt->pt_valid == NULL
1111 			      || (*pt->pt_valid)(plwp, dvp->v_mount));
1112 			if (found)
1113 				break;
1114 		}
1115 		lwp_delref(plwp);
1116 
1117 		if (i == nproc_targets) {
1118 			procfs_proc_unlock(p);
1119 			break;
1120 		}
1121 		if (pt->pt_pfstype == PFSfile) {
1122 			fvp = p->p_textvp;
1123 			/* We already checked that it exists. */
1124 			vref(fvp);
1125 			procfs_proc_unlock(p);
1126 			*vpp = fvp;
1127 			return (0);
1128 		}
1129 
1130 		error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
1131 		    pt->pt_pfstype, -1);
1132 		procfs_proc_unlock(p);
1133 		return (error);
1134 
1135 	case PFSfd: {
1136 		int fd;
1137 		file_t *fp;
1138 
1139 		if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ENOENT)) != 0)
1140 			return error;
1141 
1142 		if (cnp->cn_flags & ISDOTDOT) {
1143 			error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
1144 			    PFSproc, -1);
1145 			procfs_proc_unlock(p);
1146 			return (error);
1147 		}
1148 		fd = atoi(pname, cnp->cn_namelen);
1149 
1150 		fp = fd_getfile2(p, fd);
1151 		if (fp == NULL) {
1152 			procfs_proc_unlock(p);
1153 			return ENOENT;
1154 		}
1155 		fvp = fp->f_vnode;
1156 
1157 		/* Don't show directories */
1158 		if (fp->f_type == DTYPE_VNODE && fvp->v_type != VDIR) {
1159 			vref(fvp);
1160 			closef(fp);
1161 			procfs_proc_unlock(p);
1162 			*vpp = fvp;
1163 			return 0;
1164 		}
1165 
1166 		closef(fp);
1167 		error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
1168 		    PFSfd, fd);
1169 		procfs_proc_unlock(p);
1170 		return error;
1171 	}
1172 	case PFStask: {
1173 		int xpid;
1174 
1175 		if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ENOENT)) != 0)
1176 			return error;
1177 
1178 		if (cnp->cn_flags & ISDOTDOT) {
1179 			error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
1180 			    PFSproc, -1);
1181 			procfs_proc_unlock(p);
1182 			return (error);
1183 		}
1184 		xpid = atoi(pname, cnp->cn_namelen);
1185 
1186 		if (xpid != pfs->pfs_pid) {
1187 			procfs_proc_unlock(p);
1188 			return ENOENT;
1189 		}
1190 		error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
1191 		    PFStask, 0);
1192 		procfs_proc_unlock(p);
1193 		return error;
1194 	}
1195 	default:
1196 		return (ENOTDIR);
1197 	}
1198 
1199 	return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
1200 }
1201 
1202 int
1203 procfs_validfile(struct lwp *l, struct mount *mp)
1204 {
1205 	return l != NULL && l->l_proc != NULL && l->l_proc->p_textvp != NULL;
1206 }
1207 
1208 static int
1209 procfs_validfile_linux(struct lwp *l, struct mount *mp)
1210 {
1211 	int flags;
1212 
1213 	flags = VFSTOPROC(mp)->pmnt_flags;
1214 	return (flags & PROCFSMNT_LINUXCOMPAT) &&
1215 	    (l == NULL || l->l_proc == NULL || procfs_validfile(l, mp));
1216 }
1217 
1218 struct procfs_root_readdir_ctx {
1219 	struct uio *uiop;
1220 	off_t *cookies;
1221 	int ncookies;
1222 	off_t off;
1223 	off_t startoff;
1224 	int error;
1225 };
1226 
1227 static int
1228 procfs_root_readdir_callback(struct proc *p, void *arg)
1229 {
1230 	struct procfs_root_readdir_ctx *ctxp = arg;
1231 	struct dirent d;
1232 	struct uio *uiop;
1233 	int error;
1234 
1235 	uiop = ctxp->uiop;
1236 	if (uiop->uio_resid < UIO_MX)
1237 		return -1; /* no space */
1238 
1239 	if (ctxp->off < ctxp->startoff) {
1240 		ctxp->off++;
1241 		return 0;
1242 	}
1243 
1244 	if (kauth_authorize_process(kauth_cred_get(),
1245 	    KAUTH_PROCESS_CANSEE, p,
1246 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL) != 0)
1247 		return 0;
1248 
1249 	memset(&d, 0, UIO_MX);
1250 	d.d_reclen = UIO_MX;
1251 	d.d_fileno = PROCFS_FILENO(p->p_pid, PFSproc, -1);
1252 	d.d_namlen = snprintf(d.d_name,
1253 	    UIO_MX - offsetof(struct dirent, d_name), "%ld", (long)p->p_pid);
1254 	d.d_type = DT_DIR;
1255 
1256 	mutex_exit(proc_lock);
1257 	error = uiomove(&d, UIO_MX, uiop);
1258 	mutex_enter(proc_lock);
1259 	if (error) {
1260 		ctxp->error = error;
1261 		return -1;
1262 	}
1263 
1264 	ctxp->ncookies++;
1265 	if (ctxp->cookies)
1266 		*(ctxp->cookies)++ = ctxp->off + 1;
1267 	ctxp->off++;
1268 
1269 	return 0;
1270 }
1271 
1272 /*
1273  * readdir returns directory entries from pfsnode (vp).
1274  *
1275  * the strategy here with procfs is to generate a single
1276  * directory entry at a time (struct dirent) and then
1277  * copy that out to userland using uiomove.  a more efficent
1278  * though more complex implementation, would try to minimize
1279  * the number of calls to uiomove().  for procfs, this is
1280  * hardly worth the added code complexity.
1281  *
1282  * this should just be done through read()
1283  */
1284 int
1285 procfs_readdir(void *v)
1286 {
1287 	struct vop_readdir_args /* {
1288 		struct vnode *a_vp;
1289 		struct uio *a_uio;
1290 		kauth_cred_t a_cred;
1291 		int *a_eofflag;
1292 		off_t **a_cookies;
1293 		int *a_ncookies;
1294 	} */ *ap = v;
1295 	struct uio *uio = ap->a_uio;
1296 	struct dirent d;
1297 	struct pfsnode *pfs;
1298 	off_t i;
1299 	int error;
1300 	off_t *cookies = NULL;
1301 	int ncookies;
1302 	struct vnode *vp;
1303 	const struct proc_target *pt;
1304 	struct procfs_root_readdir_ctx ctx;
1305 	struct lwp *l;
1306 	int nfd;
1307 
1308 	vp = ap->a_vp;
1309 	pfs = VTOPFS(vp);
1310 
1311 	if (uio->uio_resid < UIO_MX)
1312 		return (EINVAL);
1313 	if (uio->uio_offset < 0)
1314 		return (EINVAL);
1315 
1316 	error = 0;
1317 	i = uio->uio_offset;
1318 	memset(&d, 0, UIO_MX);
1319 	d.d_reclen = UIO_MX;
1320 	ncookies = uio->uio_resid / UIO_MX;
1321 
1322 	switch (pfs->pfs_type) {
1323 	/*
1324 	 * this is for the process-specific sub-directories.
1325 	 * all that is needed to is copy out all the entries
1326 	 * from the procent[] table (top of this file).
1327 	 */
1328 	case PFSproc: {
1329 		struct proc *p;
1330 
1331 		if (i >= nproc_targets)
1332 			return 0;
1333 
1334 		if (procfs_proc_lock(pfs->pfs_pid, &p, ESRCH) != 0)
1335 			break;
1336 
1337 		if (ap->a_ncookies) {
1338 			ncookies = uimin(ncookies, (nproc_targets - i));
1339 			cookies = malloc(ncookies * sizeof (off_t),
1340 			    M_TEMP, M_WAITOK);
1341 			*ap->a_cookies = cookies;
1342 		}
1343 
1344 		for (pt = &proc_targets[i];
1345 		     uio->uio_resid >= UIO_MX && i < nproc_targets; pt++, i++) {
1346 			if (pt->pt_valid) {
1347 				/* XXXSMP LWP can disappear */
1348 				mutex_enter(p->p_lock);
1349 				l = LIST_FIRST(&p->p_lwps);
1350 				KASSERT(l != NULL);
1351 				mutex_exit(p->p_lock);
1352 				if ((*pt->pt_valid)(l, vp->v_mount) == 0)
1353 					continue;
1354 			}
1355 
1356 			d.d_fileno = PROCFS_FILENO(pfs->pfs_pid,
1357 			    pt->pt_pfstype, -1);
1358 			d.d_namlen = pt->pt_namlen;
1359 			memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1);
1360 			d.d_type = pt->pt_type;
1361 
1362 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1363 				break;
1364 			if (cookies)
1365 				*cookies++ = i + 1;
1366 		}
1367 
1368 		procfs_proc_unlock(p);
1369 	    	break;
1370 	}
1371 	case PFSfd: {
1372 		struct proc *p;
1373 		file_t *fp;
1374 		int lim, nc = 0;
1375 
1376 		if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ESRCH)) != 0)
1377 			return error;
1378 
1379 		/* XXX Should this be by file as well? */
1380 		if (kauth_authorize_process(kauth_cred_get(),
1381 		    KAUTH_PROCESS_CANSEE, p,
1382 		    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_OPENFILES), NULL,
1383 		    NULL) != 0) {
1384 		    	procfs_proc_unlock(p);
1385 			return ESRCH;
1386 		}
1387 
1388 		nfd = p->p_fd->fd_dt->dt_nfiles;
1389 
1390 		lim = uimin((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
1391 		if (i >= lim) {
1392 		    	procfs_proc_unlock(p);
1393 			return 0;
1394 		}
1395 
1396 		if (ap->a_ncookies) {
1397 			ncookies = uimin(ncookies, (nfd + 2 - i));
1398 			cookies = malloc(ncookies * sizeof (off_t),
1399 			    M_TEMP, M_WAITOK);
1400 			*ap->a_cookies = cookies;
1401 		}
1402 
1403 		for (; i < 2 && uio->uio_resid >= UIO_MX; i++) {
1404 			pt = &proc_targets[i];
1405 			d.d_namlen = pt->pt_namlen;
1406 			d.d_fileno = PROCFS_FILENO(pfs->pfs_pid,
1407 			    pt->pt_pfstype, -1);
1408 			(void)memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1);
1409 			d.d_type = pt->pt_type;
1410 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1411 				break;
1412 			if (cookies)
1413 				*cookies++ = i + 1;
1414 			nc++;
1415 		}
1416 		if (error) {
1417 			ncookies = nc;
1418 			break;
1419 		}
1420 		for (; uio->uio_resid >= UIO_MX && i < nfd; i++) {
1421 			/* check the descriptor exists */
1422 			if ((fp = fd_getfile2(p, i - 2)) == NULL)
1423 				continue;
1424 			closef(fp);
1425 
1426 			d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, PFSfd, i - 2);
1427 			d.d_namlen = snprintf(d.d_name, sizeof(d.d_name),
1428 			    "%lld", (long long)(i - 2));
1429 			d.d_type = VREG;
1430 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1431 				break;
1432 			if (cookies)
1433 				*cookies++ = i + 1;
1434 			nc++;
1435 		}
1436 		ncookies = nc;
1437 		procfs_proc_unlock(p);
1438 		break;
1439 	}
1440 	case PFStask: {
1441 		struct proc *p;
1442 		int nc = 0;
1443 
1444 		if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ESRCH)) != 0)
1445 			return error;
1446 
1447 		nfd = 3;	/* ., .., pid */
1448 
1449 		if (ap->a_ncookies) {
1450 			ncookies = uimin(ncookies, (nfd + 2 - i));
1451 			cookies = malloc(ncookies * sizeof (off_t),
1452 			    M_TEMP, M_WAITOK);
1453 			*ap->a_cookies = cookies;
1454 		}
1455 
1456 		for (; i < 2 && uio->uio_resid >= UIO_MX; i++) {
1457 			pt = &proc_targets[i];
1458 			d.d_namlen = pt->pt_namlen;
1459 			d.d_fileno = PROCFS_FILENO(pfs->pfs_pid,
1460 			    pt->pt_pfstype, -1);
1461 			(void)memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1);
1462 			d.d_type = pt->pt_type;
1463 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1464 				break;
1465 			if (cookies)
1466 				*cookies++ = i + 1;
1467 			nc++;
1468 		}
1469 		if (error) {
1470 			ncookies = nc;
1471 			break;
1472 		}
1473 		for (; uio->uio_resid >= UIO_MX && i < nfd; i++) {
1474 			/* check the descriptor exists */
1475 			d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, PFStask,
1476 			    i - 2);
1477 			d.d_namlen = snprintf(d.d_name, sizeof(d.d_name),
1478 			    "%ld", (long)pfs->pfs_pid);
1479 			d.d_type = DT_LNK;
1480 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1481 				break;
1482 			if (cookies)
1483 				*cookies++ = i + 1;
1484 			nc++;
1485 		}
1486 		ncookies = nc;
1487 		procfs_proc_unlock(p);
1488 		break;
1489 	}
1490 
1491 	/*
1492 	 * this is for the root of the procfs filesystem
1493 	 * what is needed are special entries for "curproc"
1494 	 * and "self" followed by an entry for each process
1495 	 * on allproc.
1496 	 */
1497 
1498 	case PFSroot: {
1499 		int nc = 0;
1500 
1501 		if (ap->a_ncookies) {
1502 			/*
1503 			 * XXX Potentially allocating too much space here,
1504 			 * but I'm lazy. This loop needs some work.
1505 			 */
1506 			cookies = malloc(ncookies * sizeof (off_t),
1507 			    M_TEMP, M_WAITOK);
1508 			*ap->a_cookies = cookies;
1509 		}
1510 		error = 0;
1511 		/* 0 ... 3 are static entries. */
1512 		for (; i <= 3 && uio->uio_resid >= UIO_MX; i++) {
1513 			switch (i) {
1514 			case 0:		/* `.' */
1515 			case 1:		/* `..' */
1516 				d.d_fileno = PROCFS_FILENO(0, PFSroot, -1);
1517 				d.d_namlen = i + 1;
1518 				memcpy(d.d_name, "..", d.d_namlen);
1519 				d.d_name[i + 1] = '\0';
1520 				d.d_type = DT_DIR;
1521 				break;
1522 
1523 			case 2:
1524 				d.d_fileno = PROCFS_FILENO(0, PFScurproc, -1);
1525 				d.d_namlen = sizeof("curproc") - 1;
1526 				memcpy(d.d_name, "curproc", sizeof("curproc"));
1527 				d.d_type = DT_LNK;
1528 				break;
1529 
1530 			case 3:
1531 				d.d_fileno = PROCFS_FILENO(0, PFSself, -1);
1532 				d.d_namlen = sizeof("self") - 1;
1533 				memcpy(d.d_name, "self", sizeof("self"));
1534 				d.d_type = DT_LNK;
1535 				break;
1536 			}
1537 
1538 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1539 				break;
1540 			nc++;
1541 			if (cookies)
1542 				*cookies++ = i + 1;
1543 		}
1544 		/* 4 ... are process entries. */
1545 		ctx.uiop = uio;
1546 		ctx.error = 0;
1547 		ctx.off = 4;
1548 		ctx.startoff = i;
1549 		ctx.cookies = cookies;
1550 		ctx.ncookies = nc;
1551 		proclist_foreach_call(&allproc,
1552 		    procfs_root_readdir_callback, &ctx);
1553 		cookies = ctx.cookies;
1554 		nc = ctx.ncookies;
1555 		error = ctx.error;
1556 		if (error)
1557 			break;
1558 
1559 		/* misc entries. */
1560 		if (i < ctx.off)
1561 			i = ctx.off;
1562 		if (i >= ctx.off + nproc_root_targets)
1563 			break;
1564 		for (pt = &proc_root_targets[i - ctx.off];
1565 		    uio->uio_resid >= UIO_MX &&
1566 		    pt < &proc_root_targets[nproc_root_targets];
1567 		    pt++, i++) {
1568 			if (pt->pt_valid &&
1569 			    (*pt->pt_valid)(NULL, vp->v_mount) == 0)
1570 				continue;
1571 			d.d_fileno = PROCFS_FILENO(0, pt->pt_pfstype, -1);
1572 			d.d_namlen = pt->pt_namlen;
1573 			memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1);
1574 			d.d_type = pt->pt_type;
1575 
1576 			if ((error = uiomove(&d, UIO_MX, uio)) != 0)
1577 				break;
1578 			nc++;
1579 			if (cookies)
1580 				*cookies++ = i + 1;
1581 		}
1582 
1583 		ncookies = nc;
1584 		break;
1585 	}
1586 
1587 	default:
1588 		error = ENOTDIR;
1589 		break;
1590 	}
1591 
1592 	if (ap->a_ncookies) {
1593 		if (error) {
1594 			if (cookies)
1595 				free(*ap->a_cookies, M_TEMP);
1596 			*ap->a_ncookies = 0;
1597 			*ap->a_cookies = NULL;
1598 		} else
1599 			*ap->a_ncookies = ncookies;
1600 	}
1601 	uio->uio_offset = i;
1602 	return (error);
1603 }
1604 
1605 /*
1606  * readlink reads the link of `curproc' and others
1607  */
1608 int
1609 procfs_readlink(void *v)
1610 {
1611 	struct vop_readlink_args *ap = v;
1612 	char bf[16];		/* should be enough */
1613 	char *bp = bf;
1614 	char *path = NULL;
1615 	int len = 0;
1616 	int error = 0;
1617 	struct pfsnode *pfs = VTOPFS(ap->a_vp);
1618 	struct proc *pown = NULL;
1619 
1620 	if (pfs->pfs_fileno == PROCFS_FILENO(0, PFScurproc, -1))
1621 		len = snprintf(bf, sizeof(bf), "%ld", (long)curproc->p_pid);
1622 	else if (pfs->pfs_fileno == PROCFS_FILENO(0, PFSself, -1))
1623 		len = snprintf(bf, sizeof(bf), "%s", "curproc");
1624 	else if (pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFStask, 0))
1625 		len = snprintf(bf, sizeof(bf), "..");
1626 	else if (pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFSexe, -1)) {
1627 		if ((error = procfs_proc_lock(pfs->pfs_pid, &pown, ESRCH)) != 0)
1628 			return error;
1629 		bp = pown->p_path;
1630 		len = strlen(bp);
1631 	} else if (pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFScwd, -1) ||
1632 	    pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFSchroot, -1)) {
1633 		if ((error = procfs_proc_lock(pfs->pfs_pid, &pown, ESRCH)) != 0)
1634 			return error;
1635 		path = malloc(MAXPATHLEN + 4, M_TEMP, M_WAITOK);
1636 		if (path == NULL) {
1637 			procfs_proc_unlock(pown);
1638 			return (ENOMEM);
1639 		}
1640 		bp = path + MAXPATHLEN;
1641 		*--bp = '\0';
1642 		procfs_dir(PROCFS_TYPE(pfs->pfs_fileno), curlwp, pown,
1643 		    &bp, path, MAXPATHLEN);
1644 		len = strlen(bp);
1645 	} else {
1646 		file_t *fp;
1647 		struct vnode *vxp, *vp;
1648 
1649 		if ((error = procfs_proc_lock(pfs->pfs_pid, &pown, ESRCH)) != 0)
1650 			return error;
1651 
1652 		fp = fd_getfile2(pown, pfs->pfs_fd);
1653 		if (fp == NULL) {
1654 			procfs_proc_unlock(pown);
1655 			return EBADF;
1656 		}
1657 
1658 		switch (fp->f_type) {
1659 		case DTYPE_VNODE:
1660 			vxp = fp->f_vnode;
1661 			if (vxp->v_type != VDIR) {
1662 				error = EINVAL;
1663 				break;
1664 			}
1665 			if ((path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK))
1666 			    == NULL) {
1667 				error = ENOMEM;
1668 				break;
1669 			}
1670 			bp = path + MAXPATHLEN;
1671 			*--bp = '\0';
1672 
1673 			/*
1674 			 * XXX: kludge to avoid locking against ourselves
1675 			 * in getcwd()
1676 			 */
1677 			if (vxp->v_tag == VT_PROCFS) {
1678 				*--bp = '/';
1679 			} else {
1680 				rw_enter(&curproc->p_cwdi->cwdi_lock,
1681 				    RW_READER);
1682 				vp = curproc->p_cwdi->cwdi_rdir;
1683 				if (vp == NULL)
1684 					vp = rootvnode;
1685 				error = getcwd_common(vxp, vp, &bp, path,
1686 				    MAXPATHLEN / 2, 0, curlwp);
1687 				rw_exit(&curproc->p_cwdi->cwdi_lock);
1688 			}
1689 			if (error)
1690 				break;
1691 			len = strlen(bp);
1692 			break;
1693 
1694 		case DTYPE_MISC:
1695 			len = snprintf(bf, sizeof(bf), "%s", "[misc]");
1696 			break;
1697 
1698 		case DTYPE_KQUEUE:
1699 			len = snprintf(bf, sizeof(bf), "%s", "[kqueue]");
1700 			break;
1701 
1702 		case DTYPE_SEM:
1703 			len = snprintf(bf, sizeof(bf), "%s", "[ksem]");
1704 			break;
1705 
1706 		default:
1707 			error = EINVAL;
1708 			break;
1709 		}
1710 		closef(fp);
1711 	}
1712 
1713 	if (error == 0)
1714 		error = uiomove(bp, len, ap->a_uio);
1715 	if (pown)
1716 		procfs_proc_unlock(pown);
1717 	if (path)
1718 		free(path, M_TEMP);
1719 	return error;
1720 }
1721 
1722 /*
1723  * convert decimal ascii to int
1724  */
1725 static int
1726 atoi(const char *b, size_t len)
1727 {
1728 	int p = 0;
1729 
1730 	while (len--) {
1731 		char c = *b++;
1732 		if (c < '0' || c > '9')
1733 			return -1;
1734 		p = 10 * p + (c - '0');
1735 	}
1736 
1737 	return p;
1738 }
1739