API del núcleo de Linux

Pasaremos por la interfaz de programación de aplicaciones de Linux, la API. Linux Kernel proporciona las llamadas del sistema que se pueden usar para realizar la tarea a través del kernel. Discutamos las pocas llamadas de sistema ampliamente utilizadas de Linux.

Descripción:

Linux Kernel proporciona el conjunto o lista de funciones que los programas de espacio de usuario pueden utilizar para utilizar los servicios de kernel de Linux.

El diagrama de bloques se parece al siguiente:

Algunas de las pocas llamadas de sistema ampliamente utilizadas están abiertas, cerca, leen y escriben. Estas son llamadas básicas del sistema proporcionadas por Linux Kernel. Cada tarea se realiza a través del archivo en Linux. Entonces, las operaciones básicas en cualquier archivo se pueden realizar a través de Open, Close, Leer y Escribir.

Tomemos un ejemplo real en el que queremos imprimir el "Hello World" en la consola serie. Para lograr esta tarea a través de llamadas del sistema, necesitamos abrir el archivo del dispositivo para la consola en /dev. Una vez que localizamos el archivo del dispositivo para la consola o UART, podemos usar la llamada del sistema abierto para abrir el dispositivo.

Aquí está la sintaxis de la llamada del sistema abierto:

int Open (const char *pathname, int flags);
int Open (const char *rathName, int flags, mode_t modo);

De esta sintaxis, el primer argumento es la ruta del archivo que queremos abrir. En nuestro caso, es el archivo del dispositivo que ubicamos como un dispositivo de consola. En el siguiente argumento, las banderas proporcionan al usuario una flexibilidad para jugar con el archivo. Poco ejemplo de las banderas son O_Creat, O_append, etc. Estas banderas tienen significados y propósito específicos y la discusión está fuera del alcance de esta discusión. Para obtener más detalles sobre las banderas y los parámetros, consulte las páginas de Kernel Man.

Una vez que el archivo está abierto correctamente, necesitamos usar la llamada del sistema de escritura para enviar el "Hello World" al dispositivo de la consola. El prototipo de la llamada del sistema de escritura es el siguiente:

ssize_t write (int fd, const void *buf, size_t count);

El primer parámetro de la llamada del sistema de escritura es el FD que es el descriptor de archivos. El "FD" nos lo da la llamada del sistema abierto. Después de abrir el archivo con éxito, debemos obtener el descriptor del archivo. Este FD se usa aún más para escribir los datos.

El segundo parámetro es la dirección del búfer para los datos que se enviarán al dispositivo de la consola. En nuestro caso, los datos de la prueba son "Hola mundo".

El último parámetro es el número total de bytes que el usuario desea escribir en el dispositivo de la consola. En nuestro caso, el número de bytes es el tamaño de "Hello World". Podemos usar el operador sizeOf o la función strlen para obtener el número de bytes. Debemos tener cuidado mientras usamos el strlen. Esta función ignora el carácter de terminador de cadena como "\ 0". Entonces, mientras lee la cadena, tenemos que asegurarnos de que el carácter nulo se maneje correctamente. De lo contrario, terminaremos con la falla de segmentación.

Ahora, implementemos la parte del código de este ejemplo. Primero, necesitamos localizar la consola serie o el dispositivo UART. En la máquina, lo que usamos tiene el dispositivo TTY en serie como/dev/pts/0. Entonces, como se discutió, primero tenemos que abrir este archivo. También debemos incluir el archivo más duro que proporciona la declaración de llamada del sistema abierto.

Nuestro código para abrir el archivo del dispositivo se parece al siguiente:

#incluir
fd = open ("/dev/pts/0", o_wronly);

A continuación, cuando queremos llamar a la llamada del sistema de escritura, usamos el FD proporcionado por el Abierto. Nuestra función de llamada a escribir se parece a la siguiente:

#incluir
char *data = "Hello World";
escribir (fd, datos, strlen (datos) +1);

El fragmento de código anterior escribe el "Hello World" en la consola serie que localizamos y queremos escribir.

Pongamos todas las piezas juntas:

#incluir
#incluir
#incluir
#incluir
#incluir
int main ()

int fd; int rc;
char *data = "Hello World";
fd = open ("/dev/pts/0", o_wronly);
Si (FD<0)

printf ("Archivo de apertura de error:%D", FD);
salida (-1);

rc = write (fd, data, strlen (datos) +1);
if (rc<0)

printf ("Archivo de escritura de error:%D", RC);
salida (-1);

cerrar (fd); // La operación del archivo está realizada, cierre el archivo.
regresar 0;

La compilación del programa anterior es lo mismo que compilar los otros programas C como los siguientes:

GCC test_write.c -o test_write.

El test_write.C es el nombre del archivo de nuestro código C.

Después de la compilación, obtenemos el ejecutable con el nombre test_write.

Consulte la siguiente instantánea:

Después de ejecutar el binario compilado y generado, tenemos la siguiente salida.

La salida de nuestro programa se destaca en letras en negrita. La siguiente es la instantánea para referencia:

Hasta ahora, hemos visto un ejemplo en el que usamos la API de Linux para mostrar la cadena de prueba en la consola. Este es el ejemplo simple. Hay muchas otras ofertas proporcionadas por la llamada del sistema. Pocas de las llamadas del sistema proporcionadas por Linux son las siguientes:

• leer: Lectura del archivo.
• escribir: Escribir en el archivo.
• abierto: Abrir el archivo.
• cerca: Cerrar el archivo.
• encuesta: Encontrar el dispositivo para el cambio en el estado.
• Lseek: Buscar en un desplazamiento particular en el archivo.
• MMAP: Mapear la memoria virtual a la memoria física.
• Brk: Cambiar el tamaño del segmento.
• IOCTL: Dispositivos de control.
• acceso: Acceso para obtener los permisos del archivo.
• tubo: Se refiere a la creación de tuberías.

y muchos más.

Esta es la enorme lista de funciones proporcionadas por Linux Kernel. Hemos visto y discutido muy pocos. Consulte la fuente del núcleo para la lista completa de llamadas del sistema que proporciona Kernel.

Conclusión

Discutimos sobre las llamadas del sistema, que es una forma de pedirle al kernel que realice las tareas para los programas de espacio de usuario. Sin la llamada del sistema, no será posible que los programas de espacio de usuario realicen la tarea por el núcleo. Tomamos una tarea o ejemplo simple de escribir los datos de la prueba, "hola mundo", al dispositivo en serie. Empleamos las API abiertas, escritas y cerradas del núcleo para completar la tarea en la mano. Una cosa más importante es verificar el valor de devolución de llamadas del sistema. El kernel proporciona valores de retorno adecuados para explicar la razón en caso de falla de la función. El usuario puede tener la idea sobre el motivo de la falla al ver los valores de retorno de la llamada del sistema. Los valores de retorno tienen algún significado específico y están bien capturados en la documentación del núcleo.