Task5 work

Makefile

@@ -166,7 +166,9 @@ clean:
 bootdisk: $(OBJDIR)/bootdisk.iso
 	@echo "CP		$<"
 	$(VERBOSE) cp $< $(DRIVE_HD)
-
+#bootdisk: $(OBJDIR)/bootdisk.iso
+#	sudo dd if=$(OBJDIR)/bootdisk.iso of=$(DRIVE_HD) bs=4M conv=fsync status=progress
+#	sync
 # --------------------------------------------------------------------------
 # 'qemu' runs the QEMU emulator with the system
 

device/cgastr.cc

@@ -5,7 +5,7 @@
 /*                         C G A _ S T R E A M                               */
 /*                                                                           */
 /*---------------------------------------------------------------------------*/
-/* The CGA_Stream class allows to print different data types as text strings */
+/* The CGA_Stream class allows to print different data types as text strings /
 /* to a PC's CGA screen.                                                     */
 /* For attributes/colors and cursor positioning use the methods of class     */
 /* CGA_Screen.                                                               */
@@ -14,6 +14,8 @@
 
 #include "device/cgastr.h"
 
+CGA_Stream kout;
+
 void CGA_Stream::flush()
 {
     screen.print(buffer, pos, 0x07);

device/cgastr.h

@@ -29,6 +29,10 @@ class CGA_Stream : public O_Stream
     CGA_Stream& operator=(const CGA_Stream&) = delete;
 
     void flush() override;
+    void setpos(int x, int y) { screen.setpos(x, y); }
+    void getpos(int &x, int &y) { screen.getpos(x, y); }
 };
 
+extern CGA_Stream kout;
+
 #endif

device/keyboard.cc

@@ -0,0 +1,45 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                            K E Y B O A R D                                */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Keyboard driver.                                                          */
+/*****************************************************************************/
+
+#include "device/keyboard.h"
+#include "machine/plugbox.h"
+#include "machine/pic.h"
+#include "device/cgastr.h"
+
+Keyboard keyboard;
+
+void Keyboard::plugin() {
+	plugbox.assign(Plugbox::keyboard, *this);
+	pic.allow(PIC::keyboard);
+}
+
+bool Keyboard::prologue() {
+	//kout<< "IRQ"<<endl;
+	//kout.flush();
+	k = key_hit();
+	if (k.valid()) {
+		if (k.ctrl() && k.alt() && k.scancode() == Key::scan::del) {
+			reboot();
+		} //else if (k.ascii() != 0) {
+		//	kout << k.ascii();
+		//	kout.flush();
+		//}
+	}
+	return k.valid() && k.ascii() != 0;
+}
+
+void Keyboard::epilogue(){
+	//kout<<"EPI"<<endl;
+	//kout.flush();
+	if(k.ascii()){
+		kout << k.ascii();
+		kout.flush();
+	}
+}

device/keyboard.h

@@ -0,0 +1,38 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                            K E Y B O A R D                                */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Keyboard driver.                                                          */
+/*****************************************************************************/
+
+#ifndef __Keyboard_include__
+#define __Keyboard_include__
+
+#include "machine/keyctrl.h"
+#include "guard/gate.h"
+#include "machine/key.h"
+
+class Keyboard : public Gate, public Keyboard_Controller
+{
+private:
+	Key k;
+public:
+	Keyboard(const Keyboard &copy) = delete; // prevent copying
+	Keyboard& operator=(const Keyboard&) = delete; // prevent assignment
+	Keyboard() {}
+
+	// PLUGIN: "Plugs in" the keyboard (driver). From now on, keypresses are handled.
+	void plugin();
+
+	// PROLOGUE: To start the interrupt handling routine.
+	bool prologue() override;
+
+	void epilogue() override;
+};
+
+extern Keyboard keyboard;
+
+#endif

device/panic.cc

@@ -0,0 +1,26 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                                 P A N I C                                 */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Default interrupt handler.                                                */
+/*****************************************************************************/
+/* Add your code here */ 
+/* Add your code here */ 
+#include "device/panic.h"
+#include "machine/cpu.h"
+#include "device/cgastr.h"
+
+extern CPU cpu;
+
+Panic panic;
+
+bool Panic::prologue(){
+	kout.setpos(0, 0);
+	kout << "PANIC: Unexpected interrupt! System halted." << endl;
+	kout.flush();
+	cpu.halt();
+	return true;	
+}

device/panic.h

@@ -0,0 +1,31 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                                 P A N I C                                 */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Default interrupt handler.                                                */
+/*****************************************************************************/
+
+#ifndef __panic_include__
+#define __panic_include__
+
+/* INCLUDES */
+
+#include "guard/gate.h"
+
+class Panic: public Gate
+/* Add your code here */ 
+{
+public:
+	Panic (const Panic &copy) = delete; // prevent copying
+	Panic& operator=(const Panic&) = delete; // prevent assignment
+	Panic () {}
+	bool prologue() override;
+/* Add your code here */ 
+};
+
+extern Panic panic;
+
+#endif

device/watch.cc

@@ -0,0 +1,40 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                              W A T C H                                    */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Handles timer interrupts by managing a time slice and triggering a        */
+/* process switch if necessary.                                              */
+/*****************************************************************************/
+
+/* Add your code here */ 
+/* Add your code here */ 
+
+/* Add your code here */ 
+/* Add your code here */ 
+#include "watch.h"
+#include "machine/plugbox.h"
+#include "machine/pic.h"
+#include "syscall/guarded_scheduler.h"
+
+extern Plugbox plugbox;
+extern PIC pic;
+extern Guarded_Scheduler scheduler;
+
+void Watch::windup()
+{
+    plugbox.assign(Plugbox::timer, *this);
+    pic.allow(PIC::timer);
+}
+
+bool Watch::prologue()
+{
+    return true;
+}
+
+void Watch::epilogue()
+{
+    scheduler.resume();
+}

device/watch.h

@@ -0,0 +1,39 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                              W A T C H                                    */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Handles timer interrupts by managing a time slice and triggering a        */
+/* process switch if necessary.                                              */
+/*****************************************************************************/
+
+#ifndef __watch_include__
+#define __watch_include__
+
+/* INCLUDES */
+
+#include "guard/gate.h"
+#include "machine/pit.h"
+
+class Watch : public Gate, public PIT {
+public:
+	// WATCH: Timer initialization, see PIT.
+	Watch(const Watch &copy) = delete; // prevent copying
+	Watch& operator=(const Watch&) = delete; // prevent assignment
+	Watch(int us) : PIT(us) {}
+
+	// WINDUP: "Winds up" the clock. To do this, the watch object must register
+	//         with the Plugbox plugbox and allow the interrupts of the timer
+	//         module with the help of the global pic object. 
+	void windup();
+
+	// PROLOGUE: Contains the prologue of the interrupt handler.
+	bool prologue();
+
+	// EPILOGUE: This method triggers the process switch.
+	void epilogue();
+};
+
+#endif

guard/gate.h

@@ -0,0 +1,30 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                                  G A T E                                  */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Class of objects that handle interrupts.                                  */
+/*****************************************************************************/
+
+#ifndef __Gate_include__
+#define __Gate_include__
+#include "object/chain.h"
+
+/* Add your code here */ 
+class Gate: public Chain{
+	private:
+		volatile bool in_queue;
+	public:
+		Gate() : in_queue(false) {}
+		virtual bool prologue()=0;
+		virtual void epilogue() {}
+		void queued(bool q){
+			in_queue = q;
+		}
+		bool queued(){
+			return in_queue;
+		}
+};
+#endif

guard/guard.cc

@@ -0,0 +1,51 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                                G U A R D                                  */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Using this class, we can synchronize activities with a critical section   */
+/* with interrupt handlers that also access this critical section. This      */
+/* synchronization takes place along the prologue/epilogue model.            */
+/*****************************************************************************/
+
+/* Add your code here */
+
+#include "guard.h"
+#include "machine/cpu.h"
+#include "gate.h"
+extern CPU cpu;
+void Guard::relay(Gate *item){
+	cpu.disable_int();
+	if(avail()){
+		enter();
+		item->queued(false);
+		cpu.enable_int();
+		item->epilogue();
+		cpu.disable_int();
+		leave();
+		cpu.enable_int();
+	}else{
+		if(!item->queued()){
+			item->queued(true);
+			queue.enqueue(item);
+		}
+		cpu.enable_int();
+	}
+}
+
+void Guard::leave(){
+	cpu.disable_int();
+	Gate *gate;
+	while((gate = (Gate*)queue.dequeue())){
+		gate->queued(false);
+		cpu.enable_int();
+		gate->epilogue();
+		cpu.disable_int();
+	}
+	retne();
+	cpu.enable_int();
+}
+
+Guard guard;

guard/guard.h

@@ -0,0 +1,34 @@
+/*****************************************************************************/
+/* Operating-System Construction                                             */
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/*                                G U A R D                                  */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Using this class, we can synchronize activities with a critical section   */
+/* with interrupt handlers that also access this critical section. This      */
+/* synchronization takes place along the prologue/epilogue model.            */
+/*****************************************************************************/
+
+#ifndef __Guard_include__
+#define __Guard_include__
+
+/* Add your code here */ 
+#include "object/queue.h"
+#include "locker.h"
+#include "gate.h"
+class Guard : public Locker {
+private:
+	Queue queue;
+public:
+	Guard (const Guard &copy) = delete; // prevent copying
+	Guard& operator=(const Guard&) = delete; // prevent assignment
+	Guard () {}
+
+	void leave();
+	void relay(Gate *item); 
+};
+
+extern Guard guard;
+
+#endif