Compiling the kernel
Process State
Process Context
Concurrency and shared resources
- Locks
Debugging
Porting the kernel to ARM devices
ARM specific files
Contributing
Testing
Useful links

Kernel headers should be copied into /usr/include to be used by libraries and compiled programs. These should be the headers glibc has been compiled against, and should be kept independent of the ones in the kernel source tree. New packages are compiled against these headers, otherwise, if packages are compiled against headers that do not match the headers glibc was compiled against, segfaults or other strange problems may appear. /usr/include headers should be what matches the library object files. By copying the headers instead of symlink them to /usr/src/<linux>/include, we make sure that they remain available if we upgrade our kernel.

Compiling the kernel

Useful in embedded systems, as only the strongly recommended options are set to Y:

make help          # provides a lot of information about kernel config options

make allnoconfig   # useful in embedded systems, setting the strongly recommended options to Y
make clean         # remove most generated files but keep config
make mrproper      # remove all generated files
make defconfig     # gives us a new config
make LSMOD=... localmodconfig   # uses the list of modules to create a configuration
make distclean     # also remove the editor backup and patch reject files

make oldcondif     # uses a provided .config as base

scripts/diffconfig .config.old .config   # shows difference between both kernel configurations

interesting option: CONFIG_WERROR

make
make LOADADDR=0x80008000 uImage
make dtbs

Useful tool to check config security

Process State

TASK_RUNNING, either running or in a runqueue waiting to run. Only possible state for a process executing in user-space.
TASK_INTERRUPTIBLE, process blocked, waiting for some condition to exist.
TASK_UNINTERRUPTIBLE, like TASK_INTERRUPTIBLE but without responding to signals.
TASK_TRACED
TASK_STOPPED

Process Context

A program running in user-space executes a system call or triggers an exception, making the kernel to run in process context.

There is also interrupt context, mostly applied to when the system is executing an interrupt handler (no process is tied to interrupt handlers). Other examples are the execution of a softirq as well as initializing or running the scheduler.

The Kernel may also run kernel threads, standard processes that exist only in kernel-space, like management threads that maintain the buffer and page caches. These processes are scheduled like normal processes and are allowed to sleep.

Concurrency and shared resources

Interrupts
Kernel preemption, causing the kernel to switch from the execution of one system call to another
Multiprocessing

We need to keep as much local state as possible and use locking for the shared resources.

Locks

Mutex, the main kernel locking primitive. Usable in contexts where sleeping is allowed.
Semaphores.
Spinlocks, used with code that is not allowed to sleep (interrupt handlers) or that doesn't want to sleep (critical sections). In single-core processors, it is better not to use spinlocks, as they would waist resources slowing down the lock owner (timeslice schedulers) or cause a deadlock (non-timeslice schedulers).
Alternatives: Lock-free algorithms like Read Copy Update (RCU) and atomic operations.

Debugging

ftp://82.96.64.7/pub/software/scm/git/docs/v1.5.0/howto/isolate-bugs-with-bisect.txt

http://www.reactivated.net/weblog/archives/2006/01/using-git-bisect-to-find-buggy-kernel-patches/

git bisect start – [path]

to restrict bisection to commits that touch [path].

http://www.av8n.com/computer/htm/kernel-lockup.htm

Porting the kernel to ARM devices

ARM11 MPCore example

ARM specific files

arch/arm/Makefile             has macros to detect machine name
         def-configs          includes the default config file
         kernel/debug.s       assembly level debugging
         lib
         boot/Makefile        lists start address from where kernel image has to be decompressed
         tools/mach-types     machine ID
         mm/proc-[CPU_TYPE]

include/asm-arm               set up functions for a specific CPU
        asm/arch/uncompress.h output kernel decompression msgs to UART
                 hardware.h   IO map of HW architecture
                 io.h         HW specific macros
                 irq.h        base address of diferent IRQs
                 irqs.h       IRQ numbers
                 time.h       time interrupt handlers and macros