OPENSOLARIS: LLAMADAS AL SISTEMA
Cueva Alvarez, Karen
Pelaez Sangay, Michel
Espinoza Sánchez, David
INTRODUCCION
Podemos definir las llamadas al sistema o
syscalls como una interfaz entre el área de
usuario y la de kernel, si un proceso
necesita realizar una tarea que implique
acceder a la área de kernel, posiblemente
por que no tenga privilegios para hacerlo el
directamente, debe hacerlo a través de una
llamada al sistema. Ejemplos típicos seria
acceder a un dispositivo de i/o, crear un
proceso hijo, esperar a que se cumpla una
condición, etc.
El listado completo de llamadas al sistema
que existen lo encontramos en el fichero
/usr/include/sys/syscall.h.
La información acerca de qué llamadas a
sistema se están ejecutando nos puede dar
pistas de la actividad de los distintos
procesos en nuestro equipo. Lógicamente
procesar una llamada tiene un coste a nivel
de recursos, sin embargo dependiendo de la
tarea que deba realizar su coste es distinto.
Un porcentaje elevado de tiempo de sistema
puede significar que nuestros procesos
están requiriendo llamadas a sistema muy
costosas.
1. FUNDAMENTOS
Los programas son un conjunto de
instrucciones organizadas con un objetivo.
Un proceso es conceptualmente un
programa en ejecución. En los sistemas
operativos multitarea como OpenSolaris,
puede haber varios procesos ejecutándose
concurrentemente. Cada proceso puede
requerir el uso de recursos de hardware,
como periféricos, o espacio de memoria
principal, u otros recursos.
Puerta Ramirez, Gallen
Vargas Guanilo, Javier
Dado que el hardware es compartido por
múltiples procesos, el acceso a los recursos
debe ser administrado para garantizar su
correcto uso y evitar problemas de
seguridad (si procesos malintencionados
desean acceder a recursos asignados a otros
procesos). Por estas razones, en los
sistemas duales, el acceso al ambiente físico
es manejado exclusivamente por el Sistema
Operativo. La única forma de acceder al
hardware es a través de las llamadas al
sistema, que están perfectamente definidas.
Esto no ocurre en los Sistemas Operativos
no duales, como el MS-DOS, donde
cualquier proceso podía acceder a todos los
niveles del hardware.
Los procesadores actuales pueden ejecutar
las instrucciones en diferentes estados. En
los sistemas duales, normalmente son
llamados modo supervisor y modo usuario.
Los procesadores proveen diferentes
niveles de privilegio de forma tal que los
sistemas operativos pueden restringir las
operaciones que ejecutan los programas
tanto por razones de seguridad como de
estabilidad. Estas operaciones incluyen el
acceso a periféricos, habilitar o deshabilitar
interrupciones, cambiar el estado del
procesador, y acceder a la memoria, entre
otras.
2. MECANISMO
Las llamadas al sistema comúnmente usan
una instrucción especial de la CPU que
causa que el procesador transfiera el control
a un código privilegiado, previamente
especificado por el mismo código. Esto
permite al código privilegiado especificar
donde va a ser conectado así como el estado
del procesador.
Cuando una llamada al sistema es invocada,
la ejecución del programa que invoca es
interrumpida y sus datos son guardados,
normalmente en su PCB(Printed Circuit
Board), para poder continuar ejecutándose
luego. El procesador entonces comienza a
ejecutar las instrucciones de código de alto
nivel de privilegio, para realizar la tarea
requerida. Cuando esta finaliza, se retorna
al proceso original, y continúa su ejecución.
El retorno al proceso demandante no
obligatoriamente es inmediato, depende del
tiempo de ejecución de la llamada al
sistema y del algoritmo de planificación de
CPU.
3. LAS LIBRERIAS COMO UN
INTERMEDIARIO
OpenSolaris provee librerías que relacionan
los programas de usuario y el resto del
sistema operativo. Estas librerías manejan
los detalles de bajo nivel para transferir
información al kernel y conmutar a modo
supervisor, así como cualquier
procesamiento de datos o tareas que deba
ser realizada en modo supervisor.
Idealmente, esto reduce la dependencia
entre el sistema operativo y la aplicación, e
incrementa su portabilidad.
4. AGREGANDO UNA LLAMADA
AL SISTEMA EN OPENSOLARIS
Veremos un ejemplo de cómo agregar una
llamada al sistema en OpenSolaris.
4.1. Estableciendo los Parámetros del
Kernel
Asumiremos que se trata de una simple
llamada al sistema que reside en el código
genérico del kernel, y que pondremos el
código en un archivo ya existente. El
objetivo es imprimir un mensaje arbitrario
cuando se realice la llamada al sistema.
4.2. Escogiendo el Número de Syscall
Antes de escribir algún código, primero
tenemos que elegir un número que
identifique a nuestra llamada al sistema. La
fuente principal de documentación aquí es
syscall.h, el cual especifica todos los
números de llamadas al sistema disponibles
y además aquellos que están reservados. El
número máximo de llamadas al sistema
normalmente es 256 (NSYSCALL). Este
número teóricamente puede ampliarse. Se
cree que el límite más difícil de ampliar es
el tamaño de sysset_t, cuyos 16 enteros
deben ser capaces de representar una
bitmask completa de todas las llamadas al
sistema. Esto pone nuestro límite real en
16*32 o 512 llamadas al sistema, pero para
los propósitos de este ejemplo, eligiremos
un número de llamada al sistema igual a 56
el cual normalmente no es usado.
Llamaremos a nuestra syscall “schrock”.
Entonces agregamos la siguiente línea a
syscall.h:
#define SYS_uadmin 55
#define SYS_schrock 56
#define SYS_utssys 57
See usr/src/uts/common/sys/syscall.h
4.3. Escribiendo el Syscall Handler
Ahora tenemos que agregar la función que
será llamada cuando invoquemos a la
llamada al sistema. Lo que realmente
deberíamos hacer es agregar un nuevo
archivo schrock.c a
usr/src/uts/common/syscall.c, sin embargo
solo usaremos el código de getpid.c.
#include <sys/cmn_err.h>
int schrock(void *arg)
{
char buf[1024];
size_t len;
if (copyinstr(arg, buf, sizeof
(buf), &len) != 0)
return (set_errno(EFAULT));
cmn_err(CE_WARN, "%s", buf);
return (0);
}
CONCLUSIONES

 Vimos los conceptos básicos de lo

que son las llamadas al sistema.
 En OpenSolaris sólo podemos
acceder al hardware a través de las
llamadas al sistema.
 Vimos como es el mecanismo para
la ejecución de las llamadas al
sistema.
 Vimos la importancia de las
librerías, las cuales relacionan los
programas de usuario con el resto
del sistema operativo.
 Por ultimo vimos un ejemplo
básico de como es que se agrega
una llamada al sistema en
OpenSolaris.

REFERENCIAS BIBLIOGRAFICAS

 OpenSolaris 2008.5. Iván Nieto

Castillero.
 Introducción a OpenSolaris.
Ricardo Laziano M.
 http://sun.com/solaris
 http://opensolaris.org