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
73 caddr_t kmdb_main_stack;
74 size_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 */
97 const 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 */
105 static char *
kmdb_modpath2lpath(const char * modpath)106 kmdb_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 */
159 int
kmdb_init(const char * execname,kmdb_auxv_t * kav)160 kmdb_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
280 void
kmdb_init_promif(char * pgmname,kmdb_auxv_t * kav)281 kmdb_init_promif(char *pgmname, kmdb_auxv_t *kav)
282 {
283 kmdb_prom_init_promif(pgmname, kav);
284 }
285
286 #else
287
288 /*ARGSUSED*/
289 void
kmdb_init_promif(char * pgmname,kmdb_auxv_t * kav)290 kmdb_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 */
304 static void
kmdb_startup(void)305 kmdb_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
377 void
kmdb_main(void)378 kmdb_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