1 /* 2 * Copyright (c) 2004 Marcel Moolenaar 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * $FreeBSD: src/gnu/usr.bin/gdb/kgdb/kthr.c,v 1.3 2005/09/10 18:25:53 marcel Exp $ 27 * $DragonFly: src/gnu/usr.bin/gdb/kgdb/kthr.c,v 1.3 2007/08/25 21:59:05 corecode Exp $ 28 */ 29 30 #define _KERNEL_STRUCTURES 31 32 #include <sys/cdefs.h> 33 34 #include <sys/param.h> 35 #include <machine/globaldata.h> 36 #include <sys/user.h> 37 #include <sys/types.h> 38 #include <sys/signal.h> 39 #include <err.h> 40 #include <inttypes.h> 41 #include <kvm.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 45 #include <defs.h> 46 #include <frame-unwind.h> 47 48 #include "kgdb.h" 49 50 static uintptr_t dumppcb; 51 static int dumptid; 52 53 static struct kthr *first; 54 struct kthr *curkthr; 55 56 struct kthr * 57 kgdb_thr_first(void) 58 { 59 return (first); 60 } 61 62 struct kthr * 63 kgdb_thr_init(void) 64 { 65 struct proc p; 66 struct lwp lwp; 67 struct thread td; 68 struct mdglobaldata gd; 69 struct kthr *kt; 70 uintptr_t addr, paddr, prvspace; 71 int cpu, ncpus; 72 73 addr = lookup("_ncpus"); 74 if (addr == 0) 75 return (NULL); 76 kvm_read(kvm, addr, &ncpus, sizeof(ncpus)); 77 78 dumppcb = lookup("_dumppcb"); 79 if (dumppcb == 0) 80 return (NULL); 81 82 prvspace = lookup("CPU_prvspace"); 83 if (prvspace == 0) 84 return (NULL); 85 86 addr = lookup("_dumpthread"); 87 if (addr != 0) { 88 kvm_read(kvm, addr, &dumptid, sizeof(dumptid)); 89 } else { 90 /* 91 * XXX Well then. We don't know who dumped us. 92 * We could do some fancy stack matching, but 93 * I doubt this will work. For now just use 94 * cpu0's curthread. 95 * 96 * Actually we don't even know if we were dumped 97 * or if we are life. Find out by querying "dumping". 98 */ 99 int dumping = 0; 100 101 addr = lookup("_dumping"); 102 kvm_read(kvm, addr, &dumping, sizeof(dumping)); 103 if (dumping) { 104 kvm_read(kvm, prvspace + 105 offsetof(struct privatespace, mdglobaldata), 106 &gd, sizeof(struct mdglobaldata)); 107 dumptid = gd.mi.gd_curthread; 108 } else { 109 /* We must be a live system */ 110 dumptid = -1; 111 } 112 } 113 114 for (cpu = 0; cpu < ncpus; cpu++) { 115 kvm_read(kvm, prvspace + 116 cpu * sizeof(struct privatespace) + 117 offsetof(struct privatespace, mdglobaldata), 118 &gd, sizeof(struct mdglobaldata)); 119 120 addr = (uintptr_t)TAILQ_FIRST(&gd.mi.gd_tdallq); 121 while (addr != 0) { 122 if (kvm_read(kvm, addr, &td, sizeof(td)) != sizeof(td)) 123 warnx("kvm_read: %s", kvm_geterr(kvm)); 124 kt = malloc(sizeof(*kt)); 125 kt->next = first; 126 kt->kaddr = addr; 127 kt->tid = addr; /* XXX do we have tids? */ 128 kt->pcb = (kt->tid == dumptid) ? dumppcb : 129 (uintptr_t)td.td_pcb; 130 kt->kstack = (uintptr_t)td.td_kstack; 131 if (td.td_proc != NULL) { 132 paddr = (uintptr_t)td.td_proc; 133 if (kvm_read(kvm, paddr, &p, sizeof(p)) != sizeof(p)) 134 warnx("kvm_read: %s", kvm_geterr(kvm)); 135 kt->pid = p.p_pid; 136 kt->paddr = paddr; 137 } else { 138 /* 139 * XXX for some stupid reason, gdb uses pid == -1 140 * as a marker for "dead" threads, so we have to 141 * hook all kernel threads on a different pid :/ 142 */ 143 kt->pid = -2; 144 kt->paddr = 0; 145 /* 146 * We are a kernel thread, so our td_pcb is 147 * not used anyways. An exception is the 148 * dumping thread. 149 * kt->pcb == NULL is a marker for 150 * "non-dumping kernel thread". 151 */ 152 if (kt->tid != dumptid) 153 kt->pcb = NULL; 154 } 155 first = kt; 156 addr = (uintptr_t)TAILQ_NEXT(&td, td_allq); 157 } 158 } 159 160 curkthr = kgdb_thr_lookup_tid(dumptid); 161 if (curkthr == NULL) 162 curkthr = first; 163 return (first); 164 } 165 166 struct kthr * 167 kgdb_thr_lookup_tid(int tid) 168 { 169 struct kthr *kt; 170 171 kt = first; 172 while (kt != NULL && kt->tid != tid) 173 kt = kt->next; 174 return (kt); 175 } 176 177 struct kthr * 178 kgdb_thr_lookup_taddr(uintptr_t taddr) 179 { 180 struct kthr *kt; 181 182 kt = first; 183 while (kt != NULL && kt->kaddr != taddr) 184 kt = kt->next; 185 return (kt); 186 } 187 188 struct kthr * 189 kgdb_thr_lookup_pid(int pid) 190 { 191 struct kthr *kt; 192 193 kt = first; 194 while (kt != NULL && kt->pid != pid) 195 kt = kt->next; 196 return (kt); 197 } 198 199 struct kthr * 200 kgdb_thr_lookup_paddr(uintptr_t paddr) 201 { 202 struct kthr *kt; 203 204 kt = first; 205 while (kt != NULL && kt->paddr != paddr) 206 kt = kt->next; 207 return (kt); 208 } 209 210 struct kthr * 211 kgdb_thr_next(struct kthr *kt) 212 { 213 return (kt->next); 214 } 215 216 struct kthr * 217 kgdb_thr_select(struct kthr *kt) 218 { 219 struct kthr *pcur; 220 221 pcur = curkthr; 222 curkthr = kt; 223 return (pcur); 224 } 225 226 char * 227 kgdb_thr_extra_thread_info(int tid) 228 { 229 struct kthr *kt; 230 static char comm[MAXCOMLEN + 1]; 231 232 kt = kgdb_thr_lookup_tid(tid); 233 if (kt == NULL) 234 return (NULL); 235 if (kvm_read(kvm, kt->kaddr + offsetof(struct thread, td_comm), &comm, 236 sizeof(comm)) != sizeof(comm)) 237 return (NULL); 238 239 return (comm); 240 } 241