TP de systèmes d'exploitation
6
pages
Français
Documents
Le téléchargement nécessite un accès à la bibliothèque YouScribe Tout savoir sur nos offres
6
pages
Français
Documents
Le téléchargement nécessite un accès à la bibliothèque YouScribe Tout savoir sur nos offres
tp, Supérieur, TP
Voir
- cours - matière potentielle : systèmes d
- redaction - matière potentielle : documents
- cours - matière potentielle : exécution
- mémoire
- revision
- signification pour la politique pol- icy
- gestion des sémaphores
- politiques d'ordonnancement
- sémaphore
- temps de réponse
- appels système
- appel système
- thread
- linux
- processus
- ressources
- ressource
Ensi de Caen TP 2A instrumentation / microélectronique
TP de systèmes d'exploitation
Page 1 / 6 PhL 18/11/04 tp_se_2a.sxw
- Partage de ressources entre processus et arbitrage par sémaphore -
Gestion des processus en C
fork() Un processus peut se dupliquer – et donc créer un nouveau processus – par la fonction : p i d _ tf o r k ( v o i d ) qui renden cas d’échec. En cas de réussite, la fonction retournedans le processus fils et le n° du processus fils – 10 Process Identifier– dans le père. Cette fonction transmet une partie du contexte du père au fils : les descripteurs desou PID fichiers standards et des autres fichiers, les redirections… Les deux programmes sont sensibles aux mêmes interruptions. À l’issue d’unles deux processus s’exécutent simultanément. f o r k ( )
exit() Un processus se termine lorsqu’il n’a plus d’instructions ou lorsqu’il exécute la fonction : v o i de x i t ( i n ts t a t u t )
wait() L’élimination d’un processus terminé de la table ne peut se faire que par son père, grâce à la fonction : i n tw a i t ( i n t* c o d e _ d e _ s o r t i e ) Avec cette instruction, le père se bloque en attente de la fin d’un fils. Elle rendra le n° PID du premier fils mort trouvé. La valeur du code de sortie est celle du paramètre de la fonctionde ce fils. On peut donc utiliser l’instruction e x i tw a i t pour connaître la valeur éventuelle de retour, fournie par, d’un processus. Ce mode d’utilisation est analogue à e x i t ( ) celui d’une fonction.rend encas d’erreur. w a i t ( ) 1 Si le fils se termine sans que son père l’attende, le fils passe à l’étatdefunctla table. Si, au contraire, le père se dans termine avant le fils, ce dernier est rattaché au processus initial. Le processus initial passe la plupart de son temps à attendre les processus orphelins.
kill() L’instruction : i n tk i l l ( i n tp i d ,i n ts i g n a l ) permet à un processus d’envoyer un signal à un autre processus.est le n° du processus à détruire et, le n° du p i ds i g n a l signal employé. La fonctioncorrespond à des interruptions logicielles. k i l l Par défaut, un signal provoque la destruction du processus récepteur, à condition bien sûr, que le processus émetteur possède ce droit de destruction. Le signal de terminaison normal est 3, et celui de terminaison sans condition est 9. Cette même commande existe aussi en shell.
–Écrire un programme qui va créer un deuxième processus. Le père va afficher les majuscules à l'écran et le fils les minuscules. Ici, le travail effectué par les 2 processus est trop court et il n'y a pas entrelacement des exécutions. Pensez à mettre un "\n" à la fin de chaque écriture afin de vider le buffer ! –programme qui va créer un deuxième processus. Le père et le fils comptent de 0 à 100000 et l'affiche à l'écran.Écrire un Le père place un P devant son comptage et le fils un F. Analysez le travail de l'ordonnanceur. –le programme précédent. Le père ouvre un fichier en écriture avant de créer le fils. Père et fils écrivent leReprenez comptage dans le fichier. –Faites de même avec un fichier ouvert en ajout à la fois par le père et par le fils. Pourquoi cela ne fonctionnetil plus correctement ?
Gestion des threads en C(voir lemande chaque fonction!!) voir aussi en annexe du polycopié.
La création et le lancement du thread se fait par : pthread_t th1 ; int ret ; pthread_create (&th1, NULL, runDuThread, "1") ;
Ensi de CaenPage 2 / 6 TP 2A instrumentation / microélectroniquePhL 18/11/04 tp_se_2a.sxw if (th1 == NULL) { fprintf(stderr, "pthread_create error 1\n") ; exit(0) ; } Le thread exécutera alors la fonctiondont le prototype est : runDuThread void* runDuthread (void *param) ; Cette fonction est à écrire par le programmeur pour décrire le comportement du thread. Le paramètreparamest un pointeur dont la valeur est celle passée en argument (le 4ième) de la fonctionpthread_create. Il permet de passer des données au thread. Si la fonction main se termine, le programme et tous les threads lancés se terminent aussi. Il faut donc s'assurer avant de terminer le programme que tous les threads ont fini leur travail. L'attente de la terminaison d'un thread se fait comme ceci : (void) pthread_join (th1, (void *)&ret) ; Le paramètreretcontiendra la valeur retournée par la fonctionà exécuter avant de terminer pthread_exit (int val) un thread. –Écrire un proprogramme qui lance 2 threads. L'un écrira les 26 minuscules à l'écran et l'autre les 26 majuscules. –en écriture puis qui crée 2 threads, les attend et ferme le ficher. Le premierÉcrire un programme qui ouvre un ficher thread écrira les nombres de 0 à 100 000 dans le ficher et l'autre de 1 000 000 à 1 100 000. Consultez le fichier ainsi créé et analysez le travail de l'ordonnanceur. –Écrire un programme qui initialise une variable globale à 0 et crée 2 threads. Chacun des threads va incrémenter la variable N fois. Afficher la valeur de la variable à la fin de l'exécution de chacun des threads. –Faites plusieurs executions et augmenter N jusqu'à remarquer que le résultat n'est plus 2xN. Pourquoi ? Vous le saurez en assistant au prochain épisode du cours de Systèmes d 'exploitation et réseaux.
Gestion des sémaphores. Lorsque 2 processus veulent se partager une ressource unique, on met en place un système de sémaphore afin d'arbitrer l'accès à cette ressource. Un sémaphore est une variable gérée par le système d'exploitation dont le test et l'affectation se font de manière atomique ; c’est à dire que le système ne peut pas être interrompu au milieu du traitement de ces 2 opérations. De plus, plusieurs processus peuvent avoir accès à cette variable. En général la prise (décrémente de 1) d'un sémaphore par un processus bloquera un autre processus qui voudrait prendre par la suite ce sémaphore ; ce dernier processus sera débloqué quand le premier rendra (incrémente de 1) le sémaphore. Voyons comment gérer les sémaphores sur un système UNIX (celle ci serait très semblable sur un système window's). Les fonctions C Voici les fonctions qui permettent la gestion des sémaphores. Elles viennent de la librairie Inter Process Communication. Vous pouvez avoir de plus amples renseignements en utilisant la commandeman. D’abord, quelques fichiers de déclaration : #include <unistd.h> #include <sys/ipc.h> #include <sys/sem.h> D'abord, il faut générer une clé unique permettant de repérer de façon univoque la ressource du système (ici un fichier) : key_t cle; int er ; cle=ftok("fichier.txt",0); if(cle==(key_t) 1) { perror ("erreur ftok\n");exit (1); } Ensuite, les sémaphores sont gérés au niveau du système par ensemble. Ici nous avons besoins de 1 seul sémaphore, donc créons un ensemble contenant 1 sémaphore avec les droits de modifications et de consultation pour tout le monde soit_rw_rw_rw ou 0666 en octal (r=4, w=2 et x=1): int semid ; semid=semget(cle,1,IPC_CREAT|0666); if(semid==1) { perror("erreur semget\n");exit(1); } La fonction semget permet aussi de récupérer un identifiant de sémaphore si il en existe un connu du système associé à la clé. Dans ce cas le troisième argument est 0.
Initialisons à 1 de notre sémaphore (qui est le sémaphore n° 0 de l'ensemble ) : union semun { intval; structsemid_ds *buf; ushort*array;
Ensi de CaenPage 3 / 6 TP 2A instrumentation / microélectroniquePhL 18/11/04 tp_se_2a.sxw }arg; arg.val = 1 ; er=semctl(semid,0,SETVAL,arg); if (er==1) {perror("erreur semctl\n");exit(1);} La fonction semctl permet d'effectuer des opérations de contrôle les sémaphores. On peut par exemple effacer un ensemble de sémaphor en passant la valeur IPC_RMID à l'argument 3.
Voilà une fonction permettant de rendre le sémaphore no de l' ensemble semid : void rendre (int semid, int no) { struct sembuf op[1]; int er ; op[0].sem_num=no;// semaphore no op[0].sem_op=1;// libération (à mettre à –1 pour une prise) op[0].sem_flg=0;// l'operation de prise sera bloquante er=semop (semid,op,1); if (er==1) {perror("erreur semop rendre\n");exit(1);} } La fonctionsemop (semid, op, n)permet de réalisernopérations décrites dans le tableau de structureopsur l'ensemble des sémaphores d'identifiantsemid.
Remarques : –Pour consulter les sémaphores du système : ipcs t –Pour effacer un sémaphore d'identifiantsemid: ipcrm s semid
Travail à effectuer : Écrireune fonctionvoid prendre (int semid, int no) quiprend le sémaphoreno del'ensemblesemid,similaire à la fonction rendre. Écrireun programme qui va créer un processus fils. Le père et le fils vont écrire simultanément, l’un, les 26 minuscules et l’autre, les 26 majuscules, à l’écran. Ceci devra donner le résultat suivant : A a B b C c D d …
Application On vous propose de réaliser un Wiki allégé (c'est à la mode). Un Wiki est un site web dynamique dont tout visiteur peut modifier les pages à volonté.
Il s'agit d'un concept assez récent, bien que la technologie nécessaire existe depuis plusieurs années. Le nom Wiki provient de l'hawaïen "WikiWiki" qui signifie vite. Ward Cunningham, le créateur de Wiki, a choisi ce nom pour former un diminutif à partir de "WikiWikiWeb".
Le principe est simple : il s'agit d'un modèle coopératif de rédaction de documents. Concrètement, n'importe quel visiteur a le droit de modifier la page qu'il est en train de lire. Ainsi, un premier auteur va rédiger un article, un second va le compléter, puis un visiteur va corriger une erreur qu'il aura remarquée en navigant sur le site.
L'élève attentif aura tout de suite remarqué qu'un grave problème peut survenir ! Que se passetil si deux visiteurs veulent modifier ensemble une même page ? Il faut en protéger l'accès par un sémaphore. Quant aux processus et les threads, les utiliseton ici ? Non tout le travail multitâche sera effectué par le serveur web de l'école. Mais nous les retrouverons en troisième année.
Concevez un miniwiki proposant un document HTML que quiconque pourra modifier en cliquant sur un lien en bas de la page. Si un utilisateur est déjà entrain de modifier cette page, une autre page HTML lui signifiera. Pensez à mettre vos programmes CGI dans le répertoire ~/public_html/cgibin.
Inspirezvous de la page web suivante :http://www.ensicaen.ismra.fr/~lefebvre/cgi/cotravail.html
Remarques –Vous aurez besoin de passer des informations non modifiables par l'utilisateur à vos programmes CGI. Ceci se fait de cette manière : <input type="hidden" name="Fichier" value="velo.html"> Ici, le champs fichier reçoit la valeur « velo.html »
Ensi de Caen TP 2A instrumentation / microélectronique
Page 4 / 6 PhL 18/11/04 tp_se_2a.sxw
–Vous aurez aussi besoin de définir une zone de texte éditable. Par exemple pour une zone de 20 lignes et 70 colonnes : <TEXTAREA ROWS=20 COLS=70 NAME="docu"> –est modifiée, si l'utilisateur essaye de la voir de nouveau avec son navigateur, il ne verra pas lesLorsqu'une page modifications. En effet, pour accélérer l'accèsà internet les navigateurs gardent en mémoire (cache) les pages web, et c'est cette dernière qui est affichée. On peut préciser au navigateur de ne pas stocker en cache une page. Ceci se fait en modifiant l'entête HTTP. A la place d'écrire : "contenttype:text/html\n\n" on écrira "contenttype:text/html\n" "CacheControl: nostore, nocache, mustrevalidate\n\n" –La fonction perror renvoie des informations pertinentes sur les sémaphores en cas de problèmes sur leur création ou sur les opérations que l'on effectue. Mais perror envoie sont résultat sur la sortie standard et non pas sur le navigateur du client. Écrivez donc une fonction perreur qui permet d'envoyer le résultat de perror sur le navigateur.
–Lorsqu'un programme CGI reçoit une chaîne de caractère, celle ci a subit un traitement particulier. Les espaces on été transformés en '+' et les caractères accentués par "%XY" avec XY le code ascii du caractère. Écrivez une fonction qui retransforme cette chaîne en la chaîne d'origine.
Annexes :Extrait de la documentation Linux sur les threads :
AUTEUR XavierLeroy <Xavier.Leroy@inria.fr> This is release 0.7 (late beta) of LinuxThreads, a BiCapitalized implementation of the Posix 1003.1c "pthread" interface for Linux.
LinuxThreads provides kernellevel threads: each thread is a separate Unix process, sharing its address space with the other threads through the new system call clone(). Scheduling between threads is handled by the kernel scheduler, just like scheduling between Unix processes.
USING LINUX THREADS:
gcc D_REENTRANT ... lpthread
rem : Threads share pretty much everything they should share according to the standard: memory space, file descriptors, signal handlers, current working directory, etc. One thing that they do not share is their pid's and parent pid's. According to the standard, they should have the same, but that's one thing we cannot achieve in this implementation (until the CLONE_PID flag to clone() becomes usable).
The stacks for the threads are allocated high in the memory space, below the stack of the initial process, and spaced 2M apart. Stacks are allocated with the "grow on demand" flag, so they don't use much virtual space initially (4k, currently), but can grow up to 2M if needed.
Reserving such a large address space for each thread means that, on a 32bit architecture, no more than about 1000 threads can coexist (assuming a 2Gb address space for user processes), but this is reasonable, since each thread uses up one entry in the kernel's process table, which is usually limited to 512 processes. ____________________________________ NOM pthread_create créé un nouveau thread
SYNOPSIS #include<pthread.h>
intpthread_create(pthread_t * thread,pthread_attr_t * attr, void * (*start_routine)(void*), void * arg);
DESCRIPTION pthread_createcréé un nouveau thread s'éxécutant concurremment avec le threadappelant. Le nouveau thread exécute la fonction start_routine en luipassant arg comme premier argument. Le nouveau thread s'achève soit explicitementen appelant pthread_exit(3), ou implicitement lorsque la fonctionstart_routine s'achève. Ce dernier cas est équivalent à appelérpthread_exit(3) avec la valeur renvoyée par start_routine comme codede sortie. _____________________________________ NOM pthread_join attend la mort d'un autre thread
SYNOPSIS #include<pthread.h>
intpthread_join(pthread_t th, void **thread_return);
DESCRIPTION pthread_joinsuspend l'exécutiondu thread appelant jusqu'à ce que le threadidentifié par th achève son exécution, soit en appelant pthread_exit(3)soit après avoir été annullé.
Sithread_return ne vaut pasNULL, la valeur renvoyée par th y sera enregistrée.Cette valeur sera soit l'argumentpassé à pthread_exit(3),soit PTHREAD_CANCELED si le thread th a été annullé.
Le thread joint th doit êtredans l'état joignable: il ne doit pas avoirété détaché par pthread_detach(3) ou par l'attribut PTHREAD_CRE ATE_DETACHEDlors de sa création par pthread_create(3).
Quandl'exécution d'un thread joignable s'achève, ses ressources mémoires(descripteur dethread et pile) ne sont pas désallouées jusqu'àce qu'un autre thread lejoigne en utilisant pthread_join. Aussi,pthread_join doit êtreappelée une fois pour chaque thread joignablepour éviter des "fuites" de mémoire.
Auplus un seul thread peut attendre la mort d'un thread donné. Appeler
Ensi de Caen TP 2A instrumentation / microélectronique
pthread_joinsur un thread th dont un autre thread attend déjàla fin renvoieune erreur. ________________________________________
NOM sched_setschedulerla politique, sched_getscheduler Lire / fixer d'ordonnancementet ses paramètres.
SYNOPSIS #include<sched.h>
intsched_setscheduler(pid_t pid, int policy, const structsched_param *p);
intsched_getscheduler(pid_t pid);
structsched_param { ... intsched_priority; ... };
DESCRIPTION sched_setschedulerfixe à la fois la politique d'ordonnancement et ses paramètrespour le processus identifié par pid.Si pid vautzéro, la politiquedu processus en cours sera fixée.L'interprétation du paramètrep dépend de la politique employée. Actuellement il y atrois politiquesproposées par Linux : SCHED_FIFO, SCHED_RR, et SCHED_OTHER. Leurssémantiques respectives sont décrites cidessous.
sched_getschedulerlit la politiqued'ordonnancement et ses paramètres pourle processus identifié par pid.Si pid vaut zéro, la politique du processusen cours sera récupérée.
Politiquesd'ordonnancement L'ordonnanceurest la partie du noyau qui décide quel processus prêt va êtreexécuté ensuite. L'ordonnanceur de Linux propose trois politiques différentes,une pour les processus classiques, et deux pour les appli cationsà vocation tempsréel.
Unevaleur de prioritéstatique sched_priority est assignée à chaque processus,et ne peut être modifiée quepar l'intermédiaire d'appels systèmes.Conceptuellement, l'ordonnanceur dispose d'une liste de tous lesprocessus prêtspour chaque valeur possible de sched_priority (sched_priorityest dans l'intervalle 0 à 99).
Afinde déterminer quel processusdoit s'exécuter ensuite, l'ordon nanceurde Linux recherche la liste nonvidede plus haute priorité statiqueet prend leprocessus en tête de cette liste.La politique d'ordonnancementdétermine pour chaque processusl'emplacement où il sera inséré dans la liste contenant les processus de même priorité sta tique,et comment il se déplacera dans cette liste.
SCHED_OTHERest l'ordonnancement universeltempspartagé par défaut, utilisépar la plupart des processus. SCHED_FIFOet SCHED_RR sont prévuspour des applications tempsréelqui nécessitent un contrôle précisde la sélection des processus prêts.
Lesprocessus ordonnancésavec SCHED_OTHER doivent avoir une priorité statiquede 0, ceux ordonnancéspar SCHED_FIFO ou SCHED_RR peuvent avoirune prioritéstatique dans l'intervalle 1 à 99.Seuls les pro cessusdisposant de privilèges SuperUser peuvent obtenir unepriorité statiquesupérieure a 0 afin d'être ordonnancé parSCHED_FIFO ou SCHED_RR.
Lesappels systèmessched_get_priority_min et sched_get_priority_max permettentde déterminerl'intervalle de priorités valides de manière portablesur les systèmes conformes à la norme POSIX.1b.
Toutordonnancement est préemptif : Si un processus avecune priorité statiqueplus élevée devient prêt, le processus en cours est interrompu etretourne dans saliste d'attente. La politique d'ordonnancement déterminesimplement l'ordre utilisé dans une liste de processus prêts avecdes priorités statiques égales.
Page 5 / 6 PhL 18/11/04 tp_se_2a.sxw
SCHED_FIFO:Ordonnancement FirstInFirst out (premier arrivé, premier servi) SCHED_FIFOne peut être utilisé qu'avec des priorités statiques supérieuresà 0, ce qui signifie quedès qu'un processus SCHED_FIFO devientprêt, un processus normal SCHED_OTHER en cours d'exécution sera interrompu.SCHED_FIFO est un ordonnancement simple à base de tranches detemps. Pour les processus ordonnancéspar SCHED_FIFO les règles suivantessont appliquées :
Unprocessus SCHED_FIFO qui a été préempté par unautre processus de prioritésupérieure restera en tête de sa listeet reprendra son exécutiondès que tous les processus de prioritéssupérieures sont à nouveaubloqués.
Quandun processusSCHED_FIFO devient prêt, il est inséré à la fin de saliste.
Unappel système sched_setscheduler ou sched_setparam placerale pro cessusSCHED_FIFO identifié par pid à la fin de sa liste s'il est prêt.
Unprocessus appelant sched_yield sera placé à la fin de sa liste.
Aucunautre évènement ne modifiera l'ordre des listes de priorités sta tiques égales avec SCHED_FIFO.
Unprocessus SCHED_FIFO s'exécute jusqu'à ce qu'il soit bloqué par une opérationd'entrée/sortie, qu'il soit préempté par un processus de pri oritésupérieure, ou qu'il appelle sched_yield.
SCHED_RR:Ordonnancement Round Robin SCHED_RRest une amélioration simple de la politique SCHED_FIFO. Tout cequi est décrit pour SCHED_FIFO s'applique aussi à SCHED_RR, sauf que chaqueprocessus nedispose que d'une tranche temporelle limitée pour sonexécution. Siun processus sous politique SCHED_RRs'est exécuté depuisune durée supérieure ou égaleà la tranche temporelle (time quantum),il sera placé à la fin de la liste de sa priorité.
Unprocessus sous SCHED_RR qui a été préempté par un processus de pri oritésupérieure terminera sa tranche de temps lorsqu'il reprendra son exécution.la longueur du time quantumpeut être lue avec sched_rr_get_interval.
SCHED_OTHER:Ordonnancement tempspartagé par défaut Lapolitique SCHED_OTHER nepeut être utilisée qu'avec des priorités statiquesà 0. C'est lapolitique standard de l'ordonnanceur temps partagéde Linux, etest conçue pour tous les processus ne réclamant pasde fonctionnalités tempsréel.
Leprocessus à exécuter est choisi dans la liste des processus depri oritésstatiques nulles, en utilisantune priorité dynamique qui ne s'appliqueque dans cette liste.
Lapriorité dynamique est basée sur la valeur de "gentillesse" dupro cessus(fixée avec les appels systèmesnice ou setpriority) et est incrémentéeà chaque time quantum où le processusest prêt mais non sélectionnépar l'ordonnanceur.Ceci garantit une progression équitablede tous les processus SCHED_OTHER.
Tempsde réponse Unprocessus de haute priorité bloqué en attente d'entrées/sortiesest affectéd'un certaintemps de réponse avant d'être sélectionné à nou veau.Le concepteur d'ungestionnaire de périphérique peut réduire grandementce temps de réponse en utilisant un gestionnaire d'interrup tionslentes comme décrit dans request_irq(9).
Divers Lesprocessus fils héritent de lapolitique d'ordonnancement et des paramètresassociés lors d'un fork.
Leverrouillage de pagesen mémoire est généralement nécessaire pour les processus temps réel afin d'éviter les délais depagination. Ceci
Ensi de Caen TP 2A instrumentation / microélectronique
peutêtre effectué avec mlock(2) ou mlockall(2).
Commeune boucle sansfin non bloquante dans un processus ordonnancé sousune politique SCHED_FIFO ou SCHED_RRbloquera indéfiniment tous lesprocessus avec une priorité plus faible, le développeur d'applica tionstempsréel devrait toujours conserver sur uneconsole un shell ordonnancéavec une priorité supérieure à celle del'application testée.
Cecipermettra un kill((1) d'urgence des applications testées qui ne se bloquentpas ou qui ne se terminent pas comme prévu.Comme les proces sussous SCHED_FIFO et SCHED_RR peuvent préempter les autres processus normauxpour toujours, seuls les processusSuperUser ont le droit d'activerces politiques sous Linux.
Lessystèmes POSIX sur lesquels sched_setscheduleret sched_getsched ulersont disponibles définissent _POSIX_PRIORITY_SCHEDULING dans <unistd.h>.
VALEUR RENVOYÉE sched_setschedulerrenvoie 0 s'il réussit sched_getscheduler renvoie la politiquepour le processus s'il réussit.
Encas d'échec, 1 est renvoyé et errno contient le code d'erreur.
ERREURS ESRCHLe processus numéro pid n'existe pas.
EPERMLe processusappelant n'a pas les privilèges nécessaires. Seul lesprocessus SuperUser peuvent activerles politiques SCHED_FIFOet SCHED_RR.Le processus appelant sched_setsched
Page 6 / 6 PhL 18/11/04 tp_se_2a.sxw
ulerdoit avoir un UID effectif égal à celui du processuspid, ouêtre SuperUser.
EINVALLa valeur de politique d'ordonnancement policy n'existe pas, ou leparamètre p n'a pas de signification pour la politiquepol icy.
CONFORMITÉ POSIX.1b(POSIX.4)
BOGUES SousLinux 1.3.81,SCHED_RR n'a pas été testé totalement, et ne se com portepeut être pas exactement comme décrit cidessus.
VOIR AUSSI sched_setparam(2),sched_getparam(2), sched_yield(2), sched_get_prior ity_max(2), sched_get_priority_min(2), nice(2), setpriority(2), getpri ority(2),mlockall(2), munlockall(2), mlock(2), munlock(2).
Programmingfor the realworld POSIX.4 by Bill O. Gallmeister, O'Reilly& Associates, Inc., ISBN 1565920740 IEEEStd 1003.1b1993 (POSIX.1b standard) ISO/IEC99451:1996 C'est une nouvelle révision 1996 de POSIX.1 qui regroupeen un seul standard les normes POSIX.1(1990),POSIX.1b (1993), POSIX.1c(1995),et POSIX.1i(1995).
TRADUCTION ChristopheBlaess, 1997.
