Lines Matching defs:pnp

226 	prnode_t *pnp = VTOP(vp);
227 prcommon_t *pcp = pnp->pr_pcommon;
228 prnodetype_t type = pnp->pr_type;
253 rvp = pnp->pr_realvp;
287 p = pr_p_lock(pnp);
308 pnp->pr_flags |= PR_ISSELF;
331 if ((pnp->pr_flags & PR_INVAL) ||
333 (VTOP(pnp->pr_pidfile)->pr_flags & PR_INVAL))) {
349 pnp->pr_flags |= PR_OFFMAX;
374 } else if (pnp->pr_hatid == 0) {
376 pnp->pr_hatid = (uint_t)id;
387 npnp->pr_ino = pnp->pr_ino;
388 npnp->pr_common = pnp->pr_common;
389 npnp->pr_pcommon = pnp->pr_pcommon;
390 npnp->pr_parent = pnp->pr_parent;
392 npnp->pr_index = pnp->pr_index;
397 VN_RELE(PTOV(pnp));
398 pnp = npnp;
400 *vpp = PTOV(pnp);
407 prunlock(pnp);
419 prnode_t *pnp = VTOP(vp);
420 prcommon_t *pcp = pnp->pr_pcommon;
421 prnodetype_t type = pnp->pr_type;
443 p = pr_p_lock(pnp);
453 if (pnp->pr_owner == curproc && !fisopen(vp))
454 pnp->pr_owner = NULL;
457 prunlock(pnp);
472 if ((pnp->pr_flags & (PR_ISSELF|PR_INVAL)) ||
474 (VTOP(pnp->pr_pidfile)->pr_flags & PR_INVAL))) {
484 if (pnp->pr_owner == curproc && !fisopen(vp))
485 pnp->pr_owner = NULL;
510 if (p->p_as != &kas && pnp->pr_hatid != 0)
511 hat_freestat(p->p_as, pnp->pr_hatid);
513 pnp->pr_hatid = 0;
533 if (pr_cancel_watch(pnp) == NULL)
571 prunlock(pnp);
649 pr_read_inval(prnode_t *pnp, uio_t *uiop)
675 pr_read_as(prnode_t *pnp, uio_t *uiop)
679 ASSERT(pnp->pr_type == PR_AS);
681 if ((error = prlock(pnp, ZNO)) == 0) {
682 proc_t *p = pnp->pr_common->prc_proc;
705 prunlock(pnp);
712 pr_read_status(prnode_t *pnp, uio_t *uiop)
717 ASSERT(pnp->pr_type == PR_STATUS);
724 if ((error = prlock(pnp, ZNO)) == 0) {
725 prgetstatus(pnp->pr_common->prc_proc, sp, VTOZONE(PTOV(pnp)));
726 prunlock(pnp);
734 pr_read_lstatus(prnode_t *pnp, uio_t *uiop)
746 ASSERT(pnp->pr_type == PR_LSTATUS);
748 if ((error = prlock(pnp, ZNO)) != 0)
750 p = pnp->pr_common->prc_proc;
769 prgetlwpstatus(t, sp, VTOZONE(PTOV(pnp)));
772 prunlock(pnp);
780 pr_read_psinfo(prnode_t *pnp, uio_t *uiop)
786 ASSERT(pnp->pr_type == PR_PSINFO);
789 * We don't want the full treatment of prlock(pnp) here.
793 p = pr_p_lock(pnp);
798 ASSERT(p == pnp->pr_common->prc_proc);
800 prunlock(pnp);
807 pr_read_lpsinfo(prnode_t *pnp, uio_t *uiop)
820 ASSERT(pnp->pr_type == PR_LPSINFO);
823 * We don't want the full treatment of prlock(pnp) here.
827 p = pr_p_lock(pnp);
831 ASSERT(p == pnp->pr_common->prc_proc);
833 prunlock(pnp);
865 prunlock(pnp);
873 pr_read_map_common(prnode_t *pnp, uio_t *uiop, prnodetype_t type)
881 if ((error = prlock(pnp, ZNO)) != 0)
884 p = pnp->pr_common->prc_proc;
888 prunlock(pnp);
893 prunlock(pnp);
913 prunlock(pnp);
921 pr_read_map(prnode_t *pnp, uio_t *uiop)
923 ASSERT(pnp->pr_type == PR_MAP);
924 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
928 pr_read_rmap(prnode_t *pnp, uio_t *uiop)
930 ASSERT(pnp->pr_type == PR_RMAP);
931 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
935 pr_read_xmap(prnode_t *pnp, uio_t *uiop)
937 ASSERT(pnp->pr_type == PR_XMAP);
938 return (pr_read_map_common(pnp, uiop, pnp->pr_type));
942 pr_read_cred(prnode_t *pnp, uio_t *uiop)
949 ASSERT(pnp->pr_type == PR_CRED);
959 if ((error = prlock(pnp, ZNO)) != 0)
961 p = pnp->pr_common->prc_proc;
965 prunlock(pnp);
977 pr_read_priv(prnode_t *pnp, uio_t *uiop)
984 ASSERT(pnp->pr_type == PR_PRIV);
986 if ((error = prlock(pnp, ZNO)) != 0)
988 p = pnp->pr_common->prc_proc;
992 prunlock(pnp);
1001 pr_read_sigact(prnode_t *pnp, uio_t *uiop)
1010 ASSERT(pnp->pr_type == PR_SIGACT);
1018 if ((error = prlock(pnp, ZNO)) != 0)
1020 p = pnp->pr_common->prc_proc;
1024 prunlock(pnp);
1031 prunlock(pnp);
1040 pr_read_auxv(prnode_t *pnp, uio_t *uiop)
1047 ASSERT(pnp->pr_type == PR_AUXV);
1049 if ((error = prlock(pnp, ZNO)) != 0)
1053 prunlock(pnp);
1057 p = pnp->pr_common->prc_proc;
1060 prunlock(pnp);
1075 pr_read_ldt(prnode_t *pnp, uio_t *uiop)
1082 ASSERT(pnp->pr_type == PR_LDT);
1084 if ((error = prlock(pnp, ZNO)) != 0)
1086 p = pnp->pr_common->prc_proc;
1094 prunlock(pnp);
1102 prunlock(pnp);
1111 pr_read_usage(prnode_t *pnp, uio_t *uiop)
1119 ASSERT(pnp->pr_type == PR_USAGE);
1126 * We don't want the full treatment of prlock(pnp) here.
1130 p = pr_p_lock(pnp);
1136 ASSERT(p == pnp->pr_common->prc_proc);
1139 prunlock(pnp);
1179 !(pnp->pr_pcommon->prc_flags & PRC_DESTROY)) {
1188 prunlock(pnp);
1200 pr_read_lusage(prnode_t *pnp, uio_t *uiop)
1214 ASSERT(pnp->pr_type == PR_LUSAGE);
1217 * We don't want the full treatment of prlock(pnp) here.
1221 p = pr_p_lock(pnp);
1225 ASSERT(p == pnp->pr_common->prc_proc);
1227 prunlock(pnp);
1233 prunlock(pnp);
1303 prunlock(pnp);
1311 pr_read_pagedata(prnode_t *pnp, uio_t *uiop)
1316 ASSERT(pnp->pr_type == PR_PAGEDATA);
1318 if ((error = prlock(pnp, ZNO)) != 0)
1321 p = pnp->pr_common->prc_proc;
1323 prunlock(pnp);
1328 error = prpdread(p, pnp->pr_hatid, uiop);
1331 prunlock(pnp);
1336 pr_read_opagedata(prnode_t *pnp, uio_t *uiop)
1342 ASSERT(pnp->pr_type == PR_OPAGEDATA);
1344 if ((error = prlock(pnp, ZNO)) != 0)
1347 p = pnp->pr_common->prc_proc;
1350 prunlock(pnp);
1355 error = oprpdread(as, pnp->pr_hatid, uiop);
1358 prunlock(pnp);
1363 pr_read_watch(prnode_t *pnp, uio_t *uiop)
1373 ASSERT(pnp->pr_type == PR_WATCH);
1375 if ((error = prlock(pnp, ZNO)) != 0)
1378 p = pnp->pr_common->prc_proc;
1382 prunlock(pnp);
1401 prunlock(pnp);
1409 pr_read_lwpstatus(prnode_t *pnp, uio_t *uiop)
1414 ASSERT(pnp->pr_type == PR_LWPSTATUS);
1422 if ((error = prlock(pnp, ZNO)) != 0)
1426 prunlock(pnp);
1430 prgetlwpstatus(pnp->pr_common->prc_thread, sp, VTOZONE(PTOV(pnp)));
1431 prunlock(pnp);
1440 pr_read_lwpsinfo(prnode_t *pnp, uio_t *uiop)
1447 ASSERT(pnp->pr_type == PR_LWPSINFO);
1450 * We don't want the full treatment of prlock(pnp) here.
1454 p = pr_p_lock(pnp);
1458 ASSERT(p == pnp->pr_common->prc_proc);
1459 if (pnp->pr_common->prc_tslot == -1) {
1460 prunlock(pnp);
1465 prunlock(pnp);
1469 if ((t = pnp->pr_common->prc_thread) != NULL)
1472 lep = p->p_lwpdir[pnp->pr_common->prc_tslot].ld_entry;
1481 prunlock(pnp);
1487 pr_read_lwpusage(prnode_t *pnp, uio_t *uiop)
1494 ASSERT(pnp->pr_type == PR_LWPUSAGE);
1501 * We don't want the full treatment of prlock(pnp) here.
1505 p = pr_p_lock(pnp);
1511 ASSERT(p == pnp->pr_common->prc_proc);
1512 if (pnp->pr_common->prc_thread == NULL) {
1513 prunlock(pnp);
1518 prunlock(pnp);
1524 prgetusage(pnp->pr_common->prc_thread, pup);
1526 prunlock(pnp);
1539 pr_read_xregs(prnode_t *pnp, uio_t *uiop)
1548 ASSERT(pnp->pr_type == PR_XREGS);
1552 if ((error = prlock(pnp, ZNO)) != 0)
1555 p = pnp->pr_common->prc_proc;
1556 t = pnp->pr_common->prc_thread;
1560 prunlock(pnp);
1568 prunlock(pnp);
1580 pr_read_spymaster(prnode_t *pnp, uio_t *uiop)
1586 ASSERT(pnp->pr_type == PR_SPYMASTER);
1588 if ((error = prlock(pnp, ZNO)) != 0)
1591 lwp = pnp->pr_common->prc_thread->t_lwp;
1594 prunlock(pnp);
1599 prunlock(pnp);
1607 pr_read_gwindows(prnode_t *pnp, uio_t *uiop)
1615 ASSERT(pnp->pr_type == PR_GWINDOWS);
1619 if ((error = prlock(pnp, ZNO)) != 0)
1622 p = pnp->pr_common->prc_proc;
1623 t = pnp->pr_common->prc_thread;
1636 prunlock(pnp);
1641 prunlock(pnp);
1651 pr_read_asrs(prnode_t *pnp, uio_t *uiop)
1655 ASSERT(pnp->pr_type == PR_ASRS);
1658 if ((error = prlock(pnp, ZNO)) == 0) {
1659 proc_t *p = pnp->pr_common->prc_proc;
1660 kthread_t *t = pnp->pr_common->prc_thread;
1665 prunlock(pnp);
1677 prunlock(pnp);
1688 pr_read_piddir(prnode_t *pnp, uio_t *uiop)
1690 ASSERT(pnp->pr_type == PR_PIDDIR);
1691 ASSERT(pnp->pr_pidfile != NULL);
1694 pnp = VTOP(pnp->pr_pidfile);
1695 ASSERT(pnp->pr_type == PR_PIDFILE);
1697 return (pr_read_pidfile(pnp, uiop));
1701 pr_read_pidfile(prnode_t *pnp, uio_t *uiop)
1705 ASSERT(pnp->pr_type == PR_PIDFILE || pnp->pr_type == PR_LWPIDFILE);
1707 if ((error = prlock(pnp, ZNO)) == 0) {
1708 proc_t *p = pnp->pr_common->prc_proc;
1728 prunlock(pnp);
1805 pr_read_status_32(prnode_t *pnp, uio_t *uiop)
1811 ASSERT(pnp->pr_type == PR_STATUS);
1818 if ((error = prlock(pnp, ZNO)) == 0) {
1823 p = pnp->pr_common->prc_proc;
1825 prunlock(pnp);
1828 prgetstatus32(pnp->pr_common->prc_proc, sp,
1829 VTOZONE(PTOV(pnp)));
1830 prunlock(pnp);
1839 pr_read_lstatus_32(prnode_t *pnp, uio_t *uiop)
1851 ASSERT(pnp->pr_type == PR_LSTATUS);
1853 if ((error = prlock(pnp, ZNO)) != 0)
1855 p = pnp->pr_common->prc_proc;
1861 prunlock(pnp);
1882 prgetlwpstatus32(t, sp, VTOZONE(PTOV(pnp)));
1885 prunlock(pnp);
1893 pr_read_psinfo_32(prnode_t *pnp, uio_t *uiop)
1899 ASSERT(pnp->pr_type == PR_PSINFO);
1902 * We don't want the full treatment of prlock(pnp) here.
1906 p = pr_p_lock(pnp);
1911 ASSERT(p == pnp->pr_common->prc_proc);
1913 prunlock(pnp);
1920 pr_read_lpsinfo_32(prnode_t *pnp, uio_t *uiop)
1933 ASSERT(pnp->pr_type == PR_LPSINFO);
1936 * We don't want the full treatment of prlock(pnp) here.
1940 p = pr_p_lock(pnp);
1944 ASSERT(p == pnp->pr_common->prc_proc);
1946 prunlock(pnp);
1976 prunlock(pnp);
1984 pr_read_map_common_32(prnode_t *pnp, uio_t *uiop, prnodetype_t type)
1992 if ((error = prlock(pnp, ZNO)) != 0)
1995 p = pnp->pr_common->prc_proc;
1999 prunlock(pnp);
2004 prunlock(pnp);
2009 prunlock(pnp);
2028 prunlock(pnp);
2036 pr_read_map_32(prnode_t *pnp, uio_t *uiop)
2038 ASSERT(pnp->pr_type == PR_MAP);
2039 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2043 pr_read_rmap_32(prnode_t *pnp, uio_t *uiop)
2045 ASSERT(pnp->pr_type == PR_RMAP);
2046 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2050 pr_read_xmap_32(prnode_t *pnp, uio_t *uiop)
2052 ASSERT(pnp->pr_type == PR_XMAP);
2053 return (pr_read_map_common_32(pnp, uiop, pnp->pr_type));
2057 pr_read_sigact_32(prnode_t *pnp, uio_t *uiop)
2066 ASSERT(pnp->pr_type == PR_SIGACT);
2074 if ((error = prlock(pnp, ZNO)) != 0)
2076 p = pnp->pr_common->prc_proc;
2079 prunlock(pnp);
2085 prunlock(pnp);
2092 prunlock(pnp);
2101 pr_read_auxv_32(prnode_t *pnp, uio_t *uiop)
2109 ASSERT(pnp->pr_type == PR_AUXV);
2111 if ((error = prlock(pnp, ZNO)) != 0)
2113 p = pnp->pr_common->prc_proc;
2116 prunlock(pnp);
2121 prunlock(pnp);
2130 prunlock(pnp);
2136 pr_read_usage_32(prnode_t *pnp, uio_t *uiop)
2144 ASSERT(pnp->pr_type == PR_USAGE);
2151 * We don't want the full treatment of prlock(pnp) here.
2155 p = pr_p_lock(pnp);
2161 ASSERT(p == pnp->pr_common->prc_proc);
2164 prunlock(pnp);
2204 !(pnp->pr_pcommon->prc_flags & PRC_DESTROY)) {
2213 prunlock(pnp);
2225 pr_read_lusage_32(prnode_t *pnp, uio_t *uiop)
2239 ASSERT(pnp->pr_type == PR_LUSAGE);
2242 * We don't want the full treatment of prlock(pnp) here.
2246 p = pr_p_lock(pnp);
2250 ASSERT(p == pnp->pr_common->prc_proc);
2252 prunlock(pnp);
2258 prunlock(pnp);
2329 prunlock(pnp);
2337 pr_read_pagedata_32(prnode_t *pnp, uio_t *uiop)
2342 ASSERT(pnp->pr_type == PR_PAGEDATA);
2344 if ((error = prlock(pnp, ZNO)) != 0)
2347 p = pnp->pr_common->prc_proc;
2349 prunlock(pnp);
2354 prunlock(pnp);
2359 error = prpdread32(p, pnp->pr_hatid, uiop);
2362 prunlock(pnp);
2367 pr_read_opagedata_32(prnode_t *pnp, uio_t *uiop)
2373 ASSERT(pnp->pr_type == PR_OPAGEDATA);
2375 if ((error = prlock(pnp, ZNO)) != 0)
2378 p = pnp->pr_common->prc_proc;
2382 prunlock(pnp);
2387 prunlock(pnp);
2392 error = oprpdread32(as, pnp->pr_hatid, uiop);
2395 prunlock(pnp);
2400 pr_read_watch_32(prnode_t *pnp, uio_t *uiop)
2410 ASSERT(pnp->pr_type == PR_WATCH);
2412 if ((error = prlock(pnp, ZNO)) != 0)
2415 p = pnp->pr_common->prc_proc;
2417 prunlock(pnp);
2423 prunlock(pnp);
2442 prunlock(pnp);
2450 pr_read_lwpstatus_32(prnode_t *pnp, uio_t *uiop)
2456 ASSERT(pnp->pr_type == PR_LWPSTATUS);
2464 if ((error = prlock(pnp, ZNO)) != 0)
2471 p = pnp->pr_common->prc_proc;
2473 prunlock(pnp);
2479 prunlock(pnp);
2483 prgetlwpstatus32(pnp->pr_common->prc_thread, sp, VTOZONE(PTOV(pnp)));
2484 prunlock(pnp);
2493 pr_read_lwpsinfo_32(prnode_t *pnp, uio_t *uiop)
2500 ASSERT(pnp->pr_type == PR_LWPSINFO);
2503 * We don't want the full treatment of prlock(pnp) here.
2507 p = pr_p_lock(pnp);
2511 ASSERT(p == pnp->pr_common->prc_proc);
2512 if (pnp->pr_common->prc_tslot == -1) {
2513 prunlock(pnp);
2518 prunlock(pnp);
2522 if ((t = pnp->pr_common->prc_thread) != NULL)
2525 lep = p->p_lwpdir[pnp->pr_common->prc_tslot].ld_entry;
2532 prunlock(pnp);
2538 pr_read_lwpusage_32(prnode_t *pnp, uio_t *uiop)
2545 ASSERT(pnp->pr_type == PR_LWPUSAGE);
2552 * We don't want the full treatment of prlock(pnp) here.
2556 p = pr_p_lock(pnp);
2562 ASSERT(p == pnp->pr_common->prc_proc);
2563 if (pnp->pr_common->prc_thread == NULL) {
2564 prunlock(pnp);
2569 prunlock(pnp);
2575 prgetusage(pnp->pr_common->prc_thread, pup);
2577 prunlock(pnp);
2589 pr_read_spymaster_32(prnode_t *pnp, uio_t *uiop)
2595 ASSERT(pnp->pr_type == PR_SPYMASTER);
2597 if ((error = prlock(pnp, ZNO)) != 0)
2600 lwp = pnp->pr_common->prc_thread->t_lwp;
2603 prunlock(pnp);
2608 prunlock(pnp);
2615 pr_read_gwindows_32(prnode_t *pnp, uio_t *uiop)
2623 ASSERT(pnp->pr_type == PR_GWINDOWS);
2627 if ((error = prlock(pnp, ZNO)) != 0)
2630 p = pnp->pr_common->prc_proc;
2631 t = pnp->pr_common->prc_thread;
2634 prunlock(pnp);
2650 prunlock(pnp);
2655 prunlock(pnp);
2670 prnode_t *pnp = VTOP(vp);
2672 ASSERT(pnp->pr_type < PR_NFILES);
2681 return (pr_read_function[pnp->pr_type](pnp, uiop));
2683 return (pr_read_function_32[pnp->pr_type](pnp, uiop));
2685 return (pr_read_function[pnp->pr_type](pnp, uiop));
2693 prnode_t *pnp = VTOP(vp);
2698 ASSERT(pnp->pr_type < PR_NFILES);
2703 switch (pnp->pr_type) {
2705 ASSERT(pnp->pr_pidfile != NULL);
2707 vp = pnp->pr_pidfile;
2708 pnp = VTOP(vp);
2709 ASSERT(pnp->pr_type == PR_PIDFILE);
2716 if ((error = prlock(pnp, ZNO)) == 0) {
2717 proc_t *p = pnp->pr_common->prc_proc;
2739 prunlock(pnp);
2777 prnode_t *pnp = VTOP(vp);
2778 prnodetype_t type = pnp->pr_type;
2831 rvp = pnp->pr_realvp;
2839 vap->va_mode &= pnp->pr_mode;
2861 vap->va_mode = pnp->pr_mode;
2894 p = pr_p_lock(pnp);
2898 pcp = pnp->pr_common;
2906 vap->va_nodeid = pnp->pr_ino? pnp->pr_ino :
2907 pmkino(pcp->prc_tslot, pcp->prc_slot, pnp->pr_type);
3123 if (pnp->pr_common->prc_thread->t_lwp->lwp_spymaster != NULL) {
3176 prunlock(pnp);
3184 prnode_t *pnp = VTOP(vp);
3185 prnodetype_t type = pnp->pr_type;
3207 rvp = pnp->pr_realvp;
3209 vmode = pnp->pr_mode;
3225 p = pr_p_lock(pnp);
3229 prunlock(pnp);
3237 if ((error = prlock(pnp,
3240 p = pnp->pr_common->prc_proc;
3246 prunlock(pnp);
3254 prunlock(pnp);
3268 return (VOP_ACCESS(pnp->pr_realvp, mode, flags, cr, ct));
3275 vmode = pnp->pr_mode;
3349 prnode_t *pnp = VTOP(dp);
3350 prnodetype_t type = pnp->pr_type;
3357 VN_HOLD(pnp->pr_parent);
3358 *vpp = pnp->pr_parent;
3377 dp = pnp->pr_realvp;
3448 prnode_t *pnp;
3457 pnp = prgetnode(dp, PR_SELF);
3458 return (PTOV(pnp));
3470 pnp = prgetnode(dp, PR_PIDDIR);
3475 prfreenode(pnp);
3483 prfreenode(pnp);
3502 prfreenode(pnp);
3507 pnp->pr_owner = curproc;
3513 pcp = pnp->pr_common; /* the newly-allocated prcommon struct */
3522 pnp->pr_common = pcp;
3534 pnp->pr_pcommon = pcp;
3535 pnp->pr_parent = dp;
3541 pnp->pr_next = p->p_trace;
3542 p->p_trace = dp = PTOV(pnp);
3547 vp = pnp->pr_pidfile;
3548 pnp = VTOP(vp);
3549 pnp->pr_ino = ptoi(pcp->prc_pid);
3550 pnp->pr_common = pcp;
3551 pnp->pr_pcommon = pcp;
3552 pnp->pr_parent = dp;
3553 pnp->pr_next = p->p_plist;
3565 prnode_t *pnp;
3585 pnp = prgetnode(dp, type);
3590 prfreenode(pnp);
3600 prfreenode(pnp);
3614 prfreenode(pnp);
3622 pnp->pr_realvp = vp;
3635 prfreenode(pnp);
3643 pnp->pr_common = dpnp->pr_common;
3644 pnp->pr_pcommon = dpnp->pr_pcommon;
3645 pnp->pr_parent = dp;
3647 pnp->pr_index = i;
3649 dpnp->pr_files[i] = vp = PTOV(pnp);
3655 pnp->pr_next = p->p_plist;
3667 prnode_t *pnp;
3676 pnp = prgetnode(dp, PR_OBJECT);
3679 prfreenode(pnp);
3685 prfreenode(pnp);
3734 prfreenode(pnp);
3743 pnp->pr_realvp = vp;
3744 vp = PTOV(pnp);
3759 prnode_t *pnp;
3788 pnp = prgetnode(dp, PR_LWPIDDIR);
3793 prfreenode(pnp);
3816 prfreenode(pnp);
3832 prfreenode(pnp);
3836 pnp->pr_owner = curproc;
3842 pcp = pnp->pr_common; /* the newly-allocated prcommon struct */
3851 pnp->pr_common = pcp;
3867 pnp->pr_pcommon = dpnp->pr_pcommon;
3868 pnp->pr_parent = dp;
3874 pnp->pr_next = lep->le_trace;
3875 lep->le_trace = vp = PTOV(pnp);
3885 prnode_t *pnp;
3904 pnp = prgetnode(dp, type);
3909 prfreenode(pnp);
3920 prfreenode(pnp);
3929 prfreenode(pnp);
3941 prfreenode(pnp);
3949 pnp->pr_common = dpnp->pr_common;
3950 pnp->pr_pcommon = dpnp->pr_pcommon;
3951 pnp->pr_parent = dp;
3953 pnp->pr_index = i;
3955 dpnp->pr_files[i] = vp = PTOV(pnp);
3961 pnp->pr_next = p->p_plist;
3976 prnode_t *pnp;
3998 pnp = prgetnode(dp, PR_FD);
4001 prfreenode(pnp);
4007 prfreenode(pnp);
4017 pnp->pr_mode = 07111;
4019 pnp->pr_mode |= 0444;
4021 pnp->pr_mode |= 0222;
4032 prfreenode(pnp);
4040 pnp->pr_realvp = vp;
4041 pnp->pr_parent = dp; /* needed for prlookup */
4043 vp = PTOV(pnp);
4044 if (pnp->pr_realvp->v_type == VDIR)
4055 prnode_t *pnp;
4222 pnp = prgetnode(dp, PR_PATH);
4224 pnp->pr_flags |= flags;
4225 pnp->pr_common = dpnp->pr_common;
4226 pnp->pr_pcommon = dpnp->pr_pcommon;
4227 pnp->pr_realvp = vp;
4228 pnp->pr_parent = dp; /* needed for prlookup */
4229 pnp->pr_ino = pmkino(idx, dpnp->pr_common->prc_slot, PR_PATH);
4231 vp = PTOV(pnp);
4245 prnode_t *pnp;
4258 pnp = prgetnode(dp, PR_TMPL);
4261 prfreenode(pnp);
4268 prfreenode(pnp);
4272 pnp->pr_common = dpnp->pr_common;
4273 pnp->pr_pcommon = dpnp->pr_pcommon;
4274 pnp->pr_parent = dp;
4275 pnp->pr_cttype = i;
4277 vp = PTOV(pnp);
4279 prfreenode(pnp);
4293 prnode_t *pnp;
4319 pnp = prgetnode(dp, PR_CT);
4322 prfreenode(pnp);
4339 prfreenode(pnp);
4343 pnp->pr_common = dpnp->pr_common;
4344 pnp->pr_pcommon = dpnp->pr_pcommon;
4345 pnp->pr_contract = ct;
4346 pnp->pr_parent = dp;
4347 pnp->pr_ino = pmkino(id, pnp->pr_common->prc_slot, PR_CT);
4350 vp = PTOV(pnp);
4360 prlwpnode(prnode_t *pnp, uint_t tid)
4371 if (pnp->pr_type == PR_PIDFILE) {
4372 dp = pnp->pr_parent; /* /proc/<pid> */
4378 } else if (pnp->pr_type == PR_LWPIDFILE) {
4379 dp = pnp->pr_parent; /* /proc/<pid>/lwp/<lwpid> */
4392 pnp = prgetnode(dp, PR_LWPIDFILE);
4393 vp = PTOV(pnp);
4400 pnp->pr_ino = ptoi(pcp->prc_pid);
4401 pnp->pr_common = pcp;
4402 pnp->pr_pcommon = VTOP(dp)->pr_pcommon;
4403 pnp->pr_parent = dp;
4407 p = pr_p_lock(pnp);
4411 prfreenode(pnp);
4414 prunlock(pnp);
4416 prfreenode(pnp);
4419 pnp->pr_next = p->p_plist;
4421 prunlock(pnp);
4448 prnode_t *pnp;
4454 pnp = kmem_zalloc(sizeof (prnode_t), KM_SLEEP);
4456 mutex_init(&pnp->pr_mutex, NULL, MUTEX_DEFAULT, NULL);
4457 pnp->pr_type = type;
4459 pnp->pr_vnode = vn_alloc(KM_SLEEP);
4461 vp = PTOV(pnp);
4466 vp->v_data = (caddr_t)pnp;
4478 pnp->pr_common = pcp;
4483 pnp->pr_files =
4497 pnp->pr_pidfile = PTOV(xpnp);
4498 pnp->pr_mode = 0511;
4501 pnp->pr_mode = 0555;
4514 pnp->pr_mode = 0500; /* read-search by owner only */
4519 pnp->pr_mode = 0500; /* read-search by owner only */
4525 pnp->pr_mode = 0777;
4530 pnp->pr_mode = 0555; /* read-search by all */
4535 pnp->pr_mode = 0600; /* read-write by owner only */
4540 pnp->pr_mode = 0200; /* write-only by owner only */
4545 pnp->pr_mode = 0600; /* read-write by owner only */
4554 pnp->pr_mode = 0444; /* read-only by all */
4558 pnp->pr_mode = 0400; /* read-only by owner only */
4562 return (pnp);
4569 prfreenode(prnode_t *pnp)
4574 vn_invalid(PTOV(pnp));
4575 vn_free(PTOV(pnp));
4576 mutex_destroy(&pnp->pr_mutex);
4578 switch (pnp->pr_type) {
4581 if (pnp->pr_pidfile != NULL) {
4582 prfreenode(VTOP(pnp->pr_pidfile));
4583 pnp->pr_pidfile = NULL;
4590 prfreecommon(pnp->pr_common);
4591 nfiles = (pnp->pr_type == PR_PIDDIR)?
4593 kmem_free(pnp->pr_files, nfiles * sizeof (vnode_t *));
4602 vp = pnp->pr_realvp;
4603 kmem_free(pnp, sizeof (*pnp));
4698 prnode_t *pnp = VTOP(vp);
4700 ASSERT(pnp->pr_type < PR_NFILES);
4703 return (pr_readdir_function[pnp->pr_type](pnp, uiop, eofp));
4708 pr_readdir_notdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4715 pr_readdir_procdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4722 ASSERT(pnp->pr_type == PR_PROCDIR);
4724 zoneid = VTOZONE(PTOV(pnp))->zone_id;
4774 pr_readdir_piddir(prnode_t *pnp, uio_t *uiop, int *eofp)
4776 int zombie = ((pnp->pr_pcommon->prc_flags & PRC_DESTROY) != 0);
4782 ASSERT(pnp->pr_type == PR_PIDDIR);
4788 if (pnp->pr_pcommon->prc_proc == NULL)
4817 dirent.d_ino = pmkino(0, pnp->pr_pcommon->prc_slot,
4955 pr_readdir_objectdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4966 ASSERT(pnp->pr_type == PR_OBJECTDIR);
4968 if ((error = prlock(pnp, ZNO)) != 0)
4970 p = pnp->pr_common->prc_proc;
4985 prunlock(pnp);
5051 prunlock(pnp);
5058 pr_readdir_lwpdir(prnode_t *pnp, uio_t *uiop, int *eofp)
5068 ASSERT(pnp->pr_type == PR_LWPDIR);
5070 p = pr_p_lock(pnp);
5074 ASSERT(p == pnp->pr_common->prc_proc);
5091 prunlock(pnp);
5125 prunlock(pnp);
5132 pr_readdir_lwpiddir(prnode_t *pnp, uio_t *uiop, int *eofp)
5134 prcommon_t *pcp = pnp->pr_common;
5143 ASSERT(pnp->pr_type == PR_LWPIDDIR);
5199 pr_readdir_fddir(prnode_t *pnp, uio_t *uiop, int *eofp)
5209 ASSERT(pnp->pr_type == PR_FDDIR);
5211 if ((error = prlock(pnp, ZNO)) != 0)
5213 p = pnp->pr_common->prc_proc;
5221 prunlock(pnp);
5257 prunlock(pnp);
5264 pr_readdir_pathdir(prnode_t *pnp, uio_t *uiop, int *eofp)
5282 ASSERT(pnp->pr_type == PR_PATHDIR);
5291 if ((error = prlock(pnp, ZNO)) != 0)
5293 p = pnp->pr_common->prc_proc;
5422 prunlock(pnp);
5427 pr_readdir_tmpldir(prnode_t *pnp, uio_t *uiop, int *eofp)
5435 ASSERT(pnp->pr_type == PR_TMPLDIR);
5437 if ((error = prlock(pnp, ZNO)) != 0)
5439 p = pnp->pr_common->prc_proc;
5440 pslot = pnp->pr_common->prc_slot;
5441 tslot = pnp->pr_common->prc_tslot;
5448 prunlock(pnp);
5459 pnp->pr_common->prc_thread->t_lwp->lwp_ct_active[n] == NULL)
5481 prunlock(pnp);
5487 pr_readdir_ctdir(prnode_t *pnp, uio_t *uiop, int *eofp)
5496 ASSERT(pnp->pr_type == PR_CTDIR);
5498 if ((error = prlock(pnp, ZNO)) != 0)
5500 p = pnp->pr_common->prc_proc;
5507 prunlock(pnp);
5511 zid = VTOZONE(pnp->pr_vnode)->zone_uniqid;
5525 prunlock(pnp);
5544 prnode_t *pnp;
5547 pnp = VTOP(vp);
5549 *listp = pnp->pr_next;
5550 pnp->pr_next = NULL;
5553 listp = &pnp->pr_next;
5561 prnode_t *pnp = VTOP(vp);
5562 prnodetype_t type = pnp->pr_type;
5575 if ((dp = pnp->pr_parent) != NULL)
5577 prfreenode(pnp);
5584 if (pnp->pr_pcommon == NULL)
5586 else if ((p = pnp->pr_pcommon->prc_proc) != NULL)
5599 if ((dp = pnp->pr_parent) != NULL) {
5611 dpnp->pr_files[pnp->pr_index] == vp)
5612 dpnp->pr_files[pnp->pr_index] = NULL;
5616 pnp->pr_parent = NULL;
5624 if (pnp->pr_pidfile != NULL) {
5626 ovp = pnp->pr_pidfile;
5629 pnp->pr_pidfile = NULL;
5646 if ((slot = pnp->pr_common->prc_tslot) != -1) {
5662 if (type == PR_CT && pnp->pr_contract != NULL) {
5663 contract_rele(pnp->pr_contract);
5664 pnp->pr_contract = NULL;
5669 prfreenode(pnp);
5694 prreadlink_lookup(prnode_t *pnp, char *buf, size_t size, cred_t *cr)
5711 ret = vnodetopath(vrootp, pnp->pr_realvp, buf, size, cr);
5718 if ((pnp->pr_flags & PR_AOUT) == 0) {
5728 if (prlock(pnp, ZNO) != 0) {
5733 p = pnp->pr_common->prc_proc;
5745 prunlock(pnp);
5764 prunlock(pnp);
5770 &vp, pnp->pr_realvp) == 0) {
5782 prunlock(pnp);
5792 if ((ret = dirfindvp(vrootp, pnp->pr_realvp, execvp, cr, dbuf,
5811 prnode_t *pnp = VTOP(vp);
5818 switch (pnp->pr_type) {
5827 if (pnp->pr_realvp->v_type == VDIR)
5833 if ((ret = prreadlink_lookup(pnp, buf, MAXPATHLEN, cr)) == 0)
5839 ASSERT(pnp->pr_contract != NULL);
5840 ct = pnp->pr_contract;
5914 prnode_t *pnp = VTOP(vp);
5915 prcommon_t *pcp = pnp->pr_common;
5922 ASSERT(pnp->pr_type < PR_NFILES);
5927 if (pnp->pr_pidfile != NULL) {
5928 vp = pnp->pr_pidfile;
5929 pnp = VTOP(vp);
5930 ASSERT(pnp->pr_type == PR_PIDFILE);
5931 ASSERT(pnp->pr_common == pcp);
5948 if ((error = prlock(pnp, ZNO)) != 0) {