Faculty of Computer Science Institute for System Architecture, Operating Systems Group. Memory Management & Program Loading

Transcription

1 Faculty of Computer Science Institute for System Architecture, Operating Systems Group Memory Management & Program Loading

2 Course Goal Pong Server Paddle Client 1 Paddle Client 2 Keyboard Driver Memory Manager Loader File System Console Name Server RootServer Sigma0 Fiasco Kernel TU Dresden Slide 2

3 Course Goal Starting L4 tasks (e.g. several pong clients) Memory management Interpreting ELF binaries TU Dresden Slide 3

4 Starting L4 Tasks l4_task_new (task_id, mcp, esp, eip, pager_id) Clans & Chiefs: Obsolete security mechanism to restrict IPC Chief creates tasks belonging to his clan Initially RootServer is the chief of all tasks... Task Task Clan Creator (Chief) Task Task Fiasco Kernel TU Dresden Slide 4

5 Starting L4 Tasks (RootServer) Allocate Tasks at RootServer See:l4/kpr/root-server/examples/task_alloc, l4/kpr/base/include/task_alloc.h, l4/kpr/base/include/task.h L4::Task_alloc alloc = L4::Info_page::info_page() ->task_alloc(); get task allocator L4::Task L4::Task_alloc::alloc() transfer task ownership from RootServer to calling task int L4::Task_alloc::free(L4::Task t) kill the task and transfer ownership of task back to RootServer Start Tasks L4::Task::start(ip, sp, pager) start thread 0 of the task at ip with stack at sp and the given pager. L4::Task::kill() stop/kill task TU Dresden Slide 5

6 Possible Variants Single-Server Multi-Server New Task New Task Loader: Create task Pager Memory server ELF interpreter Loader: Create task ELF interpreter Pager Memory Server RootServer Sigma0 RootServer Sigma0 Fiasco Kernel Fiasco Kernel TU Dresden Slide 6

7 Memory Basics Reserve memory from RootServer See:l4/kpr/root-server/examples/allocator, l4/kpr/base/include/allocator.h, l4/kpr/base/include/memory.h L4::Allocator alloc = L4::Info_page::info_page() ->allocator(); get memory allocator interface L4::Memory L4::Allocator::alloc(size) allocate size bytes of memory (must be multiple of 4Kbyte) int L4::Allocator::free(L4::Memory mem) free the given memory object Attach the allocated memory to local address space as shown for I/O memory (Keyboard Driver & Pong Client, Slide 7) using the region mapper. TU Dresden Slide 7

8 Single-Server All components in one address space Loader creates L4 task Loader is ELF interpreter Interprets modules associated with loader Loader is Pager Manages region list (region = piece of virtual memory of a specific task) Translates a page fault of a task to a region Loader is memory server Reserves memory at RootServer (See Memory Basics) Creates memory regions for started user programs TU Dresden Slide 8

9 Multi-Server I All components in separate address spaces Loader Creates L4 tasks ELF interpreter Provides memory objects for read-only ELF segments Allocates memory from memory server for writable ELF segments Uses memory server and pager interfaces Pager Manages region list Translates page-fault IPC to memory object requests (to memory server and loader) TU Dresden Slide 9

10 Multi-Server II Memory server Reserves memory at RootServer Clients may allocate a chunk of memory of a specific size and get a unique ID Clients may request the memory server to map a memory chunk named by its ID Loader must implement this map interface for the read-only program sections too Special hint: Use a common base class for remote objects consisting of: Thread ID of the server providing the object Object ID of the specific object (local to the server) TU Dresden Slide 10

11 IPC Framework Flexpages Sender side (Server) Use l4_snd_fpage_t to send flexpages via IPC streams Receiver side (Client) Set receive flexpage/window before IPC: L4::Ipc_buf<128> msg(0,0); L4::Ipc_client io(&msg, L4_OPCODE(1)); msg.rcv_fpage(l4_fpage(vaddr, size, write, 0)); TU Dresden Slide 11

12 Support for malloc() Provide a morecore function: #include <l4/sigma0/sigma0.h> /* This function must return a pointer to a piece of * free memory. The size must be at least *size bytes, * however it can be more. The size of the memory block * must be returned in *size. A return value of 0 means * 'out of memory'. */ void *morecore(unsigned long *size) {... } Link against libuc_be_morecore.a (-luc_be_morecore.a) TU Dresden Slide 12

13 Program Segment n Program Segment 2 Program Segment 1 ELF Header Interpreting ELF binaries typedef struct { // read-only, read-write,... Elf32_Word p_type; // offset of segment in program image Elf32_Off p_offset; // virtual address of program segment Elf32_Addr p_vaddr; Elf32_Addr p_paddr; // size of segment in program image Elf32_Word p_filesz; // size of segment in memory Elf32_Word p_memsz;... } Elf32_Phdr; typedef struct {... // entry of program (EIP for startup) Elf32_Addr e_entry; // offset of program headers (in file) Elf32_Off e_phoff;... // number of program headers/segments Elf32_Half e_phnum; } Elf32_Ehdr; TU Dresden Slide 13

14 Interpreting ELF binaries Check the ELF Header Elf32_Ehdr *e = (Elf32_Ehdr*)image; Check the ELF Magic ID e_ident[ei_mag0] == ELFMAG0 && e_ident[ei_mag1] == ELFMAG1 && e_ident[ei_mag2] == ELFMAG2 && e_ident[ei_mag3] == ELFMAG3 Check the ELF class e_ident[ei_class] == ELFCLASS32 e_ident[ei_data] == ELFDATA2LSB e_ident[ei_osabi] == ELFOSABI_SYSV Check the ELF architecture e_type == ET_EXEC && e_machine == EM_386 && e_version == EV_CURRENT NOTE: Use header file: l4/util/elf.h TU Dresden Slide 14

15 Interpreting ELF binaries Load the ELF program segements Elf32_Phdr *p = (Elf32_phdr*)(image + e->e_phoff); for (i=0; i<e->e_phnum; i++) { if (p[i].p_type!= PT_LOAD p[i].p_memsz == 0) continue; // segement occupies no memory if (p[i].p_vaddr + p[i].p_memsz >= 0xC ) return 0; // binary exceeds userland if (p[i].p_filesz > p[i].p_memsz) return 0; // corrupt binary if (p[i].p_flags & PF_W) p[i].p_filesz < p[i].p_memsz) { // writable segment } else { // read-only segment } } TU Dresden Slide 15