Linux, C, C++ Unix System Functions

Linux/C fork() exec()

Concept de processus

Changement de processus

États d'un processus

Visualisation des processus

Création de processus

Fin du processus

Fonction exec()

Communication entre processus

Variables d'environnement

Linux/C : fonction waitpid()

• WIFEXITED(status) : renvoie une valeur non nulle si le processus fils s'est terminé normalement.

• WEXITSTATUS(status) : renvoie le code de sortie du processus fils si celui-ci s'est terminé normalement.

• WIFSIGNALED(status) : renvoie une valeur non nulle si le processus fils s'est terminé à cause d'un signal.

• WTERMSIG(status) : renvoie le numéro de signal qui a causé la terminaison du processus fils.

• WIFSTOPPED(status) : renvoie une valeur non nulle si le processus fils a été suspendu.

• WSTOPSIG(status) : renvoie le numéro de signal qui a causé la suspension du processus fils.

• WIFCONTINUED(status) : renvoie une valeur non nulle si le processus fils a été repris.

           = WNOHANG, retourne immédiatement s'il n'y a aucun processus fils terminé, sans attendre

Signaux Linux

Concept de signal

Commandes shell

C/C++ POSIX

Fonction sigaction

#include <signal.h>

struct sigaction{
void (*sa_handler) (int);
void  (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
}

#include <signal.h>
#include <iostream>
using namespace std;

// Compteur global
int cpt = 0;
// Fonction à remplacer
void fct(int s){
  cpt++;
  cout << "M’enfin ! (" << cpt << ")"<< endl;
  if (cpt == 10) {
    cout << "Aie !!!" << endl;
    exit(EXIT_SUCCESS);
  }
}

int main(void) {
  // Installation du gestionnaire pour SIGINT (Ctrl+c)
  struct sigaction s;// this is the default
  if( sigaction(SIGINT, NULL, &s) == -1 ) exit(EXIT_FAILURE);
  s.sa_handler = fct;// replace the default by fct
  if( sigaction(SIGINT, &s, NULL) == -1 ) exit(EXIT_FAILURE);
  while(1) {
    cout << "RRRRR..." << endl;
    sleep(1);
  }
  return EXIT_SUCCESS;
}

Fonction alarm

Linux/C : ouverture, lecture et écriture de fichiers

Appels système (POSIX)

int open(const char * pathname, int flags)

ssize_t read(int fd, void *buf, size_t count);

ssize_t write(int fd, const void *buf, size_t count);

int close(int fd);

Exemple de lecture/écriture de fichier en C++ :

#include <iostream>
#include <string>

//strerror
#include <errno.h>

//read write close
#include <unistd.h>

//open
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

using namespace std;

#define LEN 16
int main(int argc, char * argv[]){
  int fd = open(argv[1], O_RDONLY);
  if(fd == -1){
    cerr << "Impossible d'ouvirir" << argv[1] << "en lecture" << endl;
    return EXIT_FAILURE;
  }
  char buf[LEN];

  int nbrd = read(fd, buf, LEN);
  while(nbrd > 0){
    int nbwr = 0;
    int nbr = nbrd;
    //les caractères lus ne peuvent pas être écrits en une seule fois
    while(nbr > 0){
        int nb = write(STDOUT_FILENO, buf+nbwr, nbr);
        if(nb < 0){
          cerr << "error quand on écrire" << endl;
          return 1;
        }
        nbwr += nb;
        nbr -= nb;
    }
    nbrd = read(fd, buf, LEN);
  }
  if(nbrd < 0){
    cerr << "error quand on lire" << endl;
    return 1;
  }
  close(fd);
  return 0;
}

Linux/C : utilisation de creat()

• S_IRUSR: lecture par l'utilisateur. Le propriétaire du fichier peut lire le fichier.

• S_IWUSR: écriture par l'utilisateur. Le propriétaire du fichier peut écrire dans le fichier.

• S_IXUSR: exécution par l'utilisateur. Le propriétaire du fichier peut exécuter le fichier.

• S_IRGRP: lecture par le groupe. Les membres du groupe du fichier peuvent lire le fichier.

• S_IWGRP: écriture par le groupe. Les membres du groupe du fichier peuvent écrire dans le fichier.

• S_IXGRP: exécution par le groupe. Les membres du groupe du fichier peuvent exécuter le fichier.

• S_IROTH: lecture par les autres utilisateurs. Les autres utilisateurs peuvent lire le fichier.

• S_IWOTH: écriture par les autres utilisateurs. Les autres utilisateurs peuvent écrire dans le fichier.

• S_IXOTH: exécution par les autres utilisateurs. Les autres utilisateurs peuvent exécuter le fichier.

• S_ISUID: définit l'ID utilisateur. Lorsque ce drapeau est activé, l'ID utilisateur effectif du processus exécutant le fichier est défini sur l'ID utilisateur du propriétaire du fichier.

• S_ISGID: définit l'ID de groupe. Lorsque ce drapeau est activé, l'ID de groupe effectif du processus exécutant le fichier est défini sur l'ID de groupe du fichier.

• S_ISVTX: bit collant. Ce drapeau est principalement utilisé pour les fichiers de répertoire. Si un fichier de répertoire a ce drapeau, seul le propriétaire du fichier peut créer, supprimer ou déplacer des fichiers dans ce répertoire, les autres utilisateurs ne le peuvent pas.

Linux/C : utilisation de rename()

• Si oldname et newname sont tous deux des répertoires, le répertoire est renommé.

• Si le répertoire spécifié par newname existe et est un répertoire vide, il est d'abord supprimé.

• Pour les deux répertoires newname et oldname, le processus appelant doit avoir des droits d'écriture.

• Lors du renommage d'un répertoire, newname ne peut pas inclure oldname en tant que préfixe de chemin. Par exemple, il n'est pas possible de renommer /usr en /usr/foo/testdir, car l'ancien nom (/usr/foo) est un préfixe du nouveau nom, il ne peut donc pas être supprimé.

Linux/C : utilisation de system()

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
int main ()
{
char command[50];
strcpy( command, "ls -l" );
system(command);
return(0);
}

Linux/C : utilisation de sprintf()

• str -- C'est un pointeur vers un tableau de caractères qui stocke la chaîne C.

• format -- C'est une chaîne qui contient le texte à écrire dans la chaîne str. Il peut contenir des balises de format intégrées, les balises de format peuvent être remplacées par des valeurs spécifiées ultérieurement dans les arguments supplémentaires en fonction des besoins. Les propriétés des balises de format sont %[flags][width][.precision][length]specifier, expliquées ci-dessous :

#include <stdio.h>
#include <math.h>

int main()
{
   char str[80];

   sprintf(str, "La valeur de Pi est = %f", M_PI);
   puts(str);

   return(0);
}

Linux/C : utilisation de lseek()

  SEEK_SET : début du fichier

  SEEK_CUR : position actuelle du fichier

  SEEK_END : fin du fichier

Linux/C : execve()

1. Lorsqu'un processus n'a plus besoin de s'exécuter, il peut utiliser une fonction de la famille exec pour continuer à s'exécuter.

2. Si un processus souhaite exécuter un autre programme exécutable, il peut utiliser la fonction fork pour d'abord créer un processus fils, puis utiliser le processus fils pour appeler la fonction exec afin d'implémenter la fonctionnalité du programme exécutable.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
	char *argv[] = {"ls", "-l", NULL};
	char *envp[] = {NULL};
	if (execve("/bin/ls", argv, envp) < 0)
	{
		perror("execve error");
		exit(1);
	}
	return 0;
}

Linux/C: Pipe

Pipe

#include <unistd.h>

int main(void)
{
    int n;
    int fd[2];
    pid_t pid;
    char line[MAXLINE];

    if(pipe(fd) != 0){                 /* Créez d'abord un pipe pour obtenir une paire de descripteurs de fichiers */
        exit(0);
    }

    if((pid = fork()) < 0)            /* Le processus parent copie le descripteur de fichier pour le processus fils */
        exit(1);
    else if(pid > 0){                /* parent écrit */
        close(fd[0]);                /* Ferme le descripteur de lecture */
        write(fd[1], "\\nhello world\\n", 14);
    }
    else{                            /* enfant lit */
        close(fd[1]);                /* Ferme l'extrémité d'écriture */
        n = read(fd[0], line, MAXLINE);
        write(STDOUT_FILENO, line, n);
    }

    exit(0);
}

FIFO (Named Pipe)

// FIFOwrite.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
    int fd;
    int ret;
    ret = mkfifo("my_fifo", 0666); // Créez une FIFO nommée
    if(ret != 0)
    {
        perror("mkfifo");
    }
    fd = open("my_fifo", O_WRONLY); // En attente de lecture
    if(fd < 0)
    {
        perror("open fifo");
    }
    char send[100] = "Hello World";
    write(fd, send, strlen(send));  // Écrire des données
    printf("write to my_fifo buf=%s\\n",send);
    while(1); // Bloquer, assurez-vous que les processus de lecture et d'écriture sont en communication
    close(fd);
    return 0;
}

// FIFOread.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
    int fd;
    int ret;
    ret = mkfifo("my_fifo", 0666); // Créez une FIFO nommée
    if(ret != 0)
    {
        perror("mkfifo");
    }
    fd = open("my_fifo", O_RDONLY); // En attente d'écriture
    if(fd < 0)
    {
        perror("open fifo");
    }
    while(1)
    {
        char recv[100] = {0};
        read(fd, recv, sizeof(recv)); // Lire des données
        printf("read from my_fifo buf=[%s]\\n", recv);
        sleep(1);
    }
    close(fd);
    return 0;
}

1. Le pipe est un tampon circulaire qui permet à deux processus de communiquer selon le modèle producteur-consommateur. Il s'agit d'une file d'attente de type FIFO (premier entré, premier sorti), où un processus écrit et un autre processus lit.

2. Le pipe a une taille fixe en nombre d'octets lors de sa création. Lorsqu'un processus essaie d'écrire dans le pipe et qu'il y a suffisamment d'espace, la demande d'écriture est exécutée immédiatement ; sinon, le processus est bloqué. Si un processus essaie de lire plus d'octets que le nombre d'octets actuellement présents dans le pipe, il est également bloqué.

3. Le système d'exploitation applique la mutual exclusion, un seul processus peut accéder au pipe à la fois.

4. Seuls les processus ayant une parenté (relation père-fils) peuvent partager un pipe anonyme, les processus non apparentés ne peuvent partager qu'un pipe nommé.

5. Les principaux usages du pipe nommé sont les suivants :

Linux/C : mkdir() Usage

Linux/C : thread

Description des threads:

Dépendances de l'en-tête:

Compilation avec GCC:

Création de threads:

Linux/C : thread

Description des threads :

Dépendances des fichiers d'en-tête :

Compilation avec GCC :

Création de threads :

• EAGAIN : Les ressources système sont insuffisantes pour fournir les ressources nécessaires à la création du thread.

• EINVAL : L'argument attr passé à la fonction pthread_create() est invalide.

• EPERM : Dans l'argument attr passé à la fonction pthread_create(), certaines des propriétés sont configurées pour une opération illégale et le programme n'a pas les autorisations appropriées pour cette configuration.

#include<stdlib.h>
#include<stdio.h>
#include<pthread.h>

void* myfunc(void* args){
    int i;
    for(i = 0; i < 50; i++){
        printf("%d\\n", i);
    }
    return NULL;
}

int main(){
    pthread_t th1;

    pthread_create(&th1, NULL, myfunc, NULL);

    pthread_join(th1, NULL);

    return 0;
}

Attendre un thread :

Quitter un thread :

Annuler un thread :

Linux/C : Mutex:

1. Structures de données : telles que des listes chaînées, des files d'attente, des piles, etc., qui peuvent être partagées entre plusieurs threads.

2. Accès aux fichiers ou aux bases de données : lorsqu'il y a plusieurs threads nécessitant l'accès en lecture ou en écriture à un même fichier ou à une même base de données, il est nécessaire de verrouiller l'accès pour garantir la cohérence des données.

3. Accès aux périphériques ou aux ressources externes : par exemple, lorsqu'il y a plusieurs threads nécessitant l'accès à un même périphérique matériel ou à une même connexion réseau, il peut être nécessaire d'utiliser un verrou pour éviter les conflits.

• Le paramètre mutex représente le mutex à initialiser ;

• Le paramètre attr est utilisé pour personnaliser les attributs du mutex nouvellement créé. Lorsque la valeur de attr est NULL, cela indique la création du mutex avec les attributs par défaut.

• Le paramètre mutex représente le mutex sur lequel nous voulons effectuer des opérations. Lorsque la fonction réussit, elle renvoie 0. Sinon, elle renvoie un nombre non nul.

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
int ticket_sum = 10;
// Créer un mutex
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
// Simuler la vente de billets par le vendeur
void *sell_ticket(void *arg) {
    // Afficher l'ID du thread en cours d'exécution
    printf("ID du thread en cours d'exécution : %u\\n", pthread_self());
    int i;
    int islock = 0;
    for (i = 0; i < 10; i++)
    {
        // Verrouiller le mutex actuel
        islock = pthread_mutex_lock(&myMutex);
        // Si la lock réussit, exécuter le code ci-dessous
        if (islock == 0) {
            // Si le nombre de billets > 0, commencez à vendre des billets
            if (ticket_sum > 0)
            {
                sleep(1);
                printf("%u Vendre le %d billet\\n", pthread_self(), 10 - ticket_sum + 1);
                ticket_sum--;
            }
            // Simulation de la fin du processus de vente de billets du thread actuel, effectuer l'opération de "déverrouillage"
            pthread_mutex_unlock(&myMutex);
        }
    }
    return 0;
}

int main() {
    int flag;
    int i;
    void *ans;
    // Créer 4 threads pour simuler 4 vendeurs
    pthread_t tids[4];
    for (i = 0; i < 4; i++)
    {
        flag = pthread_create(&tids[i], NULL, &sell_ticket, NULL);
        if (flag != 0) {
            printf("Erreur lors de la création du thread !");
            return 0;
        }
    }
    sleep(10);   // Attendez que les 4 threads se terminent
    for (i = 0; i < 4; i++)
    {
        // Bloquer le thread principal jusqu'à ce que les 4 threads se terminent
        flag = pthread_join(tids[i], &ans);
        if (flag != 0) {
            printf("tid=%d attente échouée !", tids[i]);
            return 0;
        }
    }
    return 0;
}

Linux/C : Condition Variable (Variable Conditionnelle)

Déclaration de la variable conditionnelle :

Initialisation de la variable conditionnelle :

Attente bloquante du thread pour un signal :

Réveiller un thread bloqué :

Linux/C : Socket

Création d'un socket (sock()) :

Configuration de l'adresse du socket:

struct sockaddr_in {
    short int sin_family;         // AF_INET
    unsigned short int sin_port;  // Numéro de port
    struct in_addr  sin_addr;     // Adresse IP
};

struct sockaddr_in6 {
    sa_family_t     sin6_family;   // Famille d'adresses (AF_INET6)
    in_port_t       sin6_port;     // Numéro de port (16 bits, ordre des octets réseau)
    uint32_t        sin6_flowinfo; // Informations de flux IPv6
    struct in6_addr sin6_addr;     // Adresse IPv6
    uint32_t        sin6_scope_id; // ID de portée utilisé pour traiter les adresses IPv6 avec portée
};

#include<netinet/in.h>

struct sockaddr_un {
    sa_family_t sun_family;     // AF_UNIX ou AF_LOCAL
    char sun_path[108];         // Chemin du socket Unix
};

#include<sys/un.h>

Liaison du socket bind():

Écoute des connexions listen():

Accepter les connexions accept():

Connexion connect():

Envoi et réception de chaînes:

Diagramme de flux de socket TCP:

Linux/C : Sémaphore

Déclaration d'un sémaphore:

Initialisation d'un sémaphore:

Décrémentation d'un sémaphore:

Incrémentation d'un sémaphore:

Obtention de la valeur actuelle d'un sémaphore:

Autres fonctions:

• La fonction sem_trywait() fonctionne de la même manière que sem_wait(), sauf que si la valeur du sémaphore est 0, sem_trywait() ne bloquera pas le thread appelant, mais renverra immédiatement -1.

• La fonction sem_destroy() est utilisée pour détruire manuellement un sémaphore.

Remarque pour MacOS:

Exemple:

#include<stdlib.h>
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>

#define NB_CLIENT 100
#define NB_PLACE 10
#define NB_ENTIERS 1000

sem_t sem;

typedef struct{
    int entier[NB_ENTIERS];
}panneau;

void* client(void * args){
    panneau* p = (panneau*) args;

    sem_wait(&sem);
    int position = rand() % NB_ENTIERS;
    printf("Je lis la case %d\\n", position);
    sleep(1);
    printf("La case contient %d\\n", p->entier[position]);
    sem_post(&sem);

    pthread_exit(NULL);
}

int main(){

    pthread_t th[NB_CLIENT];
    panneau p = {0};

    for(int i = 0; i < NB_ENTIERS;i++){
        p.entier[i] = rand()%10;
    }

    if(sem_init(&sem, 0, NB_PLACE) != 0){
        printf("Erreur lors de l'initialisation du sémaphore\\n");
        exit(1);
    }

    for(int i = 0;i < NB_CLIENT; i++){
        if(pthread_create(&th[i], NULL, client, (void*)&p) != 0){
            perror("Erreur lors de la création du thread\\n");
            exit(1);
        }
    }

    for(int i = 0; i < NB_CLIENT;i++){
        if(pthread_join(th[i], NULL) != 0){
            perror("Erreur lors de l'attente du thread\\n");
            exit(1);
        }
    }

    sem_destroy(&sem);
    exit(0);
}

Linux/C : Mémoire partagée

Création de la mémoire partagée avec shmget():

• 0600: Ces autorisations indiquent que le créateur du segment de mémoire partagée (propriétaire) a des autorisations de lecture (read) et d'écriture (write), tandis que les autres utilisateurs (groupe et autres) n'ont aucune autorisation. Chaque chiffre dans le nombre octal représente une autorisation différente, le premier chiffre représente les autorisations du propriétaire du fichier, le deuxième chiffre représente les autorisations des autres utilisateurs du même groupe, et le troisième chiffre représente les autorisations des autres groupes. En particulier, 6 représente les autorisations de lecture et d'écriture (4 représente la lecture, 2 représente l'écriture, donc 4 + 2 = 6), et 0 représente aucune autorisation.

• 0666: Ces autorisations indiquent que le créateur du segment de mémoire partagée (propriétaire), les autres utilisateurs du même groupe (groupe) et les autres groupes d'utilisateurs (autres) ont tous des autorisations de lecture (read) et d'écriture (write). Ici, les trois 6 représentent toutes les autorisations de lecture et d'écriture.

Attachement du segment de mémoire partagée avec shmat()

Détachement du segment de mémoire partagée avec shmdt()

Contrôle du segment de mémoire partagée avec shmctl()

• IPC_STAT: Met à jour la structure shmid_ds avec les valeurs actuelles du segment de mémoire partagée, remplace les valeurs actuelles par les valeurs actuelles du segment de mémoire partagée.

• IPC_SET: Modifie les valeurs actuelles du segment de mémoire partagée avec les valeurs spécifiées dans la structure shmid_ds, si le processus a les autorisations appropriées.

• IPC_RMID: Supprime le segment de mémoire partagée.

Exemple:

#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>

#define NB_MAX 10
typedef struct
{
    char text[NB_MAX];
    int tableau[NB_MAX];
} MEM_TAB;

int main()
{
    MEM_TAB *pointeur;
    int shmid;
    // Crée le segment de mémoire partagée
    if ((shmid = shmget(1234, sizeof(MEM_TAB), IPC_CREAT | 0600)) == -1)
        perror("erreur\\n");

    if ((pointeur = (MEM_TAB *)shmat(shmid, NULL, 0)) == NULL) // Attache le segment de mémoire partagée
        perror("erreur\\n");

    scanf("%s", pointeur->text);
    pointeur->tableau[0] = 10;

    if (shmdt(pointeur) == -1)
        perror("erreur\\n");

}

#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>
#define NB_MAX 10

typedef struct
{
    char text[NB_MAX];
    int tableau[NB_MAX];
} MEM_TAB;

int main()
{
    MEM_TAB *pointeur;
    int shmid;
    if ((shmid = shmget(1234, sizeof(MEM_TAB), IPC_CREAT | 0600)) == -1)
        perror("erreur\\n");
    if ((pointeur = (MEM_TAB *)shmat(shmid, NULL, 0)) == NULL)
        perror("erreur\\n");
    printf("%s - %d\\n", pointeur->text, pointeur->tableau[0]);
    // Détache le segment de mémoire partagée
    if (shmdt(pointeur) == -1)
        perror("erreur\\n");
    // Détruit le segment de mémoire partagée (lorsque le dernier lien est détaché)
    if (shmctl(shmid, IPC_RMID, 0) == -1)
        perror("erreur\\n");
}