17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5ae115bc7Smrj * Common Development and Distribution License (the "License"). 6ae115bc7Smrj * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*f6e214c7SGavin Maltby * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 237c478bd9Sstevel@tonic-gate */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_kvm.h> 267c478bd9Sstevel@tonic-gate #include <kmdb/kvm.h> 277c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_kdi.h> 287c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_promif.h> 297c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_module.h> 307c478bd9Sstevel@tonic-gate #include <kmdb/kmdb_asmutil.h> 317c478bd9Sstevel@tonic-gate #include <mdb/mdb_types.h> 327c478bd9Sstevel@tonic-gate #include <mdb/mdb_conf.h> 337c478bd9Sstevel@tonic-gate #include <mdb/mdb_err.h> 347c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h> 357c478bd9Sstevel@tonic-gate #include <mdb/mdb_target_impl.h> 367c478bd9Sstevel@tonic-gate #include <mdb/mdb_debug.h> 377c478bd9Sstevel@tonic-gate #include <mdb/mdb_string.h> 387c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf.h> 397c478bd9Sstevel@tonic-gate #include <mdb/mdb_kreg_impl.h> 40acbc304dSjohnlev #include <mdb/mdb_ks.h> 417c478bd9Sstevel@tonic-gate #include <mdb/mdb.h> 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate #include <strings.h> 447c478bd9Sstevel@tonic-gate #include <dlfcn.h> 457c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h> 467c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 477c478bd9Sstevel@tonic-gate #include <sys/kobj_impl.h> 487c478bd9Sstevel@tonic-gate #include <sys/bitmap.h> 497c478bd9Sstevel@tonic-gate #include <vm/as.h> 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate static const char KMT_RTLD_NAME[] = "krtld"; 527c478bd9Sstevel@tonic-gate static const char KMT_MODULE[] = "mdb_ks"; 537c478bd9Sstevel@tonic-gate static const char KMT_CTFPARENT[] = "genunix"; 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate static mdb_list_t kmt_defbp_list; /* List of current deferred bp's */ 567c478bd9Sstevel@tonic-gate static int kmt_defbp_lock; /* For list, running kernel holds */ 577c478bd9Sstevel@tonic-gate static uint_t kmt_defbp_modchg_isload; /* Whether mod change is load/unload */ 587c478bd9Sstevel@tonic-gate static struct modctl *kmt_defbp_modchg_modctl; /* modctl for defbp checking */ 597c478bd9Sstevel@tonic-gate static uint_t kmt_defbp_num; /* Number of referenced def'd bp's */ 607c478bd9Sstevel@tonic-gate static int kmt_defbp_bpspec; /* vespec for def'd bp activation bp */ 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_brkpt_ops; 637c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_wapt_ops; 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate static void kmt_sync(mdb_tgt_t *); 667c478bd9Sstevel@tonic-gate 677c478bd9Sstevel@tonic-gate typedef struct kmt_symarg { 687c478bd9Sstevel@tonic-gate mdb_tgt_sym_f *sym_cb; /* Caller's callback function */ 697c478bd9Sstevel@tonic-gate void *sym_data; /* Callback function argument */ 707c478bd9Sstevel@tonic-gate uint_t sym_type; /* Symbol type/binding filter */ 717c478bd9Sstevel@tonic-gate mdb_syminfo_t sym_info; /* Symbol id and table id */ 727c478bd9Sstevel@tonic-gate const char *sym_obj; /* Containing object */ 737c478bd9Sstevel@tonic-gate } kmt_symarg_t; 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate typedef struct kmt_maparg { 767c478bd9Sstevel@tonic-gate mdb_tgt_t *map_target; /* Target used for mapping iter */ 777c478bd9Sstevel@tonic-gate mdb_tgt_map_f *map_cb; /* Caller's callback function */ 787c478bd9Sstevel@tonic-gate void *map_data; /* Callback function argument */ 797c478bd9Sstevel@tonic-gate } kmt_maparg_t; 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 827c478bd9Sstevel@tonic-gate int 837c478bd9Sstevel@tonic-gate kmt_setflags(mdb_tgt_t *t, int flags) 847c478bd9Sstevel@tonic-gate { 857c478bd9Sstevel@tonic-gate /* 867c478bd9Sstevel@tonic-gate * We only handle one flag (ALLOWIO), and we can't fail to set or clear 877c478bd9Sstevel@tonic-gate * it, so we just blindly replace the t_flags version with the one 887c478bd9Sstevel@tonic-gate * passed. 897c478bd9Sstevel@tonic-gate */ 907c478bd9Sstevel@tonic-gate t->t_flags = (t->t_flags & ~MDB_TGT_F_ALLOWIO) | 917c478bd9Sstevel@tonic-gate (flags & MDB_TGT_F_ALLOWIO); 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate return (0); 947c478bd9Sstevel@tonic-gate } 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 977c478bd9Sstevel@tonic-gate const char * 987c478bd9Sstevel@tonic-gate kmt_name(mdb_tgt_t *t) 997c478bd9Sstevel@tonic-gate { 1007c478bd9Sstevel@tonic-gate return ("kmdb_kvm"); 1017c478bd9Sstevel@tonic-gate } 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1047c478bd9Sstevel@tonic-gate static const char * 1057c478bd9Sstevel@tonic-gate kmt_platform(mdb_tgt_t *t) 1067c478bd9Sstevel@tonic-gate { 1077c478bd9Sstevel@tonic-gate static char platform[SYS_NMLN]; 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT) 1107c478bd9Sstevel@tonic-gate return (mdb_conf_platform()); 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, platform, 1137c478bd9Sstevel@tonic-gate sizeof (platform), "unix", "platform") != sizeof (platform)) { 1147c478bd9Sstevel@tonic-gate warn("'platform' symbol is missing from kernel\n"); 1157c478bd9Sstevel@tonic-gate return ("unknown"); 1167c478bd9Sstevel@tonic-gate } 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate return (platform); 1197c478bd9Sstevel@tonic-gate } 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate static int 1227c478bd9Sstevel@tonic-gate kmt_uname(mdb_tgt_t *t, struct utsname *utsp) 1237c478bd9Sstevel@tonic-gate { 1247c478bd9Sstevel@tonic-gate return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp, 1257c478bd9Sstevel@tonic-gate sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname")); 1267c478bd9Sstevel@tonic-gate } 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1297c478bd9Sstevel@tonic-gate static int 1307c478bd9Sstevel@tonic-gate kmt_dmodel(mdb_tgt_t *t) 1317c478bd9Sstevel@tonic-gate { 1327c478bd9Sstevel@tonic-gate return (MDB_TGT_MODEL_NATIVE); 1337c478bd9Sstevel@tonic-gate } 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1367c478bd9Sstevel@tonic-gate ssize_t 1377c478bd9Sstevel@tonic-gate kmt_rw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr, 1387c478bd9Sstevel@tonic-gate ssize_t (*rw)(void *, size_t, uint64_t)) 1397c478bd9Sstevel@tonic-gate { 1407c478bd9Sstevel@tonic-gate size_t n, ndone, chunksz; 1417c478bd9Sstevel@tonic-gate jmp_buf *oldpcb = NULL; 1427c478bd9Sstevel@tonic-gate jmp_buf pcb; 1437c478bd9Sstevel@tonic-gate ssize_t res; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate kmdb_prom_check_interrupt(); 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate if (nbytes == 0) 1487c478bd9Sstevel@tonic-gate return (0); 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate /* 1517c478bd9Sstevel@tonic-gate * Try to process the entire buffer, as requested. If we catch a fault, 1527c478bd9Sstevel@tonic-gate * try smaller chunks. This allows us to handle regions that cross 1537c478bd9Sstevel@tonic-gate * mapping boundaries. 1547c478bd9Sstevel@tonic-gate */ 1557c478bd9Sstevel@tonic-gate chunksz = nbytes; 1567c478bd9Sstevel@tonic-gate ndone = 0; 1577c478bd9Sstevel@tonic-gate if (setjmp(pcb) != 0) { 1587c478bd9Sstevel@tonic-gate if (chunksz == 1) { 1597c478bd9Sstevel@tonic-gate /* We failed with the smallest chunk - give up */ 1607c478bd9Sstevel@tonic-gate kmdb_dpi_restore_fault_hdlr(oldpcb); 1617c478bd9Sstevel@tonic-gate return (ndone > 0 ? ndone : -1); /* errno set for us */ 1627c478bd9Sstevel@tonic-gate } else if (chunksz > 4) 1637c478bd9Sstevel@tonic-gate chunksz = 4; 1647c478bd9Sstevel@tonic-gate else 1657c478bd9Sstevel@tonic-gate chunksz = 1; 1667c478bd9Sstevel@tonic-gate } 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate oldpcb = kmdb_dpi_set_fault_hdlr(&pcb); 1697c478bd9Sstevel@tonic-gate while (nbytes > 0) { 1707c478bd9Sstevel@tonic-gate n = MIN(chunksz, nbytes); 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate if ((res = rw(buf, n, addr)) != n) 1737c478bd9Sstevel@tonic-gate return (res < 0 ? res : ndone + res); 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate addr += n; 1767c478bd9Sstevel@tonic-gate nbytes -= n; 1777c478bd9Sstevel@tonic-gate ndone += n; 1787c478bd9Sstevel@tonic-gate buf = ((caddr_t)buf + n); 1797c478bd9Sstevel@tonic-gate } 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate kmdb_dpi_restore_fault_hdlr(oldpcb); 1827c478bd9Sstevel@tonic-gate 1837c478bd9Sstevel@tonic-gate return (ndone); 1847c478bd9Sstevel@tonic-gate } 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate static void 1877c478bd9Sstevel@tonic-gate kmt_bcopy(const void *s1, void *s2, size_t n) 1887c478bd9Sstevel@tonic-gate { 1897c478bd9Sstevel@tonic-gate /* 1907c478bd9Sstevel@tonic-gate * We need to guarantee atomic accesses for certain sizes. bcopy won't 1917c478bd9Sstevel@tonic-gate * make that guarantee, so we need to do it ourselves. 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate #ifdef _LP64 1947c478bd9Sstevel@tonic-gate if (n == 8 && ((uintptr_t)s1 & 7) == 0 && ((uintptr_t)s2 & 7) == 0) 1957c478bd9Sstevel@tonic-gate *(uint64_t *)s2 = *(uint64_t *)s1; 1967c478bd9Sstevel@tonic-gate else 1977c478bd9Sstevel@tonic-gate #endif 1987c478bd9Sstevel@tonic-gate if (n == 4 && ((uintptr_t)s1 & 3) == 0 && ((uintptr_t)s2 & 3) == 0) 1997c478bd9Sstevel@tonic-gate *(uint32_t *)s2 = *(uint32_t *)s1; 2007c478bd9Sstevel@tonic-gate else if (n == 2 && ((uintptr_t)s1 & 1) == 0 && ((uintptr_t)s2 & 1) == 0) 2017c478bd9Sstevel@tonic-gate *(uint16_t *)s2 = *(uint16_t *)s1; 2027c478bd9Sstevel@tonic-gate else if (n == 1) 2037c478bd9Sstevel@tonic-gate *(uint8_t *)s2 = *(uint8_t *)s1; 2047c478bd9Sstevel@tonic-gate else 2057c478bd9Sstevel@tonic-gate bcopy(s1, s2, n); 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate static ssize_t 2097c478bd9Sstevel@tonic-gate kmt_reader(void *buf, size_t nbytes, uint64_t addr) 2107c478bd9Sstevel@tonic-gate { 2117c478bd9Sstevel@tonic-gate kmt_bcopy((void *)(uintptr_t)addr, buf, nbytes); 2127c478bd9Sstevel@tonic-gate return (nbytes); 2137c478bd9Sstevel@tonic-gate } 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate ssize_t 2167c478bd9Sstevel@tonic-gate kmt_writer(void *buf, size_t nbytes, uint64_t addr) 2177c478bd9Sstevel@tonic-gate { 2187c478bd9Sstevel@tonic-gate kmt_bcopy(buf, (void *)(uintptr_t)addr, nbytes); 2197c478bd9Sstevel@tonic-gate return (nbytes); 2207c478bd9Sstevel@tonic-gate } 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2237c478bd9Sstevel@tonic-gate static ssize_t 2247c478bd9Sstevel@tonic-gate kmt_read(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 2257c478bd9Sstevel@tonic-gate { 2267c478bd9Sstevel@tonic-gate /* 2277c478bd9Sstevel@tonic-gate * We don't want to allow reads of I/O-mapped memory. Multi-page reads 2287c478bd9Sstevel@tonic-gate * that cross into I/O-mapped memory should be restricted to the initial 2297c478bd9Sstevel@tonic-gate * non-I/O region. Reads that begin in I/O-mapped memory are failed 2307c478bd9Sstevel@tonic-gate * outright. 2317c478bd9Sstevel@tonic-gate */ 2327c478bd9Sstevel@tonic-gate if (!(t->t_flags & MDB_TGT_F_ALLOWIO) && 2337c478bd9Sstevel@tonic-gate (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 0)) == 0) 2347c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOMAP)); 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate return (kmt_rw(t, buf, nbytes, addr, kmt_reader)); 2377c478bd9Sstevel@tonic-gate } 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2407c478bd9Sstevel@tonic-gate static ssize_t 2417c478bd9Sstevel@tonic-gate kmt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr) 2427c478bd9Sstevel@tonic-gate { 2437c478bd9Sstevel@tonic-gate return (kmt_rw(t, buf, nbytes, addr, kmdb_kdi_pread)); 2447c478bd9Sstevel@tonic-gate } 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2477c478bd9Sstevel@tonic-gate ssize_t 2487c478bd9Sstevel@tonic-gate kmt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr) 2497c478bd9Sstevel@tonic-gate { 2507c478bd9Sstevel@tonic-gate return (kmt_rw(t, (void *)buf, nbytes, addr, kmdb_kdi_pwrite)); 2517c478bd9Sstevel@tonic-gate } 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate static uintptr_t 2547c478bd9Sstevel@tonic-gate kmt_read_kas(mdb_tgt_t *t) 2557c478bd9Sstevel@tonic-gate { 2567c478bd9Sstevel@tonic-gate GElf_Sym sym; 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_name(t, "unix", "kas", &sym, NULL) < 0) { 2597c478bd9Sstevel@tonic-gate warn("'kas' symbol is missing from kernel\n"); 2607c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOSYM); 2617c478bd9Sstevel@tonic-gate return (0); 2627c478bd9Sstevel@tonic-gate } 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate return ((uintptr_t)sym.st_value); 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate static int 2687c478bd9Sstevel@tonic-gate kmt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap) 2697c478bd9Sstevel@tonic-gate { 2707c478bd9Sstevel@tonic-gate mdb_module_t *mod; 2717c478bd9Sstevel@tonic-gate struct as *asp; 2727c478bd9Sstevel@tonic-gate mdb_var_t *v; 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate switch ((uintptr_t)as) { 2757c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_AS_PHYS: 2767c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_AS_FILE: 2777c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_AS_IO: 2787c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 2797c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_AS_VIRT: 2807c478bd9Sstevel@tonic-gate if ((asp = (struct as *)kmt_read_kas(t)) == NULL) 2817c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 2827c478bd9Sstevel@tonic-gate break; 2837c478bd9Sstevel@tonic-gate default: 2847c478bd9Sstevel@tonic-gate asp = (struct as *)as; 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* We don't support non-kas vtop */ 2877c478bd9Sstevel@tonic-gate if (asp != (struct as *)kmt_read_kas(t)) 2887c478bd9Sstevel@tonic-gate return (set_errno(EMDB_TGTNOTSUP)); 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate if (kmdb_prom_vtop(va, pap) == 0) 2927c478bd9Sstevel@tonic-gate return (0); 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL && 2957c478bd9Sstevel@tonic-gate (mod = mdb_nv_get_cookie(v)) != NULL) { 2967c478bd9Sstevel@tonic-gate int (*fptr)(uintptr_t, struct as *, physaddr_t *); 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate fptr = (int (*)(uintptr_t, struct as *, physaddr_t *)) 2997c478bd9Sstevel@tonic-gate dlsym(mod->mod_hdl, "platform_vtop"); 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0)) 3027c478bd9Sstevel@tonic-gate return (0); 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOMAP)); 3067c478bd9Sstevel@tonic-gate } 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3097c478bd9Sstevel@tonic-gate static int 3107c478bd9Sstevel@tonic-gate kmt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3117c478bd9Sstevel@tonic-gate { 3127c478bd9Sstevel@tonic-gate const mdb_tgt_gregset_t *gregs; 313acbc304dSjohnlev intptr_t cpuid = DPI_MASTER_CPUID; 3147c478bd9Sstevel@tonic-gate int i; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) { 3177c478bd9Sstevel@tonic-gate if (argc != 0) 3187c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 319acbc304dSjohnlev if ((cpuid = mdb_cpu2cpuid(addr)) < 0) { 320acbc304dSjohnlev (void) set_errno(EMDB_NOMAP); 321acbc304dSjohnlev mdb_warn("failed to find cpuid for cpu at %p", addr); 322acbc304dSjohnlev return (DCMD_ERR); 323acbc304dSjohnlev } 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate i = mdb_getopts(argc, argv, 327acbc304dSjohnlev 'c', MDB_OPT_UINTPTR, &cpuid, 3287c478bd9Sstevel@tonic-gate NULL); 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate argc -= i; 3317c478bd9Sstevel@tonic-gate argv += i; 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate if (argc != 0) 3347c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 3357c478bd9Sstevel@tonic-gate 336acbc304dSjohnlev if ((gregs = kmdb_dpi_get_gregs(cpuid)) == NULL) { 337acbc304dSjohnlev warn("failed to retrieve registers for cpu %d", (int)cpuid); 3387c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate kmt_printregs(gregs); 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate return (DCMD_OK); 3447c478bd9Sstevel@tonic-gate } 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate static int 3477c478bd9Sstevel@tonic-gate kmt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3487c478bd9Sstevel@tonic-gate { 3497c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) 3507c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate return (kmt_cpuregs(addr, flags, argc, argv)); 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate 355acbc304dSjohnlev static int 356acbc304dSjohnlev kmt_cpustack_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 357acbc304dSjohnlev { 358acbc304dSjohnlev intptr_t cpuid = DPI_MASTER_CPUID; 359acbc304dSjohnlev uint_t verbose = 0; 360acbc304dSjohnlev int i; 361acbc304dSjohnlev 362acbc304dSjohnlev if (flags & DCMD_ADDRSPEC) { 363acbc304dSjohnlev if ((cpuid = mdb_cpu2cpuid(addr)) < 0) { 364acbc304dSjohnlev (void) set_errno(EMDB_NOMAP); 365acbc304dSjohnlev mdb_warn("failed to find cpuid for cpu at %p", addr); 366acbc304dSjohnlev return (DCMD_ERR); 367acbc304dSjohnlev } 368acbc304dSjohnlev flags &= ~DCMD_ADDRSPEC; 369acbc304dSjohnlev } 370acbc304dSjohnlev 371acbc304dSjohnlev i = mdb_getopts(argc, argv, 372acbc304dSjohnlev 'c', MDB_OPT_UINTPTR, &cpuid, 373acbc304dSjohnlev 'v', MDB_OPT_SETBITS, 1, &verbose, 374acbc304dSjohnlev NULL); 375acbc304dSjohnlev 376acbc304dSjohnlev argc -= i; 377acbc304dSjohnlev argv += i; 378acbc304dSjohnlev 379acbc304dSjohnlev return (kmt_cpustack(addr, flags, argc, argv, cpuid, verbose)); 380acbc304dSjohnlev } 381acbc304dSjohnlev 3827c478bd9Sstevel@tonic-gate /* 3837c478bd9Sstevel@tonic-gate * Lasciate ogne speranza, voi ch'intrate. 3847c478bd9Sstevel@tonic-gate */ 3857c478bd9Sstevel@tonic-gate static int 3867c478bd9Sstevel@tonic-gate kmt_call(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3877c478bd9Sstevel@tonic-gate { 3887c478bd9Sstevel@tonic-gate uintptr_t *call_argv, rval; 3897c478bd9Sstevel@tonic-gate int parse_strings = 1; 3907c478bd9Sstevel@tonic-gate GElf_Sym sym; 3917c478bd9Sstevel@tonic-gate jmp_buf *oldpcb = NULL; 3927c478bd9Sstevel@tonic-gate jmp_buf pcb; 3937c478bd9Sstevel@tonic-gate int i; 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 3967c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, MDB_TGT_SYM_EXACT, 3997c478bd9Sstevel@tonic-gate NULL, 0, &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) != 4007c478bd9Sstevel@tonic-gate STT_FUNC) { 4017c478bd9Sstevel@tonic-gate warn("%a is not a function\n", addr); 4027c478bd9Sstevel@tonic-gate return (DCMD_ERR); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate if (argc > 1 && argv[0].a_type == MDB_TYPE_STRING && 4067c478bd9Sstevel@tonic-gate strcmp(argv[0].a_un.a_str, "-s") == 0) { 4077c478bd9Sstevel@tonic-gate parse_strings = 0; 4087c478bd9Sstevel@tonic-gate argc--; 4097c478bd9Sstevel@tonic-gate argv++; 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate call_argv = mdb_alloc(sizeof (uintptr_t) * argc, UM_SLEEP); 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 4157c478bd9Sstevel@tonic-gate switch (argv[i].a_type) { 4167c478bd9Sstevel@tonic-gate case MDB_TYPE_STRING: 4177c478bd9Sstevel@tonic-gate /* 4187c478bd9Sstevel@tonic-gate * mdb_strtoull doesn't return on error, so we have to 4197c478bd9Sstevel@tonic-gate * pre-check strings suspected to contain numbers. 4207c478bd9Sstevel@tonic-gate */ 4217c478bd9Sstevel@tonic-gate if (parse_strings && strisbasenum(argv[i].a_un.a_str)) { 4227c478bd9Sstevel@tonic-gate call_argv[i] = (uintptr_t)mdb_strtoull( 4237c478bd9Sstevel@tonic-gate argv[i].a_un.a_str); 4247c478bd9Sstevel@tonic-gate } else 4257c478bd9Sstevel@tonic-gate call_argv[i] = (uintptr_t)argv[i].a_un.a_str; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate break; 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate case MDB_TYPE_IMMEDIATE: 4307c478bd9Sstevel@tonic-gate call_argv[i] = argv[i].a_un.a_val; 4317c478bd9Sstevel@tonic-gate break; 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate default: 4347c478bd9Sstevel@tonic-gate mdb_free(call_argv, 4357c478bd9Sstevel@tonic-gate sizeof (uintptr_t) * argc); 4367c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate } 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate if (setjmp(pcb) != 0) { 4417c478bd9Sstevel@tonic-gate warn("call failed: caught a trap\n"); 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate kmdb_dpi_restore_fault_hdlr(oldpcb); 4447c478bd9Sstevel@tonic-gate mdb_free(call_argv, sizeof (uintptr_t) * argc); 4457c478bd9Sstevel@tonic-gate return (DCMD_ERR); 4467c478bd9Sstevel@tonic-gate } 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate oldpcb = kmdb_dpi_set_fault_hdlr(&pcb); 4497c478bd9Sstevel@tonic-gate rval = kmdb_dpi_call(addr, argc, call_argv); 4507c478bd9Sstevel@tonic-gate kmdb_dpi_restore_fault_hdlr(oldpcb); 4517c478bd9Sstevel@tonic-gate 4527c478bd9Sstevel@tonic-gate if (flags & DCMD_PIPE_OUT) { 4537c478bd9Sstevel@tonic-gate mdb_printf("%p\n", rval); 4547c478bd9Sstevel@tonic-gate } else { 4557c478bd9Sstevel@tonic-gate /* pretty-print the results */ 4567c478bd9Sstevel@tonic-gate mdb_printf("%p = %a(", rval, addr); 4577c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 4587c478bd9Sstevel@tonic-gate if (i > 0) 4597c478bd9Sstevel@tonic-gate mdb_printf(", "); 4607c478bd9Sstevel@tonic-gate if (argv[i].a_type == MDB_TYPE_STRING) { 4617c478bd9Sstevel@tonic-gate /* I'm ashamed but amused */ 4627c478bd9Sstevel@tonic-gate char *quote = &("\""[parse_strings && 4637c478bd9Sstevel@tonic-gate strisbasenum(argv[i].a_un.a_str)]); 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate mdb_printf("%s%s%s", quote, argv[i].a_un.a_str, 4667c478bd9Sstevel@tonic-gate quote); 4677c478bd9Sstevel@tonic-gate } else 4687c478bd9Sstevel@tonic-gate mdb_printf("%p", argv[i].a_un.a_val); 4697c478bd9Sstevel@tonic-gate } 4707c478bd9Sstevel@tonic-gate mdb_printf(");\n"); 4717c478bd9Sstevel@tonic-gate } 4727c478bd9Sstevel@tonic-gate 4737c478bd9Sstevel@tonic-gate mdb_free(call_argv, sizeof (uintptr_t) * argc); 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate return (DCMD_OK); 4767c478bd9Sstevel@tonic-gate } 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4797c478bd9Sstevel@tonic-gate int 4807c478bd9Sstevel@tonic-gate kmt_dump_crumbs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 4817c478bd9Sstevel@tonic-gate { 4827c478bd9Sstevel@tonic-gate intptr_t cpu = -1; 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) { 4857c478bd9Sstevel@tonic-gate if (argc != 0) 4867c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 4877c478bd9Sstevel@tonic-gate } else { 4887c478bd9Sstevel@tonic-gate addr = 0; 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 4917c478bd9Sstevel@tonic-gate 'c', MDB_OPT_UINTPTR, &cpu, 4927c478bd9Sstevel@tonic-gate NULL) != argc) 4937c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 4947c478bd9Sstevel@tonic-gate } 4957c478bd9Sstevel@tonic-gate 4967c478bd9Sstevel@tonic-gate kmdb_dpi_dump_crumbs(addr, cpu); 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate return (DCMD_OK); 4997c478bd9Sstevel@tonic-gate } 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5027c478bd9Sstevel@tonic-gate static int 5037c478bd9Sstevel@tonic-gate kmt_noducttape(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 5047c478bd9Sstevel@tonic-gate { 5057c478bd9Sstevel@tonic-gate int a = 0; 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate return (a/a); 5087c478bd9Sstevel@tonic-gate } 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate static int 5117c478bd9Sstevel@tonic-gate kmt_dmod_status(char *msg, int state) 5127c478bd9Sstevel@tonic-gate { 5137c478bd9Sstevel@tonic-gate kmdb_modctl_t *kmc; 5147c478bd9Sstevel@tonic-gate mdb_var_t *v; 5157c478bd9Sstevel@tonic-gate int first = 1, n = 0; 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate mdb_nv_rewind(&mdb.m_dmodctl); 5187c478bd9Sstevel@tonic-gate while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) { 5197c478bd9Sstevel@tonic-gate kmc = MDB_NV_COOKIE(v); 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate if (kmc->kmc_state != state) 5227c478bd9Sstevel@tonic-gate continue; 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate n++; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate if (msg != NULL) { 5277c478bd9Sstevel@tonic-gate if (first) { 5287c478bd9Sstevel@tonic-gate mdb_printf(msg, NULL); 5297c478bd9Sstevel@tonic-gate first = 0; 5307c478bd9Sstevel@tonic-gate } 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate mdb_printf(" %s", kmc->kmc_modname); 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate } 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate if (!first && msg != NULL) 5377c478bd9Sstevel@tonic-gate mdb_printf("\n"); 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate return (n); 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5437c478bd9Sstevel@tonic-gate static int 5447c478bd9Sstevel@tonic-gate kmt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 5457c478bd9Sstevel@tonic-gate { 5467c478bd9Sstevel@tonic-gate kmt_data_t *kmt = mdb.m_target->t_data; 5477c478bd9Sstevel@tonic-gate struct utsname uts; 548*f6e214c7SGavin Maltby char uuid[37]; 5497c478bd9Sstevel@tonic-gate kreg_t tt; 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, &uts, sizeof (uts), 5527c478bd9Sstevel@tonic-gate "unix", "utsname") != sizeof (uts)) { 5537c478bd9Sstevel@tonic-gate warn("failed to read 'utsname' struct from kernel\n"); 5547c478bd9Sstevel@tonic-gate bzero(&uts, sizeof (uts)); 5557c478bd9Sstevel@tonic-gate (void) strcpy(uts.nodename, "unknown machine"); 5567c478bd9Sstevel@tonic-gate } 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate mdb_printf("debugging live kernel (%d-bit) on %s\n", 5597c478bd9Sstevel@tonic-gate (int)(sizeof (void *) * NBBY), 5607c478bd9Sstevel@tonic-gate (*uts.nodename == '\0' ? "(not set)" : uts.nodename)); 5617c478bd9Sstevel@tonic-gate mdb_printf("operating system: %s %s (%s)\n", 5627c478bd9Sstevel@tonic-gate uts.release, uts.version, uts.machine); 5637c478bd9Sstevel@tonic-gate 564*f6e214c7SGavin Maltby if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, uuid, sizeof (uuid), 565*f6e214c7SGavin Maltby "genunix", "dump_osimage_uuid") != sizeof (uuid)) { 566*f6e214c7SGavin Maltby warn("failed to read 'dump_osimage_uuid' string from kernel\n"); 567*f6e214c7SGavin Maltby (void) strcpy(uuid, "(error)"); 568*f6e214c7SGavin Maltby } else if (*uuid == '\0') { 569*f6e214c7SGavin Maltby (void) strcpy(uuid, "(not set)"); 570*f6e214c7SGavin Maltby } else if (uuid[36] != '\0') { 571*f6e214c7SGavin Maltby (void) strcpy(uuid, "(invalid)"); 572*f6e214c7SGavin Maltby } 573*f6e214c7SGavin Maltby mdb_printf("image uuid: %s\n", uuid); 574*f6e214c7SGavin Maltby 5757c478bd9Sstevel@tonic-gate if (kmt->kmt_cpu != NULL) { 5767c478bd9Sstevel@tonic-gate mdb_printf("CPU-specific support: %s\n", 5777c478bd9Sstevel@tonic-gate kmt_cpu_name(kmt->kmt_cpu)); 5787c478bd9Sstevel@tonic-gate } 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate mdb_printf("DTrace state: %s\n", (kmdb_kdi_dtrace_get_state() == 5817c478bd9Sstevel@tonic-gate KDI_DTSTATE_DTRACE_ACTIVE ? "active (debugger breakpoints cannot " 5827c478bd9Sstevel@tonic-gate "be armed)" : "inactive")); 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("tt", &tt); 5857c478bd9Sstevel@tonic-gate mdb_printf("stopped on: %s\n", kmt_trapname(tt)); 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate (void) kmt_dmod_status("pending dmod loads:", KMDB_MC_STATE_LOADING); 5887c478bd9Sstevel@tonic-gate (void) kmt_dmod_status("pending dmod unloads:", 5897c478bd9Sstevel@tonic-gate KMDB_MC_STATE_UNLOADING); 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate return (DCMD_OK); 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5957c478bd9Sstevel@tonic-gate static int 5967c478bd9Sstevel@tonic-gate kmt_switch(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 5977c478bd9Sstevel@tonic-gate { 5987c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC) || argc != 0) 5997c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate if (kmdb_dpi_switch_master((int)addr) < 0) { 6027c478bd9Sstevel@tonic-gate warn("failed to switch to CPU %d", (int)addr); 6037c478bd9Sstevel@tonic-gate return (DCMD_ERR); 6047c478bd9Sstevel@tonic-gate } 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate return (DCMD_OK); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate static const mdb_dcmd_t kmt_dcmds[] = { 6107c478bd9Sstevel@tonic-gate { "$c", "?[cnt]", "print stack backtrace", kmt_stack }, 6117c478bd9Sstevel@tonic-gate { "$C", "?[cnt]", "print stack backtrace", kmt_stackv }, 6127c478bd9Sstevel@tonic-gate { "$r", NULL, "print general-purpose registers", kmt_regs }, 6137c478bd9Sstevel@tonic-gate { "$?", NULL, "print status and registers", kmt_regs }, 6147c478bd9Sstevel@tonic-gate { ":x", ":", "change the active CPU", kmt_switch }, 6157c478bd9Sstevel@tonic-gate { "call", ":[arg ...]", "call a kernel function", kmt_call }, 6167c478bd9Sstevel@tonic-gate { "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a " 6177c478bd9Sstevel@tonic-gate "specific CPU", kmt_cpustack_dcmd }, 6187c478bd9Sstevel@tonic-gate { "cpuregs", "?[-c cpuid]", "print general-purpose registers for a " 6197c478bd9Sstevel@tonic-gate "specific CPU", kmt_cpuregs }, 6207c478bd9Sstevel@tonic-gate { "crumbs", NULL, NULL, kmt_dump_crumbs }, 6217c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64) 6227c478bd9Sstevel@tonic-gate { "in", ":[-L len]", "read from I/O port", kmt_in_dcmd }, 6237c478bd9Sstevel@tonic-gate { "out", ":[-L len] val", "write to I/O port", kmt_out_dcmd }, 6247c478bd9Sstevel@tonic-gate { "rdmsr", ":", "read an MSR", kmt_rdmsr }, 6257c478bd9Sstevel@tonic-gate { "wrmsr", ": val", "write an MSR", kmt_wrmsr }, 6267aec1d6eScindi { "rdpcicfg", ": bus dev func", "read a register in PCI config space", 6277aec1d6eScindi kmt_rdpcicfg }, 6287aec1d6eScindi { "wrpcicfg", ": bus dev func val", "write a register in PCI config " 6297aec1d6eScindi "space", kmt_wrpcicfg }, 6307c478bd9Sstevel@tonic-gate #endif 6317c478bd9Sstevel@tonic-gate { "noducttape", NULL, NULL, kmt_noducttape }, 6327c478bd9Sstevel@tonic-gate { "regs", NULL, "print general-purpose registers", kmt_regs }, 6337c478bd9Sstevel@tonic-gate { "stack", "?[cnt]", "print stack backtrace", kmt_stack }, 6347c478bd9Sstevel@tonic-gate { "stackregs", "?", "print stack backtrace and registers", kmt_stackr }, 6357c478bd9Sstevel@tonic-gate { "status", NULL, "print summary of current target", kmt_status_dcmd }, 6367c478bd9Sstevel@tonic-gate { "switch", ":", "change the active CPU", kmt_switch }, 6377c478bd9Sstevel@tonic-gate { NULL } 6387c478bd9Sstevel@tonic-gate }; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate static uintmax_t 6417c478bd9Sstevel@tonic-gate kmt_reg_disc_get(const mdb_var_t *v) 6427c478bd9Sstevel@tonic-gate { 6437c478bd9Sstevel@tonic-gate mdb_tgt_reg_t r = 0; 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate (void) mdb_tgt_getareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), &r); 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate return (r); 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate static void 6517c478bd9Sstevel@tonic-gate kmt_reg_disc_set(mdb_var_t *v, uintmax_t r) 6527c478bd9Sstevel@tonic-gate { 6537c478bd9Sstevel@tonic-gate if (mdb_tgt_putareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), r) == -1) 6547c478bd9Sstevel@tonic-gate warn("failed to modify %%%s register", mdb_nv_get_name(v)); 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate static const mdb_nv_disc_t kmt_reg_disc = { 6587c478bd9Sstevel@tonic-gate kmt_reg_disc_set, 6597c478bd9Sstevel@tonic-gate kmt_reg_disc_get 6607c478bd9Sstevel@tonic-gate }; 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6637c478bd9Sstevel@tonic-gate static int 6647c478bd9Sstevel@tonic-gate kmt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, 6657c478bd9Sstevel@tonic-gate mdb_tgt_reg_t *rp) 6667c478bd9Sstevel@tonic-gate { 6677c478bd9Sstevel@tonic-gate kreg_t val; 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate if (kmdb_dpi_get_register(rname, &val) < 0) 6707c478bd9Sstevel@tonic-gate return (set_errno(EMDB_BADREG)); 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate *rp = val; 6737c478bd9Sstevel@tonic-gate return (0); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6777c478bd9Sstevel@tonic-gate static int 6787c478bd9Sstevel@tonic-gate kmt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r) 6797c478bd9Sstevel@tonic-gate { 6807c478bd9Sstevel@tonic-gate if (kmdb_dpi_set_register(rname, r) < 0) 6817c478bd9Sstevel@tonic-gate return (set_errno(EMDB_BADREG)); 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate return (0); 6847c478bd9Sstevel@tonic-gate } 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate static void 6877c478bd9Sstevel@tonic-gate kmt_mod_destroy(kmt_module_t *km) 6887c478bd9Sstevel@tonic-gate { 6897c478bd9Sstevel@tonic-gate if (km->km_name != NULL) 6907c478bd9Sstevel@tonic-gate strfree(km->km_name); 6917c478bd9Sstevel@tonic-gate if (km->km_symtab != NULL) 6927c478bd9Sstevel@tonic-gate mdb_gelf_symtab_destroy(km->km_symtab); 6937c478bd9Sstevel@tonic-gate if (km->km_ctfp != NULL) 6947c478bd9Sstevel@tonic-gate mdb_ctf_close(km->km_ctfp); 6957c478bd9Sstevel@tonic-gate } 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate static kmt_module_t * 6987c478bd9Sstevel@tonic-gate kmt_mod_create(mdb_tgt_t *t, struct modctl *ctlp, char *name) 6997c478bd9Sstevel@tonic-gate { 7007c478bd9Sstevel@tonic-gate kmt_module_t *km = mdb_zalloc(sizeof (kmt_module_t), UM_SLEEP); 7017c478bd9Sstevel@tonic-gate struct module *mod; 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate km->km_name = mdb_alloc(strlen(name) + 1, UM_SLEEP); 70480148899SSurya Prakki (void) strcpy(km->km_name, name); 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate bcopy(ctlp, &km->km_modctl, sizeof (struct modctl)); 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate if (mdb_tgt_vread(t, &km->km_module, sizeof (struct module), 7097c478bd9Sstevel@tonic-gate (uintptr_t)km->km_modctl.mod_mp) != sizeof (struct module)) 7107c478bd9Sstevel@tonic-gate goto create_module_cleanup; 7117c478bd9Sstevel@tonic-gate mod = &km->km_module; 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate if (mod->symhdr != NULL && mod->strhdr != NULL && mod->symtbl != NULL && 7147c478bd9Sstevel@tonic-gate mod->strings != NULL) { 7157c478bd9Sstevel@tonic-gate mdb_gelf_ehdr_to_gehdr(&mod->hdr, &km->km_ehdr); 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate km->km_symtab = mdb_gelf_symtab_create_raw(&km->km_ehdr, 7187c478bd9Sstevel@tonic-gate mod->symhdr, mod->symtbl, mod->strhdr, mod->strings, 7197c478bd9Sstevel@tonic-gate MDB_TGT_SYMTAB); 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate km->km_symtab_va = mod->symtbl; 7227c478bd9Sstevel@tonic-gate km->km_strtab_va = mod->strings; 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate if (mdb_tgt_vread(t, &km->km_symtab_hdr, sizeof (Shdr), 7257c478bd9Sstevel@tonic-gate (uintptr_t)mod->symhdr) != sizeof (Shdr) || 7267c478bd9Sstevel@tonic-gate mdb_tgt_vread(t, &km->km_strtab_hdr, sizeof (Shdr), 7277c478bd9Sstevel@tonic-gate (uintptr_t)mod->strhdr) != sizeof (Shdr)) 7287c478bd9Sstevel@tonic-gate goto create_module_cleanup; 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate /* 7327c478bd9Sstevel@tonic-gate * We don't want everyone rooting around in the module structure, so we 7337c478bd9Sstevel@tonic-gate * make copies of the interesting members. 7347c478bd9Sstevel@tonic-gate */ 7357c478bd9Sstevel@tonic-gate km->km_text_va = (uintptr_t)mod->text; 7367c478bd9Sstevel@tonic-gate km->km_text_size = mod->text_size; 7377c478bd9Sstevel@tonic-gate km->km_data_va = (uintptr_t)mod->data; 7387c478bd9Sstevel@tonic-gate km->km_data_size = mod->data_size; 7397c478bd9Sstevel@tonic-gate km->km_bss_va = (uintptr_t)mod->bss; 7407c478bd9Sstevel@tonic-gate km->km_bss_size = mod->bss_size; 7417c478bd9Sstevel@tonic-gate km->km_ctf_va = mod->ctfdata; 7427c478bd9Sstevel@tonic-gate km->km_ctf_size = mod->ctfsize; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate if (mod->flags & KOBJ_PRIM) 7457c478bd9Sstevel@tonic-gate km->km_flags |= KM_F_PRIMARY; 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate return (km); 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate create_module_cleanup: 7507c478bd9Sstevel@tonic-gate warn("failed to read module %s\n", name); 7517c478bd9Sstevel@tonic-gate kmt_mod_destroy(km); 7527c478bd9Sstevel@tonic-gate return (NULL); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate static void 7567c478bd9Sstevel@tonic-gate kmt_mod_remove(kmt_data_t *kmt, kmt_module_t *km) 7577c478bd9Sstevel@tonic-gate { 7587c478bd9Sstevel@tonic-gate mdb_var_t *v = mdb_nv_lookup(&kmt->kmt_modules, km->km_name); 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate ASSERT(v != NULL); 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "removing module %s\n", km->km_name); 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate mdb_list_delete(&kmt->kmt_modlist, km); 7657c478bd9Sstevel@tonic-gate mdb_nv_remove(&kmt->kmt_modules, v); 7667c478bd9Sstevel@tonic-gate kmt_mod_destroy(km); 7677c478bd9Sstevel@tonic-gate } 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate static int 7707c478bd9Sstevel@tonic-gate kmt_modlist_update_cb(struct modctl *modp, void *arg) 7717c478bd9Sstevel@tonic-gate { 7727c478bd9Sstevel@tonic-gate mdb_tgt_t *t = arg; 7737c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 7747c478bd9Sstevel@tonic-gate kmt_module_t *km; 7757c478bd9Sstevel@tonic-gate mdb_var_t *v; 7767c478bd9Sstevel@tonic-gate char name[MAXNAMELEN]; 7777c478bd9Sstevel@tonic-gate 7787c478bd9Sstevel@tonic-gate if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN, 7797c478bd9Sstevel@tonic-gate (uintptr_t)modp->mod_modname) <= 0) { 7807c478bd9Sstevel@tonic-gate warn("failed to read module name at %p", 7817c478bd9Sstevel@tonic-gate (void *)modp->mod_modname); 7827c478bd9Sstevel@tonic-gate } 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate /* We only care about modules that are actually loaded */ 7857c478bd9Sstevel@tonic-gate if (!kmdb_kdi_mod_isloaded(modp)) 7867c478bd9Sstevel@tonic-gate return (0); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /* 7897c478bd9Sstevel@tonic-gate * Skip the modules we already know about and that haven't 7907c478bd9Sstevel@tonic-gate * changed since last time we were here. 7917c478bd9Sstevel@tonic-gate */ 7927c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&kmt->kmt_modules, name)) != NULL) { 7937c478bd9Sstevel@tonic-gate km = MDB_NV_COOKIE(v); 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate if (kmdb_kdi_mod_haschanged(&km->km_modctl, &km->km_module, 7967c478bd9Sstevel@tonic-gate modp, modp->mod_mp)) { 7977c478bd9Sstevel@tonic-gate /* 7987c478bd9Sstevel@tonic-gate * The module has changed since last we saw it. For 7997c478bd9Sstevel@tonic-gate * safety, remove our old version, and treat it as a 8007c478bd9Sstevel@tonic-gate * new module. 8017c478bd9Sstevel@tonic-gate */ 8027c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "stutter module %s\n", name); 8037c478bd9Sstevel@tonic-gate kmt_mod_remove(kmt, km); 8047c478bd9Sstevel@tonic-gate } else { 8057c478bd9Sstevel@tonic-gate km->km_seen = 1; 8067c478bd9Sstevel@tonic-gate return (0); 8077c478bd9Sstevel@tonic-gate } 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "found new module %s\n", name); 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate if ((km = kmt_mod_create(t, modp, name)) != NULL) { 8137c478bd9Sstevel@tonic-gate mdb_list_append(&kmt->kmt_modlist, km); 8147c478bd9Sstevel@tonic-gate (void) mdb_nv_insert(&kmt->kmt_modules, name, NULL, 8157c478bd9Sstevel@tonic-gate (uintptr_t)km, 0); 8167c478bd9Sstevel@tonic-gate km->km_seen = 1; 8177c478bd9Sstevel@tonic-gate } 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate return (0); 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate static void 8237c478bd9Sstevel@tonic-gate kmt_modlist_update(mdb_tgt_t *t) 8247c478bd9Sstevel@tonic-gate { 8257c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 8267c478bd9Sstevel@tonic-gate kmt_module_t *km, *kmn; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate if (kmdb_kdi_mod_iter(kmt_modlist_update_cb, t) < 0) { 8297c478bd9Sstevel@tonic-gate warn("failed to complete update of kernel module list\n"); 8307c478bd9Sstevel@tonic-gate return; 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate km = mdb_list_next(&kmt->kmt_modlist); 8347c478bd9Sstevel@tonic-gate while (km != NULL) { 8357c478bd9Sstevel@tonic-gate kmn = mdb_list_next(km); 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate if (km->km_seen == 1) { 8387c478bd9Sstevel@tonic-gate /* Reset the mark for next time */ 8397c478bd9Sstevel@tonic-gate km->km_seen = 0; 8407c478bd9Sstevel@tonic-gate } else { 8417c478bd9Sstevel@tonic-gate /* 8427c478bd9Sstevel@tonic-gate * We didn't see it on the kernel's module list, so 8437c478bd9Sstevel@tonic-gate * remove it from our view of the world. 8447c478bd9Sstevel@tonic-gate */ 8457c478bd9Sstevel@tonic-gate kmt_mod_remove(kmt, km); 8467c478bd9Sstevel@tonic-gate } 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate km = kmn; 8497c478bd9Sstevel@tonic-gate } 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate static void 8537c478bd9Sstevel@tonic-gate kmt_periodic(mdb_tgt_t *t) 8547c478bd9Sstevel@tonic-gate { 8557c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &t->t_status); 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate int 8597c478bd9Sstevel@tonic-gate kmt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags, 8607c478bd9Sstevel@tonic-gate char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip) 8617c478bd9Sstevel@tonic-gate { 8627c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 8637c478bd9Sstevel@tonic-gate kmt_module_t *km = mdb_list_next(&kmt->kmt_modlist); 8647c478bd9Sstevel@tonic-gate kmt_module_t *sym_km = NULL; 8657c478bd9Sstevel@tonic-gate kmt_module_t prmod; 8667c478bd9Sstevel@tonic-gate GElf_Sym sym; 8677c478bd9Sstevel@tonic-gate uint_t symid; 8687c478bd9Sstevel@tonic-gate const char *name; 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate /* 8717c478bd9Sstevel@tonic-gate * We look through the private symbols (if any), then through the module 8727c478bd9Sstevel@tonic-gate * symbols. We can simplify the loop if we pretend the private symbols 8737c478bd9Sstevel@tonic-gate * come from a module. 8747c478bd9Sstevel@tonic-gate */ 8757c478bd9Sstevel@tonic-gate if (mdb.m_prsym != NULL) { 8767c478bd9Sstevel@tonic-gate bzero(&prmod, sizeof (kmt_module_t)); 8777c478bd9Sstevel@tonic-gate prmod.km_name = "<<<prmod>>>"; 8787c478bd9Sstevel@tonic-gate prmod.km_symtab = mdb.m_prsym; 8797c478bd9Sstevel@tonic-gate prmod.km_list.ml_next = (mdb_list_t *)km; 8807c478bd9Sstevel@tonic-gate km = &prmod; 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate 8837c478bd9Sstevel@tonic-gate /* Symbol resolution isn't available during initialization */ 8847c478bd9Sstevel@tonic-gate if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT) 8857c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYM)); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate for (; km != NULL; km = mdb_list_next(km)) { 8887c478bd9Sstevel@tonic-gate if (km != &prmod && !kmt->kmt_symavail) 8897c478bd9Sstevel@tonic-gate continue; 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate if (km->km_symtab == NULL) 8927c478bd9Sstevel@tonic-gate continue; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, flags, 8957c478bd9Sstevel@tonic-gate buf, nbytes, symp, &sip->sym_id) != 0 || 8967c478bd9Sstevel@tonic-gate symp->st_value == 0) 8977c478bd9Sstevel@tonic-gate continue; 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate if (flags & MDB_TGT_SYM_EXACT) { 9007c478bd9Sstevel@tonic-gate sym_km = km; 9017c478bd9Sstevel@tonic-gate goto found; 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate /* 9057c478bd9Sstevel@tonic-gate * If this is the first match we've found, or if this symbol is 9067c478bd9Sstevel@tonic-gate * closer to the specified address than the last one we found, 9077c478bd9Sstevel@tonic-gate * use it. 9087c478bd9Sstevel@tonic-gate */ 9097c478bd9Sstevel@tonic-gate if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) { 9107c478bd9Sstevel@tonic-gate sym_km = km; 9117c478bd9Sstevel@tonic-gate sym = *symp; 9127c478bd9Sstevel@tonic-gate symid = sip->sym_id; 9137c478bd9Sstevel@tonic-gate } 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* 9177c478bd9Sstevel@tonic-gate * kmdb dmods are normal kernel modules, loaded by krtld as such. To 9187c478bd9Sstevel@tonic-gate * avoid polluting modinfo, and to keep from confusing the module 9197c478bd9Sstevel@tonic-gate * subsystem (many dmods have the same names as real kernel modules), 9207c478bd9Sstevel@tonic-gate * kmdb keeps their modctls separate, and doesn't allow their loading 9217c478bd9Sstevel@tonic-gate * to be broadcast via the krtld module load/unload mechanism. As a 9227c478bd9Sstevel@tonic-gate * result, kmdb_kvm doesn't find out about them, and can't turn their 9237c478bd9Sstevel@tonic-gate * addresses into symbols. This can be most inconvenient during 9247c478bd9Sstevel@tonic-gate * debugger faults, as the dmod frames will show up without names. 925acbc304dSjohnlev * We weren't able to turn the requested address into a symbol, so we'll 9267c478bd9Sstevel@tonic-gate * take a spin through the dmods, trying to match our address against 9277c478bd9Sstevel@tonic-gate * their symbols. 9287c478bd9Sstevel@tonic-gate */ 9297c478bd9Sstevel@tonic-gate if (sym_km == NULL) { 9307c478bd9Sstevel@tonic-gate return (kmdb_module_lookup_by_addr(addr, flags, buf, nbytes, 9317c478bd9Sstevel@tonic-gate symp, sip)); 9327c478bd9Sstevel@tonic-gate } 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate *symp = sym; 9357c478bd9Sstevel@tonic-gate sip->sym_id = symid; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate found: 9387c478bd9Sstevel@tonic-gate /* 9397c478bd9Sstevel@tonic-gate * Once we've found something, copy the final name into the caller's 9407c478bd9Sstevel@tonic-gate * buffer and prefix it with the load object name if appropriate. 9417c478bd9Sstevel@tonic-gate */ 9427c478bd9Sstevel@tonic-gate name = mdb_gelf_sym_name(sym_km->km_symtab, symp); 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate if (sym_km == &prmod) { 9457c478bd9Sstevel@tonic-gate if (buf != NULL) { 9467c478bd9Sstevel@tonic-gate (void) strncpy(buf, name, nbytes); 9477c478bd9Sstevel@tonic-gate buf[nbytes - 1] = '\0'; 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_PRVSYM; 9507c478bd9Sstevel@tonic-gate } else { 9517c478bd9Sstevel@tonic-gate if (buf != NULL) { 9527c478bd9Sstevel@tonic-gate if (sym_km->km_flags & KM_F_PRIMARY) { 9537c478bd9Sstevel@tonic-gate (void) strncpy(buf, name, nbytes); 9547c478bd9Sstevel@tonic-gate buf[nbytes - 1] = '\0'; 9557c478bd9Sstevel@tonic-gate } else { 9567c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, nbytes, "%s`%s", 9577c478bd9Sstevel@tonic-gate sym_km->km_name, name); 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_SYMTAB; 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate return (0); 9647c478bd9Sstevel@tonic-gate } 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate static int 9677c478bd9Sstevel@tonic-gate kmt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name, 9687c478bd9Sstevel@tonic-gate GElf_Sym *symp, mdb_syminfo_t *sip) 9697c478bd9Sstevel@tonic-gate { 9707c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 9717c478bd9Sstevel@tonic-gate kmt_module_t *km; 9727c478bd9Sstevel@tonic-gate mdb_var_t *v; 9737c478bd9Sstevel@tonic-gate GElf_Sym sym; 9747c478bd9Sstevel@tonic-gate uint_t symid; 9757c478bd9Sstevel@tonic-gate int n; 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate if (!kmt->kmt_symavail) 9787c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYM)); 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate switch ((uintptr_t)obj) { 9817c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EXEC: 9827c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EVERY: 9837c478bd9Sstevel@tonic-gate km = mdb_list_next(&kmt->kmt_modlist); 9847c478bd9Sstevel@tonic-gate n = mdb_nv_size(&kmt->kmt_modules); 9857c478bd9Sstevel@tonic-gate break; 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_RTLD: 988ae115bc7Smrj obj = kmt->kmt_rtld_name; 9897c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate default: 9927c478bd9Sstevel@tonic-gate /* 9937c478bd9Sstevel@tonic-gate * If this is a request for a dmod symbol, let kmdb_module 9947c478bd9Sstevel@tonic-gate * handle it. 9957c478bd9Sstevel@tonic-gate */ 9967c478bd9Sstevel@tonic-gate if (obj != NULL && strncmp(obj, "DMOD`", 5) == 0) { 9977c478bd9Sstevel@tonic-gate return (kmdb_module_lookup_by_name(obj + 5, name, 9987c478bd9Sstevel@tonic-gate symp, sip)); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL) 10027c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOOBJ)); 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate km = mdb_nv_get_cookie(v); 10057c478bd9Sstevel@tonic-gate n = 1; 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate /* 10097c478bd9Sstevel@tonic-gate * kmdb's kvm target is at a bit of a disadvantage compared to mdb's 10107c478bd9Sstevel@tonic-gate * kvm target when it comes to global symbol lookups. mdb has ksyms, 10117c478bd9Sstevel@tonic-gate * which hides pesky things like symbols that are undefined in unix, 10127c478bd9Sstevel@tonic-gate * but which are defined in genunix. We don't have such a facility - 10137c478bd9Sstevel@tonic-gate * we simply iterate through the modules, looking for a given symbol 10147c478bd9Sstevel@tonic-gate * in each. Unless we're careful, we'll return the undef in the 10157c478bd9Sstevel@tonic-gate * aforementioned case. 10167c478bd9Sstevel@tonic-gate */ 10177c478bd9Sstevel@tonic-gate for (; n > 0; n--, km = mdb_list_next(km)) { 10187c478bd9Sstevel@tonic-gate if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name, 10197c478bd9Sstevel@tonic-gate &sym, &symid) == 0 && sym.st_shndx != SHN_UNDEF) 10207c478bd9Sstevel@tonic-gate break; 10217c478bd9Sstevel@tonic-gate } 10227c478bd9Sstevel@tonic-gate 10237c478bd9Sstevel@tonic-gate if (n == 0) 10247c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYM)); 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate found: 10277c478bd9Sstevel@tonic-gate bcopy(&sym, symp, sizeof (GElf_Sym)); 10287c478bd9Sstevel@tonic-gate sip->sym_id = symid; 10297c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_SYMTAB; 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate return (0); 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate static int 10357c478bd9Sstevel@tonic-gate kmt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id) 10367c478bd9Sstevel@tonic-gate { 10377c478bd9Sstevel@tonic-gate kmt_symarg_t *arg = data; 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate if (mdb_tgt_sym_match(sym, arg->sym_type)) { 10407c478bd9Sstevel@tonic-gate arg->sym_info.sym_id = id; 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate return (arg->sym_cb(arg->sym_data, sym, name, &arg->sym_info, 10437c478bd9Sstevel@tonic-gate arg->sym_obj)); 10447c478bd9Sstevel@tonic-gate } 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate return (0); 10477c478bd9Sstevel@tonic-gate } 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate static void 10507c478bd9Sstevel@tonic-gate kmt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj, 10517c478bd9Sstevel@tonic-gate mdb_tgt_sym_f *cb, void *p) 10527c478bd9Sstevel@tonic-gate { 10537c478bd9Sstevel@tonic-gate kmt_symarg_t arg; 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate arg.sym_cb = cb; 10567c478bd9Sstevel@tonic-gate arg.sym_data = p; 10577c478bd9Sstevel@tonic-gate arg.sym_type = type; 10587c478bd9Sstevel@tonic-gate arg.sym_info.sym_table = gst->gst_tabid; 10597c478bd9Sstevel@tonic-gate arg.sym_obj = obj; 10607c478bd9Sstevel@tonic-gate 10617c478bd9Sstevel@tonic-gate mdb_gelf_symtab_iter(gst, kmt_symtab_func, &arg); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate static int 10657c478bd9Sstevel@tonic-gate kmt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type, 10667c478bd9Sstevel@tonic-gate mdb_tgt_sym_f *cb, void *data) 10677c478bd9Sstevel@tonic-gate { 10687c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 10697c478bd9Sstevel@tonic-gate kmt_module_t *km; 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate mdb_gelf_symtab_t *symtab = NULL; 10727c478bd9Sstevel@tonic-gate mdb_var_t *v; 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate if (which == MDB_TGT_DYNSYM) 10757c478bd9Sstevel@tonic-gate return (set_errno(EMDB_TGTNOTSUP)); 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate switch ((uintptr_t)obj) { 10787c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EXEC: 10797c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EVERY: 10807c478bd9Sstevel@tonic-gate mdb_nv_rewind(&kmt->kmt_modules); 10817c478bd9Sstevel@tonic-gate while ((v = mdb_nv_advance(&kmt->kmt_modules)) != NULL) { 10827c478bd9Sstevel@tonic-gate km = mdb_nv_get_cookie(v); 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate if (km->km_symtab != NULL) { 10857c478bd9Sstevel@tonic-gate kmt_symtab_iter(km->km_symtab, type, 10867c478bd9Sstevel@tonic-gate km->km_name, cb, data); 10877c478bd9Sstevel@tonic-gate } 10887c478bd9Sstevel@tonic-gate } 10897c478bd9Sstevel@tonic-gate return (0); 10907c478bd9Sstevel@tonic-gate 10917c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_RTLD: 1092ae115bc7Smrj obj = kmt->kmt_rtld_name; 10937c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate default: 10967c478bd9Sstevel@tonic-gate if (strncmp(obj, "DMOD`", 5) == 0) { 10977c478bd9Sstevel@tonic-gate return (kmdb_module_symbol_iter(obj + 5, type, 10987c478bd9Sstevel@tonic-gate cb, data)); 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL) 11027c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOOBJ)); 11037c478bd9Sstevel@tonic-gate km = mdb_nv_get_cookie(v); 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate symtab = km->km_symtab; 11067c478bd9Sstevel@tonic-gate } 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate if (symtab != NULL) 11097c478bd9Sstevel@tonic-gate kmt_symtab_iter(symtab, type, obj, cb, data); 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate return (0); 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate static int 11157c478bd9Sstevel@tonic-gate kmt_mapping_walk(uintptr_t addr, const void *data, kmt_maparg_t *marg) 11167c478bd9Sstevel@tonic-gate { 11177c478bd9Sstevel@tonic-gate /* 11187c478bd9Sstevel@tonic-gate * This is a bit sketchy but avoids problematic compilation of this 11197c478bd9Sstevel@tonic-gate * target against the current VM implementation. Now that we have 11207c478bd9Sstevel@tonic-gate * vmem, we can make this less broken and more informative by changing 11217c478bd9Sstevel@tonic-gate * this code to invoke the vmem walker in the near future. 11227c478bd9Sstevel@tonic-gate */ 11237c478bd9Sstevel@tonic-gate const struct kmt_seg { 11247c478bd9Sstevel@tonic-gate caddr_t s_base; 11257c478bd9Sstevel@tonic-gate size_t s_size; 11267c478bd9Sstevel@tonic-gate } *segp = (const struct kmt_seg *)data; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate mdb_map_t map; 11297c478bd9Sstevel@tonic-gate GElf_Sym sym; 11307c478bd9Sstevel@tonic-gate mdb_syminfo_t info; 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate map.map_base = (uintptr_t)segp->s_base; 11337c478bd9Sstevel@tonic-gate map.map_size = segp->s_size; 11347c478bd9Sstevel@tonic-gate map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate if (kmt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT, 11377c478bd9Sstevel@tonic-gate map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) { 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ, 11407c478bd9Sstevel@tonic-gate "%lr", addr); 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate return (marg->map_cb(marg->map_data, &map, map.map_name)); 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate static int 11477c478bd9Sstevel@tonic-gate kmt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 11487c478bd9Sstevel@tonic-gate { 11497c478bd9Sstevel@tonic-gate kmt_maparg_t m; 11507c478bd9Sstevel@tonic-gate uintptr_t kas; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate m.map_target = t; 11537c478bd9Sstevel@tonic-gate m.map_cb = func; 11547c478bd9Sstevel@tonic-gate m.map_data = private; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate if ((kas = kmt_read_kas(t)) == NULL) 11577c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate return (mdb_pwalk("seg", (mdb_walk_cb_t)kmt_mapping_walk, &m, kas)); 11607c478bd9Sstevel@tonic-gate } 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate static const mdb_map_t * 11637c478bd9Sstevel@tonic-gate kmt_mod_to_map(kmt_module_t *km, mdb_map_t *map) 11647c478bd9Sstevel@tonic-gate { 11657c478bd9Sstevel@tonic-gate (void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ); 11667c478bd9Sstevel@tonic-gate map->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 11677c478bd9Sstevel@tonic-gate map->map_base = km->km_text_va; 11687c478bd9Sstevel@tonic-gate map->map_size = km->km_text_size; 11697c478bd9Sstevel@tonic-gate map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate return (map); 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate static int 11757c478bd9Sstevel@tonic-gate kmt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 11767c478bd9Sstevel@tonic-gate { 11777c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 11787c478bd9Sstevel@tonic-gate kmt_module_t *km; 11797c478bd9Sstevel@tonic-gate mdb_map_t m; 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 11827c478bd9Sstevel@tonic-gate km = mdb_list_next(km)) { 11837c478bd9Sstevel@tonic-gate if (func(private, kmt_mod_to_map(km, &m), km->km_name) == -1) 11847c478bd9Sstevel@tonic-gate break; 11857c478bd9Sstevel@tonic-gate } 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate return (0); 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate static const mdb_map_t * 11917c478bd9Sstevel@tonic-gate kmt_addr_to_map(mdb_tgt_t *t, uintptr_t addr) 11927c478bd9Sstevel@tonic-gate { 11937c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 11947c478bd9Sstevel@tonic-gate kmt_module_t *km; 11957c478bd9Sstevel@tonic-gate 11967c478bd9Sstevel@tonic-gate for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 11977c478bd9Sstevel@tonic-gate km = mdb_list_next(km)) { 11987c478bd9Sstevel@tonic-gate if (addr - km->km_text_va < km->km_text_size || 11997c478bd9Sstevel@tonic-gate addr - km->km_data_va < km->km_data_size || 12007c478bd9Sstevel@tonic-gate addr - km->km_bss_va < km->km_bss_size) 12017c478bd9Sstevel@tonic-gate return (kmt_mod_to_map(km, &kmt->kmt_map)); 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOMAP); 12057c478bd9Sstevel@tonic-gate return (NULL); 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate 1208ae115bc7Smrj static kmt_module_t * 1209ae115bc7Smrj kmt_module_by_name(kmt_data_t *kmt, const char *name) 1210ae115bc7Smrj { 1211ae115bc7Smrj kmt_module_t *km; 1212ae115bc7Smrj 1213ae115bc7Smrj for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 1214ae115bc7Smrj km = mdb_list_next(km)) { 1215ae115bc7Smrj if (strcmp(name, km->km_name) == 0) 1216ae115bc7Smrj return (km); 1217ae115bc7Smrj } 1218ae115bc7Smrj 1219ae115bc7Smrj return (NULL); 1220ae115bc7Smrj } 1221ae115bc7Smrj 12227c478bd9Sstevel@tonic-gate static const mdb_map_t * 12237c478bd9Sstevel@tonic-gate kmt_name_to_map(mdb_tgt_t *t, const char *name) 12247c478bd9Sstevel@tonic-gate { 12257c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 12267c478bd9Sstevel@tonic-gate kmt_module_t *km; 12277c478bd9Sstevel@tonic-gate mdb_map_t m; 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate /* 12307c478bd9Sstevel@tonic-gate * If name is MDB_TGT_OBJ_EXEC, return the first module on the list, 12317c478bd9Sstevel@tonic-gate * which will be unix since we keep kmt_modlist in load order. 12327c478bd9Sstevel@tonic-gate */ 12337c478bd9Sstevel@tonic-gate if (name == MDB_TGT_OBJ_EXEC) { 12347c478bd9Sstevel@tonic-gate return (kmt_mod_to_map(mdb_list_next(&kmt->kmt_modlist), 12357c478bd9Sstevel@tonic-gate &m)); 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate if (name == MDB_TGT_OBJ_RTLD) 1239ae115bc7Smrj name = kmt->kmt_rtld_name; 12407c478bd9Sstevel@tonic-gate 1241ae115bc7Smrj if ((km = kmt_module_by_name(kmt, name)) != NULL) 1242ae115bc7Smrj return (kmt_mod_to_map(km, &m)); 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOOBJ); 12457c478bd9Sstevel@tonic-gate return (NULL); 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate static ctf_file_t * 12497c478bd9Sstevel@tonic-gate kmt_load_ctfdata(mdb_tgt_t *t, kmt_module_t *km) 12507c478bd9Sstevel@tonic-gate { 12517c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 12527c478bd9Sstevel@tonic-gate int err; 12537c478bd9Sstevel@tonic-gate 12547c478bd9Sstevel@tonic-gate if (km->km_ctfp != NULL) 12557c478bd9Sstevel@tonic-gate return (km->km_ctfp); 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate if (km->km_ctf_va == NULL || km->km_symtab == NULL) { 12587c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOCTF); 12597c478bd9Sstevel@tonic-gate return (NULL); 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate if ((km->km_ctfp = mdb_ctf_bufopen(km->km_ctf_va, km->km_ctf_size, 12637c478bd9Sstevel@tonic-gate km->km_symtab_va, &km->km_symtab_hdr, km->km_strtab_va, 12647c478bd9Sstevel@tonic-gate &km->km_strtab_hdr, &err)) == NULL) { 12657c478bd9Sstevel@tonic-gate (void) set_errno(ctf_to_errno(err)); 12667c478bd9Sstevel@tonic-gate return (NULL); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n", 12707c478bd9Sstevel@tonic-gate (ulong_t)km->km_ctf_size, km->km_name); 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate if (ctf_parent_name(km->km_ctfp) != NULL) { 12737c478bd9Sstevel@tonic-gate mdb_var_t *v; 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&kmt->kmt_modules, 12767c478bd9Sstevel@tonic-gate ctf_parent_name(km->km_ctfp))) != NULL) { 12777c478bd9Sstevel@tonic-gate kmt_module_t *pm = mdb_nv_get_cookie(v); 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate if (pm->km_ctfp == NULL) 12807c478bd9Sstevel@tonic-gate (void) kmt_load_ctfdata(t, pm); 12817c478bd9Sstevel@tonic-gate 12827c478bd9Sstevel@tonic-gate if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp, 12837c478bd9Sstevel@tonic-gate pm->km_ctfp) == CTF_ERR) { 12847c478bd9Sstevel@tonic-gate warn("failed to import parent types into " 12857c478bd9Sstevel@tonic-gate "%s: %s\n", km->km_name, 12867c478bd9Sstevel@tonic-gate ctf_errmsg(ctf_errno(km->km_ctfp))); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate } else { 12897c478bd9Sstevel@tonic-gate warn("failed to load CTF data for %s - parent %s not " 12907c478bd9Sstevel@tonic-gate "loaded\n", km->km_name, 12917c478bd9Sstevel@tonic-gate ctf_parent_name(km->km_ctfp)); 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate return (km->km_ctfp); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate ctf_file_t * 12997c478bd9Sstevel@tonic-gate kmt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr) 13007c478bd9Sstevel@tonic-gate { 13017c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 13027c478bd9Sstevel@tonic-gate kmt_module_t *km; 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 13057c478bd9Sstevel@tonic-gate km = mdb_list_next(km)) { 13067c478bd9Sstevel@tonic-gate if (addr - km->km_text_va < km->km_text_size || 13077c478bd9Sstevel@tonic-gate addr - km->km_data_va < km->km_data_size || 13087c478bd9Sstevel@tonic-gate addr - km->km_bss_va < km->km_bss_size) 13097c478bd9Sstevel@tonic-gate return (kmt_load_ctfdata(t, km)); 13107c478bd9Sstevel@tonic-gate } 13117c478bd9Sstevel@tonic-gate 13125ae68c69Sjohnlev return (kmdb_module_addr_to_ctf(addr)); 13137c478bd9Sstevel@tonic-gate } 13147c478bd9Sstevel@tonic-gate 13157c478bd9Sstevel@tonic-gate ctf_file_t * 13167c478bd9Sstevel@tonic-gate kmt_name_to_ctf(mdb_tgt_t *t, const char *name) 13177c478bd9Sstevel@tonic-gate { 13187c478bd9Sstevel@tonic-gate kmt_data_t *kt = t->t_data; 13197c478bd9Sstevel@tonic-gate kmt_module_t *km; 13207c478bd9Sstevel@tonic-gate 13215ae68c69Sjohnlev if (name == MDB_TGT_OBJ_EXEC) { 1322ae115bc7Smrj name = KMT_CTFPARENT; 13235ae68c69Sjohnlev } else if (name == MDB_TGT_OBJ_RTLD) { 1324ae115bc7Smrj name = kt->kmt_rtld_name; 13255ae68c69Sjohnlev } else if (strncmp(name, "DMOD`", 5) == 0) { 13265ae68c69Sjohnlev /* Request for CTF data for a DMOD symbol */ 13275ae68c69Sjohnlev return (kmdb_module_name_to_ctf(name + 5)); 13285ae68c69Sjohnlev } 13297c478bd9Sstevel@tonic-gate 1330ae115bc7Smrj if ((km = kmt_module_by_name(kt, name)) != NULL) 1331ae115bc7Smrj return (kmt_load_ctfdata(t, km)); 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOOBJ); 13347c478bd9Sstevel@tonic-gate return (NULL); 13357c478bd9Sstevel@tonic-gate } 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13387c478bd9Sstevel@tonic-gate static int 13397c478bd9Sstevel@tonic-gate kmt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 13407c478bd9Sstevel@tonic-gate { 13417c478bd9Sstevel@tonic-gate int state; 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate bzero(tsp, sizeof (mdb_tgt_status_t)); 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate switch ((state = kmdb_dpi_get_state(NULL))) { 13467c478bd9Sstevel@tonic-gate case DPI_STATE_INIT: 13477c478bd9Sstevel@tonic-gate tsp->st_state = MDB_TGT_RUNNING; 13487c478bd9Sstevel@tonic-gate tsp->st_pc = 0; 13497c478bd9Sstevel@tonic-gate break; 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate case DPI_STATE_STOPPED: 13527c478bd9Sstevel@tonic-gate tsp->st_state = MDB_TGT_STOPPED; 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 13557c478bd9Sstevel@tonic-gate break; 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate case DPI_STATE_FAULTED: 13587c478bd9Sstevel@tonic-gate tsp->st_state = MDB_TGT_STOPPED; 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate tsp->st_flags |= MDB_TGT_ISTOP; 13637c478bd9Sstevel@tonic-gate break; 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate case DPI_STATE_LOST: 13667c478bd9Sstevel@tonic-gate tsp->st_state = MDB_TGT_LOST; 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 13697c478bd9Sstevel@tonic-gate break; 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "kmt_status, dpi: %d tsp: %d, pc = %p %A\n", 13737c478bd9Sstevel@tonic-gate state, tsp->st_state, (void *)tsp->st_pc, tsp->st_pc); 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate return (0); 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate 13787c478bd9Sstevel@tonic-gate /* 13797c478bd9Sstevel@tonic-gate * Invoked when kmt_defbp_enter_debugger is called, this routine activates and 13807c478bd9Sstevel@tonic-gate * deactivates deferred breakpoints in response to module load and unload 13817c478bd9Sstevel@tonic-gate * events. 13827c478bd9Sstevel@tonic-gate */ 13837c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13847c478bd9Sstevel@tonic-gate static void 13857c478bd9Sstevel@tonic-gate kmt_defbp_event(mdb_tgt_t *t, int vid, void *private) 13867c478bd9Sstevel@tonic-gate { 13877c478bd9Sstevel@tonic-gate if (kmt_defbp_modchg_isload) { 13887c478bd9Sstevel@tonic-gate if (!mdb_tgt_sespec_activate_all(t) && 13897c478bd9Sstevel@tonic-gate (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) { 13907c478bd9Sstevel@tonic-gate /* 13917c478bd9Sstevel@tonic-gate * We weren't able to activate the breakpoints. 13927c478bd9Sstevel@tonic-gate * If so requested, we'll return without calling 13937c478bd9Sstevel@tonic-gate * continue, thus throwing the user into the debugger. 13947c478bd9Sstevel@tonic-gate */ 13957c478bd9Sstevel@tonic-gate return; 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate } else { 13997c478bd9Sstevel@tonic-gate mdb_sespec_t *sep, *nsep; 14007c478bd9Sstevel@tonic-gate const mdb_map_t *map, *bpmap; 14017c478bd9Sstevel@tonic-gate mdb_map_t modmap; 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate if ((map = kmt_addr_to_map(t, 14047c478bd9Sstevel@tonic-gate (uintptr_t)kmt_defbp_modchg_modctl->mod_text)) == NULL) { 14057c478bd9Sstevel@tonic-gate warn("module unload notification for unknown module %s", 14067c478bd9Sstevel@tonic-gate kmt_defbp_modchg_modctl->mod_modname); 14077c478bd9Sstevel@tonic-gate return; /* drop into the debugger */ 14087c478bd9Sstevel@tonic-gate } 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate bcopy(map, &modmap, sizeof (mdb_map_t)); 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate for (sep = mdb_list_next(&t->t_active); sep; sep = nsep) { 14137c478bd9Sstevel@tonic-gate nsep = mdb_list_next(sep); 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate if (sep->se_ops == &kmt_brkpt_ops) { 14167c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate if ((bpmap = kmt_addr_to_map(t, 14197c478bd9Sstevel@tonic-gate kb->kb_addr)) == NULL || 14207c478bd9Sstevel@tonic-gate (bpmap->map_base == modmap.map_base && 14217c478bd9Sstevel@tonic-gate bpmap->map_size == modmap.map_size)) { 14227c478bd9Sstevel@tonic-gate mdb_tgt_sespec_idle_one(t, sep, 14237c478bd9Sstevel@tonic-gate EMDB_NOMAP); 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate } 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate } 14287c478bd9Sstevel@tonic-gate 14297c478bd9Sstevel@tonic-gate (void) mdb_tgt_continue(t, NULL); 14307c478bd9Sstevel@tonic-gate } 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate static void 14337c478bd9Sstevel@tonic-gate kmt_defbp_enter_debugger(void) 14347c478bd9Sstevel@tonic-gate { 14357c478bd9Sstevel@tonic-gate /* 14367c478bd9Sstevel@tonic-gate * The debugger places a breakpoint here. We can't have a simple 14377c478bd9Sstevel@tonic-gate * nop function here, because GCC knows much more than we do, and 1438acbc304dSjohnlev * will optimize away the call to it. 14397c478bd9Sstevel@tonic-gate */ 14407c478bd9Sstevel@tonic-gate (void) get_fp(); 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * This routine is called while the kernel is running. It attempts to determine 14457c478bd9Sstevel@tonic-gate * whether any deferred breakpoints exist for the module being changed (loaded 14467c478bd9Sstevel@tonic-gate * or unloaded). If any such breakpoints exist, the debugger will be entered to 14477c478bd9Sstevel@tonic-gate * process them. 14487c478bd9Sstevel@tonic-gate */ 14497c478bd9Sstevel@tonic-gate static void 14507c478bd9Sstevel@tonic-gate kmt_defbp_modchg(struct modctl *mctl, int isload) 14517c478bd9Sstevel@tonic-gate { 14527c478bd9Sstevel@tonic-gate kmt_defbp_t *dbp; 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate kmt_defbp_lock = 1; 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate for (dbp = mdb_list_next(&kmt_defbp_list); dbp; 14577c478bd9Sstevel@tonic-gate dbp = mdb_list_next(dbp)) { 14587c478bd9Sstevel@tonic-gate if (!dbp->dbp_ref) 14597c478bd9Sstevel@tonic-gate continue; 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate if (strcmp(mctl->mod_modname, dbp->dbp_objname) == 0) { 14627c478bd9Sstevel@tonic-gate /* 14637c478bd9Sstevel@tonic-gate * Activate the breakpoint 14647c478bd9Sstevel@tonic-gate */ 14657c478bd9Sstevel@tonic-gate kmt_defbp_modchg_isload = isload; 14667c478bd9Sstevel@tonic-gate kmt_defbp_modchg_modctl = mctl; 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate kmt_defbp_enter_debugger(); 14697c478bd9Sstevel@tonic-gate break; 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate } 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate kmt_defbp_lock = 0; 14747c478bd9Sstevel@tonic-gate } 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14777c478bd9Sstevel@tonic-gate static int 14787c478bd9Sstevel@tonic-gate kmt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 14797c478bd9Sstevel@tonic-gate { 14807c478bd9Sstevel@tonic-gate int n; 14817c478bd9Sstevel@tonic-gate 14827c478bd9Sstevel@tonic-gate kmdb_dpi_resume(); 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate /* 14857c478bd9Sstevel@tonic-gate * The order of the following two calls is important. If there are 14867c478bd9Sstevel@tonic-gate * load acks on the work queue, we'll initialize the dmods they 14877c478bd9Sstevel@tonic-gate * represent. This will involve a call to _mdb_init, which may very 14887c478bd9Sstevel@tonic-gate * well result in a symbol lookup. If we haven't resynced our view 14897c478bd9Sstevel@tonic-gate * of symbols with the current state of the world, this lookup could 14907c478bd9Sstevel@tonic-gate * end very badly. We therefore make sure to sync before processing 14917c478bd9Sstevel@tonic-gate * the work queue. 14927c478bd9Sstevel@tonic-gate */ 14937c478bd9Sstevel@tonic-gate kmt_sync(t); 14947c478bd9Sstevel@tonic-gate kmdb_dpi_process_work_queue(); 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate if (kmdb_kdi_get_unload_request()) 14977c478bd9Sstevel@tonic-gate t->t_flags |= MDB_TGT_F_UNLOAD; 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &t->t_status); 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate if ((n = kmt_dmod_status(NULL, KMDB_MC_STATE_LOADING) + 15027c478bd9Sstevel@tonic-gate kmt_dmod_status(NULL, KMDB_MC_STATE_UNLOADING)) != 0) { 15037c478bd9Sstevel@tonic-gate mdb_warn("%d dmod load%c/unload%c pending\n", n, 15047c478bd9Sstevel@tonic-gate "s"[n == 1], "s"[n == 1]); 15057c478bd9Sstevel@tonic-gate } 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate return (0); 15087c478bd9Sstevel@tonic-gate } 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 15117c478bd9Sstevel@tonic-gate static int 15127c478bd9Sstevel@tonic-gate kmt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 15137c478bd9Sstevel@tonic-gate { 15147c478bd9Sstevel@tonic-gate int rc; 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate if ((rc = kmdb_dpi_step()) == 0) 15177c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &t->t_status); 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate return (rc); 15207c478bd9Sstevel@tonic-gate } 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate static int 15237c478bd9Sstevel@tonic-gate kmt_defbp_activate(mdb_tgt_t *t) 15247c478bd9Sstevel@tonic-gate { 15257c478bd9Sstevel@tonic-gate kmdb_dpi_modchg_register(kmt_defbp_modchg); 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate /* 15287c478bd9Sstevel@tonic-gate * The routines that add and arm breakpoints will check for the proper 15297c478bd9Sstevel@tonic-gate * DTrace state, but they'll just put this breakpoint on the idle list 15307c478bd9Sstevel@tonic-gate * if DTrace is active. It'll correctly move to the active list when 15317c478bd9Sstevel@tonic-gate * DTrace deactivates, but that's insufficient for our purposes -- we 15327c478bd9Sstevel@tonic-gate * need to do extra processing at that point. We won't get to do said 15337c478bd9Sstevel@tonic-gate * processing with with a normal idle->active transition, so we just 15347c478bd9Sstevel@tonic-gate * won't add it add it until we're sure that it'll stick. 15357c478bd9Sstevel@tonic-gate */ 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 15387c478bd9Sstevel@tonic-gate return (set_errno(EMDB_DTACTIVE)); 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate kmt_defbp_bpspec = mdb_tgt_add_vbrkpt(t, 15417c478bd9Sstevel@tonic-gate (uintptr_t)kmt_defbp_enter_debugger, 15427c478bd9Sstevel@tonic-gate MDB_TGT_SPEC_HIDDEN, kmt_defbp_event, NULL); 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate return (0); 15457c478bd9Sstevel@tonic-gate } 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate static void 15487c478bd9Sstevel@tonic-gate kmt_defbp_deactivate(mdb_tgt_t *t) 15497c478bd9Sstevel@tonic-gate { 15507c478bd9Sstevel@tonic-gate kmdb_dpi_modchg_cancel(); 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate if (kmt_defbp_bpspec != 0) { 15537c478bd9Sstevel@tonic-gate if (t != NULL) 15547c478bd9Sstevel@tonic-gate (void) mdb_tgt_vespec_delete(t, kmt_defbp_bpspec); 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate kmt_defbp_bpspec = 0; 15577c478bd9Sstevel@tonic-gate } 15587c478bd9Sstevel@tonic-gate } 15597c478bd9Sstevel@tonic-gate 15607c478bd9Sstevel@tonic-gate static kmt_defbp_t * 15617c478bd9Sstevel@tonic-gate kmt_defbp_create(mdb_tgt_t *t, const char *objname, const char *symname) 15627c478bd9Sstevel@tonic-gate { 15637c478bd9Sstevel@tonic-gate kmt_defbp_t *dbp = mdb_alloc(sizeof (kmt_defbp_t), UM_SLEEP); 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "defbp_create %s`%s\n", objname, symname); 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate dbp->dbp_objname = strdup(objname); 15687c478bd9Sstevel@tonic-gate dbp->dbp_symname = strdup(symname); 15697c478bd9Sstevel@tonic-gate dbp->dbp_ref = 1; 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate kmt_defbp_num++; 15727c478bd9Sstevel@tonic-gate 15737c478bd9Sstevel@tonic-gate if (kmt_defbp_num == 1 || kmt_defbp_bpspec == 0) { 15747c478bd9Sstevel@tonic-gate if (kmt_defbp_activate(t) < 0) 15757c478bd9Sstevel@tonic-gate warn("failed to activate deferred breakpoints"); 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate mdb_list_append(&kmt_defbp_list, dbp); 15797c478bd9Sstevel@tonic-gate 15807c478bd9Sstevel@tonic-gate return (dbp); 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate static void 15847c478bd9Sstevel@tonic-gate kmt_defbp_destroy(kmt_defbp_t *dbp) 15857c478bd9Sstevel@tonic-gate { 15867c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "defbp_destroy %s`%s\n", dbp->dbp_objname, 15877c478bd9Sstevel@tonic-gate dbp->dbp_symname); 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate mdb_list_delete(&kmt_defbp_list, dbp); 15907c478bd9Sstevel@tonic-gate 15917c478bd9Sstevel@tonic-gate strfree(dbp->dbp_objname); 15927c478bd9Sstevel@tonic-gate strfree(dbp->dbp_symname); 15937c478bd9Sstevel@tonic-gate mdb_free(dbp, sizeof (kmt_defbp_t)); 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate 15967c478bd9Sstevel@tonic-gate static void 15977c478bd9Sstevel@tonic-gate kmt_defbp_prune_common(int all) 15987c478bd9Sstevel@tonic-gate { 15997c478bd9Sstevel@tonic-gate kmt_defbp_t *dbp, *ndbp; 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate /* We can't remove items from the list while the driver is using it. */ 16027c478bd9Sstevel@tonic-gate if (kmt_defbp_lock) 16037c478bd9Sstevel@tonic-gate return; 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate for (dbp = mdb_list_next(&kmt_defbp_list); dbp != NULL; dbp = ndbp) { 16067c478bd9Sstevel@tonic-gate ndbp = mdb_list_next(dbp); 16077c478bd9Sstevel@tonic-gate 16087c478bd9Sstevel@tonic-gate if (!all && dbp->dbp_ref) 16097c478bd9Sstevel@tonic-gate continue; 16107c478bd9Sstevel@tonic-gate 16117c478bd9Sstevel@tonic-gate kmt_defbp_destroy(dbp); 16127c478bd9Sstevel@tonic-gate } 16137c478bd9Sstevel@tonic-gate } 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate static void 16167c478bd9Sstevel@tonic-gate kmt_defbp_prune(void) 16177c478bd9Sstevel@tonic-gate { 16187c478bd9Sstevel@tonic-gate kmt_defbp_prune_common(0); 16197c478bd9Sstevel@tonic-gate } 16207c478bd9Sstevel@tonic-gate 16217c478bd9Sstevel@tonic-gate static void 16227c478bd9Sstevel@tonic-gate kmt_defbp_destroy_all(void) 16237c478bd9Sstevel@tonic-gate { 16247c478bd9Sstevel@tonic-gate kmt_defbp_prune_common(1); 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate static void 16287c478bd9Sstevel@tonic-gate kmt_defbp_delete(mdb_tgt_t *t, kmt_defbp_t *dbp) 16297c478bd9Sstevel@tonic-gate { 16307c478bd9Sstevel@tonic-gate dbp->dbp_ref = 0; 16317c478bd9Sstevel@tonic-gate 16327c478bd9Sstevel@tonic-gate ASSERT(kmt_defbp_num > 0); 16337c478bd9Sstevel@tonic-gate kmt_defbp_num--; 16347c478bd9Sstevel@tonic-gate 16357c478bd9Sstevel@tonic-gate if (kmt_defbp_num == 0) 16367c478bd9Sstevel@tonic-gate kmt_defbp_deactivate(t); 16377c478bd9Sstevel@tonic-gate 16387c478bd9Sstevel@tonic-gate kmt_defbp_prune(); 16397c478bd9Sstevel@tonic-gate } 16407c478bd9Sstevel@tonic-gate 16417c478bd9Sstevel@tonic-gate static int 16427c478bd9Sstevel@tonic-gate kmt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 16437c478bd9Sstevel@tonic-gate { 16447c478bd9Sstevel@tonic-gate mdb_tgt_status_t tsp; 16457c478bd9Sstevel@tonic-gate kmt_bparg_t *ka = args; 16467c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb; 16477c478bd9Sstevel@tonic-gate GElf_Sym s; 16487c478bd9Sstevel@tonic-gate mdb_instr_t instr; 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &tsp); 16517c478bd9Sstevel@tonic-gate if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED) 16527c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOPROC)); 16537c478bd9Sstevel@tonic-gate 16547c478bd9Sstevel@tonic-gate if (ka->ka_symbol != NULL) { 16557c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, &s, NULL) == -1) { 16567c478bd9Sstevel@tonic-gate if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM && 16577c478bd9Sstevel@tonic-gate !(mdb.m_flags & MDB_FL_BPTNOSYMSTOP))) { 16587c478bd9Sstevel@tonic-gate warn("breakpoint %s activation failed", 16597c478bd9Sstevel@tonic-gate ka->ka_symbol); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate ka->ka_addr = (uintptr_t)s.st_value; 16657c478bd9Sstevel@tonic-gate } 16667c478bd9Sstevel@tonic-gate 16677c478bd9Sstevel@tonic-gate #ifdef __sparc 16687c478bd9Sstevel@tonic-gate if (ka->ka_addr & 3) 16697c478bd9Sstevel@tonic-gate return (set_errno(EMDB_BPALIGN)); 16707c478bd9Sstevel@tonic-gate #endif 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate if (mdb_vread(&instr, sizeof (instr), ka->ka_addr) != sizeof (instr)) 16737c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 16767c478bd9Sstevel@tonic-gate warn("breakpoint will not arm until DTrace is inactive\n"); 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate kb = mdb_zalloc(sizeof (kmt_brkpt_t), UM_SLEEP); 16797c478bd9Sstevel@tonic-gate kb->kb_addr = ka->ka_addr; 16807c478bd9Sstevel@tonic-gate sep->se_data = kb; 16817c478bd9Sstevel@tonic-gate 16827c478bd9Sstevel@tonic-gate return (0); 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 16867c478bd9Sstevel@tonic-gate static void 16877c478bd9Sstevel@tonic-gate kmt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 16887c478bd9Sstevel@tonic-gate { 16897c478bd9Sstevel@tonic-gate mdb_free(sep->se_data, sizeof (kmt_brkpt_t)); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 16937c478bd9Sstevel@tonic-gate static char * 16947c478bd9Sstevel@tonic-gate kmt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 16957c478bd9Sstevel@tonic-gate mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 16967c478bd9Sstevel@tonic-gate { 16977c478bd9Sstevel@tonic-gate uintptr_t addr = NULL; 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate if (vep != NULL) { 17007c478bd9Sstevel@tonic-gate kmt_bparg_t *ka = vep->ve_args; 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate if (ka->ka_symbol != NULL) { 17037c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(buf, nbytes, "stop at %s", 17047c478bd9Sstevel@tonic-gate ka->ka_symbol); 17057c478bd9Sstevel@tonic-gate } else { 17067c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", 17077c478bd9Sstevel@tonic-gate ka->ka_addr); 17087c478bd9Sstevel@tonic-gate addr = ka->ka_addr; 17097c478bd9Sstevel@tonic-gate } 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate } else { 17127c478bd9Sstevel@tonic-gate addr = ((kmt_brkpt_t *)sep->se_data)->kb_addr; 17137c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr); 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate sp->spec_base = addr; 17177c478bd9Sstevel@tonic-gate sp->spec_size = sizeof (mdb_instr_t); 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate return (buf); 17207c478bd9Sstevel@tonic-gate } 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate static int 17237c478bd9Sstevel@tonic-gate kmt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 17247c478bd9Sstevel@tonic-gate { 17257c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 17267c478bd9Sstevel@tonic-gate kmt_bparg_t *ka = args; 17277c478bd9Sstevel@tonic-gate GElf_Sym sym; 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate if (ka->ka_symbol != NULL) { 17307c478bd9Sstevel@tonic-gate return (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, 17317c478bd9Sstevel@tonic-gate &sym, NULL) == 0 && sym.st_value == kb->kb_addr); 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate 17347c478bd9Sstevel@tonic-gate return (ka->ka_addr == kb->kb_addr); 17357c478bd9Sstevel@tonic-gate } 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 17387c478bd9Sstevel@tonic-gate static int 17397c478bd9Sstevel@tonic-gate kmt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 17407c478bd9Sstevel@tonic-gate { 17417c478bd9Sstevel@tonic-gate kmt_bparg_t *ka1 = vep->ve_args; 17427c478bd9Sstevel@tonic-gate kmt_bparg_t *ka2 = args; 17437c478bd9Sstevel@tonic-gate 17447c478bd9Sstevel@tonic-gate if (ka1->ka_symbol != NULL && ka2->ka_symbol != NULL) 17457c478bd9Sstevel@tonic-gate return (strcmp(ka1->ka_symbol, ka2->ka_symbol) == 0); 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if (ka1->ka_symbol == NULL && ka2->ka_symbol == NULL) 17487c478bd9Sstevel@tonic-gate return (ka1->ka_addr == ka2->ka_addr); 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate return (0); /* fail if one is symbolic, other is an explicit address */ 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate static int 17547c478bd9Sstevel@tonic-gate kmt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 17557c478bd9Sstevel@tonic-gate { 17567c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 17577c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 17587c478bd9Sstevel@tonic-gate int rv; 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 17617c478bd9Sstevel@tonic-gate return (set_errno(EMDB_DTACTIVE)); 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate if ((rv = kmdb_dpi_brkpt_arm(kb->kb_addr, &kb->kb_oinstr)) != 0) 17647c478bd9Sstevel@tonic-gate return (rv); 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate if (kmt->kmt_narmedbpts++ == 0) 17677c478bd9Sstevel@tonic-gate (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_ACTIVATE); 17687c478bd9Sstevel@tonic-gate 17697c478bd9Sstevel@tonic-gate return (0); 17707c478bd9Sstevel@tonic-gate } 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate static int 17737c478bd9Sstevel@tonic-gate kmt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 17747c478bd9Sstevel@tonic-gate { 17757c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 17767c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 17777c478bd9Sstevel@tonic-gate int rv; 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate ASSERT(kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_KMDB_BPT_ACTIVE); 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate if ((rv = kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr)) != 0) 17827c478bd9Sstevel@tonic-gate return (rv); 17837c478bd9Sstevel@tonic-gate 17847c478bd9Sstevel@tonic-gate if (--kmt->kmt_narmedbpts == 0) 17857c478bd9Sstevel@tonic-gate (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_DEACTIVATE); 17867c478bd9Sstevel@tonic-gate 17877c478bd9Sstevel@tonic-gate return (0); 17887c478bd9Sstevel@tonic-gate } 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate /* 17917c478bd9Sstevel@tonic-gate * Determine whether the specified sespec is an armed watchpoint that overlaps 17927c478bd9Sstevel@tonic-gate * with the given breakpoint and has the given flags set. We use this to find 17937c478bd9Sstevel@tonic-gate * conflicts with breakpoints, below. 17947c478bd9Sstevel@tonic-gate */ 17957c478bd9Sstevel@tonic-gate static int 17967c478bd9Sstevel@tonic-gate kmt_wp_overlap(mdb_sespec_t *sep, kmt_brkpt_t *kb, int flags) 17977c478bd9Sstevel@tonic-gate { 17987c478bd9Sstevel@tonic-gate const kmdb_wapt_t *wp = sep->se_data; 17997c478bd9Sstevel@tonic-gate 18007c478bd9Sstevel@tonic-gate return (sep->se_state == MDB_TGT_SPEC_ARMED && 18017c478bd9Sstevel@tonic-gate sep->se_ops == &kmt_wapt_ops && (wp->wp_wflags & flags) && 18027c478bd9Sstevel@tonic-gate kb->kb_addr - wp->wp_addr < wp->wp_size); 18037c478bd9Sstevel@tonic-gate } 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate /* 18067c478bd9Sstevel@tonic-gate * We step over breakpoints using our single-stepper. If a conflicting 18077c478bd9Sstevel@tonic-gate * watchpoint is present, we must temporarily remove it before stepping over the 18087c478bd9Sstevel@tonic-gate * breakpoint so we don't immediately re-trigger the watchpoint. We know the 18097c478bd9Sstevel@tonic-gate * watchpoint has already triggered on our trap instruction as part of fetching 18107c478bd9Sstevel@tonic-gate * it. Before we return, we must re-install any disabled watchpoints. 18117c478bd9Sstevel@tonic-gate */ 18127c478bd9Sstevel@tonic-gate static int 18137c478bd9Sstevel@tonic-gate kmt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 18147c478bd9Sstevel@tonic-gate { 18157c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 18167c478bd9Sstevel@tonic-gate int status = -1; 18177c478bd9Sstevel@tonic-gate int error; 18187c478bd9Sstevel@tonic-gate 18197c478bd9Sstevel@tonic-gate for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 18207c478bd9Sstevel@tonic-gate if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X)) 18217c478bd9Sstevel@tonic-gate (void) kmdb_dpi_wapt_disarm(sep->se_data); 18227c478bd9Sstevel@tonic-gate } 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate if (kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr) == 0 && 18257c478bd9Sstevel@tonic-gate kmt_step(t, tsp) == 0) 18267c478bd9Sstevel@tonic-gate status = kmt_status(t, tsp); 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate error = errno; /* save errno from disarm, step, or status */ 18297c478bd9Sstevel@tonic-gate 18307c478bd9Sstevel@tonic-gate for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 18317c478bd9Sstevel@tonic-gate if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X)) 18327c478bd9Sstevel@tonic-gate kmdb_dpi_wapt_arm(sep->se_data); 18337c478bd9Sstevel@tonic-gate } 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate (void) set_errno(error); 18367c478bd9Sstevel@tonic-gate return (status); 18377c478bd9Sstevel@tonic-gate } 18387c478bd9Sstevel@tonic-gate 18397c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 18407c478bd9Sstevel@tonic-gate static int 18417c478bd9Sstevel@tonic-gate kmt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 18427c478bd9Sstevel@tonic-gate { 18437c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 18447c478bd9Sstevel@tonic-gate int state, why; 18457c478bd9Sstevel@tonic-gate kreg_t pc; 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate state = kmdb_dpi_get_state(&why); 18487c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("pc", &pc); 18497c478bd9Sstevel@tonic-gate 18507c478bd9Sstevel@tonic-gate return (state == DPI_STATE_FAULTED && why == DPI_STATE_WHY_BKPT && 18517c478bd9Sstevel@tonic-gate pc == kb->kb_addr); 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_brkpt_ops = { 18557c478bd9Sstevel@tonic-gate kmt_brkpt_ctor, /* se_ctor */ 18567c478bd9Sstevel@tonic-gate kmt_brkpt_dtor, /* se_dtor */ 18577c478bd9Sstevel@tonic-gate kmt_brkpt_info, /* se_info */ 18587c478bd9Sstevel@tonic-gate kmt_brkpt_secmp, /* se_secmp */ 18597c478bd9Sstevel@tonic-gate kmt_brkpt_vecmp, /* se_vecmp */ 18607c478bd9Sstevel@tonic-gate kmt_brkpt_arm, /* se_arm */ 18617c478bd9Sstevel@tonic-gate kmt_brkpt_disarm, /* se_disarm */ 18627c478bd9Sstevel@tonic-gate kmt_brkpt_cont, /* se_cont */ 18637c478bd9Sstevel@tonic-gate kmt_brkpt_match /* se_match */ 18647c478bd9Sstevel@tonic-gate }; 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate static int 18677c478bd9Sstevel@tonic-gate kmt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 18687c478bd9Sstevel@tonic-gate { 18697c478bd9Sstevel@tonic-gate mdb_tgt_status_t tsp; 18707c478bd9Sstevel@tonic-gate kmdb_wapt_t *vwp = args; 18717c478bd9Sstevel@tonic-gate kmdb_wapt_t *swp; 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &tsp); 18747c478bd9Sstevel@tonic-gate if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED) 18757c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOPROC)); 18767c478bd9Sstevel@tonic-gate 18777c478bd9Sstevel@tonic-gate swp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP); 18787c478bd9Sstevel@tonic-gate bcopy(vwp, swp, sizeof (kmdb_wapt_t)); 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate if (kmdb_dpi_wapt_reserve(swp) < 0) { 18817c478bd9Sstevel@tonic-gate mdb_free(swp, sizeof (kmdb_wapt_t)); 18827c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 18837c478bd9Sstevel@tonic-gate } 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate sep->se_data = swp; 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate return (0); 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate 18907c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 18917c478bd9Sstevel@tonic-gate static void 18927c478bd9Sstevel@tonic-gate kmt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 18937c478bd9Sstevel@tonic-gate { 18947c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp = sep->se_data; 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate kmdb_dpi_wapt_release(wp); 18977c478bd9Sstevel@tonic-gate mdb_free(wp, sizeof (kmdb_wapt_t)); 18987c478bd9Sstevel@tonic-gate } 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19017c478bd9Sstevel@tonic-gate static char * 19027c478bd9Sstevel@tonic-gate kmt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 19037c478bd9Sstevel@tonic-gate mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 19047c478bd9Sstevel@tonic-gate { 19057c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp = vep != NULL ? vep->ve_args : sep->se_data; 19067c478bd9Sstevel@tonic-gate const char *fmt; 19077c478bd9Sstevel@tonic-gate char desc[24]; 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate ASSERT(wp->wp_wflags != 0); 19107c478bd9Sstevel@tonic-gate desc[0] = '\0'; 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate switch (wp->wp_wflags) { 19137c478bd9Sstevel@tonic-gate case MDB_TGT_WA_R: 19147c478bd9Sstevel@tonic-gate (void) strcat(desc, "/read"); 19157c478bd9Sstevel@tonic-gate break; 19167c478bd9Sstevel@tonic-gate case MDB_TGT_WA_W: 19177c478bd9Sstevel@tonic-gate (void) strcat(desc, "/write"); 19187c478bd9Sstevel@tonic-gate break; 19197c478bd9Sstevel@tonic-gate case MDB_TGT_WA_X: 19207c478bd9Sstevel@tonic-gate (void) strcat(desc, "/exec"); 19217c478bd9Sstevel@tonic-gate break; 19227c478bd9Sstevel@tonic-gate default: 19237c478bd9Sstevel@tonic-gate if (wp->wp_wflags & MDB_TGT_WA_R) 19247c478bd9Sstevel@tonic-gate (void) strcat(desc, "/r"); 19257c478bd9Sstevel@tonic-gate if (wp->wp_wflags & MDB_TGT_WA_W) 19267c478bd9Sstevel@tonic-gate (void) strcat(desc, "/w"); 19277c478bd9Sstevel@tonic-gate if (wp->wp_wflags & MDB_TGT_WA_X) 19287c478bd9Sstevel@tonic-gate (void) strcat(desc, "/x"); 19297c478bd9Sstevel@tonic-gate } 19307c478bd9Sstevel@tonic-gate 19317c478bd9Sstevel@tonic-gate switch (wp->wp_type) { 19327c478bd9Sstevel@tonic-gate case DPI_WAPT_TYPE_PHYS: 19337c478bd9Sstevel@tonic-gate fmt = "stop on %s of phys [%p, %p)"; 19347c478bd9Sstevel@tonic-gate break; 19357c478bd9Sstevel@tonic-gate 19367c478bd9Sstevel@tonic-gate case DPI_WAPT_TYPE_VIRT: 19377c478bd9Sstevel@tonic-gate fmt = "stop on %s of [%la, %la)"; 19387c478bd9Sstevel@tonic-gate break; 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate case DPI_WAPT_TYPE_IO: 19417c478bd9Sstevel@tonic-gate if (wp->wp_size == 1) 19427c478bd9Sstevel@tonic-gate fmt = "stop on %s of I/O port %p"; 19437c478bd9Sstevel@tonic-gate else 19447c478bd9Sstevel@tonic-gate fmt = "stop on %s of I/O port [%p, %p)"; 19457c478bd9Sstevel@tonic-gate break; 19467c478bd9Sstevel@tonic-gate } 19477c478bd9Sstevel@tonic-gate 19487c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(buf, nbytes, fmt, desc + 1, wp->wp_addr, 19497c478bd9Sstevel@tonic-gate wp->wp_addr + wp->wp_size); 19507c478bd9Sstevel@tonic-gate 19517c478bd9Sstevel@tonic-gate sp->spec_base = wp->wp_addr; 19527c478bd9Sstevel@tonic-gate sp->spec_size = wp->wp_size; 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate return (buf); 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19587c478bd9Sstevel@tonic-gate static int 19597c478bd9Sstevel@tonic-gate kmt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 19607c478bd9Sstevel@tonic-gate { 19617c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp1 = sep->se_data; 19627c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp2 = args; 19637c478bd9Sstevel@tonic-gate 19647c478bd9Sstevel@tonic-gate return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size && 19657c478bd9Sstevel@tonic-gate wp1->wp_wflags == wp2->wp_wflags); 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19697c478bd9Sstevel@tonic-gate static int 19707c478bd9Sstevel@tonic-gate kmt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 19717c478bd9Sstevel@tonic-gate { 19727c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp1 = vep->ve_args; 19737c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp2 = args; 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size && 19767c478bd9Sstevel@tonic-gate wp1->wp_wflags == wp2->wp_wflags); 19777c478bd9Sstevel@tonic-gate } 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19807c478bd9Sstevel@tonic-gate static int 19817c478bd9Sstevel@tonic-gate kmt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 19827c478bd9Sstevel@tonic-gate { 19837c478bd9Sstevel@tonic-gate kmdb_dpi_wapt_arm(sep->se_data); 19847c478bd9Sstevel@tonic-gate 19857c478bd9Sstevel@tonic-gate return (0); 19867c478bd9Sstevel@tonic-gate } 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19897c478bd9Sstevel@tonic-gate static int 19907c478bd9Sstevel@tonic-gate kmt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 19917c478bd9Sstevel@tonic-gate { 19927c478bd9Sstevel@tonic-gate kmdb_dpi_wapt_disarm(sep->se_data); 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate return (0); 19957c478bd9Sstevel@tonic-gate } 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate /* 19987c478bd9Sstevel@tonic-gate * Determine whether the specified sespec is an armed breakpoint at the given 19997c478bd9Sstevel@tonic-gate * %pc. We use this to find conflicts with watchpoints below. 20007c478bd9Sstevel@tonic-gate */ 20017c478bd9Sstevel@tonic-gate static int 20027c478bd9Sstevel@tonic-gate kmt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc) 20037c478bd9Sstevel@tonic-gate { 20047c478bd9Sstevel@tonic-gate kmt_brkpt_t *kb = sep->se_data; 20057c478bd9Sstevel@tonic-gate 20067c478bd9Sstevel@tonic-gate return (sep->se_state == MDB_TGT_SPEC_ARMED && 20077c478bd9Sstevel@tonic-gate sep->se_ops == &kmt_brkpt_ops && kb->kb_addr == pc); 20087c478bd9Sstevel@tonic-gate } 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate /* 20117c478bd9Sstevel@tonic-gate * We step over watchpoints using our single-stepper. If a conflicting 20127c478bd9Sstevel@tonic-gate * breakpoint is present, we must temporarily disarm it before stepping over 20137c478bd9Sstevel@tonic-gate * the watchpoint so we do not immediately re-trigger the breakpoint. This is 20147c478bd9Sstevel@tonic-gate * similar to the case handled in kmt_brkpt_cont(), above. 20157c478bd9Sstevel@tonic-gate */ 20167c478bd9Sstevel@tonic-gate static int 20177c478bd9Sstevel@tonic-gate kmt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 20187c478bd9Sstevel@tonic-gate { 20197c478bd9Sstevel@tonic-gate mdb_sespec_t *bep = NULL; 20207c478bd9Sstevel@tonic-gate int status = -1; 20217c478bd9Sstevel@tonic-gate int error, why; 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate /* 20247c478bd9Sstevel@tonic-gate * If we stopped for anything other than a watchpoint, check to see 20257c478bd9Sstevel@tonic-gate * if there's a breakpoint here. 20267c478bd9Sstevel@tonic-gate */ 20277c478bd9Sstevel@tonic-gate if (!(kmdb_dpi_get_state(&why) == DPI_STATE_FAULTED && 20287c478bd9Sstevel@tonic-gate (why == DPI_STATE_WHY_V_WAPT || why == DPI_STATE_WHY_P_WAPT))) { 20297c478bd9Sstevel@tonic-gate kreg_t pc; 20307c478bd9Sstevel@tonic-gate 20317c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("pc", &pc); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate for (bep = mdb_list_next(&t->t_active); bep != NULL; 20347c478bd9Sstevel@tonic-gate bep = mdb_list_next(bep)) { 20357c478bd9Sstevel@tonic-gate if (kmt_bp_overlap(bep, pc)) { 20367c478bd9Sstevel@tonic-gate (void) bep->se_ops->se_disarm(t, bep); 20377c478bd9Sstevel@tonic-gate bep->se_state = MDB_TGT_SPEC_ACTIVE; 20387c478bd9Sstevel@tonic-gate break; 20397c478bd9Sstevel@tonic-gate } 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate } 20427c478bd9Sstevel@tonic-gate 20437c478bd9Sstevel@tonic-gate kmdb_dpi_wapt_disarm(sep->se_data); 20447c478bd9Sstevel@tonic-gate if (kmt_step(t, tsp) == 0) 20457c478bd9Sstevel@tonic-gate status = kmt_status(t, tsp); 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate error = errno; /* save errno from step or status */ 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate if (bep != NULL) 20507c478bd9Sstevel@tonic-gate mdb_tgt_sespec_arm_one(t, bep); 20517c478bd9Sstevel@tonic-gate 20527c478bd9Sstevel@tonic-gate (void) set_errno(error); 20537c478bd9Sstevel@tonic-gate return (status); 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 20577c478bd9Sstevel@tonic-gate static int 20587c478bd9Sstevel@tonic-gate kmt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 20597c478bd9Sstevel@tonic-gate { 20607c478bd9Sstevel@tonic-gate return (kmdb_dpi_wapt_match(sep->se_data)); 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_wapt_ops = { 20647c478bd9Sstevel@tonic-gate kmt_wapt_ctor, /* se_ctor */ 20657c478bd9Sstevel@tonic-gate kmt_wapt_dtor, /* se_dtor */ 20667c478bd9Sstevel@tonic-gate kmt_wapt_info, /* se_info */ 20677c478bd9Sstevel@tonic-gate kmt_wapt_secmp, /* se_secmp */ 20687c478bd9Sstevel@tonic-gate kmt_wapt_vecmp, /* se_vecmp */ 20697c478bd9Sstevel@tonic-gate kmt_wapt_arm, /* se_arm */ 20707c478bd9Sstevel@tonic-gate kmt_wapt_disarm, /* se_disarm */ 20717c478bd9Sstevel@tonic-gate kmt_wapt_cont, /* se_cont */ 20727c478bd9Sstevel@tonic-gate kmt_wapt_match /* se_match */ 20737c478bd9Sstevel@tonic-gate }; 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 20767c478bd9Sstevel@tonic-gate static int 20777c478bd9Sstevel@tonic-gate kmt_trap_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 20787c478bd9Sstevel@tonic-gate { 20797c478bd9Sstevel@tonic-gate sep->se_data = args; /* trap number */ 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate return (0); 20827c478bd9Sstevel@tonic-gate } 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 20857c478bd9Sstevel@tonic-gate static char * 20867c478bd9Sstevel@tonic-gate kmt_trap_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 20877c478bd9Sstevel@tonic-gate mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 20887c478bd9Sstevel@tonic-gate { 20897c478bd9Sstevel@tonic-gate const char *name; 20907c478bd9Sstevel@tonic-gate int trapnum; 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate if (vep != NULL) 20937c478bd9Sstevel@tonic-gate trapnum = (intptr_t)vep->ve_args; 20947c478bd9Sstevel@tonic-gate else 20957c478bd9Sstevel@tonic-gate trapnum = (intptr_t)sep->se_data; 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate if (trapnum == KMT_TRAP_ALL) 20987c478bd9Sstevel@tonic-gate name = "any trap"; 20997c478bd9Sstevel@tonic-gate else if (trapnum == KMT_TRAP_NOTENUM) 21007c478bd9Sstevel@tonic-gate name = "miscellaneous trap"; 21017c478bd9Sstevel@tonic-gate else 21027c478bd9Sstevel@tonic-gate name = kmt_trapname(trapnum); 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate (void) mdb_iob_snprintf(buf, nbytes, "single-step stop on %s", name); 21057c478bd9Sstevel@tonic-gate 21067c478bd9Sstevel@tonic-gate return (buf); 21077c478bd9Sstevel@tonic-gate } 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate /*ARGSUSED2*/ 21107c478bd9Sstevel@tonic-gate static int 21117c478bd9Sstevel@tonic-gate kmt_trap_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 21127c478bd9Sstevel@tonic-gate { 21137c478bd9Sstevel@tonic-gate int spectt = (intptr_t)sep->se_data; 21147c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 21157c478bd9Sstevel@tonic-gate kreg_t tt; 21167c478bd9Sstevel@tonic-gate 21177c478bd9Sstevel@tonic-gate (void) kmdb_dpi_get_register("tt", &tt); 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate switch (spectt) { 21207c478bd9Sstevel@tonic-gate case KMT_TRAP_ALL: 21217c478bd9Sstevel@tonic-gate return (1); 21227c478bd9Sstevel@tonic-gate case KMT_TRAP_NOTENUM: 21237c478bd9Sstevel@tonic-gate return (tt > kmt->kmt_trapmax || 21247c478bd9Sstevel@tonic-gate !BT_TEST(kmt->kmt_trapmap, tt)); 21257c478bd9Sstevel@tonic-gate default: 21267c478bd9Sstevel@tonic-gate return (tt == spectt); 21277c478bd9Sstevel@tonic-gate } 21287c478bd9Sstevel@tonic-gate } 21297c478bd9Sstevel@tonic-gate 21307c478bd9Sstevel@tonic-gate static const mdb_se_ops_t kmt_trap_ops = { 21317c478bd9Sstevel@tonic-gate kmt_trap_ctor, /* se_ctor */ 21327c478bd9Sstevel@tonic-gate no_se_dtor, /* se_dtor */ 21337c478bd9Sstevel@tonic-gate kmt_trap_info, /* se_info */ 21347c478bd9Sstevel@tonic-gate no_se_secmp, /* se_secmp */ 21357c478bd9Sstevel@tonic-gate no_se_vecmp, /* se_vecmp */ 21367c478bd9Sstevel@tonic-gate no_se_arm, /* se_arm */ 21377c478bd9Sstevel@tonic-gate no_se_disarm, /* se_disarm */ 21387c478bd9Sstevel@tonic-gate no_se_cont, /* se_cont */ 21397c478bd9Sstevel@tonic-gate kmt_trap_match /* se_match */ 21407c478bd9Sstevel@tonic-gate }; 21417c478bd9Sstevel@tonic-gate 21427c478bd9Sstevel@tonic-gate static void 21437c478bd9Sstevel@tonic-gate kmt_bparg_dtor(mdb_vespec_t *vep) 21447c478bd9Sstevel@tonic-gate { 21457c478bd9Sstevel@tonic-gate kmt_bparg_t *ka = vep->ve_args; 21467c478bd9Sstevel@tonic-gate 21477c478bd9Sstevel@tonic-gate if (ka->ka_symbol != NULL) 21487c478bd9Sstevel@tonic-gate strfree(ka->ka_symbol); 21497c478bd9Sstevel@tonic-gate 21507c478bd9Sstevel@tonic-gate if (ka->ka_defbp != NULL) 21517c478bd9Sstevel@tonic-gate kmt_defbp_delete(mdb.m_target, ka->ka_defbp); 21527c478bd9Sstevel@tonic-gate 21537c478bd9Sstevel@tonic-gate mdb_free(ka, sizeof (kmt_bparg_t)); 21547c478bd9Sstevel@tonic-gate } 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate static int 21577c478bd9Sstevel@tonic-gate kmt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr, 21587c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data) 21597c478bd9Sstevel@tonic-gate { 21607c478bd9Sstevel@tonic-gate kmt_bparg_t *ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP); 21617c478bd9Sstevel@tonic-gate 21627c478bd9Sstevel@tonic-gate ka->ka_addr = addr; 21637c478bd9Sstevel@tonic-gate ka->ka_symbol = NULL; 21647c478bd9Sstevel@tonic-gate ka->ka_defbp = NULL; 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags, 21677c478bd9Sstevel@tonic-gate func, data, ka, kmt_bparg_dtor)); 21687c478bd9Sstevel@tonic-gate } 21697c478bd9Sstevel@tonic-gate 21707c478bd9Sstevel@tonic-gate static int 21717c478bd9Sstevel@tonic-gate kmt_add_sbrkpt(mdb_tgt_t *t, const char *fullname, 21727c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data) 21737c478bd9Sstevel@tonic-gate { 21747c478bd9Sstevel@tonic-gate kmt_bparg_t *ka; 21757c478bd9Sstevel@tonic-gate kmt_defbp_t *dbp; 21767c478bd9Sstevel@tonic-gate GElf_Sym sym; 21777c478bd9Sstevel@tonic-gate char *tick, *objname, *symname; 21787c478bd9Sstevel@tonic-gate int serrno; 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate if ((tick = strchr(fullname, '`')) == fullname) { 21817c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOOBJ); 21827c478bd9Sstevel@tonic-gate return (0); 21837c478bd9Sstevel@tonic-gate } 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate /* 21867c478bd9Sstevel@tonic-gate * Deferred breakpoints are always scoped. If we didn't find a tick, 21877c478bd9Sstevel@tonic-gate * there's no scope. We'll create a vbrkpt, but only if we can turn the 21887c478bd9Sstevel@tonic-gate * provided string into an address. 21897c478bd9Sstevel@tonic-gate */ 21907c478bd9Sstevel@tonic-gate if (tick == NULL) { 21917c478bd9Sstevel@tonic-gate uintptr_t addr; 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate if (strisbasenum(fullname)) { 21947c478bd9Sstevel@tonic-gate addr = mdb_strtoull(fullname); /* a bare address */ 21957c478bd9Sstevel@tonic-gate } else if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EVERY, 21967c478bd9Sstevel@tonic-gate fullname, &sym, NULL) < 0) { 21977c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOSYM); 21987c478bd9Sstevel@tonic-gate return (0); 21997c478bd9Sstevel@tonic-gate } else { 22007c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value; /* unscoped sym name */ 22017c478bd9Sstevel@tonic-gate } 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate return (kmt_add_vbrkpt(t, addr, spec_flags, func, data)); 22047c478bd9Sstevel@tonic-gate } 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate if (*(tick + 1) == '\0') { 22077c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOSYM); 22087c478bd9Sstevel@tonic-gate return (0); 22097c478bd9Sstevel@tonic-gate } 22107c478bd9Sstevel@tonic-gate 22117c478bd9Sstevel@tonic-gate objname = strndup(fullname, tick - fullname); 22127c478bd9Sstevel@tonic-gate symname = tick + 1; 22137c478bd9Sstevel@tonic-gate 22147c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_name(t, objname, symname, NULL, NULL) < 0 && 22157c478bd9Sstevel@tonic-gate errno != EMDB_NOOBJ) { 22167c478bd9Sstevel@tonic-gate serrno = errno; 22177c478bd9Sstevel@tonic-gate strfree(objname); 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate (void) set_errno(serrno); 22207c478bd9Sstevel@tonic-gate return (0); /* errno is set for us */ 22217c478bd9Sstevel@tonic-gate } 22227c478bd9Sstevel@tonic-gate 22237c478bd9Sstevel@tonic-gate dbp = kmt_defbp_create(t, objname, symname); 22247c478bd9Sstevel@tonic-gate strfree(objname); 22257c478bd9Sstevel@tonic-gate 22267c478bd9Sstevel@tonic-gate ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP); 22277c478bd9Sstevel@tonic-gate ka->ka_symbol = strdup(fullname); 22287c478bd9Sstevel@tonic-gate ka->ka_addr = NULL; 22297c478bd9Sstevel@tonic-gate ka->ka_defbp = dbp; 22307c478bd9Sstevel@tonic-gate 22317c478bd9Sstevel@tonic-gate return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags, 22327b9b3bf3Sedp func, data, ka, kmt_bparg_dtor)); 22337c478bd9Sstevel@tonic-gate } 22347c478bd9Sstevel@tonic-gate 22357c478bd9Sstevel@tonic-gate static int 22367c478bd9Sstevel@tonic-gate kmt_wparg_overlap(const kmdb_wapt_t *wp1, const kmdb_wapt_t *wp2) 22377c478bd9Sstevel@tonic-gate { 22387c478bd9Sstevel@tonic-gate /* Assume the watchpoint spaces don't overlap */ 22397c478bd9Sstevel@tonic-gate if (wp1->wp_type != wp2->wp_type) 22407c478bd9Sstevel@tonic-gate return (0); 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate if (wp2->wp_addr + wp2->wp_size <= wp1->wp_addr) 22437c478bd9Sstevel@tonic-gate return (0); /* no range overlap */ 22447c478bd9Sstevel@tonic-gate 22457c478bd9Sstevel@tonic-gate if (wp1->wp_addr + wp1->wp_size <= wp2->wp_addr) 22467c478bd9Sstevel@tonic-gate return (0); /* no range overlap */ 22477c478bd9Sstevel@tonic-gate 22487c478bd9Sstevel@tonic-gate return (wp1->wp_addr != wp2->wp_addr || wp1->wp_size != wp2->wp_size || 22497c478bd9Sstevel@tonic-gate wp1->wp_wflags != wp2->wp_wflags); 22507c478bd9Sstevel@tonic-gate } 22517c478bd9Sstevel@tonic-gate 22527c478bd9Sstevel@tonic-gate static void 22537c478bd9Sstevel@tonic-gate kmt_wparg_dtor(mdb_vespec_t *vep) 22547c478bd9Sstevel@tonic-gate { 22557c478bd9Sstevel@tonic-gate mdb_free(vep->ve_args, sizeof (kmdb_wapt_t)); 22567c478bd9Sstevel@tonic-gate } 22577c478bd9Sstevel@tonic-gate 22587c478bd9Sstevel@tonic-gate static int 22597c478bd9Sstevel@tonic-gate kmt_add_wapt_common(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 22607c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data, int type) 22617c478bd9Sstevel@tonic-gate { 22627c478bd9Sstevel@tonic-gate kmdb_wapt_t *wp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP); 22637c478bd9Sstevel@tonic-gate mdb_sespec_t *sep; 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate wp->wp_addr = addr; 22667c478bd9Sstevel@tonic-gate wp->wp_size = len; 22677c478bd9Sstevel@tonic-gate wp->wp_type = type; 22687c478bd9Sstevel@tonic-gate wp->wp_wflags = wflags; 22697c478bd9Sstevel@tonic-gate 22707c478bd9Sstevel@tonic-gate if (kmdb_dpi_wapt_validate(wp) < 0) 22717c478bd9Sstevel@tonic-gate return (0); /* errno is set for us */ 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 22747c478bd9Sstevel@tonic-gate if (sep->se_ops == &kmt_wapt_ops && 22757c478bd9Sstevel@tonic-gate mdb_list_next(&sep->se_velist) != NULL && 22767c478bd9Sstevel@tonic-gate kmt_wparg_overlap(wp, sep->se_data)) 22777c478bd9Sstevel@tonic-gate goto wapt_dup; 22787c478bd9Sstevel@tonic-gate } 22797c478bd9Sstevel@tonic-gate 22807c478bd9Sstevel@tonic-gate for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) { 22817c478bd9Sstevel@tonic-gate if (sep->se_ops == &kmt_wapt_ops && kmt_wparg_overlap(wp, 22827c478bd9Sstevel@tonic-gate ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args)) 22837c478bd9Sstevel@tonic-gate goto wapt_dup; 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate return (mdb_tgt_vespec_insert(t, &kmt_wapt_ops, spec_flags, 22877c478bd9Sstevel@tonic-gate func, data, wp, kmt_wparg_dtor)); 22887c478bd9Sstevel@tonic-gate 22897c478bd9Sstevel@tonic-gate wapt_dup: 22907c478bd9Sstevel@tonic-gate mdb_free(wp, sizeof (kmdb_wapt_t)); 22917c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_WPDUP); 22927c478bd9Sstevel@tonic-gate return (0); 22937c478bd9Sstevel@tonic-gate } 22947c478bd9Sstevel@tonic-gate 22957c478bd9Sstevel@tonic-gate static int 22967c478bd9Sstevel@tonic-gate kmt_add_pwapt(mdb_tgt_t *t, physaddr_t addr, size_t len, uint_t wflags, 22977c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data) 22987c478bd9Sstevel@tonic-gate { 22997c478bd9Sstevel@tonic-gate return (kmt_add_wapt_common(t, (uintptr_t)addr, len, wflags, spec_flags, 23007c478bd9Sstevel@tonic-gate func, data, DPI_WAPT_TYPE_PHYS)); 23017c478bd9Sstevel@tonic-gate } 23027c478bd9Sstevel@tonic-gate 23037c478bd9Sstevel@tonic-gate static int 23047c478bd9Sstevel@tonic-gate kmt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 23057c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data) 23067c478bd9Sstevel@tonic-gate { 23077c478bd9Sstevel@tonic-gate return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func, 23087c478bd9Sstevel@tonic-gate data, DPI_WAPT_TYPE_VIRT)); 23097c478bd9Sstevel@tonic-gate } 23107c478bd9Sstevel@tonic-gate 23117c478bd9Sstevel@tonic-gate static int 23127c478bd9Sstevel@tonic-gate kmt_add_iowapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 23137c478bd9Sstevel@tonic-gate int spec_flags, mdb_tgt_se_f *func, void *data) 23147c478bd9Sstevel@tonic-gate { 23157c478bd9Sstevel@tonic-gate return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func, 23167c478bd9Sstevel@tonic-gate data, DPI_WAPT_TYPE_IO)); 23177c478bd9Sstevel@tonic-gate } 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate static int 23207c478bd9Sstevel@tonic-gate kmt_add_trap(mdb_tgt_t *t, int trapnum, int spec_flags, mdb_tgt_se_f *func, 23217c478bd9Sstevel@tonic-gate void *data) 23227c478bd9Sstevel@tonic-gate { 23237c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 23247c478bd9Sstevel@tonic-gate 23257c478bd9Sstevel@tonic-gate if (trapnum != KMT_TRAP_ALL && trapnum != KMT_TRAP_NOTENUM) { 23267c478bd9Sstevel@tonic-gate if (trapnum < 0 || trapnum > kmt->kmt_trapmax) { 23277c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_BADFLTNUM); 23287c478bd9Sstevel@tonic-gate return (0); 23297c478bd9Sstevel@tonic-gate } 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate BT_SET(kmt->kmt_trapmap, trapnum); 23327c478bd9Sstevel@tonic-gate } 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate return (mdb_tgt_vespec_insert(t, &kmt_trap_ops, spec_flags, func, data, 23357c478bd9Sstevel@tonic-gate (void *)(uintptr_t)trapnum, no_ve_dtor)); 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 23397c478bd9Sstevel@tonic-gate static uintmax_t 23407c478bd9Sstevel@tonic-gate kmt_cpuid_disc_get(const mdb_var_t *v) 23417c478bd9Sstevel@tonic-gate { 23427c478bd9Sstevel@tonic-gate return (kmdb_dpi_get_master_cpuid()); 23437c478bd9Sstevel@tonic-gate } 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate static const mdb_nv_disc_t kmt_cpuid_disc = { 23467c478bd9Sstevel@tonic-gate NULL, 23477c478bd9Sstevel@tonic-gate kmt_cpuid_disc_get 23487c478bd9Sstevel@tonic-gate }; 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate /* 23517c478bd9Sstevel@tonic-gate * This routine executes while the kernel is running. 23527c478bd9Sstevel@tonic-gate */ 23537c478bd9Sstevel@tonic-gate void 23547c478bd9Sstevel@tonic-gate kmt_activate(mdb_tgt_t *t) 23557c478bd9Sstevel@tonic-gate { 23567c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 23577c478bd9Sstevel@tonic-gate 23587c478bd9Sstevel@tonic-gate mdb_prop_postmortem = FALSE; 23597c478bd9Sstevel@tonic-gate mdb_prop_kernel = TRUE; 23607c478bd9Sstevel@tonic-gate 23617c478bd9Sstevel@tonic-gate (void) mdb_tgt_register_dcmds(t, &kmt_dcmds[0], MDB_MOD_FORCE); 23627c478bd9Sstevel@tonic-gate mdb_tgt_register_regvars(t, kmt->kmt_rds, &kmt_reg_disc, 0); 2363ae115bc7Smrj 2364ae115bc7Smrj /* 2365ae115bc7Smrj * Force load of the MDB krtld module, in case it's been rolled into 2366ae115bc7Smrj * unix. 2367ae115bc7Smrj */ 2368ae115bc7Smrj (void) mdb_module_load(KMT_RTLD_NAME, MDB_MOD_SILENT | MDB_MOD_DEFER); 23697c478bd9Sstevel@tonic-gate } 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate static void 23727c478bd9Sstevel@tonic-gate kmt_destroy(mdb_tgt_t *t) 23737c478bd9Sstevel@tonic-gate { 23747c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 23757c478bd9Sstevel@tonic-gate kmt_module_t *km, *pkm; 23767c478bd9Sstevel@tonic-gate 23777c478bd9Sstevel@tonic-gate mdb_nv_destroy(&kmt->kmt_modules); 23787c478bd9Sstevel@tonic-gate for (km = mdb_list_prev(&kmt->kmt_modlist); km != NULL; km = pkm) { 23797c478bd9Sstevel@tonic-gate pkm = mdb_list_prev(km); 23807c478bd9Sstevel@tonic-gate mdb_free(km, sizeof (kmt_module_t)); 23817c478bd9Sstevel@tonic-gate } 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate if (!kmt_defbp_lock) 23847c478bd9Sstevel@tonic-gate kmt_defbp_destroy_all(); 23857c478bd9Sstevel@tonic-gate 23867c478bd9Sstevel@tonic-gate if (kmt->kmt_trapmap != NULL) 23877c478bd9Sstevel@tonic-gate mdb_free(kmt->kmt_trapmap, BT_SIZEOFMAP(kmt->kmt_trapmax)); 23887c478bd9Sstevel@tonic-gate 23897c478bd9Sstevel@tonic-gate if (kmt->kmt_cpu != NULL) 23907c478bd9Sstevel@tonic-gate kmt_cpu_destroy(kmt->kmt_cpu); 23917c478bd9Sstevel@tonic-gate 23927c478bd9Sstevel@tonic-gate if (kmt != NULL) 23937c478bd9Sstevel@tonic-gate mdb_free(kmt, sizeof (kmt_data_t)); 23947c478bd9Sstevel@tonic-gate } 23957c478bd9Sstevel@tonic-gate 23967c478bd9Sstevel@tonic-gate static const mdb_tgt_ops_t kmt_ops = { 23977c478bd9Sstevel@tonic-gate kmt_setflags, /* t_setflags */ 23987c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_notsup, /* t_setcontext */ 23997c478bd9Sstevel@tonic-gate kmt_activate, /* t_activate */ 24007c478bd9Sstevel@tonic-gate (void (*)()) mdb_tgt_nop, /* t_deactivate */ 24017c478bd9Sstevel@tonic-gate kmt_periodic, /* t_periodic */ 24027c478bd9Sstevel@tonic-gate kmt_destroy, /* t_destroy */ 24037c478bd9Sstevel@tonic-gate kmt_name, /* t_name */ 24047c478bd9Sstevel@tonic-gate (const char *(*)()) mdb_conf_isa, /* t_isa */ 24057c478bd9Sstevel@tonic-gate kmt_platform, /* t_platform */ 24067c478bd9Sstevel@tonic-gate kmt_uname, /* t_uname */ 24077c478bd9Sstevel@tonic-gate kmt_dmodel, /* t_dmodel */ 24087c478bd9Sstevel@tonic-gate (ssize_t (*)()) mdb_tgt_notsup, /* t_aread */ 24097c478bd9Sstevel@tonic-gate (ssize_t (*)()) mdb_tgt_notsup, /* t_awrite */ 24107c478bd9Sstevel@tonic-gate kmt_read, /* t_vread */ 24117c478bd9Sstevel@tonic-gate kmt_write, /* t_vwrite */ 24127c478bd9Sstevel@tonic-gate kmt_pread, /* t_pread */ 24137c478bd9Sstevel@tonic-gate kmt_pwrite, /* t_pwrite */ 24147c478bd9Sstevel@tonic-gate kmt_read, /* t_fread */ 24157c478bd9Sstevel@tonic-gate kmt_write, /* t_fwrite */ 24167c478bd9Sstevel@tonic-gate kmt_ioread, /* t_ioread */ 24177c478bd9Sstevel@tonic-gate kmt_iowrite, /* t_iowrite */ 24187c478bd9Sstevel@tonic-gate kmt_vtop, /* t_vtop */ 24197c478bd9Sstevel@tonic-gate kmt_lookup_by_name, /* t_lookup_by_name */ 24207c478bd9Sstevel@tonic-gate kmt_lookup_by_addr, /* t_lookup_by_addr */ 24217c478bd9Sstevel@tonic-gate kmt_symbol_iter, /* t_symbol_iter */ 24227c478bd9Sstevel@tonic-gate kmt_mapping_iter, /* t_mapping_iter */ 24237c478bd9Sstevel@tonic-gate kmt_object_iter, /* t_object_iter */ 24247c478bd9Sstevel@tonic-gate kmt_addr_to_map, /* t_addr_to_map */ 24257c478bd9Sstevel@tonic-gate kmt_name_to_map, /* t_name_to_map */ 24267c478bd9Sstevel@tonic-gate kmt_addr_to_ctf, /* t_addr_to_ctf */ 24277c478bd9Sstevel@tonic-gate kmt_name_to_ctf, /* t_name_to_ctf */ 24287c478bd9Sstevel@tonic-gate kmt_status, /* t_status */ 24297c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_notsup, /* t_run */ 24307c478bd9Sstevel@tonic-gate kmt_step, /* t_step */ 24317c478bd9Sstevel@tonic-gate kmt_step_out, /* t_step_out */ 24327c478bd9Sstevel@tonic-gate kmt_step_branch, /* t_step_branch */ 24337c478bd9Sstevel@tonic-gate kmt_next, /* t_next */ 24347c478bd9Sstevel@tonic-gate kmt_continue, /* t_cont */ 24357c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_notsup, /* t_signal */ 24367c478bd9Sstevel@tonic-gate kmt_add_vbrkpt, /* t_add_vbrkpt */ 24377c478bd9Sstevel@tonic-gate kmt_add_sbrkpt, /* t_add_sbrkpt */ 24387c478bd9Sstevel@tonic-gate kmt_add_pwapt, /* t_add_pwapt */ 24397c478bd9Sstevel@tonic-gate kmt_add_vwapt, /* t_add_vwapt */ 24407c478bd9Sstevel@tonic-gate kmt_add_iowapt, /* t_add_iowapt */ 24417c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_null, /* t_add_sysenter */ 24427c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_null, /* t_add_sysexit */ 24437c478bd9Sstevel@tonic-gate (int (*)()) mdb_tgt_null, /* t_add_signal */ 24447c478bd9Sstevel@tonic-gate kmt_add_trap, /* t_add_fault */ 24457c478bd9Sstevel@tonic-gate kmt_getareg, /* t_getareg */ 24467c478bd9Sstevel@tonic-gate kmt_putareg, /* t_putareg */ 24477b9b3bf3Sedp (int (*)()) mdb_tgt_nop, /* XXX t_stack_iter */ 24487b9b3bf3Sedp (int (*)()) mdb_tgt_notsup /* t_auxv */ 24497c478bd9Sstevel@tonic-gate }; 24507c478bd9Sstevel@tonic-gate 24517c478bd9Sstevel@tonic-gate /* 24527c478bd9Sstevel@tonic-gate * Called immediately upon resumption of the system after a step or continue. 24537c478bd9Sstevel@tonic-gate * Allows us to synchronize kmt's view of the world with reality. 24547c478bd9Sstevel@tonic-gate */ 24557c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24567c478bd9Sstevel@tonic-gate static void 24577c478bd9Sstevel@tonic-gate kmt_sync(mdb_tgt_t *t) 24587c478bd9Sstevel@tonic-gate { 24597c478bd9Sstevel@tonic-gate kmt_data_t *kmt = t->t_data; 24607c478bd9Sstevel@tonic-gate int symavail; 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "synchronizing with kernel\n"); 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate symavail = kmt->kmt_symavail; 24657c478bd9Sstevel@tonic-gate kmt->kmt_symavail = FALSE; 24667c478bd9Sstevel@tonic-gate 24677c478bd9Sstevel@tonic-gate /* 24687c478bd9Sstevel@tonic-gate * Resync our view of the world if the modules have changed, or if we 24697c478bd9Sstevel@tonic-gate * didn't have any symbols coming into this function. The latter will 24707c478bd9Sstevel@tonic-gate * only happen on startup. 24717c478bd9Sstevel@tonic-gate */ 24727c478bd9Sstevel@tonic-gate if (kmdb_kdi_mods_changed() || !symavail) 24737c478bd9Sstevel@tonic-gate kmt_modlist_update(t); 24747c478bd9Sstevel@tonic-gate 24757c478bd9Sstevel@tonic-gate /* 24767c478bd9Sstevel@tonic-gate * It would be nice if we could run this less frequently, perhaps 24777c478bd9Sstevel@tonic-gate * after a dvec-initiated trigger. 24787c478bd9Sstevel@tonic-gate */ 24797c478bd9Sstevel@tonic-gate kmdb_module_sync(); 24807c478bd9Sstevel@tonic-gate 24817c478bd9Sstevel@tonic-gate kmt->kmt_symavail = TRUE; 24827c478bd9Sstevel@tonic-gate 24837c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "synchronization complete\n"); 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate kmt_defbp_prune(); 24867c478bd9Sstevel@tonic-gate 24877c478bd9Sstevel@tonic-gate if (kmt_defbp_num > 0 && kmt_defbp_bpspec == 0 && 24887c478bd9Sstevel@tonic-gate kmdb_kdi_dtrace_get_state() != KDI_DTSTATE_DTRACE_ACTIVE) { 24897c478bd9Sstevel@tonic-gate /* 24907c478bd9Sstevel@tonic-gate * Deferred breakpoints were created while DTrace was active, 24917c478bd9Sstevel@tonic-gate * and consequently the deferred breakpoint enabling mechanism 24927c478bd9Sstevel@tonic-gate * wasn't activated. Activate it now, and then try to activate 24937c478bd9Sstevel@tonic-gate * the deferred breakpoints. We do this so that we can catch 24947c478bd9Sstevel@tonic-gate * the ones which may apply to modules that have been loaded 24957c478bd9Sstevel@tonic-gate * while they were waiting for DTrace to deactivate. 24967c478bd9Sstevel@tonic-gate */ 24977c478bd9Sstevel@tonic-gate (void) kmt_defbp_activate(t); 24987c478bd9Sstevel@tonic-gate (void) mdb_tgt_sespec_activate_all(t); 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate if (kmt->kmt_cpu_retry && ((kmt->kmt_cpu = kmt_cpu_create(t)) != 25027c478bd9Sstevel@tonic-gate NULL || errno != EAGAIN)) 25037c478bd9Sstevel@tonic-gate kmt->kmt_cpu_retry = FALSE; 25047c478bd9Sstevel@tonic-gate 25057c478bd9Sstevel@tonic-gate (void) mdb_tgt_status(t, &t->t_status); 25067c478bd9Sstevel@tonic-gate } 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate /* 25097c478bd9Sstevel@tonic-gate * This routine executes while the kernel is running. 25107c478bd9Sstevel@tonic-gate */ 25117c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 25127c478bd9Sstevel@tonic-gate int 25137c478bd9Sstevel@tonic-gate kmdb_kvm_create(mdb_tgt_t *t, int argc, const char *argv[]) 25147c478bd9Sstevel@tonic-gate { 25157c478bd9Sstevel@tonic-gate kmt_data_t *kmt; 25167c478bd9Sstevel@tonic-gate 25177c478bd9Sstevel@tonic-gate if (argc != 0) 25187c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 25197c478bd9Sstevel@tonic-gate 25207c478bd9Sstevel@tonic-gate kmt = mdb_zalloc(sizeof (kmt_data_t), UM_SLEEP); 25217c478bd9Sstevel@tonic-gate t->t_data = kmt; 25227c478bd9Sstevel@tonic-gate t->t_ops = &kmt_ops; 25237c478bd9Sstevel@tonic-gate t->t_flags |= MDB_TGT_F_RDWR; /* kmdb is always r/w */ 25247c478bd9Sstevel@tonic-gate 25257c478bd9Sstevel@tonic-gate (void) mdb_nv_insert(&mdb.m_nv, "cpuid", &kmt_cpuid_disc, 0, 25267c478bd9Sstevel@tonic-gate MDB_NV_PERSIST | MDB_NV_RDONLY); 25277c478bd9Sstevel@tonic-gate 25287c478bd9Sstevel@tonic-gate (void) mdb_nv_create(&kmt->kmt_modules, UM_SLEEP); 25297c478bd9Sstevel@tonic-gate 25307c478bd9Sstevel@tonic-gate kmt_init_isadep(t); 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate kmt->kmt_symavail = FALSE; 25337c478bd9Sstevel@tonic-gate kmt->kmt_cpu_retry = TRUE; 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate bzero(&kmt_defbp_list, sizeof (mdb_list_t)); 25367c478bd9Sstevel@tonic-gate 25377c478bd9Sstevel@tonic-gate return (0); 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate create_err: 25407c478bd9Sstevel@tonic-gate kmt_destroy(t); 25417c478bd9Sstevel@tonic-gate 25427c478bd9Sstevel@tonic-gate return (-1); 25437c478bd9Sstevel@tonic-gate } 25447c478bd9Sstevel@tonic-gate 25457c478bd9Sstevel@tonic-gate /* 25467c478bd9Sstevel@tonic-gate * This routine is called once, when kmdb first has control of the world. 25477c478bd9Sstevel@tonic-gate */ 25487c478bd9Sstevel@tonic-gate void 25497c478bd9Sstevel@tonic-gate kmdb_kvm_startup(void) 25507c478bd9Sstevel@tonic-gate { 2551ae115bc7Smrj kmt_data_t *kmt = mdb.m_target->t_data; 2552ae115bc7Smrj 25537c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm startup\n"); 25547c478bd9Sstevel@tonic-gate 25557c478bd9Sstevel@tonic-gate kmt_sync(mdb.m_target); 25567c478bd9Sstevel@tonic-gate (void) mdb_module_load_builtin(KMT_MODULE); 25577c478bd9Sstevel@tonic-gate kmt_startup_isadep(mdb.m_target); 25587c478bd9Sstevel@tonic-gate 25597c478bd9Sstevel@tonic-gate /* 25607c478bd9Sstevel@tonic-gate * This is here because we need to write the deferred breakpoint 25617c478bd9Sstevel@tonic-gate * breakpoint when the debugger starts. Our normal r/o write routines 25627c478bd9Sstevel@tonic-gate * don't work when the kernel is running, so we have to do it during 25637c478bd9Sstevel@tonic-gate * startup. 25647c478bd9Sstevel@tonic-gate */ 25657c478bd9Sstevel@tonic-gate (void) mdb_tgt_sespec_activate_all(mdb.m_target); 2566ae115bc7Smrj 2567ae115bc7Smrj kmt->kmt_rtld_name = KMT_RTLD_NAME; 2568ae115bc7Smrj 2569ae115bc7Smrj if (kmt_module_by_name(kmt, KMT_RTLD_NAME) == NULL) 2570ae115bc7Smrj kmt->kmt_rtld_name = "unix"; 25717c478bd9Sstevel@tonic-gate } 25727c478bd9Sstevel@tonic-gate 25737c478bd9Sstevel@tonic-gate /* 25747c478bd9Sstevel@tonic-gate * This routine is called after kmdb has loaded its initial set of modules. 25757c478bd9Sstevel@tonic-gate */ 25767c478bd9Sstevel@tonic-gate void 25777c478bd9Sstevel@tonic-gate kmdb_kvm_poststartup(void) 25787c478bd9Sstevel@tonic-gate { 25797c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm post-startup\n"); 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate (void) mdb_dis_select(kmt_def_dismode()); 25827c478bd9Sstevel@tonic-gate } 2583