minix administración de memoria minix administración de memoria cátedra: diseño e...

MINIXMINIXAdministración de MemoriaAdministración de Memoria

Cátedra: Diseño e Implementación de

Sistemas Operativos UTN-FRSF

Tomado de: Sistemas Operativos Diseño e Implementación - A.S.Tanenbaum

Estructura de MINIXEstructura de MINIX• Microkernel

• Estructura en 4 Capas– Gestión de Procesos– Tareas de E/S – Procesos Servidores– Procesos de Usuario

CaracterísticasCaracterísticas• División entre política y mecanismo.

– ¿Qué proceso en qué sitio? (política) MM

– Colocación de mapas de memoria para los procesos (mecanismo) tarea del sistema-KERNEL

• Modelo de administración– Particiones Dinámicas

– Política de asignación First fit

• Dos modelos: – Espacio I&D combinado– Espacio I&D separado

• Solicitud de Memoria– llamada al sistema EXEC – Llamada al sistema FORK

CaracterísticasCaracterísticas

B

A

Minix

Hijo de A

Después de un FORK

B

A

Minix

C

Después que el hijo realiza

EXEC

B

A

Minix0

Límite superior de la

memoria

Situación inicial

CaracterísticasCaracterísticas

Mapa de memoriaMapa de memoria

• Mapa de memoria una vez cargado el SOEspacio para

programas de usuarioDisco RAM

INITFile System

Memory ManagerKernel

Tarea de terminalTarea de discoTarea de reloj

Tarea de HardwareManejo de los procesos

Espacio sin usarVectores de interrupción

Segmentos de un procesoSegmentos de un proceso

SímbolosDatosTexto

Cabecera

PILA

DATOS

TEXTO

BrechaUso total de memoria

Crecimiento de la pila

Crecimiento de los datos

Segmentos de un proceso Un proceso en la

memoria (I&D combinados)

Un proceso en la memoriaUn proceso en la memoria

Texto no compartido(segmentos T&D Combinados)

Texto no compartido(segmentos T&D Separados)

Cómo aparece la información en el campo p_map de la tabla de procesos en caso de:

Virtual Física LongitudPila 0x20 0x340 0x8Datos 0 0x320 0x1cTexto 0 0x320 0

Virtual Física LongitudPila 0x14 0x340 0x8Datos 0 0x32c 0x10Texto 0 0x320 0xc

Un proceso en la memoriaUn proceso en la memoria

T&D separados(se comparte texto)

Manejo de mensajesManejo de mensajes

• Al igual que todos los componentes de MINIX, el MM es impulsado por mensajes

• La estructura algorítmica del MM:Inicialización

while(TRUE){ Recibir un mensaje Ejecutar el procedimiento adecuado Devolver una respuesta si es necesario}


• Relacionados con la asignación y desasignación de la memoria:– FORK, EXIT, WAIT, BRK, EXEC

• Pueden afectar el contenido de la memoria– KILL, ALARM, PAUSE, SIGACTION, SIGSUSPEND,

SIGPENDING, SIGMASK, SGRETURN

• No afectan el manejo de memoria– GETUID, GETGID, GETPID, SETUID, SETGID, SETSID,

GETPGRP

TIPOS DE MENSAJES


Cómo sabe el MM qué hacer ante cada tipo de mensaje que le llega???

contiene la tabla que sirve para transformar los nros de llamada al

sistema en las rutinas que las ejecutan.

Definido en table.cVector de

procedimientos callvec[NCALLS]

Estructuras de datosEstructuras de datos

• Tabla de procesos mproc/usr/src/mm/mproc.h

• Lista de Huecos hole/usr/src/mm/alloc.c

Tabla de procesosTabla de procesossrc/mm/mproc.h

16307 EXTERN struct mproc {16308 struct mem_map mp_seg[NR_SEGS]; /* ptrs a texto, datos y pila*/16309 char mp_exitstatus; /* estado para cuando proceso sale*/16310 char mp_sigstatus; /* # señal cuando un proceso reciba kill*/16311 pid_t mp_pid; /* id del proceso*/16312 pid_t mp_procgrp; /* pid para el grupo del proceso */16313 pid_t mp_wpid; /* pid del proceso que este está esperado*/16314 int mp_parent; /* índice del proceso padre*/1631516316 /* uids y gids efectivas y reales. */16317 uid_t mp_realuid; /* uid real del proceso */16318 uid_t mp_effuid; /* uid efectiva del proceso*/16319 gid_t mp_realgid; /* gid real del proceso*/16320 gid_t mp_effgid; /* gid efectiva del proceso*/1632116322 /* File identification for sharing. */16323 ino_t mp_ino; /* número de i-nodo del archivo */16324 dev_t mp_dev; /* nro. De dispositivo del file system*/16325 time_t mp_ctime; /* tiempo en que cambio el i-nodo*/16326

Tabla de procesosTabla de procesos

16327 /* Información para manejo de señales*/16328 sigset_t mp_ignore; /* 1 ignorar señal, 0 no ingnorar*/16329 sigset_t mp_catch; /* 1 atrapar señal, 0 no atrapar*/16330 sigset_t mp_sigmask; /* señales ha ser bloqueadas */16331 sigset_t mp_sigmask2; /* copia de mp_sigmask*/16332 sigset_t mp_sigpending;/* señales que están siendo bloqu.*/16333 struct sigaction mp_sigact[_NSIG + 1];/*as in sigaction(2)*/16334 vir_bytes mp_sigreturn; /* dir. de la función sigretrun */1633516336 /* Backwards compatibility for signals. */16337 sighandler_t mp_func; /*all sigs vectored to a sing user fcn*/1633816339 unsigned mp_flags; /* bits de bandera */16340 vir_bytes mp_procargs; /*ptr al argumento inic. de la pila*/16341 } mproc[NR_PROCS];

Tabla de procesosTabla de procesos

16343 /* valores de bandera */16344 #define IN_USE 001 /* set when 'mproc' slot in use */16345 #define WAITING 002 /* set by WAIT system call */16346 #define HANGING 004 /* set by EXIT system call */16347 #define PAUSED 010 /* set by PAUSE system call */16348 #define ALARM_ON 020 /*set when SIGALRM timer started*/16349 #define SEPARATE 040 /* set is separate I&D space */16350 #define TRACED 0100 /*set if proc. is to be traced*/16351 #define STOPPED 0200 /*set if proc stopped for tracing*/16352 #define SIGSUSPENDED 0400 /* set by SIGSUSPEND sys. call */1635316354 #define NIL_MPROC ((struct mproc *) 0)

La lista de huecos La lista de huecos src/mm/alloc.c

.... 18820 #define NR_HOLES 128 /* Nº DE ENTRADAS EN LA TABLA DE HUECOS*/18821 #define NIL_HOLE (struct hole *) 01882218823 PRIVATE struct hole {18824 phys_clicks h_base; /* DONDE COMIENZA EL HUECO? */18825 phys_clicks h_len; /* CUANTO OCUPA EL HUECO? */18826 struct hole *h_next; /* PUNTERO A LA SIG. ENTRADA EN LA LISTA*/18827 } hole[NR_HOLES];188281882918830 PRIVATE struct hole *hole_head; /*PUNTERO AL PRIMER HUECO*/18831 PRIVATE struct hole *free_slots; /*PUNTERO A LA LISTA DE ENTRADAS LIBRES

* DE LA TABLA*/...

La lista de huecos La lista de huecos

•Hay dos listas:- hole_head apunta a una lista enlazada de todos los bloques de memoria sin usar.- free_slots apunta a una lista enlazada de las entradas de la tabla que no están siendo usadas.

•Inicialmente, la primera tiene una entrada por cada trozo de memoria físic, y la segunda une las restantes entradas•A medida que la memoria se va fragmentando se van necesitando nuevas entradas para los nuevos huecos. Estas entradas se tomarán de la lista apuntado por free_slots


Mapa de memoria y lista de huecos


Asignación de memoria a un proceso D de 3 k


Liberación de memoria ocupada por el proceso B

El programa principalEl programa principal

MM_init()

Get_work()

Reply (who, error,result2, res_ptr)

Src/mm/main.c

Src/mm/main.cSrc/mm/main.c16627 PUBLIC void main()16628 {16629 /* Rutina principal del MM */16631 int error;16633 mm_init(); /* inicializa tablas del MM */16635 /*loop principal del MM*/16636 while (TRUE) {16637 /* espera un mensaje*/16638 get_work(); /* espera por una llamada la sistema */16639 mp = &mproc[who];16641 /* setea algunas banderas */16642 error = OK;16643 dont_reply = FALSE;16644 err_code = -999;16646 /* si el nro. de llamada es válido. Ejecuta la llamada*/16647 if (mm_call < 0 || mm_call >= NCALLS)16648 error = EBADCALL;16649 else16650 error = (*call_vec[mm_call])();16652 /* Devuelde resultados al usuario para indicar que

terminamos*/16653 if (dont_reply) continue; /*no reply for EXIT and WAIT

*/16654 if (mm_call == EXEC && error == OK) continue;16655 reply(who, error, result2, res_ptr);16656 }16657 }

Src/mm/main.cSrc/mm/main.c

Función MM_INIT(){

•Crear el conjunto de señales que provocan vaciados de núcleo•Obtener mapa de memoria del kernel (ver sys_getmap())•Inicializar tablas del MM•Esperar que FS envie mensaje con tamaño del disco de RAM y entre en línea•Inicializar listas hole_head y free_slots (ver mem_init)•Imprimir información de memoria (total, minix, disco de RAM. Disponible)•Indicar al FS que continue •Indicar a la tarea de mem. dónde está mi tabla de proc

}

Src/mm/main.cSrc/mm/main.c

16660 /*=================================*

16661 * get_work *16662 *=================================*/16663 PRIVATE void get_work()16664 {16665 /* Esperar por el próximo Mensaje */1666616667 if (receive(ANY, &mm_in) != OK)

panic("MM receive error", NO_NUM);16668 who = mm_in.m_source; /*origen del msg*/16669 mm_call = mm_in.m_type; /* # llamada al sist. */16670 }

Src/mm/main.cSrc/mm/main.c16676 PUBLIC void reply(proc_nr, result, res2, respt)16677 int proc_nr; /* process to reply to */16678 int result; /* result of the call */16679 int res2; /* secondary result */16680 char *respt; /* result if pointer */16681 {16682 /* envia una respuesta al proceso de usuario. */1668316684 register struct mproc *proc_ptr;1668516686 proc_ptr = &mproc[proc_nr];16687 /* 16688 * Chequea si el destino esta vivo. Esta16689 * validación debe saltearse si el que llamo es una tarea16690 */16691 if ((who >=0) && ((proc_ptr->mp_flags&IN_USE) == 0 || 16692 (proc_ptr->mp_flags&HANGING))) return;1669316694 reply_type = result;16695 reply_i1 = res2;16696 reply_p1 = respt;16697 if (send(proc_nr,&mm_out)!= OK) panic("MM can't reply", NO_NUM);16698 }

Src/mm/alloc.cSrc/mm/alloc.c

•Este módulo se utiliza para ubicar y liberar memoria destinada a la implementación de las llamadas FORK y EXEC•Tiene la definición de la lista de huecos•Los puntos de entrada al módulo son las funciones:

- mem_init()- max_hole()- alloc_mem()- free_mem()

•Otras funciones:- merge- del_slot


Alloc_mem

•Ubica un bloque de memoria en la lista de bloques libre usando la política First Fit. El bloque consiste en una secuencia de bytes consecutivos y su longitud viene dada en clics. •Devuelve un puntero a un bloque.•Es invocada cuando FORK o EXEC necesitan memoria

Src/mm/alloc.cSrc/mm/alloc.c18840 PUBLIC phys_clicks alloc_mem(clicks)18841 phys_clicks clicks; /* amount of memory requested */18842 {18850 register struct hole *hp, *prev_ptr;18851 phys_clicks old_base;18853 hp = hole_head;18854 while (hp != NIL_HOLE) {18855 if (hp->h_len >= clicks) {18856/* encontramos un hueco suficientemente grande. */18857 old_base = hp->h_base; /*almacena el comienzo*/18858 hp->h_base += clicks; /* toma lo necesario*/18859 hp->h_len -= clicks; /* ajusta el tamaño*/18861/* Si el hueco se usa parcialemten, se ajusta el tamaño*/18862 if (hp->h_len != 0) return(old_base);18864 /* Si se usa entero. Se lo elimina de la lista*/18865 del_slot(prev_ptr, hp);18866 return(old_base);18867 }18869 prev_ptr = hp;18870 hp = hp->h_next;18871 }18872 return(NO_MEM);18873 }


free_mem

•Devuelve un bloque de memoria libre a la lista de huecos.•Los parametros indican la dirección física de comienzo del bloque y su tamaño.•Si el bloque es contiguo a otro anteriormente existente en la lista, el nuevo bloque es unido al bloque o bloques contiguos (ver ejemplo diapositivas 18-20)

Src/mm/alloc.cSrc/mm/alloc.cPUBLIC void free_mem(base, clicks)phys_clicks base; /* dirección de inicio del bloque a liberar*/phys_clicks clicks; /* tamaño en clicks del bloque a liberar*/{ register struct hole *hp, *new_ptr, *prev_ptr; if (clicks == 0) return; if((new_ptr = free_slots)==NIL_HOLE) panic("Hole table full", NO_NUM); new_ptr->h_base = base; new_ptr->h_len = clicks; free_slots = new_ptr->h_next; hp = hole_head;/*no hay bloques en la lista o la direccion del primero es mayor?*/ if (hp == NIL_HOLE || base <= hp->h_base) { /* El bloque es el primero. */ new_ptr->h_next = hp; hole_head = new_ptr; merge(new_ptr); return; } /* Si el bloque no es el primero de la lista se busca la posición */ while (hp != NIL_HOLE && base > hp->h_base) { prev_ptr = hp; hp = hp->h_next;} /* Se encontró la posición y se inserta después de prev_ptr. */ new_ptr->h_next = prev_ptr->h_next; prev_ptr->h_next = new_ptr; merge(prev_ptr);}/* la secuencia es 'prev_ptr', 'new_ptr', 'hp' */

Src/mm/alloc.cSrc/mm/alloc.cdel_Slot

•Borra una entrada en la lista de huecos. •Se llama cuando una petición de asignación de memoria toma un hueco completo, por lo que hay que eliminar una entrada de la lista.

PRIVATE void del_slot(prev_ptr, hp)register struct hole *prev_ptr; /* puntero al bloque anterior*/register struct hole *hp; /* putnero al bloque a eliminar*/{ if (hp == hole_head) hole_head = hp->h_next; else prev_ptr->h_next = hp->h_next; hp->h_next = free_slots; free_slots = hp;}

Src/mm/alloc.cSrc/mm/alloc.cmerge

•Comprueba si hay huecos contiguos y los fusiona. •Los huecos contiguos aparecen después de liberar un bloque de memoria•El parámetro que recibe (hp) apunta al primero de uan serie de tres huecos potencialmente fusionables

Src/mm/alloc.cSrc/mm/alloc.cPRIVATE void merge(hp)register struct hole *hp; /*ptr al hueco a unir */{ register struct hole *next_ptr;/*Si hp apunta al último hueco no hay fusión posible, sino se *intenta unir a su sucesor y extrae la entrada de este de la lsita*/ 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; /* al primer hueco se le

* añade la memoria del 2do */ del_slot(hp, next_ptr); } else { hp = next_ptr; } /* Si ahora hp es ahora el último se retorna; sino se trata de unir con su sucesor*/ 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); }}

Src/mm/alloc.cSrc/mm/alloc.cmax_hole

PUBLIC phys_clicks max_hole(){/* Recorre la lista de huecos hasta encontrar el más grande*/ register struct hole *hp; register phys_clicks max; hp = hole_head; max = 0; while (hp != NIL_HOLE) { if (hp->h_len > max) max = hp->h_len; hp = hp->h_next; } return(max);}

Src/mm/alloc.cSrc/mm/alloc.cPUBLIC void mem_init(total, free) /* Inicializa la lista de huecos*/phys_clicks *total, *free; /* tamaños totales de memoria */{ register struct hole *hp; phys_clicks base; /* dir base del trozo de memoria*/ phys_clicks size; /* tamaños del trozo de memoria*/ message mess;/* Pone todos los huecos en la lista de huecos de memoria libres */ 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];/* Pide al kernel trozos de memoria y coloca cada uno de los huecos. La llamada SYS_MEM responde con la base y el tamaño del siguiente bloque y con la cantidad total de memoria. */ *free = 0; for (;;) { mess.m_type = SYS_MEM; if (sendrec(SYSTASK, &mess) != OK) panic("bad SYS_MEM?", NO_NUM); base = mess.m1_i1; size = mess.m1_i2; if (size == 0) break; /* no hay más trozos de memoria? */ free_mem(base, size); *total = mess.m1_i3; *free += size; }}

minix administración de memoria minix administración de memoria cátedra: diseño e...

Documents