Universidad Regional Autnoma de los Andes
UNIANDES
Nombre: Pablo Aguasanta
Nivel: 3 Semestre
Carrera: Ingeniera en Sistemas
Materia: Sistemas Operativos
Tema: Consulta de POSIX
IDENTIFICACIN DE PROCESOS
POSIX identifica cada proceso por medio de un entero nico denominado Identificador de
Proceso (Process ID, PID) de tipo pid_t.a-Obtener el identificador de un proceso:
pid_t getpid(void);
b-Obtener el identificador del proceso padre:pid_t getppid(void)
Ejemplo:
#include <sys/types.h>
#include <stdio.h>
main(){
pid_t id_proceso;
pid_t id_padre;
id_proceso = getpid();
id_padre = getppid();
printf("Identificador de proceso: %d\n", id_ proceso);
printf("Identificador del proceso padre %d\n", id_ padre);
}
ENTORNO DE UN PROCESO
Viene definido por una lista de variables que se pasan al mismo en el momento de
comenzar su ejecucin. Estas variables se denominan variables de entorno y son
accesibles a un proceso a travs de la variable externa environ, declarada de la
siguiente forma.
extern char **environ;
Esta variable apunta a una lista de variables de entorno. Esta lista no es ms que un
vector de punteros a cadenas de caracteres de la forma nombre=valor, donde nombre
hace referencia al nombre de una variable de entorno y valor al contenido de la misma.
Ejemplo: Programa que imprime el entorno de un proceso
#include <stdio.h>
#include <stdlib.h>
extern char **environ;
int main(int argc, char **argv)
{
int i;
printf("Lista de variables de entorno de %s\n",argv[0]);
for (i=0 ; environ[i] != NULL ; i++)
printf("environ[%d] = %s\n", i, environ[i]);
}
Cada aplicacin interpreta la lista de variables de entorno de forma especfica. POSIX establece
el significado de determinadas variables de entorno:
HOME: directorio de trabajo inicial del usuario
LOGNAME: nombre del usuario asociado al un proceso
PATH: prefijo de directorios para encontrar ejecutables
TERM: tipo de terminal
TZ: informacin de la zona horaria
El servicio getenv permite buscar una determinada variable de entorno dentro de la lista de
variables de entorno de un proceso.
char *getenv(const char *name);
Esta funcin devuelve un puntero al valor asociado a la variable de entorno de nombre name. si
la variable no se encuentra definida, lafuncin devuelve NULL.
CREACIN DE PROCESO
La nica forma es invocando la llamada al sistema fork. El SO realiza una clonacin del proceso
que lo solicite. El proceso que solicita el servicio se convierte en el proceso padre del nuevo
proceso.
pid_t fork()
La clonacin se realiza copiando la imagen de memoria y la PCB. El proceso hijo es una copia del
proceso padre en el instante en que ste solicita al servicio fork. Esto significa que los datos y la
pila del proceso hijo son los que tiene el padre en ese instante de ejecucin. Es ms, dado que,
al entrar el sistema operativo a tratar el servicio, lo primero que hace es salva los registro en la
PCB del padre, al copiarse la PCB se copian los valores salvado de los registro, por lo que el hijo
tiene los mismos valores que el padre.
Esto significa que el contador de programa de los dos procesos tiene el mismo valor, por lo que
van a ejecutar la misma instruccin mquina. No hay que caer en el error de pensar que el
proceso hijo empieza la ejecucin del cdigo en su punto de inicio, sino que el proceso hijo
comienza a ejecutar, al igual que el padre, la sentencia que se encuentra despus de fork().
Las diferencias que existen entre el proceso hijo y el padre son:
El proceso hijo tiene su propio identificador (PID).
El proceso hijo tiene una nueva descripcin de la memoria. Aunque el hijo tenga los
segmentos con el mismo contenido, no tienen por qu est en la misma zona de
memoria.
El tiempo de ejecucin del proceso hijo es igual a cero.
Toda la alarma pendiente se desactiva en el proceso hijo.
El conjunto de seales pendientes se pone en cero.
El valor que retorna el sistema operativo como resultado de fork () e distinto en el hijo
que el padre (el hijo recibe un 0 y el padre el PID del hijo).
Este valor de retorno se puede utilizar mediante una clusula de condicin para que le padre y
el hijo sigan flujos de ejecucin distintos.
Las modificaciones que realice el proceso padre sobre sus registros e imagen de memoria
despus de fork no afectan al hijo y, viceversa. Sin embargo, el proceso hijo tiene su propia
copia de los descriptores del proceso padre.
Esto hace que el hijo tenga acceso a los archivos abiertos por el proceso padre. El padre y el hijo
comparten el puntero de posicin de los archivos abiertos en el padre.
Ejemplo: Programa que crea un proceso
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(){
pid_t pid;
pid = fork();
if(pid==-1) /* error del fork() */
printf(Error\n);
else if (pid==0)
printf("Soy el HIJO, Proceso %d; padre = %d \n", getpid(), getppid());
else
printf("Soy el PADRE, Proceso %d\n", getpid());
}
TERMINACIN DE PROCESOS
Esperar la terminacin de un proceso ligero
Este servicio es similar a wait, pero a diferencia de ste, es necesario especificar el proceso
ligero por el que se quiere esperar, que no tiene por qu ser un proceso ligero hijo.
int pthread_join(pthread thid, void **value);
La funcin suspende la ejecucin del proceso ligero que la invoca hasta que el proceso ligero
con identificador thid finalice su ejecucin. La funcin devuelve en el segundo argumento el
valor que pasa el proceso ligero que finaliza su ejecucin en el servicio pthread_exit, que se
ver a continuacin. nicamente se pude solicitar el servicio pthread_join sobre procesos
ligeros creados como no independientes.
Finalizar la ejecucin de un proceso ligero
int pthread_exit(void *value)
Incluye un punteroa una estructura que es devuelta al proceso ligero que ha ejecutado la
correspondiente llamada a pthread_join, lo que es mucho ms genrico que el parmetro que
permite el servicio wait.
//Ejemplo
//Programa que crea dos procesos
ligeros no independientes
#include <pthread.h>
#include <stdio.h>
void *func(void * jj){
printf("Thread %d \n", pthread_self());
pthread_exit(0);
}
int main()
{
pthread_t th1, th2;
/* se crean dos procesos ligeros con atributos por defecto */
pthread_create(&th1, NULL, func, NULL);
pthread_create(&th2, NULL, func, NULL);
printf("El proceso ligero principal continua ejecutando
\
n");
/* se espera su terminacin */
pthread_join(th1, NULL);
pthread_join(th2, NULL);
exit(0);
}
Bibliography
Intel, (3/27/2006) Programacin con llamadas al sistema POSIX. Argentina:
Programacion_en_Linux.pdf
