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
57b9b3bf3Sedp * Common Development and Distribution License (the "License").
67b9b3bf3Sedp * 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 /*
227b9b3bf3Sedp * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
237c478bd9Sstevel@tonic-gate * Use is subject to license terms.
24399ca3a7SJohn Levon *
25399ca3a7SJohn Levon * Copyright 2018 Joyent, Inc.
26a48fdbefSBryan Cantrill * Copyright 2024 Oxide Computer Company
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * Kernel Process View Target
317c478bd9Sstevel@tonic-gate *
327c478bd9Sstevel@tonic-gate * The kproc target is activated when the user is debugging a kernel using the
337c478bd9Sstevel@tonic-gate * kvm target and executes a ::context dcmd to change the debugger view to one
347c478bd9Sstevel@tonic-gate * of the running processes. The kvm target's t_setcontext operation will
357c478bd9Sstevel@tonic-gate * create and activate a kproc target in response to this call. The kproc
367c478bd9Sstevel@tonic-gate * target itself is built upon the kvm target's libkvm cookie and the ability
377c478bd9Sstevel@tonic-gate * to read information from the kernel itself and the ability to read the
387c478bd9Sstevel@tonic-gate * address space of a particular user process with kvm_aread(). It also relies
397c478bd9Sstevel@tonic-gate * on a special set of functions provided by the kvm target's mdb_ks support
407c478bd9Sstevel@tonic-gate * module in order to bootstrap: specifically, given the initial proc pointer,
417c478bd9Sstevel@tonic-gate * mdb_ks provides functions to return the set of address space mappings, the
427c478bd9Sstevel@tonic-gate * address space pointer itself, the aux vector vector saved in the u-area,
437c478bd9Sstevel@tonic-gate * and the process data model. The kproc target maintains a list of address
447c478bd9Sstevel@tonic-gate * space mappings (kp_map_t) and load objects (kp_file_t), and for each load
457c478bd9Sstevel@tonic-gate * object will attempt to read the corresponding dynamic symbol table. In
467c478bd9Sstevel@tonic-gate * order to bootstrap, the target uses the AT_BASE and AT_ENTRY aux vector
477c478bd9Sstevel@tonic-gate * elements to locate the dynamic linker and executable mappings. With these
487c478bd9Sstevel@tonic-gate * mappings in place, we initialize a librtld_db agent on the target (see
497c478bd9Sstevel@tonic-gate * mdb_pservice.c for how this is done), and then process each load object
507c478bd9Sstevel@tonic-gate * found in the link-map chain. In order to simplify the construction of
517c478bd9Sstevel@tonic-gate * symbol tables for each load object, we would like make use of our existing
527c478bd9Sstevel@tonic-gate * library of GElf processing code. Since the MDB GElf code uses mdb_io
537c478bd9Sstevel@tonic-gate * objects to read in an ELF file, we simply define a new type of mdb_io object
547c478bd9Sstevel@tonic-gate * where each read operation is translated into a call to kproc's t_vread
557c478bd9Sstevel@tonic-gate * function to read from the range of the address space defined by the mapping
567c478bd9Sstevel@tonic-gate * as if it were a file.
577c478bd9Sstevel@tonic-gate */
587c478bd9Sstevel@tonic-gate
597c478bd9Sstevel@tonic-gate #include <sys/types.h>
607c478bd9Sstevel@tonic-gate #include <sys/proc.h>
617c478bd9Sstevel@tonic-gate #include <sys/auxv.h>
627c478bd9Sstevel@tonic-gate
637c478bd9Sstevel@tonic-gate #include <strings.h>
647c478bd9Sstevel@tonic-gate #include <limits.h>
657c478bd9Sstevel@tonic-gate #include <rtld_db.h>
667c478bd9Sstevel@tonic-gate #include <procfs.h>
677c478bd9Sstevel@tonic-gate #include <dlfcn.h>
687c478bd9Sstevel@tonic-gate #include <kvm.h>
697c478bd9Sstevel@tonic-gate
707c478bd9Sstevel@tonic-gate #include <mdb/mdb_target_impl.h>
717c478bd9Sstevel@tonic-gate #include <mdb/mdb_debug.h>
727c478bd9Sstevel@tonic-gate #include <mdb/mdb_string.h>
737c478bd9Sstevel@tonic-gate #include <mdb/mdb_err.h>
747c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h>
757c478bd9Sstevel@tonic-gate #include <mdb/mdb_gelf.h>
767c478bd9Sstevel@tonic-gate #include <mdb/mdb_io_impl.h>
777c478bd9Sstevel@tonic-gate #include <mdb/mdb.h>
787c478bd9Sstevel@tonic-gate
797c478bd9Sstevel@tonic-gate typedef struct kp_symarg {
807c478bd9Sstevel@tonic-gate mdb_tgt_sym_f *sym_cb; /* Caller's callback function */
817c478bd9Sstevel@tonic-gate void *sym_data; /* Callback function argument */
827c478bd9Sstevel@tonic-gate uint_t sym_type; /* Symbol type/binding filter */
837c478bd9Sstevel@tonic-gate uintptr_t sym_adjust; /* Symbol value adjustment */
847c478bd9Sstevel@tonic-gate mdb_syminfo_t sym_info; /* Symbol id and table id */
857c478bd9Sstevel@tonic-gate const char *sym_obj; /* Containing object */
867c478bd9Sstevel@tonic-gate } kp_symarg_t;
877c478bd9Sstevel@tonic-gate
887c478bd9Sstevel@tonic-gate typedef struct kp_file {
897c478bd9Sstevel@tonic-gate mdb_gelf_file_t *kpf_file; /* ELF file object */
907c478bd9Sstevel@tonic-gate mdb_io_t *kpf_fio; /* ELF file back-end */
917c478bd9Sstevel@tonic-gate mdb_gelf_symtab_t *kpf_dynsym; /* Dynamic symbol table */
927c478bd9Sstevel@tonic-gate struct kp_map *kpf_map; /* Primary (text) mapping */
937c478bd9Sstevel@tonic-gate const char *kpf_basename; /* Mapping basename */
947c478bd9Sstevel@tonic-gate uintptr_t kpf_dyn_base; /* Load address for ET_DYN files */
957c478bd9Sstevel@tonic-gate uintptr_t kpf_text_base; /* Base address of text mapping */
967c478bd9Sstevel@tonic-gate uintptr_t kpf_data_base; /* Base address of data mapping */
977c478bd9Sstevel@tonic-gate struct kp_file *kpf_next; /* Pointer to next file */
987c478bd9Sstevel@tonic-gate } kp_file_t;
997c478bd9Sstevel@tonic-gate
1007c478bd9Sstevel@tonic-gate typedef struct kp_map {
1017c478bd9Sstevel@tonic-gate mdb_map_t kpm_map; /* Mapping information */
1027c478bd9Sstevel@tonic-gate kp_file_t *kpm_file; /* Pointer to load object */
1037c478bd9Sstevel@tonic-gate struct kp_map *kpm_next; /* Pointer to next mapping */
1047c478bd9Sstevel@tonic-gate } kp_map_t;
1057c478bd9Sstevel@tonic-gate
1067c478bd9Sstevel@tonic-gate typedef struct kp_io {
1077c478bd9Sstevel@tonic-gate mdb_tgt_t *kpi_tgt; /* Backpointer to kproc target */
1087c478bd9Sstevel@tonic-gate kp_map_t *kpi_map; /* Mapping for this i/o */
1097c478bd9Sstevel@tonic-gate uintptr_t kpi_ptr; /* Virtual address pointer */
1107c478bd9Sstevel@tonic-gate uintptr_t kpi_lim; /* Virtual address limit */
1117c478bd9Sstevel@tonic-gate } kp_io_t;
1127c478bd9Sstevel@tonic-gate
1137c478bd9Sstevel@tonic-gate typedef struct kp_data {
1147c478bd9Sstevel@tonic-gate mdb_tgt_t *kp_parent; /* Parent kvm target */
1157c478bd9Sstevel@tonic-gate kvm_t *kp_cookie; /* Cookie for libkvm routines */
1167c478bd9Sstevel@tonic-gate rd_agent_t *kp_rap; /* Cookie for librtld_db routines */
1177c478bd9Sstevel@tonic-gate proc_t *kp_proc; /* Proc address in dump */
1187c478bd9Sstevel@tonic-gate struct as *kp_as; /* Proc as address in dump */
1197c478bd9Sstevel@tonic-gate pid_t kp_pid; /* Process ID */
1207c478bd9Sstevel@tonic-gate auxv_t *kp_auxv; /* Auxv array from u-area */
1217c478bd9Sstevel@tonic-gate int kp_nauxv; /* Length of kp_auxv */
1227c478bd9Sstevel@tonic-gate const char *kp_platform; /* Platform string from kvm target */
1237c478bd9Sstevel@tonic-gate uint_t kp_model; /* Process data model */
1247c478bd9Sstevel@tonic-gate kp_file_t *kp_file_head; /* Head of load object list */
1257c478bd9Sstevel@tonic-gate kp_file_t *kp_file_tail; /* Tail of load object list */
1267c478bd9Sstevel@tonic-gate kp_map_t *kp_map_head; /* Head of mapping list */
1277c478bd9Sstevel@tonic-gate kp_map_t *kp_map_tail; /* Tail of mapping list */
1287c478bd9Sstevel@tonic-gate int kp_num_files; /* Length of load object list */
1297c478bd9Sstevel@tonic-gate int kp_num_maps; /* Length of mapping list */
1307c478bd9Sstevel@tonic-gate kp_map_t *kp_map_exec; /* Executable mapping */
1317c478bd9Sstevel@tonic-gate kp_map_t *kp_map_ldso; /* Interpreter mapping */
1327c478bd9Sstevel@tonic-gate kp_file_t kp_prfile; /* Fake file for mdb.m_prsym */
1337c478bd9Sstevel@tonic-gate } kp_data_t;
1347c478bd9Sstevel@tonic-gate
1357c478bd9Sstevel@tonic-gate static mdb_io_t *kp_io_create(mdb_tgt_t *, kp_map_t *);
1367c478bd9Sstevel@tonic-gate
1377c478bd9Sstevel@tonic-gate static kp_map_t *
kp_addr_to_kpmap(kp_data_t * kp,uintptr_t addr)1387c478bd9Sstevel@tonic-gate kp_addr_to_kpmap(kp_data_t *kp, uintptr_t addr)
1397c478bd9Sstevel@tonic-gate {
1407c478bd9Sstevel@tonic-gate kp_map_t *kpm;
1417c478bd9Sstevel@tonic-gate
1427c478bd9Sstevel@tonic-gate for (kpm = kp->kp_map_head; kpm != NULL; kpm = kpm->kpm_next) {
1437c478bd9Sstevel@tonic-gate if (addr >= kpm->kpm_map.map_base &&
1447c478bd9Sstevel@tonic-gate addr < kpm->kpm_map.map_base + kpm->kpm_map.map_size)
1457c478bd9Sstevel@tonic-gate return (kpm);
1467c478bd9Sstevel@tonic-gate }
1477c478bd9Sstevel@tonic-gate
1487c478bd9Sstevel@tonic-gate return (NULL);
1497c478bd9Sstevel@tonic-gate }
1507c478bd9Sstevel@tonic-gate
1517c478bd9Sstevel@tonic-gate static long
kp_getauxval(kp_data_t * kp,int type)1527c478bd9Sstevel@tonic-gate kp_getauxval(kp_data_t *kp, int type)
1537c478bd9Sstevel@tonic-gate {
1547c478bd9Sstevel@tonic-gate auxv_t *auxp;
1557c478bd9Sstevel@tonic-gate
1567c478bd9Sstevel@tonic-gate for (auxp = kp->kp_auxv; auxp->a_type != AT_NULL; auxp++) {
1577c478bd9Sstevel@tonic-gate if (auxp->a_type == type)
1587c478bd9Sstevel@tonic-gate return (auxp->a_un.a_val);
1597c478bd9Sstevel@tonic-gate }
1607c478bd9Sstevel@tonic-gate
1617c478bd9Sstevel@tonic-gate return (-1L);
1627c478bd9Sstevel@tonic-gate }
1637c478bd9Sstevel@tonic-gate
1647c478bd9Sstevel@tonic-gate static void
kp_add_mapping(const mdb_map_t * pmp,void * data)1657c478bd9Sstevel@tonic-gate kp_add_mapping(const mdb_map_t *pmp, void *data)
1667c478bd9Sstevel@tonic-gate {
1677c478bd9Sstevel@tonic-gate kp_map_t *kpm = mdb_zalloc(sizeof (kp_map_t), UM_SLEEP);
1687c478bd9Sstevel@tonic-gate kp_data_t *kp = data;
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate bcopy(pmp, &kpm->kpm_map, sizeof (mdb_map_t));
1717c478bd9Sstevel@tonic-gate
1727c478bd9Sstevel@tonic-gate if (kp->kp_map_tail != NULL)
1737c478bd9Sstevel@tonic-gate kp->kp_map_tail->kpm_next = kpm;
1747c478bd9Sstevel@tonic-gate else
1757c478bd9Sstevel@tonic-gate kp->kp_map_head = kpm;
1767c478bd9Sstevel@tonic-gate
1777c478bd9Sstevel@tonic-gate kp->kp_map_tail = kpm;
1787c478bd9Sstevel@tonic-gate kp->kp_num_maps++;
1797c478bd9Sstevel@tonic-gate }
1807c478bd9Sstevel@tonic-gate
1817c478bd9Sstevel@tonic-gate static kp_file_t *
kp_file_create(mdb_tgt_t * t,kp_map_t * kpm,GElf_Half etype)1827c478bd9Sstevel@tonic-gate kp_file_create(mdb_tgt_t *t, kp_map_t *kpm, GElf_Half etype)
1837c478bd9Sstevel@tonic-gate {
1847c478bd9Sstevel@tonic-gate kp_file_t *kpf = mdb_zalloc(sizeof (kp_file_t), UM_SLEEP);
1857c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
18622872efbSedp size_t dyns_sz;
18722872efbSedp void *dyns;
1887c478bd9Sstevel@tonic-gate
1897c478bd9Sstevel@tonic-gate kpf->kpf_fio = kp_io_create(t, kpm);
1907c478bd9Sstevel@tonic-gate kpf->kpf_map = kpm;
1917c478bd9Sstevel@tonic-gate kpf->kpf_basename = strbasename(kpm->kpm_map.map_name);
1927c478bd9Sstevel@tonic-gate kpf->kpf_file = mdb_gelf_create(kpf->kpf_fio, etype, GF_PROGRAM);
1937c478bd9Sstevel@tonic-gate kpf->kpf_text_base = kpm->kpm_map.map_base;
1947c478bd9Sstevel@tonic-gate
1957c478bd9Sstevel@tonic-gate if (kpm != kp->kp_map_exec)
1967c478bd9Sstevel@tonic-gate kpf->kpf_dyn_base = kpf->kpf_text_base;
1977c478bd9Sstevel@tonic-gate
1987c478bd9Sstevel@tonic-gate if (kpf->kpf_file == NULL)
1997c478bd9Sstevel@tonic-gate goto err; /* Failed to create ELF file */
2007c478bd9Sstevel@tonic-gate
2017c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_TGT, "loading symbols for %s\n",
2027c478bd9Sstevel@tonic-gate kpm->kpm_map.map_name);
2037c478bd9Sstevel@tonic-gate
20422872efbSedp if ((kp->kp_rap != NULL) && (rd_get_dyns(kp->kp_rap,
20522872efbSedp kpf->kpf_text_base, &dyns, &dyns_sz) == RD_OK))
20622872efbSedp mdb_gelf_dyns_set(kpf->kpf_file, dyns, dyns_sz);
20722872efbSedp
2087c478bd9Sstevel@tonic-gate kpf->kpf_dynsym = mdb_gelf_symtab_create_dynamic(kpf->kpf_file,
2097c478bd9Sstevel@tonic-gate MDB_TGT_DYNSYM);
2107c478bd9Sstevel@tonic-gate
2117c478bd9Sstevel@tonic-gate if (kpf->kpf_dynsym == NULL)
2127c478bd9Sstevel@tonic-gate goto err; /* Failed to create symbol table */
2137c478bd9Sstevel@tonic-gate
2147c478bd9Sstevel@tonic-gate kpm->kpm_file = kpf;
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate if (kp->kp_file_tail != NULL)
2177c478bd9Sstevel@tonic-gate kp->kp_file_tail->kpf_next = kpf;
2187c478bd9Sstevel@tonic-gate else
2197c478bd9Sstevel@tonic-gate kp->kp_file_head = kpf;
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate kp->kp_file_tail = kpf;
2227c478bd9Sstevel@tonic-gate kp->kp_num_files++;
2237c478bd9Sstevel@tonic-gate
2247c478bd9Sstevel@tonic-gate return (kpf);
2257c478bd9Sstevel@tonic-gate
2267c478bd9Sstevel@tonic-gate err:
2277c478bd9Sstevel@tonic-gate if (kpf->kpf_file != NULL)
2287c478bd9Sstevel@tonic-gate mdb_gelf_destroy(kpf->kpf_file);
2297c478bd9Sstevel@tonic-gate else
2307c478bd9Sstevel@tonic-gate mdb_io_destroy(kpf->kpf_fio);
2317c478bd9Sstevel@tonic-gate mdb_free(kpf, sizeof (kp_file_t));
2327c478bd9Sstevel@tonic-gate return (NULL);
2337c478bd9Sstevel@tonic-gate }
2347c478bd9Sstevel@tonic-gate
2357c478bd9Sstevel@tonic-gate static void
kp_file_destroy(kp_file_t * kpf)2367c478bd9Sstevel@tonic-gate kp_file_destroy(kp_file_t *kpf)
2377c478bd9Sstevel@tonic-gate {
2387c478bd9Sstevel@tonic-gate if (kpf->kpf_dynsym != NULL)
2397c478bd9Sstevel@tonic-gate mdb_gelf_symtab_destroy(kpf->kpf_dynsym);
2407c478bd9Sstevel@tonic-gate
2417c478bd9Sstevel@tonic-gate mdb_gelf_destroy(kpf->kpf_file);
2427c478bd9Sstevel@tonic-gate mdb_free(kpf, sizeof (kp_file_t));
2437c478bd9Sstevel@tonic-gate }
2447c478bd9Sstevel@tonic-gate
2457c478bd9Sstevel@tonic-gate static int
kp_setcontext(mdb_tgt_t * t,void * context)2467c478bd9Sstevel@tonic-gate kp_setcontext(mdb_tgt_t *t, void *context)
2477c478bd9Sstevel@tonic-gate {
2487c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
2497c478bd9Sstevel@tonic-gate
2507c478bd9Sstevel@tonic-gate if (kp->kp_proc != context) {
2517c478bd9Sstevel@tonic-gate mdb_tgt_destroy(t);
2527c478bd9Sstevel@tonic-gate return (mdb_tgt_setcontext(mdb.m_target, context));
2537c478bd9Sstevel@tonic-gate }
2547c478bd9Sstevel@tonic-gate
2557c478bd9Sstevel@tonic-gate mdb_warn("debugger context is already set to proc %p\n", context);
2567c478bd9Sstevel@tonic-gate return (0);
2577c478bd9Sstevel@tonic-gate }
2587c478bd9Sstevel@tonic-gate
2597c478bd9Sstevel@tonic-gate static kp_map_t *
kp_find_data(kp_data_t * kp,kp_file_t * kpf,const rd_loadobj_t * rlp)2607c478bd9Sstevel@tonic-gate kp_find_data(kp_data_t *kp, kp_file_t *kpf, const rd_loadobj_t *rlp)
2617c478bd9Sstevel@tonic-gate {
2627c478bd9Sstevel@tonic-gate GElf_Phdr *gpp = kpf->kpf_file->gf_phdrs;
2637c478bd9Sstevel@tonic-gate size_t i, n = kpf->kpf_file->gf_npload;
2647c478bd9Sstevel@tonic-gate
2657c478bd9Sstevel@tonic-gate /*
2667c478bd9Sstevel@tonic-gate * Find the first loadable, writeable Phdr and compute kpf_data_base
2677c478bd9Sstevel@tonic-gate * as the virtual address at which is was loaded.
2687c478bd9Sstevel@tonic-gate */
2697c478bd9Sstevel@tonic-gate for (i = 0; i < n; i++, gpp++) {
2707c478bd9Sstevel@tonic-gate if (gpp->p_type == PT_LOAD && (gpp->p_flags & PF_W)) {
2717c478bd9Sstevel@tonic-gate kpf->kpf_data_base = gpp->p_vaddr;
2727c478bd9Sstevel@tonic-gate if (kpf->kpf_map != kp->kp_map_exec)
2737c478bd9Sstevel@tonic-gate kpf->kpf_data_base += rlp->rl_base;
2747c478bd9Sstevel@tonic-gate break;
2757c478bd9Sstevel@tonic-gate }
2767c478bd9Sstevel@tonic-gate }
2777c478bd9Sstevel@tonic-gate
2787c478bd9Sstevel@tonic-gate /*
2797c478bd9Sstevel@tonic-gate * If we found a suitable Phdr and set kpf_data_base, return
2807c478bd9Sstevel@tonic-gate * the mapping information for this address; otherwise fail.
2817c478bd9Sstevel@tonic-gate */
2827c478bd9Sstevel@tonic-gate if (kpf->kpf_data_base != 0)
2837c478bd9Sstevel@tonic-gate return (kp_addr_to_kpmap(kp, kpf->kpf_data_base));
2847c478bd9Sstevel@tonic-gate
2857c478bd9Sstevel@tonic-gate return (NULL);
2867c478bd9Sstevel@tonic-gate }
2877c478bd9Sstevel@tonic-gate
2887c478bd9Sstevel@tonic-gate static int
kp_iter_mapping(const rd_loadobj_t * rlp,mdb_tgt_t * t)2897c478bd9Sstevel@tonic-gate kp_iter_mapping(const rd_loadobj_t *rlp, mdb_tgt_t *t)
2907c478bd9Sstevel@tonic-gate {
2917c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
2927c478bd9Sstevel@tonic-gate kp_file_t *kpf;
2937c478bd9Sstevel@tonic-gate kp_map_t *kpm;
2947c478bd9Sstevel@tonic-gate
2957c478bd9Sstevel@tonic-gate char name[MDB_TGT_MAPSZ];
2967c478bd9Sstevel@tonic-gate
2977c478bd9Sstevel@tonic-gate if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name,
2987c478bd9Sstevel@tonic-gate sizeof (name), (mdb_tgt_addr_t)rlp->rl_nameaddr) <= 0) {
2997c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_TGT, "failed to read name %p",
3007c478bd9Sstevel@tonic-gate (void *)rlp->rl_nameaddr);
3017c478bd9Sstevel@tonic-gate return (1); /* Keep going; forget this if we can't read name */
3027c478bd9Sstevel@tonic-gate }
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_TGT, "rd_loadobj name = \"%s\" rl_base = %p\n",
3057c478bd9Sstevel@tonic-gate name, (void *)rlp->rl_base);
3067c478bd9Sstevel@tonic-gate
3077c478bd9Sstevel@tonic-gate if ((kpm = kp_addr_to_kpmap(kp, rlp->rl_base)) == NULL)
3087c478bd9Sstevel@tonic-gate return (1); /* Keep going; no mapping at this address */
3097c478bd9Sstevel@tonic-gate
3107c478bd9Sstevel@tonic-gate (void) strncpy(kpm->kpm_map.map_name, name, MDB_TGT_MAPSZ);
3117c478bd9Sstevel@tonic-gate kpm->kpm_map.map_name[MDB_TGT_MAPSZ - 1] = '\0';
3127c478bd9Sstevel@tonic-gate
3137c478bd9Sstevel@tonic-gate if ((kpf = kpm->kpm_file) == NULL) {
3147c478bd9Sstevel@tonic-gate if (kpm == kp->kp_map_exec)
3157c478bd9Sstevel@tonic-gate kpf = kp_file_create(t, kpm, ET_EXEC);
3167c478bd9Sstevel@tonic-gate else
3177c478bd9Sstevel@tonic-gate kpf = kp_file_create(t, kpm, ET_DYN);
3187c478bd9Sstevel@tonic-gate
3197c478bd9Sstevel@tonic-gate if (kpf == NULL)
3207c478bd9Sstevel@tonic-gate return (1); /* Keep going; failed to build ELF file */
3217c478bd9Sstevel@tonic-gate } else
3227c478bd9Sstevel@tonic-gate kpf->kpf_basename = strbasename(kpm->kpm_map.map_name);
3237c478bd9Sstevel@tonic-gate
3247c478bd9Sstevel@tonic-gate if ((kpm = kp_find_data(kp, kpf, rlp)) != NULL) {
3257c478bd9Sstevel@tonic-gate mdb_dprintf(MDB_DBG_TGT, "found data for %s at %p\n",
3267c478bd9Sstevel@tonic-gate kpf->kpf_basename, (void *)kpm->kpm_map.map_base);
3277c478bd9Sstevel@tonic-gate kpm->kpm_file = kpf;
3287c478bd9Sstevel@tonic-gate }
3297c478bd9Sstevel@tonic-gate
3307c478bd9Sstevel@tonic-gate return (1);
3317c478bd9Sstevel@tonic-gate }
3327c478bd9Sstevel@tonic-gate
3337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
3347c478bd9Sstevel@tonic-gate static int
kp_status_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3357c478bd9Sstevel@tonic-gate kp_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3367c478bd9Sstevel@tonic-gate {
3377c478bd9Sstevel@tonic-gate kp_data_t *kp = mdb.m_target->t_data;
3387c478bd9Sstevel@tonic-gate
3397c478bd9Sstevel@tonic-gate mdb_printf("debugging PID %d (%d-bit) in kernel crash dump\n",
3407c478bd9Sstevel@tonic-gate kp->kp_pid, kp->kp_model == PR_MODEL_ILP32 ? 32 : 64);
3417c478bd9Sstevel@tonic-gate
3427c478bd9Sstevel@tonic-gate if (kp->kp_map_exec != NULL) {
3437c478bd9Sstevel@tonic-gate mdb_printf("executable file: %s\n",
3447c478bd9Sstevel@tonic-gate kp->kp_map_exec->kpm_map.map_name);
3457c478bd9Sstevel@tonic-gate }
3467c478bd9Sstevel@tonic-gate
3477c478bd9Sstevel@tonic-gate return (DCMD_OK);
3487c478bd9Sstevel@tonic-gate }
3497c478bd9Sstevel@tonic-gate
3507c478bd9Sstevel@tonic-gate static const mdb_dcmd_t kp_dcmds[] = {
3517c478bd9Sstevel@tonic-gate { "status", NULL, "print summary of current target", kp_status_dcmd },
3527c478bd9Sstevel@tonic-gate { NULL }
3537c478bd9Sstevel@tonic-gate };
3547c478bd9Sstevel@tonic-gate
3557c478bd9Sstevel@tonic-gate static void
kp_activate(mdb_tgt_t * t)3567c478bd9Sstevel@tonic-gate kp_activate(mdb_tgt_t *t)
3577c478bd9Sstevel@tonic-gate {
3587c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
3597c478bd9Sstevel@tonic-gate
3607c478bd9Sstevel@tonic-gate mdb_prop_postmortem = TRUE;
3617c478bd9Sstevel@tonic-gate mdb_prop_kernel = FALSE;
3627c478bd9Sstevel@tonic-gate
3637c478bd9Sstevel@tonic-gate if (kp->kp_model == PR_MODEL_ILP32)
3647c478bd9Sstevel@tonic-gate mdb_prop_datamodel = MDB_TGT_MODEL_ILP32;
3657c478bd9Sstevel@tonic-gate else
3667c478bd9Sstevel@tonic-gate mdb_prop_datamodel = MDB_TGT_MODEL_LP64;
3677c478bd9Sstevel@tonic-gate
3687c478bd9Sstevel@tonic-gate /*
3697c478bd9Sstevel@tonic-gate * Initialize our rtld_db agent and then iterate over the link map,
3707c478bd9Sstevel@tonic-gate * instantiating kp_file objects as we go.
3717c478bd9Sstevel@tonic-gate */
3727c478bd9Sstevel@tonic-gate if ((kp->kp_rap = rd_new((struct ps_prochandle *)t)) != NULL) {
3737c478bd9Sstevel@tonic-gate (void) rd_loadobj_iter(kp->kp_rap, (rl_iter_f *)
3747c478bd9Sstevel@tonic-gate kp_iter_mapping, t);
3757c478bd9Sstevel@tonic-gate } else {
3767c478bd9Sstevel@tonic-gate mdb_warn("unable to initialize rtld_db agent for proc %p\n",
3777c478bd9Sstevel@tonic-gate (void *)kp->kp_proc);
3787c478bd9Sstevel@tonic-gate }
3797c478bd9Sstevel@tonic-gate
3807c478bd9Sstevel@tonic-gate (void) mdb_tgt_register_dcmds(t, &kp_dcmds[0], MDB_MOD_FORCE);
3817c478bd9Sstevel@tonic-gate
3827c478bd9Sstevel@tonic-gate if (kp->kp_map_exec != NULL && kp->kp_map_exec->kpm_file != NULL)
3837c478bd9Sstevel@tonic-gate mdb_tgt_elf_export(kp->kp_map_exec->kpm_file->kpf_file);
3847c478bd9Sstevel@tonic-gate else
3857c478bd9Sstevel@tonic-gate mdb_tgt_elf_export(NULL);
3867c478bd9Sstevel@tonic-gate }
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate static void
kp_deactivate(mdb_tgt_t * t)3897c478bd9Sstevel@tonic-gate kp_deactivate(mdb_tgt_t *t)
3907c478bd9Sstevel@tonic-gate {
3917c478bd9Sstevel@tonic-gate const mdb_dcmd_t *dcp;
3927c478bd9Sstevel@tonic-gate
3937c478bd9Sstevel@tonic-gate for (dcp = &kp_dcmds[0]; dcp->dc_name != NULL; dcp++) {
3947c478bd9Sstevel@tonic-gate if (mdb_module_remove_dcmd(t->t_module, dcp->dc_name) == -1)
3957c478bd9Sstevel@tonic-gate warn("failed to remove dcmd %s", dcp->dc_name);
3967c478bd9Sstevel@tonic-gate }
3977c478bd9Sstevel@tonic-gate
3987c478bd9Sstevel@tonic-gate mdb_prop_postmortem = FALSE;
3997c478bd9Sstevel@tonic-gate mdb_prop_kernel = FALSE;
4007c478bd9Sstevel@tonic-gate mdb_prop_datamodel = MDB_TGT_MODEL_UNKNOWN;
4017c478bd9Sstevel@tonic-gate }
4027c478bd9Sstevel@tonic-gate
4037c478bd9Sstevel@tonic-gate static void
kp_destroy(mdb_tgt_t * t)4047c478bd9Sstevel@tonic-gate kp_destroy(mdb_tgt_t *t)
4057c478bd9Sstevel@tonic-gate {
4067c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
4077c478bd9Sstevel@tonic-gate kp_map_t *kpm, *nkpm;
4087c478bd9Sstevel@tonic-gate kp_file_t *kpf, *nkpf;
4097c478bd9Sstevel@tonic-gate
4107c478bd9Sstevel@tonic-gate if (kp->kp_rap != NULL)
4117c478bd9Sstevel@tonic-gate rd_delete(kp->kp_rap);
4127c478bd9Sstevel@tonic-gate
4137c478bd9Sstevel@tonic-gate for (kpm = kp->kp_map_head; kpm != NULL; kpm = nkpm) {
4147c478bd9Sstevel@tonic-gate nkpm = kpm->kpm_next;
4157c478bd9Sstevel@tonic-gate mdb_free(kpm, sizeof (kp_map_t));
4167c478bd9Sstevel@tonic-gate }
4177c478bd9Sstevel@tonic-gate
4187c478bd9Sstevel@tonic-gate for (kpf = kp->kp_file_head; kpf != NULL; kpf = nkpf) {
4197c478bd9Sstevel@tonic-gate nkpf = kpf->kpf_next;
4207c478bd9Sstevel@tonic-gate kp_file_destroy(kpf);
4217c478bd9Sstevel@tonic-gate }
4227c478bd9Sstevel@tonic-gate
4237c478bd9Sstevel@tonic-gate mdb_free(kp->kp_auxv, kp->kp_nauxv * sizeof (auxv_t));
4247c478bd9Sstevel@tonic-gate mdb_free(kp, sizeof (kp_data_t));
4257c478bd9Sstevel@tonic-gate }
4267c478bd9Sstevel@tonic-gate
4277c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4287c478bd9Sstevel@tonic-gate static const char *
kp_name(mdb_tgt_t * t)4297c478bd9Sstevel@tonic-gate kp_name(mdb_tgt_t *t)
4307c478bd9Sstevel@tonic-gate {
4317c478bd9Sstevel@tonic-gate return ("kproc");
4327c478bd9Sstevel@tonic-gate }
4337c478bd9Sstevel@tonic-gate
4347c478bd9Sstevel@tonic-gate static const char *
kp_isa(mdb_tgt_t * t)4357c478bd9Sstevel@tonic-gate kp_isa(mdb_tgt_t *t)
4367c478bd9Sstevel@tonic-gate {
4377c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
4387c478bd9Sstevel@tonic-gate #ifdef __sparc
4397c478bd9Sstevel@tonic-gate return (kp->kp_model == PR_MODEL_ILP32 ? "sparc" : "sparcv9");
4407c478bd9Sstevel@tonic-gate #else
4417c478bd9Sstevel@tonic-gate return (kp->kp_model == PR_MODEL_ILP32 ? "i386" : "amd64");
4427c478bd9Sstevel@tonic-gate #endif
4437c478bd9Sstevel@tonic-gate }
4447c478bd9Sstevel@tonic-gate
4457c478bd9Sstevel@tonic-gate static const char *
kp_platform(mdb_tgt_t * t)4467c478bd9Sstevel@tonic-gate kp_platform(mdb_tgt_t *t)
4477c478bd9Sstevel@tonic-gate {
4487c478bd9Sstevel@tonic-gate return (((kp_data_t *)t->t_data)->kp_platform);
4497c478bd9Sstevel@tonic-gate }
4507c478bd9Sstevel@tonic-gate
4517c478bd9Sstevel@tonic-gate static int
kp_uname(mdb_tgt_t * t,struct utsname * utsp)4527c478bd9Sstevel@tonic-gate kp_uname(mdb_tgt_t *t, struct utsname *utsp)
4537c478bd9Sstevel@tonic-gate {
4547c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
4557c478bd9Sstevel@tonic-gate return (mdb_tgt_uname(kp->kp_parent, utsp));
4567c478bd9Sstevel@tonic-gate }
4577c478bd9Sstevel@tonic-gate
4587c478bd9Sstevel@tonic-gate static int
kp_dmodel(mdb_tgt_t * t)4597c478bd9Sstevel@tonic-gate kp_dmodel(mdb_tgt_t *t)
4607c478bd9Sstevel@tonic-gate {
4617c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
4627c478bd9Sstevel@tonic-gate
4637c478bd9Sstevel@tonic-gate switch (kp->kp_model) {
4647c478bd9Sstevel@tonic-gate case PR_MODEL_ILP32:
4657c478bd9Sstevel@tonic-gate return (MDB_TGT_MODEL_ILP32);
4667c478bd9Sstevel@tonic-gate case PR_MODEL_LP64:
4677c478bd9Sstevel@tonic-gate return (MDB_TGT_MODEL_LP64);
4687c478bd9Sstevel@tonic-gate }
4697c478bd9Sstevel@tonic-gate
4707c478bd9Sstevel@tonic-gate return (MDB_TGT_MODEL_UNKNOWN);
4717c478bd9Sstevel@tonic-gate }
4727c478bd9Sstevel@tonic-gate
4737c478bd9Sstevel@tonic-gate static kp_map_t *
kp_name_to_kpmap(kp_data_t * kp,const char * name)4747c478bd9Sstevel@tonic-gate kp_name_to_kpmap(kp_data_t *kp, const char *name)
4757c478bd9Sstevel@tonic-gate {
4767c478bd9Sstevel@tonic-gate size_t namelen;
4777c478bd9Sstevel@tonic-gate kp_file_t *kpf;
4787c478bd9Sstevel@tonic-gate kp_map_t *kpm;
4797c478bd9Sstevel@tonic-gate
4807c478bd9Sstevel@tonic-gate /*
4817c478bd9Sstevel@tonic-gate * Handle special reserved names (except for MDB_TGT_OBJ_EVERY):
4827c478bd9Sstevel@tonic-gate */
4837c478bd9Sstevel@tonic-gate if (name == MDB_TGT_OBJ_EXEC)
4847c478bd9Sstevel@tonic-gate return (kp->kp_map_exec);
4857c478bd9Sstevel@tonic-gate
4867c478bd9Sstevel@tonic-gate if (name == MDB_TGT_OBJ_RTLD)
4877c478bd9Sstevel@tonic-gate return (kp->kp_map_ldso);
4887c478bd9Sstevel@tonic-gate
4897c478bd9Sstevel@tonic-gate /*
4907c478bd9Sstevel@tonic-gate * First pass: look for exact matches on the entire pathname
4917c478bd9Sstevel@tonic-gate * associated with the mapping or its basename.
4927c478bd9Sstevel@tonic-gate */
4937c478bd9Sstevel@tonic-gate for (kpm = kp->kp_map_head; kpm != NULL; kpm = kpm->kpm_next) {
4947c478bd9Sstevel@tonic-gate if ((kpf = kpm->kpm_file) != NULL) {
4957c478bd9Sstevel@tonic-gate if (strcmp(kpm->kpm_map.map_name, name) == 0 ||
4967c478bd9Sstevel@tonic-gate strcmp(kpf->kpf_basename, name) == 0)
4977c478bd9Sstevel@tonic-gate return (kpf->kpf_map);
4987c478bd9Sstevel@tonic-gate }
4997c478bd9Sstevel@tonic-gate }
5007c478bd9Sstevel@tonic-gate
5017c478bd9Sstevel@tonic-gate namelen = strlen(name);
5027c478bd9Sstevel@tonic-gate
5037c478bd9Sstevel@tonic-gate /*
5047c478bd9Sstevel@tonic-gate * Second pass: look for partial matches (initial basename match
5057c478bd9Sstevel@tonic-gate * up to a '.' suffix); allows "libc.so" or "libc" to match "libc.so.1"
5067c478bd9Sstevel@tonic-gate */
5077c478bd9Sstevel@tonic-gate for (kpm = kp->kp_map_head; kpm != NULL; kpm = kpm->kpm_next) {
5087c478bd9Sstevel@tonic-gate if ((kpf = kpm->kpm_file) != NULL) {
5097c478bd9Sstevel@tonic-gate if (strncmp(kpf->kpf_basename, name, namelen) == 0 &&
5107c478bd9Sstevel@tonic-gate kpf->kpf_basename[namelen] == '.')
5117c478bd9Sstevel@tonic-gate return (kpf->kpf_map);
5127c478bd9Sstevel@tonic-gate }
5137c478bd9Sstevel@tonic-gate }
5147c478bd9Sstevel@tonic-gate
5157c478bd9Sstevel@tonic-gate /*
5167c478bd9Sstevel@tonic-gate * One last check: we allow "a.out" to always alias the executable,
5177c478bd9Sstevel@tonic-gate * assuming this name was not in use for something else.
5187c478bd9Sstevel@tonic-gate */
5197c478bd9Sstevel@tonic-gate if (strcmp(name, "a.out") == 0)
5207c478bd9Sstevel@tonic-gate return (kp->kp_map_exec);
5217c478bd9Sstevel@tonic-gate
5227c478bd9Sstevel@tonic-gate return (NULL);
5237c478bd9Sstevel@tonic-gate }
5247c478bd9Sstevel@tonic-gate
5257c478bd9Sstevel@tonic-gate
5267c478bd9Sstevel@tonic-gate static ssize_t
kp_vread(mdb_tgt_t * t,void * buf,size_t nbytes,uintptr_t addr)5277c478bd9Sstevel@tonic-gate kp_vread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
5287c478bd9Sstevel@tonic-gate {
5297c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
5307c478bd9Sstevel@tonic-gate ssize_t n = kvm_aread(kp->kp_cookie, addr, buf, nbytes, kp->kp_as);
5317c478bd9Sstevel@tonic-gate
5327c478bd9Sstevel@tonic-gate if (n == -1)
5337c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOMAP));
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate return (n);
5367c478bd9Sstevel@tonic-gate }
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate static ssize_t
kp_vwrite(mdb_tgt_t * t,const void * buf,size_t nbytes,uintptr_t addr)5397c478bd9Sstevel@tonic-gate kp_vwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
5407c478bd9Sstevel@tonic-gate {
5417c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
5427c478bd9Sstevel@tonic-gate ssize_t n = kvm_awrite(kp->kp_cookie, addr, buf, nbytes, kp->kp_as);
5437c478bd9Sstevel@tonic-gate
5447c478bd9Sstevel@tonic-gate if (n == -1)
5457c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOMAP));
5467c478bd9Sstevel@tonic-gate
5477c478bd9Sstevel@tonic-gate return (n);
5487c478bd9Sstevel@tonic-gate }
5497c478bd9Sstevel@tonic-gate
5507c478bd9Sstevel@tonic-gate
5517c478bd9Sstevel@tonic-gate int
kp_vtop(mdb_tgt_t * t,mdb_tgt_as_t as,uintptr_t va,physaddr_t * pap)5527c478bd9Sstevel@tonic-gate kp_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
5537c478bd9Sstevel@tonic-gate {
5547c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
5557c478bd9Sstevel@tonic-gate physaddr_t pa;
5567c478bd9Sstevel@tonic-gate
5579c3024a3SHans Rosenfeld if (as != MDB_TGT_AS_VIRT && as != MDB_TGT_AS_VIRT_I &&
5589c3024a3SHans Rosenfeld as != MDB_TGT_AS_VIRT_S)
5597c478bd9Sstevel@tonic-gate return (set_errno(EINVAL));
5607c478bd9Sstevel@tonic-gate
5617c478bd9Sstevel@tonic-gate if ((pa = kvm_physaddr(kp->kp_cookie, kp->kp_as, va)) != -1ULL) {
5627c478bd9Sstevel@tonic-gate *pap = pa;
5637c478bd9Sstevel@tonic-gate return (0);
5647c478bd9Sstevel@tonic-gate }
5657c478bd9Sstevel@tonic-gate
5667c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOMAP));
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate
5697c478bd9Sstevel@tonic-gate static int
kp_lookup_by_name(mdb_tgt_t * t,const char * object,const char * name,GElf_Sym * symp,mdb_syminfo_t * sip)5707c478bd9Sstevel@tonic-gate kp_lookup_by_name(mdb_tgt_t *t, const char *object,
5717c478bd9Sstevel@tonic-gate const char *name, GElf_Sym *symp, mdb_syminfo_t *sip)
5727c478bd9Sstevel@tonic-gate {
5737c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
5747c478bd9Sstevel@tonic-gate kp_file_t *kpf;
5757c478bd9Sstevel@tonic-gate int n;
5767c478bd9Sstevel@tonic-gate
5777c478bd9Sstevel@tonic-gate GElf_Sym sym;
5787c478bd9Sstevel@tonic-gate uint_t symid;
5797c478bd9Sstevel@tonic-gate int rv = -1;
5807c478bd9Sstevel@tonic-gate
5817c478bd9Sstevel@tonic-gate /*
5827c478bd9Sstevel@tonic-gate * Simplify our task: if object is EVERY, then we need to search
5837c478bd9Sstevel@tonic-gate * kp_num_files files beginning at kp_file_head; otherwise we are
5847c478bd9Sstevel@tonic-gate * searching 1 file whose file pointer is obtained via object_to_map.
5857c478bd9Sstevel@tonic-gate */
5867c478bd9Sstevel@tonic-gate if (object != MDB_TGT_OBJ_EVERY) {
5877c478bd9Sstevel@tonic-gate kp_map_t *kpm = kp_name_to_kpmap(kp, object);
5887c478bd9Sstevel@tonic-gate if (kpm == NULL || kpm->kpm_file == NULL)
5897c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOOBJ));
5907c478bd9Sstevel@tonic-gate kpf = kpm->kpm_file;
5917c478bd9Sstevel@tonic-gate n = 1;
5927c478bd9Sstevel@tonic-gate } else {
5937c478bd9Sstevel@tonic-gate kpf = kp->kp_file_head;
5947c478bd9Sstevel@tonic-gate n = kp->kp_num_files;
5957c478bd9Sstevel@tonic-gate }
5967c478bd9Sstevel@tonic-gate
5977c478bd9Sstevel@tonic-gate /*
5987c478bd9Sstevel@tonic-gate * Iterate through the load object files and look for the symbol name
5997c478bd9Sstevel@tonic-gate * in the .dynsym of each. If we encounter a match with SHN_UNDEF,
6007c478bd9Sstevel@tonic-gate * keep looking in hopes of finding a better match. This means that
6017c478bd9Sstevel@tonic-gate * a name such as "puts" will match the puts function in libc instead
6027c478bd9Sstevel@tonic-gate * of matching the puts PLT entry in the a.out file.
6037c478bd9Sstevel@tonic-gate */
6047c478bd9Sstevel@tonic-gate for (; n > 0; n--, kpf = kpf->kpf_next) {
6057c478bd9Sstevel@tonic-gate if (kpf->kpf_dynsym == NULL)
6067c478bd9Sstevel@tonic-gate continue; /* No symbols for this file */
6077c478bd9Sstevel@tonic-gate
6087c478bd9Sstevel@tonic-gate if (mdb_gelf_symtab_lookup_by_name(kpf->kpf_dynsym,
6097c478bd9Sstevel@tonic-gate name, symp, &sip->sym_id) != 0)
6107c478bd9Sstevel@tonic-gate continue; /* Symbol name not found */
6117c478bd9Sstevel@tonic-gate
6127c478bd9Sstevel@tonic-gate symp->st_value += kpf->kpf_dyn_base;
6137c478bd9Sstevel@tonic-gate
6147c478bd9Sstevel@tonic-gate if (symp->st_shndx != SHN_UNDEF) {
6157c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_DYNSYM;
6167c478bd9Sstevel@tonic-gate return (0);
6177c478bd9Sstevel@tonic-gate }
6187c478bd9Sstevel@tonic-gate
6197c478bd9Sstevel@tonic-gate if (rv != 0) {
6207c478bd9Sstevel@tonic-gate sym = *symp;
6217c478bd9Sstevel@tonic-gate symid = sip->sym_id;
6227c478bd9Sstevel@tonic-gate rv = 0;
6237c478bd9Sstevel@tonic-gate }
6247c478bd9Sstevel@tonic-gate }
6257c478bd9Sstevel@tonic-gate
6267c478bd9Sstevel@tonic-gate if (rv != 0)
6277c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYM));
6287c478bd9Sstevel@tonic-gate
6297c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_DYNSYM;
6307c478bd9Sstevel@tonic-gate sip->sym_id = symid;
6317c478bd9Sstevel@tonic-gate *symp = sym;
6327c478bd9Sstevel@tonic-gate
6337c478bd9Sstevel@tonic-gate return (0);
6347c478bd9Sstevel@tonic-gate }
6357c478bd9Sstevel@tonic-gate
6367c478bd9Sstevel@tonic-gate static int
kp_lookup_by_addr(mdb_tgt_t * t,uintptr_t addr,uint_t flags,char * buf,size_t nbytes,GElf_Sym * symp,mdb_syminfo_t * sip)6377c478bd9Sstevel@tonic-gate kp_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
6387c478bd9Sstevel@tonic-gate char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip)
6397c478bd9Sstevel@tonic-gate {
6407c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
6417c478bd9Sstevel@tonic-gate kp_map_t *kpm = kp_addr_to_kpmap(kp, addr);
6427c478bd9Sstevel@tonic-gate
6437c478bd9Sstevel@tonic-gate kp_file_t *sym_kpf = NULL;
6447c478bd9Sstevel@tonic-gate GElf_Sym sym;
6457c478bd9Sstevel@tonic-gate uint_t symid;
6467c478bd9Sstevel@tonic-gate
6477c478bd9Sstevel@tonic-gate const char *name;
6487c478bd9Sstevel@tonic-gate kp_file_t *kpf;
6497c478bd9Sstevel@tonic-gate int n;
6507c478bd9Sstevel@tonic-gate
6517c478bd9Sstevel@tonic-gate /*
6527c478bd9Sstevel@tonic-gate * Check the user's private symbol table first; if a match is
6537c478bd9Sstevel@tonic-gate * found there, we're done or we have a first guess.
6547c478bd9Sstevel@tonic-gate */
6557c478bd9Sstevel@tonic-gate if (mdb_gelf_symtab_lookup_by_addr(mdb.m_prsym,
6567c478bd9Sstevel@tonic-gate addr, flags, buf, nbytes, symp, &sip->sym_id) == 0) {
6577c478bd9Sstevel@tonic-gate sym_kpf = &kp->kp_prfile;
6587c478bd9Sstevel@tonic-gate if (flags & MDB_TGT_SYM_EXACT)
6597c478bd9Sstevel@tonic-gate goto found;
6607c478bd9Sstevel@tonic-gate sym = *symp;
6617c478bd9Sstevel@tonic-gate symid = sip->sym_id;
6627c478bd9Sstevel@tonic-gate }
6637c478bd9Sstevel@tonic-gate
6647c478bd9Sstevel@tonic-gate /*
6657c478bd9Sstevel@tonic-gate * If no mapping contains the address and EXACT mode is set, we're done.
6667c478bd9Sstevel@tonic-gate * Otherwise we need to search all the symbol tables in fuzzy mode.
6677c478bd9Sstevel@tonic-gate * If we find a mapping, then we only need to search that symtab.
6687c478bd9Sstevel@tonic-gate */
6697c478bd9Sstevel@tonic-gate if (kpm == NULL || kpm->kpm_file == NULL) {
6707c478bd9Sstevel@tonic-gate if (flags & MDB_TGT_SYM_EXACT)
6717c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYMADDR));
6727c478bd9Sstevel@tonic-gate kpf = kp->kp_file_head;
6737c478bd9Sstevel@tonic-gate n = kp->kp_num_files;
6747c478bd9Sstevel@tonic-gate } else {
6757c478bd9Sstevel@tonic-gate kpf = kpm->kpm_file;
6767c478bd9Sstevel@tonic-gate n = 1;
6777c478bd9Sstevel@tonic-gate }
6787c478bd9Sstevel@tonic-gate
6797c478bd9Sstevel@tonic-gate /*
6807c478bd9Sstevel@tonic-gate * Iterate through our list of load objects, scanning each one which
6817c478bd9Sstevel@tonic-gate * has a symbol table. In fuzzy mode, we continue looking and
6827c478bd9Sstevel@tonic-gate * improve our choice if we find a closer symbol.
6837c478bd9Sstevel@tonic-gate */
6847c478bd9Sstevel@tonic-gate for (; n > 0; n--, kpf = kpf->kpf_next) {
6857c478bd9Sstevel@tonic-gate if (kpf->kpf_dynsym == NULL)
6867c478bd9Sstevel@tonic-gate continue; /* No symbols for this file */
6877c478bd9Sstevel@tonic-gate
6887c478bd9Sstevel@tonic-gate if (mdb_gelf_symtab_lookup_by_addr(kpf->kpf_dynsym,
6897c478bd9Sstevel@tonic-gate addr - kpf->kpf_dyn_base, flags, buf, nbytes,
6907c478bd9Sstevel@tonic-gate symp, &sip->sym_id) != 0)
6917c478bd9Sstevel@tonic-gate continue; /* No symbol for this address */
6927c478bd9Sstevel@tonic-gate
6937c478bd9Sstevel@tonic-gate symp->st_value += kpf->kpf_dyn_base;
6947c478bd9Sstevel@tonic-gate
6957c478bd9Sstevel@tonic-gate if (flags & MDB_TGT_SYM_EXACT) {
6967c478bd9Sstevel@tonic-gate sym_kpf = kpf;
6977c478bd9Sstevel@tonic-gate goto found;
6987c478bd9Sstevel@tonic-gate }
6997c478bd9Sstevel@tonic-gate
7007c478bd9Sstevel@tonic-gate if (sym_kpf == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) {
7017c478bd9Sstevel@tonic-gate sym_kpf = kpf;
7027c478bd9Sstevel@tonic-gate sym = *symp;
7037c478bd9Sstevel@tonic-gate symid = sip->sym_id;
7047c478bd9Sstevel@tonic-gate }
7057c478bd9Sstevel@tonic-gate }
7067c478bd9Sstevel@tonic-gate
7077c478bd9Sstevel@tonic-gate if (sym_kpf == NULL)
7087c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOSYMADDR));
7097c478bd9Sstevel@tonic-gate
7107c478bd9Sstevel@tonic-gate *symp = sym; /* Copy our best symbol into the caller's symbol */
7117c478bd9Sstevel@tonic-gate sip->sym_id = symid;
7127c478bd9Sstevel@tonic-gate found:
7137c478bd9Sstevel@tonic-gate /*
7147c478bd9Sstevel@tonic-gate * Once we've found something, copy the final name into the caller's
7157c478bd9Sstevel@tonic-gate * buffer and prefix it with the load object name if appropriate.
7167c478bd9Sstevel@tonic-gate */
7177c478bd9Sstevel@tonic-gate name = mdb_gelf_sym_name(sym_kpf->kpf_dynsym, symp);
7187c478bd9Sstevel@tonic-gate
7197c478bd9Sstevel@tonic-gate if (sym_kpf != kp->kp_map_exec->kpm_file && sym_kpf != &kp->kp_prfile) {
7207c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, nbytes, "%s`%s",
7217c478bd9Sstevel@tonic-gate sym_kpf->kpf_basename, name);
7227c478bd9Sstevel@tonic-gate } else if (nbytes > 0) {
7237c478bd9Sstevel@tonic-gate (void) strncpy(buf, name, nbytes);
7247c478bd9Sstevel@tonic-gate buf[nbytes - 1] = '\0';
7257c478bd9Sstevel@tonic-gate }
7267c478bd9Sstevel@tonic-gate
7277c478bd9Sstevel@tonic-gate if (sym_kpf == &kp->kp_prfile)
7287c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_PRVSYM;
7297c478bd9Sstevel@tonic-gate else
7307c478bd9Sstevel@tonic-gate sip->sym_table = MDB_TGT_DYNSYM;
7317c478bd9Sstevel@tonic-gate
7327c478bd9Sstevel@tonic-gate return (0);
7337c478bd9Sstevel@tonic-gate }
7347c478bd9Sstevel@tonic-gate
7357c478bd9Sstevel@tonic-gate static int
kp_symtab_func(void * data,const GElf_Sym * symp,const char * name,uint_t id)7367c478bd9Sstevel@tonic-gate kp_symtab_func(void *data, const GElf_Sym *symp, const char *name, uint_t id)
7377c478bd9Sstevel@tonic-gate {
7387c478bd9Sstevel@tonic-gate kp_symarg_t *argp = data;
7397c478bd9Sstevel@tonic-gate if (mdb_tgt_sym_match(symp, argp->sym_type)) {
7407c478bd9Sstevel@tonic-gate GElf_Sym sym = *symp;
7417c478bd9Sstevel@tonic-gate
7427c478bd9Sstevel@tonic-gate sym.st_value += argp->sym_adjust;
7437c478bd9Sstevel@tonic-gate
7447c478bd9Sstevel@tonic-gate argp->sym_info.sym_id = id;
7457c478bd9Sstevel@tonic-gate
7467c478bd9Sstevel@tonic-gate return (argp->sym_cb(argp->sym_data, &sym, name,
7477c478bd9Sstevel@tonic-gate &argp->sym_info, argp->sym_obj));
7487c478bd9Sstevel@tonic-gate }
7497c478bd9Sstevel@tonic-gate
7507c478bd9Sstevel@tonic-gate return (0);
7517c478bd9Sstevel@tonic-gate }
7527c478bd9Sstevel@tonic-gate
7537c478bd9Sstevel@tonic-gate static void
kp_symtab_iter(kp_file_t * kpf,uint_t type,const char * obj,mdb_tgt_sym_f * cb,void * data)7547c478bd9Sstevel@tonic-gate kp_symtab_iter(kp_file_t *kpf, uint_t type, const char *obj,
7557c478bd9Sstevel@tonic-gate mdb_tgt_sym_f *cb, void *data)
7567c478bd9Sstevel@tonic-gate {
7577c478bd9Sstevel@tonic-gate if (kpf->kpf_dynsym != NULL) {
7587c478bd9Sstevel@tonic-gate kp_symarg_t arg;
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate arg.sym_cb = cb;
7617c478bd9Sstevel@tonic-gate arg.sym_data = data;
7627c478bd9Sstevel@tonic-gate arg.sym_type = type;
7637c478bd9Sstevel@tonic-gate arg.sym_adjust = kpf->kpf_dyn_base;
7647c478bd9Sstevel@tonic-gate arg.sym_info.sym_table = kpf->kpf_dynsym->gst_tabid;
7657c478bd9Sstevel@tonic-gate arg.sym_obj = obj;
7667c478bd9Sstevel@tonic-gate
7677c478bd9Sstevel@tonic-gate mdb_gelf_symtab_iter(kpf->kpf_dynsym, kp_symtab_func, &arg);
7687c478bd9Sstevel@tonic-gate }
7697c478bd9Sstevel@tonic-gate }
7707c478bd9Sstevel@tonic-gate
7717c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7727c478bd9Sstevel@tonic-gate static int
kp_symbol_iter(mdb_tgt_t * t,const char * object,uint_t which,uint_t type,mdb_tgt_sym_f * func,void * private)7737c478bd9Sstevel@tonic-gate kp_symbol_iter(mdb_tgt_t *t, const char *object, uint_t which,
7747c478bd9Sstevel@tonic-gate uint_t type, mdb_tgt_sym_f *func, void *private)
7757c478bd9Sstevel@tonic-gate {
7767c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
7777c478bd9Sstevel@tonic-gate kp_file_t *kpf = NULL;
7787c478bd9Sstevel@tonic-gate kp_map_t *kpm;
7797c478bd9Sstevel@tonic-gate
7807c478bd9Sstevel@tonic-gate switch ((uintptr_t)object) {
7817c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EVERY:
7827c478bd9Sstevel@tonic-gate if (kp->kp_map_exec && kp->kp_map_exec->kpm_file) {
7837c478bd9Sstevel@tonic-gate kpf = kp->kp_map_exec->kpm_file;
7847c478bd9Sstevel@tonic-gate kp_symtab_iter(kpf, type, MDB_TGT_OBJ_EXEC, func,
7857c478bd9Sstevel@tonic-gate private);
7867c478bd9Sstevel@tonic-gate }
7877c478bd9Sstevel@tonic-gate if (kp->kp_map_ldso && kp->kp_map_ldso->kpm_file) {
7887c478bd9Sstevel@tonic-gate kpf = kp->kp_map_ldso->kpm_file;
7897c478bd9Sstevel@tonic-gate kp_symtab_iter(kpf, type, MDB_TGT_OBJ_RTLD, func,
7907c478bd9Sstevel@tonic-gate private);
7917c478bd9Sstevel@tonic-gate }
7927c478bd9Sstevel@tonic-gate return (0);
7937c478bd9Sstevel@tonic-gate
7947c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_EXEC:
7957c478bd9Sstevel@tonic-gate if (kp->kp_map_exec && kp->kp_map_exec->kpm_file)
7967c478bd9Sstevel@tonic-gate kpf = kp->kp_map_exec->kpm_file;
7977c478bd9Sstevel@tonic-gate break;
7987c478bd9Sstevel@tonic-gate
7997c478bd9Sstevel@tonic-gate case (uintptr_t)MDB_TGT_OBJ_RTLD:
8007c478bd9Sstevel@tonic-gate if (kp->kp_map_ldso && kp->kp_map_ldso->kpm_file)
8017c478bd9Sstevel@tonic-gate kpf = kp->kp_map_ldso->kpm_file;
8027c478bd9Sstevel@tonic-gate break;
8037c478bd9Sstevel@tonic-gate
8047c478bd9Sstevel@tonic-gate default:
8057c478bd9Sstevel@tonic-gate if ((kpm = kp_name_to_kpmap(kp, object)) != NULL) {
8067c478bd9Sstevel@tonic-gate kpf = kpm->kpm_file;
8077c478bd9Sstevel@tonic-gate break;
8087c478bd9Sstevel@tonic-gate } else
8097c478bd9Sstevel@tonic-gate return (set_errno(EMDB_NOOBJ));
8107c478bd9Sstevel@tonic-gate }
8117c478bd9Sstevel@tonic-gate
8127c478bd9Sstevel@tonic-gate if (kpf != NULL)
8137c478bd9Sstevel@tonic-gate kp_symtab_iter(kpf, type, object, func, private);
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate return (0);
8167c478bd9Sstevel@tonic-gate }
8177c478bd9Sstevel@tonic-gate
8187c478bd9Sstevel@tonic-gate static int
kp_mapping_iter(mdb_tgt_t * t,mdb_tgt_map_f * func,void * private)8197c478bd9Sstevel@tonic-gate kp_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
8207c478bd9Sstevel@tonic-gate {
8217c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
8227c478bd9Sstevel@tonic-gate kp_map_t *kpm;
8237c478bd9Sstevel@tonic-gate
8247c478bd9Sstevel@tonic-gate for (kpm = kp->kp_map_head; kpm != NULL; kpm = kpm->kpm_next) {
8257c478bd9Sstevel@tonic-gate if (func(private, &kpm->kpm_map, kpm->kpm_map.map_name) != 0)
8267c478bd9Sstevel@tonic-gate break;
8277c478bd9Sstevel@tonic-gate }
8287c478bd9Sstevel@tonic-gate
8297c478bd9Sstevel@tonic-gate return (0);
8307c478bd9Sstevel@tonic-gate }
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate static int
kp_object_iter(mdb_tgt_t * t,mdb_tgt_map_f * func,void * private)8337c478bd9Sstevel@tonic-gate kp_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
8347c478bd9Sstevel@tonic-gate {
8357c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
8367c478bd9Sstevel@tonic-gate kp_file_t *kpf;
8377c478bd9Sstevel@tonic-gate
8387c478bd9Sstevel@tonic-gate for (kpf = kp->kp_file_head; kpf != NULL; kpf = kpf->kpf_next) {
8397c478bd9Sstevel@tonic-gate if (func(private, &kpf->kpf_map->kpm_map,
8407c478bd9Sstevel@tonic-gate kpf->kpf_map->kpm_map.map_name) != 0)
8417c478bd9Sstevel@tonic-gate break;
8427c478bd9Sstevel@tonic-gate }
8437c478bd9Sstevel@tonic-gate
8447c478bd9Sstevel@tonic-gate return (0);
8457c478bd9Sstevel@tonic-gate }
8467c478bd9Sstevel@tonic-gate
8477c478bd9Sstevel@tonic-gate static const mdb_map_t *
kp_addr_to_map(mdb_tgt_t * t,uintptr_t addr)8487c478bd9Sstevel@tonic-gate kp_addr_to_map(mdb_tgt_t *t, uintptr_t addr)
8497c478bd9Sstevel@tonic-gate {
8507c478bd9Sstevel@tonic-gate kp_map_t *kpm = kp_addr_to_kpmap(t->t_data, addr);
8517c478bd9Sstevel@tonic-gate
8527c478bd9Sstevel@tonic-gate if (kpm != NULL)
8537c478bd9Sstevel@tonic-gate return (&kpm->kpm_map);
8547c478bd9Sstevel@tonic-gate
8557c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOMAP);
8567c478bd9Sstevel@tonic-gate return (NULL);
8577c478bd9Sstevel@tonic-gate }
8587c478bd9Sstevel@tonic-gate
8597c478bd9Sstevel@tonic-gate static const mdb_map_t *
kp_name_to_map(mdb_tgt_t * t,const char * name)8607c478bd9Sstevel@tonic-gate kp_name_to_map(mdb_tgt_t *t, const char *name)
8617c478bd9Sstevel@tonic-gate {
8627c478bd9Sstevel@tonic-gate kp_map_t *kpm = kp_name_to_kpmap(t->t_data, name);
8637c478bd9Sstevel@tonic-gate
8647c478bd9Sstevel@tonic-gate if (kpm != NULL)
8657c478bd9Sstevel@tonic-gate return (&kpm->kpm_map);
8667c478bd9Sstevel@tonic-gate
8677c478bd9Sstevel@tonic-gate (void) set_errno(EMDB_NOOBJ);
8687c478bd9Sstevel@tonic-gate return (NULL);
8697c478bd9Sstevel@tonic-gate }
8707c478bd9Sstevel@tonic-gate
8717c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8727c478bd9Sstevel@tonic-gate static int
kp_status(mdb_tgt_t * t,mdb_tgt_status_t * tsp)8737c478bd9Sstevel@tonic-gate kp_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
8747c478bd9Sstevel@tonic-gate {
8757c478bd9Sstevel@tonic-gate bzero(tsp, sizeof (mdb_tgt_status_t));
8767c478bd9Sstevel@tonic-gate tsp->st_state = MDB_TGT_DEAD;
8777c478bd9Sstevel@tonic-gate return (0);
8787c478bd9Sstevel@tonic-gate }
8797c478bd9Sstevel@tonic-gate
8807b9b3bf3Sedp static int
kp_auxv(mdb_tgt_t * t,const auxv_t ** auxvp)8817b9b3bf3Sedp kp_auxv(mdb_tgt_t *t, const auxv_t **auxvp)
8827b9b3bf3Sedp {
8837b9b3bf3Sedp kp_data_t *kp = t->t_data;
8847b9b3bf3Sedp *auxvp = kp->kp_auxv;
8857b9b3bf3Sedp return (0);
8867b9b3bf3Sedp }
8877b9b3bf3Sedp
8887c478bd9Sstevel@tonic-gate static const mdb_tgt_ops_t kproc_ops = {
889*0c1b95beSRichard Lowe .t_setflags = (int (*)())(uintptr_t)mdb_tgt_notsup,
890*0c1b95beSRichard Lowe .t_setcontext = kp_setcontext,
891*0c1b95beSRichard Lowe .t_activate = kp_activate,
892*0c1b95beSRichard Lowe .t_deactivate = kp_deactivate,
893*0c1b95beSRichard Lowe .t_periodic = (void (*)())(uintptr_t)mdb_tgt_nop,
894*0c1b95beSRichard Lowe .t_destroy = kp_destroy,
895*0c1b95beSRichard Lowe .t_name = kp_name,
896*0c1b95beSRichard Lowe .t_isa = kp_isa,
897*0c1b95beSRichard Lowe .t_platform = kp_platform,
898*0c1b95beSRichard Lowe .t_uname = kp_uname,
899*0c1b95beSRichard Lowe .t_dmodel = kp_dmodel,
900*0c1b95beSRichard Lowe .t_aread = (ssize_t (*)())mdb_tgt_notsup,
901*0c1b95beSRichard Lowe .t_awrite = (ssize_t (*)())mdb_tgt_notsup,
902*0c1b95beSRichard Lowe .t_vread = kp_vread,
903*0c1b95beSRichard Lowe .t_vwrite = kp_vwrite,
904*0c1b95beSRichard Lowe .t_pread = (ssize_t (*)())mdb_tgt_notsup,
905*0c1b95beSRichard Lowe .t_pwrite = (ssize_t (*)())mdb_tgt_notsup,
906*0c1b95beSRichard Lowe .t_fread = (ssize_t (*)())mdb_tgt_notsup,
907*0c1b95beSRichard Lowe .t_fwrite = (ssize_t (*)())mdb_tgt_notsup,
908*0c1b95beSRichard Lowe .t_ioread = (ssize_t (*)())mdb_tgt_notsup,
909*0c1b95beSRichard Lowe .t_iowrite = (ssize_t (*)())mdb_tgt_notsup,
910*0c1b95beSRichard Lowe .t_vtop = kp_vtop,
911*0c1b95beSRichard Lowe .t_lookup_by_name = kp_lookup_by_name,
912*0c1b95beSRichard Lowe .t_lookup_by_addr = kp_lookup_by_addr,
913*0c1b95beSRichard Lowe .t_symbol_iter = kp_symbol_iter,
914*0c1b95beSRichard Lowe .t_mapping_iter = kp_mapping_iter,
915*0c1b95beSRichard Lowe .t_object_iter = kp_object_iter,
916*0c1b95beSRichard Lowe .t_addr_to_map = kp_addr_to_map,
917*0c1b95beSRichard Lowe .t_name_to_map = kp_name_to_map,
918*0c1b95beSRichard Lowe .t_addr_to_ctf = (struct ctf_file *(*)())mdb_tgt_null,
919*0c1b95beSRichard Lowe .t_name_to_ctf = (struct ctf_file *(*)())mdb_tgt_null,
920*0c1b95beSRichard Lowe .t_status = kp_status,
921*0c1b95beSRichard Lowe .t_run = (int (*)())(uintptr_t)mdb_tgt_notsup,
922*0c1b95beSRichard Lowe .t_step = (int (*)())(uintptr_t)mdb_tgt_notsup,
923*0c1b95beSRichard Lowe .t_step_out = (int (*)())(uintptr_t)mdb_tgt_notsup,
924*0c1b95beSRichard Lowe .t_next = (int (*)())(uintptr_t)mdb_tgt_notsup,
925*0c1b95beSRichard Lowe .t_cont = (int (*)())(uintptr_t)mdb_tgt_notsup,
926*0c1b95beSRichard Lowe .t_signal = (int (*)())(uintptr_t)mdb_tgt_notsup,
927*0c1b95beSRichard Lowe .t_add_sbrkpt = (int (*)())(uintptr_t)mdb_tgt_null,
928*0c1b95beSRichard Lowe .t_add_vbrkpt = (int (*)())(uintptr_t)mdb_tgt_null,
929*0c1b95beSRichard Lowe .t_add_pwapt = (int (*)())(uintptr_t)mdb_tgt_null,
930*0c1b95beSRichard Lowe .t_add_vwapt = (int (*)())(uintptr_t)mdb_tgt_null,
931*0c1b95beSRichard Lowe .t_add_iowapt = (int (*)())(uintptr_t)mdb_tgt_null,
932*0c1b95beSRichard Lowe .t_add_sysenter = (int (*)())(uintptr_t)mdb_tgt_null,
933*0c1b95beSRichard Lowe .t_add_sysexit = (int (*)())(uintptr_t)mdb_tgt_null,
934*0c1b95beSRichard Lowe .t_add_signal = (int (*)())(uintptr_t)mdb_tgt_null,
935*0c1b95beSRichard Lowe .t_add_fault = (int (*)())(uintptr_t)mdb_tgt_null,
936*0c1b95beSRichard Lowe .t_getareg = (int (*)())(uintptr_t)mdb_tgt_notsup, /* XXX */
937*0c1b95beSRichard Lowe .t_putareg = (int (*)())(uintptr_t)mdb_tgt_notsup, /* XXX */
938*0c1b95beSRichard Lowe .t_stack_iter = (int (*)())(uintptr_t)mdb_tgt_notsup, /* XXX */
939*0c1b95beSRichard Lowe .t_auxv = kp_auxv,
940*0c1b95beSRichard Lowe .t_thread_name = (int (*)())(uintptr_t)mdb_tgt_notsup,
9417c478bd9Sstevel@tonic-gate };
9427c478bd9Sstevel@tonic-gate
9437c478bd9Sstevel@tonic-gate int
mdb_kproc_tgt_create(mdb_tgt_t * t,int argc,const char * argv[])9447c478bd9Sstevel@tonic-gate mdb_kproc_tgt_create(mdb_tgt_t *t, int argc, const char *argv[])
9457c478bd9Sstevel@tonic-gate {
9467c478bd9Sstevel@tonic-gate kp_data_t *kp = mdb_zalloc(sizeof (kp_data_t), UM_SLEEP);
9477c478bd9Sstevel@tonic-gate void *proc = (void *)argv[0];
9487c478bd9Sstevel@tonic-gate long at_entry, at_base;
9497c478bd9Sstevel@tonic-gate GElf_Sym sym;
9507c478bd9Sstevel@tonic-gate
9517c478bd9Sstevel@tonic-gate int (*f_asiter)(uintptr_t, void (*)(const mdb_map_t *, void *), void *);
9527c478bd9Sstevel@tonic-gate int (*f_auxv)(uintptr_t, auxv_t *);
9537c478bd9Sstevel@tonic-gate uintptr_t (*f_as)(uintptr_t);
9547c478bd9Sstevel@tonic-gate uint_t (*f_model)(uintptr_t);
9557c478bd9Sstevel@tonic-gate pid_t (*f_pid)(uintptr_t);
9567c478bd9Sstevel@tonic-gate
9577c478bd9Sstevel@tonic-gate if (argc != 1)
9587c478bd9Sstevel@tonic-gate return (set_errno(EINVAL));
9597c478bd9Sstevel@tonic-gate
9607c478bd9Sstevel@tonic-gate t->t_flags &= ~MDB_TGT_F_RDWR;
9617c478bd9Sstevel@tonic-gate t->t_data = kp;
9627c478bd9Sstevel@tonic-gate t->t_ops = &kproc_ops;
9637c478bd9Sstevel@tonic-gate
9647c478bd9Sstevel@tonic-gate f_asiter = (int (*)()) dlsym(RTLD_NEXT, "mdb_kproc_asiter");
9657c478bd9Sstevel@tonic-gate f_auxv = (int (*)()) dlsym(RTLD_NEXT, "mdb_kproc_auxv");
9667c478bd9Sstevel@tonic-gate f_as = (uintptr_t (*)()) dlsym(RTLD_NEXT, "mdb_kproc_as");
9677c478bd9Sstevel@tonic-gate f_model = (model_t (*)()) dlsym(RTLD_NEXT, "mdb_kproc_model");
9687c478bd9Sstevel@tonic-gate f_pid = (pid_t (*)()) dlsym(RTLD_NEXT, "mdb_kproc_pid");
9697c478bd9Sstevel@tonic-gate
9707c478bd9Sstevel@tonic-gate if (f_asiter == NULL || f_auxv == NULL ||
9717c478bd9Sstevel@tonic-gate f_as == NULL || f_model == NULL || f_pid == NULL) {
9727c478bd9Sstevel@tonic-gate warn("required kernel support module is not loaded\n");
9737c478bd9Sstevel@tonic-gate goto err;
9747c478bd9Sstevel@tonic-gate }
9757c478bd9Sstevel@tonic-gate
9767c478bd9Sstevel@tonic-gate /*
9777c478bd9Sstevel@tonic-gate * Here the kproc target relies on the fact that at the time of its
9787c478bd9Sstevel@tonic-gate * instantiation, mdb.m_target is pointing at a kvm target, and
9797c478bd9Sstevel@tonic-gate * that the kvm target has stored its libkvm handle in t_pshandle.
9807c478bd9Sstevel@tonic-gate */
9817c478bd9Sstevel@tonic-gate kp->kp_parent = mdb.m_target;
9827c478bd9Sstevel@tonic-gate kp->kp_cookie = mdb.m_target->t_pshandle;
9837c478bd9Sstevel@tonic-gate kp->kp_platform = mdb_tgt_platform(mdb.m_target);
9847c478bd9Sstevel@tonic-gate kp->kp_proc = proc;
9857c478bd9Sstevel@tonic-gate kp->kp_as = (struct as *)f_as((uintptr_t)proc);
9867c478bd9Sstevel@tonic-gate kp->kp_pid = f_pid((uintptr_t)proc);
9877c478bd9Sstevel@tonic-gate
9887c478bd9Sstevel@tonic-gate if (kp->kp_as == NULL) {
9897c478bd9Sstevel@tonic-gate warn("failed to obtain address space for proc %p\n", proc);
9907c478bd9Sstevel@tonic-gate goto err;
9917c478bd9Sstevel@tonic-gate }
9927c478bd9Sstevel@tonic-gate
9937c478bd9Sstevel@tonic-gate if (kp->kp_pid == -1) {
9947c478bd9Sstevel@tonic-gate warn("failed to obtain PID for proc %p\n", proc);
9957c478bd9Sstevel@tonic-gate goto err;
9967c478bd9Sstevel@tonic-gate }
9977c478bd9Sstevel@tonic-gate
9987c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_name(kp->kp_parent, MDB_TGT_OBJ_EXEC, "kas",
9997c478bd9Sstevel@tonic-gate &sym, NULL) == 0 && kp->kp_as ==
10007c478bd9Sstevel@tonic-gate (struct as *)(uintptr_t)sym.st_value) {
10017c478bd9Sstevel@tonic-gate warn("specified process is a system process (no context)\n");
10027c478bd9Sstevel@tonic-gate goto err;
10037c478bd9Sstevel@tonic-gate }
10047c478bd9Sstevel@tonic-gate
10057c478bd9Sstevel@tonic-gate if ((kp->kp_model = f_model((uintptr_t)proc)) == PR_MODEL_UNKNOWN) {
10067c478bd9Sstevel@tonic-gate warn("failed to obtain data model for proc %p\n", proc);
10077c478bd9Sstevel@tonic-gate goto err;
10087c478bd9Sstevel@tonic-gate }
10097c478bd9Sstevel@tonic-gate
10107c478bd9Sstevel@tonic-gate if (f_asiter((uintptr_t)kp->kp_as, kp_add_mapping, kp) == -1) {
10117c478bd9Sstevel@tonic-gate warn("failed to load mappings for proc %p", proc);
10127c478bd9Sstevel@tonic-gate goto err;
10137c478bd9Sstevel@tonic-gate }
10147c478bd9Sstevel@tonic-gate
10157c478bd9Sstevel@tonic-gate kp->kp_nauxv = f_auxv((uintptr_t)proc, NULL) + 1;
10167c478bd9Sstevel@tonic-gate kp->kp_auxv = mdb_alloc(sizeof (auxv_t) * kp->kp_nauxv, UM_SLEEP);
10177c478bd9Sstevel@tonic-gate
10187c478bd9Sstevel@tonic-gate if (f_auxv((uintptr_t)proc, kp->kp_auxv) == -1) {
10197c478bd9Sstevel@tonic-gate warn("failed to load auxv for proc %p", proc);
10207c478bd9Sstevel@tonic-gate goto err;
10217c478bd9Sstevel@tonic-gate }
10227c478bd9Sstevel@tonic-gate
10237c478bd9Sstevel@tonic-gate kp->kp_auxv[kp->kp_nauxv - 1].a_type = AT_NULL;
10247c478bd9Sstevel@tonic-gate kp->kp_auxv[kp->kp_nauxv - 1].a_un.a_val = 0;
10257c478bd9Sstevel@tonic-gate
10267c478bd9Sstevel@tonic-gate if ((at_entry = kp_getauxval(kp, AT_ENTRY)) == -1L) {
10277c478bd9Sstevel@tonic-gate warn("auxv for proc %p is missing AT_ENTRY\n", proc);
10287c478bd9Sstevel@tonic-gate goto err;
10297c478bd9Sstevel@tonic-gate }
10307c478bd9Sstevel@tonic-gate
10317c478bd9Sstevel@tonic-gate if ((at_base = kp_getauxval(kp, AT_BASE)) == -1L) {
10327c478bd9Sstevel@tonic-gate warn("auxv for proc %p is missing AT_BASE\n", proc);
10337c478bd9Sstevel@tonic-gate goto err;
10347c478bd9Sstevel@tonic-gate }
10357c478bd9Sstevel@tonic-gate
10367c478bd9Sstevel@tonic-gate /*
10377c478bd9Sstevel@tonic-gate * If we're applying kproc to a live kernel, we need to force libkvm
10387c478bd9Sstevel@tonic-gate * to set the current process to the process in question so we can
10397c478bd9Sstevel@tonic-gate * read from its address space. If kvm_getproc returns NULL, the
10407c478bd9Sstevel@tonic-gate * process may have gone away since our previous calls to mdb_ks.
10417c478bd9Sstevel@tonic-gate */
10427c478bd9Sstevel@tonic-gate if (mdb_prop_postmortem == FALSE &&
10437c478bd9Sstevel@tonic-gate kvm_getproc(kp->kp_cookie, kp->kp_pid) == NULL)
10447c478bd9Sstevel@tonic-gate warn("failed to attach to PID %d\n", (int)kp->kp_pid);
10457c478bd9Sstevel@tonic-gate
10467c478bd9Sstevel@tonic-gate kp->kp_map_exec = kp_addr_to_kpmap(kp, at_entry);
10477c478bd9Sstevel@tonic-gate kp->kp_map_ldso = kp_addr_to_kpmap(kp, at_base);
10487c478bd9Sstevel@tonic-gate
10497c478bd9Sstevel@tonic-gate (void) kp_file_create(t, kp->kp_map_exec, ET_EXEC);
10507c478bd9Sstevel@tonic-gate (void) kp_file_create(t, kp->kp_map_ldso, ET_DYN);
10517c478bd9Sstevel@tonic-gate
10527c478bd9Sstevel@tonic-gate kp->kp_prfile.kpf_dynsym = mdb.m_prsym;
10537c478bd9Sstevel@tonic-gate
10547c478bd9Sstevel@tonic-gate return (0);
10557c478bd9Sstevel@tonic-gate
10567c478bd9Sstevel@tonic-gate err:
10577c478bd9Sstevel@tonic-gate kp_destroy(t);
10587c478bd9Sstevel@tonic-gate return (-1);
10597c478bd9Sstevel@tonic-gate }
10607c478bd9Sstevel@tonic-gate
10617c478bd9Sstevel@tonic-gate static ssize_t
kp_io_read(mdb_io_t * io,void * buf,size_t nbytes)10627c478bd9Sstevel@tonic-gate kp_io_read(mdb_io_t *io, void *buf, size_t nbytes)
10637c478bd9Sstevel@tonic-gate {
10647c478bd9Sstevel@tonic-gate kp_io_t *kpi = io->io_data;
10657c478bd9Sstevel@tonic-gate kp_data_t *kp = kpi->kpi_tgt->t_data;
10667c478bd9Sstevel@tonic-gate
10677c478bd9Sstevel@tonic-gate kp_map_t *kpm = kp_addr_to_kpmap(kp, kpi->kpi_ptr);
10687c478bd9Sstevel@tonic-gate size_t left;
10697c478bd9Sstevel@tonic-gate
10707c478bd9Sstevel@tonic-gate if (kpm != NULL) {
10717c478bd9Sstevel@tonic-gate const mdb_map_t *mp = &kpm->kpm_map;
10727c478bd9Sstevel@tonic-gate left = mp->map_base + mp->map_size - kpi->kpi_ptr;
10737c478bd9Sstevel@tonic-gate } else
10747c478bd9Sstevel@tonic-gate left = 0;
10757c478bd9Sstevel@tonic-gate
10767c478bd9Sstevel@tonic-gate if (left != 0) {
10777c478bd9Sstevel@tonic-gate ssize_t rbytes = kp_vread(kpi->kpi_tgt,
10787c478bd9Sstevel@tonic-gate buf, MIN(nbytes, left), kpi->kpi_ptr);
10797c478bd9Sstevel@tonic-gate
10807c478bd9Sstevel@tonic-gate if (rbytes >= 0)
10817c478bd9Sstevel@tonic-gate kpi->kpi_ptr += rbytes;
10827c478bd9Sstevel@tonic-gate
10837c478bd9Sstevel@tonic-gate return (rbytes);
10847c478bd9Sstevel@tonic-gate }
10857c478bd9Sstevel@tonic-gate
10867c478bd9Sstevel@tonic-gate return (0); /* At end of segment or in hole; return EOF */
10877c478bd9Sstevel@tonic-gate }
10887c478bd9Sstevel@tonic-gate
10897c478bd9Sstevel@tonic-gate static off64_t
kp_io_seek(mdb_io_t * io,off64_t offset,int whence)10907c478bd9Sstevel@tonic-gate kp_io_seek(mdb_io_t *io, off64_t offset, int whence)
10917c478bd9Sstevel@tonic-gate {
10927c478bd9Sstevel@tonic-gate kp_io_t *kpi = io->io_data;
10937c478bd9Sstevel@tonic-gate const mdb_map_t *mp = &kpi->kpi_map->kpm_map;
10947c478bd9Sstevel@tonic-gate uintptr_t nptr;
10957c478bd9Sstevel@tonic-gate
10967c478bd9Sstevel@tonic-gate if (io->io_next != NULL)
10977c478bd9Sstevel@tonic-gate return (IOP_SEEK(io->io_next, offset, whence));
10987c478bd9Sstevel@tonic-gate
10997c478bd9Sstevel@tonic-gate switch (whence) {
11007c478bd9Sstevel@tonic-gate case SEEK_SET:
11017c478bd9Sstevel@tonic-gate nptr = mp->map_base + offset;
11027c478bd9Sstevel@tonic-gate break;
11037c478bd9Sstevel@tonic-gate case SEEK_CUR:
11047c478bd9Sstevel@tonic-gate nptr = kpi->kpi_ptr + offset;
11057c478bd9Sstevel@tonic-gate break;
11067c478bd9Sstevel@tonic-gate case SEEK_END:
11077c478bd9Sstevel@tonic-gate nptr = kpi->kpi_lim + offset;
11087c478bd9Sstevel@tonic-gate break;
11097c478bd9Sstevel@tonic-gate default:
11107c478bd9Sstevel@tonic-gate return (set_errno(EINVAL));
11117c478bd9Sstevel@tonic-gate }
11127c478bd9Sstevel@tonic-gate
11137c478bd9Sstevel@tonic-gate if (nptr < mp->map_base || nptr >= kpi->kpi_lim)
11147c478bd9Sstevel@tonic-gate return (set_errno(EINVAL));
11157c478bd9Sstevel@tonic-gate
11167c478bd9Sstevel@tonic-gate kpi->kpi_ptr = nptr;
11177c478bd9Sstevel@tonic-gate return ((off64_t)(nptr - mp->map_base));
11187c478bd9Sstevel@tonic-gate }
11197c478bd9Sstevel@tonic-gate
11207c478bd9Sstevel@tonic-gate static void
kp_io_close(mdb_io_t * io)11217c478bd9Sstevel@tonic-gate kp_io_close(mdb_io_t *io)
11227c478bd9Sstevel@tonic-gate {
11237c478bd9Sstevel@tonic-gate mdb_free(io->io_data, sizeof (kp_io_t));
11247c478bd9Sstevel@tonic-gate }
11257c478bd9Sstevel@tonic-gate
11267c478bd9Sstevel@tonic-gate static const char *
kp_io_name(mdb_io_t * io)11277c478bd9Sstevel@tonic-gate kp_io_name(mdb_io_t *io)
11287c478bd9Sstevel@tonic-gate {
11297c478bd9Sstevel@tonic-gate kp_io_t *kpi = io->io_data;
11307c478bd9Sstevel@tonic-gate
11317c478bd9Sstevel@tonic-gate if (io->io_next != NULL)
11327c478bd9Sstevel@tonic-gate return (IOP_NAME(io->io_next));
11337c478bd9Sstevel@tonic-gate
11347c478bd9Sstevel@tonic-gate return (kpi->kpi_map->kpm_map.map_name);
11357c478bd9Sstevel@tonic-gate }
11367c478bd9Sstevel@tonic-gate
11377c478bd9Sstevel@tonic-gate static const mdb_io_ops_t kp_io_ops = {
1138*0c1b95beSRichard Lowe .io_read = kp_io_read,
1139*0c1b95beSRichard Lowe .io_write = no_io_write,
1140*0c1b95beSRichard Lowe .io_seek = kp_io_seek,
1141*0c1b95beSRichard Lowe .io_ctl = no_io_ctl,
1142*0c1b95beSRichard Lowe .io_close = kp_io_close,
1143*0c1b95beSRichard Lowe .io_name = kp_io_name,
1144*0c1b95beSRichard Lowe .io_link = no_io_link,
1145*0c1b95beSRichard Lowe .io_unlink = no_io_unlink,
1146*0c1b95beSRichard Lowe .io_setattr = no_io_setattr,
1147*0c1b95beSRichard Lowe .io_suspend = no_io_suspend,
1148*0c1b95beSRichard Lowe .io_resume = no_io_resume,
11497c478bd9Sstevel@tonic-gate };
11507c478bd9Sstevel@tonic-gate
11517c478bd9Sstevel@tonic-gate static mdb_io_t *
kp_io_create(mdb_tgt_t * t,kp_map_t * kpm)11527c478bd9Sstevel@tonic-gate kp_io_create(mdb_tgt_t *t, kp_map_t *kpm)
11537c478bd9Sstevel@tonic-gate {
11547c478bd9Sstevel@tonic-gate kp_data_t *kp = t->t_data;
11557c478bd9Sstevel@tonic-gate mdb_map_t *mp = &kp->kp_map_tail->kpm_map;
11567c478bd9Sstevel@tonic-gate
11577c478bd9Sstevel@tonic-gate mdb_io_t *io = mdb_alloc(sizeof (mdb_io_t), UM_SLEEP);
11587c478bd9Sstevel@tonic-gate kp_io_t *kpi = mdb_alloc(sizeof (kp_io_t), UM_SLEEP);
11597c478bd9Sstevel@tonic-gate
11607c478bd9Sstevel@tonic-gate kpi->kpi_tgt = t;
11617c478bd9Sstevel@tonic-gate kpi->kpi_map = kpm;
11627c478bd9Sstevel@tonic-gate kpi->kpi_ptr = kpm->kpm_map.map_base;
11637c478bd9Sstevel@tonic-gate kpi->kpi_lim = mp->map_base + mp->map_size;
11647c478bd9Sstevel@tonic-gate
11657c478bd9Sstevel@tonic-gate io->io_ops = &kp_io_ops;
11667c478bd9Sstevel@tonic-gate io->io_data = kpi;
11677c478bd9Sstevel@tonic-gate io->io_next = NULL;
11687c478bd9Sstevel@tonic-gate io->io_refcnt = 0;
11697c478bd9Sstevel@tonic-gate
11707c478bd9Sstevel@tonic-gate return (io);
11717c478bd9Sstevel@tonic-gate }
1172