/* * dproc.c -- Darwin process access functions for libproc-based lsof */ /* * Portions Copyright 2005-2007 Apple Inc. All rights reserved. * * Copyright 2005 Purdue Research Foundation, West Lafayette, Indiana * 47907. All rights reserved. * * Written by Allan Nathanson, Apple Inc., and Victor A. Abell, Purdue * University. * * This software is not subject to any license of the American Telephone * and Telegraph Company or the Regents of the University of California. * * Permission is granted to anyone to use this software for any purpose on * any computer system, and to alter it and redistribute it freely, subject * to the following restrictions: * * 1. Neither the authors, nor Apple Inc. nor Purdue University are * responsible for any consequences of the use of this software. * * 2. The origin of this software must not be misrepresented, either * by explicit claim or by omission. Credit to the authors, Apple * Inc. and Purdue University must appear in documentation and sources. * and sources. * * 3. Altered versions must be plainly marked as such, and must not be * misrepresented as being the original software. * * 4. This notice may not be removed or altered. */ #ifndef lint static char copyright[] = "@(#) Copyright 2005-2007 Apple Inc. and Purdue Research Foundation.\nAll rights reserved.\n"; static char *rcsid = "$Id: dproc.c,v 1.7 2011/08/07 22:52:30 abe Exp $"; #endif #include "lsof.h" /* * Local definitions */ #define PIDS_INCR (sizeof(int) * 32) /* PID space increment */ #define VIPS_INCR 16 /* Vips space increment */ #if DARWINV>=900 #define THREADS_INCR (sizeof(uint64_t) * 32) /* Threads space increment */ #endif /* DARWINV>=900 */ /* * Local static variables */ static struct proc_fdinfo *Fds = (struct proc_fdinfo *)NULL; /* FD buffer */ static int NbPids = 0; /* bytes allocated to Pids */ static int NbFds = 0; /* bytes allocated to FDs */ static int *Pids = (int *)NULL; /* PID buffer */ #if DARWINV>=900 static int NbThreads = 0; /* Threads bytes allocated */ static uint64_t *Threads = (uint64_t *)NULL; /* Thread buffer */ #endif /* DARWINV>=900 */ /* * Local structure definitions */ static struct vips_info { dev_t dev; ino_t ino; } *Vips = (struct vips_info *)NULL; /* recorded vnodes */ static int NbVips = 0; /* bytes allocated to Vips */ static int NVips = 0; /* entries allocated to Vips */ /* * Local function prototypes */ _PROTOTYPE(static void enter_vn_text,(struct vnode_info_path *vip, int *n)); _PROTOTYPE(static void process_fds,(int pid, uint32_t n, int ckscko)); _PROTOTYPE(static void process_text,(int pid)); #if DARWINV>=900 _PROTOTYPE(static void process_threads,(int pid, uint32_t n)); #endif /* DARWINV>=900 */ /* * enter_vn_text() -- enter vnode information text reference */ static void enter_vn_text(vip, n) struct vnode_info_path *vip; /* vnode info */ int *n; /* number of vips[] entries in use */ { int i; /* * Ignore the request if the vnode information has already been entered. */ for (i = 0; i < *n; i++) { if ((vip->vip_vi.vi_stat.vst_dev == Vips[i].dev) && (vip->vip_vi.vi_stat.vst_ino == Vips[i].ino)) { return; } } /* * Save the text file information. */ alloc_lfile(" txt", -1); Cfp = (struct file *)NULL; (void) enter_vnode_info(vip); if (Lf->sf) link_lfile(); /* * Record the entry of the vnode information. */ if (i >= NVips) { /* * Allocate space for recording the vnode information. */ NVips += VIPS_INCR; NbVips += (int)(VIPS_INCR * sizeof(struct vips_info)); if (!Vips) Vips = (struct vips_info *)malloc((MALLOC_S)NbVips); else Vips = (struct vips_info *)realloc((MALLOC_P *)Vips, (MALLOC_S)NbVips); if (!Vips) { (void) fprintf(stderr, "%s: PID %d: no text recording space\n", Pn, Lp->pid); Exit(1); } } /* * Record the vnode information. */ Vips[*n].dev = vip->vip_vi.vi_stat.vst_dev; Vips[*n].ino = vip->vip_vi.vi_stat.vst_ino; (*n)++; } /* * gather_proc_info() -- gather process information */ void gather_proc_info() { short cckreg; /* conditional status of regular file * checking: * 0 = unconditionally check * 1 = conditionally check */ short ckscko; /* socket file only checking status: * 0 = none * 1 = check only socket files, * including TCP and UDP * streams with eXPORT data, * where supported */ int cre, cres, ef, i, nb, np, pid; short pss, sf; struct proc_taskallinfo tai; struct proc_vnodepathinfo vpi; /* * Define socket and regular file conditional processing flags. * * If only socket files have been selected, or socket files have been * selected, ANDed with other selection options, enable the skipping of * regular files. * * If socket files and some process options have been selected, enable * conditional skipping of regular file; i.e., regular files will be skipped * unless they belong to a process selected by one of the specified options. */ if (Selflags & SELNW) { /* * Some network files selection options have been specified. */ if (Fand || !(Selflags & ~SELNW)) { /* * Selection ANDing or only network file options have been * specified, so set unconditional skipping of regular files * and socket file only checking. */ cckreg = 0; ckscko = 1; } else { /* * If ORed file selection options have been specified, or no * ORed process selection options have been specified, enable * unconditional file checking and clear socket file only * checking. * * If only ORed process selection options have been specified, * enable conditional file skipping and socket file only checking. */ if ((Selflags & SELFILE) || !(Selflags & SELPROC)) cckreg = ckscko = 0; else cckreg = ckscko = 1; } } else { /* * No network file selection options were specified. Enable * unconditional file checking and clear socket file only checking. */ cckreg = ckscko = 0; } /* * Determine how many bytes are needed to contain the PIDs on the system; * make sure sufficient buffer space is allocated to hold them (and a few * extra); then read the list of PIDs. */ if ((nb = proc_listpids(PROC_ALL_PIDS, 0, NULL, 0)) <= 0) { (void) fprintf(stderr, "%s: can't get PID byte count: %s\n", Pn, strerror(errno)); Exit(1); } if (nb > NbPids) { while (nb > NbPids) { NbPids += PIDS_INCR; } if (!Pids) Pids = (int *)malloc((MALLOC_S)NbPids); else Pids = (int *)realloc((MALLOC_P *)Pids, (MALLOC_S)NbPids); if (!Pids) { (void) fprintf(stderr, "%s: can't allocate space for %d PIDs\n", Pn, (int)(NbPids / sizeof(int *))); Exit(1); } } /* * Get the list of PIDs. */ for (ef = 0; !ef;) { if ((nb = proc_listpids(PROC_ALL_PIDS, 0, Pids, NbPids)) <= 0) { (void) fprintf(stderr, "%s: can't get list of PIDs: %s\n", Pn, strerror(errno)); Exit(1); } if ((nb + sizeof(int)) < NbPids) { /* * There is room in the buffer for at least one more PID. */ np = nb / sizeof(int); ef = 1; } else { /* * The PID buffer must be enlarged. */ NbPids += PIDS_INCR; Pids = (int *)realloc((MALLOC_P *)Pids, (MALLOC_S)NbPids); if (!Pids) { (void) fprintf(stderr, "%s: can't allocate space for %d PIDs\n", Pn, (int)(NbPids / sizeof(int *))); Exit(1); } } } /* * Loop through the identified processes. */ for (i = 0; i < np; i++) { if (!(pid = Pids[i])) continue; nb = proc_pidinfo(pid, PROC_PIDTASKALLINFO, 0, &tai, sizeof(tai)); if (nb <= 0) { if ((errno == EPERM) || (errno == ESRCH)) continue; if (!Fwarn) { (void) fprintf(stderr, "%s: PID %d information error: %s\n", Pn, pid, strerror(errno)); } continue; } else if (nb < sizeof(tai)) { (void) fprintf(stderr, "%s: PID %d: proc_pidinfo(PROC_PIDTASKALLINFO);\n", Pn, pid); (void) fprintf(stderr, " too few bytes; expected %ld, got %d\n", sizeof(tai), nb); Exit(1); } /* * Check for process or command exclusion. */ if (is_proc_excl((int)pid, (int)tai.pbsd.pbi_rgid, (UID_ARG)tai.pbsd.pbi_uid, &pss, &sf)) { continue; } tai.pbsd.pbi_comm[sizeof(tai.pbsd.pbi_comm) - 1] = '\0'; if (is_cmd_excl(tai.pbsd.pbi_comm, &pss, &sf)) continue; if (tai.pbsd.pbi_name[0]) { tai.pbsd.pbi_name[sizeof(tai.pbsd.pbi_name) - 1] = '\0'; if (is_cmd_excl(tai.pbsd.pbi_name, &pss, &sf)) continue; } if (cckreg) { /* * If conditional checking of regular files is enabled, enable * socket file only checking, based on the process' selection * status. */ ckscko = (sf & SELPROC) ? 0 : 1; } /* * Get root and current directory information. */ if (!ckscko) { nb = proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof(vpi)); if (nb <= 0) { cre = errno; cres = 1; } else if (nb < sizeof(vpi)) { (void) fprintf(stderr, "%s: PID %d: proc_pidinfo(PROC_PIDVNODEPATHINFO);\n", Pn, pid); (void) fprintf(stderr, " too few bytes; expected %ld, got %d\n", sizeof(vpi), nb); Exit(1); } else cres = 0; } /* * Allocate local process space. */ alloc_lproc((int)pid, (int)tai.pbsd.pbi_rgid, (int)tai.pbsd.pbi_ppid, (UID_ARG)tai.pbsd.pbi_uid, (tai.pbsd.pbi_name[0] != '\0') ? tai.pbsd.pbi_name : tai.pbsd.pbi_comm, (int)pss, (int)sf); Plf = (struct lfile *)NULL; /* * Save current working directory information. */ if (!ckscko) { if (cres || vpi.pvi_cdir.vip_path[0]) { alloc_lfile(CWD, -1); Cfp = (struct file *)NULL; if (cres) { /* * If the CWD|RTD information access error is ESRCH, * ignore it; otherwise report the error's message in the * CWD's NAME column. */ if (cre != ESRCH) { (void) snpf(Namech, Namechl, "%s|%s info error: %s", CWD + 1, RTD + 1, strerror(cre)); Namech[Namechl - 1] = '\0'; enter_nm(Namech); if (Lf->sf) link_lfile(); } } else { (void) enter_vnode_info(&vpi.pvi_cdir); if (Lf->sf) link_lfile(); } } } /* * Save root directory information. */ if (!ckscko) { if (!cres && vpi.pvi_rdir.vip_path[0]) { alloc_lfile(RTD, -1); Cfp = (struct file *)NULL; (void) enter_vnode_info(&vpi.pvi_rdir); if (Lf->sf) link_lfile(); } } #if DARWINV>=900 /* * Check for per-thread current working directories */ if (!ckscko) { if (tai.pbsd.pbi_flags & PROC_FLAG_THCWD) { (void) process_threads(pid, tai.ptinfo.pti_threadnum); } } #endif /* DARWINV>=900 */ /* * Print text file information. */ if (!ckscko) (void) process_text(pid); /* * Loop through the file descriptors. */ (void) process_fds(pid, tai.pbsd.pbi_nfiles, ckscko); /* * Examine results. */ if (examine_lproc()) return; } } /* * initialize() -- perform all initialization */ void initialize() { } /* * process_fds() -- process file descriptors */ static void process_fds(pid, n, ckscko) int pid; /* PID of interest */ uint32_t n; /* max FDs */ int ckscko; /* check socket files only */ { int i, isock, nb, nf; struct proc_fdinfo *fdp; /* * Make sure an FD buffer has been allocated. */ if (!Fds) { NbFds = sizeof(struct proc_fdinfo) * n; Fds = (struct proc_fdinfo *)malloc((MALLOC_S)NbFds); } else if (NbFds < sizeof(struct proc_fdinfo) * n) { /* * More proc_fdinfo space is required. Allocate it. */ NbFds = sizeof(struct proc_fdinfo) * n; Fds = (struct proc_fdinfo *)realloc((MALLOC_P *)Fds, (MALLOC_S)NbFds); } if (!Fds) { (void) fprintf(stderr, "%s: PID %d: can't allocate space for %d FDs\n", Pn, pid, (int)(NbFds / sizeof(struct proc_fdinfo))); Exit(1); } /* * Get FD information for the process. */ nb = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, Fds, NbFds); if (nb <= 0) { if (errno == ESRCH) { /* * Quit if no FD information is available for the process. */ return; } /* * Make a dummy file entry with an error message in its NAME column. */ alloc_lfile(" err", -1); (void) snpf(Namech, Namechl, "FD info error: %s", strerror(errno)); Namech[Namechl - 1] = '\0'; enter_nm(Namech); if (Lf->sf) link_lfile(); return; } nf = (int)(nb / sizeof(struct proc_fdinfo)); /* * Loop through the file descriptors. */ for (i = 0; i < nf; i++) { fdp = &Fds[i]; alloc_lfile(NULL, (int)fdp->proc_fd); /* * Process the file by its type. */ isock = 0; switch (fdp->proc_fdtype) { case PROX_FDTYPE_ATALK: if (!ckscko) (void) process_atalk(pid, fdp->proc_fd); break; case PROX_FDTYPE_FSEVENTS: if (!ckscko) (void) process_fsevents(pid, fdp->proc_fd); break; case PROX_FDTYPE_KQUEUE: if (!ckscko) (void) process_kqueue(pid, fdp->proc_fd); break; case PROX_FDTYPE_PIPE: if (!ckscko) (void) process_pipe(pid, fdp->proc_fd); break; case PROX_FDTYPE_PSEM: if (!ckscko) (void) process_psem(pid, fdp->proc_fd); break; case PROX_FDTYPE_SOCKET: (void) process_socket(pid, fdp->proc_fd); isock = 1; break; case PROX_FDTYPE_PSHM: (void) process_pshm(pid, fdp->proc_fd); break; case PROX_FDTYPE_VNODE: (void) process_vnode(pid, fdp->proc_fd); break; default: (void) snpf(Namech, Namechl - 1, "unknown file type: %d", fdp->proc_fdtype); Namech[Namechl - 1] = '\0'; (void) enter_nm(Namech); break; } if (Lf->sf) { if (!ckscko || isock) link_lfile(); } } } /* * process_text() -- process text information */ static void process_text(pid) int pid; /* PID */ { uint64_t a; int i, n, nb; struct proc_regionwithpathinfo rwpi; for (a = (uint64_t)0, i = n = 0; i < 10000; i++) { nb = proc_pidinfo(pid, PROC_PIDREGIONPATHINFO, a, &rwpi, sizeof(rwpi)); if (nb <= 0) { if ((errno == ESRCH) || (errno == EINVAL)) { /* * Quit if no more text information is available for the * process. */ return; } /* * Warn about all other errors via a NAME column message. */ alloc_lfile(" txt", -1); Cfp = (struct file *)NULL; (void) snpf(Namech, Namechl, "region info error: %s", strerror(errno)); Namech[Namechl - 1] = '\0'; enter_nm(Namech); if (Lf->sf) link_lfile(); return; } else if (nb < sizeof(rwpi)) { (void) fprintf(stderr, "%s: PID %d: proc_pidinfo(PROC_PIDREGIONPATHINFO);\n", Pn, pid); (void) fprintf(stderr, " too few bytes; expected %ld, got %d\n", sizeof(rwpi), nb); Exit(1); } if (rwpi.prp_vip.vip_path[0]) enter_vn_text(&rwpi.prp_vip, &n); a = rwpi.prp_prinfo.pri_address + rwpi.prp_prinfo.pri_size; } } #if DARWINV>=900 /* * process_threads() -- process thread information */ #define TWD " twd" /* per-thread current working directory * fd name */ static void process_threads(pid, n) int pid; /* PID */ uint32_t n; /* number of threads */ { int i, nb, nt; /* * Make sure a thread buffer has been allocated. */ n += 10; if (n > NbThreads) { while (n > NbThreads) { NbThreads += THREADS_INCR; } if (!Threads) Threads = (uint64_t *)malloc((MALLOC_S)NbThreads); else Threads = (uint64_t *)realloc((MALLOC_P *)Threads, (MALLOC_S)NbThreads); if (!Threads) { (void) fprintf(stderr, "%s: can't allocate space for %d Threads\n", Pn, (int)(NbThreads / sizeof(int *))); Exit(1); } } /* * Get thread information for the process. */ nb = proc_pidinfo(pid, PROC_PIDLISTTHREADS, 0, Threads, NbThreads); if (nb <= 0) { if (errno == ESRCH) { /* * Quit if no thread information is available for the * process. */ return; } } nt = (int)(nb / sizeof(uint64_t)); /* * Loop through the threads. */ for (i = 0; i < nt; i++) { uint64_t t; struct proc_threadwithpathinfo tpi; t = Threads[i]; nb = proc_pidinfo(pid, PROC_PIDTHREADPATHINFO, t, &tpi, sizeof(tpi)); if (nb <= 0) { if ((errno == ESRCH) || (errno == EINVAL)) { /* * Quit if no more thread information is available for the * process. */ return; } /* * Warn about all other errors via a NAME column message. */ alloc_lfile(TWD, -1); Cfp = (struct file *)NULL; (void) snpf(Namech, Namechl, "thread info error: %s", strerror(errno)); Namech[Namechl - 1] = '\0'; enter_nm(Namech); if (Lf->sf) link_lfile(); return; } else if (nb < sizeof(tpi)) { (void) fprintf(stderr, "%s: PID %d: proc_pidinfo(PROC_PIDTHREADPATHINFO);\n", Pn, pid); (void) fprintf(stderr, " too few bytes; expected %ld, got %d\n", sizeof(tpi), nb); Exit(1); } if (tpi.pvip.vip_path[0]) { alloc_lfile(TWD, -1); Cfp = (struct file *)NULL; (void) enter_vnode_info(&tpi.pvip); if (Lf->sf) link_lfile(); } } } #endif /* DARWINV>=900 */