PDF de programación - GNU/Linux: Programación de Sistemas

GNU/Linux:

Programación de Sistemas
Pablo Garaizar Sagarminaga
[email protected]

GNU/Linux:

Programación de

Sistemas

Pablo Garaizar Sagarminaga

email: [email protected]
web: http://paginaspersonales.deusto.es/garaizar
blog: http://blog.txipinet.com

Facultad de Ingeniería - ESIDE
Universidad de Deusto
Bilbao

Tabla de contenido

1. PROGRAMACIÓN EN GNU/LINUX...........................................5
1.1 Llamadas al sistema..........................................................5
1.2 Programas, procesos, hilos................................................6
1.2.1 Estructuras de datos...............................................7
1.2.2 Estados de los procesos en Linux...........................8
1.2.3 Identificativos de proceso.......................................9
1.2.4 Planificación..........................................................11
1.3 El GCC.............................................................................12
1.3.1 Compilación básica...............................................12
1.3.2 Paso a paso...........................................................13
1.3.3 Librerías................................................................14
1.3.4 Optimizaciones.....................................................14
1.3.5 Debugging............................................................15
1.4 make world......................................................................15
1.4.1 Makefile, el guión de make...................................16
1.5 Programando en C para GNU/Linux.................................20
1.5.1 Hola, mundo!........................................................20
1.5.2 Llamadas sencillas................................................21
1.5.3 Manejo de directorios...........................................32
1.5.4 Jugando con los permisos.....................................35
1.5.5 Creación y duplicación de procesos.....................38
1.5.6 Comunicación entre procesos..............................43
1.5.7 Comunicación por red...........................................62
2. LICENCIA....................................................................80

ii

Índice de figuras

FIGURA 1.1.1 MECANISMO DE PETICIÓN DE SERVICIOS AL KERNEL..........6
FIGURA 1.5.2 LOS DESCRIPTORES DE FICHERO INICIALES DE UN PROCESO.
..............................................................................24
FIGURA 1.5.3 DUPLICACIÓN DE PROCESOS MEDIANTE FORK().............39
FIGURA 1.5.4 PROCESOS RECIBIENDO SEÑALES, RUTINAS DE CAPTURA Y
PROCESO DE SEÑALES.......................................................48
FIGURA 1.5.5 LA LLAMADA A LA FUNCIÓN ALARM() GENERARÁ UNA SEÑAL
SIG_ALARM HACIA EL MISMO PROCESO QUE LA INVOCA...............49
FIGURA 1.5.6 UNA TUBERÍA ES UNIDIRECCIONAL, COMO LOS TELÉFONOS DE
YOGUR.......................................................................52
FIGURA 1.5.7 EL PROCESO PADRE Y SU HIJO COMPARTEN DATOS MEDIANTE
UNA TUBERÍA................................................................53
FIGURA 1.5.8 DOS PROCESOS SE COMUNICAN BIDIRECCIONALMENTE CON
DOS TUBERÍAS...............................................................55
FIGURA 1.5.9 COMUNICACIÓN MEDIANTE CAPAS DE PROTOCOLOS DE RED.64

iii

Índice de tablas

TABLA 1.2.1 CREDENCIALES DE UN PROCESO Y SUS SIGNIFICADOS.........11
TABLA 1.4.2 LISTA DE LAS VARIABLES AUTOMÁTICAS MÁS COMUNES EN
MAKEFILES..................................................................18
TABLA 1.5.3 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “FLAGS”.
..............................................................................23
TABLA 1.5.4 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “MODE”.
..............................................................................23
TABLA 1.5.5 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “WHENCE”.
..............................................................................28

iv

1.Programación en
GNU/Linux

E

n este texto repasaremos conceptos de multiprogramación como las
definiciones de programa, proceso e hilos, y explicaremos el
mecanismo de llamadas al sistema que emplea Linux para poder

aceptar las peticiones desde el entorno de usuario.

Seguidamente veremos las posibilidades que nos ofrece el Compilador de

C de GNU, GCC, y programaremos nuestros primeros ejecutables para
GNU/Linux. Después de repasar las llamadas al sistema más comunes,
analizaremos las particularidades de UNIX a la hora de manejar directorios,
permisos, etc., y nos adentraremos en la Comunicación Interproceso (IPC).
Finalmente abordaremos de forma introductoria la programación de sockets
de red, para dotar de capacidades telemáticas a nuestros programas.

1.1

Llamadas al sistema

GNU/Linux es un Sistema Operativo multitarea en el que van a convivir
un gran número de procesos. Es posible, bien por un fallo de programación o
bien por un intento malicioso, que alguno de esos procesos haga cosas que
atenten contra la estabilidad de todo el sistema. Por ello, con vistas a
proteger esa estabilidad, el núcleo o kernel del sistema funciona en un
entorno totalmente diferente al resto de programas. Se definen entonces dos
modos de ejecución totalmente separados: el modo kernel y el modo usuario.
Cada uno de estos modos de ejecución dispone de memoria y procedimientos
diferentes, por lo que un programa de usuario no podrá ser capaz de dañar
al núcleo.

Aquí se plantea una duda: si el núcleo del sistema es el único capaz de
manipular los recursos físicos del sistema (hardware), y éste se ejecuta en un
modo de ejecución totalmente disjunto al del resto de los programas, ¿cómo
es posible que un pequeño programa hecho por mí sea capaz de leer y
escribir en disco? Bien, la duda es lógica, porque todavía no hemos hablado
de las “llamadas o peticiones al sistema” (“syscalls”).

5

Programación de Sistemas

6

Las syscalls o llamadas al sistema son el mecanismo por el cual los

procesos y aplicaciones de usuario acceden a los servicios del núcleo. Son la
interfaz que proporciona el núcleo para realizar desde el modo usuario las
cosas que son propias del modo kernel (como acceder a disco o utilizar una
tarjeta de sonido). La siguiente figura explica de forma gráfica cómo
funciona la syscall read( ):

Figura 1.1.1 Mecanismo de petición de servicios al kernel.

El proceso de usuario necesita acceder al disco para leer, para ello
utiliza la syscall read() utilizando la interfaz de llamadas al sistema. El
núcleo atiende la petición accediendo al hardware y devolviendo el resultado
al proceso que inició la petición. Este procedimiento me recuerda al comedor
de un restaurante, en él todos los clientes piden al camarero lo que desean,
pero nunca entran en la cocina. El camarero, después de pasar por la cocina,
traerá el plato que cada cliente haya pedido. Ningún comensal podría
estropear la cocina, puesto que no tiene acceso a ella.

Prácticamente todas las funciones que utilicemos desde el espacio de
ejecución de usuario necesitarán solicitar una petición al kernel mediante
una syscall, esto es, la ejecución de las aplicaciones de usuario se canaliza a
través del sistema de peticiones al sistema. Este hecho es importante a la
hora de fijar controles y registros en el sistema, ya que si utilizamos nuestras
propias versiones de las syscalls para ello, estaremos abarcando todas las
aplicaciones y procesos del espacio de ejecución de usuario. Imaginemos un
“camarero” malicioso que capturase todas las peticiones de todos los
clientes y envenenase todos los platos antes de servirlos... nuestro
restaurante debería cuidarse muy bien de qué personal contrata y nosotros
deberemos ser cautelosos también a la hora de cargar drivers o módulos en
nuestro núcleo.

1.2

Programas, procesos, hilos...

Un proceso es una entidad activa que tiene asociada un conjunto de

atributos: código, datos, pila, registros e identificador único. Representa la
entidad de ejecución utilizada por el Sistema Operativo. Frecuentemente se
conocen también con el nombre de tareas (“tasks”).

Programación de Sistemas

7

Un programa representa una entidad pasiva. Cuando un programa es

reconocido por el Sistema Operativo y tiene asignado recursos, se convierte
en proceso. Es decir, la ejecución de código implica la existencia de un
entorno concreto.

Generalmente un proceso:

• Es la unidad de asignación de recursos: el Sistema

Operativo va asignando los recursos del sistema a cada
proceso.
• Es una unidad de despacho: un proceso es una entidad
activa que puede ser ejecutada, por lo que el Sistema
Operativo conmuta entre los diferentes procesos listos
para ser ejecutados o despachados.

Sin embargo, en algunos Sistemas Operativos estas dos unidades se
separan, entendiéndose la segunda como un hilo o thread. Los hilos no
generan un nuevo proceso sino que producen flujos de ejecución disjuntos
dentro del mismo proceso. Así pues, un hilo o “proceso ligero” (“lightweight
process, LWP”) comparte los recursos del proceso, así como la sección de
datos y de código del proceso con el resto de hilos. Esto hace que la creación
de hilos y el cambio de ejecución entre hilos sea menos costoso que el
cambio de contexto entre procesos, aumentando el rendimiento global del
sistema.

Un Sistema Operativo multiusuario y multiprogramado (multitarea)
pretende crear la ilusión a sus usuarios de que se dispone del sistema al
completo. La capacidad de un procesador de cambiar de tarea o contexto es
infinitamente más rápida que la que pueda tener una persona normal, por lo
que habitualmente el sistema cumple este objetivo. Es algo parecido a lo que
pasa en un restaurante de comida rápida: por muy rápido que seas
comiendo, normalmente la velocidad de servir comida es mucho mayor. Si un
camarero fuese atendiéndote cada 5 minutos, podrías tener la sensación de
que eres el cliente más importante del local, pero en