1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2015, Joyent, Inc. 27 * Copyright 2024 Oxide Computer Company 28 */ 29 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <unistd.h> 33 #include <fcntl.h> 34 #include <string.h> 35 #include <limits.h> 36 #include <sys/secflags.h> 37 #include <errno.h> 38 39 #include "Pcontrol.h" 40 41 /* 42 * These several routines simply get the indicated /proc structures 43 * for a process identified by process ID. They are convenience 44 * functions for one-time operations. They do the mechanics of 45 * open() / read() / close() of the necessary /proc files so the 46 * caller's code can look relatively less cluttered. 47 */ 48 49 /* 50 * 'ngroups' is the number of supplementary group entries allocated in 51 * the caller's cred structure. It should equal zero or one unless extra 52 * space has been allocated for the group list by the caller, like this: 53 * credp = malloc(sizeof (prcred_t) + (ngroups - 1) * sizeof (gid_t)); 54 */ 55 int 56 proc_get_cred(pid_t pid, prcred_t *credp, int ngroups) 57 { 58 char fname[PATH_MAX]; 59 int fd; 60 int rv = -1; 61 ssize_t minsize = sizeof (*credp) - sizeof (gid_t); 62 size_t size = minsize + ngroups * sizeof (gid_t); 63 64 (void) snprintf(fname, sizeof (fname), "%s/%d/cred", 65 procfs_path, (int)pid); 66 if ((fd = open(fname, O_RDONLY)) >= 0) { 67 if (read(fd, credp, size) >= minsize) 68 rv = 0; 69 (void) close(fd); 70 } 71 return (rv); 72 } 73 74 int 75 proc_get_secflags(pid_t pid, prsecflags_t **psf) 76 { 77 char fname[PATH_MAX]; 78 int fd; 79 int rv = -1; 80 81 if ((*psf = calloc(1, sizeof (prsecflags_t))) == NULL) 82 return (-1); 83 84 (void) snprintf(fname, sizeof (fname), "%s/%d/secflags", 85 procfs_path, (int)pid); 86 if ((fd = open(fname, O_RDONLY)) >= 0) { 87 if (read(fd, *psf, sizeof (prsecflags_t)) == 88 sizeof (prsecflags_t)) 89 rv = 0; 90 (void) close(fd); 91 } 92 return (rv); 93 } 94 95 void 96 proc_free_priv(prpriv_t *prv) 97 { 98 free(prv); 99 } 100 101 /* 102 * Malloc and return a properly sized structure. 103 */ 104 prpriv_t * 105 proc_get_priv(pid_t pid) 106 { 107 char fname[PATH_MAX]; 108 int fd; 109 struct stat statb; 110 prpriv_t *rv = NULL; 111 112 (void) snprintf(fname, sizeof (fname), "%s/%d/priv", 113 procfs_path, (int)pid); 114 if ((fd = open(fname, O_RDONLY)) >= 0) { 115 if (fstat(fd, &statb) != 0 || 116 (rv = malloc(statb.st_size)) == NULL || 117 read(fd, rv, statb.st_size) != statb.st_size) { 118 free(rv); 119 rv = NULL; 120 } 121 (void) close(fd); 122 } 123 return (rv); 124 } 125 126 #if defined(__i386) || defined(__amd64) 127 /* 128 * Fill in a pointer to a process LDT structure. 129 * The caller provides a buffer of size 'nldt * sizeof (struct ssd)'; 130 * If pldt == NULL or nldt == 0, we return the number of existing LDT entries. 131 * Otherwise we return the actual number of LDT entries fetched (<= nldt). 132 */ 133 int 134 proc_get_ldt(pid_t pid, struct ssd *pldt, int nldt) 135 { 136 char fname[PATH_MAX]; 137 int fd; 138 struct stat statb; 139 size_t size; 140 ssize_t ssize; 141 142 (void) snprintf(fname, sizeof (fname), "%s/%d/ldt", 143 procfs_path, (int)pid); 144 if ((fd = open(fname, O_RDONLY)) < 0) 145 return (-1); 146 147 if (pldt == NULL || nldt == 0) { 148 nldt = 0; 149 if (fstat(fd, &statb) == 0) 150 nldt = statb.st_size / sizeof (struct ssd); 151 (void) close(fd); 152 return (nldt); 153 } 154 155 size = nldt * sizeof (struct ssd); 156 if ((ssize = read(fd, pldt, size)) < 0) 157 nldt = -1; 158 else 159 nldt = ssize / sizeof (struct ssd); 160 161 (void) close(fd); 162 return (nldt); 163 } 164 #endif /* __i386 || __amd64 */ 165 166 int 167 proc_get_psinfo(pid_t pid, psinfo_t *psp) 168 { 169 char fname[PATH_MAX]; 170 int fd; 171 int rv = -1; 172 173 (void) snprintf(fname, sizeof (fname), "%s/%d/psinfo", 174 procfs_path, (int)pid); 175 if ((fd = open(fname, O_RDONLY)) >= 0) { 176 if (read(fd, psp, sizeof (*psp)) == sizeof (*psp)) 177 rv = 0; 178 (void) close(fd); 179 } 180 return (rv); 181 } 182 183 int 184 proc_get_status(pid_t pid, pstatus_t *psp) 185 { 186 char fname[PATH_MAX]; 187 int fd; 188 int rv = -1; 189 190 (void) snprintf(fname, sizeof (fname), "%s/%d/status", 191 procfs_path, (int)pid); 192 if ((fd = open(fname, O_RDONLY)) >= 0) { 193 if (read(fd, psp, sizeof (*psp)) == sizeof (*psp)) 194 rv = 0; 195 (void) close(fd); 196 } 197 return (rv); 198 } 199 200 /* 201 * Get the process's aux vector. 202 * 'naux' is the number of aux entries in the caller's buffer. 203 * We return the number of aux entries actually fetched from 204 * the process (less than or equal to 'naux') or -1 on failure. 205 */ 206 int 207 proc_get_auxv(pid_t pid, auxv_t *pauxv, int naux) 208 { 209 char fname[PATH_MAX]; 210 int fd; 211 int rv = -1; 212 213 (void) snprintf(fname, sizeof (fname), "%s/%d/auxv", 214 procfs_path, (int)pid); 215 if ((fd = open(fname, O_RDONLY)) >= 0) { 216 if ((rv = read(fd, pauxv, naux * sizeof (auxv_t))) >= 0) 217 rv /= sizeof (auxv_t); 218 (void) close(fd); 219 } 220 return (rv); 221 } 222 223 int 224 proc_get_lwpsinfo(pid_t pid, uint_t thr, lwpsinfo_t *lwpip) 225 { 226 char fname[PATH_MAX]; 227 int fd; 228 int rv = -1; 229 230 (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%u/lwpsinfo", 231 procfs_path, (int)pid, thr); 232 if ((fd = open(fname, O_RDONLY)) >= 0) { 233 if (read(fd, lwpip, sizeof (*lwpip)) == sizeof (*lwpip)) 234 rv = 0; 235 (void) close(fd); 236 } 237 return (rv); 238 } 239 240 int 241 proc_get_lwpstatus(pid_t pid, uint_t thr, lwpstatus_t *lwp) 242 { 243 char fname[PATH_MAX]; 244 int fd; 245 int rv = -1; 246 247 (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%u/lwpstatus", 248 procfs_path, (int)pid, thr); 249 if ((fd = open(fname, O_RDONLY)) >= 0) { 250 if (read(fd, lwp, sizeof (*lwp)) == sizeof (*lwp)) 251 rv = 0; 252 (void) close(fd); 253 } 254 return (rv); 255 } 256 257 ssize_t 258 proc_get_cwd(pid_t pid, char *cwd, size_t len) 259 { 260 ssize_t ret; 261 char fname[PATH_MAX]; 262 263 if (len == 0) { 264 errno = EINVAL; 265 return (-1); 266 } 267 268 (void) snprintf(fname, sizeof (fname), "%s/%d/path/cwd", 269 procfs_path, (int)pid); 270 271 if ((ret = readlink(fname, cwd, len - 1)) > 0) 272 cwd[ret] = '\0'; 273 274 return (ret); 275 } 276