C : coups de cœur et coups de gueule » Manipulation des processus https://blog.developpez.com/kirilenko Write in C! Sat, 20 Apr 2013 16:54:09 +0000 fr-FR hourly 1 https://wordpress.org/?v=4.1.42 Le bloc de contrôle de processus https://blog.developpez.com/kirilenko/p10651/manipulation-des-processus/le_bloc_de_controle_de_processus https://blog.developpez.com/kirilenko/p10651/manipulation-des-processus/le_bloc_de_controle_de_processus#comments Sat, 14 Jan 2012 17:37:26 +0000 Le système d’exploitation dispose d’une table de processus, permettant de gérer de manière globale chaque processus.
Chaque processus possède une entrée, appelée bloc de contrôle de processus. Il contient diverses informations, comme :

– son PID ;
– son PPID ;
– son état ;
– son contexte processeur (état des registres) et mémoire (adresses de l’espace d’adressage) ;
– ses critères d’ordonnancement ;
– les fichiers ouverts.

]]> 0 Etats d’un processus https://blog.developpez.com/kirilenko/p10650/manipulation-des-processus/etats_d_un_processus https://blog.developpez.com/kirilenko/p10650/manipulation-des-processus/etats_d_un_processus#comments Sat, 14 Jan 2012 17:34:49 +0000 Un processus Unix peut-être caractérisé par son état. Il existe communément trois états :

– élu ;
– bloqué ;
– prêt.

Un processus est dans l’état élu lorsqu’il s’exécute, après avoir obtenu le processeur.
Il est bloqué lorsqu’il est en attente, par exemple d’une lecture de disque.
Il est dans l’état prêt lorsqu’il est n’est pas en attente, mais qu’il n’a pas le processeur. Il attend simplement que ce soit son tour.

Le passage de l’état prêt à l’état élu constitue l’opération d’élection.
Le passage de l’état élu à l’état bloqué constitue l’opération de blocage.
Le passage de l’état bloqué à l’état prêt constitue l’opération de déblocage.

]]> 0 Terminaison de processus https://blog.developpez.com/kirilenko/p10641/manipulation-des-processus/terminaison_de_processus https://blog.developpez.com/kirilenko/p10641/manipulation-des-processus/terminaison_de_processus#comments Tue, 10 Jan 2012 18:21:15 +0000 Un processus peut se terminer suite à l’appel de la fonction :

void exit(int status);

de stdlib.h.

status est un entier, qui permet d’indiquer la valeur de retour du processus. Conventionnellement, on utilise la valeur de 0 pour indiquer une sortie correcte, ou une autre valeur pour indiquer l’erreur. Exemple :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
 
void task(void) {
  puts("Child process... end.");
  exit(0);
}
 
int main(void) {
  pid_t p;
 
  p = fork();
 
  switch (p) {
    case -1:
      perror("fork");
      break;
    case 0:
      task();
      break;
    default:
      puts("Father process...");
      break;
  }
  return EXIT_SUCCESS;
}

On pourra récupérer la valeur envoyée à exit par un processus fils par son processus père, et ce sera l’objet d’un prochain article plus complet, concernant la synchronisation des processus.

]]> 0 Quelques fonctions bien utiles https://blog.developpez.com/kirilenko/p10637/manipulation-des-processus/quelques_fonctions_bien_utiles https://blog.developpez.com/kirilenko/p10637/manipulation-des-processus/quelques_fonctions_bien_utiles#comments Mon, 09 Jan 2012 18:41:20 +0000 Bonjour,

Après avoir introduit la création des processus, je souhaitais vous présenter quelques fonctions qui sont utiles, notamment lors du débogage de votre application.

Je cite :

pid_t getpid(void);

qui retourne le PID du processus courant.

pid_t getppid(void);

qui retourne le PID du processus père du processus courant.

uid_t getuid(void);

qui retourne l’UID (identificateur de l’utilisateur qui a créé le processus) du processus courant.

gid_t getgid(void);

qui retourne le GID (identificateur du groupe auquel appartient l’utilisateur) du processus courant.

Exemple qui résument les fonctions que je viens de vous présenter :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
 
int main(void) {
  pid_t p;
 
  p = fork();
 
  switch (p) {
  case -1:
    perror("fork");
    break;
  case 0:
    fprintf(stdout, "I'm father process.\n");
    break;
  default:
    fprintf(stdout, "I'm child process, PID = #%u"
                    " ; PPID = #%u ; UID = #%u ; GID = #%u\n",
           (unsigned)getpid(), (unsigned)getppid(),  
           (unsigned)getuid(), (unsigned)getgid());
  }
  return EXIT_SUCCESS;
}

Bon codage !

]]> 0 Création de processus https://blog.developpez.com/kirilenko/p10636/manipulation-des-processus/creation_de_processus https://blog.developpez.com/kirilenko/p10636/manipulation-des-processus/creation_de_processus#comments Mon, 09 Jan 2012 18:16:58 +0000 Bonjour,

Dans ce billet, qui est le premier de ce blog, je souhaitais vous présenter mon projet. Je suis passionné par la programmation en C, et plus particulièrement par l’aspect « bas niveau » de celle-ci. Le C a été créé pour développer le système d’exploitation UNIX, sur lequel sont basés la plupart des OS couramment usés.
La programmation système consiste au développement d’applications qui font partie intégrante du système d’exploitation. C’est ce type de programmation, opposée aux programmes utilisateurs, que je voulais vous faire découvrir dans ce blog.

Ce premier billet commence par la pratique, et avec la création des processus. Les processus représentent l’image d’un programme à un instant donné (état des registres entres autres).

Chaque processus possède un espace d’adressage donné, dans lequel il peut lire et écrire. Cet espace est divisé en trois grandes parties (segment texte, segment données, pile).

En C et sous un système d’exploitation basé sur UNIX, il est possible de créer un processus grâce à la fonction conforme POSIX.1 :

#include <unistd.h>
 
pid_t fork(void);

Le type pid_t (déclaré dans sys/types.h) représente l’identificateur d’un processus (appelé PID pour Process IDentifier). En l’occurrence, la fonction renvoie trois valeurs, suivant ce qui s’est passé lors de l’exécution de cet appel-système :

  • -1 en cas d’erreur, et errno est positionnée pour contenir le code de l’erreur (à savoir EAGAIN ou ENOMEM) ;
  • 0 si on est dans le processus père ;
  • une autre valeur, positive, indiquant le PID du processus créé (appelé processus fils).

Premier exemple pratique :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
 
int main(void) {
  pid_t p;
 
  p = fork();
 
  switch (p) {
  case -1:
    perror("fork");
    break;
  case 0:
    fprintf(stdout, "I'm father process.\n");
    break;
  default:
    fprintf(stdout, "I'm child process, PID = #%u", (unsigned)p);
    break;
  }
  return EXIT_SUCCESS;
}

Le résultat peut varier selon l’ordre d’exécution des processus sur votre machine. Notez que la synchronisation des processus pourrait permettre une certaine unité, et ce sera l’objectif d’un des prochains articles !

]]> 0