Linux Source

Mark's Home↑

How to build vanilla linux kernel from kernel.org

Read explanation on how to verify the signature here.
emerge app-crypt/gnupg (if using gentoo)
gpg --keyserver wwwkeys.pgp.net --recv-keys 0x517D0F0E - this receives the public key, make sure to check that this is still the most current key
Unzipping Linux Kernel (for bzip file)
tar -xvjf filename -C directory
Example: tar -xvjf linux-2.6.14.tar.bz2 -C ./temp/
make mrproper - removes any stale .o files
make menuconfig
make randconfig allyesconfig allnoconfig allmodconfig defconfig

To make a link to the linux kernel:

ln -svin filename/dir link name
s - specifies a symbolic link instead of a hard link
v - verbose
i - interactive, ask before deleting an old link
n - no dereference, treat the destination as a normal file
e.g. ln -svin linux-2.6.18.2 linux

make

headers_install

Install sanitised kernel headers to INSTALL_HDR_PATH
installs a set of kernel headers useful for libraries and user-space tools. A limited set of headers is installed, and those headers are sanitized on their way to the destination directory. It is hoped that distributors will use this mechanism to set up kernel headers for inclusion from user space in the future.

Source Code

Browse Code (usually more recent kernel than below)
Browse Code
Coding style

use checkpatch
use scripts/Lindent
sendpatchset script by Paul Jackson
Documentation/CodingStyle
Documentation/kernel-doc-nano-HOWTO.txt
if, while, etc. vs functions
Comments on LogFS Code
check a-b < 0 vs check a < b
function signatures
add comments to all struct fields to help readability
avoiding patch rejections
static functions - are functions only visible to other functions in the same file
comments on spacing, tabs, etc
move and change code in separate operations
"multi-line" if statement
various
They should *not* be one big function with lots of case statements. They should be lots of small functions!
when to inline
must_check and deprecated
don't split expressions across lines
assert(expression-with-side-effects)
struct xyz xyz_name = {
Adding #ifdef around an #include is considered bad style
the perfect patch
submitting a new driver

volatile (c keyword)

Scripts

make and copy kernel

Processes

Process Management

Hard Disks

Interrupts

cli

CLear Interrupts
cli x86 instruction
clears (i.e. sets to zero) the interrupt flag (IF) in the EFLAGS register
disables all maskable interrupts

sti

Set Interrupts
sti x86 instruction
sets (i.e. sets to one) the interrupt flag (IF) in the EFLAGS register
enables all maskable interrupts to be received by the processor

to determine the type of programmable interrupt controller your computer is using type: cat /proc/interrupts

IO-APIC - the I/O APIC type architecture is used in the system
XT-PIC - the 8259 type architecture is used in the system

interrupt code path

entry.S

assign each interrupt a vector which is used as an index into the Interrupt Descriptor Table(IDT)
the IDT is an array of 8-byte interrupt descriptors
assembly notes:

lines beginning with a period are assembler directives
lines beginning with text followed by a colon are labels(i.e. named locations in the assembly code)

eventually after everything is setup, the result is that the do_IRQ() routine will be called when a hardware interrupt occurs

arch/i386/kernel/irq.c fastcall unsigned int do_IRQ(struct pt_regs *regs)
kernel/irq/handle.c fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
kernel/irq/handle.c fastcall int handle_IRQ_event(unsigned int irq, struct pt_regs *regs, struct irqaction *action)

printk

Depending on the loglevel, the printk message may be output to the console. The output to the console will occur when the priority of the printk is less than console_loglevel.

#define KERN_MSG_LVL KERN_DEBUG
/* value from 0-5(0 - least messages, 5 - most messages) */
#define KERN_MSG_DEBUG_LVL 4

#define KERN_MSG(level, fmt, args...) do { \
   if (level <= KERN_MSG_DEBUG_LVL) { \
      printk(KERN_MSG_LVL "kern_msg * " fmt "\n", ## args ); \
   } \
} while (0)

The following conforms more to ISO C99, however if no args are used (e.g. KERN_MSG (3, "test")), the warning: 'ISO C99 requires rest arguments to be used' appears when the pedantic CFLAG is used. Also, you will see the warning: 'anonymous variadic macros were introduced in C99', due to using __VA_ARGS__, since this was introdueced in ISO C99, but may have not been available previously
```
#define KERN_MSG_LVL KERN_DEBUG
/* value from 0-5(0 - least messages, 5 - most messages) */
#define KERN_MSG_DEBUG_LVL 4

#define KERN_MSG(level, fmt, ...) do { \
   if (level <= KERN_MSG_DEBUG_LVL) { \
      printk(KERN_MSG_LVL "kern_msg * " fmt "\n", ## __VA_ARGS__ ); \
   } \
} while (0) 
							
```

print out function name

#define KERN_FUNC() do { \
        KERN_MSG(5, "%s", __func__); \
} while (0)

Device debugging

device.h

networking

"echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all" - stops kernel from answering pings
location: net/ipv4/sysctl_net_ipv4.c
ref

Block Layer

swappiness

/proc/sys/vm/swappiness
value - 0 to 100
0 - try not to swap pages out
100 - aggressively swap pages out

serial port

drivers/char/tty_io.c

I/O

Direct I/O

operations are not buffered through the kernel
overhead associated with setting up direct I/O include: faulting in and pinning down the relevant user pages
write may happen synchronously since the application must know when it can use the I/O buffer again

block - a fixed-size chunk of data
sector - small block where the size is usually determined by the underlying hardware

Kernel Debuggers

KGDB -Source level debugging for linux kernel. Allows debugging of linux kernel using gdb over a serial line.
References

system calls

related files

arch/i386/kernel/entry.S

#define nr_syscalls ((syscall_table_size)/4)

        # system call handler stub
ENTRY(system_call)
        pushl %eax                      # save orig_eax
        SAVE_ALL
        GET_THREAD_INFO(%ebp)
        testl $TF_MASK,EFLAGS(%esp)
        jz no_singlestep
        orl $_TIF_SINGLESTEP,TI_flags(%ebp)
no_singlestep:
                                        # system call tracing in operation / emulation
        /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */
        testw $(_TIF_SYSCALL_EMU|_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT),TI_flags(%ebp)
        jnz syscall_trace_entry
        cmpl $(nr_syscalls), %eax
        jae syscall_badsys
syscall_call:
        call *sys_call_table(,%eax,4)
        movl %eax,EAX(%esp)             # store the return value
syscall_exit:
        cli                             # make sure we don't miss an interrupt
                                        # setting need_resched or sigpending
                                        # between sampling and the iret
        movl TI_flags(%ebp), %ecx
        testw $_TIF_ALLWORK_MASK, %cx   # current->work
        jne syscall_exit_work

#include "syscall_table.S"

syscall_table_size=(.-sys_call_table)

include/linux/linkage.h

#ifndef ENTRY
#define ENTRY(name) \
  .globl name; \
  ALIGN; \
  name:
#endif

i386/kernel/syscall_table.S

ENTRY(sys_call_table)
	.long sys_restart_syscall
	...

include/asm-i386/unistd.h

/*
* This file contains the system call numbers.
*/

#define __NR_restart_syscall      0
#define __NR_exit                 1
#define __NR_fork                 2
#define __NR_read                 3
#define __NR_write                4

each system call function is of the format sys_SYSTEM_CALL_NAME (e.g. asmlinkage long sys_mlockall(int flags);

Pages

varies among architectures defined in <asm/page.h>

i386 - page size is 4096 bytes

/* PAGE_SHIFT determines the page size */
#define PAGE_SHIFT      12
#define PAGE_SIZE       (1UL >> PAGE_SHIFT)

page shift is the number of least significant bits that can be discarded to get the page frame number. Shifting PAGE_SHIFT amount will give the page frame number.
there is one struct page for each physical page on the system

flags - describe the status of the page
PG_locked
PG_reserved

File System Capabilities

ineresting source code

Interesting Articles

Andrew Morton

SCSI

Acronyms

AFAICT - As Far As I Can Tell
AHCI - Advanced Host Controller Interface
DASD - Direct Access Storage Device
EIP - Extended Instruction Pointer
LUN - Logical Unit Number
LVM - Logical Volume Manager
MTRR - Memory Type Range Registers
PAT - Page Attribute Tables
PAE - Physical Address Extension - allows more than 4GB of physical memory to be addressed in 32-bit systems
PFN - Page Frame Number
FPU Stack - Floating Point Unit Stack
EDD - Enhanced Disk Drive Services - x86 BIOS service that allows the OS to determine which disk the BIOS believes the system booted.
IPI - Inter-Processor Interrupt - special interrupt that interrupts one processor from another processor in a multi-processor system
EFI - Extensible Firmware Interface
RCU - Read-Copy update
- Explanation
- more stuff
- usually in reference to the Logical Volume Manager for the Linux operating system
References

features in config

irq load balancing - processor type and features

floating point in the kernel

discussion

kernel archives

Sparse (Semantic Parser)

site

Debugging

getting good information/output from the kernel
- 1
- 2
- 3
- 4
- 5
Filing Bug Report

DebugFS

explanation

Prove Locking

enable CONFIG_PROVE_LOCKING (lockdep) also try to get a full task state dump via: echo t > /proc/sysrq-trigger
link for above

Tracing

Tracing Patches

ClockSource

TSC unstable
check /proc/cpuinfo for constant_tsc
use cpu_clock vs sched_clock to get the time
ktime example in blktrace
debug patch 1
debug patch 2
Order of choosing

Memory

CPU

Pointers

check for zero or null pointerif (unlikely(ZERO_OR_NULL_PTR(block))

Synchronization

Ways to lock
- Disable interrupts
- spin (i.e. use test and set instruction)
- disable preemption in the scheduler
Mutex vs Semaphore
Sample conversion of semaphore to mutex

#include <linux/mutex.h>

struct mutex mutex_name;
mutex_init(&mutex_name);
mutex_lock(&mutex_name);
mutex_unlock(&mutex_name);

RT-Mutexes: simple blocking mutual exclusion locks with PI support
Big Kernel Lock(BKL)
- Debugging and Removing
Locks and atomic operations

Useful Links

Compiler Stuff

uninitialized_var() - quiets the compilerlink

Compiler Flags when Compiling the Kernel

CFLAGS_REMOVE (e.g. CFLAGS_REMOVE_string.o = -pg)
EXTRA_CFLAGS (e.g. EXTRA_CFLAGS = $(DEBFLAGS) -I$(LDDINC))
adding CFLAGS for a particular file (e.g. CFLAGS_prom_init.o += -mno-minimal-toc)

Memory Allocation

use private data, therefore don't have to worry about ref. countinglink

Userspace IO devices

link

Page Cache

disable Page Cache

Patches

advice

vmlinux

vmlinux includes build timestamps

pipe buffers

ref1
ref2

Other topics