Programaci

1
Programación de Sistemas

• MC Hilda Castillo Zacatelco

2
Familia de funciones EXEC

• En POSIX existe una familia de funciones exec,
  cuyos prototipos se muestran a continuación
• int execl(char path, char arg, ...)
• int execv(char path, char argv)
• int execle(char path, char arg, ...)
• int execve(char path, char argv, char
  envp)
• int execlp(char file, const char arg, ...)
• int execvp(char file, char argv)
• argv es un vector de cadenas que representan los
  argumentos pasados al programa, el primer
  elemento del vector, argv0, es el nombre del
  programa, argv debe terminar con NULL.
• path apunta al nombre del archivo ejecutable
• file se utiliza para construir el nombre del
  archivo ejecutable
• envp apunta al entorno que se pasará al nuevo
  proceso y se obtiene de la variable externa
  environ.

3

• include ltsys/types.hgt
• include ltstdio.hgt
• main()
• pid_t pid
• char argumentos3
• argumentos0ls
• argumentos1-l
• argumentos2NULL
• pidfork()
• switch(pid)
• case 1 exit(-1)
• case 0
• execvp(argumentos0, argumentos)
• perror(exec)
• break
• default printf(Proceso padre\n)

4

• Terminacion de procesos
• Un proceso puede terminar su ejecución de forma
  normal o anormal. Un proceso puede terminar su
  ejecución de forma normal usando cualquiera de
  las tres formas siguientes
• Ejecutando una sentencia return en la funcion
  main.
• Ejecutando la llamada exit
• Ejecutando la llamada _exit
• Cuando un proceso ejecuta dentro de la función
  main la sentencia return (valor), ésta es similar
  a exit(valor). El prototipo de la función exit
  es
• void exit(int status)
• Estos servicios tienen por función finalizar la
  ejecución de un proceso.

5

• La finalización de un proceso tiene las
  siguientes consecuencias
• Se cierran todos los descriptores de archivos.
• La terminación del proceso no finaliza de forma
  directa la ejecución de sus procesos hijos.
• Si el proceso padre del proceso que realiza la
  llamada se encuentra ejecutando una llamada wait
  o waitpid, se notifica la terminación del
  proceso.
• Si el proceso padre no se encuentra ejecutando
  una llamada wait o waitpid, el código de
  finalización (status) se salva hasta que el
  proceso padre ejecute la llamada wait o waitpid.
• Si la implementación soporta la señal SIGCHLD,
  ésta se envía el proceso padre.
• El sistema operativo libera todos los recursos
  utilizados por el proceso.

6

• Un proceso también puede terminar su ejecución de
  forma anormal, llamando a la función abort, por
  la recepción de una señal que provoca su
  finalización. La señal puede ser causada por un
  evento externo, por una señal enviada por otro
  proceso, o por un error de ejecución.
• Cuando un proceso termina de forma anormal,
  generalmente, se produce un archivo denominado
  core que incluye la imagen de memoria del proceso
  en el momento de producirse su terminación y
  puede ser utilizado para depurar el programa.

7

• En realidad exit es una función de biblioteca que
  llama al servicio _exit después de preparar la
  terminación ordenada del proceso. El prototipo de
  _exit es
• void _exit(int status)
• En general se recomienda utilizar la llamada exit
  en vez de _exit, puesto que es más portable y
  permite volcar a disco los datos no actualizados.
  Una llamada a exit realiza las siguientes
  funciones
• Todas las funciones registradas con la función
  estándar de C atexit, son llamadas en orden
  inverso a su registro. Si cualquiera de estas
  funciones llama a exit, los resultados no serán
  portables. La sintaxis de esta función es
• int atexit(void (func)(void))
• Todos los archivos abiertos son cerrados y todos
  los datos en el almacenamiento intermedio son
  copiados al sistema operativo.
• Se llama a la función _exit.

8

• include ltstdio.hgt
• include ltstdlib.hgt
• void fin(void)
• printf(Fin de la ejecución del proceso d\n,
  getpid())
• return
• int main(void)
• if (atexit(fin)!0)
• perror(atexit)
• exit(1)
• exit(0) /provoca la ejecución de la función
  fin/

9

• Esperar por la finalización de un proceso hijo.
• Permite a un proceso padre esperar hasta que
  termine la ejecución de un proceso hijo. Existen
  dos formas de invocar este servicio
• pid_t wait(int status)
• pid_t waitpid(pid_t pid, int status, int
  options)
• Ambas llamadas esperan la finalización de un
  proceso hijo y permiten obtener información sobre
  el estado de terminación del mismo.
• La llamada wait suspende la ejecución del proceso
  hasta que finaliza la ejecución de uno de sus
  procesos hijos. Esta función devuelve el
  identificador del proceso hijo cuya ejecución ha
  finalizado. Si status es distinto de NULL,
  entonces se almacena en esta variable información
  relativa al proceso que ha terminado.
• Si el hijo retornó un valor desde la función
  main, utilizando la sentencia return, o pasó un
  valor como argumento a exit, éste valor puede ser
  obtenido por medio de la variable utilizando las
  siguientes macros definidas en el archivo de
  cabecera sys/wait.h

10

• WIFEXITED(status), devuelve un valor verdadero
  (distinto de cero) si el hijo terminó
  normalmente.
• WEXITSTATUS(status), permite obtener el valor
  devuelto por el proceso hijo en la llamada exit o
  el valor devuelto en la función main, utilizando
  la sentencia return. Esta macro solo puede ser
  utilizada cuando WIFEXITED devuelve un valor
  verdadero (distinto de cero).
• WIFSIGNALED(status), devuelve un valor verdadero
  si el proceso hijo finalizó su ejecución como
  consecuencia de la recepción de una señal para la
  cual no se había programado manejador.
• WTERMSIG(status), devuelve el número de la señal
  que provocó la finalización del proceso hijo.
  Esta macro sólo puede utilizarse si WIFSIGNALED
  devuelve un valor verdadero.

11

• El servicio waitpid tiene el mismo funcionamiento
  si el argumento pid es 1 y el argumento options
  es cero. Su funcionamiento general es el
  siguiente
• Si pid es 1, se espera la finalización de
  cualquier proceso.
• Si pid es mayor que cero, se espera la
  finalización del proceso hijo con identificador
  pid.
• Si pid es cero, se espera la finalización de
  cualquier proceso hijo con el mismo identificador
  de grupo de proceso que el del proceso que
  realiza la llamada.
• Si pid es menor que 1, se espera la finalización
  de cualquier proceso hijo cuyo identificador de
  grupo de proceso sea igual al valor absoluto del
  valor de pid.
• El argumento options se construye mediante el OR
  binario de cero o más valores definidos en el
  archivo de cabecera sys/wait.h.

12

• Programa que imprime información sobre el estado
  de terminación de un proceso hijo.
• include ltsys/types.hgt
• include ltsys/wait.hgt
• include ltstdio.hgt
• main(int argc, char argv)
• pid_t pid
• int valor
•  
• pidfork()
• switch(pid)
• case 1 exit(1)
• case 0 if (execvp(argv1, argv1) lt 0)
• perror(exec)
• default while(wait(valor) ! pid)
• if (valor 0)
• printf(El mandato se
  ejecuto de forma normal\n)
• else
• if (WIFEXITED(valor))
• printf(El hijo termino normalmente y su
  valor devuelto fue d\n, WEXITEDSTATUS(valor))

13

• Ejecución de un proceso en background
• include ltsys/types.hgt
• include ltstdio.hgt
• main( int argc, char argv)
• pid_t pid
•  
• pidfork()
• switch(pid)
• case 1 exit(-1)
• case 0 if (execvp(argv1, argv1)lt 0)
• perror(exec)
• default exit(0)

14
Comunicación entre procesos
15

• Es deseable construir software que consista de
  procesos diferentes cooperativos, en vez de un
  solo programa, por lo tanto es necesario tener
  mecanismo de comunicación entre procesos.
• Las tres técnicas más ampliamente usadas son
• señales
• pipes
• fifos.

16

• Señales y Excepciones
•  
• Son mecanismos a los que recurre el sistema
  operativo para notificar a un determinado proceso
  la ocurrencia de un determinado evento o error.
• (Se llaman señales en Posix y Excepciones en
  Windows NT)
• Señales
• Las señales tiene frente al proceso el mismo
  comportamiento que las interrupciones tienen
  frente al procesador, por lo que se puede decir
  que una señal es una interrupción al proceso.
• Por ejemplo, si tenemos un programa muy grande
  ejecutándose y queremos terminarlo solo oprimimos
  las teclas ctrl-C (señal SIGINT ). El kernel
  envía la señal a todos los procesos que
  reconozcan a la terminal como su terminal de
  control, y el programa atrapa la señal y realiza
  la función correspondiente.