School-DUT-info/M311-Principes-des-systemes-d-exploitation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

p_fork ok

Browse Source
This commit is contained in:
srifi jose 2020-09-24 10:59:26 +02:00
parent 40b1703374
commit d54e5da572
14 changed files with 357 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/Makefile Normal file
View File

@ -0,0 +1,16 @@
CFLAGS = -Wall -g -std=gnu99
EXECUTABLES = demo_base \
demo_exit \
demo_sleep \
demo_fork \
demo_exec_scan \
demo_exec_arg \
demo_strtok
all : ${EXECUTABLES}
clean :
@rm -f core *.o *.out *~
@rm -f ${EXECUTABLES}

21
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_base.c Normal file
View File

@ -0,0 +1,21 @@
/**************************************/
/* demo_base : demonstration basique */
/**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <assert.h>
int main (int argc, char* argv[], char* envp[])
// argc = compteur d'arguments
// argv et envp = tableau de pointeurs de chaines
{
if (argc != 2){
fprintf(stdout, "\nSyntaxe : %s nom-de-variable\n\n", argv[0]);
exit (1);
}
printf ("\nProcessus %d (pere : %d) - 2eme mot ='%s'\n", getpid (), getppid (),
getenv(argv[1]));
return 0;
}

25
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_exec_arg.c Normal file
View File

@ -0,0 +1,25 @@
/*************************************************************/
/* demo_exec_arg : */
/* - Reservation de la place max des arguments */
/* (20 car.), */
/* - 1er paramètre = la commande a executer, */
/* - 2ème paramètre et suivant = paramètres de */
/* la commande */
/* - execution (avec prise en compte de la */
/* variable PATH). */
/*************************************************************/
#include <stdio.h>
#include <unistd.h>
int main (int argc, char* argv[])
{
char* argv2[argc];
int i;
printf(" argc=%i \n", argc);
for (i= 1; i <= argc; i++)
{
argv2[i-1] = argv[i];
printf(" argv[%i] = %s\n", i, argv2[i-1]);
}
execvp (argv2[0],argv2);
printf ("\nERREUR : execvp impossible\n");
}

22
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_exec_scan.c Normal file
View File

@ -0,0 +1,22 @@
/***************************************************************/
/* demo_exec_scan : */
/* - Reservation de la place max des arguments */
/* (30 car.), */
/* - lecture du nom de la commande a executer, */
/* - lecture d'un param. obligatoire, */
/* - execution (avec prise en compte de la */
/* variable PATH). */
/***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main ()
{ char *argv[3];
argv[0] = (char*) malloc(30); argv[1] = (char*)malloc(30);
printf ("Nom de la commande a executer : "); scanf ("%s", argv[0]);
printf ("Un argument (obligatoire) : "); scanf ("%s", argv[1]);
argv[2] = (char*)0;
execvp (argv[0],argv);
printf ("\nERREUR : execvp impossible\n");
}

18
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_exit.c Normal file
View File

@ -0,0 +1,18 @@
/*************************************************/
/* demo_exit : envoi d'un code de retour */
/*************************************************/
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[])
{
if (argc != 2) {fprintf (stderr, "Syntaxe : %s code-de-retour \n", argv[0]); exit(-1);}
exit (atoi (argv[1]));
}
/// Par exemple, tester en bash avec :
/// if ./demo_exit 3 ; then echo OK ; else echo KO ; fi
/// Puis avec .\demo_exit 0 ...

13
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_fork.c Normal file
View File

@ -0,0 +1,13 @@
/******************************************************/
/* demo_fork : Ce programme illustre le mecanisme de */
/* duplication d'images de LINUX. */
/******************************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{ int res;
res = fork();
if (res == -1) {perror ("demo_fork - fork"); exit (1);}
printf ("\nProcessus %d (pere : %d) - res ='%d'\n", getpid (), getppid (), res);
}

23
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_sleep.c Normal file
View File

@ -0,0 +1,23 @@
/*************************************************/
/* demo_sleep : Utilisation de "sleep" */
/*************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
int main (int argc, char* argv[])
/* argc : compteur d'arguments */
/* argv : tableau de pointeurs de chaines */
{
if (argc != 2)
{
fprintf (stderr, "Syntaxe : %s duree-du-sleep\n", argv[0]);
exit (1);
}
printf("\n%s (Pid = %d): Regardez-moi avec ps ... Je m'endors %s secondes.\n",
argv[0], getpid(),argv[1]);
sleep (atoi(argv[1]));
printf("%s (Pid = %d): Je me reveille après %s secondes.\n\n",
argv[0], getpid(), argv[1]);
}

20
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/demo_strtok.c Normal file
View File

@ -0,0 +1,20 @@
/// M311 - demonstration : gets, strtok
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
int main()
{
char *mot;
char *ligne = malloc (80);
ligne = fgets (ligne, 80, stdin);
printf("===%s===\n", ligne);
mot = strtok (ligne, " ");
while (mot != NULL)
{
printf("%s\n", mot);
mot = strtok (NULL, " ");
}
return 0;
}

23
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_fichier.c Normal file
View File

@ -0,0 +1,23 @@
/*******************************************************/
/* p_fichier: Ce programme crée un nouveau */
/* processus avec fork */
/* - Le processus pere ouvre un nouveau fichier en */
/* création de nom donné en argument */
/* - Le processus fils écrit une chaine donnee en */
/* argument dans le fichier puis meurt */
/* - Le processus pere affiche le fichier puis meurt */
/* */
/* syntaxe : p_fichier fichier chaine */
/*******************************************************/
#include <stdio.h>
int main (int argc, char* argv[]) {
if (argc != 3) fprintf (stderr, "\nSyntaxe: %s <fichier> <chaine>\n\n", argv[0]);
/**********************/
/* PARTIE A COMPLETER */
/**********************/
}

58
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_fork.c Normal file
View File

@ -0,0 +1,58 @@
/*******************************************************/ /* */
/* p_fork : Ce programme illustre le mecanisme de */
/* duplication de processus de LINUX. */
/* Le processus pere affiche N etoiles, alors */
/* que le processus fils affiche N slashs. */
/* La valeur de N est transmise en premier argument */
/* de la commande. */
/* */
/*******************************************************/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
/**********************/
/* PARTIE A COMPLETER */
/**********************/
int res = fork();
int max = atoi(argv[1]);
if (res < 0)
{
printf("ERREUR FORK\n");
}
else
{
if (res == 0)
{ /************************** FILS ***********************/
printf("Je suis le fils :\n");
printf("pid : %d\n", getpid());
printf("ppid : %d\n", getppid());
for (int i = 0; i < max; i++)
{
printf("/");
}
printf("\n\n");
}
else
{ /************************** PERE ***********************/
printf("Je suis le père :\n");
printf("pid : %d\n", getpid());
printf("ppid : %d\n", getppid());
for (int i = 0; i < max; i++)
{
printf("*");
}
printf("\n\n");
}
}
return 0;
}

41
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_fork_exec.c Normal file
View File

@ -0,0 +1,41 @@
/*********************************************************/
/* */
/* p_fork_exec : Prototype extremement simplifie d' une */
/* boucle de SHELL : */
/* - Le pere lit une commande a executer (fait) */
/* - Le pere se duplique et attend la fin du fils */
/* - Le pere affiche OK si le fils s'est "bien" fini */
/* (exit avec 0) et KO sinon. */
/* et KO sinon. */
/* - Le fils execute la commande lue par le pere */
/* (avec utilisation de la variable PATH). */
/* */
/*********************************************************/
#include <stdio.h>
#include <stdlib.h>
int main ()
{ char *arguments[3];
arguments[0] = (char*) malloc(30);
arguments[1] = (char*) malloc(30);
printf ("\n=============================\n");
printf (" BIENVENUE SOUS p_fork_exec \n");
printf ("=============================\n\n");
printf ("? Nom de la commande a executer : "); scanf ("%s", arguments[0]);
printf ("? Un argument (obligatoire) : "); scanf ("%s", arguments[1]);
arguments[2] = (char*)0;
/**********************/
/* PARTIE A COMPLETER */
/**********************/
printf ("\n==============================\n");
printf (" p_fork_exec: FIN DE SESSION \n");
printf ("==============================\n\n");
}

20
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_fork_wait.c Normal file
View File

@ -0,0 +1,20 @@
/*******************************************************/ /* */
/* p_fork_wait : Ce programme illustre le mecanisme */
/* de duplication de processus de LINUX. */
/* Le processus fils affiche N slashs,pendant */
/* que le père attend la fin du fils pour afficher */
/* un message de fin. */
/* La valeur de N est transmise en premier argument */
/* de la commande. */
/* */
/*******************************************************/
#include <stdio.h>
int main (int argc, char* argv[]) {
/**********************/
/* PARTIE A COMPLETER */
/**********************/
}

26
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_fork_wait_exit.c Normal file
View File

@ -0,0 +1,26 @@
/*******************************************************/ /* */
/* p_fork_wait_exit : Ce programme illustre le */
/* mecanisme de duplication de processus */
/* de LINUX. */
/* Le processus pere attend le fils. */
/* Le processus fils dort quelques secondes puis ... */
/* Le processus fils affiche un message puis retourne */
/* un code de retour pris dans argv[1]. */
/* Le pere affiche "Operation reussie" si le fils */
/* s'est bien terminé, et "Echec d'operation" sinon. */
/* */
/* Convention : "bien terminé" == (code de retour == 0)*/
/* */
/* Technique : Utiliser wait (adresse) et WEXITSTATUS */
/* */
/*******************************************************/
#include <stdio.h>
int main (int argc, char* argv[]) {
/**********************/
/* PARTIE A COMPLETER */
/**********************/
}

31
2020-2021/S3T_TP_03_PROCESSUS-2-PROG/Demonstrations_a_etudier/p_system.c Normal file
View File

@ -0,0 +1,31 @@
/*******************************************************/ /* */
/* p_system : Ce programme définit une fonction */
/* "p_system" qui reproduit le fonctionnement */
/* de la routine system(3). */
/* */
/*******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
int p_system (char* commande){
printf ("Execution de p_system avec : %s\n", commande);
/**********************/
/* PARTIE A COMPLETER */
/**********************/
return 0; // A modifier ...
}
int main(int argc, char * argv[]){
int res;
if (argc != 2) {
fprintf (stderr, "\nSyntaxe : %s \"une ligne de commande\"\n\n", argv[0]); exit (1);}
res = p_system (argv[1]);
printf ("Code de retour : %d\n", res);
}