gnu/usr.bin/gdb/kgdb/kthr.c

   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.5 2008/01/14 21:36:38 corecode Exp $
  28  */
  29
  30 #include <sys/cdefs.h>
  31
  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>
  42
  43 #include <defs.h>
  44 #include <frame-unwind.h>
  45
  46 #include "kgdb.h"
  47
  48 static uintptr_t dumppcb;
  49 static int dumptid;
  50
  51 static struct kthr *first;
  52 struct kthr *curkthr;
  53
  54 struct kthr *
  55 kgdb_thr_first(void)
  56 {
  57         return (first);
  58 }
  59
  60 struct kthr *
  61 kgdb_thr_init(void)
  62 {
  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;
  70
  71         addr = lookup("_ncpus");
  72         if (addr == 0)
  73                 return (NULL);
  74         kvm_read(kvm, addr, &ncpus, sizeof(ncpus));
  75
  76         dumppcb = lookup("_dumppcb");
  77         if (dumppcb == 0)
  78                 return (NULL);
  79
  80         prvspace = lookup("CPU_prvspace");
  81         if (prvspace == 0)
  82                 return (NULL);
  83
  84         addr = lookup("_dumpthread");
  85         if (addr != 0) {
  86                 kvm_read(kvm, addr, &dumptid, sizeof(dumptid));
  87         } else {
  88                 /*
  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.
  93                  *
  94                  * Actually we don't even know if we were dumped
  95                  * or if we are life.  Find out by querying "dumping".
  96                  */
  97                 int dumping = 0;
  98
  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;
 109                 }
 110         }
 111
 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));
 117
 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;
 124                         }
 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 {
 139                                 /*
 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 :/
 143                                  */
 144                                 kt->pid = -2;
 145                                 kt->paddr = 0;
 146                                 /*
 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".
 152                                  */
 153                                 if (kt->tid != dumptid)
 154                                         kt->pcb = 0;
 155                         }
 156                         first = kt;
 157                         addr = (uintptr_t)TAILQ_NEXT(&td, td_allq);
 158                 }
 159         }
 160
 161         curkthr = kgdb_thr_lookup_tid(dumptid);
 162         if (curkthr == NULL)
 163                 curkthr = first;
 164         return (first);
 165 }
 166
 167 struct kthr *
 168 kgdb_thr_lookup_tid(int tid)
 169 {
 170         struct kthr *kt;
 171
 172         kt = first;
 173         while (kt != NULL && kt->tid != tid)
 174                 kt = kt->next;
 175         return (kt);
 176 }
 177
 178 struct kthr *
 179 kgdb_thr_lookup_taddr(uintptr_t taddr)
 180 {
 181         struct kthr *kt;
 182
 183         kt = first;
 184         while (kt != NULL && kt->kaddr != taddr)
 185                 kt = kt->next;
 186         return (kt);
 187 }
 188
 189 struct kthr *
 190 kgdb_thr_lookup_pid(int pid)
 191 {
 192         struct kthr *kt;
 193
 194         kt = first;
 195         while (kt != NULL && kt->pid != pid)
 196                 kt = kt->next;
 197         return (kt);
 198 }
 199
 200 struct kthr *
 201 kgdb_thr_lookup_paddr(uintptr_t paddr)
 202 {
 203         struct kthr *kt;
 204
 205         kt = first;
 206         while (kt != NULL && kt->paddr != paddr)
 207                 kt = kt->next;
 208         return (kt);
 209 }
 210
 211 struct kthr *
 212 kgdb_thr_next(struct kthr *kt)
 213 {
 214         return (kt->next);
 215 }
 216
 217 struct kthr *
 218 kgdb_thr_select(struct kthr *kt)
 219 {
 220         struct kthr *pcur;
 221
 222         pcur = curkthr;
 223         curkthr = kt;
 224         return (pcur);
 225 }
 226
 227 char *
 228 kgdb_thr_extra_thread_info(int tid)
 229 {
 230         struct kthr *kt;
 231         static char comm[MAXCOMLEN + 1];
 232
 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);
 239
 240         return (comm);
 241 }