src/arch/x86/interrupts.cc

   1 /*
   2  * Copyright (c) 2012-2013 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Copyright (c) 2008 The Hewlett-Packard Development Company
  15  * All rights reserved.
  16  *
  17  * The license below extends only to copyright in the software and shall
  18  * not be construed as granting a license to any other intellectual
  19  * property including but not limited to intellectual property relating
  20  * to a hardware implementation of the functionality of the software
  21  * licensed hereunder.  You may use the software subject to the license
  22  * terms below provided that you ensure that this notice is replicated
  23  * unmodified and in its entirety in all distributions of the software,
  24  * modified or unmodified, in source code or in binary form.
  25  *
  26  * Redistribution and use in source and binary forms, with or without
  27  * modification, are permitted provided that the following conditions are
  28  * met: redistributions of source code must retain the above copyright
  29  * notice, this list of conditions and the following disclaimer;
  30  * redistributions in binary form must reproduce the above copyright
  31  * notice, this list of conditions and the following disclaimer in the
  32  * documentation and/or other materials provided with the distribution;
  33  * neither the name of the copyright holders nor the names of its
  34  * contributors may be used to endorse or promote products derived from
  35  * this software without specific prior written permission.
  36  *
  37  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  38  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  39  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  40  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  41  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  45  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  47  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  *
  49  * Authors: Gabe Black
  50  */
  51
  52 #include "arch/x86/interrupts.hh"
  53
  54 #include <list>
  55 #include <memory>
  56
  57 #include "arch/x86/intmessage.hh"
  58 #include "arch/x86/regs/apic.hh"
  59 #include "cpu/base.hh"
  60 #include "debug/LocalApic.hh"
  61 #include "dev/x86/i82094aa.hh"
  62 #include "dev/x86/pc.hh"
  63 #include "dev/x86/south_bridge.hh"
  64 #include "mem/packet_access.hh"
  65 #include "sim/full_system.hh"
  66 #include "sim/system.hh"
  67
  68 int
  69 divideFromConf(uint32_t conf)
  70 {
  71     // This figures out what division we want from the division configuration
  72     // register in the local APIC. The encoding is a little odd but it can
  73     // be deciphered fairly easily.
  74     int shift = ((conf & 0x8) >> 1) | (conf & 0x3);
  75     shift = (shift + 1) % 8;
  76     return 1 << shift;
  77 }
  78
  79 namespace X86ISA
  80 {
  81
  82 ApicRegIndex
  83 decodeAddr(Addr paddr)
  84 {
  85     ApicRegIndex regNum;
  86     paddr &= ~mask(3);
  87     switch (paddr)
  88     {
  89       case 0x20:
  90         regNum = APIC_ID;
  91         break;
  92       case 0x30:
  93         regNum = APIC_VERSION;
  94         break;
  95       case 0x80:
  96         regNum = APIC_TASK_PRIORITY;
  97         break;
  98       case 0x90:
  99         regNum = APIC_ARBITRATION_PRIORITY;
 100         break;
 101       case 0xA0:
 102         regNum = APIC_PROCESSOR_PRIORITY;
 103         break;
 104       case 0xB0:
 105         regNum = APIC_EOI;
 106         break;
 107       case 0xD0:
 108         regNum = APIC_LOGICAL_DESTINATION;
 109         break;
 110       case 0xE0:
 111         regNum = APIC_DESTINATION_FORMAT;
 112         break;
 113       case 0xF0:
 114         regNum = APIC_SPURIOUS_INTERRUPT_VECTOR;
 115         break;
 116       case 0x100:
 117       case 0x110:
 118       case 0x120:
 119       case 0x130:
 120       case 0x140:
 121       case 0x150:
 122       case 0x160:
 123       case 0x170:
 124         regNum = APIC_IN_SERVICE((paddr - 0x100) / 0x10);
 125         break;
 126       case 0x180:
 127       case 0x190:
 128       case 0x1A0:
 129       case 0x1B0:
 130       case 0x1C0:
 131       case 0x1D0:
 132       case 0x1E0:
 133       case 0x1F0:
 134         regNum = APIC_TRIGGER_MODE((paddr - 0x180) / 0x10);
 135         break;
 136       case 0x200:
 137       case 0x210:
 138       case 0x220:
 139       case 0x230:
 140       case 0x240:
 141       case 0x250:
 142       case 0x260:
 143       case 0x270:
 144         regNum = APIC_INTERRUPT_REQUEST((paddr - 0x200) / 0x10);
 145         break;
 146       case 0x280:
 147         regNum = APIC_ERROR_STATUS;
 148         break;
 149       case 0x300:
 150         regNum = APIC_INTERRUPT_COMMAND_LOW;
 151         break;
 152       case 0x310:
 153         regNum = APIC_INTERRUPT_COMMAND_HIGH;
 154         break;
 155       case 0x320:
 156         regNum = APIC_LVT_TIMER;
 157         break;
 158       case 0x330:
 159         regNum = APIC_LVT_THERMAL_SENSOR;
 160         break;
 161       case 0x340:
 162         regNum = APIC_LVT_PERFORMANCE_MONITORING_COUNTERS;
 163         break;
 164       case 0x350:
 165         regNum = APIC_LVT_LINT0;
 166         break;
 167       case 0x360:
 168         regNum = APIC_LVT_LINT1;
 169         break;
 170       case 0x370:
 171         regNum = APIC_LVT_ERROR;
 172         break;
 173       case 0x380:
 174         regNum = APIC_INITIAL_COUNT;
 175         break;
 176       case 0x390:
 177         regNum = APIC_CURRENT_COUNT;
 178         break;
 179       case 0x3E0:
 180         regNum = APIC_DIVIDE_CONFIGURATION;
 181         break;
 182       default:
 183         // A reserved register field.
 184         panic("Accessed reserved register field %#x.\n", paddr);
 185         break;
 186     }
 187     return regNum;
 188 }
 189 }
 190
 191 Tick
 192 X86ISA::Interrupts::read(PacketPtr pkt)
 193 {
 194     Addr offset = pkt->getAddr() - pioAddr;
 195     // Make sure we're at least only accessing one register.
 196     if ((offset & ~mask(3)) != ((offset + pkt->getSize()) & ~mask(3)))
 197         panic("Accessed more than one register at a time in the APIC!\n");
 198     ApicRegIndex reg = decodeAddr(offset);
 199     uint32_t val = htog(readReg(reg));
 200     DPRINTF(LocalApic,
 201             "Reading Local APIC register %d at offset %#x as %#x.\n",
 202             reg, offset, val);
 203     pkt->setData(((uint8_t *)&val) + (offset & mask(3)));
 204     pkt->makeAtomicResponse();
 205     return pioDelay;
 206 }
 207
 208 Tick
 209 X86ISA::Interrupts::write(PacketPtr pkt)
 210 {
 211     Addr offset = pkt->getAddr() - pioAddr;
 212     // Make sure we're at least only accessing one register.
 213     if ((offset & ~mask(3)) != ((offset + pkt->getSize()) & ~mask(3)))
 214         panic("Accessed more than one register at a time in the APIC!\n");
 215     ApicRegIndex reg = decodeAddr(offset);
 216     uint32_t val = regs[reg];
 217     pkt->writeData(((uint8_t *)&val) + (offset & mask(3)));
 218     DPRINTF(LocalApic,
 219             "Writing Local APIC register %d at offset %#x as %#x.\n",
 220             reg, offset, gtoh(val));
 221     setReg(reg, gtoh(val));
 222     pkt->makeAtomicResponse();
 223     return pioDelay;
 224 }
 225 void
 226 X86ISA::Interrupts::requestInterrupt(uint8_t vector,
 227         uint8_t deliveryMode, bool level)
 228 {
 229     /*
 230      * Fixed and lowest-priority delivery mode interrupts are handled
 231      * using the IRR/ISR registers, checking against the TPR, etc.
 232      * The SMI, NMI, ExtInt, INIT, etc interrupts go straight through.
 233      */
 234     if (deliveryMode == DeliveryMode::Fixed ||
 235             deliveryMode == DeliveryMode::LowestPriority) {
 236         DPRINTF(LocalApic, "Interrupt is an %s.\n",
 237                 DeliveryMode::names[deliveryMode]);
 238         // Queue up the interrupt in the IRR.
 239         if (vector > IRRV)
 240             IRRV = vector;
 241         if (!getRegArrayBit(APIC_INTERRUPT_REQUEST_BASE, vector)) {
 242             setRegArrayBit(APIC_INTERRUPT_REQUEST_BASE, vector);
 243             if (level) {
 244                 setRegArrayBit(APIC_TRIGGER_MODE_BASE, vector);
 245             } else {
 246                 clearRegArrayBit(APIC_TRIGGER_MODE_BASE, vector);
 247             }
 248         }
 249     } else if (!DeliveryMode::isReserved(deliveryMode)) {
 250         DPRINTF(LocalApic, "Interrupt is an %s.\n",
 251                 DeliveryMode::names[deliveryMode]);
 252         if (deliveryMode == DeliveryMode::SMI && !pendingSmi) {
 253             pendingUnmaskableInt = pendingSmi = true;
 254             smiVector = vector;
 255         } else if (deliveryMode == DeliveryMode::NMI && !pendingNmi) {
 256             pendingUnmaskableInt = pendingNmi = true;
 257             nmiVector = vector;
 258         } else if (deliveryMode == DeliveryMode::ExtInt && !pendingExtInt) {
 259             pendingExtInt = true;
 260             extIntVector = vector;
 261         } else if (deliveryMode == DeliveryMode::INIT && !pendingInit) {
 262             pendingUnmaskableInt = pendingInit = true;
 263             initVector = vector;
 264         } else if (deliveryMode == DeliveryMode::SIPI &&
 265                 !pendingStartup && !startedUp) {
 266             pendingUnmaskableInt = pendingStartup = true;
 267             startupVector = vector;
 268         }
 269     }
 270     if (FullSystem)
 271         cpu->wakeup(0);
 272 }
 273
 274
 275 void
 276 X86ISA::Interrupts::setCPU(BaseCPU * newCPU)
 277 {
 278     assert(newCPU);
 279     if (cpu != NULL && cpu->cpuId() != newCPU->cpuId()) {
 280         panic("Local APICs can't be moved between CPUs"
 281                 " with different IDs.\n");
 282     }
 283     cpu = newCPU;
 284     initialApicId = cpu->cpuId();
 285     regs[APIC_ID] = (initialApicId << 24);
 286     pioAddr = x86LocalAPICAddress(initialApicId, 0);
 287 }
 288
 289
 290 void
 291 X86ISA::Interrupts::init()
 292 {
 293     //
 294     // The local apic must register its address ranges on its pio
 295     // port via the basicpiodevice(piodevice) init() function.
 296     PioDevice::init();
 297
 298     // The slave port has a range, so inform the connected master.
 299     intSlavePort.sendRangeChange();
 300     // If the master port isn't connected, we can't send interrupts anywhere.
 301     panic_if(!intMasterPort.isConnected(),
 302             "Int port not connected to anything!");
 303 }
 304
 305
 306 Tick
 307 X86ISA::Interrupts::recvMessage(PacketPtr pkt)
 308 {
 309     Addr offset = pkt->getAddr() - x86InterruptAddress(initialApicId, 0);
 310     assert(pkt->cmd == MemCmd::WriteReq);
 311     switch(offset)
 312     {
 313       case 0:
 314         {
 315             TriggerIntMessage message = pkt->getRaw<TriggerIntMessage>();
 316             DPRINTF(LocalApic,
 317                     "Got Trigger Interrupt message with vector %#x.\n",
 318                     message.vector);
 319
 320             requestInterrupt(message.vector,
 321                     message.deliveryMode, message.trigger);
 322         }
 323         break;
 324       default:
 325         panic("Local apic got unknown interrupt message at offset %#x.\n",
 326                 offset);
 327         break;
 328     }
 329     pkt->makeAtomicResponse();
 330     return pioDelay;
 331 }
 332
 333
 334 void
 335 X86ISA::Interrupts::completeIPI(PacketPtr pkt)
 336 {
 337     if (--pendingIPIs == 0) {
 338         InterruptCommandRegLow low = regs[APIC_INTERRUPT_COMMAND_LOW];
 339         // Record that the ICR is now idle.
 340         low.deliveryStatus = 0;
 341         regs[APIC_INTERRUPT_COMMAND_LOW] = low;
 342     }
 343     DPRINTF(LocalApic, "ICR is now idle.\n");
 344     delete pkt;
 345 }
 346
 347
 348 AddrRangeList
 349 X86ISA::Interrupts::getAddrRanges() const
 350 {
 351     assert(cpu);
 352     AddrRangeList ranges;
 353     ranges.push_back(RangeSize(pioAddr, PageBytes));
 354     return ranges;
 355 }
 356
 357
 358 AddrRangeList
 359 X86ISA::Interrupts::getIntAddrRange() const
 360 {
 361     AddrRangeList ranges;
 362     ranges.push_back(RangeEx(x86InterruptAddress(initialApicId, 0),
 363                              x86InterruptAddress(initialApicId, 0) +
 364                              PhysAddrAPICRangeSize));
 365     return ranges;
 366 }
 367
 368
 369 uint32_t
 370 X86ISA::Interrupts::readReg(ApicRegIndex reg)
 371 {
 372     if (reg >= APIC_TRIGGER_MODE(0) &&
 373             reg <= APIC_TRIGGER_MODE(15)) {
 374         panic("Local APIC Trigger Mode registers are unimplemented.\n");
 375     }
 376     switch (reg) {
 377       case APIC_ARBITRATION_PRIORITY:
 378         panic("Local APIC Arbitration Priority register unimplemented.\n");
 379         break;
 380       case APIC_PROCESSOR_PRIORITY:
 381         panic("Local APIC Processor Priority register unimplemented.\n");
 382         break;
 383       case APIC_ERROR_STATUS:
 384         regs[APIC_INTERNAL_STATE] &= ~ULL(0x1);
 385         break;
 386       case APIC_CURRENT_COUNT:
 387         {
 388             if (apicTimerEvent.scheduled()) {
 389                 // Compute how many m5 ticks happen per count.
 390                 uint64_t ticksPerCount = clockPeriod() *
 391                     divideFromConf(regs[APIC_DIVIDE_CONFIGURATION]);
 392                 // Compute how many m5 ticks are left.
 393                 uint64_t val = apicTimerEvent.when() - curTick();
 394                 // Turn that into a count.
 395                 val = (val + ticksPerCount - 1) / ticksPerCount;
 396                 return val;
 397             } else {
 398                 return 0;
 399             }
 400         }
 401       default:
 402         break;
 403     }
 404     return regs[reg];
 405 }
 406
 407 void
 408 X86ISA::Interrupts::setReg(ApicRegIndex reg, uint32_t val)
 409 {
 410     uint32_t newVal = val;
 411     if (reg >= APIC_IN_SERVICE(0) &&
 412             reg <= APIC_IN_SERVICE(15)) {
 413         panic("Local APIC In-Service registers are unimplemented.\n");
 414     }
 415     if (reg >= APIC_TRIGGER_MODE(0) &&
 416             reg <= APIC_TRIGGER_MODE(15)) {
 417         panic("Local APIC Trigger Mode registers are unimplemented.\n");
 418     }
 419     if (reg >= APIC_INTERRUPT_REQUEST(0) &&
 420             reg <= APIC_INTERRUPT_REQUEST(15)) {
 421         panic("Local APIC Interrupt Request registers "
 422                 "are unimplemented.\n");
 423     }
 424     switch (reg) {
 425       case APIC_ID:
 426         newVal = val & 0xFF;
 427         break;
 428       case APIC_VERSION:
 429         // The Local APIC Version register is read only.
 430         return;
 431       case APIC_TASK_PRIORITY:
 432         newVal = val & 0xFF;
 433         break;
 434       case APIC_ARBITRATION_PRIORITY:
 435         panic("Local APIC Arbitration Priority register unimplemented.\n");
 436         break;
 437       case APIC_PROCESSOR_PRIORITY:
 438         panic("Local APIC Processor Priority register unimplemented.\n");
 439         break;
 440       case APIC_EOI:
 441         // Remove the interrupt that just completed from the local apic state.
 442         clearRegArrayBit(APIC_IN_SERVICE_BASE, ISRV);
 443         updateISRV();
 444         return;
 445       case APIC_LOGICAL_DESTINATION:
 446         newVal = val & 0xFF000000;
 447         break;
 448       case APIC_DESTINATION_FORMAT:
 449         newVal = val | 0x0FFFFFFF;
 450         break;
 451       case APIC_SPURIOUS_INTERRUPT_VECTOR:
 452         regs[APIC_INTERNAL_STATE] &= ~ULL(1 << 1);
 453         regs[APIC_INTERNAL_STATE] |= val & (1 << 8);
 454         if (val & (1 << 9))
 455             warn("Focus processor checking not implemented.\n");
 456         break;
 457       case APIC_ERROR_STATUS:
 458         {
 459             if (regs[APIC_INTERNAL_STATE] & 0x1) {
 460                 regs[APIC_INTERNAL_STATE] &= ~ULL(0x1);
 461                 newVal = 0;
 462             } else {
 463                 regs[APIC_INTERNAL_STATE] |= ULL(0x1);
 464                 return;
 465             }
 466
 467         }
 468         break;
 469       case APIC_INTERRUPT_COMMAND_LOW:
 470         {
 471             InterruptCommandRegLow low = regs[APIC_INTERRUPT_COMMAND_LOW];
 472             // Check if we're already sending an IPI.
 473             if (low.deliveryStatus) {
 474                 newVal = low;
 475                 break;
 476             }
 477             low = val;
 478             InterruptCommandRegHigh high = regs[APIC_INTERRUPT_COMMAND_HIGH];
 479             TriggerIntMessage message = 0;
 480             message.destination = high.destination;
 481             message.vector = low.vector;
 482             message.deliveryMode = low.deliveryMode;
 483             message.destMode = low.destMode;
 484             message.level = low.level;
 485             message.trigger = low.trigger;
 486             std::list<int> apics;
 487             int numContexts = sys->numContexts();
 488             switch (low.destShorthand) {
 489               case 0:
 490                 if (message.deliveryMode == DeliveryMode::LowestPriority) {
 491                     panic("Lowest priority delivery mode "
 492                             "IPIs aren't implemented.\n");
 493                 }
 494                 if (message.destMode == 1) {
 495                     int dest = message.destination;
 496                     hack_once("Assuming logical destinations are 1 << id.\n");
 497                     for (int i = 0; i < numContexts; i++) {
 498                         if (dest & 0x1)
 499                             apics.push_back(i);
 500                         dest = dest >> 1;
 501                     }
 502                 } else {
 503                     if (message.destination == 0xFF) {
 504                         for (int i = 0; i < numContexts; i++) {
 505                             if (i == initialApicId) {
 506                                 requestInterrupt(message.vector,
 507                                         message.deliveryMode, message.trigger);
 508                             } else {
 509                                 apics.push_back(i);
 510                             }
 511                         }
 512                     } else {
 513                         if (message.destination == initialApicId) {
 514                             requestInterrupt(message.vector,
 515                                     message.deliveryMode, message.trigger);
 516                         } else {
 517                             apics.push_back(message.destination);
 518                         }
 519                     }
 520                 }
 521                 break;
 522               case 1:
 523                 newVal = val;
 524                 requestInterrupt(message.vector,
 525                         message.deliveryMode, message.trigger);
 526                 break;
 527               case 2:
 528                 requestInterrupt(message.vector,
 529                         message.deliveryMode, message.trigger);
 530                 // Fall through
 531               case 3:
 532                 {
 533                     for (int i = 0; i < numContexts; i++) {
 534                         if (i != initialApicId) {
 535                             apics.push_back(i);
 536                         }
 537                     }
 538                 }
 539                 break;
 540             }
 541             // Record that an IPI is being sent if one actually is.
 542             if (apics.size()) {
 543                 low.deliveryStatus = 1;
 544                 pendingIPIs += apics.size();
 545             }
 546             regs[APIC_INTERRUPT_COMMAND_LOW] = low;
 547             for (auto id: apics) {
 548                 PacketPtr pkt = buildIntTriggerPacket(id, message);
 549                 intMasterPort.sendMessage(pkt, sys->isTimingMode(),
 550                         [this](PacketPtr pkt) { completeIPI(pkt); });
 551             }
 552             newVal = regs[APIC_INTERRUPT_COMMAND_LOW];
 553         }
 554         break;
 555       case APIC_LVT_TIMER:
 556       case APIC_LVT_THERMAL_SENSOR:
 557       case APIC_LVT_PERFORMANCE_MONITORING_COUNTERS:
 558       case APIC_LVT_LINT0:
 559       case APIC_LVT_LINT1:
 560       case APIC_LVT_ERROR:
 561         {
 562             uint64_t readOnlyMask = (1 << 12) | (1 << 14);
 563             newVal = (val & ~readOnlyMask) |
 564                      (regs[reg] & readOnlyMask);
 565         }
 566         break;
 567       case APIC_INITIAL_COUNT:
 568         {
 569             newVal = bits(val, 31, 0);
 570             // Compute how many timer ticks we're being programmed for.
 571             uint64_t newCount = newVal *
 572                 (divideFromConf(regs[APIC_DIVIDE_CONFIGURATION]));
 573             // Schedule on the edge of the next tick plus the new count.
 574             Tick offset = curTick() % clockPeriod();
 575             if (offset) {
 576                 reschedule(apicTimerEvent,
 577                            curTick() + (newCount + 1) *
 578                            clockPeriod() - offset, true);
 579             } else {
 580                 if (newCount)
 581                     reschedule(apicTimerEvent,
 582                                curTick() + newCount *
 583                                clockPeriod(), true);
 584             }
 585         }
 586         break;
 587       case APIC_CURRENT_COUNT:
 588         //Local APIC Current Count register is read only.
 589         return;
 590       case APIC_DIVIDE_CONFIGURATION:
 591         newVal = val & 0xB;
 592         break;
 593       default:
 594         break;
 595     }
 596     regs[reg] = newVal;
 597     return;
 598 }
 599
 600
 601 X86ISA::Interrupts::Interrupts(Params * p)
 602     : PioDevice(p),
 603       apicTimerEvent([this]{ processApicTimerEvent(); }, name()),
 604       pendingSmi(false), smiVector(0),
 605       pendingNmi(false), nmiVector(0),
 606       pendingExtInt(false), extIntVector(0),
 607       pendingInit(false), initVector(0),
 608       pendingStartup(false), startupVector(0),
 609       startedUp(false), pendingUnmaskableInt(false),
 610       pendingIPIs(0), cpu(NULL),
 611       intSlavePort(name() + ".int_slave", this, this),
 612       intMasterPort(name() + ".int_master", this, this, p->int_latency),
 613       pioDelay(p->pio_latency)
 614 {
 615     memset(regs, 0, sizeof(regs));
 616     //Set the local apic DFR to the flat model.
 617     regs[APIC_DESTINATION_FORMAT] = (uint32_t)(-1);
 618     ISRV = 0;
 619     IRRV = 0;
 620 }
 621
 622
 623 bool
 624 X86ISA::Interrupts::checkInterrupts(ThreadContext *tc) const
 625 {
 626     RFLAGS rflags = tc->readMiscRegNoEffect(MISCREG_RFLAGS);
 627     if (pendingUnmaskableInt) {
 628         DPRINTF(LocalApic, "Reported pending unmaskable interrupt.\n");
 629         return true;
 630     }
 631     if (rflags.intf) {
 632         if (pendingExtInt) {
 633             DPRINTF(LocalApic, "Reported pending external interrupt.\n");
 634             return true;
 635         }
 636         if (IRRV > ISRV && bits(IRRV, 7, 4) >
 637                bits(regs[APIC_TASK_PRIORITY], 7, 4)) {
 638             DPRINTF(LocalApic, "Reported pending regular interrupt.\n");
 639             return true;
 640         }
 641     }
 642     return false;
 643 }
 644
 645 bool
 646 X86ISA::Interrupts::checkInterruptsRaw() const
 647 {
 648     return pendingUnmaskableInt || pendingExtInt ||
 649         (IRRV > ISRV && bits(IRRV, 7, 4) >
 650          bits(regs[APIC_TASK_PRIORITY], 7, 4));
 651 }
 652
 653 Fault
 654 X86ISA::Interrupts::getInterrupt(ThreadContext *tc)
 655 {
 656     assert(checkInterrupts(tc));
 657     // These are all probably fairly uncommon, so we'll make them easier to
 658     // check for.
 659     if (pendingUnmaskableInt) {
 660         if (pendingSmi) {
 661             DPRINTF(LocalApic, "Generated SMI fault object.\n");
 662             return std::make_shared<SystemManagementInterrupt>();
 663         } else if (pendingNmi) {
 664             DPRINTF(LocalApic, "Generated NMI fault object.\n");
 665             return std::make_shared<NonMaskableInterrupt>(nmiVector);
 666         } else if (pendingInit) {
 667             DPRINTF(LocalApic, "Generated INIT fault object.\n");
 668             return std::make_shared<InitInterrupt>(initVector);
 669         } else if (pendingStartup) {
 670             DPRINTF(LocalApic, "Generating SIPI fault object.\n");
 671             return std::make_shared<StartupInterrupt>(startupVector);
 672         } else {
 673             panic("pendingUnmaskableInt set, but no unmaskable "
 674                     "ints were pending.\n");
 675             return NoFault;
 676         }
 677     } else if (pendingExtInt) {
 678         DPRINTF(LocalApic, "Generated external interrupt fault object.\n");
 679         return std::make_shared<ExternalInterrupt>(extIntVector);
 680     } else {
 681         DPRINTF(LocalApic, "Generated regular interrupt fault object.\n");
 682         // The only thing left are fixed and lowest priority interrupts.
 683         return std::make_shared<ExternalInterrupt>(IRRV);
 684     }
 685 }
 686
 687 void
 688 X86ISA::Interrupts::updateIntrInfo(ThreadContext *tc)
 689 {
 690     assert(checkInterrupts(tc));
 691     if (pendingUnmaskableInt) {
 692         if (pendingSmi) {
 693             DPRINTF(LocalApic, "SMI sent to core.\n");
 694             pendingSmi = false;
 695         } else if (pendingNmi) {
 696             DPRINTF(LocalApic, "NMI sent to core.\n");
 697             pendingNmi = false;
 698         } else if (pendingInit) {
 699             DPRINTF(LocalApic, "Init sent to core.\n");
 700             pendingInit = false;
 701             startedUp = false;
 702         } else if (pendingStartup) {
 703             DPRINTF(LocalApic, "SIPI sent to core.\n");
 704             pendingStartup = false;
 705             startedUp = true;
 706         }
 707         if (!(pendingSmi || pendingNmi || pendingInit || pendingStartup))
 708             pendingUnmaskableInt = false;
 709     } else if (pendingExtInt) {
 710         pendingExtInt = false;
 711     } else {
 712         DPRINTF(LocalApic, "Interrupt %d sent to core.\n", IRRV);
 713         // Mark the interrupt as "in service".
 714         ISRV = IRRV;
 715         setRegArrayBit(APIC_IN_SERVICE_BASE, ISRV);
 716         // Clear it out of the IRR.
 717         clearRegArrayBit(APIC_INTERRUPT_REQUEST_BASE, IRRV);
 718         updateIRRV();
 719     }
 720 }
 721
 722 void
 723 X86ISA::Interrupts::serialize(CheckpointOut &cp) const
 724 {
 725     SERIALIZE_ARRAY(regs, NUM_APIC_REGS);
 726     SERIALIZE_SCALAR(pendingSmi);
 727     SERIALIZE_SCALAR(smiVector);
 728     SERIALIZE_SCALAR(pendingNmi);
 729     SERIALIZE_SCALAR(nmiVector);
 730     SERIALIZE_SCALAR(pendingExtInt);
 731     SERIALIZE_SCALAR(extIntVector);
 732     SERIALIZE_SCALAR(pendingInit);
 733     SERIALIZE_SCALAR(initVector);
 734     SERIALIZE_SCALAR(pendingStartup);
 735     SERIALIZE_SCALAR(startupVector);
 736     SERIALIZE_SCALAR(startedUp);
 737     SERIALIZE_SCALAR(pendingUnmaskableInt);
 738     SERIALIZE_SCALAR(pendingIPIs);
 739     SERIALIZE_SCALAR(IRRV);
 740     SERIALIZE_SCALAR(ISRV);
 741     bool apicTimerEventScheduled = apicTimerEvent.scheduled();
 742     SERIALIZE_SCALAR(apicTimerEventScheduled);
 743     Tick apicTimerEventTick = apicTimerEvent.when();
 744     SERIALIZE_SCALAR(apicTimerEventTick);
 745 }
 746
 747 void
 748 X86ISA::Interrupts::unserialize(CheckpointIn &cp)
 749 {
 750     UNSERIALIZE_ARRAY(regs, NUM_APIC_REGS);
 751     UNSERIALIZE_SCALAR(pendingSmi);
 752     UNSERIALIZE_SCALAR(smiVector);
 753     UNSERIALIZE_SCALAR(pendingNmi);
 754     UNSERIALIZE_SCALAR(nmiVector);
 755     UNSERIALIZE_SCALAR(pendingExtInt);
 756     UNSERIALIZE_SCALAR(extIntVector);
 757     UNSERIALIZE_SCALAR(pendingInit);
 758     UNSERIALIZE_SCALAR(initVector);
 759     UNSERIALIZE_SCALAR(pendingStartup);
 760     UNSERIALIZE_SCALAR(startupVector);
 761     UNSERIALIZE_SCALAR(startedUp);
 762     UNSERIALIZE_SCALAR(pendingUnmaskableInt);
 763     UNSERIALIZE_SCALAR(pendingIPIs);
 764     UNSERIALIZE_SCALAR(IRRV);
 765     UNSERIALIZE_SCALAR(ISRV);
 766     bool apicTimerEventScheduled;
 767     UNSERIALIZE_SCALAR(apicTimerEventScheduled);
 768     if (apicTimerEventScheduled) {
 769         Tick apicTimerEventTick;
 770         UNSERIALIZE_SCALAR(apicTimerEventTick);
 771         if (apicTimerEvent.scheduled()) {
 772             reschedule(apicTimerEvent, apicTimerEventTick, true);
 773         } else {
 774             schedule(apicTimerEvent, apicTimerEventTick);
 775         }
 776     }
 777 }
 778
 779 X86ISA::Interrupts *
 780 X86LocalApicParams::create()
 781 {
 782     return new X86ISA::Interrupts(this);
 783 }
 784
 785 void
 786 X86ISA::Interrupts::processApicTimerEvent() {
 787     if (triggerTimerInterrupt())
 788         setReg(APIC_INITIAL_COUNT, readReg(APIC_INITIAL_COUNT));
 789 }