Mejor respuesta
En resumen
Cada sistema de archivos tiene un superbloque, que contiene información sobre el sistema de archivos como:
- Tipo de sistema de archivos
- Tamaño
- Estado
- Información sobre otras estructuras de metadatos
En detalle
El superbloque es una estructura que representa un sistema de archivos. Incluye la información necesaria para administrar el sistema de archivos durante la operación. Incluye el nombre del sistema de archivos (como ext4), el tamaño del sistema de archivos y su estado, una referencia al dispositivo de bloque e información de metadatos (como listas libres, etc.). El superbloque normalmente se almacena en el medio de almacenamiento, pero se puede crear en tiempo real si no existe uno. Puede encontrar la estructura del superbloque en ./linux/include/linux/fs.h.
Uno Un elemento importante del superbloque es una definición de las operaciones del superbloque. Esta estructura define el conjunto de funciones para administrar inodos dentro del sistema de archivos. Por ejemplo, los inodos se pueden asignar con alloc\_inode o eliminar con destroy\_inode. Puede leer y escribir inodos con read\_inode y write\_inode o sincronizar el archivo sistema con sync\_fs. Puede encontrar la estructura super\_operations en ./linux/include/linux/fs.h. Cada sistema de archivos proporciona su propios métodos de inodo, que implementan las operaciones y proporcionan la abstracción común a la capa VFS.
Estructura física
La estructura física de los sistemas de archivos Ext2 ha sido fuertemente influenciada por el diseño del sistema de archivos BSD. Un sistema de archivos está formado por grupos de bloques. Los grupos de bloques son análogos a los grupos de cilindros de BSD FFS. Sin embargo, los grupos de bloques no están vinculados al diseño físico de los bloques en el disco, ya que las unidades modernas tienden a optimizarse para el acceso secuencial y ocultan su geometría física al sistema operativo.
,---------+---------+---------+---------+---------,
| Boot | Block | Block | ... | Block |
| sector | group 1 | group 2 | | group n |
`---------+---------+---------+---------+---------"
Cada grupo de bloques contiene una copia redundante de información crucial de control del sistema de archivos (superbloque y el sistema de archivos descriptores) y también contiene una parte del sistema de archivos (un mapa de bits de bloque, un mapa de bits de inodo, una parte de la tabla de inodo y bloques de datos). La estructura de un grupo de bloques se representa en esta tabla:
,---------+---------+---------+---------+---------+---------,
| Super | FS | Block | Inode | Inode | Data |
| block | desc. | bitmap | bitmap | table | blocks |
`---------+---------+---------+---------+---------+---------"
El uso de grupos de bloques es una gran ventaja en términos de confiabilidad: dado que las estructuras de control se replican en cada grupo de bloques, es e asy para recuperarse de un sistema de archivos donde el superbloque se ha dañado. Esta estructura también ayuda a obtener buenos rendimientos: al reducir la distancia entre la tabla de inodos y los bloques de datos, es posible reducir las búsquedas de cabeza de disco durante la E / S en archivos.
Referencia: – Sistemas de archivos extendidos (Ext, Ext2, Ext3)
Respuesta
Los sistemas de archivos en Linux operan en varias capas: A) a conjunto de rutinas primitivas para interactuar con el dispositivo (es decir, el controlador), B) un conjunto de registros en el disco correspondientes a lo que llamamos archivos, y C) información de metadatos sobre cada archivo que se denominan inodos, hay 1 inodo para cada archivo. Estos inodos rastrean cosas como cuáles son los atributos de su archivo, cómo se define la lectura / escritura en sus archivos, etc.
Resulta que esto es solo una imagen incompleta. Eso es antes de que cada tipo de sistema de archivos pueda optar por organizar sus inodos de la forma que desee en el disco. Incluso la representación en el disco de los inodos puede variar entre diferentes sistemas de archivos; lo que importa es solo que vista con el que se proporciona el VFS de las estructuras de inodo están de acuerdo. Por lo tanto, Linux no per se cómo se puede acceder a los archivos / inodos individuales en un sistema de archivos.
El problema se maneja cuidadosamente mediante el uso de la estructura struct file\_system y tipos de super\_block . El último vive en el disco mientras que el primero vive solo en la memoria. Cuando monta un sistema de archivos usando say,
monta -t ext4 / dev / usb1 / mnt / usb1
el objeto file\_system que define el tipo ext4 contiene un mount () rutina que especifica cómo leer el objeto superbloque fuera del disco. Este objeto de superbloque especifica todo lo que necesita para acceder (asignar, eliminar, leer, corregir, sincronizar entre el dispositivo y la memoria, etc.) los inodos en el dispositivo.Una vez que este objeto superbloque se recupera en la memoria, usamos sus operaciones lookup () para leer inodos del disco en la memoria. Luego, usamos estos inodos a su vez para llegar a los sistemas de archivos. ¡Es jerárquico, de verdad, y bastante bueno en eso!