1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2013 Mikolaj Golub <trociny@FreeBSD.org> 5 * Copyright (c) 2017 Dell EMC 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/elf.h> 35 #include <sys/exec.h> 36 #include <sys/ptrace.h> 37 #include <sys/user.h> 38 39 #include <assert.h> 40 #include <err.h> 41 #include <fcntl.h> 42 #include <gelf.h> 43 #include <libelf.h> 44 #include <stdbool.h> 45 #include <stdint.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <unistd.h> 50 51 #include "core.h" 52 53 #define PROCSTAT_CORE_MAGIC 0x012DADB8 54 struct procstat_core 55 { 56 int pc_magic; 57 int pc_fd; 58 Elf *pc_elf; 59 GElf_Ehdr pc_ehdr; 60 GElf_Phdr pc_phdr; 61 }; 62 63 static struct psc_type_info { 64 unsigned int n_type; 65 int structsize; 66 } psc_type_info[PSC_TYPE_MAX] = { 67 { .n_type = NT_PROCSTAT_PROC, .structsize = sizeof(struct kinfo_proc) }, 68 { .n_type = NT_PROCSTAT_FILES, .structsize = sizeof(struct kinfo_file) }, 69 { .n_type = NT_PROCSTAT_VMMAP, .structsize = sizeof(struct kinfo_vmentry) }, 70 { .n_type = NT_PROCSTAT_GROUPS, .structsize = sizeof(gid_t) }, 71 { .n_type = NT_PROCSTAT_UMASK, .structsize = sizeof(u_short) }, 72 { .n_type = NT_PROCSTAT_RLIMIT, .structsize = sizeof(struct rlimit) * RLIM_NLIMITS }, 73 { .n_type = NT_PROCSTAT_OSREL, .structsize = sizeof(int) }, 74 { .n_type = NT_PROCSTAT_PSSTRINGS, .structsize = sizeof(vm_offset_t) }, 75 { .n_type = NT_PROCSTAT_PSSTRINGS, .structsize = sizeof(vm_offset_t) }, 76 { .n_type = NT_PROCSTAT_PSSTRINGS, .structsize = sizeof(vm_offset_t) }, 77 { .n_type = NT_PROCSTAT_AUXV, .structsize = sizeof(Elf_Auxinfo) }, 78 { .n_type = NT_PTLWPINFO, .structsize = sizeof(struct ptrace_lwpinfo) }, 79 }; 80 81 static bool core_offset(struct procstat_core *core, off_t offset); 82 static bool core_read(struct procstat_core *core, void *buf, size_t len); 83 static ssize_t core_read_mem(struct procstat_core *core, void *buf, 84 size_t len, vm_offset_t addr, bool readall); 85 static void *get_args(struct procstat_core *core, vm_offset_t psstrings, 86 enum psc_type type, void *buf, size_t *lenp); 87 88 struct procstat_core * 89 procstat_core_open(const char *filename) 90 { 91 struct procstat_core *core; 92 Elf *e; 93 GElf_Ehdr ehdr; 94 GElf_Phdr phdr; 95 size_t nph; 96 int fd, i; 97 98 if (elf_version(EV_CURRENT) == EV_NONE) { 99 warnx("ELF library too old"); 100 return (NULL); 101 } 102 fd = open(filename, O_RDONLY, 0); 103 if (fd == -1) { 104 warn("open(%s)", filename); 105 return (NULL); 106 } 107 e = elf_begin(fd, ELF_C_READ, NULL); 108 if (e == NULL) { 109 warnx("elf_begin: %s", elf_errmsg(-1)); 110 goto fail; 111 } 112 if (elf_kind(e) != ELF_K_ELF) { 113 warnx("%s is not an ELF object", filename); 114 goto fail; 115 } 116 if (gelf_getehdr(e, &ehdr) == NULL) { 117 warnx("gelf_getehdr: %s", elf_errmsg(-1)); 118 goto fail; 119 } 120 if (ehdr.e_type != ET_CORE) { 121 warnx("%s is not a CORE file", filename); 122 goto fail; 123 } 124 if (elf_getphnum(e, &nph) == 0) { 125 warnx("program headers not found"); 126 goto fail; 127 } 128 for (i = 0; i < ehdr.e_phnum; i++) { 129 if (gelf_getphdr(e, i, &phdr) != &phdr) { 130 warnx("gelf_getphdr: %s", elf_errmsg(-1)); 131 goto fail; 132 } 133 if (phdr.p_type == PT_NOTE) 134 break; 135 } 136 if (i == ehdr.e_phnum) { 137 warnx("NOTE program header not found"); 138 goto fail; 139 } 140 core = malloc(sizeof(struct procstat_core)); 141 if (core == NULL) { 142 warn("malloc(%zu)", sizeof(struct procstat_core)); 143 goto fail; 144 } 145 core->pc_magic = PROCSTAT_CORE_MAGIC; 146 core->pc_fd = fd; 147 core->pc_elf = e; 148 core->pc_ehdr = ehdr; 149 core->pc_phdr = phdr; 150 151 return (core); 152 fail: 153 if (e != NULL) 154 elf_end(e); 155 close(fd); 156 157 return (NULL); 158 } 159 160 void 161 procstat_core_close(struct procstat_core *core) 162 { 163 164 assert(core->pc_magic == PROCSTAT_CORE_MAGIC); 165 166 elf_end(core->pc_elf); 167 close(core->pc_fd); 168 free(core); 169 } 170 171 void * 172 procstat_core_get(struct procstat_core *core, enum psc_type type, void *buf, 173 size_t *lenp) 174 { 175 Elf_Note nhdr; 176 off_t offset, eoffset; 177 vm_offset_t psstrings; 178 void *freebuf; 179 size_t len, curlen; 180 int cstructsize; 181 char nbuf[8]; 182 183 assert(core->pc_magic == PROCSTAT_CORE_MAGIC); 184 185 if (type >= PSC_TYPE_MAX) { 186 warnx("unknown core stat type: %d", type); 187 return (NULL); 188 } 189 190 offset = core->pc_phdr.p_offset; 191 eoffset = offset + core->pc_phdr.p_filesz; 192 curlen = 0; 193 194 while (offset < eoffset) { 195 if (!core_offset(core, offset)) 196 return (NULL); 197 if (!core_read(core, &nhdr, sizeof(nhdr))) 198 return (NULL); 199 200 offset += sizeof(nhdr) + 201 roundup2(nhdr.n_namesz, sizeof(Elf32_Size)) + 202 roundup2(nhdr.n_descsz, sizeof(Elf32_Size)); 203 204 if (nhdr.n_namesz == 0 && nhdr.n_descsz == 0) 205 break; 206 if (nhdr.n_type != psc_type_info[type].n_type) 207 continue; 208 if (nhdr.n_namesz != 8) 209 continue; 210 if (!core_read(core, nbuf, sizeof(nbuf))) 211 return (NULL); 212 if (strcmp(nbuf, "FreeBSD") != 0) 213 continue; 214 if (nhdr.n_descsz < sizeof(cstructsize)) { 215 warnx("corrupted core file"); 216 return (NULL); 217 } 218 if (!core_read(core, &cstructsize, sizeof(cstructsize))) 219 return (NULL); 220 if (cstructsize != psc_type_info[type].structsize) { 221 warnx("version mismatch"); 222 return (NULL); 223 } 224 len = nhdr.n_descsz - sizeof(cstructsize); 225 if (len == 0) 226 return (NULL); 227 if (buf != NULL) { 228 len = MIN(len, *lenp); 229 freebuf = NULL; 230 } else { 231 freebuf = buf = malloc(len); 232 if (buf == NULL) { 233 warn("malloc(%zu)", len); 234 return (NULL); 235 } 236 } 237 if (!core_read(core, (char *)buf + curlen, len)) { 238 free(freebuf); 239 return (NULL); 240 } 241 if (type == PSC_TYPE_ARGV || type == PSC_TYPE_ENVV) { 242 if (len < sizeof(psstrings)) { 243 free(freebuf); 244 return (NULL); 245 } 246 psstrings = *(vm_offset_t *)buf; 247 if (freebuf == NULL) 248 len = *lenp; 249 else 250 buf = NULL; 251 free(freebuf); 252 buf = get_args(core, psstrings, type, buf, &len); 253 } else if (type == PSC_TYPE_PTLWPINFO) { 254 *lenp -= len; 255 curlen += len; 256 continue; 257 } 258 *lenp = len; 259 return (buf); 260 } 261 262 if (curlen != 0) { 263 *lenp = curlen; 264 return (buf); 265 } 266 267 return (NULL); 268 } 269 270 static bool 271 core_offset(struct procstat_core *core, off_t offset) 272 { 273 274 assert(core->pc_magic == PROCSTAT_CORE_MAGIC); 275 276 if (lseek(core->pc_fd, offset, SEEK_SET) == -1) { 277 warn("core: lseek(%jd)", (intmax_t)offset); 278 return (false); 279 } 280 return (true); 281 } 282 283 static bool 284 core_read(struct procstat_core *core, void *buf, size_t len) 285 { 286 ssize_t n; 287 288 assert(core->pc_magic == PROCSTAT_CORE_MAGIC); 289 290 n = read(core->pc_fd, buf, len); 291 if (n == -1) { 292 warn("core: read"); 293 return (false); 294 } 295 if (n < (ssize_t)len) { 296 warnx("core: short read"); 297 return (false); 298 } 299 return (true); 300 } 301 302 static ssize_t 303 core_read_mem(struct procstat_core *core, void *buf, size_t len, 304 vm_offset_t addr, bool readall) 305 { 306 GElf_Phdr phdr; 307 off_t offset; 308 int i; 309 310 assert(core->pc_magic == PROCSTAT_CORE_MAGIC); 311 312 for (i = 0; i < core->pc_ehdr.e_phnum; i++) { 313 if (gelf_getphdr(core->pc_elf, i, &phdr) != &phdr) { 314 warnx("gelf_getphdr: %s", elf_errmsg(-1)); 315 return (-1); 316 } 317 if (phdr.p_type != PT_LOAD) 318 continue; 319 if (addr < phdr.p_vaddr || addr > phdr.p_vaddr + phdr.p_memsz) 320 continue; 321 offset = phdr.p_offset + (addr - phdr.p_vaddr); 322 if ((phdr.p_vaddr + phdr.p_memsz) - addr < len) { 323 if (readall) { 324 warnx("format error: " 325 "attempt to read out of segment"); 326 return (-1); 327 } 328 len = (phdr.p_vaddr + phdr.p_memsz) - addr; 329 } 330 if (!core_offset(core, offset)) 331 return (-1); 332 if (!core_read(core, buf, len)) 333 return (-1); 334 return (len); 335 } 336 warnx("format error: address %ju not found", (uintmax_t)addr); 337 return (-1); 338 } 339 340 #define ARGS_CHUNK_SZ 256 /* Chunk size (bytes) for get_args operations. */ 341 342 static void * 343 get_args(struct procstat_core *core, vm_offset_t psstrings, enum psc_type type, 344 void *args, size_t *lenp) 345 { 346 struct ps_strings pss; 347 void *freeargs; 348 vm_offset_t addr; 349 char **argv, *p; 350 size_t chunksz, done, len, nchr, size; 351 ssize_t n; 352 u_int i, nstr; 353 354 assert(type == PSC_TYPE_ARGV || type == PSC_TYPE_ENVV); 355 356 if (core_read_mem(core, &pss, sizeof(pss), psstrings, true) == -1) 357 return (NULL); 358 if (type == PSC_TYPE_ARGV) { 359 addr = (vm_offset_t)pss.ps_argvstr; 360 nstr = pss.ps_nargvstr; 361 } else /* type == PSC_TYPE_ENVV */ { 362 addr = (vm_offset_t)pss.ps_envstr; 363 nstr = pss.ps_nenvstr; 364 } 365 if (addr == 0 || nstr == 0) 366 return (NULL); 367 if (nstr > ARG_MAX) { 368 warnx("format error"); 369 return (NULL); 370 } 371 size = nstr * sizeof(char *); 372 argv = malloc(size); 373 if (argv == NULL) { 374 warn("malloc(%zu)", size); 375 return (NULL); 376 } 377 done = 0; 378 freeargs = NULL; 379 if (core_read_mem(core, argv, size, addr, true) == -1) 380 goto fail; 381 if (args != NULL) { 382 nchr = MIN(ARG_MAX, *lenp); 383 } else { 384 nchr = ARG_MAX; 385 freeargs = args = malloc(nchr); 386 if (args == NULL) { 387 warn("malloc(%zu)", nchr); 388 goto fail; 389 } 390 } 391 p = args; 392 for (i = 0; ; i++) { 393 if (i == nstr) 394 goto done; 395 /* 396 * The program may have scribbled into its argv array, e.g. to 397 * remove some arguments. If that has happened, break out 398 * before trying to read from NULL. 399 */ 400 if (argv[i] == NULL) 401 goto done; 402 for (addr = (vm_offset_t)argv[i]; ; addr += chunksz) { 403 chunksz = MIN(ARGS_CHUNK_SZ, nchr - 1 - done); 404 if (chunksz <= 0) 405 goto done; 406 n = core_read_mem(core, p, chunksz, addr, false); 407 if (n == -1) 408 goto fail; 409 len = strnlen(p, chunksz); 410 p += len; 411 done += len; 412 if (len != chunksz) 413 break; 414 } 415 *p++ = '\0'; 416 done++; 417 } 418 fail: 419 free(freeargs); 420 args = NULL; 421 done: 422 *lenp = done; 423 free(argv); 424 return (args); 425 } 426 427 int 428 procstat_core_note_count(struct procstat_core *core, enum psc_type type) 429 { 430 Elf_Note nhdr; 431 off_t offset, eoffset; 432 int cstructsize; 433 char nbuf[8]; 434 int n; 435 436 if (type >= PSC_TYPE_MAX) { 437 warnx("unknown core stat type: %d", type); 438 return (0); 439 } 440 441 offset = core->pc_phdr.p_offset; 442 eoffset = offset + core->pc_phdr.p_filesz; 443 444 for (n = 0; offset < eoffset; n++) { 445 if (!core_offset(core, offset)) 446 return (0); 447 if (!core_read(core, &nhdr, sizeof(nhdr))) 448 return (0); 449 450 offset += sizeof(nhdr) + 451 roundup2(nhdr.n_namesz, sizeof(Elf32_Size)) + 452 roundup2(nhdr.n_descsz, sizeof(Elf32_Size)); 453 454 if (nhdr.n_namesz == 0 && nhdr.n_descsz == 0) 455 break; 456 if (nhdr.n_type != psc_type_info[type].n_type) 457 continue; 458 if (nhdr.n_namesz != 8) 459 continue; 460 if (!core_read(core, nbuf, sizeof(nbuf))) 461 return (0); 462 if (strcmp(nbuf, "FreeBSD") != 0) 463 continue; 464 if (nhdr.n_descsz < sizeof(cstructsize)) { 465 warnx("corrupted core file"); 466 return (0); 467 } 468 if (!core_read(core, &cstructsize, sizeof(cstructsize))) 469 return (0); 470 if (cstructsize != psc_type_info[type].structsize) { 471 warnx("version mismatch"); 472 return (0); 473 } 474 if (nhdr.n_descsz - sizeof(cstructsize) == 0) 475 return (0); 476 } 477 478 return (n); 479 } 480