Changes between Version 37 and Version 38 of GSoC/2013/ParavirtualizationOfRTEMS

Timestamp:

09/17/13 17:47:41 (11 years ago)

Author:

Phipse

Comment:

/* Implementation */

GSoC/2013/ParavirtualizationOfRTEMS

@@ -292 +292 @@
 =  Implementation  =
 
-=  Issues  =
-
-This section deals with implementation issues, which occurred during the implementation process.
- *  No console write in POK.
+=  Virtualization layer (POK)  =
+
+The virt. layer is implemented in the user code part of the partitions code.
+Mostly, it only makes a syscall and passes the arguments through.
+
+=  libpart.a creation (POK)  =
+
+libpart.a is build after libpok.a but with the same makefile rule. 
+libpart.a consists of libpok.a plus the objects from the user code files. 
+
+=  Interrupt design (POK)  =
+
+I redesigned the interrupt handling in POK.
+Previously there was no way of knowing which interrupt number occurred, as the IDT directly invoked the corresponding handler.
+I replaced all 16 hardware interrupt handlers with predefined handlers, which know their interrupt number. 
+Then a meta handler is called to look up the registered handlers for this vector number and invokes first a kernel handler and then the partition handlers.
+The lookup table is an array consisting of objects which have fields for the vector number, the handler list for the number of configured partitions plus one (kernel) and a list to indicate if the partition is waiting for an interrupt.
+The waiting flag is necessary, because a partition needs to process the interrupt before a new one can be delivered.
+
+To register a handler I introduced new syscalls with POK to register and unregister a handler, to enable and disable interrupt delivery to the partition and to acknowledge an interrupt.
+The acknowledge syscall sets the waiting flag mentioned above.
+
+The functions corresponding to these syscalls are implemented in the x86 bsp.c file.
+There is a new pok_bsp_irq_register_hw function, which is only accepting IRQ values for the hardware IRQ lines (0-15).
+pok_bsp_irq_register cannot be used to register IRQ handlers for hardware IRQs.
+
+=  Remaining Issues  =
+==  Forwarding interrupts to user space handlers  ==
+
+
+The transition to user space proved very challenging. 
+I was not able to implement it in a reliable way.
+In my design I will only make the transition to user space once.
+The kernel stack will be cleaned up, after the transition, so no memory leaks will occur there.
+To make this transition the interrupted context and the vector is passed to the user space handler, which is responsible to find the right handler for this interrupt number and before it returns to the point of interruption it has to restore the register and stack state. 
+The return instruction of the handler is used to pop the interrupted EIP from the stack.
+Then the user space shall proceed like no interrupt occurred.
+
+This doesn't work well. 
+This is implemented with manual stack manipulation and magic values to find the data on the stack. 
+This leads to GPF (0xd) as the EIP is pointing to invalid instructions.
+This needs debugging - but GDB is of no help, because it can't handle segmentation. 
+At time of writing, I need to write documentation before I can go back to debugging.
 =  References  =