1.Komentowanie programów

P.1

#include <stdio.h>
#include <unistd.h>
int main()
{
	//printf przeznaczony dla procesu macierzystego
	printf("Poczatek\n");

	//tworzenie potomka który będzie od tego momentu kontynuował program
	fork();

	//printf dla procesu macierzystego jak i potomnego dlatego "Koniec" jest wypisany 2 	razy
	printf("Koniec\n");
	return 0;
}

Wynik:

siara@siara-VirtualBox:~/Pulpit/termin 6$ gcc P1.c
siara@siara-VirtualBox:~/Pulpit/termin 6$ ./a.out
Poczatek
Koniec
Koniec

P.2
#include <stdio.h>
#include <unistd.h>
int main()
{
	//Wypisanie na ekran "Początek"
	printf("Poczatek\n");

	//zastąpienie procesu  innym, w tym przypadku procesem ls z parametrem -al
	execlp("ls", "ls", "-al", NULL);

	//przez zastąpienie programu innym procesu ta komenda jest nie użyta
	printf("Koniec\n");
	return 0;
}

Wyniki:

Poczatek
razem 36
drwxrwxr-x 2 siara siara 4096 maj 28 15:08 .
drwxr-xr-x 3 siara siara 4096 maj 28 14:56 ..
-rwxrwxr-x 1 siara siara 7194 maj 28 15:08 a.out
-rwxrwxr-x 1 siara siara 7194 maj 28 15:06 P1
-rw-rw-r-- 1 siara siara  139 maj 28 15:06 P1.c
-rw-rw-r-- 1 siara siara 1156 maj 28 15:06 P1.o
-rw-rw-r-- 1 siara siara  139 maj 28 15:06 P2.c

P.3

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{

	printf("Poczatek\n");
	//if który rozdziela instrukcje rodzica i potomka, fork() zwraca 0 dla potomka, sam 	fork 	//tworzy potomka
	if (fork() == 0)
	//child
	{
		//printf potomka
		printf("Child\n");

		//zastąpienie procesu potomnego procesem ls -a
		execlp("ls", "ls", "-a", NULL);

		//w przypadku błedu zostanie wysłany komunikat
		perror("Blad uruchmienia programu");

		//zamknięcie programu z kodem wyjścia 1
		exit(1);

	}
	else
	// parent
	{
		//printf rodzica
		printf("Parent\n");

		// proces macierzysty czeka, aż proces potomny skończy prace
		wait(NULL);

		//wypisaje na sam koniec wiadomość
		printf("Parent: koniec\n");
		return 0;
	}
}

Wyniki:
Poczatek
Parent
Child
.  ..  a.out  P1  P1.c	P1.o  P2  P2.c	P2.o  P3.c
Parent: koniec

P.4

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	// zadeklarowanie zmienny które będe przechowywać PID potomka
	pid_t pid1, pid2, status;

	//porzypisanie do pid1 PID potomka i jego utworzenie
	pid1 = fork();
	if (pid1 == 0)
	{
		printf("Child\n");
		//zakończenie procesu z kodem wyjścia = 7, zostanie on póżniej wyświetlony
		exit(7);

	}
	else
	{
		printf("Parent\n");
		//printf  wypisujący PID potomka
		printf("Mam potomka o identyfikatorze %d", pid1);

		//pjednoczesnie czeka na skonczenie pracy potomka i przypisuje jego PID do 		pid2
		pid2 = wait(&status);

		//wypisauje PID zamkniętego procesu potomnego oraz status jego zamknięcia
		printf(" Wartość zmiennej status: %d: %x\n", pid2, status);

		//wykona instrukcje jeżeli potomek zakończył proces przez wywołanie fukncji 		exit
		if(WIFEXITED(status))

		//zwraca status zakończenia potomka, w tym przypadku jest to 7
		printf("Status zakonczenia procesu %d\n", WEXITSTATUS(status));
		return 0;
	}
}

Wynik:
Parent
Child
Mam potomka o identyfikatorze 3064 Wartość zmiennej status: 3064: 700
Status zakonczenia procesu 7

P.5

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
int main()
{
	pid_t pid1, pid2, status;
	//przypisanie do pid1 PID procesu potomnego i jego utworzenie
	pid1 = fork();

	//instrukcje dla potomka
	if (pid1 == 0)
	{
		printf("Child\n");
		//działanie programu zostanie wstrzymane na 10s, w tym czasie proces zostanie 			//zakończony przez rodzinca komendą kill
		sleep(10);

		//nie zostanie użyte gdyż prędzej zostanie zakonczony proces
		exit(7);
	}
	//intrukcje dla rodzica
	else

	{
		printf("Parent\n");
		//wypisanie PID potomka
		printf("Mam potomka o identyfikatorze %d\n", pid1);

		//wysłanie komedy kill do zakmnięcia procesu potomnego o sygnale = 9
		kill(pid1, 9);

		//czeka na zakmnięcie procesu potomneog oraz przypisuje PID zamkniętego 			//procesu potomnego
		pid2 = wait(&status);



		//wyświetla PID zamkniętego procesu oraz status zamknięcia wysłąny z komedy 		kill
	printf("Wartość zmiennej status: %d: %x\n", pid2, status);


	//Jęzeli proces został zakmnięty w wyniku otrzymania synału (przez kill) wywoła 	isntrukcje
	if(WIFSIGNALED(status))

	//wypisze wartość sygnału który spowodował zamknięcie potomka
	printf("Status zakonczenia procesu w wyniku otrzymania sygnału o numerze: %d\n", 	WTERMSIG(status));
	return 0;
	}
}

Wynik:
Parent
Mam potomka o identyfikatorze 3302
Wartość zmiennej status: 3302: 9
Status zakonczenia procesu w wyniku otrzymania sygnału o numerze: 9

P.6

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
int main()
{
	//rodzice pisze "start" pierwszy
	printf("Parent: start\n");

	//instrukcje dla potomka i jego utworzenie
	if (fork() ==0)
	{
		//potomek wypisuje start odrazu po utworzeniu
		printf("Child: start\n");

		//czeka 30s, az rodzic skończy prace i zostaje procesem sierotą
		sleep(30);

		//po 30s wypisuje na zakończenie jako ostatni "end"
		printf("Child: end\n");
		exit(0);
	}
	//rodzic odrazu po utworzeniu potomka wypisuje "end"
	printf("Parent: end\n");

	//rodzic kończy prace i osieraca potomka
	exit(0);
}

Wynik:
Parent: start
Parent: end
Child: start
Child: end

P.7

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
int main()
{
	// jako pierwszy rodzic wypisuje "start"
	printf("Parent: start\n");
	if (fork() ==0)
	{

		//printf "Child: start" i "Child: end" potomka wypisane jedno pod drugim
		printf("Child: start\n");
		printf("Child: end\n");

		//zamknięcie procesu i wysłanie statusu zakończenia do rodzica
		exit(0);
	}
else
	{

		//rodzic zwleka 30s z odebraniem statusu zakończenia od potomka, tworząc 			proces-zombie
		sleep(30);
		printf("Parent: before wait()\n");

		//rodzic wreście odbiera status od potomka co usuwa proces-zombie
		wait(NULL);

		//wypisuje jako ostani "Parent: end"
		printf("Parent: end\n");
		exit(0);
	}
}

Wynik:
Parent: start
Child: start
Child: end
Parent: before wait()
Parent: end
2.Modyfikowanie programów

P.1

#include <stdio.h>
#include <unistd.h>
int main()
{
	//printf przeznaczony dla procesu macierzystego
	printf("Poczatek\n");

	//tworzenie potomka który nie zrobi nic i zakończy prace
	if(fork()==0)
	{
		    exit(0);
	}
	else
	//instrukcje dla rodzica
	{
		    printf("Koniec\n");
	}
	//printf dla procesu macierzystego jak i potomnego dlatego "Koniec" jest wypisany 2 	razy

	return 0;
	}

Wynik:
Poczatek
Koniec

P.2
A
#include <stdio.h>
#include <unistd.h>
int main()
{
	//Wypisanie na ekran "Początek"
	printf("Poczatek\n");

	//zastąpienie procesu  innym, w tym przypadku procesem ls z parametrem -al, przy 	//execl 	trzeba podać ścieżke do programu
	execl("/bin/ls", "ls", "-al", NULL);

	//przez zastąpienie programu innym procesu ta komenda jest nie użyta
	printf("Koniec\n");
	return 0;
}


Wynik:
Poczatek
razem 116
drwxrwxr-x 2 siara siara 4096 maj 28 17:54 .
drwxr-xr-x 3 siara siara 4096 maj 28 14:56 ..
-rwxrwxr-x 1 siara siara 7193 maj 28 17:54 a.out
-rwxrwxr-x 1 siara siara 7192 maj 28 17:48 P1
-rw-rw-r-- 1 siara siara  361 maj 28 17:48 P1.c
-rw-rw-r-- 1 siara siara 1100 maj 28 17:48 P1.o
-rwxrwxr-x 1 siara siara 7193 maj 28 17:54 P2
-rw-rw-r-- 1 siara siara  373 maj 28 17:54 P2.c
-rw-rw-r-- 1 siara siara 1164 maj 28 17:54 P2.o
-rwxrwxr-x 1 siara siara 7340 maj 28 15:57 P3
-rw-rw-r-- 1 siara siara  357 maj 28 15:57 P3.c
-rw-rw-r-- 1 siara siara 1432 maj 28 15:57 P3.o
-rwxrwxr-x 1 siara siara 7302 maj 28 15:58 P4
-rw-rw-r-- 1 siara siara  986 maj 28 15:57 P4.c
-rw-rw-r-- 1 siara siara 1472 maj 28 15:58 P4.o
-rwxrwxr-x 1 siara siara 7375 maj 28 16:39 P5
-rw-rw-r-- 1 siara siara 1273 maj 28 16:39 P5.c
-rw-rw-r-- 1 siara siara 1604 maj 28 16:39 P5.o
-rw-rw-r-- 1 siara siara  606 maj 28 16:39 P6.c
-rwxrwxr-x 1 siara siara 7301 maj 28 17:01 P7
-rw-rw-r-- 1 siara siara  699 maj 28 17:37 P7.c
-rw-rw-r-- 1 siara siara 1372 maj 28 17:01 P7.o

B

P2.c
#include <stdio.h>
#include <unistd.h>
int main()
{
	//Wypisanie na ekran "Początek"
	printf("Poczatek\n");

	//zastąpienie naszym własynm programem
	execl("/home/siara/Pulpit/termin 6/P2b",NULL, NULL);

	//przez zastąpienie programu innym procesu ta komenda jest nie użyta
	printf("Koniec\n");
	return 0;
}







P2b.c
#include <stdio.h>
#include <unistd.h>

int main()
{
    int i;
    //pętla wypisująca kolejne liczby
    for( i=1;i<11;i++)
    {
        printf("%d \n",i);
    }

}
Wynik:
Poczatek
1
2
3
4
5
6
7
8
9
10

P.3

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t pid1, pid2, pid3;

	pid1 = fork();
	if (pid1 == 0)
	{
  		  //pobranie pid potomka i pid rodzica za pomocą geterów
 		   pid2 = getpid();
 		   pid3 = getppid();

  		  //wypisanie PID i PPID
 		   printf("Child: PID potomka %d\n",pid2);
		    printf("Child: PPID potomka %d\n",pid3);
		    //child
 		   int i;

  		  //wypisanie w odstępak 1s printf
		    for(i=1;i<11;i++)
   		 {
   		  	   printf("Child: %d\n",i);
   		  	   sleep(1);
 		   }



  		  exit(1);
	}
	else
	// parent
	{
  		  //wypisanie PID potomka
  		  printf("Parent: PID potomka %d\n",pid1);
  		  int j;
  		  //pętla rodzica wypisująca w odstępach 1s wiadomości
 		   for(j=1;j<11;j++)
 		   {
    		   	 sleep(1);
     		   	printf("Parent: %d\n",j);

  		  }
   		 //czekanie aż potomek skończy prace, chociaż kończy ją wcześniej niż rodzic
  		  //uważam że nie ma to chyba znaczenia który program skończy prace  wcześniej
  		 wait(NULL);
   		 printf("Parent: koniec\n");
   		 return 0;
}
}
Wynik:
Parent: PID potomka 5686
Child: PID potomka 5686
Child: PPID potomka 5685
Child: 1
Parent: 1
Child: 2
Parent: 2
Child: 3
Parent: 3
Child: 4
Parent: 4
Child: 5
Parent: 5
Child: 6
Parent: 6
Child: 7
Parent: 7
Child: 8
Parent: 8
Child: 9
Parent: 9
Child: 10
Parent: 10
Parent: koniec

P.4

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
int main()
{
	//rodzic pisze "start" pierwszy
	printf("Parent: start\n");
	pid_t ppid;
	//instrukcje dla potomka i jego utworzenie
	if (fork() ==0)
	{
		    //potomek wypisuje start odrazu po utworzeniu
		    printf("Child: start\n");
		    ppid = getppid();
		    //czeka 10s, az rodzic skończy prace i zostaje procesem sierotą
		    sleep(10);
		    printf("Child: PPID %d\n",ppid);
		    sleep(30);
 		    ppid = getppid();
  		   printf("Child: nowe PPID %d\n",ppid);
  		   //po 30s wypisuje na zakończenie jako ostatni "end"
		    printf("Child: end\n");
		    exit(0);
	}
	//rodzic odrazu po utworzeniu potomka wypisuje "end"
	sleep(30);
	printf("Parent: end\n");

	//rodzic kończy prace i osieraca potomka
	exit(0);
}

Wynik:
Parent: start
Child: start
Child: PPID 5882
Parent: end
nowe PPID 1
Chil: end