Llamadas al sistema

De Departamento de Informatica
Saltar a: navegación, buscar
Interface para llamadas al sistema

Las llamadas al sistema son interfaces de programación que sirven para poder invocar los servicios que el sistema operativo nos ofrece. Estas llamadas se encuentran escritas en lenguajes de alto nivel como C y C++. En general, las llamadas a sistemas son accesadas mediante una API (interfaz de programación de aplicaciones), en vez de invocarlas directamente, de ésta manera se hace más fácil el trabajo para un programador de aplicaciones.


Esta API especifica un conjunto de funciones que el programador puede utilizar, incluyendo los parámetros que son pasados a cada función y que retornan valores que el programador puede esperar.. Las API más comunes que existen son tres:

  • Win32 para Windows, la cual surge para cubrir la necesidad de crear un sistema operativo de 32 bits como es Windows 95, frente a la API de 16 bits de Windows 3.1. Las limitaciones de esta API son que no soporta nombre de ficheros largos, sólo el formato 8.3 de DOS, no tiene API de comunicaciones y no soporta las capacidades Plug & Play
  • POSIX para sistemas basados en POSIX (Unix, Linux, Mac OS X), sus principales características son:
    • Algunos tipos de datos utilizados por las funciones no se definen como parte de la implementación. Estos tipos se encuentran definidos en el archivo de cabecera y acaban con el sufijo _t.
    • Los nombres de las funciones en POSIX son en general cortos y con todas sus letras en minúsculas, por ejemplo fork (para crear un nuevo proceso), read (para leer datos de un archivo), close (para cerrar un archivo).
    • Las funciones, normalmente, devuelven cero si se ejecutaron con éxito o -1 en caso de error.
    • La mayoría de los recursos gestionados por el sistema operativo se referencian mediante descriptores. Un descriptor es un número entero mayor o igual que cero.
  • Java API para la Java Virtual Machine (JVM), brinda funciones de uso común para el programador como por ejemplo, creación y manejo de elementos de GUI, manejo de archivos, funciones de red, comunicación entre programas, además de existir dentro de su librería clases gráficas (awt y swing), las cuales permiten crear objetos gráficos comunes altamente configurables y con una arquitectura independiente de la plataforma.


Cada sistema operativo tiene sus propios nombres de llamadas al sistema. Por ejemplo: La función CreateProcess() (crea un nuevo proceso) de Win32 realmente invoca a la llamada NTCreateProcess() del kernel del SO.

A un programador le resulta más fácil utilizar una API que realizar las llamadas al sistema directamente debido a que posee una mayor portabilidad (cuando se desea compilar el programa en cualquier SO que pueda soportar la API utilizada), y a menudo es más díficil trabajar con las propias llamadas al sistema.


El sistema de soporte en tiempo de ejecución, nos provee de una interfaz de llamadas al sistema que sirve como enlace con las llamadas al sistema disponibles en el sistema operativo. Ésta se encarga de interceptar las llamadas a funciones dentro de la API e invoca a la llamada al sistema necesaria. Cada llamada al sistema tiene asociado un número y la interfaz mantiene una tabla indexada con dichos números. Esta tabla sirve para invocar las llamadas al kernel del SO y retorna el estado de ejecución de la llamada al sistema y los valores posibles de retorno.

Funcionamiento de llamadas al sistema:

API para la función Readfile()

Descripción de los parámetros pasados a ReadFile() es la siguiente:

  • Archivo Handle: el archivo a ser leído.
  • Bucle LPVOID: un búfer donde los datos son leídos y escritos.
  • DWORD bytesToRead: el número de bytes para leer dentro del búfer.
  • LPDWORD bytesRead: el número de bytes leídos durante la última lectura.
  • LPOVERLAPPED ovl: indica si E/S superpuesta se está utilizando


El programador no necesita saber cómo la llamada al sistema es implementada o qué está haciendo durante la ejecución. Más bien, sólo necesita obedecer la API y entender lo que el sistema operativo va a hacer como resultado de la ejecución de esa llamada al sistema. Así, la mayoría de los detalles de la interfaz del sistema operativo se ocultan del programador por la API y son gestionados por el sistema de soporte de tiempo de ejecución. La relación existente entre una API, una interfaz de llamadas al sistema y el sistema operativo se muestran a continuación, utilizando la llamada al sistema open().

El manejo de una aplicación de usuario invoca la llamada al sistema open()


Las llamadas al sistema ocurren de diferentes formas, dependiendo del computador en uso. El tipo exacto y la cantidad de información necesitadas varía acorde al sistema operativo particular y la llamada. Tres métodos generales son usados para pasar parámetros al sistema operativo.

  • Registros: Es la técnica más sencilla, consiste en pasar parámetros a una serie de registros. Pueden ser más parámetros que registros.
  • Bloque o Tabla: Este evento ocurre cuando existen más registros que parámetros disponibles, en este caso se almacenan los parámetros en un bloque o tabla, en memoria y la dirección del bloque se pasa como parámetro en un registro. Esta técnica es utilizada por Linux y Solaris.
  • Pila: Se pueden colocar o insertar los parámetros de la pila mediante el programa, el sistema operativo se encargará de extraer de la pila esos parámetros.

Algunos sistemas operativos prefieren el método del bloque o el de la pila porque esos enfoques no limitan el número o la longitud de los parámetros que se pasan.

Paso de parámetros como una tabla.



Investigación

Ejemplos detallados de algunas llamadas al sistema.



Referencias

Herramientas personales
Espacios de nombres
Variantes
Acciones
Navegación
Herramientas