PDF de programación - GNULinux programacion de sistemas (1)

GNU/Linux: Programación de Sistemas Pablo Garaizar [email protected] GNU/Linux: Programación de SistemasPablo Garaizar Sagarminagaemail: [email protected]: http://paginaspersonales.deusto.es/garaizarblog: http://blog.txipinet.comFacultad de Ingeniería - ESIDEUniversidad de DeustoBilbao Tabla de contenido1. PROGRAMACIÓN EN GNU/LINUX...........................................51.1 Llamadas al sistema..........................................................51.2 Programas, procesos, hilos................................................61.2.1 Estructuras de datos...............................................71.2.2 Estados de los procesos en Linux...........................81.2.3 Identificativos de proceso.......................................91.2.4 Planificación..........................................................111.3 El GCC.............................................................................121.3.1 Compilación básica...............................................121.3.2 Paso a paso...........................................................131.3.3 Librerías................................................................141.3.4 Optimizaciones.....................................................141.3.5 Debugging............................................................151.4 make world......................................................................151.4.1 Makefile, el guión de make...................................161.5 Programando en C para GNU/Linux.................................201.5.1 Hola, mundo!........................................................201.5.2 Llamadas sencillas................................................211.5.3 Manejo de directorios...........................................321.5.4 Jugando con los permisos.....................................351.5.5 Creación y duplicación de procesos.....................381.5.6 Comunicación entre procesos..............................431.5.7 Comunicación por red...........................................622. LICENCIA....................................................................80ii Í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.64iii Índice de tablasTABLA 1.2.1 CREDENCIALES DE UN PROCESO Y SUS SIGNIFICADOS.........11TABLA 1.4.2 LISTA DE LAS VARIABLES AUTOMÁTICAS MÁS COMUNES EN MAKEFILES..................................................................18TABLA 1.5.3 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “FLAGS”...............................................................................23TABLA 1.5.4 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “MODE”...............................................................................23TABLA 1.5.5 LISTA DE LOS POSIBLES VALORES DEL ARGUMENTO “WHENCE”...............................................................................28iv 1.Programación en GNU/Linux 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.ESeguidamente 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.1Llamadas al sistemaGNU/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 Sistemas6Las 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.1Mecanismo 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.2Programas, 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 Sistemas7Un 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 realidad lo que está haciendo es compartir sus servicios (recursos) entre todos los clientes de forma rápida (“time-sharing”).1.2.1Estructuras de datosSi queremos implementar la ejecución de varias tareas al mismo tiempo, los cambios de contexto entre tareas y