Necesidad de un sistema de archivos

Nótese que, una vez que un proceso termina, toda la memoria relacionada con él (su espacio de direcciones o segmentos) se borran, lo que es inaceptable para algunas aplicaciones (p.e.: Bases de Datos).

En general, tenemos 3 requisitos esenciales para el almacenamiento de información a largo plazo:

• Debe ser posible almacenar una gran cantidad de información.
• La información debe persistir tras la terminación del proceso que la utilice.
• Múltiples procesos deben poder acceder a la información de forma concurrente.

Los discos son los dispositivos que se utilizan para este almacenamiento a largo plazo, lo que permiten (entre otras) dos operaciones básicas:

• Leer un bloque
• Escribir un bloque

Lo que no es muy satisfactorio:

• ¿Cómo sabemos qué bloques están libres?
• ¿Cómo se gestionan los sistemas con muchas aplicaciones y usuarios?
• ¿Cómo evitamos que un usuario lea datos de otro?
• ¿Cómo se encuentra la información?
• …

Además, ya se ha visto en la introducción que los dispositivos de E/S, en especial los discos, son bastante complejos de gestionar.

Abstracción del sistema de archivos

Archivo

Al igual que con los procesos y el espacio de direcciones virtuales, el Sistema Operativo soluciona todos estos problemas creando una nueva abstracción: el archivo.

Cuando un proceso crea un archivo, le da un nombre. La nomenclatura depende un poco de cada sistema:

• Habitualmente se permiten símbolos hasta 255 caracteres.
• Unix diferencia mayúsculas de minúsculas, mientras que para MS-DOS, ARCHIVO, archivo y arCHiVo representa lo mismo.

Muchos sistemas aceptan nombres de archivos en dos partes, separadas por un punto. La parte que va después del punto se llama la extensión del archivo y normalmente indica el tipo de archivo: .c indica un archivo de código fuente C, .zip un archivo comprimido o .pdf un archivo en Formato de Documento Portable.

• En MS-DOS se permiten de 3 a 8 caracteres para el nombre del archivo y una extensión opcional de 1 a 3 caracteres.
• En Unix, la extensión también es opcional y puede ser de longitud variable.

Estas extensiones son solo convenciones, el Sistema Operativo no las impone. Son más bien un recordatorio para el usuario o impuestas por algún programa en concreto. Aun así, Windows es consciente de las extensiones: los usuarios o procesos pueden registrar extensiones y especificar a qué programa corresponden.

Ejemplo de uso de estas llamadas:

// Programa Linux para copiar archivos: copyfile input output
// NOTA: la verificación y reporte de errores es mínimo

#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>

#define TAM_BUF     4096
#define MODO_SALIDA 0700 // rwx --- ---

int main(int argc, char** argv) {
    if (argc != 3) exit(1); // Error de sintaxis

    char buffer[TAM_BUFF];

    // Abrir los archivos
    int fd_input = open(arg[1], O_RDONLY); // Abrir input solo lectura
    if (fd_input < 0) exit(2);             // Error al abrir input

    int fd_output = creat(arg[1], MODO_SALIDA); // Crear output
    if (fd_output < 0) exit(3);                 // Error al abrir output

    // Bucle de copia
    while (1) {
        // Lee un bloque de datos al buffer
        int bytes_leidos = read(fd_input, buffer, TAM_BUF);

        if (bytes_leidos == 0) break;   // Fin de archivo
        if (bytes_leidos < 0)  exit(4); // Error

        // Escribe en el archivo de salida
        int bytes_escritos = write(fd_output, buffer, bytes_leidos);
        if (bytes_escritos <= 0) exit(5);
    }

    // Cierra los archivos
    close(fd_input);
    close(fd_output);
    exit(0);
}

Los enteros fd_input y fd_output son dos descriptores de archivos (File Descriptors) que se usan para hacer referencia a cada archivo.

Tipos de archivos

• Archivos regulares: contienen información del usuario
  • Texto: se usan distintos caracteres para marcar el final de la línea y diferentes formatos para codificar el texto. El más común es UTF8.
  • Binarios: tienen una estructura interna que los programas utilizan. Un campo muy común es el número mágico, que indica el tipo de archivo que es.
• Directorios: sistemas de archivos para dar una estructura a los archivos
• Archivos especiales de caracteres: se relacionan con dispositivos E/S en serie
• Archivos especiales de bloque: se usan para modelar discos

Permisos

Cada archivo tiene asociada una máscara de 16 bits, llamada la máscara de modo. La llamada al sistema chmod permite cambiarla.

• Los 3 bits rwx de menos peso de permisos que aplican a otros usuarios.
• Los 3 bits rwx siguientes al grupo propietario.
• Los 3 bits rwx siguientes al usuario propietario.
• Los 3 bits siguientes indican permisos especiales.
• Los 4 bits de más peso indican el tipo de archivo (regular, plano, bloque, carácter o link)

Los tres octales (otros, grupo y propietario) aplican todo tipo de archivos, pero tener un efecto diferente dependiendo si es un archivo normal o un directorio. Puede consultar la tabla completa en la ArchWiki.

• Lectura en directorios (l): permite listar su contenido.
• Escritura en directorios (w): permite crear, renombrar o borrar elementos. Require el bit x.
• Ejecución en directorios (x): permite acceder usando cd.

Los permisos especiales solo son aplicables a determinados tipos de archivos:

• Sticky bit (S_ISVTX): indica la compartición del segmento de código, por lo que debe mantenerse en memoria. Sin embargo, hoy en día no se usa para eso, sino para directorios. Significa que los elementos de ese directorio solo pueden ser renombrados o borrados por su propietario. Se muestra una t en el comando ls.
• SGID (S_ISGID): cambiar el EGID al ejecutar. Se muestra una s en el comando ls.
• SUID (S_ISUID): cambiar el EUID al ejecutar. Se muestra una s en el comando ls.

Si al usar ls aparece una S mayúscula, quiere decir que hay un error: probablemente el archivo no es ejecutable. No tiene sentido activar el bit SUID en un archivo no ejecutable. Lo mismo sucede con el sticky bit, T cuando el directorio no es ejecutable.

El funcionamiento del usuario real y efectivo se explica en más detalle en el siguiente apartado.

En resumen:

Identificadores de Usuario y Grupo

Ya sabemos que un fichero ejecutable contiene todas las instrucciones y datos necesarios para el programa. Este tiene también una máscara de modo. Cuando se ejecuta, aparte del PID, tiene asociados dos identificadores de usuario y dos de grupo. Son dos enteros positivos.

• UID y EUID: identificador de usuario real y efectivo respectivamente
• GID y EGID: identificador de grupo real y efectivo respectivamente

Vamos a centrarnos en el identificador de usuario, ya que para el identificador de grupo es análogo.

• UID: es el usuario responsable de la ejecución del proceso (quien ejecuta)
• EUID: es el usuario que se usa para determinar el propietario de los ficheros creados, comprobar si tiene los permisos para acceder a determinados ficheros, permisos para enviar señales, etc.

Es decir: el usuario real es quien ejecuta el programa y un proceso solo puede trabajar con los archivos que pueda acceder el usuario efectivo.

Vale, pero… ¿quién es el usuario efectivo? Esto lo determina por el bit SUID. Si un ejecutable tiene el bit SUID=1, el EUID pasa a ser el propietario del programa.

Además, mediante las llamadas al sistema setuid y setgid se puede cambiar el EUID, pero su funcionamiento es algo particular. Para consultar los valores se usan getuid, geteuid, getgid, getegid.

Tenga en cuenta que en la mayoría de los casos, UID = EUID.

#include <fcntl.h>
salida = setuid(par);

-rwxrwxr-x 1 user1 ... exe
-rw-rw---- 1 user1 ... mi_archivo.txt
-rw-rw---- 1 user2 ... otro_archivo.txt

-rwsrwxr-x 1 user1 ... exe
-rw-rw---- 1 user1 ... mi_archivo.txt
-rw-rw---- 1 user2 ... otro_archivo.txt

-rwsrwxrwx user1 ... exe
-rw------- user1 ... fichero1.txt
-rw------- user2 ... fichero2.txt

// Código del programa EXE
#include <fcntl.h>

int main() {
    int x, y, fd1,fd2;

    x = getuid(); y = geteuid();
    printf("\nUID=%d, EUID=%d\n", x, y);

    fd1 = open("fichero1.txt", O_RDONLY);
    fd2 = open("fichero2.txt", O_RDONLY);
    printf("fd1=%d, fd2=%d\n", fd1, fd2);

    setuid(x);
    printf("UID=%d, EUID=%d\n",getuid(),geteuid());

    fd1 = open("fichero1.txt", O_RDONLY);
    fd2 = open("fichero2.txt", O_RDONLY);
    printf("fd1=%d, fd2=%d\n", fd1, fd2);

    setuid(y);
    printf("UID=%d, EUID=%d\n",getuid(),geteuid());
}

UID=501, EUID=501   fd1=3, fd2=-1
UID=501, EUID=501   fd1=4, fd2=-1
UID=501, EUID=501

UID=502, EUID=502   fd1=-1, fd2=3
UID=502, EUID=502   fd1=-1, fd2=4
UID=502, EUID=502

UID=502, EUID=501   fd1=3, fd2=-1
UID=502, EUID=502   fd1=-1, fd2=4
UID=502, EUID=501

Directorios

Para llevar registro de los archivos, por lo general se permiten crear directorios o carpetas, que en muchos sistemas también son archivos.

Gracias a la creación de directorios dentro de otros directorios, se crean las jerarquías o árboles de directorios. Estas permiten al usuario organizar sus archivos de una forma bastante natural, mediante agrupaciones. Además, se pueden asignar determinados directorios a cada usuario para establecer permisos y seguridad de los archivos.

Rutas

Cuando los archivos se organizan en una estructura arbórea, ya no se pueden identificar únicamente por su nombre, sino que se utilizan nombres de rutas.

• Ruta absoluta: consiste en el camino de directorios desde el directorio raíz, hasta el archivo deseado.
• Ruta relativa: es el camino de directorios desde el directorio de trabajo actual hasta el archivo deseado.

En las rutas relativas, habitualmente se puede hacer referencia al directorio de trabajo actual con . y directorios superiores con ... Por ejemplo, la ruta Unix ../../layouts/404.html retrocede dos directorios y obtiene al archivo HTML dentro del subdirectorio layouts.

La nomenclatura de las rutas también varía de un sistema a otro:

• Windows: \, p.e.: C:\Programacion\blog\content\so\archivos.md. C es la unidad (dispositivo) y continuación aparece la ruta.
• Unix: /, p.e.: /home/magno/Programacion/blog/content/so/archivos.md. El directorio raíz se especifica con /.

Implementación

Hasta ahora, se ha visto el funcionamiento de la abstracción creada por el Sistema Operativo. Véase ahora cómo se lleva a cabo.

• ¿Cómo se almacenan los archivos y los directorios?
• ¿Cómo se administra del espacio del disco?

Disco duro

Ya hemos visto en las nociones de hardware de la introducción las diferentes partes de los discos. Vamos a profundizar un poco en su funcionamiento.

• Pueden haber varios discos apilados, e incluso varias unidades a la vez. La controladora debe poder gestionar todas las unidades (búsquedas traslapadas).
• Hay dos cabezas electromagnéticas por cada disco, una por cada superficie.
• Un peine contiene todas las cabezas y se desplaza hacia dentro y afuera de los discos. El disco rota para acceder al resto de datos.

• Cada círculo concéntrico en un disco se llama pista.
• Cada porción de pista se llama sector. Es la unidad mínima de información que permite el hardware.
• Como es un círculo, en las pistas exteriores hay más sectores que en las interiores. Por eso se dividen en cilindros.

Disco físico y lógico

Se diferencian de otros dispositivos como ratones y teclados que transmiten información de carácter a carácter.

Se distinguen varios tipos:

• SATA (Serial ATA): Se llaman así porque utilizan el bus SATA. En Linux se identifican como sd (Sata Disk) y una letra minúscula, en función del orden en el que se descubran (/dev/sda primero, luego /dev/sdb).

• SCSI: Formatos por distintos dispositivos como cintas, CD-ROMS, escáneres, etc, conectados en cadena. Son usados por servidores de altas prestaciones y se identifican de forma similar a los SATA.

• IDE o Parallel ATA: Poco usados en la actualidad e identificados como /dev/hda y /dev/hdb para el controlador primario (esclavo y maestro respectivamente); /dev/hdc y /dev/hdd para el controlador secundario.

• NVMe (Non Volative Memory express):

  • Nuevo protocolo de acceso a unidades no volátiles como SSD basado en el bus PCI express. Se utiliza para conectar todo tipo de tarjetas y es mucho más rápido que el bus SATA. NVMe suele usar un conector específico llamado M.2.
  • En Linux se identifican como /dev/nvmeXnYpZ, donde X es el controlador, Y es el dispositivo y Z es el número de partición.

Ejemplos de discos lógicos:

• En un sistema operativo como Windows, una partición funciona como un disco lógico.
• Volumen Lógico en [Logical Volume Management]
• Disco lógico de un sistema operativo virtualizado: los discos que utiliza una máquina virtual y que se almacenan como archivos, también cumplen esta definición.

Partición

Normalmente las particiones se identifican con el pseudo-archivo de su disco y se le añade un número de partición: /dev/sda4.

Algunos tipos de particiones pueden ser:

• Partición de arranque (boot partition): Es una partición primaria que contiene el programa de arranque. Por ejemplo, en Linux, sus archivos (kernel, initrd y GRUB) se montan en /boot (BIOS Boot Partition o BIOS BP, y EFI System Partition).

• Partición del sistema: contiene un sistema de archivos con la carpeta del Sistema Operativo (system root). En Linux se monta sobre /.

• Partición de intercambio o swap: Sirve de zona de almacenamiento temporal para almacenar páginas de los procesos cuando no quede suficiente RAM. Para más información, ver zona de intercambio.

Como cada partición se comporta como un disco lógico, esto permite la coexistencia varios SO en el mismo ordenador: una partición para cada uno (dual boot).

La herramienta fdisk (entre muchas otras herramientas) permite manipular la tabla de particiones para crear, extender y eliminar particiones.

Más información en la archwiki.

Master Boot Record

En los sistemas BIOS, el primer bloque del disco (512 bytes) se conoce como el Master Boot Record (MBR), fuera de cualquier tipo de partición.

Contiene el código del bootloader del sistema operativo (440 bytes) y la tabla de particiones (al final del bloque). Una de ellas está marcada como activa para arrancar desde ahí.

Debido a esta organización, el MBR limita el tamaño máximo del disco particionado a 2 TiB ($2^{32} \times 512$).

Con el fin de superar esta limitación, se realizó una transición a GUID Partitions Table (GPT).

Puede consultar todos los IDs de las particiones.

Para llevar la cuenta de las particiones lógicas, dado que no están la tabla, cada una lógica tiene un EBR o EPBR (Extended Partition Boot Record) que ocupa su primer sector. Esta describe dos elementos:

• Ubicación y tamaño
• Puntero al siguiente EBR

Este mecanismo tiene las siguientes limitaciones:

• Eficiencia: recorrer una lista enlazada para encontrar una partición determinada.
• Complejidad: más difícil de gestionar que una tabla centralizada.

Windows requiere estar instalado en una partición primaria (no lógica) si intentas hacer dual boot.

GUID Partition Table

El GPT (GUI Partition Table) es el nuevo estándar que sustituye a MBR. Es más fiable y está asociado a sistemas UEFI.

Se almacena en una partición con un tamaño de unos 256-512 MB, pero también crea múltiples copias redundantes a través de todo el disco. También tiene al inicio un Protective Master Boot Record (PMBR) con el propósito de proteger el disco contra sistemas que no soporten GPT y ser retrocompatible.

Es posible utilizarlo en discos mayores de 2 TiB.

Con UEFI se pueden crear hasta 128 particiones primarias (límite impuesto por los sistemas Windows). A cada una de ellas se le asocia un identificador global único (GUID o UUID).

Nótese que las particiones extendidas pueden existir en GTP, pero no se usan porque no tienen mucho sentido.

Implementación de archivos

Es necesario mantener un registro de la correspondencia de un archivo y de los bloques de disco que contienen su información.

Implementación de directorios

La función principal del sistema de directorios es asociar cada nombre de archivo a la información necesaria para localizar los datos. Muchos sistemas también almacenan en la entrada de directorio de un archivo sus atributos.

Montaje de sistemas de archivos

En Windows, a cada disco lógico se le llama unidad y cada uno puede contener un sistema de archivos con su propia jerarquía. Se identifican por una letra mayúscula, donde normalmente C se refiere a donde está Windows instalado.

En Unix es posible tener varios subárboles independientes, cada uno con un sistema de archivos completo. Sin embargo, uno de ellos se configura para ser el sistema de archivos raíz y para que su directorio raíz sea el directorio raíz del sistema. Otros sistemas de ficheros se adjuntan a la estructura montándolos sobre un directorio ya existente, llamado directorio de montaje o punto de montaje, gracias a la llamada del sistema mount.

Una vez montado, el directorio raíz de la nueva estructura pasa a ser el directorio de montaje, y cualquier acceso se traduce al sistema de archivos montado. Esto permanecerá visible hasta que se desmonte con umount.

// Ver man mount(2)
#include <sys/mount.h>

// Sintaxis en Linux
int mount(const char* device, const char* mountdir,
          const char* filesystem_type,   // ext4, vfat, proc, tmpfs, ...
          unsigned long flags,
          const void *_Nullable data);
int umount(const char* device);

// Sintaxis en Unix clásico
mount("/dev/hda2", "/usr", 0);
umount("/dev/hda2");

Alternativamente, desde Bash, se usan los comandos siguientes:

mount /dev/... ruta         # Monta la partición en directorio
mount --mkdir /dev/... ruta # Para crear directorio si no existe
mount -a                    # Monta los fs especificados en /etc/fstab
mount -o ruta opciones      # Permite remontar con otras opciones
umount ruta                 # Desmonta el fs del directorio

Esta noción de montaje, permite ocultar al usuario los detalles de la organización del almacenamiento: las rutas siguen siendo homogéneas y no es necesario especificar ninguna unidad.

# device    directory   type    options   dump pass
/dev/hda1   /           ext2    defaults  0    0
/dev/hda2   /usr        ext2    defaults  0    0
/dev/hda3   none        swap    sw        0    0 # Zona de swapping
/dev/sda1   /dosc       msdos   defaults  0    0
/proc       /proc       proc    none      0    0

Administración y optimización de Sistemas de Archivos

Hacer que el sistema de archivos es una cosa, que sea eficiente es otra. Véanse ahora algunas ideas para mejorar el rendimiento.

Un parámetro fundamental para ello es el tamaño del bloque, que ya se ha comentado previamente.

Registro de bloques libres

Problema muy similar a la administración de memoria libre, por lo que se utiliza el mismo tipo de estrategias: listas enlazadas y mapas de bits.

Disco de 500 GB, bloques de 1 KiB $\implies n_b = 500 \times 10^{9} / 2^{10} = 488,281\,250$ bloques.

• Lista enlazada: $2^{10} / 4 - 1 = 255$ entradas $\implies \lceil n_b / 255 \rceil = 1\,914\,829$ bloques, 0.3922% (si el disco está vacío).
• Mapa de bits: $n_b$ bloques $\implies n_b$ bits $\implies \lceil (n_b / 8) / 2^{10} \rceil = 59\,605$ bloques, 0.0122%

[Logical Volume Management]: {{/*< ref “linux/instalacion/#logical-volume-management” */>}}