xref: /illumos-gate/usr/src/cmd/ptools/pflags/pflags.c (revision f971a346)
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 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
29  */
30 
31 #include <stdio.h>
32 #include <stdio_ext.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <ctype.h>
36 #include <fcntl.h>
37 #include <strings.h>
38 #include <dirent.h>
39 #include <errno.h>
40 #include <sys/types.h>
41 #include <sys/int_fmtio.h>
42 #include <libproc.h>
43 
44 typedef struct look_arg {
45 	int pflags;
46 	const char *lwps;
47 	int count;
48 } look_arg_t;
49 
50 static	int	look(char *);
51 static	int	lwplook(look_arg_t *, const lwpstatus_t *, const lwpsinfo_t *);
52 static	char	*prflags(int);
53 static	char	*prwhy(int);
54 static	char	*prwhat(int, int);
55 static	void	dumpregs(const prgregset_t, int);
56 #if defined(__sparc) && defined(_ILP32)
57 static	void	dumpregs_v8p(const prgregset_t, const prxregset_t *, int);
58 #endif
59 
60 static	char	*command;
61 static	struct	ps_prochandle *Pr;
62 
63 static	int	is64;	/* Is current process 64-bit? */
64 static	int	rflag;	/* Show registers? */
65 
66 #define	LWPFLAGS	\
67 	(PR_STOPPED|PR_ISTOP|PR_DSTOP|PR_ASLEEP|PR_PCINVAL|PR_STEP \
68 	|PR_AGENT|PR_DETACH|PR_DAEMON)
69 
70 #define	PROCFLAGS	\
71 	(PR_ISSYS|PR_VFORKP|PR_ORPHAN|PR_NOSIGCHLD|PR_WAITPID \
72 	|PR_FORK|PR_RLC|PR_KLC|PR_ASYNC|PR_BPTADJ|PR_MSACCT|PR_MSFORK|PR_PTRACE)
73 
74 #define	ALLFLAGS	(LWPFLAGS|PROCFLAGS)
75 
76 int
main(int argc,char ** argv)77 main(int argc, char **argv)
78 {
79 	int rc = 0;
80 	int errflg = 0;
81 	int opt;
82 	struct rlimit rlim;
83 
84 	if ((command = strrchr(argv[0], '/')) != NULL)
85 		command++;
86 	else
87 		command = argv[0];
88 
89 	/* options */
90 	while ((opt = getopt(argc, argv, "r")) != EOF) {
91 		switch (opt) {
92 		case 'r':		/* show registers */
93 			rflag = 1;
94 			break;
95 		default:
96 			errflg = 1;
97 			break;
98 		}
99 	}
100 
101 	argc -= optind;
102 	argv += optind;
103 
104 	if (errflg || argc <= 0) {
105 		(void) fprintf(stderr,
106 		    "usage:\t%s [-r] { pid | core }[/lwps] ...\n", command);
107 		(void) fprintf(stderr, "  (report process status flags)\n");
108 		(void) fprintf(stderr, "  -r : report registers\n");
109 		return (2);
110 	}
111 
112 	/*
113 	 * Make sure we'll have enough file descriptors to handle a target
114 	 * that has many many mappings.
115 	 */
116 	if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
117 		rlim.rlim_cur = rlim.rlim_max;
118 		(void) setrlimit(RLIMIT_NOFILE, &rlim);
119 		(void) enable_extended_FILE_stdio(-1, -1);
120 	}
121 
122 	while (argc-- > 0)
123 		rc += look(*argv++);
124 
125 	return (rc);
126 }
127 
128 static int
look(char * arg)129 look(char *arg)
130 {
131 	int gcode;
132 	int gcode2;
133 	pstatus_t pstatus;
134 	psinfo_t psinfo;
135 	int flags;
136 	sigset_t sigmask;
137 	fltset_t fltmask;
138 	sysset_t entryset;
139 	sysset_t exitset;
140 	uint32_t sigtrace, sigtrace1, sigtrace2, fltbits;
141 	uint32_t sigpend, sigpend1, sigpend2;
142 	uint32_t *bits;
143 	char buf[PRSIGBUFSZ];
144 	look_arg_t lookarg;
145 
146 	if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_ANY,
147 	    PGRAB_RETAIN | PGRAB_FORCE | PGRAB_RDONLY | PGRAB_NOSTOP, &gcode,
148 	    &lookarg.lwps)) == NULL) {
149 		if (gcode == G_NOPROC &&
150 		    proc_arg_psinfo(arg, PR_ARG_PIDS, &psinfo, &gcode2) > 0 &&
151 		    psinfo.pr_nlwp == 0) {
152 			(void) printf("%d:\t<defunct>\n\n", (int)psinfo.pr_pid);
153 			return (0);
154 		}
155 		(void) fprintf(stderr, "%s: cannot examine %s: %s\n",
156 		    command, arg, Pgrab_error(gcode));
157 		return (1);
158 	}
159 
160 	(void) memcpy(&pstatus, Pstatus(Pr), sizeof (pstatus_t));
161 	(void) memcpy(&psinfo, Ppsinfo(Pr), sizeof (psinfo_t));
162 	proc_unctrl_psinfo(&psinfo);
163 
164 	if (psinfo.pr_nlwp == 0) {
165 		(void) printf("%d:\t<defunct>\n\n", (int)psinfo.pr_pid);
166 		Prelease(Pr, PRELEASE_RETAIN);
167 		return (0);
168 	}
169 
170 	is64 = (pstatus.pr_dmodel == PR_MODEL_LP64);
171 
172 	sigmask = pstatus.pr_sigtrace;
173 	fltmask = pstatus.pr_flttrace;
174 	entryset = pstatus.pr_sysentry;
175 	exitset = pstatus.pr_sysexit;
176 
177 	if (Pstate(Pr) == PS_DEAD) {
178 		(void) printf("core '%s' of %d:\t%.70s\n",
179 		    arg, (int)psinfo.pr_pid, psinfo.pr_psargs);
180 	} else {
181 		(void) printf("%d:\t%.70s\n",
182 		    (int)psinfo.pr_pid, psinfo.pr_psargs);
183 	}
184 
185 	(void) printf("\tdata model = %s", is64? "_LP64" : "_ILP32");
186 	if ((flags = (pstatus.pr_flags & PROCFLAGS)) != 0)
187 		(void) printf("  flags = %s", prflags(flags));
188 	(void) printf("\n");
189 
190 	fltbits = *((uint32_t *)&fltmask);
191 	if (fltbits)
192 		(void) printf("\tflttrace = 0x%.8x\n", fltbits);
193 
194 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32)	/* assumption */
195 	sigtrace = *((uint32_t *)&sigmask);
196 	sigtrace1 = *((uint32_t *)&sigmask + 1);
197 	sigtrace2 = *((uint32_t *)&sigmask + 2);
198 #else
199 #error "fix me: MAXSIG out of bounds"
200 #endif
201 	if (sigtrace | sigtrace1 | sigtrace2)
202 		(void) printf("\tsigtrace = 0x%.8x 0x%.8x 0x%.8x\n\t    %s\n",
203 		    sigtrace, sigtrace1, sigtrace2,
204 		    proc_sigset2str(&sigmask, "|", 1, buf, sizeof (buf)));
205 
206 	bits = ((uint32_t *)&entryset);
207 	if (bits[0] | bits[1] | bits[2] | bits[3] |
208 	    bits[4] | bits[5] | bits[6] | bits[7])
209 		(void) printf(
210 		    "\tentryset = "
211 		    "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n"
212 		    "\t           "
213 		    "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n",
214 		    bits[0], bits[1], bits[2], bits[3],
215 		    bits[4], bits[5], bits[6], bits[7]);
216 
217 	bits = ((uint32_t *)&exitset);
218 	if (bits[0] | bits[1] | bits[2] | bits[3] |
219 	    bits[4] | bits[5] | bits[6] | bits[7])
220 		(void) printf(
221 		    "\texitset  = "
222 		    "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n"
223 		    "\t           "
224 		    "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n",
225 		    bits[0], bits[1], bits[2], bits[3],
226 		    bits[4], bits[5], bits[6], bits[7]);
227 
228 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32)	/* assumption */
229 	sigpend  = *((uint32_t *)&pstatus.pr_sigpend);
230 	sigpend1 = *((uint32_t *)&pstatus.pr_sigpend + 1);
231 	sigpend2 = *((uint32_t *)&pstatus.pr_sigpend + 2);
232 #else
233 #error "fix me: MAXSIG out of bounds"
234 #endif
235 	if (sigpend | sigpend1 | sigpend2)
236 		(void) printf("\tsigpend = 0x%.8x,0x%.8x,0x%.8x\n",
237 		    sigpend, sigpend1, sigpend2);
238 
239 	lookarg.pflags = pstatus.pr_flags;
240 	lookarg.count = 0;
241 	(void) Plwp_iter_all(Pr, (proc_lwp_all_f *)lwplook, &lookarg);
242 
243 	if (lookarg.count == 0)
244 		(void) printf("No matching lwps found");
245 
246 	(void) printf("\n");
247 	Prelease(Pr, PRELEASE_RETAIN);
248 
249 	return (0);
250 }
251 
252 static int
lwplook_zombie(const lwpsinfo_t * pip)253 lwplook_zombie(const lwpsinfo_t *pip)
254 {
255 	(void) printf(" /%d:\t<defunct>\n", (int)pip->pr_lwpid);
256 	return (0);
257 }
258 
259 static int
lwplook(look_arg_t * arg,const lwpstatus_t * psp,const lwpsinfo_t * pip)260 lwplook(look_arg_t *arg, const lwpstatus_t *psp, const lwpsinfo_t *pip)
261 {
262 	int flags;
263 	uint32_t sighold, sighold1, sighold2;
264 	uint32_t sigpend, sigpend1, sigpend2;
265 	psinfo_t ps;
266 	int cursig;
267 	char buf[32];
268 
269 	if (!proc_lwp_in_set(arg->lwps, pip->pr_lwpid))
270 		return (0);
271 
272 	arg->count++;
273 
274 	if (psp == NULL)
275 		return (lwplook_zombie(pip));
276 
277 	/*
278 	 * PR_PCINVAL is just noise if the lwp is not stopped.
279 	 * Don't bother reporting it unless the lwp is stopped.
280 	 */
281 	flags = psp->pr_flags & LWPFLAGS;
282 	if (!(flags & PR_STOPPED))
283 		flags &= ~PR_PCINVAL;
284 
285 	(void) printf(" /%d:\tflags = %s", (int)psp->pr_lwpid, prflags(flags));
286 	if ((flags & PR_ASLEEP) || (psp->pr_syscall &&
287 	    !(arg->pflags & PR_ISSYS))) {
288 		if (flags & PR_ASLEEP) {
289 			if ((flags & ~PR_ASLEEP) != 0)
290 				(void) printf("|");
291 			(void) printf("ASLEEP");
292 		}
293 		if (psp->pr_syscall && !(arg->pflags & PR_ISSYS)) {
294 			uint_t i;
295 
296 			(void) printf("  %s(",
297 			    proc_sysname(psp->pr_syscall, buf, sizeof (buf)));
298 			for (i = 0; i < psp->pr_nsysarg; i++) {
299 				if (i != 0)
300 					(void) printf(",");
301 				(void) printf("0x%lx", psp->pr_sysarg[i]);
302 			}
303 			(void) printf(")");
304 		}
305 	}
306 	(void) printf("\n");
307 
308 	if (flags & PR_STOPPED) {
309 		(void) printf("\twhy = %s", prwhy(psp->pr_why));
310 		if (psp->pr_why != PR_REQUESTED &&
311 		    psp->pr_why != PR_SUSPENDED)
312 			(void) printf("  what = %s",
313 			    prwhat(psp->pr_why, psp->pr_what));
314 		(void) printf("\n");
315 	}
316 
317 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32)	/* assumption */
318 	sighold  = *((uint32_t *)&psp->pr_lwphold);
319 	sighold1 = *((uint32_t *)&psp->pr_lwphold + 1);
320 	sighold2 = *((uint32_t *)&psp->pr_lwphold + 2);
321 	sigpend  = *((uint32_t *)&psp->pr_lwppend);
322 	sigpend1 = *((uint32_t *)&psp->pr_lwppend + 1);
323 	sigpend2 = *((uint32_t *)&psp->pr_lwppend + 2);
324 #else
325 #error "fix me: MAXSIG out of bounds"
326 #endif
327 	cursig   = psp->pr_cursig;
328 
329 	if (sighold | sighold1 | sighold2)
330 		(void) printf("\tsigmask = 0x%.8x,0x%.8x,0x%.8x\n",
331 		    sighold, sighold1, sighold2);
332 	if (sigpend | sigpend1 | sigpend2)
333 		(void) printf("\tlwppend = 0x%.8x,0x%.8x,0x%.8x\n",
334 		    sigpend, sigpend1, sigpend2);
335 	if (cursig)
336 		(void) printf("\tcursig = %s\n",
337 		    proc_signame(cursig, buf, sizeof (buf)));
338 
339 	if ((flags & PR_AGENT) &&
340 	    Plwp_getspymaster(Pr, pip->pr_lwpid, &ps) == 0) {
341 		time_t time = ps.pr_time.tv_sec;
342 		char t[64];
343 
344 		(void) strftime(t, sizeof (t), "%F:%H.%M.%S", localtime(&time));
345 
346 		(void) printf("\tspymaster = pid %d, \"%s\" at %s\n",
347 		    (int)ps.pr_pid, ps.pr_psargs, t);
348 	}
349 
350 	if (rflag) {
351 		if (Pstate(Pr) == PS_DEAD || (arg->pflags & PR_STOPPED)) {
352 #if defined(__sparc) && defined(_ILP32)
353 			/*
354 			 * If we're SPARC/32-bit, see if we can get extra
355 			 * register state for this lwp.  If it's a v8plus
356 			 * program, print the 64-bit register values.
357 			 */
358 			prxregset_t prx;
359 
360 			if (Plwp_getxregs(Pr, psp->pr_lwpid, &prx) == 0 &&
361 			    prx.pr_type == XR_TYPE_V8P)
362 				dumpregs_v8p(psp->pr_reg, &prx, is64);
363 			else
364 #endif	/* __sparc && _ILP32 */
365 				dumpregs(psp->pr_reg, is64);
366 		} else
367 			(void) printf("\tNot stopped, can't show registers\n");
368 	}
369 
370 	return (0);
371 }
372 
373 static char *
prflags(int arg)374 prflags(int arg)
375 {
376 	static char code_buf[200];
377 	char *str = code_buf;
378 
379 	if (arg == 0)
380 		return ("0");
381 
382 	if (arg & ~ALLFLAGS)
383 		(void) sprintf(str, "0x%x", arg & ~ALLFLAGS);
384 	else
385 		*str = '\0';
386 
387 	/*
388 	 * Display the semi-permanent lwp flags first.
389 	 */
390 	if (arg & PR_DAEMON)		/* daemons are always detached so */
391 		(void) strcat(str, "|DAEMON");
392 	else if (arg & PR_DETACH)	/* report detach only if non-daemon */
393 		(void) strcat(str, "|DETACH");
394 
395 	if (arg & PR_STOPPED)
396 		(void) strcat(str, "|STOPPED");
397 	if (arg & PR_ISTOP)
398 		(void) strcat(str, "|ISTOP");
399 	if (arg & PR_DSTOP)
400 		(void) strcat(str, "|DSTOP");
401 #if 0		/* displayed elsewhere */
402 	if (arg & PR_ASLEEP)
403 		(void) strcat(str, "|ASLEEP");
404 #endif
405 	if (arg & PR_PCINVAL)
406 		(void) strcat(str, "|PCINVAL");
407 	if (arg & PR_STEP)
408 		(void) strcat(str, "|STEP");
409 	if (arg & PR_AGENT)
410 		(void) strcat(str, "|AGENT");
411 	if (arg & PR_ISSYS)
412 		(void) strcat(str, "|ISSYS");
413 	if (arg & PR_VFORKP)
414 		(void) strcat(str, "|VFORKP");
415 	if (arg & PR_ORPHAN)
416 		(void) strcat(str, "|ORPHAN");
417 	if (arg & PR_NOSIGCHLD)
418 		(void) strcat(str, "|NOSIGCHLD");
419 	if (arg & PR_WAITPID)
420 		(void) strcat(str, "|WAITPID");
421 	if (arg & PR_FORK)
422 		(void) strcat(str, "|FORK");
423 	if (arg & PR_RLC)
424 		(void) strcat(str, "|RLC");
425 	if (arg & PR_KLC)
426 		(void) strcat(str, "|KLC");
427 	if (arg & PR_ASYNC)
428 		(void) strcat(str, "|ASYNC");
429 	if (arg & PR_BPTADJ)
430 		(void) strcat(str, "|BPTADJ");
431 	if (arg & PR_MSACCT)
432 		(void) strcat(str, "|MSACCT");
433 	if (arg & PR_MSFORK)
434 		(void) strcat(str, "|MSFORK");
435 	if (arg & PR_PTRACE)
436 		(void) strcat(str, "|PTRACE");
437 
438 	if (*str == '|')
439 		str++;
440 
441 	return (str);
442 }
443 
444 static char *
prwhy(int why)445 prwhy(int why)
446 {
447 	static char buf[20];
448 	char *str;
449 
450 	switch (why) {
451 	case PR_REQUESTED:
452 		str = "PR_REQUESTED";
453 		break;
454 	case PR_SIGNALLED:
455 		str = "PR_SIGNALLED";
456 		break;
457 	case PR_SYSENTRY:
458 		str = "PR_SYSENTRY";
459 		break;
460 	case PR_SYSEXIT:
461 		str = "PR_SYSEXIT";
462 		break;
463 	case PR_JOBCONTROL:
464 		str = "PR_JOBCONTROL";
465 		break;
466 	case PR_FAULTED:
467 		str = "PR_FAULTED";
468 		break;
469 	case PR_SUSPENDED:
470 		str = "PR_SUSPENDED";
471 		break;
472 	default:
473 		str = buf;
474 		(void) sprintf(str, "%d", why);
475 		break;
476 	}
477 
478 	return (str);
479 }
480 
481 static char *
prwhat(int why,int what)482 prwhat(int why, int what)
483 {
484 	static char buf[32];
485 	char *str;
486 
487 	switch (why) {
488 	case PR_SIGNALLED:
489 	case PR_JOBCONTROL:
490 		str = proc_signame(what, buf, sizeof (buf));
491 		break;
492 	case PR_SYSENTRY:
493 	case PR_SYSEXIT:
494 		str = proc_sysname(what, buf, sizeof (buf));
495 		break;
496 	case PR_FAULTED:
497 		str = proc_fltname(what, buf, sizeof (buf));
498 		break;
499 	default:
500 		(void) sprintf(str = buf, "%d", what);
501 		break;
502 	}
503 
504 	return (str);
505 }
506 
507 #if defined(__sparc)
508 static const char * const regname[NPRGREG] = {
509 	" %g0", " %g1", " %g2", " %g3", " %g4", " %g5", " %g6", " %g7",
510 	" %o0", " %o1", " %o2", " %o3", " %o4", " %o5", " %sp", " %o7",
511 	" %l0", " %l1", " %l2", " %l3", " %l4", " %l5", " %l6", " %l7",
512 	" %i0", " %i1", " %i2", " %i3", " %i4", " %i5", " %fp", " %i7",
513 #ifdef __sparcv9
514 	"%ccr", " %pc", "%npc", "  %y", "%asi", "%fprs"
515 #else
516 	"%psr", " %pc", "%npc", "  %y", "%wim", "%tbr"
517 #endif
518 };
519 #endif	/* __sparc */
520 
521 #if defined(__amd64)
522 static const char * const regname[NPRGREG] = {
523 	"%r15", "%r14", "%r13", "%r12", "%r11", "%r10", " %r9", " %r8",
524 	"%rdi", "%rsi", "%rbp", "%rbx", "%rdx", "%rcx", "%rax", "%trapno",
525 	"%err", "%rip", " %cs", "%rfl", "%rsp", " %ss", " %fs", " %gs",
526 	" %es", " %ds", "%fsbase", "%gsbase"
527 };
528 
529 static const char * const regname32[NPRGREG32] = {
530 	" %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
531 	"%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
532 	"%efl", "%uesp", " %ss"
533 };
534 
535 /* XX64 Do we want to expose this through libproc */
536 void
prgregset_n_to_32(const prgreg_t * src,prgreg32_t * dst)537 prgregset_n_to_32(const prgreg_t *src, prgreg32_t *dst)
538 {
539 	bzero(dst, NPRGREG32 * sizeof (prgreg32_t));
540 	dst[GS] = src[REG_GS];
541 	dst[FS] = src[REG_FS];
542 	dst[DS] = src[REG_DS];
543 	dst[ES] = src[REG_ES];
544 	dst[EDI] = src[REG_RDI];
545 	dst[ESI] = src[REG_RSI];
546 	dst[EBP] = src[REG_RBP];
547 	dst[EBX] = src[REG_RBX];
548 	dst[EDX] = src[REG_RDX];
549 	dst[ECX] = src[REG_RCX];
550 	dst[EAX] = src[REG_RAX];
551 	dst[TRAPNO] = src[REG_TRAPNO];
552 	dst[ERR] = src[REG_ERR];
553 	dst[EIP] = src[REG_RIP];
554 	dst[CS] = src[REG_CS];
555 	dst[EFL] = src[REG_RFL];
556 	dst[UESP] = src[REG_RSP];
557 	dst[SS] = src[REG_SS];
558 }
559 
560 #elif defined(__i386)
561 static const char * const regname[NPRGREG] = {
562 	" %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
563 	"%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
564 	"%efl", "%uesp", " %ss"
565 };
566 #endif /* __i386 */
567 
568 #if defined(__amd64) && defined(_LP64)
569 static void
dumpregs32(const prgregset_t reg)570 dumpregs32(const prgregset_t reg)
571 {
572 	prgregset32_t reg32;
573 	int i;
574 
575 	prgregset_n_to_32(reg, reg32);
576 
577 	for (i = 0; i < NPRGREG32; i++) {
578 		(void) printf("  %s = 0x%.8X",
579 		    regname32[i], reg32[i]);
580 		if ((i+1) % 4 == 0)
581 			(void) putchar('\n');
582 	}
583 	if (i % 4 != 0)
584 		(void) putchar('\n');
585 }
586 #endif
587 
588 static void
dumpregs(const prgregset_t reg,int is64)589 dumpregs(const prgregset_t reg, int is64)
590 {
591 	int width = is64? 16 : 8;
592 	int cols = is64? 2 : 4;
593 	int i;
594 
595 #if defined(__amd64) && defined(_LP64)
596 	if (!is64) {
597 		dumpregs32(reg);
598 		return;
599 	}
600 #endif
601 
602 	for (i = 0; i < NPRGREG; i++) {
603 		(void) printf("  %s = 0x%.*lX",
604 		    regname[i], width, (long)reg[i]);
605 		if ((i+1) % cols == 0)
606 			(void) putchar('\n');
607 	}
608 	if (i % cols != 0)
609 		(void) putchar('\n');
610 }
611 
612 #if defined(__sparc) && defined(_ILP32)
613 static void
dumpregs_v8p(const prgregset_t reg,const prxregset_t * xreg,int is64)614 dumpregs_v8p(const prgregset_t reg, const prxregset_t *xreg, int is64)
615 {
616 	static const uint32_t zero[8] = { 0 };
617 	int gr, xr, cols = 2;
618 	uint64_t xval;
619 
620 	if (memcmp(xreg->pr_un.pr_v8p.pr_xg, zero, sizeof (zero)) == 0 &&
621 	    memcmp(xreg->pr_un.pr_v8p.pr_xo, zero, sizeof (zero)) == 0) {
622 		dumpregs(reg, is64);
623 		return;
624 	}
625 
626 	for (gr = R_G0, xr = XR_G0; gr <= R_G7; gr++, xr++) {
627 		xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xg[xr] << 32 |
628 		    (uint64_t)(uint32_t)reg[gr];
629 		(void) printf("  %s = 0x%.16" PRIX64, regname[gr], xval);
630 		if ((gr + 1) % cols == 0)
631 			(void) putchar('\n');
632 	}
633 
634 	for (gr = R_O0, xr = XR_O0; gr <= R_O7; gr++, xr++) {
635 		xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xo[xr] << 32 |
636 		    (uint64_t)(uint32_t)reg[gr];
637 		(void) printf("  %s = 0x%.16" PRIX64, regname[gr], xval);
638 		if ((gr + 1) % cols == 0)
639 			(void) putchar('\n');
640 	}
641 
642 	for (gr = R_L0; gr < NPRGREG; gr++) {
643 		(void) printf("  %s =         0x%.8lX",
644 		    regname[gr], (long)reg[gr]);
645 		if ((gr + 1) % cols == 0)
646 			(void) putchar('\n');
647 	}
648 
649 	if (gr % cols != 0)
650 		(void) putchar('\n');
651 }
652 #endif	/* __sparc && _ILP32 */
653