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 #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 = (intptr_t)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 == 0 is a marker for
 150                                  * "non-dumping kernel thread".
 151                                  */
 152                                 if (kt->tid != dumptid)
 153                                         kt->pcb = 0;
 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 }