1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/time.h>
32 #include <sys/cred.h>
33 #include <sys/policy.h>
34 #include <sys/debug.h>
35 #include <sys/dirent.h>
36 #include <sys/errno.h>
37 #include <sys/file.h>
38 #include <sys/inline.h>
39 #include <sys/kmem.h>
40 #include <sys/pathname.h>
41 #include <sys/proc.h>
42 #include <sys/brand.h>
43 #include <sys/signal.h>
44 #include <sys/stat.h>
45 #include <sys/sysmacros.h>
46 #include <sys/systm.h>
47 #include <sys/zone.h>
48 #include <sys/uio.h>
49 #include <sys/var.h>
50 #include <sys/mode.h>
51 #include <sys/poll.h>
52 #include <sys/user.h>
53 #include <sys/vfs.h>
54 #include <sys/vfs_opreg.h>
55 #include <sys/gfs.h>
56 #include <sys/vnode.h>
57 #include <sys/fault.h>
58 #include <sys/syscall.h>
59 #include <sys/procfs.h>
60 #include <sys/atomic.h>
61 #include <sys/cmn_err.h>
62 #include <sys/contract_impl.h>
63 #include <sys/ctfs.h>
64 #include <sys/avl.h>
65 #include <fs/fs_subr.h>
66 #include <vm/rm.h>
67 #include <vm/as.h>
68 #include <vm/seg.h>
69 #include <vm/seg_vn.h>
70 #include <vm/hat.h>
71 #include <fs/proc/prdata.h>
72 #if defined(__sparc)
73 #include <sys/regset.h>
74 #endif
75 #if defined(__x86)
76 #include <sys/sysi86.h>
77 #endif
78
79 /*
80 * Created by prinit.
81 */
82 vnodeops_t *prvnodeops;
83
84 /*
85 * Directory characteristics (patterned after the s5 file system).
86 */
87 #define PRROOTINO 2
88
89 #define PRDIRSIZE 14
90 struct prdirect {
91 ushort_t d_ino;
92 char d_name[PRDIRSIZE];
93 };
94
95 #define PRSDSIZE (sizeof (struct prdirect))
96
97 /*
98 * Directory characteristics.
99 */
100 typedef struct prdirent {
101 ino64_t d_ino; /* "inode number" of entry */
102 off64_t d_off; /* offset of disk directory entry */
103 unsigned short d_reclen; /* length of this record */
104 char d_name[14]; /* name of file */
105 } prdirent_t;
106
107 /*
108 * Contents of a /proc/<pid> directory.
109 * Reuse d_ino field for the /proc file type.
110 */
111 static prdirent_t piddir[] = {
112 { PR_PIDDIR, 1 * sizeof (prdirent_t), sizeof (prdirent_t),
113 "." },
114 { PR_PROCDIR, 2 * sizeof (prdirent_t), sizeof (prdirent_t),
115 ".." },
116 { PR_AS, 3 * sizeof (prdirent_t), sizeof (prdirent_t),
117 "as" },
118 { PR_CTL, 4 * sizeof (prdirent_t), sizeof (prdirent_t),
119 "ctl" },
120 { PR_STATUS, 5 * sizeof (prdirent_t), sizeof (prdirent_t),
121 "status" },
122 { PR_LSTATUS, 6 * sizeof (prdirent_t), sizeof (prdirent_t),
123 "lstatus" },
124 { PR_PSINFO, 7 * sizeof (prdirent_t), sizeof (prdirent_t),
125 "psinfo" },
126 { PR_LPSINFO, 8 * sizeof (prdirent_t), sizeof (prdirent_t),
127 "lpsinfo" },
128 { PR_MAP, 9 * sizeof (prdirent_t), sizeof (prdirent_t),
129 "map" },
130 { PR_RMAP, 10 * sizeof (prdirent_t), sizeof (prdirent_t),
131 "rmap" },
132 { PR_XMAP, 11 * sizeof (prdirent_t), sizeof (prdirent_t),
133 "xmap" },
134 { PR_CRED, 12 * sizeof (prdirent_t), sizeof (prdirent_t),
135 "cred" },
136 { PR_SIGACT, 13 * sizeof (prdirent_t), sizeof (prdirent_t),
137 "sigact" },
138 { PR_AUXV, 14 * sizeof (prdirent_t), sizeof (prdirent_t),
139 "auxv" },
140 { PR_USAGE, 15 * sizeof (prdirent_t), sizeof (prdirent_t),
141 "usage" },
142 { PR_LUSAGE, 16 * sizeof (prdirent_t), sizeof (prdirent_t),
143 "lusage" },
144 { PR_PAGEDATA, 17 * sizeof (prdirent_t), sizeof (prdirent_t),
145 "pagedata" },
146 { PR_WATCH, 18 * sizeof (prdirent_t), sizeof (prdirent_t),
147 "watch" },
148 { PR_CURDIR, 19 * sizeof (prdirent_t), sizeof (prdirent_t),
149 "cwd" },
150 { PR_ROOTDIR, 20 * sizeof (prdirent_t), sizeof (prdirent_t),
151 "root" },
152 { PR_FDDIR, 21 * sizeof (prdirent_t), sizeof (prdirent_t),
153 "fd" },
154 { PR_OBJECTDIR, 22 * sizeof (prdirent_t), sizeof (prdirent_t),
155 "object" },
156 { PR_LWPDIR, 23 * sizeof (prdirent_t), sizeof (prdirent_t),
157 "lwp" },
158 { PR_PRIV, 24 * sizeof (prdirent_t), sizeof (prdirent_t),
159 "priv" },
160 { PR_PATHDIR, 25 * sizeof (prdirent_t), sizeof (prdirent_t),
161 "path" },
162 { PR_CTDIR, 26 * sizeof (prdirent_t), sizeof (prdirent_t),
163 "contracts" },
164 #if defined(__x86)
165 { PR_LDT, 27 * sizeof (prdirent_t), sizeof (prdirent_t),
166 "ldt" },
167 #endif
168 };
169
170 #define NPIDDIRFILES (sizeof (piddir) / sizeof (piddir[0]) - 2)
171
172 /*
173 * Contents of a /proc/<pid>/lwp/<lwpid> directory.
174 */
175 static prdirent_t lwpiddir[] = {
176 { PR_LWPIDDIR, 1 * sizeof (prdirent_t), sizeof (prdirent_t),
177 "." },
178 { PR_LWPDIR, 2 * sizeof (prdirent_t), sizeof (prdirent_t),
179 ".." },
180 { PR_LWPCTL, 3 * sizeof (prdirent_t), sizeof (prdirent_t),
181 "lwpctl" },
182 { PR_LWPSTATUS, 4 * sizeof (prdirent_t), sizeof (prdirent_t),
183 "lwpstatus" },
184 { PR_LWPSINFO, 5 * sizeof (prdirent_t), sizeof (prdirent_t),
185 "lwpsinfo" },
186 { PR_LWPUSAGE, 6 * sizeof (prdirent_t), sizeof (prdirent_t),
187 "lwpusage" },
188 { PR_XREGS, 7 * sizeof (prdirent_t), sizeof (prdirent_t),
189 "xregs" },
190 { PR_TMPLDIR, 8 * sizeof (prdirent_t), sizeof (prdirent_t),
191 "templates" },
192 #if defined(__sparc)
193 { PR_GWINDOWS, 9 * sizeof (prdirent_t), sizeof (prdirent_t),
194 "gwindows" },
195 { PR_ASRS, 10 * sizeof (prdirent_t), sizeof (prdirent_t),
196 "asrs" },
197 #endif
198 };
199
200 #define NLWPIDDIRFILES (sizeof (lwpiddir) / sizeof (lwpiddir[0]) - 2)
201
202 /*
203 * Span of entries in the array files (lstatus, lpsinfo, lusage).
204 * We make the span larger than the size of the structure on purpose,
205 * to make sure that programs cannot use the structure size by mistake.
206 * Align _ILP32 structures at 8 bytes, _LP64 structures at 16 bytes.
207 */
208 #ifdef _LP64
209 #define LSPAN(type) (round16(sizeof (type)) + 16)
210 #define LSPAN32(type) (round8(sizeof (type)) + 8)
211 #else
212 #define LSPAN(type) (round8(sizeof (type)) + 8)
213 #endif
214
215 static void rebuild_objdir(struct as *);
216 static void prfreecommon(prcommon_t *);
217 static int praccess(vnode_t *, int, int, cred_t *, caller_context_t *);
218
219 static int
220 propen(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
221 {
222 vnode_t *vp = *vpp;
223 prnode_t *pnp = VTOP(vp);
224 prcommon_t *pcp = pnp->pr_pcommon;
225 prnodetype_t type = pnp->pr_type;
226 vnode_t *rvp;
227 vtype_t vtype;
228 proc_t *p;
229 int error = 0;
230 prnode_t *npnp = NULL;
231
232 /*
233 * Nothing to do for the /proc directory itself.
234 */
235 if (type == PR_PROCDIR)
236 return (0);
237
238 /*
239 * If we are opening an underlying mapped object, reject opens
240 * for writing regardless of the objects's access modes.
241 * If we are opening a file in the /proc/pid/fd directory,
242 * reject the open for any but a regular file or directory.
243 * Just do it if we are opening the current or root directory.
244 */
245 switch (type) {
246 case PR_OBJECT:
247 case PR_FD:
248 case PR_CURDIR:
249 case PR_ROOTDIR:
250 rvp = pnp->pr_realvp;
251 vtype = rvp->v_type;
252 if ((type == PR_OBJECT && (flag & FWRITE)) ||
253 (type == PR_FD && vtype != VREG && vtype != VDIR))
254 error = EACCES;
255 else {
256 /*
257 * Need to hold rvp since VOP_OPEN() may release it.
258 */
259 VN_HOLD(rvp);
260 error = VOP_OPEN(&rvp, flag, cr, ct);
261 if (error) {
262 VN_RELE(rvp);
263 } else {
264 *vpp = rvp;
265 VN_RELE(vp);
266 }
267 }
268 return (error);
269 default:
270 break;
271 }
272
273 /*
274 * If we are opening the pagedata file, allocate a prnode now
275 * to avoid calling kmem_alloc() while holding p->p_lock.
276 */
277 if (type == PR_PAGEDATA || type == PR_OPAGEDATA)
278 npnp = prgetnode(vp, type);
279
280 /*
281 * If the process exists, lock it now.
282 * Otherwise we have a race condition with prclose().
283 */
284 p = pr_p_lock(pnp);
285 mutex_exit(&pr_pidlock);
286 if (p == NULL) {
287 if (npnp != NULL)
288 prfreenode(npnp);
289 return (ENOENT);
290 }
291 ASSERT(p == pcp->prc_proc);
292 ASSERT(p->p_proc_flag & P_PR_LOCK);
293
294 /*
295 * Maintain a count of opens for write. Allow exactly one
296 * O_WRITE|O_EXCL request and fail subsequent ones.
297 * Don't fail opens of old (bletch!) /proc lwp files.
298 * Special case for open by the process itself:
299 * Always allow the open by self and discount this
300 * open for other opens for writing.
301 */
302 if (flag & FWRITE) {
303 if (p == curproc) {
304 pcp->prc_selfopens++;
305 pnp->pr_flags |= PR_ISSELF;
306 } else if (type == PR_LWPIDFILE) {
307 /* EMPTY */;
308 } else if (flag & FEXCL) {
309 if (pcp->prc_writers > pcp->prc_selfopens) {
310 error = EBUSY;
311 goto out;
312 }
313 /* semantic for old /proc interface */
314 if (type == PR_PIDDIR)
315 pcp->prc_flags |= PRC_EXCL;
316 } else if (pcp->prc_flags & PRC_EXCL) {
317 ASSERT(pcp->prc_writers > pcp->prc_selfopens);
318 error = secpolicy_proc_excl_open(cr);
319 if (error)
320 goto out;
321 }
322 pcp->prc_writers++;
323 /*
324 * The vnode may have become invalid between the
325 * VOP_LOOKUP() of the /proc vnode and the VOP_OPEN().
326 * If so, do now what prinvalidate() should have done.
327 */
328 if ((pnp->pr_flags & PR_INVAL) ||
329 (type == PR_PIDDIR &&
330 (VTOP(pnp->pr_pidfile)->pr_flags & PR_INVAL))) {
331 if (p != curproc)
332 pcp->prc_selfopens++;
333 ASSERT(pcp->prc_selfopens <= pcp->prc_writers);
334 if (pcp->prc_selfopens == pcp->prc_writers)
335 pcp->prc_flags &= ~PRC_EXCL;
336 }
337 }
338
339 /*
340 * Do file-specific things.
341 */
342 switch (type) {
343 default:
344 break;
345 case PR_PAGEDATA:
346 case PR_OPAGEDATA:
347 /*
348 * Enable data collection for page data file;
349 * get unique id from the hat layer.
350 */
351 {
352 int id;
353
354 /*
355 * Drop p->p_lock to call hat_startstat()
356 */
357 mutex_exit(&p->p_lock);
358 if ((p->p_flag & SSYS) || p->p_as == &kas ||
359 (id = hat_startstat(p->p_as)) == -1) {
360 mutex_enter(&p->p_lock);
361 error = ENOMEM;
362 } else if (pnp->pr_hatid == 0) {
363 mutex_enter(&p->p_lock);
364 pnp->pr_hatid = (uint_t)id;
365 } else {
366 mutex_enter(&p->p_lock);
367 /*
368 * Use our newly allocated prnode.
369 */
370 npnp->pr_hatid = (uint_t)id;
371 /*
372 * prgetnode() initialized most of the prnode.
373 * Duplicate the remainder.
374 */
375 npnp->pr_ino = pnp->pr_ino;
376 npnp->pr_common = pnp->pr_common;
377 npnp->pr_pcommon = pnp->pr_pcommon;
378 npnp->pr_parent = pnp->pr_parent;
379 VN_HOLD(npnp->pr_parent);
380 npnp->pr_index = pnp->pr_index;
381
382 npnp->pr_next = p->p_plist;
383 p->p_plist = PTOV(npnp);
384
385 VN_RELE(PTOV(pnp));
386 pnp = npnp;
387 npnp = NULL;
388 *vpp = PTOV(pnp);
389 }
390 }
391 break;
392 }
393
394 out:
395 prunlock(pnp);
396
397 if (npnp != NULL)
398 prfreenode(npnp);
399 return (error);
400 }
401
402 /* ARGSUSED */
403 static int
404 prclose(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
405 caller_context_t *ct)
406 {
407 prnode_t *pnp = VTOP(vp);
408 prcommon_t *pcp = pnp->pr_pcommon;
409 prnodetype_t type = pnp->pr_type;
410 proc_t *p;
411 kthread_t *t;
412 user_t *up;
413
414 /*
415 * Nothing to do for the /proc directory itself.
416 */
417 if (type == PR_PROCDIR)
418 return (0);
419
420 ASSERT(type != PR_OBJECT && type != PR_FD &&
421 type != PR_CURDIR && type != PR_ROOTDIR);
422
423 /*
424 * If the process exists, lock it now.
425 * Otherwise we have a race condition with propen().
426 * Hold pr_pidlock across the reference to prc_selfopens,
427 * and prc_writers in case there is no process anymore,
428 * to cover the case of concurrent calls to prclose()
429 * after the process has been reaped by freeproc().
430 */
431 p = pr_p_lock(pnp);
432
433 /*
434 * There is nothing more to do until the last close of
435 * the file table entry except to clear the pr_owner
436 * field of the prnode and notify any waiters
437 * (their file descriptor may have just been closed).
438 */
439 if (count > 1) {
440 mutex_exit(&pr_pidlock);
441 if (pnp->pr_owner == curproc && !fisopen(vp))
442 pnp->pr_owner = NULL;
443 if (p != NULL) {
444 prnotify(vp);
445 prunlock(pnp);
446 }
447 return (0);
448 }
449
450 /*
451 * Decrement the count of self-opens for writing.
452 * Decrement the total count of opens for writing.
453 * Cancel exclusive opens when only self-opens remain.
454 */
455 if (flag & FWRITE) {
456 /*
457 * prc_selfopens also contains the count of
458 * invalid writers. See prinvalidate().
459 */
460 if ((pnp->pr_flags & (PR_ISSELF|PR_INVAL)) ||
461 (type == PR_PIDDIR &&
462 (VTOP(pnp->pr_pidfile)->pr_flags & PR_INVAL))) {
463 ASSERT(pcp->prc_selfopens != 0);
464 --pcp->prc_selfopens;
465 }
466 ASSERT(pcp->prc_writers != 0);
467 if (--pcp->prc_writers == pcp->prc_selfopens)
468 pcp->prc_flags &= ~PRC_EXCL;
469 }
470 ASSERT(pcp->prc_writers >= pcp->prc_selfopens);
471 mutex_exit(&pr_pidlock);
472 if (pnp->pr_owner == curproc && !fisopen(vp))
473 pnp->pr_owner = NULL;
474
475 /*
476 * If there is no process, there is nothing more to do.
477 */
478 if (p == NULL)
479 return (0);
480
481 ASSERT(p == pcp->prc_proc);
482 prnotify(vp); /* notify waiters */
483
484 /*
485 * Do file-specific things.
486 */
487 switch (type) {
488 default:
489 break;
490 case PR_PAGEDATA:
491 case PR_OPAGEDATA:
492 /*
493 * This is a page data file.
494 * Free the hat level statistics.
495 * Drop p->p_lock before calling hat_freestat().
496 */
497 mutex_exit(&p->p_lock);
498 if (p->p_as != &kas && pnp->pr_hatid != 0)
499 hat_freestat(p->p_as, pnp->pr_hatid);
500 mutex_enter(&p->p_lock);
501 pnp->pr_hatid = 0;
502 break;
503 }
504
505 /*
506 * On last close of all writable file descriptors,
507 * perform run-on-last-close and/or kill-on-last-close logic.
508 * Can't do this is the /proc agent lwp still exists.
509 */
510 if (pcp->prc_writers == 0 &&
511 p->p_agenttp == NULL &&
512 !(pcp->prc_flags & PRC_DESTROY) &&
513 p->p_stat != SZOMB &&
514 (p->p_proc_flag & (P_PR_RUNLCL|P_PR_KILLCL))) {
515 int killproc;
516
517 /*
518 * Cancel any watchpoints currently in effect.
519 * The process might disappear during this operation.
520 */
521 if (pr_cancel_watch(pnp) == NULL)
522 return (0);
523 /*
524 * If any tracing flags are set, clear them.
525 */
526 if (p->p_proc_flag & P_PR_TRACE) {
527 up = PTOU(p);
528 premptyset(&up->u_entrymask);
529 premptyset(&up->u_exitmask);
530 up->u_systrap = 0;
531 }
532 premptyset(&p->p_sigmask);
533 premptyset(&p->p_fltmask);
534 killproc = (p->p_proc_flag & P_PR_KILLCL);
535 p->p_proc_flag &= ~(P_PR_RUNLCL|P_PR_KILLCL|P_PR_TRACE);
536 /*
537 * Cancel any outstanding single-step requests.
538 */
539 if ((t = p->p_tlist) != NULL) {
540 /*
541 * Drop p_lock because prnostep() touches the stack.
542 * The loop is safe because the process is P_PR_LOCK'd.
543 */
544 mutex_exit(&p->p_lock);
545 do {
546 prnostep(ttolwp(t));
547 } while ((t = t->t_forw) != p->p_tlist);
548 mutex_enter(&p->p_lock);
549 }
550 /*
551 * Set runnable all lwps stopped by /proc.
552 */
553 if (killproc)
554 sigtoproc(p, NULL, SIGKILL);
555 else
556 allsetrun(p);
557 }
558
559 prunlock(pnp);
560 return (0);
561 }
562
563 /*
564 * Array of read functions, indexed by /proc file type.
565 */
566 static int pr_read_inval(), pr_read_as(), pr_read_status(),
567 pr_read_lstatus(), pr_read_psinfo(), pr_read_lpsinfo(),
568 pr_read_map(), pr_read_rmap(), pr_read_xmap(),
569 pr_read_cred(), pr_read_sigact(), pr_read_auxv(),
570 #if defined(__x86)
571 pr_read_ldt(),
572 #endif
573 pr_read_usage(), pr_read_lusage(), pr_read_pagedata(),
574 pr_read_watch(), pr_read_lwpstatus(), pr_read_lwpsinfo(),
575 pr_read_lwpusage(), pr_read_xregs(), pr_read_priv(),
576 #if defined(__sparc)
577 pr_read_gwindows(), pr_read_asrs(),
578 #endif
579 pr_read_piddir(), pr_read_pidfile(), pr_read_opagedata();
580
581 static int (*pr_read_function[PR_NFILES])() = {
582 pr_read_inval, /* /proc */
583 pr_read_inval, /* /proc/self */
584 pr_read_piddir, /* /proc/<pid> (old /proc read()) */
585 pr_read_as, /* /proc/<pid>/as */
586 pr_read_inval, /* /proc/<pid>/ctl */
587 pr_read_status, /* /proc/<pid>/status */
588 pr_read_lstatus, /* /proc/<pid>/lstatus */
589 pr_read_psinfo, /* /proc/<pid>/psinfo */
590 pr_read_lpsinfo, /* /proc/<pid>/lpsinfo */
591 pr_read_map, /* /proc/<pid>/map */
592 pr_read_rmap, /* /proc/<pid>/rmap */
593 pr_read_xmap, /* /proc/<pid>/xmap */
594 pr_read_cred, /* /proc/<pid>/cred */
595 pr_read_sigact, /* /proc/<pid>/sigact */
596 pr_read_auxv, /* /proc/<pid>/auxv */
597 #if defined(__x86)
598 pr_read_ldt, /* /proc/<pid>/ldt */
599 #endif
600 pr_read_usage, /* /proc/<pid>/usage */
601 pr_read_lusage, /* /proc/<pid>/lusage */
602 pr_read_pagedata, /* /proc/<pid>/pagedata */
603 pr_read_watch, /* /proc/<pid>/watch */
604 pr_read_inval, /* /proc/<pid>/cwd */
605 pr_read_inval, /* /proc/<pid>/root */
606 pr_read_inval, /* /proc/<pid>/fd */
607 pr_read_inval, /* /proc/<pid>/fd/nn */
608 pr_read_inval, /* /proc/<pid>/object */
609 pr_read_inval, /* /proc/<pid>/object/xxx */
610 pr_read_inval, /* /proc/<pid>/lwp */
611 pr_read_inval, /* /proc/<pid>/lwp/<lwpid> */
612 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
613 pr_read_lwpstatus, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
614 pr_read_lwpsinfo, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
615 pr_read_lwpusage, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
616 pr_read_xregs, /* /proc/<pid>/lwp/<lwpid>/xregs */
617 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/templates */
618 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
619 #if defined(__sparc)
620 pr_read_gwindows, /* /proc/<pid>/lwp/<lwpid>/gwindows */
621 pr_read_asrs, /* /proc/<pid>/lwp/<lwpid>/asrs */
622 #endif
623 pr_read_priv, /* /proc/<pid>/priv */
624 pr_read_inval, /* /proc/<pid>/path */
625 pr_read_inval, /* /proc/<pid>/path/xxx */
626 pr_read_inval, /* /proc/<pid>/contracts */
627 pr_read_inval, /* /proc/<pid>/contracts/<ctid> */
628 pr_read_pidfile, /* old process file */
629 pr_read_pidfile, /* old lwp file */
630 pr_read_opagedata, /* old pagedata file */
631 };
632
633 /* ARGSUSED */
634 static int
635 pr_read_inval(prnode_t *pnp, uio_t *uiop)
636 {
637 /*
638 * No read() on any /proc directory, use getdents(2) instead.
639 * Cannot read a control file either.
640 * An underlying mapped object file cannot get here.
641 */
642 return (EINVAL);
643 }
644
645 static int
646 pr_uioread(void *base, long count, uio_t *uiop)
647 {
648 int error = 0;
649
650 ASSERT(count >= 0);
651 count -= uiop->uio_offset;
652 if (count > 0 && uiop->uio_offset >= 0) {
653 error = uiomove((char *)base + uiop->uio_offset,
654 count, UIO_READ, uiop);
655 }
656
657 return (error);
658 }
659
660 static int
661 pr_read_as(prnode_t *pnp, uio_t *uiop)
662 {
663 int error;
664
665 ASSERT(pnp->pr_type == PR_AS);
666
667 if ((error = prlock(pnp, ZNO)) == 0) {
668 proc_t *p = pnp->pr_common->prc_proc;
669 struct as *as = p->p_as;
670
671 /*
672 * /proc I/O cannot be done to a system process.
673 * A 32-bit process cannot read a 64-bit process.
674 */
675 if ((p->p_flag & SSYS) || as == &kas) {
676 error = 0;
677 #ifdef _SYSCALL32_IMPL
678 } else if (curproc->p_model == DATAMODEL_ILP32 &&
679 PROCESS_NOT_32BIT(p)) {
680 error = EOVERFLOW;
681 #endif
682 } else {
683 /*
684 * We don't hold p_lock over an i/o operation because
685 * that could lead to deadlock with the clock thread.
686 */
687 mutex_exit(&p->p_lock);
688 error = prusrio(p, UIO_READ, uiop, 0);
689 mutex_enter(&p->p_lock);
690 }
691 prunlock(pnp);
692 }
693
694 return (error);
695 }
696
697 static int
698 pr_read_status(prnode_t *pnp, uio_t *uiop)
699 {
700 pstatus_t *sp;
701 int error;
702
703 ASSERT(pnp->pr_type == PR_STATUS);
704
705 /*
706 * We kmem_alloc() the pstatus structure because
707 * it is so big it might blow the kernel stack.
708 */
709 sp = kmem_alloc(sizeof (*sp), KM_SLEEP);
710 if ((error = prlock(pnp, ZNO)) == 0) {
711 prgetstatus(pnp->pr_common->prc_proc, sp, VTOZONE(PTOV(pnp)));
712 prunlock(pnp);
713 error = pr_uioread(sp, sizeof (*sp), uiop);
714 }
715 kmem_free(sp, sizeof (*sp));
716 return (error);
717 }
718
719 static int
720 pr_read_lstatus(prnode_t *pnp, uio_t *uiop)
721 {
722 proc_t *p;
723 kthread_t *t;
724 lwpdir_t *ldp;
725 size_t size;
726 prheader_t *php;
727 lwpstatus_t *sp;
728 int error;
729 int nlwp;
730 int i;
731
732 ASSERT(pnp->pr_type == PR_LSTATUS);
733
734 if ((error = prlock(pnp, ZNO)) != 0)
735 return (error);
736 p = pnp->pr_common->prc_proc;
737 nlwp = p->p_lwpcnt;
738 size = sizeof (prheader_t) + nlwp * LSPAN(lwpstatus_t);
739
740 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
741 mutex_exit(&p->p_lock);
742 php = kmem_zalloc(size, KM_SLEEP);
743 mutex_enter(&p->p_lock);
744 /* p->p_lwpcnt can't change while process is locked */
745 ASSERT(nlwp == p->p_lwpcnt);
746
747 php->pr_nent = nlwp;
748 php->pr_entsize = LSPAN(lwpstatus_t);
749
750 sp = (lwpstatus_t *)(php + 1);
751 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
752 if (ldp->ld_entry == NULL ||
753 (t = ldp->ld_entry->le_thread) == NULL)
754 continue;
755 prgetlwpstatus(t, sp, VTOZONE(PTOV(pnp)));
756 sp = (lwpstatus_t *)((caddr_t)sp + LSPAN(lwpstatus_t));
757 }
758 prunlock(pnp);
759
760 error = pr_uioread(php, size, uiop);
761 kmem_free(php, size);
762 return (error);
763 }
764
765 static int
766 pr_read_psinfo(prnode_t *pnp, uio_t *uiop)
767 {
768 psinfo_t psinfo;
769 proc_t *p;
770 int error = 0;
771
772 ASSERT(pnp->pr_type == PR_PSINFO);
773
774 /*
775 * We don't want the full treatment of prlock(pnp) here.
776 * This file is world-readable and never goes invalid.
777 * It doesn't matter if we are in the middle of an exec().
778 */
779 p = pr_p_lock(pnp);
780 mutex_exit(&pr_pidlock);
781 if (p == NULL)
782 error = ENOENT;
783 else {
784 ASSERT(p == pnp->pr_common->prc_proc);
785 prgetpsinfo(p, &psinfo);
786 prunlock(pnp);
787 error = pr_uioread(&psinfo, sizeof (psinfo), uiop);
788 }
789 return (error);
790 }
791
792 static int
793 pr_read_lpsinfo(prnode_t *pnp, uio_t *uiop)
794 {
795 proc_t *p;
796 kthread_t *t;
797 lwpdir_t *ldp;
798 lwpent_t *lep;
799 size_t size;
800 prheader_t *php;
801 lwpsinfo_t *sp;
802 int error;
803 int nlwp;
804 int i;
805
806 ASSERT(pnp->pr_type == PR_LPSINFO);
807
808 /*
809 * We don't want the full treatment of prlock(pnp) here.
810 * This file is world-readable and never goes invalid.
811 * It doesn't matter if we are in the middle of an exec().
812 */
813 p = pr_p_lock(pnp);
814 mutex_exit(&pr_pidlock);
815 if (p == NULL)
816 return (ENOENT);
817 ASSERT(p == pnp->pr_common->prc_proc);
818 if ((nlwp = p->p_lwpcnt + p->p_zombcnt) == 0) {
819 prunlock(pnp);
820 return (ENOENT);
821 }
822 size = sizeof (prheader_t) + nlwp * LSPAN(lwpsinfo_t);
823
824 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
825 mutex_exit(&p->p_lock);
826 php = kmem_zalloc(size, KM_SLEEP);
827 mutex_enter(&p->p_lock);
828 /* p->p_lwpcnt can't change while process is locked */
829 ASSERT(nlwp == p->p_lwpcnt + p->p_zombcnt);
830
831 php->pr_nent = nlwp;
832 php->pr_entsize = LSPAN(lwpsinfo_t);
833
834 sp = (lwpsinfo_t *)(php + 1);
835 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
836 if ((lep = ldp->ld_entry) == NULL)
837 continue;
838 if ((t = lep->le_thread) != NULL)
839 prgetlwpsinfo(t, sp);
840 else {
841 bzero(sp, sizeof (*sp));
842 sp->pr_lwpid = lep->le_lwpid;
843 sp->pr_state = SZOMB;
844 sp->pr_sname = 'Z';
845 sp->pr_start.tv_sec = lep->le_start;
846 sp->pr_bindpro = PBIND_NONE;
847 sp->pr_bindpset = PS_NONE;
848 }
849 sp = (lwpsinfo_t *)((caddr_t)sp + LSPAN(lwpsinfo_t));
850 }
851 prunlock(pnp);
852
853 error = pr_uioread(php, size, uiop);
854 kmem_free(php, size);
855 return (error);
856 }
857
858 static int
859 pr_read_map_common(prnode_t *pnp, uio_t *uiop, prnodetype_t type)
860 {
861 proc_t *p;
862 struct as *as;
863 list_t iolhead;
864 int error;
865
866 readmap_common:
867 if ((error = prlock(pnp, ZNO)) != 0)
868 return (error);
869
870 p = pnp->pr_common->prc_proc;
871 as = p->p_as;
872
873 if ((p->p_flag & SSYS) || as == &kas) {
874 prunlock(pnp);
875 return (0);
876 }
877
878 if (!AS_LOCK_TRYENTER(as, &as->a_lock, RW_WRITER)) {
879 prunlock(pnp);
880 delay(1);
881 goto readmap_common;
882 }
883 mutex_exit(&p->p_lock);
884
885 switch (type) {
886 case PR_XMAP:
887 error = prgetxmap(p, &iolhead);
888 break;
889 case PR_RMAP:
890 error = prgetmap(p, 1, &iolhead);
891 break;
892 case PR_MAP:
893 error = prgetmap(p, 0, &iolhead);
894 break;
895 }
896
897 AS_LOCK_EXIT(as, &as->a_lock);
898 mutex_enter(&p->p_lock);
899 prunlock(pnp);
900
901 error = pr_iol_uiomove_and_free(&iolhead, uiop, error);
902
903 return (error);
904 }
905
906 static int
907 pr_read_map(prnode_t *pnp, uio_t *uiop)
908 {
909 ASSERT(pnp->pr_type == PR_MAP);
910 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
911 }
912
913 static int
914 pr_read_rmap(prnode_t *pnp, uio_t *uiop)
915 {
916 ASSERT(pnp->pr_type == PR_RMAP);
917 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
918 }
919
920 static int
921 pr_read_xmap(prnode_t *pnp, uio_t *uiop)
922 {
923 ASSERT(pnp->pr_type == PR_XMAP);
924 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
925 }
926
927 static int
928 pr_read_cred(prnode_t *pnp, uio_t *uiop)
929 {
930 proc_t *p;
931 prcred_t *pcrp;
932 int error;
933 size_t count;
934
935 ASSERT(pnp->pr_type == PR_CRED);
936
937 /*
938 * We kmem_alloc() the prcred_t structure because
939 * the number of supplementary groups is variable.
940 */
941 pcrp =
942 kmem_alloc(sizeof (prcred_t) + sizeof (gid_t) * (ngroups_max - 1),
943 KM_SLEEP);
944
945 if ((error = prlock(pnp, ZNO)) != 0)
946 goto out;
947 p = pnp->pr_common->prc_proc;
948 ASSERT(p != NULL);
949
950 prgetcred(p, pcrp);
951 prunlock(pnp);
952
953 count = sizeof (prcred_t);
954 if (pcrp->pr_ngroups > 1)
955 count += sizeof (gid_t) * (pcrp->pr_ngroups - 1);
956 error = pr_uioread(pcrp, count, uiop);
957 out:
958 kmem_free(pcrp, sizeof (prcred_t) + sizeof (gid_t) * (ngroups_max - 1));
959 return (error);
960 }
961
962 static int
963 pr_read_priv(prnode_t *pnp, uio_t *uiop)
964 {
965 proc_t *p;
966 size_t psize = prgetprivsize();
967 prpriv_t *ppriv = kmem_alloc(psize, KM_SLEEP);
968 int error;
969
970 ASSERT(pnp->pr_type == PR_PRIV);
971
972 if ((error = prlock(pnp, ZNO)) != 0)
973 goto out;
974 p = pnp->pr_common->prc_proc;
975 ASSERT(p != NULL);
976
977 prgetpriv(p, ppriv);
978 prunlock(pnp);
979
980 error = pr_uioread(ppriv, psize, uiop);
981 out:
982 kmem_free(ppriv, psize);
983 return (error);
984 }
985
986 static int
987 pr_read_sigact(prnode_t *pnp, uio_t *uiop)
988 {
989 int nsig = PROC_IS_BRANDED(curproc)? BROP(curproc)->b_nsig : NSIG;
990 proc_t *p;
991 struct sigaction *sap;
992 int sig;
993 int error;
994 user_t *up;
995
996 ASSERT(pnp->pr_type == PR_SIGACT);
997
998 /*
999 * We kmem_alloc() the sigaction array because
1000 * it is so big it might blow the kernel stack.
1001 */
1002 sap = kmem_alloc((nsig-1) * sizeof (struct sigaction), KM_SLEEP);
1003
1004 if ((error = prlock(pnp, ZNO)) != 0)
1005 goto out;
1006 p = pnp->pr_common->prc_proc;
1007 ASSERT(p != NULL);
1008
1009 if (uiop->uio_offset >= (nsig-1)*sizeof (struct sigaction)) {
1010 prunlock(pnp);
1011 goto out;
1012 }
1013
1014 up = PTOU(p);
1015 for (sig = 1; sig < nsig; sig++)
1016 prgetaction(p, up, sig, &sap[sig-1]);
1017 prunlock(pnp);
1018
1019 error = pr_uioread(sap, (nsig - 1) * sizeof (struct sigaction), uiop);
1020 out:
1021 kmem_free(sap, (nsig-1) * sizeof (struct sigaction));
1022 return (error);
1023 }
1024
1025 static int
1026 pr_read_auxv(prnode_t *pnp, uio_t *uiop)
1027 {
1028 auxv_t auxv[__KERN_NAUXV_IMPL];
1029 proc_t *p;
1030 user_t *up;
1031 int error;
1032
1033 ASSERT(pnp->pr_type == PR_AUXV);
1034
1035 if ((error = prlock(pnp, ZNO)) != 0)
1036 return (error);
1037
1038 if (uiop->uio_offset >= sizeof (auxv)) {
1039 prunlock(pnp);
1040 return (0);
1041 }
1042
1043 p = pnp->pr_common->prc_proc;
1044 up = PTOU(p);
1045 bcopy(up->u_auxv, auxv, sizeof (auxv));
1046 prunlock(pnp);
1047
1048 return (pr_uioread(auxv, sizeof (auxv), uiop));
1049 }
1050
1051 #if defined(__x86)
1052 /*
1053 * XX64
1054 * This is almost certainly broken for the amd64 kernel, because
1055 * we have two kinds of LDT structures to export -- one for compatibility
1056 * mode, and one for long mode, sigh.
1057 *
1058 * For now lets just have a ldt of size 0 for 64-bit processes.
1059 */
1060 static int
1061 pr_read_ldt(prnode_t *pnp, uio_t *uiop)
1062 {
1063 proc_t *p;
1064 struct ssd *ssd;
1065 size_t size;
1066 int error;
1067
1068 ASSERT(pnp->pr_type == PR_LDT);
1069
1070 if ((error = prlock(pnp, ZNO)) != 0)
1071 return (error);
1072 p = pnp->pr_common->prc_proc;
1073
1074 mutex_exit(&p->p_lock);
1075 mutex_enter(&p->p_ldtlock);
1076 size = prnldt(p) * sizeof (struct ssd);
1077 if (uiop->uio_offset >= size) {
1078 mutex_exit(&p->p_ldtlock);
1079 mutex_enter(&p->p_lock);
1080 prunlock(pnp);
1081 return (0);
1082 }
1083
1084 ssd = kmem_alloc(size, KM_SLEEP);
1085 prgetldt(p, ssd);
1086 mutex_exit(&p->p_ldtlock);
1087 mutex_enter(&p->p_lock);
1088 prunlock(pnp);
1089
1090 error = pr_uioread(ssd, size, uiop);
1091 kmem_free(ssd, size);
1092 return (error);
1093 }
1094 #endif /* __x86 */
1095
1096 static int
1097 pr_read_usage(prnode_t *pnp, uio_t *uiop)
1098 {
1099 prhusage_t *pup;
1100 prusage_t *upup;
1101 proc_t *p;
1102 kthread_t *t;
1103 int error;
1104
1105 ASSERT(pnp->pr_type == PR_USAGE);
1106
1107 /* allocate now, before locking the process */
1108 pup = kmem_zalloc(sizeof (*pup), KM_SLEEP);
1109 upup = kmem_alloc(sizeof (*upup), KM_SLEEP);
1110
1111 /*
1112 * We don't want the full treatment of prlock(pnp) here.
1113 * This file is world-readable and never goes invalid.
1114 * It doesn't matter if we are in the middle of an exec().
1115 */
1116 p = pr_p_lock(pnp);
1117 mutex_exit(&pr_pidlock);
1118 if (p == NULL) {
1119 error = ENOENT;
1120 goto out;
1121 }
1122 ASSERT(p == pnp->pr_common->prc_proc);
1123
1124 if (uiop->uio_offset >= sizeof (prusage_t)) {
1125 prunlock(pnp);
1126 error = 0;
1127 goto out;
1128 }
1129
1130 pup->pr_tstamp = gethrtime();
1131
1132 pup->pr_count = p->p_defunct;
1133 pup->pr_create = p->p_mstart;
1134 pup->pr_term = p->p_mterm;
1135
1136 pup->pr_rtime = p->p_mlreal;
1137 pup->pr_utime = p->p_acct[LMS_USER];
1138 pup->pr_stime = p->p_acct[LMS_SYSTEM];
1139 pup->pr_ttime = p->p_acct[LMS_TRAP];
1140 pup->pr_tftime = p->p_acct[LMS_TFAULT];
1141 pup->pr_dftime = p->p_acct[LMS_DFAULT];
1142 pup->pr_kftime = p->p_acct[LMS_KFAULT];
1143 pup->pr_ltime = p->p_acct[LMS_USER_LOCK];
1144 pup->pr_slptime = p->p_acct[LMS_SLEEP];
1145 pup->pr_wtime = p->p_acct[LMS_WAIT_CPU];
1146 pup->pr_stoptime = p->p_acct[LMS_STOPPED];
1147
1148 pup->pr_minf = p->p_ru.minflt;
1149 pup->pr_majf = p->p_ru.majflt;
1150 pup->pr_nswap = p->p_ru.nswap;
1151 pup->pr_inblk = p->p_ru.inblock;
1152 pup->pr_oublk = p->p_ru.oublock;
1153 pup->pr_msnd = p->p_ru.msgsnd;
1154 pup->pr_mrcv = p->p_ru.msgrcv;
1155 pup->pr_sigs = p->p_ru.nsignals;
1156 pup->pr_vctx = p->p_ru.nvcsw;
1157 pup->pr_ictx = p->p_ru.nivcsw;
1158 pup->pr_sysc = p->p_ru.sysc;
1159 pup->pr_ioch = p->p_ru.ioch;
1160
1161 /*
1162 * Add the usage information for each active lwp.
1163 */
1164 if ((t = p->p_tlist) != NULL &&
1165 !(pnp->pr_pcommon->prc_flags & PRC_DESTROY)) {
1166 do {
1167 if (t->t_proc_flag & TP_LWPEXIT)
1168 continue;
1169 pup->pr_count++;
1170 praddusage(t, pup);
1171 } while ((t = t->t_forw) != p->p_tlist);
1172 }
1173
1174 prunlock(pnp);
1175
1176 prcvtusage(pup, upup);
1177
1178 error = pr_uioread(upup, sizeof (prusage_t), uiop);
1179 out:
1180 kmem_free(pup, sizeof (*pup));
1181 kmem_free(upup, sizeof (*upup));
1182 return (error);
1183 }
1184
1185 static int
1186 pr_read_lusage(prnode_t *pnp, uio_t *uiop)
1187 {
1188 int nlwp;
1189 prhusage_t *pup;
1190 prheader_t *php;
1191 prusage_t *upup;
1192 size_t size;
1193 hrtime_t curtime;
1194 proc_t *p;
1195 kthread_t *t;
1196 lwpdir_t *ldp;
1197 int error;
1198 int i;
1199
1200 ASSERT(pnp->pr_type == PR_LUSAGE);
1201
1202 /*
1203 * We don't want the full treatment of prlock(pnp) here.
1204 * This file is world-readable and never goes invalid.
1205 * It doesn't matter if we are in the middle of an exec().
1206 */
1207 p = pr_p_lock(pnp);
1208 mutex_exit(&pr_pidlock);
1209 if (p == NULL)
1210 return (ENOENT);
1211 ASSERT(p == pnp->pr_common->prc_proc);
1212 if ((nlwp = p->p_lwpcnt) == 0) {
1213 prunlock(pnp);
1214 return (ENOENT);
1215 }
1216
1217 size = sizeof (prheader_t) + (nlwp + 1) * LSPAN(prusage_t);
1218 if (uiop->uio_offset >= size) {
1219 prunlock(pnp);
1220 return (0);
1221 }
1222
1223 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1224 mutex_exit(&p->p_lock);
1225 pup = kmem_zalloc(size + sizeof (prhusage_t), KM_SLEEP);
1226 mutex_enter(&p->p_lock);
1227 /* p->p_lwpcnt can't change while process is locked */
1228 ASSERT(nlwp == p->p_lwpcnt);
1229
1230 php = (prheader_t *)(pup + 1);
1231 upup = (prusage_t *)(php + 1);
1232
1233 php->pr_nent = nlwp + 1;
1234 php->pr_entsize = LSPAN(prusage_t);
1235
1236 curtime = gethrtime();
1237
1238 /*
1239 * First the summation over defunct lwps.
1240 */
1241 pup->pr_count = p->p_defunct;
1242 pup->pr_tstamp = curtime;
1243 pup->pr_create = p->p_mstart;
1244 pup->pr_term = p->p_mterm;
1245
1246 pup->pr_rtime = p->p_mlreal;
1247 pup->pr_utime = p->p_acct[LMS_USER];
1248 pup->pr_stime = p->p_acct[LMS_SYSTEM];
1249 pup->pr_ttime = p->p_acct[LMS_TRAP];
1250 pup->pr_tftime = p->p_acct[LMS_TFAULT];
1251 pup->pr_dftime = p->p_acct[LMS_DFAULT];
1252 pup->pr_kftime = p->p_acct[LMS_KFAULT];
1253 pup->pr_ltime = p->p_acct[LMS_USER_LOCK];
1254 pup->pr_slptime = p->p_acct[LMS_SLEEP];
1255 pup->pr_wtime = p->p_acct[LMS_WAIT_CPU];
1256 pup->pr_stoptime = p->p_acct[LMS_STOPPED];
1257
1258 pup->pr_minf = p->p_ru.minflt;
1259 pup->pr_majf = p->p_ru.majflt;
1260 pup->pr_nswap = p->p_ru.nswap;
1261 pup->pr_inblk = p->p_ru.inblock;
1262 pup->pr_oublk = p->p_ru.oublock;
1263 pup->pr_msnd = p->p_ru.msgsnd;
1264 pup->pr_mrcv = p->p_ru.msgrcv;
1265 pup->pr_sigs = p->p_ru.nsignals;
1266 pup->pr_vctx = p->p_ru.nvcsw;
1267 pup->pr_ictx = p->p_ru.nivcsw;
1268 pup->pr_sysc = p->p_ru.sysc;
1269 pup->pr_ioch = p->p_ru.ioch;
1270
1271 prcvtusage(pup, upup);
1272
1273 /*
1274 * Fill one prusage struct for each active lwp.
1275 */
1276 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
1277 if (ldp->ld_entry == NULL ||
1278 (t = ldp->ld_entry->le_thread) == NULL)
1279 continue;
1280 ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
1281 ASSERT(nlwp > 0);
1282 --nlwp;
1283 upup = (prusage_t *)((caddr_t)upup + LSPAN(prusage_t));
1284 prgetusage(t, pup);
1285 prcvtusage(pup, upup);
1286 }
1287 ASSERT(nlwp == 0);
1288
1289 prunlock(pnp);
1290
1291 error = pr_uioread(php, size, uiop);
1292 kmem_free(pup, size + sizeof (prhusage_t));
1293 return (error);
1294 }
1295
1296 static int
1297 pr_read_pagedata(prnode_t *pnp, uio_t *uiop)
1298 {
1299 proc_t *p;
1300 int error;
1301
1302 ASSERT(pnp->pr_type == PR_PAGEDATA);
1303
1304 if ((error = prlock(pnp, ZNO)) != 0)
1305 return (error);
1306
1307 p = pnp->pr_common->prc_proc;
1308 if ((p->p_flag & SSYS) || p->p_as == &kas) {
1309 prunlock(pnp);
1310 return (0);
1311 }
1312
1313 mutex_exit(&p->p_lock);
1314 error = prpdread(p, pnp->pr_hatid, uiop);
1315 mutex_enter(&p->p_lock);
1316
1317 prunlock(pnp);
1318 return (error);
1319 }
1320
1321 static int
1322 pr_read_opagedata(prnode_t *pnp, uio_t *uiop)
1323 {
1324 proc_t *p;
1325 struct as *as;
1326 int error;
1327
1328 ASSERT(pnp->pr_type == PR_OPAGEDATA);
1329
1330 if ((error = prlock(pnp, ZNO)) != 0)
1331 return (error);
1332
1333 p = pnp->pr_common->prc_proc;
1334 as = p->p_as;
1335 if ((p->p_flag & SSYS) || as == &kas) {
1336 prunlock(pnp);
1337 return (0);
1338 }
1339
1340 mutex_exit(&p->p_lock);
1341 error = oprpdread(as, pnp->pr_hatid, uiop);
1342 mutex_enter(&p->p_lock);
1343
1344 prunlock(pnp);
1345 return (error);
1346 }
1347
1348 static int
1349 pr_read_watch(prnode_t *pnp, uio_t *uiop)
1350 {
1351 proc_t *p;
1352 int error;
1353 prwatch_t *Bpwp;
1354 size_t size;
1355 prwatch_t *pwp;
1356 int nwarea;
1357 struct watched_area *pwarea;
1358
1359 ASSERT(pnp->pr_type == PR_WATCH);
1360
1361 if ((error = prlock(pnp, ZNO)) != 0)
1362 return (error);
1363
1364 p = pnp->pr_common->prc_proc;
1365 nwarea = avl_numnodes(&p->p_warea);
1366 size = nwarea * sizeof (prwatch_t);
1367 if (uiop->uio_offset >= size) {
1368 prunlock(pnp);
1369 return (0);
1370 }
1371
1372 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1373 mutex_exit(&p->p_lock);
1374 Bpwp = pwp = kmem_zalloc(size, KM_SLEEP);
1375 mutex_enter(&p->p_lock);
1376 /* p->p_nwarea can't change while process is locked */
1377 ASSERT(nwarea == avl_numnodes(&p->p_warea));
1378
1379 /* gather the watched areas */
1380 for (pwarea = avl_first(&p->p_warea); pwarea != NULL;
1381 pwarea = AVL_NEXT(&p->p_warea, pwarea), pwp++) {
1382 pwp->pr_vaddr = (uintptr_t)pwarea->wa_vaddr;
1383 pwp->pr_size = pwarea->wa_eaddr - pwarea->wa_vaddr;
1384 pwp->pr_wflags = (int)pwarea->wa_flags;
1385 }
1386
1387 prunlock(pnp);
1388
1389 error = pr_uioread(Bpwp, size, uiop);
1390 kmem_free(Bpwp, size);
1391 return (error);
1392 }
1393
1394 static int
1395 pr_read_lwpstatus(prnode_t *pnp, uio_t *uiop)
1396 {
1397 lwpstatus_t *sp;
1398 int error;
1399
1400 ASSERT(pnp->pr_type == PR_LWPSTATUS);
1401
1402 /*
1403 * We kmem_alloc() the lwpstatus structure because
1404 * it is so big it might blow the kernel stack.
1405 */
1406 sp = kmem_alloc(sizeof (*sp), KM_SLEEP);
1407
1408 if ((error = prlock(pnp, ZNO)) != 0)
1409 goto out;
1410
1411 if (uiop->uio_offset >= sizeof (*sp)) {
1412 prunlock(pnp);
1413 goto out;
1414 }
1415
1416 prgetlwpstatus(pnp->pr_common->prc_thread, sp, VTOZONE(PTOV(pnp)));
1417 prunlock(pnp);
1418
1419 error = pr_uioread(sp, sizeof (*sp), uiop);
1420 out:
1421 kmem_free(sp, sizeof (*sp));
1422 return (error);
1423 }
1424
1425 static int
1426 pr_read_lwpsinfo(prnode_t *pnp, uio_t *uiop)
1427 {
1428 lwpsinfo_t lwpsinfo;
1429 proc_t *p;
1430 kthread_t *t;
1431 lwpent_t *lep;
1432
1433 ASSERT(pnp->pr_type == PR_LWPSINFO);
1434
1435 /*
1436 * We don't want the full treatment of prlock(pnp) here.
1437 * This file is world-readable and never goes invalid.
1438 * It doesn't matter if we are in the middle of an exec().
1439 */
1440 p = pr_p_lock(pnp);
1441 mutex_exit(&pr_pidlock);
1442 if (p == NULL)
1443 return (ENOENT);
1444 ASSERT(p == pnp->pr_common->prc_proc);
1445 if (pnp->pr_common->prc_tslot == -1) {
1446 prunlock(pnp);
1447 return (ENOENT);
1448 }
1449
1450 if (uiop->uio_offset >= sizeof (lwpsinfo)) {
1451 prunlock(pnp);
1452 return (0);
1453 }
1454
1455 if ((t = pnp->pr_common->prc_thread) != NULL)
1456 prgetlwpsinfo(t, &lwpsinfo);
1457 else {
1458 lep = p->p_lwpdir[pnp->pr_common->prc_tslot].ld_entry;
1459 bzero(&lwpsinfo, sizeof (lwpsinfo));
1460 lwpsinfo.pr_lwpid = lep->le_lwpid;
1461 lwpsinfo.pr_state = SZOMB;
1462 lwpsinfo.pr_sname = 'Z';
1463 lwpsinfo.pr_start.tv_sec = lep->le_start;
1464 lwpsinfo.pr_bindpro = PBIND_NONE;
1465 lwpsinfo.pr_bindpset = PS_NONE;
1466 }
1467 prunlock(pnp);
1468
1469 return (pr_uioread(&lwpsinfo, sizeof (lwpsinfo), uiop));
1470 }
1471
1472 static int
1473 pr_read_lwpusage(prnode_t *pnp, uio_t *uiop)
1474 {
1475 prhusage_t *pup;
1476 prusage_t *upup;
1477 proc_t *p;
1478 int error;
1479
1480 ASSERT(pnp->pr_type == PR_LWPUSAGE);
1481
1482 /* allocate now, before locking the process */
1483 pup = kmem_zalloc(sizeof (*pup), KM_SLEEP);
1484 upup = kmem_alloc(sizeof (*upup), KM_SLEEP);
1485
1486 /*
1487 * We don't want the full treatment of prlock(pnp) here.
1488 * This file is world-readable and never goes invalid.
1489 * It doesn't matter if we are in the middle of an exec().
1490 */
1491 p = pr_p_lock(pnp);
1492 mutex_exit(&pr_pidlock);
1493 if (p == NULL) {
1494 error = ENOENT;
1495 goto out;
1496 }
1497 ASSERT(p == pnp->pr_common->prc_proc);
1498 if (pnp->pr_common->prc_thread == NULL) {
1499 prunlock(pnp);
1500 error = ENOENT;
1501 goto out;
1502 }
1503 if (uiop->uio_offset >= sizeof (prusage_t)) {
1504 prunlock(pnp);
1505 error = 0;
1506 goto out;
1507 }
1508
1509 pup->pr_tstamp = gethrtime();
1510 prgetusage(pnp->pr_common->prc_thread, pup);
1511
1512 prunlock(pnp);
1513
1514 prcvtusage(pup, upup);
1515
1516 error = pr_uioread(upup, sizeof (prusage_t), uiop);
1517 out:
1518 kmem_free(pup, sizeof (*pup));
1519 kmem_free(upup, sizeof (*upup));
1520 return (error);
1521 }
1522
1523 /* ARGSUSED */
1524 static int
1525 pr_read_xregs(prnode_t *pnp, uio_t *uiop)
1526 {
1527 #if defined(__sparc)
1528 proc_t *p;
1529 kthread_t *t;
1530 int error;
1531 char *xreg;
1532 size_t size;
1533
1534 ASSERT(pnp->pr_type == PR_XREGS);
1535
1536 xreg = kmem_zalloc(sizeof (prxregset_t), KM_SLEEP);
1537
1538 if ((error = prlock(pnp, ZNO)) != 0)
1539 goto out;
1540
1541 p = pnp->pr_common->prc_proc;
1542 t = pnp->pr_common->prc_thread;
1543
1544 size = prhasx(p)? prgetprxregsize(p) : 0;
1545 if (uiop->uio_offset >= size) {
1546 prunlock(pnp);
1547 goto out;
1548 }
1549
1550 /* drop p->p_lock while (possibly) touching the stack */
1551 mutex_exit(&p->p_lock);
1552 prgetprxregs(ttolwp(t), xreg);
1553 mutex_enter(&p->p_lock);
1554 prunlock(pnp);
1555
1556 error = pr_uioread(xreg, size, uiop);
1557 out:
1558 kmem_free(xreg, sizeof (prxregset_t));
1559 return (error);
1560 #else
1561 return (0);
1562 #endif
1563 }
1564
1565 #if defined(__sparc)
1566
1567 static int
1568 pr_read_gwindows(prnode_t *pnp, uio_t *uiop)
1569 {
1570 proc_t *p;
1571 kthread_t *t;
1572 gwindows_t *gwp;
1573 int error;
1574 size_t size;
1575
1576 ASSERT(pnp->pr_type == PR_GWINDOWS);
1577
1578 gwp = kmem_zalloc(sizeof (gwindows_t), KM_SLEEP);
1579
1580 if ((error = prlock(pnp, ZNO)) != 0)
1581 goto out;
1582
1583 p = pnp->pr_common->prc_proc;
1584 t = pnp->pr_common->prc_thread;
1585
1586 /*
1587 * Drop p->p_lock while touching the stack.
1588 * The P_PR_LOCK flag prevents the lwp from
1589 * disappearing while we do this.
1590 */
1591 mutex_exit(&p->p_lock);
1592 if ((size = prnwindows(ttolwp(t))) != 0)
1593 size = sizeof (gwindows_t) -
1594 (SPARC_MAXREGWINDOW - size) * sizeof (struct rwindow);
1595 if (uiop->uio_offset >= size) {
1596 mutex_enter(&p->p_lock);
1597 prunlock(pnp);
1598 goto out;
1599 }
1600 prgetwindows(ttolwp(t), gwp);
1601 mutex_enter(&p->p_lock);
1602 prunlock(pnp);
1603
1604 error = pr_uioread(gwp, size, uiop);
1605 out:
1606 kmem_free(gwp, sizeof (gwindows_t));
1607 return (error);
1608 }
1609
1610 /* ARGSUSED */
1611 static int
1612 pr_read_asrs(prnode_t *pnp, uio_t *uiop)
1613 {
1614 int error;
1615
1616 ASSERT(pnp->pr_type == PR_ASRS);
1617
1618 /* the asrs file exists only for sparc v9 _LP64 processes */
1619 if ((error = prlock(pnp, ZNO)) == 0) {
1620 proc_t *p = pnp->pr_common->prc_proc;
1621 kthread_t *t = pnp->pr_common->prc_thread;
1622 asrset_t asrset;
1623
1624 if (p->p_model != DATAMODEL_LP64 ||
1625 uiop->uio_offset >= sizeof (asrset_t)) {
1626 prunlock(pnp);
1627 return (0);
1628 }
1629
1630 /*
1631 * Drop p->p_lock while touching the stack.
1632 * The P_PR_LOCK flag prevents the lwp from
1633 * disappearing while we do this.
1634 */
1635 mutex_exit(&p->p_lock);
1636 prgetasregs(ttolwp(t), asrset);
1637 mutex_enter(&p->p_lock);
1638 prunlock(pnp);
1639
1640 error = pr_uioread(&asrset[0], sizeof (asrset_t), uiop);
1641 }
1642
1643 return (error);
1644 }
1645
1646 #endif /* __sparc */
1647
1648 static int
1649 pr_read_piddir(prnode_t *pnp, uio_t *uiop)
1650 {
1651 ASSERT(pnp->pr_type == PR_PIDDIR);
1652 ASSERT(pnp->pr_pidfile != NULL);
1653
1654 /* use the underlying PR_PIDFILE to read the process */
1655 pnp = VTOP(pnp->pr_pidfile);
1656 ASSERT(pnp->pr_type == PR_PIDFILE);
1657
1658 return (pr_read_pidfile(pnp, uiop));
1659 }
1660
1661 static int
1662 pr_read_pidfile(prnode_t *pnp, uio_t *uiop)
1663 {
1664 int error;
1665
1666 ASSERT(pnp->pr_type == PR_PIDFILE || pnp->pr_type == PR_LWPIDFILE);
1667
1668 if ((error = prlock(pnp, ZNO)) == 0) {
1669 proc_t *p = pnp->pr_common->prc_proc;
1670 struct as *as = p->p_as;
1671
1672 if ((p->p_flag & SSYS) || as == &kas) {
1673 /*
1674 * /proc I/O cannot be done to a system process.
1675 */
1676 error = EIO; /* old /proc semantics */
1677 } else {
1678 /*
1679 * We drop p_lock because we don't want to hold
1680 * it over an I/O operation because that could
1681 * lead to deadlock with the clock thread.
1682 * The process will not disappear and its address
1683 * space will not change because it is marked P_PR_LOCK.
1684 */
1685 mutex_exit(&p->p_lock);
1686 error = prusrio(p, UIO_READ, uiop, 1);
1687 mutex_enter(&p->p_lock);
1688 }
1689 prunlock(pnp);
1690 }
1691
1692 return (error);
1693 }
1694
1695 #ifdef _SYSCALL32_IMPL
1696
1697 /*
1698 * Array of ILP32 read functions, indexed by /proc file type.
1699 */
1700 static int pr_read_status_32(),
1701 pr_read_lstatus_32(), pr_read_psinfo_32(), pr_read_lpsinfo_32(),
1702 pr_read_map_32(), pr_read_rmap_32(), pr_read_xmap_32(),
1703 pr_read_sigact_32(), pr_read_auxv_32(),
1704 pr_read_usage_32(), pr_read_lusage_32(), pr_read_pagedata_32(),
1705 pr_read_watch_32(), pr_read_lwpstatus_32(), pr_read_lwpsinfo_32(),
1706 pr_read_lwpusage_32(),
1707 #if defined(__sparc)
1708 pr_read_gwindows_32(),
1709 #endif
1710 pr_read_opagedata_32();
1711
1712 static int (*pr_read_function_32[PR_NFILES])() = {
1713 pr_read_inval, /* /proc */
1714 pr_read_inval, /* /proc/self */
1715 pr_read_piddir, /* /proc/<pid> (old /proc read()) */
1716 pr_read_as, /* /proc/<pid>/as */
1717 pr_read_inval, /* /proc/<pid>/ctl */
1718 pr_read_status_32, /* /proc/<pid>/status */
1719 pr_read_lstatus_32, /* /proc/<pid>/lstatus */
1720 pr_read_psinfo_32, /* /proc/<pid>/psinfo */
1721 pr_read_lpsinfo_32, /* /proc/<pid>/lpsinfo */
1722 pr_read_map_32, /* /proc/<pid>/map */
1723 pr_read_rmap_32, /* /proc/<pid>/rmap */
1724 pr_read_xmap_32, /* /proc/<pid>/xmap */
1725 pr_read_cred, /* /proc/<pid>/cred */
1726 pr_read_sigact_32, /* /proc/<pid>/sigact */
1727 pr_read_auxv_32, /* /proc/<pid>/auxv */
1728 #if defined(__x86)
1729 pr_read_ldt, /* /proc/<pid>/ldt */
1730 #endif
1731 pr_read_usage_32, /* /proc/<pid>/usage */
1732 pr_read_lusage_32, /* /proc/<pid>/lusage */
1733 pr_read_pagedata_32, /* /proc/<pid>/pagedata */
1734 pr_read_watch_32, /* /proc/<pid>/watch */
1735 pr_read_inval, /* /proc/<pid>/cwd */
1736 pr_read_inval, /* /proc/<pid>/root */
1737 pr_read_inval, /* /proc/<pid>/fd */
1738 pr_read_inval, /* /proc/<pid>/fd/nn */
1739 pr_read_inval, /* /proc/<pid>/object */
1740 pr_read_inval, /* /proc/<pid>/object/xxx */
1741 pr_read_inval, /* /proc/<pid>/lwp */
1742 pr_read_inval, /* /proc/<pid>/lwp/<lwpid> */
1743 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
1744 pr_read_lwpstatus_32, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
1745 pr_read_lwpsinfo_32, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
1746 pr_read_lwpusage_32, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
1747 pr_read_xregs, /* /proc/<pid>/lwp/<lwpid>/xregs */
1748 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/templates */
1749 pr_read_inval, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
1750 #if defined(__sparc)
1751 pr_read_gwindows_32, /* /proc/<pid>/lwp/<lwpid>/gwindows */
1752 pr_read_asrs, /* /proc/<pid>/lwp/<lwpid>/asrs */
1753 #endif
1754 pr_read_priv, /* /proc/<pid>/priv */
1755 pr_read_inval, /* /proc/<pid>/path */
1756 pr_read_inval, /* /proc/<pid>/path/xxx */
1757 pr_read_inval, /* /proc/<pid>/contracts */
1758 pr_read_inval, /* /proc/<pid>/contracts/<ctid> */
1759 pr_read_pidfile, /* old process file */
1760 pr_read_pidfile, /* old lwp file */
1761 pr_read_opagedata_32, /* old pagedata file */
1762 };
1763
1764 static int
1765 pr_read_status_32(prnode_t *pnp, uio_t *uiop)
1766 {
1767 pstatus32_t *sp;
1768 proc_t *p;
1769 int error;
1770
1771 ASSERT(pnp->pr_type == PR_STATUS);
1772
1773 /*
1774 * We kmem_alloc() the pstatus structure because
1775 * it is so big it might blow the kernel stack.
1776 */
1777 sp = kmem_alloc(sizeof (*sp), KM_SLEEP);
1778 if ((error = prlock(pnp, ZNO)) == 0) {
1779 /*
1780 * A 32-bit process cannot get the status of a 64-bit process.
1781 * The fields for the 64-bit quantities are not large enough.
1782 */
1783 p = pnp->pr_common->prc_proc;
1784 if (PROCESS_NOT_32BIT(p)) {
1785 prunlock(pnp);
1786 error = EOVERFLOW;
1787 } else {
1788 prgetstatus32(pnp->pr_common->prc_proc, sp,
1789 VTOZONE(PTOV(pnp)));
1790 prunlock(pnp);
1791 error = pr_uioread(sp, sizeof (*sp), uiop);
1792 }
1793 }
1794 kmem_free((caddr_t)sp, sizeof (*sp));
1795 return (error);
1796 }
1797
1798 static int
1799 pr_read_lstatus_32(prnode_t *pnp, uio_t *uiop)
1800 {
1801 proc_t *p;
1802 kthread_t *t;
1803 lwpdir_t *ldp;
1804 size_t size;
1805 prheader32_t *php;
1806 lwpstatus32_t *sp;
1807 int error;
1808 int nlwp;
1809 int i;
1810
1811 ASSERT(pnp->pr_type == PR_LSTATUS);
1812
1813 if ((error = prlock(pnp, ZNO)) != 0)
1814 return (error);
1815 p = pnp->pr_common->prc_proc;
1816 /*
1817 * A 32-bit process cannot get the status of a 64-bit process.
1818 * The fields for the 64-bit quantities are not large enough.
1819 */
1820 if (PROCESS_NOT_32BIT(p)) {
1821 prunlock(pnp);
1822 return (EOVERFLOW);
1823 }
1824 nlwp = p->p_lwpcnt;
1825 size = sizeof (prheader32_t) + nlwp * LSPAN32(lwpstatus32_t);
1826
1827 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1828 mutex_exit(&p->p_lock);
1829 php = kmem_zalloc(size, KM_SLEEP);
1830 mutex_enter(&p->p_lock);
1831 /* p->p_lwpcnt can't change while process is locked */
1832 ASSERT(nlwp == p->p_lwpcnt);
1833
1834 php->pr_nent = nlwp;
1835 php->pr_entsize = LSPAN32(lwpstatus32_t);
1836
1837 sp = (lwpstatus32_t *)(php + 1);
1838 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
1839 if (ldp->ld_entry == NULL ||
1840 (t = ldp->ld_entry->le_thread) == NULL)
1841 continue;
1842 prgetlwpstatus32(t, sp, VTOZONE(PTOV(pnp)));
1843 sp = (lwpstatus32_t *)((caddr_t)sp + LSPAN32(lwpstatus32_t));
1844 }
1845 prunlock(pnp);
1846
1847 error = pr_uioread(php, size, uiop);
1848 kmem_free(php, size);
1849 return (error);
1850 }
1851
1852 static int
1853 pr_read_psinfo_32(prnode_t *pnp, uio_t *uiop)
1854 {
1855 psinfo32_t psinfo;
1856 proc_t *p;
1857 int error = 0;
1858
1859 ASSERT(pnp->pr_type == PR_PSINFO);
1860
1861 /*
1862 * We don't want the full treatment of prlock(pnp) here.
1863 * This file is world-readable and never goes invalid.
1864 * It doesn't matter if we are in the middle of an exec().
1865 */
1866 p = pr_p_lock(pnp);
1867 mutex_exit(&pr_pidlock);
1868 if (p == NULL)
1869 error = ENOENT;
1870 else {
1871 ASSERT(p == pnp->pr_common->prc_proc);
1872 prgetpsinfo32(p, &psinfo);
1873 prunlock(pnp);
1874 error = pr_uioread(&psinfo, sizeof (psinfo), uiop);
1875 }
1876 return (error);
1877 }
1878
1879 static int
1880 pr_read_lpsinfo_32(prnode_t *pnp, uio_t *uiop)
1881 {
1882 proc_t *p;
1883 kthread_t *t;
1884 lwpdir_t *ldp;
1885 lwpent_t *lep;
1886 size_t size;
1887 prheader32_t *php;
1888 lwpsinfo32_t *sp;
1889 int error;
1890 int nlwp;
1891 int i;
1892
1893 ASSERT(pnp->pr_type == PR_LPSINFO);
1894
1895 /*
1896 * We don't want the full treatment of prlock(pnp) here.
1897 * This file is world-readable and never goes invalid.
1898 * It doesn't matter if we are in the middle of an exec().
1899 */
1900 p = pr_p_lock(pnp);
1901 mutex_exit(&pr_pidlock);
1902 if (p == NULL)
1903 return (ENOENT);
1904 ASSERT(p == pnp->pr_common->prc_proc);
1905 if ((nlwp = p->p_lwpcnt + p->p_zombcnt) == 0) {
1906 prunlock(pnp);
1907 return (ENOENT);
1908 }
1909 size = sizeof (prheader32_t) + nlwp * LSPAN32(lwpsinfo32_t);
1910
1911 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1912 mutex_exit(&p->p_lock);
1913 php = kmem_zalloc(size, KM_SLEEP);
1914 mutex_enter(&p->p_lock);
1915 /* p->p_lwpcnt can't change while process is locked */
1916 ASSERT(nlwp == p->p_lwpcnt + p->p_zombcnt);
1917
1918 php->pr_nent = nlwp;
1919 php->pr_entsize = LSPAN32(lwpsinfo32_t);
1920
1921 sp = (lwpsinfo32_t *)(php + 1);
1922 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
1923 if ((lep = ldp->ld_entry) == NULL)
1924 continue;
1925 if ((t = lep->le_thread) != NULL)
1926 prgetlwpsinfo32(t, sp);
1927 else {
1928 bzero(sp, sizeof (*sp));
1929 sp->pr_lwpid = lep->le_lwpid;
1930 sp->pr_state = SZOMB;
1931 sp->pr_sname = 'Z';
1932 sp->pr_start.tv_sec = (time32_t)lep->le_start;
1933 }
1934 sp = (lwpsinfo32_t *)((caddr_t)sp + LSPAN32(lwpsinfo32_t));
1935 }
1936 prunlock(pnp);
1937
1938 error = pr_uioread(php, size, uiop);
1939 kmem_free(php, size);
1940 return (error);
1941 }
1942
1943 static int
1944 pr_read_map_common_32(prnode_t *pnp, uio_t *uiop, prnodetype_t type)
1945 {
1946 proc_t *p;
1947 struct as *as;
1948 list_t iolhead;
1949 int error;
1950
1951 readmap32_common:
1952 if ((error = prlock(pnp, ZNO)) != 0)
1953 return (error);
1954
1955 p = pnp->pr_common->prc_proc;
1956 as = p->p_as;
1957
1958 if ((p->p_flag & SSYS) || as == &kas) {
1959 prunlock(pnp);
1960 return (0);
1961 }
1962
1963 if (PROCESS_NOT_32BIT(p)) {
1964 prunlock(pnp);
1965 return (EOVERFLOW);
1966 }
1967
1968 if (!AS_LOCK_TRYENTER(as, &as->a_lock, RW_WRITER)) {
1969 prunlock(pnp);
1970 delay(1);
1971 goto readmap32_common;
1972 }
1973 mutex_exit(&p->p_lock);
1974
1975 switch (type) {
1976 case PR_XMAP:
1977 error = prgetxmap32(p, &iolhead);
1978 break;
1979 case PR_RMAP:
1980 error = prgetmap32(p, 1, &iolhead);
1981 break;
1982 case PR_MAP:
1983 error = prgetmap32(p, 0, &iolhead);
1984 break;
1985 }
1986 AS_LOCK_EXIT(as, &as->a_lock);
1987 mutex_enter(&p->p_lock);
1988 prunlock(pnp);
1989
1990 error = pr_iol_uiomove_and_free(&iolhead, uiop, error);
1991
1992 return (error);
1993 }
1994
1995 static int
1996 pr_read_map_32(prnode_t *pnp, uio_t *uiop)
1997 {
1998 ASSERT(pnp->pr_type == PR_MAP);
1999 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2000 }
2001
2002 static int
2003 pr_read_rmap_32(prnode_t *pnp, uio_t *uiop)
2004 {
2005 ASSERT(pnp->pr_type == PR_RMAP);
2006 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2007 }
2008
2009 static int
2010 pr_read_xmap_32(prnode_t *pnp, uio_t *uiop)
2011 {
2012 ASSERT(pnp->pr_type == PR_XMAP);
2013 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2014 }
2015
2016 static int
2017 pr_read_sigact_32(prnode_t *pnp, uio_t *uiop)
2018 {
2019 int nsig = PROC_IS_BRANDED(curproc)? BROP(curproc)->b_nsig : NSIG;
2020 proc_t *p;
2021 struct sigaction32 *sap;
2022 int sig;
2023 int error;
2024 user_t *up;
2025
2026 ASSERT(pnp->pr_type == PR_SIGACT);
2027
2028 /*
2029 * We kmem_alloc() the sigaction32 array because
2030 * it is so big it might blow the kernel stack.
2031 */
2032 sap = kmem_alloc((nsig-1) * sizeof (struct sigaction32), KM_SLEEP);
2033
2034 if ((error = prlock(pnp, ZNO)) != 0)
2035 goto out;
2036 p = pnp->pr_common->prc_proc;
2037
2038 if (PROCESS_NOT_32BIT(p)) {
2039 prunlock(pnp);
2040 error = EOVERFLOW;
2041 goto out;
2042 }
2043
2044 if (uiop->uio_offset >= (nsig-1) * sizeof (struct sigaction32)) {
2045 prunlock(pnp);
2046 goto out;
2047 }
2048
2049 up = PTOU(p);
2050 for (sig = 1; sig < nsig; sig++)
2051 prgetaction32(p, up, sig, &sap[sig-1]);
2052 prunlock(pnp);
2053
2054 error = pr_uioread(sap, (nsig - 1) * sizeof (struct sigaction32), uiop);
2055 out:
2056 kmem_free(sap, (nsig-1) * sizeof (struct sigaction32));
2057 return (error);
2058 }
2059
2060 static int
2061 pr_read_auxv_32(prnode_t *pnp, uio_t *uiop)
2062 {
2063 auxv32_t auxv[__KERN_NAUXV_IMPL];
2064 proc_t *p;
2065 user_t *up;
2066 int error;
2067 int i;
2068
2069 ASSERT(pnp->pr_type == PR_AUXV);
2070
2071 if ((error = prlock(pnp, ZNO)) != 0)
2072 return (error);
2073 p = pnp->pr_common->prc_proc;
2074
2075 if (PROCESS_NOT_32BIT(p)) {
2076 prunlock(pnp);
2077 return (EOVERFLOW);
2078 }
2079
2080 if (uiop->uio_offset >= sizeof (auxv)) {
2081 prunlock(pnp);
2082 return (0);
2083 }
2084
2085 up = PTOU(p);
2086 for (i = 0; i < __KERN_NAUXV_IMPL; i++) {
2087 auxv[i].a_type = (int32_t)up->u_auxv[i].a_type;
2088 auxv[i].a_un.a_val = (int32_t)up->u_auxv[i].a_un.a_val;
2089 }
2090 prunlock(pnp);
2091
2092 return (pr_uioread(auxv, sizeof (auxv), uiop));
2093 }
2094
2095 static int
2096 pr_read_usage_32(prnode_t *pnp, uio_t *uiop)
2097 {
2098 prhusage_t *pup;
2099 prusage32_t *upup;
2100 proc_t *p;
2101 kthread_t *t;
2102 int error;
2103
2104 ASSERT(pnp->pr_type == PR_USAGE);
2105
2106 /* allocate now, before locking the process */
2107 pup = kmem_zalloc(sizeof (*pup), KM_SLEEP);
2108 upup = kmem_alloc(sizeof (*upup), KM_SLEEP);
2109
2110 /*
2111 * We don't want the full treatment of prlock(pnp) here.
2112 * This file is world-readable and never goes invalid.
2113 * It doesn't matter if we are in the middle of an exec().
2114 */
2115 p = pr_p_lock(pnp);
2116 mutex_exit(&pr_pidlock);
2117 if (p == NULL) {
2118 error = ENOENT;
2119 goto out;
2120 }
2121 ASSERT(p == pnp->pr_common->prc_proc);
2122
2123 if (uiop->uio_offset >= sizeof (prusage32_t)) {
2124 prunlock(pnp);
2125 error = 0;
2126 goto out;
2127 }
2128
2129 pup->pr_tstamp = gethrtime();
2130
2131 pup->pr_count = p->p_defunct;
2132 pup->pr_create = p->p_mstart;
2133 pup->pr_term = p->p_mterm;
2134
2135 pup->pr_rtime = p->p_mlreal;
2136 pup->pr_utime = p->p_acct[LMS_USER];
2137 pup->pr_stime = p->p_acct[LMS_SYSTEM];
2138 pup->pr_ttime = p->p_acct[LMS_TRAP];
2139 pup->pr_tftime = p->p_acct[LMS_TFAULT];
2140 pup->pr_dftime = p->p_acct[LMS_DFAULT];
2141 pup->pr_kftime = p->p_acct[LMS_KFAULT];
2142 pup->pr_ltime = p->p_acct[LMS_USER_LOCK];
2143 pup->pr_slptime = p->p_acct[LMS_SLEEP];
2144 pup->pr_wtime = p->p_acct[LMS_WAIT_CPU];
2145 pup->pr_stoptime = p->p_acct[LMS_STOPPED];
2146
2147 pup->pr_minf = p->p_ru.minflt;
2148 pup->pr_majf = p->p_ru.majflt;
2149 pup->pr_nswap = p->p_ru.nswap;
2150 pup->pr_inblk = p->p_ru.inblock;
2151 pup->pr_oublk = p->p_ru.oublock;
2152 pup->pr_msnd = p->p_ru.msgsnd;
2153 pup->pr_mrcv = p->p_ru.msgrcv;
2154 pup->pr_sigs = p->p_ru.nsignals;
2155 pup->pr_vctx = p->p_ru.nvcsw;
2156 pup->pr_ictx = p->p_ru.nivcsw;
2157 pup->pr_sysc = p->p_ru.sysc;
2158 pup->pr_ioch = p->p_ru.ioch;
2159
2160 /*
2161 * Add the usage information for each active lwp.
2162 */
2163 if ((t = p->p_tlist) != NULL &&
2164 !(pnp->pr_pcommon->prc_flags & PRC_DESTROY)) {
2165 do {
2166 if (t->t_proc_flag & TP_LWPEXIT)
2167 continue;
2168 pup->pr_count++;
2169 praddusage(t, pup);
2170 } while ((t = t->t_forw) != p->p_tlist);
2171 }
2172
2173 prunlock(pnp);
2174
2175 prcvtusage32(pup, upup);
2176
2177 error = pr_uioread(upup, sizeof (prusage32_t), uiop);
2178 out:
2179 kmem_free(pup, sizeof (*pup));
2180 kmem_free(upup, sizeof (*upup));
2181 return (error);
2182 }
2183
2184 static int
2185 pr_read_lusage_32(prnode_t *pnp, uio_t *uiop)
2186 {
2187 int nlwp;
2188 prhusage_t *pup;
2189 prheader32_t *php;
2190 prusage32_t *upup;
2191 size_t size;
2192 hrtime_t curtime;
2193 proc_t *p;
2194 kthread_t *t;
2195 lwpdir_t *ldp;
2196 int error;
2197 int i;
2198
2199 ASSERT(pnp->pr_type == PR_LUSAGE);
2200
2201 /*
2202 * We don't want the full treatment of prlock(pnp) here.
2203 * This file is world-readable and never goes invalid.
2204 * It doesn't matter if we are in the middle of an exec().
2205 */
2206 p = pr_p_lock(pnp);
2207 mutex_exit(&pr_pidlock);
2208 if (p == NULL)
2209 return (ENOENT);
2210 ASSERT(p == pnp->pr_common->prc_proc);
2211 if ((nlwp = p->p_lwpcnt) == 0) {
2212 prunlock(pnp);
2213 return (ENOENT);
2214 }
2215
2216 size = sizeof (prheader32_t) + (nlwp + 1) * LSPAN32(prusage32_t);
2217 if (uiop->uio_offset >= size) {
2218 prunlock(pnp);
2219 return (0);
2220 }
2221
2222 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
2223 mutex_exit(&p->p_lock);
2224 pup = kmem_zalloc(size + sizeof (prhusage_t), KM_SLEEP);
2225 mutex_enter(&p->p_lock);
2226 /* p->p_lwpcnt can't change while process is locked */
2227 ASSERT(nlwp == p->p_lwpcnt);
2228
2229 php = (prheader32_t *)(pup + 1);
2230 upup = (prusage32_t *)(php + 1);
2231
2232 php->pr_nent = nlwp + 1;
2233 php->pr_entsize = LSPAN32(prusage32_t);
2234
2235 curtime = gethrtime();
2236
2237 /*
2238 * First the summation over defunct lwps.
2239 */
2240 pup->pr_count = p->p_defunct;
2241 pup->pr_tstamp = curtime;
2242 pup->pr_create = p->p_mstart;
2243 pup->pr_term = p->p_mterm;
2244
2245 pup->pr_rtime = p->p_mlreal;
2246 pup->pr_utime = p->p_acct[LMS_USER];
2247 pup->pr_stime = p->p_acct[LMS_SYSTEM];
2248 pup->pr_ttime = p->p_acct[LMS_TRAP];
2249 pup->pr_tftime = p->p_acct[LMS_TFAULT];
2250 pup->pr_dftime = p->p_acct[LMS_DFAULT];
2251 pup->pr_kftime = p->p_acct[LMS_KFAULT];
2252 pup->pr_ltime = p->p_acct[LMS_USER_LOCK];
2253 pup->pr_slptime = p->p_acct[LMS_SLEEP];
2254 pup->pr_wtime = p->p_acct[LMS_WAIT_CPU];
2255 pup->pr_stoptime = p->p_acct[LMS_STOPPED];
2256
2257 pup->pr_minf = p->p_ru.minflt;
2258 pup->pr_majf = p->p_ru.majflt;
2259 pup->pr_nswap = p->p_ru.nswap;
2260 pup->pr_inblk = p->p_ru.inblock;
2261 pup->pr_oublk = p->p_ru.oublock;
2262 pup->pr_msnd = p->p_ru.msgsnd;
2263 pup->pr_mrcv = p->p_ru.msgrcv;
2264 pup->pr_sigs = p->p_ru.nsignals;
2265 pup->pr_vctx = p->p_ru.nvcsw;
2266 pup->pr_ictx = p->p_ru.nivcsw;
2267 pup->pr_sysc = p->p_ru.sysc;
2268 pup->pr_ioch = p->p_ru.ioch;
2269
2270 prcvtusage32(pup, upup);
2271
2272 /*
2273 * Fill one prusage struct for each active lwp.
2274 */
2275 for (ldp = p->p_lwpdir, i = 0; i < p->p_lwpdir_sz; i++, ldp++) {
2276 if (ldp->ld_entry == NULL ||
2277 (t = ldp->ld_entry->le_thread) == NULL)
2278 continue;
2279 ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
2280 ASSERT(nlwp > 0);
2281 --nlwp;
2282 upup = (prusage32_t *)
2283 ((caddr_t)upup + LSPAN32(prusage32_t));
2284 prgetusage(t, pup);
2285 prcvtusage32(pup, upup);
2286 }
2287 ASSERT(nlwp == 0);
2288
2289 prunlock(pnp);
2290
2291 error = pr_uioread(php, size, uiop);
2292 kmem_free(pup, size + sizeof (prhusage_t));
2293 return (error);
2294 }
2295
2296 static int
2297 pr_read_pagedata_32(prnode_t *pnp, uio_t *uiop)
2298 {
2299 proc_t *p;
2300 int error;
2301
2302 ASSERT(pnp->pr_type == PR_PAGEDATA);
2303
2304 if ((error = prlock(pnp, ZNO)) != 0)
2305 return (error);
2306
2307 p = pnp->pr_common->prc_proc;
2308 if ((p->p_flag & SSYS) || p->p_as == &kas) {
2309 prunlock(pnp);
2310 return (0);
2311 }
2312
2313 if (PROCESS_NOT_32BIT(p)) {
2314 prunlock(pnp);
2315 return (EOVERFLOW);
2316 }
2317
2318 mutex_exit(&p->p_lock);
2319 error = prpdread32(p, pnp->pr_hatid, uiop);
2320 mutex_enter(&p->p_lock);
2321
2322 prunlock(pnp);
2323 return (error);
2324 }
2325
2326 static int
2327 pr_read_opagedata_32(prnode_t *pnp, uio_t *uiop)
2328 {
2329 proc_t *p;
2330 struct as *as;
2331 int error;
2332
2333 ASSERT(pnp->pr_type == PR_OPAGEDATA);
2334
2335 if ((error = prlock(pnp, ZNO)) != 0)
2336 return (error);
2337
2338 p = pnp->pr_common->prc_proc;
2339 as = p->p_as;
2340
2341 if ((p->p_flag & SSYS) || as == &kas) {
2342 prunlock(pnp);
2343 return (0);
2344 }
2345
2346 if (PROCESS_NOT_32BIT(p)) {
2347 prunlock(pnp);
2348 return (EOVERFLOW);
2349 }
2350
2351 mutex_exit(&p->p_lock);
2352 error = oprpdread32(as, pnp->pr_hatid, uiop);
2353 mutex_enter(&p->p_lock);
2354
2355 prunlock(pnp);
2356 return (error);
2357 }
2358
2359 static int
2360 pr_read_watch_32(prnode_t *pnp, uio_t *uiop)
2361 {
2362 proc_t *p;
2363 int error;
2364 prwatch32_t *Bpwp;
2365 size_t size;
2366 prwatch32_t *pwp;
2367 int nwarea;
2368 struct watched_area *pwarea;
2369
2370 ASSERT(pnp->pr_type == PR_WATCH);
2371
2372 if ((error = prlock(pnp, ZNO)) != 0)
2373 return (error);
2374
2375 p = pnp->pr_common->prc_proc;
2376 if (PROCESS_NOT_32BIT(p)) {
2377 prunlock(pnp);
2378 return (EOVERFLOW);
2379 }
2380 nwarea = avl_numnodes(&p->p_warea);
2381 size = nwarea * sizeof (prwatch32_t);
2382 if (uiop->uio_offset >= size) {
2383 prunlock(pnp);
2384 return (0);
2385 }
2386
2387 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
2388 mutex_exit(&p->p_lock);
2389 Bpwp = pwp = kmem_zalloc(size, KM_SLEEP);
2390 mutex_enter(&p->p_lock);
2391 /* p->p_nwarea can't change while process is locked */
2392 ASSERT(nwarea == avl_numnodes(&p->p_warea));
2393
2394 /* gather the watched areas */
2395 for (pwarea = avl_first(&p->p_warea); pwarea != NULL;
2396 pwarea = AVL_NEXT(&p->p_warea, pwarea), pwp++) {
2397 pwp->pr_vaddr = (caddr32_t)(uintptr_t)pwarea->wa_vaddr;
2398 pwp->pr_size = (size32_t)(pwarea->wa_eaddr - pwarea->wa_vaddr);
2399 pwp->pr_wflags = (int)pwarea->wa_flags;
2400 }
2401
2402 prunlock(pnp);
2403
2404 error = pr_uioread(Bpwp, size, uiop);
2405 kmem_free(Bpwp, size);
2406 return (error);
2407 }
2408
2409 static int
2410 pr_read_lwpstatus_32(prnode_t *pnp, uio_t *uiop)
2411 {
2412 lwpstatus32_t *sp;
2413 proc_t *p;
2414 int error;
2415
2416 ASSERT(pnp->pr_type == PR_LWPSTATUS);
2417
2418 /*
2419 * We kmem_alloc() the lwpstatus structure because
2420 * it is so big it might blow the kernel stack.
2421 */
2422 sp = kmem_alloc(sizeof (*sp), KM_SLEEP);
2423
2424 if ((error = prlock(pnp, ZNO)) != 0)
2425 goto out;
2426
2427 /*
2428 * A 32-bit process cannot get the status of a 64-bit process.
2429 * The fields for the 64-bit quantities are not large enough.
2430 */
2431 p = pnp->pr_common->prc_proc;
2432 if (PROCESS_NOT_32BIT(p)) {
2433 prunlock(pnp);
2434 error = EOVERFLOW;
2435 goto out;
2436 }
2437
2438 if (uiop->uio_offset >= sizeof (*sp)) {
2439 prunlock(pnp);
2440 goto out;
2441 }
2442
2443 prgetlwpstatus32(pnp->pr_common->prc_thread, sp, VTOZONE(PTOV(pnp)));
2444 prunlock(pnp);
2445
2446 error = pr_uioread(sp, sizeof (*sp), uiop);
2447 out:
2448 kmem_free(sp, sizeof (*sp));
2449 return (error);
2450 }
2451
2452 static int
2453 pr_read_lwpsinfo_32(prnode_t *pnp, uio_t *uiop)
2454 {
2455 lwpsinfo32_t lwpsinfo;
2456 proc_t *p;
2457 kthread_t *t;
2458 lwpent_t *lep;
2459
2460 ASSERT(pnp->pr_type == PR_LWPSINFO);
2461
2462 /*
2463 * We don't want the full treatment of prlock(pnp) here.
2464 * This file is world-readable and never goes invalid.
2465 * It doesn't matter if we are in the middle of an exec().
2466 */
2467 p = pr_p_lock(pnp);
2468 mutex_exit(&pr_pidlock);
2469 if (p == NULL)
2470 return (ENOENT);
2471 ASSERT(p == pnp->pr_common->prc_proc);
2472 if (pnp->pr_common->prc_tslot == -1) {
2473 prunlock(pnp);
2474 return (ENOENT);
2475 }
2476
2477 if (uiop->uio_offset >= sizeof (lwpsinfo)) {
2478 prunlock(pnp);
2479 return (0);
2480 }
2481
2482 if ((t = pnp->pr_common->prc_thread) != NULL)
2483 prgetlwpsinfo32(t, &lwpsinfo);
2484 else {
2485 lep = p->p_lwpdir[pnp->pr_common->prc_tslot].ld_entry;
2486 bzero(&lwpsinfo, sizeof (lwpsinfo));
2487 lwpsinfo.pr_lwpid = lep->le_lwpid;
2488 lwpsinfo.pr_state = SZOMB;
2489 lwpsinfo.pr_sname = 'Z';
2490 lwpsinfo.pr_start.tv_sec = (time32_t)lep->le_start;
2491 }
2492 prunlock(pnp);
2493
2494 return (pr_uioread(&lwpsinfo, sizeof (lwpsinfo), uiop));
2495 }
2496
2497 static int
2498 pr_read_lwpusage_32(prnode_t *pnp, uio_t *uiop)
2499 {
2500 prhusage_t *pup;
2501 prusage32_t *upup;
2502 proc_t *p;
2503 int error;
2504
2505 ASSERT(pnp->pr_type == PR_LWPUSAGE);
2506
2507 /* allocate now, before locking the process */
2508 pup = kmem_zalloc(sizeof (*pup), KM_SLEEP);
2509 upup = kmem_alloc(sizeof (*upup), KM_SLEEP);
2510
2511 /*
2512 * We don't want the full treatment of prlock(pnp) here.
2513 * This file is world-readable and never goes invalid.
2514 * It doesn't matter if we are in the middle of an exec().
2515 */
2516 p = pr_p_lock(pnp);
2517 mutex_exit(&pr_pidlock);
2518 if (p == NULL) {
2519 error = ENOENT;
2520 goto out;
2521 }
2522 ASSERT(p == pnp->pr_common->prc_proc);
2523 if (pnp->pr_common->prc_thread == NULL) {
2524 prunlock(pnp);
2525 error = ENOENT;
2526 goto out;
2527 }
2528 if (uiop->uio_offset >= sizeof (prusage32_t)) {
2529 prunlock(pnp);
2530 error = 0;
2531 goto out;
2532 }
2533
2534 pup->pr_tstamp = gethrtime();
2535 prgetusage(pnp->pr_common->prc_thread, pup);
2536
2537 prunlock(pnp);
2538
2539 prcvtusage32(pup, upup);
2540
2541 error = pr_uioread(upup, sizeof (prusage32_t), uiop);
2542 out:
2543 kmem_free(pup, sizeof (*pup));
2544 kmem_free(upup, sizeof (*upup));
2545 return (error);
2546 }
2547
2548 #if defined(__sparc)
2549 static int
2550 pr_read_gwindows_32(prnode_t *pnp, uio_t *uiop)
2551 {
2552 proc_t *p;
2553 kthread_t *t;
2554 gwindows32_t *gwp;
2555 int error;
2556 size_t size;
2557
2558 ASSERT(pnp->pr_type == PR_GWINDOWS);
2559
2560 gwp = kmem_zalloc(sizeof (gwindows32_t), KM_SLEEP);
2561
2562 if ((error = prlock(pnp, ZNO)) != 0)
2563 goto out;
2564
2565 p = pnp->pr_common->prc_proc;
2566 t = pnp->pr_common->prc_thread;
2567
2568 if (PROCESS_NOT_32BIT(p)) {
2569 prunlock(pnp);
2570 error = EOVERFLOW;
2571 goto out;
2572 }
2573
2574 /*
2575 * Drop p->p_lock while touching the stack.
2576 * The P_PR_LOCK flag prevents the lwp from
2577 * disappearing while we do this.
2578 */
2579 mutex_exit(&p->p_lock);
2580 if ((size = prnwindows(ttolwp(t))) != 0)
2581 size = sizeof (gwindows32_t) -
2582 (SPARC_MAXREGWINDOW - size) * sizeof (struct rwindow32);
2583 if (uiop->uio_offset >= size) {
2584 mutex_enter(&p->p_lock);
2585 prunlock(pnp);
2586 goto out;
2587 }
2588 prgetwindows32(ttolwp(t), gwp);
2589 mutex_enter(&p->p_lock);
2590 prunlock(pnp);
2591
2592 error = pr_uioread(gwp, size, uiop);
2593 out:
2594 kmem_free(gwp, sizeof (gwindows32_t));
2595 return (error);
2596 }
2597 #endif /* __sparc */
2598
2599 #endif /* _SYSCALL32_IMPL */
2600
2601 /* ARGSUSED */
2602 static int
2603 prread(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, caller_context_t *ct)
2604 {
2605 prnode_t *pnp = VTOP(vp);
2606
2607 ASSERT(pnp->pr_type < PR_NFILES);
2608
2609 #ifdef _SYSCALL32_IMPL
2610 /*
2611 * What is read from the /proc files depends on the data
2612 * model of the caller. An LP64 process will see LP64
2613 * data. An ILP32 process will see ILP32 data.
2614 */
2615 if (curproc->p_model == DATAMODEL_LP64)
2616 return (pr_read_function[pnp->pr_type](pnp, uiop));
2617 else
2618 return (pr_read_function_32[pnp->pr_type](pnp, uiop));
2619 #else
2620 return (pr_read_function[pnp->pr_type](pnp, uiop));
2621 #endif
2622 }
2623
2624 /* ARGSUSED */
2625 static int
2626 prwrite(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, caller_context_t *ct)
2627 {
2628 prnode_t *pnp = VTOP(vp);
2629 int old = 0;
2630 int error;
2631 ssize_t resid;
2632
2633 ASSERT(pnp->pr_type < PR_NFILES);
2634
2635 /*
2636 * Only a handful of /proc files are writable, enumerate them here.
2637 */
2638 switch (pnp->pr_type) {
2639 case PR_PIDDIR: /* directory write()s: visceral revulsion. */
2640 ASSERT(pnp->pr_pidfile != NULL);
2641 /* use the underlying PR_PIDFILE to write the process */
2642 vp = pnp->pr_pidfile;
2643 pnp = VTOP(vp);
2644 ASSERT(pnp->pr_type == PR_PIDFILE);
2645 /* FALLTHROUGH */
2646 case PR_PIDFILE:
2647 case PR_LWPIDFILE:
2648 old = 1;
2649 /* FALLTHROUGH */
2650 case PR_AS:
2651 if ((error = prlock(pnp, ZNO)) == 0) {
2652 proc_t *p = pnp->pr_common->prc_proc;
2653 struct as *as = p->p_as;
2654
2655 if ((p->p_flag & SSYS) || as == &kas) {
2656 /*
2657 * /proc I/O cannot be done to a system process.
2658 */
2659 error = EIO;
2660 #ifdef _SYSCALL32_IMPL
2661 } else if (curproc->p_model == DATAMODEL_ILP32 &&
2662 PROCESS_NOT_32BIT(p)) {
2663 error = EOVERFLOW;
2664 #endif
2665 } else {
2666 /*
2667 * See comments above (pr_read_pidfile)
2668 * about this locking dance.
2669 */
2670 mutex_exit(&p->p_lock);
2671 error = prusrio(p, UIO_WRITE, uiop, old);
2672 mutex_enter(&p->p_lock);
2673 }
2674 prunlock(pnp);
2675 }
2676 return (error);
2677
2678 case PR_CTL:
2679 case PR_LWPCTL:
2680 resid = uiop->uio_resid;
2681 /*
2682 * Perform the action on the control file
2683 * by passing curthreads credentials
2684 * and not target process's credentials.
2685 */
2686 #ifdef _SYSCALL32_IMPL
2687 if (curproc->p_model == DATAMODEL_ILP32)
2688 error = prwritectl32(vp, uiop, CRED());
2689 else
2690 error = prwritectl(vp, uiop, CRED());
2691 #else
2692 error = prwritectl(vp, uiop, CRED());
2693 #endif
2694 /*
2695 * This hack makes sure that the EINTR is passed
2696 * all the way back to the caller's write() call.
2697 */
2698 if (error == EINTR)
2699 uiop->uio_resid = resid;
2700 return (error);
2701
2702 default:
2703 return ((vp->v_type == VDIR)? EISDIR : EBADF);
2704 }
2705 /* NOTREACHED */
2706 }
2707
2708 static int
2709 prgetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
2710 caller_context_t *ct)
2711 {
2712 prnode_t *pnp = VTOP(vp);
2713 prnodetype_t type = pnp->pr_type;
2714 prcommon_t *pcp;
2715 proc_t *p;
2716 struct as *as;
2717 int error;
2718 vnode_t *rvp;
2719 timestruc_t now;
2720 extern uint_t nproc;
2721 int ngroups;
2722 int nsig;
2723
2724 /*
2725 * This ugly bit of code allows us to keep both versions of this
2726 * function from the same source.
2727 */
2728 #ifdef _LP64
2729 int iam32bit = (curproc->p_model == DATAMODEL_ILP32);
2730 #define PR_OBJSIZE(obj32, obj64) \
2731 (iam32bit ? sizeof (obj32) : sizeof (obj64))
2732 #define PR_OBJSPAN(obj32, obj64) \
2733 (iam32bit ? LSPAN32(obj32) : LSPAN(obj64))
2734 #else
2735 #define PR_OBJSIZE(obj32, obj64) \
2736 (sizeof (obj64))
2737 #define PR_OBJSPAN(obj32, obj64) \
2738 (LSPAN(obj64))
2739 #endif
2740
2741 /*
2742 * Return all the attributes. Should be refined
2743 * so that it returns only those asked for.
2744 * Most of this is complete fakery anyway.
2745 */
2746
2747 /*
2748 * For files in the /proc/<pid>/object directory,
2749 * return the attributes of the underlying object.
2750 * For files in the /proc/<pid>/fd directory,
2751 * return the attributes of the underlying file, but
2752 * make it look inaccessible if it is not a regular file.
2753 * Make directories look like symlinks.
2754 */
2755 switch (type) {
2756 case PR_CURDIR:
2757 case PR_ROOTDIR:
2758 if (!(flags & ATTR_REAL))
2759 break;
2760 /* restrict full knowledge of the attributes to owner or root */
2761 if ((error = praccess(vp, 0, 0, cr, ct)) != 0)
2762 return (error);
2763 /* FALLTHROUGH */
2764 case PR_OBJECT:
2765 case PR_FD:
2766 rvp = pnp->pr_realvp;
2767 error = VOP_GETATTR(rvp, vap, flags, cr, ct);
2768 if (error)
2769 return (error);
2770 if (type == PR_FD) {
2771 if (rvp->v_type != VREG && rvp->v_type != VDIR)
2772 vap->va_mode = 0;
2773 else
2774 vap->va_mode &= pnp->pr_mode;
2775 }
2776 if (type == PR_OBJECT)
2777 vap->va_mode &= 07555;
2778 if (rvp->v_type == VDIR && !(flags & ATTR_REAL)) {
2779 vap->va_type = VLNK;
2780 vap->va_size = 0;
2781 vap->va_nlink = 1;
2782 }
2783 return (0);
2784 default:
2785 break;
2786 }
2787
2788 bzero(vap, sizeof (*vap));
2789 /*
2790 * Large Files: Internally proc now uses VPROC to indicate
2791 * a proc file. Since we have been returning VREG through
2792 * VOP_GETATTR() until now, we continue to do this so as
2793 * not to break apps depending on this return value.
2794 */
2795 vap->va_type = (vp->v_type == VPROC) ? VREG : vp->v_type;
2796 vap->va_mode = pnp->pr_mode;
2797 vap->va_fsid = vp->v_vfsp->vfs_dev;
2798 vap->va_blksize = DEV_BSIZE;
2799 vap->va_rdev = 0;
2800 vap->va_seq = 0;
2801
2802 if (type == PR_PROCDIR) {
2803 vap->va_uid = 0;
2804 vap->va_gid = 0;
2805 vap->va_nlink = nproc + 2;
2806 vap->va_nodeid = (ino64_t)PRROOTINO;
2807 gethrestime(&now);
2808 vap->va_atime = vap->va_mtime = vap->va_ctime = now;
2809 vap->va_size = (v.v_proc + 2) * PRSDSIZE;
2810 vap->va_nblocks = btod(vap->va_size);
2811 return (0);
2812 }
2813
2814 /*
2815 * /proc/<pid>/self is a symbolic link, and has no prcommon member
2816 */
2817 if (type == PR_SELF) {
2818 vap->va_uid = crgetruid(CRED());
2819 vap->va_gid = crgetrgid(CRED());
2820 vap->va_nodeid = (ino64_t)PR_SELF;
2821 gethrestime(&now);
2822 vap->va_atime = vap->va_mtime = vap->va_ctime = now;
2823 vap->va_nlink = 1;
2824 vap->va_type = VLNK;
2825 vap->va_size = 0;
2826 return (0);
2827 }
2828
2829 p = pr_p_lock(pnp);
2830 mutex_exit(&pr_pidlock);
2831 if (p == NULL)
2832 return (ENOENT);
2833 pcp = pnp->pr_common;
2834
2835 mutex_enter(&p->p_crlock);
2836 vap->va_uid = crgetruid(p->p_cred);
2837 vap->va_gid = crgetrgid(p->p_cred);
2838 mutex_exit(&p->p_crlock);
2839
2840 vap->va_nlink = 1;
2841 vap->va_nodeid = pnp->pr_ino? pnp->pr_ino :
2842 pmkino(pcp->prc_tslot, pcp->prc_slot, pnp->pr_type);
2843 if ((pcp->prc_flags & PRC_LWP) && pcp->prc_tslot != -1) {
2844 vap->va_atime.tv_sec = vap->va_mtime.tv_sec =
2845 vap->va_ctime.tv_sec =
2846 p->p_lwpdir[pcp->prc_tslot].ld_entry->le_start;
2847 vap->va_atime.tv_nsec = vap->va_mtime.tv_nsec =
2848 vap->va_ctime.tv_nsec = 0;
2849 } else {
2850 user_t *up = PTOU(p);
2851 vap->va_atime.tv_sec = vap->va_mtime.tv_sec =
2852 vap->va_ctime.tv_sec = up->u_start.tv_sec;
2853 vap->va_atime.tv_nsec = vap->va_mtime.tv_nsec =
2854 vap->va_ctime.tv_nsec = up->u_start.tv_nsec;
2855 }
2856
2857 switch (type) {
2858 case PR_PIDDIR:
2859 /* va_nlink: count 'lwp', 'object' and 'fd' directory links */
2860 vap->va_nlink = 5;
2861 vap->va_size = sizeof (piddir);
2862 break;
2863 case PR_OBJECTDIR:
2864 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2865 vap->va_size = 2 * PRSDSIZE;
2866 else {
2867 mutex_exit(&p->p_lock);
2868 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
2869 if (as->a_updatedir)
2870 rebuild_objdir(as);
2871 vap->va_size = (as->a_sizedir + 2) * PRSDSIZE;
2872 AS_LOCK_EXIT(as, &as->a_lock);
2873 mutex_enter(&p->p_lock);
2874 }
2875 vap->va_nlink = 2;
2876 break;
2877 case PR_PATHDIR:
2878 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2879 vap->va_size = (P_FINFO(p)->fi_nfiles + 4) * PRSDSIZE;
2880 else {
2881 mutex_exit(&p->p_lock);
2882 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
2883 if (as->a_updatedir)
2884 rebuild_objdir(as);
2885 vap->va_size = (as->a_sizedir + 4 +
2886 P_FINFO(p)->fi_nfiles) * PRSDSIZE;
2887 AS_LOCK_EXIT(as, &as->a_lock);
2888 mutex_enter(&p->p_lock);
2889 }
2890 vap->va_nlink = 2;
2891 break;
2892 case PR_PATH:
2893 case PR_CURDIR:
2894 case PR_ROOTDIR:
2895 case PR_CT:
2896 vap->va_type = VLNK;
2897 vap->va_size = 0;
2898 break;
2899 case PR_FDDIR:
2900 vap->va_nlink = 2;
2901 vap->va_size = (P_FINFO(p)->fi_nfiles + 2) * PRSDSIZE;
2902 break;
2903 case PR_LWPDIR:
2904 /*
2905 * va_nlink: count each lwp as a directory link.
2906 * va_size: size of p_lwpdir + 2
2907 */
2908 vap->va_nlink = p->p_lwpcnt + p->p_zombcnt + 2;
2909 vap->va_size = (p->p_lwpdir_sz + 2) * PRSDSIZE;
2910 break;
2911 case PR_LWPIDDIR:
2912 vap->va_nlink = 2;
2913 vap->va_size = sizeof (lwpiddir);
2914 break;
2915 case PR_CTDIR:
2916 vap->va_nlink = 2;
2917 vap->va_size = (avl_numnodes(&p->p_ct_held) + 2) * PRSDSIZE;
2918 break;
2919 case PR_TMPLDIR:
2920 vap->va_nlink = 2;
2921 vap->va_size = (ct_ntypes + 2) * PRSDSIZE;
2922 break;
2923 case PR_AS:
2924 case PR_PIDFILE:
2925 case PR_LWPIDFILE:
2926 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2927 vap->va_size = 0;
2928 else
2929 vap->va_size = as->a_resvsize;
2930 break;
2931 case PR_STATUS:
2932 vap->va_size = PR_OBJSIZE(pstatus32_t, pstatus_t);
2933 break;
2934 case PR_LSTATUS:
2935 vap->va_size = PR_OBJSIZE(prheader32_t, prheader_t) +
2936 p->p_lwpcnt * PR_OBJSPAN(lwpstatus32_t, lwpstatus_t);
2937 break;
2938 case PR_PSINFO:
2939 vap->va_size = PR_OBJSIZE(psinfo32_t, psinfo_t);
2940 break;
2941 case PR_LPSINFO:
2942 vap->va_size = PR_OBJSIZE(prheader32_t, prheader_t) +
2943 (p->p_lwpcnt + p->p_zombcnt) *
2944 PR_OBJSPAN(lwpsinfo32_t, lwpsinfo_t);
2945 break;
2946 case PR_MAP:
2947 case PR_RMAP:
2948 case PR_XMAP:
2949 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2950 vap->va_size = 0;
2951 else {
2952 mutex_exit(&p->p_lock);
2953 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
2954 if (type == PR_MAP)
2955 vap->va_mtime = as->a_updatetime;
2956 if (type == PR_XMAP)
2957 vap->va_size = prnsegs(as, 0) *
2958 PR_OBJSIZE(prxmap32_t, prxmap_t);
2959 else
2960 vap->va_size = prnsegs(as, type == PR_RMAP) *
2961 PR_OBJSIZE(prmap32_t, prmap_t);
2962 AS_LOCK_EXIT(as, &as->a_lock);
2963 mutex_enter(&p->p_lock);
2964 }
2965 break;
2966 case PR_CRED:
2967 mutex_enter(&p->p_crlock);
2968 vap->va_size = sizeof (prcred_t);
2969 ngroups = crgetngroups(p->p_cred);
2970 if (ngroups > 1)
2971 vap->va_size += (ngroups - 1) * sizeof (gid_t);
2972 mutex_exit(&p->p_crlock);
2973 break;
2974 case PR_PRIV:
2975 vap->va_size = prgetprivsize();
2976 break;
2977 case PR_SIGACT:
2978 nsig = PROC_IS_BRANDED(curproc)? BROP(curproc)->b_nsig : NSIG;
2979 vap->va_size = (nsig-1) *
2980 PR_OBJSIZE(struct sigaction32, struct sigaction);
2981 break;
2982 case PR_AUXV:
2983 vap->va_size = __KERN_NAUXV_IMPL * PR_OBJSIZE(auxv32_t, auxv_t);
2984 break;
2985 #if defined(__x86)
2986 case PR_LDT:
2987 mutex_exit(&p->p_lock);
2988 mutex_enter(&p->p_ldtlock);
2989 vap->va_size = prnldt(p) * sizeof (struct ssd);
2990 mutex_exit(&p->p_ldtlock);
2991 mutex_enter(&p->p_lock);
2992 break;
2993 #endif
2994 case PR_USAGE:
2995 vap->va_size = PR_OBJSIZE(prusage32_t, prusage_t);
2996 break;
2997 case PR_LUSAGE:
2998 vap->va_size = PR_OBJSIZE(prheader32_t, prheader_t) +
2999 (p->p_lwpcnt + 1) * PR_OBJSPAN(prusage32_t, prusage_t);
3000 break;
3001 case PR_PAGEDATA:
3002 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
3003 vap->va_size = 0;
3004 else {
3005 /*
3006 * We can drop p->p_lock before grabbing the
3007 * address space lock because p->p_as will not
3008 * change while the process is marked P_PR_LOCK.
3009 */
3010 mutex_exit(&p->p_lock);
3011 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
3012 #ifdef _LP64
3013 vap->va_size = iam32bit?
3014 prpdsize32(as) : prpdsize(as);
3015 #else
3016 vap->va_size = prpdsize(as);
3017 #endif
3018 AS_LOCK_EXIT(as, &as->a_lock);
3019 mutex_enter(&p->p_lock);
3020 }
3021 break;
3022 case PR_OPAGEDATA:
3023 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
3024 vap->va_size = 0;
3025 else {
3026 mutex_exit(&p->p_lock);
3027 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
3028 #ifdef _LP64
3029 vap->va_size = iam32bit?
3030 oprpdsize32(as) : oprpdsize(as);
3031 #else
3032 vap->va_size = oprpdsize(as);
3033 #endif
3034 AS_LOCK_EXIT(as, &as->a_lock);
3035 mutex_enter(&p->p_lock);
3036 }
3037 break;
3038 case PR_WATCH:
3039 vap->va_size = avl_numnodes(&p->p_warea) *
3040 PR_OBJSIZE(prwatch32_t, prwatch_t);
3041 break;
3042 case PR_LWPSTATUS:
3043 vap->va_size = PR_OBJSIZE(lwpstatus32_t, lwpstatus_t);
3044 break;
3045 case PR_LWPSINFO:
3046 vap->va_size = PR_OBJSIZE(lwpsinfo32_t, lwpsinfo_t);
3047 break;
3048 case PR_LWPUSAGE:
3049 vap->va_size = PR_OBJSIZE(prusage32_t, prusage_t);
3050 break;
3051 case PR_XREGS:
3052 if (prhasx(p))
3053 vap->va_size = prgetprxregsize(p);
3054 else
3055 vap->va_size = 0;
3056 break;
3057 #if defined(__sparc)
3058 case PR_GWINDOWS:
3059 {
3060 kthread_t *t;
3061 int n;
3062
3063 /*
3064 * If there is no lwp then just make the size zero.
3065 * This can happen if the lwp exits between the VOP_LOOKUP()
3066 * of the /proc/<pid>/lwp/<lwpid>/gwindows file and the
3067 * VOP_GETATTR() of the resulting vnode.
3068 */
3069 if ((t = pcp->prc_thread) == NULL) {
3070 vap->va_size = 0;
3071 break;
3072 }
3073 /*
3074 * Drop p->p_lock while touching the stack.
3075 * The P_PR_LOCK flag prevents the lwp from
3076 * disappearing while we do this.
3077 */
3078 mutex_exit(&p->p_lock);
3079 if ((n = prnwindows(ttolwp(t))) == 0)
3080 vap->va_size = 0;
3081 else
3082 vap->va_size = PR_OBJSIZE(gwindows32_t, gwindows_t) -
3083 (SPARC_MAXREGWINDOW - n) *
3084 PR_OBJSIZE(struct rwindow32, struct rwindow);
3085 mutex_enter(&p->p_lock);
3086 break;
3087 }
3088 case PR_ASRS:
3089 #ifdef _LP64
3090 if (p->p_model == DATAMODEL_LP64)
3091 vap->va_size = sizeof (asrset_t);
3092 else
3093 #endif
3094 vap->va_size = 0;
3095 break;
3096 #endif
3097 case PR_CTL:
3098 case PR_LWPCTL:
3099 default:
3100 vap->va_size = 0;
3101 break;
3102 }
3103
3104 prunlock(pnp);
3105 vap->va_nblocks = (fsblkcnt64_t)btod(vap->va_size);
3106 return (0);
3107 }
3108
3109 static int
3110 praccess(vnode_t *vp, int mode, int flags, cred_t *cr, caller_context_t *ct)
3111 {
3112 prnode_t *pnp = VTOP(vp);
3113 prnodetype_t type = pnp->pr_type;
3114 int vmode;
3115 vtype_t vtype;
3116 proc_t *p;
3117 int error = 0;
3118 vnode_t *rvp;
3119 vnode_t *xvp;
3120
3121 if ((mode & VWRITE) && vn_is_readonly(vp))
3122 return (EROFS);
3123
3124 switch (type) {
3125 case PR_PROCDIR:
3126 break;
3127
3128 case PR_OBJECT:
3129 case PR_FD:
3130 /*
3131 * Disallow write access to the underlying objects.
3132 * Disallow access to underlying non-regular-file fds.
3133 * Disallow access to fds with other than existing open modes.
3134 */
3135 rvp = pnp->pr_realvp;
3136 vtype = rvp->v_type;
3137 vmode = pnp->pr_mode;
3138 if ((type == PR_OBJECT && (mode & VWRITE)) ||
3139 (type == PR_FD && vtype != VREG && vtype != VDIR) ||
3140 (type == PR_FD && (vmode & mode) != mode &&
3141 secpolicy_proc_access(cr) != 0))
3142 return (EACCES);
3143 return (VOP_ACCESS(rvp, mode, flags, cr, ct));
3144
3145 case PR_PSINFO: /* these files can be read by anyone */
3146 case PR_LPSINFO:
3147 case PR_LWPSINFO:
3148 case PR_LWPDIR:
3149 case PR_LWPIDDIR:
3150 case PR_USAGE:
3151 case PR_LUSAGE:
3152 case PR_LWPUSAGE:
3153 p = pr_p_lock(pnp);
3154 mutex_exit(&pr_pidlock);
3155 if (p == NULL)
3156 return (ENOENT);
3157 prunlock(pnp);
3158 break;
3159
3160 default:
3161 /*
3162 * Except for the world-readable files above,
3163 * only /proc/pid exists if the process is a zombie.
3164 */
3165 if ((error = prlock(pnp,
3166 (type == PR_PIDDIR)? ZYES : ZNO)) != 0)
3167 return (error);
3168 p = pnp->pr_common->prc_proc;
3169 if (p != curproc)
3170 error = priv_proc_cred_perm(cr, p, NULL, mode);
3171
3172 if (error != 0 || p == curproc || (p->p_flag & SSYS) ||
3173 p->p_as == &kas || (xvp = p->p_exec) == NULL) {
3174 prunlock(pnp);
3175 } else {
3176 /*
3177 * Determine if the process's executable is readable.
3178 * We have to drop p->p_lock before the secpolicy
3179 * and VOP operation.
3180 */
3181 VN_HOLD(xvp);
3182 prunlock(pnp);
3183 if (secpolicy_proc_access(cr) != 0)
3184 error = VOP_ACCESS(xvp, VREAD, 0, cr, ct);
3185 VN_RELE(xvp);
3186 }
3187 if (error)
3188 return (error);
3189 break;
3190 }
3191
3192 if (type == PR_CURDIR || type == PR_ROOTDIR) {
3193 /*
3194 * Final access check on the underlying directory vnode.
3195 */
3196 return (VOP_ACCESS(pnp->pr_realvp, mode, flags, cr, ct));
3197 }
3198
3199 /*
3200 * Visceral revulsion: For compatibility with old /proc,
3201 * allow the /proc/<pid> directory to be opened for writing.
3202 */
3203 vmode = pnp->pr_mode;
3204 if (type == PR_PIDDIR)
3205 vmode |= VWRITE;
3206 if ((vmode & mode) != mode)
3207 error = secpolicy_proc_access(cr);
3208 return (error);
3209 }
3210
3211 /*
3212 * Array of lookup functions, indexed by /proc file type.
3213 */
3214 static vnode_t *pr_lookup_notdir(), *pr_lookup_procdir(), *pr_lookup_piddir(),
3215 *pr_lookup_objectdir(), *pr_lookup_lwpdir(), *pr_lookup_lwpiddir(),
3216 *pr_lookup_fddir(), *pr_lookup_pathdir(), *pr_lookup_tmpldir(),
3217 *pr_lookup_ctdir();
3218
3219 static vnode_t *(*pr_lookup_function[PR_NFILES])() = {
3220 pr_lookup_procdir, /* /proc */
3221 pr_lookup_notdir, /* /proc/self */
3222 pr_lookup_piddir, /* /proc/<pid> */
3223 pr_lookup_notdir, /* /proc/<pid>/as */
3224 pr_lookup_notdir, /* /proc/<pid>/ctl */
3225 pr_lookup_notdir, /* /proc/<pid>/status */
3226 pr_lookup_notdir, /* /proc/<pid>/lstatus */
3227 pr_lookup_notdir, /* /proc/<pid>/psinfo */
3228 pr_lookup_notdir, /* /proc/<pid>/lpsinfo */
3229 pr_lookup_notdir, /* /proc/<pid>/map */
3230 pr_lookup_notdir, /* /proc/<pid>/rmap */
3231 pr_lookup_notdir, /* /proc/<pid>/xmap */
3232 pr_lookup_notdir, /* /proc/<pid>/cred */
3233 pr_lookup_notdir, /* /proc/<pid>/sigact */
3234 pr_lookup_notdir, /* /proc/<pid>/auxv */
3235 #if defined(__x86)
3236 pr_lookup_notdir, /* /proc/<pid>/ldt */
3237 #endif
3238 pr_lookup_notdir, /* /proc/<pid>/usage */
3239 pr_lookup_notdir, /* /proc/<pid>/lusage */
3240 pr_lookup_notdir, /* /proc/<pid>/pagedata */
3241 pr_lookup_notdir, /* /proc/<pid>/watch */
3242 pr_lookup_notdir, /* /proc/<pid>/cwd */
3243 pr_lookup_notdir, /* /proc/<pid>/root */
3244 pr_lookup_fddir, /* /proc/<pid>/fd */
3245 pr_lookup_notdir, /* /proc/<pid>/fd/nn */
3246 pr_lookup_objectdir, /* /proc/<pid>/object */
3247 pr_lookup_notdir, /* /proc/<pid>/object/xxx */
3248 pr_lookup_lwpdir, /* /proc/<pid>/lwp */
3249 pr_lookup_lwpiddir, /* /proc/<pid>/lwp/<lwpid> */
3250 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
3251 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
3252 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
3253 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
3254 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/xregs */
3255 pr_lookup_tmpldir, /* /proc/<pid>/lwp/<lwpid>/templates */
3256 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
3257 #if defined(__sparc)
3258 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/gwindows */
3259 pr_lookup_notdir, /* /proc/<pid>/lwp/<lwpid>/asrs */
3260 #endif
3261 pr_lookup_notdir, /* /proc/<pid>/priv */
3262 pr_lookup_pathdir, /* /proc/<pid>/path */
3263 pr_lookup_notdir, /* /proc/<pid>/path/xxx */
3264 pr_lookup_ctdir, /* /proc/<pid>/contracts */
3265 pr_lookup_notdir, /* /proc/<pid>/contracts/<ctid> */
3266 pr_lookup_notdir, /* old process file */
3267 pr_lookup_notdir, /* old lwp file */
3268 pr_lookup_notdir, /* old pagedata file */
3269 };
3270
3271 static int
3272 prlookup(vnode_t *dp, char *comp, vnode_t **vpp, pathname_t *pathp,
3273 int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
3274 int *direntflags, pathname_t *realpnp)
3275 {
3276 prnode_t *pnp = VTOP(dp);
3277 prnodetype_t type = pnp->pr_type;
3278 int error;
3279
3280 ASSERT(dp->v_type == VDIR);
3281 ASSERT(type < PR_NFILES);
3282
3283 if (type != PR_PROCDIR && strcmp(comp, "..") == 0) {
3284 VN_HOLD(pnp->pr_parent);
3285 *vpp = pnp->pr_parent;
3286 return (0);
3287 }
3288
3289 if (*comp == '\0' ||
3290 strcmp(comp, ".") == 0 || strcmp(comp, "..") == 0) {
3291 VN_HOLD(dp);
3292 *vpp = dp;
3293 return (0);
3294 }
3295
3296 switch (type) {
3297 case PR_CURDIR:
3298 case PR_ROOTDIR:
3299 /* restrict lookup permission to owner or root */
3300 if ((error = praccess(dp, VEXEC, 0, cr, ct)) != 0)
3301 return (error);
3302 /* FALLTHROUGH */
3303 case PR_FD:
3304 dp = pnp->pr_realvp;
3305 return (VOP_LOOKUP(dp, comp, vpp, pathp, flags, rdir, cr, ct,
3306 direntflags, realpnp));
3307 default:
3308 break;
3309 }
3310
3311 if ((type == PR_OBJECTDIR || type == PR_FDDIR || type == PR_PATHDIR) &&
3312 (error = praccess(dp, VEXEC, 0, cr, ct)) != 0)
3313 return (error);
3314
3315 /* XXX - Do we need to pass ct, direntflags, or realpnp? */
3316 *vpp = (pr_lookup_function[type](dp, comp));
3317
3318 return ((*vpp == NULL) ? ENOENT : 0);
3319 }
3320
3321 /* ARGSUSED */
3322 static int
3323 prcreate(vnode_t *dp, char *comp, vattr_t *vap, vcexcl_t excl,
3324 int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
3325 vsecattr_t *vsecp)
3326 {
3327 int error;
3328
3329 if ((error = prlookup(dp, comp, vpp, NULL, 0, NULL, cr,
3330 ct, NULL, NULL)) != 0) {
3331 if (error == ENOENT) /* can't O_CREAT nonexistent files */
3332 error = EACCES; /* unwriteable directories */
3333 } else {
3334 if (excl == EXCL) /* O_EXCL */
3335 error = EEXIST;
3336 else if (vap->va_mask & AT_SIZE) { /* O_TRUNC */
3337 vnode_t *vp = *vpp;
3338 uint_t mask;
3339
3340 if (vp->v_type == VDIR)
3341 error = EISDIR;
3342 else if (vp->v_type != VPROC ||
3343 VTOP(vp)->pr_type != PR_FD)
3344 error = EACCES;
3345 else { /* /proc/<pid>/fd/<n> */
3346 vp = VTOP(vp)->pr_realvp;
3347 mask = vap->va_mask;
3348 vap->va_mask = AT_SIZE;
3349 error = VOP_SETATTR(vp, vap, 0, cr, ct);
3350 vap->va_mask = mask;
3351 }
3352 }
3353 if (error) {
3354 VN_RELE(*vpp);
3355 *vpp = NULL;
3356 }
3357 }
3358 return (error);
3359 }
3360
3361 /* ARGSUSED */
3362 static vnode_t *
3363 pr_lookup_notdir(vnode_t *dp, char *comp)
3364 {
3365 return (NULL);
3366 }
3367
3368 /*
3369 * Find or construct a process vnode for the given pid.
3370 */
3371 static vnode_t *
3372 pr_lookup_procdir(vnode_t *dp, char *comp)
3373 {
3374 pid_t pid;
3375 prnode_t *pnp;
3376 prcommon_t *pcp;
3377 vnode_t *vp;
3378 proc_t *p;
3379 int c;
3380
3381 ASSERT(VTOP(dp)->pr_type == PR_PROCDIR);
3382
3383 if (strcmp(comp, "self") == 0) {
3384 pnp = prgetnode(dp, PR_SELF);
3385 return (PTOV(pnp));
3386 } else {
3387 pid = 0;
3388 while ((c = *comp++) != '\0') {
3389 if (c < '0' || c > '9')
3390 return (NULL);
3391 pid = 10*pid + c - '0';
3392 if (pid > maxpid)
3393 return (NULL);
3394 }
3395 }
3396
3397 pnp = prgetnode(dp, PR_PIDDIR);
3398
3399 mutex_enter(&pidlock);
3400 if ((p = prfind(pid)) == NULL || p->p_stat == SIDL) {
3401 mutex_exit(&pidlock);
3402 prfreenode(pnp);
3403 return (NULL);
3404 }
3405 ASSERT(p->p_stat != 0);
3406
3407 /* NOTE: we're holding pidlock across the policy call. */
3408 if (secpolicy_basic_procinfo(CRED(), p, curproc) != 0) {
3409 mutex_exit(&pidlock);
3410 prfreenode(pnp);
3411 return (NULL);
3412 }
3413
3414 mutex_enter(&p->p_lock);
3415 mutex_exit(&pidlock);
3416
3417 /*
3418 * If a process vnode already exists and it is not invalid
3419 * and it was created by the current process and it belongs
3420 * to the same /proc mount point as our parent vnode, then
3421 * just use it and discard the newly-allocated prnode.
3422 */
3423 for (vp = p->p_trace; vp != NULL; vp = VTOP(vp)->pr_next) {
3424 if (!(VTOP(VTOP(vp)->pr_pidfile)->pr_flags & PR_INVAL) &&
3425 VTOP(vp)->pr_owner == curproc &&
3426 vp->v_vfsp == dp->v_vfsp) {
3427 ASSERT(!(VTOP(vp)->pr_flags & PR_INVAL));
3428 VN_HOLD(vp);
3429 prfreenode(pnp);
3430 mutex_exit(&p->p_lock);
3431 return (vp);
3432 }
3433 }
3434 pnp->pr_owner = curproc;
3435
3436 /*
3437 * prgetnode() initialized most of the prnode.
3438 * Finish the job.
3439 */
3440 pcp = pnp->pr_common; /* the newly-allocated prcommon struct */
3441 if ((vp = p->p_trace) != NULL) {
3442 /* discard the new prcommon and use the existing prcommon */
3443 prfreecommon(pcp);
3444 pcp = VTOP(vp)->pr_common;
3445 mutex_enter(&pcp->prc_mutex);
3446 ASSERT(pcp->prc_refcnt > 0);
3447 pcp->prc_refcnt++;
3448 mutex_exit(&pcp->prc_mutex);
3449 pnp->pr_common = pcp;
3450 } else {
3451 /* initialize the new prcommon struct */
3452 if ((p->p_flag & SSYS) || p->p_as == &kas)
3453 pcp->prc_flags |= PRC_SYS;
3454 if (p->p_stat == SZOMB)
3455 pcp->prc_flags |= PRC_DESTROY;
3456 pcp->prc_proc = p;
3457 pcp->prc_datamodel = p->p_model;
3458 pcp->prc_pid = p->p_pid;
3459 pcp->prc_slot = p->p_slot;
3460 }
3461 pnp->pr_pcommon = pcp;
3462 pnp->pr_parent = dp;
3463 VN_HOLD(dp);
3464 /*
3465 * Link in the old, invalid directory vnode so we
3466 * can later determine the last close of the file.
3467 */
3468 pnp->pr_next = p->p_trace;
3469 p->p_trace = dp = PTOV(pnp);
3470
3471 /*
3472 * Kludge for old /proc: initialize the PR_PIDFILE as well.
3473 */
3474 vp = pnp->pr_pidfile;
3475 pnp = VTOP(vp);
3476 pnp->pr_ino = ptoi(pcp->prc_pid);
3477 pnp->pr_common = pcp;
3478 pnp->pr_pcommon = pcp;
3479 pnp->pr_parent = dp;
3480 pnp->pr_next = p->p_plist;
3481 p->p_plist = vp;
3482
3483 mutex_exit(&p->p_lock);
3484 return (dp);
3485 }
3486
3487 static vnode_t *
3488 pr_lookup_piddir(vnode_t *dp, char *comp)
3489 {
3490 prnode_t *dpnp = VTOP(dp);
3491 vnode_t *vp;
3492 prnode_t *pnp;
3493 proc_t *p;
3494 user_t *up;
3495 prdirent_t *dirp;
3496 int i;
3497 enum prnodetype type;
3498
3499 ASSERT(dpnp->pr_type == PR_PIDDIR);
3500
3501 for (i = 0; i < NPIDDIRFILES; i++) {
3502 /* Skip "." and ".." */
3503 dirp = &piddir[i+2];
3504 if (strcmp(comp, dirp->d_name) == 0)
3505 break;
3506 }
3507
3508 if (i >= NPIDDIRFILES)
3509 return (NULL);
3510
3511 type = (int)dirp->d_ino;
3512 pnp = prgetnode(dp, type);
3513
3514 p = pr_p_lock(dpnp);
3515 mutex_exit(&pr_pidlock);
3516 if (p == NULL) {
3517 prfreenode(pnp);
3518 return (NULL);
3519 }
3520 if (dpnp->pr_pcommon->prc_flags & PRC_DESTROY) {
3521 switch (type) {
3522 case PR_PSINFO:
3523 case PR_USAGE:
3524 break;
3525 default:
3526 prunlock(dpnp);
3527 prfreenode(pnp);
3528 return (NULL);
3529 }
3530 }
3531
3532 switch (type) {
3533 case PR_CURDIR:
3534 case PR_ROOTDIR:
3535 up = PTOU(p);
3536 vp = (type == PR_CURDIR)? up->u_cdir :
3537 (up->u_rdir? up->u_rdir : rootdir);
3538
3539 if (vp == NULL) { /* can't happen? */
3540 prunlock(dpnp);
3541 prfreenode(pnp);
3542 return (NULL);
3543 }
3544 /*
3545 * Fill in the prnode so future references will
3546 * be able to find the underlying object's vnode.
3547 */
3548 VN_HOLD(vp);
3549 pnp->pr_realvp = vp;
3550 break;
3551 default:
3552 break;
3553 }
3554
3555 mutex_enter(&dpnp->pr_mutex);
3556
3557 if ((vp = dpnp->pr_files[i]) != NULL &&
3558 !(VTOP(vp)->pr_flags & PR_INVAL)) {
3559 VN_HOLD(vp);
3560 mutex_exit(&dpnp->pr_mutex);
3561 prunlock(dpnp);
3562 prfreenode(pnp);
3563 return (vp);
3564 }
3565
3566 /*
3567 * prgetnode() initialized most of the prnode.
3568 * Finish the job.
3569 */
3570 pnp->pr_common = dpnp->pr_common;
3571 pnp->pr_pcommon = dpnp->pr_pcommon;
3572 pnp->pr_parent = dp;
3573 VN_HOLD(dp);
3574 pnp->pr_index = i;
3575
3576 dpnp->pr_files[i] = vp = PTOV(pnp);
3577
3578 /*
3579 * Link new vnode into list of all /proc vnodes for the process.
3580 */
3581 if (vp->v_type == VPROC) {
3582 pnp->pr_next = p->p_plist;
3583 p->p_plist = vp;
3584 }
3585 mutex_exit(&dpnp->pr_mutex);
3586 prunlock(dpnp);
3587 return (vp);
3588 }
3589
3590 static vnode_t *
3591 pr_lookup_objectdir(vnode_t *dp, char *comp)
3592 {
3593 prnode_t *dpnp = VTOP(dp);
3594 prnode_t *pnp;
3595 proc_t *p;
3596 struct seg *seg;
3597 struct as *as;
3598 vnode_t *vp;
3599 vattr_t vattr;
3600
3601 ASSERT(dpnp->pr_type == PR_OBJECTDIR);
3602
3603 pnp = prgetnode(dp, PR_OBJECT);
3604
3605 if (prlock(dpnp, ZNO) != 0) {
3606 prfreenode(pnp);
3607 return (NULL);
3608 }
3609 p = dpnp->pr_common->prc_proc;
3610 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
3611 prunlock(dpnp);
3612 prfreenode(pnp);
3613 return (NULL);
3614 }
3615
3616 /*
3617 * We drop p_lock before grabbing the address space lock
3618 * in order to avoid a deadlock with the clock thread.
3619 * The process will not disappear and its address space
3620 * will not change because it is marked P_PR_LOCK.
3621 */
3622 mutex_exit(&p->p_lock);
3623 AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
3624 if ((seg = AS_SEGFIRST(as)) == NULL) {
3625 vp = NULL;
3626 goto out;
3627 }
3628 if (strcmp(comp, "a.out") == 0) {
3629 vp = p->p_exec;
3630 goto out;
3631 }
3632 do {
3633 /*
3634 * Manufacture a filename for the "object" directory.
3635 */
3636 vattr.va_mask = AT_FSID|AT_NODEID;
3637 if (seg->s_ops == &segvn_ops &&
3638 SEGOP_GETVP(seg, seg->s_base, &vp) == 0 &&
3639 vp != NULL && vp->v_type == VREG &&
3640 VOP_GETATTR(vp, &vattr, 0, CRED(), NULL) == 0) {
3641 char name[64];
3642
3643 if (vp == p->p_exec) /* "a.out" */
3644 continue;
3645 pr_object_name(name, vp, &vattr);
3646 if (strcmp(name, comp) == 0)
3647 goto out;
3648 }
3649 } while ((seg = AS_SEGNEXT(as, seg)) != NULL);
3650
3651 vp = NULL;
3652 out:
3653 if (vp != NULL) {
3654 VN_HOLD(vp);
3655 }
3656 AS_LOCK_EXIT(as, &as->a_lock);
3657 mutex_enter(&p->p_lock);
3658 prunlock(dpnp);
3659
3660 if (vp == NULL)
3661 prfreenode(pnp);
3662 else {
3663 /*
3664 * Fill in the prnode so future references will
3665 * be able to find the underlying object's vnode.
3666 * Don't link this prnode into the list of all
3667 * prnodes for the process; this is a one-use node.
3668 * Its use is entirely to catch and fail opens for writing.
3669 */
3670 pnp->pr_realvp = vp;
3671 vp = PTOV(pnp);
3672 }
3673
3674 return (vp);
3675 }
3676
3677 /*
3678 * Find or construct an lwp vnode for the given lwpid.
3679 */
3680 static vnode_t *
3681 pr_lookup_lwpdir(vnode_t *dp, char *comp)
3682 {
3683 id_t tid; /* same type as t->t_tid */
3684 int want_agent;
3685 prnode_t *dpnp = VTOP(dp);
3686 prnode_t *pnp;
3687 prcommon_t *pcp;
3688 vnode_t *vp;
3689 proc_t *p;
3690 kthread_t *t;
3691 lwpdir_t *ldp;
3692 lwpent_t *lep;
3693 int tslot;
3694 int c;
3695
3696 ASSERT(dpnp->pr_type == PR_LWPDIR);
3697
3698 tid = 0;
3699 if (strcmp(comp, "agent") == 0)
3700 want_agent = 1;
3701 else {
3702 want_agent = 0;
3703 while ((c = *comp++) != '\0') {
3704 id_t otid;
3705
3706 if (c < '0' || c > '9')
3707 return (NULL);
3708 otid = tid;
3709 tid = 10*tid + c - '0';
3710 if (tid/10 != otid) /* integer overflow */
3711 return (NULL);
3712 }
3713 }
3714
3715 pnp = prgetnode(dp, PR_LWPIDDIR);
3716
3717 p = pr_p_lock(dpnp);
3718 mutex_exit(&pr_pidlock);
3719 if (p == NULL) {
3720 prfreenode(pnp);
3721 return (NULL);
3722 }
3723
3724 if (want_agent) {
3725 if ((t = p->p_agenttp) == NULL)
3726 lep = NULL;
3727 else {
3728 tid = t->t_tid;
3729 tslot = t->t_dslot;
3730 lep = p->p_lwpdir[tslot].ld_entry;
3731 }
3732 } else {
3733 if ((ldp = lwp_hash_lookup(p, tid)) == NULL)
3734 lep = NULL;
3735 else {
3736 tslot = (int)(ldp - p->p_lwpdir);
3737 lep = ldp->ld_entry;
3738 }
3739 }
3740
3741 if (lep == NULL) {
3742 prunlock(dpnp);
3743 prfreenode(pnp);
3744 return (NULL);
3745 }
3746
3747 /*
3748 * If an lwp vnode already exists and it is not invalid
3749 * and it was created by the current process and it belongs
3750 * to the same /proc mount point as our parent vnode, then
3751 * just use it and discard the newly-allocated prnode.
3752 */
3753 for (vp = lep->le_trace; vp != NULL; vp = VTOP(vp)->pr_next) {
3754 if (!(VTOP(vp)->pr_flags & PR_INVAL) &&
3755 VTOP(vp)->pr_owner == curproc &&
3756 vp->v_vfsp == dp->v_vfsp) {
3757 VN_HOLD(vp);
3758 prunlock(dpnp);
3759 prfreenode(pnp);
3760 return (vp);
3761 }
3762 }
3763 pnp->pr_owner = curproc;
3764
3765 /*
3766 * prgetnode() initialized most of the prnode.
3767 * Finish the job.
3768 */
3769 pcp = pnp->pr_common; /* the newly-allocated prcommon struct */
3770 if ((vp = lep->le_trace) != NULL) {
3771 /* discard the new prcommon and use the existing prcommon */
3772 prfreecommon(pcp);
3773 pcp = VTOP(vp)->pr_common;
3774 mutex_enter(&pcp->prc_mutex);
3775 ASSERT(pcp->prc_refcnt > 0);
3776 pcp->prc_refcnt++;
3777 mutex_exit(&pcp->prc_mutex);
3778 pnp->pr_common = pcp;
3779 } else {
3780 /* initialize the new prcommon struct */
3781 pcp->prc_flags |= PRC_LWP;
3782 if ((p->p_flag & SSYS) || p->p_as == &kas)
3783 pcp->prc_flags |= PRC_SYS;
3784 if ((t = lep->le_thread) == NULL)
3785 pcp->prc_flags |= PRC_DESTROY;
3786 pcp->prc_proc = p;
3787 pcp->prc_datamodel = dpnp->pr_pcommon->prc_datamodel;
3788 pcp->prc_pid = p->p_pid;
3789 pcp->prc_slot = p->p_slot;
3790 pcp->prc_thread = t;
3791 pcp->prc_tid = tid;
3792 pcp->prc_tslot = tslot;
3793 }
3794 pnp->pr_pcommon = dpnp->pr_pcommon;
3795 pnp->pr_parent = dp;
3796 VN_HOLD(dp);
3797 /*
3798 * Link in the old, invalid directory vnode so we
3799 * can later determine the last close of the file.
3800 */
3801 pnp->pr_next = lep->le_trace;
3802 lep->le_trace = vp = PTOV(pnp);
3803 prunlock(dpnp);
3804 return (vp);
3805 }
3806
3807 static vnode_t *
3808 pr_lookup_lwpiddir(vnode_t *dp, char *comp)
3809 {
3810 prnode_t *dpnp = VTOP(dp);
3811 vnode_t *vp;
3812 prnode_t *pnp;
3813 proc_t *p;
3814 prdirent_t *dirp;
3815 int i;
3816 enum prnodetype type;
3817
3818 ASSERT(dpnp->pr_type == PR_LWPIDDIR);
3819
3820 for (i = 0; i < NLWPIDDIRFILES; i++) {
3821 /* Skip "." and ".." */
3822 dirp = &lwpiddir[i+2];
3823 if (strcmp(comp, dirp->d_name) == 0)
3824 break;
3825 }
3826
3827 if (i >= NLWPIDDIRFILES)
3828 return (NULL);
3829
3830 type = (int)dirp->d_ino;
3831 pnp = prgetnode(dp, type);
3832
3833 p = pr_p_lock(dpnp);
3834 mutex_exit(&pr_pidlock);
3835 if (p == NULL) {
3836 prfreenode(pnp);
3837 return (NULL);
3838 }
3839 if (dpnp->pr_common->prc_flags & PRC_DESTROY) {
3840 /*
3841 * Only the lwpsinfo file is present for zombie lwps.
3842 * Nothing is present if the lwp has been reaped.
3843 */
3844 if (dpnp->pr_common->prc_tslot == -1 ||
3845 type != PR_LWPSINFO) {
3846 prunlock(dpnp);
3847 prfreenode(pnp);
3848 return (NULL);
3849 }
3850 }
3851
3852 #if defined(__sparc)
3853 /* the asrs file exists only for sparc v9 _LP64 processes */
3854 if (type == PR_ASRS && p->p_model != DATAMODEL_LP64) {
3855 prunlock(dpnp);
3856 prfreenode(pnp);
3857 return (NULL);
3858 }
3859 #endif
3860
3861 mutex_enter(&dpnp->pr_mutex);
3862
3863 if ((vp = dpnp->pr_files[i]) != NULL &&
3864 !(VTOP(vp)->pr_flags & PR_INVAL)) {
3865 VN_HOLD(vp);
3866 mutex_exit(&dpnp->pr_mutex);
3867 prunlock(dpnp);
3868 prfreenode(pnp);
3869 return (vp);
3870 }
3871
3872 /*
3873 * prgetnode() initialized most of the prnode.
3874 * Finish the job.
3875 */
3876 pnp->pr_common = dpnp->pr_common;
3877 pnp->pr_pcommon = dpnp->pr_pcommon;
3878 pnp->pr_parent = dp;
3879 VN_HOLD(dp);
3880 pnp->pr_index = i;
3881
3882 dpnp->pr_files[i] = vp = PTOV(pnp);
3883
3884 /*
3885 * Link new vnode into list of all /proc vnodes for the process.
3886 */
3887 if (vp->v_type == VPROC) {
3888 pnp->pr_next = p->p_plist;
3889 p->p_plist = vp;
3890 }
3891 mutex_exit(&dpnp->pr_mutex);
3892 prunlock(dpnp);
3893 return (vp);
3894 }
3895
3896 /*
3897 * Lookup one of the process's open files.
3898 */
3899 static vnode_t *
3900 pr_lookup_fddir(vnode_t *dp, char *comp)
3901 {
3902 prnode_t *dpnp = VTOP(dp);
3903 prnode_t *pnp;
3904 vnode_t *vp = NULL;
3905 proc_t *p;
3906 file_t *fp;
3907 uint_t fd;
3908 int c;
3909 uf_entry_t *ufp;
3910 uf_info_t *fip;
3911
3912 ASSERT(dpnp->pr_type == PR_FDDIR);
3913
3914 fd = 0;
3915 while ((c = *comp++) != '\0') {
3916 int ofd;
3917 if (c < '0' || c > '9')
3918 return (NULL);
3919 ofd = fd;
3920 fd = 10*fd + c - '0';
3921 if (fd/10 != ofd) /* integer overflow */
3922 return (NULL);
3923 }
3924
3925 pnp = prgetnode(dp, PR_FD);
3926
3927 if (prlock(dpnp, ZNO) != 0) {
3928 prfreenode(pnp);
3929 return (NULL);
3930 }
3931 p = dpnp->pr_common->prc_proc;
3932 if ((p->p_flag & SSYS) || p->p_as == &kas) {
3933 prunlock(dpnp);
3934 prfreenode(pnp);
3935 return (NULL);
3936 }
3937
3938 fip = P_FINFO(p);
3939 mutex_exit(&p->p_lock);
3940 mutex_enter(&fip->fi_lock);
3941 if (fd < fip->fi_nfiles) {
3942 UF_ENTER(ufp, fip, fd);
3943 if ((fp = ufp->uf_file) != NULL) {
3944 pnp->pr_mode = 07111;
3945 if (fp->f_flag & FREAD)
3946 pnp->pr_mode |= 0444;
3947 if (fp->f_flag & FWRITE)
3948 pnp->pr_mode |= 0222;
3949 vp = fp->f_vnode;
3950 VN_HOLD(vp);
3951 }
3952 UF_EXIT(ufp);
3953 }
3954 mutex_exit(&fip->fi_lock);
3955 mutex_enter(&p->p_lock);
3956 prunlock(dpnp);
3957
3958 if (vp == NULL)
3959 prfreenode(pnp);
3960 else {
3961 /*
3962 * Fill in the prnode so future references will
3963 * be able to find the underlying object's vnode.
3964 * Don't link this prnode into the list of all
3965 * prnodes for the process; this is a one-use node.
3966 */
3967 pnp->pr_realvp = vp;
3968 pnp->pr_parent = dp; /* needed for prlookup */
3969 VN_HOLD(dp);
3970 vp = PTOV(pnp);
3971 if (pnp->pr_realvp->v_type == VDIR)
3972 vp->v_type = VDIR;
3973 }
3974
3975 return (vp);
3976 }
3977
3978 static vnode_t *
3979 pr_lookup_pathdir(vnode_t *dp, char *comp)
3980 {
3981 prnode_t *dpnp = VTOP(dp);
3982 prnode_t *pnp;
3983 vnode_t *vp = NULL;
3984 proc_t *p;
3985 uint_t fd, flags = 0;
3986 int c;
3987 uf_entry_t *ufp;
3988 uf_info_t *fip;
3989 enum { NAME_FD, NAME_OBJECT, NAME_ROOT, NAME_CWD, NAME_UNKNOWN } type;
3990 char *tmp;
3991 int idx;
3992 struct seg *seg;
3993 struct as *as = NULL;
3994 vattr_t vattr;
3995
3996 ASSERT(dpnp->pr_type == PR_PATHDIR);
3997
3998 /*
3999 * First, check if this is a numeric entry, in which case we have a
4000 * file descriptor.
4001 */
4002 fd = 0;
4003 type = NAME_FD;
4004 tmp = comp;
4005 while ((c = *tmp++) != '\0') {
4006 int ofd;
4007 if (c < '0' || c > '9') {
4008 type = NAME_UNKNOWN;
4009 break;
4010 }
4011 ofd = fd;
4012 fd = 10*fd + c - '0';
4013 if (fd/10 != ofd) { /* integer overflow */
4014 type = NAME_UNKNOWN;
4015 break;
4016 }
4017 }
4018
4019 /*
4020 * Next, see if it is one of the special values {root, cwd}.
4021 */
4022 if (type == NAME_UNKNOWN) {
4023 if (strcmp(comp, "root") == 0)
4024 type = NAME_ROOT;
4025 else if (strcmp(comp, "cwd") == 0)
4026 type = NAME_CWD;
4027 }
4028
4029 /*
4030 * Grab the necessary data from the process
4031 */
4032 if (prlock(dpnp, ZNO) != 0)
4033 return (NULL);
4034 p = dpnp->pr_common->prc_proc;
4035
4036 fip = P_FINFO(p);
4037
4038 switch (type) {
4039 case NAME_ROOT:
4040 if ((vp = PTOU(p)->u_rdir) == NULL)
4041 vp = p->p_zone->zone_rootvp;
4042 VN_HOLD(vp);
4043 break;
4044 case NAME_CWD:
4045 vp = PTOU(p)->u_cdir;
4046 VN_HOLD(vp);
4047 break;
4048 default:
4049 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
4050 prunlock(dpnp);
4051 return (NULL);
4052 }
4053 }
4054 mutex_exit(&p->p_lock);
4055
4056 /*
4057 * Determine if this is an object entry
4058 */
4059 if (type == NAME_UNKNOWN) {
4060 /*
4061 * Start with the inode index immediately after the number of
4062 * files.
4063 */
4064 mutex_enter(&fip->fi_lock);
4065 idx = fip->fi_nfiles + 4;
4066 mutex_exit(&fip->fi_lock);
4067
4068 if (strcmp(comp, "a.out") == 0) {
4069 if (p->p_execdir != NULL) {
4070 vp = p->p_execdir;
4071 VN_HOLD(vp);
4072 type = NAME_OBJECT;
4073 flags |= PR_AOUT;
4074 } else {
4075 vp = p->p_exec;
4076 VN_HOLD(vp);
4077 type = NAME_OBJECT;
4078 }
4079 } else {
4080 AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
4081 if ((seg = AS_SEGFIRST(as)) != NULL) {
4082 do {
4083 /*
4084 * Manufacture a filename for the
4085 * "object" directory.
4086 */
4087 vattr.va_mask = AT_FSID|AT_NODEID;
4088 if (seg->s_ops == &segvn_ops &&
4089 SEGOP_GETVP(seg, seg->s_base, &vp)
4090 == 0 &&
4091 vp != NULL && vp->v_type == VREG &&
4092 VOP_GETATTR(vp, &vattr, 0, CRED(),
4093 NULL) == 0) {
4094 char name[64];
4095
4096 if (vp == p->p_exec)
4097 continue;
4098 idx++;
4099 pr_object_name(name, vp,
4100 &vattr);
4101 if (strcmp(name, comp) == 0)
4102 break;
4103 }
4104 } while ((seg = AS_SEGNEXT(as, seg)) != NULL);
4105 }
4106
4107 if (seg == NULL) {
4108 vp = NULL;
4109 } else {
4110 VN_HOLD(vp);
4111 type = NAME_OBJECT;
4112 }
4113
4114 AS_LOCK_EXIT(as, &as->a_lock);
4115 }
4116 }
4117
4118
4119 switch (type) {
4120 case NAME_FD:
4121 mutex_enter(&fip->fi_lock);
4122 if (fd < fip->fi_nfiles) {
4123 UF_ENTER(ufp, fip, fd);
4124 if (ufp->uf_file != NULL) {
4125 vp = ufp->uf_file->f_vnode;
4126 VN_HOLD(vp);
4127 }
4128 UF_EXIT(ufp);
4129 }
4130 mutex_exit(&fip->fi_lock);
4131 idx = fd + 4;
4132 break;
4133 case NAME_ROOT:
4134 idx = 2;
4135 break;
4136 case NAME_CWD:
4137 idx = 3;
4138 break;
4139 case NAME_OBJECT:
4140 case NAME_UNKNOWN:
4141 /* Nothing to do */
4142 break;
4143 }
4144
4145 mutex_enter(&p->p_lock);
4146 prunlock(dpnp);
4147
4148 if (vp != NULL) {
4149 pnp = prgetnode(dp, PR_PATH);
4150
4151 pnp->pr_flags |= flags;
4152 pnp->pr_common = dpnp->pr_common;
4153 pnp->pr_pcommon = dpnp->pr_pcommon;
4154 pnp->pr_realvp = vp;
4155 pnp->pr_parent = dp; /* needed for prlookup */
4156 pnp->pr_ino = pmkino(idx, dpnp->pr_common->prc_slot, PR_PATH);
4157 VN_HOLD(dp);
4158 vp = PTOV(pnp);
4159 vp->v_type = VLNK;
4160 }
4161
4162 return (vp);
4163 }
4164
4165 /*
4166 * Look up one of the process's active templates.
4167 */
4168 static vnode_t *
4169 pr_lookup_tmpldir(vnode_t *dp, char *comp)
4170 {
4171 prnode_t *dpnp = VTOP(dp);
4172 prnode_t *pnp;
4173 vnode_t *vp = NULL;
4174 proc_t *p;
4175 int i;
4176
4177 ASSERT(dpnp->pr_type == PR_TMPLDIR);
4178
4179 for (i = 0; i < ct_ntypes; i++)
4180 if (strcmp(comp, ct_types[i]->ct_type_name) == 0)
4181 break;
4182 if (i == ct_ntypes)
4183 return (NULL);
4184
4185 pnp = prgetnode(dp, PR_TMPL);
4186
4187 if (prlock(dpnp, ZNO) != 0) {
4188 prfreenode(pnp);
4189 return (NULL);
4190 }
4191 p = dpnp->pr_common->prc_proc;
4192 if ((p->p_flag & SSYS) || p->p_as == &kas ||
4193 (dpnp->pr_common->prc_flags & (PRC_DESTROY | PRC_LWP)) != PRC_LWP) {
4194 prunlock(dpnp);
4195 prfreenode(pnp);
4196 return (NULL);
4197 }
4198 if (ttolwp(dpnp->pr_common->prc_thread)->lwp_ct_active[i] != NULL) {
4199 pnp->pr_common = dpnp->pr_common;
4200 pnp->pr_pcommon = dpnp->pr_pcommon;
4201 pnp->pr_parent = dp;
4202 pnp->pr_cttype = i;
4203 VN_HOLD(dp);
4204 vp = PTOV(pnp);
4205 } else {
4206 prfreenode(pnp);
4207 }
4208 prunlock(dpnp);
4209
4210 return (vp);
4211 }
4212
4213 /*
4214 * Look up one of the contracts owned by the process.
4215 */
4216 static vnode_t *
4217 pr_lookup_ctdir(vnode_t *dp, char *comp)
4218 {
4219 prnode_t *dpnp = VTOP(dp);
4220 prnode_t *pnp;
4221 vnode_t *vp = NULL;
4222 proc_t *p;
4223 id_t id = 0;
4224 contract_t *ct;
4225 int c;
4226
4227 ASSERT(dpnp->pr_type == PR_CTDIR);
4228
4229 while ((c = *comp++) != '\0') {
4230 id_t oid;
4231 if (c < '0' || c > '9')
4232 return (NULL);
4233 oid = id;
4234 id = 10 * id + c - '0';
4235 if (id / 10 != oid) /* integer overflow */
4236 return (NULL);
4237 }
4238
4239 /*
4240 * Search all contracts; we'll filter below.
4241 */
4242 ct = contract_ptr(id, GLOBAL_ZONEUNIQID);
4243 if (ct == NULL)
4244 return (NULL);
4245
4246 pnp = prgetnode(dp, PR_CT);
4247
4248 if (prlock(dpnp, ZNO) != 0) {
4249 prfreenode(pnp);
4250 contract_rele(ct);
4251 return (NULL);
4252 }
4253 p = dpnp->pr_common->prc_proc;
4254 /*
4255 * We only allow lookups of contracts owned by this process, or,
4256 * if we are zsched and this is a zone's procfs, contracts on
4257 * stuff in the zone which are held by processes or contracts
4258 * outside the zone. (see logic in contract_status_common)
4259 */
4260 if ((ct->ct_owner != p) &&
4261 !(p == VTOZONE(dp)->zone_zsched && ct->ct_state < CTS_ORPHAN &&
4262 VTOZONE(dp)->zone_uniqid == contract_getzuniqid(ct) &&
4263 VTOZONE(dp)->zone_uniqid != GLOBAL_ZONEUNIQID &&
4264 ct->ct_czuniqid == GLOBAL_ZONEUNIQID)) {
4265 prunlock(dpnp);
4266 prfreenode(pnp);
4267 contract_rele(ct);
4268 return (NULL);
4269 }
4270 pnp->pr_common = dpnp->pr_common;
4271 pnp->pr_pcommon = dpnp->pr_pcommon;
4272 pnp->pr_contract = ct;
4273 pnp->pr_parent = dp;
4274 pnp->pr_ino = pmkino(id, pnp->pr_common->prc_slot, PR_CT);
4275 VN_HOLD(dp);
4276 prunlock(dpnp);
4277 vp = PTOV(pnp);
4278
4279 return (vp);
4280 }
4281
4282 /*
4283 * Construct an lwp vnode for the old /proc interface.
4284 * We stand on our head to make the /proc plumbing correct.
4285 */
4286 vnode_t *
4287 prlwpnode(prnode_t *pnp, uint_t tid)
4288 {
4289 char comp[12];
4290 vnode_t *dp;
4291 vnode_t *vp;
4292 prcommon_t *pcp;
4293 proc_t *p;
4294
4295 /*
4296 * Lookup the /proc/<pid>/lwp/<lwpid> directory vnode.
4297 */
4298 if (pnp->pr_type == PR_PIDFILE) {
4299 dp = pnp->pr_parent; /* /proc/<pid> */
4300 VN_HOLD(dp);
4301 vp = pr_lookup_piddir(dp, "lwp");
4302 VN_RELE(dp);
4303 if ((dp = vp) == NULL) /* /proc/<pid>/lwp */
4304 return (NULL);
4305 } else if (pnp->pr_type == PR_LWPIDFILE) {
4306 dp = pnp->pr_parent; /* /proc/<pid>/lwp/<lwpid> */
4307 dp = VTOP(dp)->pr_parent; /* /proc/<pid>/lwp */
4308 VN_HOLD(dp);
4309 } else {
4310 return (NULL);
4311 }
4312
4313 (void) pr_u32tos(tid, comp, sizeof (comp));
4314 vp = pr_lookup_lwpdir(dp, comp);
4315 VN_RELE(dp);
4316 if ((dp = vp) == NULL)
4317 return (NULL);
4318
4319 pnp = prgetnode(dp, PR_LWPIDFILE);
4320 vp = PTOV(pnp);
4321
4322 /*
4323 * prgetnode() initialized most of the prnode.
4324 * Finish the job.
4325 */
4326 pcp = VTOP(dp)->pr_common;
4327 pnp->pr_ino = ptoi(pcp->prc_pid);
4328 pnp->pr_common = pcp;
4329 pnp->pr_pcommon = VTOP(dp)->pr_pcommon;
4330 pnp->pr_parent = dp;
4331 /*
4332 * Link new vnode into list of all /proc vnodes for the process.
4333 */
4334 p = pr_p_lock(pnp);
4335 mutex_exit(&pr_pidlock);
4336 if (p == NULL) {
4337 VN_RELE(dp);
4338 prfreenode(pnp);
4339 vp = NULL;
4340 } else if (pcp->prc_thread == NULL) {
4341 prunlock(pnp);
4342 VN_RELE(dp);
4343 prfreenode(pnp);
4344 vp = NULL;
4345 } else {
4346 pnp->pr_next = p->p_plist;
4347 p->p_plist = vp;
4348 prunlock(pnp);
4349 }
4350
4351 return (vp);
4352 }
4353
4354 #if defined(DEBUG)
4355
4356 static uint32_t nprnode;
4357 static uint32_t nprcommon;
4358
4359 #define INCREMENT(x) atomic_add_32(&x, 1);
4360 #define DECREMENT(x) atomic_add_32(&x, -1);
4361
4362 #else
4363
4364 #define INCREMENT(x)
4365 #define DECREMENT(x)
4366
4367 #endif /* DEBUG */
4368
4369 /*
4370 * New /proc vnode required; allocate it and fill in most of the fields.
4371 */
4372 prnode_t *
4373 prgetnode(vnode_t *dp, prnodetype_t type)
4374 {
4375 prnode_t *pnp;
4376 prcommon_t *pcp;
4377 vnode_t *vp;
4378 ulong_t nfiles;
4379
4380 INCREMENT(nprnode);
4381 pnp = kmem_zalloc(sizeof (prnode_t), KM_SLEEP);
4382
4383 mutex_init(&pnp->pr_mutex, NULL, MUTEX_DEFAULT, NULL);
4384 pnp->pr_type = type;
4385
4386 pnp->pr_vnode = vn_alloc(KM_SLEEP);
4387
4388 vp = PTOV(pnp);
4389 vp->v_flag = VNOCACHE|VNOMAP|VNOSWAP|VNOMOUNT;
4390 vn_setops(vp, prvnodeops);
4391 vp->v_vfsp = dp->v_vfsp;
4392 vp->v_type = VPROC;
4393 vp->v_data = (caddr_t)pnp;
4394
4395 switch (type) {
4396 case PR_PIDDIR:
4397 case PR_LWPIDDIR:
4398 /*
4399 * We need a prcommon and a files array for each of these.
4400 */
4401 INCREMENT(nprcommon);
4402
4403 pcp = kmem_zalloc(sizeof (prcommon_t), KM_SLEEP);
4404 pcp->prc_refcnt = 1;
4405 pnp->pr_common = pcp;
4406 mutex_init(&pcp->prc_mutex, NULL, MUTEX_DEFAULT, NULL);
4407 cv_init(&pcp->prc_wait, NULL, CV_DEFAULT, NULL);
4408
4409 nfiles = (type == PR_PIDDIR)? NPIDDIRFILES : NLWPIDDIRFILES;
4410 pnp->pr_files =
4411 kmem_zalloc(nfiles * sizeof (vnode_t *), KM_SLEEP);
4412
4413 vp->v_type = VDIR;
4414 /*
4415 * Mode should be read-search by all, but we cannot so long
4416 * as we must support compatibility mode with old /proc.
4417 * Make /proc/<pid> be read by owner only, search by all.
4418 * Make /proc/<pid>/lwp/<lwpid> read-search by all. Also,
4419 * set VDIROPEN on /proc/<pid> so it can be opened for writing.
4420 */
4421 if (type == PR_PIDDIR) {
4422 /* kludge for old /proc interface */
4423 prnode_t *xpnp = prgetnode(dp, PR_PIDFILE);
4424 pnp->pr_pidfile = PTOV(xpnp);
4425 pnp->pr_mode = 0511;
4426 vp->v_flag |= VDIROPEN;
4427 } else {
4428 pnp->pr_mode = 0555;
4429 }
4430
4431 break;
4432
4433 case PR_CURDIR:
4434 case PR_ROOTDIR:
4435 case PR_FDDIR:
4436 case PR_OBJECTDIR:
4437 case PR_PATHDIR:
4438 case PR_CTDIR:
4439 case PR_TMPLDIR:
4440 vp->v_type = VDIR;
4441 pnp->pr_mode = 0500; /* read-search by owner only */
4442 break;
4443
4444 case PR_CT:
4445 vp->v_type = VLNK;
4446 pnp->pr_mode = 0500; /* read-search by owner only */
4447 break;
4448
4449 case PR_PATH:
4450 case PR_SELF:
4451 vp->v_type = VLNK;
4452 pnp->pr_mode = 0777;
4453 break;
4454
4455 case PR_LWPDIR:
4456 vp->v_type = VDIR;
4457 pnp->pr_mode = 0555; /* read-search by all */
4458 break;
4459
4460 case PR_AS:
4461 case PR_TMPL:
4462 pnp->pr_mode = 0600; /* read-write by owner only */
4463 break;
4464
4465 case PR_CTL:
4466 case PR_LWPCTL:
4467 pnp->pr_mode = 0200; /* write-only by owner only */
4468 break;
4469
4470 case PR_PIDFILE:
4471 case PR_LWPIDFILE:
4472 pnp->pr_mode = 0600; /* read-write by owner only */
4473 break;
4474
4475 case PR_PSINFO:
4476 case PR_LPSINFO:
4477 case PR_LWPSINFO:
4478 case PR_USAGE:
4479 case PR_LUSAGE:
4480 case PR_LWPUSAGE:
4481 pnp->pr_mode = 0444; /* read-only by all */
4482 break;
4483
4484 default:
4485 pnp->pr_mode = 0400; /* read-only by owner only */
4486 break;
4487 }
4488 vn_exists(vp);
4489 return (pnp);
4490 }
4491
4492 /*
4493 * Free the storage obtained from prgetnode().
4494 */
4495 void
4496 prfreenode(prnode_t *pnp)
4497 {
4498 vnode_t *vp;
4499 ulong_t nfiles;
4500
4501 vn_invalid(PTOV(pnp));
4502 vn_free(PTOV(pnp));
4503 mutex_destroy(&pnp->pr_mutex);
4504
4505 switch (pnp->pr_type) {
4506 case PR_PIDDIR:
4507 /* kludge for old /proc interface */
4508 if (pnp->pr_pidfile != NULL) {
4509 prfreenode(VTOP(pnp->pr_pidfile));
4510 pnp->pr_pidfile = NULL;
4511 }
4512 /* FALLTHROUGH */
4513 case PR_LWPIDDIR:
4514 /*
4515 * We allocated a prcommon and a files array for each of these.
4516 */
4517 prfreecommon(pnp->pr_common);
4518 nfiles = (pnp->pr_type == PR_PIDDIR)?
4519 NPIDDIRFILES : NLWPIDDIRFILES;
4520 kmem_free(pnp->pr_files, nfiles * sizeof (vnode_t *));
4521 break;
4522 default:
4523 break;
4524 }
4525 /*
4526 * If there is an underlying vnode, be sure
4527 * to release it after freeing the prnode.
4528 */
4529 vp = pnp->pr_realvp;
4530 kmem_free(pnp, sizeof (*pnp));
4531 DECREMENT(nprnode);
4532 if (vp != NULL) {
4533 VN_RELE(vp);
4534 }
4535 }
4536
4537 /*
4538 * Free a prcommon structure, if the reference count reaches zero.
4539 */
4540 static void
4541 prfreecommon(prcommon_t *pcp)
4542 {
4543 mutex_enter(&pcp->prc_mutex);
4544 ASSERT(pcp->prc_refcnt > 0);
4545 if (--pcp->prc_refcnt != 0)
4546 mutex_exit(&pcp->prc_mutex);
4547 else {
4548 mutex_exit(&pcp->prc_mutex);
4549 ASSERT(pcp->prc_pollhead.ph_list == NULL);
4550 ASSERT(pcp->prc_refcnt == 0);
4551 ASSERT(pcp->prc_selfopens == 0 && pcp->prc_writers == 0);
4552 mutex_destroy(&pcp->prc_mutex);
4553 cv_destroy(&pcp->prc_wait);
4554 kmem_free(pcp, sizeof (prcommon_t));
4555 DECREMENT(nprcommon);
4556 }
4557 }
4558
4559 /*
4560 * Array of readdir functions, indexed by /proc file type.
4561 */
4562 static int pr_readdir_notdir(), pr_readdir_procdir(), pr_readdir_piddir(),
4563 pr_readdir_objectdir(), pr_readdir_lwpdir(), pr_readdir_lwpiddir(),
4564 pr_readdir_fddir(), pr_readdir_pathdir(), pr_readdir_tmpldir(),
4565 pr_readdir_ctdir();
4566
4567 static int (*pr_readdir_function[PR_NFILES])() = {
4568 pr_readdir_procdir, /* /proc */
4569 pr_readdir_notdir, /* /proc/self */
4570 pr_readdir_piddir, /* /proc/<pid> */
4571 pr_readdir_notdir, /* /proc/<pid>/as */
4572 pr_readdir_notdir, /* /proc/<pid>/ctl */
4573 pr_readdir_notdir, /* /proc/<pid>/status */
4574 pr_readdir_notdir, /* /proc/<pid>/lstatus */
4575 pr_readdir_notdir, /* /proc/<pid>/psinfo */
4576 pr_readdir_notdir, /* /proc/<pid>/lpsinfo */
4577 pr_readdir_notdir, /* /proc/<pid>/map */
4578 pr_readdir_notdir, /* /proc/<pid>/rmap */
4579 pr_readdir_notdir, /* /proc/<pid>/xmap */
4580 pr_readdir_notdir, /* /proc/<pid>/cred */
4581 pr_readdir_notdir, /* /proc/<pid>/sigact */
4582 pr_readdir_notdir, /* /proc/<pid>/auxv */
4583 #if defined(__x86)
4584 pr_readdir_notdir, /* /proc/<pid>/ldt */
4585 #endif
4586 pr_readdir_notdir, /* /proc/<pid>/usage */
4587 pr_readdir_notdir, /* /proc/<pid>/lusage */
4588 pr_readdir_notdir, /* /proc/<pid>/pagedata */
4589 pr_readdir_notdir, /* /proc/<pid>/watch */
4590 pr_readdir_notdir, /* /proc/<pid>/cwd */
4591 pr_readdir_notdir, /* /proc/<pid>/root */
4592 pr_readdir_fddir, /* /proc/<pid>/fd */
4593 pr_readdir_notdir, /* /proc/<pid>/fd/nn */
4594 pr_readdir_objectdir, /* /proc/<pid>/object */
4595 pr_readdir_notdir, /* /proc/<pid>/object/xxx */
4596 pr_readdir_lwpdir, /* /proc/<pid>/lwp */
4597 pr_readdir_lwpiddir, /* /proc/<pid>/lwp/<lwpid> */
4598 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
4599 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
4600 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
4601 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
4602 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/xregs */
4603 pr_readdir_tmpldir, /* /proc/<pid>/lwp/<lwpid>/templates */
4604 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
4605 #if defined(__sparc)
4606 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/gwindows */
4607 pr_readdir_notdir, /* /proc/<pid>/lwp/<lwpid>/asrs */
4608 #endif
4609 pr_readdir_notdir, /* /proc/<pid>/priv */
4610 pr_readdir_pathdir, /* /proc/<pid>/path */
4611 pr_readdir_notdir, /* /proc/<pid>/path/xxx */
4612 pr_readdir_ctdir, /* /proc/<pid>/contracts */
4613 pr_readdir_notdir, /* /proc/<pid>/contracts/<ctid> */
4614 pr_readdir_notdir, /* old process file */
4615 pr_readdir_notdir, /* old lwp file */
4616 pr_readdir_notdir, /* old pagedata file */
4617 };
4618
4619 /* ARGSUSED */
4620 static int
4621 prreaddir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp,
4622 caller_context_t *ct, int flags)
4623 {
4624 prnode_t *pnp = VTOP(vp);
4625
4626 ASSERT(pnp->pr_type < PR_NFILES);
4627
4628 /* XXX - Do we need to pass ct and flags? */
4629 return (pr_readdir_function[pnp->pr_type](pnp, uiop, eofp));
4630 }
4631
4632 /* ARGSUSED */
4633 static int
4634 pr_readdir_notdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4635 {
4636 return (ENOTDIR);
4637 }
4638
4639 /* ARGSUSED */
4640 static int
4641 pr_readdir_procdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4642 {
4643 zoneid_t zoneid;
4644 gfs_readdir_state_t gstate;
4645 int error, eof = 0;
4646 offset_t n;
4647
4648 ASSERT(pnp->pr_type == PR_PROCDIR);
4649
4650 zoneid = VTOZONE(PTOV(pnp))->zone_id;
4651
4652 if ((error = gfs_readdir_init(&gstate, PNSIZ, PRSDSIZE, uiop,
4653 PRROOTINO, PRROOTINO, 0)) != 0)
4654 return (error);
4655
4656 /*
4657 * Loop until user's request is satisfied or until all processes
4658 * have been examined.
4659 */
4660 while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
4661 uint_t pid;
4662 int pslot;
4663 proc_t *p;
4664
4665 /*
4666 * Find next entry. Skip processes not visible where
4667 * this /proc was mounted.
4668 */
4669 mutex_enter(&pidlock);
4670 while (n < v.v_proc &&
4671 ((p = pid_entry(n)) == NULL || p->p_stat == SIDL ||
4672 (zoneid != GLOBAL_ZONEID && p->p_zone->zone_id != zoneid) ||
4673 secpolicy_basic_procinfo(CRED(), p, curproc) != 0))
4674 n++;
4675
4676 /*
4677 * Stop when entire proc table has been examined.
4678 */
4679 if (n >= v.v_proc) {
4680 mutex_exit(&pidlock);
4681 eof = 1;
4682 break;
4683 }
4684
4685 ASSERT(p->p_stat != 0);
4686 pid = p->p_pid;
4687 pslot = p->p_slot;
4688 mutex_exit(&pidlock);
4689 error = gfs_readdir_emitn(&gstate, uiop, n,
4690 pmkino(0, pslot, PR_PIDDIR), pid);
4691 if (error)
4692 break;
4693 }
4694
4695 return (gfs_readdir_fini(&gstate, error, eofp, eof));
4696 }
4697
4698 /* ARGSUSED */
4699 static int
4700 pr_readdir_piddir(prnode_t *pnp, uio_t *uiop, int *eofp)
4701 {
4702 int zombie = ((pnp->pr_pcommon->prc_flags & PRC_DESTROY) != 0);
4703 prdirent_t dirent;
4704 prdirent_t *dirp;
4705 offset_t off;
4706 int error;
4707
4708 ASSERT(pnp->pr_type == PR_PIDDIR);
4709
4710 if (uiop->uio_offset < 0 ||
4711 uiop->uio_offset % sizeof (prdirent_t) != 0 ||
4712 uiop->uio_resid < sizeof (prdirent_t))
4713 return (EINVAL);
4714 if (pnp->pr_pcommon->prc_proc == NULL)
4715 return (ENOENT);
4716 if (uiop->uio_offset >= sizeof (piddir))
4717 goto out;
4718
4719 /*
4720 * Loop until user's request is satisfied, omitting some
4721 * files along the way if the process is a zombie.
4722 */
4723 for (dirp = &piddir[uiop->uio_offset / sizeof (prdirent_t)];
4724 uiop->uio_resid >= sizeof (prdirent_t) &&
4725 dirp < &piddir[NPIDDIRFILES+2];
4726 uiop->uio_offset = off + sizeof (prdirent_t), dirp++) {
4727 off = uiop->uio_offset;
4728 if (zombie) {
4729 switch (dirp->d_ino) {
4730 case PR_PIDDIR:
4731 case PR_PROCDIR:
4732 case PR_PSINFO:
4733 case PR_USAGE:
4734 break;
4735 default:
4736 continue;
4737 }
4738 }
4739 bcopy(dirp, &dirent, sizeof (prdirent_t));
4740 if (dirent.d_ino == PR_PROCDIR)
4741 dirent.d_ino = PRROOTINO;
4742 else
4743 dirent.d_ino = pmkino(0, pnp->pr_pcommon->prc_slot,
4744 dirent.d_ino);
4745 if ((error = uiomove((caddr_t)&dirent, sizeof (prdirent_t),
4746 UIO_READ, uiop)) != 0)
4747 return (error);
4748 }
4749 out:
4750 if (eofp)
4751 *eofp = (uiop->uio_offset >= sizeof (piddir));
4752 return (0);
4753 }
4754
4755 static void
4756 rebuild_objdir(struct as *as)
4757 {
4758 struct seg *seg;
4759 vnode_t *vp;
4760 vattr_t vattr;
4761 vnode_t **dir;
4762 ulong_t nalloc;
4763 ulong_t nentries;
4764 int i, j;
4765 ulong_t nold, nnew;
4766
4767 ASSERT(AS_WRITE_HELD(as, &as->a_lock));
4768
4769 if (as->a_updatedir == 0 && as->a_objectdir != NULL)
4770 return;
4771 as->a_updatedir = 0;
4772
4773 if ((nalloc = avl_numnodes(&as->a_segtree)) == 0 ||
4774 (seg = AS_SEGFIRST(as)) == NULL) /* can't happen? */
4775 return;
4776
4777 /*
4778 * Allocate space for the new object directory.
4779 * (This is usually about two times too many entries.)
4780 */
4781 nalloc = (nalloc + 0xf) & ~0xf; /* multiple of 16 */
4782 dir = kmem_zalloc(nalloc * sizeof (vnode_t *), KM_SLEEP);
4783
4784 /* fill in the new directory with desired entries */
4785 nentries = 0;
4786 do {
4787 vattr.va_mask = AT_FSID|AT_NODEID;
4788 if (seg->s_ops == &segvn_ops &&
4789 SEGOP_GETVP(seg, seg->s_base, &vp) == 0 &&
4790 vp != NULL && vp->v_type == VREG &&
4791 VOP_GETATTR(vp, &vattr, 0, CRED(), NULL) == 0) {
4792 for (i = 0; i < nentries; i++)
4793 if (vp == dir[i])
4794 break;
4795 if (i == nentries) {
4796 ASSERT(nentries < nalloc);
4797 dir[nentries++] = vp;
4798 }
4799 }
4800 } while ((seg = AS_SEGNEXT(as, seg)) != NULL);
4801
4802 if (as->a_objectdir == NULL) { /* first time */
4803 as->a_objectdir = dir;
4804 as->a_sizedir = nalloc;
4805 return;
4806 }
4807
4808 /*
4809 * Null out all of the defunct entries in the old directory.
4810 */
4811 nold = 0;
4812 nnew = nentries;
4813 for (i = 0; i < as->a_sizedir; i++) {
4814 if ((vp = as->a_objectdir[i]) != NULL) {
4815 for (j = 0; j < nentries; j++) {
4816 if (vp == dir[j]) {
4817 dir[j] = NULL;
4818 nnew--;
4819 break;
4820 }
4821 }
4822 if (j == nentries)
4823 as->a_objectdir[i] = NULL;
4824 else
4825 nold++;
4826 }
4827 }
4828
4829 if (nold + nnew > as->a_sizedir) {
4830 /*
4831 * Reallocate the old directory to have enough
4832 * space for the old and new entries combined.
4833 * Round up to the next multiple of 16.
4834 */
4835 ulong_t newsize = (nold + nnew + 0xf) & ~0xf;
4836 vnode_t **newdir = kmem_zalloc(newsize * sizeof (vnode_t *),
4837 KM_SLEEP);
4838 bcopy(as->a_objectdir, newdir,
4839 as->a_sizedir * sizeof (vnode_t *));
4840 kmem_free(as->a_objectdir, as->a_sizedir * sizeof (vnode_t *));
4841 as->a_objectdir = newdir;
4842 as->a_sizedir = newsize;
4843 }
4844
4845 /*
4846 * Move all new entries to the old directory and
4847 * deallocate the space used by the new directory.
4848 */
4849 if (nnew) {
4850 for (i = 0, j = 0; i < nentries; i++) {
4851 if ((vp = dir[i]) == NULL)
4852 continue;
4853 for (; j < as->a_sizedir; j++) {
4854 if (as->a_objectdir[j] != NULL)
4855 continue;
4856 as->a_objectdir[j++] = vp;
4857 break;
4858 }
4859 }
4860 }
4861 kmem_free(dir, nalloc * sizeof (vnode_t *));
4862 }
4863
4864 /*
4865 * Return the vnode from a slot in the process's object directory.
4866 * The caller must have locked the process's address space.
4867 * The only caller is below, in pr_readdir_objectdir().
4868 */
4869 static vnode_t *
4870 obj_entry(struct as *as, int slot)
4871 {
4872 ASSERT(AS_LOCK_HELD(as, &as->a_lock));
4873 if (as->a_objectdir == NULL)
4874 return (NULL);
4875 ASSERT(slot < as->a_sizedir);
4876 return (as->a_objectdir[slot]);
4877 }
4878
4879 /* ARGSUSED */
4880 static int
4881 pr_readdir_objectdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4882 {
4883 gfs_readdir_state_t gstate;
4884 int error, eof = 0;
4885 offset_t n;
4886 int pslot;
4887 size_t objdirsize;
4888 proc_t *p;
4889 struct as *as;
4890 vnode_t *vp;
4891
4892 ASSERT(pnp->pr_type == PR_OBJECTDIR);
4893
4894 if ((error = prlock(pnp, ZNO)) != 0)
4895 return (error);
4896 p = pnp->pr_common->prc_proc;
4897 pslot = p->p_slot;
4898
4899 /*
4900 * We drop p_lock before grabbing the address space lock
4901 * in order to avoid a deadlock with the clock thread.
4902 * The process will not disappear and its address space
4903 * will not change because it is marked P_PR_LOCK.
4904 */
4905 mutex_exit(&p->p_lock);
4906
4907 if ((error = gfs_readdir_init(&gstate, 64, PRSDSIZE, uiop,
4908 pmkino(0, pslot, PR_PIDDIR),
4909 pmkino(0, pslot, PR_OBJECTDIR), 0)) != 0) {
4910 mutex_enter(&p->p_lock);
4911 prunlock(pnp);
4912 return (error);
4913 }
4914
4915 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
4916 as = NULL;
4917 objdirsize = 0;
4918 }
4919
4920 /*
4921 * Loop until user's request is satisfied or until
4922 * all mapped objects have been examined. Cannot hold
4923 * the address space lock for the following call as
4924 * gfs_readdir_pred() utimately causes a call to uiomove().
4925 */
4926 while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
4927 vattr_t vattr;
4928 char str[64];
4929
4930 /*
4931 * Set the correct size of the directory just
4932 * in case the process has changed it's address
4933 * space via mmap/munmap calls.
4934 */
4935 if (as != NULL) {
4936 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
4937 if (as->a_updatedir)
4938 rebuild_objdir(as);
4939 objdirsize = as->a_sizedir;
4940 }
4941
4942 /*
4943 * Find next object.
4944 */
4945 vattr.va_mask = AT_FSID | AT_NODEID;
4946 while (n < objdirsize && (((vp = obj_entry(as, n)) == NULL) ||
4947 (VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)
4948 != 0))) {
4949 vattr.va_mask = AT_FSID | AT_NODEID;
4950 n++;
4951 }
4952
4953 if (as != NULL)
4954 AS_LOCK_EXIT(as, &as->a_lock);
4955
4956 /*
4957 * Stop when all objects have been reported.
4958 */
4959 if (n >= objdirsize) {
4960 eof = 1;
4961 break;
4962 }
4963
4964 if (vp == p->p_exec)
4965 (void) strcpy(str, "a.out");
4966 else
4967 pr_object_name(str, vp, &vattr);
4968
4969 error = gfs_readdir_emit(&gstate, uiop, n, vattr.va_nodeid,
4970 str, 0);
4971
4972 if (error)
4973 break;
4974 }
4975
4976 mutex_enter(&p->p_lock);
4977 prunlock(pnp);
4978
4979 return (gfs_readdir_fini(&gstate, error, eofp, eof));
4980 }
4981
4982 /* ARGSUSED */
4983 static int
4984 pr_readdir_lwpdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4985 {
4986 gfs_readdir_state_t gstate;
4987 int error, eof = 0;
4988 offset_t tslot;
4989 proc_t *p;
4990 int pslot;
4991 lwpdir_t *lwpdir;
4992 int lwpdirsize;
4993
4994 ASSERT(pnp->pr_type == PR_LWPDIR);
4995
4996 p = pr_p_lock(pnp);
4997 mutex_exit(&pr_pidlock);
4998 if (p == NULL)
4999 return (ENOENT);
5000 ASSERT(p == pnp->pr_common->prc_proc);
5001 pslot = p->p_slot;
5002 lwpdir = p->p_lwpdir;
5003 lwpdirsize = p->p_lwpdir_sz;
5004
5005 /*
5006 * Drop p->p_lock so we can safely do uiomove().
5007 * The lwp directory will not change because
5008 * we have the process locked with P_PR_LOCK.
5009 */
5010 mutex_exit(&p->p_lock);
5011
5012
5013 if ((error = gfs_readdir_init(&gstate, PLNSIZ, PRSDSIZE, uiop,
5014 pmkino(0, pslot, PR_PIDDIR),
5015 pmkino(0, pslot, PR_LWPDIR), 0)) != 0) {
5016 mutex_enter(&p->p_lock);
5017 prunlock(pnp);
5018 return (error);
5019 }
5020
5021 /*
5022 * Loop until user's request is satisfied or until all lwps
5023 * have been examined.
5024 */
5025 while ((error = gfs_readdir_pred(&gstate, uiop, &tslot)) == 0) {
5026 lwpent_t *lep;
5027 uint_t tid;
5028
5029 /*
5030 * Find next LWP.
5031 */
5032 while (tslot < lwpdirsize &&
5033 ((lep = lwpdir[tslot].ld_entry) == NULL))
5034 tslot++;
5035 /*
5036 * Stop when all lwps have been reported.
5037 */
5038 if (tslot >= lwpdirsize) {
5039 eof = 1;
5040 break;
5041 }
5042
5043 tid = lep->le_lwpid;
5044 error = gfs_readdir_emitn(&gstate, uiop, tslot,
5045 pmkino(tslot, pslot, PR_LWPIDDIR), tid);
5046 if (error)
5047 break;
5048 }
5049
5050 mutex_enter(&p->p_lock);
5051 prunlock(pnp);
5052
5053 return (gfs_readdir_fini(&gstate, error, eofp, eof));
5054 }
5055
5056 /* ARGSUSED */
5057 static int
5058 pr_readdir_lwpiddir(prnode_t *pnp, uio_t *uiop, int *eofp)
5059 {
5060 prcommon_t *pcp = pnp->pr_common;
5061 int zombie = ((pcp->prc_flags & PRC_DESTROY) != 0);
5062 prdirent_t dirent;
5063 prdirent_t *dirp;
5064 offset_t off;
5065 int error;
5066 int pslot;
5067 int tslot;
5068
5069 ASSERT(pnp->pr_type == PR_LWPIDDIR);
5070
5071 if (uiop->uio_offset < 0 ||
5072 uiop->uio_offset % sizeof (prdirent_t) != 0 ||
5073 uiop->uio_resid < sizeof (prdirent_t))
5074 return (EINVAL);
5075 if (pcp->prc_proc == NULL || pcp->prc_tslot == -1)
5076 return (ENOENT);
5077 if (uiop->uio_offset >= sizeof (lwpiddir))
5078 goto out;
5079
5080 /*
5081 * Loop until user's request is satisfied, omitting some files
5082 * along the way if the lwp is a zombie and also depending
5083 * on the data model of the process.
5084 */
5085 pslot = pcp->prc_slot;
5086 tslot = pcp->prc_tslot;
5087 for (dirp = &lwpiddir[uiop->uio_offset / sizeof (prdirent_t)];
5088 uiop->uio_resid >= sizeof (prdirent_t) &&
5089 dirp < &lwpiddir[NLWPIDDIRFILES+2];
5090 uiop->uio_offset = off + sizeof (prdirent_t), dirp++) {
5091 off = uiop->uio_offset;
5092 if (zombie) {
5093 switch (dirp->d_ino) {
5094 case PR_LWPIDDIR:
5095 case PR_LWPDIR:
5096 case PR_LWPSINFO:
5097 break;
5098 default:
5099 continue;
5100 }
5101 }
5102 #if defined(__sparc)
5103 /* the asrs file exists only for sparc v9 _LP64 processes */
5104 if (dirp->d_ino == PR_ASRS &&
5105 pcp->prc_datamodel != DATAMODEL_LP64)
5106 continue;
5107 #endif
5108 bcopy(dirp, &dirent, sizeof (prdirent_t));
5109 if (dirent.d_ino == PR_LWPDIR)
5110 dirent.d_ino = pmkino(0, pslot, dirp->d_ino);
5111 else
5112 dirent.d_ino = pmkino(tslot, pslot, dirp->d_ino);
5113 if ((error = uiomove((caddr_t)&dirent, sizeof (prdirent_t),
5114 UIO_READ, uiop)) != 0)
5115 return (error);
5116 }
5117 out:
5118 if (eofp)
5119 *eofp = (uiop->uio_offset >= sizeof (lwpiddir));
5120 return (0);
5121 }
5122
5123 /* ARGSUSED */
5124 static int
5125 pr_readdir_fddir(prnode_t *pnp, uio_t *uiop, int *eofp)
5126 {
5127 gfs_readdir_state_t gstate;
5128 int error, eof = 0;
5129 offset_t n;
5130 proc_t *p;
5131 int pslot;
5132 int fddirsize;
5133 uf_info_t *fip;
5134
5135 ASSERT(pnp->pr_type == PR_FDDIR);
5136
5137 if ((error = prlock(pnp, ZNO)) != 0)
5138 return (error);
5139 p = pnp->pr_common->prc_proc;
5140 pslot = p->p_slot;
5141 fip = P_FINFO(p);
5142 mutex_exit(&p->p_lock);
5143
5144 if ((error = gfs_readdir_init(&gstate, PLNSIZ, PRSDSIZE, uiop,
5145 pmkino(0, pslot, PR_PIDDIR), pmkino(0, pslot, PR_FDDIR), 0)) != 0) {
5146 mutex_enter(&p->p_lock);
5147 prunlock(pnp);
5148 return (error);
5149 }
5150
5151 mutex_enter(&fip->fi_lock);
5152 if ((p->p_flag & SSYS) || p->p_as == &kas)
5153 fddirsize = 0;
5154 else
5155 fddirsize = fip->fi_nfiles;
5156
5157 /*
5158 * Loop until user's request is satisfied or until
5159 * all file descriptors have been examined.
5160 */
5161 while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
5162 /*
5163 * Find next fd.
5164 */
5165 while (n < fddirsize && fip->fi_list[n].uf_file == NULL)
5166 n++;
5167 /*
5168 * Stop when all fds have been reported.
5169 */
5170 if (n >= fddirsize) {
5171 eof = 1;
5172 break;
5173 }
5174
5175 error = gfs_readdir_emitn(&gstate, uiop, n,
5176 pmkino(n, pslot, PR_FD), n);
5177 if (error)
5178 break;
5179 }
5180
5181 mutex_exit(&fip->fi_lock);
5182 mutex_enter(&p->p_lock);
5183 prunlock(pnp);
5184
5185 return (gfs_readdir_fini(&gstate, error, eofp, eof));
5186 }
5187
5188 /* ARGSUSED */
5189 static int
5190 pr_readdir_pathdir(prnode_t *pnp, uio_t *uiop, int *eofp)
5191 {
5192 longlong_t bp[DIRENT64_RECLEN(64) / sizeof (longlong_t)];
5193 dirent64_t *dirent = (dirent64_t *)bp;
5194 int reclen;
5195 ssize_t oresid;
5196 offset_t off, idx;
5197 int error = 0;
5198 proc_t *p;
5199 int fd, obj;
5200 int pslot;
5201 int fddirsize;
5202 uf_info_t *fip;
5203 struct as *as = NULL;
5204 size_t objdirsize;
5205 vattr_t vattr;
5206 vnode_t *vp;
5207
5208 ASSERT(pnp->pr_type == PR_PATHDIR);
5209
5210 if (uiop->uio_offset < 0 ||
5211 uiop->uio_resid <= 0 ||
5212 (uiop->uio_offset % PRSDSIZE) != 0)
5213 return (EINVAL);
5214 oresid = uiop->uio_resid;
5215 bzero(bp, sizeof (bp));
5216
5217 if ((error = prlock(pnp, ZNO)) != 0)
5218 return (error);
5219 p = pnp->pr_common->prc_proc;
5220 fip = P_FINFO(p);
5221 pslot = p->p_slot;
5222 mutex_exit(&p->p_lock);
5223
5224 if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
5225 as = NULL;
5226 objdirsize = 0;
5227 } else {
5228 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
5229 if (as->a_updatedir)
5230 rebuild_objdir(as);
5231 objdirsize = as->a_sizedir;
5232 AS_LOCK_EXIT(as, &as->a_lock);
5233 as = NULL;
5234 }
5235
5236 mutex_enter(&fip->fi_lock);
5237 if ((p->p_flag & SSYS) || p->p_as == &kas)
5238 fddirsize = 0;
5239 else
5240 fddirsize = fip->fi_nfiles;
5241
5242 for (; uiop->uio_resid > 0; uiop->uio_offset = off + PRSDSIZE) {
5243 /*
5244 * There are 4 special files in the path directory: ".", "..",
5245 * "root", and "cwd". We handle those specially here.
5246 */
5247 off = uiop->uio_offset;
5248 idx = off / PRSDSIZE;
5249 if (off == 0) { /* "." */
5250 dirent->d_ino = pmkino(0, pslot, PR_PATHDIR);
5251 dirent->d_name[0] = '.';
5252 dirent->d_name[1] = '\0';
5253 reclen = DIRENT64_RECLEN(1);
5254 } else if (idx == 1) { /* ".." */
5255 dirent->d_ino = pmkino(0, pslot, PR_PIDDIR);
5256 dirent->d_name[0] = '.';
5257 dirent->d_name[1] = '.';
5258 dirent->d_name[2] = '\0';
5259 reclen = DIRENT64_RECLEN(2);
5260 } else if (idx == 2) { /* "root" */
5261 dirent->d_ino = pmkino(idx, pslot, PR_PATH);
5262 (void) strcpy(dirent->d_name, "root");
5263 reclen = DIRENT64_RECLEN(4);
5264 } else if (idx == 3) { /* "cwd" */
5265 dirent->d_ino = pmkino(idx, pslot, PR_PATH);
5266 (void) strcpy(dirent->d_name, "cwd");
5267 reclen = DIRENT64_RECLEN(3);
5268 } else if (idx < 4 + fddirsize) {
5269 /*
5270 * In this case, we have one of the file descriptors.
5271 */
5272 fd = idx - 4;
5273 if (fip->fi_list[fd].uf_file == NULL)
5274 continue;
5275 dirent->d_ino = pmkino(idx, pslot, PR_PATH);
5276 (void) pr_u32tos(fd, dirent->d_name, PLNSIZ+1);
5277 reclen = DIRENT64_RECLEN(PLNSIZ);
5278 } else if (idx < 4 + fddirsize + objdirsize) {
5279 if (fip != NULL) {
5280 mutex_exit(&fip->fi_lock);
5281 fip = NULL;
5282 }
5283
5284 /*
5285 * We drop p_lock before grabbing the address space lock
5286 * in order to avoid a deadlock with the clock thread.
5287 * The process will not disappear and its address space
5288 * will not change because it is marked P_PR_LOCK.
5289 */
5290 if (as == NULL) {
5291 as = p->p_as;
5292 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
5293 }
5294
5295 if (as->a_updatedir) {
5296 rebuild_objdir(as);
5297 objdirsize = as->a_sizedir;
5298 }
5299
5300 obj = idx - 4 - fddirsize;
5301 if ((vp = obj_entry(as, obj)) == NULL)
5302 continue;
5303 vattr.va_mask = AT_FSID|AT_NODEID;
5304 if (VOP_GETATTR(vp, &vattr, 0, CRED(), NULL) != 0)
5305 continue;
5306 if (vp == p->p_exec)
5307 (void) strcpy(dirent->d_name, "a.out");
5308 else
5309 pr_object_name(dirent->d_name, vp, &vattr);
5310 dirent->d_ino = pmkino(idx, pslot, PR_PATH);
5311 reclen = DIRENT64_RECLEN(strlen(dirent->d_name));
5312 } else {
5313 break;
5314 }
5315
5316 dirent->d_off = uiop->uio_offset + PRSDSIZE;
5317 dirent->d_reclen = (ushort_t)reclen;
5318 if (reclen > uiop->uio_resid) {
5319 /*
5320 * Error if no entries have been returned yet.
5321 */
5322 if (uiop->uio_resid == oresid)
5323 error = EINVAL;
5324 break;
5325 }
5326 /*
5327 * Drop the address space lock to do the uiomove().
5328 */
5329 if (as != NULL)
5330 AS_LOCK_EXIT(as, &as->a_lock);
5331
5332 error = uiomove((caddr_t)dirent, reclen, UIO_READ, uiop);
5333 if (as != NULL)
5334 AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
5335
5336 if (error)
5337 break;
5338 }
5339
5340 if (error == 0 && eofp)
5341 *eofp = (uiop->uio_offset >= (fddirsize + 2) * PRSDSIZE);
5342
5343 if (fip != NULL)
5344 mutex_exit(&fip->fi_lock);
5345 if (as != NULL)
5346 AS_LOCK_EXIT(as, &as->a_lock);
5347 mutex_enter(&p->p_lock);
5348 prunlock(pnp);
5349 return (error);
5350 }
5351
5352 static int
5353 pr_readdir_tmpldir(prnode_t *pnp, uio_t *uiop, int *eofp)
5354 {
5355 proc_t *p;
5356 int pslot, tslot;
5357 gfs_readdir_state_t gstate;
5358 int error, eof = 0;
5359 offset_t n;
5360
5361 ASSERT(pnp->pr_type == PR_TMPLDIR);
5362
5363 if ((error = prlock(pnp, ZNO)) != 0)
5364 return (error);
5365 p = pnp->pr_common->prc_proc;
5366 pslot = pnp->pr_common->prc_slot;
5367 tslot = pnp->pr_common->prc_tslot;
5368 mutex_exit(&p->p_lock);
5369
5370 if ((error = gfs_readdir_init(&gstate, PRDIRSIZE, PRSDSIZE, uiop,
5371 pmkino(tslot, pslot, PR_LWPDIR),
5372 pmkino(tslot, pslot, PR_TMPLDIR), 0)) != 0) {
5373 mutex_enter(&p->p_lock);
5374 prunlock(pnp);
5375 return (error);
5376 }
5377
5378 while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
5379 /*
5380 * Check for an active template. Reading a directory's
5381 * contents is already racy, so we don't bother taking
5382 * any locks.
5383 */
5384 while (n < ct_ntypes &&
5385 pnp->pr_common->prc_thread->t_lwp->lwp_ct_active[n] == NULL)
5386 n++;
5387 /*
5388 * Stop when all types have been reported.
5389 */
5390 if (n >= ct_ntypes) {
5391 eof = 1;
5392 break;
5393 }
5394 /*
5395 * The pmkino invocation below will need to be updated
5396 * when we create our fifth contract type.
5397 */
5398 ASSERT(ct_ntypes <= 4);
5399 error = gfs_readdir_emit(&gstate, uiop, n,
5400 pmkino((tslot << 2) | n, pslot, PR_TMPL),
5401 ct_types[n]->ct_type_name, 0);
5402 if (error)
5403 break;
5404 }
5405
5406 mutex_enter(&p->p_lock);
5407 prunlock(pnp);
5408
5409 return (gfs_readdir_fini(&gstate, error, eofp, eof));
5410 }
5411
5412 static int
5413 pr_readdir_ctdir(prnode_t *pnp, uio_t *uiop, int *eofp)
5414 {
5415 proc_t *p;
5416 int pslot;
5417 gfs_readdir_state_t gstate;
5418 int error, eof = 0;
5419 offset_t n;
5420 uint64_t zid;
5421
5422 ASSERT(pnp->pr_type == PR_CTDIR);
5423
5424 if ((error = prlock(pnp, ZNO)) != 0)
5425 return (error);
5426 p = pnp->pr_common->prc_proc;
5427 pslot = p->p_slot;
5428 mutex_exit(&p->p_lock);
5429
5430 if ((error = gfs_readdir_init(&gstate, PRDIRSIZE, PRSDSIZE, uiop,
5431 pmkino(0, pslot, PR_PIDDIR), pmkino(0, pslot, PR_CTDIR), 0)) != 0) {
5432 mutex_enter(&p->p_lock);
5433 prunlock(pnp);
5434 return (error);
5435 }
5436
5437 zid = VTOZONE(pnp->pr_vnode)->zone_uniqid;
5438 while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
5439 id_t next = contract_plookup(p, n, zid);
5440 if (next == -1) {
5441 eof = 1;
5442 break;
5443 }
5444 error = gfs_readdir_emitn(&gstate, uiop, next,
5445 pmkino(next, pslot, PR_CT), next);
5446 if (error)
5447 break;
5448 }
5449
5450 mutex_enter(&p->p_lock);
5451 prunlock(pnp);
5452
5453 return (gfs_readdir_fini(&gstate, error, eofp, eof));
5454 }
5455
5456 /* ARGSUSED */
5457 static int
5458 prfsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)
5459 {
5460 return (0);
5461 }
5462
5463 /*
5464 * Utility: remove a /proc vnode from a linked list, threaded through pr_next.
5465 */
5466 static void
5467 pr_list_unlink(vnode_t *pvp, vnode_t **listp)
5468 {
5469 vnode_t *vp;
5470 prnode_t *pnp;
5471
5472 while ((vp = *listp) != NULL) {
5473 pnp = VTOP(vp);
5474 if (vp == pvp) {
5475 *listp = pnp->pr_next;
5476 pnp->pr_next = NULL;
5477 break;
5478 }
5479 listp = &pnp->pr_next;
5480 }
5481 }
5482
5483 /* ARGSUSED */
5484 static void
5485 prinactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
5486 {
5487 prnode_t *pnp = VTOP(vp);
5488 prnodetype_t type = pnp->pr_type;
5489 proc_t *p;
5490 vnode_t *dp;
5491 vnode_t *ovp = NULL;
5492 prnode_t *opnp = NULL;
5493
5494 switch (type) {
5495 case PR_OBJECT:
5496 case PR_FD:
5497 case PR_SELF:
5498 case PR_PATH:
5499 /* These are not linked into the usual lists */
5500 ASSERT(vp->v_count == 1);
5501 if ((dp = pnp->pr_parent) != NULL)
5502 VN_RELE(dp);
5503 prfreenode(pnp);
5504 return;
5505 default:
5506 break;
5507 }
5508
5509 mutex_enter(&pr_pidlock);
5510 if (pnp->pr_pcommon == NULL)
5511 p = NULL;
5512 else if ((p = pnp->pr_pcommon->prc_proc) != NULL)
5513 mutex_enter(&p->p_lock);
5514 mutex_enter(&vp->v_lock);
5515
5516 if (type == PR_PROCDIR || vp->v_count > 1) {
5517 vp->v_count--;
5518 mutex_exit(&vp->v_lock);
5519 if (p != NULL)
5520 mutex_exit(&p->p_lock);
5521 mutex_exit(&pr_pidlock);
5522 return;
5523 }
5524
5525 if ((dp = pnp->pr_parent) != NULL) {
5526 prnode_t *dpnp;
5527
5528 switch (type) {
5529 case PR_PIDFILE:
5530 case PR_LWPIDFILE:
5531 case PR_OPAGEDATA:
5532 break;
5533 default:
5534 dpnp = VTOP(dp);
5535 mutex_enter(&dpnp->pr_mutex);
5536 if (dpnp->pr_files != NULL &&
5537 dpnp->pr_files[pnp->pr_index] == vp)
5538 dpnp->pr_files[pnp->pr_index] = NULL;
5539 mutex_exit(&dpnp->pr_mutex);
5540 break;
5541 }
5542 pnp->pr_parent = NULL;
5543 }
5544
5545 ASSERT(vp->v_count == 1);
5546
5547 /*
5548 * If we allocated an old /proc/pid node, free it too.
5549 */
5550 if (pnp->pr_pidfile != NULL) {
5551 ASSERT(type == PR_PIDDIR);
5552 ovp = pnp->pr_pidfile;
5553 opnp = VTOP(ovp);
5554 ASSERT(opnp->pr_type == PR_PIDFILE);
5555 pnp->pr_pidfile = NULL;
5556 }
5557
5558 mutex_exit(&pr_pidlock);
5559
5560 if (p != NULL) {
5561 /*
5562 * Remove the vnodes from the lists of
5563 * /proc vnodes for the process.
5564 */
5565 int slot;
5566
5567 switch (type) {
5568 case PR_PIDDIR:
5569 pr_list_unlink(vp, &p->p_trace);
5570 break;
5571 case PR_LWPIDDIR:
5572 if ((slot = pnp->pr_common->prc_tslot) != -1) {
5573 lwpent_t *lep = p->p_lwpdir[slot].ld_entry;
5574 pr_list_unlink(vp, &lep->le_trace);
5575 }
5576 break;
5577 default:
5578 pr_list_unlink(vp, &p->p_plist);
5579 break;
5580 }
5581 if (ovp != NULL)
5582 pr_list_unlink(ovp, &p->p_plist);
5583 mutex_exit(&p->p_lock);
5584 }
5585
5586 mutex_exit(&vp->v_lock);
5587
5588 if (type == PR_CT && pnp->pr_contract != NULL) {
5589 contract_rele(pnp->pr_contract);
5590 pnp->pr_contract = NULL;
5591 }
5592
5593 if (opnp != NULL)
5594 prfreenode(opnp);
5595 prfreenode(pnp);
5596 if (dp != NULL) {
5597 VN_RELE(dp);
5598 }
5599 }
5600
5601 /* ARGSUSED */
5602 static int
5603 prseek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
5604 {
5605 return (0);
5606 }
5607
5608 /*
5609 * We use the p_execdir member of proc_t to expand the %d token in core file
5610 * paths (the directory path for the executable that dumped core; see
5611 * coreadm(1M) for details). We'd like gcore(1) to be able to expand %d in
5612 * the same way as core dumping from the kernel, but there's no convenient
5613 * and comprehensible way to export the path name for p_execdir. To solve
5614 * this, we try to find the actual path to the executable that was used. In
5615 * pr_lookup_pathdir(), we mark the a.out path name vnode with the PR_AOUT
5616 * flag, and use that here to indicate that more work is needed beyond the
5617 * call to vnodetopath().
5618 */
5619 static int
5620 prreadlink_lookup(prnode_t *pnp, char *buf, size_t size, cred_t *cr)
5621 {
5622 proc_t *p;
5623 vnode_t *vp, *execvp, *vrootp;
5624 int ret;
5625 size_t len;
5626 dirent64_t *dp;
5627 size_t dlen = DIRENT64_RECLEN(MAXPATHLEN);
5628 char *dbuf;
5629
5630 p = curproc;
5631 mutex_enter(&p->p_lock);
5632 if ((vrootp = PTOU(p)->u_rdir) == NULL)
5633 vrootp = rootdir;
5634 VN_HOLD(vrootp);
5635 mutex_exit(&p->p_lock);
5636
5637 ret = vnodetopath(vrootp, pnp->pr_realvp, buf, size, cr);
5638
5639 /*
5640 * If PR_AOUT isn't set, then we looked up the path for the vnode;
5641 * otherwise, we looked up the path for (what we believe to be) the
5642 * containing directory.
5643 */
5644 if ((pnp->pr_flags & PR_AOUT) == 0) {
5645 VN_RELE(vrootp);
5646 return (ret);
5647 }
5648
5649 /*
5650 * Fail if there's a problem locking the process. This will only
5651 * occur if the process is changing so the information we would
5652 * report would already be invalid.
5653 */
5654 if (prlock(pnp, ZNO) != 0) {
5655 VN_RELE(vrootp);
5656 return (EIO);
5657 }
5658
5659 p = pnp->pr_common->prc_proc;
5660 mutex_exit(&p->p_lock);
5661
5662 execvp = p->p_exec;
5663 VN_HOLD(execvp);
5664
5665 /*
5666 * If our initial lookup of the directory failed, fall back to
5667 * the path name information for p_exec.
5668 */
5669 if (ret != 0) {
5670 mutex_enter(&p->p_lock);
5671 prunlock(pnp);
5672 ret = vnodetopath(vrootp, execvp, buf, size, cr);
5673 VN_RELE(execvp);
5674 VN_RELE(vrootp);
5675 return (ret);
5676 }
5677
5678 len = strlen(buf);
5679
5680 /*
5681 * We use u_comm as a guess for the last component of the full
5682 * executable path name. If there isn't going to be enough space
5683 * we fall back to using the p_exec so that we can have _an_
5684 * answer even if it's not perfect.
5685 */
5686 if (strlen(PTOU(p)->u_comm) + len + 1 < size) {
5687 buf[len] = '/';
5688 (void) strcpy(buf + len + 1, PTOU(p)->u_comm);
5689 mutex_enter(&p->p_lock);
5690 prunlock(pnp);
5691
5692 /*
5693 * Do a forward lookup of our u_comm guess.
5694 */
5695 if (lookupnameat(buf + len + 1, UIO_SYSSPACE, FOLLOW, NULLVPP,
5696 &vp, pnp->pr_realvp) == 0) {
5697 if (vn_compare(vp, execvp)) {
5698 VN_RELE(vp);
5699 VN_RELE(execvp);
5700 VN_RELE(vrootp);
5701 return (0);
5702 }
5703
5704 VN_RELE(vp);
5705 }
5706 } else {
5707 mutex_enter(&p->p_lock);
5708 prunlock(pnp);
5709 }
5710
5711 dbuf = kmem_alloc(dlen, KM_SLEEP);
5712
5713 /*
5714 * Try to find a matching vnode by iterating through the directory's
5715 * entries. If that fails, fall back to the path information for
5716 * p_exec.
5717 */
5718 if ((ret = dirfindvp(vrootp, pnp->pr_realvp, execvp, cr, dbuf,
5719 dlen, &dp)) == 0 && strlen(dp->d_name) + len + 1 < size) {
5720 buf[len] = '/';
5721 (void) strcpy(buf + len + 1, dp->d_name);
5722 } else {
5723 ret = vnodetopath(vrootp, execvp, buf, size, cr);
5724 }
5725
5726 kmem_free(dbuf, dlen);
5727 VN_RELE(execvp);
5728 VN_RELE(vrootp);
5729
5730 return (ret);
5731 }
5732
5733 /* ARGSUSED */
5734 static int
5735 prreadlink(vnode_t *vp, uio_t *uiop, cred_t *cr, caller_context_t *ctp)
5736 {
5737 prnode_t *pnp = VTOP(vp);
5738 char *buf;
5739 int ret = EINVAL;
5740 char idbuf[16];
5741 int length, rlength;
5742 contract_t *ct;
5743
5744 switch (pnp->pr_type) {
5745 case PR_SELF:
5746 (void) snprintf(idbuf, sizeof (idbuf), "%d", curproc->p_pid);
5747 ret = uiomove(idbuf, strlen(idbuf), UIO_READ, uiop);
5748 break;
5749 case PR_OBJECT:
5750 case PR_FD:
5751 case PR_CURDIR:
5752 case PR_ROOTDIR:
5753 if (pnp->pr_realvp->v_type == VDIR)
5754 ret = 0;
5755 break;
5756 case PR_PATH:
5757 buf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
5758
5759 if ((ret = prreadlink_lookup(pnp, buf, MAXPATHLEN, cr)) == 0)
5760 ret = uiomove(buf, strlen(buf), UIO_READ, uiop);
5761
5762 kmem_free(buf, MAXPATHLEN);
5763 break;
5764 case PR_CT:
5765 ASSERT(pnp->pr_contract != NULL);
5766 ct = pnp->pr_contract;
5767 length = sizeof (CTFS_ROOT "//") + sizeof (idbuf) +
5768 strlen(ct->ct_type->ct_type_name);
5769 buf = kmem_alloc(length, KM_SLEEP);
5770 rlength = snprintf(buf, length, CTFS_ROOT "/%s/%d",
5771 ct->ct_type->ct_type_name, ct->ct_id);
5772 ASSERT(rlength < length);
5773 ret = uiomove(buf, rlength, UIO_READ, uiop);
5774 kmem_free(buf, length);
5775 break;
5776 default:
5777 break;
5778 }
5779
5780 return (ret);
5781 }
5782
5783 /*ARGSUSED2*/
5784 static int
5785 prcmp(vnode_t *vp1, vnode_t *vp2, caller_context_t *ct)
5786 {
5787 prnode_t *pp1, *pp2;
5788
5789 if (vp1 == vp2)
5790 return (1);
5791
5792 if (!vn_matchops(vp1, prvnodeops) || !vn_matchops(vp2, prvnodeops))
5793 return (0);
5794
5795 pp1 = VTOP(vp1);
5796 pp2 = VTOP(vp2);
5797
5798 if (pp1->pr_type != pp2->pr_type)
5799 return (0);
5800 if (pp1->pr_type == PR_PROCDIR)
5801 return (1);
5802 if (pp1->pr_ino || pp2->pr_ino)
5803 return (pp2->pr_ino == pp1->pr_ino);
5804
5805 if (pp1->pr_common == NULL || pp2->pr_common == NULL)
5806 return (0);
5807
5808 return (pp1->pr_common->prc_slot == pp2->pr_common->prc_slot &&
5809 pp1->pr_common->prc_tslot == pp2->pr_common->prc_tslot);
5810 }
5811
5812 static int
5813 prrealvp(vnode_t *vp, vnode_t **vpp, caller_context_t *ct)
5814 {
5815 vnode_t *rvp;
5816
5817 if ((rvp = VTOP(vp)->pr_realvp) != NULL) {
5818 vp = rvp;
5819 if (VOP_REALVP(vp, &rvp, ct) == 0)
5820 vp = rvp;
5821 }
5822
5823 *vpp = vp;
5824 return (0);
5825 }
5826
5827 /*
5828 * Return the answer requested to poll().
5829 * POLLIN, POLLRDNORM, and POLLOUT are recognized as in fs_poll().
5830 * In addition, these have special meaning for /proc files:
5831 * POLLPRI process or lwp stopped on an event of interest
5832 * POLLERR /proc file descriptor is invalid
5833 * POLLHUP process or lwp has terminated
5834 */
5835 /*ARGSUSED5*/
5836 static int
5837 prpoll(vnode_t *vp, short events, int anyyet, short *reventsp,
5838 pollhead_t **phpp, caller_context_t *ct)
5839 {
5840 prnode_t *pnp = VTOP(vp);
5841 prcommon_t *pcp = pnp->pr_common;
5842 pollhead_t *php = &pcp->prc_pollhead;
5843 proc_t *p;
5844 short revents;
5845 int error;
5846 int lockstate;
5847
5848 ASSERT(pnp->pr_type < PR_NFILES);
5849
5850 /*
5851 * Support for old /proc interface.
5852 */
5853 if (pnp->pr_pidfile != NULL) {
5854 vp = pnp->pr_pidfile;
5855 pnp = VTOP(vp);
5856 ASSERT(pnp->pr_type == PR_PIDFILE);
5857 ASSERT(pnp->pr_common == pcp);
5858 }
5859
5860 *reventsp = revents = 0;
5861 *phpp = (pollhead_t *)NULL;
5862
5863 if (vp->v_type == VDIR) {
5864 *reventsp |= POLLNVAL;
5865 return (0);
5866 }
5867
5868 lockstate = pollunlock(); /* avoid deadlock with prnotify() */
5869
5870 if ((error = prlock(pnp, ZNO)) != 0) {
5871 pollrelock(lockstate);
5872 switch (error) {
5873 case ENOENT: /* process or lwp died */
5874 *reventsp = POLLHUP;
5875 error = 0;
5876 break;
5877 case EAGAIN: /* invalidated */
5878 *reventsp = POLLERR;
5879 error = 0;
5880 break;
5881 }
5882 return (error);
5883 }
5884
5885 /*
5886 * We have the process marked locked (P_PR_LOCK) and we are holding
5887 * its p->p_lock. We want to unmark the process but retain
5888 * exclusive control w.r.t. other /proc controlling processes
5889 * before reacquiring the polling locks.
5890 *
5891 * prunmark() does this for us. It unmarks the process
5892 * but retains p->p_lock so we still have exclusive control.
5893 * We will drop p->p_lock at the end to relinquish control.
5894 *
5895 * We cannot call prunlock() at the end to relinquish control
5896 * because prunlock(), like prunmark(), may drop and reacquire
5897 * p->p_lock and that would lead to a lock order violation
5898 * w.r.t. the polling locks we are about to reacquire.
5899 */
5900 p = pcp->prc_proc;
5901 ASSERT(p != NULL);
5902 prunmark(p);
5903
5904 pollrelock(lockstate); /* reacquire dropped poll locks */
5905
5906 if ((p->p_flag & SSYS) || p->p_as == &kas)
5907 revents = POLLNVAL;
5908 else {
5909 short ev;
5910
5911 if ((ev = (events & (POLLIN|POLLRDNORM))) != 0)
5912 revents |= ev;
5913 /*
5914 * POLLWRNORM (same as POLLOUT) really should not be
5915 * used to indicate that the process or lwp stopped.
5916 * However, USL chose to use POLLWRNORM rather than
5917 * POLLPRI to indicate this, so we just accept either
5918 * requested event to indicate stopped. (grr...)
5919 */
5920 if ((ev = (events & (POLLPRI|POLLOUT|POLLWRNORM))) != 0) {
5921 kthread_t *t;
5922
5923 if (pcp->prc_flags & PRC_LWP) {
5924 t = pcp->prc_thread;
5925 ASSERT(t != NULL);
5926 thread_lock(t);
5927 } else {
5928 t = prchoose(p); /* returns locked t */
5929 ASSERT(t != NULL);
5930 }
5931
5932 if (ISTOPPED(t) || VSTOPPED(t))
5933 revents |= ev;
5934 thread_unlock(t);
5935 }
5936 }
5937
5938 *reventsp = revents;
5939 if (!anyyet && revents == 0) {
5940 /*
5941 * Arrange to wake up the polling lwp when
5942 * the target process/lwp stops or terminates
5943 * or when the file descriptor becomes invalid.
5944 */
5945 pcp->prc_flags |= PRC_POLL;
5946 *phpp = php;
5947 }
5948 mutex_exit(&p->p_lock);
5949 return (0);
5950 }
5951
5952 /* in prioctl.c */
5953 extern int prioctl(vnode_t *, int, intptr_t, int, cred_t *, int *,
5954 caller_context_t *);
5955
5956 /*
5957 * /proc vnode operations vector
5958 */
5959 const fs_operation_def_t pr_vnodeops_template[] = {
5960 VOPNAME_OPEN, { .vop_open = propen },
5961 VOPNAME_CLOSE, { .vop_close = prclose },
5962 VOPNAME_READ, { .vop_read = prread },
5963 VOPNAME_WRITE, { .vop_write = prwrite },
5964 VOPNAME_IOCTL, { .vop_ioctl = prioctl },
5965 VOPNAME_GETATTR, { .vop_getattr = prgetattr },
5966 VOPNAME_ACCESS, { .vop_access = praccess },
5967 VOPNAME_LOOKUP, { .vop_lookup = prlookup },
5968 VOPNAME_CREATE, { .vop_create = prcreate },
5969 VOPNAME_READDIR, { .vop_readdir = prreaddir },
5970 VOPNAME_READLINK, { .vop_readlink = prreadlink },
5971 VOPNAME_FSYNC, { .vop_fsync = prfsync },
5972 VOPNAME_INACTIVE, { .vop_inactive = prinactive },
5973 VOPNAME_SEEK, { .vop_seek = prseek },
5974 VOPNAME_CMP, { .vop_cmp = prcmp },
5975 VOPNAME_FRLOCK, { .error = fs_error },
5976 VOPNAME_REALVP, { .vop_realvp = prrealvp },
5977 VOPNAME_POLL, { .vop_poll = prpoll },
5978 VOPNAME_DISPOSE, { .error = fs_error },
5979 VOPNAME_SHRLOCK, { .error = fs_error },
5980 NULL, NULL
5981 };