La descarga está en progreso. Por favor, espere

La descarga está en progreso. Por favor, espere

Sistema Paginado Santiago Elizondo Mujica Pedro Henríquez Castellano Ingeniería en Informática Diseño de Sistemas Operativos Curso 2005 - 2006.

Presentaciones similares


Presentación del tema: "Sistema Paginado Santiago Elizondo Mujica Pedro Henríquez Castellano Ingeniería en Informática Diseño de Sistemas Operativos Curso 2005 - 2006."— Transcripción de la presentación:

1 Sistema Paginado Santiago Elizondo Mujica Pedro Henríquez Castellano Ingeniería en Informática Diseño de Sistemas Operativos Curso

2 I N D I C E T E M A T I C O 1.Introducción 2.Diagrama General 3.Estructuras de Datos Tabla de Páginas Directorio de Páginas Cachés 4.Gestión Asignación y Liberación de páginas Asignación y Liberación de zonas de memoria (núcleo) Bloqueo de páginas en memoria 5.Tratamiento de Excepciones 6.Novedades de la Version 2.6

3 Todo proceso tiene asociado un espacio de direccionamiento donde se encuentran las zonas de memoria que le han sido asignadas. Este espacio se compone de varias regiones de memoria: código datos inicializados no inicializados código y datos de las bibliotecas compartidas pila Memoria del núcleo Entorno Argumentos Pila Pila Datos (bss) Datos (data) Código Espacio de direccionamiento de un proceso 0xC _end _data _etext 0 INTRODUCCIÓN

4 Al arrancar un proceso, no siempre es necesaria toda la información del mismo PAGINACIÓN BAJO DEMANDA El espacio de cada región de memoria se organiza en páginas para un mejor manejo de la información. Cada pagina es de tamaño fijo. INTRODUCCIÓN Memoria del núcleo Entorno Argumentos Pila Pila Datos (bss) Datos (data) Código Espacio de direccionamiento de un proceso 0xC _end _data _etext 0

5 mm task_struct count pgd mmap mmap_avl mmap_sem mm_struct 0x x x8059BB8 DATA CODE vm_next vm_area_struct vm_end vm_start vm_flags vm_inode vm_ops vm_next vm_area_struct vm_end vm_start vm_flags vm_inode vm_ops Memoria física DIAGRAMA GENERAL

6 Los procesos necesitan direcciones contiguas DIRECCIONES VIRTUALES (no tienen porqué ser contiguas en memoria física) Estas direcciones son utilizadas tanto por los procesos como por el núcleo. Para acceder a memoria es necesario convertir la dirección virtual en una dirección física. La dirección virtual se divide en dos partes: número de página desplazamiento dirección PaginaDesplaz. PaginaDesplaz. Dirección virtual Dirección física Tabla de páginas ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

7 El número de página se utiliza como índice de una tabla de páginas y el desplazamiento hace referencia a la posición que ocupa el dato dentro de la página en cuestión. Todos los accesos a memoria se realizan a través de la tabla de páginas y cada proceso tiene una propia. Para que 2 procesos compartan una página, debe aparecer el nº de marco de la página física en sus respectivas tablas de páginas. marco es a memoria física lo que página a memoria virtual dirección PaginaDesplaz. PaginaDesplaz. Dirección virtual Dirección física Tabla de páginas ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

8 La tabla de páginas contiene la siguiente información: Flag de validación nº de marco (memoria física) información de control Cuando el contenido de una página se altera, el núcleo se encarga de actualizar la página correspondiente TABLA DE DESCRIPTORES DescriptorPágina de memoria dirección PaginaDesplaz. PaginaDesplaz. Dirección virtual Dirección física Tabla de páginas ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

9 La estructura page ( ) define el formato de cada descriptor. Contiene los siguientes campos: struct page { page_flags_tpage_flags_t flags;flags atomic_tatomic_t _count; atomic_tatomic_t _mapcount; unsigned long private;private struct address_space *mapping;address_space pgoff_tpgoff_t index;index struct list_head lru;list_head #if defined(WANT_PAGE_VIRTUAL)WANT_PAGE_VIRTUAL void *virtual; #endif }; ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

10 TIPOCAMPODESCRIPCIÓN page_flags_tflagsEstado de la página atomic_tatomic_t;_countNúmeros de referencia a la página atomic_t_mapcountContador de las entradas a la tabla de páginas. Limita la busqueda reverse mapping unsigned longprivateCuando la pagina esta libre indica el orden en el buddy system. struct address_space address_space *mappingSi bit menos significativo esta a 0 o NULL es un puntero a inode, sino es un puntero a anon_vma (memoria anonima) object. Esta estructura contiene métodos como set_page_dirty set_page_dirty pgoff_tpgoff_t indexindex Dezplazamiento dentro del mapeado. struct list_headlist_headlruLista paginas a salir (algoritmo lru) ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

11 CONSTANTE (FLAGS) VALORSIGNIFICADO PG_locked 0La página está bloqueada en memoria PG_error 1Se ha producido un error en la carga de la página en memoria PG_referenced 2La página ha sido accedida PG_uptodate 3El contenido de la página está actualizado PG_dirty 4Indica si el contenido de la página se ha modificado PG_lru 5 PG_reserved 11La página está reservada para un uso futuro, no es posible acceder a ella. PG_private 12Contiene datos privados (something private) PG_writeback 13Se indica que la pagina usa el método writeback PG_swapcache 1616 Indica si la pagina esta intercambiada PG_nosave_free 18Pagina libre, pero no debería ser escrita. Los valores que puede tomar el campo flags ) de la estructura anterior se muestran en la siguiente tabla:linuxpage-flags.h ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

12 PROBLEMAS Es necesario mantener la tabla de páginas en memoria, sin embargo, dado el espacio de direccionamiento de cada proceso sería imposible. Otro problema que surge con este tipo de tablas tiene que ver con la velocidad. Si la tabla de un proceso es muy grande, acceder a ella ralentizaría la ejecución del mismo. SOLUCIÓN Como solución, Linux descompone la tabla de páginas original en distintos niveles. Este conjunto de tablas se denomina directorio de páginas. CAT PAG DESPLAZAMIENTOPAG OFFSET addr ESTRUCTURAS DE DATOS: TABLAS DE PÁGINAS

13 El directorio de tablas de páginas contiene en cada entrada la dirección base de la tabla de páginas correspondiente. Se utilizan los 10 bits de mayor peso de la dirección lineal (31-22) como índice en el directorio. Cada tabla de páginas contiene en cada entrada la dirección base de una página física o marco. Se utilizan los siguientes 10 bits de la dirección lineal (21-12) como índice en la tabla. Los restantes 12 bits de la dirección lineal se utilizan como desplazamiento dentro del marco de página. CAT PAG DESPLAZAMIENTOPAG OFFSET addr ESTRUCTURAS DE DATOS: DIRECTORIO DE PÁGINAS GLOBAL

14 Linux soporta tipos de arquitecturas basadas en 3 niveles, por lo que introduce una tabla intermedia para darles soporte. Si la arquitectura pertenece a la familia x86, Linux utiliza la tabla intermedia que contiene un único descriptor. Los siguientes tipos están declarados en y son los tipos de datos utilizados en las entradas de las tablas de páginas. L1L2L3offset Directorio Intermedio Paginas Memoria fisica typedef struct { unsigned long pte_low, pte_high; } pte_t;pte_t typedef struct { unsigned long long pmd; } pmd_t;pmd_t typedef struct { unsigned long long pgd; } pgd_t;pgd_t ESTRUCTURAS DE DATOS: DIRECTORIO DE PÁGINAS GLOBAL

15 count pgd mmap mmap_avl mmap_sem mm_struct mm task_struct Cada proceso (task_struct) tiene un campo mm de tipo mm_struct que almacena la información de su espacio de direcciones. El campo pgd es del tipo pgd_t: typedef struct { unsigned long long pgd; } pgd_t; pgd_t Mantiene el directorio de páginas utilizado para resolver la dirección física dada una dirección virtual. ESTRUCTURAS DE DATOS: DIRECTORIO DE PÁGINAS GLOBAL

16 count pgd mmap mmap_avl mmap_sem mm_struct mm task_struct Para localizar una dirección (addr), es necesario saber a que pgd_t pertenece: pgd = mm->pgd[addr >> 22]; y determinar la entrada correspondiente en la tabla de descriptores intermedia: pmd = (pmd_t *) pgd; Una vez sabemos a qué entrada pmd_t corresponde la dirección, se consulta el último nivel del árbol: un arreglo de PTRS_PER_PTE (1024) objetos de tipo pte_t asociado a la estructura pmd_t: pte = pmd[(addr>>PAGE_SHIFT) & (PTRS_PER_PTE - 1)]; ESTRUCTURAS DE DATOS: DIRECTORIO DE PÁGINAS GLOBAL

17 La mejor forma de obtener un buen rendimiento consiste en mantener en memoria caches de las páginas que se utilizan muy a menudo. Las páginas pueden corresponder a: - Código ejecutado por los procesos - Contenido de archivos proyectados en memoria Linux emplea unas cuantas caches para la gestión de la memoria: - Buffer Cache - Cache de Páginas - Cache de Intercambio (swap) - Caches Hardware La caché se gestiona dinámicamente. DATA CODE pagina Proceso Memoria Disco ESTRUCTURAS DE DATOS: CACHÉ DE PÁGINAS

18 Buffer Cache Contiene buffers de datos que son utilizados por los manejadores de dispositivos de bloques. Un dispositivo de bloques es aquel sobre el que sólo se pueden realizar operaciones de lectura o escritura de bloques de tamaño fijo. Si un bloque se puede encontrar en el buffer cache, no es necesario leerlo del dispositivo de bloques físico. Cache de Páginas Se utiliza para acelerar el acceso a imágenes y datos en disco. Guarda el contenido lógico de un fichero de página en página. Conforme las páginas se leen en memoria, se almacenan en la page cache. DATA CODE pagina Proceso Memoria ESTRUCTURAS DE DATOS: CACHÉ DE PÁGINAS

19 Cache de Intercambio (swap) Solo las páginas que han sido modificadas (dirty) son guardadas en el fichero de intercambio. Evita muchas operaciones de disco innecesarias y costosas producidas en un sistema con mucho trasiego de páginas. Caches Hardware Es una cache normalmente implementada en el propio procesador; la cache de entradas de tabla de página. El procesador no necesita siempre leer la tabla de páginas directamente, sino que guarda en esta cache las traducciones de las páginas conforme las va necesitando. Son los Translation Look-aside Buffers (TLB) que contienen copias de las entradas de la tabla de páginas de uno o más procesos del sistema. DATA CODE pagina Proceso Memoria ESTRUCTURAS DE DATOS: CACHÉ DE PÁGINAS

20 Linux utiliza el principio del Buddy system para asignar y liberar eficientemente bloques de páginas. El núcleo mantiene una lista de grupos de páginas disponibles. El tamaño de los grupos es fijo, siendo asignados un número de páginas igual a potencias de 2. 0Grupos de 1 página 1Grupos de 2 páginas... 5Grupos de 32 páginas Cada grupo hace referencia a páginas contiguas en memoria. pagina pagina pagina ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

21 BUDDY SYSTEM: Petición de asignación busca un grupo disponible dentro de la lista que contiene grupos de páginas de tamaño igual o inmediatamente superior al especificado. El grupo se divide en 2 partes: tantas páginas como tamaño de memoria especificado resto de páginas que continúan disponibles ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

22 Las páginas que no son utilizadas se insertan en las otras listas. Dentro de cada lista, se comprobaría si el grupo de páginas adyacentes se encuentra disponible, en ese caso se fusionan los grupos y pasan a la lista de grupos de tamaño inmediatamente superior. Así sucesivamente hasta llegar al tope. Este proceso se repite si en vez de ser páginas que sobran de una asignación, son páginas que han sido liberadas. ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

23 zone 456 page Nr_fr ee 0 page nr_free page free_area ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

24 La tabla free_area (linux/mmzone.h) contiene la dirección del primer descriptor de grupo de páginas para cada tamaño de grupo: La estructura zone (linux/mmzone.h) contiene un vector de areas libres (free_area. La estructura zonelist (linux/mmzone.h) contiene un vector de estructuras zones: La memoria física se divide en multiples zonas: 0- ZONE_DMA < 16 MB ISA DMA capable memory 1- ZONE_NORMAL MB direct mapped by the kernel 2- ZONE_HIGHMEM > 896 MB only page cache and user processes 3- MAX_NR_ZONES struct free_area {free_area struct list_head free_list;list_headfree_list unsigned long nr_free; }; struct zonelist {zonelist struct zone *zones[MAX_NUMNODES * MAX_NR_ZONES + 1];zoneMAX_NUMNODESMAX_NR_ZONES }; ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

25 struct zone {zone unsigned long free_pages;free_pages unsigned long pages_min, pages_low, pages_high; unsigned long lowmem_reserve[MAX_NR_ZONES];MAX_NR_ZONES /* Diferentes tamaños de area libre */ struct free_area free_area[MAX_ORDER];free_areaMAX_ORDER ZONE_PADDING(_pad1_)ZONE_PADDING /* Fields commonly accessed by the page reclaim scanner */ spinlock_t lru_lock;spinlock_t struct list_head active_list;list_head struct list_head inactive_list;list_head unsigned long nr_scan_active; unsigned long nr_scan_inactive; unsigned long nr_active; unsigned long nr_inactive; unsigned long pages_scanned; int all_unreclaimable; ZONE_PADDING(_pad2_)ZONE_PADDING } ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

26 #define get_free_page get_zeroed_pageget_zeroed_page fastcallfastcall unsigned long get_zeroed_page(unsigned int gfp_mask)get_zeroed_page { struct page * page;page BUG_ONBUG_ON(gfp_mask & __GFP_HIGHMEM);__GFP_HIGHMEM pagepage = alloc_pages(gfp_mask | __GFP_ZERO, 0);alloc_pages__GFP_ZERO if (page)page return (unsigned long) page_address(page);page_addresspage return 0; } fastcallfastcall unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order)__get_free_pagesorder { struct page * page;page page = alloc_pages(gfp_mask, order);alloc_pagesorder if (!page)page return 0; return (unsigned long) page_address(page);page_addresspage } ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

27 Se distinguen dos tipos de paginas: Hot: La pagina esta en la cache del procesador. Hot: La pagina esta en la cache del procesador. Cold: La pagina esta en la memoria principal. Cold: La pagina esta en la memoria principal. void free_hot_page(struct page *page); void free_hot_page(struct page *page); void free_cold_page(struct page *page); void free_cold_page(struct page *page); ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

28 fastcall void __free_pages(struct page *page, unsigned int order) {fastcall__free_pagespage order if (!PageReserved(page) && put_page_testzero(page)) {PageReservedpageput_page_testzeropage if (order == 0)order free_hot_page(page);free_hot_pagepage 905 else __free_pages_ok(page, order);__free_pages_okpageorder } } 912 fastcall void free_pages(unsigned long addr, unsigned int order)912fastcallfree_pagesaddrorder { if (addr != 0) {addr BUG_ON(!virt_addr_valid((void *)addr));BUG_ONvirt_addr_validaddr __free_pages(virt_to_page((void *)addr), order);__free_pagesvirt_to_pageaddrorder } } ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS

29 Linux ofrece 2 tipos de funciones para asignar zonas de memoria del espacio de direccionamiento propio del núcleo: kmalloc y kfree: páginas contiguas en memoria central - Útiles para la gestión de zonas pequeñas. - Es más apropiada para el manejo de memoria utilizada por dispositivos o tareas en tiempo real. - Ineficaces con zonas de grandes tamaños - Bloques de tamaño fijo vmalloc y vfree: páginas no contiguas en memoria central - El tamaño de la memoria desperdiciada es menos importante. ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS (NÚCLEO)

30 En la implementación de kmalloc y kfree, Linux utiliza listas de zonas disponibles. Existe una para cada tamaño de zona. Aunque kmalloc pida un tamaño específico, Linux busca dentro de la lista de tamaño inmediatamente superior. El número de páginas varía según el tamaño de los bloques almacenados en la lista. Como mínimo se establece tantas como sean necesarias para formar un bloque. firstfree next firstfreebh_next Listas de bloques de memoria disponibles firstfree ASIGNACIÓN Y LIBERACIÓN DE PÁGINAS (NÚCLEO)

31 Linux, al arrancar un proceso, evita cargar todas las páginas que forman parte del espacio de direccionamiento de éste utilizando la paginación bajo demanda. De la misma forma, cuando el núcleo necesita memoria central puede decidir liberar aquellas páginas que no han sido utilizadas en un periodo de tiempo, escribiéndolas en memoria secundaria (en caso de haber sido modificadas). Para evitar que un proceso se vea suspendido por el núcleo mientras espera por la carga de sus páginas, Linux permite a los procesos privilegiados bloquear ciertas páginas en memoria. Existen diversas llamadas al sistema que permiten a un proceso especificar que sus páginas no deben ser descartadas de la memoria. DATA CODE pagina Proceso Memoria Disco BLOQUEO DE PÁGINAS EN MEMORIA

32 Cuando el núcleo necesita memoria resuelve el problema eliminando páginas. Si estas páginas han sido modificadas, será necesario guardarlas en disco: Archivo proyectado en memoria se rescribe en el archivo. Datos se guarda en un dispositivo swap. Linux puede llegar a utilizar varios dispositivos swap; por este motivo, cuando se ha de guardar una página, se exploran los dispositivos de swap activos hasta encontrar un lugar donde escribirla. Funciones utilizadas: Inicialización de dispositivo mkswap Activación de dispositivo swapon Desactivación de dispositivo swapoff Descartar páginas de la memoria kswapd DISPOSITIVOS DE SWAP

33 Copy-on-write es una técnica para realizar eficientemente la copia de páginas. Cuando se invoca a la primitiva fork, Linux no duplica las páginas de memoria que son necesarias para el nuevo proceso, sino que hace apuntar las entradas de la tabla de páginas del nuevo proceso a las páginas del proceso padre. Cuando alguna de las páginas es modificada por alguno de los procesos, entonces el núcleo pasa a realizar la duplicación de dicha página. Así, Linux se evita la copia de páginas de memoria que no van a ser utilizadas (p.e. el código situado antes de la primitiva fork, en muy probable que no sea utilizado por el proceso hijo), ahorrando la memoria correspondiente y el tiempo necesario para copiarlas. La forma de llevar a cabo este proceso consiste en establecer los permisos de estas páginas a sólo-lectura pero sabiendo que dichas páginas se pueden modificar (indicándolo en el vma correspondiente). Cuando ocurre una violación de acceso a estas páginas (uno de los procesos intenta escribir) es cuando se realiza la duplicación propiamente dicha. COPY ON WRITE

34

35 Es el procesador (a través del MMU) quien provoca las excepciones en ciertos accesos a memoria: Acceso incompatible con la protección asociada a una página en memoria. Acceso a una pagina no presente en memoria. Las funciones usadas en el tratamiento de una excepción se definen en mm/memory.c: do_wp_page do_swap_page do_no_page Valores devuelto: #define VM_FAULT_OOM -1 VM_FAULT_OOM #define VM_FAULT_SIGBUS 0 VM_FAULT_SIGBUS #define VM_FAULT_MINOR 1 VM_FAULT_MINOR #define VM_FAULT_MAJOR 2 VM_FAULT_MAJOR handle_pte_fault handle_mm_fault do_page_fault TRATAMIENTO DE EXCEPCIONES

36 S – Selector D – Desplazamiento A – Atributos B – Base L - Limite EAX EBX ECX... CS FLG TSS Descriptor 1 Descriptor 2 Descriptor 3 Descriptor n Descriptor LDT MEMORIA NÚCLEO Bas e Limite Desplazamiento + SDA SDA SDA SDA SDA SDA SDA SDA 255 i IDT BL IDTR BLA BLA BLA BLA BLA BLA BLA BLA GDT BL GDTR CPU genera una excepción con un fallo de página TR LDTR TRATAMIENTO DE EXCEPCIONES Page_fault { pushl $do_page_fault jmp error_code }

37 Esta función se encarga de manejar los fallos de pagina do_page_fault, se encuentra en el archivo /arch/i386/mm/fault.c La funcionalidad en resumen es: 1- Determinar la dirección de memoria que ocasiono la interrupción. 2- Determina el problema y llama a la rutina apropiada Si se trata de un acceso indebido el núcleo avisa al proceso mediante una señal. Puede ocurrir que sea el núcleo el que genero la interrupción. fastcallfastcall void do_page_fault(struct pt_regs *regs, unsigned long error_code)do_page_faultpt_regsregs error_code: bit 0 == 0 means no page found, 1 means protection fault bit 1 == 0 means read, 1 means write bit 2 == 0 means kernel, 1 means user-mode Segmentation fault se envia señal al proceso: Force_sig(SIGSERV,task); Error del núcleo no ha podido tratar -> Detención del sistema. do_exit(SIGKILL); do_exitSIGKILL TRATAMIENTO DE EXCEPCIONES

38 Se obtiene el descriptor de la región de memoria afectada mediante la función find_vma, y luego comprueba el tipo de error: Si el error lo ha causado una pagina no presente en el segmento de la pila, se llama a la función expand_stack, para aumentar el tamaño de ésta. Si el error se debe a un acceso en escritura en una región protegida en lectura, el error se señala enviándole al proceso actual la señal SIGSEV. Si se accede a una página para escribir y esta compartida con protegida de lectura, se llama a la función do_wp_page. Si el error se debe a una página no presente en memoria, se llama a la función do_no_page, para cargarla. TRATAMIENTO DE EXCEPCIONES

39 do_wp_page: Gestiona la copia en escritura. Cuando un proceso accede en escritura a una página compartida y protegida en lectura exclusiva, se asigna una nueva página, y se comprueba si la página afectada es compartida por varios procesos. En caso afirmativo se copia su contenido en la nueva página, y se inserta en la tabla de páginas del proceso. El número de referencias a la anterior página se decrementa por la llamada a liberar la pagina. En el caso de que la página afectada no sea compartida, su protección simplemente se modifica para hacer posible la escritura. TRATAMIENTO DE EXCEPCIONES

40 static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,do_wp_pagemm_structvm_area_struct unsigned long address, pte_t *page_table, pmd_t *pmd, pte_t pte)addresspte_tpmd_tpte_t { struct page *old_page, *new_page;page unsigned long pfn = pte_pfn(pte);pte_pfn pte_t entry;pte_tentry //Se obtiene la pagina vieja. old_page = pfn_to_page(pfn);pfn_to_page //comprueba la pagina no esta compartida if (!TestSetPageLocked(old_page)) {TestSetPageLocked int reuse = can_share_swap_page(old_page);can_share_swap_page //se desbloquea la pagina ya que no esta compartida. unlock_pageunlock_page(old_page); if (reuse) { //se inserta en la tabla de paginas del proceso ptep_set_access_flagsptep_set_access_flags(vma, address, page_table, entry, 1);addressentry update_mmu_cacheupdate_mmu_cache(vma, address, entry);addressentry pte_unmappte_unmap(page_table); return VM_FAULT_MINOR; //devuelve 0VM_FAULT_MINOR } …… /* se copia la pagina porque tiene protección */ new_page = alloc_zeroed_user_highpage(vma, address); if (!new_page)alloc_zeroed_user_highpageaddress goto no_new_page; TRATAMIENTO DE EXCEPCIONES

41 …………….. …………. /* se recomprueba que la pagina que queremos traer no esta bloqueada. */ //se bloquea la tabla de paginas spin_lock(&mm->page_table_lock);spin_lock page_table = pte_offset_map(pmd, address);pte_offset_mapaddress if (likely(pte_same(*page_table, pte))) {likelypte_same …. new_page = old_page; } //se inserta en la tabla de paginas del proceso pte_unmap(page_table);pte_unmap //pone en la cache la pagina page_cache_release(new_page);page_cache_release page_cache_release(old_page);page_cache_release spin_unlock(&mm->page_table_lock);spin_unlock return VM_FAULT_MINOR; //devuelve 0VM_FAULT_MINOR no_new_page: page_cache_release(old_page);page_cache_release return VM_FAULT_OOM; //devuelve -1VM_FAULT_OOM } TRATAMIENTO DE EXCEPCIONES

42 do_swap_page: Carga en memoria el contenido de una pagina situada en el espacio de swap. Si una operación swapin está asociada a la región de memoria que contiene la página, se llama a esta función, en caso contrario se llama a la función swap_in. En ambos casos, la página asignada se inserta en el espacio de direccionamiento del proceso actual. TRATAMIENTO DE EXCEPCIONES

43 static int do_swap_page(struct mm_struct * mm, 1689 struct vm_area_struct * vma, unsigned long address, 1690 pte_t *page_table, pmd_t *pmd, pte_t orig_pte, int write_access) { 1692 struct page *page; 1693 swp_entry_t entry = pte_to_swp_entry(orig_pte); 1694 pte_t pte; 1695 int ret = VM_FAULT_MINOR; 1697 pte_unmap(page_table); 1698 spin_unlock(&mm->page_table_lock); //se comprueba que se tiene la pagina especifica 1699 page = lookup_swap_cache(entry); 1700 if (!page) { //se lee desde el area de swap un grupo de 2n paginas 1701 swapin_readahead(entry, address, vma); 1702 page = read_swap_cache_async(entry, vma, address); 1703 if (!page) { spin_lock(&mm->page_table_lock); 1709 page_table = pte_offset_map(pmd, address); 1710 if (likely(pte_same(*page_table, orig_pte))) 1711 ret = VM_FAULT_OOM; 1712 else 1713 ret = VM_FAULT_MINOR; 1714 pte_unmap(page_table); 1715 spin_unlock(&mm->page_table_lock); 1716 goto out; 1717 } 1719 /* tiene que leer la pagina del area de swap Major fault */ 1720 ret = VM_FAULT_MAJOR; 1721 inc_page_state(pgmajfault); 1722 grab_swap_token(); 1723 } TRATAMIENTO DE EXCEPCIONES

44 do_no_page: Acceso a una página no presente en memoria. Se comprueba si la pagina ha sido descartada de la memoria y esta en el espacio swap: - do_swap_page En caso negativo se comprueba si existe una operación de memoria nopage asociada a la región que contiene la página. En caso afirmativo se usa esta operación para cargar el contenido en memoria, insertando la página en la tabla de páginas correspondiente. En caso negativo se asigna una nueva pagina rellenada con 0s. TRATAMIENTO DE EXCEPCIONES

45 1852 static int do_no_page(struct mm_struct *mm, struct vm_area_struct *vma, 1853 unsigned long address, int write_access, pte_t *page_table, pmd_t *pmd) 1854 { 1855 //declaran variables para la nueva estructura struct page * new_page; 1856 struct address_space *mapping = NULL; 1857 pte_t entry; 1858 unsigned int sequence = 0; 1859 int ret = VM_FAULT_MINOR; 1860 int anon = 0; //se localiza la pagina de memoria virtual 1868 if (vma->vm_file) { 1869 mapping = vma->vm_file->f_mapping; 1870 sequence = mapping->truncate_count; 1871 smp_rmb(); /* serializes i_size against truncate_count */ 1872 } TRATAMIENTO DE EXCEPCIONES

46 1873 retry: 1874 cond_resched(); //obtenemos la nueva pagina 1875 new_page = vma->vm_ops->nopage(vma, address & PAGE_MASK, &ret); /* pagina no disponible */ 1885 if (new_page == NOPAGE_SIGBUS) 1886 return VM_FAULT_SIGBUS; 1887 if (new_page == NOPAGE_OOM) 1888 return VM_FAULT_OOM; //se copia la pagina en memoria y en la cache de paginas copy_user_highpage(page, new_page, address); 1902 page_cache_release(new_page);//pone pagina en cache 1903 new_page = page; 1904 anon = 1; 1905 } 1906 } TRATAMIENTO DE EXCEPCIONES

47 page_table = pte_offset_map(pmd, address); if(anon) { 1944 lru_cache_add_active(new_page); 1945 page_add_anon_rmap(new_page, vma, address); 1946 } else // marcara la pagina como usada por este proceso 1947 page_add_file_rmap(new_page); 1948 pte_unmap(page_table); update_mmu_cache(vma, address, entry); 1959 spin_unlock(&mm->page_table_lock); 1960 out: 1961 return ret; 1962 oom: 1963 page_cache_release(new_page); 1964 ret = VM_FAULT_OOM; 1965 goto out; 1966 } TRATAMIENTO DE EXCEPCIONES

48 En interrupción o Kernel thread Acceso de escritura Pertenece a la Pila del modo usuario Pertenece a Una región Región legible o ejecutable Pagina presente Región con permiso de escritura En Modo usuario Dirección incorrecta En una llamada al sistema Si No Si Copy on Write Paginacion Por demanda Enviar SIGSEGV Matar el proceso Y kernel Ops Fixup Code SiNo Si No Si No Si TRATAMIENTO DE EXCEPCIONES

49 Large Memory Page La página fisica en Linux 2.6 puede tener un tamaño de 4MB o 2 MB. Para 1 GB de memoria física: Page size Page table entries Memory space consumed (8 bytes /page table entry) 4 KB 262,144 2 MB 4 MB 256 2,048 bytes NOVEDADES VERSION 2.6

50 Reverse Mapping: Proporciona un mecanismo para encontrar que procesos están usando la página física de la memoria. Physical Page PTE Chain PageTable (Process 1) PageTable (Process 2) NOVEDADES VERSION 2.6

51 /* Comprueba si la pagina ha sido referenciada */ int page_referenced(struct page *page, int is_locked, int ignore_token) {page_referencedpage int referenced = 0; if (!swap_token_default_timeout) ignore_token = 1;swap_token_default_timeout if (page_test_and_clear_young(page)) referenced++;page_test_and_clear_youngpage if (TestClearPageReferenced(page)) referenced++;TestClearPageReferencedpage if (page_mapped(page) && page->mapping) {page_mappedpage if (PageAnon(page))PageAnonpage referenced += page_referenced_anon(page, ignore_token);page_referenced_anonpage else if (is_locked) referenced += page_referenced_file(page, ignore_token);page_referenced_filepage else if (TestSetPageLocked(page))TestSetPageLockedpage referenced++; else { if (page->mapping)page referenced += page_referenced_file(page, ignore_token);page_referenced_filepage unlock_page(page);unlock_pagepage } } return referenced; } REVERSE MAPPING

52 /* Añade a la entrada de la tabla de pagina en memoria para una pagina anonima */ void page_add_anon_rmap(struct page *page,page_add_anon_rmappage struct vm_area_struct *vma, unsigned long address)vm_area_structaddress { struct anon_vma *anon_vma = vma->anon_vma;anon_vma pgoff_t index;pgoff_tindex BUG_ON(PageReserved(page));BUG_ONPageReservedpage BUG_ON(!anon_vma);BUG_ONanon_vma vma->vm_mm->anon_rss++; anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;anon_vma PAGE_MAPPING_ANON index = (address - vma->vm_start) >> PAGE_SHIFT;indexaddressPAGE_SHIFT index += vma->vm_pgoff;index index >>= PAGE_CACHE_SHIFT - PAGE_SHIFT;indexPAGE_CACHE_SHIFTPAGE_SHIFT if (atomic_inc_and_test(&page->_mapcount)) {atomic_inc_and_testpage page->index = index;pageindex page->mapping = (struct address_space *) anon_vma;pageaddress_spaceanon_vma inc_page_state(nr_mapped);inc_page_state } /* else checking page index and mapping is racy */ } REVERSE MAPPING

53 /* Añade a la entrada de la tabla de pagina en memoria para un fichero de pagina */ void page_add_file_rmap(struct page *page)page_add_file_rmappage { BUG_ON(PageAnon(page));BUG_ONPageAnonpage if (!pfn_valid(page_to_pfn(page)) || PageReserved(page))pfn_validpage_to_pfnpagePageReservedpage return; if (atomic_inc_and_test(&page->_mapcount))atomic_inc_and_testpage inc_page_state(nr_mapped);inc_page_state } /* Quitar de la memoria el pte de una pagina */ void page_remove_rmap(struct page *page)page_remove_rmappage { BUG_ON(PageReserved(page));BUG_ONPageReservedpage if (atomic_add_negative(-1, &page->_mapcount)) {atomic_add_negativepage BUG_ON(page_mapcount(page) < 0);BUG_ONpage_mapcountpage if (page_test_and_clear_dirty(page))page_test_and_clear_dirtypage set_page_dirty(page);set_page_dirtypage dec_page_state(nr_mapped);dec_page_state } } REVERSE MAPPING

54 /* Intenta liberar toda tabla de paginas de memoria para una pagina dada. Los valores devueltos son: SWAP_SUCCESS,SWAP_AGAIN,SWAP_FAIL */ int try_to_unmap(struct page *page)try_to_unmappage { int ret; BUG_ON(PageReserved(page));BUG_ONPageReservedpage BUG_ON(!PageLocked(page));BUG_ONPageLockedpage if (PageAnon(page))PageAnonpage ret = try_to_unmap_anon(page);try_to_unmap_anonpage else ret = try_to_unmap_file(page);try_to_unmap_filepage if (!page_mapped(page))page_mappedpage ret = SWAP_SUCCESS;SWAP_SUCCESS return ret; } REVERSE MAPPING


Descargar ppt "Sistema Paginado Santiago Elizondo Mujica Pedro Henríquez Castellano Ingeniería en Informática Diseño de Sistemas Operativos Curso 2005 - 2006."

Presentaciones similares


Anuncios Google