xref: /illumos-gate/usr/src/cmd/mdb/common/mdb/mdb_main.c (revision 67e3a03ed4a2813074d36330f062ed6e593a4937)
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 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <sys/mman.h>
30 #include <sys/priocntl.h>
31 #include <sys/rtpriocntl.h>
32 #include <sys/resource.h>
33 #include <sys/termios.h>
34 #include <sys/param.h>
35 #include <sys/regset.h>
36 #include <sys/frame.h>
37 #include <sys/stack.h>
38 #include <sys/reg.h>
39 
40 #include <libproc.h>
41 #include <libscf.h>
42 #include <alloca.h>
43 #include <unistd.h>
44 #include <string.h>
45 #include <stdlib.h>
46 #include <fcntl.h>
47 #include <dlfcn.h>
48 #include <libctf.h>
49 #include <errno.h>
50 #include <kvm.h>
51 
52 #include <mdb/mdb_lex.h>
53 #include <mdb/mdb_debug.h>
54 #include <mdb/mdb_signal.h>
55 #include <mdb/mdb_string.h>
56 #include <mdb/mdb_modapi.h>
57 #include <mdb/mdb_target.h>
58 #include <mdb/mdb_gelf.h>
59 #include <mdb/mdb_conf.h>
60 #include <mdb/mdb_err.h>
61 #include <mdb/mdb_io_impl.h>
62 #include <mdb/mdb_frame.h>
63 #include <mdb/mdb_set.h>
64 #include <kmdb/kmdb_kctl.h>
65 #include <mdb/mdb.h>
66 
67 #ifndef STACK_BIAS
68 #define	STACK_BIAS	0
69 #endif
70 
71 #if defined(__sparc)
72 #define	STACK_REGISTER	SP
73 #else
74 #define	STACK_REGISTER	REG_FP
75 #endif
76 
77 #ifdef _LP64
78 #define	MDB_DEF_IPATH	\
79 	"%r/usr/platform/%p/lib/adb/%i:" \
80 	"%r/usr/platform/%m/lib/adb/%i:" \
81 	"%r/usr/lib/adb/%i"
82 #define	MDB_DEF_LPATH	\
83 	"%r/usr/platform/%p/lib/mdb/%t/%i:" \
84 	"%r/usr/platform/%m/lib/mdb/%t/%i:" \
85 	"%r/usr/lib/mdb/%t/%i"
86 #else
87 #define	MDB_DEF_IPATH	\
88 	"%r/usr/platform/%p/lib/adb:" \
89 	"%r/usr/platform/%m/lib/adb:" \
90 	"%r/usr/lib/adb"
91 #define	MDB_DEF_LPATH	\
92 	"%r/usr/platform/%p/lib/mdb/%t:" \
93 	"%r/usr/platform/%m/lib/mdb/%t:" \
94 	"%r/usr/lib/mdb/%t"
95 #endif
96 
97 #define	MDB_DEF_PROMPT "> "
98 
99 /*
100  * Similar to the panic_* variables in the kernel, we keep some relevant
101  * information stored in a set of global _mdb_abort_* variables; in the
102  * event that the debugger dumps core, these will aid core dump analysis.
103  */
104 const char *volatile _mdb_abort_str;	/* reason for failure */
105 siginfo_t _mdb_abort_info;		/* signal info for fatal signal */
106 ucontext_t _mdb_abort_ctx;		/* context fatal signal interrupted */
107 int _mdb_abort_rcount;			/* number of times resume requested */
108 int _mdb_self_fd = -1;			/* fd for self as for valid_frame */
109 
110 static void
111 terminate(int status)
112 {
113 	mdb_destroy();
114 	exit(status);
115 }
116 
117 static void
118 print_frame(uintptr_t pc, int fnum)
119 {
120 	Dl_info dli;
121 
122 	if (dladdr((void *)pc, &dli)) {
123 		mdb_iob_printf(mdb.m_err, "    [%d] %s`%s+0x%lx()\n", fnum,
124 		    strbasename(dli.dli_fname), dli.dli_sname,
125 		    pc - (uintptr_t)dli.dli_saddr);
126 	} else
127 		mdb_iob_printf(mdb.m_err, "    [%d] %p()\n", fnum, pc);
128 }
129 
130 static int
131 valid_frame(struct frame *fr)
132 {
133 	static struct frame fake;
134 	uintptr_t addr = (uintptr_t)fr;
135 
136 	if (pread(_mdb_self_fd, &fake, sizeof (fake), addr) != sizeof (fake)) {
137 		mdb_iob_printf(mdb.m_err, "    invalid frame (%p)\n", fr);
138 		return (0);
139 	}
140 
141 	if (addr & (STACK_ALIGN - 1)) {
142 		mdb_iob_printf(mdb.m_err, "    mis-aligned frame (%p)\n", fr);
143 		return (0);
144 	}
145 
146 	return (1);
147 }
148 
149 /*ARGSUSED*/
150 static void
151 flt_handler(int sig, siginfo_t *sip, ucontext_t *ucp, void *data)
152 {
153 	static const struct rlimit rl = {
154 		(rlim_t)RLIM_INFINITY, (rlim_t)RLIM_INFINITY
155 	};
156 
157 	const mdb_idcmd_t *idcp = NULL;
158 
159 	if (mdb.m_frame != NULL && mdb.m_frame->f_cp != NULL)
160 		idcp = mdb.m_frame->f_cp->c_dcmd;
161 
162 	if (sip != NULL)
163 		bcopy(sip, &_mdb_abort_info, sizeof (_mdb_abort_info));
164 	if (ucp != NULL)
165 		bcopy(ucp, &_mdb_abort_ctx, sizeof (_mdb_abort_ctx));
166 
167 	_mdb_abort_info.si_signo = sig;
168 	(void) mdb_signal_sethandler(sig, SIG_DFL, NULL);
169 
170 	/*
171 	 * If there is no current dcmd, or the current dcmd comes from a
172 	 * builtin module, we don't allow resume and always core dump.
173 	 */
174 	if (idcp == NULL || idcp->idc_modp == NULL ||
175 	    idcp->idc_modp == &mdb.m_rmod || idcp->idc_modp->mod_hdl == NULL)
176 		goto dump;
177 
178 	if (mdb.m_term != NULL) {
179 		struct frame *fr = (struct frame *)
180 		    (ucp->uc_mcontext.gregs[STACK_REGISTER] + STACK_BIAS);
181 
182 		char signame[SIG2STR_MAX];
183 		int i = 1;
184 		char c;
185 
186 		if (sig2str(sig, signame) == -1) {
187 			mdb_iob_printf(mdb.m_err,
188 			    "\n*** %s: received signal %d at:\n",
189 			    mdb.m_pname, sig);
190 		} else {
191 			mdb_iob_printf(mdb.m_err,
192 			    "\n*** %s: received signal %s at:\n",
193 			    mdb.m_pname, signame);
194 		}
195 
196 		if (ucp->uc_mcontext.gregs[REG_PC] != 0)
197 			print_frame(ucp->uc_mcontext.gregs[REG_PC], i++);
198 
199 		while (fr != NULL && valid_frame(fr) && fr->fr_savpc != 0) {
200 			print_frame(fr->fr_savpc, i++);
201 			fr = (struct frame *)
202 			    ((uintptr_t)fr->fr_savfp + STACK_BIAS);
203 		}
204 
205 query:
206 		mdb_iob_printf(mdb.m_err, "\n%s: (c)ore dump, (q)uit, "
207 		    "(r)ecover, or (s)top for debugger [cqrs]? ", mdb.m_pname);
208 
209 		mdb_iob_flush(mdb.m_err);
210 
211 		for (;;) {
212 			if (IOP_READ(mdb.m_term, &c, sizeof (c)) != sizeof (c))
213 				goto dump;
214 
215 			switch (c) {
216 			case 'c':
217 			case 'C':
218 				(void) setrlimit(RLIMIT_CORE, &rl);
219 				mdb_iob_printf(mdb.m_err, "\n%s: attempting "
220 				    "to dump core ...\n", mdb.m_pname);
221 				goto dump;
222 
223 			case 'q':
224 			case 'Q':
225 				mdb_iob_discard(mdb.m_out);
226 				mdb_iob_nl(mdb.m_err);
227 				(void) mdb_signal_unblockall();
228 				terminate(1);
229 				/*NOTREACHED*/
230 
231 			case 'r':
232 			case 'R':
233 				mdb_iob_printf(mdb.m_err, "\n%s: unloading "
234 				    "module '%s' ...\n", mdb.m_pname,
235 				    idcp->idc_modp->mod_name);
236 
237 				(void) mdb_module_unload(
238 				    idcp->idc_modp->mod_name, 0);
239 
240 				(void) mdb_signal_sethandler(sig,
241 				    flt_handler, NULL);
242 
243 				_mdb_abort_rcount++;
244 				mdb.m_intr = 0;
245 				mdb.m_pend = 0;
246 
247 				(void) mdb_signal_unblockall();
248 				longjmp(mdb.m_frame->f_pcb, MDB_ERR_ABORT);
249 				/*NOTREACHED*/
250 
251 			case 's':
252 			case 'S':
253 				mdb_iob_printf(mdb.m_err, "\n%s: "
254 				    "attempting to stop pid %d ...\n",
255 				    mdb.m_pname, (int)getpid());
256 
257 				/*
258 				 * Stop ourself; if this fails or we are
259 				 * subsequently continued, ask again.
260 				 */
261 				(void) mdb_signal_raise(SIGSTOP);
262 				(void) mdb_signal_unblockall();
263 				goto query;
264 			}
265 		}
266 	}
267 
268 dump:
269 	if (SI_FROMUSER(sip)) {
270 		(void) mdb_signal_block(sig);
271 		(void) mdb_signal_raise(sig);
272 	}
273 
274 	(void) sigfillset(&ucp->uc_sigmask);
275 	(void) sigdelset(&ucp->uc_sigmask, sig);
276 
277 	if (_mdb_abort_str == NULL)
278 		_mdb_abort_str = "fatal signal received";
279 
280 	ucp->uc_flags |= UC_SIGMASK;
281 	(void) setcontext(ucp);
282 }
283 
284 /*ARGSUSED*/
285 static void
286 int_handler(int sig, siginfo_t *sip, ucontext_t *ucp, void *data)
287 {
288 	if (mdb.m_intr == 0)
289 		longjmp(mdb.m_frame->f_pcb, MDB_ERR_SIGINT);
290 	else
291 		mdb.m_pend++;
292 }
293 
294 static void
295 control_kmdb(int start)
296 {
297 	int fd;
298 
299 	if ((fd = open("/dev/kmdb", O_RDONLY)) < 0)
300 		die("failed to open /dev/kmdb");
301 
302 	if (start) {
303 		char *state = mdb_get_config();
304 
305 		if (ioctl(fd, KMDB_IOC_START, state) < 0)
306 			die("failed to start kmdb");
307 
308 		strfree(state);
309 	} else {
310 		if (ioctl(fd, KMDB_IOC_STOP) < 0)
311 			die("failed to stop kmdb");
312 	}
313 
314 	close(fd);
315 }
316 
317 static void
318 usage(int status)
319 {
320 	mdb_iob_printf(mdb.m_err, "Usage: %s [-fkmuwyAFKMSUW] [+/-o option] "
321 	    "[-p pid] [-s dist] [-I path] [-L path]\n\t[-P prompt] "
322 	    "[-R root] [-V dis-version] [object [core] | core | suffix]\n\n",
323 	    mdb.m_pname);
324 
325 	mdb_iob_puts(mdb.m_err,
326 	    "\t-f force raw file debugging mode\n"
327 	    "\t-k force kernel debugging mode\n"
328 	    "\t-m disable demand-loading of module symbols\n"
329 	    "\t-o set specified debugger option (+o to unset)\n"
330 	    "\t-p attach to specified process-id\n"
331 	    "\t-s set symbol matching distance\n"
332 	    "\t-u force user program debugging mode\n"
333 	    "\t-w enable write mode\n"
334 	    "\t-y send terminal initialization sequences for tty mode\n"
335 	    "\t-A disable automatic loading of mdb modules\n"
336 	    "\t-F enable forcible takeover mode\n"
337 	    "\t-K stop operating system and enter live kernel debugger\n"
338 	    "\t-M preload all module symbols\n"
339 	    "\t-I set initial path for macro files\n"
340 	    "\t-L set initial path for module libs\n"
341 	    "\t-P set command-line prompt\n"
342 	    "\t-R set root directory for pathname expansion\n"
343 	    "\t-S suppress processing of ~/.mdbrc file\n"
344 	    "\t-U unload live kernel debugger\n"
345 	    "\t-W enable I/O-mapped memory access (kernel only)\n"
346 	    "\t-V set disassembler version\n");
347 
348 	terminate(status);
349 }
350 
351 static char *
352 mdb_scf_console_term(void)
353 {
354 	scf_simple_prop_t *prop;
355 	char *term = NULL;
356 
357 	if ((prop = scf_simple_prop_get(NULL,
358 	    "svc:/system/console-login:default", "ttymon",
359 	    "terminal_type")) == NULL)
360 		return (NULL);
361 
362 	if (scf_simple_prop_type(prop) == SCF_TYPE_ASTRING &&
363 	    (term = scf_simple_prop_next_astring(prop)) != NULL)
364 		term = strdup(term);
365 
366 	scf_simple_prop_free(prop);
367 	return (term);
368 }
369 
370 /*
371  * Unpleasant hack: we might be debugging a hypervisor domain dump.
372  * Earlier versions use a non-ELF file.  Later versions are ELF, but are
373  * /always/ ELF64, so our standard ehdr check isn't good enough.  Since
374  * we don't want to know too much about the file format, we'll ask
375  * mdb_kb.
376  */
377 #ifdef __x86
378 static int
379 identify_xvm_file(const char *file, int *longmode)
380 {
381 	int (*identify)(const char *, int *);
382 
383 	if (mdb_module_load("mdb_kb", MDB_MOD_GLOBAL | MDB_MOD_SILENT) != 0)
384 		return (0);
385 
386 	identify = (int (*)())dlsym(RTLD_NEXT, "xkb_identify");
387 
388 	if (identify == NULL)
389 		return (0);
390 
391 	return (identify(file, longmode));
392 }
393 #else
394 /*ARGSUSED*/
395 static int
396 identify_xvm_file(const char *file, int *longmode)
397 {
398 	return (0);
399 }
400 #endif /* __x86 */
401 
402 int
403 main(int argc, char *argv[], char *envp[])
404 {
405 	mdb_tgt_ctor_f *tgt_ctor = NULL;
406 	const char **tgt_argv = alloca(argc * sizeof (char *));
407 	int tgt_argc = 0;
408 	mdb_tgt_t *tgt;
409 
410 	char object[MAXPATHLEN], execname[MAXPATHLEN];
411 	mdb_io_t *in_io, *out_io, *err_io, *null_io;
412 	struct termios tios;
413 	int status, c;
414 	char *p;
415 
416 	const char *Iflag = NULL, *Lflag = NULL, *Vflag = NULL, *pidarg = NULL;
417 	int fflag = 0, Kflag = 0, Rflag = 0, Sflag = 0, Oflag = 0, Uflag = 0;
418 
419 	int ttylike;
420 	int longmode = 0;
421 
422 	stack_t sigstack;
423 
424 	if (realpath(getexecname(), execname) == NULL) {
425 		(void) strncpy(execname, argv[0], MAXPATHLEN);
426 		execname[MAXPATHLEN - 1] = '\0';
427 	}
428 
429 	mdb_create(execname, argv[0]);
430 	bzero(tgt_argv, argc * sizeof (char *));
431 	argv[0] = (char *)mdb.m_pname;
432 	_mdb_self_fd = open("/proc/self/as", O_RDONLY);
433 
434 	mdb.m_env = envp;
435 
436 	out_io = mdb_fdio_create(STDOUT_FILENO);
437 	mdb.m_out = mdb_iob_create(out_io, MDB_IOB_WRONLY);
438 
439 	err_io = mdb_fdio_create(STDERR_FILENO);
440 	mdb.m_err = mdb_iob_create(err_io, MDB_IOB_WRONLY);
441 	mdb_iob_clrflags(mdb.m_err, MDB_IOB_AUTOWRAP);
442 
443 	null_io = mdb_nullio_create();
444 	mdb.m_null = mdb_iob_create(null_io, MDB_IOB_WRONLY);
445 
446 	in_io = mdb_fdio_create(STDIN_FILENO);
447 	if ((mdb.m_termtype = getenv("TERM")) != NULL) {
448 		mdb.m_termtype = strdup(mdb.m_termtype);
449 		mdb.m_flags |= MDB_FL_TERMGUESS;
450 	}
451 	mdb.m_term = NULL;
452 
453 	mdb_dmode(mdb_dstr2mode(getenv("MDB_DEBUG")));
454 	mdb.m_pgid = getpgrp();
455 
456 	if (getenv("_MDB_EXEC") != NULL)
457 		mdb.m_flags |= MDB_FL_EXEC;
458 
459 	/*
460 	 * Setup an alternate signal stack.  When tearing down pipelines in
461 	 * terminate(), we may have to destroy the stack of the context in
462 	 * which we are currently executing the signal handler.
463 	 */
464 	sigstack.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ | PROT_WRITE,
465 	    MAP_PRIVATE | MAP_ANON, -1, 0);
466 	if (sigstack.ss_sp == MAP_FAILED)
467 		die("could not allocate signal stack");
468 	sigstack.ss_size = SIGSTKSZ;
469 	sigstack.ss_flags = 0;
470 	if (sigaltstack(&sigstack, NULL) != 0)
471 		die("could not set signal stack");
472 
473 	(void) mdb_signal_sethandler(SIGPIPE, SIG_IGN, NULL);
474 	(void) mdb_signal_sethandler(SIGQUIT, SIG_IGN, NULL);
475 
476 	(void) mdb_signal_sethandler(SIGILL, flt_handler, NULL);
477 	(void) mdb_signal_sethandler(SIGTRAP, flt_handler, NULL);
478 	(void) mdb_signal_sethandler(SIGIOT, flt_handler, NULL);
479 	(void) mdb_signal_sethandler(SIGEMT, flt_handler, NULL);
480 	(void) mdb_signal_sethandler(SIGFPE, flt_handler, NULL);
481 	(void) mdb_signal_sethandler(SIGBUS, flt_handler, NULL);
482 	(void) mdb_signal_sethandler(SIGSEGV, flt_handler, NULL);
483 
484 	(void) mdb_signal_sethandler(SIGHUP, (mdb_signal_f *)terminate, NULL);
485 	(void) mdb_signal_sethandler(SIGTERM, (mdb_signal_f *)terminate, NULL);
486 
487 	for (mdb.m_rdvers = RD_VERSION; mdb.m_rdvers > 0; mdb.m_rdvers--) {
488 		if (rd_init(mdb.m_rdvers) == RD_OK)
489 			break;
490 	}
491 
492 	for (mdb.m_ctfvers = CTF_VERSION; mdb.m_ctfvers > 0; mdb.m_ctfvers--) {
493 		if (ctf_version(mdb.m_ctfvers) != -1)
494 			break;
495 	}
496 
497 	if ((p = getenv("HISTSIZE")) != NULL && strisnum(p)) {
498 		mdb.m_histlen = strtoi(p);
499 		if (mdb.m_histlen < 1)
500 			mdb.m_histlen = 1;
501 	}
502 
503 	while (optind < argc) {
504 		while ((c = getopt(argc, argv,
505 		    "fkmo:p:s:uwyACD:FI:KL:MOP:R:SUV:W")) != (int)EOF) {
506 			switch (c) {
507 			case 'f':
508 				fflag++;
509 				tgt_ctor = mdb_rawfile_tgt_create;
510 				break;
511 			case 'k':
512 				tgt_ctor = mdb_kvm_tgt_create;
513 				break;
514 			case 'm':
515 				mdb.m_tgtflags |= MDB_TGT_F_NOLOAD;
516 				mdb.m_tgtflags &= ~MDB_TGT_F_PRELOAD;
517 				break;
518 			case 'o':
519 				if (!mdb_set_options(optarg, TRUE))
520 					terminate(2);
521 				break;
522 			case 'p':
523 				tgt_ctor = mdb_proc_tgt_create;
524 				pidarg = optarg;
525 				break;
526 			case 's':
527 				if (!strisnum(optarg)) {
528 					warn("expected integer following -s\n");
529 					terminate(2);
530 				}
531 				mdb.m_symdist = (size_t)(uint_t)strtoi(optarg);
532 				break;
533 			case 'u':
534 				tgt_ctor = mdb_proc_tgt_create;
535 				break;
536 			case 'w':
537 				mdb.m_tgtflags |= MDB_TGT_F_RDWR;
538 				break;
539 			case 'y':
540 				mdb.m_flags |= MDB_FL_USECUP;
541 				break;
542 			case 'A':
543 				(void) mdb_set_options("nomods", TRUE);
544 				break;
545 			case 'C':
546 				(void) mdb_set_options("noctf", TRUE);
547 				break;
548 			case 'D':
549 				mdb_dmode(mdb_dstr2mode(optarg));
550 				break;
551 			case 'F':
552 				mdb.m_tgtflags |= MDB_TGT_F_FORCE;
553 				break;
554 			case 'I':
555 				Iflag = optarg;
556 				break;
557 			case 'L':
558 				Lflag = optarg;
559 				break;
560 			case 'K':
561 				Kflag++;
562 				break;
563 			case 'M':
564 				mdb.m_tgtflags |= MDB_TGT_F_PRELOAD;
565 				mdb.m_tgtflags &= ~MDB_TGT_F_NOLOAD;
566 				break;
567 			case 'O':
568 				Oflag++;
569 				break;
570 			case 'P':
571 				if (!mdb_set_prompt(optarg))
572 					terminate(2);
573 				break;
574 			case 'R':
575 				(void) strncpy(mdb.m_root, optarg, MAXPATHLEN);
576 				mdb.m_root[MAXPATHLEN - 1] = '\0';
577 				Rflag++;
578 				break;
579 			case 'S':
580 				Sflag++;
581 				break;
582 			case 'U':
583 				Uflag++;
584 				break;
585 			case 'V':
586 				Vflag = optarg;
587 				break;
588 			case 'W':
589 				mdb.m_tgtflags |= MDB_TGT_F_ALLOWIO;
590 				break;
591 			case '?':
592 				if (optopt == '?')
593 					usage(0);
594 				/* FALLTHROUGH */
595 			default:
596 				usage(2);
597 			}
598 		}
599 
600 		if (optind < argc) {
601 			const char *arg = argv[optind++];
602 
603 			if (arg[0] == '+' && strlen(arg) == 2) {
604 				if (arg[1] != 'o') {
605 					warn("illegal option -- %s\n", arg);
606 					terminate(2);
607 				}
608 				if (optind >= argc) {
609 					warn("option requires an argument -- "
610 					    "%s\n", arg);
611 					terminate(2);
612 				}
613 				if (!mdb_set_options(argv[optind++], FALSE))
614 					terminate(2);
615 			} else
616 				tgt_argv[tgt_argc++] = arg;
617 		}
618 	}
619 
620 	if (rd_ctl(RD_CTL_SET_HELPPATH, (void *)mdb.m_root) != RD_OK) {
621 		warn("cannot set librtld_db helper path to %s\n", mdb.m_root);
622 		terminate(2);
623 	}
624 
625 	if (mdb.m_debug & MDB_DBG_HELP)
626 		terminate(0); /* Quit here if we've printed out the tokens */
627 
628 
629 	if (Iflag != NULL && strchr(Iflag, ';') != NULL) {
630 		warn("macro path cannot contain semicolons\n");
631 		terminate(2);
632 	}
633 
634 	if (Lflag != NULL && strchr(Lflag, ';') != NULL) {
635 		warn("module path cannot contain semicolons\n");
636 		terminate(2);
637 	}
638 
639 	if (Kflag || Uflag) {
640 		char *nm;
641 
642 		if (tgt_ctor != NULL || Iflag != NULL) {
643 			warn("neither -f, -k, -p, -u, nor -I "
644 			    "may be used with -K\n");
645 			usage(2);
646 		}
647 
648 		if (Lflag != NULL)
649 			mdb_set_lpath(Lflag);
650 
651 		if ((nm = ttyname(STDIN_FILENO)) == NULL ||
652 		    strcmp(nm, "/dev/console") != 0) {
653 			/*
654 			 * Due to the consequences of typing mdb -K instead of
655 			 * mdb -k on a tty other than /dev/console, we require
656 			 * -F when starting kmdb from a tty other than
657 			 * /dev/console.
658 			 */
659 			if (!(mdb.m_tgtflags & MDB_TGT_F_FORCE)) {
660 				die("-F must also be supplied to start kmdb "
661 				    "from non-console tty\n");
662 			}
663 
664 			if (mdb.m_termtype == NULL || (mdb.m_flags &
665 			    MDB_FL_TERMGUESS)) {
666 				if (mdb.m_termtype != NULL)
667 					strfree(mdb.m_termtype);
668 
669 				if ((mdb.m_termtype = mdb_scf_console_term()) !=
670 				    NULL)
671 					mdb.m_flags |= MDB_FL_TERMGUESS;
672 			}
673 		} else {
674 			/*
675 			 * When on console, $TERM (if set) takes precedence over
676 			 * the SMF setting.
677 			 */
678 			if (mdb.m_termtype == NULL && (mdb.m_termtype =
679 			    mdb_scf_console_term()) != NULL)
680 				mdb.m_flags |= MDB_FL_TERMGUESS;
681 		}
682 
683 		control_kmdb(Kflag);
684 		terminate(0);
685 		/*NOTREACHED*/
686 	}
687 
688 	/*
689 	 * If standard input appears to have tty attributes, attempt to
690 	 * initialize a terminal i/o backend on top of stdin and stdout.
691 	 */
692 	ttylike = (IOP_CTL(in_io, TCGETS, &tios) == 0);
693 	if (ttylike) {
694 		if ((mdb.m_term = mdb_termio_create(mdb.m_termtype,
695 		    in_io, out_io)) == NULL) {
696 			if (!(mdb.m_flags & MDB_FL_EXEC)) {
697 				warn("term init failed: command-line editing "
698 				    "and prompt will not be available\n");
699 			}
700 		} else {
701 			in_io = mdb.m_term;
702 		}
703 	}
704 
705 	mdb.m_in = mdb_iob_create(in_io, MDB_IOB_RDONLY);
706 	if (mdb.m_term != NULL) {
707 		mdb_iob_setpager(mdb.m_out, mdb.m_term);
708 		if (mdb.m_flags & MDB_FL_PAGER)
709 			mdb_iob_setflags(mdb.m_out, MDB_IOB_PGENABLE);
710 		else
711 			mdb_iob_clrflags(mdb.m_out, MDB_IOB_PGENABLE);
712 	} else if (ttylike)
713 		mdb_iob_setflags(mdb.m_in, MDB_IOB_TTYLIKE);
714 	else
715 		mdb_iob_setbuf(mdb.m_in, mdb_alloc(1, UM_SLEEP), 1);
716 
717 	mdb_pservice_init();
718 	mdb_lex_reset();
719 
720 	if ((mdb.m_shell = getenv("SHELL")) == NULL)
721 		mdb.m_shell = "/bin/sh";
722 
723 	/*
724 	 * If the debugger state is to be inherited from a previous instance,
725 	 * restore it now prior to path evaluation so that %R is updated.
726 	 */
727 	if ((p = getenv(MDB_CONFIG_ENV_VAR)) != NULL) {
728 		mdb_set_config(p);
729 		(void) unsetenv(MDB_CONFIG_ENV_VAR);
730 	}
731 
732 	/*
733 	 * Path evaluation part 1: Create the initial module path to allow
734 	 * the target constructor to load a support module.  Then expand
735 	 * any command-line arguments that modify the paths.
736 	 */
737 	if (Iflag != NULL)
738 		mdb_set_ipath(Iflag);
739 	else
740 		mdb_set_ipath(MDB_DEF_IPATH);
741 
742 	if (Lflag != NULL)
743 		mdb_set_lpath(Lflag);
744 	else
745 		mdb_set_lpath(MDB_DEF_LPATH);
746 
747 	if (mdb_get_prompt() == NULL && !(mdb.m_flags & MDB_FL_ADB))
748 		(void) mdb_set_prompt(MDB_DEF_PROMPT);
749 
750 	if (tgt_ctor == mdb_kvm_tgt_create) {
751 		if (pidarg != NULL) {
752 			warn("-p and -k options are mutually exclusive\n");
753 			terminate(2);
754 		}
755 
756 		if (tgt_argc == 0)
757 			tgt_argv[tgt_argc++] = "/dev/ksyms";
758 		if (tgt_argc == 1 && strisnum(tgt_argv[0]) == 0) {
759 			if (mdb.m_tgtflags & MDB_TGT_F_ALLOWIO)
760 				tgt_argv[tgt_argc++] = "/dev/allkmem";
761 			else
762 				tgt_argv[tgt_argc++] = "/dev/kmem";
763 		}
764 	}
765 
766 	if (pidarg != NULL) {
767 		if (tgt_argc != 0) {
768 			warn("-p may not be used with other arguments\n");
769 			terminate(2);
770 		}
771 		if (proc_arg_psinfo(pidarg, PR_ARG_PIDS, NULL, &status) == -1) {
772 			die("cannot attach to %s: %s\n",
773 			    pidarg, Pgrab_error(status));
774 		}
775 		if (strchr(pidarg, '/') != NULL)
776 			(void) mdb_iob_snprintf(object, MAXPATHLEN,
777 			    "%s/object/a.out", pidarg);
778 		else
779 			(void) mdb_iob_snprintf(object, MAXPATHLEN,
780 			    "/proc/%s/object/a.out", pidarg);
781 		tgt_argv[tgt_argc++] = object;
782 		tgt_argv[tgt_argc++] = pidarg;
783 	}
784 
785 	/*
786 	 * Find the first argument that is not a special "-" token.  If one is
787 	 * found, we will examine this file and make some inferences below.
788 	 */
789 	for (c = 0; c < tgt_argc && strcmp(tgt_argv[c], "-") == 0; c++)
790 		continue;
791 
792 	if (c < tgt_argc) {
793 		Elf32_Ehdr ehdr;
794 		mdb_io_t *io;
795 
796 		/*
797 		 * If special "-" tokens preceded an argument, shift the entire
798 		 * argument list to the left to remove the leading "-" args.
799 		 */
800 		if (c > 0) {
801 			bcopy(&tgt_argv[c], tgt_argv,
802 			    sizeof (const char *) * (tgt_argc - c));
803 			tgt_argc -= c;
804 		}
805 
806 		/*
807 		 * If we just have an object file name, and that file doesn't
808 		 * exist, and it's a string of digits, infer it to be a
809 		 * sequence number referring to a pair of crash dump files.
810 		 */
811 		if (tgt_argc == 1 && access(tgt_argv[0], F_OK) == -1 &&
812 		    strisnum(tgt_argv[0])) {
813 
814 			size_t len = strlen(tgt_argv[0]) + 8;
815 			const char *object = tgt_argv[0];
816 
817 			tgt_argv[0] = mdb_alloc(len, UM_SLEEP);
818 			tgt_argv[1] = mdb_alloc(len, UM_SLEEP);
819 
820 			(void) strcpy((char *)tgt_argv[0], "unix.");
821 			(void) strcat((char *)tgt_argv[0], object);
822 			(void) strcpy((char *)tgt_argv[1], "vmcore.");
823 			(void) strcat((char *)tgt_argv[1], object);
824 
825 			tgt_argc = 2;
826 		}
827 
828 		/*
829 		 * We need to open the object file in order to determine its
830 		 * ELF class and potentially re-exec ourself.
831 		 */
832 		if ((io = mdb_fdio_create_path(NULL, tgt_argv[0],
833 		    O_RDONLY, 0)) == NULL)
834 			die("failed to open %s", tgt_argv[0]);
835 
836 		/*
837 		 * If the target is unknown or is not the rawfile target, do
838 		 * a gelf_check to determine if the file is an ELF file.  If
839 		 * it is not and the target is unknown, use the rawfile tgt.
840 		 * Otherwise an ELF-based target is needed, so we must abort.
841 		 */
842 		if (tgt_ctor != mdb_rawfile_tgt_create &&
843 		    mdb_gelf_check(io, &ehdr, ET_NONE) == -1) {
844 			if (tgt_ctor != NULL) {
845 				(void) mdb_gelf_check(io, &ehdr, ET_EXEC);
846 				mdb_io_destroy(io);
847 				terminate(1);
848 			} else
849 				tgt_ctor = mdb_rawfile_tgt_create;
850 		}
851 
852 		mdb_io_destroy(io);
853 
854 		if (identify_xvm_file(tgt_argv[0], &longmode) == 1 &&
855 		    !fflag) {
856 #ifdef _LP64
857 			if (!longmode)
858 				goto reexec;
859 #else
860 			if (longmode)
861 				goto reexec;
862 #endif
863 			tgt_ctor = mdb_kvm_tgt_create;
864 			goto tcreate;
865 		}
866 
867 		if (tgt_ctor == mdb_rawfile_tgt_create)
868 			goto tcreate; /* skip re-exec and just create target */
869 
870 		/*
871 		 * The object file turned out to be a user core file (ET_CORE),
872 		 * and no other arguments were specified, swap 0 and 1.  The
873 		 * proc target will infer the executable for us.
874 		 */
875 		if (ehdr.e_type == ET_CORE) {
876 			tgt_argv[tgt_argc++] = tgt_argv[0];
877 			tgt_argv[0] = NULL;
878 			tgt_ctor = mdb_proc_tgt_create;
879 		}
880 
881 		/*
882 		 * If tgt_argv[1] is filled in, open it up and determine if it
883 		 * is a vmcore file.  If it is, gelf_check will fail and we
884 		 * set tgt_ctor to 'kvm'; otherwise we use the default.
885 		 */
886 		if (tgt_argc > 1 && strcmp(tgt_argv[1], "-") != 0 &&
887 		    tgt_argv[0] != NULL && pidarg == NULL) {
888 			Elf32_Ehdr chdr;
889 
890 			if (access(tgt_argv[1], F_OK) == -1)
891 				die("failed to access %s", tgt_argv[1]);
892 
893 			if ((io = mdb_fdio_create_path(NULL, tgt_argv[1],
894 			    O_RDONLY, 0)) == NULL)
895 				die("failed to open %s", tgt_argv[1]);
896 
897 			if (mdb_gelf_check(io, &chdr, ET_NONE) == -1)
898 				tgt_ctor = mdb_kvm_tgt_create;
899 
900 			mdb_io_destroy(io);
901 		}
902 
903 		/*
904 		 * At this point, we've read the ELF header for either an
905 		 * object file or core into ehdr.  If the class does not match
906 		 * ours, attempt to exec the mdb of the appropriate class.
907 		 */
908 #ifdef _LP64
909 		if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
910 			goto reexec;
911 #else
912 		if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
913 			goto reexec;
914 #endif
915 	}
916 
917 tcreate:
918 	if (tgt_ctor == NULL)
919 		tgt_ctor = mdb_proc_tgt_create;
920 
921 	tgt = mdb_tgt_create(tgt_ctor, mdb.m_tgtflags, tgt_argc, tgt_argv);
922 
923 	if (tgt == NULL) {
924 		if (errno == EINVAL)
925 			usage(2); /* target can return EINVAL to get usage */
926 		if (errno == EMDB_TGT)
927 			terminate(1); /* target already printed error msg */
928 		die("failed to initialize target");
929 	}
930 
931 	mdb_tgt_activate(tgt);
932 
933 	mdb_create_loadable_disasms();
934 
935 	if (Vflag != NULL && mdb_dis_select(Vflag) == -1)
936 		warn("invalid disassembler mode -- %s\n", Vflag);
937 
938 
939 	if (Rflag && mdb.m_term != NULL)
940 		warn("Using proto area %s\n", mdb.m_root);
941 
942 	/*
943 	 * If the target was successfully constructed and -O was specified,
944 	 * we now attempt to enter piggy-mode for debugging jurassic problems.
945 	 */
946 	if (Oflag) {
947 		pcinfo_t pci;
948 
949 		(void) strcpy(pci.pc_clname, "RT");
950 
951 		if (priocntl(P_LWPID, P_MYID, PC_GETCID, (caddr_t)&pci) != -1) {
952 			pcparms_t pcp;
953 			rtparms_t *rtp = (rtparms_t *)pcp.pc_clparms;
954 
955 			rtp->rt_pri = 35;
956 			rtp->rt_tqsecs = 0;
957 			rtp->rt_tqnsecs = RT_TQDEF;
958 
959 			pcp.pc_cid = pci.pc_cid;
960 
961 			if (priocntl(P_LWPID, P_MYID, PC_SETPARMS,
962 			    (caddr_t)&pcp) == -1) {
963 				warn("failed to set RT parameters");
964 				Oflag = 0;
965 			}
966 		} else {
967 			warn("failed to get RT class id");
968 			Oflag = 0;
969 		}
970 
971 		if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
972 			warn("failed to lock address space");
973 			Oflag = 0;
974 		}
975 
976 		if (Oflag)
977 			mdb_printf("%s: oink, oink!\n", mdb.m_pname);
978 	}
979 
980 	/*
981 	 * Path evaluation part 2: Re-evaluate the path now that the target
982 	 * is ready (and thus we have access to the real platform string).
983 	 * Do this before reading ~/.mdbrc to allow path modifications prior
984 	 * to performing module auto-loading.
985 	 */
986 	mdb_set_ipath(mdb.m_ipathstr);
987 	mdb_set_lpath(mdb.m_lpathstr);
988 
989 	if (!Sflag && (p = getenv("HOME")) != NULL) {
990 		char rcpath[MAXPATHLEN];
991 		mdb_io_t *rc_io;
992 		int fd;
993 
994 		(void) mdb_iob_snprintf(rcpath, MAXPATHLEN, "%s/.mdbrc", p);
995 		fd = open64(rcpath, O_RDONLY);
996 
997 		if (fd >= 0 && (rc_io = mdb_fdio_create_named(fd, rcpath))) {
998 			mdb_iob_t *iob = mdb_iob_create(rc_io, MDB_IOB_RDONLY);
999 			mdb_iob_t *old = mdb.m_in;
1000 
1001 			mdb.m_in = iob;
1002 			(void) mdb_run();
1003 			mdb.m_in = old;
1004 		}
1005 	}
1006 
1007 	if (!(mdb.m_flags & MDB_FL_NOMODS))
1008 		mdb_module_load_all(0);
1009 
1010 	(void) mdb_signal_sethandler(SIGINT, int_handler, NULL);
1011 	while ((status = mdb_run()) == MDB_ERR_ABORT ||
1012 	    status == MDB_ERR_OUTPUT) {
1013 		/*
1014 		 * If a write failed on stdout, give up.  A more informative
1015 		 * error message will already have been printed by mdb_run().
1016 		 */
1017 		if (status == MDB_ERR_OUTPUT &&
1018 		    mdb_iob_getflags(mdb.m_out) & MDB_IOB_ERR) {
1019 			mdb_warn("write to stdout failed, exiting\n");
1020 			break;
1021 		}
1022 		continue;
1023 	}
1024 
1025 	terminate((status == MDB_ERR_QUIT || status == 0) ? 0 : 1);
1026 	/*NOTREACHED*/
1027 	return (0);
1028 
1029 reexec:
1030 	if ((p = strrchr(execname, '/')) == NULL)
1031 		die("cannot determine absolute pathname\n");
1032 #ifdef _LP64
1033 #ifdef __sparc
1034 	(void) strcpy(p, "/../sparcv7/");
1035 #else
1036 	(void) strcpy(p, "/../i86/");
1037 #endif
1038 #else
1039 #ifdef __sparc
1040 	(void) strcpy(p, "/../sparcv9/");
1041 #else
1042 	(void) strcpy(p, "/../amd64/");
1043 #endif
1044 #endif
1045 	(void) strcat(p, mdb.m_pname);
1046 
1047 	if (mdb.m_term != NULL)
1048 		(void) IOP_CTL(in_io, TCSETSW, &tios);
1049 
1050 	(void) putenv("_MDB_EXEC=1");
1051 	(void) execv(execname, argv);
1052 
1053 	/*
1054 	 * If execv fails, suppress ENOEXEC.  Experience shows the most common
1055 	 * reason is that the machine is booted under a 32-bit kernel, in which
1056 	 * case it is clearer to only print the message below.
1057 	 */
1058 	if (errno != ENOEXEC)
1059 		warn("failed to exec %s", execname);
1060 #ifdef _LP64
1061 	die("64-bit %s cannot debug 32-bit program %s\n",
1062 	    mdb.m_pname, tgt_argv[0] ?
1063 	    tgt_argv[0] : tgt_argv[1]);
1064 #else
1065 	die("32-bit %s cannot debug 64-bit program %s\n",
1066 	    mdb.m_pname, tgt_argv[0] ?
1067 	    tgt_argv[0] : tgt_argv[1]);
1068 #endif
1069 
1070 	goto tcreate;
1071 }
1072