En informática, un llamada al sistema Es una forma programática en la que un programa de computadora solicita un servicio del núcleo del sistema operativo en el que se ejecuta. Una llamada al sistema es una forma para que los programas interactuar con el sistema operativo . Un programa de computadora realiza una llamada al sistema cuando realiza una solicitud al núcleo del sistema operativo. llamada al sistema proporciona los servicios del sistema operativo a los programas de usuario a través de la Interfaz de Programa de Aplicación (API). Proporciona una interfaz entre un proceso y un sistema operativo para permitir que los procesos a nivel de usuario soliciten servicios del sistema operativo. Las llamadas al sistema son los únicos puntos de entrada al núcleo sistema. Todos los programas que necesitan recursos deben utilizar llamadas al sistema.
Un programa de usuario puede interactuar con el sistema operativo mediante una llamada al sistema. El programa solicita una serie de servicios y el sistema operativo responde lanzando una serie de llamadas al sistema para cumplir con la solicitud. Una llamada al sistema se puede escribir en lenguajes de alto nivel como C o Pascal o en lenguaje ensamblador. Si se utiliza un lenguaje de alto nivel, el sistema operativo puede invocar directamente llamadas al sistema, que son funciones predefinidas.
Una llamada al sistema es un mecanismo utilizado por los programas para solicitar servicios del Sistema operativo (SO). En términos más simples, es una forma que tiene un programa de interactuar con el sistema subyacente, como acceder a recursos de hardware o realizar operaciones privilegiadas.
Una llamada al sistema es iniciada por el programa que ejecuta una instrucción específica, lo que activa un cambio a núcleo modo, permitiendo que el programa solicite un servicio del sistema operativo. Luego, el sistema operativo maneja la solicitud, realiza las operaciones necesarias y devuelve el resultado al programa.
Las llamadas al sistema son esenciales para el correcto funcionamiento de un sistema operativo, ya que proporcionan una forma estandarizada para que los programas accedan a los recursos del sistema. Sin llamadas al sistema, cada programa necesitaría implementar sus propios métodos para acceder al hardware y a los servicios del sistema, lo que llevaría a un comportamiento inconsistente y propenso a errores.
Servicios proporcionados por llamadas al sistema
- Creación y gestión de procesos.
- Gestión de la memoria principal
- Gestión de acceso a archivos, directorios y sistemas de archivos
- Manejo de dispositivos (E/S)
- Proteccion
- Redes, etc
- Control de procesos: finalizar, abortar, crear, terminar, asignar y liberar memoria.
- Gestión de archivos: crear, abrir, cerrar, eliminar, leer archivos, etc.
- Gestión de dispositivos
- Mantenimiento de información
- Comunicación
Características de las llamadas al sistema
- Interfaz: Las llamadas al sistema proporcionan una interfaz bien definida entre los programas de usuario y el sistema operativo. Los programas realizan solicitudes llamando a funciones específicas y el sistema operativo responde ejecutando el servicio solicitado y devolviendo un resultado.
- Proteccion: Las llamadas al sistema se utilizan para acceder a operaciones privilegiadas que no están disponibles para los programas de usuario normales. El sistema operativo utiliza este privilegio para proteger el sistema contra accesos maliciosos o no autorizados.
- Modo núcleo: Cuando se realiza una llamada al sistema, el programa cambia temporalmente del modo de usuario al modo kernel. En modo kernel, el programa tiene acceso a todos los recursos del sistema, incluido el hardware, la memoria y otros procesos.
- Cambio de contexto: Una llamada al sistema requiere un cambio de contexto, que implica guardar el estado del proceso actual y cambiar al modo kernel para ejecutar el servicio solicitado. Esto puede generar una sobrecarga, que puede afectar el rendimiento del sistema.
- Manejo de errores: Las llamadas al sistema pueden devolver códigos de error para indicar problemas con el servicio solicitado. Los programas deben verificar estos errores y manejarlos adecuadamente.
- Sincronización: Las llamadas al sistema se pueden utilizar para sincronizar el acceso a recursos compartidos, como archivos o conexiones de red. El sistema operativo proporciona mecanismos de sincronización, como bloqueos o semáforos, para garantizar que múltiples programas puedan acceder a estos recursos de forma segura.
Ventajas de las llamadas al sistema
- Acceso a recursos de hardware: Las llamadas al sistema permiten que los programas accedan a recursos de hardware como unidades de disco, impresoras y dispositivos de red.
- Gestión de la memoria: Las llamadas al sistema proporcionan una forma para que los programas asignen y desasignen memoria, así como también accedan a dispositivos de hardware asignados en memoria.
- Gestión de proceso: Las llamadas al sistema permiten que los programas creen y finalicen procesos, así como también administren la comunicación entre procesos.
- Seguridad: Las llamadas al sistema proporcionan una forma para que los programas accedan a recursos privilegiados, como la capacidad de modificar la configuración del sistema o realizar operaciones que requieren permisos administrativos.
- Estandarización: Las llamadas al sistema proporcionan una interfaz estandarizada para que los programas interactúen con el sistema operativo, lo que garantiza coherencia y compatibilidad entre diferentes plataformas de hardware y versiones de sistemas operativos.
¿Cómo funciona la llamada al sistema?
Aquí está la explicación detallada paso a paso de cómo funcionan las llamadas al sistema:
- El usuario necesita recursos especiales: A veces, los programas necesitan hacer algunas cosas especiales que no se pueden hacer sin el permiso del sistema operativo, como leer un archivo, escribir en un archivo, obtener información del hardware o solicitar un espacio en la memoria.
- El programa realiza una solicitud de llamada al sistema: Hay instrucciones especiales predefinidas para realizar una solicitud al sistema operativo. Estas instrucciones no son más que solo una llamada al sistema. El programa utiliza estas llamadas al sistema en su código cuando es necesario.
- El sistema operativo ve la llamada al sistema: Cuando el sistema operativo ve la llamada del sistema, reconoce que el programa necesita ayuda en este momento, por lo que detiene temporalmente la ejecución del programa y le da todo el control a una parte especial de sí mismo llamada 'Kernel'. Ahora 'Kernel' resuelve la necesidad del programa.
- El sistema operativo realiza las operaciones: Ahora el sistema operativo realiza la operación solicitada por el programa. Ejemplo: leer contenido de un archivo, etc.
- El sistema operativo devuelve el control al programa: Después de realizar la operación especial, el sistema operativo devuelve el control al programa para su posterior ejecución.
Ejemplos de una llamada al sistema en Windows y Unix
Las llamadas al sistema para Windows y Unix vienen en muchas formas diferentes. Estos se enumeran en la siguiente tabla de la siguiente manera:
| Proceso | ventanas | Unix |
|---|---|---|
| Control de procesos | Proceso de creación() Proceso de salida() EsperarObjetoÚnico() | Tenedor() Salida() Esperar() |
| Manipulación de archivos | Crea un archivo() Leer archivo() Escribir archivo() | Abierto() Leer() Escribir() Cerca() |
| Gestión de dispositivos | Establecer modo consola() LeerConsola() Consola de escritura() | ioctl() Leer() Escribir() |
| Mantenimiento de la información | Obtener ID de proceso actual() Establecer temporizador() Dormir() | Getpid() Alarma() Dormir() |
| Comunicación | Creartubería() CrearAsignación de archivos() VistaMapaDeArchivo() | Tubo() Shmget() Mmap() |
| Proteccion | Establecer seguridad de archivo() InicializarDescriptorDeSeguridad() Establecer grupo de descriptores de seguridad() | Mod() desenmascarar() Chown() |
abierto(): Es posible acceder a un archivo en un sistema de archivos con la llamada al sistema open(). Proporciona al archivo los recursos que necesita y un identificador que el proceso puede utilizar. Un archivo puede ser abierto por varios procesos simultáneamente o solo por un proceso. Todo se basa en la estructura y el sistema de archivos.
leer(): Los datos de un archivo en el sistema de archivos se recuperan usándolo. En general, acepta tres argumentos:
- Una descripción de un archivo.
- Un búfer para el almacenamiento de datos de lectura.
- ¿Cuántos bytes se deben leer del archivo?
Antes de leer, el archivo a leer podría identificarse por su descriptor de archivo y abrirse usando la función open().
esperar(): En algunos sistemas, es posible que un proceso deba posponerse hasta que otro proceso haya terminado de ejecutarse antes de continuar. Cuando un proceso padre crea un proceso hijo, la ejecución del proceso padre se detiene hasta que se completa el proceso hijo. El proceso principal se detiene mediante la llamada al sistema wait(). El proceso padre recupera el control una vez que el proceso hijo ha terminado de ejecutarse.
escribir(): Los datos de un búfer de usuario se escriben usándolo en un dispositivo como un archivo. Un programa puede producir datos de una manera usando este llamada al sistema . generalmente, hay tres argumentos:
- Una descripción de un archivo.
- Una referencia al búfer donde se almacenan los datos.
- La cantidad de datos que se escribirán desde el búfer en bytes.
tenedor(): Los procesos utilizan la llamada al sistema fork() para crear copias de sí mismos. Es uno de los métodos más utilizados en los sistemas operativos para crear procesos. Cuando un proceso padre crea un proceso hijo, la ejecución del proceso padre se suspende hasta que finaliza el proceso hijo. El proceso padre recupera el control una vez que el proceso hijo ha terminado de ejecutarse.
salida(): Se utiliza una llamada al sistema llamada exit() para finalizar un programa. En entornos con múltiples subprocesos, esta llamada indica que la ejecución del subproceso ha finalizado. Después de utilizar la función del sistema exit(), el sistema operativo recupera los recursos utilizados por el proceso.
Métodos para pasar parámetros al sistema operativo
Si se produce una llamada al sistema, tenemos que pasar el parámetro a la parte Kernal del sistema operativo.
Por ejemplo, mira lo dado. abierto() llamada al sistema:
C
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Aquí nombre de ruta , banderas y modo_t son los parametros.
Así pues cabe señalar que:
- No podemos pasar los parámetros directamente como en una llamada de función normal.
- En el modo Kernal hay una forma diferente de realizar una llamada a una función.
Por lo tanto, no podemos ejecutarlo en el espacio de direcciones normal que el proceso ya había creado y, por lo tanto, no podemos colocar los parámetros en la parte superior de la pila porque no están disponibles para el kernel del sistema operativo para su procesamiento. entonces tenemos que adoptar cualquier otro método para pasar los parámetros al Kernal del sistema operativo.
Podemos hacerlo a través de
- Pasar parámetros en registros
- La dirección del bloque se pasa como parámetro en un registro.
- Los parámetros se colocan en una pila.
Analicemos cada punto en detalle:
1. Pasar parámetros en registros.
- Es el método más simple entre los tres.
- Aquí pasamos directamente los parámetros a los registros.
- Pero será limitado cuando el número de parámetros sea mayor que el número de registros.
- Aquí está el código del programa C:
C
instancia java de
// Passing parameters in registers.> #include> #include> int> main()> {> >const> char>* pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd = open(pathname, flags, mode);> >// in function call open(), we passed the parameters pathanme,flags,mode to the kernal directly> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
2.La dirección del bloque se pasa como parámetro.
- Se puede aplicar cuando el número de parámetros es mayor que el número de registros.
- Los parámetros se almacenan en bloques o tablas.
- La dirección del bloque se pasa a un registro como parámetro.
- Más comúnmente utilizado en Linux y Solaris.
- Aquí está el código del programa C:
C
//Address of the block is passed as parameters> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> params[3];> >// Block of data(parameters) in array> >params[0] = (>int>)pathname;> >params[1] = flags;> >params[2] = mode;> >int> fd = syscall(SYS_open, params);> >// system call> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
3.Los parámetros se colocan en una pila.
- En este método, los parámetros se pueden ingresar usando el programa y extraerse usando el sistema operativo.
- De modo que Kernal puede acceder fácilmente a los datos recuperando información de la parte superior de la pila.
- Aquí está el código del programa C.
C
//parameters are pushed into the stack> #include> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd;> >asm>volatile>(> >'mov %1, %%rdi
'> >'mov %2, %%rsi
'> >'mov %3, %%rdx
'> >'mov , %%rax
'> >'syscall'> >:>'=a'> (fd)> >:>'r'> (pathname),>'r'> (flags),>'r'> (mode)> >:>'%rdi'>,>'%rsi'>,>'%rdx'> >);> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
Preguntas frecuentes
P.1: ¿Cómo funciona una llamada al sistema?
Respuesta:
Cuando un programa ejecuta una llamada al sistema, pasa del modo de usuario al modo kernel, que es un modo con mayores privilegios. La transición generalmente se inicia invocando una función específica o interrumpiendo una instrucción proporcionada por el lenguaje de programación o el sistema operativo.
Una vez en modo kernel, la llamada al sistema es manejada por el sistema operativo. El kernel realiza la operación solicitada en nombre del programa y devuelve el resultado. Luego, el control regresa al programa de nivel de usuario, que continúa su ejecución.
P.2: ¿Por qué son necesarias las llamadas al sistema?
Respuesta:
Las llamadas al sistema son necesarias por varias razones:
Acceso a operaciones privilegiadas: Muchas operaciones, como administrar dispositivos de hardware o modificar configuraciones del sistema, requieren privilegios más altos a los que solo se puede acceder a través de llamadas al sistema.
Administracion de recursos: Las llamadas al sistema proporcionan una interfaz estandarizada para asignar y administrar recursos del sistema como memoria, archivos y dispositivos, garantizando un acceso justo y controlado por parte de diferentes procesos.
Abstracción: Las llamadas al sistema abstraen las complejidades subyacentes del sistema operativo, lo que permite a los desarrolladores de aplicaciones interactuar con el sistema en un nivel superior e independiente de la plataforma.
Seguridad y protección: Las llamadas al sistema imponen políticas de seguridad y control de acceso, evitando el acceso no autorizado a recursos confidenciales y protegiendo la integridad del sistema.