Lines Matching +full:entry +full:- +full:method
1 /*-
2 * SPDX-License-Identifier: BSD-4-Clause
185 if (procstat->type == PROCSTAT_KVM)
186 kvm_close(procstat->kd);
187 else if (procstat->type == PROCSTAT_CORE)
188 procstat_core_close(procstat->core);
204 procstat->type = PROCSTAT_SYSCTL;
226 procstat->type = PROCSTAT_KVM;
227 procstat->kd = kd;
247 procstat->type = PROCSTAT_CORE;
248 procstat->core = core;
265 if (procstat->type == PROCSTAT_KVM) {
267 p0 = kvm_getprocs(procstat->kd, what, arg, &cnt);
279 } else if (procstat->type == PROCSTAT_SYSCTL) {
309 if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
315 } else if (procstat->type == PROCSTAT_CORE) {
316 p = procstat_core_get(procstat->core, PSC_TYPE_PROC, NULL,
318 if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
325 warnx("unknown access method: %d", procstat->type);
347 switch (procstat->type) {
354 warnx("unknown access method: %d", procstat->type);
365 if (fst->fs_path != NULL)
366 free(fst->fs_path);
370 if (procstat->vmentries != NULL) {
371 free(procstat->vmentries);
372 procstat->vmentries = NULL;
374 if (procstat->files != NULL) {
375 free(procstat->files);
376 procstat->files = NULL;
384 struct filestat *entry;
386 entry = calloc(1, sizeof(*entry));
387 if (entry == NULL) {
391 entry->fs_typedep = typedep;
392 entry->fs_fflags = fflags;
393 entry->fs_uflags = uflags;
394 entry->fs_fd = fd;
395 entry->fs_type = type;
396 entry->fs_ref_count = refcount;
397 entry->fs_offset = offset;
398 entry->fs_path = path;
400 entry->fs_cap_rights = *cap_rightsp;
402 cap_rights_init(&entry->fs_cap_rights);
403 return (entry);
415 error = kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
419 kp->ki_paddr, kp->ki_pid);
428 proc.p_pgrp, kp->ki_pid);
435 pgrp.pg_session, kp->ki_pid);
465 struct filestat *entry;
477 kd = procstat->kd;
480 if (kp->ki_fd == NULL || kp->ki_pd == NULL)
482 if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &filed,
484 warnx("can't read filedesc at %p", (void *)kp->ki_fd);
487 if (!kvm_read_all(kd, (unsigned long)kp->ki_pd, &pathsd,
489 warnx("can't read pwddesc at %p", (void *)kp->ki_pd);
513 entry = filestat_new_entry(pwd.pwd_rdir, PS_FST_TYPE_VNODE, -1,
515 if (entry != NULL)
516 STAILQ_INSERT_TAIL(head, entry, next);
520 entry = filestat_new_entry(pwd.pwd_cdir, PS_FST_TYPE_VNODE, -1,
522 if (entry != NULL)
523 STAILQ_INSERT_TAIL(head, entry, next);
527 entry = filestat_new_entry(pwd.pwd_jdir, PS_FST_TYPE_VNODE, -1,
529 if (entry != NULL)
530 STAILQ_INSERT_TAIL(head, entry, next);
534 if (kp->ki_tracep) {
535 entry = filestat_new_entry(kp->ki_tracep, PS_FST_TYPE_VNODE, -1,
538 if (entry != NULL)
539 STAILQ_INSERT_TAIL(head, entry, next);
542 if (kp->ki_textvp) {
543 entry = filestat_new_entry(kp->ki_textvp, PS_FST_TYPE_VNODE, -1,
545 if (entry != NULL)
546 STAILQ_INSERT_TAIL(head, entry, next);
550 entry = filestat_new_entry(vp, PS_FST_TYPE_VNODE, -1,
553 if (entry != NULL)
554 STAILQ_INSERT_TAIL(head, entry, next);
575 if (fdt->fdt_ofiles[i].fde_file == NULL) {
578 if (!kvm_read_all(kd, (unsigned long)fdt->fdt_ofiles[i].fde_file, &file,
581 (void *)fdt->fdt_ofiles[i].fde_file);
631 entry = filestat_new_entry(data, type, i,
633 if (entry != NULL)
634 STAILQ_INSERT_TAIL(head, entry, next);
644 if (!kvm_read_all(kd, (unsigned long)kp->ki_vmspace, &vmspace,
647 (void *)kp->ki_vmspace);
653 entryp != NULL && entryp != &kp->ki_vmspace->vm_map.header;
681 * Create filestat entry.
683 entry = filestat_new_entry(object.handle,
684 PS_FST_TYPE_VNODE, -1, fflags,
686 if (entry != NULL)
687 STAILQ_INSERT_TAIL(head, entry, next);
815 if (kf->kf_structsize == 0)
817 bp += kf->kf_structsize;
832 if (kf->kf_structsize == 0)
834 /* Copy/expand into pre-zeroed buffer */
835 memcpy(kp, kf, kf->kf_structsize);
837 bp += kf->kf_structsize;
839 kp->kf_structsize = sizeof(*kp);
854 struct filestat *entry;
863 switch (procstat->type) {
865 files = kinfo_getfile(kp->ki_pid, &cnt);
868 files = kinfo_getfile_core(procstat->core, &cnt);
877 procstat->files = files;
889 type = kinfo_type2fst(kif->kf_type);
890 fd = kif->kf_fd >= 0 ? kif->kf_fd : -1;
891 fflags = kinfo_fflags2fst(kif->kf_flags);
892 uflags = kinfo_uflags2fst(kif->kf_fd);
893 refcount = kif->kf_ref_count;
894 offset = kif->kf_offset;
895 if (*kif->kf_path != '\0')
896 path = strdup(kif->kf_path);
899 cap_rights = kif->kf_cap_rights;
902 * Create filestat entry.
904 entry = filestat_new_entry(kif, type, fd, fflags, uflags,
906 if (entry != NULL)
907 STAILQ_INSERT_TAIL(head, entry, next);
911 procstat->vmentries = vmentries;
916 if (kve->kve_type != KVME_TYPE_VNODE)
919 if (kve->kve_protection & KVME_PROT_READ)
921 if ((kve->kve_flags & KVME_FLAG_COW) == 0 &&
922 kve->kve_protection & KVME_PROT_WRITE)
924 offset = kve->kve_offset;
925 refcount = kve->kve_ref_count;
926 if (*kve->kve_path != '\0')
927 path = strdup(kve->kve_path);
930 entry = filestat_new_entry(kve, PS_FST_TYPE_VNODE, -1,
933 if (entry != NULL)
934 STAILQ_INSERT_TAIL(head, entry, next);
947 if (procstat->type == PROCSTAT_KVM) {
948 return (procstat_get_pipe_info_kvm(procstat->kd, fst, ps,
950 } else if (procstat->type == PROCSTAT_SYSCTL ||
951 procstat->type == PROCSTAT_CORE) {
954 warnx("unknown access method: %d", procstat->type);
972 pipep = fst->fs_typedep;
979 ps->addr = (uintptr_t)pipep;
980 ps->peer = (uintptr_t)pi.pipe_peer;
981 ps->buffer_cnt = pi.pipe_buffer.cnt;
999 kif = fst->fs_typedep;
1002 ps->addr = kif->kf_un.kf_pipe.kf_pipe_addr;
1003 ps->peer = kif->kf_un.kf_pipe.kf_pipe_peer;
1004 ps->buffer_cnt = kif->kf_un.kf_pipe.kf_pipe_buffer_cnt;
1014 if (procstat->type == PROCSTAT_KVM) {
1015 return (procstat_get_pts_info_kvm(procstat->kd, fst, pts,
1017 } else if (procstat->type == PROCSTAT_SYSCTL ||
1018 procstat->type == PROCSTAT_CORE) {
1021 warnx("unknown access method: %d", procstat->type);
1039 ttyp = fst->fs_typedep;
1046 pts->dev = dev2udev(kd, tty.t_dev);
1047 (void)kdevtoname(kd, tty.t_dev, pts->devname);
1065 kif = fst->fs_typedep;
1068 pts->dev = kif->kf_un.kf_pts.kf_pts_dev;
1069 strlcpy(pts->devname, kif->kf_path, sizeof(pts->devname));
1079 if (procstat->type == PROCSTAT_KVM) {
1080 return (procstat_get_sem_info_kvm(procstat->kd, fst, sem,
1082 } else if (procstat->type == PROCSTAT_SYSCTL ||
1083 procstat->type == PROCSTAT_CORE) {
1086 warnx("unknown access method: %d", procstat->type);
1106 ksemp = fst->fs_typedep;
1114 sem->mode = S_IFREG | ksem.ks_mode;
1115 sem->value = ksem.ks_value;
1116 if (fst->fs_path == NULL && ksem.ks_path != NULL) {
1118 for (i = 0; i < MAXPATHLEN - 1; i++) {
1129 fst->fs_path = path;
1148 kif = fst->fs_typedep;
1151 sem->value = kif->kf_un.kf_sem.kf_sem_value;
1152 sem->mode = kif->kf_un.kf_sem.kf_sem_mode;
1162 if (procstat->type == PROCSTAT_KVM) {
1163 return (procstat_get_shm_info_kvm(procstat->kd, fst, shm,
1165 } else if (procstat->type == PROCSTAT_SYSCTL ||
1166 procstat->type == PROCSTAT_CORE) {
1169 warnx("unknown access method: %d", procstat->type);
1189 shmfdp = fst->fs_typedep;
1197 shm->mode = S_IFREG | shmfd.shm_mode;
1198 shm->size = shmfd.shm_size;
1199 if (fst->fs_path == NULL && shmfd.shm_path != NULL) {
1201 for (i = 0; i < MAXPATHLEN - 1; i++) {
1212 fst->fs_path = path;
1231 kif = fst->fs_typedep;
1234 shm->size = kif->kf_un.kf_file.kf_file_size;
1235 shm->mode = kif->kf_un.kf_file.kf_file_mode;
1245 if (procstat->type == PROCSTAT_KVM) {
1246 return (procstat_get_vnode_info_kvm(procstat->kd, fst, vn,
1248 } else if (procstat->type == PROCSTAT_SYSCTL ||
1249 procstat->type == PROCSTAT_CORE) {
1252 warnx("unknown access method: %d", procstat->type);
1291 vp = fst->fs_typedep;
1300 vn->vn_type = vntype2psfsttype(vnode.v_type);
1309 tagstr[sizeof(tagstr) - 1] = '\0';
1326 vn->vn_mntdir = getmnton(kd, vnode.v_mount);
1329 vn->vn_dev = dev2udev(kd, vnode.v_rdev);
1330 (void)kdevtoname(kd, vnode.v_rdev, vn->vn_devname);
1332 vn->vn_dev = -1;
1392 if (fst->fs_typedep == NULL)
1394 if (fst->fs_uflags & PS_FST_UFLAG_MMAP) {
1395 kve = fst->fs_typedep;
1396 fileid = kve->kve_vn_fileid;
1397 fsid = kve->kve_vn_fsid;
1398 mode = kve->kve_vn_mode;
1399 path = kve->kve_path;
1400 rdev = kve->kve_vn_rdev;
1401 size = kve->kve_vn_size;
1402 vntype = kinfo_vtype2fst(kve->kve_vn_type);
1403 status = kve->kve_status;
1405 kif = fst->fs_typedep;
1406 fileid = kif->kf_un.kf_file.kf_file_fileid;
1407 fsid = kif->kf_un.kf_file.kf_file_fsid;
1408 mode = kif->kf_un.kf_file.kf_file_mode;
1409 path = kif->kf_path;
1410 rdev = kif->kf_un.kf_file.kf_file_rdev;
1411 size = kif->kf_un.kf_file.kf_file_size;
1412 vntype = kinfo_vtype2fst(kif->kf_vnode_type);
1413 status = kif->kf_status;
1415 vn->vn_type = vntype;
1427 vn->vn_mntdir = strdup(stbuf.f_mntonname);
1429 vn->vn_mntdir = strdup("-");
1430 vn->vn_dev = rdev;
1434 strlcpy(vn->vn_devname, name,
1435 sizeof(vn->vn_devname));
1437 name = devname(vn->vn_dev, S_IFCHR);
1439 strlcpy(vn->vn_devname, name,
1440 sizeof(vn->vn_devname));
1442 vn->vn_fsid = fsid;
1443 vn->vn_fileid = fileid;
1444 vn->vn_size = size;
1445 vn->vn_mode = mode;
1455 if (procstat->type == PROCSTAT_KVM) {
1456 return (procstat_get_socket_info_kvm(procstat->kd, fst, sock,
1458 } else if (procstat->type == PROCSTAT_SYSCTL ||
1459 procstat->type == PROCSTAT_CORE) {
1462 warnx("unknown access method: %d", procstat->type);
1484 so = fst->fs_typedep;
1487 sock->so_addr = (uintptr_t)so;
1494 /* fill in protosw entry */
1507 if ((len = kvm_read(kd, (unsigned long)dom.dom_name, sock->dname,
1508 sizeof(sock->dname) - 1)) < 0) {
1510 sock->dname[0] = '\0';
1513 sock->dname[len] = '\0';
1518 sock->type = s.so_type;
1519 sock->proto = proto.pr_protocol;
1520 sock->dom_family = dom.dom_family;
1521 sock->so_pcb = (uintptr_t)s.so_pcb;
1522 sock->sendq = s.so_snd.sb_ccc;
1523 sock->recvq = s.so_rcv.sb_ccc;
1524 sock->so_rcv_sb_state = s.so_rcv.sb_state;
1525 sock->so_snd_sb_state = s.so_snd.sb_state;
1538 sock->unp_conn = (uintptr_t)unpcb.unp_conn;
1562 kif = fst->fs_typedep;
1569 sock->type = kif->kf_sock_type;
1570 sock->proto = kif->kf_sock_protocol;
1571 sock->dom_family = kif->kf_sock_domain;
1572 sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
1573 strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
1574 bcopy(&kif->kf_un.kf_sock.kf_sa_local, &sock->sa_local,
1575 kif->kf_un.kf_sock.kf_sa_local.ss_len);
1576 bcopy(&kif->kf_un.kf_sock.kf_sa_peer, &sock->sa_peer,
1577 kif->kf_un.kf_sock.kf_sa_peer.ss_len);
1582 switch (sock->dom_family) {
1585 if (sock->proto == IPPROTO_TCP) {
1586 sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
1587 sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
1591 if (kif->kf_un.kf_sock.kf_sock_unpconn != 0) {
1592 sock->so_rcv_sb_state =
1593 kif->kf_un.kf_sock.kf_sock_rcv_sb_state;
1594 sock->so_snd_sb_state =
1595 kif->kf_un.kf_sock.kf_sock_snd_sb_state;
1596 sock->unp_conn =
1597 kif->kf_un.kf_sock.kf_sock_unpconn;
1598 sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
1599 sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
1688 for (mt = mhead; mt != NULL; mt = mt->next)
1689 if (m == mt->m)
1690 return (mt->mntonname);
1697 mt->m = m;
1698 bcopy(&mnt.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
1699 mt->mntonname[MNAMELEN] = '\0';
1700 mt->next = mhead;
1702 return (mt->mntonname);
1724 av->bufsize = bufsize;
1725 av->buf = malloc(av->bufsize);
1726 if (av->buf == NULL) {
1730 av->argc = 32;
1731 av->argv = malloc(sizeof(char *) * av->argc);
1732 if (av->argv == NULL) {
1733 free(av->buf);
1744 free(av->argv);
1745 free(av->buf);
1760 if (procstat->type == PROCSTAT_KVM) {
1761 warnx("can't use kvm access method");
1764 if (procstat->type != PROCSTAT_SYSCTL &&
1765 procstat->type != PROCSTAT_CORE) {
1766 warnx("unknown access method: %d", procstat->type);
1773 avp = (struct argvec **)(env ? &procstat->argv : &procstat->envv);
1785 } else if (av->bufsize < nchr) {
1786 av->buf = reallocf(av->buf, nchr);
1787 if (av->buf == NULL) {
1792 if (procstat->type == PROCSTAT_SYSCTL) {
1796 name[3] = kp->ki_pid;
1798 error = sysctl(name, nitems(name), av->buf, &len, NULL, 0);
1803 } else /* procstat->type == PROCSTAT_CORE */ {
1806 if (procstat_core_get(procstat->core, type, av->buf, &len)
1812 argv = av->argv;
1813 argc = av->argc;
1815 for (p = av->buf; p < av->buf + len; p += strlen(p) + 1) {
1826 av->argv = argv;
1827 av->argc = argc;
1851 if (procstat->argv != NULL) {
1852 argvec_free(procstat->argv);
1853 procstat->argv = NULL;
1873 if (procstat->envv != NULL) {
1874 argvec_free(procstat->envv);
1875 procstat->envv = NULL;
1905 if (kv->kve_structsize == 0)
1907 bp += kv->kve_structsize;
1922 if (kv->kve_structsize == 0)
1924 /* Copy/expand into pre-zeroed buffer */
1925 memcpy(kp, kv, kv->kve_structsize);
1927 bp += kv->kve_structsize;
1929 kp->kve_structsize = sizeof(*kp);
1942 switch (procstat->type) {
1944 warnx("kvm method is not supported");
1947 return (kinfo_getvmmap(kp->ki_pid, cntp));
1949 return (kinfo_getvmmap_core(procstat->core, cntp));
1951 warnx("unknown access method: %d", procstat->type);
1974 if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
1977 kp->ki_paddr, kp->ki_pid);
1985 proc.p_ucred, kp->ki_pid);
1996 ucred.cr_groups, kp->ki_pid);
2021 if (sysctl(mib, nitems(mib), groups, &len, NULL, 0) == -1) {
2047 switch (procstat->type) {
2049 return (procstat_getgroups_kvm(procstat->kd, kp, cntp));
2051 return (procstat_getgroups_sysctl(kp->ki_pid, cntp));
2053 return (procstat_getgroups_core(procstat->core, cntp));
2055 warnx("unknown access method: %d", procstat->type);
2074 if (kp->ki_pd == NULL)
2075 return (-1);
2076 if (!kvm_read_all(kd, (unsigned long)kp->ki_pd, &pd, sizeof(pd))) {
2077 warnx("can't read pwddesc at %p for pid %d", kp->ki_pd,
2078 kp->ki_pid);
2079 return (-1);
2111 return (-1);
2114 return (-1);
2125 switch (procstat->type) {
2127 return (procstat_getumask_kvm(procstat->kd, kp, maskp));
2129 return (procstat_getumask_sysctl(kp->ki_pid, maskp));
2131 return (procstat_getumask_core(procstat->core, maskp));
2133 warnx("unknown access method: %d", procstat->type);
2134 return (-1);
2148 if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
2151 kp->ki_paddr, kp->ki_pid);
2152 return (-1);
2155 return (-1);
2159 (void *)offset, kp->ki_pid);
2160 return (-1);
2180 return (-1);
2183 return (-1);
2197 return (-1);
2201 return (-1);
2204 return (-1);
2215 switch (procstat->type) {
2217 return (procstat_getrlimit_kvm(procstat->kd, kp, which,
2220 return (procstat_getrlimit_sysctl(kp->ki_pid, which, rlimit));
2222 return (procstat_getrlimit_core(procstat->core, which, rlimit));
2224 warnx("unknown access method: %d", procstat->type);
2225 return (-1);
2257 return (-1);
2258 result = -1;
2274 switch (procstat->type) {
2281 return (procstat_getpathname_sysctl(kp->ki_pid, pathname,
2284 return (procstat_getpathname_core(procstat->core, pathname,
2287 warnx("unknown access method: %d", procstat->type);
2288 return (-1);
2299 if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
2302 kp->ki_paddr, kp->ki_pid);
2303 return (-1);
2334 return (-1);
2337 return (-1);
2347 switch (procstat->type) {
2349 return (procstat_getosrel_kvm(procstat->kd, kp, osrelp));
2351 return (procstat_getosrel_sysctl(kp->ki_pid, osrelp));
2353 return (procstat_getosrel_core(procstat->core, osrelp));
2355 warnx("unknown access method: %d", procstat->type);
2356 return (-1);
2410 if (sysctl(name, nitems(name), auxv32, &len, NULL, 0) == -1) {
2423 * XXX: We expect that values for a_type on a 32-bit platform
2424 * are directly mapped to values on 64-bit one, which is not
2436 * type-aware.
2468 if (sysctl(name, nitems(name), auxv, &len, NULL, 0) == -1) {
2495 switch (procstat->type) {
2497 warnx("kvm method is not supported");
2500 return (procstat_getauxv_sysctl(kp->ki_pid, cntp));
2502 return (procstat_getauxv_core(procstat->core, cntp));
2504 warnx("unknown access method: %d", procstat->type);
2542 switch (procstat->type) {
2544 warnx("kvm method is not supported");
2547 warnx("sysctl method is not supported");
2550 return (procstat_getptlwpinfo_core(procstat->core, cntp));
2552 warnx("unknown access method: %d", procstat->type);
2582 if (error == -1 && errno == ENOENT) {
2587 if (error == -1)
2594 if (sysctl(name, nitems(name), kkstp, &len, NULL, 0) == -1 &&
2609 switch (procstat->type) {
2611 warnx("kvm method is not supported");
2614 return (procstat_getkstack_sysctl(kp->ki_pid, cntp));
2616 warnx("core method is not supported");
2619 warnx("unknown access method: %d", procstat->type);
2669 c += kl->kl_structsize) {
2671 if (sizeof(*kl) < (size_t)kl->kl_structsize) {
2680 switch (kl->kl_rw) {
2682 a->rw = PS_ADVLOCK_RO;
2685 a->rw = PS_ADVLOCK_RW;
2692 switch (kl->kl_type) {
2694 a->type = PS_ADVLOCK_TYPE_FLOCK;
2697 a->type = PS_ADVLOCK_TYPE_PID;
2700 a->type = PS_ADVLOCK_TYPE_REMOTE;
2707 a->pid = kl->kl_pid;
2708 a->sysid = kl->kl_sysid;
2709 a->file_fsid = kl->kl_file_fsid;
2710 a->file_rdev = kl->kl_file_rdev;
2711 a->file_fileid = kl->kl_file_fileid;
2712 a->start = kl->kl_start;
2713 a->len = kl->kl_len;
2714 if (kl->kl_path[0] != '\0') {
2715 a->path = strdup(kl->kl_path);
2716 if (a->path == NULL) {
2722 a->path = NULL;
2738 switch (procstat->type) {
2740 warnx("kvm method is not supported");
2745 warnx("core method is not supported");
2748 warnx("unknown access method: %d", procstat->type);
2760 free(__DECONST(char *, a->path));
2780 if (error == -1)
2787 if (error == -1) {
2799 switch (procstat->type) {
2801 warnx("kvm method is not supported");
2804 return (procstat_getrlimitusage_sysctl(kp->ki_pid, cntp));
2806 warnx("core method is not supported");
2809 warnx("unknown access method: %d", procstat->type);