1 / 38

Estructura de MINIX

MINIX Administració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 MINIX. Microkernel Estructura en 4 Capas Gestión de Procesos Tareas de E/S Procesos Servidores

kibo-dudley
Download Presentation

Estructura de MINIX

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. MINIXAdministración de MemoriaCátedra: Diseño e Implementación de Sistemas Operativos UTN-FRSFTomado de: Sistemas Operativos Diseño e Implementación - A.S.Tanenbaum

  2. Estructura de MINIX • Microkernel • Estructura en 4 Capas • Gestión de Procesos • Tareas de E/S • Procesos Servidores • Procesos de Usuario

  3. Caracterí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

  4. Características • Dos modelos: • Espacio I&D combinado • Espacio I&D separado • Solicitud de Memoria • llamada al sistema EXEC • Llamada al sistema FORK

  5. Límite superior de la memoria C Hijo de A B B B A A A Minix Minix Minix 0 Después que el hijo realiza EXEC Situación inicial Después de un FORK Características

  6. Mapa de memoria • Mapa de memoria una vez cargado el SO Espacio para programas de usuario Disco RAM INIT File System Memory Manager Kernel Tarea de terminal Tarea de disco Tarea de reloj Tarea de Hardware Manejo de los procesos Espacio sin usar Vectores de interrupción

  7. PILA Crecimiento de la pila Brecha Uso total de memoria Crecimiento de los datos Símbolos Datos DATOS Texto TEXTO Cabecera Segmentos de un proceso Segmentos de un proceso Un proceso en la memoria (I&D combinados)

  8. Un proceso en la memoria Texto no compartido (segmentos T&D Combinados) Cómo aparece la información en el campo p_map de la tabla de procesos en caso de: Texto no compartido (segmentos T&D Separados)

  9. Un proceso en la memoria T&D separados (se comparte texto)

  10. Manejo 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 }

  11. Manejo de mensajes TIPOS DE MENSAJES • 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

  12. Manejo de mensajes Cómo sabe el MM qué hacer ante cada tipo de mensaje que le llega??? Vector de procedimientos callvec[NCALLS] Definido en table.c contiene la tabla que sirve para transformar los nros de llamada al sistema en las rutinas que las ejecutan.

  13. Estructuras de datos • Tabla de procesos mproc /usr/src/mm/mproc.h • Lista de Huecos hole /usr/src/mm/alloc.c

  14. Tabla de procesos src/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*/ 16315 16316/* 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*/ 16321 16322/* 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

  15. Tabla 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 */ 16335 16336 /* Backwards compatibility for signals. */ 16337 sighandler_t mp_func; /*all sigs vectored to a sing user fcn*/ 16338 16339 unsigned mp_flags; /* bits de bandera */ 16340 vir_bytes mp_procargs;/*ptr al argumento inic. de la pila*/ 16341 } mproc[NR_PROCS];

  16. Tabla 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 */ 16353 16354 #define NIL_MPROC ((struct mproc *) 0)

  17. 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 *) 0 18822 18823 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]; 18828 18829 18830 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*/ ...

  18. La lista de huecos • Hay dos listas: • hole_headapunta 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

  19. La lista de huecos

  20. La lista de huecos Mapa de memoria y lista de huecos

  21. La lista de huecos Asignación de memoria a un proceso D de 3 k

  22. La lista de huecos Liberación de memoria ocupada por el proceso B

  23. MM_init() Get_work() Reply (who, error,result2, res_ptr) El programa principal Src/mm/main.c

  24. Src/mm/main.c • 16627 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; • 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 else • 16650 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 }

  25. Src/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 • }

  26. Src/mm/main.c 16660 /*=================================* 16661 * get_work * 16662 *=================================*/ 16663 PRIVATE void get_work() 16664 { 16665 /* Esperar por el próximo Mensaje */ 16666 16667 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 }

  27. Src/mm/main.c 16676 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. */ 16683 16684 register struct mproc *proc_ptr; 16685 16686 proc_ptr = &mproc[proc_nr]; 16687 /* 16688 * Chequea si el destino esta vivo. Esta 16689 * validación debe saltearse si el que llamo es una tarea 16690 */ 16691 if ((who >=0) && ((proc_ptr->mp_flags&IN_USE) == 0 || 16692 (proc_ptr->mp_flags&HANGING))) return; 16693 16694 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 }

  28. Src/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

  29. Src/mm/alloc.c

  30. Src/mm/alloc.c 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

  31. Src/mm/alloc.c 18840 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 }

  32. Src/mm/alloc.c 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)

  33. Src/mm/alloc.c PUBLIC 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' */

  34. Src/mm/alloc.c del_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; }

  35. Src/mm/alloc.c merge • 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

  36. Src/mm/alloc.c PRIVATE 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); } }

  37. Src/mm/alloc.c max_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); }

  38. Src/mm/alloc.c PUBLIC 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; }}

More Related