LINUX KERNEL RESOURCE LOCKING MECHANISM CODE

Round Robin) could be called from within interrupt context if your systick is sufficiently slow. It would seem that a simpler scheduler (e.g.

Of course, I have not yet begun implementing multitasking. While moving to x86 development after beginning in low-capability embedded devices has given me appropriate perspective and experience to understand why too much processing in an interrupt context is bad, I assumed this would be one of the exceptions. I suppose a background/idle kernel task could periodically check if the current task has been running sufficiently long and stage a flag that forces a task switch on the next systick. This would simplify things in that it need only return into a new task. I have yet to drill down into the specifics of scheduling in Linux or Minix, but I always thought the scheduler would be called from the systick handler.

Though this nominally makes sense for interrupts in general, is this methodology traditionally followed for the mutlitask/scheduling system? As I near developing mutlitasking in my own OS I was beginning to consider how this might be implemented.

LINUX KERNEL RESOURCE LOCKING MECHANISM CODE

This is usually solved by the code that processes the interrupt is done in an bottom-half or in a user process depending on the OS architecture. In about all contemporary operating systems, any type of scheduling is prohibited inside the actual interrupt. In general, any scheduling primitive inside an interrupt is usually no-go. So how is this usually addressed in more general terms (more general than just saying 'don't print from the interrupt handlers!' because I guess this conflict could occur over other resources)? However, this means that the code that was interrupted (the actual printing, triggered by the process itself, which holds the lock) will now never finish up and actually release the lock! This is because there's no way we can 'switch out' of the interrupt handler and back to the system call. But since the semaphore has already been acquired, the process is added to the wait list and put to sleep. The keyboard interrupt handler also tries to grab the semaphore. However, while inside the function that actually updates the video memory, a keyboard interrupt occurs. The print system calls grabs the semaphore. This of course also waits for the semaphore and releases it after printing.īut now the failing case is this: A process calls the print system call.

However, I also have an interrupt handler for the keyboard which prints something everytime there's a keyboard interrupt. So of course I wait for the semaphore when printing the string and release it afterwards. So I have a syscall handler (that can handle calls from userspace) that can print a string. So I have created a semaphore for the text console. So I wanted to use this new shiny semaphore. So I have now implemented a semaphore including wait list and connection to scheduler etc. However, now I have a deadlock and want to know what is the way this is usually resolved. Anyway, working on my kernel and am in beginning phases of multitasking (single CPU) and interrupt handling.

I am quite new to o/s development but I do have experience from many other programming contexts.

Linux kernel resource locking mechanism