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.
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.
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]
23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2018, Joyent, Inc.
25 * Copyright (c) 2017 by Delphix. All rights reserved.
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
31 #include <sys/types.h>
32 #include <sys/param.h>
35 #include <sys/policy.h>
36 #include <sys/debug.h>
37 #include <sys/dirent.h>
38 #include <sys/errno.h>
40 #include <sys/inline.h>
42 #include <sys/pathname.h>
44 #include <sys/brand.h>
45 #include <sys/signal.h>
47 #include <sys/sysmacros.h>
48 #include <sys/systm.h>
56 #include <sys/vfs_opreg.h>
58 #include <sys/vnode.h>
59 #include <sys/fault.h>
60 #include <sys/syscall.h>
61 #include <sys/procfs.h>
62 #include <sys/atomic.h>
63 #include <sys/cmn_err.h>
64 #include <sys/contract_impl.h>
67 #include <sys/ctype.h>
68 #include <fs/fs_subr.h>
72 #include <vm/seg_vn.h>
74 #include <fs/proc/prdata.h>
76 #include <sys/regset.h>
79 #include <sys/sysi86.h>
85 vnodeops_t
*prvnodeops
;
88 * Directory characteristics (patterned after the s5 file system).
95 char d_name
[PRDIRSIZE
];
98 #define PRSDSIZE (sizeof (struct prdirect))
101 * Directory characteristics.
103 typedef struct prdirent
{
104 ino64_t d_ino
; /* "inode number" of entry */
105 off64_t d_off
; /* offset of disk directory entry */
106 unsigned short d_reclen
; /* length of this record */
107 char d_name
[14]; /* name of file */
111 * Contents of a /proc/<pid> directory.
112 * Reuse d_ino field for the /proc file type.
114 static prdirent_t piddir
[] = {
115 { PR_PIDDIR
, 1 * sizeof (prdirent_t
), sizeof (prdirent_t
),
117 { PR_PROCDIR
, 2 * sizeof (prdirent_t
), sizeof (prdirent_t
),
119 { PR_AS
, 3 * sizeof (prdirent_t
), sizeof (prdirent_t
),
121 { PR_CTL
, 4 * sizeof (prdirent_t
), sizeof (prdirent_t
),
123 { PR_STATUS
, 5 * sizeof (prdirent_t
), sizeof (prdirent_t
),
125 { PR_LSTATUS
, 6 * sizeof (prdirent_t
), sizeof (prdirent_t
),
127 { PR_PSINFO
, 7 * sizeof (prdirent_t
), sizeof (prdirent_t
),
129 { PR_LPSINFO
, 8 * sizeof (prdirent_t
), sizeof (prdirent_t
),
131 { PR_MAP
, 9 * sizeof (prdirent_t
), sizeof (prdirent_t
),
133 { PR_RMAP
, 10 * sizeof (prdirent_t
), sizeof (prdirent_t
),
135 { PR_XMAP
, 11 * sizeof (prdirent_t
), sizeof (prdirent_t
),
137 { PR_CRED
, 12 * sizeof (prdirent_t
), sizeof (prdirent_t
),
139 { PR_SIGACT
, 13 * sizeof (prdirent_t
), sizeof (prdirent_t
),
141 { PR_AUXV
, 14 * sizeof (prdirent_t
), sizeof (prdirent_t
),
143 { PR_USAGE
, 15 * sizeof (prdirent_t
), sizeof (prdirent_t
),
145 { PR_LUSAGE
, 16 * sizeof (prdirent_t
), sizeof (prdirent_t
),
147 { PR_PAGEDATA
, 17 * sizeof (prdirent_t
), sizeof (prdirent_t
),
149 { PR_WATCH
, 18 * sizeof (prdirent_t
), sizeof (prdirent_t
),
151 { PR_CURDIR
, 19 * sizeof (prdirent_t
), sizeof (prdirent_t
),
153 { PR_ROOTDIR
, 20 * sizeof (prdirent_t
), sizeof (prdirent_t
),
155 { PR_FDDIR
, 21 * sizeof (prdirent_t
), sizeof (prdirent_t
),
157 { PR_OBJECTDIR
, 22 * sizeof (prdirent_t
), sizeof (prdirent_t
),
159 { PR_LWPDIR
, 23 * sizeof (prdirent_t
), sizeof (prdirent_t
),
161 { PR_PRIV
, 24 * sizeof (prdirent_t
), sizeof (prdirent_t
),
163 { PR_PATHDIR
, 25 * sizeof (prdirent_t
), sizeof (prdirent_t
),
165 { PR_CTDIR
, 26 * sizeof (prdirent_t
), sizeof (prdirent_t
),
167 { PR_SECFLAGS
, 27 * sizeof (prdirent_t
), sizeof (prdirent_t
),
170 { PR_LDT
, 28 * sizeof (prdirent_t
), sizeof (prdirent_t
),
175 #define NPIDDIRFILES (sizeof (piddir) / sizeof (piddir[0]) - 2)
178 * Contents of a /proc/<pid>/lwp/<lwpid> directory.
180 static prdirent_t lwpiddir
[] = {
181 { PR_LWPIDDIR
, 1 * sizeof (prdirent_t
), sizeof (prdirent_t
),
183 { PR_LWPDIR
, 2 * sizeof (prdirent_t
), sizeof (prdirent_t
),
185 { PR_LWPCTL
, 3 * sizeof (prdirent_t
), sizeof (prdirent_t
),
187 { PR_LWPNAME
, 4 * sizeof (prdirent_t
), sizeof (prdirent_t
),
189 { PR_LWPSTATUS
, 5 * sizeof (prdirent_t
), sizeof (prdirent_t
),
191 { PR_LWPSINFO
, 6 * sizeof (prdirent_t
), sizeof (prdirent_t
),
193 { PR_LWPUSAGE
, 7 * sizeof (prdirent_t
), sizeof (prdirent_t
),
195 { PR_XREGS
, 8 * sizeof (prdirent_t
), sizeof (prdirent_t
),
197 { PR_TMPLDIR
, 9 * sizeof (prdirent_t
), sizeof (prdirent_t
),
199 { PR_SPYMASTER
, 10 * sizeof (prdirent_t
), sizeof (prdirent_t
),
202 { PR_GWINDOWS
, 11 * sizeof (prdirent_t
), sizeof (prdirent_t
),
204 { PR_ASRS
, 12 * sizeof (prdirent_t
), sizeof (prdirent_t
),
209 #define NLWPIDDIRFILES (sizeof (lwpiddir) / sizeof (lwpiddir[0]) - 2)
212 * Span of entries in the array files (lstatus, lpsinfo, lusage).
213 * We make the span larger than the size of the structure on purpose,
214 * to make sure that programs cannot use the structure size by mistake.
215 * Align _ILP32 structures at 8 bytes, _LP64 structures at 16 bytes.
218 #define LSPAN(type) (round16(sizeof (type)) + 16)
219 #define LSPAN32(type) (round8(sizeof (type)) + 8)
221 #define LSPAN(type) (round8(sizeof (type)) + 8)
224 static void rebuild_objdir(struct as
*);
225 static void prfreecommon(prcommon_t
*);
226 static int praccess(vnode_t
*, int, int, cred_t
*, caller_context_t
*);
229 propen(vnode_t
**vpp
, int flag
, cred_t
*cr
, caller_context_t
*ct
)
232 prnode_t
*pnp
= VTOP(vp
);
233 prcommon_t
*pcp
= pnp
->pr_pcommon
;
234 prnodetype_t type
= pnp
->pr_type
;
239 prnode_t
*npnp
= NULL
;
242 * Nothing to do for the /proc directory itself.
244 if (type
== PR_PROCDIR
)
248 * If we are opening an underlying mapped object, reject opens
249 * for writing regardless of the objects's access modes.
250 * If we are opening a file in the /proc/pid/fd directory,
251 * reject the open for any but a regular file or directory.
252 * Just do it if we are opening the current or root directory.
259 rvp
= pnp
->pr_realvp
;
261 if ((type
== PR_OBJECT
&& (flag
& FWRITE
)) ||
262 (type
== PR_FD
&& vtype
!= VREG
&& vtype
!= VDIR
))
266 * Need to hold rvp since VOP_OPEN() may release it.
269 error
= VOP_OPEN(&rvp
, flag
, cr
, ct
);
283 * If we are opening the pagedata file, allocate a prnode now
284 * to avoid calling kmem_alloc() while holding p->p_lock.
286 if (type
== PR_PAGEDATA
|| type
== PR_OPAGEDATA
)
287 npnp
= prgetnode(vp
, type
);
290 * If the process exists, lock it now.
291 * Otherwise we have a race condition with prclose().
294 mutex_exit(&pr_pidlock
);
300 ASSERT(p
== pcp
->prc_proc
);
301 ASSERT(p
->p_proc_flag
& P_PR_LOCK
);
304 * Maintain a count of opens for write. Allow exactly one
305 * O_WRITE|O_EXCL request and fail subsequent ones.
306 * Don't fail opens of old (bletch!) /proc lwp files.
307 * Special case for open by the process itself:
308 * Always allow the open by self and discount this
309 * open for other opens for writing.
313 pcp
->prc_selfopens
++;
314 pnp
->pr_flags
|= PR_ISSELF
;
315 } else if (type
== PR_LWPIDFILE
) {
317 } else if (flag
& FEXCL
) {
318 if (pcp
->prc_writers
> pcp
->prc_selfopens
) {
322 /* semantic for old /proc interface */
323 if (type
== PR_PIDDIR
)
324 pcp
->prc_flags
|= PRC_EXCL
;
325 } else if (pcp
->prc_flags
& PRC_EXCL
) {
326 ASSERT(pcp
->prc_writers
> pcp
->prc_selfopens
);
327 error
= secpolicy_proc_excl_open(cr
);
333 * The vnode may have become invalid between the
334 * VOP_LOOKUP() of the /proc vnode and the VOP_OPEN().
335 * If so, do now what prinvalidate() should have done.
337 if ((pnp
->pr_flags
& PR_INVAL
) ||
338 (type
== PR_PIDDIR
&&
339 (VTOP(pnp
->pr_pidfile
)->pr_flags
& PR_INVAL
))) {
341 pcp
->prc_selfopens
++;
342 ASSERT(pcp
->prc_selfopens
<= pcp
->prc_writers
);
343 if (pcp
->prc_selfopens
== pcp
->prc_writers
)
344 pcp
->prc_flags
&= ~PRC_EXCL
;
349 * If this is a large file open, indicate that in our flags -- some
350 * procfs structures are not off_t-neutral (e.g., priovec_t), and
351 * the open will need to be differentiated where 32-bit processes
352 * pass these structures across the user/kernel boundary.
355 pnp
->pr_flags
|= PR_OFFMAX
;
358 * Do file-specific things.
366 * Enable data collection for page data file;
367 * get unique id from the hat layer.
373 * Drop p->p_lock to call hat_startstat()
375 mutex_exit(&p
->p_lock
);
376 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
||
377 (id
= hat_startstat(p
->p_as
)) == -1) {
378 mutex_enter(&p
->p_lock
);
380 } else if (pnp
->pr_hatid
== 0) {
381 mutex_enter(&p
->p_lock
);
382 pnp
->pr_hatid
= (uint_t
)id
;
384 mutex_enter(&p
->p_lock
);
386 * Use our newly allocated prnode.
388 npnp
->pr_hatid
= (uint_t
)id
;
390 * prgetnode() initialized most of the prnode.
391 * Duplicate the remainder.
393 npnp
->pr_ino
= pnp
->pr_ino
;
394 npnp
->pr_common
= pnp
->pr_common
;
395 npnp
->pr_pcommon
= pnp
->pr_pcommon
;
396 npnp
->pr_parent
= pnp
->pr_parent
;
397 VN_HOLD(npnp
->pr_parent
);
398 npnp
->pr_index
= pnp
->pr_index
;
400 npnp
->pr_next
= p
->p_plist
;
401 p
->p_plist
= PTOV(npnp
);
422 prclose(vnode_t
*vp
, int flag
, int count
, offset_t offset
, cred_t
*cr
,
423 caller_context_t
*ct
)
425 prnode_t
*pnp
= VTOP(vp
);
426 prcommon_t
*pcp
= pnp
->pr_pcommon
;
427 prnodetype_t type
= pnp
->pr_type
;
433 * Nothing to do for the /proc directory itself.
435 if (type
== PR_PROCDIR
)
438 ASSERT(type
!= PR_OBJECT
&& type
!= PR_FD
&&
439 type
!= PR_CURDIR
&& type
!= PR_ROOTDIR
);
442 * If the process exists, lock it now.
443 * Otherwise we have a race condition with propen().
444 * Hold pr_pidlock across the reference to prc_selfopens,
445 * and prc_writers in case there is no process anymore,
446 * to cover the case of concurrent calls to prclose()
447 * after the process has been reaped by freeproc().
452 * There is nothing more to do until the last close of
453 * the file table entry except to clear the pr_owner
454 * field of the prnode and notify any waiters
455 * (their file descriptor may have just been closed).
458 mutex_exit(&pr_pidlock
);
459 if (pnp
->pr_owner
== curproc
&& !fisopen(vp
))
460 pnp
->pr_owner
= NULL
;
469 * Decrement the count of self-opens for writing.
470 * Decrement the total count of opens for writing.
471 * Cancel exclusive opens when only self-opens remain.
475 * prc_selfopens also contains the count of
476 * invalid writers. See prinvalidate().
478 if ((pnp
->pr_flags
& (PR_ISSELF
|PR_INVAL
)) ||
479 (type
== PR_PIDDIR
&&
480 (VTOP(pnp
->pr_pidfile
)->pr_flags
& PR_INVAL
))) {
481 ASSERT(pcp
->prc_selfopens
!= 0);
482 --pcp
->prc_selfopens
;
484 ASSERT(pcp
->prc_writers
!= 0);
485 if (--pcp
->prc_writers
== pcp
->prc_selfopens
)
486 pcp
->prc_flags
&= ~PRC_EXCL
;
488 ASSERT(pcp
->prc_writers
>= pcp
->prc_selfopens
);
489 mutex_exit(&pr_pidlock
);
490 if (pnp
->pr_owner
== curproc
&& !fisopen(vp
))
491 pnp
->pr_owner
= NULL
;
494 * If there is no process, there is nothing more to do.
499 ASSERT(p
== pcp
->prc_proc
);
500 prnotify(vp
); /* notify waiters */
503 * Do file-specific things.
511 * This is a page data file.
512 * Free the hat level statistics.
513 * Drop p->p_lock before calling hat_freestat().
515 mutex_exit(&p
->p_lock
);
516 if (p
->p_as
!= &kas
&& pnp
->pr_hatid
!= 0)
517 hat_freestat(p
->p_as
, pnp
->pr_hatid
);
518 mutex_enter(&p
->p_lock
);
524 * On last close of all writable file descriptors,
525 * perform run-on-last-close and/or kill-on-last-close logic.
526 * Can't do this is the /proc agent lwp still exists.
528 if (pcp
->prc_writers
== 0 &&
529 p
->p_agenttp
== NULL
&&
530 !(pcp
->prc_flags
& PRC_DESTROY
) &&
531 p
->p_stat
!= SZOMB
&&
532 (p
->p_proc_flag
& (P_PR_RUNLCL
|P_PR_KILLCL
))) {
536 * Cancel any watchpoints currently in effect.
537 * The process might disappear during this operation.
539 if (pr_cancel_watch(pnp
) == NULL
)
542 * If any tracing flags are set, clear them.
544 if (p
->p_proc_flag
& P_PR_TRACE
) {
546 premptyset(&up
->u_entrymask
);
547 premptyset(&up
->u_exitmask
);
550 premptyset(&p
->p_sigmask
);
551 premptyset(&p
->p_fltmask
);
552 killproc
= (p
->p_proc_flag
& P_PR_KILLCL
);
553 p
->p_proc_flag
&= ~(P_PR_RUNLCL
|P_PR_KILLCL
|P_PR_TRACE
);
555 * Cancel any outstanding single-step requests.
557 if ((t
= p
->p_tlist
) != NULL
) {
559 * Drop p_lock because prnostep() touches the stack.
560 * The loop is safe because the process is P_PR_LOCK'd.
562 mutex_exit(&p
->p_lock
);
565 } while ((t
= t
->t_forw
) != p
->p_tlist
);
566 mutex_enter(&p
->p_lock
);
569 * Set runnable all lwps stopped by /proc.
572 sigtoproc(p
, NULL
, SIGKILL
);
582 * Array of read functions, indexed by /proc file type.
584 static int pr_read_inval(), pr_read_as(), pr_read_status(),
585 pr_read_lstatus(), pr_read_psinfo(), pr_read_lpsinfo(),
586 pr_read_map(), pr_read_rmap(), pr_read_xmap(),
587 pr_read_cred(), pr_read_sigact(), pr_read_auxv(),
591 pr_read_usage(), pr_read_lusage(), pr_read_pagedata(),
592 pr_read_watch(), pr_read_lwpstatus(), pr_read_lwpsinfo(),
593 pr_read_lwpusage(), pr_read_lwpname(),
594 pr_read_xregs(), pr_read_priv(),
595 pr_read_spymaster(), pr_read_secflags(),
597 pr_read_gwindows(), pr_read_asrs(),
599 pr_read_piddir(), pr_read_pidfile(), pr_read_opagedata();
601 static int (*pr_read_function
[PR_NFILES
])() = {
602 pr_read_inval
, /* /proc */
603 pr_read_inval
, /* /proc/self */
604 pr_read_piddir
, /* /proc/<pid> (old /proc read()) */
605 pr_read_as
, /* /proc/<pid>/as */
606 pr_read_inval
, /* /proc/<pid>/ctl */
607 pr_read_status
, /* /proc/<pid>/status */
608 pr_read_lstatus
, /* /proc/<pid>/lstatus */
609 pr_read_psinfo
, /* /proc/<pid>/psinfo */
610 pr_read_lpsinfo
, /* /proc/<pid>/lpsinfo */
611 pr_read_map
, /* /proc/<pid>/map */
612 pr_read_rmap
, /* /proc/<pid>/rmap */
613 pr_read_xmap
, /* /proc/<pid>/xmap */
614 pr_read_cred
, /* /proc/<pid>/cred */
615 pr_read_sigact
, /* /proc/<pid>/sigact */
616 pr_read_auxv
, /* /proc/<pid>/auxv */
618 pr_read_ldt
, /* /proc/<pid>/ldt */
620 pr_read_usage
, /* /proc/<pid>/usage */
621 pr_read_lusage
, /* /proc/<pid>/lusage */
622 pr_read_pagedata
, /* /proc/<pid>/pagedata */
623 pr_read_watch
, /* /proc/<pid>/watch */
624 pr_read_inval
, /* /proc/<pid>/cwd */
625 pr_read_inval
, /* /proc/<pid>/root */
626 pr_read_inval
, /* /proc/<pid>/fd */
627 pr_read_inval
, /* /proc/<pid>/fd/nn */
628 pr_read_inval
, /* /proc/<pid>/object */
629 pr_read_inval
, /* /proc/<pid>/object/xxx */
630 pr_read_inval
, /* /proc/<pid>/lwp */
631 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid> */
632 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
633 pr_read_lwpname
, /* /proc/<pid>/lwp/<lwpid>/lwpname */
634 pr_read_lwpstatus
, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
635 pr_read_lwpsinfo
, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
636 pr_read_lwpusage
, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
637 pr_read_xregs
, /* /proc/<pid>/lwp/<lwpid>/xregs */
638 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/templates */
639 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
640 pr_read_spymaster
, /* /proc/<pid>/lwp/<lwpid>/spymaster */
642 pr_read_gwindows
, /* /proc/<pid>/lwp/<lwpid>/gwindows */
643 pr_read_asrs
, /* /proc/<pid>/lwp/<lwpid>/asrs */
645 pr_read_priv
, /* /proc/<pid>/priv */
646 pr_read_inval
, /* /proc/<pid>/path */
647 pr_read_inval
, /* /proc/<pid>/path/xxx */
648 pr_read_inval
, /* /proc/<pid>/contracts */
649 pr_read_inval
, /* /proc/<pid>/contracts/<ctid> */
650 pr_read_secflags
, /* /proc/<pid>/secflags */
651 pr_read_pidfile
, /* old process file */
652 pr_read_pidfile
, /* old lwp file */
653 pr_read_opagedata
, /* old pagedata file */
658 pr_read_inval(prnode_t
*pnp
, uio_t
*uiop
)
661 * No read() on any /proc directory, use getdents(2) instead.
662 * Cannot read a control file either.
663 * An underlying mapped object file cannot get here.
669 pr_uioread(void *base
, long count
, uio_t
*uiop
)
674 count
-= uiop
->uio_offset
;
675 if (count
> 0 && uiop
->uio_offset
>= 0) {
676 error
= uiomove((char *)base
+ uiop
->uio_offset
,
677 count
, UIO_READ
, uiop
);
684 pr_read_as(prnode_t
*pnp
, uio_t
*uiop
)
688 ASSERT(pnp
->pr_type
== PR_AS
);
690 if ((error
= prlock(pnp
, ZNO
)) == 0) {
691 proc_t
*p
= pnp
->pr_common
->prc_proc
;
692 struct as
*as
= p
->p_as
;
695 * /proc I/O cannot be done to a system process.
696 * A 32-bit process cannot read a 64-bit process.
698 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
700 #ifdef _SYSCALL32_IMPL
701 } else if (curproc
->p_model
== DATAMODEL_ILP32
&&
702 PROCESS_NOT_32BIT(p
)) {
707 * We don't hold p_lock over an i/o operation because
708 * that could lead to deadlock with the clock thread.
710 mutex_exit(&p
->p_lock
);
711 error
= prusrio(p
, UIO_READ
, uiop
, 0);
712 mutex_enter(&p
->p_lock
);
721 pr_read_status(prnode_t
*pnp
, uio_t
*uiop
)
726 ASSERT(pnp
->pr_type
== PR_STATUS
);
729 * We kmem_alloc() the pstatus structure because
730 * it is so big it might blow the kernel stack.
732 sp
= kmem_alloc(sizeof (*sp
), KM_SLEEP
);
733 if ((error
= prlock(pnp
, ZNO
)) == 0) {
734 prgetstatus(pnp
->pr_common
->prc_proc
, sp
, VTOZONE(PTOV(pnp
)));
736 error
= pr_uioread(sp
, sizeof (*sp
), uiop
);
738 kmem_free(sp
, sizeof (*sp
));
743 pr_read_lstatus(prnode_t
*pnp
, uio_t
*uiop
)
755 ASSERT(pnp
->pr_type
== PR_LSTATUS
);
757 if ((error
= prlock(pnp
, ZNO
)) != 0)
759 p
= pnp
->pr_common
->prc_proc
;
761 size
= sizeof (prheader_t
) + nlwp
* LSPAN(lwpstatus_t
);
763 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
764 mutex_exit(&p
->p_lock
);
765 php
= kmem_zalloc(size
, KM_SLEEP
);
766 mutex_enter(&p
->p_lock
);
767 /* p->p_lwpcnt can't change while process is locked */
768 ASSERT(nlwp
== p
->p_lwpcnt
);
771 php
->pr_entsize
= LSPAN(lwpstatus_t
);
773 sp
= (lwpstatus_t
*)(php
+ 1);
774 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
775 if (ldp
->ld_entry
== NULL
||
776 (t
= ldp
->ld_entry
->le_thread
) == NULL
)
778 prgetlwpstatus(t
, sp
, VTOZONE(PTOV(pnp
)));
779 sp
= (lwpstatus_t
*)((caddr_t
)sp
+ LSPAN(lwpstatus_t
));
783 error
= pr_uioread(php
, size
, uiop
);
784 kmem_free(php
, size
);
789 pr_read_psinfo(prnode_t
*pnp
, uio_t
*uiop
)
795 ASSERT(pnp
->pr_type
== PR_PSINFO
);
798 * We don't want the full treatment of prlock(pnp) here.
799 * This file is world-readable and never goes invalid.
800 * It doesn't matter if we are in the middle of an exec().
803 mutex_exit(&pr_pidlock
);
807 ASSERT(p
== pnp
->pr_common
->prc_proc
);
808 prgetpsinfo(p
, &psinfo
);
810 error
= pr_uioread(&psinfo
, sizeof (psinfo
), uiop
);
816 pr_read_lpsinfo(prnode_t
*pnp
, uio_t
*uiop
)
829 ASSERT(pnp
->pr_type
== PR_LPSINFO
);
832 * We don't want the full treatment of prlock(pnp) here.
833 * This file is world-readable and never goes invalid.
834 * It doesn't matter if we are in the middle of an exec().
837 mutex_exit(&pr_pidlock
);
840 ASSERT(p
== pnp
->pr_common
->prc_proc
);
841 if ((nlwp
= p
->p_lwpcnt
+ p
->p_zombcnt
) == 0) {
845 size
= sizeof (prheader_t
) + nlwp
* LSPAN(lwpsinfo_t
);
847 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
848 mutex_exit(&p
->p_lock
);
849 php
= kmem_zalloc(size
, KM_SLEEP
);
850 mutex_enter(&p
->p_lock
);
851 /* p->p_lwpcnt can't change while process is locked */
852 ASSERT(nlwp
== p
->p_lwpcnt
+ p
->p_zombcnt
);
855 php
->pr_entsize
= LSPAN(lwpsinfo_t
);
857 sp
= (lwpsinfo_t
*)(php
+ 1);
858 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
859 if ((lep
= ldp
->ld_entry
) == NULL
)
861 if ((t
= lep
->le_thread
) != NULL
)
862 prgetlwpsinfo(t
, sp
);
864 bzero(sp
, sizeof (*sp
));
865 sp
->pr_lwpid
= lep
->le_lwpid
;
866 sp
->pr_state
= SZOMB
;
868 sp
->pr_start
.tv_sec
= lep
->le_start
;
869 sp
->pr_bindpro
= PBIND_NONE
;
870 sp
->pr_bindpset
= PS_NONE
;
872 sp
= (lwpsinfo_t
*)((caddr_t
)sp
+ LSPAN(lwpsinfo_t
));
876 error
= pr_uioread(php
, size
, uiop
);
877 kmem_free(php
, size
);
882 pr_read_map_common(prnode_t
*pnp
, uio_t
*uiop
, prnodetype_t type
)
890 if ((error
= prlock(pnp
, ZNO
)) != 0)
893 p
= pnp
->pr_common
->prc_proc
;
896 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
901 if (!AS_LOCK_TRYENTER(as
, RW_WRITER
)) {
906 mutex_exit(&p
->p_lock
);
910 error
= prgetxmap(p
, &iolhead
);
913 error
= prgetmap(p
, 1, &iolhead
);
916 error
= prgetmap(p
, 0, &iolhead
);
921 mutex_enter(&p
->p_lock
);
924 error
= pr_iol_uiomove_and_free(&iolhead
, uiop
, error
);
930 pr_read_map(prnode_t
*pnp
, uio_t
*uiop
)
932 ASSERT(pnp
->pr_type
== PR_MAP
);
933 return (pr_read_map_common(pnp
, uiop
, pnp
->pr_type
));
937 pr_read_rmap(prnode_t
*pnp
, uio_t
*uiop
)
939 ASSERT(pnp
->pr_type
== PR_RMAP
);
940 return (pr_read_map_common(pnp
, uiop
, pnp
->pr_type
));
944 pr_read_xmap(prnode_t
*pnp
, uio_t
*uiop
)
946 ASSERT(pnp
->pr_type
== PR_XMAP
);
947 return (pr_read_map_common(pnp
, uiop
, pnp
->pr_type
));
951 pr_read_cred(prnode_t
*pnp
, uio_t
*uiop
)
958 ASSERT(pnp
->pr_type
== PR_CRED
);
961 * We kmem_alloc() the prcred_t structure because
962 * the number of supplementary groups is variable.
965 kmem_alloc(sizeof (prcred_t
) + sizeof (gid_t
) * (ngroups_max
- 1),
968 if ((error
= prlock(pnp
, ZNO
)) != 0)
970 p
= pnp
->pr_common
->prc_proc
;
976 count
= sizeof (prcred_t
);
977 if (pcrp
->pr_ngroups
> 1)
978 count
+= sizeof (gid_t
) * (pcrp
->pr_ngroups
- 1);
979 error
= pr_uioread(pcrp
, count
, uiop
);
981 kmem_free(pcrp
, sizeof (prcred_t
) + sizeof (gid_t
) * (ngroups_max
- 1));
986 pr_read_priv(prnode_t
*pnp
, uio_t
*uiop
)
989 size_t psize
= prgetprivsize();
990 prpriv_t
*ppriv
= kmem_alloc(psize
, KM_SLEEP
);
993 ASSERT(pnp
->pr_type
== PR_PRIV
);
995 if ((error
= prlock(pnp
, ZNO
)) != 0)
997 p
= pnp
->pr_common
->prc_proc
;
1000 prgetpriv(p
, ppriv
);
1003 error
= pr_uioread(ppriv
, psize
, uiop
);
1005 kmem_free(ppriv
, psize
);
1010 pr_read_sigact(prnode_t
*pnp
, uio_t
*uiop
)
1012 int nsig
= PROC_IS_BRANDED(curproc
)? BROP(curproc
)->b_nsig
: NSIG
;
1014 struct sigaction
*sap
;
1019 ASSERT(pnp
->pr_type
== PR_SIGACT
);
1022 * We kmem_alloc() the sigaction array because
1023 * it is so big it might blow the kernel stack.
1025 sap
= kmem_alloc((nsig
-1) * sizeof (struct sigaction
), KM_SLEEP
);
1027 if ((error
= prlock(pnp
, ZNO
)) != 0)
1029 p
= pnp
->pr_common
->prc_proc
;
1032 if (uiop
->uio_offset
>= (nsig
-1)*sizeof (struct sigaction
)) {
1038 for (sig
= 1; sig
< nsig
; sig
++)
1039 prgetaction(p
, up
, sig
, &sap
[sig
-1]);
1042 error
= pr_uioread(sap
, (nsig
- 1) * sizeof (struct sigaction
), uiop
);
1044 kmem_free(sap
, (nsig
-1) * sizeof (struct sigaction
));
1049 pr_read_auxv(prnode_t
*pnp
, uio_t
*uiop
)
1051 auxv_t auxv
[__KERN_NAUXV_IMPL
];
1056 ASSERT(pnp
->pr_type
== PR_AUXV
);
1058 if ((error
= prlock(pnp
, ZNO
)) != 0)
1061 if (uiop
->uio_offset
>= sizeof (auxv
)) {
1066 p
= pnp
->pr_common
->prc_proc
;
1068 bcopy(up
->u_auxv
, auxv
, sizeof (auxv
));
1071 return (pr_uioread(auxv
, sizeof (auxv
), uiop
));
1077 * This is almost certainly broken for the amd64 kernel, because
1078 * we have two kinds of LDT structures to export -- one for compatibility
1079 * mode, and one for long mode, sigh.
1081 * For now let's just have a ldt of size 0 for 64-bit processes.
1084 pr_read_ldt(prnode_t
*pnp
, uio_t
*uiop
)
1091 ASSERT(pnp
->pr_type
== PR_LDT
);
1093 if ((error
= prlock(pnp
, ZNO
)) != 0)
1095 p
= pnp
->pr_common
->prc_proc
;
1097 mutex_exit(&p
->p_lock
);
1098 mutex_enter(&p
->p_ldtlock
);
1099 size
= prnldt(p
) * sizeof (struct ssd
);
1100 if (uiop
->uio_offset
>= size
) {
1101 mutex_exit(&p
->p_ldtlock
);
1102 mutex_enter(&p
->p_lock
);
1107 ssd
= kmem_alloc(size
, KM_SLEEP
);
1109 mutex_exit(&p
->p_ldtlock
);
1110 mutex_enter(&p
->p_lock
);
1113 error
= pr_uioread(ssd
, size
, uiop
);
1114 kmem_free(ssd
, size
);
1120 pr_read_usage(prnode_t
*pnp
, uio_t
*uiop
)
1128 ASSERT(pnp
->pr_type
== PR_USAGE
);
1130 /* allocate now, before locking the process */
1131 pup
= kmem_zalloc(sizeof (*pup
), KM_SLEEP
);
1132 upup
= kmem_alloc(sizeof (*upup
), KM_SLEEP
);
1135 * We don't want the full treatment of prlock(pnp) here.
1136 * This file is world-readable and never goes invalid.
1137 * It doesn't matter if we are in the middle of an exec().
1140 mutex_exit(&pr_pidlock
);
1145 ASSERT(p
== pnp
->pr_common
->prc_proc
);
1147 if (uiop
->uio_offset
>= sizeof (prusage_t
)) {
1153 pup
->pr_tstamp
= gethrtime();
1155 pup
->pr_count
= p
->p_defunct
;
1156 pup
->pr_create
= p
->p_mstart
;
1157 pup
->pr_term
= p
->p_mterm
;
1159 pup
->pr_rtime
= p
->p_mlreal
;
1160 pup
->pr_utime
= p
->p_acct
[LMS_USER
];
1161 pup
->pr_stime
= p
->p_acct
[LMS_SYSTEM
];
1162 pup
->pr_ttime
= p
->p_acct
[LMS_TRAP
];
1163 pup
->pr_tftime
= p
->p_acct
[LMS_TFAULT
];
1164 pup
->pr_dftime
= p
->p_acct
[LMS_DFAULT
];
1165 pup
->pr_kftime
= p
->p_acct
[LMS_KFAULT
];
1166 pup
->pr_ltime
= p
->p_acct
[LMS_USER_LOCK
];
1167 pup
->pr_slptime
= p
->p_acct
[LMS_SLEEP
];
1168 pup
->pr_wtime
= p
->p_acct
[LMS_WAIT_CPU
];
1169 pup
->pr_stoptime
= p
->p_acct
[LMS_STOPPED
];
1171 pup
->pr_minf
= p
->p_ru
.minflt
;
1172 pup
->pr_majf
= p
->p_ru
.majflt
;
1173 pup
->pr_nswap
= p
->p_ru
.nswap
;
1174 pup
->pr_inblk
= p
->p_ru
.inblock
;
1175 pup
->pr_oublk
= p
->p_ru
.oublock
;
1176 pup
->pr_msnd
= p
->p_ru
.msgsnd
;
1177 pup
->pr_mrcv
= p
->p_ru
.msgrcv
;
1178 pup
->pr_sigs
= p
->p_ru
.nsignals
;
1179 pup
->pr_vctx
= p
->p_ru
.nvcsw
;
1180 pup
->pr_ictx
= p
->p_ru
.nivcsw
;
1181 pup
->pr_sysc
= p
->p_ru
.sysc
;
1182 pup
->pr_ioch
= p
->p_ru
.ioch
;
1185 * Add the usage information for each active lwp.
1187 if ((t
= p
->p_tlist
) != NULL
&&
1188 !(pnp
->pr_pcommon
->prc_flags
& PRC_DESTROY
)) {
1190 if (t
->t_proc_flag
& TP_LWPEXIT
)
1194 } while ((t
= t
->t_forw
) != p
->p_tlist
);
1199 prcvtusage(pup
, upup
);
1201 error
= pr_uioread(upup
, sizeof (prusage_t
), uiop
);
1203 kmem_free(pup
, sizeof (*pup
));
1204 kmem_free(upup
, sizeof (*upup
));
1209 pr_read_lusage(prnode_t
*pnp
, uio_t
*uiop
)
1223 ASSERT(pnp
->pr_type
== PR_LUSAGE
);
1226 * We don't want the full treatment of prlock(pnp) here.
1227 * This file is world-readable and never goes invalid.
1228 * It doesn't matter if we are in the middle of an exec().
1231 mutex_exit(&pr_pidlock
);
1234 ASSERT(p
== pnp
->pr_common
->prc_proc
);
1235 if ((nlwp
= p
->p_lwpcnt
) == 0) {
1240 size
= sizeof (prheader_t
) + (nlwp
+ 1) * LSPAN(prusage_t
);
1241 if (uiop
->uio_offset
>= size
) {
1246 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1247 mutex_exit(&p
->p_lock
);
1248 pup
= kmem_zalloc(size
+ sizeof (prhusage_t
), KM_SLEEP
);
1249 mutex_enter(&p
->p_lock
);
1250 /* p->p_lwpcnt can't change while process is locked */
1251 ASSERT(nlwp
== p
->p_lwpcnt
);
1253 php
= (prheader_t
*)(pup
+ 1);
1254 upup
= (prusage_t
*)(php
+ 1);
1256 php
->pr_nent
= nlwp
+ 1;
1257 php
->pr_entsize
= LSPAN(prusage_t
);
1259 curtime
= gethrtime();
1262 * First the summation over defunct lwps.
1264 pup
->pr_count
= p
->p_defunct
;
1265 pup
->pr_tstamp
= curtime
;
1266 pup
->pr_create
= p
->p_mstart
;
1267 pup
->pr_term
= p
->p_mterm
;
1269 pup
->pr_rtime
= p
->p_mlreal
;
1270 pup
->pr_utime
= p
->p_acct
[LMS_USER
];
1271 pup
->pr_stime
= p
->p_acct
[LMS_SYSTEM
];
1272 pup
->pr_ttime
= p
->p_acct
[LMS_TRAP
];
1273 pup
->pr_tftime
= p
->p_acct
[LMS_TFAULT
];
1274 pup
->pr_dftime
= p
->p_acct
[LMS_DFAULT
];
1275 pup
->pr_kftime
= p
->p_acct
[LMS_KFAULT
];
1276 pup
->pr_ltime
= p
->p_acct
[LMS_USER_LOCK
];
1277 pup
->pr_slptime
= p
->p_acct
[LMS_SLEEP
];
1278 pup
->pr_wtime
= p
->p_acct
[LMS_WAIT_CPU
];
1279 pup
->pr_stoptime
= p
->p_acct
[LMS_STOPPED
];
1281 pup
->pr_minf
= p
->p_ru
.minflt
;
1282 pup
->pr_majf
= p
->p_ru
.majflt
;
1283 pup
->pr_nswap
= p
->p_ru
.nswap
;
1284 pup
->pr_inblk
= p
->p_ru
.inblock
;
1285 pup
->pr_oublk
= p
->p_ru
.oublock
;
1286 pup
->pr_msnd
= p
->p_ru
.msgsnd
;
1287 pup
->pr_mrcv
= p
->p_ru
.msgrcv
;
1288 pup
->pr_sigs
= p
->p_ru
.nsignals
;
1289 pup
->pr_vctx
= p
->p_ru
.nvcsw
;
1290 pup
->pr_ictx
= p
->p_ru
.nivcsw
;
1291 pup
->pr_sysc
= p
->p_ru
.sysc
;
1292 pup
->pr_ioch
= p
->p_ru
.ioch
;
1294 prcvtusage(pup
, upup
);
1297 * Fill one prusage struct for each active lwp.
1299 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
1300 if (ldp
->ld_entry
== NULL
||
1301 (t
= ldp
->ld_entry
->le_thread
) == NULL
)
1303 ASSERT(!(t
->t_proc_flag
& TP_LWPEXIT
));
1306 upup
= (prusage_t
*)((caddr_t
)upup
+ LSPAN(prusage_t
));
1308 prcvtusage(pup
, upup
);
1314 error
= pr_uioread(php
, size
, uiop
);
1315 kmem_free(pup
, size
+ sizeof (prhusage_t
));
1320 pr_read_pagedata(prnode_t
*pnp
, uio_t
*uiop
)
1325 ASSERT(pnp
->pr_type
== PR_PAGEDATA
);
1327 if ((error
= prlock(pnp
, ZNO
)) != 0)
1330 p
= pnp
->pr_common
->prc_proc
;
1331 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
) {
1336 mutex_exit(&p
->p_lock
);
1337 error
= prpdread(p
, pnp
->pr_hatid
, uiop
);
1338 mutex_enter(&p
->p_lock
);
1345 pr_read_opagedata(prnode_t
*pnp
, uio_t
*uiop
)
1351 ASSERT(pnp
->pr_type
== PR_OPAGEDATA
);
1353 if ((error
= prlock(pnp
, ZNO
)) != 0)
1356 p
= pnp
->pr_common
->prc_proc
;
1358 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
1363 mutex_exit(&p
->p_lock
);
1364 error
= oprpdread(as
, pnp
->pr_hatid
, uiop
);
1365 mutex_enter(&p
->p_lock
);
1372 pr_read_watch(prnode_t
*pnp
, uio_t
*uiop
)
1380 struct watched_area
*pwarea
;
1382 ASSERT(pnp
->pr_type
== PR_WATCH
);
1384 if ((error
= prlock(pnp
, ZNO
)) != 0)
1387 p
= pnp
->pr_common
->prc_proc
;
1388 nwarea
= avl_numnodes(&p
->p_warea
);
1389 size
= nwarea
* sizeof (prwatch_t
);
1390 if (uiop
->uio_offset
>= size
) {
1395 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1396 mutex_exit(&p
->p_lock
);
1397 Bpwp
= pwp
= kmem_zalloc(size
, KM_SLEEP
);
1398 mutex_enter(&p
->p_lock
);
1399 /* p->p_nwarea can't change while process is locked */
1400 ASSERT(nwarea
== avl_numnodes(&p
->p_warea
));
1402 /* gather the watched areas */
1403 for (pwarea
= avl_first(&p
->p_warea
); pwarea
!= NULL
;
1404 pwarea
= AVL_NEXT(&p
->p_warea
, pwarea
), pwp
++) {
1405 pwp
->pr_vaddr
= (uintptr_t)pwarea
->wa_vaddr
;
1406 pwp
->pr_size
= pwarea
->wa_eaddr
- pwarea
->wa_vaddr
;
1407 pwp
->pr_wflags
= (int)pwarea
->wa_flags
;
1412 error
= pr_uioread(Bpwp
, size
, uiop
);
1413 kmem_free(Bpwp
, size
);
1418 pr_read_lwpstatus(prnode_t
*pnp
, uio_t
*uiop
)
1423 ASSERT(pnp
->pr_type
== PR_LWPSTATUS
);
1426 * We kmem_alloc() the lwpstatus structure because
1427 * it is so big it might blow the kernel stack.
1429 sp
= kmem_alloc(sizeof (*sp
), KM_SLEEP
);
1431 if ((error
= prlock(pnp
, ZNO
)) != 0)
1434 if (uiop
->uio_offset
>= sizeof (*sp
)) {
1439 prgetlwpstatus(pnp
->pr_common
->prc_thread
, sp
, VTOZONE(PTOV(pnp
)));
1442 error
= pr_uioread(sp
, sizeof (*sp
), uiop
);
1444 kmem_free(sp
, sizeof (*sp
));
1449 pr_read_lwpsinfo(prnode_t
*pnp
, uio_t
*uiop
)
1451 lwpsinfo_t lwpsinfo
;
1456 ASSERT(pnp
->pr_type
== PR_LWPSINFO
);
1459 * We don't want the full treatment of prlock(pnp) here.
1460 * This file is world-readable and never goes invalid.
1461 * It doesn't matter if we are in the middle of an exec().
1464 mutex_exit(&pr_pidlock
);
1467 ASSERT(p
== pnp
->pr_common
->prc_proc
);
1468 if (pnp
->pr_common
->prc_tslot
== -1) {
1473 if (uiop
->uio_offset
>= sizeof (lwpsinfo
)) {
1478 if ((t
= pnp
->pr_common
->prc_thread
) != NULL
)
1479 prgetlwpsinfo(t
, &lwpsinfo
);
1481 lep
= p
->p_lwpdir
[pnp
->pr_common
->prc_tslot
].ld_entry
;
1482 bzero(&lwpsinfo
, sizeof (lwpsinfo
));
1483 lwpsinfo
.pr_lwpid
= lep
->le_lwpid
;
1484 lwpsinfo
.pr_state
= SZOMB
;
1485 lwpsinfo
.pr_sname
= 'Z';
1486 lwpsinfo
.pr_start
.tv_sec
= lep
->le_start
;
1487 lwpsinfo
.pr_bindpro
= PBIND_NONE
;
1488 lwpsinfo
.pr_bindpset
= PS_NONE
;
1492 return (pr_uioread(&lwpsinfo
, sizeof (lwpsinfo
), uiop
));
1496 pr_read_lwpusage(prnode_t
*pnp
, uio_t
*uiop
)
1503 ASSERT(pnp
->pr_type
== PR_LWPUSAGE
);
1505 /* allocate now, before locking the process */
1506 pup
= kmem_zalloc(sizeof (*pup
), KM_SLEEP
);
1507 upup
= kmem_alloc(sizeof (*upup
), KM_SLEEP
);
1510 * We don't want the full treatment of prlock(pnp) here.
1511 * This file is world-readable and never goes invalid.
1512 * It doesn't matter if we are in the middle of an exec().
1515 mutex_exit(&pr_pidlock
);
1520 ASSERT(p
== pnp
->pr_common
->prc_proc
);
1521 if (pnp
->pr_common
->prc_thread
== NULL
) {
1526 if (uiop
->uio_offset
>= sizeof (prusage_t
)) {
1532 pup
->pr_tstamp
= gethrtime();
1533 prgetusage(pnp
->pr_common
->prc_thread
, pup
);
1537 prcvtusage(pup
, upup
);
1539 error
= pr_uioread(upup
, sizeof (prusage_t
), uiop
);
1541 kmem_free(pup
, sizeof (*pup
));
1542 kmem_free(upup
, sizeof (*upup
));
1547 pr_read_lwpname(prnode_t
*pnp
, uio_t
*uiop
)
1549 char lwpname
[THREAD_NAME_MAX
];
1553 ASSERT(pnp
->pr_type
== PR_LWPNAME
);
1555 if (uiop
->uio_offset
>= THREAD_NAME_MAX
)
1558 if ((error
= prlock(pnp
, ZNO
)) != 0)
1561 bzero(lwpname
, sizeof (lwpname
));
1563 t
= pnp
->pr_common
->prc_thread
;
1565 if (t
->t_name
!= NULL
)
1566 (void) strlcpy(lwpname
, t
->t_name
, sizeof (lwpname
));
1570 return (pr_uioread(lwpname
, sizeof (lwpname
), uiop
));
1575 pr_read_xregs(prnode_t
*pnp
, uio_t
*uiop
)
1577 #if defined(__sparc)
1584 ASSERT(pnp
->pr_type
== PR_XREGS
);
1586 xreg
= kmem_zalloc(sizeof (prxregset_t
), KM_SLEEP
);
1588 if ((error
= prlock(pnp
, ZNO
)) != 0)
1591 p
= pnp
->pr_common
->prc_proc
;
1592 t
= pnp
->pr_common
->prc_thread
;
1594 size
= prhasx(p
)? prgetprxregsize(p
) : 0;
1595 if (uiop
->uio_offset
>= size
) {
1600 /* drop p->p_lock while (possibly) touching the stack */
1601 mutex_exit(&p
->p_lock
);
1602 prgetprxregs(ttolwp(t
), xreg
);
1603 mutex_enter(&p
->p_lock
);
1606 error
= pr_uioread(xreg
, size
, uiop
);
1608 kmem_free(xreg
, sizeof (prxregset_t
));
1616 pr_read_spymaster(prnode_t
*pnp
, uio_t
*uiop
)
1622 ASSERT(pnp
->pr_type
== PR_SPYMASTER
);
1624 if ((error
= prlock(pnp
, ZNO
)) != 0)
1627 if (pnp
->pr_common
->prc_thread
== NULL
) {
1632 lwp
= pnp
->pr_common
->prc_thread
->t_lwp
;
1634 if (lwp
->lwp_spymaster
== NULL
) {
1639 bcopy(lwp
->lwp_spymaster
, &psinfo
, sizeof (psinfo_t
));
1642 return (pr_uioread(&psinfo
, sizeof (psinfo
), uiop
));
1646 pr_read_secflags(prnode_t
*pnp
, uio_t
*uiop
)
1652 ASSERT(pnp
->pr_type
== PR_SECFLAGS
);
1654 if ((error
= prlock(pnp
, ZNO
)) != 0)
1657 p
= pnp
->pr_common
->prc_proc
;
1658 prgetsecflags(p
, &ret
);
1661 return (pr_uioread(&ret
, sizeof (ret
), uiop
));
1664 #if defined(__sparc)
1667 pr_read_gwindows(prnode_t
*pnp
, uio_t
*uiop
)
1675 ASSERT(pnp
->pr_type
== PR_GWINDOWS
);
1677 gwp
= kmem_zalloc(sizeof (gwindows_t
), KM_SLEEP
);
1679 if ((error
= prlock(pnp
, ZNO
)) != 0)
1682 p
= pnp
->pr_common
->prc_proc
;
1683 t
= pnp
->pr_common
->prc_thread
;
1686 * Drop p->p_lock while touching the stack.
1687 * The P_PR_LOCK flag prevents the lwp from
1688 * disappearing while we do this.
1690 mutex_exit(&p
->p_lock
);
1691 if ((size
= prnwindows(ttolwp(t
))) != 0)
1692 size
= sizeof (gwindows_t
) -
1693 (SPARC_MAXREGWINDOW
- size
) * sizeof (struct rwindow
);
1694 if (uiop
->uio_offset
>= size
) {
1695 mutex_enter(&p
->p_lock
);
1699 prgetwindows(ttolwp(t
), gwp
);
1700 mutex_enter(&p
->p_lock
);
1703 error
= pr_uioread(gwp
, size
, uiop
);
1705 kmem_free(gwp
, sizeof (gwindows_t
));
1711 pr_read_asrs(prnode_t
*pnp
, uio_t
*uiop
)
1715 ASSERT(pnp
->pr_type
== PR_ASRS
);
1717 /* the asrs file exists only for sparc v9 _LP64 processes */
1718 if ((error
= prlock(pnp
, ZNO
)) == 0) {
1719 proc_t
*p
= pnp
->pr_common
->prc_proc
;
1720 kthread_t
*t
= pnp
->pr_common
->prc_thread
;
1723 if (p
->p_model
!= DATAMODEL_LP64
||
1724 uiop
->uio_offset
>= sizeof (asrset_t
)) {
1730 * Drop p->p_lock while touching the stack.
1731 * The P_PR_LOCK flag prevents the lwp from
1732 * disappearing while we do this.
1734 mutex_exit(&p
->p_lock
);
1735 prgetasregs(ttolwp(t
), asrset
);
1736 mutex_enter(&p
->p_lock
);
1739 error
= pr_uioread(&asrset
[0], sizeof (asrset_t
), uiop
);
1745 #endif /* __sparc */
1748 pr_read_piddir(prnode_t
*pnp
, uio_t
*uiop
)
1750 ASSERT(pnp
->pr_type
== PR_PIDDIR
);
1751 ASSERT(pnp
->pr_pidfile
!= NULL
);
1753 /* use the underlying PR_PIDFILE to read the process */
1754 pnp
= VTOP(pnp
->pr_pidfile
);
1755 ASSERT(pnp
->pr_type
== PR_PIDFILE
);
1757 return (pr_read_pidfile(pnp
, uiop
));
1761 pr_read_pidfile(prnode_t
*pnp
, uio_t
*uiop
)
1765 ASSERT(pnp
->pr_type
== PR_PIDFILE
|| pnp
->pr_type
== PR_LWPIDFILE
);
1767 if ((error
= prlock(pnp
, ZNO
)) == 0) {
1768 proc_t
*p
= pnp
->pr_common
->prc_proc
;
1769 struct as
*as
= p
->p_as
;
1771 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
1773 * /proc I/O cannot be done to a system process.
1775 error
= EIO
; /* old /proc semantics */
1778 * We drop p_lock because we don't want to hold
1779 * it over an I/O operation because that could
1780 * lead to deadlock with the clock thread.
1781 * The process will not disappear and its address
1782 * space will not change because it is marked P_PR_LOCK.
1784 mutex_exit(&p
->p_lock
);
1785 error
= prusrio(p
, UIO_READ
, uiop
, 1);
1786 mutex_enter(&p
->p_lock
);
1794 #ifdef _SYSCALL32_IMPL
1797 * Array of ILP32 read functions, indexed by /proc file type.
1799 static int pr_read_status_32(),
1800 pr_read_lstatus_32(), pr_read_psinfo_32(), pr_read_lpsinfo_32(),
1801 pr_read_map_32(), pr_read_rmap_32(), pr_read_xmap_32(),
1802 pr_read_sigact_32(), pr_read_auxv_32(),
1803 pr_read_usage_32(), pr_read_lusage_32(), pr_read_pagedata_32(),
1804 pr_read_watch_32(), pr_read_lwpstatus_32(), pr_read_lwpsinfo_32(),
1805 pr_read_lwpusage_32(), pr_read_spymaster_32(),
1806 #if defined(__sparc)
1807 pr_read_gwindows_32(),
1809 pr_read_opagedata_32();
1811 static int (*pr_read_function_32
[PR_NFILES
])() = {
1812 pr_read_inval
, /* /proc */
1813 pr_read_inval
, /* /proc/self */
1814 pr_read_piddir
, /* /proc/<pid> (old /proc read()) */
1815 pr_read_as
, /* /proc/<pid>/as */
1816 pr_read_inval
, /* /proc/<pid>/ctl */
1817 pr_read_status_32
, /* /proc/<pid>/status */
1818 pr_read_lstatus_32
, /* /proc/<pid>/lstatus */
1819 pr_read_psinfo_32
, /* /proc/<pid>/psinfo */
1820 pr_read_lpsinfo_32
, /* /proc/<pid>/lpsinfo */
1821 pr_read_map_32
, /* /proc/<pid>/map */
1822 pr_read_rmap_32
, /* /proc/<pid>/rmap */
1823 pr_read_xmap_32
, /* /proc/<pid>/xmap */
1824 pr_read_cred
, /* /proc/<pid>/cred */
1825 pr_read_sigact_32
, /* /proc/<pid>/sigact */
1826 pr_read_auxv_32
, /* /proc/<pid>/auxv */
1828 pr_read_ldt
, /* /proc/<pid>/ldt */
1830 pr_read_usage_32
, /* /proc/<pid>/usage */
1831 pr_read_lusage_32
, /* /proc/<pid>/lusage */
1832 pr_read_pagedata_32
, /* /proc/<pid>/pagedata */
1833 pr_read_watch_32
, /* /proc/<pid>/watch */
1834 pr_read_inval
, /* /proc/<pid>/cwd */
1835 pr_read_inval
, /* /proc/<pid>/root */
1836 pr_read_inval
, /* /proc/<pid>/fd */
1837 pr_read_inval
, /* /proc/<pid>/fd/nn */
1838 pr_read_inval
, /* /proc/<pid>/object */
1839 pr_read_inval
, /* /proc/<pid>/object/xxx */
1840 pr_read_inval
, /* /proc/<pid>/lwp */
1841 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid> */
1842 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
1843 pr_read_lwpname
, /* /proc/<pid>/lwp/<lwpid>/lwpname */
1844 pr_read_lwpstatus_32
, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
1845 pr_read_lwpsinfo_32
, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
1846 pr_read_lwpusage_32
, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
1847 pr_read_xregs
, /* /proc/<pid>/lwp/<lwpid>/xregs */
1848 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/templates */
1849 pr_read_inval
, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
1850 pr_read_spymaster_32
, /* /proc/<pid>/lwp/<lwpid>/spymaster */
1851 #if defined(__sparc)
1852 pr_read_gwindows_32
, /* /proc/<pid>/lwp/<lwpid>/gwindows */
1853 pr_read_asrs
, /* /proc/<pid>/lwp/<lwpid>/asrs */
1855 pr_read_priv
, /* /proc/<pid>/priv */
1856 pr_read_inval
, /* /proc/<pid>/path */
1857 pr_read_inval
, /* /proc/<pid>/path/xxx */
1858 pr_read_inval
, /* /proc/<pid>/contracts */
1859 pr_read_inval
, /* /proc/<pid>/contracts/<ctid> */
1860 pr_read_secflags
, /* /proc/<pid>/secflags */
1861 pr_read_pidfile
, /* old process file */
1862 pr_read_pidfile
, /* old lwp file */
1863 pr_read_opagedata_32
, /* old pagedata file */
1867 pr_read_status_32(prnode_t
*pnp
, uio_t
*uiop
)
1873 ASSERT(pnp
->pr_type
== PR_STATUS
);
1876 * We kmem_alloc() the pstatus structure because
1877 * it is so big it might blow the kernel stack.
1879 sp
= kmem_alloc(sizeof (*sp
), KM_SLEEP
);
1880 if ((error
= prlock(pnp
, ZNO
)) == 0) {
1882 * A 32-bit process cannot get the status of a 64-bit process.
1883 * The fields for the 64-bit quantities are not large enough.
1885 p
= pnp
->pr_common
->prc_proc
;
1886 if (PROCESS_NOT_32BIT(p
)) {
1890 prgetstatus32(pnp
->pr_common
->prc_proc
, sp
,
1891 VTOZONE(PTOV(pnp
)));
1893 error
= pr_uioread(sp
, sizeof (*sp
), uiop
);
1896 kmem_free((caddr_t
)sp
, sizeof (*sp
));
1901 pr_read_lstatus_32(prnode_t
*pnp
, uio_t
*uiop
)
1913 ASSERT(pnp
->pr_type
== PR_LSTATUS
);
1915 if ((error
= prlock(pnp
, ZNO
)) != 0)
1917 p
= pnp
->pr_common
->prc_proc
;
1919 * A 32-bit process cannot get the status of a 64-bit process.
1920 * The fields for the 64-bit quantities are not large enough.
1922 if (PROCESS_NOT_32BIT(p
)) {
1927 size
= sizeof (prheader32_t
) + nlwp
* LSPAN32(lwpstatus32_t
);
1929 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
1930 mutex_exit(&p
->p_lock
);
1931 php
= kmem_zalloc(size
, KM_SLEEP
);
1932 mutex_enter(&p
->p_lock
);
1933 /* p->p_lwpcnt can't change while process is locked */
1934 ASSERT(nlwp
== p
->p_lwpcnt
);
1936 php
->pr_nent
= nlwp
;
1937 php
->pr_entsize
= LSPAN32(lwpstatus32_t
);
1939 sp
= (lwpstatus32_t
*)(php
+ 1);
1940 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
1941 if (ldp
->ld_entry
== NULL
||
1942 (t
= ldp
->ld_entry
->le_thread
) == NULL
)
1944 prgetlwpstatus32(t
, sp
, VTOZONE(PTOV(pnp
)));
1945 sp
= (lwpstatus32_t
*)((caddr_t
)sp
+ LSPAN32(lwpstatus32_t
));
1949 error
= pr_uioread(php
, size
, uiop
);
1950 kmem_free(php
, size
);
1955 pr_read_psinfo_32(prnode_t
*pnp
, uio_t
*uiop
)
1961 ASSERT(pnp
->pr_type
== PR_PSINFO
);
1964 * We don't want the full treatment of prlock(pnp) here.
1965 * This file is world-readable and never goes invalid.
1966 * It doesn't matter if we are in the middle of an exec().
1969 mutex_exit(&pr_pidlock
);
1973 ASSERT(p
== pnp
->pr_common
->prc_proc
);
1974 prgetpsinfo32(p
, &psinfo
);
1976 error
= pr_uioread(&psinfo
, sizeof (psinfo
), uiop
);
1982 pr_read_lpsinfo_32(prnode_t
*pnp
, uio_t
*uiop
)
1995 ASSERT(pnp
->pr_type
== PR_LPSINFO
);
1998 * We don't want the full treatment of prlock(pnp) here.
1999 * This file is world-readable and never goes invalid.
2000 * It doesn't matter if we are in the middle of an exec().
2003 mutex_exit(&pr_pidlock
);
2006 ASSERT(p
== pnp
->pr_common
->prc_proc
);
2007 if ((nlwp
= p
->p_lwpcnt
+ p
->p_zombcnt
) == 0) {
2011 size
= sizeof (prheader32_t
) + nlwp
* LSPAN32(lwpsinfo32_t
);
2013 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
2014 mutex_exit(&p
->p_lock
);
2015 php
= kmem_zalloc(size
, KM_SLEEP
);
2016 mutex_enter(&p
->p_lock
);
2017 /* p->p_lwpcnt can't change while process is locked */
2018 ASSERT(nlwp
== p
->p_lwpcnt
+ p
->p_zombcnt
);
2020 php
->pr_nent
= nlwp
;
2021 php
->pr_entsize
= LSPAN32(lwpsinfo32_t
);
2023 sp
= (lwpsinfo32_t
*)(php
+ 1);
2024 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
2025 if ((lep
= ldp
->ld_entry
) == NULL
)
2027 if ((t
= lep
->le_thread
) != NULL
)
2028 prgetlwpsinfo32(t
, sp
);
2030 bzero(sp
, sizeof (*sp
));
2031 sp
->pr_lwpid
= lep
->le_lwpid
;
2032 sp
->pr_state
= SZOMB
;
2034 sp
->pr_start
.tv_sec
= (time32_t
)lep
->le_start
;
2036 sp
= (lwpsinfo32_t
*)((caddr_t
)sp
+ LSPAN32(lwpsinfo32_t
));
2040 error
= pr_uioread(php
, size
, uiop
);
2041 kmem_free(php
, size
);
2046 pr_read_map_common_32(prnode_t
*pnp
, uio_t
*uiop
, prnodetype_t type
)
2054 if ((error
= prlock(pnp
, ZNO
)) != 0)
2057 p
= pnp
->pr_common
->prc_proc
;
2060 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
2065 if (PROCESS_NOT_32BIT(p
)) {
2070 if (!AS_LOCK_TRYENTER(as
, RW_WRITER
)) {
2073 goto readmap32_common
;
2075 mutex_exit(&p
->p_lock
);
2079 error
= prgetxmap32(p
, &iolhead
);
2082 error
= prgetmap32(p
, 1, &iolhead
);
2085 error
= prgetmap32(p
, 0, &iolhead
);
2089 mutex_enter(&p
->p_lock
);
2092 error
= pr_iol_uiomove_and_free(&iolhead
, uiop
, error
);
2098 pr_read_map_32(prnode_t
*pnp
, uio_t
*uiop
)
2100 ASSERT(pnp
->pr_type
== PR_MAP
);
2101 return (pr_read_map_common_32(pnp
, uiop
, pnp
->pr_type
));
2105 pr_read_rmap_32(prnode_t
*pnp
, uio_t
*uiop
)
2107 ASSERT(pnp
->pr_type
== PR_RMAP
);
2108 return (pr_read_map_common_32(pnp
, uiop
, pnp
->pr_type
));
2112 pr_read_xmap_32(prnode_t
*pnp
, uio_t
*uiop
)
2114 ASSERT(pnp
->pr_type
== PR_XMAP
);
2115 return (pr_read_map_common_32(pnp
, uiop
, pnp
->pr_type
));
2119 pr_read_sigact_32(prnode_t
*pnp
, uio_t
*uiop
)
2121 int nsig
= PROC_IS_BRANDED(curproc
)? BROP(curproc
)->b_nsig
: NSIG
;
2123 struct sigaction32
*sap
;
2128 ASSERT(pnp
->pr_type
== PR_SIGACT
);
2131 * We kmem_alloc() the sigaction32 array because
2132 * it is so big it might blow the kernel stack.
2134 sap
= kmem_alloc((nsig
-1) * sizeof (struct sigaction32
), KM_SLEEP
);
2136 if ((error
= prlock(pnp
, ZNO
)) != 0)
2138 p
= pnp
->pr_common
->prc_proc
;
2140 if (PROCESS_NOT_32BIT(p
)) {
2146 if (uiop
->uio_offset
>= (nsig
-1) * sizeof (struct sigaction32
)) {
2152 for (sig
= 1; sig
< nsig
; sig
++)
2153 prgetaction32(p
, up
, sig
, &sap
[sig
-1]);
2156 error
= pr_uioread(sap
, (nsig
- 1) * sizeof (struct sigaction32
), uiop
);
2158 kmem_free(sap
, (nsig
-1) * sizeof (struct sigaction32
));
2163 pr_read_auxv_32(prnode_t
*pnp
, uio_t
*uiop
)
2165 auxv32_t auxv
[__KERN_NAUXV_IMPL
];
2171 ASSERT(pnp
->pr_type
== PR_AUXV
);
2173 if ((error
= prlock(pnp
, ZNO
)) != 0)
2175 p
= pnp
->pr_common
->prc_proc
;
2177 if (PROCESS_NOT_32BIT(p
)) {
2182 if (uiop
->uio_offset
>= sizeof (auxv
)) {
2188 for (i
= 0; i
< __KERN_NAUXV_IMPL
; i
++) {
2189 auxv
[i
].a_type
= (int32_t)up
->u_auxv
[i
].a_type
;
2190 auxv
[i
].a_un
.a_val
= (int32_t)up
->u_auxv
[i
].a_un
.a_val
;
2194 return (pr_uioread(auxv
, sizeof (auxv
), uiop
));
2198 pr_read_usage_32(prnode_t
*pnp
, uio_t
*uiop
)
2206 ASSERT(pnp
->pr_type
== PR_USAGE
);
2208 /* allocate now, before locking the process */
2209 pup
= kmem_zalloc(sizeof (*pup
), KM_SLEEP
);
2210 upup
= kmem_alloc(sizeof (*upup
), KM_SLEEP
);
2213 * We don't want the full treatment of prlock(pnp) here.
2214 * This file is world-readable and never goes invalid.
2215 * It doesn't matter if we are in the middle of an exec().
2218 mutex_exit(&pr_pidlock
);
2223 ASSERT(p
== pnp
->pr_common
->prc_proc
);
2225 if (uiop
->uio_offset
>= sizeof (prusage32_t
)) {
2231 pup
->pr_tstamp
= gethrtime();
2233 pup
->pr_count
= p
->p_defunct
;
2234 pup
->pr_create
= p
->p_mstart
;
2235 pup
->pr_term
= p
->p_mterm
;
2237 pup
->pr_rtime
= p
->p_mlreal
;
2238 pup
->pr_utime
= p
->p_acct
[LMS_USER
];
2239 pup
->pr_stime
= p
->p_acct
[LMS_SYSTEM
];
2240 pup
->pr_ttime
= p
->p_acct
[LMS_TRAP
];
2241 pup
->pr_tftime
= p
->p_acct
[LMS_TFAULT
];
2242 pup
->pr_dftime
= p
->p_acct
[LMS_DFAULT
];
2243 pup
->pr_kftime
= p
->p_acct
[LMS_KFAULT
];
2244 pup
->pr_ltime
= p
->p_acct
[LMS_USER_LOCK
];
2245 pup
->pr_slptime
= p
->p_acct
[LMS_SLEEP
];
2246 pup
->pr_wtime
= p
->p_acct
[LMS_WAIT_CPU
];
2247 pup
->pr_stoptime
= p
->p_acct
[LMS_STOPPED
];
2249 pup
->pr_minf
= p
->p_ru
.minflt
;
2250 pup
->pr_majf
= p
->p_ru
.majflt
;
2251 pup
->pr_nswap
= p
->p_ru
.nswap
;
2252 pup
->pr_inblk
= p
->p_ru
.inblock
;
2253 pup
->pr_oublk
= p
->p_ru
.oublock
;
2254 pup
->pr_msnd
= p
->p_ru
.msgsnd
;
2255 pup
->pr_mrcv
= p
->p_ru
.msgrcv
;
2256 pup
->pr_sigs
= p
->p_ru
.nsignals
;
2257 pup
->pr_vctx
= p
->p_ru
.nvcsw
;
2258 pup
->pr_ictx
= p
->p_ru
.nivcsw
;
2259 pup
->pr_sysc
= p
->p_ru
.sysc
;
2260 pup
->pr_ioch
= p
->p_ru
.ioch
;
2263 * Add the usage information for each active lwp.
2265 if ((t
= p
->p_tlist
) != NULL
&&
2266 !(pnp
->pr_pcommon
->prc_flags
& PRC_DESTROY
)) {
2268 if (t
->t_proc_flag
& TP_LWPEXIT
)
2272 } while ((t
= t
->t_forw
) != p
->p_tlist
);
2277 prcvtusage32(pup
, upup
);
2279 error
= pr_uioread(upup
, sizeof (prusage32_t
), uiop
);
2281 kmem_free(pup
, sizeof (*pup
));
2282 kmem_free(upup
, sizeof (*upup
));
2287 pr_read_lusage_32(prnode_t
*pnp
, uio_t
*uiop
)
2301 ASSERT(pnp
->pr_type
== PR_LUSAGE
);
2304 * We don't want the full treatment of prlock(pnp) here.
2305 * This file is world-readable and never goes invalid.
2306 * It doesn't matter if we are in the middle of an exec().
2309 mutex_exit(&pr_pidlock
);
2312 ASSERT(p
== pnp
->pr_common
->prc_proc
);
2313 if ((nlwp
= p
->p_lwpcnt
) == 0) {
2318 size
= sizeof (prheader32_t
) + (nlwp
+ 1) * LSPAN32(prusage32_t
);
2319 if (uiop
->uio_offset
>= size
) {
2324 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
2325 mutex_exit(&p
->p_lock
);
2326 pup
= kmem_zalloc(size
+ sizeof (prhusage_t
), KM_SLEEP
);
2327 mutex_enter(&p
->p_lock
);
2328 /* p->p_lwpcnt can't change while process is locked */
2329 ASSERT(nlwp
== p
->p_lwpcnt
);
2331 php
= (prheader32_t
*)(pup
+ 1);
2332 upup
= (prusage32_t
*)(php
+ 1);
2334 php
->pr_nent
= nlwp
+ 1;
2335 php
->pr_entsize
= LSPAN32(prusage32_t
);
2337 curtime
= gethrtime();
2340 * First the summation over defunct lwps.
2342 pup
->pr_count
= p
->p_defunct
;
2343 pup
->pr_tstamp
= curtime
;
2344 pup
->pr_create
= p
->p_mstart
;
2345 pup
->pr_term
= p
->p_mterm
;
2347 pup
->pr_rtime
= p
->p_mlreal
;
2348 pup
->pr_utime
= p
->p_acct
[LMS_USER
];
2349 pup
->pr_stime
= p
->p_acct
[LMS_SYSTEM
];
2350 pup
->pr_ttime
= p
->p_acct
[LMS_TRAP
];
2351 pup
->pr_tftime
= p
->p_acct
[LMS_TFAULT
];
2352 pup
->pr_dftime
= p
->p_acct
[LMS_DFAULT
];
2353 pup
->pr_kftime
= p
->p_acct
[LMS_KFAULT
];
2354 pup
->pr_ltime
= p
->p_acct
[LMS_USER_LOCK
];
2355 pup
->pr_slptime
= p
->p_acct
[LMS_SLEEP
];
2356 pup
->pr_wtime
= p
->p_acct
[LMS_WAIT_CPU
];
2357 pup
->pr_stoptime
= p
->p_acct
[LMS_STOPPED
];
2359 pup
->pr_minf
= p
->p_ru
.minflt
;
2360 pup
->pr_majf
= p
->p_ru
.majflt
;
2361 pup
->pr_nswap
= p
->p_ru
.nswap
;
2362 pup
->pr_inblk
= p
->p_ru
.inblock
;
2363 pup
->pr_oublk
= p
->p_ru
.oublock
;
2364 pup
->pr_msnd
= p
->p_ru
.msgsnd
;
2365 pup
->pr_mrcv
= p
->p_ru
.msgrcv
;
2366 pup
->pr_sigs
= p
->p_ru
.nsignals
;
2367 pup
->pr_vctx
= p
->p_ru
.nvcsw
;
2368 pup
->pr_ictx
= p
->p_ru
.nivcsw
;
2369 pup
->pr_sysc
= p
->p_ru
.sysc
;
2370 pup
->pr_ioch
= p
->p_ru
.ioch
;
2372 prcvtusage32(pup
, upup
);
2375 * Fill one prusage struct for each active lwp.
2377 for (ldp
= p
->p_lwpdir
, i
= 0; i
< p
->p_lwpdir_sz
; i
++, ldp
++) {
2378 if (ldp
->ld_entry
== NULL
||
2379 (t
= ldp
->ld_entry
->le_thread
) == NULL
)
2381 ASSERT(!(t
->t_proc_flag
& TP_LWPEXIT
));
2384 upup
= (prusage32_t
*)
2385 ((caddr_t
)upup
+ LSPAN32(prusage32_t
));
2387 prcvtusage32(pup
, upup
);
2393 error
= pr_uioread(php
, size
, uiop
);
2394 kmem_free(pup
, size
+ sizeof (prhusage_t
));
2399 pr_read_pagedata_32(prnode_t
*pnp
, uio_t
*uiop
)
2404 ASSERT(pnp
->pr_type
== PR_PAGEDATA
);
2406 if ((error
= prlock(pnp
, ZNO
)) != 0)
2409 p
= pnp
->pr_common
->prc_proc
;
2410 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
) {
2415 if (PROCESS_NOT_32BIT(p
)) {
2420 mutex_exit(&p
->p_lock
);
2421 error
= prpdread32(p
, pnp
->pr_hatid
, uiop
);
2422 mutex_enter(&p
->p_lock
);
2429 pr_read_opagedata_32(prnode_t
*pnp
, uio_t
*uiop
)
2435 ASSERT(pnp
->pr_type
== PR_OPAGEDATA
);
2437 if ((error
= prlock(pnp
, ZNO
)) != 0)
2440 p
= pnp
->pr_common
->prc_proc
;
2443 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
2448 if (PROCESS_NOT_32BIT(p
)) {
2453 mutex_exit(&p
->p_lock
);
2454 error
= oprpdread32(as
, pnp
->pr_hatid
, uiop
);
2455 mutex_enter(&p
->p_lock
);
2462 pr_read_watch_32(prnode_t
*pnp
, uio_t
*uiop
)
2470 struct watched_area
*pwarea
;
2472 ASSERT(pnp
->pr_type
== PR_WATCH
);
2474 if ((error
= prlock(pnp
, ZNO
)) != 0)
2477 p
= pnp
->pr_common
->prc_proc
;
2478 if (PROCESS_NOT_32BIT(p
)) {
2482 nwarea
= avl_numnodes(&p
->p_warea
);
2483 size
= nwarea
* sizeof (prwatch32_t
);
2484 if (uiop
->uio_offset
>= size
) {
2489 /* drop p->p_lock to do kmem_alloc(KM_SLEEP) */
2490 mutex_exit(&p
->p_lock
);
2491 Bpwp
= pwp
= kmem_zalloc(size
, KM_SLEEP
);
2492 mutex_enter(&p
->p_lock
);
2493 /* p->p_nwarea can't change while process is locked */
2494 ASSERT(nwarea
== avl_numnodes(&p
->p_warea
));
2496 /* gather the watched areas */
2497 for (pwarea
= avl_first(&p
->p_warea
); pwarea
!= NULL
;
2498 pwarea
= AVL_NEXT(&p
->p_warea
, pwarea
), pwp
++) {
2499 pwp
->pr_vaddr
= (caddr32_t
)(uintptr_t)pwarea
->wa_vaddr
;
2500 pwp
->pr_size
= (size32_t
)(pwarea
->wa_eaddr
- pwarea
->wa_vaddr
);
2501 pwp
->pr_wflags
= (int)pwarea
->wa_flags
;
2506 error
= pr_uioread(Bpwp
, size
, uiop
);
2507 kmem_free(Bpwp
, size
);
2512 pr_read_lwpstatus_32(prnode_t
*pnp
, uio_t
*uiop
)
2518 ASSERT(pnp
->pr_type
== PR_LWPSTATUS
);
2521 * We kmem_alloc() the lwpstatus structure because
2522 * it is so big it might blow the kernel stack.
2524 sp
= kmem_alloc(sizeof (*sp
), KM_SLEEP
);
2526 if ((error
= prlock(pnp
, ZNO
)) != 0)
2530 * A 32-bit process cannot get the status of a 64-bit process.
2531 * The fields for the 64-bit quantities are not large enough.
2533 p
= pnp
->pr_common
->prc_proc
;
2534 if (PROCESS_NOT_32BIT(p
)) {
2540 if (uiop
->uio_offset
>= sizeof (*sp
)) {
2545 prgetlwpstatus32(pnp
->pr_common
->prc_thread
, sp
, VTOZONE(PTOV(pnp
)));
2548 error
= pr_uioread(sp
, sizeof (*sp
), uiop
);
2550 kmem_free(sp
, sizeof (*sp
));
2555 pr_read_lwpsinfo_32(prnode_t
*pnp
, uio_t
*uiop
)
2557 lwpsinfo32_t lwpsinfo
;
2562 ASSERT(pnp
->pr_type
== PR_LWPSINFO
);
2565 * We don't want the full treatment of prlock(pnp) here.
2566 * This file is world-readable and never goes invalid.
2567 * It doesn't matter if we are in the middle of an exec().
2570 mutex_exit(&pr_pidlock
);
2573 ASSERT(p
== pnp
->pr_common
->prc_proc
);
2574 if (pnp
->pr_common
->prc_tslot
== -1) {
2579 if (uiop
->uio_offset
>= sizeof (lwpsinfo
)) {
2584 if ((t
= pnp
->pr_common
->prc_thread
) != NULL
)
2585 prgetlwpsinfo32(t
, &lwpsinfo
);
2587 lep
= p
->p_lwpdir
[pnp
->pr_common
->prc_tslot
].ld_entry
;
2588 bzero(&lwpsinfo
, sizeof (lwpsinfo
));
2589 lwpsinfo
.pr_lwpid
= lep
->le_lwpid
;
2590 lwpsinfo
.pr_state
= SZOMB
;
2591 lwpsinfo
.pr_sname
= 'Z';
2592 lwpsinfo
.pr_start
.tv_sec
= (time32_t
)lep
->le_start
;
2596 return (pr_uioread(&lwpsinfo
, sizeof (lwpsinfo
), uiop
));
2600 pr_read_lwpusage_32(prnode_t
*pnp
, uio_t
*uiop
)
2607 ASSERT(pnp
->pr_type
== PR_LWPUSAGE
);
2609 /* allocate now, before locking the process */
2610 pup
= kmem_zalloc(sizeof (*pup
), KM_SLEEP
);
2611 upup
= kmem_alloc(sizeof (*upup
), KM_SLEEP
);
2614 * We don't want the full treatment of prlock(pnp) here.
2615 * This file is world-readable and never goes invalid.
2616 * It doesn't matter if we are in the middle of an exec().
2619 mutex_exit(&pr_pidlock
);
2624 ASSERT(p
== pnp
->pr_common
->prc_proc
);
2625 if (pnp
->pr_common
->prc_thread
== NULL
) {
2630 if (uiop
->uio_offset
>= sizeof (prusage32_t
)) {
2636 pup
->pr_tstamp
= gethrtime();
2637 prgetusage(pnp
->pr_common
->prc_thread
, pup
);
2641 prcvtusage32(pup
, upup
);
2643 error
= pr_uioread(upup
, sizeof (prusage32_t
), uiop
);
2645 kmem_free(pup
, sizeof (*pup
));
2646 kmem_free(upup
, sizeof (*upup
));
2651 pr_read_spymaster_32(prnode_t
*pnp
, uio_t
*uiop
)
2657 ASSERT(pnp
->pr_type
== PR_SPYMASTER
);
2659 if ((error
= prlock(pnp
, ZNO
)) != 0)
2662 if (pnp
->pr_common
->prc_thread
== NULL
) {
2667 lwp
= pnp
->pr_common
->prc_thread
->t_lwp
;
2669 if (lwp
->lwp_spymaster
== NULL
) {
2674 psinfo_kto32(lwp
->lwp_spymaster
, &psinfo
);
2677 return (pr_uioread(&psinfo
, sizeof (psinfo
), uiop
));
2680 #if defined(__sparc)
2682 pr_read_gwindows_32(prnode_t
*pnp
, uio_t
*uiop
)
2690 ASSERT(pnp
->pr_type
== PR_GWINDOWS
);
2692 gwp
= kmem_zalloc(sizeof (gwindows32_t
), KM_SLEEP
);
2694 if ((error
= prlock(pnp
, ZNO
)) != 0)
2697 p
= pnp
->pr_common
->prc_proc
;
2698 t
= pnp
->pr_common
->prc_thread
;
2700 if (PROCESS_NOT_32BIT(p
)) {
2707 * Drop p->p_lock while touching the stack.
2708 * The P_PR_LOCK flag prevents the lwp from
2709 * disappearing while we do this.
2711 mutex_exit(&p
->p_lock
);
2712 if ((size
= prnwindows(ttolwp(t
))) != 0)
2713 size
= sizeof (gwindows32_t
) -
2714 (SPARC_MAXREGWINDOW
- size
) * sizeof (struct rwindow32
);
2715 if (uiop
->uio_offset
>= size
) {
2716 mutex_enter(&p
->p_lock
);
2720 prgetwindows32(ttolwp(t
), gwp
);
2721 mutex_enter(&p
->p_lock
);
2724 error
= pr_uioread(gwp
, size
, uiop
);
2726 kmem_free(gwp
, sizeof (gwindows32_t
));
2729 #endif /* __sparc */
2731 #endif /* _SYSCALL32_IMPL */
2735 prread(vnode_t
*vp
, uio_t
*uiop
, int ioflag
, cred_t
*cr
, caller_context_t
*ct
)
2737 prnode_t
*pnp
= VTOP(vp
);
2739 ASSERT(pnp
->pr_type
< PR_NFILES
);
2741 #ifdef _SYSCALL32_IMPL
2743 * What is read from the /proc files depends on the data
2744 * model of the caller. An LP64 process will see LP64
2745 * data. An ILP32 process will see ILP32 data.
2747 if (curproc
->p_model
== DATAMODEL_LP64
)
2748 return (pr_read_function
[pnp
->pr_type
](pnp
, uiop
));
2750 return (pr_read_function_32
[pnp
->pr_type
](pnp
, uiop
));
2752 return (pr_read_function
[pnp
->pr_type
](pnp
, uiop
));
2756 /* Note we intentionally don't handle partial writes/updates. */
2758 pr_write_lwpname(prnode_t
*pnp
, uio_t
*uiop
)
2760 kthread_t
*t
= NULL
;
2764 lwpname
= kmem_zalloc(THREAD_NAME_MAX
, KM_SLEEP
);
2766 if ((error
= uiomove(lwpname
, THREAD_NAME_MAX
, UIO_WRITE
, uiop
)) != 0) {
2767 kmem_free(lwpname
, THREAD_NAME_MAX
);
2771 /* Somebody tried to write too long a thread name... */
2772 if (lwpname
[THREAD_NAME_MAX
- 1] != '\0' || uiop
->uio_resid
> 0) {
2773 kmem_free(lwpname
, THREAD_NAME_MAX
);
2777 VERIFY3U(lwpname
[THREAD_NAME_MAX
- 1], ==, '\0');
2779 for (size_t i
= 0; lwpname
[i
] != '\0'; i
++) {
2780 if (!ISPRINT(lwpname
[i
])) {
2781 kmem_free(lwpname
, THREAD_NAME_MAX
);
2786 /* Equivalent of thread_setname(), but with the ZNO magic. */
2787 if ((error
= prlock(pnp
, ZNO
)) != 0) {
2788 kmem_free(lwpname
, THREAD_NAME_MAX
);
2792 t
= pnp
->pr_common
->prc_thread
;
2793 if (t
->t_name
== NULL
) {
2794 t
->t_name
= lwpname
;
2796 (void) strlcpy(t
->t_name
, lwpname
, THREAD_NAME_MAX
);
2797 kmem_free(lwpname
, THREAD_NAME_MAX
);
2806 prwrite(vnode_t
*vp
, uio_t
*uiop
, int ioflag
, cred_t
*cr
, caller_context_t
*ct
)
2808 prnode_t
*pnp
= VTOP(vp
);
2813 ASSERT(pnp
->pr_type
< PR_NFILES
);
2816 * Only a handful of /proc files are writable, enumerate them here.
2818 switch (pnp
->pr_type
) {
2819 case PR_PIDDIR
: /* directory write()s: visceral revulsion. */
2820 ASSERT(pnp
->pr_pidfile
!= NULL
);
2821 /* use the underlying PR_PIDFILE to write the process */
2822 vp
= pnp
->pr_pidfile
;
2824 ASSERT(pnp
->pr_type
== PR_PIDFILE
);
2831 if ((error
= prlock(pnp
, ZNO
)) == 0) {
2832 proc_t
*p
= pnp
->pr_common
->prc_proc
;
2833 struct as
*as
= p
->p_as
;
2835 if ((p
->p_flag
& SSYS
) || as
== &kas
) {
2837 * /proc I/O cannot be done to a system process.
2840 #ifdef _SYSCALL32_IMPL
2841 } else if (curproc
->p_model
== DATAMODEL_ILP32
&&
2842 PROCESS_NOT_32BIT(p
)) {
2847 * See comments above (pr_read_pidfile)
2848 * about this locking dance.
2850 mutex_exit(&p
->p_lock
);
2851 error
= prusrio(p
, UIO_WRITE
, uiop
, old
);
2852 mutex_enter(&p
->p_lock
);
2860 resid
= uiop
->uio_resid
;
2862 * Perform the action on the control file
2863 * by passing curthreads credentials
2864 * and not target process's credentials.
2866 #ifdef _SYSCALL32_IMPL
2867 if (curproc
->p_model
== DATAMODEL_ILP32
)
2868 error
= prwritectl32(vp
, uiop
, CRED());
2870 error
= prwritectl(vp
, uiop
, CRED());
2872 error
= prwritectl(vp
, uiop
, CRED());
2875 * This hack makes sure that the EINTR is passed
2876 * all the way back to the caller's write() call.
2879 uiop
->uio_resid
= resid
;
2883 return (pr_write_lwpname(pnp
, uiop
));
2886 return ((vp
->v_type
== VDIR
)? EISDIR
: EBADF
);
2892 prgetattr(vnode_t
*vp
, vattr_t
*vap
, int flags
, cred_t
*cr
,
2893 caller_context_t
*ct
)
2895 prnode_t
*pnp
= VTOP(vp
);
2896 prnodetype_t type
= pnp
->pr_type
;
2903 extern uint_t nproc
;
2908 * This ugly bit of code allows us to keep both versions of this
2909 * function from the same source.
2912 int iam32bit
= (curproc
->p_model
== DATAMODEL_ILP32
);
2913 #define PR_OBJSIZE(obj32, obj64) \
2914 (iam32bit ? sizeof (obj32) : sizeof (obj64))
2915 #define PR_OBJSPAN(obj32, obj64) \
2916 (iam32bit ? LSPAN32(obj32) : LSPAN(obj64))
2918 #define PR_OBJSIZE(obj32, obj64) \
2920 #define PR_OBJSPAN(obj32, obj64) \
2925 * Return all the attributes. Should be refined
2926 * so that it returns only those asked for.
2927 * Most of this is complete fakery anyway.
2931 * For files in the /proc/<pid>/object directory,
2932 * return the attributes of the underlying object.
2933 * For files in the /proc/<pid>/fd directory,
2934 * return the attributes of the underlying file, but
2935 * make it look inaccessible if it is not a regular file.
2936 * Make directories look like symlinks.
2941 if (!(flags
& ATTR_REAL
))
2943 /* restrict full knowledge of the attributes to owner or root */
2944 if ((error
= praccess(vp
, 0, 0, cr
, ct
)) != 0)
2949 rvp
= pnp
->pr_realvp
;
2950 error
= VOP_GETATTR(rvp
, vap
, flags
, cr
, ct
);
2953 if (type
== PR_FD
) {
2954 if (rvp
->v_type
!= VREG
&& rvp
->v_type
!= VDIR
)
2957 vap
->va_mode
&= pnp
->pr_mode
;
2959 if (type
== PR_OBJECT
)
2960 vap
->va_mode
&= 07555;
2961 if (rvp
->v_type
== VDIR
&& !(flags
& ATTR_REAL
)) {
2962 vap
->va_type
= VLNK
;
2971 bzero(vap
, sizeof (*vap
));
2973 * Large Files: Internally proc now uses VPROC to indicate
2974 * a proc file. Since we have been returning VREG through
2975 * VOP_GETATTR() until now, we continue to do this so as
2976 * not to break apps depending on this return value.
2978 vap
->va_type
= (vp
->v_type
== VPROC
) ? VREG
: vp
->v_type
;
2979 vap
->va_mode
= pnp
->pr_mode
;
2980 vap
->va_fsid
= vp
->v_vfsp
->vfs_dev
;
2981 vap
->va_blksize
= DEV_BSIZE
;
2985 if (type
== PR_PROCDIR
) {
2988 vap
->va_nlink
= nproc
+ 2;
2989 vap
->va_nodeid
= (ino64_t
)PRROOTINO
;
2991 vap
->va_atime
= vap
->va_mtime
= vap
->va_ctime
= now
;
2992 vap
->va_size
= (v
.v_proc
+ 2) * PRSDSIZE
;
2993 vap
->va_nblocks
= btod(vap
->va_size
);
2998 * /proc/<pid>/self is a symbolic link, and has no prcommon member
3000 if (type
== PR_SELF
) {
3001 vap
->va_uid
= crgetruid(CRED());
3002 vap
->va_gid
= crgetrgid(CRED());
3003 vap
->va_nodeid
= (ino64_t
)PR_SELF
;
3005 vap
->va_atime
= vap
->va_mtime
= vap
->va_ctime
= now
;
3007 vap
->va_type
= VLNK
;
3013 mutex_exit(&pr_pidlock
);
3016 pcp
= pnp
->pr_common
;
3018 mutex_enter(&p
->p_crlock
);
3019 vap
->va_uid
= crgetruid(p
->p_cred
);
3020 vap
->va_gid
= crgetrgid(p
->p_cred
);
3021 mutex_exit(&p
->p_crlock
);
3024 vap
->va_nodeid
= pnp
->pr_ino
? pnp
->pr_ino
:
3025 pmkino(pcp
->prc_tslot
, pcp
->prc_slot
, pnp
->pr_type
);
3026 if ((pcp
->prc_flags
& PRC_LWP
) && pcp
->prc_tslot
!= -1) {
3027 vap
->va_atime
.tv_sec
= vap
->va_mtime
.tv_sec
=
3028 vap
->va_ctime
.tv_sec
=
3029 p
->p_lwpdir
[pcp
->prc_tslot
].ld_entry
->le_start
;
3030 vap
->va_atime
.tv_nsec
= vap
->va_mtime
.tv_nsec
=
3031 vap
->va_ctime
.tv_nsec
= 0;
3033 user_t
*up
= PTOU(p
);
3034 vap
->va_atime
.tv_sec
= vap
->va_mtime
.tv_sec
=
3035 vap
->va_ctime
.tv_sec
= up
->u_start
.tv_sec
;
3036 vap
->va_atime
.tv_nsec
= vap
->va_mtime
.tv_nsec
=
3037 vap
->va_ctime
.tv_nsec
= up
->u_start
.tv_nsec
;
3042 /* va_nlink: count 'lwp', 'object' and 'fd' directory links */
3044 vap
->va_size
= sizeof (piddir
);
3047 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3048 vap
->va_size
= 2 * PRSDSIZE
;
3050 mutex_exit(&p
->p_lock
);
3051 AS_LOCK_ENTER(as
, RW_WRITER
);
3052 if (as
->a_updatedir
)
3054 vap
->va_size
= (as
->a_sizedir
+ 2) * PRSDSIZE
;
3056 mutex_enter(&p
->p_lock
);
3061 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3062 vap
->va_size
= (P_FINFO(p
)->fi_nfiles
+ 4) * PRSDSIZE
;
3064 mutex_exit(&p
->p_lock
);
3065 AS_LOCK_ENTER(as
, RW_WRITER
);
3066 if (as
->a_updatedir
)
3068 vap
->va_size
= (as
->a_sizedir
+ 4 +
3069 P_FINFO(p
)->fi_nfiles
) * PRSDSIZE
;
3071 mutex_enter(&p
->p_lock
);
3079 vap
->va_type
= VLNK
;
3084 vap
->va_size
= (P_FINFO(p
)->fi_nfiles
+ 2) * PRSDSIZE
;
3088 * va_nlink: count each lwp as a directory link.
3089 * va_size: size of p_lwpdir + 2
3091 vap
->va_nlink
= p
->p_lwpcnt
+ p
->p_zombcnt
+ 2;
3092 vap
->va_size
= (p
->p_lwpdir_sz
+ 2) * PRSDSIZE
;
3096 vap
->va_size
= sizeof (lwpiddir
);
3100 vap
->va_size
= (avl_numnodes(&p
->p_ct_held
) + 2) * PRSDSIZE
;
3104 vap
->va_size
= (ct_ntypes
+ 2) * PRSDSIZE
;
3109 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3112 vap
->va_size
= as
->a_resvsize
;
3115 vap
->va_size
= PR_OBJSIZE(pstatus32_t
, pstatus_t
);
3118 vap
->va_size
= PR_OBJSIZE(prheader32_t
, prheader_t
) +
3119 p
->p_lwpcnt
* PR_OBJSPAN(lwpstatus32_t
, lwpstatus_t
);
3122 vap
->va_size
= PR_OBJSIZE(psinfo32_t
, psinfo_t
);
3125 vap
->va_size
= PR_OBJSIZE(prheader32_t
, prheader_t
) +
3126 (p
->p_lwpcnt
+ p
->p_zombcnt
) *
3127 PR_OBJSPAN(lwpsinfo32_t
, lwpsinfo_t
);
3132 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3135 mutex_exit(&p
->p_lock
);
3136 AS_LOCK_ENTER(as
, RW_WRITER
);
3138 vap
->va_mtime
= as
->a_updatetime
;
3139 if (type
== PR_XMAP
)
3140 vap
->va_size
= prnsegs(as
, 0) *
3141 PR_OBJSIZE(prxmap32_t
, prxmap_t
);
3143 vap
->va_size
= prnsegs(as
, type
== PR_RMAP
) *
3144 PR_OBJSIZE(prmap32_t
, prmap_t
);
3146 mutex_enter(&p
->p_lock
);
3150 mutex_enter(&p
->p_crlock
);
3151 vap
->va_size
= sizeof (prcred_t
);
3152 ngroups
= crgetngroups(p
->p_cred
);
3154 vap
->va_size
+= (ngroups
- 1) * sizeof (gid_t
);
3155 mutex_exit(&p
->p_crlock
);
3158 vap
->va_size
= prgetprivsize();
3161 vap
->va_size
= sizeof (prsecflags_t
);
3164 nsig
= PROC_IS_BRANDED(curproc
)? BROP(curproc
)->b_nsig
: NSIG
;
3165 vap
->va_size
= (nsig
-1) *
3166 PR_OBJSIZE(struct sigaction32
, struct sigaction
);
3169 vap
->va_size
= __KERN_NAUXV_IMPL
* PR_OBJSIZE(auxv32_t
, auxv_t
);
3173 mutex_exit(&p
->p_lock
);
3174 mutex_enter(&p
->p_ldtlock
);
3175 vap
->va_size
= prnldt(p
) * sizeof (struct ssd
);
3176 mutex_exit(&p
->p_ldtlock
);
3177 mutex_enter(&p
->p_lock
);
3181 vap
->va_size
= PR_OBJSIZE(prusage32_t
, prusage_t
);
3184 vap
->va_size
= PR_OBJSIZE(prheader32_t
, prheader_t
) +
3185 (p
->p_lwpcnt
+ 1) * PR_OBJSPAN(prusage32_t
, prusage_t
);
3188 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3192 * We can drop p->p_lock before grabbing the
3193 * address space lock because p->p_as will not
3194 * change while the process is marked P_PR_LOCK.
3196 mutex_exit(&p
->p_lock
);
3197 AS_LOCK_ENTER(as
, RW_WRITER
);
3199 vap
->va_size
= iam32bit
?
3200 prpdsize32(as
) : prpdsize(as
);
3202 vap
->va_size
= prpdsize(as
);
3205 mutex_enter(&p
->p_lock
);
3209 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
)
3212 mutex_exit(&p
->p_lock
);
3213 AS_LOCK_ENTER(as
, RW_WRITER
);
3215 vap
->va_size
= iam32bit
?
3216 oprpdsize32(as
) : oprpdsize(as
);
3218 vap
->va_size
= oprpdsize(as
);
3221 mutex_enter(&p
->p_lock
);
3225 vap
->va_size
= avl_numnodes(&p
->p_warea
) *
3226 PR_OBJSIZE(prwatch32_t
, prwatch_t
);
3229 vap
->va_size
= PR_OBJSIZE(lwpstatus32_t
, lwpstatus_t
);
3232 vap
->va_size
= PR_OBJSIZE(lwpsinfo32_t
, lwpsinfo_t
);
3235 vap
->va_size
= PR_OBJSIZE(prusage32_t
, prusage_t
);
3239 vap
->va_size
= prgetprxregsize(p
);
3244 if (pnp
->pr_common
->prc_thread
!= NULL
&&
3245 pnp
->pr_common
->prc_thread
->t_lwp
->lwp_spymaster
!= NULL
) {
3246 vap
->va_size
= PR_OBJSIZE(psinfo32_t
, psinfo_t
);
3251 #if defined(__sparc)
3258 * If there is no lwp then just make the size zero.
3259 * This can happen if the lwp exits between the VOP_LOOKUP()
3260 * of the /proc/<pid>/lwp/<lwpid>/gwindows file and the
3261 * VOP_GETATTR() of the resulting vnode.
3263 if ((t
= pcp
->prc_thread
) == NULL
) {
3268 * Drop p->p_lock while touching the stack.
3269 * The P_PR_LOCK flag prevents the lwp from
3270 * disappearing while we do this.
3272 mutex_exit(&p
->p_lock
);
3273 if ((n
= prnwindows(ttolwp(t
))) == 0)
3276 vap
->va_size
= PR_OBJSIZE(gwindows32_t
, gwindows_t
) -
3277 (SPARC_MAXREGWINDOW
- n
) *
3278 PR_OBJSIZE(struct rwindow32
, struct rwindow
);
3279 mutex_enter(&p
->p_lock
);
3284 if (p
->p_model
== DATAMODEL_LP64
)
3285 vap
->va_size
= sizeof (asrset_t
);
3299 vap
->va_nblocks
= (fsblkcnt64_t
)btod(vap
->va_size
);
3304 praccess(vnode_t
*vp
, int mode
, int flags
, cred_t
*cr
, caller_context_t
*ct
)
3306 prnode_t
*pnp
= VTOP(vp
);
3307 prnodetype_t type
= pnp
->pr_type
;
3315 if ((mode
& VWRITE
) && vn_is_readonly(vp
))
3325 * Disallow write access to the underlying objects.
3326 * Disallow access to underlying non-regular-file fds.
3327 * Disallow access to fds with other than existing open modes.
3329 rvp
= pnp
->pr_realvp
;
3330 vtype
= rvp
->v_type
;
3331 vmode
= pnp
->pr_mode
;
3332 if ((type
== PR_OBJECT
&& (mode
& VWRITE
)) ||
3333 (type
== PR_FD
&& vtype
!= VREG
&& vtype
!= VDIR
) ||
3334 (type
== PR_FD
&& (vmode
& mode
) != mode
&&
3335 secpolicy_proc_access(cr
) != 0))
3337 return (VOP_ACCESS(rvp
, mode
, flags
, cr
, ct
));
3339 case PR_PSINFO
: /* these files can be read by anyone */
3348 mutex_exit(&pr_pidlock
);
3356 * Except for the world-readable files above,
3357 * only /proc/pid exists if the process is a zombie.
3359 if ((error
= prlock(pnp
,
3360 (type
== PR_PIDDIR
)? ZYES
: ZNO
)) != 0)
3362 p
= pnp
->pr_common
->prc_proc
;
3364 error
= priv_proc_cred_perm(cr
, p
, NULL
, mode
);
3366 if (error
!= 0 || p
== curproc
|| (p
->p_flag
& SSYS
) ||
3367 p
->p_as
== &kas
|| (xvp
= p
->p_exec
) == NULL
) {
3371 * Determine if the process's executable is readable.
3372 * We have to drop p->p_lock before the secpolicy
3373 * and VOP operation.
3377 if (secpolicy_proc_access(cr
) != 0)
3378 error
= VOP_ACCESS(xvp
, VREAD
, 0, cr
, ct
);
3386 if (type
== PR_CURDIR
|| type
== PR_ROOTDIR
) {
3388 * Final access check on the underlying directory vnode.
3390 return (VOP_ACCESS(pnp
->pr_realvp
, mode
, flags
, cr
, ct
));
3394 * Visceral revulsion: For compatibility with old /proc,
3395 * allow the /proc/<pid> directory to be opened for writing.
3397 vmode
= pnp
->pr_mode
;
3398 if (type
== PR_PIDDIR
)
3400 if ((vmode
& mode
) != mode
)
3401 error
= secpolicy_proc_access(cr
);
3406 * Array of lookup functions, indexed by /proc file type.
3408 static vnode_t
*pr_lookup_notdir(), *pr_lookup_procdir(), *pr_lookup_piddir(),
3409 *pr_lookup_objectdir(), *pr_lookup_lwpdir(), *pr_lookup_lwpiddir(),
3410 *pr_lookup_fddir(), *pr_lookup_pathdir(), *pr_lookup_tmpldir(),
3413 static vnode_t
*(*pr_lookup_function
[PR_NFILES
])() = {
3414 pr_lookup_procdir
, /* /proc */
3415 pr_lookup_notdir
, /* /proc/self */
3416 pr_lookup_piddir
, /* /proc/<pid> */
3417 pr_lookup_notdir
, /* /proc/<pid>/as */
3418 pr_lookup_notdir
, /* /proc/<pid>/ctl */
3419 pr_lookup_notdir
, /* /proc/<pid>/status */
3420 pr_lookup_notdir
, /* /proc/<pid>/lstatus */
3421 pr_lookup_notdir
, /* /proc/<pid>/psinfo */
3422 pr_lookup_notdir
, /* /proc/<pid>/lpsinfo */
3423 pr_lookup_notdir
, /* /proc/<pid>/map */
3424 pr_lookup_notdir
, /* /proc/<pid>/rmap */
3425 pr_lookup_notdir
, /* /proc/<pid>/xmap */
3426 pr_lookup_notdir
, /* /proc/<pid>/cred */
3427 pr_lookup_notdir
, /* /proc/<pid>/sigact */
3428 pr_lookup_notdir
, /* /proc/<pid>/auxv */
3430 pr_lookup_notdir
, /* /proc/<pid>/ldt */
3432 pr_lookup_notdir
, /* /proc/<pid>/usage */
3433 pr_lookup_notdir
, /* /proc/<pid>/lusage */
3434 pr_lookup_notdir
, /* /proc/<pid>/pagedata */
3435 pr_lookup_notdir
, /* /proc/<pid>/watch */
3436 pr_lookup_notdir
, /* /proc/<pid>/cwd */
3437 pr_lookup_notdir
, /* /proc/<pid>/root */
3438 pr_lookup_fddir
, /* /proc/<pid>/fd */
3439 pr_lookup_notdir
, /* /proc/<pid>/fd/nn */
3440 pr_lookup_objectdir
, /* /proc/<pid>/object */
3441 pr_lookup_notdir
, /* /proc/<pid>/object/xxx */
3442 pr_lookup_lwpdir
, /* /proc/<pid>/lwp */
3443 pr_lookup_lwpiddir
, /* /proc/<pid>/lwp/<lwpid> */
3444 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
3445 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpname */
3446 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
3447 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
3448 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
3449 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/xregs */
3450 pr_lookup_tmpldir
, /* /proc/<pid>/lwp/<lwpid>/templates */
3451 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
3452 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/spymaster */
3453 #if defined(__sparc)
3454 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/gwindows */
3455 pr_lookup_notdir
, /* /proc/<pid>/lwp/<lwpid>/asrs */
3457 pr_lookup_notdir
, /* /proc/<pid>/priv */
3458 pr_lookup_pathdir
, /* /proc/<pid>/path */
3459 pr_lookup_notdir
, /* /proc/<pid>/path/xxx */
3460 pr_lookup_ctdir
, /* /proc/<pid>/contracts */
3461 pr_lookup_notdir
, /* /proc/<pid>/contracts/<ctid> */
3462 pr_lookup_notdir
, /* /proc/<pid>/secflags */
3463 pr_lookup_notdir
, /* old process file */
3464 pr_lookup_notdir
, /* old lwp file */
3465 pr_lookup_notdir
, /* old pagedata file */
3469 prlookup(vnode_t
*dp
, char *comp
, vnode_t
**vpp
, pathname_t
*pathp
,
3470 int flags
, vnode_t
*rdir
, cred_t
*cr
, caller_context_t
*ct
,
3471 int *direntflags
, pathname_t
*realpnp
)
3473 prnode_t
*pnp
= VTOP(dp
);
3474 prnodetype_t type
= pnp
->pr_type
;
3477 ASSERT(dp
->v_type
== VDIR
);
3478 ASSERT(type
< PR_NFILES
);
3480 if (type
!= PR_PROCDIR
&& strcmp(comp
, "..") == 0) {
3481 VN_HOLD(pnp
->pr_parent
);
3482 *vpp
= pnp
->pr_parent
;
3486 if (*comp
== '\0' ||
3487 strcmp(comp
, ".") == 0 || strcmp(comp
, "..") == 0) {
3496 /* restrict lookup permission to owner or root */
3497 if ((error
= praccess(dp
, VEXEC
, 0, cr
, ct
)) != 0)
3502 * Performing a VOP_LOOKUP on the underlying vnode and emitting
3503 * the resulting vnode, without encapsulation, as our own is a
3504 * very special case when it comes to the assumptions built
3507 * Since the resulting vnode is highly likely to be at some
3508 * abitrary position in another filesystem, we insist that the
3509 * VTRAVERSE flag is set on the parent. This prevents things
3510 * such as the v_path freshness logic from mistaking the
3511 * resulting vnode as a "real" child of the parent, rather than
3512 * a consequence of this "procfs wormhole".
3514 * Failure to establish such protections can lead to
3515 * incorrectly calculated v_paths being set on nodes reached
3516 * through these lookups.
3518 ASSERT((dp
->v_flag
& VTRAVERSE
) != 0);
3520 dp
= pnp
->pr_realvp
;
3521 return (VOP_LOOKUP(dp
, comp
, vpp
, pathp
, flags
, rdir
, cr
, ct
,
3522 direntflags
, realpnp
));
3527 if ((type
== PR_OBJECTDIR
|| type
== PR_FDDIR
|| type
== PR_PATHDIR
) &&
3528 (error
= praccess(dp
, VEXEC
, 0, cr
, ct
)) != 0)
3531 /* XXX - Do we need to pass ct, direntflags, or realpnp? */
3532 *vpp
= (pr_lookup_function
[type
](dp
, comp
));
3534 return ((*vpp
== NULL
) ? ENOENT
: 0);
3539 prcreate(vnode_t
*dp
, char *comp
, vattr_t
*vap
, vcexcl_t excl
,
3540 int mode
, vnode_t
**vpp
, cred_t
*cr
, int flag
, caller_context_t
*ct
,
3545 if ((error
= prlookup(dp
, comp
, vpp
, NULL
, 0, NULL
, cr
,
3546 ct
, NULL
, NULL
)) != 0) {
3547 if (error
== ENOENT
) {
3548 /* One can't O_CREAT nonexistent files in /proc. */
3555 /* Disallow the O_EXCL case */
3557 } else if ((error
= praccess(*vpp
, mode
, 0, cr
, ct
)) == 0) {
3558 /* Before proceeding, handle O_TRUNC if necessary. */
3559 if (vap
->va_mask
& AT_SIZE
) {
3562 if (vp
->v_type
== VDIR
) {
3563 /* Only allow O_TRUNC on files */
3565 } else if (vp
->v_type
!= VPROC
||
3566 VTOP(vp
)->pr_type
!= PR_FD
) {
3568 * Disallow for files outside of the
3569 * /proc/<pid>/fd/<n> entries
3575 vp
= VTOP(vp
)->pr_realvp
;
3576 mask
= vap
->va_mask
;
3577 vap
->va_mask
= AT_SIZE
;
3578 error
= VOP_SETATTR(vp
, vap
, 0, cr
, ct
);
3579 vap
->va_mask
= mask
;
3593 pr_lookup_notdir(vnode_t
*dp
, char *comp
)
3599 * Find or construct a process vnode for the given pid.
3602 pr_lookup_procdir(vnode_t
*dp
, char *comp
)
3611 ASSERT(VTOP(dp
)->pr_type
== PR_PROCDIR
);
3613 if (strcmp(comp
, "self") == 0) {
3614 pnp
= prgetnode(dp
, PR_SELF
);
3618 while ((c
= *comp
++) != '\0') {
3619 if (c
< '0' || c
> '9')
3621 pid
= 10*pid
+ c
- '0';
3627 pnp
= prgetnode(dp
, PR_PIDDIR
);
3629 mutex_enter(&pidlock
);
3630 if ((p
= prfind(pid
)) == NULL
|| p
->p_stat
== SIDL
) {
3631 mutex_exit(&pidlock
);
3635 ASSERT(p
->p_stat
!= 0);
3637 /* NOTE: we're holding pidlock across the policy call. */
3638 if (secpolicy_basic_procinfo(CRED(), p
, curproc
) != 0) {
3639 mutex_exit(&pidlock
);
3644 mutex_enter(&p
->p_lock
);
3645 mutex_exit(&pidlock
);
3648 * If a process vnode already exists and it is not invalid
3649 * and it was created by the current process and it belongs
3650 * to the same /proc mount point as our parent vnode, then
3651 * just use it and discard the newly-allocated prnode.
3653 for (vp
= p
->p_trace
; vp
!= NULL
; vp
= VTOP(vp
)->pr_next
) {
3654 if (!(VTOP(VTOP(vp
)->pr_pidfile
)->pr_flags
& PR_INVAL
) &&
3655 VTOP(vp
)->pr_owner
== curproc
&&
3656 vp
->v_vfsp
== dp
->v_vfsp
) {
3657 ASSERT(!(VTOP(vp
)->pr_flags
& PR_INVAL
));
3660 mutex_exit(&p
->p_lock
);
3664 pnp
->pr_owner
= curproc
;
3667 * prgetnode() initialized most of the prnode.
3670 pcp
= pnp
->pr_common
; /* the newly-allocated prcommon struct */
3671 if ((vp
= p
->p_trace
) != NULL
) {
3672 /* discard the new prcommon and use the existing prcommon */
3674 pcp
= VTOP(vp
)->pr_common
;
3675 mutex_enter(&pcp
->prc_mutex
);
3676 ASSERT(pcp
->prc_refcnt
> 0);
3678 mutex_exit(&pcp
->prc_mutex
);
3679 pnp
->pr_common
= pcp
;
3681 /* initialize the new prcommon struct */
3682 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
)
3683 pcp
->prc_flags
|= PRC_SYS
;
3684 if (p
->p_stat
== SZOMB
|| (p
->p_flag
& SEXITING
) != 0)
3685 pcp
->prc_flags
|= PRC_DESTROY
;
3687 pcp
->prc_datamodel
= p
->p_model
;
3688 pcp
->prc_pid
= p
->p_pid
;
3689 pcp
->prc_slot
= p
->p_slot
;
3691 pnp
->pr_pcommon
= pcp
;
3692 pnp
->pr_parent
= dp
;
3695 * Link in the old, invalid directory vnode so we
3696 * can later determine the last close of the file.
3698 pnp
->pr_next
= p
->p_trace
;
3699 p
->p_trace
= dp
= PTOV(pnp
);
3702 * Kludge for old /proc: initialize the PR_PIDFILE as well.
3704 vp
= pnp
->pr_pidfile
;
3706 pnp
->pr_ino
= ptoi(pcp
->prc_pid
);
3707 pnp
->pr_common
= pcp
;
3708 pnp
->pr_pcommon
= pcp
;
3709 pnp
->pr_parent
= dp
;
3710 pnp
->pr_next
= p
->p_plist
;
3713 mutex_exit(&p
->p_lock
);
3718 pr_lookup_piddir(vnode_t
*dp
, char *comp
)
3720 prnode_t
*dpnp
= VTOP(dp
);
3727 enum prnodetype type
;
3729 ASSERT(dpnp
->pr_type
== PR_PIDDIR
);
3731 for (i
= 0; i
< NPIDDIRFILES
; i
++) {
3732 /* Skip "." and ".." */
3733 dirp
= &piddir
[i
+2];
3734 if (strcmp(comp
, dirp
->d_name
) == 0)
3738 if (i
>= NPIDDIRFILES
)
3741 type
= (int)dirp
->d_ino
;
3742 pnp
= prgetnode(dp
, type
);
3744 p
= pr_p_lock(dpnp
);
3745 mutex_exit(&pr_pidlock
);
3750 if (dpnp
->pr_pcommon
->prc_flags
& PRC_DESTROY
) {
3766 vp
= (type
== PR_CURDIR
)? up
->u_cdir
:
3767 (up
->u_rdir
? up
->u_rdir
: rootdir
);
3770 /* can't happen(?) */
3776 * Fill in the prnode so future references will
3777 * be able to find the underlying object's vnode.
3780 pnp
->pr_realvp
= vp
;
3781 PTOV(pnp
)->v_flag
|= VTRAVERSE
;
3787 mutex_enter(&dpnp
->pr_mutex
);
3789 if ((vp
= dpnp
->pr_files
[i
]) != NULL
&&
3790 !(VTOP(vp
)->pr_flags
& PR_INVAL
)) {
3792 mutex_exit(&dpnp
->pr_mutex
);
3799 * prgetnode() initialized most of the prnode.
3802 pnp
->pr_common
= dpnp
->pr_common
;
3803 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
3804 pnp
->pr_parent
= dp
;
3808 dpnp
->pr_files
[i
] = vp
= PTOV(pnp
);
3811 * Link new vnode into list of all /proc vnodes for the process.
3813 if (vp
->v_type
== VPROC
) {
3814 pnp
->pr_next
= p
->p_plist
;
3817 mutex_exit(&dpnp
->pr_mutex
);
3823 pr_lookup_objectdir(vnode_t
*dp
, char *comp
)
3825 prnode_t
*dpnp
= VTOP(dp
);
3833 ASSERT(dpnp
->pr_type
== PR_OBJECTDIR
);
3835 pnp
= prgetnode(dp
, PR_OBJECT
);
3837 if (prlock(dpnp
, ZNO
) != 0) {
3841 p
= dpnp
->pr_common
->prc_proc
;
3842 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
) {
3849 * We drop p_lock before grabbing the address space lock
3850 * in order to avoid a deadlock with the clock thread.
3851 * The process will not disappear and its address space
3852 * will not change because it is marked P_PR_LOCK.
3854 mutex_exit(&p
->p_lock
);
3855 AS_LOCK_ENTER(as
, RW_READER
);
3856 if ((seg
= AS_SEGFIRST(as
)) == NULL
) {
3860 if (strcmp(comp
, "a.out") == 0) {
3866 * Manufacture a filename for the "object" directory.
3868 vattr
.va_mask
= AT_FSID
|AT_NODEID
;
3869 if (seg
->s_ops
== &segvn_ops
&&
3870 SEGOP_GETVP(seg
, seg
->s_base
, &vp
) == 0 &&
3871 vp
!= NULL
&& vp
->v_type
== VREG
&&
3872 VOP_GETATTR(vp
, &vattr
, 0, CRED(), NULL
) == 0) {
3875 if (vp
== p
->p_exec
) /* "a.out" */
3877 pr_object_name(name
, vp
, &vattr
);
3878 if (strcmp(name
, comp
) == 0)
3881 } while ((seg
= AS_SEGNEXT(as
, seg
)) != NULL
);
3889 mutex_enter(&p
->p_lock
);
3896 * Fill in the prnode so future references will
3897 * be able to find the underlying object's vnode.
3898 * Don't link this prnode into the list of all
3899 * prnodes for the process; this is a one-use node.
3900 * Its use is entirely to catch and fail opens for writing.
3902 pnp
->pr_realvp
= vp
;
3910 * Find or construct an lwp vnode for the given lwpid.
3913 pr_lookup_lwpdir(vnode_t
*dp
, char *comp
)
3915 id_t tid
; /* same type as t->t_tid */
3917 prnode_t
*dpnp
= VTOP(dp
);
3928 ASSERT(dpnp
->pr_type
== PR_LWPDIR
);
3931 if (strcmp(comp
, "agent") == 0)
3935 while ((c
= *comp
++) != '\0') {
3938 if (c
< '0' || c
> '9')
3941 tid
= 10*tid
+ c
- '0';
3942 if (tid
/10 != otid
) /* integer overflow */
3947 pnp
= prgetnode(dp
, PR_LWPIDDIR
);
3949 p
= pr_p_lock(dpnp
);
3950 mutex_exit(&pr_pidlock
);
3957 if ((t
= p
->p_agenttp
) == NULL
)
3962 lep
= p
->p_lwpdir
[tslot
].ld_entry
;
3965 if ((ldp
= lwp_hash_lookup(p
, tid
)) == NULL
)
3968 tslot
= (int)(ldp
- p
->p_lwpdir
);
3969 lep
= ldp
->ld_entry
;
3980 * If an lwp vnode already exists and it is not invalid
3981 * and it was created by the current process and it belongs
3982 * to the same /proc mount point as our parent vnode, then
3983 * just use it and discard the newly-allocated prnode.
3985 for (vp
= lep
->le_trace
; vp
!= NULL
; vp
= VTOP(vp
)->pr_next
) {
3986 if (!(VTOP(vp
)->pr_flags
& PR_INVAL
) &&
3987 VTOP(vp
)->pr_owner
== curproc
&&
3988 vp
->v_vfsp
== dp
->v_vfsp
) {
3995 pnp
->pr_owner
= curproc
;
3998 * prgetnode() initialized most of the prnode.
4001 pcp
= pnp
->pr_common
; /* the newly-allocated prcommon struct */
4002 if ((vp
= lep
->le_trace
) != NULL
) {
4003 /* discard the new prcommon and use the existing prcommon */
4005 pcp
= VTOP(vp
)->pr_common
;
4006 mutex_enter(&pcp
->prc_mutex
);
4007 ASSERT(pcp
->prc_refcnt
> 0);
4009 mutex_exit(&pcp
->prc_mutex
);
4010 pnp
->pr_common
= pcp
;
4012 /* initialize the new prcommon struct */
4013 pcp
->prc_flags
|= PRC_LWP
;
4014 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
)
4015 pcp
->prc_flags
|= PRC_SYS
;
4016 if ((t
= lep
->le_thread
) == NULL
)
4017 pcp
->prc_flags
|= PRC_DESTROY
;
4019 pcp
->prc_datamodel
= dpnp
->pr_pcommon
->prc_datamodel
;
4020 pcp
->prc_pid
= p
->p_pid
;
4021 pcp
->prc_slot
= p
->p_slot
;
4022 pcp
->prc_thread
= t
;
4024 pcp
->prc_tslot
= tslot
;
4026 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
4027 pnp
->pr_parent
= dp
;
4030 * Link in the old, invalid directory vnode so we
4031 * can later determine the last close of the file.
4033 pnp
->pr_next
= lep
->le_trace
;
4034 lep
->le_trace
= vp
= PTOV(pnp
);
4040 pr_lookup_lwpiddir(vnode_t
*dp
, char *comp
)
4042 prnode_t
*dpnp
= VTOP(dp
);
4048 enum prnodetype type
;
4050 ASSERT(dpnp
->pr_type
== PR_LWPIDDIR
);
4052 for (i
= 0; i
< NLWPIDDIRFILES
; i
++) {
4053 /* Skip "." and ".." */
4054 dirp
= &lwpiddir
[i
+2];
4055 if (strcmp(comp
, dirp
->d_name
) == 0)
4059 if (i
>= NLWPIDDIRFILES
)
4062 type
= (int)dirp
->d_ino
;
4063 pnp
= prgetnode(dp
, type
);
4065 p
= pr_p_lock(dpnp
);
4066 mutex_exit(&pr_pidlock
);
4071 if (dpnp
->pr_common
->prc_flags
& PRC_DESTROY
) {
4073 * Only the lwpsinfo file is present for zombie lwps.
4074 * Nothing is present if the lwp has been reaped.
4076 if (dpnp
->pr_common
->prc_tslot
== -1 ||
4077 type
!= PR_LWPSINFO
) {
4084 #if defined(__sparc)
4085 /* the asrs file exists only for sparc v9 _LP64 processes */
4086 if (type
== PR_ASRS
&& p
->p_model
!= DATAMODEL_LP64
) {
4093 mutex_enter(&dpnp
->pr_mutex
);
4095 if ((vp
= dpnp
->pr_files
[i
]) != NULL
&&
4096 !(VTOP(vp
)->pr_flags
& PR_INVAL
)) {
4098 mutex_exit(&dpnp
->pr_mutex
);
4105 * prgetnode() initialized most of the prnode.
4108 pnp
->pr_common
= dpnp
->pr_common
;
4109 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
4110 pnp
->pr_parent
= dp
;
4114 dpnp
->pr_files
[i
] = vp
= PTOV(pnp
);
4117 * Link new vnode into list of all /proc vnodes for the process.
4119 if (vp
->v_type
== VPROC
) {
4120 pnp
->pr_next
= p
->p_plist
;
4123 mutex_exit(&dpnp
->pr_mutex
);
4129 * Lookup one of the process's open files.
4132 pr_lookup_fddir(vnode_t
*dp
, char *comp
)
4134 prnode_t
*dpnp
= VTOP(dp
);
4144 ASSERT(dpnp
->pr_type
== PR_FDDIR
);
4147 while ((c
= *comp
++) != '\0') {
4149 if (c
< '0' || c
> '9')
4152 fd
= 10*fd
+ c
- '0';
4153 if (fd
/10 != ofd
) /* integer overflow */
4157 pnp
= prgetnode(dp
, PR_FD
);
4159 if (prlock(dpnp
, ZNO
) != 0) {
4163 p
= dpnp
->pr_common
->prc_proc
;
4164 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
) {
4171 mutex_exit(&p
->p_lock
);
4172 mutex_enter(&fip
->fi_lock
);
4173 if (fd
< fip
->fi_nfiles
) {
4174 UF_ENTER(ufp
, fip
, fd
);
4175 if ((fp
= ufp
->uf_file
) != NULL
) {
4176 pnp
->pr_mode
= 07111;
4177 if (fp
->f_flag
& FREAD
)
4178 pnp
->pr_mode
|= 0444;
4179 if (fp
->f_flag
& FWRITE
)
4180 pnp
->pr_mode
|= 0222;
4186 mutex_exit(&fip
->fi_lock
);
4187 mutex_enter(&p
->p_lock
);
4194 * Fill in the prnode so future references will
4195 * be able to find the underlying object's vnode.
4196 * Don't link this prnode into the list of all
4197 * prnodes for the process; this is a one-use node.
4199 pnp
->pr_realvp
= vp
;
4200 pnp
->pr_parent
= dp
; /* needed for prlookup */
4203 if (pnp
->pr_realvp
->v_type
== VDIR
) {
4205 vp
->v_flag
|= VTRAVERSE
;
4213 pr_lookup_pathdir(vnode_t
*dp
, char *comp
)
4215 prnode_t
*dpnp
= VTOP(dp
);
4219 uint_t fd
, flags
= 0;
4223 enum { NAME_FD
, NAME_OBJECT
, NAME_ROOT
, NAME_CWD
, NAME_UNKNOWN
} type
;
4227 struct as
*as
= NULL
;
4230 ASSERT(dpnp
->pr_type
== PR_PATHDIR
);
4233 * First, check if this is a numeric entry, in which case we have a
4239 while ((c
= *tmp
++) != '\0') {
4241 if (c
< '0' || c
> '9') {
4242 type
= NAME_UNKNOWN
;
4246 fd
= 10*fd
+ c
- '0';
4247 if (fd
/10 != ofd
) { /* integer overflow */
4248 type
= NAME_UNKNOWN
;
4254 * Next, see if it is one of the special values {root, cwd}.
4256 if (type
== NAME_UNKNOWN
) {
4257 if (strcmp(comp
, "root") == 0)
4259 else if (strcmp(comp
, "cwd") == 0)
4264 * Grab the necessary data from the process
4266 if (prlock(dpnp
, ZNO
) != 0)
4268 p
= dpnp
->pr_common
->prc_proc
;
4274 if ((vp
= PTOU(p
)->u_rdir
) == NULL
)
4275 vp
= p
->p_zone
->zone_rootvp
;
4279 vp
= PTOU(p
)->u_cdir
;
4283 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
) {
4288 mutex_exit(&p
->p_lock
);
4291 * Determine if this is an object entry
4293 if (type
== NAME_UNKNOWN
) {
4295 * Start with the inode index immediately after the number of
4298 mutex_enter(&fip
->fi_lock
);
4299 idx
= fip
->fi_nfiles
+ 4;
4300 mutex_exit(&fip
->fi_lock
);
4302 if (strcmp(comp
, "a.out") == 0) {
4303 if (p
->p_execdir
!= NULL
) {
4314 AS_LOCK_ENTER(as
, RW_READER
);
4315 if ((seg
= AS_SEGFIRST(as
)) != NULL
) {
4318 * Manufacture a filename for the
4319 * "object" directory.
4321 vattr
.va_mask
= AT_FSID
|AT_NODEID
;
4322 if (seg
->s_ops
== &segvn_ops
&&
4323 SEGOP_GETVP(seg
, seg
->s_base
, &vp
)
4325 vp
!= NULL
&& vp
->v_type
== VREG
&&
4326 VOP_GETATTR(vp
, &vattr
, 0, CRED(),
4330 if (vp
== p
->p_exec
)
4333 pr_object_name(name
, vp
,
4335 if (strcmp(name
, comp
) == 0)
4338 } while ((seg
= AS_SEGNEXT(as
, seg
)) != NULL
);
4355 mutex_enter(&fip
->fi_lock
);
4356 if (fd
< fip
->fi_nfiles
) {
4357 UF_ENTER(ufp
, fip
, fd
);
4358 if (ufp
->uf_file
!= NULL
) {
4359 vp
= ufp
->uf_file
->f_vnode
;
4364 mutex_exit(&fip
->fi_lock
);
4379 mutex_enter(&p
->p_lock
);
4383 pnp
= prgetnode(dp
, PR_PATH
);
4385 pnp
->pr_flags
|= flags
;
4386 pnp
->pr_common
= dpnp
->pr_common
;
4387 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
4388 pnp
->pr_realvp
= vp
;
4389 pnp
->pr_parent
= dp
; /* needed for prlookup */
4390 pnp
->pr_ino
= pmkino(idx
, dpnp
->pr_common
->prc_slot
, PR_PATH
);
4400 * Look up one of the process's active templates.
4403 pr_lookup_tmpldir(vnode_t
*dp
, char *comp
)
4405 prnode_t
*dpnp
= VTOP(dp
);
4411 ASSERT(dpnp
->pr_type
== PR_TMPLDIR
);
4413 for (i
= 0; i
< ct_ntypes
; i
++)
4414 if (strcmp(comp
, ct_types
[i
]->ct_type_name
) == 0)
4419 pnp
= prgetnode(dp
, PR_TMPL
);
4421 if (prlock(dpnp
, ZNO
) != 0) {
4425 p
= dpnp
->pr_common
->prc_proc
;
4426 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
||
4427 (dpnp
->pr_common
->prc_flags
& (PRC_DESTROY
| PRC_LWP
)) != PRC_LWP
) {
4432 if (ttolwp(dpnp
->pr_common
->prc_thread
)->lwp_ct_active
[i
] != NULL
) {
4433 pnp
->pr_common
= dpnp
->pr_common
;
4434 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
4435 pnp
->pr_parent
= dp
;
4448 * Look up one of the contracts owned by the process.
4451 pr_lookup_ctdir(vnode_t
*dp
, char *comp
)
4453 prnode_t
*dpnp
= VTOP(dp
);
4461 ASSERT(dpnp
->pr_type
== PR_CTDIR
);
4463 while ((c
= *comp
++) != '\0') {
4465 if (c
< '0' || c
> '9')
4468 id
= 10 * id
+ c
- '0';
4469 if (id
/ 10 != oid
) /* integer overflow */
4474 * Search all contracts; we'll filter below.
4476 ct
= contract_ptr(id
, GLOBAL_ZONEUNIQID
);
4480 pnp
= prgetnode(dp
, PR_CT
);
4482 if (prlock(dpnp
, ZNO
) != 0) {
4487 p
= dpnp
->pr_common
->prc_proc
;
4489 * We only allow lookups of contracts owned by this process, or,
4490 * if we are zsched and this is a zone's procfs, contracts on
4491 * stuff in the zone which are held by processes or contracts
4492 * outside the zone. (see logic in contract_status_common)
4494 if ((ct
->ct_owner
!= p
) &&
4495 !(p
== VTOZONE(dp
)->zone_zsched
&& ct
->ct_state
< CTS_ORPHAN
&&
4496 VTOZONE(dp
)->zone_uniqid
== contract_getzuniqid(ct
) &&
4497 VTOZONE(dp
)->zone_uniqid
!= GLOBAL_ZONEUNIQID
&&
4498 ct
->ct_czuniqid
== GLOBAL_ZONEUNIQID
)) {
4504 pnp
->pr_common
= dpnp
->pr_common
;
4505 pnp
->pr_pcommon
= dpnp
->pr_pcommon
;
4506 pnp
->pr_contract
= ct
;
4507 pnp
->pr_parent
= dp
;
4508 pnp
->pr_ino
= pmkino(id
, pnp
->pr_common
->prc_slot
, PR_CT
);
4517 * Construct an lwp vnode for the old /proc interface.
4518 * We stand on our head to make the /proc plumbing correct.
4521 prlwpnode(prnode_t
*pnp
, uint_t tid
)
4530 * Lookup the /proc/<pid>/lwp/<lwpid> directory vnode.
4532 if (pnp
->pr_type
== PR_PIDFILE
) {
4533 dp
= pnp
->pr_parent
; /* /proc/<pid> */
4535 vp
= pr_lookup_piddir(dp
, "lwp");
4537 if ((dp
= vp
) == NULL
) /* /proc/<pid>/lwp */
4539 } else if (pnp
->pr_type
== PR_LWPIDFILE
) {
4540 dp
= pnp
->pr_parent
; /* /proc/<pid>/lwp/<lwpid> */
4541 dp
= VTOP(dp
)->pr_parent
; /* /proc/<pid>/lwp */
4547 (void) pr_u32tos(tid
, comp
, sizeof (comp
));
4548 vp
= pr_lookup_lwpdir(dp
, comp
);
4550 if ((dp
= vp
) == NULL
)
4553 pnp
= prgetnode(dp
, PR_LWPIDFILE
);
4557 * prgetnode() initialized most of the prnode.
4560 pcp
= VTOP(dp
)->pr_common
;
4561 pnp
->pr_ino
= ptoi(pcp
->prc_pid
);
4562 pnp
->pr_common
= pcp
;
4563 pnp
->pr_pcommon
= VTOP(dp
)->pr_pcommon
;
4564 pnp
->pr_parent
= dp
;
4566 * Link new vnode into list of all /proc vnodes for the process.
4569 mutex_exit(&pr_pidlock
);
4574 } else if (pcp
->prc_thread
== NULL
) {
4580 pnp
->pr_next
= p
->p_plist
;
4590 static uint32_t nprnode
;
4591 static uint32_t nprcommon
;
4593 #define INCREMENT(x) atomic_inc_32(&x);
4594 #define DECREMENT(x) atomic_dec_32(&x);
4598 #define INCREMENT(x)
4599 #define DECREMENT(x)
4604 * New /proc vnode required; allocate it and fill in most of the fields.
4607 prgetnode(vnode_t
*dp
, prnodetype_t type
)
4615 pnp
= kmem_zalloc(sizeof (prnode_t
), KM_SLEEP
);
4617 mutex_init(&pnp
->pr_mutex
, NULL
, MUTEX_DEFAULT
, NULL
);
4618 pnp
->pr_type
= type
;
4620 pnp
->pr_vnode
= vn_alloc(KM_SLEEP
);
4623 vp
->v_flag
= VNOCACHE
|VNOMAP
|VNOSWAP
|VNOMOUNT
;
4624 vn_setops(vp
, prvnodeops
);
4625 vp
->v_vfsp
= dp
->v_vfsp
;
4627 vp
->v_data
= (caddr_t
)pnp
;
4633 * We need a prcommon and a files array for each of these.
4635 INCREMENT(nprcommon
);
4637 pcp
= kmem_zalloc(sizeof (prcommon_t
), KM_SLEEP
);
4638 pcp
->prc_refcnt
= 1;
4639 pnp
->pr_common
= pcp
;
4640 mutex_init(&pcp
->prc_mutex
, NULL
, MUTEX_DEFAULT
, NULL
);
4641 cv_init(&pcp
->prc_wait
, NULL
, CV_DEFAULT
, NULL
);
4643 nfiles
= (type
== PR_PIDDIR
)? NPIDDIRFILES
: NLWPIDDIRFILES
;
4645 kmem_zalloc(nfiles
* sizeof (vnode_t
*), KM_SLEEP
);
4649 * Mode should be read-search by all, but we cannot so long
4650 * as we must support compatibility mode with old /proc.
4651 * Make /proc/<pid> be read by owner only, search by all.
4652 * Make /proc/<pid>/lwp/<lwpid> read-search by all. Also,
4653 * set VDIROPEN on /proc/<pid> so it can be opened for writing.
4655 if (type
== PR_PIDDIR
) {
4656 /* kludge for old /proc interface */
4657 prnode_t
*xpnp
= prgetnode(dp
, PR_PIDFILE
);
4658 pnp
->pr_pidfile
= PTOV(xpnp
);
4659 pnp
->pr_mode
= 0511;
4660 vp
->v_flag
|= VDIROPEN
;
4662 pnp
->pr_mode
= 0555;
4675 pnp
->pr_mode
= 0500; /* read-search by owner only */
4680 pnp
->pr_mode
= 0500; /* read-search by owner only */
4686 pnp
->pr_mode
= 0777;
4691 pnp
->pr_mode
= 0555; /* read-search by all */
4696 pnp
->pr_mode
= 0600; /* read-write by owner only */
4701 pnp
->pr_mode
= 0200; /* write-only by owner only */
4706 pnp
->pr_mode
= 0600; /* read-write by owner only */
4710 pnp
->pr_mode
= 0644; /* readable by all + owner can write */
4719 pnp
->pr_mode
= 0444; /* read-only by all */
4723 pnp
->pr_mode
= 0400; /* read-only by owner only */
4731 * Free the storage obtained from prgetnode().
4734 prfreenode(prnode_t
*pnp
)
4739 vn_invalid(PTOV(pnp
));
4741 mutex_destroy(&pnp
->pr_mutex
);
4743 switch (pnp
->pr_type
) {
4745 /* kludge for old /proc interface */
4746 if (pnp
->pr_pidfile
!= NULL
) {
4747 prfreenode(VTOP(pnp
->pr_pidfile
));
4748 pnp
->pr_pidfile
= NULL
;
4753 * We allocated a prcommon and a files array for each of these.
4755 prfreecommon(pnp
->pr_common
);
4756 nfiles
= (pnp
->pr_type
== PR_PIDDIR
)?
4757 NPIDDIRFILES
: NLWPIDDIRFILES
;
4758 kmem_free(pnp
->pr_files
, nfiles
* sizeof (vnode_t
*));
4764 * If there is an underlying vnode, be sure
4765 * to release it after freeing the prnode.
4767 vp
= pnp
->pr_realvp
;
4768 kmem_free(pnp
, sizeof (*pnp
));
4776 * Free a prcommon structure, if the reference count reaches zero.
4779 prfreecommon(prcommon_t
*pcp
)
4781 mutex_enter(&pcp
->prc_mutex
);
4782 ASSERT(pcp
->prc_refcnt
> 0);
4783 if (--pcp
->prc_refcnt
!= 0)
4784 mutex_exit(&pcp
->prc_mutex
);
4786 mutex_exit(&pcp
->prc_mutex
);
4787 ASSERT(pcp
->prc_pollhead
.ph_list
== NULL
);
4788 ASSERT(pcp
->prc_refcnt
== 0);
4789 ASSERT(pcp
->prc_selfopens
== 0 && pcp
->prc_writers
== 0);
4790 mutex_destroy(&pcp
->prc_mutex
);
4791 cv_destroy(&pcp
->prc_wait
);
4792 kmem_free(pcp
, sizeof (prcommon_t
));
4793 DECREMENT(nprcommon
);
4798 * Array of readdir functions, indexed by /proc file type.
4800 static int pr_readdir_notdir(), pr_readdir_procdir(), pr_readdir_piddir(),
4801 pr_readdir_objectdir(), pr_readdir_lwpdir(), pr_readdir_lwpiddir(),
4802 pr_readdir_fddir(), pr_readdir_pathdir(), pr_readdir_tmpldir(),
4805 static int (*pr_readdir_function
[PR_NFILES
])() = {
4806 pr_readdir_procdir
, /* /proc */
4807 pr_readdir_notdir
, /* /proc/self */
4808 pr_readdir_piddir
, /* /proc/<pid> */
4809 pr_readdir_notdir
, /* /proc/<pid>/as */
4810 pr_readdir_notdir
, /* /proc/<pid>/ctl */
4811 pr_readdir_notdir
, /* /proc/<pid>/status */
4812 pr_readdir_notdir
, /* /proc/<pid>/lstatus */
4813 pr_readdir_notdir
, /* /proc/<pid>/psinfo */
4814 pr_readdir_notdir
, /* /proc/<pid>/lpsinfo */
4815 pr_readdir_notdir
, /* /proc/<pid>/map */
4816 pr_readdir_notdir
, /* /proc/<pid>/rmap */
4817 pr_readdir_notdir
, /* /proc/<pid>/xmap */
4818 pr_readdir_notdir
, /* /proc/<pid>/cred */
4819 pr_readdir_notdir
, /* /proc/<pid>/sigact */
4820 pr_readdir_notdir
, /* /proc/<pid>/auxv */
4822 pr_readdir_notdir
, /* /proc/<pid>/ldt */
4824 pr_readdir_notdir
, /* /proc/<pid>/usage */
4825 pr_readdir_notdir
, /* /proc/<pid>/lusage */
4826 pr_readdir_notdir
, /* /proc/<pid>/pagedata */
4827 pr_readdir_notdir
, /* /proc/<pid>/watch */
4828 pr_readdir_notdir
, /* /proc/<pid>/cwd */
4829 pr_readdir_notdir
, /* /proc/<pid>/root */
4830 pr_readdir_fddir
, /* /proc/<pid>/fd */
4831 pr_readdir_notdir
, /* /proc/<pid>/fd/nn */
4832 pr_readdir_objectdir
, /* /proc/<pid>/object */
4833 pr_readdir_notdir
, /* /proc/<pid>/object/xxx */
4834 pr_readdir_lwpdir
, /* /proc/<pid>/lwp */
4835 pr_readdir_lwpiddir
, /* /proc/<pid>/lwp/<lwpid> */
4836 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpctl */
4837 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpname */
4838 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpstatus */
4839 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpsinfo */
4840 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/lwpusage */
4841 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/xregs */
4842 pr_readdir_tmpldir
, /* /proc/<pid>/lwp/<lwpid>/templates */
4843 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/templates/<id> */
4844 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/spymaster */
4845 #if defined(__sparc)
4846 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/gwindows */
4847 pr_readdir_notdir
, /* /proc/<pid>/lwp/<lwpid>/asrs */
4849 pr_readdir_notdir
, /* /proc/<pid>/priv */
4850 pr_readdir_pathdir
, /* /proc/<pid>/path */
4851 pr_readdir_notdir
, /* /proc/<pid>/path/xxx */
4852 pr_readdir_ctdir
, /* /proc/<pid>/contracts */
4853 pr_readdir_notdir
, /* /proc/<pid>/contracts/<ctid> */
4854 pr_readdir_notdir
, /* /proc/<pid>/secflags */
4855 pr_readdir_notdir
, /* old process file */
4856 pr_readdir_notdir
, /* old lwp file */
4857 pr_readdir_notdir
, /* old pagedata file */
4862 prreaddir(vnode_t
*vp
, uio_t
*uiop
, cred_t
*cr
, int *eofp
,
4863 caller_context_t
*ct
, int flags
)
4865 prnode_t
*pnp
= VTOP(vp
);
4867 ASSERT(pnp
->pr_type
< PR_NFILES
);
4869 /* XXX - Do we need to pass ct and flags? */
4870 return (pr_readdir_function
[pnp
->pr_type
](pnp
, uiop
, eofp
));
4875 pr_readdir_notdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
4882 pr_readdir_procdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
4885 gfs_readdir_state_t gstate
;
4889 ASSERT(pnp
->pr_type
== PR_PROCDIR
);
4891 zoneid
= VTOZONE(PTOV(pnp
))->zone_id
;
4893 if ((error
= gfs_readdir_init(&gstate
, PNSIZ
, PRSDSIZE
, uiop
,
4894 PRROOTINO
, PRROOTINO
, 0)) != 0)
4898 * Loop until user's request is satisfied or until all processes
4899 * have been examined.
4901 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &n
)) == 0) {
4907 * Find next entry. Skip processes not visible where
4908 * this /proc was mounted.
4910 mutex_enter(&pidlock
);
4911 while (n
< v
.v_proc
&&
4912 ((p
= pid_entry(n
)) == NULL
|| p
->p_stat
== SIDL
||
4913 (zoneid
!= GLOBAL_ZONEID
&& p
->p_zone
->zone_id
!= zoneid
) ||
4914 secpolicy_basic_procinfo(CRED(), p
, curproc
) != 0))
4918 * Stop when entire proc table has been examined.
4920 if (n
>= v
.v_proc
) {
4921 mutex_exit(&pidlock
);
4926 ASSERT(p
->p_stat
!= 0);
4929 mutex_exit(&pidlock
);
4930 error
= gfs_readdir_emitn(&gstate
, uiop
, n
,
4931 pmkino(0, pslot
, PR_PIDDIR
), pid
);
4936 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
4941 pr_readdir_piddir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
4943 int zombie
= ((pnp
->pr_pcommon
->prc_flags
& PRC_DESTROY
) != 0);
4949 ASSERT(pnp
->pr_type
== PR_PIDDIR
);
4951 if (uiop
->uio_offset
< 0 ||
4952 uiop
->uio_offset
% sizeof (prdirent_t
) != 0 ||
4953 uiop
->uio_resid
< sizeof (prdirent_t
))
4955 if (pnp
->pr_pcommon
->prc_proc
== NULL
)
4957 if (uiop
->uio_offset
>= sizeof (piddir
))
4961 * Loop until user's request is satisfied, omitting some
4962 * files along the way if the process is a zombie.
4964 for (dirp
= &piddir
[uiop
->uio_offset
/ sizeof (prdirent_t
)];
4965 uiop
->uio_resid
>= sizeof (prdirent_t
) &&
4966 dirp
< &piddir
[NPIDDIRFILES
+2];
4967 uiop
->uio_offset
= off
+ sizeof (prdirent_t
), dirp
++) {
4968 off
= uiop
->uio_offset
;
4970 switch (dirp
->d_ino
) {
4980 bcopy(dirp
, &dirent
, sizeof (prdirent_t
));
4981 if (dirent
.d_ino
== PR_PROCDIR
)
4982 dirent
.d_ino
= PRROOTINO
;
4984 dirent
.d_ino
= pmkino(0, pnp
->pr_pcommon
->prc_slot
,
4986 if ((error
= uiomove((caddr_t
)&dirent
, sizeof (prdirent_t
),
4987 UIO_READ
, uiop
)) != 0)
4992 *eofp
= (uiop
->uio_offset
>= sizeof (piddir
));
4997 rebuild_objdir(struct as
*as
)
5008 ASSERT(AS_WRITE_HELD(as
));
5010 if (as
->a_updatedir
== 0 && as
->a_objectdir
!= NULL
)
5012 as
->a_updatedir
= 0;
5014 if ((nalloc
= avl_numnodes(&as
->a_segtree
)) == 0 ||
5015 (seg
= AS_SEGFIRST(as
)) == NULL
) /* can't happen? */
5019 * Allocate space for the new object directory.
5020 * (This is usually about two times too many entries.)
5022 nalloc
= (nalloc
+ 0xf) & ~0xf; /* multiple of 16 */
5023 dir
= kmem_zalloc(nalloc
* sizeof (vnode_t
*), KM_SLEEP
);
5025 /* fill in the new directory with desired entries */
5028 vattr
.va_mask
= AT_FSID
|AT_NODEID
;
5029 if (seg
->s_ops
== &segvn_ops
&&
5030 SEGOP_GETVP(seg
, seg
->s_base
, &vp
) == 0 &&
5031 vp
!= NULL
&& vp
->v_type
== VREG
&&
5032 VOP_GETATTR(vp
, &vattr
, 0, CRED(), NULL
) == 0) {
5033 for (i
= 0; i
< nentries
; i
++)
5036 if (i
== nentries
) {
5037 ASSERT(nentries
< nalloc
);
5038 dir
[nentries
++] = vp
;
5041 } while ((seg
= AS_SEGNEXT(as
, seg
)) != NULL
);
5043 if (as
->a_objectdir
== NULL
) { /* first time */
5044 as
->a_objectdir
= dir
;
5045 as
->a_sizedir
= nalloc
;
5050 * Null out all of the defunct entries in the old directory.
5054 for (i
= 0; i
< as
->a_sizedir
; i
++) {
5055 if ((vp
= as
->a_objectdir
[i
]) != NULL
) {
5056 for (j
= 0; j
< nentries
; j
++) {
5064 as
->a_objectdir
[i
] = NULL
;
5070 if (nold
+ nnew
> as
->a_sizedir
) {
5072 * Reallocate the old directory to have enough
5073 * space for the old and new entries combined.
5074 * Round up to the next multiple of 16.
5076 ulong_t newsize
= (nold
+ nnew
+ 0xf) & ~0xf;
5077 vnode_t
**newdir
= kmem_zalloc(newsize
* sizeof (vnode_t
*),
5079 bcopy(as
->a_objectdir
, newdir
,
5080 as
->a_sizedir
* sizeof (vnode_t
*));
5081 kmem_free(as
->a_objectdir
, as
->a_sizedir
* sizeof (vnode_t
*));
5082 as
->a_objectdir
= newdir
;
5083 as
->a_sizedir
= newsize
;
5087 * Move all new entries to the old directory and
5088 * deallocate the space used by the new directory.
5091 for (i
= 0, j
= 0; i
< nentries
; i
++) {
5092 if ((vp
= dir
[i
]) == NULL
)
5094 for (; j
< as
->a_sizedir
; j
++) {
5095 if (as
->a_objectdir
[j
] != NULL
)
5097 as
->a_objectdir
[j
++] = vp
;
5102 kmem_free(dir
, nalloc
* sizeof (vnode_t
*));
5106 * Return the vnode from a slot in the process's object directory.
5107 * The caller must have locked the process's address space.
5108 * The only caller is below, in pr_readdir_objectdir().
5111 obj_entry(struct as
*as
, int slot
)
5113 ASSERT(AS_LOCK_HELD(as
));
5114 if (as
->a_objectdir
== NULL
)
5116 ASSERT(slot
< as
->a_sizedir
);
5117 return (as
->a_objectdir
[slot
]);
5122 pr_readdir_objectdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5124 gfs_readdir_state_t gstate
;
5133 ASSERT(pnp
->pr_type
== PR_OBJECTDIR
);
5135 if ((error
= prlock(pnp
, ZNO
)) != 0)
5137 p
= pnp
->pr_common
->prc_proc
;
5141 * We drop p_lock before grabbing the address space lock
5142 * in order to avoid a deadlock with the clock thread.
5143 * The process will not disappear and its address space
5144 * will not change because it is marked P_PR_LOCK.
5146 mutex_exit(&p
->p_lock
);
5148 if ((error
= gfs_readdir_init(&gstate
, 64, PRSDSIZE
, uiop
,
5149 pmkino(0, pslot
, PR_PIDDIR
),
5150 pmkino(0, pslot
, PR_OBJECTDIR
), 0)) != 0) {
5151 mutex_enter(&p
->p_lock
);
5156 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
) {
5162 * Loop until user's request is satisfied or until
5163 * all mapped objects have been examined. Cannot hold
5164 * the address space lock for the following call as
5165 * gfs_readdir_pred() utimately causes a call to uiomove().
5167 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &n
)) == 0) {
5172 * Set the correct size of the directory just
5173 * in case the process has changed it's address
5174 * space via mmap/munmap calls.
5177 AS_LOCK_ENTER(as
, RW_WRITER
);
5178 if (as
->a_updatedir
)
5180 objdirsize
= as
->a_sizedir
;
5186 vattr
.va_mask
= AT_FSID
| AT_NODEID
;
5187 while (n
< objdirsize
&& (((vp
= obj_entry(as
, n
)) == NULL
) ||
5188 (VOP_GETATTR(vp
, &vattr
, 0, CRED(), NULL
)
5190 vattr
.va_mask
= AT_FSID
| AT_NODEID
;
5198 * Stop when all objects have been reported.
5200 if (n
>= objdirsize
) {
5205 if (vp
== p
->p_exec
)
5206 (void) strcpy(str
, "a.out");
5208 pr_object_name(str
, vp
, &vattr
);
5210 error
= gfs_readdir_emit(&gstate
, uiop
, n
, vattr
.va_nodeid
,
5217 mutex_enter(&p
->p_lock
);
5220 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
5225 pr_readdir_lwpdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5227 gfs_readdir_state_t gstate
;
5235 ASSERT(pnp
->pr_type
== PR_LWPDIR
);
5238 mutex_exit(&pr_pidlock
);
5241 ASSERT(p
== pnp
->pr_common
->prc_proc
);
5243 lwpdir
= p
->p_lwpdir
;
5244 lwpdirsize
= p
->p_lwpdir_sz
;
5247 * Drop p->p_lock so we can safely do uiomove().
5248 * The lwp directory will not change because
5249 * we have the process locked with P_PR_LOCK.
5251 mutex_exit(&p
->p_lock
);
5254 if ((error
= gfs_readdir_init(&gstate
, PLNSIZ
, PRSDSIZE
, uiop
,
5255 pmkino(0, pslot
, PR_PIDDIR
),
5256 pmkino(0, pslot
, PR_LWPDIR
), 0)) != 0) {
5257 mutex_enter(&p
->p_lock
);
5263 * Loop until user's request is satisfied or until all lwps
5264 * have been examined.
5266 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &tslot
)) == 0) {
5273 while (tslot
< lwpdirsize
&&
5274 ((lep
= lwpdir
[tslot
].ld_entry
) == NULL
))
5277 * Stop when all lwps have been reported.
5279 if (tslot
>= lwpdirsize
) {
5284 tid
= lep
->le_lwpid
;
5285 error
= gfs_readdir_emitn(&gstate
, uiop
, tslot
,
5286 pmkino(tslot
, pslot
, PR_LWPIDDIR
), tid
);
5291 mutex_enter(&p
->p_lock
);
5294 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
5299 pr_readdir_lwpiddir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5301 prcommon_t
*pcp
= pnp
->pr_common
;
5302 int zombie
= ((pcp
->prc_flags
& PRC_DESTROY
) != 0);
5310 ASSERT(pnp
->pr_type
== PR_LWPIDDIR
);
5312 if (uiop
->uio_offset
< 0 ||
5313 uiop
->uio_offset
% sizeof (prdirent_t
) != 0 ||
5314 uiop
->uio_resid
< sizeof (prdirent_t
))
5316 if (pcp
->prc_proc
== NULL
|| pcp
->prc_tslot
== -1)
5318 if (uiop
->uio_offset
>= sizeof (lwpiddir
))
5322 * Loop until user's request is satisfied, omitting some files
5323 * along the way if the lwp is a zombie and also depending
5324 * on the data model of the process.
5326 pslot
= pcp
->prc_slot
;
5327 tslot
= pcp
->prc_tslot
;
5328 for (dirp
= &lwpiddir
[uiop
->uio_offset
/ sizeof (prdirent_t
)];
5329 uiop
->uio_resid
>= sizeof (prdirent_t
) &&
5330 dirp
< &lwpiddir
[NLWPIDDIRFILES
+2];
5331 uiop
->uio_offset
= off
+ sizeof (prdirent_t
), dirp
++) {
5332 off
= uiop
->uio_offset
;
5334 switch (dirp
->d_ino
) {
5343 #if defined(__sparc)
5344 /* the asrs file exists only for sparc v9 _LP64 processes */
5345 if (dirp
->d_ino
== PR_ASRS
&&
5346 pcp
->prc_datamodel
!= DATAMODEL_LP64
)
5349 bcopy(dirp
, &dirent
, sizeof (prdirent_t
));
5350 if (dirent
.d_ino
== PR_LWPDIR
)
5351 dirent
.d_ino
= pmkino(0, pslot
, dirp
->d_ino
);
5353 dirent
.d_ino
= pmkino(tslot
, pslot
, dirp
->d_ino
);
5354 if ((error
= uiomove((caddr_t
)&dirent
, sizeof (prdirent_t
),
5355 UIO_READ
, uiop
)) != 0)
5360 *eofp
= (uiop
->uio_offset
>= sizeof (lwpiddir
));
5366 pr_readdir_fddir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5368 gfs_readdir_state_t gstate
;
5376 ASSERT(pnp
->pr_type
== PR_FDDIR
);
5378 if ((error
= prlock(pnp
, ZNO
)) != 0)
5380 p
= pnp
->pr_common
->prc_proc
;
5383 mutex_exit(&p
->p_lock
);
5385 if ((error
= gfs_readdir_init(&gstate
, PLNSIZ
, PRSDSIZE
, uiop
,
5386 pmkino(0, pslot
, PR_PIDDIR
), pmkino(0, pslot
, PR_FDDIR
), 0)) != 0) {
5387 mutex_enter(&p
->p_lock
);
5392 mutex_enter(&fip
->fi_lock
);
5393 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
)
5396 fddirsize
= fip
->fi_nfiles
;
5399 * Loop until user's request is satisfied or until
5400 * all file descriptors have been examined.
5402 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &n
)) == 0) {
5406 while (n
< fddirsize
&& fip
->fi_list
[n
].uf_file
== NULL
)
5409 * Stop when all fds have been reported.
5411 if (n
>= fddirsize
) {
5416 error
= gfs_readdir_emitn(&gstate
, uiop
, n
,
5417 pmkino(n
, pslot
, PR_FD
), n
);
5422 mutex_exit(&fip
->fi_lock
);
5423 mutex_enter(&p
->p_lock
);
5426 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
5431 pr_readdir_pathdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5433 longlong_t bp
[DIRENT64_RECLEN(64) / sizeof (longlong_t
)];
5434 dirent64_t
*dirent
= (dirent64_t
*)bp
;
5444 struct as
*as
= NULL
;
5449 ASSERT(pnp
->pr_type
== PR_PATHDIR
);
5451 if (uiop
->uio_offset
< 0 ||
5452 uiop
->uio_resid
<= 0 ||
5453 (uiop
->uio_offset
% PRSDSIZE
) != 0)
5455 oresid
= uiop
->uio_resid
;
5456 bzero(bp
, sizeof (bp
));
5458 if ((error
= prlock(pnp
, ZNO
)) != 0)
5460 p
= pnp
->pr_common
->prc_proc
;
5463 mutex_exit(&p
->p_lock
);
5465 if ((p
->p_flag
& SSYS
) || (as
= p
->p_as
) == &kas
) {
5469 AS_LOCK_ENTER(as
, RW_WRITER
);
5470 if (as
->a_updatedir
)
5472 objdirsize
= as
->a_sizedir
;
5477 mutex_enter(&fip
->fi_lock
);
5478 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
)
5481 fddirsize
= fip
->fi_nfiles
;
5483 for (; uiop
->uio_resid
> 0; uiop
->uio_offset
= off
+ PRSDSIZE
) {
5485 * There are 4 special files in the path directory: ".", "..",
5486 * "root", and "cwd". We handle those specially here.
5488 off
= uiop
->uio_offset
;
5489 idx
= off
/ PRSDSIZE
;
5490 if (off
== 0) { /* "." */
5491 dirent
->d_ino
= pmkino(0, pslot
, PR_PATHDIR
);
5492 dirent
->d_name
[0] = '.';
5493 dirent
->d_name
[1] = '\0';
5494 reclen
= DIRENT64_RECLEN(1);
5495 } else if (idx
== 1) { /* ".." */
5496 dirent
->d_ino
= pmkino(0, pslot
, PR_PIDDIR
);
5497 dirent
->d_name
[0] = '.';
5498 dirent
->d_name
[1] = '.';
5499 dirent
->d_name
[2] = '\0';
5500 reclen
= DIRENT64_RECLEN(2);
5501 } else if (idx
== 2) { /* "root" */
5502 dirent
->d_ino
= pmkino(idx
, pslot
, PR_PATH
);
5503 (void) strcpy(dirent
->d_name
, "root");
5504 reclen
= DIRENT64_RECLEN(4);
5505 } else if (idx
== 3) { /* "cwd" */
5506 dirent
->d_ino
= pmkino(idx
, pslot
, PR_PATH
);
5507 (void) strcpy(dirent
->d_name
, "cwd");
5508 reclen
= DIRENT64_RECLEN(3);
5509 } else if (idx
< 4 + fddirsize
) {
5511 * In this case, we have one of the file descriptors.
5514 if (fip
->fi_list
[fd
].uf_file
== NULL
)
5516 dirent
->d_ino
= pmkino(idx
, pslot
, PR_PATH
);
5517 (void) pr_u32tos(fd
, dirent
->d_name
, PLNSIZ
+1);
5518 reclen
= DIRENT64_RECLEN(PLNSIZ
);
5519 } else if (idx
< 4 + fddirsize
+ objdirsize
) {
5521 mutex_exit(&fip
->fi_lock
);
5526 * We drop p_lock before grabbing the address space lock
5527 * in order to avoid a deadlock with the clock thread.
5528 * The process will not disappear and its address space
5529 * will not change because it is marked P_PR_LOCK.
5533 AS_LOCK_ENTER(as
, RW_WRITER
);
5536 if (as
->a_updatedir
) {
5538 objdirsize
= as
->a_sizedir
;
5541 obj
= idx
- 4 - fddirsize
;
5542 if ((vp
= obj_entry(as
, obj
)) == NULL
)
5544 vattr
.va_mask
= AT_FSID
|AT_NODEID
;
5545 if (VOP_GETATTR(vp
, &vattr
, 0, CRED(), NULL
) != 0)
5547 if (vp
== p
->p_exec
)
5548 (void) strcpy(dirent
->d_name
, "a.out");
5550 pr_object_name(dirent
->d_name
, vp
, &vattr
);
5551 dirent
->d_ino
= pmkino(idx
, pslot
, PR_PATH
);
5552 reclen
= DIRENT64_RECLEN(strlen(dirent
->d_name
));
5557 dirent
->d_off
= uiop
->uio_offset
+ PRSDSIZE
;
5558 dirent
->d_reclen
= (ushort_t
)reclen
;
5559 if (reclen
> uiop
->uio_resid
) {
5561 * Error if no entries have been returned yet.
5563 if (uiop
->uio_resid
== oresid
)
5568 * Drop the address space lock to do the uiomove().
5573 error
= uiomove((caddr_t
)dirent
, reclen
, UIO_READ
, uiop
);
5575 AS_LOCK_ENTER(as
, RW_WRITER
);
5581 if (error
== 0 && eofp
)
5582 *eofp
= (uiop
->uio_offset
>= (fddirsize
+ 2) * PRSDSIZE
);
5585 mutex_exit(&fip
->fi_lock
);
5588 mutex_enter(&p
->p_lock
);
5594 pr_readdir_tmpldir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5598 gfs_readdir_state_t gstate
;
5602 ASSERT(pnp
->pr_type
== PR_TMPLDIR
);
5604 if ((error
= prlock(pnp
, ZNO
)) != 0)
5606 p
= pnp
->pr_common
->prc_proc
;
5607 pslot
= pnp
->pr_common
->prc_slot
;
5608 tslot
= pnp
->pr_common
->prc_tslot
;
5609 mutex_exit(&p
->p_lock
);
5611 if ((error
= gfs_readdir_init(&gstate
, PRDIRSIZE
, PRSDSIZE
, uiop
,
5612 pmkino(tslot
, pslot
, PR_LWPDIR
),
5613 pmkino(tslot
, pslot
, PR_TMPLDIR
), 0)) != 0) {
5614 mutex_enter(&p
->p_lock
);
5619 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &n
)) == 0) {
5621 * Check for an active template. Reading a directory's
5622 * contents is already racy, so we don't bother taking
5625 while (n
< ct_ntypes
&&
5626 pnp
->pr_common
->prc_thread
->t_lwp
->lwp_ct_active
[n
] == NULL
)
5629 * Stop when all types have been reported.
5631 if (n
>= ct_ntypes
) {
5636 * The pmkino invocation below will need to be updated
5637 * when we create our fifth contract type.
5639 ASSERT(ct_ntypes
<= 4);
5640 error
= gfs_readdir_emit(&gstate
, uiop
, n
,
5641 pmkino((tslot
<< 2) | n
, pslot
, PR_TMPL
),
5642 ct_types
[n
]->ct_type_name
, 0);
5647 mutex_enter(&p
->p_lock
);
5650 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
5654 pr_readdir_ctdir(prnode_t
*pnp
, uio_t
*uiop
, int *eofp
)
5658 gfs_readdir_state_t gstate
;
5663 ASSERT(pnp
->pr_type
== PR_CTDIR
);
5665 if ((error
= prlock(pnp
, ZNO
)) != 0)
5667 p
= pnp
->pr_common
->prc_proc
;
5669 mutex_exit(&p
->p_lock
);
5671 if ((error
= gfs_readdir_init(&gstate
, PRDIRSIZE
, PRSDSIZE
, uiop
,
5672 pmkino(0, pslot
, PR_PIDDIR
), pmkino(0, pslot
, PR_CTDIR
), 0)) != 0) {
5673 mutex_enter(&p
->p_lock
);
5678 zid
= VTOZONE(pnp
->pr_vnode
)->zone_uniqid
;
5679 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &n
)) == 0) {
5680 id_t next
= contract_plookup(p
, n
, zid
);
5685 error
= gfs_readdir_emitn(&gstate
, uiop
, next
,
5686 pmkino(next
, pslot
, PR_CT
), next
);
5691 mutex_enter(&p
->p_lock
);
5694 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
5699 prfsync(vnode_t
*vp
, int syncflag
, cred_t
*cr
, caller_context_t
*ct
)
5705 * Utility: remove a /proc vnode from a linked list, threaded through pr_next.
5708 pr_list_unlink(vnode_t
*pvp
, vnode_t
**listp
)
5713 while ((vp
= *listp
) != NULL
) {
5716 *listp
= pnp
->pr_next
;
5717 pnp
->pr_next
= NULL
;
5720 listp
= &pnp
->pr_next
;
5726 prinactive(vnode_t
*vp
, cred_t
*cr
, caller_context_t
*ct
)
5728 prnode_t
*pnp
= VTOP(vp
);
5729 prnodetype_t type
= pnp
->pr_type
;
5732 vnode_t
*ovp
= NULL
;
5733 prnode_t
*opnp
= NULL
;
5740 /* These are not linked into the usual lists */
5741 ASSERT(vp
->v_count
== 1);
5742 if ((dp
= pnp
->pr_parent
) != NULL
)
5750 mutex_enter(&pr_pidlock
);
5751 if (pnp
->pr_pcommon
== NULL
)
5753 else if ((p
= pnp
->pr_pcommon
->prc_proc
) != NULL
)
5754 mutex_enter(&p
->p_lock
);
5755 mutex_enter(&vp
->v_lock
);
5757 if (type
== PR_PROCDIR
|| vp
->v_count
> 1) {
5759 mutex_exit(&vp
->v_lock
);
5761 mutex_exit(&p
->p_lock
);
5762 mutex_exit(&pr_pidlock
);
5766 if ((dp
= pnp
->pr_parent
) != NULL
) {
5776 mutex_enter(&dpnp
->pr_mutex
);
5777 if (dpnp
->pr_files
!= NULL
&&
5778 dpnp
->pr_files
[pnp
->pr_index
] == vp
)
5779 dpnp
->pr_files
[pnp
->pr_index
] = NULL
;
5780 mutex_exit(&dpnp
->pr_mutex
);
5783 pnp
->pr_parent
= NULL
;
5786 ASSERT(vp
->v_count
== 1);
5789 * If we allocated an old /proc/pid node, free it too.
5791 if (pnp
->pr_pidfile
!= NULL
) {
5792 ASSERT(type
== PR_PIDDIR
);
5793 ovp
= pnp
->pr_pidfile
;
5795 ASSERT(opnp
->pr_type
== PR_PIDFILE
);
5796 pnp
->pr_pidfile
= NULL
;
5799 mutex_exit(&pr_pidlock
);
5803 * Remove the vnodes from the lists of
5804 * /proc vnodes for the process.
5810 pr_list_unlink(vp
, &p
->p_trace
);
5813 if ((slot
= pnp
->pr_common
->prc_tslot
) != -1) {
5814 lwpent_t
*lep
= p
->p_lwpdir
[slot
].ld_entry
;
5815 pr_list_unlink(vp
, &lep
->le_trace
);
5819 pr_list_unlink(vp
, &p
->p_plist
);
5823 pr_list_unlink(ovp
, &p
->p_plist
);
5824 mutex_exit(&p
->p_lock
);
5827 mutex_exit(&vp
->v_lock
);
5829 if (type
== PR_CT
&& pnp
->pr_contract
!= NULL
) {
5830 contract_rele(pnp
->pr_contract
);
5831 pnp
->pr_contract
= NULL
;
5844 prseek(vnode_t
*vp
, offset_t ooff
, offset_t
*noffp
, caller_context_t
*ct
)
5850 * We use the p_execdir member of proc_t to expand the %d token in core file
5851 * paths (the directory path for the executable that dumped core; see
5852 * coreadm(1M) for details). We'd like gcore(1) to be able to expand %d in
5853 * the same way as core dumping from the kernel, but there's no convenient
5854 * and comprehensible way to export the path name for p_execdir. To solve
5855 * this, we try to find the actual path to the executable that was used. In
5856 * pr_lookup_pathdir(), we mark the a.out path name vnode with the PR_AOUT
5857 * flag, and use that here to indicate that more work is needed beyond the
5858 * call to vnodetopath().
5861 prreadlink_lookup(prnode_t
*pnp
, char *buf
, size_t size
, cred_t
*cr
)
5864 vnode_t
*vp
, *execvp
, *vrootp
;
5868 size_t dlen
= DIRENT64_RECLEN(MAXPATHLEN
);
5872 mutex_enter(&p
->p_lock
);
5873 if ((vrootp
= PTOU(p
)->u_rdir
) == NULL
)
5876 mutex_exit(&p
->p_lock
);
5878 ret
= vnodetopath(vrootp
, pnp
->pr_realvp
, buf
, size
, cr
);
5881 * If PR_AOUT isn't set, then we looked up the path for the vnode;
5882 * otherwise, we looked up the path for (what we believe to be) the
5883 * containing directory.
5885 if ((pnp
->pr_flags
& PR_AOUT
) == 0) {
5891 * Fail if there's a problem locking the process. This will only
5892 * occur if the process is changing so the information we would
5893 * report would already be invalid.
5895 if (prlock(pnp
, ZNO
) != 0) {
5900 p
= pnp
->pr_common
->prc_proc
;
5901 mutex_exit(&p
->p_lock
);
5907 * If our initial lookup of the directory failed, fall back to
5908 * the path name information for p_exec.
5911 mutex_enter(&p
->p_lock
);
5913 ret
= vnodetopath(vrootp
, execvp
, buf
, size
, cr
);
5922 * We use u_comm as a guess for the last component of the full
5923 * executable path name. If there isn't going to be enough space
5924 * we fall back to using the p_exec so that we can have _an_
5925 * answer even if it's not perfect.
5927 if (strlen(PTOU(p
)->u_comm
) + len
+ 1 < size
) {
5929 (void) strcpy(buf
+ len
+ 1, PTOU(p
)->u_comm
);
5930 mutex_enter(&p
->p_lock
);
5934 * Do a forward lookup of our u_comm guess.
5936 if (lookupnameat(buf
+ len
+ 1, UIO_SYSSPACE
, FOLLOW
, NULLVPP
,
5937 &vp
, pnp
->pr_realvp
) == 0) {
5938 if (vn_compare(vp
, execvp
)) {
5948 mutex_enter(&p
->p_lock
);
5952 dbuf
= kmem_alloc(dlen
, KM_SLEEP
);
5955 * Try to find a matching vnode by iterating through the directory's
5956 * entries. If that fails, fall back to the path information for
5959 if ((ret
= dirfindvp(vrootp
, pnp
->pr_realvp
, execvp
, cr
, dbuf
,
5960 dlen
, &dp
)) == 0 && strlen(dp
->d_name
) + len
+ 1 < size
) {
5962 (void) strcpy(buf
+ len
+ 1, dp
->d_name
);
5964 ret
= vnodetopath(vrootp
, execvp
, buf
, size
, cr
);
5967 kmem_free(dbuf
, dlen
);
5976 prreadlink(vnode_t
*vp
, uio_t
*uiop
, cred_t
*cr
, caller_context_t
*ctp
)
5978 prnode_t
*pnp
= VTOP(vp
);
5982 int length
, rlength
;
5985 switch (pnp
->pr_type
) {
5987 (void) snprintf(idbuf
, sizeof (idbuf
), "%d", curproc
->p_pid
);
5988 ret
= uiomove(idbuf
, strlen(idbuf
), UIO_READ
, uiop
);
5994 if (pnp
->pr_realvp
->v_type
== VDIR
)
5998 buf
= kmem_alloc(MAXPATHLEN
, KM_SLEEP
);
6000 if ((ret
= prreadlink_lookup(pnp
, buf
, MAXPATHLEN
, cr
)) == 0)
6001 ret
= uiomove(buf
, strlen(buf
), UIO_READ
, uiop
);
6003 kmem_free(buf
, MAXPATHLEN
);
6006 ASSERT(pnp
->pr_contract
!= NULL
);
6007 ct
= pnp
->pr_contract
;
6008 length
= sizeof (CTFS_ROOT
"//") + sizeof (idbuf
) +
6009 strlen(ct
->ct_type
->ct_type_name
);
6010 buf
= kmem_alloc(length
, KM_SLEEP
);
6011 rlength
= snprintf(buf
, length
, CTFS_ROOT
"/%s/%d",
6012 ct
->ct_type
->ct_type_name
, ct
->ct_id
);
6013 ASSERT(rlength
< length
);
6014 ret
= uiomove(buf
, rlength
, UIO_READ
, uiop
);
6015 kmem_free(buf
, length
);
6026 prcmp(vnode_t
*vp1
, vnode_t
*vp2
, caller_context_t
*ct
)
6028 prnode_t
*pp1
, *pp2
;
6033 if (!vn_matchops(vp1
, prvnodeops
) || !vn_matchops(vp2
, prvnodeops
))
6039 if (pp1
->pr_type
!= pp2
->pr_type
)
6041 if (pp1
->pr_type
== PR_PROCDIR
)
6043 if (pp1
->pr_ino
|| pp2
->pr_ino
)
6044 return (pp2
->pr_ino
== pp1
->pr_ino
);
6046 if (pp1
->pr_common
== NULL
|| pp2
->pr_common
== NULL
)
6049 return (pp1
->pr_common
->prc_slot
== pp2
->pr_common
->prc_slot
&&
6050 pp1
->pr_common
->prc_tslot
== pp2
->pr_common
->prc_tslot
);
6054 prrealvp(vnode_t
*vp
, vnode_t
**vpp
, caller_context_t
*ct
)
6058 if ((rvp
= VTOP(vp
)->pr_realvp
) != NULL
) {
6060 if (VOP_REALVP(vp
, &rvp
, ct
) == 0)
6069 * Return the answer requested to poll().
6070 * POLLIN, POLLRDNORM, and POLLOUT are recognized as in fs_poll().
6071 * In addition, these have special meaning for /proc files:
6072 * POLLPRI process or lwp stopped on an event of interest
6073 * POLLERR /proc file descriptor is invalid
6074 * POLLHUP process or lwp has terminated
6078 prpoll(vnode_t
*vp
, short events
, int anyyet
, short *reventsp
,
6079 pollhead_t
**phpp
, caller_context_t
*ct
)
6081 prnode_t
*pnp
= VTOP(vp
);
6082 prcommon_t
*pcp
= pnp
->pr_common
;
6083 pollhead_t
*php
= &pcp
->prc_pollhead
;
6089 ASSERT(pnp
->pr_type
< PR_NFILES
);
6092 * Support for old /proc interface.
6094 if (pnp
->pr_pidfile
!= NULL
) {
6095 vp
= pnp
->pr_pidfile
;
6097 ASSERT(pnp
->pr_type
== PR_PIDFILE
);
6098 ASSERT(pnp
->pr_common
== pcp
);
6101 *reventsp
= revents
= 0;
6102 *phpp
= (pollhead_t
*)NULL
;
6104 if (vp
->v_type
== VDIR
) {
6105 *reventsp
|= POLLNVAL
;
6109 /* avoid deadlock with prnotify() */
6110 if (pollunlock(&lockstate
) != 0) {
6111 *reventsp
= POLLNVAL
;
6115 if ((error
= prlock(pnp
, ZNO
)) != 0) {
6116 pollrelock(lockstate
);
6118 case ENOENT
: /* process or lwp died */
6119 *reventsp
= POLLHUP
;
6122 case EAGAIN
: /* invalidated */
6123 *reventsp
= POLLERR
;
6131 * We have the process marked locked (P_PR_LOCK) and we are holding
6132 * its p->p_lock. We want to unmark the process but retain
6133 * exclusive control w.r.t. other /proc controlling processes
6134 * before reacquiring the polling locks.
6136 * prunmark() does this for us. It unmarks the process
6137 * but retains p->p_lock so we still have exclusive control.
6138 * We will drop p->p_lock at the end to relinquish control.
6140 * We cannot call prunlock() at the end to relinquish control
6141 * because prunlock(), like prunmark(), may drop and reacquire
6142 * p->p_lock and that would lead to a lock order violation
6143 * w.r.t. the polling locks we are about to reacquire.
6149 pollrelock(lockstate
); /* reacquire dropped poll locks */
6151 if ((p
->p_flag
& SSYS
) || p
->p_as
== &kas
)
6156 if ((ev
= (events
& (POLLIN
|POLLRDNORM
))) != 0)
6159 * POLLWRNORM (same as POLLOUT) really should not be
6160 * used to indicate that the process or lwp stopped.
6161 * However, USL chose to use POLLWRNORM rather than
6162 * POLLPRI to indicate this, so we just accept either
6163 * requested event to indicate stopped. (grr...)
6165 if ((ev
= (events
& (POLLPRI
|POLLOUT
|POLLWRNORM
))) != 0) {
6168 if (pcp
->prc_flags
& PRC_LWP
) {
6169 t
= pcp
->prc_thread
;
6173 t
= prchoose(p
); /* returns locked t */
6177 if (ISTOPPED(t
) || VSTOPPED(t
))
6183 *reventsp
= revents
;
6184 if ((!anyyet
&& revents
== 0) || (events
& POLLET
)) {
6186 * Arrange to wake up the polling lwp when
6187 * the target process/lwp stops or terminates
6188 * or when the file descriptor becomes invalid.
6190 pcp
->prc_flags
|= PRC_POLL
;
6193 mutex_exit(&p
->p_lock
);
6198 extern int prioctl(vnode_t
*, int, intptr_t, int, cred_t
*, int *,
6199 caller_context_t
*);
6202 * /proc vnode operations vector
6204 const fs_operation_def_t pr_vnodeops_template
[] = {
6205 VOPNAME_OPEN
, { .vop_open
= propen
},
6206 VOPNAME_CLOSE
, { .vop_close
= prclose
},
6207 VOPNAME_READ
, { .vop_read
= prread
},
6208 VOPNAME_WRITE
, { .vop_write
= prwrite
},
6209 VOPNAME_IOCTL
, { .vop_ioctl
= prioctl
},
6210 VOPNAME_GETATTR
, { .vop_getattr
= prgetattr
},
6211 VOPNAME_ACCESS
, { .vop_access
= praccess
},
6212 VOPNAME_LOOKUP
, { .vop_lookup
= prlookup
},
6213 VOPNAME_CREATE
, { .vop_create
= prcreate
},
6214 VOPNAME_READDIR
, { .vop_readdir
= prreaddir
},
6215 VOPNAME_READLINK
, { .vop_readlink
= prreadlink
},
6216 VOPNAME_FSYNC
, { .vop_fsync
= prfsync
},
6217 VOPNAME_INACTIVE
, { .vop_inactive
= prinactive
},
6218 VOPNAME_SEEK
, { .vop_seek
= prseek
},
6219 VOPNAME_CMP
, { .vop_cmp
= prcmp
},
6220 VOPNAME_FRLOCK
, { .error
= fs_error
},
6221 VOPNAME_REALVP
, { .vop_realvp
= prrealvp
},
6222 VOPNAME_POLL
, { .vop_poll
= prpoll
},
6223 VOPNAME_DISPOSE
, { .error
= fs_error
},
6224 VOPNAME_SHRLOCK
, { .error
= fs_error
},