CS452 - Real-Time Programming - Fall 2008

Lecture 6 - Kernel, Tasks

Questions & Comments

1. Bill Cowan's easy method versus inline assembly.
   • tutorial on inline assembly

Tasks

Kernel maintains a task descriptor (TD) for each created task. That is, to create a task the kernel must allocate a TD and initialize it. The TD normall contains

1. The task's stack pointer, which points to a private stack containing
   • PC
   • other registers
   • local variables

   all ready to be reloaded whenever the task next runs.

2. Possibly the return value for when the task is next activated
3. The task's parent
4. The task's state

Possible states of the task

1. Active: running or about to run
2. Ready: can run if scheduled
3. Blocked: waiting for something to happen

Diagram

Hardware Facts for Eos

Memory Map

• 0x000000 to 0x09FFFF: low memory (size is 640K)
• 0x0A0000 to 0x0FFFFF: VGA, etc (size is 360K)
• 0x100000 to 0x1XXXXF: your kernel (size is determined by you)
• (Ox1XXXXF + 0x1) to 0x1FFFFF: free memory for tasks (size is the remainder of 2 Mbyte)

Devices

Accessed by special I/O instructions

Architecture of X86

General Purpose Registers

• E[A-D]X: general purpose registers
• ESP: the stack pointer
• EBP: the base pointer
• ESI, EDI: used for string copying

All these registers have special names for the low 16 bits. (drop the E), and for the low 8 bits (add an L), and for the second 8 bits (add an H)

Special Purpose Registers

1. IDTR: interrupt descriptor table
   • the IDTR is 48 bits, divided [--16--|---32---]
     1. 16 bit part is limit, the size of the table
     2. 32 bit part is base, the start of the table
   • write using lidt [idtr],where idtr is a pointer a struct containing an interrupt descriptor
   • read using sidt
   • a description of how to hijack a machine using interrupts, which describes the IDT
   • another description
   • a description from a university
2. GDTR: global descriptor table
   1. the GDTR is 48 bits, divided [--16--|---32---]
      1. 16 bit part is limit, the size of the table
      2. 32 bit part is base, the start of the table
   2. write using lgdt [gdtr],where idtr is a pointer a struct containing an interrupt descriptor
   3. read using sidt
3. CS, DS, ES, FS, GS, SS: segment registers
   • address is segment base plus offset
   • segment description
4. EIP: program counter

Addressing Memory

Physical address is

• start of segment + offset

Helps to provide

1. position independent (relocatable) code
2. memory protection
   • program owns segment(s)
   • segment has low and high limits
   • program can't access outside the limits

Six segment registers

1. CS
2. DS
3. ES
4. FS
5. GS
6. SS

Each segment register is an index into a Global Descriptor Table (GDT), which contains

1. low limit
2. high limit
3. etc.

Index is actually contents of register >> 3.

Setting up a Task

Every task requires at least two GDTs

• accessed through CS and DS
• This includes the kernel

The compiler assumes that DS = SS

• That is, the stack is in the data segment.

Set DS = ES = FS = GS = SS for each task

There is no GDT in place when the kernel boots

• You have to create them

How is this done

1. The address of the table is kept in the special register GDTR
2. lgdt sets GDTR; sgdt reads GDTR

Yet another register EFLAGS contains processor state such as

• condition codes
• what is enabled
• Getting started you want to have interrupts disabled!

Setting up a task

• CS points to code in ELF executable
• DS points to memory you allocate for the task.

Context Switch in the 386

int <vector>

• pushes EFLAGS, CS, EIP onto the active task's stack
• finds entry <vector> in the interrupt descriptor table (IDT)
• jumps to the address in the IDT[<vector>]

iretl

• pops EFLAGS, CS, EIP from the active task's stack
• puts them in the registers

Task to kernel

1. int <vector> in task
2. pushal saves all the active task's registers on the active task's stack
3. switch to kernel stack
   1. you got CS, EIP from IDT
   2. ESP from your magic place
   3. DS from the kernel variables
4. restore remainder of kernel state from stack

Kernel to task

1. save kernel state on kernel stack
2. switch to active task's stack
3. restore general purpose registers: popal

iretl gets EFLAGS, CS, EIP from the task stack.

Getting the Kernel Started

Each task is a C function

• e.g. hello-world.c

So is the kernel

• e.g. kernel.c

Each gets compiled and linked into an ELF executable

• ELF = Executable and Linking Format

Then 452-post.py (/u/cs452/public/tools/bin/452-post.py) binds the ELFs together to be downloaded.

Downloading

Before starting to execute the kernel needs to have

1. A stack, on which it can place data, with the stack pointer set.
2. Its first instruction in the PC

The boot loader does this. How?

1. The bound executable obeys the multiboot specification
2. The kernel is called by int main( unsigned long magic, multiboot_info_t *mbiaddr )
3. The stack starts as mbiaddr, magic
4. multiboot_info_t is a struct with the following interesting fields

   typedef struct multiboot_info {
     ...
     unsigned long mods_count;
     unsigned long mods_addr;
     ...
   } multiboot_info_t
       

   The second is a pointer to module_t, the first module record.

5. module_t is a struct with the following interesting fields

   typedef struct module {
     unsigned long mod_start;
     unsigned long mod_end;
     unsigned long string;
     ...
   } module_t

You might find this URL has some interesting information (and links) if you are really interested in how executables are structured, or in the multiboot boot process.

Return to:

• Bill Cowan's Fall 2008 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page