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 2006 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/resource.h>
31#include <sys/termios.h>
32#include <sys/param.h>
33#include <sys/salib.h>
34
35#include <alloca.h>
36#include <unistd.h>
37#include <string.h>
38#include <stdlib.h>
39#include <fcntl.h>
40#include <libctf.h>
41#include <errno.h>
42#include <ctype.h>
43
44#include <kmdb/kmdb_promif.h>
45#include <kmdb/kmdb_dpi.h>
46#include <kmdb/kmdb_umemglue.h>
47#include <kmdb/kmdb_io.h>
48#include <kmdb/kmdb_dpi.h>
49#include <kmdb/kmdb_wr.h>
50#include <kmdb/kmdb_start.h>
51#include <kmdb/kmdb_kdi.h>
52#include <kmdb/kmdb_kvm.h>
53#include <mdb/mdb_lex.h>
54#include <mdb/mdb_debug.h>
55#include <mdb/mdb_signal.h>
56#include <mdb/mdb_string.h>
57#include <mdb/mdb_modapi.h>
58#include <mdb/mdb_target.h>
59#include <mdb/mdb_gelf.h>
60#include <mdb/mdb_conf.h>
61#include <mdb/mdb_err.h>
62#include <mdb/mdb_io_impl.h>
63#include <mdb/mdb_frame.h>
64#include <mdb/mdb_set.h>
65#include <mdb/mdb.h>
66
67#ifdef __sparc
68#define	KMDB_STACK_SIZE	(384 * 1024)
69#else
70#define	KMDB_STACK_SIZE (192 * 1024)
71#endif
72
73caddr_t kmdb_main_stack;
74size_t kmdb_main_stack_size;
75
76#define	KMDB_DEF_IPATH	"internal"
77#if defined(_LP64)
78#define	KMDB_DEF_LPATH	\
79	"%r/platform/%p/kernel/kmdb/%i:" \
80	"%r/platform/%m/kernel/kmdb/%i:" \
81	"%r/kernel/kmdb/%i"
82#else
83#define	KMDB_DEF_LPATH	\
84	"%r/platform/%m/kernel/kmdb:" \
85	"%r/kernel/kmdb"
86#endif
87
88#define	MDB_DEF_PROMPT "[%<_cpuid>]> "
89
90#define	KMDB_DEF_TERM_TYPE	"vt100"
91
92/*
93 * Similar to the panic_* variables in the kernel, we keep some relevant
94 * information stored in a set of global _mdb_abort_* variables; in the
95 * event that the debugger dumps core, these will aid core dump analysis.
96 */
97const char *volatile _mdb_abort_str;	/* reason for failure */
98
99/*
100 * The kernel supplies a space-delimited list of directories
101 * (/platform/sun4u/kernel /kernel /usr/kernel ...) which we must transform into
102 * a debugger-friendly, colon-delimited module search path.  We add the kmdb
103 * module directory to each component and change the delimiter.
104 */
105static char *
106kmdb_modpath2lpath(const char *modpath)
107{
108#ifdef	_LP64
109	static const char suffix[] = "/kmdb/%i:";
110#else
111	static const char suffix[] = "/kmdb:";
112#endif
113	const char *c;
114	char *lpath, *lpend, *nlpath;
115	size_t lpsz, lpres;
116
117	if (strchr(modpath, ':') != NULL) {
118		warn("invalid kernel module path\n");
119		return (NULL);
120	}
121
122	lpres = lpsz = strlen(modpath) + MAXPATHLEN;
123	lpend = lpath = mdb_zalloc(lpsz, UM_SLEEP);
124
125	while (isspace(*modpath))
126		modpath++;
127
128	for (; *modpath != '\0'; modpath = c) {
129		size_t sz;
130
131		for (c = modpath; !isspace(*c) && *c != '\0'; c++)
132			continue;
133
134		sz = (c - modpath) + sizeof (suffix) - 1;
135		if (sz >= lpres)
136			continue;
137
138		(void) strncpy(lpend, modpath, c - modpath);
139		(void) strcpy(lpend + (c - modpath), suffix);
140
141		lpend += sz;
142		lpres -= sz;
143
144		while (isspace(*c))
145			c++;
146	}
147
148	if (lpend != lpath)
149		lpend[-1] = '\0';	/* eat trailing colon */
150
151	nlpath = strdup(lpath);
152	mdb_free(lpath, lpsz);
153	return (nlpath);
154}
155
156/*
157 * called while the kernel is running
158 */
159int
160kmdb_init(const char *execname, kmdb_auxv_t *kav)
161{
162	mdb_io_t *in_io, *out_io, *err_io, *null_io;
163	mdb_tgt_ctor_f *tgt_ctor = kmdb_kvm_create;
164	mdb_tgt_t *tgt;
165	int i;
166
167	/*
168	 * The beginnings of debugger initialization are a bit of a dance, due
169	 * to interlocking dependencies between kmdb_prom_init,
170	 * mdb_umem_startup, and mdb_create.  In particular, allocator
171	 * initialization can't begin until prom_init() is called,
172	 * kmdb_prom_init can't finish until the allocator is ready and
173	 * mdb_create has been called.  We therefore split kmdb_prom_init into
174	 * two pieces, and call thembefore and after umem initialization and
175	 * mdb_create.
176	 */
177	kmdb_prom_init_begin("kmdb", kav);
178	mdb_umem_startup(kav->kav_dseg, kav->kav_dseg_size,
179	    kav->kav_pagesize);
180	mdb_create(execname, "kmdb");
181	kmdb_prom_init_finish(kav);
182
183	mdb.m_dseg = kav->kav_dseg;
184	mdb.m_dsegsz = kav->kav_dseg_size;
185
186	out_io = kmdb_promio_create("stdout");
187	mdb.m_out = mdb_iob_create(out_io, MDB_IOB_WRONLY);
188
189	err_io = kmdb_promio_create("stderr");
190	mdb.m_err = mdb_iob_create(err_io, MDB_IOB_WRONLY);
191	mdb_iob_clrflags(mdb.m_err, MDB_IOB_AUTOWRAP);
192
193	null_io = mdb_nullio_create();
194	mdb.m_null = mdb_iob_create(null_io, MDB_IOB_WRONLY);
195
196	in_io = kmdb_promio_create("stdin");
197	mdb.m_term = NULL;
198
199	if (kav->kav_config != NULL)
200		mdb_set_config(kav->kav_config);
201
202	if (kav->kav_argv != NULL) {
203		for (i = 0; kav->kav_argv[i] != NULL; i++) {
204			if (!mdb_set_options(kav->kav_argv[i], TRUE))
205				return (-1);
206		}
207	}
208
209	if (kav->kav_flags & KMDB_AUXV_FL_NOUNLOAD)
210		mdb.m_flags |= MDB_FL_NOUNLOAD;
211
212	mdb.m_in = mdb_iob_create(in_io, MDB_IOB_RDONLY);
213	mdb_iob_setflags(mdb.m_in, MDB_IOB_TTYLIKE);
214
215	mdb_lex_reset();
216
217	kmdb_kdi_init(kav->kav_kdi, kav);
218
219	if (kmdb_dpi_init(kav) < 0) {
220		warn("Couldn't initialize kernel/PROM interface\n");
221		return (-1);
222	}
223
224	/*
225	 * Path evaluation part 1: Create the initial module path to allow
226	 * the target constructor to load a support module.  We base kmdb's
227	 * module path off the kernel's module path unless the user has
228	 * explicitly supplied one.
229	 */
230	mdb_set_ipath(KMDB_DEF_IPATH);
231	if (strlen(mdb.m_lpathstr) > 0) {
232		mdb_set_lpath(mdb.m_lpathstr);
233	} else {
234		char *lpath;
235
236		if (kav->kav_modpath != NULL && *kav->kav_modpath != '\0' &&
237		    (lpath = kmdb_modpath2lpath(kav->kav_modpath)) != NULL) {
238			mdb_set_lpath(lpath);
239			strfree(lpath);
240		} else {
241			mdb_set_lpath(KMDB_DEF_LPATH);
242		}
243	}
244
245	if (mdb_get_prompt() == NULL)
246		(void) mdb_set_prompt(MDB_DEF_PROMPT);
247
248	tgt = mdb_tgt_create(tgt_ctor, mdb.m_tgtflags, 0, NULL);
249
250	if (tgt == NULL) {
251		warn("failed to initialize target");
252		return (-1);
253	}
254
255	mdb_tgt_activate(tgt);
256
257	mdb_create_loadable_disasms();
258
259	/*
260	 * Path evaluation part 2: Re-evaluate the path now that the target
261	 * is ready (and thus we have access to the real platform string).
262	 */
263	mdb_set_ipath(mdb.m_ipathstr);
264	mdb_set_lpath(mdb.m_lpathstr);
265
266	if (!(mdb.m_flags & MDB_FL_NOMODS))
267		mdb_module_load_all(MDB_MOD_DEFER);
268
269	/* Allocate the main debugger stack */
270	kmdb_main_stack = mdb_alloc(KMDB_STACK_SIZE, UM_SLEEP);
271	kmdb_main_stack_size = KMDB_STACK_SIZE;
272
273	kmdb_kdi_end_init();
274
275	return (0);
276}
277
278#ifdef sun4v
279
280void
281kmdb_init_promif(char *pgmname, kmdb_auxv_t *kav)
282{
283	kmdb_prom_init_promif(pgmname, kav);
284}
285
286#else
287
288/*ARGSUSED*/
289void
290kmdb_init_promif(char *pgmname, kmdb_auxv_t *kav)
291{
292	/*
293	 * Fake function for non sun4v. See comments in kmdb_ctl.h
294	 */
295	ASSERT(0);
296}
297
298#endif
299
300/*
301 * First-time kmdb startup.  Run when kmdb has control of the machine for the
302 * first time.
303 */
304static void
305kmdb_startup(void)
306{
307	mdb_io_t *inio, *outio;
308
309	if (mdb.m_termtype == NULL) {
310		/*
311		 * The terminal type wasn't specified, so we guess.  If we're
312		 * on console, we'll get a terminal type from the PROM.  If not,
313		 * we'll use the default.
314		 */
315		const char *ttype;
316
317		if ((ttype = kmdb_prom_term_type()) == NULL) {
318			ttype = KMDB_DEF_TERM_TYPE;
319			warn("unable to determine terminal type: "
320			    "assuming `%s'\n", ttype);
321		}
322
323		mdb.m_flags |= MDB_FL_TERMGUESS;
324		mdb.m_termtype = strdup(ttype);
325
326	} else if (mdb.m_flags & MDB_FL_TERMGUESS) {
327		/*
328		 * The terminal type wasn't specified by the user, but a guess
329		 * was made using either $TERM or a property from the SMF.  A
330		 * terminal type from the PROM code overrides the guess, so
331		 * we'll use that if we can.
332		 */
333		char *promttype;
334
335		if ((promttype = kmdb_prom_term_type()) != NULL) {
336			strfree(mdb.m_termtype);
337			mdb.m_termtype = strdup(promttype);
338		}
339	}
340
341	inio = kmdb_promio_create("stdin");
342	outio = kmdb_promio_create("stdout");
343
344	if ((mdb.m_term = mdb_termio_create(mdb.m_termtype, inio, outio)) ==
345	    NULL && strcmp(mdb.m_termtype, KMDB_DEF_TERM_TYPE) != 0) {
346		warn("failed to set terminal type to `%s', using `"
347		    KMDB_DEF_TERM_TYPE "'\n", mdb.m_termtype);
348
349		strfree(mdb.m_termtype);
350		mdb.m_termtype = strdup(KMDB_DEF_TERM_TYPE);
351
352		if ((mdb.m_term = mdb_termio_create(mdb.m_termtype, inio,
353		    outio)) == NULL) {
354			fail("failed to set terminal type to `"
355			    KMDB_DEF_TERM_TYPE "'\n");
356		}
357	}
358
359	mdb_iob_destroy(mdb.m_in);
360	mdb.m_in = mdb_iob_create(mdb.m_term, MDB_IOB_RDONLY);
361	mdb_iob_setpager(mdb.m_out, mdb.m_term);
362	mdb_iob_setflags(mdb.m_out, MDB_IOB_PGENABLE);
363
364	kmdb_kvm_startup();
365
366	/*
367	 * kmdb_init() and kctl_activate() may have been talking to each other,
368	 * and may have left some messages for us.  The driver -> debugger
369	 * queue is normally processed during the resume path, so we have to
370	 * do it manually here if we want it to be run for first startup.
371	 */
372	kmdb_dpi_process_work_queue();
373
374	kmdb_kvm_poststartup();
375}
376
377void
378kmdb_main(void)
379{
380	int status;
381
382	kmdb_dpi_set_state(DPI_STATE_STOPPED, 0);
383	mdb_printf("\nWelcome to kmdb\n");
384	kmdb_startup();
385
386	/*
387	 * Debugger termination is a bit tricky.  For compatibility with kadb,
388	 * neither an EOF on stdin nor a normal ::quit will cause the debugger
389	 * to unload.  In both cases, they get a trip to OBP, after which the
390	 * debugger returns.
391	 *
392	 * The only supported way to cause the debugger to unload is to specify
393	 * the unload flag to ::quit, or to have the driver request it.  The
394	 * driver request is the primary exit mechanism - the ::quit flag is
395	 * provided for convenience.
396	 *
397	 * Both forms of "exit" (unqualified ::quit that won't cause an unload,
398	 * and a driver request that will) are signalled by an MDB_ERR_QUIT.  In
399	 * the latter case, however, the KDI will have the unload request.
400	 */
401	for (;;) {
402		status = mdb_run();
403
404		if (status == MDB_ERR_QUIT && kmdb_kdi_get_unload_request()) {
405			break;
406
407		} else if (status == MDB_ERR_QUIT || status == 0) {
408			kmdb_dpi_enter_mon();
409
410		} else if (status == MDB_ERR_OUTPUT) {
411			/*
412			 * If a write failed on stdout, give up.  A more
413			 * informative error message will already have been
414			 * printed by mdb_run().
415			 */
416			if (mdb_iob_getflags(mdb.m_out) & MDB_IOB_ERR)
417				fail("write to stdout failed, exiting\n");
418
419		} else if (status != MDB_ERR_ABORT) {
420			fail("debugger exited abnormally (status = %s)\n",
421			    mdb_err2str(status));
422		}
423	}
424
425	mdb_destroy();
426
427	kmdb_dpi_resume_unload();
428
429	/*NOTREACHED*/
430}
431