usr/src/cmd/mdb/i86xpv/modules/xpv_psm/xpv_psm.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright (c) 2013 by Delphix. All rights reserved.
  27  */
  28
  29 #include <mdb/mdb_modapi.h>
  30 #include <mdb/mdb_ks.h>
  31 #include <mdb/mdb_ctf.h>
  32 #include <sys/evtchn_impl.h>
  33 #include <errno.h>
  34 #include <sys/xc_levels.h>
  35
  36 #include "intr_common.h"
  37
  38 typedef struct mdb_shared_info {
  39         unsigned long evtchn_pending[sizeof (unsigned long) * NBBY];
  40         unsigned long evtchn_mask[sizeof (unsigned long) * NBBY];
  41 } mdb_shared_info_t;
  42
  43 static mdb_shared_info_t shared_info;
  44 static int have_shared_info;
  45 static uintptr_t evtchn_cpus_addr;
  46 static struct av_head avec_tbl[NR_IRQS];
  47 static irq_info_t irq_tbl[NR_IRQS];
  48 static mec_info_t ipi_tbl[MAXIPL];
  49 static mec_info_t virq_tbl[NR_VIRQS];
  50 static short evtchn_tbl[NR_EVENT_CHANNELS];
  51 static apic_irq_t *apic_irq_tbl[APIC_MAX_VECTOR+1];
  52 static char level_tbl[APIC_MAX_VECTOR+1];
  53
  54 static int
  55 update_tables(void)
  56 {
  57         GElf_Sym sym;
  58         uintptr_t shared_info_addr;
  59
  60         if (mdb_readvar(&irq_tbl, "irq_info") == -1) {
  61                 mdb_warn("failed to read irq_info");
  62                 return (0);
  63         }
  64
  65         if (mdb_readvar(&ipi_tbl, "ipi_info") == -1) {
  66                 mdb_warn("failed to read ipi_info");
  67                 return (0);
  68         }
  69
  70         if (mdb_readvar(&avec_tbl, "autovect") == -1) {
  71                 mdb_warn("failed to read autovect");
  72                 return (0);
  73         }
  74
  75         if (mdb_readvar(&irq_tbl, "irq_info") == -1) {
  76                 mdb_warn("failed to read irq_info");
  77                 return (0);
  78         }
  79
  80         if (mdb_readvar(&ipi_tbl, "ipi_info") == -1) {
  81                 mdb_warn("failed to read ipi_info");
  82                 return (0);
  83         }
  84
  85         if (mdb_readvar(&virq_tbl, "virq_info") == -1) {
  86                 mdb_warn("failed to read virq_info");
  87                 return (0);
  88         }
  89
  90         if (mdb_readvar(&evtchn_tbl, "evtchn_to_irq") == -1) {
  91                 mdb_warn("failed to read evtchn_to_irq");
  92                 return (0);
  93         }
  94
  95         if (mdb_readvar(&apic_irq_tbl, "apic_irq_table") == -1) {
  96                 mdb_warn("failed to read apic_irq_table");
  97                 return (0);
  98         }
  99
 100         if (mdb_readvar(&level_tbl, "apic_level_intr") == -1) {
 101                 mdb_warn("failed to read apic_level_intr");
 102                 return (0);
 103         }
 104
 105         if (mdb_lookup_by_name("evtchn_cpus", &sym) == -1) {
 106                 mdb_warn("failed to lookup evtchn_cpus");
 107                 return (0);
 108         }
 109
 110         evtchn_cpus_addr = sym.st_value;
 111
 112         if (mdb_readvar(&shared_info_addr, "HYPERVISOR_shared_info") == -1) {
 113                 mdb_warn("failed to read HYPERVISOR_shared_info");
 114                 return (0);
 115         }
 116
 117         /*
 118          * It's normal for this to fail with a domain dump.
 119          */
 120         if (mdb_ctf_vread(&shared_info, "shared_info_t", "mdb_shared_info_t",
 121             shared_info_addr, MDB_CTF_VREAD_QUIET) != -1)
 122                 have_shared_info = 1;
 123
 124         return (1);
 125 }
 126
 127 static const char *
 128 virq_type(int irq)
 129 {
 130         int i;
 131
 132         for (i = 0; i < NR_VIRQS; i++) {
 133                 if (virq_tbl[i].mi_irq == irq)
 134                         break;
 135         }
 136
 137         switch (i) {
 138         case VIRQ_TIMER:
 139                 return ("virq:timer");
 140         case VIRQ_DEBUG:
 141                 return ("virq:debug");
 142         case VIRQ_CONSOLE:
 143                 return ("virq:console");
 144         case VIRQ_DOM_EXC:
 145                 return ("virq:dom exc");
 146         case VIRQ_DEBUGGER:
 147                 return ("virq:debugger");
 148         case VIRQ_MCA:
 149                 return ("virq:mca");
 150         default:
 151                 break;
 152         }
 153
 154         return ("virq:?");
 155 }
 156
 157 static const char *
 158 irq_type(int irq, int extended)
 159 {
 160         switch (irq_tbl[irq].ii_type) {
 161         case IRQT_UNBOUND:
 162                 return ("unset");
 163         case IRQT_PIRQ:
 164                 return ("pirq");
 165         case IRQT_VIRQ:
 166                 if (extended)
 167                         return (virq_type(irq));
 168                 return ("virq");
 169         case IRQT_IPI:
 170                 return ("ipi");
 171         case IRQT_EVTCHN:
 172                 return ("evtchn");
 173         case IRQT_DEV_EVTCHN:
 174                 return ("device");
 175         }
 176
 177         return ("?");
 178 }
 179
 180 /*
 181  * We need a non-trivial IPL lookup as the CPU poke's IRQ doesn't have ii_ipl
 182  * set -- see evtchn.h.
 183  */
 184 static int
 185 irq_ipl(int irq)
 186 {
 187         int i;
 188
 189         if (irq_tbl[irq].ii_u2.ipl != 0)
 190                 return (irq_tbl[irq].ii_u2.ipl);
 191
 192         for (i = 0; i < MAXIPL; i++) {
 193                 if (ipi_tbl[i].mi_irq == irq) {
 194                         return (i);
 195                 }
 196         }
 197
 198         return (0);
 199 }
 200
 201 static void
 202 print_cpu(irq_info_t *irqp, int evtchn)
 203 {
 204         size_t cpuset_size = BT_BITOUL(NCPU) * sizeof (ulong_t);
 205         int cpu;
 206
 207         if (irqp != NULL) {
 208                 switch (irqp->ii_type) {
 209                 case IRQT_VIRQ:
 210                 case IRQT_IPI:
 211                         mdb_printf("all ");
 212                         return;
 213
 214                 case IRQT_DEV_EVTCHN:
 215                         mdb_printf("0   ");
 216                         return;
 217
 218                 default:
 219                         break;
 220                 }
 221         }
 222
 223         if (evtchn >= NR_EVENT_CHANNELS || evtchn == 0) {
 224                 mdb_printf("-   ");
 225                 return;
 226         }
 227
 228         cpu = mdb_cpuset_find(evtchn_cpus_addr +
 229             (cpuset_size * evtchn));
 230
 231         /*
 232          * XXPV: we should verify this against the CPU's mask and show
 233          * something if they don't match.
 234          */
 235         mdb_printf("%-4d", cpu);
 236 }
 237
 238 static void
 239 print_isr(int i)
 240 {
 241         if (avec_tbl[i].avh_link != NULL) {
 242                 struct autovec avhp;
 243
 244                 (void) mdb_vread(&avhp, sizeof (struct autovec),
 245                     (uintptr_t)avec_tbl[i].avh_link);
 246
 247                 interrupt_print_isr((uintptr_t)avhp.av_vector,
 248                     (uintptr_t)avhp.av_intarg1, (uintptr_t)avhp.av_dip);
 249         } else if (irq_ipl(i) == XC_CPUPOKE_PIL) {
 250                 mdb_printf("poke_cpu");
 251         }
 252 }
 253
 254 static int
 255 evtchn_masked(int i)
 256 {
 257         return (!!TEST_EVTCHN_BIT(i, &shared_info.evtchn_mask[0]));
 258 }
 259
 260 static int
 261 evtchn_pending(int i)
 262 {
 263         return (!!TEST_EVTCHN_BIT(i, &shared_info.evtchn_pending[0]));
 264 }
 265
 266 typedef struct mdb_xpv_psm_autovec {
 267         dev_info_t *av_dip;
 268 } mdb_xpv_psm_autovec_t;
 269
 270 static void
 271 print_bus(int irq)
 272 {
 273         char parent[7];
 274         uintptr_t dip_addr;
 275         struct dev_info dev_info;
 276         mdb_xpv_psm_autovec_t avhp;
 277
 278         if (mdb_ctf_vread(&avhp, "struct autovec", "mdb_xpv_psm_autovec_t",
 279             (uintptr_t)avec_tbl[irq].avh_link, MDB_CTF_VREAD_QUIET) == -1)
 280                 goto fail;
 281
 282         dip_addr = (uintptr_t)avhp.av_dip;
 283
 284         if (dip_addr == (uintptr_t)NULL)
 285                 goto fail;
 286
 287         /*
 288          * Sigh.  As a result of the perennial confusion of how you do opaque
 289          * handles, dev_info_t has a funny old type, which means we can't use
 290          * mdb_ctf_vread() here.
 291          */
 292
 293         if (mdb_vread(&dev_info, sizeof (struct dev_info), dip_addr) == -1)
 294                 goto fail;
 295
 296         dip_addr = (uintptr_t)dev_info.devi_parent;
 297
 298         if (mdb_vread(&dev_info, sizeof (struct dev_info), dip_addr) == -1)
 299                 goto fail;
 300
 301         if (mdb_readstr(parent, 7, (uintptr_t)dev_info.devi_node_name) == -1)
 302                 goto fail;
 303
 304         mdb_printf("%-6s ", parent);
 305         return;
 306
 307 fail:
 308         mdb_printf("-      ");
 309 }
 310
 311 static void
 312 ec_interrupt_dump(int i)
 313 {
 314         irq_info_t *irqp = &irq_tbl[i];
 315         char evtchn[8];
 316
 317         if (irqp->ii_type == IRQT_UNBOUND)
 318                 return;
 319
 320         if (option_flags & INTR_DISPLAY_INTRSTAT) {
 321                 print_cpu(irqp, irqp->ii_u.evtchn);
 322                 print_isr(i);
 323                 mdb_printf("\n");
 324                 return;
 325         }
 326
 327         switch (irqp->ii_type) {
 328         case IRQT_EVTCHN:
 329         case IRQT_VIRQ:
 330                 if (irqp->ii_u.index == VIRQ_TIMER) {
 331                         strcpy(evtchn, "T");
 332                 } else {
 333                         mdb_snprintf(evtchn, sizeof (evtchn), "%-7d",
 334                             irqp->ii_u.evtchn);
 335                 }
 336                 break;
 337         case IRQT_IPI:
 338                 strcpy(evtchn, "I");
 339                 break;
 340         case IRQT_DEV_EVTCHN:
 341                 strcpy(evtchn, "D");
 342                 break;
 343         }
 344
 345         /* IRQ */
 346         mdb_printf("%3d  ", i);
 347         /* Vector */
 348         mdb_printf("-    ");
 349         /* Evtchn */
 350         mdb_printf("%-7s", evtchn);
 351         /* IPL */
 352         mdb_printf("%-4d", irq_ipl(i));
 353         /* Bus */
 354         print_bus(i);
 355         /* Trigger */
 356         mdb_printf("%-4s", "Edg");
 357         /* Type */
 358         mdb_printf("%-7s", irq_type(i, 0));
 359         /* CPU */
 360         print_cpu(irqp, irqp->ii_u.evtchn);
 361         /* Share */
 362         mdb_printf("-     ");
 363         /* APIC/INT# */
 364         mdb_printf("-         ");
 365
 366         print_isr(i);
 367
 368         mdb_printf("\n");
 369 }
 370
 371 /* ARGSUSED */
 372 static int
 373 interrupts_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 374 {
 375         int i;
 376
 377         option_flags = 0;
 378         if (mdb_getopts(argc, argv,
 379             'd', MDB_OPT_SETBITS, INTR_DISPLAY_DRVR_INST, &option_flags,
 380             'i', MDB_OPT_SETBITS, INTR_DISPLAY_INTRSTAT, &option_flags,
 381             NULL) != argc)
 382                 return (DCMD_USAGE);
 383
 384         if (!update_tables())
 385                 return (DCMD_ERR);
 386
 387         if (option_flags & INTR_DISPLAY_INTRSTAT) {
 388                 mdb_printf("%<u>CPU ");
 389         } else {
 390                 mdb_printf("%<u>IRQ  Vect Evtchn IPL Bus    Trg Type   "
 391                     "CPU Share APIC/INT# ");
 392         }
 393         mdb_printf("%s %</u>\n", option_flags & INTR_DISPLAY_DRVR_INST ?
 394             "Driver Name(s)" : "ISR(s)");
 395
 396         for (i = 0; i < NR_IRQS; i++) {
 397                 if (irq_tbl[i].ii_type == IRQT_PIRQ) {
 398                         apic_irq_t airq;
 399
 400                         if (irq_tbl[i].ii_u.evtchn == 0)
 401                                 continue;
 402
 403                         if (mdb_vread(&airq, sizeof (apic_irq_t),
 404                             (uintptr_t)apic_irq_tbl[i]) == -1)
 405                                 continue;
 406
 407                         apic_interrupt_dump(&airq, &avec_tbl[i], i,
 408                             &irq_tbl[i].ii_u.evtchn, level_tbl[i]);
 409                         continue;
 410                 }
 411
 412                 ec_interrupt_dump(i);
 413         }
 414
 415         return (DCMD_OK);
 416 }
 417
 418 static void
 419 evtchn_dump(int i)
 420 {
 421         int irq = evtchn_tbl[i];
 422
 423         if (irq == INVALID_IRQ) {
 424                 mdb_printf("%-14s%-7d%-4s%-4s", "unassigned", i, "-", "-");
 425                 print_cpu(NULL, i);
 426                 if (have_shared_info) {
 427                         mdb_printf("%-7d", evtchn_masked(i));
 428                         mdb_printf("%-8d", evtchn_pending(i));
 429                 }
 430                 mdb_printf("\n");
 431                 return;
 432         }
 433
 434         /* Type */
 435         mdb_printf("%-14s", irq_type(irq, 1));
 436         /* Evtchn */
 437         mdb_printf("%-7d", i);
 438         /* IRQ */
 439         mdb_printf("%-4d", irq);
 440         /* IPL */
 441         mdb_printf("%-4d", irq_ipl(irq));
 442         /* CPU */
 443         print_cpu(NULL, i);
 444         if (have_shared_info) {
 445                 /* Masked/Pending */
 446                 mdb_printf("%-7d", evtchn_masked(i));
 447                 mdb_printf("%-8d", evtchn_pending(i));
 448         }
 449         /* ISR */
 450         print_isr(irq);
 451
 452         mdb_printf("\n");
 453 }
 454
 455 /* ARGSUSED */
 456 static int
 457 evtchns_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 458 {
 459         int i;
 460
 461         option_flags = 0;
 462         if (mdb_getopts(argc, argv,
 463             'd', MDB_OPT_SETBITS, INTR_DISPLAY_DRVR_INST, &option_flags,
 464             NULL) != argc)
 465                 return (DCMD_USAGE);
 466
 467         if (!update_tables())
 468                 return (DCMD_ERR);
 469
 470         if (flags & DCMD_ADDRSPEC) {
 471                 /*
 472                  * Note: we allow the invalid evtchn 0, as it can help catch if
 473                  * we incorrectly try to configure it.
 474                  */
 475                 if ((int)addr >= NR_EVENT_CHANNELS) {
 476                         mdb_warn("Invalid event channel %d.\n", (int)addr);
 477                         return (DCMD_ERR);
 478                 }
 479         }
 480
 481         mdb_printf("%<u>Type          Evtchn IRQ IPL CPU ");
 482         if (have_shared_info)
 483                 mdb_printf("Masked Pending ");
 484
 485         mdb_printf("%s %</u>\n", option_flags & INTR_DISPLAY_DRVR_INST ?
 486             "Driver Name(s)" : "ISR(s)");
 487
 488         if (flags & DCMD_ADDRSPEC) {
 489                 evtchn_dump((int)addr);
 490                 return (DCMD_OK);
 491         }
 492
 493         for (i = 0; i < NR_EVENT_CHANNELS; i++) {
 494                 if (evtchn_tbl[i] == INVALID_IRQ)
 495                         continue;
 496
 497                 evtchn_dump(i);
 498         }
 499
 500         return (DCMD_OK);
 501 }
 502
 503 static void
 504 evtchns_help(void)
 505 {
 506         mdb_printf("Print valid event channels\n"
 507             "If %<u>addr%</u> is given, interpret it as an evtchn to print "
 508             "details of.\n"
 509             "By default, only interrupt service routine names are printed.\n\n"
 510             "Switches:\n"
 511             "  -d   instead of ISR, print <driver_name><instance#>\n");
 512 }
 513
 514 static const mdb_dcmd_t dcmds[] = {
 515         { "interrupts", "?[-di]", "print interrupts", interrupts_dump,
 516             interrupt_help },
 517         { "evtchns", "?[-d]", "print event channels", evtchns_dump,
 518             evtchns_help },
 519         { "softint", "?[-d]", "print soft interrupts", soft_interrupt_dump,
 520             soft_interrupt_help},
 521         { NULL }
 522 };
 523
 524 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, NULL };
 525
 526 const mdb_modinfo_t *
 527 _mdb_init(void)
 528 {
 529         GElf_Sym sym;
 530
 531         if (mdb_lookup_by_name("gld_intr", &sym) != -1)
 532                 if (GELF_ST_TYPE(sym.st_info) == STT_FUNC)
 533                         gld_intr_addr = (uintptr_t)sym.st_value;
 534
 535         return (&modinfo);
 536 }