Download doc - TP2-grupo4

SISTEMAS OPERATIVOS

“LLAMADAS AL SISTEMA”

2012 – 2DO. CUATRIMESTRE (T: TARDE)

4

FERRERO, LUCRECIA e-mail: [email protected]

MÁNDOLA, SILVINA e-mail: [email protected]

mailto:[email protected]

mailto:[email protected]

Ferrero, Lucrecia UTN-FRSFMándola, Silvina TP2: llamadas al sistema

2


ARGUMENTOS POR LÍNEA DE COMANDO (ARGC – ARGV – OPCIONES)EJERCICIO 1.Deberá generar un programa en C que le permitirá manejar opciones y argumentos a través de la línea de comandos.Sintaxis de ejecución (suponiendo que se lo compila con el nombre ej1):ej1 [-cl] [-s nombre_archivo]opciones:

c: indicará la cantidad de argumentos con el que fue llamado ej1 (incluyendo también el primer argumento reservado para el nombre del programa)l: listará cada argumento indicando el número que representa.s: almacenará en el archivo: nombre_archivo los argumentos con el que se llama el programa incluyendo el nombre del programa. El archivo deberá ser creado al momento de esta acción ya que debe contener sólo la información correspondiente a la corrida actual.

Si no se especifican opciones, deberá imprimir por pantalla un mensaje con la sintaxis del programa.

ej1 [-cl] [-s nombre_archivo]#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <string.h>#include <stdlib.h>#include <fcntl.h>

int main(int argc, char *argv[]){

int parametro;if ( argc == 1 ){

printf("%s", "uso: [-cl] [-s nombre_archivo]\n");}if ( argc >= 1 && argc <= 4 )

3


{while ((parametro = getopt (argc, argv, "cls:")) != -1){

switch (parametro) {

case 'c':printf("%s%d", "cantidad de argumento:",

argc);printf("\n");break;

case 'l':printf("%s%s", "argumento: 0- ",

argv[0]);printf("\n");printf("%s%s", "argumento: 1 ", argv[1]);printf("\n");break;

case 's':if ( argc == 2 ){

printf("%s%s", argv[0], ": option requires an argument --s \n");

printf("\n");}else{

int fd = creat(argv[2], O_CREAT + O_WRONLY);

write(fd, argv[0], 5);write(fd, argv[1], 5);

}break;

default: printf("%s", "uso: [-cl] [-s nombre_archivo]\n");

}}

}if ( argc > 3 ){

printf("%s", "uso: [-cl] [-s nombre_archivo]\n");}

return 0;}

4


GESTIÓN DE PROCESOSEJERCICIO 2.Genere un programa en C: ej2.c que mostrará a través del siguiente árbol de jerarquía de procesos, los diferentes resultados para la variable “VALOR”:Árbol:

Nodo R (Raíz): corresponde al proceso principal, imprimirá el valor inicial para la variable. Este valor será recibido como argumento por línea de comando.Nodo 1: es el primer hijo del proceso principal, que a su vez será raíz del subárbol 1. Imprimirá el incremento en 100 de la variable VALOR.

5


o Nodo 1.1: corresponde al primer hijo del Nodo 1 e imprimirá el doble de la variable VALOR calculado en el Nodo 1.

o Nodo 1.2: corresponde al segundo hijo del Nodo 1 e imprimirá la mitad de la variable VALOR. calculado en el Nodo 1.

Nodo 2: es el segundo hijo del proceso principal, mostrará el decremento en 100 de la variable VALOR.

En cada resultado que se muestre se deberá indicar el “nodo” en que se está realizando el cálculo, además de la identificación del proceso. Para los procesos hijos también se deberá identificar al padre.La variable VALOR sólo puede definirse una sola vez.Sintaxis de ejecución (suponiendo que se lo compila con el nombre ej2):ej2 nro

ej2 nro#include <sys/types.h>#include <unistd.h>#include <stdio.h>

void ChildProcessleft(int valor); void ChildProcessright(int valor);void Grandsonleft(int valor); void Grandsonright(int valor);

int main(int argc, int *argv[]){

pid_t pid;int valor = atoi(argv[1]);

printf("\n");printf("%s%d", "NODO R - VALOR = ", valor);printf("\n");printf("%s%d","ID Proceso Principal = ", getpid());printf("\n");

pid = fork();

if (pid == 0){

ChildProcessleft(valor);

6


}else{

ChildProcessright(valor);}return 0;

}

void ChildProcessleft(int valor){

pid_t pid;int valorp = valor + 100; printf("\n");printf("%s%d"," NODO 1 - VALOR = ", valorp);printf("\n");printf("%s%d%s%d"," ID NODO 1 = ", getpid(), "- ID Padre NODO 1

(NODO R): ", getppid());printf("\n");

pid = fork();

if (pid == 0){

Grandsonleft(valorp);}else{

Grandsonright(valorp);}

}

void ChildProcessright(int valor){

pid_t pidr;pidr = fork();if (pidr == 0){

printf("\n");printf("%s%d"," NODO 2 - VALOR = ", valor - 100);printf("\n");printf("%s%d%s%d"," ID NODO 2 = ", getpid(), "- ID Padre

NODO 2 (NODO R): ", getppid());printf("\n");printf("\n");

}

}void Grandsonleft(int valor){

printf("\n");printf("%s%d"," NODO 1.1 - VALOR = ", valor * 2);printf("\n");printf("%s%d%s%d"," ID NODO 1.1 = ", getpid(), "- ID Padre NODO

1.1 (NODO 1): ", getppid());printf("\n");

}

7


void Grandsonright(int valor){

pid_t pids;pids = fork();if (pids == 0){

printf("\n");printf("%s%d"," NODO 1.2 - VALOR = ", valor / 2);printf("\n");printf("%s%d%s%d"," ID NODO 1.2 = ", getpid(), "- ID Padre

NODO 1.2 (NODO 1): ", getppid());printf("\n");

}}

EJERCICIO 3.Deberá generar un programa que calcula el factorial del siguiente rango de numeración: 1 a 10.El programa se llamará factorial.c. Antes de finalizar y luego de realizado el cálculo en caso de que se haya recibido un número valido, deberá imprimir el número de su identificación de proceso. En caso de que no sea un número válido mostrará un mensaje de error y también deberá imprimir el número de ID.Este programa (factorial) será invocado desde ej3.c reemplazándolo (ej3 será sustituido por factorial). Antes de invocar al programa factorial, ej3 deberá mostrar su propio número de identificación de proceso. En caso de error se deberá indicar que factorial no ha podido ejecutarse.Al finalizar la corrida, deberá incluir en el archivo de texto de resolución del TP una breve conclusión sobre los números de procesos que fueron identificados.Sintaxis de ejecución (suponiendo que se lo compila con el nombre ej3):ej3 número

8


factorial.c#include <sys/types.h>#include <unistd.h>#include <fcntl.h>#include <stdio.h>

int factorial(int valor);

int main(int argc, char* argv[]){

if ( argc == 1 ){

printf("%s", "Error. Usar ./Nombre_Pgr_Invoca [numero]: \n");

printf("%s%d", "Id de Prg-Factorial: ", getpid());printf("\n");

}if (argc > 1){

int valor = atoi(argv[1]);int resultado;if (valor >= 1 && valor <= 10){

resultado = factorial(valor);printf("%s%d%s%d", "Factorial de ", valor, " = ",

resultado);printf("\n");

}else{

printf("%s%d", "Numero fuera de rango: ", valor);printf("\n");

}

printf("%s%d", "Id de Prg-Factorial: ", getpid());printf("\n");

}return 0;

}

int factorial(int valor){

if (valor == 0 || valor == 1){

return 1;}else {

9


return (valor * factorial(valor - 1));}

}

ej3.c.#include <sys/types.h>#include <unistd.h>#include <fcntl.h>#include <stdio.h>

int main(int argc, char *argv[], char *envp[]){

if ( argc > 1 ){

printf("%s%d", "Id proceso que invoca: ", getpid());printf("\n");

}execve("./factorial", argv, envp);return 0;

}

10


GESTIÓN DE ARCHIVOS, DIRECTORIOS Y SISTEMA DE ARCHIVOSEJERCICIO 4.Genere el programa ej4.c que permitirá listar el contenido de un directorio, tendrá la siguiente sintaxis de ejecución:ej4 [opciones] [pathname]Opciones:

l: lista el contenido del directorio. t: tipo.

Listará el contenido del directorio especificando el tipo de cada archivo (Regular, directorio, especial de dispositivo de caracteres, especial de dispositivo de bloques, enlace simbólico, etc.)

i: número de inodoPathname: será el nombre de un directorio, en caso de que sea inválido deberá mostrar el mensaje de error correspondiente. Si no se especifica al momento de la ejecución deberá ejecutarse sobre el directorio actual.Sintaxis de ejecución (suponiendo que se lo compila con el nombre ej3):ej4 [-lti] [dir_name]

ej4 [-lti] [dir_name]#include <stdio.h>#include <dirent.h>

11


void tipo (int argc, char *argv[]);void directorios (int argc, char *argv[]);void inodo (int argc, char *argv[]);


int parametro;if ( argc == 1 ){

printf("%s", "uso: [-lti] [nombre_directorio]\n");}if ( argc >= 1 && argc <= 3 ){

while ((parametro = getopt (argc, argv, "lti:")) != -1){

switch (parametro) {

case 'l':directorios (argc, argv);break;

case 't':tipo (argc, argv);break;

case 's':inodo (argc, argv);break;

}}

}else{

printf("%s", "uso: [-lti] [nombre_directorio]\n");}

}

void tipo (int argc, char *argv[]){

static unsigned char tipoID[7] = {DT_BLK, DT_CHR, DT_DIR, DT_FIFO, DT_LNK, DT_REG, DT_SOCK};

static char *tipoSTRs[7] = {"Dispositivo de bloques", "Dispositivo de caracteres", "Directorio", "FIFO", "Enlace", "Archivo Regular", "Socket Unix"};

DIR *pd; //ptro a fichero directoriostruct dirent *dirdatos; //info sobre 1 entrada en el directorioif (argc == 1){

fprintf (stderr, "numero de parametro erroneo \n");fprintf (stderr, "Uso %s <Directorio>\n", argv[0]);exit(1);

}pd = opendir(argv[2]);if(pd == NULL)

{perror(argv[2]);exit(1);

} dirdatos = readdir(pd);printf("%s%s", "Tipos de arhivos del directorio: ", argv[2]);

12


printf("\n");while (dirdatos != NULL){ int tipo = dirdatos->d_type;

switch (tipo){

case 1: printf ("%s%s%s \n", dirdatos-> d_name, " -

" ,tipoSTRs[0]);dirdatos = readdir(pd);













}if (dirdatos-> d_type & DT_REG){

printf ("%s%s \n", dirdatos-> d_name, " - Regular");dirdatos = readdir(pd);

}}closedir (pd);

}

void directorios (int argc, char *argv[]){

DIR *pd; //ptro a fichero directoriostruct dirent *dirdatos; //info sobre 1 entrada en el directorioif (argc == 1)

{fprintf (stderr, "numero de parametro erroneo \n");fprintf (stderr, "Uso %s <Directorio>\n", argv[0]);exit(1);

}pd = opendir(argv[2]);

13


if(pd == NULL){

perror(argv[2]);exit(1);

}

dirdatos = readdir(pd);printf("%s%s", "Listado del directorio: ", argv[2]);printf("\n");while (dirdatos != NULL){

printf ("%s \n", dirdatos-> d_name);dirdatos = readdir(pd);

}closedir (pd);

}

void inodo (int argc, char *argv[]){

DIR *pd; //ptro a fichero directoriostruct dirent *dirdatos; //info sobre 1 entrada en el directorioif (argc == 1){

fprintf (stderr, "numero de parametro erroneo \n");fprintf (stderr, "Uso %s <Directorio>\n", argv[0]);exit(1);

}pd = opendir(argv[2]);if(pd == NULL){

perror(argv[2]);exit(1);

} dirdatos = readdir(pd);printf("%s%s", "Numero de inodo de archivos del directorio: ",

argv[2]);printf("\n");while (dirdatos != NULL){

printf ("%s - %d \n", dirdatos-> d_name, dirdatos-> d_ino);dirdatos = readdir(pd);

}closedir (pd);

}

GESTIÓN DE SEÑALESEJERCICIO 5.A los huéspedes del hotel se les ofrece entre otros tantos servicios, el desayuno buffete. Una de las principales preferencias elegidas por los visitantes son las tostadas para poder acompañar con una gran variedad de mermeladas regionales de diferentes sabores.

14


Deberá simular el comportamiento de la tostadora que tiene ciertas particularidades, teniendo en cuenta las siguientes condiciones:

1 de cada 5 huéspedes elige pan negro para tostar.Cada tostada de pan negro demora, para la graduación de temperatura ya estipulada: 30 segundos (representar en la simulación por 1 seg) en tostarse, mientras que la de pan blanco tarda 45 segundos (representar en la simulación por 2 seg).La tostadora se programa de acuerdo a uno u otro tipo de pan.Las tostadas se preparan por pares, pero solamente admite un tipo de programación (blanco/negro).

Cada vez que finaliza la tostadora de tostar el pan, emite una alarma indicando que la tostada está hecha.Datos para la simulación:

La tostadora será un proceso a la espera de las señales de los huéspedes (segundo proceso) cuando van a realizar las tostadas (pan blanco –SIGURSR1- / pan negro –SIGURSR2). Por cada señal imprimirá el siguiente mensaje:

“Tostar pan blanco”“Tostar pan negro”

Los huéspedes enviarán una señal cuando quieran una tostada:

“Pedido de tostadas de pan blanco”“Pedido de tostadas de pan negro”

Se solicita simular la situación promedio de 30 tostadas por día que son solicitadas por los huéspedes.

Sintaxis de ejecución (suponiendo que se lo compila con el nombre tostadora y huesped):./tostadora ./huesped [pid_tostadora]

./tostadora#include <sys/types.h>#include <unistd.h>#include <signal.h>#include <stdio.h>

int tostadas = 0;int lista = 1;

void tostar (int sig);void man_alarm (int sig);

int main(){

signal(SIGUSR1, &tostar);signal(SIGUSR2, &tostar);signal(SIGALRM, &man_alarm);while( tostadas < 15 )

15


{if (lista) printf("Tostadora libre, esperando pan.\n");pause();}return 0;

}

void man_alarm (int sig){lista = 1;printf ("Tostadas listas\n");}

void tostar (int sig){

tostadas ++;lista = 0;switch (sig){

case SIGUSR1: printf("\n");printf("Deseo tostadas de pan blanco.\n"); printf("Tostada de pan blanco (%d) \n",

tostadas);alarm(2);break;

case SIGUSR2: printf("\n");printf("Deseo tostadas de pan negro.\n");printf("Tostada de pan negro: (%d)\n",

tostadas);alarm(1);break;

}}

./huesped [pid_tostadora]#include <sys/types.h>#include <signal.h>#include <stdio.h>#include <unistd.h>#include <stdlib.h>

int main (int argc, char *argv[]){

int pid_m, i;pid_m = atoi(argv[1]);for (i=1; i < 16; i++){

if ((i % 5) != 0){

printf("%s%d\n","Pedido de tostadas de pan Blanco. Huesped: ", i);

16


kill(pid_m, SIGUSR1);

}else{

printf("%s%d\n","Pedido de tostadas de pan Negro. Huesped: ", i);

kill(pid_m, SIGUSR2);

}Sleep(2);}return 0;

}

REDIRECCIÓN DE ENTRADA Y SALIDA.EJERCICIO 6.Una línea aérea cubre el transporte de pasajeros en el centro del país, con una flota de aeronaves de mediano porte como la que se muestra en la imagen.La aeronave cuenta con 33 plazas y tiene una alta demanda de pedidos. Para agilizar los trámites de los pasajeros la compañía cuenta con la opción de Web check-in, para lo que previamente se debe contar con el código de la reserva.Se solicita modelar la situación descripta anteriormente con la generación de 3 programas, suponiendo que se trata del vuelo AR234, para lo que se deberá generar:

El programa reservas.c agregará al nombre del pasajero y el código de reserva la identificación del vuelo. El programa checkin.c agregará por cada nombre del pasajero y el código de reserva el número de asiento.

Se supone que se cuenta con el archivo pasajeros.txt que contiene la siguiente información (para el vuelo que se desea programar):LEIVA,JUAN_KLRZIDIAZ,MAIRA_KLRZISANCHEZ,ESTEBAN_QWERODIEGUEZ,DARIO_FRTYUMENDEZ,ELBA_YTHGJ

17


NOTA: los elementos antes del “_” corresponden a los nombres de los pasajeros y las 5 letras siguientes a la reserva.Sintaxis de ejecución (suponiendo que se lo compila con el nombre reservas y checkin respectivamente):./reservas./checkinFinalmente, el programa plandevuelo.c , realizará las dos acciones anteriores tomando desde el archivo pasajeros.txt la información y almacenándola en el archivo plandevuelo.txt.Sintaxis de ejecución (suponiendo que se lo compila con el nombre plandevuelo): ./plandevuelo –rc plandevuelo.txt

./reservas

#include <sys/types.h>#include <unistd.h>#include <fcntl.h>#include <stdio.h>

int main(void){

int fd, newfd;while ((getc(stdin) != -1 )){

char *c[50]; scanf("%[^\n]", c);printf("%s%s\n", c, "_AR234");

}return 0;

}

./checkin

#include <sys/types.h>#include <unistd.h>#include <fcntl.h>#include <stdio.h>

int main(void){

int asiento = 1;char linea[50] = getline(stdin, 50);printf("%s\n", linea);while (getc(stdin) != -1 ){

char *c[50]; scanf("%[^\n]\n", c);printf("%s%s%d\n", c, "_", asiento);asiento ++;

}return 0;

}

./plandevuelo –rc plandevuelo.txt

18


#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/types.h>#include <string.h>#include <fcntl.h>

void checkin (char *archivo[]);void reservas(char *archivo[]);void reservascheckin (char *archivo[]);


int parametro;char *archivo[] = {argv[2]};if (argc < 3 || argc > 4){

printf("Nro de parametros incorrecto\n");return 0;

}if (strcmp(argv[1], "-r") == 0){

reservas (archivo);}if (strcmp(argv[1], "-c") == 0){

checkin (archivo);}if (strcmp(argv[1], "-rc") == 0){

reservascheckin (archivo);}return 0;

}

void checkin (char *archivo[]){

FILE *fl;pid_t pid;int tuberia[2];pipe (tuberia);pid = fork();if (pid) //padre{

char linea [150];fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de pasajerosclose(tuberia[0]); // cierra pipe de lecturaclose(1);dup(tuberia[1]);while (feof(fl) == 0 ){

fgets(linea, 150, fl);printf("%s", linea);

}fclose(fl); // cierra el archivo

}else //hijo{

19


close(tuberia[1]); //cierra el pipe de escrituraclose(1); // cierra la salida estandarint fd = creat(archivo[0], O_CREAT + O_WRONLY); // crea el archivo

plandevuelo.txtdup(fd); // ponemos el file descriptor en la salida estandarclose(0); //cierro la entrada estandardup(tuberia[0]); // pone el file descriptor en la entrada estandar.execve("./checkin", archivo, NULL);

}}

void reservas (char *archivo[]){

FILE *fl;pid_t pid;int tuberia[2];pipe (tuberia);pid = fork();if (pid) //padre{

char linea [150];fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de pasajerosclose(tuberia[0]); // cierra pipe de lecturaclose(1);dup(tuberia[1]);while (feof(fl) == 0 ){

fgets(linea, 150, fl);printf("%s", linea);

}fclose(fl); // cierra el archivo

}else //hijo{

close(tuberia[1]); //cierra el pipe de escrituraclose(1); // cierra la salida estandarint fd = creat(archivo[0], O_CREAT + O_WRONLY); // crea el archivo

plandevuelo.xtdup(fd); // ponemos el file descriptor en la salida estandarclose(0); //cierro la entrada estandardup(tuberia[0]); // pone el file descriptor en la entrada estandar.execve("./reservas", archivo, NULL);

}}

void reservascheckin (char *archivo[]){

FILE *fl;pid_t pid;

20


int tuberia[2];pipe (tuberia);pid = fork();if (pid==0) //hijo{

pid_t pid2;int fd = creat("reservas.txt", O_CREAT + O_WRONLY); // crea

el archivo plandevuelo.txtdup(tuberia[0]); //conecto la entrada estandar al archivoclose(1); // cierra la salida estandardup(fd); // ponemos el file descriptor en la salida

estandarexecve("./reservas", archivo, NULL);

}else //padre{

char linea [150];fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de

pasajerosclose(1);//cierra salida estandardup(tuberia[1]);// pone el file descriptor en la entrada

estandar.fl = fopen ("reservas.txt", "r"); // abrimos el archivo de

pasajerosdup(tuberia[1]); // pone el file descriptor en la salida

estandar.execve("./checkin", archivo, NULL);

}}

21


En esta sección dejamos en claro lo siguiente:

22


CONCLUSION EJERCICIO 3: Es que el ID del Proceso que invoca y el ID del Prg-Factorial son iguales, lo que significa que al llamar a execve, no cambia de proceso sino que se sigue ejecutando el mismo.

Fuentes desde donde nos guiamos para la sintaxis de algunas funciones:

http://www.forosdelweb.com/f96/mostrar-directorios-contenido- ficheros-txt-765146/

http://totaki.com/poesiabinaria/2011/09/listar-archivos-dentro-de-un- directorio-o-carpeta-en-c/

Ejercicio 6:

Realizamos la codificación de los 3 programas: reservas.c, checkin.c y plandevuelo.c. “reservas.c” y “checkin.c” funcionan correctamente en “plandevuelo.c”. Hemos dedicado tiempo investigando, realizando consultas y pruebas, pero no logramos que funcione con la opción “-rc”. Sin embargo dejamos expuesta su codificación en la imagen (.img) y en este documento.

23

http://totaki.com/poesiabinaria/2011/09/listar-archivos-dentro-de-un-directorio-o-carpeta-en-c/

http://totaki.com/poesiabinaria/2011/09/listar-archivos-dentro-de-un-directorio-o-carpeta-en-c/

http://www.forosdelweb.com/f96/mostrar-directorios-contenido-ficheros-txt-765146/

http://www.forosdelweb.com/f96/mostrar-directorios-contenido-ficheros-txt-765146/