programmation système unix - deptinfo

P.RAZAC CNAM 1

Programmation système UNIX

P.RAZAC

P.RAZAC CNAM 2

PLAN

UNIX - GénéralitésFichiers et Entrées/SortiesLes processusLes signauxIPC système VLes Threads

P.RAZAC CNAM 3

Structure d’UNIX

Modèle en couchesPOSIX

P.RAZAC CNAM 4

UNIX - Modèle en couches

Applications

Machine

Shell

Noyau

P.RAZAC CNAM 5

POSIX (1)

Cette norme porte sur la specification d’un ensemble de fonctions portant sur les services de base d’un système UNIX.

P.RAZAC CNAM 6

POSIX (2)fichiers d’en tête

Dans ces fchiers on retrouve la définition de constantes, de structures et de types et le prototypage des fonctions.Fichier Utilisation<errno.h> gestion des erreurs<math.h> fonctions mathématiques<signal.h> gestion des signaux<stdio.h> bibliothèque d’E/S standard<string.h> manipulation de chaînes de caractères<sys/stat.h> accès aux caractèristiques d’un fichier<sys/wait.h> synchro de processus père/fils<sys/types.h> définition de types standard<stdlib.h> fonctions C standard antérieures à POSIX<unistd.h> appels système antérieurs à POSIX

P.RAZAC CNAM 7

Entrées/sorties

GénéralitésFonctions de baseFonctions de la bibliothèque standard

P.RAZAC CNAM 8

E/S - Généralités

Le terme de fichier est associé à un ensemble de ressourcesRessources matériellesRessources logiciellesA chaque fichier est associé sur disque une structure appelée INODE

P.RAZAC CNAM 9

Types de fichiers

Fichiers réguliersRépertoireFichiers spéciaux

P.RAZAC CNAM 10

E/S - Fonctions de base (1)

1) OPEN#include <sys/types.h>#include <sys/stat.h>#include <sys/fcntl.h>int open (const char *ref, int openflag, mode_t droits)

-> demande l’allocation d’une nouvelle entrée dans la tabledes fichiers ouverts du système-> un descripteur est alloué dans la table des descripteurs du processus-> il y a chargement dans la tables des inodes en mémoire de l’inode du fichier

P.RAZAC CNAM 11


2) CREAT int creat (const char *ref, mode_t droits);équivalent à open (const char *ref, o_wronly | o_creat | o_trunc,droits)3) CLOSE#include <unistd.h>int close( int desc);

P.RAZAC CNAM 12


4) READ#include <unistd.h>ssize_t read (int desc, void *buf, size_t nb_octets);5) WRITE#include <unistd.h>ssize_t write( int desc, void *buf, size_t nb_octets);6) Manipulation de l’offset ou position courante dans le fichier#include <unistd.h>off_t int lseek(int desc, off_t offset, int origine);

P.RAZAC CNAM 13

E/S - Fonctions de la bibliothèque standard (1)

1) Ouverture d’un fichier#include <stdio.h>FILE *fopen (const char *path, const char *mode);Définition du type FILE :À chaque fichier ouvert par un processus est associé un objet de type FILE.Cet objet contient :

- un descripteur- un tampon de taille BUFSIZE

P.RAZAC CNAM 14

E/S - Fonctions de la bibliothèque standard (2)

2) Fermeture d’un fichier#include <stdio.h>int fclose (FILE *prt_file);

3) Écriture dans le fichierÉcriture du tableau ptr d’un certain nombre d’enregistrementsint fwrite (void *ptr, size *taille, size_t nb_elem, FILE *ptr_file);

4) Lecture dans le fichierLecture du tableau ptr d’un certain nombre d’enregistrementsint fread (void *ptr, size *taille, size_t nb_elem, FILE *ptr_file);

P.RAZAC CNAM 15

Gestion des systèmes de fichiers (1)

Appels système STAT, FSTAT, ACCESSLes caractèristiques d’un fichier sont stockées dans stat .nom type descriptionst_mode mode_t type du fichier et droits d’accèsst_ino ino_t numéro d’inodest_dev dev_t identifiant du supportst_link nlink_t nbre de liensst_uid uid_t id. du propriétaire du fichierst_gid gid_t id. du groupest_size off_t taille du fichier en bytesst_atime time_t date du dernier accèsst_ctime time_t date du dernier chgt. de statutst_mtime time_t date de la dernière modif. des données

P.RAZAC CNAM 16

Gestion des systèmes de fichiers (2)

La fonction stat :#include <sys/types.h>#include <sys/stat.h>int stat(const char *path, struct stat *buf)int fsat(const int fildes, struct stat *buf)

Test des droits d’accès: access #include <unistd.h>int access (char *path, int type_access)

P.RAZAC CNAM 17

Le système de fichiers UNIX

Ce système a quatre composantes:

1) le boot block

2) le super block

3) les blocs de données (data blocks)

4) les inodes

P.RAZAC CNAM 18

Système de fichiersAccès aux blocs de données I

numéro d’entrée

0

12

9101112

bloc donnée 0

bloc donnée 1bloc donnée 2

bloc donnée 9

bloc d’indirection

bloc de données .bloc de données

second bloc d’indirectionqui contient la localisation de256 blocs de données

second bloc d’indirection



bloc d’indirectiontroisième

troisièmebloc d’indirectionqui contient la localisation de256 blocs de données



blocs i



blocs de données

blocs de données

P.RAZAC CNAM 19

Système de fichiersAccès aux blocs de données 2

numéro d’entrée

0

12

9101112

bloc donnée 0

bloc donnée 1bloc donnée 2

bloc donnée 9


il contient la localisation de 256 blocs de données


second bloc d’indirectionqui contient la localisation de256 blocs de données

second bloc d’indirection



bloc d’indirectiontroisième

troisièmebloc d’indirectionqui contient la localisation de256 blocs de données



blocs i

bloc de données bloc de données


blocs de données

blocs de données

P.RAZAC CNAM 20

Les tables du systèmetable des descritpteurs

table des fichiers ouverts

table des inodesen mémoire table des verrous

compteurdedescripteurs

modeouverture

position

pointeursur inode

P.RAZAC CNAM 21

Les repertoires UNIXNumérosd’inode Liste des inodes

5

8

13

19

22

29

33

entrée n. d’inode. 5.. 5a ƒ 8b 13c ƒ 19

entrée n. d’inode. 8.. 5d 22

données de b

entrée n. d’inode. 19.. 5e 29f 33

données de d

données de e

données de f

P.RAZAC CNAM 22

Gestion des processus

Caractéristiques d’un processusReprésentation en mémoireFonctions de gestion de mémoireFonctions de création de processusMécanismes de synchronisation

P.RAZAC CNAM 23

Caractéristiques d’un processus (1)

Identité du processus

# include <unistd.h>pid_t getpid (void)

Identité du père du processuspid_t getppid (void)

Relation du processus avec les utilisateursle propriétaire réel : uid_t getuid (void)le propriétaire effectif : uid_t geteuid (void)modification du propriétaire : int setuid (uid_t uid)

P.RAZAC CNAM 24

Caractéristiques d’un processus (2)

Caractéristiques d’un utilisateur#include <pwd.h>struct passwd * getpwuid (uid_t uid)Détails de la structure passwdNom Type Descriptionpw_name char * nom de login de l’utilisateurpw_uid uid_t numéro d’identificationpw_gid gid_t num. d’ident. du groupepw_dir char * repertoire de travailpw_shell char * shell

P.RAZAC CNAM 25

Etats du processus

nouveau pret zombi

suspendu

actif noyau actif utilisateur

endormi

1

2

3

4

5

69

7

7

P.RAZAC CNAM 26

Représentation en mémoireProcessus A Mémoire physique Processus B

Pile

BBS

Données

Code

Pile

BBS

Données

Code

Pile

Pile

BBS

Données

BBS

Données

Code

Système0 0

P.RAZAC CNAM 27

Fonctions de gestion de mémoire

Fonctions de haut niveau1) la fonction malloc demande l’allocation de size octets:#include <stdlib.h>void *malloc (size_t size);La valeur retournée est un pointeur sur la zone alllouée.

2) la fonction calloc pour l’allocation d’un espace pour stocker nb-elms éléments de taille size:void *calloc (size_t nb-elms, size_t size);

3) la fonction realloc pour changer la taille de la zone allouée:void *realloc (void *ptr, size_t size);

P.RAZAC CNAM 28

La projection des fichiers en mémoire - mmap et munmap

mmap permet d’associerà une adresse de l’espace d’adresssage du processus len bytes d’un fichier.

#include <sys/types.h>

#include <sys/mman.h>

caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fildes, off_t off);

munmap permet la libération de la zone mémoire (adr,adr + len).

int munmap(caddr_t addr, size_t len);

P.RAZAC CNAM 29

Fonctions de création de processus (1)

Chaque processus UNIX est créé par l’appel système fork:#include <unistd.h>pid_t fork (void);

pid = fork()

pid = numéro d’ident.du proc. fils

pid = 0

Processus père Processus fils

P.RAZAC CNAM 30

Fonctions de création de processus (2)

Héritage entre le père et le fils

- Les descripteurs de fichiersLe fils reçoit une copie des descripteurs de son père.

=> les descripteurs du père et du fils pointent sur la même entrée dans la table des fichiers ouverts

P.RAZAC CNAM 31

Mécanismes de synchronisation (1)

Tout processus fils se terminant se trouve a l’état de zombieZombie: le processus occupe un emplacement dans la table des processus et ne consomme aucun temps CPU.

Les fonctions wait et waitidElles assurent:•l’élimination des processus zombies•la synchronisation d’un processus sur la terminaison de ses fils avec récupération des informations relatives à cette terminaison

P.RAZAC CNAM 32


La fonction WAIT:#include <sys/types.h>#include <sys/wait.h>pid_t wait ( int *pointeur_status);

• Cette fonction retourne le PID de l’un des ses fils zombis.• Si *pointeur_status ≠ NULL alors elle fournit des informations sur la terminaison de ce processus zombi.

P.RAZAC CNAM 33


La fonction waitid#include <sys/types.h>#include <sys/wait.h>int waitid (idtype_t idtype,pid_t id, siginfo_t *infop, int options);

Waitid() suspend le processus père appelant jusqu’à ce qu’un processus fils change d’état.Elle enregistre l’état courant du fils dans une structure pointée par infop.

Les arguments idtype et id spécifient lesquels des processus fils waitid() va attendre.• idtype_t = P_PID => elle attend un fils dont le num. de proc. est égal à (pid_t) id.• idtype_t = P_GID => elle attend un fils dont le num. de groupe de proc. est égal à (pid_t) id.• idtype_t = P_ALL => elle attend n’importe quel fils et id est ignoré.

P.RAZAC CNAM 34

Fonction de recouvrement de processus

La famille des fonctions execUn processus fils peut executer un nouveau programme.Cette famille de fonctions remplace l’image courante d’un processus par un nouveau.

execl (const char *ref, const char *arg, ....., NULL);execlp(const char *ref, const char *arg, ....., NULL);execle(const char *ref, const char *arg, ....., NULL,

const char ** arge);

P.RAZAC CNAM 35

Le système de fichiers de type processus - /proc

/proc permet l’accès à l’image de chaque processus présent en mémoire.Les opérations portant sur l’information et le contrôle du processus se font par la fonction système ioctl.

#include <unistd.h>

#include <sys/signal.h>

#include <sys/fault.h>#include <sys/syscall.h>

#include <sys/procfs.h>

void *p;

retval = ioctl ( fildes, request, p);

P.RAZAC CNAM 36

Gestion des signaux

Définition du signalIdentificationEnvoi de signauxMasquage, démasquage

P.RAZAC CNAM 37

Définition du signal

C’est une interruption logicielle

Un signal est dit pendant quand il a été envoyé au processus mais n’a pas été pris en compte.

Un signal est délivré à un processus lorsque celui le prend en compte au cours de son execution

Il y a exécution d’une fonction particulière quand il est délivré

P.RAZAC CNAM 38

Identification des signaux (1)

Chaque signal est identifié par un nombre et un nom symbolique.Il y a NSIG signaux.Ils sont décrits dans /usr/include/signal.h .

P.RAZAC CNAM 39

Identification des signaux (2)Signaux de base

Signal Evénement associé Comportement

sighup Terminaison du processus Term.sigint Frappe du caractère Interruption Term.sigquit Frappe du caractère Quitter Term.+imsigfpe Erreur arithmétique Term.sigkill Signal de terminaison Term.sigsegv Violation mémoire Term.+imsigalrm Fin de temporisation Term.sigterm Signal de terminaison Term.sigusr1 Signal émis par un proc. utilisateur Term.sigchld Terminaison d’un processus fils Sans effet

P.RAZAC CNAM 40

Identification des signaux (3)Contrôle du processus

Signal Evénément associé Comportement

Sigstop Signal de suspension Suspendu

Sigtstp Frappe du caractère Suspension Suspendu

Sigcont Signal de continuation Repriseou ignoré

P.RAZAC CNAM 41

Envoi des signaux

La fonction kill:Elle permet l’envoi d’un signal.int kill (pid_t pid, int sig);

P.RAZAC CNAM 42

Prise en compte et délivrance du signal (1)

A chaque type de signal est associé un traitement ou handler par défaut

appelé SIG_DFL.Le handler définit le traitement par défaut d’un processus auquel un signal a été délivré.A part pour SIGKILL, SIGCONT, SIGSTOP, le processus peut définir pour chaque type de signal un nouveau handler.

P.RAZAC CNAM 43

Prise en compte et délivrance du signal (2)

Lorsque le processus passe de l’état actif noyau à l’état actif utilisateur, a lieula délivrance des signaux non bloqués.Un processus n’est pas interruptible par un signal en mode noyau.

P.RAZAC CNAM 44

Gestion des ensembles de signaux

Un processus a dans son bloc de controle un masque qui définit un ensemble de signaux dont la délivrance n’est pas assurée normalement.Le type sigset_t définit ces ensembles

L’interface liée à ces ensembles:int sigemptyset(sigset_t *p_ens); *p_ens=0

int sigfillset(sigset_t *p_ens); *p_ens={1,nsig}int sigaddset(sigset_t *p_ens, int sig); *p_ens= *p_ensU{sig}

int sigdelset (sigset_t *p_ens, int sig); *p_ens= *p_ens-{sig}int sigismember (sigset_t *p_ens, int sig); sig E *p_ens

P.RAZAC CNAM 45

Masque de blocage des signaux

L’installation d’un masque de blocage des signaux est réalisé par sigprocmask :

#include <signal.h>int sigprocmask(int op, const sigset_t *p_ens,

sigset_t *p_ens_ancien);La liste des signaux pendants bloqués :

int sigpending(sigset_t *p_ens);

P.RAZAC CNAM 46

Handlers - la structure et la primitive sigaction (1)

La structure sigaction permet de spécifier le comportement d’un signal lors de la délivrance d’un signal.

struct sigaction{void (*sa_handler) ();sigset_t sa_mask;

int sa_flags;}

P.RAZAC CNAM 47

Handlers - la structure et la primitive sigaction (2)

La fonction sigaction permet d’installer un handler pour un signal donné

#include <signal.h>int sigaction (int sig, const struct sigaction

*p_action, struct sigaction *p_action_anc);

P.RAZAC CNAM 48

Les fonctions associées à l’attente d’un signal

Elles permettent de se mettre en attentede l’arrivée d’un signal.

La fonction pause:#include <unistd.h>int pause (void);

la fonction sigsuspend:int sigsuspend (const sigset_t *p_ens);

P.RAZAC CNAM 49

Réalisation de temporisation SIGALRM

La fonction sigalrm permet grace à une requête au système d’envoyer au processus le signal SIGALRM dans n secondes.

#include <unistd.h>unsigned int alarm (unsigned int n);

Le comportement associé à SIGALRM est la terminaisonCette fonction permet de réaliser un mécanisme de time-out ou délai de garde

P.RAZAC CNAM 50

IPC système V

3 mécanismes:MessagesMémoire partagéeSémaphores

P.RAZAC CNAM 51

IPC système V

Propriétés communes aux trois mécanismes:une tableclé numériqueappel get: créer oudétruire un élémentmême formule pour retrouver un indice dans la table

P.RAZAC CNAM 52

IPC système V

ftok - génère une clé de communication interprocessus standardkey_t ftok {

char *path_name,

char project_id};

Parametres :path_name spécifie le chemin d'une fichier existant qui est

accessible au processus.

project_id spécifie un caractère qui va identifier de facon unique

un projet.

P.RAZAC CNAM 53

IPC système V

Propriétés communes aux 3 mécanismes (II)chaque élément contient une structure de permissionschaque élément possède des informations d’étatà chaque mécanisme est associé un appel système “control”

P.RAZAC CNAM 54

IPC SYSV - Messages

Il y a 4 appels système:msgget msgrcvmsgctlmsgsnd

P.RAZAC CNAM 55

IPC SYS V - Messages

MSGGET :#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

int msgget (key_t key, int msgflg );MSGRCV:

int msgrcv(int msgid,

struct msgbuf *msgp,

size_t msgsz,long msgtyp,

int msgflg);

P.RAZAC CNAM 56

IPC SYS V - Messages

MSGSND:int msgsnd(int msqid, const void *msgp,

size_t msgsz,

int msgflg);

MSGCTL:int msgctl(

int msqid,

int cmd,

struct msgqid_ds *buf);

P.RAZAC CNAM 57

IPC SYS V - mémoire partagée

Les processus communiquent entre eux en partageant leur espace d’adressage virtuel.Ils peuvent grâce à cet espace d’adressage lire et écrire des données.

P.RAZAC CNAM 58

IPC SYS V - mémoire partagée

Les commandes :shmget : retourne et si possible crée un identificateur pour une région de mémoire partagée.

shmctl : met en oeuvre des opérations de controle sur la mémoire partagée.

shmat: attache une région de mémoire partagée.

shmdt: détache une région de mémoire partagée.shm_open: ouvre ou crée un objet de mémoire partagée.

shm_unlink: détruit un objet.

P.RAZAC CNAM 59

IPC SYS V - sémaphores

Le sémaphore est utilisé pour limiter l'accès a une ressourcecritique.

Quand un processus demande l'accès à une ressource sans

interférence avec les autres processus , on établit la connexion

avec la ressource en association avec un sémaphore.Si la valeur du sémaphore est plus grande que zéro, la connexion

est établie et la valeur du sémaphore est décrémentée par un.

Si la valeur du sémaphore est inférieure ou égale a zéro, le

processus qui veut accéder a la ressource est bloqué et doitattendre qu'un autre processus lache le sémaphore et incrémente

la valeur du sémaphore.

P.RAZAC CNAM 60


sem_init - initialise/ouvre un sémaphore non nomme#include <semaphore.h>int sem_init(sem_t *sem, int pshared, unsigned int value );Parametres:sem - le sémaphore a initialiserpshared - une valeur non nulle indique que le sémaphore pourraêtre partagé entre processus

value - la valeur du sémaphore initialisé

P.RAZAC CNAM 61


sem_open - initialise/ouvre un sémaphore nommésem_t *sem_open(const char *name, int oflag);

Paramètres:

*name - pointe sur la chaîne de caractères nommant le sémaphore.

oflag - contrôle la façon dont le sémaphore est crée :

O_CREAT crée le sémaphore s'il n'existe pas encore O_EXCL si O_EXCL et O_CREAT sont positionnés alors il y a

échec de la fonction si un sémaphore de même nom existe.

P.RAZAC CNAM 62


sem_wait : int sem_wait(sem_t *sem);

int sem_trywait(sem_t *sem);

Ces fonctions verrouillent le semaphore.

La fonction sem_trywait verrouille le semaphore seulementsi le semaphore n'est pas verouille.

Si la valeur du semaphore est zero, alors sem_wait

bloque jusqu'a ce qu'on verouille le semaphore ou

qu'il soit interrompu par un signal.

P.RAZAC CNAM 63


sem_post:

int sem_post(sem_t *sem);

cette fonction déverrouille le sémaphore.

P.RAZAC CNAM 64


sem_destroy: int sem_destroy(sem_t *sem);

paramètre : sem - sémaphore non nomme

Cette fonction désalloue les ressources système allouées

à un processus utilisées avec un sémaphore.sem_getvalue:

int sem_getvalue(sem_t *sem, int *sval);

parametres :

sem - sémaphore*sval - fait référence à une position qui va être mise à

jour avec la valeur du sémaphore sem.

P.RAZAC CNAM 65

Posix threads (I)

Définition d’un thread :C’est l’entité de base à laquelle le système d’exploitation alloue du

temps CPU.Un thread peut executer n’importe quelle partie du code d’une application même si celle-ci est déjà traiteé par un autre thread.

cc [ flag ... ] file ... -lpthread (DIGITAL UNIX)

cc [ flag ... ] file ... -lpthread -posix4 (Solaris)

#include <pthread.h>Chaque fonction Posix thread commence par pthread .

P.RAZAC CNAM 66

Posix threads (I)

L’espace d’adressage virtuel, les variables globales, les ressources d’un processus sont partagées par tous les threads.

Posix établit les caractéristiques de chaque thread par l’intermédiaire d’objets d’attributs configurables.

Posix posséde le mécanisme d’annulation de thread.

Posix applique des algorithmes d’ordonnancement.

Posix prévoit des traitements pour les appels système fork().

P.RAZAC CNAM 67

Posix threads (I)

Synchronisation:Un mécanisme multi-threadé est asynchrone .

Il est donc fait pour les traitements parallèles et concurrents.

Comme les threads partagent l’espace d’adressage, les variables globales d’un processus, il n’y aucune certitude d’un accés exclusif aux données partagées au un instant donné.

Sécuriser les accés dans le cadre de données partagées implique des mécanismes de synchronisation.

Posix utilise trois mécanismes:

-Exclusion mutuelle

-Variable de condition

-Sémaphore

P.RAZAC CNAM 68

Posix threads (I)

Fonctions :pthread_create : création d'une thread.

pthread_delay_np : force une pthread a attendre pendant un certain laps de temps.

pthread_detach : marque une pthread pour destruction.

pthread_exit : termine la pthread appelantepthread_join : force une pthread a attendre la terminaison

d'une thread spécifique.

pthread_once : appelle une fonction d'initialisation pour être exécutée une fois.

pthread_self : renvoit l'identificateur de la thread courante.pthread_yield : prévient l'ordonnanceur que la pthread courante

laissera son processeur aux autres threads de même priorité.

P.RAZAC CNAM 69

Posix threads (I)

Pthread_create:int pthread_create(pthread_t *new_thread_ID,

const pthread_attr_t *attr, void * (*start_func)(void *), void *arg);

P.RAZAC CNAM 70

Posix threads (I)

Fonctions d'objets d'attributs :1)

pthread_attr_init : crée un objet contenant les attributs d'un thread.

int pthread_attr_init(pthread_attr_t *attr);

pthread_attr_destroy : détruit l'objet contenant les attributs d'un thread.int pthread_attr_destroy(pthread_attr_t *attr);

P.RAZAC CNAM 71

Posix threads (II)

Exclusion mutuelle:

int pthread_mutex_init(pthread_mutex_t *mp, const pthread_mutexattr_t *attr);

pthread_mutex_tmutex=PTHREAD_MUTEX_INITIALIZER;

int pthread_mutex_lock(pthread_mutex_t *mp);int pthread_mutex_unlock(pthread_mutex_t *mp);

int pthread_mutex_destroy(pthread_mutex_t *mp);

P.RAZAC CNAM 72

Posix threads (II)

Fonctions portant sur les attributs d’exclusion mutuelle:pthread_mutexattr_init : crée l'objet contenant les attributs

d'exclusion mutuelle.

int pthread_mutexattr_init(pthread_mutexattr_t *attr);

pthread_mutexattr_destroy : détruit l'objet contenant les attributs d'exclusion mutuelle.

int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

P.RAZAC CNAM 73

Posix threads (III)

Variable de condition:Initialisation:pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

Attente:

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

Signal: int pthread_cond_signal(pthread_cond_t *cond);Débloque une thread bloquée sous la var. de condition.

Destruction: int pthread_cond_destroy(pthread_cond_t *cond);

P.RAZAC CNAM 74

SUNOS Multi-thread Architecture

utilisateur

NOYAU

MATERIEL

Processus 1 Processus 2 Processus 3

thread

LWP

CPU

programmation système unix - deptinfo

Documents