init: init nachos hw01, should pass jenkins os_group_20_hw job but fail on os_group_20_ta job

code/machine/interrupt.h

@@ -0,0 +1,145 @@
+// interrupt.h 
+//	Data structures to emulate low-level interrupt hardware.
+//
+//	The hardware provides a routine (SetLevel) to enable or disable
+//	interrupts.
+//
+//	In order to emulate the hardware, we need to keep track of all
+//	interrupts the hardware devices would cause, and when they
+//	are supposed to occur.  
+//
+//	This module also keeps track of simulated time.  Time advances
+//	only when the following occur: 
+//		interrupts are re-enabled
+//		a user instruction is executed
+//		there is nothing in the ready queue
+//
+//	As a result, unlike real hardware, interrupts (and thus time-slice 
+//	context switches) cannot occur anywhere in the code where interrupts
+//	are enabled, but rather only at those places in the code where 
+//	simulated time advances (so that it becomes time to invoke an
+//	interrupt in the hardware simulation).
+//
+//	NOTE: this means that incorrectly synchronized code may work
+//	fine on this hardware simulation (even with randomized time slices),
+//	but it wouldn't work on real hardware.
+//
+//  DO NOT CHANGE -- part of the machine emulation
+//
+// Copyright (c) 1992-1996 The Regents of the University of California.
+// All rights reserved.  See copyright.h for copyright notice and limitation 
+// of liability and disclaimer of warranty provisions.
+
+#ifndef INTERRUPT_H
+#define INTERRUPT_H
+
+#include "copyright.h"
+#include "list.h"
+#include "callback.h"
+
+// Interrupts can be disabled (IntOff) or enabled (IntOn)
+enum IntStatus { IntOff, IntOn };
+
+// Nachos can be running kernel code (SystemMode), user code (UserMode),
+// or there can be no runnable thread, because the ready list 
+// is empty (IdleMode).
+enum MachineStatus {IdleMode, SystemMode, UserMode};
+
+// IntType records which hardware device generated an interrupt.
+// In Nachos, we support a hardware timer device, a disk, a console
+// display and keyboard, and a network.
+enum IntType { TimerInt, DiskInt, ConsoleWriteInt, ConsoleReadInt, 
+			NetworkSendInt, NetworkRecvInt};
+
+// The following class defines an interrupt that is scheduled
+// to occur in the future.  The internal data structures are
+// left public to make it simpler to manipulate.
+
+class PendingInterrupt {
+  public:
+    PendingInterrupt(CallBackObj *callOnInt, int time, IntType kind);
+				// initialize an interrupt that will
+				// occur in the future
+
+    CallBackObj *callOnInterrupt;// The object (in the hardware device
+				// emulator) to call when the interrupt occurs
+    
+    int when;			// When the interrupt is supposed to fire
+    IntType type;		// for debugging
+};
+
+// The following class defines the data structures for the simulation
+// of hardware interrupts.  We record whether interrupts are enabled
+// or disabled, and any hardware interrupts that are scheduled to occur
+// in the future.
+
+class Interrupt {
+  public:
+    Interrupt();		// initialize the interrupt simulation
+    ~Interrupt();		// de-allocate data structures
+    
+    IntStatus SetLevel(IntStatus level);
+    				// Disable or enable interrupts 
+				// and return previous setting.
+
+    void Enable() { (void) SetLevel(IntOn); }
+				// Enable interrupts.
+    IntStatus getLevel() {return level;}
+    				// Return whether interrupts
+				// are enabled or disabled
+    
+    void Idle(); 		// The ready queue is empty, roll 
+				// simulated time forward until the 
+				// next interrupt
+
+    void Halt(); 		// quit and print out stats
+
+    void PrintInt(int number);
+	int CreateFile(char *filename);
+ 
+    void YieldOnReturn();	// cause a context switch on return 
+				// from an interrupt handler
+
+    MachineStatus getStatus() { return status; } 
+    void setStatus(MachineStatus st) { status = st; }
+        			// idle, kernel, user
+
+    void DumpState();		// Print interrupt state
+    
+
+    // NOTE: the following are internal to the hardware simulation code.
+    // DO NOT call these directly.  I should make them "private",
+    // but they need to be public since they are called by the
+    // hardware device simulators.
+
+    void Schedule(CallBackObj *callTo, int when, IntType type);
+    				// Schedule an interrupt to occur
+				// at time "when".  This is called
+    				// by the hardware device simulators.
+    
+    void OneTick();       	// Advance simulated time
+
+  private:
+    IntStatus level;		// are interrupts enabled or disabled?
+    SortedList<PendingInterrupt *> *pending;		
+    				// the list of interrupts scheduled
+				// to occur in the future
+    //int writeFileNo;            //UNIX file emulating the display
+    bool inHandler;		// TRUE if we are running an interrupt handler
+    //bool putBusy;               // Is a PrintInt operation in progress
+                                  //If so, you cannoot do another one
+    bool yieldOnReturn; 	// TRUE if we are to context switch
+				// on return from the interrupt handler
+    MachineStatus status;	// idle, kernel mode, user mode
+
+    // these functions are internal to the interrupt simulation code
+
+    bool CheckIfDue(bool advanceClock); 
+    				// Check if any interrupts are supposed
+				// to occur now, and if so, do them
+
+    void ChangeLevel(IntStatus old, 	// SetLevel, without advancing the
+			IntStatus now); // simulated time
+};
+
+#endif // INTERRRUPT_H