MINIX 3. Memory Management DATA STRUCTURES

Size: px

Start display at page:

Download "MINIX 3. Memory Management DATA STRUCTURES"

Bertha Ryan
6 years ago
Views:

1 MINIX 3 Memory Management In MINIX 3 memory is managed through multiple partitions technique. The Process Manager (PM) is the server process deals with memory management. PM uses two important data structures: Process Table Hole Table Process Table holds necessary information for PM to manage user processes in memory. DATA STRUCTURES /servers/pm/mproc.h EXTERN struct mproc { struct mem_map mp_seg[nr_local_segs]; /* points to text, data, stack */ char mp_exitstatus; /* storage for status when process exits */ char mp_sigstatus; /* storage for signal # for killed procs */ pid_t mp_pid; /* process id */ pid_t mp_procgrp; /* pid of process group (used for signals) */ pid_t mp_wpid; /* pid this process is waiting for */ int mp_parent; /* index of parent process */ unsigned mp_flags; /* flag bits */ char mp_name[proc_name_len]; /* process name */ mproc[nr_procs]; The most important field is mp_seg array, which maintains information of the three segments associated to a process: 1. Text 2. Data 3. Stack 1

2 Each segment is structured with the follow layout: /include/minix/type.h struct mem_map { vir_clicks mem_vir; /* virtual address */ phys_clicks mem_phys; /* physical address */ vir_clicks mem_len; /* length */ ; Each field is measured in clicks rather than in byte for a simple reason. Each click is 1024 bytes Therefore is possible to refer to 2 2 = 2 address fields, 4 terabytes (4096 gigabyte), rather 32 than the standard 2. Another data structure is the Hole Table. /include/minix/sys_config.h #define _NR_PROCS 64 /include/minix/config.h #define NR_PROCS _NR_PROCS /servers/pm/alloc.c #define NR_HOLES (2*NR_PROCS) /* max # entries in hole table*/ PRIVATE struct hole { struct hole *h_next; /* pointer to next entry on the list */ phys_clicks h_base; /* where does the hole begin? */ phys_clicks h_len; /* how big is the hole? */ hole[nr_holes]; This table records holes created when a new process is allocated in memory. To the Hole Table are associated two linked list: 1. free holes list headed by hole_head; 2. a list of free slots in the Hole Table. This list is headed by free_slots. Initially the former list has one entry for each chunk of physical memory, while the second list links together the remaining table slots. As memory becomes more fragmented in the course of time, new table slots are needed to represent those areas. These slots are taken from the list headed by free_slots. 2

3 The free holes list is ordered with the first-fit algorithm. In this way the list is kept sorted in order of increasing memory address. PROCESS IMAGE MEMORY LAYOUT The default of MINIX 3 is to compile programs to use separate I and D space. This choice is advantageous because a text segment can be shared between two or more processes. For each process is reserved a fixed amount of memory for the combined text, data and stack segments. The amount used for a child process created by Fork is the same as the parent had. If the child does an Exec later, the new size is taken from the header of the file Exec'ed. Memory layout consists of the text segment followed by data segment. Between data and stack segment there s an unused memory, called gap. The data segment grows upward and the stack grows downward, so each can take memory from the gap. If they meet, the process must be killed. 3

4 HOLE TABLE INITIALIZATION Hole Table is initialized by mem_init(). This procedure is called at the end of the PM s initialization procedure, pm_init(). /servers/pm/alloc.c PUBLIC void mem_init(chunks, free) List of free memory chunks struct memory *chunks; phys_clicks *free; { Output parameter, free memory size in clicks int i; register struct hole *hp; /* Put all holes on the free list. */ for (hp = &hole[0]; hp < &hole[nr_holes]; hp++) hp->h_next = hp + 1; hole[nr_holes-1].h_next = NIL_HOLE; hole_head = NIL_HOLE; free_slots = &hole[0]; /* Use the chunks of physical memory to allocate holes. */ *free = 0; for (i=nr_mems-1; i>=0; i--) { if (chunks[i].size > 0) { free_mem(chunks[i].base, chunks[i].size); *free += chunks[i].size; 4

5 HOLES INSERTION IN THE FREE HOLES LIST PUBLIC void free_mem(base, clicks) phys_clicks base; /* base address of block to free */ phys_clicks clicks; /* number of clicks to free */ { register struct hole *hp, *new_ptr, *prev_ptr; if (clicks == 0) return; if ( (new_ptr = free_slots) == NIL_HOLE) panic( FILE,"hole table full", NO_NUM); new_ptr->h_base = base; new_ptr->h_len = clicks; free_slots = new_ptr->h_next; hp = hole_head; if (hp == NIL_HOLE base <= hp->h_base) { /* Block to be freed goes on front of the hole list. */ new_ptr->h_next = hp; hole_head = new_ptr; merge(new_ptr); return; prev_ptr = NIL_HOLE; while (hp!= NIL_HOLE && base > hp->h_base) { prev_ptr = hp; hp = hp->h_next; Is there a free slot? Checks if the hole is: The first to allocate; The previous to the first hole now accessible. Then insert hole to the head of the list. Decides the insertion position new_ptr->h_next = prev_ptr->h_next; prev_ptr->h_next = new_ptr; merge(prev_ptr); Insertion 5

6 HOLES FUSION /servers/pm/alloc.c PRIVATE void merge(hp) register struct hole *hp; /* ptr to hole to merge with its successors */ { register struct hole *next_ptr; if ( (next_ptr = hp->h_next) == NIL_HOLE) return; if (hp->h_base + hp->h_len == next_ptr->h_base) { else { hp->h_len += next_ptr->h_len; del_slot(hp, next_ptr); hp = next_ptr; if ( (next_ptr = hp->h_next) == NIL_HOLE) return; if (hp->h_base + hp->h_len == next_ptr->h_base) { hp->h_len += next_ptr->h_len; del_slot(hp, next_ptr); Fusion is impossible if the hole is the last in the list. Merge if the two holes are contiguous Free slot of the absorbed hole. Link new hole with the successive of the absorbed hole. 6

7 MEMORY ALLOCATION Memory is allocated only with a Fork or Exec. When a process is allocated in memory remain in that position for all its execution. It can t be change because of absence of swap procedures. The procedure for the allocation memory is: /servers/pm/alloc.c PUBLIC phys_clicks alloc_mem(clicks) phys_clicks clicks; /* amount of memory requested */ { register struct hole *hp, *prev_ptr; phys_clicks old_base; do { prev_ptr = NIL_HOLE; hp = hole_head; while (hp!= NIL_HOLE && hp->h_base < swap_base) { while (swap_out()); return(no_mem); if (hp->h_len >= clicks) { prev_ptr = hp; /* We found a hole that is big enough. Use it. */ old_base = hp->h_base; /* remember where it started */ hp->h_base += clicks; /* bite a piece off */ hp->h_len -= clicks; /* ditto */ /* Delete the hole if used up completely. */ if (hp->h_len == 0) del_slot(prev_ptr, hp); /* Return the start address of the acquired block. */ return(old_base); hp = hp->h_next; Search a suitable hole for the process size. #define swap_out() (0) 7

8 PROCESS MEMORY DEALLOCATION A process termination is notified by Exit system call. This information is kept by do_pm_exit which calls pm_exit. /servers/pm/forkexit.c PUBLIC void pm_exit(rmp, exit_status) register struct mproc *rmp; /* pointer to the process to be terminated */ { /* Release the memory occupied by the child. */ if (find_share(rmp, rmp->mp_ino, rmp->mp_dev, rmp->mp_ctime) == NULL) { free_mem(rmp->mp_seg[t].mem_phys, rmp->mp_seg[t].mem_len); /* Free the data and stack segments. */ free_mem(rmp->mp_seg[d].mem_phys, rmp->mp_seg[s].mem_vir + rmp->mp_seg[s].mem_len - rmp->mp_seg[d].mem_vir); 8

9 MEMORY INITIALIZATION When MINIX 3 is installed on Hard-disk is needed to load it in the central memory. Each hard-disk can be divided in partition. The first sector of the hard-disk, called master boot record, contains a program called boot loader and the partition table, which records information on the various disc s partitions. The boot loader reads the partition table to find the active partition. The first sector of the active partition, called boot block, contains the bootstrap program, a very small program container in only one sector, which load a program called boot. This one loads the operating system itself: it search the boot image to load servers and drivers in specified memory areas. /kernel/table.c PUBLIC struct boot_image image[] = { /* process nr, pc, flags, qs, queue, stack, traps, ipcto, call, name */ { IDLE, idle_task, IDL_F, 8, IDLE_Q, IDL_S, 0, 0, 0, "IDLE", { CLOCK, clock_task, TSK_F, 64, TASK_Q,TSK_S, TSK_T, 0, 0, "CLOCK", { SYSTEM, sys_task, TSK_F, 64, TASK_Q,TSK_S, TSK_T, 0, 0, "SYSTEM", { HARDWARE, 0, TSK_F, 64, TASK_Q,HRD_S, 0, 0, 0, "KERNEL", { PM_PROC_NR, 0, SRV_F, 32, 3, 0, SRV_T, SRV_M, PM_C, "pm", { FS_PROC_NR, 0, SRV_F, 32, 4, 0, SRV_T, SRV_M, FS_C, "fs", { RS_PROC_NR, 0, SRV_F, 4, 3, 0, SRV_T, SYS_M, RS_C, "rs", { TTY_PROC_NR, 0, SRV_F, 4, 1, 0, SRV_T, SYS_M, DRV_C, "tty", { MEM_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, DRV_M, MEM_C, "memory", { LOG_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, SYS_M, DRV_C, "log", { DRVR_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, SYS_M, DRV_C, "driver", { INIT_PROC_NR, 0, USR_F, 8, USER_Q, 0, USR_T, USR_M, 0, "init", ; 9

10 When the start-up phase is finished, memory has this layout. EXTENDED MEMORY HMA UMA BASE MEMORY 10

11 SOME IMPORTANT AREAS The first section of the Base Memory is called BIOS memory. The former 1024 bytes contain the table of the interrupt vectors. The latter 256 bytes contain informations used by driver to know hardware s details. /kernel/ibm/memory.h #define BIOS_MEM_BEGIN 0x00000 /* all BIOS memory */ #define BIOS_MEM_END 0x004FF #define BIOS_IVT_BEGIN 0x00000 /* BIOS interrupt vectors */ #define BIOS_IVT_END 0x003FF #define BIOS_DATA_BEGIN 0x00400 /* BIOS data area */ #define BIOS_DATA_END 0x004FF UMA area is divided in three sectors of 128 Kbytes. The first one is called VIDEO RAM and the display s driver write datas directly in this part of memory. Then asks to monitor to show them on the screen. #define UMA_VIDEO_RAM_BEGIN 0xA0000 /* video RAM */ #define UMA_VIDEO_RAM_END 0xBFFFF #define UMA_GRAPHICS_RAM_BEGIN 0xA0000 /* graphics RAM */ #define UMA_GRAPHICS_RAM_END 0xAFFFF #define UMA_MONO_TEXT_BEGIN 0xB0000 /* monochrome text */ #define UMA_MONO_TEXT_END 0xB7FFF #define UMA_COLOR_TEXT_BEGIN 0xB8000 /* color text */ #define UMA_COLOR_TEXT_END 0xBFFFF 11

Operating Systems Design and Implementation

Operating Systems Design and Implementation Chapter 4 (version January 3, 28) Melanie Rieback Vrije Universiteit Amsterdam, Faculty of Sciences Dept. Computer Science Room R4.23. Tel: (2) 598 7874 E-mail: