rednotes

Una llamada al sistema (system call, syscall) es el mecanismo mediante el cual un programa en modo usuario solicita un servicio al Sistemas Operativos/Kernel. Es la verdadera interfaz entre los programas y el Sistemas Operativos.

Cómo funciona una syscall

Tanenbaum la ilustra con read(fd, buffer, nbytes):

El programa coloca los parámetros en la pila o en registros.
Llama al procedimiento de biblioteca (p. ej. read de libc).
La biblioteca coloca el número de la syscall en un registro conocido.
Ejecuta una instrucción TRAP (syscall en x86-64, svc en ARM), que cambia a modo kernel y salta a una dirección fija.
El kernel examina el número y despacha al manejador correspondiente mediante una tabla de punteros.
El manejador hace el trabajo.
El control vuelve a la biblioteca en modo usuario (o el proceso se bloquea si debe esperar E/S).
La biblioteca regresa al programa, que limpia la pila.

Una syscall se parece a una llamada a procedimiento, pero cruza la frontera usuario/kernel, lo que la hace mucho más costosa.

Principales llamadas POSIX

Gestión de Sistemas Operativos/Procesos

Llamada	Descripción
`pid = fork()`	Crea un proceso hijo idéntico al padre
`pid = waitpid(pid, &status, opts)`	Espera a que termine un hijo
`s = execve(name, argv, envp)`	Reemplaza la imagen del proceso
`exit(status)`	Termina el proceso

Gestión de archivos

Llamada	Descripción
`fd = open(file, how, ...)`	Abre un archivo
`s = close(fd)`	Cierra un archivo
`n = read(fd, buf, nbytes)`	Lee datos
`n = write(fd, buf, nbytes)`	Escribe datos
`pos = lseek(fd, offset, whence)`	Mueve el puntero del archivo
`s = stat(name, &buf)`	Obtiene información de estado

Directorios y sistema de archivos

mkdir, rmdir, link, unlink, mount, umount.

Misceláneas

chdir, chmod, kill, time.

Ejemplo: un shell mínimo

while (TRUE) {
    type_prompt();
    read_command(command, parameters);
    if (fork() != 0) {
        /* Código del padre */
        waitpid(-1, &status, 0);
    } else {
        /* Código del hijo */
        execve(command, parameters, 0);
    }
}

API Win32

Windows separa las llamadas reales del kernel de la API pública Win32 (CreateProcess, WaitForSingleObject, CreateFile, ReadFile...). Las llamadas internas cambian entre versiones; la API se mantiene estable.

#sistemas-operativos #tanenbaum #syscalls