Sistemi operativi (programmazione system call e java multithread)

MODALITà RW CON I PERMESSI r--rw-rw-:

4 //i processi dispari scrivono illoro pid nel file corrispondente(1 in testo0 e 3 in

testo2) e inviano il segnale SIGUSR1 al processo pari creato prima di loro

5 //i processi pari aspettano SIGURS1,leggono dal file il PID del processo generato

dopo di loro(0 in testoo e 2 in testo2) e lo stampano a video

6

7 #include <stdio.h>

8 #include <sys/types.h>

9 #include <sys/wait.h>

10 #include <stdlib.h>

11 #include <signal.h>

12 #include <string.h>

13 #include <unistd.h>

14 #include <fcntl.h>

15

16

17 int main(){

18

19

20

21

22 void SIGUSR1_handler(int); //siccome SIGUSR1 NON HA UN AZIONE ATTACCATA NE ATTACCO

UNA

23

24 pid_t pid0,pid1,pid2,pid3 ;

25 int status,fdc1,fdc2,fdO1,fdO2;

26 int p1,p3; //qui ci metto l'intero (pid) che devo memorizzare

27

28 fdc1=creat("testo0",0466);

29 fdc2=creat("testo2",0466);

30

31 fdO1=open("testo0",O_RDWR);

32 fdO2=open("testo2",O_RDWR);

33

34 pid0 =fork(); //DA QUI CI SONO 2 PROCESSI IN GIOCO,PADRE E FIGLIO

35

36 if(pid0<0) {

37 printf("ERRORE! FALLIMENTO DELLA FORK\n");

38 }

39

40

41 else if(pid0 == 0){ //PROCESSO FIGLIO 0 - PARI -

42 printf("SONO IL PROCESSO figlio 0, CON PID:%d E CON PPID:%d\n",getpid(),getppid());

43

44 signal(SIGUSR1,SIGUSR1_handler);

45 pause();

46 lseek(fdc1,0,SEEK_SET); //METTO la testina all inizio

47 read(fdc1,&p1,sizeof(int)); //DEVE LEGGERE DAL FILE TESTO0 IL PID DEL PROCESSO 1

(CHE STA GIA SCRITTO SUL FILE) mette nell intero p1 quello che legge,cioe il pid di

quello dopo

48 printf("SONO IL PROCESSO 0 E HO LETTO IL PID DEL PROCESSO 1 CHE È: PID1=%d\n",p1);

49 exit(0);

50

51 }

52

53

54 else{ //processo padre t

55 printf("SONO IL PROCESSO padre,e creo il processo 1\n ");

56 pid1=fork();

57

58

59

60 //DA QUI HO IN GIOCO IL PROCESSO 0,IL PADRE, E IL NUOVO FIGLIO PROCESSO1

61

62 if(pid1<0) {

63 printf("ERRORE! FALLIMENTO DELLA FORK\n");

64 }

65

66 else if(pid1==0){ //PROCESSO FIGLIO 1 -DISPARI-

67 printf("SONO IL PROCESSO figlio 1, CON PID:%d E CON PPID:%d\n",getpid(),getppid());

68

69 write(fdc1,&pid1,sizeof(int)); //DEVE SCRIVERE IL SUO PID NEL FILE

TESTO0,quindi richiamo pid1 è la scrivo

70 kill(pid0,SIGUSR1); //MANDO A PID0,CIOÈ AL PROCESSO1 IL SEGNALE

71 exit(0);

72

73 }

74

75 else { //processo padre z

76 printf("SONO IL PROCESSO padre,e creo il processo 2\n ");

77 pid2=fork();

78

79

80

81

82 if(pid2< 0){

83 printf("ERRORE! FALLIMENTO DELLA FORK\n");

84 }

85

86 else if(pid2 == 0) { //PROCESSO FIGLIO 2 -PARI-

87 printf("SONO IL PROCESSO figlio 2, CON PID:%d E CON PPID:%d\n",getpid(),getppid());

88 signal(SIGUSR1,SIGUSR1_handler);

89 pause();

90 lseek(fdc2,0,SEEK_SET);

91 read(fdc2,&p3,sizeof(int)); //leggo dal file testo2 il pid3(che sta gia scritto

sopra,lo ha scritto il processo figlio 3) e lo salvo nella variabile intera p3

92 printf("SONO IL PROCESSO 2 E HO LETTO IL PID DEL PROCESSO 3 CHE È: PID1=%d\n",p3);

93 exit(0);

94

95 }

96

97 else{ //processo padre g

98

99 printf("SONO IL PROCESSO padre,e creo il processo 3 ");

100 pid3=fork();

101

102

103

104 if(pid3< 0){

105 printf("ERRORE! FALLIMENTO DELLA FORK\n");

106 }

107

108

109 else if(pid3 ==0){ //PROCESSO FIGLIO 3 -DISPARI-

110 printf("SONO IL PROCESSO figlio 3, CON PID:%d E CON PPID:%d\n",getpid(),getppid());

111 write(fdc2,&pid3,sizeof(int)); //DEVE SCRIVERE IL SUO PID NEL FILE

TESTO0,quindi richiamo pid1 è la scrivo

112 kill(pid2,SIGUSR1); //MANDO A PID0,CIOÈ AL PROCESSO1 IL SEGNALE

113 exit(0);

114

115 }

116

117

118 else{ //processo padre h

119

120

121

122

123

124 printf("SONO IL PADRE E TERMINO IL PROCESSO 0\n");

125 pid0= waitpid(pid0,&status,0);

126 printf("IL PROCESSO figlio 0, CON PID:%d E CON status:%d È TERMINATO\n",pid0,status);

127

128 printf("SONO IL PADRE E TERMINO IL PROCESSO 1\n");

129 pid1= waitpid(pid1,&status,0);

130 printf("IL PROCESSO figlio 1, CON PID:%d E CON status:%d È TERMINATO\n",pid1,status);

131

132 printf("SONO IL PADRE E TERMINO IL PROCESSO 2\n");

133 pid2= waitpid(pid2,&status,0);

134 printf("IL PROCESSO figlio 2, CON PID:%d E CON status:%d È TERMINATO\n",pid2,status);

135

136 printf("SONO IL PADRE E TERMINO IL PROCESSO 3\n");

137 pid3= waitpid(pid3,&status,0);

138 printf("IL PROCESSO figlio 3, CON PID:%d E CON status:%d È TERMINATO\n",pid3,status);

139

140 printf("PROGRAMMA TERMINATO !\n");

141

142 close(fdc1);

143 close(fdc2);

144 close(fdO1);

145 close(fdO2);

146

147

148

149

150

151

152

153 }

154

155 }

156 }

157

158

159

160

161

162

163 }

164

165

166 }

167

168

169

170

171 void SIGUSR1_handler(int sig){

172 printf("È ARRIVATO IL SEGNALE:%d AL PROCESSO CON PID:%d\n",sig,getpid());

173 }

174

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <signal.h>

4 #include <string.h>

5 #include <fcntl.h>

6 #include <unistd.h>

7 #include <sys/wait.h>

8 #include <sys/types.h>

9

10 /*Esercizio sulle system call

11 Scrivere un programma C con le seguente struttura:

12 -> un processo padre che effettua le seguenti attività nell’ordine:

13 - apre un file nuovo “dati.txt” in lettura e scrittura;

14 - apre una pipe;

15 - crea un processo figlio P0

16 - scrive una stringa letta da tastiera nel file;

17 - scrive nella pipe il numero di caratteri della stringa;

18 - invia un segnale SIGURS1 al figlio;

19 - attende la terminazione del processo Po;

20 *

21 -> il processo figlio Po dovrà effettuare le seguenti operazioni:

22 - attende un segnale di tipo SIGURS1;

23 - legge dalla pipe il numero di caratteri della stringa;

24 - legge la stringa da file e la visualizza a Video;

25 - chiude il file;

26 - termina l’esecuzione.

27 */

28 void signalHandler(int signal){

29 printf("S1-signal %d received\n",signal);

30

31 }

32

33 int main(){

34 pid_t son;

35 int pipecont [2];

36 int status_son;

37

38 int fd;//file descriptor

39 if ((fd=open("dati.txt",O_RDWR))<0){

40 printf("Cancello file precedente\n");

41 unlink("dati.txt");

42 close(fd);

43 fd=0;

44 }

45

46 if ((fd=open("dati.txt",O_CREAT|O_RDWR,0777))<0)

47 perror("Errore apertura file ");

48 else{

49 printf("F1-Apertura file fd:%d\n",fd);

50 }

51 if(pipe(pipecont)<0)

52 perror("Errore pipe ");

53 else printf("F2-Pipe Aperta\n");

54 son=fork();

55

56 if (!son){//son

57 signal(SIGUSR1,signalHandler);

58 pause();

59 int numchar;

60 close(pipecont[1]);

61 if (read(pipecont[0],&numchar,sizeof(numchar))<0)

62 perror("Errore lettura pipe\n");

63 else printf("S2-Ho letto dalla pipe:%d\n",numchar);

64 char testo[20];

65 lseek(fd,0,SEEK_SET);//posizioni il cursorea ll'inizio ora

66 if(read(fd,testo,sizeof(testo))<0)

67 perror("errore lettura file");

68 else printf("S3-Ho letto dal file:%s\n",testo);

69

70 if(close(fd)<0)

71 perror("errore chiusura file\n");

72 else printf("S4-Ho chiuso il file\n");

73

74 exit(0);

75 }

76 else if (son) {//father

77 printf("F3-Processo figlio creato da padrePID: %d\n",getpid());

78 char stringa[20];

79 int byteswritten=0;

80 //devo scrivere una stringa da tastiera in file

81 printf("F4 - Inserisci una stringa: ");

82 scanf("%s",stringa);

83 if((byteswritten=write(fd,stringa,strlen(stringa)))<0)

84 perror("Errore Scrittura");

85 else printf("F4-Ho scritto nel file (%s) nbytes:%d\n",stringa,byteswritten);

86 int i=0;

87 while(stringa[i]!='\0')

88 {

89 i++;

90 }

91 printf("F5-Il num caratteri inserito è: %d\n",i);

92 close(pipecont[0]);

93 if (write(pipecont[1],&i,sizeof(i))<0)

94 perror("Errore scrittura pipe\n");

95 else printf("F5-Ho scritto nella pipe: %d\n",i);

96 if(kill(son,SIGUSR1)<0)

97 perror("Error kill");

98 else printf("F6-Ho inviato il signal\n");

99

100 printf("F7-Attendo terminazione figlio\n");

101 waitpid(son,&status_son,0);

102 printf("F7-son terminated\n");

103 exit(0);

104 }

105

106 //exit(0);

107 }

108

1 PROVA SETTEMBRE 2015

2 un p legge da tastiera un intero n,crea n P figli , scrive tutti i pid dei figli in

un file figli.dat e invia SIGURS1 a tutti i figli; appena ricevuto il segnale dal

padre; P0 invia SIGUGURS2 a P2, che dopo averlo ricevuto lo invia al processo p di

indice pari;l'ultimo blocca la catena. lo stesso fanno i processi dispari a partire

da P1.

3

4 #include<librerie>

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

6 int fd=open("figli.dat",O_CREAT|O_TRUNC|O_RDWR,0777);

7 int N=atoi(argv[1]);

8 pid_t pid;

9 int Array[100];

10 char buffer1[100];

11 char buffer2[100];

12 sprintf(buffer2,"%d",N);//per portare anche N nell'eseguibile passandolo nel main

dell'exec

13 for(int i=0;i<st;i++){

14 pid=fork();

15 if(pid<0){

16 printf("errore fork");}

17 else if(pid==0){ //codice figlio i-simo

18 sprintf(buffer1,"%d",i);

19 char*argv[]={"file",buffer1,buffer2,(char*)0};

20 exec("file",argv);

21 exit(2);}

22 else{

23 write(fd,&pid,sizeof(int)); //salvo il pid del figlio i-simo nella i-sima posizione

dell'array

24 Array[i]=pid;}}

25 lseek(fd,0,SEEK_SET);

26 for (int i=0;i<N;i++){ //estraggo il pid dall'array e invio il segnale sigurs1 ,

solo doopo finito scrivere

27 pid=Array[i];

28 kill(pid,SIGURS1);}

29 exit(0);}

30

31 ESEGUIBILE FILE

32 #include<librerie>

33 void SIGURS1_handler(int);

34 void SIGURS2_handler(int);

35 int attesa=1;

36 int main(){

37 int i =atoi(buffer1);

38 int N =a<toi(buffer2);