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 * 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 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 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 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 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 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