initial commit

2026-05-26 13:56:03 +02:00
parent 4c720637a1
commit ff4bb12d22
539 changed files with 12415 additions and 0 deletions
@@ -0,0 +1,5 @@
+# UTC502-17-10-24
+
+## Notion de base sur les systemes d'exploitation
+
+Regardez le cour en pdf .. car la moi JPP de ce cour mdr.
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+typedef struct student {
+    char nom[10];
+    int note;
+} eleve;
+
+int main() {
+    int fd, i, ret;
+    eleve un_eleve;
+    const char *filename = "students.dat"; // Change the filename as needed
+
+    // Open the file for writing (create if it doesn't exist)
+    fd = open(filename, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
+    if (fd == -1) {
+        perror("prob open");
+        return 1;
+    }
+
+    // Write student records to the file
+    for (i = 0; i < 4; i++) {
+        printf("Donnez le nom de l’élève \n");
+        scanf("%s", un_eleve.nom);
+        printf("Donnez la note de l’élève \n");
+        scanf("%d", &un_eleve.note);
+        if (write(fd, &un_eleve, sizeof(eleve)) == -1) {
+            perror("prob write");
+            close(fd);
+            return 1;
+        }
+    }
+
+    // Move to the beginning of the file to read records
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret == -1) {
+        perror("prob lseek");
+        close(fd);
+        return 1;
+    }
+    printf("la nouvelle position est %d\n", ret);
+
+    // Read and display student records
+    for (i = 0; i < 4; i++) {
+        if (read(fd, &un_eleve, sizeof(eleve)) == -1) {
+            perror("prob read");
+            close(fd);
+            return 1;
+        }
+        printf("le nom et la note de l’élève sont %s, %d\n",
+               un_eleve.nom, un_eleve.note);
+    }
+
+    close(fd);
+    return 0;
+}
@@ -0,0 +1,49 @@
+/****************************************************************/
+/* Exemple de manipulation d’un fichier: */
+/* création, positionnement, fermeture */
+/****************************************************************/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+typedef struct student
+{
+    char nom[10];
+    int note;
+} eleve;
+int main() 
+{
+    
+    int fd, i, ret;
+    eleve un_eleve;
+    fd = open("./eleves.txt", O_CREAT | O_TRUNC | O_RDWR , S_IRUSR | S_IRGRP);
+    if (fd == -1)
+        perror("prob open");
+    i = 0;
+    while (i < 4)
+    {
+        printf("Donnez le nom de l’élève \n");
+        scanf("%s", un_eleve.nom);
+        printf("Donnez la note de l’élève \n");
+        scanf("%d", &un_eleve.note);
+        write(fd, &un_eleve, sizeof(eleve));
+        i = i + 1;
+    }
+    ret = lseek(fd, SEEK_SET, 0);
+    if (ret == -1)
+        perror("prob lseek");
+        printf("la nouvelle position est %d\n", ret);
+    i = 0;
+    while (i < 4)
+    {
+        read(fd, &un_eleve, sizeof(eleve));
+        printf("le nom et la note de l’élève sont %s, %d\n",
+               un_eleve.nom,
+               un_eleve.note);
+        i = i + 1;
+    }
+    close(fd);
+    return 0;
+
+}
@@ -0,0 +1,46 @@
+/****************************************************************/
+/* Exemple de manipulation d’un fichier: */
+/* création, positionnement, fermeture */
+/****************************************************************/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+typedef struct student {
+char nom[10];
+int note;
+} eleve;
+int main()
+{
+int fd, i, ret;
+eleve un_eleve;
+fd = open ("./eleve.txt", O_RDWR);
+if (fd == -1)
+perror ("prob open");
+i = 0;
+while (i<4)
+{
+printf ("Donnez le nom de l’élève \n");
+scanf ("%s", un_eleve.nom);
+printf ("Donnez la note de l’élève \n");
+scanf ("%d", &un_eleve.note);
+write (fd, &un_eleve, sizeof(eleve) );
+i = i + 1;
+}
+ret = lseek(fd, SEEK_SET, 0);
+if (ret==-1)
+perror ("prob lseek");
+printf ("la nouvelle position est %d\n", ret);
+i = 0;
+while(i<4)
+{
+read (fd, &un_eleve, sizeof(eleve));
+printf ("le nom et la note de l’élève sont %s, %d\n", 
+un_eleve.nom,
+un_eleve.note);
+i = i + 1;
+}
+close(fd);
+return 0;
+}
@@ -0,0 +1,51 @@
+/*
+Énoncé
+
+Écrire :
+
+- une fonction, nommée f1, se contentant d’afficher « bonjour » (elle ne possédera aucun argument, ni valeur de retour) ;
+- une fonction, nommée f2, qui affiche « bonjour » un nombre de fois égal à la valeur reçue en argument (int) et qui ne renvoie aucune valeur ;
+- une fonction, nommée f3, qui fait la même chose que f2, mais qui, de plus, renvoie la valeur (int) 0.
+
+Écrire un petit programme appelant successivement chacune de ces 3 fonctions, après les avoir convenablement déclarées (on ne fera aucune hypothèse sur les emplacements relatifs des différentes fonctions composant le fichier source).
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// Function declaration
+
+void f1();
+void f2(int nombreDeFoisBonjour);
+int f3(int nombreDeFoisBonjour);
+
+int main() {
+    f1();
+    f2(3);
+    f3(2);
+}
+
+// Fonction definition
+
+void f1(){
+    std::cout << "Bonjour \n" << std::ends;
+}
+
+void f2(int nombreDeFoisBonjour){
+
+    for(int i = 0; i < nombreDeFoisBonjour; i++){
+        std::cout << "Bonjour f2 \n" << std::ends;
+    }
+
+}
+
+int f3(int nombreDeFoisBonjour){
+
+    for(int i = 0; i < nombreDeFoisBonjour; i++){
+        std::cout << "Bonjour f3 \n" << std::ends;
+    }   
+    
+    return 0;
+    
+}
@@ -0,0 +1,47 @@
+/*
+Énoncé
+Quels résultats fournira ce programme :
+*/
+
+#include <iostream>
+using namespace std;
+int n = 10, q = 2;
+//int main()
+main()
+{
+    int fct(int);
+    void f(void);
+    int n = 0, p = 5;
+    n = fct(p);
+    cout << "A : dans main, n = " << n << " p = " << p
+         << " q = " << q << "\n";
+    f();
+}
+int fct(int p)
+{
+    int q;
+    q = 2 * p + n;
+    cout << "B : dans fct, n = " << n << " p = " << p
+         << " q = " << q << "\n";
+    return q;
+}
+void f(void)
+{
+    int p = q * n;
+    cout << "C : dans f, n = " << n << " p = " << p
+         << " q = " << q << "\n";
+}
+
+/*
+
+Résultat :
+
+B : dans fct, n = 10 p = 5 q = 20
+A : dans main, n = 20 p = 5 q = 2
+C : dans f, n = 10 p = 20 q = 2
+
+Un Warning avec le code tel quel tous de même :
+
+main() -> int main()
+
+*/
@@ -0,0 +1,57 @@
+/*
+Énoncé
+
+Écrire une fonction qui reçoit en arguments 2 nombres flottants et un caractère, et qui fournit un résultat correspondant à l’une des 4 opérations appliquées à ses deux premiers arguments, en fonction de la valeur du dernier, à savoir : addition pour le caractère +, soustraction pour -, multiplication pour * et division pour / (tout autre caractère que l’un des 4 cités sera interprété comme une addition). On ne tiendra pas compte des risques de division par zéro.
+
+Écrire un petit programme (main) utilisant cette fonction pour effectuer les 4 opérations sur les 2 nombres fournis en donnée. 
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// Function declaration
+
+void fonction1(float float1, float float2, char char1);
+
+int main(){
+
+    float float1;
+    float float2;
+    char char1;
+
+    cout<<"Tapez un premier entier : "; cin>>float1;
+    cout<<"Tapez un second entier : "; cin>>float2;
+    cout<<"Tapez l'opérations voulu : "; cin>>char1;
+
+    fonction1(float1, float2, char1);
+
+}
+
+// Fonction definition
+
+void fonction1(float float1, float float2, char char1){
+
+    switch (char1)
+    {
+    case '+':
+        std::cout << float1 + float2 << std::ends;
+            std::cout << "\n" << std::ends;
+        break;
+    case '-':
+        std::cout << float1 - float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    case '*':
+        std::cout << float1 * float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    case '/':
+        std::cout << float1 / float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    default:
+        std::cout << "nique ta mère \n" << std::ends;
+    }
+}
+
@@ -0,0 +1,59 @@
+/*
+
+Énoncé
+
+Transformer le programme (fonction + main) écrit dans l’exercice précédent de manière que la fonction ne dispose plus que de 2 arguments, le caractère indiquant la nature de l’opération à effectuer étant précisé, cette fois, à l’aide d’une variable globale.
+
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// variable globale 
+
+char operateur;
+
+// Function declaration
+
+void fonction1(float float1, float float2);
+
+int main(){
+
+    float float1;
+    float float2;
+
+    cout<<"Tapez un premier entier : "; cin>>float1;
+    cout<<"Tapez un second entier : "; cin>>float2;
+    cout<<"Tapez l'opérations voulu : "; cin>>::operateur;
+
+    fonction1(float1, float2);
+
+}
+
+// Fonction definition
+
+void fonction1(float float1, float float2){
+
+    switch (::operateur)
+    {
+    case '+':
+        std::cout << float1 + float2 << std::ends;
+            std::cout << "\n" << std::ends;
+        break;
+    case '-':
+        std::cout << float1 - float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    case '*':
+        std::cout << float1 * float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    case '/':
+        std::cout << float1 / float2 << std::ends;
+        std::cout << "\n" << std::ends;
+        break;
+    default:
+        std::cout << "nique ta mère \n" << std::ends;
+    }
+}
@@ -0,0 +1,43 @@
+/*
+
+Énoncé
+
+Écrire une fonction, sans argument ni valeur de retour, qui se contente d’afficher, à chaque appel, le nombre total de fois où elle a été appelée sous la forme :
+
+appel numéro 3
+
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// variable globale 
+
+int count = 0;
+
+// Function declaration
+
+void fonction1();
+
+int main(){
+
+    char input;
+    cout<<"Voulez vous appeler la fonction ? o/n : "; cin>>input;
+
+    while (input == 'o')
+    {
+        fonction1();
+        cout<<"Voulez vous de nouveau appeler la fonction ? o/n : "; cin>>input;
+    }
+
+    std::cout << "Vous avez tapez autre chose que 'o', Fin du programe \n" << std::ends;
+    return 0;
+}
+
+// Fonction definition
+
+void fonction1(){
+    ::count = ::count +1;
+    std::cout << "appel numéro " << ::count << "\n" << std::ends;
+}
@@ -0,0 +1,52 @@
+/*
+Énoncé
+
+Écrire 2 fonctions à un argument entier et une valeur de retour entière permettant de préciser si l’argument reçu est multiple de 2 (pour la première fonction) ou multiple de 3 (pour la seconde fonction).
+
+Utiliser ces deux fonctions dans un petit programme qui lit un nombre entier et qui précise s’il est pair, multiple de 3 et/ou multiple de 6, comme dans cet exemple (il y a deux exécutions) : 
+
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// variable globale 
+
+int count = 0;
+
+// Function declaration
+
+int estMultiple2(int n);
+int estMultiple3(int n);
+
+int main(){
+
+    int nombre(0);
+    cout << "Entrer un nombre : ";
+    cin >> nombre;
+    if (estMultiple2(nombre)) {
+            cout << "il est pair\n";
+            if (estMultiple3(nombre)) {
+                    cout << "il est multiple de 3 \n";
+                    cout << "il est divisible par 6\n";
+            }
+    }
+    else if (estMultiple3(nombre)) {
+            cout << "il est multiple de 3 \n";
+    }
+
+    return 0;
+}
+
+// Fonction definition
+
+int estMultiple2(int n){
+        if(n % 2 == 0) return 1;
+        else return 0;
+}
+
+int estMultiple3(int n){
+        if(n % 3 == 0) return 1;
+        else return 0;
+}
@@ -0,0 +1,32 @@
+/*
+
+Énoncé
+
+Écrire une fonction permettant d’ajouter une valeur fournie en argument à une variable fournie également en argument. Par exemple, l’appel (n et p étant entiers) :
+
+ajouter (2*p+1, n) ;
+
+ajoutera la valeur de l’expression 2*p+1 à la variable n.
+Écrire un petit programme de test de la fonction.
+
+*/
+
+#include <iostream>
+
+using namespace std;
+
+// Function declaration
+
+void ajouter(int p, int n);
+
+int main(){
+    ajouter(2*3+1, 2);
+}
+
+// Fonction definition
+
+void ajouter(int p, int n){
+    int toto = p + n; 
+    cout << toto << "\n";
+}
+
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# 1. Définissez une variable nommée Nom dont le contenu est ENI.
+Nom="ENI"
+# 2. Définissez une variable nommée Collection avec le contenu : Ressources Informatiques.
+Collection="Ressources Informatiques"
+# 3. Affichez la chaîne de caractères suivante : Les Editions ENI. Collection Ressources Informatiques. Utilisez vos deux variables Nom et Collection définies précédement.
+echo "Les Editions $Nom. Collection $Collection."
+# 4. Définissez une variable Var1 avec le contenu : bon.
+Var1="bon"
+# 5. Nous voulons afficher le mot : bonjour en se servent du contenu de la variable Var1. Laquelle des commandes suivantes devons-nous exécuter ?
+    # a. echo $Var1jour
+    # b. echo $(Var1)jour
+    # c. echo ${Var1}jour
+echo ${Var1}jour #réponse c
+# A quoi servent les accolades ? A quoi servent les parenthèses ?
+
+# 6. Exécutez les commandes suivantes (Aidez-vous de ce document) :
+
+# a. echo ${var2:?“var2 n'est pas encore définie”}
+# echo ${var2:?"var2 n'est pas encore définie"}
+# b. var2=Bonjour
+# c. echo ${var2:?“var2 n'est pas encore définie”}
+# d. echo ${lejour:=`date +%d`}
+# e. lejour=24
+# f. echo “Jour : ${lejour:+01}”
+
+#     Quel est l'intérêt de la première commande ?
+#     Quel est l'intérêt de la quatrième commande ?
+#     Quelle est la différencce entre la quatrième et la dernière commande ?
@@ -0,0 +1,12 @@
+#!/bin/bash
+ 
+# La première ligne indique au système que /bin/bash est le programme
+# shell à utiliser pour exécuter les commandes du script.
+ 
+# Affiche deux chaînes de caractères
+ 
+echo "Mon premier script shell"
+echo "Chaque ligne du fichier est une commande"
+ 
+# Le script retourne 0, valeur synonyme de succès.
+exit 0
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+echo -e $HOME "\nCeci est la variable globale HOME"
+echo -e $PATH "\nCeci est la variable globale PATH"
+echo -e $USER "\nCeci est la variable globale USER"
+echo -e $PWD "\nCeci est la variable globale PWD"
+
+# for i in $HOME $PATH $USER $PWD
+# do
+#     echo $i 
+# done
@@ -0,0 +1,63 @@
+Scripts simples - variables utilisateur et variables globales
+
+    Durée : 15 minutes
+
+1. Créez un alias cx dont le contenu permet de rendre un fichier exécutable. Comment pouvez-vous rendre cet alias permanent pour toutes les sessions ?
+2. Créez un fichier nommé affiche renfermant les commandes suivantes :
+
+```
+#!/bin/bash
+ 
+# La première ligne indique au système que /bin/bash est le programme
+# shell à utiliser pour exécuter les commandes du script.
+ 
+# Affiche deux chaînes de caractères
+ 
+echo "Mon premier script shell"
+echo "Chaque ligne du fichier est une commande"
+ 
+# Le script retourne 0, valeur synonyme de succès.
+exit 0
+```
+
+3. Après avoir saisi le script et l'avoir enregistré, n'oubliez pas de le rendre exécutable à l'aide de l'alias créé précédemment.
+
+cx affiche 
+
+4. Pour exécuter le script, tapez la commande suivante :
+
+./affiche 
+
+5. Créez un script nommé afficheVarEnv qui affiche le contenu des variables d'environnement suivantes : HOME, PATH, USER et PWD. Chaque contenu devra être précédé d'un commentaire correspondant à l'intitulé de la variable. Exécutez ce script.
+
+6. Créez un script nommé varLocGlob renfermant les commandes suivantes :
+
+```
+#!/bin/bash
+ 
+# Manipulation de variables locales et globales
+ 
+echo "Mon répertoire de connexion est : $HOME"
+echo "Mon nom de connexion est : $(logname) "
+echo "Nous sommes le : `date +%D`"
+ 
+Nom=Torvalds
+Prenom=Linus
+echo "Linux a été créé par $Nom $Prenom à l'université d'Helsinki."
+exit 0
+```
+⇒ Exécutez le script.
+
+7. Créez un script nommé varLocGlob1 qui effectue les opérations suivantes :
+
+    Affiche le contenu du répertoire coutant.
+    Affiche le shell de l'utilisateur.
+    Affiche le nom de la machine.
+    Définir une variable appelée os contenant le nom du système d'exploitation.
+    Définir une variable appelée ver contenant le numéro de version su système d'exploitation.
+    Afficher le contenu des deux variable os et ver.
+
+    Consultez la page du manuel de la commande alias.
+    Utilisez la commande chmod avec l'option adéquate.
+    Si vous n'avez pas de répertoire courant (.) dans votre PATH, le ./ devant le nom du script est indispensable, sinon il suffit de taper directement le nom du script.
+    Utiliszez la commande uname avec les options adéquates.
@@ -0,0 +1,12 @@
+#!/bin/bash
+ 
+# Manipulation de variables locales et globales
+ 
+echo "Mon répertoire de connexion est : $HOME"
+echo "Mon nom de connexion est : $(logname) "
+echo "Nous sommes le : `date +%D`"
+ 
+Nom=Torvalds
+Prenom=Linus
+echo "Linux a été créé par $Nom $Prenom à l'université d'Helsinki."
+exit 0
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+Message="Bonjour tout le monde"
+echo $Message
+
+# unset Message
+# echo $Message
+
+if [ $# == 2 ]
+then
+    echo "Seulement 2 arguments d'entrés"
+    exit 1
+elif [ $# != 3 ]
+then 
+    echo "Il n'y a pas 3 arguments"
+    exit 1
+else
+    echo "Les arguments sont '$1', '$2' et '$3'"
+fi
+
+Compteur=0
+
+for i in $1 $2 $3 
+
+do
+    ((Compteur++))
+
+    case "$i" in
+        "toto") echo "Vous avez entré l'argument toto" 
+    ;;
+        "tata") echo "Vous avez entré l'argument tata"
+    ;;
+        "titi") echo "Vous avez entré l'argument titi"
+    ;;
+        *) echo "Vous n'avez pas entré un des argument toto, tata ou titi mais l'argument $i pour l'argument $Compteur"
+    esac
+done
+
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+#  2. Créez un script nommé afficheRep qui affiche les caractèristiques et le contenu d'un répertoire dont le nom est donné en paramètre du script. 
+ls -l $1
@@ -0,0 +1,5 @@
+#! /bin/bash
+
+#  3. Créez un script nommé chercheUser qui cherche un utilisateur dont le nom de connexion est donné en paramètre du script. 
+
+cat /etc/passwd | grep $1
@@ -0,0 +1,37 @@
+#!/bin/bash 
+
+# Utilisation de la commande set
+ 
+# Première façon : set chaine_de_caracteres
+set Nom Prenom
+echo $1
+echo $2
+ 
+#set `commande`
+set `ls -ld /etc`
+echo "Resultat : $*"
+echo "Paramètre 1 de resultat : $1"
+echo "Paramètre 2 de resultat : $2"
+echo "Paramètre 3 de resultat : $3"
+echo "Paramètre 4 de resultat : $4"
+echo "Paramètre 5 de resultat : $5"
+echo "Paramètre 6 de resultat : $6"
+echo "Paramètre 7 de resultat : $7"
+echo "Paramètre 8 de resultat : $8"
+ 
+Horaire=$8
+ 
+# Rôle de la variable IFS
+set $Horaire
+echo "Paramètre 1 de $Horaire est : $1"
+echo "Paramètre 2 de $Horaire est : $2"
+ 
+# On modifie le séparateur de champs
+IFS=:
+echo "Le séparateur de paramètres est : $IFS"
+set $Horaire
+ 
+echo "Paramètre 1 : $1"
+echo "Paramètre 2 : $2"
+ 
+exit 0
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+#7. Créez un script nommé infoDate qui affiche la date sous la forme : nom_du_jour-mois-annee et l'heure sous la forme suivante : heures:minutes:secondes. Chaque affichage est précédé d'un libellé de votre choix.
+#⇒ Une seule commande est utilisée pour récupérer les informations demandées. 
+
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# 6. Créez un script nommé infoSys qui affiche les informations suivantes du système : 
+
+
+echo "Architecture matérielle : " `uname -i`
+echo "Nom de la machine : " `uname -n`
+echo "Nom du système d'exploitation : " `uname -s`
+echo "Version du noyau : " `uname -v`
@@ -0,0 +1,13 @@
+#! /bin/bash
+
+# parametres : Variables de paramètre ou de position
+ 
+echo "Nom du script en cours d'exécution : $0"
+echo "Nombre de paramètres transmis au script : $#"
+echo "Numéro du processus du script en cours d'exécution $0 est : $$"
+ 
+echo "Paramètre 1 du script $0 : $1"
+echo "Paramètre 2 du script $0 : $2"
+echo "Paramètre 3 du script $0 : $3"
+echo "Liste de tous les parametres du script $0 : $*"
+exit 0
@@ -0,0 +1,3 @@
+Salut 
+Ca va ?
+bloublou
@@ -0,0 +1,17 @@
+#! /bin/bash
+
+#    Affiche le contenu du répertoire courant.
+#    Affiche le shell de l'utilisateur.
+#    Affiche le nom de la machine.
+#    Définir une variable appelée os contenant le nom du système d'exploitation.
+#    Définir une variable appelée ver contenant le numéro de version du système d'exploitation.
+#    Afficher le contenu des deux variable os et ver.
+
+echo "Mon repertoir courant : "
+ls -l
+echo "Le shell de l'utilisateur est : $SHELL"
+echo "Le nom de ma machine est : $HOSTNAME"
+os=
+ver=
+echo $os
+echo $ver
@@ -0,0 +1,8 @@
+#! /bin/bash
+
+#  4. Créez un script nommé vi2 qui prend en argument un nom de fichier. Le script réalise une sauvegarde du fichier dans le répertoire /tmp avant de lancer l'éditeur de texte vi pour afficher et/ou modifier son contenu. Le fichier de sauvegarde aura comme nom nom_parametre_1.numero_processus_script_en_cours. 
+
+fichierAModifier=$1
+fichierSauvegarde=$1.$$
+cp $fichierAModifier /tmp/$fichierSauvegarde
+vi $fichierAModifier
@@ -0,0 +1,2 @@
+# UTC502-26-11-24
+
@@ -0,0 +1,53 @@
+# TD Sauvegarde :
+
+Mettre en place un système de sauvegarde simple
+Sauvegarde locale
+Nous allons maintenant voir comment mettre en place un système de sauvegarde simple locale. Pour cela, nous allons faire les choix suivants :
+utilisation de tar avec la compression bzip2 des données modifiées depuis moins de 24h ;·
+stockage sur une partition dédiée (autre que celle du système), ici hda10; ⚫ sauvegarde des dossiers/home et /etc.
+Pour cela, créez un fichier sauvegarde.sh ayant pour contenu :
+
+```
+#!/bin/sh
+#Script de sauvegarde
+#Dossiers à sauvegarder
+DATA_TO_BACKUP="/home/etc"
+#Partition recevant la sauvegarde
+BACKUP_DEV=/dev/hda10
+BACKUP_DIR=/sauvegarde
+#Montage de la partition de sauvegarde
+mount -t auto $BACKUP_DEV $BACKUP_DIR
+#Définition de la date du jour afin de pouvoir récupérer #1'année ($6), le mois ($2) et le jour ($3) pour nommer le fichier de sauvegarde
+set $(date)
+ave #Sauvegarde des données
+echo "Sauvegarde de $DATA_TO_BACKUP dans $BACKUP_DIR/svg_$6$2$3.tar.bz2" tar cvjf $BACKUP_DIR/svg $6$2$3.tar.bz2 --newer-mtime '1 day ago' $DATA_TO_
+BACKUP
+```
+
+Enregistrez le script dans le répertoire /usr/local/bin et rendez-le exécutable: chmod +x /usr/local/bin/sauvegarde.sh
+Pour l'utiliser, il suffira alors de saisir dans une console: sauvegarde.sh
+Sauvegarde à distance
+Nous allons maintenant reprendre l'exemple précédent avec les mêmes hypothè- ses, mais en outre nous allons envoyer le fichier de sauvegarde sur une machine distante. Nous allons utiliser deux systèmes différents : un premier avec l'utilisa- tion de ssh qui permet d'assurer un transfert sécurisé des données et un deuxième avec l'utilisation de ncftp pour envoyer l'archive sur un espace d'hébergement.
+Utiliser ssh. Si vous souhaitez et pouvez utiliser ssh avec la machine distante, le script devient donc :
+
+```
+#!/bin/sh
+#Script de sauvegarde
+#Dossiers à sauvegarder DATA_TO_BACKUP="/home /etc"
+#Partition recevant la sauvegarde BACKUP_DEV=/dev/hda10
+BACKUP_DIR=/sauvegarde
+#Définition des paramètres pour l'envoi à distance
+REMOTE_USER=backup
+REMOTE_COMPUTER=ip_ordinateur
+REMOTE_DIR=/home/backup/
+#Montage de la partition de sauvegarde
+mount -t auto $BACKUP_DEV $BACKUP_DIR
+#Définition de la date du jour afin de pouvoir récupérer
+#1'année ($6), le mois ($2) et le jour ($3) pour nommer le fichier de sauvegarde
+set $(date)
+#Sauvegarde des données
+echo "Sauvegarde de $DATA_TO_BACKUP dans $BACKUP_DIR/svg $6$2$3.tar.bz2" tar cvjf $BACKUP_DIR/svg $6$2$3.tar.bz2 --newer-mtime '1 day ago $DATA_TO_
+#Envoi de la sauvegarde sur la machine distante
+BACKUP
+scp $BACKUP_DIR/svg $6$2$3.tar.bz2 $REMOTE_USER@$REMOTE_COMPUTER: $REMOTE_DIR Il ne reste alors plus qu'à saisir le mot de passe demandé, mais si l'on veut utiliser ceci automatiquement, il faudra utiliser les phrases le système de clefs publique et privée de ssh. Ainsi il ne sera plus nécessaire de saisir de mot de passe.
+```
@@ -0,0 +1,87 @@
+#!/bin/bash
+#Script de restoration
+
+#Utilisateur du serveur destinataire de la sauvegarde :
+USER_DEST="user"
+
+#Serveur destinataire de la sauvegarde :
+ADDRESS_DEST="172.20.10.5" #adresse serveur distant
+
+#Dossier du serveur destinataire de la sauvegarde
+BACKUP_DIR_DEST="/home/user/rep_dest/"
+
+#Dossier local de la receprtion de la sauvegarder, à créer si il n'existe pas, a modifier selon l'utilisateur
+BACKUP_DIR="/home/nk/sauvegarde/"
+
+SEPARATOR="--------------------"
+
+#Début du script de restoration de /home
+echo $SEPARATOR
+echo "Debut du script de restauration de /home"
+echo $SEPARATOR
+
+#Tableau de la liste des fichiers de sauvegardes présentent sur le serveur dans /home/user/rep_dest/ 
+filesList=($(ssh $USER_DEST@$ADRESS_DEST ls $BACKUP_DIR_DEST))
+
+echo "Voici la liste des sauvegardes disponible sur $ADRESS_DEST dans le repertoir $BACKUP_DIR_DEST :"
+echo
+
+# Boucle For afin d'afficher les fichiers avec leur position dans le tableau devant :
+for (( i=0; i<${#filesList[@]}; i++ ))
+do
+    echo "$i-${filesList[$i]}"  # Premier fichier
+done
+
+echo
+echo $SEPARATOR
+
+# Un read pour que l'utilisateur puissent entrer le numero de la sauvegarde qu'il veut
+read -r -p "Choisir l'archive à restaurer : " numSauv
+echo $SEPARATOR
+
+#Place le nom de la sauvegarde voulu dans une variable OKZOU
+NAME_SAVE=${filesList[$numSauv]}
+echo "Vous avez choisi : $NAME_SAVE"
+echo $SEPARATOR
+
+# Je rentre dans un boucle "infini" mais controlé par une action utilisateur.
+while true; do
+
+    # Un read pour que l'utilisateur puisse confirmer si oui ou non il veut restaurer 
+    read -r -p "Lancer la restauration ? (o/n) " response
+    case "$response" in
+        [oO]|[yY]|oui|yes) 
+            # Récupération avec le protoclole ssh (commande scp) de la sauvegarde présente sur le serveur, vers notre pc
+            echo "Reception de $NAME_SAVE dans $BACKUP_DIR"
+            scp $USER_DEST@$ADRESS_DEST:$BACKUP_DIR_DEST$NAME_SAVE $BACKUP_DIR
+            echo $SEPARATOR
+
+            # Extraction de l'archive à la racine (donc /) pour recepecter la structure des répertoires d'un chemin
+            echo "Extraction de la sauvegarde"
+            tar xvjf $BACKUP_DIR$NAME_SAVE -C /
+            echo $SEPARATOR
+
+            # Petit Nettoayage de la sauvegarde présent sur notre pc
+            echo "Nettoayage de $NAME_SAVE"
+            rm $BACKUP_DIR$NAME_SAVE 
+
+            #Fin du script de Sauvegarde de /home
+            echo $SEPARATOR
+            echo "Fin du script de Restauration de /home"
+            echo $SEPARATOR
+            exit 0
+            ;;
+        [nN]|non|no)
+            #Fin du script de Sauvegarde de /home
+            echo $SEPARATOR
+            echo "Fin du script de Restauration de /home"
+            echo $SEPARATOR
+            exit 0
+            ;;
+        *) 
+            echo "Erreur, merci d'entrer o ou n"
+            ;;
+    esac
+done
+
+
@@ -0,0 +1,58 @@
+#!/bin/bash
+#Script de sauvegarde
+ 
+#Dossier à sauvegarder, a modifier selon l'utilisateur
+DATA_TO_BACKUP="/home/nk/rep_src/"
+
+#Dossier local de la création de la sauvegarder, a modifier selon l'utilisateur
+BACKUP_DIR="/home/nk/sauvegarde/"
+
+#Utilisateur du serveur destinataire de la sauvegarde :
+USER_DEST="user"
+
+#Serveur destinataire de la sauvegarde :
+ADDRESS_DEST="172.20.10.5" #adresse serveur distant
+
+#Dossier du serveur destinataire de la sauvegarde
+BACKUP_DIR_DEST="/home/user/rep_dest/"
+
+SEPARATOR="--------------------"
+
+#Définition de la date du jour afin de pouvoir récupérer (a adapter)
+#l'année ($3), le mois ($1) et le jour ($2) pour nommer le fichier de sauvegarde
+IFS=/
+set $(date +%D)
+annee=$3
+mois=$1
+jour=$2
+ 
+unset IFS
+
+#Début du script de Sauvegarde de /home
+echo $SEPARATOR
+echo "Debut du script de Sauvegarde de /home"
+ 
+#Sauvegarde des données
+echo $SEPARATOR
+echo "Sauvegarde de $DATA_TO_BACKUP dans $BACKUP_DIR/$BACKUP_FILE"
+tar cvjf $BACKUP_DIR/svg._$annee$mois$jour.tar.bz2 --newer-mtime '1 day ago' "$DATA_TO_BACKUP"
+
+#Envoie vers le serveur de sauvegarde 
+echo $SEPARATOR
+echo "Envoie de svg._$annee$mois$jour.tar.bz2 vers le serveur $USER_DEST@$ADRESS_DEST:$BACKUP_DIR_DEST"
+scp $BACKUP_DIR/svg._$annee$mois$jour.tar.bz2 $USER_DEST@$ADRESS_DEST:$BACKUP_DIR_DEST
+
+#Verification de la bonne reception
+echo $SEPARATOR
+echo "ls -l de $USER_DEST@$ADRESS_DEST:$BACKUP_DIR_DEST pour confirmer bonne reception :"
+ssh $USER_DEST@$ADRESS_DEST ls -l $BACKUP_DIR_DEST
+
+#Nettoyage de la sauvegarde local
+echo $SEPARATOR
+echo "Nettoyage de la sauvegarde local présente dans $BACKUP_DIR"
+rm -f $BACKUP_DIR/svg._$annee$mois$jour.tar.bz2
+
+#Fin du script de Sauvegarde de /home
+echo $SEPARATOR
+echo "Fin du script de Sauvegarde de /home"
+echo $SEPARATOR
@@ -0,0 +1,3 @@
+# UTC 502 28/11/2024
+
+
@@ -0,0 +1,9 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char ** argv){
+    //printf(":%!xxd (-r)");
+    system("wine /etc/Looping/Looping.exe");
+    return(EXIT_SUCCESS);
+}
@@ -0,0 +1,79 @@
+# UTC 502 17 12 24
+
+## Oronnancement sur l'unité centrale
+
+### A. Prolitique Premier Arrivé, Premier servi (First In, First Out)
+
+- Les processus sont élus selon l’ordre dans lequel ils 
+arrivent dans la file d’attente des processus prêts. 
+- Il n’y a pas de réquisition.
+- L’avantage de cette politique est sa simplicité.
+- Inconvénient : les processus de petit temps d’exécution 
+sont pénalisés en terme de temps de réponse par les 
+processus de grand temps d’exécution qui se trouvent 
+avant eux dans la file d’attente.
+
+### B. Politique Plus Court d’Abord
+
+- Le processus de plus petit temps d’exécution est celui qui est ordonnancé en premier. 
+- La politique est sans réquisition.
+- Remédie à l’inconvénient cité pour la politique précédente du « Premier Arrivé, Premier Servi ».
+- Politique est optimale dans le sens où elle permet d’obtenir le temps de réponse moyen minimal pour un 
+ensemble de processus donné.
+- La difficulté  : la connaissance a priori des temps d’exécution des processus.  Cette connaissance n’est pas 
+disponible dans un système interactif. 
+- Politique est essentiellement mise en œuvre dans les systèmes de traitement par lots.
+
+### C. Politique par priorité
+
+- La politique très courante.
+- Chaque processus possède une priorité, un nombre positif . Selon le système d’exploitation, une valeur basse est plus prioritaire qu’une valeur haute ou inversement.
+- Cette politique se décline en deux versions selon si la réquisition est autorisée ou non. La figure 16 donne un exemple d’application de cette politique en mode préemptif et en mode non préemptif.
+- Un inconvénient de cette politique est le risque de famine pour les processus de petite priorité si il y a de nombreux processus de haute priorité. On dit aussi qu’il y a coalition des processus de forte priorité contre les processus de faible priorité
+
+![figure_16.png](./16.png)
+
+### D. Politique du tourniquet (round robin)
+- Politique mise en œuvre dans les systèmes dits en temps partagé. 
+- Le temps est découpé en tranches nommées quantums de temps. 
+- Un processus est élu, il s’exécute au plus durant un quantum de temps.
+- Si le processus n’a pas terminé son exécution à l’issue du quantum de temps, il est préempté et il réintègre la file des processus prêts mais en fin de file.
+- Le processus en tête de file de la file des processus prêts est alors à son tour élu pour une durée égale à un quantum de temps.
+- La valeur du quantum constitue un facteur important de performance de la politique, elle influe directement sur le nombre de commutations de contexte.
+
+![figure_17.png](./17.png)
+
+### Exemples :
+
+#### Ordonnancement sous Unix
+- L’ordonnanceur Unix est un ordonnanceur de type tourniquet, avec plusieurs niveaux de priorités.
+- À un instant t, le processus élu est celui de plus forte priorité. 
+- Le système effectue un recalcul des priorités mettant en œuvre un principe d’extinction de priorité afin de garantir une équité d’accès au processeur.
+
+Exemple :
+
+- Supposons que toutes les secondes, le système recalcule les priorités des processus élus et prêts selon le principe suivant : 
+
+**Extinction** : compte_UC = compte_UC / 2 où compte_UC est le temps CPU consommé par le processus.
+
+**Priorité** = compte_UC/2 + 40 où 40 est une priorité de base de niveau utilisateur.
+
+Soient trois processus P1, P2 et P3, P1 de priorité 40 et P2, P3 de priorité 45. P1 s’exécute.
+
+Au bout d’1 seconde : 
+- Priorité P1 : compte_UC = 60/2 = 30 et priorité = 15 + 40 = 55
+- Priorité P2, inchangée : 45
+- Priorité P3, inchangée : 45
+- P2 est élu
+
+Au bout de 2 secondes : 
+- Priorité P1 : compte_UC = 30/2 = 15 et priorité = 7 + 40 =  47
+- Priorité P2 : compte_UC = 60/2 = 30 et priorité = 15 + 40 = 55
+- Priorité P3, inchangée : 45
+- P3 est élu
+
+Au bout de 3 secondes : 
+- Priorité P1 : compte_UC = 15/2 = 7 et priorité = 3 + 40 =  43
+- Priorité P2 : compte_UC = 30/2 = 15 et priorité = 17 + 40 = 47
+- Priorité P3 : compte_UC = 60/2 = 30 et priorité = 15 + 40 = 55
+- P1 est de nouveau élu
@@ -0,0 +1,133 @@
+# TD Processus et ordonnancement
+
+## A Processus Linux
+
+`essai.c :`
+
+```
+#include <stdio.h>
+#include <unistd.h>
+
+int main(){
+    
+    int pid;
+    pid = fork();
+    
+    if (pid == 0){for(;;)
+        printf ("je suis le fils\n");
+    }
+    else{for(;;)
+        printf("je suis le père\n");
+    }
+}
+```
+
+### 1) On compile ce programme pour générer un exécutable appelé essai dont on lance l’exécution. La commande ps –l permettant d’afficher les caractéristiques de l’ensemble des processus de l’utilisateur donne les éléments suivants :
+
+`./essai`
+
+
+```
+...
+
+je suis le père
+je suis le fils
+je suis le père
+je suis le fils
+je suis le père
+je suis le fils
+je suis le père
+je suis le fils
+je suis le père
+
+...
+```
+
+`ps -efl :`
+
+```
+user@debian-cli:~$ ps -efl | grep essai
+0 S user        4150    1942 12  80   0 -   615 file_t 09:25 pts/0    00:00:00 ./essai
+1 S user        4151    4150 12  80   0 -   615 wait_w 09:25 pts/0    00:00:00 ./essai
+0 S user        4153    4031  0  80   0 -  1583 pipe_r 09:25 pts/5    00:00:00 grep essai
+```
+
+`user@debian-cli:~$ kill -9 4151`
+
+`user@debian-cli:~$ ps -efl | grep essai`
+
+```
+...
+
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+je suis le père
+
+...
+```
+
+`user@debian-cli:~$ ps -efl | grep essai`
+```
+0 S user        4150    1942  7  80   0 -   615 wait_w 09:25 pts/0    00:00:36 ./essai
+1 Z user        4151    4150  5  80   0 -     0 -      09:25 pts/0    00:00:27 [essai] <defunct>
+0 S user        4249    4031  0  80   0 -  1583 pipe_r 09:34 pts/5    00:00:00 grep essai
+```
+
+### 3) Le programme essai.c est modifié :
+
+```
+#include <stdio.h>
+#include <unistd.h>
+
+int main(){
+    int pid;
+    pid = fork();
+    if (pid == 0){for(;;)
+        printf ("je suis le fils\n");
+    }
+    else{
+        printf("je suis le père\n");
+        int wait();
+    }
+}
+```
+
+`./essai2`
+
+```
+...
+
+je suis le fils
+je suis le fils
+je suis le fils
+je suis le fils
+je suis le fils
+je suis le fils
+je suis le fils
+
+...
+```
+
+`ps -lef | grep essai`
+
+```
+user@debian-cli:~/Documents/TD/TD_Processus_et_ordonnancement$ ps -lef | grep essai
+1 S user        4841    1519 17  80   0 -   615 wait_w 09:47 pts/5    00:00:05 ./essai2
+0 S user        4852    1942  0  80   0 -  1583 pipe_r 09:47 pts/0    00:00:00 grep essai
+```
+
+`kill -9 4841`
+
+`ps -lef | grep essai`
+
+```
+user@debian-cli:~/Documents/TD/TD_Processus_et_ordonnancement$ ps -lef | grep essai
+0 S user        4906    1942  0  80   0 -  1583 pipe_r 09:52 pts/0    00:00:00 grep essai
+```
+
@@ -0,0 +1,9 @@
+# UTC 502 Systeme
+
+***Principes fondamentaux des SE***
+
+* [Cours](./Cours/)
+* [17/10/24](./UTC502-17-10-24/)
+* [05/11/24](./UTC502-05-11-24)
+* [26/11/24](./UTC502-26-11-24)
+* [28/11/24](./UTC502-28-11-24)
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main()
+{
+int pid;
+pid = fork();
+if (pid == 0)
+ {for(;;)
+ printf ("je suis le fils\n");
+ }
+else
+ {for(;;)
+ printf("je suis le père\n");
+ }
+ return(EXIT_SUCCESS);
+}
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <unistd.h>
+
+int main()
+{
+int pid;
+pid = fork();
+if (pid == 0)
+ {for(;;)
+ printf ("je suis le fils\n");
+ }
+else
+ {for(;;)
+ printf("je suis le père\n");
+ }
+}