test/debug/wildcardinfo.c

   1 /*
   2  * WILDCARDINFO.C
   3  *
   4  * cc -I/usr/src/sys wildcardinfo.c -o /usr/local/bin/wildcardinfo -lkvm
   5  *
   6  * wildcardinfo
   7  *
   8  * Dump the tcbinfo[] array and wildcard hash table for each cpu.
   9  *
  10  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
  11  *
  12  * This code is derived from software contributed to The DragonFly Project
  13  * by Matthew Dillon <dillon@backplane.com>
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  *
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in
  23  *    the documentation and/or other materials provided with the
  24  *    distribution.
  25  * 3. Neither the name of The DragonFly Project nor the names of its
  26  *    contributors may be used to endorse or promote products derived
  27  *    from this software without specific, prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  32  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  33  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  35  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  36  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  37  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  38  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  39  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40  * SUCH DAMAGE.
  41  *
  42  * $DragonFly: src/test/debug/wildcardinfo.c,v 1.1 2005/04/05 02:49:15 dillon Exp $
  43  */
  44
  45 #define _KERNEL_STRUCTURES_
  46 #include <sys/param.h>
  47 #include <sys/user.h>
  48 #include <sys/malloc.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/socket.h>
  51 #include <sys/socketvar.h>
  52 #include <net/route.h>
  53 #include <net/if.h>
  54 #include <net/if_var.h>
  55 #include <net/netisr.h>
  56 #include <netinet/in_systm.h>
  57 #include <netinet/in.h>
  58 #include <netinet/ip.h>
  59 #include <netinet/in_pcb.h>
  60 #include <netinet/in_var.h>
  61 #include <arpa/inet.h>
  62
  63 #include <stdio.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66 #include <fcntl.h>
  67 #include <kvm.h>
  68 #include <nlist.h>
  69 #include <getopt.h>
  70
  71 struct nlist Nl[] = {
  72     { "_ncpus" },
  73     { "_tcbinfo" },
  74     { NULL }
  75 };
  76
  77 static void dumptcb(kvm_t *kd, intptr_t tcbinfo);
  78 static void dumpinpcontainerhead(kvm_t *kd, int index, void *kptr);
  79 static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
  80
  81 int
  82 main(int ac, char **av)
  83 {
  84     kvm_t *kd;
  85     int i;
  86     int ch;
  87     int ncpus;
  88     const char *corefile = NULL;
  89     const char *sysfile = NULL;
  90
  91     while ((ch = getopt(ac, av, "M:N:")) != -1) {
  92         switch(ch) {
  93         case 'M':
  94             corefile = optarg;
  95             break;
  96         case 'N':
  97             sysfile = optarg;
  98             break;
  99         default:
 100             fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
 101             exit(1);
 102         }
 103     }
 104
 105     if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
 106         perror("kvm_open");
 107         exit(1);
 108     }
 109     if (kvm_nlist(kd, Nl) != 0) {
 110         perror("kvm_nlist");
 111         exit(1);
 112     }
 113     kkread(kd, Nl[0].n_value, &ncpus, sizeof(ncpus));
 114     for (i = 0; i < ncpus; ++i) {
 115         printf("CPU %d\n", i);
 116         dumptcb(kd, (intptr_t)Nl[1].n_value + i * sizeof(struct inpcbinfo));
 117     }
 118     return(0);
 119 }
 120
 121 static
 122 void
 123 dumptcb(kvm_t *kd, intptr_t tcbaddr)
 124 {
 125     struct inpcbinfo info;
 126     struct inpcbportinfo pinfo;
 127     int i;
 128
 129     kkread(kd, tcbaddr, &info, sizeof(info));
 130     kkread(kd, (intptr_t)info.portinfo, &pinfo, sizeof(pinfo));
 131     printf("    hashbase %p\n", info.hashbase);
 132     printf("    hashmask %ld\n", info.hashmask);
 133     printf("    porthashbase %p\n", pinfo.porthashbase);
 134     printf("    porthashmask %lu\n", pinfo.porthashcnt);
 135     printf("    wildcardhashbase %p\n", info.wildcardhashbase);
 136     printf("    wildcardhashmask %lu\n", info.wildcardhashmask);
 137     printf("    ipi_size %zu\n", info.ipi_size);
 138     printf("    ipi_count %d\n", (int)info.ipi_count);
 139     printf("    ipi_gencnt %lld\n", (long long)info.ipi_gencnt);
 140     printf("    cpu %d\n", info.cpu);
 141     for (i = 0; i <= info.wildcardhashmask; ++i)
 142         dumpinpcontainerhead(kd, i, info.wildcardhashbase + i);
 143 }
 144
 145 static
 146 void
 147 dumpinpcontainerhead(kvm_t *kd, int index, void *kptr)
 148 {
 149     struct inpcontainerhead head;
 150     struct inpcontainer node;
 151     struct inpcb pcb;
 152
 153     kkread(kd, (intptr_t)kptr, &head, sizeof(head));
 154     if (head.lh_first == NULL)
 155         return;
 156     printf("\tinpcontainer list at index %d {\n", index);
 157     for (kptr = head.lh_first; kptr; kptr = node.ic_list.le_next)  {
 158         kkread(kd, (intptr_t)kptr, &node, sizeof(node));
 159         printf("\t    inpcontainer %p inpcb %p", kptr, node.ic_inp);
 160         if (node.ic_inp) {
 161                 printf(" {\n");
 162                 kkread(kd, (intptr_t)node.ic_inp, &pcb, sizeof(pcb));
 163                 printf("\t\tlocal %s:%d foreign %s:%d\n",
 164                         inet_ntoa(pcb.inp_inc.inc_laddr),
 165                         ntohs(pcb.inp_inc.inc_lport),
 166                         inet_ntoa(pcb.inp_inc.inc_faddr),
 167                         ntohs(pcb.inp_inc.inc_fport));
 168                 printf("\t    }");
 169         }
 170         printf("\n");
 171     }
 172     printf("\t}\n");
 173 }
 174
 175 static void
 176 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
 177 {
 178     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
 179         perror("kvm_read");
 180         exit(1);
 181     }
 182 }
 183