?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8158 Want named threads API
[unleashed.git] / usr / src / lib / libproc / common / Pgcore.c
blob64ef98065bcc1208624193e00962fe3c8545f502
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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
28 * Copyright 2018 Joyent, Inc.
29 * Copyright (c) 2013 by Delphix. All rights reserved.
30 */
31
32 #define _STRUCTURED_PROC 1
33
34 #include <stdlib.h>
35 #include <ctype.h>
36 #include <string.h>
37 #include <strings.h>
38 #include <errno.h>
39 #include <procfs.h>
40 #include <priv.h>
41 #include <sys/elf.h>
42 #include <sys/machelf.h>
43 #include <sys/sysmacros.h>
44 #include <sys/systeminfo.h>
45 #include <sys/proc.h>
46 #include <sys/utsname.h>
47
48 #include <sys/old_procfs.h>
49
50 #include "Pcontrol.h"
51 #include "P32ton.h"
52
53 typedef enum {
54 STR_NONE,
55 STR_CTF,
56 STR_SYMTAB,
57 STR_DYNSYM,
58 STR_STRTAB,
59 STR_DYNSTR,
60 STR_SHSTRTAB,
61 STR_NUM
62 } shstrtype_t;
63
64 static const char *shstrtab_data[] = {
65 "",
66 ".SUNW_ctf",
67 ".symtab",
68 ".dynsym",
69 ".strtab",
70 ".dynstr",
71 ".shstrtab"
72 };
73
74 typedef struct shstrtab {
75 int sst_ndx[STR_NUM];
76 int sst_cur;
77 } shstrtab_t;
78
79 typedef struct {
80 struct ps_prochandle *P;
81 int pgc_fd;
82 off64_t *pgc_poff;
83 off64_t *pgc_soff;
84 off64_t *pgc_doff;
85 core_content_t pgc_content;
86 void *pgc_chunk;
87 size_t pgc_chunksz;
88
89 shstrtab_t pgc_shstrtab;
90 } pgcore_t;
91
92 typedef struct {
93 int fd_fd;
94 off64_t *fd_doff;
95 } fditer_t;
96
97 static int
98 gc_pwrite64(int fd, const void *buf, size_t len, off64_t off)
99 {
100 int err;
101
102 err = pwrite64(fd, buf, len, off);
103
104 if (err < 0)
105 return (err);
106
107 /*
108 * We will take a page from ZFS's book here and use the otherwise
109 * unused EBADE to mean a short write. Typically this will actually
110 * result from ENOSPC or EDQUOT, but we can't be sure.
111 */
112 if (err < len) {
113 errno = EBADE;
114 return (-1);
115 }
116
117 return (0);
118 }
119
120 static void
121 shstrtab_init(shstrtab_t *s)
122 {
123 bzero(&s->sst_ndx, sizeof (s->sst_ndx));
124 s->sst_cur = 1;
125 }
126
127 static int
128 shstrtab_ndx(shstrtab_t *s, shstrtype_t type)
129 {
130 int ret;
131
132 if ((ret = s->sst_ndx[type]) != 0 || type == STR_NONE)
133 return (ret);
134
135 ret = s->sst_ndx[type] = s->sst_cur;
136 s->sst_cur += strlen(shstrtab_data[type]) + 1;
137
138 return (ret);
139 }
140
141 static size_t
142 shstrtab_size(const shstrtab_t *s)
143 {
144 return (s->sst_cur);
145 }
146
147 int
148 Pgcore(struct ps_prochandle *P, const char *fname, core_content_t content)
149 {
150 int fd;
151 int err;
152 int saved_errno;
153
154 if ((fd = creat64(fname, 0666)) < 0)
155 return (-1);
156
157 if ((err = Pfgcore(P, fd, content)) != 0) {
158 saved_errno = errno;
159 (void) close(fd);
160 (void) unlink(fname);
161 errno = saved_errno;
162 return (err);
163 }
164
165 return (close(fd));
166 }
167
168 /*
169 * Since we don't want to use the old-school procfs interfaces, we use the
170 * new-style data structures we already have to construct the old-style
171 * data structures. We include these data structures in core files for
172 * backward compatability.
173 */
174
175 static void
176 mkprstatus(struct ps_prochandle *P, const lwpstatus_t *lsp,
177 const lwpsinfo_t *lip, prstatus_t *psp)
178 {
179 bzero(psp, sizeof (*psp));
180
181 if (lsp->pr_flags & PR_STOPPED)
182 psp->pr_flags = 0x0001;
183 if (lsp->pr_flags & PR_ISTOP)
184 psp->pr_flags = 0x0002;
185 if (lsp->pr_flags & PR_DSTOP)
186 psp->pr_flags = 0x0004;
187 if (lsp->pr_flags & PR_ASLEEP)
188 psp->pr_flags = 0x0008;
189 if (lsp->pr_flags & PR_FORK)
190 psp->pr_flags = 0x0010;
191 if (lsp->pr_flags & PR_RLC)
192 psp->pr_flags = 0x0020;
193 /*
194 * Note that PR_PTRACE (0x0040) from <sys/old_procfs.h> is never set;
195 * PR_PCOMPAT corresponds to PR_PTRACE in the newer <sys/procfs.h>.
196 */
197 if (lsp->pr_flags & PR_PCINVAL)
198 psp->pr_flags = 0x0080;
199 if (lsp->pr_flags & PR_ISSYS)
200 psp->pr_flags = 0x0100;
201 if (lsp->pr_flags & PR_STEP)
202 psp->pr_flags = 0x0200;
203 if (lsp->pr_flags & PR_KLC)
204 psp->pr_flags = 0x0400;
205 if (lsp->pr_flags & PR_ASYNC)
206 psp->pr_flags = 0x0800;
207 if (lsp->pr_flags & PR_PTRACE)
208 psp->pr_flags = 0x1000;
209 if (lsp->pr_flags & PR_MSACCT)
210 psp->pr_flags = 0x2000;
211 if (lsp->pr_flags & PR_BPTADJ)
212 psp->pr_flags = 0x4000;
213 if (lsp->pr_flags & PR_ASLWP)
214 psp->pr_flags = 0x8000;
215
216 psp->pr_why = lsp->pr_why;
217 psp->pr_what = lsp->pr_what;
218 psp->pr_info = lsp->pr_info;
219 psp->pr_cursig = lsp->pr_cursig;
220 psp->pr_nlwp = P->status.pr_nlwp;
221 psp->pr_sigpend = P->status.pr_sigpend;
222 psp->pr_sighold = lsp->pr_lwphold;
223 psp->pr_altstack = lsp->pr_altstack;
224 psp->pr_action = lsp->pr_action;
225 psp->pr_pid = P->status.pr_pid;
226 psp->pr_ppid = P->status.pr_ppid;
227 psp->pr_pgrp = P->status.pr_pgid;
228 psp->pr_sid = P->status.pr_sid;
229 psp->pr_utime = P->status.pr_utime;
230 psp->pr_stime = P->status.pr_stime;
231 psp->pr_cutime = P->status.pr_cutime;
232 psp->pr_cstime = P->status.pr_cstime;
233 (void) strncpy(psp->pr_clname, lsp->pr_clname, sizeof (psp->pr_clname));
234 psp->pr_syscall = lsp->pr_syscall;
235 psp->pr_nsysarg = lsp->pr_nsysarg;
236 bcopy(lsp->pr_sysarg, psp->pr_sysarg, sizeof (psp->pr_sysarg));
237 psp->pr_who = lsp->pr_lwpid;
238 psp->pr_lwppend = lsp->pr_lwppend;
239 psp->pr_oldcontext = (ucontext_t *)lsp->pr_oldcontext;
240 psp->pr_brkbase = (caddr_t)P->status.pr_brkbase;
241 psp->pr_brksize = P->status.pr_brksize;
242 psp->pr_stkbase = (caddr_t)P->status.pr_stkbase;
243 psp->pr_stksize = P->status.pr_stksize;
244 psp->pr_processor = (short)lip->pr_onpro;
245 psp->pr_bind = (short)lip->pr_bindpro;
246 psp->pr_instr = lsp->pr_instr;
247 bcopy(lsp->pr_reg, psp->pr_reg, sizeof (psp->pr_sysarg));
248 }
249
250 static void
251 mkprpsinfo(struct ps_prochandle *P, prpsinfo_t *psp)
252 {
253 bzero(psp, sizeof (*psp));
254 psp->pr_state = P->psinfo.pr_lwp.pr_state;
255 psp->pr_sname = P->psinfo.pr_lwp.pr_sname;
256 psp->pr_zomb = (psp->pr_state == SZOMB);
257 psp->pr_nice = P->psinfo.pr_lwp.pr_nice;
258 psp->pr_flag = P->psinfo.pr_lwp.pr_flag;
259 psp->pr_uid = P->psinfo.pr_uid;
260 psp->pr_gid = P->psinfo.pr_gid;
261 psp->pr_pid = P->psinfo.pr_pid;
262 psp->pr_ppid = P->psinfo.pr_ppid;
263 psp->pr_pgrp = P->psinfo.pr_pgid;
264 psp->pr_sid = P->psinfo.pr_sid;
265 psp->pr_addr = (caddr_t)P->psinfo.pr_addr;
266 psp->pr_size = P->psinfo.pr_size;
267 psp->pr_rssize = P->psinfo.pr_rssize;
268 psp->pr_wchan = (caddr_t)P->psinfo.pr_lwp.pr_wchan;
269 psp->pr_start = P->psinfo.pr_start;
270 psp->pr_time = P->psinfo.pr_time;
271 psp->pr_pri = P->psinfo.pr_lwp.pr_pri;
272 psp->pr_oldpri = P->psinfo.pr_lwp.pr_oldpri;
273 psp->pr_cpu = P->psinfo.pr_lwp.pr_cpu;
274 psp->pr_ottydev = cmpdev(P->psinfo.pr_ttydev);
275 psp->pr_lttydev = P->psinfo.pr_ttydev;
276 (void) strncpy(psp->pr_clname, P->psinfo.pr_lwp.pr_clname,
277 sizeof (psp->pr_clname));
278 (void) strncpy(psp->pr_fname, P->psinfo.pr_fname,
279 sizeof (psp->pr_fname));
280 bcopy(&P->psinfo.pr_psargs, &psp->pr_psargs,
281 sizeof (psp->pr_psargs));
282 psp->pr_syscall = P->psinfo.pr_lwp.pr_syscall;
283 psp->pr_ctime = P->psinfo.pr_ctime;
284 psp->pr_bysize = psp->pr_size * PAGESIZE;
285 psp->pr_byrssize = psp->pr_rssize * PAGESIZE;
286 psp->pr_argc = P->psinfo.pr_argc;
287 psp->pr_argv = (char **)P->psinfo.pr_argv;
288 psp->pr_envp = (char **)P->psinfo.pr_envp;
289 psp->pr_wstat = P->psinfo.pr_wstat;
290 psp->pr_pctcpu = P->psinfo.pr_pctcpu;
291 psp->pr_pctmem = P->psinfo.pr_pctmem;
292 psp->pr_euid = P->psinfo.pr_euid;
293 psp->pr_egid = P->psinfo.pr_egid;
294 psp->pr_aslwpid = 0;
295 psp->pr_dmodel = P->psinfo.pr_dmodel;
296 }
297
298 #ifdef _LP64
299
300 static void
301 mkprstatus32(struct ps_prochandle *P, const lwpstatus_t *lsp,
302 const lwpsinfo_t *lip, prstatus32_t *psp)
303 {
304 bzero(psp, sizeof (*psp));
305
306 if (lsp->pr_flags & PR_STOPPED)
307 psp->pr_flags = 0x0001;
308 if (lsp->pr_flags & PR_ISTOP)
309 psp->pr_flags = 0x0002;
310 if (lsp->pr_flags & PR_DSTOP)
311 psp->pr_flags = 0x0004;
312 if (lsp->pr_flags & PR_ASLEEP)
313 psp->pr_flags = 0x0008;
314 if (lsp->pr_flags & PR_FORK)
315 psp->pr_flags = 0x0010;
316 if (lsp->pr_flags & PR_RLC)
317 psp->pr_flags = 0x0020;
318 /*
319 * Note that PR_PTRACE (0x0040) from <sys/old_procfs.h> is never set;
320 * PR_PCOMPAT corresponds to PR_PTRACE in the newer <sys/procfs.h>.
321 */
322 if (lsp->pr_flags & PR_PCINVAL)
323 psp->pr_flags = 0x0080;
324 if (lsp->pr_flags & PR_ISSYS)
325 psp->pr_flags = 0x0100;
326 if (lsp->pr_flags & PR_STEP)
327 psp->pr_flags = 0x0200;
328 if (lsp->pr_flags & PR_KLC)
329 psp->pr_flags = 0x0400;
330 if (lsp->pr_flags & PR_ASYNC)
331 psp->pr_flags = 0x0800;
332 if (lsp->pr_flags & PR_PTRACE)
333 psp->pr_flags = 0x1000;
334 if (lsp->pr_flags & PR_MSACCT)
335 psp->pr_flags = 0x2000;
336 if (lsp->pr_flags & PR_BPTADJ)
337 psp->pr_flags = 0x4000;
338 if (lsp->pr_flags & PR_ASLWP)
339 psp->pr_flags = 0x8000;
340
341 psp->pr_why = lsp->pr_why;
342 psp->pr_what = lsp->pr_what;
343 siginfo_n_to_32(&lsp->pr_info, &psp->pr_info);
344 psp->pr_cursig = lsp->pr_cursig;
345 psp->pr_nlwp = P->status.pr_nlwp;
346 psp->pr_sigpend = P->status.pr_sigpend;
347 psp->pr_sighold = lsp->pr_lwphold;
348 stack_n_to_32(&lsp->pr_altstack, &psp->pr_altstack);
349 sigaction_n_to_32(&lsp->pr_action, &psp->pr_action);
350 psp->pr_pid = P->status.pr_pid;
351 psp->pr_ppid = P->status.pr_ppid;
352 psp->pr_pgrp = P->status.pr_pgid;
353 psp->pr_sid = P->status.pr_sid;
354 timestruc_n_to_32(&P->status.pr_utime, &psp->pr_utime);
355 timestruc_n_to_32(&P->status.pr_stime, &psp->pr_stime);
356 timestruc_n_to_32(&P->status.pr_cutime, &psp->pr_cutime);
357 timestruc_n_to_32(&P->status.pr_cstime, &psp->pr_cstime);
358 (void) strncpy(psp->pr_clname, lsp->pr_clname, sizeof (psp->pr_clname));
359 psp->pr_syscall = lsp->pr_syscall;
360 psp->pr_nsysarg = lsp->pr_nsysarg;
361 bcopy(lsp->pr_sysarg, psp->pr_sysarg, sizeof (psp->pr_sysarg));
362 psp->pr_who = lsp->pr_lwpid;
363 psp->pr_lwppend = lsp->pr_lwppend;
364 psp->pr_oldcontext = (caddr32_t)lsp->pr_oldcontext;
365 psp->pr_brkbase = (caddr32_t)P->status.pr_brkbase;
366 psp->pr_brksize = P->status.pr_brksize;
367 psp->pr_stkbase = (caddr32_t)P->status.pr_stkbase;
368 psp->pr_stksize = P->status.pr_stksize;
369 psp->pr_processor = (short)lip->pr_onpro;
370 psp->pr_bind = (short)lip->pr_bindpro;
371 psp->pr_instr = lsp->pr_instr;
372 bcopy(lsp->pr_reg, psp->pr_reg, sizeof (psp->pr_sysarg));
373 }
374
375 static void
376 mkprpsinfo32(struct ps_prochandle *P, prpsinfo32_t *psp)
377 {
378 bzero(psp, sizeof (*psp));
379 psp->pr_state = P->psinfo.pr_lwp.pr_state;
380 psp->pr_sname = P->psinfo.pr_lwp.pr_sname;
381 psp->pr_zomb = (psp->pr_state == SZOMB);
382 psp->pr_nice = P->psinfo.pr_lwp.pr_nice;
383 psp->pr_flag = P->psinfo.pr_lwp.pr_flag;
384 psp->pr_uid = P->psinfo.pr_uid;
385 psp->pr_gid = P->psinfo.pr_gid;
386 psp->pr_pid = P->psinfo.pr_pid;
387 psp->pr_ppid = P->psinfo.pr_ppid;
388 psp->pr_pgrp = P->psinfo.pr_pgid;
389 psp->pr_sid = P->psinfo.pr_sid;
390 psp->pr_addr = (caddr32_t)P->psinfo.pr_addr;
391 psp->pr_size = P->psinfo.pr_size;
392 psp->pr_rssize = P->psinfo.pr_rssize;
393 psp->pr_wchan = (caddr32_t)P->psinfo.pr_lwp.pr_wchan;
394 timestruc_n_to_32(&P->psinfo.pr_start, &psp->pr_start);
395 timestruc_n_to_32(&P->psinfo.pr_time, &psp->pr_time);
396 psp->pr_pri = P->psinfo.pr_lwp.pr_pri;
397 psp->pr_oldpri = P->psinfo.pr_lwp.pr_oldpri;
398 psp->pr_cpu = P->psinfo.pr_lwp.pr_cpu;
399 psp->pr_ottydev = cmpdev(P->psinfo.pr_ttydev);
400 psp->pr_lttydev = prcmpldev(P->psinfo.pr_ttydev);
401 (void) strncpy(psp->pr_clname, P->psinfo.pr_lwp.pr_clname,
402 sizeof (psp->pr_clname));
403 (void) strncpy(psp->pr_fname, P->psinfo.pr_fname,
404 sizeof (psp->pr_fname));
405 bcopy(&P->psinfo.pr_psargs, &psp->pr_psargs,
406 sizeof (psp->pr_psargs));
407 psp->pr_syscall = P->psinfo.pr_lwp.pr_syscall;
408 timestruc_n_to_32(&P->psinfo.pr_ctime, &psp->pr_ctime);
409 psp->pr_bysize = psp->pr_size * PAGESIZE;
410 psp->pr_byrssize = psp->pr_rssize * PAGESIZE;
411 psp->pr_argc = P->psinfo.pr_argc;
412 psp->pr_argv = (caddr32_t)P->psinfo.pr_argv;
413 psp->pr_envp = (caddr32_t)P->psinfo.pr_envp;
414 psp->pr_wstat = P->psinfo.pr_wstat;
415 psp->pr_pctcpu = P->psinfo.pr_pctcpu;
416 psp->pr_pctmem = P->psinfo.pr_pctmem;
417 psp->pr_euid = P->psinfo.pr_euid;
418 psp->pr_egid = P->psinfo.pr_egid;
419 psp->pr_aslwpid = 0;
420 psp->pr_dmodel = P->psinfo.pr_dmodel;
421 }
422
423 #endif /* _LP64 */
424
425 static int
426 write_note(int fd, uint_t type, const void *desc, size_t descsz, off64_t *offp)
427 {
428 /*
429 * Note headers are the same regardless of the data model of the
430 * ELF file; we arbitrarily use Elf64_Nhdr here.
431 */
432 struct {
433 Elf64_Nhdr nhdr;
434 char name[8];
435 } n;
436
437 bzero(&n, sizeof (n));
438 bcopy("CORE", n.name, 4);
439 n.nhdr.n_type = type;
440 n.nhdr.n_namesz = 5;
441 n.nhdr.n_descsz = roundup(descsz, 4);
442
443 if (gc_pwrite64(fd, &n, sizeof (n), *offp) != 0)
444 return (-1);
445
446 *offp += sizeof (n);
447
448 if (gc_pwrite64(fd, desc, n.nhdr.n_descsz, *offp) != 0)
449 return (-1);
450
451 *offp += n.nhdr.n_descsz;
452
453 return (0);
454 }
455
456 static int
457 old_per_lwp(void *data, const lwpstatus_t *lsp, const lwpsinfo_t *lip)
458 {
459 pgcore_t *pgc = data;
460 struct ps_prochandle *P = pgc->P;
461
462 /*
463 * Legacy core files don't contain information about zombie LWPs.
464 * We use Plwp_iter_all() so that we get the lwpsinfo_t structure
465 * more cheaply.
466 */
467 if (lsp == NULL)
468 return (0);
469
470 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
471 prstatus_t prstatus;
472 mkprstatus(P, lsp, lip, &prstatus);
473 if (write_note(pgc->pgc_fd, NT_PRSTATUS, &prstatus,
474 sizeof (prstatus_t), pgc->pgc_doff) != 0)
475 return (0);
476 if (write_note(pgc->pgc_fd, NT_PRFPREG, &lsp->pr_fpreg,
477 sizeof (prfpregset_t), pgc->pgc_doff) != 0)
478 return (1);
479 #ifdef _LP64
480 } else {
481 prstatus32_t pr32;
482 prfpregset32_t pf32;
483 mkprstatus32(P, lsp, lip, &pr32);
484 if (write_note(pgc->pgc_fd, NT_PRSTATUS, &pr32,
485 sizeof (prstatus32_t), pgc->pgc_doff) != 0)
486 return (1);
487 prfpregset_n_to_32(&lsp->pr_fpreg, &pf32);
488 if (write_note(pgc->pgc_fd, NT_PRFPREG, &pf32,
489 sizeof (prfpregset32_t), pgc->pgc_doff) != 0)
490 return (1);
491 #endif /* _LP64 */
492 }
493
494 #ifdef sparc
495 {
496 prxregset_t xregs;
497 if (Plwp_getxregs(P, lsp->pr_lwpid, &xregs) == 0 &&
498 write_note(pgc->pgc_fd, NT_PRXREG, &xregs,
499 sizeof (prxregset_t), pgc->pgc_doff) != 0)
500 return (1);
501 }
502 #endif /* sparc */
503
504 return (0);
505 }
506
507 static int
508 new_per_lwp(void *data, const lwpstatus_t *lsp, const lwpsinfo_t *lip)
509 {
510 pgcore_t *pgc = data;
511 struct ps_prochandle *P = pgc->P;
512 prlwpname_t name = { 0, "" };
513 psinfo_t ps;
514
515 /*
516 * If lsp is NULL this indicates that this is a zombie LWP in
517 * which case we dump only the lwpsinfo_t structure and none of
518 * the other ancillary LWP state data.
519 */
520 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
521 if (write_note(pgc->pgc_fd, NT_LWPSINFO, lip,
522 sizeof (lwpsinfo_t), pgc->pgc_doff) != 0)
523 return (1);
524 if (lsp == NULL)
525 return (0);
526 if (write_note(pgc->pgc_fd, NT_LWPSTATUS, lsp,
527 sizeof (lwpstatus_t), pgc->pgc_doff) != 0)
528 return (1);
529 #ifdef _LP64
530 } else {
531 lwpsinfo32_t li32;
532 lwpstatus32_t ls32;
533 lwpsinfo_n_to_32(lip, &li32);
534 if (write_note(pgc->pgc_fd, NT_LWPSINFO, &li32,
535 sizeof (lwpsinfo32_t), pgc->pgc_doff) != 0)
536 return (1);
537 if (lsp == NULL)
538 return (0);
539 lwpstatus_n_to_32(lsp, &ls32);
540 if (write_note(pgc->pgc_fd, NT_LWPSTATUS, &ls32,
541 sizeof (lwpstatus32_t), pgc->pgc_doff) != 0)
542 return (1);
543 #endif /* _LP64 */
544 }
545
546 #ifdef sparc
547 {
548 prxregset_t xregs;
549 gwindows_t gwins;
550 size_t size;
551
552 if (Plwp_getxregs(P, lsp->pr_lwpid, &xregs) == 0) {
553 if (write_note(pgc->pgc_fd, NT_PRXREG, &xregs,
554 sizeof (prxregset_t), pgc->pgc_doff) != 0)
555 return (1);
556 }
557
558 if (Plwp_getgwindows(P, lsp->pr_lwpid, &gwins) == 0 &&
559 gwins.wbcnt > 0) {
560 size = sizeof (gwins) - sizeof (gwins.wbuf) +
561 gwins.wbcnt * sizeof (gwins.wbuf[0]);
562
563 if (write_note(pgc->pgc_fd, NT_GWINDOWS, &gwins, size,
564 pgc->pgc_doff) != 0)
565 return (1);
566 }
567
568 }
569 #ifdef __sparcv9
570 if (P->status.pr_dmodel == PR_MODEL_LP64) {
571 asrset_t asrs;
572 if (Plwp_getasrs(P, lsp->pr_lwpid, asrs) == 0) {
573 if (write_note(pgc->pgc_fd, NT_ASRS, &asrs,
574 sizeof (asrset_t), pgc->pgc_doff) != 0)
575 return (1);
576 }
577 }
578 #endif /* __sparcv9 */
579 #endif /* sparc */
580
581 if (Plwp_getname(P, lsp->pr_lwpid, name.pr_lwpname,
582 sizeof (name.pr_lwpname)) == 0) {
583 name.pr_lwpid = lsp->pr_lwpid;
584 if (write_note(pgc->pgc_fd, NT_LWPNAME, &name,
585 sizeof (name), pgc->pgc_doff) != 0)
586 return (1);
587 }
588
589 if (!(lsp->pr_flags & PR_AGENT))
590 return (0);
591
592 if (Plwp_getspymaster(P, lsp->pr_lwpid, &ps) != 0)
593 return (0);
594
595 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
596 if (write_note(pgc->pgc_fd, NT_SPYMASTER, &ps,
597 sizeof (psinfo_t), pgc->pgc_doff) != 0)
598 return (1);
599 #ifdef _LP64
600 } else {
601 psinfo32_t ps32;
602 psinfo_n_to_32(&ps, &ps32);
603 if (write_note(pgc->pgc_fd, NT_SPYMASTER, &ps32,
604 sizeof (psinfo32_t), pgc->pgc_doff) != 0)
605 return (1);
606 #endif /* _LP64 */
607 }
608
609
610 return (0);
611 }
612
613 static int
614 iter_fd(void *data, prfdinfo_t *fdinfo)
615 {
616 fditer_t *iter = data;
617
618 if (write_note(iter->fd_fd, NT_FDINFO, fdinfo,
619 sizeof (*fdinfo), iter->fd_doff) != 0)
620 return (1);
621 return (0);
622 }
623
624 static uint_t
625 count_sections(pgcore_t *pgc)
626 {
627 struct ps_prochandle *P = pgc->P;
628 file_info_t *fptr;
629 uint_t cnt;
630 uint_t nshdrs = 0;
631
632 if (!(pgc->pgc_content & (CC_CONTENT_CTF | CC_CONTENT_SYMTAB)))
633 return (0);
634
635 fptr = list_next(&P->file_head);
636 for (cnt = P->num_files; cnt > 0; cnt--, fptr = list_next(fptr)) {
637 int hit_symtab = 0;
638
639 Pbuild_file_symtab(P, fptr);
640
641 if ((pgc->pgc_content & CC_CONTENT_CTF) &&
642 Pbuild_file_ctf(P, fptr) != NULL) {
643 sym_tbl_t *sym;
644
645 nshdrs++;
646
647 if (fptr->file_ctf_dyn) {
648 sym = &fptr->file_dynsym;
649 } else {
650 sym = &fptr->file_symtab;
651 hit_symtab = 1;
652 }
653
654 if (sym->sym_data_pri != NULL && sym->sym_symn != 0 &&
655 sym->sym_strs != NULL)
656 nshdrs += 2;
657 }
658
659 if ((pgc->pgc_content & CC_CONTENT_SYMTAB) && !hit_symtab &&
660 fptr->file_symtab.sym_data_pri != NULL &&
661 fptr->file_symtab.sym_symn != 0 &&
662 fptr->file_symtab.sym_strs != NULL) {
663 nshdrs += 2;
664 }
665 }
666
667 return (nshdrs == 0 ? 0 : nshdrs + 2);
668 }
669
670 static int
671 write_shdr(pgcore_t *pgc, shstrtype_t name, uint_t type, ulong_t flags,
672 uintptr_t addr, ulong_t offset, size_t size, uint_t link, uint_t info,
673 uintptr_t addralign, uintptr_t entsize)
674 {
675 if (pgc->P->status.pr_dmodel == PR_MODEL_ILP32) {
676 Elf32_Shdr shdr;
677
678 bzero(&shdr, sizeof (shdr));
679 shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, name);
680 shdr.sh_type = type;
681 shdr.sh_flags = flags;
682 shdr.sh_addr = (Elf32_Addr)addr;
683 shdr.sh_offset = offset;
684 shdr.sh_size = size;
685 shdr.sh_link = link;
686 shdr.sh_info = info;
687 shdr.sh_addralign = addralign;
688 shdr.sh_entsize = entsize;
689
690 if (gc_pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),
691 *pgc->pgc_soff) != 0)
692 return (-1);
693
694 *pgc->pgc_soff += sizeof (shdr);
695 #ifdef _LP64
696 } else {
697 Elf64_Shdr shdr;
698
699 bzero(&shdr, sizeof (shdr));
700 shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, name);
701 shdr.sh_type = type;
702 shdr.sh_flags = flags;
703 shdr.sh_addr = addr;
704 shdr.sh_offset = offset;
705 shdr.sh_size = size;
706 shdr.sh_link = link;
707 shdr.sh_info = info;
708 shdr.sh_addralign = addralign;
709 shdr.sh_entsize = entsize;
710
711 if (gc_pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),
712 *pgc->pgc_soff) != 0)
713 return (-1);
714
715 *pgc->pgc_soff += sizeof (shdr);
716 #endif /* _LP64 */
717 }
718
719 return (0);
720 }
721
722 static int
723 dump_symtab(pgcore_t *pgc, file_info_t *fptr, uint_t index, int dynsym)
724 {
725 sym_tbl_t *sym = dynsym ? &fptr->file_dynsym : &fptr->file_symtab;
726 shstrtype_t symname = dynsym ? STR_DYNSYM : STR_SYMTAB;
727 shstrtype_t strname = dynsym ? STR_DYNSTR : STR_STRTAB;
728 uint_t symtype = dynsym ? SHT_DYNSYM : SHT_SYMTAB;
729 size_t size;
730 uintptr_t addr = fptr->file_map->map_pmap.pr_vaddr;
731
732 if (sym->sym_data_pri == NULL || sym->sym_symn == 0 ||
733 sym->sym_strs == NULL)
734 return (0);
735
736 size = sym->sym_hdr_pri.sh_size;
737 if (gc_pwrite64(pgc->pgc_fd, sym->sym_data_pri->d_buf, size,
738 *pgc->pgc_doff) != 0)
739 return (-1);
740
741 if (write_shdr(pgc, symname, symtype, 0, addr, *pgc->pgc_doff, size,
742 index + 1, sym->sym_hdr_pri.sh_info, sym->sym_hdr_pri.sh_addralign,
743 sym->sym_hdr_pri.sh_entsize) != 0)
744 return (-1);
745
746 *pgc->pgc_doff += roundup(size, 8);
747
748 size = sym->sym_strhdr.sh_size;
749 if (gc_pwrite64(pgc->pgc_fd, sym->sym_strs, size, *pgc->pgc_doff) != 0)
750 return (-1);
751
752 if (write_shdr(pgc, strname, SHT_STRTAB, SHF_STRINGS, addr,
753 *pgc->pgc_doff, size, 0, 0, 1, 0) != 0)
754 return (-1);
755
756 *pgc->pgc_doff += roundup(size, 8);
757
758 return (0);
759 }
760
761 static int
762 dump_sections(pgcore_t *pgc)
763 {
764 struct ps_prochandle *P = pgc->P;
765 file_info_t *fptr;
766 uint_t cnt;
767 uint_t index = 1;
768
769 if (!(pgc->pgc_content & (CC_CONTENT_CTF | CC_CONTENT_SYMTAB)))
770 return (0);
771
772 fptr = list_next(&P->file_head);
773 for (cnt = P->num_files; cnt > 0; cnt--, fptr = list_next(fptr)) {
774 int hit_symtab = 0;
775
776 Pbuild_file_symtab(P, fptr);
777
778 if ((pgc->pgc_content & CC_CONTENT_CTF) &&
779 Pbuild_file_ctf(P, fptr) != NULL) {
780 sym_tbl_t *sym;
781 uint_t dynsym;
782 uint_t symindex = 0;
783
784 /*
785 * Write the symtab out first so we can correctly
786 * set the sh_link field in the CTF section header.
787 * symindex will be 0 if there is no corresponding
788 * symbol table section.
789 */
790 if (fptr->file_ctf_dyn) {
791 sym = &fptr->file_dynsym;
792 dynsym = 1;
793 } else {
794 sym = &fptr->file_symtab;
795 dynsym = 0;
796 hit_symtab = 1;
797 }
798
799 if (sym->sym_data_pri != NULL && sym->sym_symn != 0 &&
800 sym->sym_strs != NULL) {
801 symindex = index;
802 if (dump_symtab(pgc, fptr, index, dynsym) != 0)
803 return (-1);
804 index += 2;
805 }
806
807 /*
808 * Write the CTF data that we've read out of the
809 * file itself into the core file.
810 */
811 if (gc_pwrite64(pgc->pgc_fd, fptr->file_ctf_buf,
812 fptr->file_ctf_size, *pgc->pgc_doff) != 0)
813 return (-1);
814
815 if (write_shdr(pgc, STR_CTF, SHT_PROGBITS, 0,
816 fptr->file_map->map_pmap.pr_vaddr, *pgc->pgc_doff,
817 fptr->file_ctf_size, symindex, 0, 4, 0) != 0)
818 return (-1);
819
820 index++;
821 *pgc->pgc_doff += roundup(fptr->file_ctf_size, 8);
822 }
823
824 if ((pgc->pgc_content & CC_CONTENT_SYMTAB) && !hit_symtab &&
825 fptr->file_symtab.sym_data_pri != NULL &&
826 fptr->file_symtab.sym_symn != 0 &&
827 fptr->file_symtab.sym_strs != NULL) {
828 if (dump_symtab(pgc, fptr, index, 0) != 0)
829 return (-1);
830 index += 2;
831 }
832 }
833
834 return (0);
835 }
836
837 /*ARGSUSED*/
838 static int
839 dump_map(void *data, const prmap_t *pmp, const char *name)
840 {
841 pgcore_t *pgc = data;
842 struct ps_prochandle *P = pgc->P;
843 #ifdef _LP64
844 Elf64_Phdr phdr;
845 #else
846 Elf32_Phdr phdr;
847 #endif
848 size_t n;
849
850 bzero(&phdr, sizeof (phdr));
851 phdr.p_type = PT_LOAD;
852 phdr.p_vaddr = pmp->pr_vaddr;
853 phdr.p_memsz = pmp->pr_size;
854 if (pmp->pr_mflags & MA_READ)
855 phdr.p_flags |= PF_R;
856 if (pmp->pr_mflags & MA_WRITE)
857 phdr.p_flags |= PF_W;
858 if (pmp->pr_mflags & MA_EXEC)
859 phdr.p_flags |= PF_X;
860
861 if (pmp->pr_vaddr + pmp->pr_size > P->status.pr_stkbase &&
862 pmp->pr_vaddr < P->status.pr_stkbase + P->status.pr_stksize) {
863 if (!(pgc->pgc_content & CC_CONTENT_STACK))
864 goto exclude;
865
866 } else if ((pmp->pr_mflags & MA_ANON) &&
867 pmp->pr_vaddr + pmp->pr_size > P->status.pr_brkbase &&
868 pmp->pr_vaddr < P->status.pr_brkbase + P->status.pr_brksize) {
869 if (!(pgc->pgc_content & CC_CONTENT_HEAP))
870 goto exclude;
871
872 } else if (pmp->pr_mflags & MA_ISM) {
873 if (pmp->pr_mflags & MA_NORESERVE) {
874 if (!(pgc->pgc_content & CC_CONTENT_DISM))
875 goto exclude;
876 } else {
877 if (!(pgc->pgc_content & CC_CONTENT_ISM))
878 goto exclude;
879 }
880
881 } else if (pmp->pr_mflags & MA_SHM) {
882 if (!(pgc->pgc_content & CC_CONTENT_SHM))
883 goto exclude;
884
885 } else if (pmp->pr_mflags & MA_SHARED) {
886 if (pmp->pr_mflags & MA_ANON) {
887 if (!(pgc->pgc_content & CC_CONTENT_SHANON))
888 goto exclude;
889 } else {
890 if (!(pgc->pgc_content & CC_CONTENT_SHFILE))
891 goto exclude;
892 }
893
894 } else if (pmp->pr_mflags & MA_ANON) {
895 if (!(pgc->pgc_content & CC_CONTENT_ANON))
896 goto exclude;
897
898 } else if (phdr.p_flags == (PF_R | PF_X)) {
899 if (!(pgc->pgc_content & CC_CONTENT_TEXT))
900 goto exclude;
901
902 } else if (phdr.p_flags == PF_R) {
903 if (!(pgc->pgc_content & CC_CONTENT_RODATA))
904 goto exclude;
905
906 } else {
907 if (!(pgc->pgc_content & CC_CONTENT_DATA))
908 goto exclude;
909 }
910
911 n = 0;
912 while (n < pmp->pr_size) {
913 size_t csz = MIN(pmp->pr_size - n, pgc->pgc_chunksz);
914
915 /*
916 * If we can't read out part of the victim's address
917 * space for some reason ignore that failure and try to
918 * emit a partial core file without that mapping's data.
919 * As in the kernel, we mark these failures with the
920 * PF_SUNW_FAILURE flag and store the errno where the
921 * mapping would have been.
922 */
923 if (Pread(P, pgc->pgc_chunk, csz, pmp->pr_vaddr + n) != csz ||
924 gc_pwrite64(pgc->pgc_fd, pgc->pgc_chunk, csz,
925 *pgc->pgc_doff + n) != 0) {
926 int err = errno;
927 (void) gc_pwrite64(pgc->pgc_fd, &err, sizeof (err),
928 *pgc->pgc_doff);
929 *pgc->pgc_doff += roundup(sizeof (err), 8);
930
931 phdr.p_flags |= PF_SUNW_FAILURE;
932 (void) ftruncate64(pgc->pgc_fd, *pgc->pgc_doff);
933 goto exclude;
934 }
935
936 n += csz;
937 }
938
939 phdr.p_offset = *pgc->pgc_doff;
940 phdr.p_filesz = pmp->pr_size;
941 *pgc->pgc_doff += roundup(phdr.p_filesz, 8);
942
943 exclude:
944 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
945 if (gc_pwrite64(pgc->pgc_fd, &phdr, sizeof (phdr),
946 *pgc->pgc_poff) != 0)
947 return (1);
948
949 *pgc->pgc_poff += sizeof (phdr);
950 #ifdef _LP64
951 } else {
952 Elf32_Phdr phdr32;
953
954 bzero(&phdr32, sizeof (phdr32));
955 phdr32.p_type = phdr.p_type;
956 phdr32.p_vaddr = (Elf32_Addr)phdr.p_vaddr;
957 phdr32.p_memsz = (Elf32_Word)phdr.p_memsz;
958 phdr32.p_flags = phdr.p_flags;
959 phdr32.p_offset = (Elf32_Off)phdr.p_offset;
960 phdr32.p_filesz = (Elf32_Word)phdr.p_filesz;
961
962 if (gc_pwrite64(pgc->pgc_fd, &phdr32, sizeof (phdr32),
963 *pgc->pgc_poff) != 0)
964 return (1);
965
966 *pgc->pgc_poff += sizeof (phdr32);
967 #endif /* _LP64 */
968 }
969
970 return (0);
971 }
972
973 int
974 write_shstrtab(struct ps_prochandle *P, pgcore_t *pgc)
975 {
976 off64_t off = *pgc->pgc_doff;
977 size_t size = 0;
978 shstrtab_t *s = &pgc->pgc_shstrtab;
979 int i, ndx;
980
981 if (shstrtab_size(s) == 1)
982 return (0);
983
984 /*
985 * Preemptively stick the name of the shstrtab in the string table.
986 */
987 (void) shstrtab_ndx(&pgc->pgc_shstrtab, STR_SHSTRTAB);
988 size = shstrtab_size(s);
989
990 /*
991 * Dump all the strings that we used being sure we include the
992 * terminating null character.
993 */
994 for (i = 0; i < STR_NUM; i++) {
995 if ((ndx = s->sst_ndx[i]) != 0 || i == STR_NONE) {
996 const char *str = shstrtab_data[i];
997 size_t len = strlen(str) + 1;
998 if (gc_pwrite64(pgc->pgc_fd, str, len, off + ndx) != 0)
999 return (1);
1000 }
1001 }
1002
1003 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
1004 Elf32_Shdr shdr;
1005
1006 bzero(&shdr, sizeof (shdr));
1007 shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, STR_SHSTRTAB);
1008 shdr.sh_size = size;
1009 shdr.sh_offset = *pgc->pgc_doff;
1010 shdr.sh_addralign = 1;
1011 shdr.sh_flags = SHF_STRINGS;
1012 shdr.sh_type = SHT_STRTAB;
1013
1014 if (gc_pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),
1015 *pgc->pgc_soff) != 0)
1016 return (1);
1017
1018 *pgc->pgc_soff += sizeof (shdr);
1019 #ifdef _LP64
1020 } else {
1021 Elf64_Shdr shdr;
1022
1023 bzero(&shdr, sizeof (shdr));
1024 shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, STR_SHSTRTAB);
1025 shdr.sh_size = size;
1026 shdr.sh_offset = *pgc->pgc_doff;
1027 shdr.sh_addralign = 1;
1028 shdr.sh_flags = SHF_STRINGS;
1029 shdr.sh_type = SHT_STRTAB;
1030
1031 if (gc_pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),
1032 *pgc->pgc_soff) != 0)
1033 return (1);
1034
1035 *pgc->pgc_soff += sizeof (shdr);
1036 #endif /* _LP64 */
1037 }
1038
1039 *pgc->pgc_doff += roundup(size, 8);
1040
1041 return (0);
1042 }
1043
1044 /*
1045 * Don't explicity stop the process; that's up to the consumer.
1046 */
1047 int
1048 Pfgcore(struct ps_prochandle *P, int fd, core_content_t content)
1049 {
1050 char plat[SYS_NMLN];
1051 char zonename[ZONENAME_MAX];
1052 int platlen = -1;
1053 pgcore_t pgc;
1054 off64_t poff, soff, doff, boff;
1055 struct utsname uts;
1056 uint_t nphdrs, nshdrs;
1057
1058 if (ftruncate64(fd, 0) != 0)
1059 return (-1);
1060
1061 if (content == CC_CONTENT_INVALID) {
1062 errno = EINVAL;
1063 return (-1);
1064 }
1065
1066 /*
1067 * Cache the mappings and other useful data.
1068 */
1069 (void) Prd_agent(P);
1070 (void) Ppsinfo(P);
1071
1072 pgc.P = P;
1073 pgc.pgc_fd = fd;
1074 pgc.pgc_poff = &poff;
1075 pgc.pgc_soff = &soff;
1076 pgc.pgc_doff = &doff;
1077 pgc.pgc_content = content;
1078 pgc.pgc_chunksz = PAGESIZE;
1079 if ((pgc.pgc_chunk = malloc(pgc.pgc_chunksz)) == NULL)
1080 return (-1);
1081
1082 shstrtab_init(&pgc.pgc_shstrtab);
1083
1084 /*
1085 * There are two PT_NOTE program headers for ancillary data, and
1086 * one for each mapping.
1087 */
1088 nphdrs = 2 + P->map_count;
1089 nshdrs = count_sections(&pgc);
1090
1091 (void) Pplatform(P, plat, sizeof (plat));
1092 platlen = strlen(plat) + 1;
1093 Preadauxvec(P);
1094 (void) Puname(P, &uts);
1095 if (Pzonename(P, zonename, sizeof (zonename)) == NULL)
1096 zonename[0] = '\0';
1097
1098 /*
1099 * The core file contents may required zero section headers, but if we
1100 * overflow the 16 bits allotted to the program header count in the ELF
1101 * header, we'll need that program header at index zero.
1102 */
1103 if (nshdrs == 0 && nphdrs >= PN_XNUM)
1104 nshdrs = 1;
1105
1106 /*
1107 * Set up the ELF header.
1108 */
1109 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
1110 Elf32_Ehdr ehdr;
1111
1112 bzero(&ehdr, sizeof (ehdr));
1113 ehdr.e_ident[EI_MAG0] = ELFMAG0;
1114 ehdr.e_ident[EI_MAG1] = ELFMAG1;
1115 ehdr.e_ident[EI_MAG2] = ELFMAG2;
1116 ehdr.e_ident[EI_MAG3] = ELFMAG3;
1117 ehdr.e_type = ET_CORE;
1118
1119 ehdr.e_ident[EI_CLASS] = ELFCLASS32;
1120 #if defined(__sparc)
1121 ehdr.e_machine = EM_SPARC;
1122 ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
1123 #elif defined(__i386) || defined(__amd64)
1124 ehdr.e_machine = EM_386;
1125 ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
1126 #else
1127 #error "unknown machine type"
1128 #endif
1129 ehdr.e_ident[EI_VERSION] = EV_CURRENT;
1130
1131 ehdr.e_version = EV_CURRENT;
1132 ehdr.e_ehsize = sizeof (ehdr);
1133
1134 if (nphdrs >= PN_XNUM)
1135 ehdr.e_phnum = PN_XNUM;
1136 else
1137 ehdr.e_phnum = (unsigned short)nphdrs;
1138
1139 ehdr.e_phentsize = sizeof (Elf32_Phdr);
1140 ehdr.e_phoff = ehdr.e_ehsize;
1141
1142 if (nshdrs > 0) {
1143 if (nshdrs >= SHN_LORESERVE)
1144 ehdr.e_shnum = 0;
1145 else
1146 ehdr.e_shnum = (unsigned short)nshdrs;
1147
1148 if (nshdrs - 1 >= SHN_LORESERVE)
1149 ehdr.e_shstrndx = SHN_XINDEX;
1150 else
1151 ehdr.e_shstrndx = (unsigned short)(nshdrs - 1);
1152
1153 ehdr.e_shentsize = sizeof (Elf32_Shdr);
1154 ehdr.e_shoff = ehdr.e_phoff + ehdr.e_phentsize * nphdrs;
1155 }
1156
1157 if (gc_pwrite64(fd, &ehdr, sizeof (ehdr), 0) != 0)
1158 goto err;
1159
1160 poff = ehdr.e_phoff;
1161 soff = ehdr.e_shoff;
1162 doff = boff = ehdr.e_ehsize +
1163 ehdr.e_phentsize * nphdrs +
1164 ehdr.e_shentsize * nshdrs;
1165
1166 #ifdef _LP64
1167 } else {
1168 Elf64_Ehdr ehdr;
1169
1170 bzero(&ehdr, sizeof (ehdr));
1171 ehdr.e_ident[EI_MAG0] = ELFMAG0;
1172 ehdr.e_ident[EI_MAG1] = ELFMAG1;
1173 ehdr.e_ident[EI_MAG2] = ELFMAG2;
1174 ehdr.e_ident[EI_MAG3] = ELFMAG3;
1175 ehdr.e_type = ET_CORE;
1176
1177 ehdr.e_ident[EI_CLASS] = ELFCLASS64;
1178 #if defined(__sparc)
1179 ehdr.e_machine = EM_SPARCV9;
1180 ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
1181 #elif defined(__i386) || defined(__amd64)
1182 ehdr.e_machine = EM_AMD64;
1183 ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
1184 #else
1185 #error "unknown machine type"
1186 #endif
1187 ehdr.e_ident[EI_VERSION] = EV_CURRENT;
1188
1189 ehdr.e_version = EV_CURRENT;
1190 ehdr.e_ehsize = sizeof (ehdr);
1191
1192 if (nphdrs >= PN_XNUM)
1193 ehdr.e_phnum = PN_XNUM;
1194 else
1195 ehdr.e_phnum = (unsigned short)nphdrs;
1196
1197 ehdr.e_phentsize = sizeof (Elf64_Phdr);
1198 ehdr.e_phoff = ehdr.e_ehsize;
1199
1200 if (nshdrs > 0) {
1201 if (nshdrs >= SHN_LORESERVE)
1202 ehdr.e_shnum = 0;
1203 else
1204 ehdr.e_shnum = (unsigned short)nshdrs;
1205
1206 if (nshdrs - 1 >= SHN_LORESERVE)
1207 ehdr.e_shstrndx = SHN_XINDEX;
1208 else
1209 ehdr.e_shstrndx = (unsigned short)(nshdrs - 1);
1210
1211 ehdr.e_shentsize = sizeof (Elf64_Shdr);
1212 ehdr.e_shoff = ehdr.e_phoff + ehdr.e_phentsize * nphdrs;
1213 }
1214
1215 if (gc_pwrite64(fd, &ehdr, sizeof (ehdr), 0) != 0)
1216 goto err;
1217
1218 poff = ehdr.e_phoff;
1219 soff = ehdr.e_shoff;
1220 doff = boff = ehdr.e_ehsize +
1221 ehdr.e_phentsize * nphdrs +
1222 ehdr.e_shentsize * nshdrs;
1223
1224 #endif /* _LP64 */
1225 }
1226
1227 /*
1228 * Write the zero indexed section if it exists.
1229 */
1230 if (nshdrs > 0 && write_shdr(&pgc, STR_NONE, 0, 0, 0, 0,
1231 nshdrs >= SHN_LORESERVE ? nshdrs : 0,
1232 nshdrs - 1 >= SHN_LORESERVE ? nshdrs - 1 : 0,
1233 nphdrs >= PN_XNUM ? nphdrs : 0, 0, 0) != 0)
1234 goto err;
1235
1236 /*
1237 * Construct the old-style note header and section.
1238 */
1239
1240 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
1241 prpsinfo_t prpsinfo;
1242
1243 mkprpsinfo(P, &prpsinfo);
1244 if (write_note(fd, NT_PRPSINFO, &prpsinfo, sizeof (prpsinfo_t),
1245 &doff) != 0) {
1246 goto err;
1247 }
1248 if (write_note(fd, NT_AUXV, P->auxv,
1249 P->nauxv * sizeof (P->auxv[0]), &doff) != 0) {
1250 goto err;
1251 }
1252 #ifdef _LP64
1253 } else {
1254 prpsinfo32_t pi32;
1255 auxv32_t *av32;
1256 size_t size = sizeof (auxv32_t) * P->nauxv;
1257 int i;
1258
1259 mkprpsinfo32(P, &pi32);
1260 if (write_note(fd, NT_PRPSINFO, &pi32, sizeof (prpsinfo32_t),
1261 &doff) != 0) {
1262 goto err;
1263 }
1264
1265 if ((av32 = malloc(size)) == NULL)
1266 goto err;
1267
1268 for (i = 0; i < P->nauxv; i++) {
1269 auxv_n_to_32(&P->auxv[i], &av32[i]);
1270 }
1271
1272 if (write_note(fd, NT_AUXV, av32, size, &doff) != 0) {
1273 free(av32);
1274 goto err;
1275 }
1276
1277 free(av32);
1278 #endif /* _LP64 */
1279 }
1280
1281 if (write_note(fd, NT_PLATFORM, plat, platlen, &doff) != 0)
1282 goto err;
1283
1284 if (Plwp_iter_all(P, old_per_lwp, &pgc) != 0)
1285 goto err;
1286
1287 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
1288 Elf32_Phdr phdr;
1289
1290 bzero(&phdr, sizeof (phdr));
1291 phdr.p_type = PT_NOTE;
1292 phdr.p_flags = PF_R;
1293 phdr.p_offset = (Elf32_Off)boff;
1294 phdr.p_filesz = doff - boff;
1295 boff = doff;
1296
1297 if (gc_pwrite64(fd, &phdr, sizeof (phdr), poff) != 0)
1298 goto err;
1299 poff += sizeof (phdr);
1300 #ifdef _LP64
1301 } else {
1302 Elf64_Phdr phdr;
1303
1304 bzero(&phdr, sizeof (phdr));
1305 phdr.p_type = PT_NOTE;
1306 phdr.p_flags = PF_R;
1307 phdr.p_offset = boff;
1308 phdr.p_filesz = doff - boff;
1309 boff = doff;
1310
1311 if (gc_pwrite64(fd, &phdr, sizeof (phdr), poff) != 0)
1312 goto err;
1313 poff += sizeof (phdr);
1314 #endif /* _LP64 */
1315 }
1316
1317 /*
1318 * Construct the new-style note header and section.
1319 */
1320
1321 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
1322 if (write_note(fd, NT_PSINFO, &P->psinfo, sizeof (psinfo_t),
1323 &doff) != 0) {
1324 goto err;
1325 }
1326 if (write_note(fd, NT_PSTATUS, &P->status, sizeof (pstatus_t),
1327 &doff) != 0) {
1328 goto err;
1329 }
1330 if (write_note(fd, NT_AUXV, P->auxv,
1331 P->nauxv * sizeof (P->auxv[0]), &doff) != 0) {
1332 goto err;
1333 }
1334 #ifdef _LP64
1335 } else {
1336 psinfo32_t pi32;
1337 pstatus32_t ps32;
1338 auxv32_t *av32;
1339 size_t size = sizeof (auxv32_t) * P->nauxv;
1340 int i;
1341
1342 psinfo_n_to_32(&P->psinfo, &pi32);
1343 if (write_note(fd, NT_PSINFO, &pi32, sizeof (psinfo32_t),
1344 &doff) != 0) {
1345 goto err;
1346 }
1347 pstatus_n_to_32(&P->status, &ps32);
1348 if (write_note(fd, NT_PSTATUS, &ps32, sizeof (pstatus32_t),
1349 &doff) != 0) {
1350 goto err;
1351 }
1352 if ((av32 = malloc(size)) == NULL)
1353 goto err;
1354
1355 for (i = 0; i < P->nauxv; i++) {
1356 auxv_n_to_32(&P->auxv[i], &av32[i]);
1357 }
1358
1359 if (write_note(fd, NT_AUXV, av32, size, &doff) != 0) {
1360 free(av32);
1361 goto err;
1362 }
1363
1364 free(av32);
1365 #endif /* _LP64 */
1366 }
1367
1368 if (write_note(fd, NT_PLATFORM, plat, platlen, &doff) != 0 ||
1369 write_note(fd, NT_UTSNAME, &uts, sizeof (uts), &doff) != 0 ||
1370 write_note(fd, NT_CONTENT, &content, sizeof (content), &doff) != 0)
1371 goto err;
1372
1373 {
1374 prcred_t cred, *cp;
1375 size_t size = sizeof (prcred_t);
1376
1377 if (Pcred(P, &cred, 0) != 0)
1378 goto err;
1379
1380 if (cred.pr_ngroups > 0)
1381 size += sizeof (gid_t) * (cred.pr_ngroups - 1);
1382 if ((cp = malloc(size)) == NULL)
1383 goto err;
1384
1385 if (Pcred(P, cp, cred.pr_ngroups) != 0 ||
1386 write_note(fd, NT_PRCRED, cp, size, &doff) != 0) {
1387 free(cp);
1388 goto err;
1389 }
1390
1391 free(cp);
1392 }
1393
1394 {
1395 prpriv_t *ppriv = NULL;
1396 const priv_impl_info_t *pinfo;
1397 size_t pprivsz, pinfosz;
1398
1399 if (Ppriv(P, &ppriv) == -1)
1400 goto err;
1401 pprivsz = PRIV_PRPRIV_SIZE(ppriv);
1402
1403 if (write_note(fd, NT_PRPRIV, ppriv, pprivsz, &doff) != 0) {
1404 Ppriv_free(P, ppriv);
1405 goto err;
1406 }
1407 Ppriv_free(P, ppriv);
1408
1409 if ((pinfo = getprivimplinfo()) == NULL)
1410 goto err;
1411 pinfosz = PRIV_IMPL_INFO_SIZE(pinfo);
1412
1413 if (write_note(fd, NT_PRPRIVINFO, pinfo, pinfosz, &doff) != 0)
1414 goto err;
1415 }
1416
1417 if (write_note(fd, NT_ZONENAME, zonename, strlen(zonename) + 1,
1418 &doff) != 0)
1419 goto err;
1420
1421 {
1422 fditer_t iter;
1423 iter.fd_fd = fd;
1424 iter.fd_doff = &doff;
1425
1426 if (Pfdinfo_iter(P, iter_fd, &iter) != 0)
1427 goto err;
1428 }
1429
1430
1431 {
1432 prsecflags_t *psf = NULL;
1433
1434 if (Psecflags(P, &psf) != 0)
1435 goto err;
1436
1437 if (write_note(fd, NT_SECFLAGS, psf,
1438 sizeof (prsecflags_t), &doff) != 0) {
1439 Psecflags_free(psf);
1440 goto err;
1441 }
1442
1443 Psecflags_free(psf);
1444 }
1445
1446 #if defined(__i386) || defined(__amd64)
1447 /* CSTYLED */
1448 {
1449 struct ssd *ldtp;
1450 size_t size;
1451 int nldt;
1452
1453 /*
1454 * Only dump out non-zero sized LDT notes.
1455 */
1456 if ((nldt = Pldt(P, NULL, 0)) != 0) {
1457 size = sizeof (struct ssd) * nldt;
1458 if ((ldtp = malloc(size)) == NULL)
1459 goto err;
1460
1461 if (Pldt(P, ldtp, nldt) == -1 ||
1462 write_note(fd, NT_LDT, ldtp, size, &doff) != 0) {
1463 free(ldtp);
1464 goto err;
1465 }
1466
1467 free(ldtp);
1468 }
1469 }
1470 #endif /* __i386 || __amd64 */
1471
1472 if (Plwp_iter_all(P, new_per_lwp, &pgc) != 0)
1473 goto err;
1474
1475 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
1476 Elf32_Phdr phdr;
1477
1478 bzero(&phdr, sizeof (phdr));
1479 phdr.p_type = PT_NOTE;
1480 phdr.p_flags = PF_R;
1481 phdr.p_offset = (Elf32_Off)boff;
1482 phdr.p_filesz = doff - boff;
1483 boff = doff;
1484
1485 if (gc_pwrite64(fd, &phdr, sizeof (phdr), poff) != 0)
1486 goto err;
1487 poff += sizeof (phdr);
1488 #ifdef _LP64
1489 } else {
1490 Elf64_Phdr phdr;
1491
1492 bzero(&phdr, sizeof (phdr));
1493 phdr.p_type = PT_NOTE;
1494 phdr.p_flags = PF_R;
1495 phdr.p_offset = boff;
1496 phdr.p_filesz = doff - boff;
1497 boff = doff;
1498
1499 if (gc_pwrite64(fd, &phdr, sizeof (phdr), poff) != 0)
1500 goto err;
1501 poff += sizeof (phdr);
1502 #endif /* _LP64 */
1503 }
1504
1505 /*
1506 * Construct the headers for each mapping and write out its data
1507 * if the content parameter indicates that it should be present
1508 * in the core file.
1509 */
1510 if (Pmapping_iter(P, dump_map, &pgc) != 0)
1511 goto err;
1512
1513 if (dump_sections(&pgc) != 0)
1514 goto err;
1515
1516 if (write_shstrtab(P, &pgc) != 0)
1517 goto err;
1518
1519 free(pgc.pgc_chunk);
1520
1521 return (0);
1522
1523 err:
1524 /*
1525 * Wipe out anything we may have written if there was an error.
1526 */
1527 (void) ftruncate64(fd, 0);
1528 free(pgc.pgc_chunk);
1529
1530 return (-1);
1531 }
1532
1533 static const char *content_str[] = {
1534 "stack", /* CC_CONTENT_STACK */
1535 "heap", /* CC_CONTENT_HEAP */
1536 "shfile", /* CC_CONTENT_SHFILE */
1537 "shanon", /* CC_CONTENT_SHANON */
1538 "text", /* CC_CONTENT_TEXT */
1539 "data", /* CC_CONTENT_DATA */
1540 "rodata", /* CC_CONTENT_RODATA */
1541 "anon", /* CC_CONTENT_ANON */
1542 "shm", /* CC_CONTENT_SHM */
1543 "ism", /* CC_CONTENT_ISM */
1544 "dism", /* CC_CONTENT_DISM */
1545 "ctf", /* CC_CONTENT_CTF */
1546 "symtab", /* CC_CONTENT_SYMTAB */
1547 };
1548
1549 static uint_t ncontent_str = sizeof (content_str) / sizeof (content_str[0]);
1550
1551 #define STREQ(a, b, n) (strlen(b) == (n) && strncmp(a, b, n) == 0)
1552
1553 int
1554 proc_str2content(const char *str, core_content_t *cp)
1555 {
1556 const char *cur = str;
1557 int add = 1;
1558 core_content_t mask, content = 0;
1559
1560 for (;;) {
1561 for (cur = str; isalpha(*cur); cur++)
1562 continue;
1563
1564 if (STREQ(str, "default", cur - str)) {
1565 mask = CC_CONTENT_DEFAULT;
1566 } else if (STREQ(str, "all", cur - str)) {
1567 mask = CC_CONTENT_ALL;
1568 } else if (STREQ(str, "none", cur - str)) {
1569 mask = 0;
1570 } else {
1571 int i = 0;
1572
1573 while (!STREQ(str, content_str[i], cur - str)) {
1574 i++;
1575
1576 if (i >= ncontent_str)
1577 return (-1);
1578 }
1579
1580 mask = (core_content_t)1 << i;
1581 }
1582
1583 if (add)
1584 content |= mask;
1585 else
1586 content &= ~mask;
1587
1588 switch (*cur) {
1589 case '\0':
1590 *cp = content;
1591 return (0);
1592 case '+':
1593 add = 1;
1594 break;
1595 case '-':
1596 add = 0;
1597 break;
1598 default:
1599 return (-1);
1600 }
1601
1602 str = cur + 1;
1603 }
1604 }
1605
1606 static int
1607 popc(core_content_t x)
1608 {
1609 int i;
1610
1611 for (i = 0; x != 0; i++)
1612 x &= x - 1;
1613
1614 return (i);
1615 }
1616
1617 int
1618 proc_content2str(core_content_t content, char *buf, size_t size)
1619 {
1620 int nonecnt, defcnt, allcnt;
1621 core_content_t mask, bit;
1622 int first;
1623 uint_t index;
1624 size_t n, tot = 0;
1625
1626 if (content == 0)
1627 return ((int)strlcpy(buf, "none", size));
1628
1629 if (content & ~CC_CONTENT_ALL)
1630 return ((int)strlcpy(buf, "<invalid>", size));
1631
1632 nonecnt = popc(content);
1633 defcnt = 1 + popc(content ^ CC_CONTENT_DEFAULT);
1634 allcnt = 1 + popc(content ^ CC_CONTENT_ALL);
1635
1636 if (defcnt <= nonecnt && defcnt <= allcnt) {
1637 mask = content ^ CC_CONTENT_DEFAULT;
1638 first = 0;
1639 tot += (n = strlcpy(buf, "default", size));
1640 if (n > size)
1641 n = size;
1642 buf += n;
1643 size -= n;
1644 } else if (allcnt < nonecnt) {
1645 mask = content ^ CC_CONTENT_ALL;
1646 first = 0;
1647 tot += (n = strlcpy(buf, "all", size));
1648 if (n > size)
1649 n = size;
1650 buf += n;
1651 size -= n;
1652 } else {
1653 mask = content;
1654 first = 1;
1655 }
1656
1657 while (mask != 0) {
1658 bit = mask ^ (mask & (mask - 1));
1659
1660 if (!first) {
1661 if (size > 1) {
1662 *buf = (bit & content) ? '+' : '-';
1663 buf++;
1664 size--;
1665 }
1666
1667 tot++;
1668 }
1669 index = popc(bit - 1);
1670 tot += (n = strlcpy(buf, content_str[index], size));
1671 if (n > size)
1672 n = size;
1673 buf += n;
1674 size -= n;
1675
1676 mask ^= bit;
1677 first = 0;
1678 }
1679
1680 return ((int)tot);
1681 }
Unleashed OS