Interfaces del Sistema Operativo

Los sistemas operativos son componentes fundamentales de cualquier dispositivo informático, desde smartphones hasta servidores empresariales. A través de llamadas al sistema (system calls), el núcleo del sistema operativo (kernel) proporciona una capa de abstracción que permite a las aplicaciones interactuar con los recursos del hardware sin conocer sus detalles internos. Este documento explora las interfaces clave implementadas en xv6, un sistema operativo educativo basado en Unix, centrándose en procesos, gestión de memoria, E/S, descriptores de archivos y la implementación de tuberías.

1.1 Procesos y Gestión de Memoria

**int fork()**Crea un proceso hijo copiando el estado del proceso padre. Retorna 0 en el hijo y el PID del hijo en el padre. Ejemplo:

if (fork() == 0) {
    // Código ejecutado por el proceso hijo
} else {
    // Código ejecutado por el proceso padre
}

**int exit(int status)**Finaliza un proceso liberando sus recursos. El valor de estado se comunica al proceso padre para manejo de errores:

if (error_detectado) {
    exit(EXIT_FAILURE); // Valor distinto de cero indica error
}

**int wait(int *status)**Bloquea al proceso padre hasta que un hijo finalice, recuperando su estado de salida:

int status;
pid_t pid = wait(&status);
if (WIFEXITED(status)) {
    printf("Hijo terminado con código %d\n", WEXITSTATUS(status));
}

**int exec(char *file, char *argv[])**Reemplaza el proceso actual con un nuevo programa sin crear un nuevo proceso:

char *args[] = {"ls", "-l", NULL};
exec("/bin/ls", args); // Reemplaza el proceso actual con ls -l

En shells como xv6, la ejecución de comandos se logra mediante la secuencia fork-exec:

while (1) {
    leer_comando();
    if (fork() == 0) {
        exec(comando, args);
    } else {
        wait(0);
    }
}

1.2 E/S y Descriptores de Archivos

En Unix, todo es tratado como archivo, incluyendo dispositivos periféricos y la consola. Los descriptores de archivos (0=stdin, 1=stdout, 2=stderr) permiten operaciones genéricas:

char buffer[1024];
int bytes_leidos = read(0, buffer, sizeof(buffer));
write(1, buffer, bytes_leidos);

**int open(char *file, int flags)**Abre archivos con permisos específicos:

int fd = open("datos.txt", O_RDONLY);
if (fd < 0) {
    perror("Error al abrir archivo");
}

**int close(int fd)**Libera recursos asociados a un descriptor:

close(fd); // Cierra el descriptor de archivo

**int dup(int fd)**Duplica un descriptor para mantener acceso múltiple al mismo archivo:

int nuevo_fd = dup(fd); // Crea un nuevo descriptor apuntando al mismo archivo

Ejemplo de redirección de entrada:

if (fork() == 0) {
    close(0);
    open("entrada.txt", O_RDONLY);
    exec("cat", NULL);
}

1.3 Tuberías (Pipes)

Las tuberías permiten comunicación entre procesos mediante dos descriptores (leer y escribir):

int tuberia[2];
pipe(tuberia); // tuberia[0] = lectura, tuberia[1] = escritura

if (fork() == 0) {
    close(tuberia[1]); // Cerrar extremo de escritura en el hijo
    char buffer[1024];
    read(tuberia[0], buffer, sizeof(buffer));
    close(tuberia[0]);
    printf("Hijo recibió: %s\n", buffer);
    exit(0);
} else {
    close(tuberia[0]); // Cerrar extremo de lectura en el padre
    write(tuberia[1], "Hola desde el padre", 20);
    close(tuberia[1]);
    wait(NULL);
}

Este mecanismo es la base del operador | en shells Unix, permitiendo encadenar procesos como comando1 | comando2.

1.4 Sistema de Archivos

xv6 implementa operaciones básicas sobre directorios y archivos:

chdir para cambiar directorio actual:

chdir("/ruta/absoluta");
chdir("ruta/relativa"); 

mkdir para crear directorios:

mkdir("nuevo_directorio");

mknod para crear dispositivos:

mknod("/dev/tty", 1, 0); // Crea un dispositivo de terminal

fstat obtiene información de archivos:

struct stat info;
fstat(fd, &info);
printf("Tamaño: %d bytes\n", info.size);

Los enlaces (links) permiten múltiples nombres para un mismo archivo:

open("archivo.txt", O_CREAT|O_WRONLY);
link("archivo.txt", "otronombre.txt"); // Crea un enlace al mismo archivo