kgdb(1): _KERNEL_STRUCTURES is defined globally, so don't redefine it here.
[dragonfly.git] / gnu / usr.bin / gdb / kgdb / kthr.c
blob90347811f52fc6d2d0a5e2635bd0715699632754
1 /*
2 * Copyright (c) 2004 Marcel Moolenaar
3 * All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
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.
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.5 2008/01/14 21:36:38 corecode Exp $
30 #include <sys/cdefs.h>
32 #include <sys/param.h>
33 #include <machine/globaldata.h>
34 #include <sys/user.h>
35 #include <sys/types.h>
36 #include <sys/signal.h>
37 #include <err.h>
38 #include <inttypes.h>
39 #include <kvm.h>
40 #include <stdio.h>
41 #include <stdlib.h>
43 #include <defs.h>
44 #include <frame-unwind.h>
46 #include "kgdb.h"
48 static uintptr_t dumppcb;
49 static int dumptid;
51 static struct kthr *first;
52 struct kthr *curkthr;
54 struct kthr *
55 kgdb_thr_first(void)
57 return (first);
60 struct kthr *
61 kgdb_thr_init(void)
63 struct proc p;
64 struct lwp lwp;
65 struct thread td;
66 struct mdglobaldata gd;
67 struct kthr *kt;
68 uintptr_t addr, paddr, prvspace;
69 int cpu, ncpus;
71 addr = lookup("_ncpus");
72 if (addr == 0)
73 return (NULL);
74 kvm_read(kvm, addr, &ncpus, sizeof(ncpus));
76 dumppcb = lookup("_dumppcb");
77 if (dumppcb == 0)
78 return (NULL);
80 prvspace = lookup("CPU_prvspace");
81 if (prvspace == 0)
82 return (NULL);
84 addr = lookup("_dumpthread");
85 if (addr != 0) {
86 kvm_read(kvm, addr, &dumptid, sizeof(dumptid));
87 } else {
89 * XXX Well then. We don't know who dumped us.
90 * We could do some fancy stack matching, but
91 * I doubt this will work. For now just use
92 * cpu0's curthread.
94 * Actually we don't even know if we were dumped
95 * or if we are life. Find out by querying "dumping".
97 int dumping = 0;
99 addr = lookup("_dumping");
100 kvm_read(kvm, addr, &dumping, sizeof(dumping));
101 if (dumping) {
102 kvm_read(kvm, prvspace +
103 offsetof(struct privatespace, mdglobaldata),
104 &gd, sizeof(struct mdglobaldata));
105 dumptid = (intptr_t)gd.mi.gd_curthread;
106 } else {
107 /* We must be a live system */
108 dumptid = -1;
112 for (cpu = 0; cpu < ncpus; cpu++) {
113 kvm_read(kvm, prvspace +
114 cpu * sizeof(struct privatespace) +
115 offsetof(struct privatespace, mdglobaldata),
116 &gd, sizeof(struct mdglobaldata));
118 addr = (uintptr_t)TAILQ_FIRST(&gd.mi.gd_tdallq);
119 while (addr != 0) {
120 if (kvm_read(kvm, addr, &td, sizeof(td)) != sizeof(td)) {
121 warnx("kvm_read: %s, while accessing thread",
122 kvm_geterr(kvm));
123 break;
125 kt = malloc(sizeof(*kt));
126 kt->next = first;
127 kt->kaddr = addr;
128 kt->tid = addr; /* XXX do we have tids? */
129 kt->pcb = (kt->tid == dumptid) ? dumppcb :
130 (uintptr_t)td.td_pcb;
131 kt->kstack = (uintptr_t)td.td_kstack;
132 if (td.td_proc != NULL) {
133 paddr = (uintptr_t)td.td_proc;
134 if (kvm_read(kvm, paddr, &p, sizeof(p)) != sizeof(p))
135 warnx("kvm_read: %s", kvm_geterr(kvm));
136 kt->pid = p.p_pid;
137 kt->paddr = paddr;
138 } else {
140 * XXX for some stupid reason, gdb uses pid == -1
141 * as a marker for "dead" threads, so we have to
142 * hook all kernel threads on a different pid :/
144 kt->pid = -2;
145 kt->paddr = 0;
147 * We are a kernel thread, so our td_pcb is
148 * not used anyways. An exception is the
149 * dumping thread.
150 * kt->pcb == 0 is a marker for
151 * "non-dumping kernel thread".
153 if (kt->tid != dumptid)
154 kt->pcb = 0;
156 first = kt;
157 addr = (uintptr_t)TAILQ_NEXT(&td, td_allq);
161 curkthr = kgdb_thr_lookup_tid(dumptid);
162 if (curkthr == NULL)
163 curkthr = first;
164 return (first);
167 struct kthr *
168 kgdb_thr_lookup_tid(int tid)
170 struct kthr *kt;
172 kt = first;
173 while (kt != NULL && kt->tid != tid)
174 kt = kt->next;
175 return (kt);
178 struct kthr *
179 kgdb_thr_lookup_taddr(uintptr_t taddr)
181 struct kthr *kt;
183 kt = first;
184 while (kt != NULL && kt->kaddr != taddr)
185 kt = kt->next;
186 return (kt);
189 struct kthr *
190 kgdb_thr_lookup_pid(int pid)
192 struct kthr *kt;
194 kt = first;
195 while (kt != NULL && kt->pid != pid)
196 kt = kt->next;
197 return (kt);
200 struct kthr *
201 kgdb_thr_lookup_paddr(uintptr_t paddr)
203 struct kthr *kt;
205 kt = first;
206 while (kt != NULL && kt->paddr != paddr)
207 kt = kt->next;
208 return (kt);
211 struct kthr *
212 kgdb_thr_next(struct kthr *kt)
214 return (kt->next);
217 struct kthr *
218 kgdb_thr_select(struct kthr *kt)
220 struct kthr *pcur;
222 pcur = curkthr;
223 curkthr = kt;
224 return (pcur);
227 char *
228 kgdb_thr_extra_thread_info(int tid)
230 struct kthr *kt;
231 static char comm[MAXCOMLEN + 1];
233 kt = kgdb_thr_lookup_tid(tid);
234 if (kt == NULL)
235 return (NULL);
236 if (kvm_read(kvm, kt->kaddr + offsetof(struct thread, td_comm), &comm,
237 sizeof(comm)) != sizeof(comm))
238 return (NULL);
240 return (comm);