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 2015, Joyent, Inc.
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
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
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
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
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 *
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 *
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 case PR_BRAND:
473 str = "PR_BRAND";
474 break;
475 default:
476 str = buf;
477 (void) sprintf(str, "%d", why);
478 break;
479 }
480
481 return (str);
482 }
483
484 static char *
485 prwhat(int why, int what)
486 {
487 static char buf[32];
488 char *str;
489
490 switch (why) {
491 case PR_SIGNALLED:
492 case PR_JOBCONTROL:
493 str = proc_signame(what, buf, sizeof (buf));
494 break;
495 case PR_SYSENTRY:
496 case PR_SYSEXIT:
497 str = proc_sysname(what, buf, sizeof (buf));
498 break;
499 case PR_FAULTED:
500 str = proc_fltname(what, buf, sizeof (buf));
501 break;
502 default:
503 (void) sprintf(str = buf, "%d", what);
504 break;
505 }
506
507 return (str);
508 }
509
510 #if defined(__sparc)
511 static const char * const regname[NPRGREG] = {
512 " %g0", " %g1", " %g2", " %g3", " %g4", " %g5", " %g6", " %g7",
513 " %o0", " %o1", " %o2", " %o3", " %o4", " %o5", " %sp", " %o7",
514 " %l0", " %l1", " %l2", " %l3", " %l4", " %l5", " %l6", " %l7",
515 " %i0", " %i1", " %i2", " %i3", " %i4", " %i5", " %fp", " %i7",
516 #ifdef __sparcv9
517 "%ccr", " %pc", "%npc", " %y", "%asi", "%fprs"
518 #else
519 "%psr", " %pc", "%npc", " %y", "%wim", "%tbr"
520 #endif
521 };
522 #endif /* __sparc */
523
524 #if defined(__amd64)
525 static const char * const regname[NPRGREG] = {
526 "%r15", "%r14", "%r13", "%r12", "%r11", "%r10", " %r9", " %r8",
527 "%rdi", "%rsi", "%rbp", "%rbx", "%rdx", "%rcx", "%rax", "%trapno",
528 "%err", "%rip", " %cs", "%rfl", "%rsp", " %ss", " %fs", " %gs",
529 " %es", " %ds", "%fsbase", "%gsbase"
530 };
531
532 static const char * const regname32[NPRGREG32] = {
533 " %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
534 "%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
535 "%efl", "%uesp", " %ss"
536 };
537
538 /* XX64 Do we want to expose this through libproc */
539 void
540 prgregset_n_to_32(const prgreg_t *src, prgreg32_t *dst)
541 {
542 bzero(dst, NPRGREG32 * sizeof (prgreg32_t));
543 dst[GS] = src[REG_GS];
544 dst[FS] = src[REG_FS];
545 dst[DS] = src[REG_DS];
546 dst[ES] = src[REG_ES];
547 dst[EDI] = src[REG_RDI];
548 dst[ESI] = src[REG_RSI];
549 dst[EBP] = src[REG_RBP];
550 dst[EBX] = src[REG_RBX];
551 dst[EDX] = src[REG_RDX];
552 dst[ECX] = src[REG_RCX];
553 dst[EAX] = src[REG_RAX];
554 dst[TRAPNO] = src[REG_TRAPNO];
555 dst[ERR] = src[REG_ERR];
556 dst[EIP] = src[REG_RIP];
557 dst[CS] = src[REG_CS];
558 dst[EFL] = src[REG_RFL];
559 dst[UESP] = src[REG_RSP];
560 dst[SS] = src[REG_SS];
561 }
562
563 #elif defined(__i386)
564 static const char * const regname[NPRGREG] = {
565 " %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
566 "%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
567 "%efl", "%uesp", " %ss"
568 };
569 #endif /* __i386 */
570
571 #if defined(__amd64) && defined(_LP64)
572 static void
573 dumpregs32(const prgregset_t reg)
574 {
575 prgregset32_t reg32;
576 int i;
577
578 prgregset_n_to_32(reg, reg32);
579
580 for (i = 0; i < NPRGREG32; i++) {
581 (void) printf(" %s = 0x%.8X",
582 regname32[i], reg32[i]);
583 if ((i+1) % 4 == 0)
584 (void) putchar('\n');
585 }
586 if (i % 4 != 0)
587 (void) putchar('\n');
588 }
589 #endif
590
591 static void
592 dumpregs(const prgregset_t reg, int is64)
593 {
594 int width = is64? 16 : 8;
595 int cols = is64? 2 : 4;
596 int i;
597
598 #if defined(__amd64) && defined(_LP64)
599 if (!is64) {
600 dumpregs32(reg);
601 return;
602 }
603 #endif
604
605 for (i = 0; i < NPRGREG; i++) {
606 (void) printf(" %s = 0x%.*lX",
607 regname[i], width, (long)reg[i]);
608 if ((i+1) % cols == 0)
609 (void) putchar('\n');
610 }
611 if (i % cols != 0)
612 (void) putchar('\n');
613 }
614
615 #if defined(__sparc) && defined(_ILP32)
616 static void
617 dumpregs_v8p(const prgregset_t reg, const prxregset_t *xreg, int is64)
618 {
619 static const uint32_t zero[8] = { 0 };
620 int gr, xr, cols = 2;
621 uint64_t xval;
622
623 if (memcmp(xreg->pr_un.pr_v8p.pr_xg, zero, sizeof (zero)) == 0 &&
624 memcmp(xreg->pr_un.pr_v8p.pr_xo, zero, sizeof (zero)) == 0) {
625 dumpregs(reg, is64);
626 return;
627 }
628
629 for (gr = R_G0, xr = XR_G0; gr <= R_G7; gr++, xr++) {
630 xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xg[xr] << 32 |
631 (uint64_t)(uint32_t)reg[gr];
632 (void) printf(" %s = 0x%.16" PRIX64, regname[gr], xval);
633 if ((gr + 1) % cols == 0)
634 (void) putchar('\n');
635 }
636
637 for (gr = R_O0, xr = XR_O0; gr <= R_O7; gr++, xr++) {
638 xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xo[xr] << 32 |
639 (uint64_t)(uint32_t)reg[gr];
640 (void) printf(" %s = 0x%.16" PRIX64, regname[gr], xval);
641 if ((gr + 1) % cols == 0)
642 (void) putchar('\n');
643 }
644
645 for (gr = R_L0; gr < NPRGREG; gr++) {
646 (void) printf(" %s = 0x%.8lX",
647 regname[gr], (long)reg[gr]);
648 if ((gr + 1) % cols == 0)
649 (void) putchar('\n');
650 }
651
652 if (gr % cols != 0)
653 (void) putchar('\n');
654 }
655 #endif /* __sparc && _ILP32 */