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
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/proc.h>
  32 #include <sys/types.h>
  33 #include <sys/signal.h>
  34 #include <err.h>
  35 #include <inttypes.h>
  36 #include <kvm.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39
  40 #include <defs.h>
  41
  42 #include "kgdb.h"
  43
  44 static uintptr_t dumppcb;
  45 static int dumptid;
  46
  47 static struct kthr *first;
  48 struct kthr *curkthr;
  49
  50 static uintptr_t
  51 lookup(const char *sym)
  52 {
  53         struct nlist nl[2];
  54
  55         nl[0].n_name = (char *)(uintptr_t)sym;
  56         nl[1].n_name = NULL;
  57         if (kvm_nlist(kvm, nl) != 0) {
  58                 warnx("kvm_nlist(%s): %s", sym, kvm_geterr(kvm));
  59                 return (0);
  60         }
  61         return (nl[0].n_value);
  62 }
  63
  64 struct kthr *
  65 kgdb_thr_first(void)
  66 {
  67         return (first);
  68 }
  69
  70 struct kthr *
  71 kgdb_thr_init(void)
  72 {
  73         struct proc p;
  74         struct thread td;
  75         struct kthr *kt;
  76         uintptr_t addr, paddr;
  77
  78         addr = lookup("_allproc");
  79         if (addr == 0)
  80                 return (NULL);
  81         kvm_read(kvm, addr, &paddr, sizeof(paddr));
  82
  83         dumppcb = lookup("_dumppcb");
  84         if (dumppcb == 0)
  85                 return (NULL);
  86
  87         addr = lookup("_dumptid");
  88         if (addr != 0)
  89                 kvm_read(kvm, addr, &dumptid, sizeof(dumptid));
  90         else
  91                 dumptid = -1;
  92
  93         while (paddr != 0) {
  94                 if (kvm_read(kvm, paddr, &p, sizeof(p)) != sizeof(p))
  95                         warnx("kvm_read: %s", kvm_geterr(kvm));
  96                 addr = (uintptr_t)TAILQ_FIRST(&p.p_threads);
  97                 while (addr != 0) {
  98                         if (kvm_read(kvm, addr, &td, sizeof(td)) != sizeof(td))
  99                                 warnx("kvm_read: %s", kvm_geterr(kvm));
 100                         kt = malloc(sizeof(*kt));
 101                         kt->next = first;
 102                         kt->kaddr = addr;
 103                         kt->pcb = (td.td_tid == dumptid) ? dumppcb :
 104                             (uintptr_t)td.td_pcb;
 105                         kt->kstack = td.td_kstack;
 106                         kt->tid = td.td_tid;
 107                         kt->pid = p.p_pid;
 108                         kt->paddr = paddr;
 109                         first = kt;
 110                         addr = (uintptr_t)TAILQ_NEXT(&td, td_plist);
 111                 }
 112                 paddr = (uintptr_t)LIST_NEXT(&p, p_list);
 113         }
 114         curkthr = kgdb_thr_lookup_tid(dumptid);
 115         if (curkthr == NULL)
 116                 curkthr = first;
 117         return (first);
 118 }
 119
 120 struct kthr *
 121 kgdb_thr_lookup_tid(int tid)
 122 {
 123         struct kthr *kt;
 124
 125         kt = first;
 126         while (kt != NULL && kt->tid != tid)
 127                 kt = kt->next;
 128         return (kt);
 129 }
 130
 131 struct kthr *
 132 kgdb_thr_lookup_taddr(uintptr_t taddr)
 133 {
 134         struct kthr *kt;
 135
 136         kt = first;
 137         while (kt != NULL && kt->kaddr != taddr)
 138                 kt = kt->next;
 139         return (kt);
 140 }
 141
 142 struct kthr *
 143 kgdb_thr_lookup_pid(int pid)
 144 {
 145         struct kthr *kt;
 146
 147         kt = first;
 148         while (kt != NULL && kt->pid != pid)
 149                 kt = kt->next;
 150         return (kt);
 151 }
 152
 153 struct kthr *
 154 kgdb_thr_lookup_paddr(uintptr_t paddr)
 155 {
 156         struct kthr *kt;
 157
 158         kt = first;
 159         while (kt != NULL && kt->paddr != paddr)
 160                 kt = kt->next;
 161         return (kt);
 162 }
 163
 164 struct kthr *
 165 kgdb_thr_next(struct kthr *kt)
 166 {
 167         return (kt->next);
 168 }
 169
 170 struct kthr *
 171 kgdb_thr_select(struct kthr *kt)
 172 {
 173         struct kthr *pcur;
 174
 175         pcur = curkthr;
 176         curkthr = kt;
 177         return (pcur);
 178 }
 179
 180 char *
 181 kgdb_thr_extra_thread_info(int tid)
 182 {
 183         struct kthr *kt;
 184         struct proc *p;
 185         static char comm[MAXCOMLEN + 1];
 186
 187         kt = kgdb_thr_lookup_tid(tid);
 188         if (kt == NULL)
 189                 return (NULL);
 190         p = (struct proc *)kt->paddr;
 191         if (kvm_read(kvm, (uintptr_t)&p->p_comm[0], &comm, sizeof(comm)) !=
 192             sizeof(comm))
 193                 return (NULL);
 194
 195         return (comm);
 196 }