Llamadas al Sistema

Los sistemas operativos tienen dos funciones principales: las cuales son proveer abstracciones a
los programas de usuario y administrar los recursos de la computadora. En su mayor parte la
interacción entre los programas de usuario y el sistema operativo se relaciona con la primera
función:

Ejemplo: Crear, Escribir, Leer y Eliminar archivos

La parte de la administración de los recursos es en gran parte transparente para los usuarios y se
realiza de manera automática. Por lo cual la interfaz entre los programas de usuario y el sistema
operativo trata principalmente acerca de como lidiar con las abstracciones.

Las llamadas al (S.O) disponibles de la interfaz varían de un sistema operativo a otro (aunque los
conceptos subyacentes tienden a ser similares). Por lo tanto, nos vemos obligados a elegir a una
opción entre 1) Generalidades imprecisas (“los sistemas operativos tienen llamadas al sistema
para leer archivos”) y 2) Cierto sistema especifico (“UNIX tiene una llamada al sistema conocida
como READ con tres parámetros: uno para especificar el archivo, otro para decir en donde se van
a colocar los datos y por ultimo para indicar cuantos bytes se deben leer”) El cual Hemos optado
por la última opción la cual nos implica mas trabajo, pero nos da una visión un poco mas detallada
en cuanto a lo que realmente hacen los sistemas operativos. Excepto que este análisis se refiere
de forma más directa a POSIX (Estándar internacional 9945-1) y por ende también a UNIX, System
v, BSD, LINUX, minix 3, etc. La mayoría de los demás sistemas operativos modernos tienen
llamadas al sistema que realizan las mismas funciones, incluso si difieren los detalles.

Es conveniente tener en cuenta lo siguiente. Cualquier computadora con una sola CPU puede
ejecutar solo una instrucción a la vez. Si un proceso esta ejecutando un programa de usuario en
modo usuario y necesita un servicio del sistema.

Nota: Como leer datos de un archivo, tiene que ejecutar una instrucción de Trap para transferir el
control al sistema operativo. Después, el sistema operativo averigua que es lo que quiere el
proceso llamador, para lo cual inspecciona los parámetros. Luego lleva acabo la llamada al sistema
y devuelve el control a la instrucción que va después de la llamada al sistema.

Para hacer más entendible el mecanismo de llamadas al sistema, vamos a dar un vistazo rápido a
la llamada al sistema read. Como dijimos antes, tiene tres parámetros: el primero especifica el
archivo, el segundo apunta al búfer y el tercero proporciona el número de bytes a leer. Al igual
que casi todas las llamadas al sistema, se invoca desde programas en C mediante una llamada a un
procedimiento de la biblioteca con el mismo nombre que la llamada al sistema: read. Una llamada
desde un programa en C podría tener la siguiente apariencia:

cuenta=read (fd, bufer, nbytes);

Las llamadas al sistema se llevan a cabo en una serie de pasos. Para que este concepto que demás
claro, vamos a examinar la llamada read antes descrita. En su preparación para llamar al
procedimiento de biblioteca read, que es quien realmente hace la llamada al sistema read, el
programa llamador primero mete los parámetros en la pila, Los compiladores de C y C++ meten los
parámetros en la pila en orden inverso por razones históricas (esto tiene que ver con hacer que el
primer parámetro para printf, la cadena del formato aparezca en la parte superior de la pila). Los
parámetros primero y tercero se pasan por valor, pero el segundo parámetro se pasa por
referencia, lo cual significa que se pasa la dirección del búfer (lo cual se indica mediante &), no el
contenido del mismo. Después viene la llamada al procedimiento de biblioteca (paso 4). Esta
instrucción es la instrucción de llamada a procedimiento normal utilizada para llamar a todos los
procedimientos.

El procedimiento de biblioteca (probablemente escrito en lenguaje ensamblador) coloca por lo

general el número de la llamada al sistema en un lugar en el que el sistema operativo lo espera,
como en un registro (paso 5). Después ejecuta una instrucción TRAP para cambiar del modo
usuario al modo kernel y empezar la ejecución en una dirección fija dentro del núcleo (paso 6). La
instrucción TRAP en realidad es muy similar a la instrucción de llamada a procedimiento en el
sentido en que la instrucción que le sigue se toma de una ubicación distante y la dirección de
retorno se guarda en la pila para un uso posterior.
Sin embargo, la instrucción TRAP también difiere de la instrucción de llamada a un procedimiento
en dos formas básicas. En primer lugar, como efecto secundario, cambia a modo kernel. La
instrucción de llamada al procedimiento no cambia el modo. En segundo lugar, en vez de dar una
dirección relativa o absoluta en donde se encuentra el procedimiento, la instrucción TRAP no
puede saltar a una dirección arbitraria.

El código de kernel que empieza después de la instrucción TRAP examina el número de llamada al
sistema y después la pasa al manejador correspondiente de llamadas al sistema, por lo general a
través de una tabla de apuntadores a manejadores de llamadas al sistema, indexados en base al
numero de llamadas al sistema.

(paso 7). En ese momento se ejecuta el manejador de llamadas al sistema (paso 8). Una vez que el
manejador ha terminado su trabajo, el control se puede regresar al procedimiento de biblioteca
que está en espacio de usuario

(paso 9). Luego este procedimiento regresa al programa de usuario en la forma usual en que
regresan las llamadas a procedimientos

(paso 10). Para terminar el trabajo, el programa de usuario tiene que limpiar la pila, como lo hace
después de cualquier llamada a un procedimiento

(paso 11). Suponiendo que la pila crece hacia abajo, como es comúnmente el caso, el código
compilado incrementa el apuntador de la pila lo suficiente como para eliminar los parámetros que
se metieron antes de la llamada a read. Ahora el programa es libre de hacer lo que quiera a
continuación.

En las siguientes secciones examinaremos algunas de las llamadas al sistema POSIX de uso más
frecuente, o dicho en forma más específica, los procedimientos de biblioteca que realizan esas
llamadas al sistema. POSIX tiene aproximadamente 100 llamadas a procedimientos.

En mayor grado, los servicios ofrecidos por estas llamadas determinan la mayor parte de la labor
del sistema operativo, ya que la administración de recursos en las computadoras personales es
una actividad mínima (por lo menos si se le compara con los equipos grandes que tienen muchos
usuarios). Los servicios incluyen acciones tales como crear y terminar procesos, crear, eliminar,
leer y escribir en archivos, administrar directorios y realizar operaciones de entrada y salida.

Al margen, vale la pena mencionar que la asignación de las llamadas a procedimientos POSIX a
llamadas al sistema no es de uno a uno. El estándar POSIX especifica varios procedimientos que
debe suministrar un sistema que se conforme a este estándar, pero no especifica si deben ser
llamadas al sistema, llamadas a una biblioteca, o algo más. Si un procedimiento puede llevarse a
cabo sin necesidad de invocar una llamada al sistema (es decir, sin atrapar en el kernel), por lo
general se realizará en espacio de usuario por cuestión de rendimiento. Sin embargo, la mayoría
de los procedimientos POSIX invocan llamadas al sistema, en donde por lo general un
procedimiento se asigna directamente a una llamada al sistema. En unos cuantos casos, en
especial en donde los procedimientos requeridos son sólo pequeñas variaciones de algún otro
procedimiento, una llamada al sistema maneja más de una llamada a la biblioteca.
Manipulación de archivos
El sistema de archivos se estudiará con mayor detalle en los capítulos 10 y 11, pero aquí podemos
identificar varias llamadas al sistema comunes que tienen que ver con los archivos.

Primero necesitamos la facultad de crear (créate) y eliminar (delete) archivos. Ambas llamadas al
sistema necesitan el nombre del archivo y tal vez algunos de sus atributos. Una vez creado un
archivo, es preciso abrirlo (open) para usarlo. También podríamos leer (read), escribir (write)
reposicionar (reposition) (rebobinar 0 saltar al fin del archivo,) por ejemplo: Por último,
necesitamos cerrar (close) el archivo para indicar que ya no lo estamos usando.

Es posible que necesitemos estos mismos tipos de operaciones para manipular directorios si
tenemos una estructura de d1rectonos para organizar los archivos en el sistema de archivos.
Además, tanto para archivos como para directorios, necesitamos poder determinar los valores de
diversos atributos, y quizá asignarles valores si es necesario.

Se necesita al menos dos llamadas al sistema, obtener atributo de archivo (get file attribute) Y
establecer atributo de archivo (set file attribute), para esta función. Algunos sistemas operativos
ofrecen muchas llamadas más.

Gestión de dispositivos
Un programa podría requerir recursos adicionales durante su ejecución para poder continuar.
Tales recursos podrían ser más memoria, unidades de cinta, acceso a archivos, y demás. Si los
recursos están disponibles, se pueden conceder, y el control se devolverá al programa de usuario;
si no, el programa tendrá que esperar hasta que haya suficientes recursos disponibles.

Podemos ver los archivos como dispositivos abstractos o virtuales. Así, muchas de las llamadas al
sistema para archivos también se necesitan para los dispositivos. Si el sistema tiene múltiples
usuarios, primero hay que solicitar (request) el dispositivo, a fin de asegurar su uso exclusivo.
Cuando el dispositivo ya no se necesite, será preciso liberarlo (release). Estas funciones son
similares a las llamadas al sistema abrir y cerrar para archivos.

Una vez solicitado (y asignado) el dispositivo, se puede leer, escribir y (posiblemente) reposicionar,
igual que los archivos ordinarios. De hecho, la similitud entre los dispositivos de E/S y los archivos
es tan grande que muchos sistemas operativos, incluidos UNIX y MS-DOS, combinan las dos cosas
en una sola estructura archivos-dispositivos. En este caso, los dispositivos de E 1 S se identifican
con nombres de archivo especiales.

Mantenimiento de información
Muchas llamadas al sistema existen con el solo propósito de transferir información entre el
programa del usuario y el sistema operativo. Por ejemplo, la mayor parte de los sistemas
operativos tiene una llamada al sistema para devolver la hora (time) y la fecha (date) actuales.
Otras llamadas al sistema podrían devolver información acerca del sistema, como el número de
usuarios actuales, el número de versión del sistema operativo, la cantidad de memoria o espacio
en disco libre, etcétera.
Además, el sistema operativo mantiene información acerca de todos sus procesos, y hay llamadas
al sistema para acceder a esta información. Generalmente, también hay llamadas para restablecer
la información de los procesos (obtener atributos de proceso [get process attributes] y establecer
atributos de proceso [set process attributes]).