Changes between Version 41 and Version 42 of GSoC/2013/ParavirtualizationOfRTEMS

Timestamp:

09/18/13 14:48:17 (11 years ago)

Author:

Phipse

Comment:

/* Implementation */ GDB && Open work

GSoC/2013/ParavirtualizationOfRTEMS

@@ -297 +297 @@
 
 '''More implementation details''', including source code samples, can be found in the projects [http://phipse.github.io/rtems/ blog!]
-=  Virtualization layer (POK)  =
+=  Virtualization layer  && libpart.a (POK)   =
 
 The virtualization layer is implemented in the user code part of the partitions code.
 Mostly, it 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 is build after libpok.a but with the same 
+[https://github.com/phipse/pok/blob/master/misc/mk/rules-partition.mk makefile rule].
 libpart.a consists of libpok.a plus the objects from the user code files. 
 
@@ -309 +309 @@
 
 I redesigned the interrupt handling in POK.
+The way interrupts were handled before and my changes, are described [http://phipse.github.io/rtems/blog/2013/08/17/pok-hardware-interrupt-handling/ here].
 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 waiting flag is necessary, because a partition needs to process the interrupt before a new one can be delivered, thus imitating hardware behaviour. 
+
+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.
+(see [https://github.com/phipse/pok/blob/master/kernel/include/core/syscall.h syscall.h] and 
+[https://github.com/phipse/pok/blob/master/kernel/core/syscall.c syscall.c] and 
+[https://github.com/phipse/pok/blob/master/kernel/arch/x86/x86-qemu/bsp.c bsp.c] )
 
 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.
+There are new functions: 
+ *  pok_bsp_irq_register_hw,
+ *  pok_bsp_irq_unregister_hw,
+ *  pok_bsp_irq_partition_ack,
+ *  pok_bsp_irq_partition_enable and
+ *  pok_bsp_irq_partition_disable.
+pok_bsp_register_hw and pok_bsp_unregister_hw only accpet IRQ values for the hardware IRQ lines (0-15) and pok_bsp_irq_register cannot be used to register IRQ handlers for hardware IRQs anymore.
+The enable and disable functions will decrease/increase a counter and return the previous state, thus the previous interrupt level can be restored. 
+
+=  Be careful with GDB  =
+
+
+GDB isn't designed for low level debugging.
+To me it seems, it isn't able to handle memory segments.
+When you single-step through the kernel space - user space transition, you will see, that GDB won't show anything on the user-stack, if you inspect the memory address, just 0x00000000. 
+But if you load the values written to %%gs:(%%ebx) back into %%eax, and inspect EAX, it will show the right value. 
+Debugging this piece of code is only able by loading values into the register and print them step by step. 
+I asked a question on [http://stackoverflow.com/questions/18869624/how-can-gdb-print-segmentoffset-addresses stack overflow] about this.
+
+How to use GDB with POK can be found in the pok-devel guide in the section "GDB'ing POK with QEMU". 
+The guide is located in the doc directory of the repo.
 
 =  Remaining Issues  =
@@ -339 +362 @@
 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.
+
+==  Deliver interrupts occurring, while partition is not able to receive  ==
+
+
+This can mean to things: Either the partition has registered an interrupt and is not scheduled at the moment or it is busy servicing another interrupt occurred earlier.
+I [http://phipse.github.io/rtems/blog/2013/07/09/how-late-is-it/ discussed this] earlier under the term pending interrupts, as undelivered interrupts '''mustn't''' get lost and therefore be stored for later delivery. 
+I didn't come around to implement this, but a simple ''unsigned array[16]'' for each partition, counting the undelivered but occurred interrupts, should do it.
+
+The scheduler then has to check this array when it schedules the partition again and care for the delivery of all pending interrupts, either one by one, or by delivering the amount. 
+If the latter is chosen, the partition needs to be aware of this.
+For instance a time_warp function for the clock interrupt is needed.
+Claudio da Silva has provided one [https://gist.github.com/cdcs/5874932 here].
 =  References  =