1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Copyright 2020 Joyent, Inc.
28 * Copyright (c) 2016 by Delphix. All rights reserved.
29 */
30
31 /*
32 * MDB uses its own enhanced standard i/o mechanism for all input and output.
33 * This file provides the underpinnings of this mechanism, including the
34 * printf-style formatting code, the output pager, and APIs for raw input
35 * and output. This mechanism is used throughout the debugger for everything
36 * from simple sprintf and printf-style formatting, to input to the lexer
37 * and parser, to raw file i/o for reading ELF files. In general, we divide
38 * our i/o implementation into two parts:
39 *
40 * (1) An i/o buffer (mdb_iob_t) provides buffered read or write capabilities,
41 * as well as access to formatting and the ability to invoke a pager. The
42 * buffer is constructed explicitly for use in either reading or writing; it
43 * may not be used for both simultaneously.
44 *
45 * (2) Each i/o buffer is associated with an underlying i/o backend (mdb_io_t).
46 * The backend provides, through an ops-vector, equivalents for the standard
47 * read, write, lseek, ioctl, and close operations. In addition, the backend
48 * can provide an IOP_NAME entry point for returning a name for the backend,
49 * IOP_LINK and IOP_UNLINK entry points that are called when the backend is
50 * connected or disconnected from an mdb_iob_t, and an IOP_SETATTR entry point
51 * for manipulating terminal attributes.
52 *
53 * The i/o objects themselves are reference counted so that more than one i/o
54 * buffer may make use of the same i/o backend. In addition, each buffer
55 * provides the ability to push or pop backends to interpose on input or output
56 * behavior. We make use of this, for example, to implement interactive
57 * session logging. Normally, the stdout iob has a backend that is either
58 * file descriptor 1, or a terminal i/o backend associated with the tty.
59 * However, we can push a log i/o backend on top that multiplexes stdout to
60 * the original back-end and another backend that writes to a log file. The
61 * use of i/o backends is also used for simplifying tasks such as making
62 * lex and yacc read from strings for mdb_eval(), and making our ELF file
63 * processing code read executable "files" from a crash dump via kvm_uread.
64 *
65 * Additionally, the formatting code provides auto-wrap and indent facilities
66 * that are necessary for compatibility with adb macro formatting. In auto-
67 * wrap mode, the formatting code examines each new chunk of output to determine
68 * if it will fit on the current line. If not, instead of having the chunk
69 * divided between the current line of output and the next, the auto-wrap
70 * code will automatically output a newline, auto-indent the next line,
71 * and then continue. Auto-indent is implemented by simply prepending a number
72 * of blanks equal to iob_margin to the start of each line. The margin is
73 * inserted when the iob is created, and following each flush of the buffer.
74 */
75
76 #include <sys/types.h>
77 #include <sys/termios.h>
78 #include <stdarg.h>
79 #include <arpa/inet.h>
80 #include <sys/socket.h>
81
82 #include <mdb/mdb_types.h>
83 #include <mdb/mdb_argvec.h>
84 #include <mdb/mdb_stdlib.h>
85 #include <mdb/mdb_string.h>
86 #include <mdb/mdb_target.h>
87 #include <mdb/mdb_signal.h>
88 #include <mdb/mdb_debug.h>
89 #include <mdb/mdb_io_impl.h>
90 #include <mdb/mdb_modapi.h>
91 #include <mdb/mdb_demangle.h>
92 #include <mdb/mdb_err.h>
93 #include <mdb/mdb_nv.h>
94 #include <mdb/mdb_frame.h>
95 #include <mdb/mdb_lex.h>
96 #include <mdb/mdb.h>
97
98 /*
99 * Define list of possible integer sizes for conversion routines:
100 */
101 typedef enum {
102 SZ_SHORT, /* format %h? */
103 SZ_INT, /* format %? */
104 SZ_LONG, /* format %l? */
105 SZ_LONGLONG /* format %ll? */
106 } intsize_t;
107
108 /*
109 * The iob snprintf family of functions makes use of a special "sprintf
110 * buffer" i/o backend in order to provide the appropriate snprintf semantics.
111 * This structure is maintained as the backend-specific private storage,
112 * and its use is described in more detail below (see spbuf_write()).
113 */
114 typedef struct {
115 char *spb_buf; /* pointer to underlying buffer */
116 size_t spb_bufsiz; /* length of underlying buffer */
117 size_t spb_total; /* total of all bytes passed via IOP_WRITE */
118 } spbuf_t;
119
120 /*
121 * Define VA_ARG macro for grabbing the next datum to format for the printf
122 * family of functions. We use VA_ARG so that we can support two kinds of
123 * argument lists: the va_list type supplied by <stdarg.h> used for printf and
124 * vprintf, and an array of mdb_arg_t structures, which we expect will be
125 * either type STRING or IMMEDIATE. The vec_arg function takes care of
126 * handling the mdb_arg_t case.
127 */
128
129 typedef enum {
130 VAT_VARARGS, /* va_list is a va_list */
131 VAT_ARGVEC /* va_list is a const mdb_arg_t[] in disguise */
132 } vatype_t;
133
134 typedef struct {
135 vatype_t val_type;
136 union {
137 va_list _val_valist;
138 const mdb_arg_t *_val_argv;
139 } _val_u;
140 } varglist_t;
141
142 #define val_valist _val_u._val_valist
143 #define val_argv _val_u._val_argv
144
145 #define VA_ARG(ap, type) ((ap->val_type == VAT_VARARGS) ? \
146 va_arg(ap->val_valist, type) : (type)vec_arg(&ap->val_argv))
147 #define VA_PTRARG(ap) ((ap->val_type == VAT_VARARGS) ? \
148 (void *)va_arg(ap->val_valist, uintptr_t) : \
149 (void *)(uintptr_t)vec_arg(&ap->val_argv))
150
151 /*
152 * Define macro for converting char constant to Ctrl-char equivalent:
153 */
154 #ifndef CTRL
155 #define CTRL(c) ((c) & 0x01f)
156 #endif
157
158 #define IOB_AUTOWRAP(iob) \
159 ((mdb.m_flags & MDB_FL_AUTOWRAP) && \
160 ((iob)->iob_flags & MDB_IOB_AUTOWRAP))
161
162 /*
163 * Define macro for determining if we should automatically wrap to the next
164 * line of output, based on the amount of consumed buffer space and the
165 * specified size of the next thing to be inserted (n) -- being careful to
166 * not force a spurious wrap if we're autoindented and already at the margin.
167 */
168 #define IOB_WRAPNOW(iob, n) \
169 (IOB_AUTOWRAP(iob) && (iob)->iob_nbytes != 0 && \
170 ((n) + (iob)->iob_nbytes > (iob)->iob_cols) && \
171 !(((iob)->iob_flags & MDB_IOB_INDENT) && \
172 (iob)->iob_nbytes == (iob)->iob_margin))
173
174 /*
175 * Define prompt string and string to erase prompt string for iob_pager
176 * function, which is invoked if the pager is enabled on an i/o buffer
177 * and we're about to print a line which would be the last on the screen.
178 */
179
180 static const char io_prompt[] = ">> More [<space>, <cr>, q, n, c, a] ? ";
181 static const char io_perase[] = " ";
182
183 static const char io_pbcksp[] =
184 /*CSTYLED*/
185 "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";
186
187 static const size_t io_promptlen = sizeof (io_prompt) - 1;
188 static const size_t io_peraselen = sizeof (io_perase) - 1;
189 static const size_t io_pbcksplen = sizeof (io_pbcksp) - 1;
190
191 static ssize_t
192 iob_write(mdb_iob_t *iob, mdb_io_t *io, const void *buf, size_t n)
193 {
194 ssize_t resid = n;
195 ssize_t len;
196
197 while (resid != 0) {
198 if ((len = IOP_WRITE(io, buf, resid)) <= 0)
199 break;
200
201 buf = (char *)buf + len;
202 resid -= len;
203 }
204
205 /*
206 * Note that if we had a partial write before an error, we still want
207 * to return the fact something was written. The caller will get an
208 * error next time it tries to write anything.
209 */
210 if (resid == n && n != 0) {
211 iob->iob_flags |= MDB_IOB_ERR;
212 return (-1);
213 }
214
215 return (n - resid);
216 }
217
218 static ssize_t
219 iob_read(mdb_iob_t *iob, mdb_io_t *io)
220 {
221 ssize_t len;
222
223 ASSERT(iob->iob_nbytes == 0);
224 len = IOP_READ(io, iob->iob_buf, iob->iob_bufsiz);
225 iob->iob_bufp = &iob->iob_buf[0];
226
227 switch (len) {
228 case -1:
229 iob->iob_flags |= MDB_IOB_ERR;
230 break;
231 case 0:
232 iob->iob_flags |= MDB_IOB_EOF;
233 break;
234 default:
235 iob->iob_nbytes = len;
236 }
237
238 return (len);
239 }
240
241 /*ARGSUSED*/
242 static void
243 iob_winch(int sig, siginfo_t *sip, ucontext_t *ucp, void *data)
244 {
245 siglongjmp(*((sigjmp_buf *)data), sig);
246 }
247
248 static int
249 iob_pager(mdb_iob_t *iob)
250 {
251 int status = 0;
252 sigjmp_buf env;
253 uchar_t c;
254
255 mdb_signal_f *termio_winch;
256 void *termio_data;
257 size_t old_rows;
258
259 if (iob->iob_pgp == NULL || (iob->iob_flags & MDB_IOB_PGCONT))
260 return (0);
261
262 termio_winch = mdb_signal_gethandler(SIGWINCH, &termio_data);
263 (void) mdb_signal_sethandler(SIGWINCH, iob_winch, &env);
264
265 if (sigsetjmp(env, 1) != 0) {
266 /*
267 * Reset the cursor back to column zero before printing a new
268 * prompt, since its position is unreliable after a SIGWINCH.
269 */
270 (void) iob_write(iob, iob->iob_pgp, "\r", sizeof (char));
271 old_rows = iob->iob_rows;
272
273 /*
274 * If an existing SIGWINCH handler was present, call it. We
275 * expect that this will be termio: the handler will read the
276 * new window size, and then resize this iob appropriately.
277 */
278 if (termio_winch != (mdb_signal_f *)NULL)
279 termio_winch(SIGWINCH, NULL, NULL, termio_data);
280
281 /*
282 * If the window has increased in size, we treat this like a
283 * request to fill out the new remainder of the page.
284 */
285 if (iob->iob_rows > old_rows) {
286 iob->iob_flags &= ~MDB_IOB_PGSINGLE;
287 iob->iob_nlines = old_rows;
288 status = 0;
289 goto winch;
290 }
291 }
292
293 (void) iob_write(iob, iob->iob_pgp, io_prompt, io_promptlen);
294
295 for (;;) {
296 if (IOP_READ(iob->iob_pgp, &c, sizeof (c)) != sizeof (c)) {
297 status = MDB_ERR_PAGER;
298 break;
299 }
300
301 switch (c) {
302 case 'N':
303 case 'n':
304 case '\n':
305 case '\r':
306 iob->iob_flags |= MDB_IOB_PGSINGLE;
307 goto done;
308
309 case CTRL('c'):
310 case CTRL('\\'):
311 case 'Q':
312 case 'q':
313 mdb_iob_discard(iob);
314 status = MDB_ERR_PAGER;
315 goto done;
316
317 case 'A':
318 case 'a':
319 mdb_iob_discard(iob);
320 status = MDB_ERR_ABORT;
321 goto done;
322
323 case 'C':
324 case 'c':
325 iob->iob_flags |= MDB_IOB_PGCONT;
326 /*FALLTHRU*/
327
328 case ' ':
329 iob->iob_flags &= ~MDB_IOB_PGSINGLE;
330 goto done;
331 }
332 }
333
334 done:
335 (void) iob_write(iob, iob->iob_pgp, io_pbcksp, io_pbcksplen);
336 winch:
337 (void) iob_write(iob, iob->iob_pgp, io_perase, io_peraselen);
338 (void) iob_write(iob, iob->iob_pgp, io_pbcksp, io_pbcksplen);
339 (void) mdb_signal_sethandler(SIGWINCH, termio_winch, termio_data);
340
341 if ((iob->iob_flags & MDB_IOB_ERR) && status == 0)
342 status = MDB_ERR_OUTPUT;
343
344 return (status);
345 }
346
347 static void
348 iob_indent(mdb_iob_t *iob)
349 {
350 if (iob->iob_nbytes == 0 && iob->iob_margin != 0 &&
351 (iob->iob_flags & MDB_IOB_INDENT)) {
352 size_t i;
353
354 ASSERT(iob->iob_margin < iob->iob_cols);
355 ASSERT(iob->iob_bufp == iob->iob_buf);
356
357 for (i = 0; i < iob->iob_margin; i++)
358 *iob->iob_bufp++ = ' ';
359
360 iob->iob_nbytes = iob->iob_margin;
361 }
362 }
363
364 static void
365 iob_unindent(mdb_iob_t *iob)
366 {
367 if (iob->iob_nbytes != 0 && iob->iob_nbytes == iob->iob_margin) {
368 const char *p = iob->iob_buf;
369
370 while (p < &iob->iob_buf[iob->iob_margin]) {
371 if (*p++ != ' ')
372 return;
373 }
374
375 iob->iob_bufp = &iob->iob_buf[0];
376 iob->iob_nbytes = 0;
377 }
378 }
379
380 mdb_iob_t *
381 mdb_iob_create(mdb_io_t *io, uint_t flags)
382 {
383 mdb_iob_t *iob = mdb_alloc(sizeof (mdb_iob_t), UM_SLEEP);
384
385 iob->iob_buf = mdb_alloc(BUFSIZ, UM_SLEEP);
386 iob->iob_bufsiz = BUFSIZ;
387 iob->iob_bufp = &iob->iob_buf[0];
388 iob->iob_nbytes = 0;
389 iob->iob_nlines = 0;
390 iob->iob_lineno = 1;
391 iob->iob_rows = MDB_IOB_DEFROWS;
392 iob->iob_cols = MDB_IOB_DEFCOLS;
393 iob->iob_tabstop = MDB_IOB_DEFTAB;
394 iob->iob_margin = MDB_IOB_DEFMARGIN;
395 iob->iob_flags = flags & ~(MDB_IOB_EOF|MDB_IOB_ERR) | MDB_IOB_AUTOWRAP;
396 iob->iob_iop = mdb_io_hold(io);
397 iob->iob_pgp = NULL;
398 iob->iob_next = NULL;
399
400 IOP_LINK(io, iob);
401 iob_indent(iob);
402 return (iob);
403 }
404
405 void
406 mdb_iob_pipe(mdb_iob_t **iobs, mdb_iobsvc_f *rdsvc, mdb_iobsvc_f *wrsvc)
407 {
408 mdb_io_t *pio = mdb_pipeio_create(rdsvc, wrsvc);
409 int i;
410
411 iobs[0] = mdb_iob_create(pio, MDB_IOB_RDONLY);
412 iobs[1] = mdb_iob_create(pio, MDB_IOB_WRONLY);
413
414 for (i = 0; i < 2; i++) {
415 iobs[i]->iob_flags &= ~MDB_IOB_AUTOWRAP;
416 iobs[i]->iob_cols = iobs[i]->iob_bufsiz;
417 }
418 }
419
420 void
421 mdb_iob_destroy(mdb_iob_t *iob)
422 {
423 /*
424 * Don't flush a pipe, since it may cause a context switch when the
425 * other side has already been destroyed.
426 */
427 if (!mdb_iob_isapipe(iob))
428 mdb_iob_flush(iob);
429
430 if (iob->iob_pgp != NULL)
431 mdb_io_rele(iob->iob_pgp);
432
433 while (iob->iob_iop != NULL) {
434 IOP_UNLINK(iob->iob_iop, iob);
435 (void) mdb_iob_pop_io(iob);
436 }
437
438 mdb_free(iob->iob_buf, iob->iob_bufsiz);
439 mdb_free(iob, sizeof (mdb_iob_t));
440 }
441
442 void
443 mdb_iob_discard(mdb_iob_t *iob)
444 {
445 iob->iob_bufp = &iob->iob_buf[0];
446 iob->iob_nbytes = 0;
447 }
448
449 void
450 mdb_iob_flush(mdb_iob_t *iob)
451 {
452 int pgerr = 0;
453
454 if (iob->iob_nbytes == 0)
455 return; /* Nothing to do if buffer is empty */
456
457 if (iob->iob_flags & MDB_IOB_WRONLY) {
458 if (iob->iob_flags & MDB_IOB_PGSINGLE) {
459 iob->iob_flags &= ~MDB_IOB_PGSINGLE;
460 iob->iob_nlines = 0;
461 pgerr = iob_pager(iob);
462
463 } else if (iob->iob_nlines >= iob->iob_rows - 1) {
464 iob->iob_nlines = 0;
465 if (iob->iob_flags & MDB_IOB_PGENABLE)
466 pgerr = iob_pager(iob);
467 }
468
469 if (pgerr == 0) {
470 /*
471 * We only jump out of the dcmd on error if the iob is
472 * m_out. Presumably, if a dcmd has opened a special
473 * file and is writing to it, it will handle errors
474 * properly.
475 */
476 if (iob_write(iob, iob->iob_iop, iob->iob_buf,
477 iob->iob_nbytes) < 0 && iob == mdb.m_out)
478 pgerr = MDB_ERR_OUTPUT;
479 iob->iob_nlines++;
480 }
481 }
482
483 iob->iob_bufp = &iob->iob_buf[0];
484 iob->iob_nbytes = 0;
485 iob_indent(iob);
486
487 if (pgerr)
488 longjmp(mdb.m_frame->f_pcb, pgerr);
489 }
490
491 void
492 mdb_iob_nlflush(mdb_iob_t *iob)
493 {
494 iob_unindent(iob);
495
496 if (iob->iob_nbytes != 0)
497 mdb_iob_nl(iob);
498 else
499 iob_indent(iob);
500 }
501
502 void
503 mdb_iob_push_io(mdb_iob_t *iob, mdb_io_t *io)
504 {
505 ASSERT(io->io_next == NULL);
506
507 io->io_next = iob->iob_iop;
508 iob->iob_iop = mdb_io_hold(io);
509 }
510
511 mdb_io_t *
512 mdb_iob_pop_io(mdb_iob_t *iob)
513 {
514 mdb_io_t *io = iob->iob_iop;
515
516 if (io != NULL) {
517 iob->iob_iop = io->io_next;
518 io->io_next = NULL;
519 mdb_io_rele(io);
520 }
521
522 return (io);
523 }
524
525 void
526 mdb_iob_resize(mdb_iob_t *iob, size_t rows, size_t cols)
527 {
528 if (cols > iob->iob_bufsiz)
529 iob->iob_cols = iob->iob_bufsiz;
530 else
531 iob->iob_cols = cols != 0 ? cols : MDB_IOB_DEFCOLS;
532
533 iob->iob_rows = rows != 0 ? rows : MDB_IOB_DEFROWS;
534 }
535
536 void
537 mdb_iob_setpager(mdb_iob_t *iob, mdb_io_t *pgio)
538 {
539 struct winsize winsz;
540
541 if (iob->iob_pgp != NULL) {
542 IOP_UNLINK(iob->iob_pgp, iob);
543 mdb_io_rele(iob->iob_pgp);
544 }
545
546 iob->iob_flags |= MDB_IOB_PGENABLE;
547 iob->iob_flags &= ~(MDB_IOB_PGSINGLE | MDB_IOB_PGCONT);
548 iob->iob_pgp = mdb_io_hold(pgio);
549
550 IOP_LINK(iob->iob_pgp, iob);
551
552 if (IOP_CTL(pgio, TIOCGWINSZ, &winsz) == 0)
553 mdb_iob_resize(iob, (size_t)winsz.ws_row, (size_t)winsz.ws_col);
554 }
555
556 void
557 mdb_iob_tabstop(mdb_iob_t *iob, size_t tabstop)
558 {
559 iob->iob_tabstop = MIN(tabstop, iob->iob_cols - 1);
560 }
561
562 void
563 mdb_iob_margin(mdb_iob_t *iob, size_t margin)
564 {
565 iob_unindent(iob);
566 iob->iob_margin = MIN(margin, iob->iob_cols - 1);
567 iob_indent(iob);
568 }
569
570 void
571 mdb_iob_setbuf(mdb_iob_t *iob, void *buf, size_t bufsiz)
572 {
573 ASSERT(buf != NULL && bufsiz != 0);
574
575 mdb_free(iob->iob_buf, iob->iob_bufsiz);
576 iob->iob_buf = buf;
577 iob->iob_bufsiz = bufsiz;
578
579 if (iob->iob_flags & MDB_IOB_WRONLY)
580 iob->iob_cols = MIN(iob->iob_cols, iob->iob_bufsiz);
581 }
582
583 void
584 mdb_iob_clearlines(mdb_iob_t *iob)
585 {
586 iob->iob_flags &= ~(MDB_IOB_PGSINGLE | MDB_IOB_PGCONT);
587 iob->iob_nlines = 0;
588 }
589
590 void
591 mdb_iob_setflags(mdb_iob_t *iob, uint_t flags)
592 {
593 iob->iob_flags |= flags;
594 if (flags & MDB_IOB_INDENT)
595 iob_indent(iob);
596 }
597
598 void
599 mdb_iob_clrflags(mdb_iob_t *iob, uint_t flags)
600 {
601 iob->iob_flags &= ~flags;
602 if (flags & MDB_IOB_INDENT)
603 iob_unindent(iob);
604 }
605
606 uint_t
607 mdb_iob_getflags(mdb_iob_t *iob)
608 {
609 return (iob->iob_flags);
610 }
611
612 static uintmax_t
613 vec_arg(const mdb_arg_t **app)
614 {
615 uintmax_t value;
616
617 if ((*app)->a_type == MDB_TYPE_STRING)
618 value = (uintmax_t)(uintptr_t)(*app)->a_un.a_str;
619 else
620 value = (*app)->a_un.a_val;
621
622 (*app)++;
623 return (value);
624 }
625
626 static const char *
627 iob_size2str(intsize_t size)
628 {
629 switch (size) {
630 case SZ_SHORT:
631 return ("short");
632 case SZ_INT:
633 return ("int");
634 case SZ_LONG:
635 return ("long");
636 case SZ_LONGLONG:
637 return ("long long");
638 }
639 return ("");
640 }
641
642 /*
643 * In order to simplify maintenance of the ::formats display, we provide an
644 * unparser for mdb_printf format strings that converts a simple format
645 * string with one specifier into a descriptive representation, e.g.
646 * mdb_iob_format2str("%llx") returns "hexadecimal long long".
647 */
648 const char *
649 mdb_iob_format2str(const char *format)
650 {
651 intsize_t size = SZ_INT;
652 const char *p;
653
654 static char buf[64];
655
656 buf[0] = '\0';
657
658 if ((p = strchr(format, '%')) == NULL)
659 goto done;
660
661 fmt_switch:
662 switch (*++p) {
663 case '0': case '1': case '2': case '3': case '4':
664 case '5': case '6': case '7': case '8': case '9':
665 while (*p >= '0' && *p <= '9')
666 p++;
667 p--;
668 goto fmt_switch;
669
670 case 'a':
671 case 'A':
672 return ("symbol");
673
674 case 'b':
675 (void) strcpy(buf, "unsigned ");
676 (void) strcat(buf, iob_size2str(size));
677 (void) strcat(buf, " bitfield");
678 break;
679
680 case 'c':
681 return ("character");
682
683 case 'd':
684 case 'i':
685 (void) strcpy(buf, "decimal signed ");
686 (void) strcat(buf, iob_size2str(size));
687 break;
688
689 case 'e':
690 case 'E':
691 case 'g':
692 case 'G':
693 return ("double");
694
695 case 'h':
696 size = SZ_SHORT;
697 goto fmt_switch;
698
699 case 'H':
700 return ("human-readable size");
701
702 case 'I':
703 return ("IPv4 address");
704
705 case 'l':
706 if (size >= SZ_LONG)
707 size = SZ_LONGLONG;
708 else
709 size = SZ_LONG;
710 goto fmt_switch;
711
712 case 'm':
713 return ("margin");
714
715 case 'N':
716 return ("IPv6 address");
717
718 case 'o':
719 (void) strcpy(buf, "octal unsigned ");
720 (void) strcat(buf, iob_size2str(size));
721 break;
722
723 case 'p':
724 return ("pointer");
725
726 case 'q':
727 (void) strcpy(buf, "octal signed ");
728 (void) strcat(buf, iob_size2str(size));
729 break;
730
731 case 'r':
732 (void) strcpy(buf, "default radix unsigned ");
733 (void) strcat(buf, iob_size2str(size));
734 break;
735
736 case 'R':
737 (void) strcpy(buf, "default radix signed ");
738 (void) strcat(buf, iob_size2str(size));
739 break;
740
741 case 's':
742 return ("string");
743
744 case 't':
745 case 'T':
746 return ("tab");
747
748 case 'u':
749 (void) strcpy(buf, "decimal unsigned ");
750 (void) strcat(buf, iob_size2str(size));
751 break;
752
753 case 'x':
754 case 'X':
755 (void) strcat(buf, "hexadecimal ");
756 (void) strcat(buf, iob_size2str(size));
757 break;
758
759 case 'Y':
760 return ("time_t");
761
762 case '<':
763 return ("terminal attribute");
764
765 case '?':
766 case '#':
767 case '+':
768 case '-':
769 goto fmt_switch;
770 }
771
772 done:
773 if (buf[0] == '\0')
774 (void) strcpy(buf, "text");
775
776 return ((const char *)buf);
777 }
778
779 static const char *
780 iob_int2str(varglist_t *ap, intsize_t size, int base, uint_t flags, int *zero,
781 u_longlong_t *value)
782 {
783 uintmax_t i;
784
785 switch (size) {
786 case SZ_LONGLONG:
787 if (flags & NTOS_UNSIGNED)
788 i = (u_longlong_t)VA_ARG(ap, u_longlong_t);
789 else
790 i = (longlong_t)VA_ARG(ap, longlong_t);
791 break;
792
793 case SZ_LONG:
794 if (flags & NTOS_UNSIGNED)
795 i = (ulong_t)VA_ARG(ap, ulong_t);
796 else
797 i = (long)VA_ARG(ap, long);
798 break;
799
800 case SZ_SHORT:
801 if (flags & NTOS_UNSIGNED)
802 i = (ushort_t)VA_ARG(ap, uint_t);
803 else
804 i = (short)VA_ARG(ap, int);
805 break;
806
807 default:
808 if (flags & NTOS_UNSIGNED)
809 i = (uint_t)VA_ARG(ap, uint_t);
810 else
811 i = (int)VA_ARG(ap, int);
812 }
813
814 *zero = i == 0; /* Return flag indicating if result was zero */
815 *value = i; /* Return value retrieved from va_list */
816
817 return (numtostr(i, base, flags));
818 }
819
820 static const char *
821 iob_time2str(time_t *tmp)
822 {
823 /*
824 * ctime(3c) returns a string of the form
825 * "Fri Sep 13 00:00:00 1986\n\0". We turn this into the canonical
826 * adb /y format "1986 Sep 13 00:00:00" below.
827 */
828 const char *src = ctime(tmp);
829 static char buf[32];
830 char *dst = buf;
831 int i;
832
833 if (src == NULL)
834 return (numtostr((uintmax_t)*tmp, mdb.m_radix, 0));
835
836 for (i = 20; i < 24; i++)
837 *dst++ = src[i]; /* Copy the 4-digit year */
838
839 for (i = 3; i < 19; i++)
840 *dst++ = src[i]; /* Copy month, day, and h:m:s */
841
842 *dst = '\0';
843 return (buf);
844 }
845
846 static const char *
847 iob_addr2str(uintptr_t addr)
848 {
849 static char buf[MDB_TGT_SYM_NAMLEN];
850 char *name = buf;
851 longlong_t offset;
852 GElf_Sym sym;
853
854 if (mdb_tgt_lookup_by_addr(mdb.m_target, addr,
855 MDB_TGT_SYM_FUZZY, buf, sizeof (buf), &sym, NULL) == -1)
856 return (NULL);
857
858 if (mdb.m_demangler != NULL && (mdb.m_flags & MDB_FL_DEMANGLE))
859 name = (char *)mdb_dem_convert(mdb.m_demangler, buf);
860
861 /*
862 * Here we provide a little cooperation between the %a formatting code
863 * and the proc target: if the initial address passed to %a is in fact
864 * a PLT address, the proc target's lookup_by_addr code will convert
865 * this to the PLT destination (a different address). We do not want
866 * to append a "+/-offset" suffix based on comparison with the query
867 * symbol in this case because the proc target has really done a hidden
868 * query for us with a different address. We detect this case by
869 * comparing the initial characters of buf to the special PLT= string.
870 */
871 if (sym.st_value != addr && strncmp(name, "PLT=", 4) != 0) {
872 if (sym.st_value > addr)
873 offset = -(longlong_t)(sym.st_value - addr);
874 else
875 offset = (longlong_t)(addr - sym.st_value);
876
877 (void) strcat(name, numtostr(offset, mdb.m_radix,
878 NTOS_SIGNPOS | NTOS_SHOWBASE));
879 }
880
881 return (name);
882 }
883
884 /*
885 * Produce human-readable size, similar in spirit (and identical in output)
886 * to libzfs's zfs_nicenum() -- but made significantly more complicated by
887 * the constraint that we cannot use snprintf() as an implementation detail.
888 * Recall, floating point is verboten in kmdb.
889 */
890 static const char *
891 iob_bytes2str(varglist_t *ap, intsize_t size)
892 {
893 #ifndef _KMDB
894 const int sigfig = 3;
895 uint64_t orig;
896 #endif
897 uint64_t n;
898
899 static char buf[68], *c;
900 int index = 0;
901 char u;
902
903 switch (size) {
904 case SZ_LONGLONG:
905 n = (u_longlong_t)VA_ARG(ap, u_longlong_t);
906 break;
907
908 case SZ_LONG:
909 n = (ulong_t)VA_ARG(ap, ulong_t);
910 break;
911
912 case SZ_SHORT:
913 n = (ushort_t)VA_ARG(ap, uint_t);
914 break;
915
916 default:
917 n = (uint_t)VA_ARG(ap, uint_t);
918 }
919
920 #ifndef _KMDB
921 orig = n;
922 #endif
923
924 while (n >= 1024) {
925 n /= 1024;
926 index++;
927 }
928
929 u = " KMGTPE"[index];
930 buf[0] = '\0';
931
932 if (index == 0) {
933 return (numtostr(n, 10, 0));
934 #ifndef _KMDB
935 } else if ((orig & ((1ULL << 10 * index) - 1)) == 0) {
936 #else
937 } else {
938 #endif
939 /*
940 * If this is an even multiple of the base or we are in an
941 * environment where floating point is verboten (i.e., kmdb),
942 * always display without any decimal precision.
943 */
944 (void) strcat(buf, numtostr(n, 10, 0));
945 #ifndef _KMDB
946 } else {
947 /*
948 * We want to choose a precision that results in the specified
949 * number of significant figures (by default, 3). This is
950 * similar to the output that one would get specifying the %.*g
951 * format specifier (where the asterisk denotes the number of
952 * significant digits), but (1) we include trailing zeros if
953 * the there are non-zero digits beyond the number of
954 * significant digits (that is, 10241 is '10.0K', not the
955 * '10K' that it would be with %.3g) and (2) we never resort
956 * to %e notation when the number of digits exceeds the
957 * number of significant figures (that is, 1043968 is '1020K',
958 * not '1.02e+03K'). This is also made somewhat complicated
959 * by the fact that we need to deal with rounding (10239 is
960 * '10.0K', not '9.99K'), for which we perform nearest-even
961 * rounding.
962 */
963 double val = (double)orig / (1ULL << 10 * index);
964 int i, mag = 1, thresh;
965
966 for (i = 0; i < sigfig - 1; i++)
967 mag *= 10;
968
969 for (thresh = mag * 10; mag >= 1; mag /= 10, i--) {
970 double mult = val * (double)mag;
971 uint32_t v;
972
973 /*
974 * Note that we cast mult to a 32-bit value. We know
975 * that val is less than 1024 due to the logic above,
976 * and that mag is at most 10^(sigfig - 1). This means
977 * that as long as sigfig is 9 or lower, this will not
978 * overflow. (We perform this cast because it assures
979 * that we are never converting a double to a uint64_t,
980 * which for some compilers requires a call to a
981 * function not guaranteed to be in libstand.)
982 */
983 if (mult - (double)(uint32_t)mult != 0.5) {
984 v = (uint32_t)(mult + 0.5);
985 } else {
986 /*
987 * We are exactly between integer multiples
988 * of units; perform nearest-even rounding
989 * to be consistent with the behavior of
990 * printf().
991 */
992 if ((v = (uint32_t)mult) & 1)
993 v++;
994 }
995
996 if (mag == 1) {
997 (void) strcat(buf, numtostr(v, 10, 0));
998 break;
999 }
1000
1001 if (v < thresh) {
1002 (void) strcat(buf, numtostr(v / mag, 10, 0));
1003 (void) strcat(buf, ".");
1004
1005 c = (char *)numtostr(v % mag, 10, 0);
1006 i -= strlen(c);
1007
1008 /*
1009 * We need to zero-fill from the right of the
1010 * decimal point to the first significant digit
1011 * of the fractional component.
1012 */
1013 while (i--)
1014 (void) strcat(buf, "0");
1015
1016 (void) strcat(buf, c);
1017 break;
1018 }
1019 }
1020 #endif
1021 }
1022
1023 c = &buf[strlen(buf)];
1024 *c++ = u;
1025 *c++ = '\0';
1026
1027 return (buf);
1028 }
1029
1030 static int
1031 iob_setattr(mdb_iob_t *iob, const char *s, size_t nbytes)
1032 {
1033 uint_t attr;
1034 int req;
1035
1036 if (iob->iob_pgp == NULL)
1037 return (set_errno(ENOTTY));
1038
1039 if (nbytes != 0 && *s == '/') {
1040 req = ATT_OFF;
1041 nbytes--;
1042 s++;
1043 } else
1044 req = ATT_ON;
1045
1046 if (nbytes != 1)
1047 return (set_errno(EINVAL));
1048
1049 switch (*s) {
1050 case 's':
1051 attr = ATT_STANDOUT;
1052 break;
1053 case 'u':
1054 attr = ATT_UNDERLINE;
1055 break;
1056 case 'r':
1057 attr = ATT_REVERSE;
1058 break;
1059 case 'b':
1060 attr = ATT_BOLD;
1061 break;
1062 case 'd':
1063 attr = ATT_DIM;
1064 break;
1065 case 'a':
1066 attr = ATT_ALTCHARSET;
1067 break;
1068 default:
1069 return (set_errno(EINVAL));
1070 }
1071
1072 /*
1073 * We need to flush the current buffer contents before calling
1074 * IOP_SETATTR because IOP_SETATTR may need to synchronously output
1075 * terminal escape sequences directly to the underlying device.
1076 */
1077 (void) iob_write(iob, iob->iob_iop, iob->iob_buf, iob->iob_nbytes);
1078 iob->iob_bufp = &iob->iob_buf[0];
1079 iob->iob_nbytes = 0;
1080
1081 return (IOP_SETATTR(iob->iob_pgp, req, attr));
1082 }
1083
1084 static void
1085 iob_bits2str(mdb_iob_t *iob, u_longlong_t value, const mdb_bitmask_t *bmp,
1086 mdb_bool_t altflag)
1087 {
1088 mdb_bool_t delim = FALSE;
1089 const char *str;
1090 size_t width;
1091
1092 if (bmp == NULL)
1093 goto out;
1094
1095 for (; bmp->bm_name != NULL; bmp++) {
1096 if ((value & bmp->bm_mask) == bmp->bm_bits) {
1097 width = strlen(bmp->bm_name) + delim;
1098
1099 if (IOB_WRAPNOW(iob, width))
1100 mdb_iob_nl(iob);
1101
1102 if (delim)
1103 mdb_iob_putc(iob, ',');
1104 else
1105 delim = TRUE;
1106
1107 mdb_iob_puts(iob, bmp->bm_name);
1108 value &= ~bmp->bm_bits;
1109 }
1110 }
1111
1112 out:
1113 if (altflag == TRUE && (delim == FALSE || value != 0)) {
1114 str = numtostr(value, 16, NTOS_UNSIGNED | NTOS_SHOWBASE);
1115 width = strlen(str) + delim;
1116
1117 if (IOB_WRAPNOW(iob, width))
1118 mdb_iob_nl(iob);
1119 if (delim)
1120 mdb_iob_putc(iob, ',');
1121 mdb_iob_puts(iob, str);
1122 }
1123 }
1124
1125 static const char *
1126 iob_inaddr2str(uint32_t addr)
1127 {
1128 static char buf[INET_ADDRSTRLEN];
1129
1130 (void) mdb_inet_ntop(AF_INET, &addr, buf, sizeof (buf));
1131
1132 return (buf);
1133 }
1134
1135 static const char *
1136 iob_ipv6addr2str(void *addr)
1137 {
1138 static char buf[INET6_ADDRSTRLEN];
1139
1140 (void) mdb_inet_ntop(AF_INET6, addr, buf, sizeof (buf));
1141
1142 return (buf);
1143 }
1144
1145 static const char *
1146 iob_getvar(const char *s, size_t len)
1147 {
1148 mdb_var_t *val;
1149 char *var;
1150
1151 if (len == 0) {
1152 (void) set_errno(EINVAL);
1153 return (NULL);
1154 }
1155
1156 var = strndup(s, len);
1157 val = mdb_nv_lookup(&mdb.m_nv, var);
1158 strfree(var);
1159
1160 if (val == NULL) {
1161 (void) set_errno(EINVAL);
1162 return (NULL);
1163 }
1164
1165 return (numtostr(mdb_nv_get_value(val), 10, 0));
1166 }
1167
1168 /*
1169 * The iob_doprnt function forms the main engine of the debugger's output
1170 * formatting capabilities. Note that this is NOT exactly compatible with
1171 * the printf(3S) family, nor is it intended to be so. We support some
1172 * extensions and format characters not supported by printf(3S), and we
1173 * explicitly do NOT provide support for %C, %S, %ws (wide-character strings),
1174 * do NOT provide for the complete functionality of %f, %e, %E, %g, %G
1175 * (alternate double formats), and do NOT support %.x (precision specification).
1176 * Note that iob_doprnt consumes varargs off the original va_list.
1177 */
1178 static void
1179 iob_doprnt(mdb_iob_t *iob, const char *format, varglist_t *ap)
1180 {
1181 char c[2] = { 0, 0 }; /* Buffer for single character output */
1182 const char *p; /* Current position in format string */
1183 size_t len; /* Length of format string to copy verbatim */
1184 size_t altlen; /* Length of alternate print format prefix */
1185 const char *altstr; /* Alternate print format prefix */
1186 const char *symstr; /* Symbol + offset string */
1187
1188 u_longlong_t val; /* Current integer value */
1189 intsize_t size; /* Current integer value size */
1190 uint_t flags; /* Current flags to pass to iob_int2str */
1191 size_t width; /* Current field width */
1192 int zero; /* If != 0, then integer value == 0 */
1193
1194 mdb_bool_t f_alt; /* Use alternate print format (%#) */
1195 mdb_bool_t f_altsuff; /* Alternate print format is a suffix */
1196 mdb_bool_t f_zfill; /* Zero-fill field (%0) */
1197 mdb_bool_t f_left; /* Left-adjust field (%-) */
1198 mdb_bool_t f_digits; /* Explicit digits used to set field width */
1199
1200 union {
1201 const char *str;
1202 uint32_t ui32;
1203 void *ptr;
1204 time_t tm;
1205 char c;
1206 double d;
1207 long double ld;
1208 } u;
1209
1210 ASSERT(iob->iob_flags & MDB_IOB_WRONLY);
1211
1212 while ((p = strchr(format, '%')) != NULL) {
1213 /*
1214 * Output the format string verbatim up to the next '%' char
1215 */
1216 if (p != format) {
1217 len = p - format;
1218 if (IOB_WRAPNOW(iob, len) && *format != '\n')
1219 mdb_iob_nl(iob);
1220 mdb_iob_nputs(iob, format, len);
1221 }
1222
1223 /*
1224 * Now we need to parse the sequence of format characters
1225 * following the % marker and do the appropriate thing.
1226 */
1227 size = SZ_INT; /* Use normal-sized int by default */
1228 flags = 0; /* Clear numtostr() format flags */
1229 width = 0; /* No field width limit by default */
1230 altlen = 0; /* No alternate format string yet */
1231 altstr = NULL; /* No alternate format string yet */
1232
1233 f_alt = FALSE; /* Alternate format off by default */
1234 f_altsuff = FALSE; /* Alternate format is a prefix */
1235 f_zfill = FALSE; /* Zero-fill off by default */
1236 f_left = FALSE; /* Left-adjust off by default */
1237 f_digits = FALSE; /* No digits for width specified yet */
1238
1239 fmt_switch:
1240 switch (*++p) {
1241 case '0': case '1': case '2': case '3': case '4':
1242 case '5': case '6': case '7': case '8': case '9':
1243 if (f_digits == FALSE && *p == '0') {
1244 f_zfill = TRUE;
1245 goto fmt_switch;
1246 }
1247
1248 if (f_digits == FALSE)
1249 width = 0; /* clear any other width specifier */
1250
1251 for (u.c = *p; u.c >= '0' && u.c <= '9'; u.c = *++p)
1252 width = width * 10 + u.c - '0';
1253
1254 p--;
1255 f_digits = TRUE;
1256 goto fmt_switch;
1257
1258 case 'a':
1259 if (size < SZ_LONG)
1260 size = SZ_LONG; /* Bump to size of uintptr_t */
1261
1262 u.str = iob_int2str(ap, size, 16,
1263 NTOS_UNSIGNED | NTOS_SHOWBASE, &zero, &val);
1264
1265 if ((symstr = iob_addr2str(val)) != NULL)
1266 u.str = symstr;
1267
1268 if (f_alt == TRUE) {
1269 f_altsuff = TRUE;
1270 altstr = ":";
1271 altlen = 1;
1272 }
1273 break;
1274
1275 case 'A':
1276 if (size < SZ_LONG)
1277 size = SZ_LONG; /* Bump to size of uintptr_t */
1278
1279 (void) iob_int2str(ap, size, 16,
1280 NTOS_UNSIGNED, &zero, &val);
1281
1282 u.str = iob_addr2str(val);
1283
1284 if (f_alt == TRUE && u.str == NULL)
1285 u.str = "?";
1286 break;
1287
1288 case 'b':
1289 u.str = iob_int2str(ap, size, 16,
1290 NTOS_UNSIGNED | NTOS_SHOWBASE, &zero, &val);
1291
1292 iob_bits2str(iob, val, VA_PTRARG(ap), f_alt);
1293
1294 format = ++p;
1295 continue;
1296
1297 case 'c':
1298 c[0] = (char)VA_ARG(ap, int);
1299 u.str = c;
1300 break;
1301
1302 case 'd':
1303 case 'i':
1304 if (f_alt)
1305 flags |= NTOS_SHOWBASE;
1306 u.str = iob_int2str(ap, size, 10, flags, &zero, &val);
1307 break;
1308
1309 /* No floating point in kmdb */
1310 #ifndef _KMDB
1311 case 'e':
1312 case 'E':
1313 u.d = VA_ARG(ap, double);
1314 u.str = doubletos(u.d, 7, *p);
1315 break;
1316
1317 case 'g':
1318 case 'G':
1319 if (size >= SZ_LONG) {
1320 u.ld = VA_ARG(ap, long double);
1321 u.str = longdoubletos(&u.ld, 16,
1322 (*p == 'g') ? 'e' : 'E');
1323 } else {
1324 u.d = VA_ARG(ap, double);
1325 u.str = doubletos(u.d, 16,
1326 (*p == 'g') ? 'e' : 'E');
1327 }
1328 break;
1329 #endif
1330
1331 case 'h':
1332 size = SZ_SHORT;
1333 goto fmt_switch;
1334
1335 case 'H':
1336 u.str = iob_bytes2str(ap, size);
1337 break;
1338
1339 case 'I':
1340 u.ui32 = VA_ARG(ap, uint32_t);
1341 u.str = iob_inaddr2str(u.ui32);
1342 break;
1343
1344 case 'l':
1345 if (size >= SZ_LONG)
1346 size = SZ_LONGLONG;
1347 else
1348 size = SZ_LONG;
1349 goto fmt_switch;
1350
1351 case 'm':
1352 if (iob->iob_nbytes == 0) {
1353 mdb_iob_ws(iob, (width != 0) ? width :
1354 iob->iob_margin);
1355 }
1356 format = ++p;
1357 continue;
1358
1359 case 'N':
1360 u.ptr = VA_PTRARG(ap);
1361 u.str = iob_ipv6addr2str(u.ptr);
1362 break;
1363
1364 case 'o':
1365 u.str = iob_int2str(ap, size, 8, NTOS_UNSIGNED,
1366 &zero, &val);
1367
1368 if (f_alt && !zero) {
1369 altstr = "0";
1370 altlen = 1;
1371 }
1372 break;
1373
1374 case 'p':
1375 u.ptr = VA_PTRARG(ap);
1376 u.str = numtostr((uintptr_t)u.ptr, 16, NTOS_UNSIGNED);
1377 break;
1378
1379 case 'q':
1380 u.str = iob_int2str(ap, size, 8, flags, &zero, &val);
1381
1382 if (f_alt && !zero) {
1383 altstr = "0";
1384 altlen = 1;
1385 }
1386 break;
1387
1388 case 'r':
1389 if (f_alt)
1390 flags |= NTOS_SHOWBASE;
1391 u.str = iob_int2str(ap, size, mdb.m_radix,
1392 NTOS_UNSIGNED | flags, &zero, &val);
1393 break;
1394
1395 case 'R':
1396 if (f_alt)
1397 flags |= NTOS_SHOWBASE;
1398 u.str = iob_int2str(ap, size, mdb.m_radix, flags,
1399 &zero, &val);
1400 break;
1401
1402 case 's':
1403 u.str = VA_PTRARG(ap);
1404 if (u.str == NULL)
1405 u.str = "<NULL>"; /* Be forgiving of NULL */
1406 break;
1407
1408 case 't':
1409 if (width != 0) {
1410 while (width-- > 0)
1411 mdb_iob_tab(iob);
1412 } else
1413 mdb_iob_tab(iob);
1414
1415 format = ++p;
1416 continue;
1417
1418 case 'T':
1419 if (width != 0 && (iob->iob_nbytes % width) != 0) {
1420 size_t ots = iob->iob_tabstop;
1421 iob->iob_tabstop = width;
1422 mdb_iob_tab(iob);
1423 iob->iob_tabstop = ots;
1424 }
1425 format = ++p;
1426 continue;
1427
1428 case 'u':
1429 if (f_alt)
1430 flags |= NTOS_SHOWBASE;
1431 u.str = iob_int2str(ap, size, 10,
1432 flags | NTOS_UNSIGNED, &zero, &val);
1433 break;
1434
1435 case 'x':
1436 u.str = iob_int2str(ap, size, 16, NTOS_UNSIGNED,
1437 &zero, &val);
1438
1439 if (f_alt && !zero) {
1440 altstr = "0x";
1441 altlen = 2;
1442 }
1443 break;
1444
1445 case 'X':
1446 u.str = iob_int2str(ap, size, 16,
1447 NTOS_UNSIGNED | NTOS_UPCASE, &zero, &val);
1448
1449 if (f_alt && !zero) {
1450 altstr = "0X";
1451 altlen = 2;
1452 }
1453 break;
1454
1455 case 'Y':
1456 u.tm = VA_ARG(ap, time_t);
1457 u.str = iob_time2str(&u.tm);
1458 break;
1459
1460 case '<':
1461 /*
1462 * Used to turn attributes on (<b>), to turn them
1463 * off (</b>), or to print variables (<_var>).
1464 */
1465 for (u.str = ++p; *p != '\0' && *p != '>'; p++)
1466 continue;
1467
1468 if (*p == '>') {
1469 size_t paramlen = p - u.str;
1470
1471 if (paramlen > 0) {
1472 if (*u.str == '_') {
1473 u.str = iob_getvar(u.str + 1,
1474 paramlen - 1);
1475 break;
1476 } else {
1477 (void) iob_setattr(iob, u.str,
1478 paramlen);
1479 }
1480 }
1481
1482 p++;
1483 }
1484
1485 format = p;
1486 continue;
1487
1488 case '*':
1489 width = (size_t)(uint_t)VA_ARG(ap, int);
1490 goto fmt_switch;
1491
1492 case '%':
1493 u.str = "%";
1494 break;
1495
1496 case '?':
1497 width = sizeof (uintptr_t) * 2;
1498 goto fmt_switch;
1499
1500 case '#':
1501 f_alt = TRUE;
1502 goto fmt_switch;
1503
1504 case '+':
1505 flags |= NTOS_SIGNPOS;
1506 goto fmt_switch;
1507
1508 case '-':
1509 f_left = TRUE;
1510 goto fmt_switch;
1511
1512 default:
1513 c[0] = p[0];
1514 u.str = c;
1515 }
1516
1517 len = u.str != NULL ? strlen(u.str) : 0;
1518
1519 if (len + altlen > width)
1520 width = len + altlen;
1521
1522 /*
1523 * If the string and the option altstr won't fit on this line
1524 * and auto-wrap is set (default), skip to the next line.
1525 * If the string contains \n, and the \n terminated substring
1526 * + altstr is shorter than the above, use the shorter lf_len.
1527 */
1528 if (u.str != NULL) {
1529 char *np = strchr(u.str, '\n');
1530 if (np != NULL) {
1531 int lf_len = (np - u.str) + altlen;
1532 if (lf_len < width)
1533 width = lf_len;
1534 }
1535 }
1536 if (IOB_WRAPNOW(iob, width))
1537 mdb_iob_nl(iob);
1538
1539 /*
1540 * Optionally add whitespace or zeroes prefixing the value if
1541 * we haven't filled the minimum width and we're right-aligned.
1542 */
1543 if (len < (width - altlen) && f_left == FALSE) {
1544 mdb_iob_fill(iob, f_zfill ? '0' : ' ',
1545 width - altlen - len);
1546 }
1547
1548 /*
1549 * Print the alternate string if it's a prefix, and then
1550 * print the value string itself.
1551 */
1552 if (altstr != NULL && f_altsuff == FALSE)
1553 mdb_iob_nputs(iob, altstr, altlen);
1554 if (len != 0)
1555 mdb_iob_nputs(iob, u.str, len);
1556
1557 /*
1558 * If we have an alternate string and it's a suffix, print it.
1559 */
1560 if (altstr != NULL && f_altsuff == TRUE)
1561 mdb_iob_nputs(iob, altstr, altlen);
1562
1563 /*
1564 * Finally, if we haven't filled the field width and we're
1565 * left-aligned, pad out the rest with whitespace.
1566 */
1567 if ((len + altlen) < width && f_left == TRUE)
1568 mdb_iob_ws(iob, width - altlen - len);
1569
1570 format = (*p != '\0') ? ++p : p;
1571 }
1572
1573 /*
1574 * If there's anything left in the format string, output it now
1575 */
1576 if (*format != '\0') {
1577 len = strlen(format);
1578 if (IOB_WRAPNOW(iob, len) && *format != '\n')
1579 mdb_iob_nl(iob);
1580 mdb_iob_nputs(iob, format, len);
1581 }
1582 }
1583
1584 void
1585 mdb_iob_vprintf(mdb_iob_t *iob, const char *format, va_list alist)
1586 {
1587 varglist_t ap = { VAT_VARARGS };
1588 va_copy(ap.val_valist, alist);
1589 iob_doprnt(iob, format, &ap);
1590 }
1591
1592 void
1593 mdb_iob_aprintf(mdb_iob_t *iob, const char *format, const mdb_arg_t *argv)
1594 {
1595 varglist_t ap = { VAT_ARGVEC };
1596 ap.val_argv = argv;
1597 iob_doprnt(iob, format, &ap);
1598 }
1599
1600 void
1601 mdb_iob_printf(mdb_iob_t *iob, const char *format, ...)
1602 {
1603 va_list alist;
1604
1605 va_start(alist, format);
1606 mdb_iob_vprintf(iob, format, alist);
1607 va_end(alist);
1608 }
1609
1610 /*
1611 * In order to handle the sprintf family of functions, we define a special
1612 * i/o backend known as a "sprintf buf" (or spbuf for short). This back end
1613 * provides an IOP_WRITE entry point that concatenates each buffer sent from
1614 * mdb_iob_flush() onto the caller's buffer until the caller's buffer is
1615 * exhausted. We also keep an absolute count of how many bytes were sent to
1616 * this function during the lifetime of the snprintf call. This allows us
1617 * to provide the ability to (1) return the total size required for the given
1618 * format string and argument list, and (2) support a call to snprintf with a
1619 * NULL buffer argument with no special case code elsewhere.
1620 */
1621 static ssize_t
1622 spbuf_write(mdb_io_t *io, const void *buf, size_t buflen)
1623 {
1624 spbuf_t *spb = io->io_data;
1625
1626 if (spb->spb_bufsiz != 0) {
1627 size_t n = MIN(spb->spb_bufsiz, buflen);
1628 bcopy(buf, spb->spb_buf, n);
1629 spb->spb_buf += n;
1630 spb->spb_bufsiz -= n;
1631 }
1632
1633 spb->spb_total += buflen;
1634 return (buflen);
1635 }
1636
1637 static const mdb_io_ops_t spbuf_ops = {
1638 no_io_read,
1639 spbuf_write,
1640 no_io_seek,
1641 no_io_ctl,
1642 no_io_close,
1643 no_io_name,
1644 no_io_link,
1645 no_io_unlink,
1646 no_io_setattr,
1647 no_io_suspend,
1648 no_io_resume
1649 };
1650
1651 /*
1652 * The iob_spb_create function initializes an iob suitable for snprintf calls,
1653 * a spbuf i/o backend, and the spbuf private data, and then glues these
1654 * objects together. The caller (either vsnprintf or asnprintf below) is
1655 * expected to have allocated the various structures on their stack.
1656 */
1657 static void
1658 iob_spb_create(mdb_iob_t *iob, char *iob_buf, size_t iob_len,
1659 mdb_io_t *io, spbuf_t *spb, char *spb_buf, size_t spb_len)
1660 {
1661 spb->spb_buf = spb_buf;
1662 spb->spb_bufsiz = spb_len;
1663 spb->spb_total = 0;
1664
1665 io->io_ops = &spbuf_ops;
1666 io->io_data = spb;
1667 io->io_next = NULL;
1668 io->io_refcnt = 1;
1669
1670 iob->iob_buf = iob_buf;
1671 iob->iob_bufsiz = iob_len;
1672 iob->iob_bufp = iob_buf;
1673 iob->iob_nbytes = 0;
1674 iob->iob_nlines = 0;
1675 iob->iob_lineno = 1;
1676 iob->iob_rows = MDB_IOB_DEFROWS;
1677 iob->iob_cols = iob_len;
1678 iob->iob_tabstop = MDB_IOB_DEFTAB;
1679 iob->iob_margin = MDB_IOB_DEFMARGIN;
1680 iob->iob_flags = MDB_IOB_WRONLY;
1681 iob->iob_iop = io;
1682 iob->iob_pgp = NULL;
1683 iob->iob_next = NULL;
1684 }
1685
1686 /*ARGSUSED*/
1687 ssize_t
1688 null_io_write(mdb_io_t *io, const void *buf, size_t nbytes)
1689 {
1690 return (nbytes);
1691 }
1692
1693 static const mdb_io_ops_t null_ops = {
1694 no_io_read,
1695 null_io_write,
1696 no_io_seek,
1697 no_io_ctl,
1698 no_io_close,
1699 no_io_name,
1700 no_io_link,
1701 no_io_unlink,
1702 no_io_setattr,
1703 no_io_suspend,
1704 no_io_resume
1705 };
1706
1707 mdb_io_t *
1708 mdb_nullio_create(void)
1709 {
1710 static mdb_io_t null_io = {
1711 &null_ops,
1712 NULL,
1713 NULL,
1714 1
1715 };
1716
1717 return (&null_io);
1718 }
1719
1720 size_t
1721 mdb_iob_vsnprintf(char *buf, size_t nbytes, const char *format, va_list alist)
1722 {
1723 varglist_t ap = { VAT_VARARGS };
1724 char iob_buf[64];
1725 mdb_iob_t iob;
1726 mdb_io_t io;
1727 spbuf_t spb;
1728
1729 ASSERT(buf != NULL || nbytes == 0);
1730 iob_spb_create(&iob, iob_buf, sizeof (iob_buf), &io, &spb, buf, nbytes);
1731 va_copy(ap.val_valist, alist);
1732 iob_doprnt(&iob, format, &ap);
1733 mdb_iob_flush(&iob);
1734
1735 if (spb.spb_bufsiz != 0)
1736 *spb.spb_buf = '\0';
1737 else if (buf != NULL && nbytes > 0)
1738 *--spb.spb_buf = '\0';
1739
1740 return (spb.spb_total);
1741 }
1742
1743 size_t
1744 mdb_iob_asnprintf(char *buf, size_t nbytes, const char *format,
1745 const mdb_arg_t *argv)
1746 {
1747 varglist_t ap = { VAT_ARGVEC };
1748 char iob_buf[64];
1749 mdb_iob_t iob;
1750 mdb_io_t io;
1751 spbuf_t spb;
1752
1753 ASSERT(buf != NULL || nbytes == 0);
1754 iob_spb_create(&iob, iob_buf, sizeof (iob_buf), &io, &spb, buf, nbytes);
1755 ap.val_argv = argv;
1756 iob_doprnt(&iob, format, &ap);
1757 mdb_iob_flush(&iob);
1758
1759 if (spb.spb_bufsiz != 0)
1760 *spb.spb_buf = '\0';
1761 else if (buf != NULL && nbytes > 0)
1762 *--spb.spb_buf = '\0';
1763
1764 return (spb.spb_total);
1765 }
1766
1767 /*PRINTFLIKE3*/
1768 size_t
1769 mdb_iob_snprintf(char *buf, size_t nbytes, const char *format, ...)
1770 {
1771 va_list alist;
1772
1773 va_start(alist, format);
1774 nbytes = mdb_iob_vsnprintf(buf, nbytes, format, alist);
1775 va_end(alist);
1776
1777 return (nbytes);
1778 }
1779
1780 /*
1781 * Return how many bytes we can copy into our buffer, limited by either cols or
1782 * bufsiz depending on whether AUTOWRAP is on. Note that typically,
1783 * mdb_iob_set_autowrap() will have already checked for an existing
1784 * "->iob_nbytes > ->iob_cols" situation, but we double check here anyway.
1785 */
1786 static size_t
1787 iob_bufleft(mdb_iob_t *iob)
1788 {
1789 if (IOB_AUTOWRAP(iob)) {
1790 if (iob->iob_cols < iob->iob_nbytes) {
1791 mdb_iob_nl(iob);
1792 ASSERT(iob->iob_cols >= iob->iob_nbytes);
1793 }
1794 return (iob->iob_cols - iob->iob_nbytes);
1795 }
1796
1797 ASSERT(iob->iob_bufsiz >= iob->iob_nbytes);
1798 return (iob->iob_bufsiz - iob->iob_nbytes);
1799 }
1800
1801 void
1802 mdb_iob_nputs(mdb_iob_t *iob, const char *s, size_t nbytes)
1803 {
1804 size_t m, n, nleft = nbytes;
1805 const char *p, *q = s;
1806
1807 ASSERT(iob->iob_flags & MDB_IOB_WRONLY);
1808
1809 if (nbytes == 0)
1810 return; /* Return immediately if there is no work to do */
1811
1812 /*
1813 * If the string contains embedded newlines or tabs, invoke ourself
1814 * recursively for each string component, followed by a call to the
1815 * newline or tab routine. This insures that strings with these
1816 * characters obey our wrapping and indenting rules, and that strings
1817 * with embedded newlines are flushed after each newline, allowing
1818 * the output pager to take over if it is enabled.
1819 */
1820 while ((p = strnpbrk(q, "\t\n", nleft)) != NULL) {
1821 if (p > q)
1822 mdb_iob_nputs(iob, q, (size_t)(p - q));
1823
1824 if (*p == '\t')
1825 mdb_iob_tab(iob);
1826 else
1827 mdb_iob_nl(iob);
1828
1829 nleft -= (size_t)(p - q) + 1; /* Update byte count */
1830 q = p + 1; /* Advance past delimiter */
1831 }
1832
1833 /*
1834 * For a given string component, we copy a chunk into the buffer, and
1835 * flush the buffer if we reach the end of a line.
1836 */
1837 while (nleft != 0) {
1838 n = iob_bufleft(iob);
1839 m = MIN(nleft, n); /* copy at most n bytes in this pass */
1840
1841 bcopy(q, iob->iob_bufp, m);
1842 nleft -= m;
1843 q += m;
1844
1845 iob->iob_bufp += m;
1846 iob->iob_nbytes += m;
1847
1848 if (m == n && nleft != 0) {
1849 if (IOB_AUTOWRAP(iob)) {
1850 mdb_iob_nl(iob);
1851 } else {
1852 mdb_iob_flush(iob);
1853 }
1854 }
1855 }
1856 }
1857
1858 void
1859 mdb_iob_puts(mdb_iob_t *iob, const char *s)
1860 {
1861 mdb_iob_nputs(iob, s, strlen(s));
1862 }
1863
1864 void
1865 mdb_iob_putc(mdb_iob_t *iob, int c)
1866 {
1867 mdb_iob_fill(iob, c, 1);
1868 }
1869
1870 void
1871 mdb_iob_tab(mdb_iob_t *iob)
1872 {
1873 ASSERT(iob->iob_flags & MDB_IOB_WRONLY);
1874
1875 if (iob->iob_tabstop != 0) {
1876 /*
1877 * Round up to the next multiple of the tabstop. If this puts
1878 * us off the end of the line, just insert a newline; otherwise
1879 * insert sufficient whitespace to reach position n.
1880 */
1881 size_t n = (iob->iob_nbytes + iob->iob_tabstop) /
1882 iob->iob_tabstop * iob->iob_tabstop;
1883
1884 if (n < iob->iob_cols)
1885 mdb_iob_fill(iob, ' ', n - iob->iob_nbytes);
1886 else
1887 mdb_iob_nl(iob);
1888 }
1889 }
1890
1891 void
1892 mdb_iob_fill(mdb_iob_t *iob, int c, size_t nfill)
1893 {
1894 size_t i, m, n;
1895
1896 ASSERT(iob->iob_flags & MDB_IOB_WRONLY);
1897
1898 while (nfill != 0) {
1899 n = iob_bufleft(iob);
1900 m = MIN(nfill, n); /* fill at most n bytes in this pass */
1901
1902 for (i = 0; i < m; i++)
1903 *iob->iob_bufp++ = (char)c;
1904
1905 iob->iob_nbytes += m;
1906 nfill -= m;
1907
1908 if (m == n && nfill != 0) {
1909 if (IOB_AUTOWRAP(iob)) {
1910 mdb_iob_nl(iob);
1911 } else {
1912 mdb_iob_flush(iob);
1913 }
1914 }
1915 }
1916 }
1917
1918 void
1919 mdb_iob_ws(mdb_iob_t *iob, size_t n)
1920 {
1921 if (!IOB_AUTOWRAP(iob) || iob->iob_nbytes + n < iob->iob_cols)
1922 mdb_iob_fill(iob, ' ', n);
1923 else
1924 mdb_iob_nl(iob);
1925 }
1926
1927 void
1928 mdb_iob_nl(mdb_iob_t *iob)
1929 {
1930 ASSERT(iob->iob_flags & MDB_IOB_WRONLY);
1931
1932 if (iob->iob_nbytes == iob->iob_bufsiz)
1933 mdb_iob_flush(iob);
1934
1935 *iob->iob_bufp++ = '\n';
1936 iob->iob_nbytes++;
1937
1938 mdb_iob_flush(iob);
1939 }
1940
1941 ssize_t
1942 mdb_iob_ngets(mdb_iob_t *iob, char *buf, size_t n)
1943 {
1944 ssize_t resid = n - 1;
1945 ssize_t len;
1946 int c;
1947
1948 if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF))
1949 return (EOF); /* can't gets a write buf or a read buf at EOF */
1950
1951 if (n == 0)
1952 return (0); /* we need room for a terminating \0 */
1953
1954 while (resid != 0) {
1955 if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
1956 goto done; /* failed to refill buffer */
1957
1958 for (len = MIN(iob->iob_nbytes, resid); len != 0; len--) {
1959 c = *iob->iob_bufp++;
1960 iob->iob_nbytes--;
1961
1962 if (c == EOF || c == '\n')
1963 goto done;
1964
1965 *buf++ = (char)c;
1966 resid--;
1967 }
1968 }
1969 done:
1970 *buf = '\0';
1971 return (n - resid - 1);
1972 }
1973
1974 int
1975 mdb_iob_getc(mdb_iob_t *iob)
1976 {
1977 int c;
1978
1979 if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF | MDB_IOB_ERR))
1980 return (EOF); /* can't getc if write-only, EOF, or error bit */
1981
1982 if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
1983 return (EOF); /* failed to refill buffer */
1984
1985 c = (uchar_t)*iob->iob_bufp++;
1986 iob->iob_nbytes--;
1987
1988 return (c);
1989 }
1990
1991 int
1992 mdb_iob_ungetc(mdb_iob_t *iob, int c)
1993 {
1994 if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_ERR))
1995 return (EOF); /* can't ungetc if write-only or error bit set */
1996
1997 if (c == EOF || iob->iob_nbytes == iob->iob_bufsiz)
1998 return (EOF); /* can't ungetc EOF, or ungetc if buffer full */
1999
2000 *--iob->iob_bufp = (char)c;
2001 iob->iob_nbytes++;
2002 iob->iob_flags &= ~MDB_IOB_EOF;
2003
2004 return (c);
2005 }
2006
2007 int
2008 mdb_iob_eof(mdb_iob_t *iob)
2009 {
2010 return ((iob->iob_flags & (MDB_IOB_RDONLY | MDB_IOB_EOF)) ==
2011 (MDB_IOB_RDONLY | MDB_IOB_EOF));
2012 }
2013
2014 int
2015 mdb_iob_err(mdb_iob_t *iob)
2016 {
2017 return ((iob->iob_flags & MDB_IOB_ERR) == MDB_IOB_ERR);
2018 }
2019
2020 ssize_t
2021 mdb_iob_read(mdb_iob_t *iob, void *buf, size_t n)
2022 {
2023 ssize_t resid = n;
2024 ssize_t len;
2025
2026 if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF | MDB_IOB_ERR))
2027 return (0); /* can't read if write-only, eof, or error */
2028
2029 while (resid != 0) {
2030 if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
2031 break; /* failed to refill buffer */
2032
2033 len = MIN(resid, iob->iob_nbytes);
2034 bcopy(iob->iob_bufp, buf, len);
2035
2036 iob->iob_bufp += len;
2037 iob->iob_nbytes -= len;
2038
2039 buf = (char *)buf + len;
2040 resid -= len;
2041 }
2042
2043 return (n - resid);
2044 }
2045
2046 /*
2047 * For now, all binary writes are performed unbuffered. This has the
2048 * side effect that the pager will not be triggered by mdb_iob_write.
2049 */
2050 ssize_t
2051 mdb_iob_write(mdb_iob_t *iob, const void *buf, size_t n)
2052 {
2053 ssize_t ret;
2054
2055 if (iob->iob_flags & MDB_IOB_ERR)
2056 return (set_errno(EIO));
2057 if (iob->iob_flags & MDB_IOB_RDONLY)
2058 return (set_errno(EMDB_IORO));
2059
2060 mdb_iob_flush(iob);
2061 ret = iob_write(iob, iob->iob_iop, buf, n);
2062
2063 if (ret < 0 && iob == mdb.m_out)
2064 longjmp(mdb.m_frame->f_pcb, MDB_ERR_OUTPUT);
2065
2066 return (ret);
2067 }
2068
2069 int
2070 mdb_iob_ctl(mdb_iob_t *iob, int req, void *arg)
2071 {
2072 return (IOP_CTL(iob->iob_iop, req, arg));
2073 }
2074
2075 const char *
2076 mdb_iob_name(mdb_iob_t *iob)
2077 {
2078 if (iob == NULL)
2079 return ("<NULL>");
2080
2081 return (IOP_NAME(iob->iob_iop));
2082 }
2083
2084 size_t
2085 mdb_iob_lineno(mdb_iob_t *iob)
2086 {
2087 return (iob->iob_lineno);
2088 }
2089
2090 size_t
2091 mdb_iob_gettabstop(mdb_iob_t *iob)
2092 {
2093 return (iob->iob_tabstop);
2094 }
2095
2096 size_t
2097 mdb_iob_getmargin(mdb_iob_t *iob)
2098 {
2099 return (iob->iob_margin);
2100 }
2101
2102 mdb_io_t *
2103 mdb_io_hold(mdb_io_t *io)
2104 {
2105 io->io_refcnt++;
2106 return (io);
2107 }
2108
2109 void
2110 mdb_io_rele(mdb_io_t *io)
2111 {
2112 ASSERT(io->io_refcnt != 0);
2113
2114 if (--io->io_refcnt == 0) {
2115 IOP_CLOSE(io);
2116 mdb_free(io, sizeof (mdb_io_t));
2117 }
2118 }
2119
2120 void
2121 mdb_io_destroy(mdb_io_t *io)
2122 {
2123 ASSERT(io->io_refcnt == 0);
2124 IOP_CLOSE(io);
2125 mdb_free(io, sizeof (mdb_io_t));
2126 }
2127
2128 void
2129 mdb_iob_stack_create(mdb_iob_stack_t *stk)
2130 {
2131 stk->stk_top = NULL;
2132 stk->stk_size = 0;
2133 }
2134
2135 void
2136 mdb_iob_stack_destroy(mdb_iob_stack_t *stk)
2137 {
2138 mdb_iob_t *top, *ntop;
2139
2140 for (top = stk->stk_top; top != NULL; top = ntop) {
2141 ntop = top->iob_next;
2142 mdb_iob_destroy(top);
2143 }
2144 }
2145
2146 void
2147 mdb_iob_stack_push(mdb_iob_stack_t *stk, mdb_iob_t *iob, size_t lineno)
2148 {
2149 iob->iob_lineno = lineno;
2150 iob->iob_next = stk->stk_top;
2151 stk->stk_top = iob;
2152 stk->stk_size++;
2153 yylineno = 1;
2154 }
2155
2156 mdb_iob_t *
2157 mdb_iob_stack_pop(mdb_iob_stack_t *stk)
2158 {
2159 mdb_iob_t *top = stk->stk_top;
2160
2161 ASSERT(top != NULL);
2162
2163 stk->stk_top = top->iob_next;
2164 top->iob_next = NULL;
2165 stk->stk_size--;
2166
2167 return (top);
2168 }
2169
2170 size_t
2171 mdb_iob_stack_size(mdb_iob_stack_t *stk)
2172 {
2173 return (stk->stk_size);
2174 }
2175
2176 /*
2177 * This only enables autowrap for iobs that are already autowrap themselves such
2178 * as mdb.m_out typically.
2179 *
2180 * Note that we might be the middle of the iob buffer at this point, and
2181 * specifically, iob->iob_nbytes could be more than iob->iob_cols. As that's
2182 * not a valid situation, we may need to do an autowrap *now*.
2183 *
2184 * In theory, we would need to do this across all MDB_IOB_AUTOWRAP iob's;
2185 * instead, we have a failsafe in iob_bufleft().
2186 */
2187 void
2188 mdb_iob_set_autowrap(mdb_iob_t *iob)
2189 {
2190 mdb.m_flags |= MDB_FL_AUTOWRAP;
2191 if (IOB_WRAPNOW(iob, 0))
2192 mdb_iob_nl(iob);
2193 ASSERT(iob->iob_cols >= iob->iob_nbytes);
2194 }
2195
2196 /*
2197 * Stub functions for i/o backend implementors: these stubs either act as
2198 * pass-through no-ops or return ENOTSUP as appropriate.
2199 */
2200 ssize_t
2201 no_io_read(mdb_io_t *io, void *buf, size_t nbytes)
2202 {
2203 if (io->io_next != NULL)
2204 return (IOP_READ(io->io_next, buf, nbytes));
2205
2206 return (set_errno(EMDB_IOWO));
2207 }
2208
2209 ssize_t
2210 no_io_write(mdb_io_t *io, const void *buf, size_t nbytes)
2211 {
2212 if (io->io_next != NULL)
2213 return (IOP_WRITE(io->io_next, buf, nbytes));
2214
2215 return (set_errno(EMDB_IORO));
2216 }
2217
2218 off64_t
2219 no_io_seek(mdb_io_t *io, off64_t offset, int whence)
2220 {
2221 if (io->io_next != NULL)
2222 return (IOP_SEEK(io->io_next, offset, whence));
2223
2224 return (set_errno(ENOTSUP));
2225 }
2226
2227 int
2228 no_io_ctl(mdb_io_t *io, int req, void *arg)
2229 {
2230 if (io->io_next != NULL)
2231 return (IOP_CTL(io->io_next, req, arg));
2232
2233 return (set_errno(ENOTSUP));
2234 }
2235
2236 /*ARGSUSED*/
2237 void
2238 no_io_close(mdb_io_t *io)
2239 {
2240 /*
2241 * Note that we do not propagate IOP_CLOSE down the io stack. IOP_CLOSE should
2242 * only be called by mdb_io_rele when an io's reference count has gone to zero.
2243 */
2244 }
2245
2246 const char *
2247 no_io_name(mdb_io_t *io)
2248 {
2249 if (io->io_next != NULL)
2250 return (IOP_NAME(io->io_next));
2251
2252 return ("(anonymous)");
2253 }
2254
2255 void
2256 no_io_link(mdb_io_t *io, mdb_iob_t *iob)
2257 {
2258 if (io->io_next != NULL)
2259 IOP_LINK(io->io_next, iob);
2260 }
2261
2262 void
2263 no_io_unlink(mdb_io_t *io, mdb_iob_t *iob)
2264 {
2265 if (io->io_next != NULL)
2266 IOP_UNLINK(io->io_next, iob);
2267 }
2268
2269 int
2270 no_io_setattr(mdb_io_t *io, int req, uint_t attrs)
2271 {
2272 if (io->io_next != NULL)
2273 return (IOP_SETATTR(io->io_next, req, attrs));
2274
2275 return (set_errno(ENOTSUP));
2276 }
2277
2278 void
2279 no_io_suspend(mdb_io_t *io)
2280 {
2281 if (io->io_next != NULL)
2282 IOP_SUSPEND(io->io_next);
2283 }
2284
2285 void
2286 no_io_resume(mdb_io_t *io)
2287 {
2288 if (io->io_next != NULL)
2289 IOP_RESUME(io->io_next);
2290 }
2291
2292 /*
2293 * Iterate over the varargs. The first item indicates the mode:
2294 * MDB_TBL_PRNT
2295 * pull out the next vararg as a const char * and pass it and the
2296 * remaining varargs to iob_doprnt; if we want to print the column,
2297 * direct the output to mdb.m_out otherwise direct it to mdb.m_null
2298 *
2299 * MDB_TBL_FUNC
2300 * pull out the next vararg as type mdb_table_print_f and the
2301 * following one as a void * argument to the function; call the
2302 * function with the given argument if we want to print the column
2303 *
2304 * The second item indicates the flag; if the flag is set in the flags
2305 * argument, then the column is printed. A flag value of 0 indicates
2306 * that the column should always be printed.
2307 */
2308 void
2309 mdb_table_print(uint_t flags, const char *delimeter, ...)
2310 {
2311 va_list alist;
2312 uint_t flg;
2313 uint_t type;
2314 const char *fmt;
2315 mdb_table_print_f *func;
2316 void *arg;
2317 mdb_iob_t *out;
2318 mdb_bool_t first = TRUE;
2319 mdb_bool_t print;
2320
2321 va_start(alist, delimeter);
2322
2323 while ((type = va_arg(alist, uint_t)) != MDB_TBL_DONE) {
2324 flg = va_arg(alist, uint_t);
2325
2326 print = flg == 0 || (flg & flags) != 0;
2327
2328 if (print) {
2329 if (first)
2330 first = FALSE;
2331 else
2332 mdb_printf("%s", delimeter);
2333 }
2334
2335 switch (type) {
2336 case MDB_TBL_PRNT: {
2337 varglist_t ap = { VAT_VARARGS };
2338 fmt = va_arg(alist, const char *);
2339 out = print ? mdb.m_out : mdb.m_null;
2340 va_copy(ap.val_valist, alist);
2341 iob_doprnt(out, fmt, &ap);
2342 va_end(alist);
2343 va_copy(alist, ap.val_valist);
2344 break;
2345 }
2346
2347 case MDB_TBL_FUNC:
2348 func = va_arg(alist, mdb_table_print_f *);
2349 arg = va_arg(alist, void *);
2350
2351 if (print)
2352 func(arg);
2353
2354 break;
2355
2356 default:
2357 warn("bad format type %x\n", type);
2358 break;
2359 }
2360 }
2361
2362 va_end(alist);
2363 }