When makeing two kernels with different configuration files in a row, the build system does strange mix for the second one. This is because the dependency tracking is done only on the time of files, and not path.

We (I) should add a dependency tracking on the contents, or the name of the file...

There are two main types of exception/interrupts:

• hardware interrupts
• program exception (sysreq, faults, traps, ...)

We'll need to be able to switch from a task to another when handling exceptions, this is because of different needs, but in the end is wanted:

• syscall triggering a device action, thus making the task non-eligible to scheduling until the request ends
• syscall begin sched_switch() or yield()
• page fault triggering a page refill

Sometimes for hardware interrupts, we want to be able to switch tasks as well (eg timer + preempt)

Unfortunately, we cant do most of these jobs directly from the exception handlers because some CPUs (arm) use a special stack pointer when handling interrupts and exceptions. We dont want to loose time in IRQ processing, so we'll spend more time in exception processing.

We could handle all this a portable and easy way if we switched back to kernel mode (not exception or user). On exception/syscall, we can switch to other kernel-mode threads.

Optional exception:

This does not concern IRQs, which must be as-quick as possible. But as we sometimes have to switch threads on IRQ, we should add a mecanism allowing the IRQ handler to request a system service ASAP. Then directly in the asm IRQ handling code, we can detect this service request, and make the IRQ handler jump to the syscall code rather than returning to the user code.

Block device API

Add a flag argument in requests in order to be able to optimize buffer-cache operations, we could imagine:

• nocache attribute
• some hints about the usage of blocks (write only, read once, …)

This could allow not to cache certain blocks because upper layer knows they wont be reused, and they would clean the cache, which is not wanted

Buffer cache implementation as a block-device

• A double struct:
  • a linked-link implementing a LRU
  • a hash-table indexed by LBA for lookups
• Have a dirty flag