1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.16
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction de surveillance d'un processus fils.
29: Elle tourne dans un thread séparé et ferme les descripteurs lors
30: de la mort du fils.
31: ================================================================================
32: Entrées : pointeur sur une structure
33: --------------------------------------------------------------------------------
34: Sorties :
35: --------------------------------------------------------------------------------
36: Effets de bord : néant
37: ================================================================================
38: */
39:
40: void *
41: surveillance_processus(void *argument)
42: {
43: int iostat;
44: int status;
45:
46: integer8 nombre_donnees;
47:
48: logical1 drapeau;
49: logical1 drapeau_fin;
50: logical1 drapeau_fin_scrutation;
51: logical1 drapeau_interruptions_traitees;
52: logical1 drapeau_objets_traites;
53:
54: pid_t pid;
55: pid_t pid_candidat;
56:
57: pthread_t tid_candidat;
58:
59: sigset_t masque;
60:
61: ssize_t longueur_ecriture;
62:
63: struct_descripteur_thread *s_argument_thread;
64:
65: struct_liste_chainee *l_element_courant;
66: struct_liste_chainee *l_element_precedent;
67:
68: struct_processus *s_etat_processus;
69:
70: struct timespec attente;
71:
72: unsigned char caractere;
73:
74: unsigned int tampon_erreur;
75:
76: sigemptyset(&masque);
77: sigaddset(&masque, SIGINJECT);
78: sigaddset(&masque, SIGFSTOP);
79: sigaddset(&masque, SIGFABORT);
80: sigaddset(&masque, SIGURG);
81: sigaddset(&masque, SIGALRM);
82: sigaddset(&masque, SIGCONT);
83: sigaddset(&masque, SIGINT);
84: pthread_sigmask(SIG_BLOCK, &masque, NULL);
85:
86: s_argument_thread = argument;
87: s_etat_processus = (*s_argument_thread).s_etat_processus;
88:
89: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
90: {
91: (*s_etat_processus).erreur_systeme = d_es_processus;
92: BUG(1, uprintf("General mutex error!\n"));
93: }
94:
95: insertion_thread_surveillance(s_etat_processus, s_argument_thread);
96:
97: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
98: {
99: (*s_etat_processus).erreur_systeme = d_es_processus;
100: BUG(1, uprintf("General mutex error!\n"));
101: }
102:
103:
104: attente.tv_sec = 0;
105: attente.tv_nsec = GRANULARITE_us * 1000;
106:
107: status = 0;
108:
109: drapeau_interruptions_traitees = d_faux;
110: drapeau_objets_traites = d_faux;
111:
112: if ((*s_etat_processus).debug == d_vrai)
113: if (((*s_etat_processus).type_debug &
114: d_debug_processus) != 0)
115: {
116: if ((*s_argument_thread).processus_detache == d_vrai)
117: {
118: if ((*s_etat_processus).langue == 'F')
119: {
120: printf("[%d] Lancement du thread de surveillance du"
121: " processus %d\n", (int) getpid(),
122: (int) (*s_argument_thread).pid);
123: }
124: else
125: {
126: printf("[%d] Start monitoring of process %d\n", (int) getpid(),
127: (int) (*s_argument_thread).pid);
128: }
129: }
130: else
131: {
132: if ((*s_etat_processus).langue == 'F')
133: {
134: printf("[%d] Lancement du thread de surveillance du"
135: " thread %llu\n", (int) getpid(), (unsigned long long)
136: (*s_argument_thread).tid);
137: }
138: else
139: {
140: printf("[%d] Start monitoring of thread %llu\n",
141: (int) getpid(), (unsigned long long)
142: (*s_argument_thread).tid);
143: }
144: }
145:
146: fflush(stdout);
147: }
148:
149: /*
150: * On attend une donnée fictive pour être sûr que le processus fils
151: * est bien démarré.
152: */
153:
154: while(read_atomic(s_etat_processus,
155: (*s_argument_thread).pipe_nombre_objets_attente[0],
156: &caractere, sizeof(caractere)) == 0)
157: {
158: if ((*s_etat_processus).var_volatile_requete_arret != 0)
159: {
160: drapeau_objets_traites = d_vrai;
161: drapeau_interruptions_traitees = d_vrai;
162: }
163:
164: nanosleep(&attente, NULL);
165: }
166:
167: do
168: {
169: if ((*s_argument_thread).processus_detache == d_vrai)
170: {
171: /*
172: * Le processus est un processus détaché.
173: */
174:
175: // Scrutation de l'envoi de données par le fils.
176:
177: pid_candidat = 0;
178:
179: if (drapeau_objets_traites == d_vrai)
180: {
181: nanosleep(&attente, NULL);
182: }
183: else if ((iostat = read_atomic(s_etat_processus,
184: (*s_argument_thread).pipe_nombre_objets_attente[0],
185: &pid_candidat, sizeof(pid_candidat))) == 0)
186: {
187: // Rien dans le pipe
188:
189: nanosleep(&attente, NULL);
190: }
191: else if (iostat != sizeof(pid_candidat))
192: {
193: (*s_etat_processus).erreur_systeme_processus_fils =
194: d_es_processus;
195: }
196: else
197: {
198: // Un pid est dans le pipe. On vérifie que les deux pids
199: // correspondent.
200:
201: if (pid_candidat == -2)
202: {
203: drapeau_objets_traites = d_vrai;
204: }
205: else if (pid_candidat == -1)
206: {
207: }
208: else if ((iostat = read_atomic(s_etat_processus,
209: (*s_argument_thread).pipe_nombre_objets_attente[0],
210: &pid_candidat, sizeof(pid_candidat))) ==
211: sizeof(pid_candidat))
212: {
213: if ((*s_argument_thread).pid != pid_candidat)
214: {
215: (*s_etat_processus).erreur_systeme_processus_fils =
216: d_es_processus;
217: BUG(1, printf("Spurious process identifier"));
218: }
219:
220: // Un objet supplémentaire est dans le pipe correspondant
221: // au processus surveillé par ce thread.
222:
223: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
224: {
225: (*s_etat_processus).erreur_systeme_processus_fils =
226: d_es_processus;
227: }
228: else
229: {
230: l_element_courant = (struct_liste_chainee *)
231: (*s_etat_processus).l_base_pile_processus;
232:
233: while(l_element_courant != NULL)
234: {
235: if ((*(*((struct_processus_fils *)
236: (*(*l_element_courant).donnee).objet))
237: .thread).processus_detache == d_faux)
238: {
239: l_element_courant = (*l_element_courant)
240: .suivant;
241: continue;
242: }
243:
244: if ((*(*((struct_processus_fils *)
245: (*(*l_element_courant).donnee).objet))
246: .thread).pid == pid_candidat)
247: {
248: if ((*s_etat_processus).debug == d_vrai)
249: if (((*s_etat_processus).type_debug &
250: d_debug_processus) != 0)
251: {
252: if ((*s_etat_processus).langue == 'F')
253: {
254: printf("[%d] Données en provenance "
255: "du processus %d\n",
256: (int) getpid(),
257: (int) (*s_argument_thread).pid);
258: fflush(stdout);
259: }
260: else
261: {
262: printf("[%d] Data from process %d\n",
263: (int) getpid(),
264: (int) (*s_argument_thread).pid);
265: fflush(stdout);
266: }
267: }
268:
269: if (pthread_mutex_lock(
270: &((*(*((struct_processus_fils *)
271: (*(*l_element_courant).donnee).objet))
272: .thread).mutex)) != 0)
273: {
274: (*s_etat_processus).erreur_systeme =
275: d_es_processus;
276: }
277:
278: (*(*((struct_processus_fils *)
279: (*(*l_element_courant).donnee).objet))
280: .thread).nombre_objets_dans_pipe++;
281:
282: if (pthread_mutex_unlock(
283: &((*(*((struct_processus_fils *)
284: (*(*l_element_courant).donnee).objet))
285: .thread).mutex)) != 0)
286: {
287: (*s_etat_processus).erreur_systeme =
288: d_es_processus;
289: }
290:
291: while((longueur_ecriture =
292: write_atomic(s_etat_processus,
293: (*(*((struct_processus_fils *)
294: (*(*l_element_courant).donnee).objet))
295: .thread).pipe_acquittement[1], "-",
296: sizeof(unsigned char))) !=
297: sizeof(unsigned char))
298: {
299: if (longueur_ecriture == -1)
300: {
301: (*s_etat_processus)
302: .erreur_systeme_processus_fils =
303: d_es_processus;
304: }
305: }
306:
307: if ((*s_etat_processus).debug == d_vrai)
308: if (((*s_etat_processus).type_debug &
309: d_debug_processus) != 0)
310: {
311: if ((*s_etat_processus).langue == 'F')
312: {
313: printf("[%d] Données acquittées "
314: "en provenance du "
315: "processus %d\n",
316: (int) getpid(),
317: (int) (*s_argument_thread).pid);
318: fflush(stdout);
319: }
320: else
321: {
322: printf("[%d] Data acknowklegment "
323: "from process %d\n",
324: (int) getpid(),
325: (int) (*s_argument_thread).pid);
326: fflush(stdout);
327: }
328: }
329:
330: break;
331: }
332:
333: l_element_courant = (*l_element_courant).suivant;
334: }
335:
336: BUG(l_element_courant == NULL,
337: printf("Process or thread not found"));
338:
339: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
340: != 0)
341: {
342: (*s_etat_processus).erreur_systeme_processus_fils =
343: d_es_processus;
344: }
345:
346: pthread_kill((*s_argument_thread).thread_pere,
347: SIGINJECT);
348: }
349: }
350: else
351: {
352: (*s_etat_processus).erreur_systeme_processus_fils =
353: d_es_processus;
354: }
355: }
356:
357: // Scrutation de l'envoi d'interruptions par le fils.
358:
359: if (drapeau_interruptions_traitees == d_vrai)
360: {
361: nanosleep(&attente, NULL);
362: }
363: else if ((iostat = read_atomic(s_etat_processus,
364: (*s_argument_thread).pipe_nombre_interruptions_attente[0],
365: &pid_candidat, sizeof(pid_candidat))) == 0)
366: {
367: // Rien dans le pipe
368:
369: nanosleep(&attente, NULL);
370: }
371: else if (iostat != sizeof(pid_candidat))
372: {
373: (*s_etat_processus).erreur_systeme_processus_fils =
374: d_es_processus;
375: }
376: else
377: {
378: // Un pid est dans le pipe. On vérifie que les deux pids
379: // correspondent.
380:
381: if (pid_candidat == -2)
382: {
383: drapeau_interruptions_traitees = d_vrai;
384: }
385: else if (pid_candidat == -1)
386: {
387: }
388: else if ((iostat = read_atomic(s_etat_processus,
389: (*s_argument_thread).pipe_nombre_interruptions_attente
390: [0], &pid_candidat, sizeof(pid_candidat)))
391: == sizeof(pid_candidat))
392: {
393: if ((*s_argument_thread).pid != pid_candidat)
394: {
395: (*s_etat_processus).erreur_systeme_processus_fils =
396: d_es_processus;
397: BUG(1, printf("Spurious interrupt"));
398: }
399:
400: // Une interruption supplémentaire est dans le pipe
401: // correspondant au processus surveillé par ce thread.
402:
403: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
404: {
405: (*s_etat_processus).erreur_systeme_processus_fils =
406: d_es_processus;
407: }
408: else
409: {
410: l_element_courant = (struct_liste_chainee *)
411: (*s_etat_processus).l_base_pile_processus;
412:
413: while(l_element_courant != NULL)
414: {
415: if ((*(*((struct_processus_fils *)
416: (*(*l_element_courant).donnee).objet))
417: .thread).processus_detache == d_faux)
418: {
419: l_element_courant = (*l_element_courant)
420: .suivant;
421: continue;
422: }
423:
424: if ((*(*((struct_processus_fils *)
425: (*(*l_element_courant).donnee).objet))
426: .thread).pid == pid_candidat)
427: {
428: if ((*s_etat_processus).debug == d_vrai)
429: if (((*s_etat_processus).type_debug &
430: d_traitement_interruption) != 0)
431: {
432: if ((*s_etat_processus).langue == 'F')
433: {
434: printf("[%d] Interrution logicielle "
435: "en provenance du processus "
436: "%d\n", (int) getpid(),
437: (int) (*s_argument_thread).pid);
438: fflush(stdout);
439: }
440: else
441: {
442: printf("[%d] Software interrupt "
443: "from process %d\n",
444: (int) getpid(),
445: (int) (*s_argument_thread).pid);
446: fflush(stdout);
447: }
448: }
449:
450: if (pthread_mutex_lock(
451: &((*(*((struct_processus_fils *)
452: (*(*l_element_courant).donnee).objet))
453: .thread).mutex)) != 0)
454: {
455: (*s_etat_processus).erreur_systeme =
456: d_es_processus;
457: }
458:
459: (*(*((struct_processus_fils *)
460: (*(*l_element_courant).donnee)
461: .objet)).thread)
462: .nombre_interruptions_dans_pipe++;
463:
464: if (pthread_mutex_unlock(
465: &((*(*((struct_processus_fils *)
466: (*(*l_element_courant).donnee).objet))
467: .thread).mutex)) != 0)
468: {
469: (*s_etat_processus).erreur_systeme =
470: d_es_processus;
471: }
472:
473: (*s_etat_processus)
474: .nombre_interruptions_non_affectees++;
475:
476: while((longueur_ecriture =
477: write_atomic(s_etat_processus,
478: (*(*((struct_processus_fils *)
479: (*(*l_element_courant).donnee).objet))
480: .thread).pipe_acquittement[1], "-",
481: sizeof(unsigned char))) !=
482: sizeof(unsigned char))
483: {
484: if (longueur_ecriture == -1)
485: {
486: (*s_etat_processus)
487: .erreur_systeme_processus_fils =
488: d_es_processus;
489: }
490: }
491:
492: if ((*s_etat_processus).debug == d_vrai)
493: if (((*s_etat_processus).type_debug &
494: d_traitement_interruption) != 0)
495: {
496: if ((*s_etat_processus).langue == 'F')
497: {
498: printf("[%d] Interruption logicielle "
499: "acquittée en provenance "
500: "du processus %d\n",
501: (int) getpid(),
502: (int) (*s_argument_thread).pid);
503: fflush(stdout);
504: }
505: else
506: {
507: printf("[%d] Software interrupt "
508: "acknowklegment from "
509: "process %d\n",
510: (int) getpid(),
511: (int) (*s_argument_thread).pid);
512: fflush(stdout);
513: }
514: }
515:
516: break;
517: }
518:
519: l_element_courant = (*l_element_courant).suivant;
520: }
521:
522: BUG(l_element_courant == NULL,
523: printf("Process or thread not found"));
524:
525: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
526: != 0)
527: {
528: (*s_etat_processus).erreur_systeme_processus_fils =
529: d_es_processus;
530: }
531:
532: pthread_kill((*s_argument_thread).thread_pere,
533: SIGINJECT);
534: }
535: }
536: else
537: {
538: (*s_etat_processus).erreur_systeme_processus_fils =
539: d_es_processus;
540: }
541: }
542:
543: if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0)
544: {
545: break;
546: }
547:
548: drapeau_fin_scrutation = (!WIFEXITED(status)) ||
549: (!WIFSIGNALED(status)) || (pid == 0);
550:
551: if (WIFEXITED(status))
552: {
553: if (WEXITSTATUS(status) == (0xFF & EXIT_FAILURE))
554: {
555: (*s_etat_processus).erreur_systeme = d_es_processus;
556: }
557: }
558: }
559: else
560: {
561: /*
562: * Le processus n'est pas détaché.
563: */
564:
565: // Scrutation de l'envoi de données par le fils.
566:
567: tid_candidat = (pthread_t) 0;
568:
569: if (drapeau_objets_traites == d_vrai)
570: {
571: nanosleep(&attente, NULL);
572: }
573: else if ((iostat = read_atomic(s_etat_processus,
574: (*s_argument_thread).pipe_nombre_objets_attente[0],
575: &tid_candidat, sizeof(tid_candidat))) == 0)
576: {
577: // Rien dans le pipe
578:
579: nanosleep(&attente, NULL);
580: }
581: else if (iostat != sizeof(tid_candidat))
582: {
583: (*s_etat_processus).erreur_systeme_processus_fils =
584: d_es_processus;
585: }
586: else
587: {
588: // Un pid est dans le pipe. On vérifie que les deux pids
589: // correspondent.
590:
591: if (tid_candidat == (pthread_t) -2)
592: {
593: drapeau_objets_traites = d_vrai;
594: }
595: else if (tid_candidat == (pthread_t) -1)
596: {
597: }
598: else if ((iostat = read_atomic(s_etat_processus,
599: (*s_argument_thread).pipe_nombre_objets_attente[0],
600: &tid_candidat, sizeof(tid_candidat))) ==
601: sizeof(tid_candidat))
602: {
603: if (pthread_equal((*s_argument_thread).tid,
604: tid_candidat) == 0)
605: {
606: (*s_etat_processus).erreur_systeme_processus_fils =
607: d_es_processus;
608: BUG(1, printf("Spurious thread identifier"));
609: }
610:
611: // Un objet supplémentaire est dans le pipe correspondant
612: // au processus surveillé par ce thread.
613:
614: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
615: {
616: (*s_etat_processus).erreur_systeme_processus_fils =
617: d_es_processus;
618: }
619: else
620: {
621: l_element_courant = (struct_liste_chainee *)
622: (*s_etat_processus).l_base_pile_processus;
623:
624: while(l_element_courant != NULL)
625: {
626: if ((*(*((struct_processus_fils *)
627: (*(*l_element_courant).donnee).objet))
628: .thread).processus_detache == d_vrai)
629: {
630: l_element_courant = (*l_element_courant)
631: .suivant;
632: continue;
633: }
634:
635: if (pthread_equal((*(*((struct_processus_fils *)
636: (*(*l_element_courant).donnee).objet))
637: .thread).tid, tid_candidat) != 0)
638: {
639: if ((*s_etat_processus).debug == d_vrai)
640: if (((*s_etat_processus).type_debug &
641: d_debug_processus) != 0)
642: {
643: if ((*s_etat_processus).langue == 'F')
644: {
645: printf("[%d] Données en provenance "
646: "du thread %llu\n",
647: (int) getpid(),
648: (unsigned long long)
649: (*s_argument_thread).tid);
650: fflush(stdout);
651: }
652: else
653: {
654: printf("[%d] Data from thread %llu\n",
655: (int) getpid(),
656: (unsigned long long)
657: (*s_argument_thread).tid);
658: fflush(stdout);
659: }
660: }
661:
662: if (pthread_mutex_lock(
663: &((*(*((struct_processus_fils *)
664: (*(*l_element_courant).donnee).objet))
665: .thread).mutex)) != 0)
666: {
667: (*s_etat_processus).erreur_systeme =
668: d_es_processus;
669: }
670:
671: (*(*((struct_processus_fils *)
672: (*(*l_element_courant).donnee).objet))
673: .thread).nombre_objets_dans_pipe++;
674:
675: if (pthread_mutex_unlock(
676: &((*(*((struct_processus_fils *)
677: (*(*l_element_courant).donnee).objet))
678: .thread).mutex)) != 0)
679: {
680: (*s_etat_processus).erreur_systeme =
681: d_es_processus;
682: }
683:
684: while((longueur_ecriture =
685: write_atomic(s_etat_processus,
686: (*(*((struct_processus_fils *)
687: (*(*l_element_courant).donnee).objet))
688: .thread).pipe_acquittement[1], "-",
689: sizeof(unsigned char))) !=
690: sizeof(unsigned char))
691: {
692: if (longueur_ecriture == -1)
693: {
694: (*s_etat_processus)
695: .erreur_systeme_processus_fils =
696: d_es_processus;
697: }
698: }
699:
700: if ((*s_etat_processus).debug == d_vrai)
701: if (((*s_etat_processus).type_debug &
702: d_debug_processus) != 0)
703: {
704: if ((*s_etat_processus).langue == 'F')
705: {
706: printf("[%d] Données acquittées "
707: "en provenance du thread "
708: "%llu\n", (int) getpid(),
709: (unsigned long long)
710: (*s_argument_thread).tid);
711: fflush(stdout);
712: }
713: else
714: {
715: printf("[%d] Data acknowklegment "
716: "from thread %llu\n",
717: (int) getpid(),
718: (unsigned long long)
719: (*s_argument_thread).tid);
720: fflush(stdout);
721: }
722: }
723:
724: break;
725: }
726:
727: l_element_courant = (*l_element_courant).suivant;
728: }
729:
730: BUG(l_element_courant == NULL,
731: printf("Process or thread not found\n"));
732:
733: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
734: != 0)
735: {
736: (*s_etat_processus).erreur_systeme_processus_fils =
737: d_es_processus;
738: }
739: }
740: }
741: else
742: {
743: (*s_etat_processus).erreur_systeme_processus_fils =
744: d_es_processus;
745: }
746: }
747:
748: // Scrutation de l'envoi d'interruptions par le fils.
749:
750: if (drapeau_interruptions_traitees == d_vrai)
751: {
752: nanosleep(&attente, NULL);
753: }
754: else if ((iostat = read_atomic(s_etat_processus,
755: (*s_argument_thread).pipe_nombre_interruptions_attente[0],
756: &tid_candidat, sizeof(tid_candidat))) == 0)
757: {
758: // Rien dans le pipe
759:
760: nanosleep(&attente, NULL);
761: }
762: else if (iostat != sizeof(tid_candidat))
763: {
764: (*s_etat_processus).erreur_systeme_processus_fils =
765: d_es_processus;
766: }
767: else
768: {
769: // Un pid est dans le pipe. On vérifie que les deux pids
770: // correspondent.
771:
772: if (tid_candidat == (pthread_t) -2)
773: {
774: drapeau_interruptions_traitees = d_vrai;
775: }
776: else if (tid_candidat == (pthread_t) -1)
777: {
778: }
779: else if ((iostat = read_atomic(s_etat_processus,
780: (*s_argument_thread).pipe_nombre_interruptions_attente
781: [0], &tid_candidat, sizeof(tid_candidat))) ==
782: sizeof(tid_candidat))
783: {
784: if (pthread_equal((*s_argument_thread).tid,
785: tid_candidat) == 0)
786: {
787: (*s_etat_processus).erreur_systeme_processus_fils =
788: d_es_processus;
789: BUG(1, printf("Spurious interrupt"));
790: }
791:
792: // Une interruption supplémentaire est dans le pipe
793: // correspondant au processus surveillé par ce thread.
794:
795: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
796: {
797: (*s_etat_processus).erreur_systeme_processus_fils =
798: d_es_processus;
799: }
800: else
801: {
802: l_element_courant = (struct_liste_chainee *)
803: (*s_etat_processus).l_base_pile_processus;
804:
805: while(l_element_courant != NULL)
806: {
807: if ((*(*((struct_processus_fils *)
808: (*(*l_element_courant).donnee).objet))
809: .thread).processus_detache == d_vrai)
810: {
811: l_element_courant = (*l_element_courant)
812: .suivant;
813: continue;
814: }
815:
816: if (pthread_equal((*(*((struct_processus_fils *)
817: (*(*l_element_courant).donnee).objet))
818: .thread).tid, tid_candidat) != 0)
819: {
820: if ((*s_etat_processus).debug == d_vrai)
821: if (((*s_etat_processus).type_debug &
822: d_debug_processus) != 0)
823: {
824: if ((*s_etat_processus).langue == 'F')
825: {
826: printf("[%d] Interrution logicielle "
827: "en provenance du thread "
828: "%llu\n", (int) getpid(),
829: (unsigned long long)
830: (*s_argument_thread).tid);
831: fflush(stdout);
832: }
833: else
834: {
835: printf("[%d] Software interrupt "
836: "from thread %llu\n",
837: (int) getpid(),
838: (unsigned long long)
839: (*s_argument_thread).tid);
840: fflush(stdout);
841: }
842: }
843:
844: if (pthread_mutex_lock(
845: &((*(*((struct_processus_fils *)
846: (*(*l_element_courant).donnee).objet))
847: .thread).mutex)) != 0)
848: {
849: (*s_etat_processus).erreur_systeme =
850: d_es_processus;
851: }
852:
853: (*(*((struct_processus_fils *)
854: (*(*l_element_courant).donnee)
855: .objet)).thread)
856: .nombre_interruptions_dans_pipe++;
857:
858: if (pthread_mutex_unlock(
859: &((*(*((struct_processus_fils *)
860: (*(*l_element_courant).donnee).objet))
861: .thread).mutex)) != 0)
862: {
863: (*s_etat_processus).erreur_systeme =
864: d_es_processus;
865: }
866:
867: (*s_etat_processus)
868: .nombre_interruptions_non_affectees++;
869:
870: while((longueur_ecriture =
871: write_atomic(s_etat_processus,
872: (*(*((struct_processus_fils *)
873: (*(*l_element_courant).donnee).objet))
874: .thread).pipe_acquittement[1], "-",
875: sizeof(unsigned char))) !=
876: sizeof(unsigned char))
877: {
878: if (longueur_ecriture == -1)
879: {
880: (*s_etat_processus)
881: .erreur_systeme_processus_fils =
882: d_es_processus;
883: }
884: }
885:
886: if ((*s_etat_processus).debug == d_vrai)
887: if (((*s_etat_processus).type_debug &
888: d_traitement_interruption) != 0)
889: {
890: if ((*s_etat_processus).langue == 'F')
891: {
892: printf("[%d] Interruption logicielle "
893: "acquittée en provenance "
894: "du thread %llu\n",
895: (int) getpid(),
896: (unsigned long long)
897: (*s_argument_thread).tid);
898: fflush(stdout);
899: }
900: else
901: {
902: printf("[%d] Software interrupt "
903: "acknowklegment from "
904: "thread %llu\n",
905: (int) getpid(),
906: (unsigned long long)
907: (*s_argument_thread).tid);
908: fflush(stdout);
909: }
910: }
911:
912: break;
913: }
914:
915: l_element_courant = (*l_element_courant).suivant;
916: }
917:
918: BUG(l_element_courant == NULL,
919: printf("Process or thread not found"));
920:
921: if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
922: != 0)
923: {
924: (*s_etat_processus).erreur_systeme_processus_fils =
925: d_es_processus;
926: }
927: }
928: }
929: else
930: {
931: (*s_etat_processus).erreur_systeme_processus_fils =
932: d_es_processus;
933: }
934: }
935:
936: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
937: {
938: (*s_etat_processus).erreur_systeme = d_es_processus;
939: }
940:
941: if ((*s_argument_thread).thread_actif == d_faux)
942: {
943: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
944: {
945: (*s_etat_processus).erreur_systeme = d_es_processus;
946: }
947:
948: pthread_join((*s_argument_thread).tid, NULL);
949: drapeau_fin_scrutation = (0 != 0);
950: }
951: else
952: {
953: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
954: {
955: (*s_etat_processus).erreur_systeme = d_es_processus;
956: }
957:
958: drapeau_fin_scrutation = (0 == 0);
959: }
960: }
961: } while(drapeau_fin_scrutation);
962:
963: /*
964: * Le processus fils est terminé. On s'assure qu'il ne
965: * reste plus rien dans les tuyaux...
966: */
967:
968: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
969: {
970: (*s_etat_processus).erreur_systeme_processus_fils =
971: d_es_processus;
972: }
973: else
974: {
975: if ((*s_etat_processus).debug == d_vrai)
976: if (((*s_etat_processus).type_debug &
977: d_debug_processus) != 0)
978: {
979: if ((*s_argument_thread).processus_detache == d_vrai)
980: {
981: if ((*s_etat_processus).langue == 'F')
982: {
983: printf("[%d] Surveillance des tuyaux du processus %d\n",
984: (int) getpid(), (int) (*s_argument_thread).pid);
985: fflush(stdout);
986: }
987: else
988: {
989: printf("[%d] Check remaining pipes of process %d\n",
990: (int) getpid(), (int) (*s_argument_thread).pid);
991: fflush(stdout);
992: }
993: }
994: else
995: {
996: if ((*s_etat_processus).langue == 'F')
997: {
998: printf("[%d] Surveillance des tuyaux du thread %llu\n",
999: (int) getpid(), (unsigned long long)
1000: (*s_argument_thread).tid);
1001: fflush(stdout);
1002: }
1003: else
1004: {
1005: printf("[%d] Check remaining pipes of thread %llu\n",
1006: (int) getpid(), (unsigned long long)
1007: (*s_argument_thread).tid);
1008: fflush(stdout);
1009: }
1010: }
1011: }
1012:
1013: l_element_courant = (struct_liste_chainee *)
1014: (*s_etat_processus).l_base_pile_processus;
1015:
1016: if (drapeau_objets_traites == d_faux)
1017: {
1018: if ((*s_argument_thread).processus_detache == d_vrai)
1019: {
1020: while(l_element_courant != NULL)
1021: {
1022: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1023: .donnee).objet)).thread).processus_detache
1024: == d_faux)
1025: {
1026: l_element_courant = (*l_element_courant).suivant;
1027: continue;
1028: }
1029:
1030: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1031: .donnee).objet)).thread).pid ==
1032: (*s_argument_thread).pid)
1033: {
1034: while(read_atomic(s_etat_processus, (*s_argument_thread)
1035: .pipe_nombre_objets_attente[0],
1036: &pid_candidat, sizeof(pid_candidat)) ==
1037: sizeof(pid_candidat))
1038: {
1039: /*
1040: * -1 est renvoyé par l'instruction SWI
1041: */
1042:
1043: if (pid_candidat == -2)
1044: {
1045: break;
1046: }
1047: else if (pid_candidat == -1)
1048: {
1049: }
1050: else if (read_atomic(s_etat_processus,
1051: (*s_argument_thread)
1052: .pipe_nombre_objets_attente[0],
1053: &pid_candidat, sizeof(pid_candidat)) ==
1054: sizeof(pid_candidat))
1055: {
1056: if ((*s_etat_processus).debug == d_vrai)
1057: if (((*s_etat_processus).type_debug &
1058: d_debug_processus) != 0)
1059: {
1060: if ((*s_etat_processus).langue == 'F')
1061: {
1062: printf("[%d] Données en provenance du "
1063: "processus %d (processus "
1064: "arrêté)\n", (int) getpid(),
1065: (int) (*s_argument_thread).pid);
1066: fflush(stdout);
1067: }
1068: else
1069: {
1070: printf("[%d] Data from process %d "
1071: "(processus stopped)\n",
1072: (int) getpid(),
1073: (int) (*s_argument_thread).pid);
1074: fflush(stdout);
1075: }
1076: }
1077:
1078: if (pthread_mutex_lock(
1079: &((*(*((struct_processus_fils *)
1080: (*(*l_element_courant).donnee).objet))
1081: .thread).mutex)) != 0)
1082: {
1083: (*s_etat_processus).erreur_systeme =
1084: d_es_processus;
1085: }
1086:
1087: (*(*((struct_processus_fils *)
1088: (*(*l_element_courant).donnee).objet))
1089: .thread).nombre_objets_dans_pipe++;
1090:
1091: if (pthread_mutex_unlock(
1092: &((*(*((struct_processus_fils *)
1093: (*(*l_element_courant).donnee).objet))
1094: .thread).mutex)) != 0)
1095: {
1096: (*s_etat_processus).erreur_systeme =
1097: d_es_processus;
1098: }
1099: }
1100: }
1101:
1102: break;
1103: }
1104:
1105: l_element_courant = (*l_element_courant).suivant;
1106: }
1107: }
1108: else
1109: {
1110: while(l_element_courant != NULL)
1111: {
1112: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1113: .donnee).objet)).thread).processus_detache
1114: == d_vrai)
1115: {
1116: l_element_courant = (*l_element_courant).suivant;
1117: continue;
1118: }
1119:
1120: if (pthread_equal((*(*((struct_processus_fils *)
1121: (*(*l_element_courant).donnee).objet)).thread).tid,
1122: (*s_argument_thread).tid) != 0)
1123: {
1124: while(read_atomic(s_etat_processus, (*s_argument_thread)
1125: .pipe_nombre_objets_attente[0],
1126: &tid_candidat, sizeof(tid_candidat)) ==
1127: sizeof(tid_candidat))
1128: {
1129: /*
1130: * -1 est renvoyé par l'instruction SWI
1131: */
1132:
1133: if (tid_candidat == (pthread_t) -2)
1134: {
1135: break;
1136: }
1137: else if (tid_candidat == (pthread_t) -1)
1138: {
1139: }
1140: else if (read_atomic(s_etat_processus,
1141: (*s_argument_thread)
1142: .pipe_nombre_objets_attente[0],
1143: &tid_candidat, sizeof(tid_candidat)) ==
1144: sizeof(tid_candidat))
1145: {
1146: if ((*s_etat_processus).debug == d_vrai)
1147: if (((*s_etat_processus).type_debug &
1148: d_debug_processus) != 0)
1149: {
1150: if ((*s_etat_processus).langue == 'F')
1151: {
1152: printf("[%d] Données en provenance du "
1153: "thread %llu (thread "
1154: "arrêté)\n", (int) getpid(),
1155: (unsigned long long)
1156: (*s_argument_thread).tid);
1157: fflush(stdout);
1158: }
1159: else
1160: {
1161: printf("[%d] Data from thread %llu "
1162: "(thread stopped)\n",
1163: (int) getpid(),
1164: (unsigned long long)
1165: (*s_argument_thread).tid);
1166: fflush(stdout);
1167: }
1168: }
1169:
1170: if (pthread_mutex_lock(
1171: &((*(*((struct_processus_fils *)
1172: (*(*l_element_courant).donnee).objet))
1173: .thread).mutex)) != 0)
1174: {
1175: (*s_etat_processus).erreur_systeme =
1176: d_es_processus;
1177: }
1178:
1179: (*(*((struct_processus_fils *)
1180: (*(*l_element_courant).donnee).objet))
1181: .thread).nombre_objets_dans_pipe++;
1182:
1183: if (pthread_mutex_unlock(
1184: &((*(*((struct_processus_fils *)
1185: (*(*l_element_courant).donnee).objet))
1186: .thread).mutex)) != 0)
1187: {
1188: (*s_etat_processus).erreur_systeme =
1189: d_es_processus;
1190: }
1191: }
1192: }
1193:
1194: break;
1195: }
1196:
1197: l_element_courant = (*l_element_courant).suivant;
1198: }
1199: }
1200: }
1201:
1202: l_element_courant = (struct_liste_chainee *)
1203: (*s_etat_processus).l_base_pile_processus;
1204:
1205: if (drapeau_interruptions_traitees == d_faux)
1206: {
1207: if ((*s_argument_thread).processus_detache == d_vrai)
1208: {
1209: while(l_element_courant != NULL)
1210: {
1211: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1212: .donnee).objet)).thread).processus_detache
1213: == d_faux)
1214: {
1215: l_element_courant = (*l_element_courant).suivant;
1216: continue;
1217: }
1218:
1219: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1220: .donnee).objet)).thread).pid ==
1221: (*s_argument_thread).pid)
1222: {
1223: while(read_atomic(s_etat_processus, (*s_argument_thread)
1224: .pipe_nombre_interruptions_attente[0],
1225: &pid_candidat, sizeof(pid_candidat)) ==
1226: sizeof(pid_candidat))
1227: {
1228: if (pid_candidat == -2)
1229: {
1230: break;
1231: }
1232: else if (pid_candidat == -1)
1233: {
1234: }
1235: else if (read_atomic(s_etat_processus,
1236: (*s_argument_thread)
1237: .pipe_nombre_interruptions_attente[0],
1238: &pid_candidat, sizeof(pid_candidat)) ==
1239: sizeof(pid_candidat))
1240: {
1241: if ((*s_etat_processus).debug == d_vrai)
1242: if (((*s_etat_processus).type_debug &
1243: d_traitement_interruption) != 0)
1244: {
1245: if ((*s_etat_processus).langue == 'F')
1246: {
1247: printf("[%d] Interruption logicielle "
1248: "en provenance du processus %d"
1249: " (processus arrêté)\n",
1250: (int) getpid(),
1251: (int) (*s_argument_thread).pid);
1252: fflush(stdout);
1253: }
1254: else
1255: {
1256: printf("[%d] Software interrupt "
1257: "from process %d (processus "
1258: "stopped)\n", (int) getpid(),
1259: (int) (*s_argument_thread).pid);
1260: fflush(stdout);
1261: }
1262: }
1263:
1264: if (pthread_mutex_lock(
1265: &((*(*((struct_processus_fils *)
1266: (*(*l_element_courant).donnee).objet))
1267: .thread).mutex)) != 0)
1268: {
1269: (*s_etat_processus).erreur_systeme =
1270: d_es_processus;
1271: }
1272:
1273: (*(*((struct_processus_fils *)
1274: (*(*l_element_courant).donnee)
1275: .objet)).thread)
1276: .nombre_interruptions_dans_pipe++;
1277:
1278: if (pthread_mutex_unlock(
1279: &((*(*((struct_processus_fils *)
1280: (*(*l_element_courant).donnee).objet))
1281: .thread).mutex)) != 0)
1282: {
1283: (*s_etat_processus).erreur_systeme =
1284: d_es_processus;
1285: }
1286:
1287: (*s_etat_processus)
1288: .nombre_interruptions_non_affectees++;
1289: }
1290: }
1291:
1292: break;
1293: }
1294:
1295: l_element_courant = (*l_element_courant).suivant;
1296: }
1297: }
1298: else
1299: {
1300: while(l_element_courant != NULL)
1301: {
1302: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1303: .donnee).objet)).thread).processus_detache
1304: == d_vrai)
1305: {
1306: l_element_courant = (*l_element_courant).suivant;
1307: continue;
1308: }
1309:
1310: if (pthread_equal((*(*((struct_processus_fils *)
1311: (*(*l_element_courant).donnee).objet)).thread).tid,
1312: (*s_argument_thread).tid) != 0)
1313: {
1314: while(read_atomic(s_etat_processus, (*s_argument_thread)
1315: .pipe_nombre_interruptions_attente[0],
1316: &tid_candidat, sizeof(tid_candidat)) ==
1317: sizeof(tid_candidat))
1318: {
1319: if (tid_candidat == (pthread_t) -2)
1320: {
1321: break;
1322: }
1323: else if (tid_candidat == (pthread_t) -1)
1324: {
1325: }
1326: else if (read_atomic(s_etat_processus,
1327: (*s_argument_thread)
1328: .pipe_nombre_interruptions_attente[0],
1329: &tid_candidat, sizeof(tid_candidat)) ==
1330: sizeof(tid_candidat))
1331: {
1332: if ((*s_etat_processus).debug == d_vrai)
1333: if (((*s_etat_processus).type_debug &
1334: d_traitement_interruption) != 0)
1335: {
1336: if ((*s_etat_processus).langue == 'F')
1337: {
1338: printf("[%d] Interruption logicielle "
1339: "en provenance du thread %llu"
1340: " (thread arrêté)\n",
1341: (int) getpid(),
1342: (unsigned long long)
1343: (*s_argument_thread).tid);
1344: fflush(stdout);
1345: }
1346: else
1347: {
1348: printf("[%d] Software interrupt "
1349: "from thread %llu (thread "
1350: "stopped)\n", (int) getpid(),
1351: (unsigned long long)
1352: (*s_argument_thread).tid);
1353: fflush(stdout);
1354: }
1355: }
1356:
1357: if (pthread_mutex_lock(
1358: &((*(*((struct_processus_fils *)
1359: (*(*l_element_courant).donnee).objet))
1360: .thread).mutex)) != 0)
1361: {
1362: (*s_etat_processus).erreur_systeme =
1363: d_es_processus;
1364: }
1365:
1366: (*(*((struct_processus_fils *)
1367: (*(*l_element_courant).donnee)
1368: .objet)).thread)
1369: .nombre_interruptions_dans_pipe++;
1370:
1371: if (pthread_mutex_unlock(
1372: &((*(*((struct_processus_fils *)
1373: (*(*l_element_courant).donnee).objet))
1374: .thread).mutex)) != 0)
1375: {
1376: (*s_etat_processus).erreur_systeme =
1377: d_es_processus;
1378: }
1379:
1380: (*s_etat_processus)
1381: .nombre_interruptions_non_affectees++;
1382: }
1383: }
1384:
1385: break;
1386: }
1387:
1388: l_element_courant = (*l_element_courant).suivant;
1389: }
1390: }
1391: }
1392:
1393: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1394: {
1395: (*s_etat_processus).erreur_systeme_processus_fils =
1396: d_es_processus;
1397: }
1398: }
1399:
1400: /*
1401: * Traitement des interruptions et des erreurs.
1402: */
1403:
1404: if ((*s_etat_processus).debug == d_vrai)
1405: if (((*s_etat_processus).type_debug &
1406: d_debug_processus) != 0)
1407: {
1408: if ((*s_argument_thread).processus_detache == d_vrai)
1409: {
1410: if ((*s_etat_processus).langue == 'F')
1411: {
1412: printf("[%d] Récupération des erreurs du processus "
1413: "%d\n", (int) getpid(),
1414: (int) (*s_argument_thread).pid);
1415: fflush(stdout);
1416: }
1417: else
1418: {
1419: printf("[%d] Check errors from process %d\n", (int) getpid(),
1420: (int) (*s_argument_thread).pid);
1421: fflush(stdout);
1422: }
1423: }
1424: else
1425: {
1426: if ((*s_etat_processus).langue == 'F')
1427: {
1428: printf("[%d] Récupération des erreurs du thread "
1429: "%llu\n", (int) getpid(), (unsigned long long)
1430: (*s_argument_thread).tid);
1431: fflush(stdout);
1432: }
1433: else
1434: {
1435: printf("[%d] Check errors from process %llu\n", (int) getpid(),
1436: (unsigned long long) (*s_argument_thread).tid);
1437: fflush(stdout);
1438: }
1439: }
1440: }
1441:
1442: attente.tv_sec = 0;
1443: attente.tv_nsec = GRANULARITE_us * 1000;
1444:
1445: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1446: &((*s_etat_processus).erreur_execution_processus_fils),
1447: sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
1448: sizeof((*s_etat_processus).erreur_execution_processus_fils))
1449: {
1450: nanosleep(&attente, NULL);
1451: INCR_GRANULARITE(attente.tv_nsec);
1452: }
1453:
1454: attente.tv_sec = 0;
1455: attente.tv_nsec = GRANULARITE_us * 1000;
1456:
1457: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1458: &tampon_erreur,
1459: sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
1460: sizeof((*s_etat_processus).erreur_systeme_processus_fils))
1461: {
1462: nanosleep(&attente, NULL);
1463: INCR_GRANULARITE(attente.tv_nsec);
1464: }
1465:
1466: (*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur;
1467:
1468: attente.tv_sec = 0;
1469: attente.tv_nsec = GRANULARITE_us * 1000;
1470:
1471: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1472: &((*s_etat_processus).pid_erreur_processus_fils),
1473: sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
1474: sizeof((*s_etat_processus).pid_erreur_processus_fils))
1475: {
1476: nanosleep(&attente, NULL);
1477: INCR_GRANULARITE(attente.tv_nsec);
1478: }
1479:
1480: /*
1481: * Si une erreur est déclarée dans le processus fils, le message
1482: * d'erreur a déjà été affiché.
1483: */
1484:
1485: if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
1486: ((*s_etat_processus).erreur_execution_processus_fils != d_ex))
1487: {
1488: (*s_etat_processus).erreur_processus_fils = d_vrai;
1489: (*s_etat_processus).invalidation_message_erreur = d_vrai;
1490: }
1491:
1492: /*
1493: * Retrait du processus de la pile des processus
1494: */
1495:
1496: if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
1497: {
1498: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1499: }
1500:
1501: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1502: {
1503: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1504: }
1505: else
1506: {
1507: do
1508: {
1509: drapeau_fin = d_faux;
1510: l_element_courant = (struct_liste_chainee *)
1511: (*s_etat_processus).l_base_pile_processus;
1512: nombre_donnees = -1;
1513:
1514: while(l_element_courant != NULL)
1515: {
1516: if ((*s_argument_thread).processus_detache == d_vrai)
1517: {
1518: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1519: .donnee).objet)).thread).processus_detache
1520: == d_vrai)
1521: {
1522: if ((*s_argument_thread).pid ==
1523: (*(*((struct_processus_fils *)
1524: (*(*l_element_courant)
1525: .donnee).objet)).thread).pid)
1526: {
1527: if (pthread_mutex_lock(
1528: &((*(*((struct_processus_fils *)
1529: (*(*l_element_courant).donnee).objet))
1530: .thread).mutex)) != 0)
1531: {
1532: (*s_etat_processus).erreur_systeme =
1533: d_es_processus;
1534: }
1535:
1536: nombre_donnees = (*(*((struct_processus_fils *)
1537: (*(*l_element_courant).donnee).objet))
1538: .thread).nombre_objets_dans_pipe +
1539: (*(*((struct_processus_fils *)
1540: (*(*l_element_courant).donnee).objet))
1541: .thread).nombre_interruptions_dans_pipe;
1542:
1543: if (pthread_mutex_unlock(
1544: &((*(*((struct_processus_fils *)
1545: (*(*l_element_courant).donnee).objet))
1546: .thread).mutex)) != 0)
1547: {
1548: (*s_etat_processus).erreur_systeme =
1549: d_es_processus;
1550: }
1551:
1552: break;
1553: }
1554: }
1555: }
1556: else
1557: {
1558: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1559: .donnee).objet)).thread).processus_detache
1560: == d_faux)
1561: {
1562: if (pthread_equal((*s_argument_thread).tid,
1563: (*(*((struct_processus_fils *)
1564: (*(*l_element_courant)
1565: .donnee).objet)).thread).tid) != 0)
1566: {
1567: if (pthread_mutex_lock(
1568: &((*(*((struct_processus_fils *)
1569: (*(*l_element_courant).donnee).objet))
1570: .thread).mutex)) != 0)
1571: {
1572: (*s_etat_processus).erreur_systeme =
1573: d_es_processus;
1574: }
1575:
1576: nombre_donnees = (*(*((struct_processus_fils *)
1577: (*(*l_element_courant).donnee).objet))
1578: .thread).nombre_objets_dans_pipe +
1579: (*(*((struct_processus_fils *)
1580: (*(*l_element_courant).donnee).objet))
1581: .thread).nombre_interruptions_dans_pipe;
1582:
1583: if (pthread_mutex_unlock(
1584: &((*(*((struct_processus_fils *)
1585: (*(*l_element_courant).donnee).objet))
1586: .thread).mutex)) != 0)
1587: {
1588: (*s_etat_processus).erreur_systeme =
1589: d_es_processus;
1590: }
1591:
1592: break;
1593: }
1594: }
1595: }
1596:
1597: l_element_courant = (*l_element_courant).suivant;
1598: }
1599:
1600: if (nombre_donnees == -1)
1601: {
1602: (*s_etat_processus).erreur_systeme_processus_fils =
1603: d_es_processus;
1604: drapeau_fin = d_vrai;
1605: BUG(1, printf("Process or thread not found"));
1606: }
1607: else if ((nombre_donnees == 0) ||
1608: ((*s_etat_processus).var_volatile_requete_arret == -1))
1609: {
1610: if ((*s_etat_processus).debug == d_vrai)
1611: if (((*s_etat_processus).type_debug &
1612: d_debug_processus) != 0)
1613: {
1614: if ((*s_argument_thread).processus_detache == d_vrai)
1615: {
1616: if ((*s_etat_processus).langue == 'F')
1617: {
1618: printf("[%d] Fermeture des tuyaux du processus "
1619: "%d\n", (int) getpid(), (int)
1620: (*s_argument_thread).pid);
1621: fflush(stdout);
1622: }
1623: else
1624: {
1625: printf("[%d] Close remaining pipes "
1626: "of process %d\n", (int) getpid(),
1627: (int) (*s_argument_thread).pid);
1628: fflush(stdout);
1629: }
1630: }
1631: else
1632: {
1633: if ((*s_etat_processus).langue == 'F')
1634: {
1635: printf("[%d] Fermeture des tuyaux du thread "
1636: "%llu\n", (int) getpid(),
1637: (unsigned long long)
1638: (*s_argument_thread).tid);
1639: fflush(stdout);
1640: }
1641: else
1642: {
1643: printf("[%d] Close remaining pipes "
1644: "of thread %llu\n", (int) getpid(),
1645: (unsigned long long) (*s_argument_thread)
1646: .tid);
1647: fflush(stdout);
1648: }
1649: }
1650: }
1651:
1652: if (close((*s_argument_thread).pipe_objets[0]) != 0)
1653: {
1654: (*s_etat_processus).erreur_systeme_processus_fils =
1655: d_es_processus;
1656: }
1657:
1658: if (close((*s_argument_thread).pipe_acquittement[1]) != 0)
1659: {
1660: (*s_etat_processus).erreur_systeme_processus_fils =
1661: d_es_processus;
1662: }
1663:
1664: if (close((*s_argument_thread).pipe_injections[1]) != 0)
1665: {
1666: (*s_etat_processus).erreur_systeme_processus_fils =
1667: d_es_processus;
1668: }
1669:
1670: if (close((*s_argument_thread).pipe_nombre_injections[1]) != 0)
1671: {
1672: (*s_etat_processus).erreur_systeme_processus_fils =
1673: d_es_processus;
1674: }
1675:
1676: if (close((*s_argument_thread)
1677: .pipe_nombre_objets_attente[0]) != 0)
1678: {
1679: (*s_etat_processus).erreur_systeme_processus_fils =
1680: d_es_processus;
1681: }
1682:
1683: if (close((*s_argument_thread)
1684: .pipe_interruptions[0]) != 0)
1685: {
1686: (*s_etat_processus).erreur_systeme_processus_fils =
1687: d_es_processus;
1688: }
1689:
1690: if (close((*s_argument_thread)
1691: .pipe_nombre_interruptions_attente[0]) != 0)
1692: {
1693: (*s_etat_processus).erreur_systeme_processus_fils =
1694: d_es_processus;
1695: }
1696:
1697: drapeau_fin = d_vrai;
1698: }
1699: else
1700: {
1701: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1702: {
1703: (*s_etat_processus).erreur_systeme_processus_fils =
1704: d_es_processus;
1705: drapeau_fin = d_vrai;
1706: }
1707:
1708: nanosleep(&attente, NULL);
1709: INCR_GRANULARITE(attente.tv_nsec);
1710:
1711: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1712: {
1713: (*s_etat_processus).erreur_systeme_processus_fils =
1714: d_es_processus;
1715: drapeau_fin = d_vrai;
1716: }
1717: }
1718: } while(drapeau_fin == d_faux);
1719:
1720: l_element_courant = (struct_liste_chainee *)
1721: (*s_etat_processus).l_base_pile_processus;
1722: l_element_precedent = NULL;
1723:
1724: while(l_element_courant != NULL)
1725: {
1726: drapeau = d_faux;
1727:
1728: if ((*s_argument_thread).processus_detache ==
1729: (*(*((struct_processus_fils *) (*(*l_element_courant)
1730: .donnee).objet)).thread).processus_detache)
1731: {
1732: if ((*s_argument_thread).processus_detache == d_vrai)
1733: {
1734: if ((*(*((struct_processus_fils *)
1735: (*(*l_element_courant).donnee).objet))
1736: .thread).pid == (*s_argument_thread).pid)
1737: {
1738: drapeau = d_vrai;
1739: }
1740: else
1741: {
1742: drapeau = d_faux;
1743: }
1744: }
1745: else
1746: {
1747: if (pthread_equal((*(*((struct_processus_fils *)
1748: (*(*l_element_courant).donnee).objet))
1749: .thread).tid, (*s_argument_thread).tid) != 0)
1750: {
1751: drapeau = d_vrai;
1752: }
1753: else
1754: {
1755: drapeau = d_faux;
1756: }
1757: }
1758: }
1759: else
1760: {
1761: drapeau = d_faux;
1762: }
1763:
1764: if (drapeau == d_vrai)
1765: {
1766: if (l_element_precedent == NULL)
1767: {
1768: (*s_etat_processus).l_base_pile_processus =
1769: (*l_element_courant).suivant;
1770:
1771: (*(*((struct_processus_fils *) (*(*l_element_courant)
1772: .donnee).objet)).thread).nombre_references--;
1773:
1774: // Cette référence ne peut être nulle car l'objet est encore
1775: // référencé par la liste des threads de surveillance.
1776:
1777: BUG((*(*((struct_processus_fils *) (*(*l_element_courant)
1778: .donnee).objet)).thread).nombre_references <= 0,
1779: uprintf("(*(*((struct_processus_fils *) "
1780: "(*(*l_element_courant).donnee).objet)).thread)"
1781: ".nombre_references = %d\n",
1782: (*(*((struct_processus_fils *)
1783: (*(*l_element_courant).donnee).objet)).thread)
1784: .nombre_references));
1785:
1786: free((*(*l_element_courant).donnee).objet);
1787: free((*l_element_courant).donnee);
1788: free(l_element_courant);
1789:
1790: l_element_courant = (struct_liste_chainee *)
1791: (*s_etat_processus).l_base_pile_processus;
1792: }
1793: else
1794: {
1795: (*l_element_precedent).suivant =
1796: (*l_element_courant).suivant;
1797:
1798: (*(*((struct_processus_fils *) (*(*l_element_courant)
1799: .donnee).objet)).thread).nombre_references--;
1800:
1801: // Cette référence ne peut être nulle car l'objet est encore
1802: // référencé par la liste des threads de surveillance.
1803:
1804: BUG((*(*((struct_processus_fils *) (*(*l_element_courant)
1805: .donnee).objet)).thread).nombre_references <= 0,
1806: uprintf("(*(*((struct_processus_fils *) "
1807: "(*(*l_element_courant).donnee).objet)).thread)"
1808: ".nombre_references = %d\n",
1809: (*(*((struct_processus_fils *)
1810: (*(*l_element_courant).donnee).objet)).thread)
1811: .nombre_references));
1812:
1813: free((*(*l_element_courant).donnee).objet);
1814: free((*l_element_courant).donnee);
1815: free(l_element_courant);
1816: }
1817:
1818: break;
1819: }
1820: else
1821: {
1822: l_element_precedent = l_element_courant;
1823: l_element_courant = (*l_element_courant).suivant;
1824: }
1825: }
1826:
1827: if ((*s_etat_processus).debug == d_vrai)
1828: if (((*s_etat_processus).type_debug &
1829: d_debug_processus) != 0)
1830: {
1831: if ((*s_argument_thread).processus_detache == d_vrai)
1832: {
1833: if ((*s_etat_processus).langue == 'F')
1834: {
1835: printf("[%d] Arrêt du thread de surveillance du"
1836: " processus %d\n", (int) getpid(),
1837: (int) (*s_argument_thread).pid);
1838: }
1839: else
1840: {
1841: printf("[%d] Stop monitoring of process %d", (int) getpid(),
1842: (int) (*s_argument_thread).pid);
1843: }
1844: }
1845: else
1846: {
1847: if ((*s_etat_processus).langue == 'F')
1848: {
1849: printf("[%d] Arrêt du thread de surveillance du"
1850: " thread %llu\n", (int) getpid(),
1851: (unsigned long long) (*s_argument_thread)
1852: .tid);
1853: }
1854: else
1855: {
1856: printf("[%d] Stop monitoring of thread %llu",
1857: (int) getpid(),
1858: (unsigned long long) (*s_argument_thread)
1859: .tid);
1860: }
1861: }
1862:
1863: fflush(stdout);
1864: }
1865:
1866: retrait_thread_surveillance(s_etat_processus, s_argument_thread);
1867:
1868: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1869: {
1870: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1871: }
1872: }
1873:
1874: pthread_exit(NULL);
1875: }
1876:
1877:
1878: /*
1879: ================================================================================
1880: Fonction d'écriture dans un pipe
1881: ================================================================================
1882: Entrées : pointeur sur une structure de description du processus,
1883: numéro du pipe et objet à écrire
1884: --------------------------------------------------------------------------------
1885: Sorties :
1886: --------------------------------------------------------------------------------
1887: Effets de bord : néant
1888: ================================================================================
1889: */
1890:
1891: logical1
1892: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
1893: struct_objet *s_objet)
1894: {
1895: struct_liste_chainee *l_element_courant;
1896:
1897: struct timespec attente;
1898:
1899: unsigned long i;
1900: unsigned long j;
1901:
1902: size_t longueur;
1903: ssize_t longueur_ecriture;
1904:
1905: if ((*s_objet).type == INT)
1906: {
1907: attente.tv_sec = 0;
1908: attente.tv_nsec = GRANULARITE_us * 1000;
1909:
1910: while((longueur_ecriture = write_atomic(s_etat_processus,
1911: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1912: sizeof((*s_objet).type))
1913: {
1914: if (longueur_ecriture == -1)
1915: {
1916: return(d_erreur);
1917: }
1918:
1919: nanosleep(&attente, NULL);
1920: INCR_GRANULARITE(attente.tv_nsec);
1921: }
1922:
1923: attente.tv_sec = 0;
1924: attente.tv_nsec = GRANULARITE_us * 1000;
1925:
1926: while((longueur_ecriture = write_atomic(s_etat_processus,
1927: pipe, (integer8 *)
1928: (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
1929: {
1930: if (longueur_ecriture == -1)
1931: {
1932: return(d_erreur);
1933: }
1934:
1935: nanosleep(&attente, NULL);
1936: INCR_GRANULARITE(attente.tv_nsec);
1937: }
1938: }
1939: else if ((*s_objet).type == REL)
1940: {
1941: attente.tv_sec = 0;
1942: attente.tv_nsec = GRANULARITE_us * 1000;
1943:
1944: while((longueur_ecriture = write_atomic(s_etat_processus,
1945: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1946: sizeof((*s_objet).type))
1947: {
1948: if (longueur_ecriture == -1)
1949: {
1950: return(d_erreur);
1951: }
1952:
1953: nanosleep(&attente, NULL);
1954: INCR_GRANULARITE(attente.tv_nsec);
1955: }
1956:
1957: attente.tv_sec = 0;
1958: attente.tv_nsec = GRANULARITE_us * 1000;
1959:
1960: while((longueur_ecriture = write_atomic(s_etat_processus,
1961: pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
1962: sizeof(real8))
1963: {
1964: if (longueur_ecriture == -1)
1965: {
1966: return(d_erreur);
1967: }
1968:
1969: nanosleep(&attente, NULL);
1970: INCR_GRANULARITE(attente.tv_nsec);
1971: }
1972: }
1973: else if ((*s_objet).type == CPL)
1974: {
1975: attente.tv_sec = 0;
1976: attente.tv_nsec = GRANULARITE_us * 1000;
1977:
1978: while((longueur_ecriture = write_atomic(s_etat_processus,
1979: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1980: sizeof((*s_objet).type))
1981: {
1982: if (longueur_ecriture == -1)
1983: {
1984: return(d_erreur);
1985: }
1986:
1987: nanosleep(&attente, NULL);
1988: INCR_GRANULARITE(attente.tv_nsec);
1989: }
1990:
1991: attente.tv_sec = 0;
1992: attente.tv_nsec = GRANULARITE_us * 1000;
1993:
1994: while((longueur_ecriture = write_atomic(s_etat_processus,
1995: pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
1996: != sizeof(complex16))
1997: {
1998: if (longueur_ecriture == -1)
1999: {
2000: return(d_erreur);
2001: }
2002:
2003: nanosleep(&attente, NULL);
2004: INCR_GRANULARITE(attente.tv_nsec);
2005: }
2006: }
2007: else if ((*s_objet).type == VIN)
2008: {
2009: attente.tv_sec = 0;
2010: attente.tv_nsec = GRANULARITE_us * 1000;
2011:
2012: while((longueur_ecriture = write_atomic(s_etat_processus,
2013: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2014: sizeof((*s_objet).type))
2015: {
2016: if (longueur_ecriture == -1)
2017: {
2018: return(d_erreur);
2019: }
2020:
2021: nanosleep(&attente, NULL);
2022: INCR_GRANULARITE(attente.tv_nsec);
2023: }
2024:
2025: attente.tv_sec = 0;
2026: attente.tv_nsec = GRANULARITE_us * 1000;
2027:
2028: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2029: &((*((struct_vecteur *) (*s_objet).objet))
2030: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2031: {
2032: if (longueur_ecriture == -1)
2033: {
2034: return(d_erreur);
2035: }
2036:
2037: nanosleep(&attente, NULL);
2038: INCR_GRANULARITE(attente.tv_nsec);
2039: }
2040:
2041: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2042: {
2043: attente.tv_sec = 0;
2044: attente.tv_nsec = GRANULARITE_us * 1000;
2045:
2046: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2047: &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
2048: .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
2049: {
2050: if (longueur_ecriture == -1)
2051: {
2052: return(d_erreur);
2053: }
2054:
2055: nanosleep(&attente, NULL);
2056: INCR_GRANULARITE(attente.tv_nsec);
2057: }
2058: }
2059: }
2060: else if ((*s_objet).type == VRL)
2061: {
2062: attente.tv_sec = 0;
2063: attente.tv_nsec = GRANULARITE_us * 1000;
2064:
2065: while((longueur_ecriture = write_atomic(s_etat_processus,
2066: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2067: sizeof((*s_objet).type))
2068: {
2069: if (longueur_ecriture == -1)
2070: {
2071: return(d_erreur);
2072: }
2073:
2074: nanosleep(&attente, NULL);
2075: INCR_GRANULARITE(attente.tv_nsec);
2076: }
2077:
2078: attente.tv_sec = 0;
2079: attente.tv_nsec = GRANULARITE_us * 1000;
2080:
2081: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2082: &((*((struct_vecteur *) (*s_objet).objet))
2083: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2084: {
2085: if (longueur_ecriture == -1)
2086: {
2087: return(d_erreur);
2088: }
2089:
2090: nanosleep(&attente, NULL);
2091: INCR_GRANULARITE(attente.tv_nsec);
2092: }
2093:
2094: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2095: {
2096: attente.tv_sec = 0;
2097: attente.tv_nsec = GRANULARITE_us * 1000;
2098:
2099: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2100: &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
2101: .tableau)[i]), sizeof(real8))) != sizeof(real8))
2102: {
2103: if (longueur_ecriture == -1)
2104: {
2105: return(d_erreur);
2106: }
2107:
2108: nanosleep(&attente, NULL);
2109: INCR_GRANULARITE(attente.tv_nsec);
2110: }
2111: }
2112: }
2113: else if ((*s_objet).type == VCX)
2114: {
2115: attente.tv_sec = 0;
2116: attente.tv_nsec = GRANULARITE_us * 1000;
2117:
2118: while((longueur_ecriture = write_atomic(s_etat_processus,
2119: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2120: sizeof((*s_objet).type))
2121: {
2122: if (longueur_ecriture == -1)
2123: {
2124: return(d_erreur);
2125: }
2126:
2127: nanosleep(&attente, NULL);
2128: INCR_GRANULARITE(attente.tv_nsec);
2129: }
2130:
2131: attente.tv_sec = 0;
2132: attente.tv_nsec = GRANULARITE_us * 1000;
2133:
2134: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2135: &((*((struct_vecteur *) (*s_objet).objet))
2136: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2137: {
2138: if (longueur_ecriture == -1)
2139: {
2140: return(d_erreur);
2141: }
2142:
2143: nanosleep(&attente, NULL);
2144: INCR_GRANULARITE(attente.tv_nsec);
2145: }
2146:
2147: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2148: {
2149: attente.tv_sec = 0;
2150: attente.tv_nsec = GRANULARITE_us * 1000;
2151:
2152: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2153: &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
2154: .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
2155: {
2156: if (longueur_ecriture == -1)
2157: {
2158: return(d_erreur);
2159: }
2160:
2161: nanosleep(&attente, NULL);
2162: INCR_GRANULARITE(attente.tv_nsec);
2163: }
2164: }
2165: }
2166: else if ((*s_objet).type == MIN)
2167: {
2168: attente.tv_sec = 0;
2169: attente.tv_nsec = GRANULARITE_us * 1000;
2170:
2171: while((longueur_ecriture = write_atomic(s_etat_processus,
2172: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2173: sizeof((*s_objet).type))
2174: {
2175: if (longueur_ecriture == -1)
2176: {
2177: return(d_erreur);
2178: }
2179:
2180: nanosleep(&attente, NULL);
2181: INCR_GRANULARITE(attente.tv_nsec);
2182: }
2183:
2184: attente.tv_sec = 0;
2185: attente.tv_nsec = GRANULARITE_us * 1000;
2186:
2187: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2188: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2189: sizeof(unsigned long))) != sizeof(unsigned long))
2190: {
2191: if (longueur_ecriture == -1)
2192: {
2193: return(d_erreur);
2194: }
2195:
2196: nanosleep(&attente, NULL);
2197: INCR_GRANULARITE(attente.tv_nsec);
2198: }
2199:
2200: attente.tv_sec = 0;
2201: attente.tv_nsec = GRANULARITE_us * 1000;
2202:
2203: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2204: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2205: sizeof(unsigned long))) != sizeof(unsigned long))
2206: {
2207: if (longueur_ecriture == -1)
2208: {
2209: return(d_erreur);
2210: }
2211:
2212: nanosleep(&attente, NULL);
2213: INCR_GRANULARITE(attente.tv_nsec);
2214: }
2215:
2216: for(i = 0; i < (*((struct_matrice *)
2217: (*s_objet).objet)).nombre_lignes; i++)
2218: {
2219: for(j = 0; j < (*((struct_matrice *)
2220: (*s_objet).objet)).nombre_colonnes; j++)
2221: {
2222: attente.tv_sec = 0;
2223: attente.tv_nsec = GRANULARITE_us * 1000;
2224:
2225: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2226: &(((integer8 **) (*((struct_matrice *)
2227: (*s_objet).objet)).tableau)[i][j]),
2228: sizeof(integer8))) != sizeof(integer8))
2229: {
2230: if (longueur_ecriture == -1)
2231: {
2232: return(d_erreur);
2233: }
2234:
2235: nanosleep(&attente, NULL);
2236: INCR_GRANULARITE(attente.tv_nsec);
2237: }
2238: }
2239: }
2240: }
2241: else if ((*s_objet).type == MRL)
2242: {
2243: attente.tv_sec = 0;
2244: attente.tv_nsec = GRANULARITE_us * 1000;
2245:
2246: while((longueur_ecriture = write_atomic(s_etat_processus,
2247: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2248: sizeof((*s_objet).type))
2249: {
2250: if (longueur_ecriture == -1)
2251: {
2252: return(d_erreur);
2253: }
2254:
2255: nanosleep(&attente, NULL);
2256: INCR_GRANULARITE(attente.tv_nsec);
2257: }
2258:
2259: attente.tv_sec = 0;
2260: attente.tv_nsec = GRANULARITE_us * 1000;
2261:
2262: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2263: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2264: sizeof(unsigned long))) != sizeof(unsigned long))
2265: {
2266: if (longueur_ecriture == -1)
2267: {
2268: return(d_erreur);
2269: }
2270:
2271: nanosleep(&attente, NULL);
2272: INCR_GRANULARITE(attente.tv_nsec);
2273: }
2274:
2275: attente.tv_sec = 0;
2276: attente.tv_nsec = GRANULARITE_us * 1000;
2277:
2278: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2279: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2280: sizeof(unsigned long))) != sizeof(unsigned long))
2281: {
2282: if (longueur_ecriture == -1)
2283: {
2284: return(d_erreur);
2285: }
2286:
2287: nanosleep(&attente, NULL);
2288: INCR_GRANULARITE(attente.tv_nsec);
2289: }
2290:
2291: for(i = 0; i < (*((struct_matrice *)
2292: (*s_objet).objet)).nombre_lignes; i++)
2293: {
2294: for(j = 0; j < (*((struct_matrice *)
2295: (*s_objet).objet)).nombre_colonnes; j++)
2296: {
2297: attente.tv_sec = 0;
2298: attente.tv_nsec = GRANULARITE_us * 1000;
2299:
2300: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2301: &(((real8 **) (*((struct_matrice *)
2302: (*s_objet).objet)).tableau)[i][j]),
2303: sizeof(real8))) != sizeof(real8))
2304: {
2305: if (longueur_ecriture == -1)
2306: {
2307: return(d_erreur);
2308: }
2309:
2310: nanosleep(&attente, NULL);
2311: INCR_GRANULARITE(attente.tv_nsec);
2312: }
2313: }
2314: }
2315: }
2316: else if ((*s_objet).type == MCX)
2317: {
2318: attente.tv_sec = 0;
2319: attente.tv_nsec = GRANULARITE_us * 1000;
2320:
2321: while((longueur_ecriture = write_atomic(s_etat_processus,
2322: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2323: sizeof((*s_objet).type))
2324: {
2325: if (longueur_ecriture == -1)
2326: {
2327: return(d_erreur);
2328: }
2329:
2330: nanosleep(&attente, NULL);
2331: INCR_GRANULARITE(attente.tv_nsec);
2332: }
2333:
2334: attente.tv_sec = 0;
2335: attente.tv_nsec = GRANULARITE_us * 1000;
2336:
2337: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2338: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2339: sizeof(unsigned long))) != sizeof(unsigned long))
2340: {
2341: if (longueur_ecriture == -1)
2342: {
2343: return(d_erreur);
2344: }
2345:
2346: nanosleep(&attente, NULL);
2347: INCR_GRANULARITE(attente.tv_nsec);
2348: }
2349:
2350: attente.tv_sec = 0;
2351: attente.tv_nsec = GRANULARITE_us * 1000;
2352:
2353: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2354: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2355: sizeof(unsigned long))) != sizeof(unsigned long))
2356: {
2357: if (longueur_ecriture == -1)
2358: {
2359: return(d_erreur);
2360: }
2361:
2362: nanosleep(&attente, NULL);
2363: INCR_GRANULARITE(attente.tv_nsec);
2364: }
2365:
2366: for(i = 0; i < (*((struct_matrice *)
2367: (*s_objet).objet)).nombre_lignes; i++)
2368: {
2369: for(j = 0; j < (*((struct_matrice *)
2370: (*s_objet).objet)).nombre_colonnes; j++)
2371: {
2372: attente.tv_sec = 0;
2373: attente.tv_nsec = GRANULARITE_us * 1000;
2374:
2375: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2376: &(((complex16 **) (*((struct_matrice *)
2377: (*s_objet).objet)).tableau)[i][j]),
2378: sizeof(complex16))) != sizeof(complex16))
2379: {
2380: if (longueur_ecriture == -1)
2381: {
2382: return(d_erreur);
2383: }
2384:
2385: nanosleep(&attente, NULL);
2386: INCR_GRANULARITE(attente.tv_nsec);
2387: }
2388: }
2389: }
2390: }
2391: else if ((*s_objet).type == BIN)
2392: {
2393: attente.tv_sec = 0;
2394: attente.tv_nsec = GRANULARITE_us * 1000;
2395:
2396: while((longueur_ecriture = write_atomic(s_etat_processus,
2397: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2398: sizeof((*s_objet).type))
2399: {
2400: if (longueur_ecriture == -1)
2401: {
2402: return(d_erreur);
2403: }
2404:
2405: nanosleep(&attente, NULL);
2406: INCR_GRANULARITE(attente.tv_nsec);
2407: }
2408:
2409: attente.tv_sec = 0;
2410: attente.tv_nsec = GRANULARITE_us * 1000;
2411:
2412: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2413: (integer8 *) (*s_objet).objet,
2414: sizeof(integer8))) != sizeof(integer8))
2415: {
2416: if (longueur_ecriture == -1)
2417: {
2418: return(d_erreur);
2419: }
2420:
2421: nanosleep(&attente, NULL);
2422: INCR_GRANULARITE(attente.tv_nsec);
2423: }
2424: }
2425: else if ((*s_objet).type == NOM)
2426: {
2427: attente.tv_sec = 0;
2428: attente.tv_nsec = GRANULARITE_us * 1000;
2429:
2430: while((longueur_ecriture = write_atomic(s_etat_processus,
2431: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2432: sizeof((*s_objet).type))
2433: {
2434: if (longueur_ecriture == -1)
2435: {
2436: return(d_erreur);
2437: }
2438:
2439: nanosleep(&attente, NULL);
2440: INCR_GRANULARITE(attente.tv_nsec);
2441: }
2442:
2443: longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
2444:
2445: attente.tv_sec = 0;
2446: attente.tv_nsec = GRANULARITE_us * 1000;
2447:
2448: while((longueur_ecriture = write_atomic(s_etat_processus,
2449: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2450: {
2451: if (longueur_ecriture == -1)
2452: {
2453: return(d_erreur);
2454: }
2455:
2456: nanosleep(&attente, NULL);
2457: INCR_GRANULARITE(attente.tv_nsec);
2458: }
2459:
2460: attente.tv_sec = 0;
2461: attente.tv_nsec = GRANULARITE_us * 1000;
2462:
2463: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2464: (*((struct_nom *) (*s_objet).objet)).nom,
2465: longueur)) != (ssize_t) longueur)
2466: {
2467: if (longueur_ecriture == -1)
2468: {
2469: return(d_erreur);
2470: }
2471:
2472: nanosleep(&attente, NULL);
2473: INCR_GRANULARITE(attente.tv_nsec);
2474: }
2475:
2476: attente.tv_sec = 0;
2477: attente.tv_nsec = GRANULARITE_us * 1000;
2478:
2479: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2480: &((*((struct_nom *) (*s_objet).objet))
2481: .symbole), sizeof(logical1))) != sizeof(logical1))
2482: {
2483: if (longueur_ecriture == -1)
2484: {
2485: return(d_erreur);
2486: }
2487:
2488: nanosleep(&attente, NULL);
2489: INCR_GRANULARITE(attente.tv_nsec);
2490: }
2491: }
2492: else if ((*s_objet).type == FCT)
2493: {
2494: attente.tv_sec = 0;
2495: attente.tv_nsec = GRANULARITE_us * 1000;
2496:
2497: while((longueur_ecriture = write_atomic(s_etat_processus,
2498: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2499: sizeof((*s_objet).type))
2500: {
2501: if (longueur_ecriture == -1)
2502: {
2503: return(d_erreur);
2504: }
2505:
2506: nanosleep(&attente, NULL);
2507: INCR_GRANULARITE(attente.tv_nsec);
2508: }
2509:
2510: longueur = strlen((*((struct_fonction *)
2511: (*s_objet).objet)).nom_fonction) + 1;
2512:
2513: attente.tv_sec = 0;
2514: attente.tv_nsec = GRANULARITE_us * 1000;
2515:
2516: while((longueur_ecriture = write_atomic(s_etat_processus,
2517: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2518: {
2519: if (longueur_ecriture == -1)
2520: {
2521: return(d_erreur);
2522: }
2523:
2524: nanosleep(&attente, NULL);
2525: INCR_GRANULARITE(attente.tv_nsec);
2526: }
2527:
2528: attente.tv_sec = 0;
2529: attente.tv_nsec = GRANULARITE_us * 1000;
2530:
2531: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2532: (*((struct_fonction *) (*s_objet).objet))
2533: .nom_fonction, longueur)) != (ssize_t) longueur)
2534: {
2535: if (longueur_ecriture == -1)
2536: {
2537: return(d_erreur);
2538: }
2539:
2540: nanosleep(&attente, NULL);
2541: INCR_GRANULARITE(attente.tv_nsec);
2542: }
2543:
2544: attente.tv_sec = 0;
2545: attente.tv_nsec = GRANULARITE_us * 1000;
2546:
2547: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2548: &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
2549: sizeof(unsigned long))) != sizeof(unsigned long))
2550: {
2551: if (longueur_ecriture == -1)
2552: {
2553: return(d_erreur);
2554: }
2555:
2556: nanosleep(&attente, NULL);
2557: INCR_GRANULARITE(attente.tv_nsec);
2558: }
2559: }
2560: else if ((*s_objet).type == CHN)
2561: {
2562: attente.tv_sec = 0;
2563: attente.tv_nsec = GRANULARITE_us * 1000;
2564:
2565: while((longueur_ecriture = write_atomic(s_etat_processus,
2566: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2567: sizeof((*s_objet).type))
2568: {
2569: if (longueur_ecriture == -1)
2570: {
2571: return(d_erreur);
2572: }
2573:
2574: nanosleep(&attente, NULL);
2575: INCR_GRANULARITE(attente.tv_nsec);
2576: }
2577:
2578: longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
2579:
2580: attente.tv_sec = 0;
2581: attente.tv_nsec = GRANULARITE_us * 1000;
2582:
2583: while((longueur_ecriture = write_atomic(s_etat_processus,
2584: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2585: {
2586: if (longueur_ecriture == -1)
2587: {
2588: return(d_erreur);
2589: }
2590:
2591: nanosleep(&attente, NULL);
2592: INCR_GRANULARITE(attente.tv_nsec);
2593: }
2594:
2595: attente.tv_sec = 0;
2596: attente.tv_nsec = GRANULARITE_us * 1000;
2597:
2598: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2599: (unsigned char *) (*s_objet).objet,
2600: longueur)) != (ssize_t) longueur)
2601: {
2602: if (longueur_ecriture == -1)
2603: {
2604: return(d_erreur);
2605: }
2606:
2607: nanosleep(&attente, NULL);
2608: INCR_GRANULARITE(attente.tv_nsec);
2609: }
2610: }
2611: else if (((*s_objet).type == LST) ||
2612: ((*s_objet).type == ALG) ||
2613: ((*s_objet).type == RPN))
2614: {
2615: attente.tv_sec = 0;
2616: attente.tv_nsec = GRANULARITE_us * 1000;
2617:
2618: while((longueur_ecriture = write_atomic(s_etat_processus,
2619: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2620: sizeof((*s_objet).type))
2621: {
2622: if (longueur_ecriture == -1)
2623: {
2624: return(d_erreur);
2625: }
2626:
2627: nanosleep(&attente, NULL);
2628: INCR_GRANULARITE(attente.tv_nsec);
2629: }
2630:
2631: l_element_courant = (*s_objet).objet;
2632: i = 0;
2633:
2634: while(l_element_courant != NULL)
2635: {
2636: i++;
2637: l_element_courant = (*l_element_courant).suivant;
2638: }
2639:
2640: attente.tv_sec = 0;
2641: attente.tv_nsec = GRANULARITE_us * 1000;
2642:
2643: while((longueur_ecriture = write_atomic(s_etat_processus,
2644: pipe, &i, sizeof(i))) != sizeof(i))
2645: {
2646: if (longueur_ecriture == -1)
2647: {
2648: return(d_erreur);
2649: }
2650:
2651: nanosleep(&attente, NULL);
2652: INCR_GRANULARITE(attente.tv_nsec);
2653: }
2654:
2655: l_element_courant = (*s_objet).objet;
2656:
2657: while(l_element_courant != NULL)
2658: {
2659: if (ecriture_pipe(s_etat_processus, pipe,
2660: (*l_element_courant).donnee) == d_erreur)
2661: {
2662: return(d_erreur);
2663: }
2664:
2665: l_element_courant = (*l_element_courant).suivant;
2666: }
2667: }
2668: else if ((*s_objet).type == TBL)
2669: {
2670: attente.tv_sec = 0;
2671: attente.tv_nsec = GRANULARITE_us * 1000;
2672:
2673: while((longueur_ecriture = write_atomic(s_etat_processus,
2674: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2675: sizeof((*s_objet).type))
2676: {
2677: if (longueur_ecriture == -1)
2678: {
2679: return(d_erreur);
2680: }
2681:
2682: nanosleep(&attente, NULL);
2683: INCR_GRANULARITE(attente.tv_nsec);
2684: }
2685:
2686: attente.tv_sec = 0;
2687: attente.tv_nsec = GRANULARITE_us * 1000;
2688:
2689: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2690: &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
2691: sizeof(unsigned long))) != sizeof(unsigned long))
2692: {
2693: if (longueur_ecriture == -1)
2694: {
2695: return(d_erreur);
2696: }
2697:
2698: nanosleep(&attente, NULL);
2699: INCR_GRANULARITE(attente.tv_nsec);
2700: }
2701:
2702: for(i = 0; i < (*((struct_tableau *)
2703: (*s_objet).objet)).nombre_elements; i++)
2704: {
2705: if (ecriture_pipe(s_etat_processus, pipe,
2706: (*((struct_tableau *) (*s_objet).objet)).elements[i])
2707: == d_erreur)
2708: {
2709: return(d_erreur);
2710: }
2711: }
2712: }
2713: else
2714: {
2715: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2716: return(d_erreur);
2717: }
2718:
2719: return(d_absence_erreur);
2720: }
2721:
2722:
2723: /*
2724: ================================================================================
2725: Fonction de lecture dans un pipe
2726: ================================================================================
2727: Entrées : pointeur sur une structure de description du processus,
2728: numéro du pipe et objet à écrire
2729: --------------------------------------------------------------------------------
2730: Sorties :
2731: --------------------------------------------------------------------------------
2732: Effets de bord : néant
2733: ================================================================================
2734: */
2735:
2736: struct_objet *
2737: lecture_pipe(struct_processus *s_etat_processus, int pipe)
2738: {
2739: size_t longueur;
2740:
2741: struct_liste_chainee *l_element_courant;
2742:
2743: struct_objet *s_objet;
2744:
2745: struct timespec attente;
2746:
2747: unsigned long i;
2748: unsigned long j;
2749:
2750: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
2751: {
2752: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2753: return(NULL);
2754: }
2755:
2756: attente.tv_sec = 0;
2757: attente.tv_nsec = GRANULARITE_us * 1000;
2758:
2759: while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
2760: sizeof((*s_objet).type)) != sizeof((*s_objet).type))
2761: {
2762: nanosleep(&attente, NULL);
2763: INCR_GRANULARITE(attente.tv_nsec);
2764: }
2765:
2766: if ((*s_objet).type == INT)
2767: {
2768: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2769: {
2770: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2771: return(NULL);
2772: }
2773:
2774: attente.tv_sec = 0;
2775: attente.tv_nsec = GRANULARITE_us * 1000;
2776:
2777: while(read_atomic(s_etat_processus, pipe,
2778: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2779: {
2780: nanosleep(&attente, NULL);
2781: INCR_GRANULARITE(attente.tv_nsec);
2782: }
2783: }
2784: else if ((*s_objet).type == REL)
2785: {
2786: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
2787: {
2788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2789: return(NULL);
2790: }
2791:
2792: attente.tv_sec = 0;
2793: attente.tv_nsec = GRANULARITE_us * 1000;
2794:
2795: while(read_atomic(s_etat_processus, pipe,
2796: (*s_objet).objet, sizeof(real8)) != sizeof(real8))
2797: {
2798: nanosleep(&attente, NULL);
2799: INCR_GRANULARITE(attente.tv_nsec);
2800: }
2801: }
2802: else if ((*s_objet).type == CPL)
2803: {
2804: if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
2805: {
2806: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2807: return(NULL);
2808: }
2809:
2810: attente.tv_sec = 0;
2811: attente.tv_nsec = GRANULARITE_us * 1000;
2812:
2813: while(read_atomic(s_etat_processus, pipe,
2814: (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
2815: {
2816: nanosleep(&attente, NULL);
2817: INCR_GRANULARITE(attente.tv_nsec);
2818: }
2819: }
2820: else if ((*s_objet).type == VIN)
2821: {
2822: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2823: {
2824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2825: return(NULL);
2826: }
2827:
2828: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
2829:
2830: attente.tv_sec = 0;
2831: attente.tv_nsec = GRANULARITE_us * 1000;
2832:
2833: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2834: (*s_objet).objet)).taille),
2835: sizeof(unsigned long)) != sizeof(unsigned long))
2836: {
2837: nanosleep(&attente, NULL);
2838: INCR_GRANULARITE(attente.tv_nsec);
2839: }
2840:
2841: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2842: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2843: sizeof(integer8))) == NULL)
2844: {
2845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2846: return(NULL);
2847: }
2848:
2849: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2850: {
2851: attente.tv_sec = 0;
2852: attente.tv_nsec = GRANULARITE_us * 1000;
2853:
2854: while(read_atomic(s_etat_processus, pipe,
2855: &(((integer8 *) (*((struct_vecteur *)
2856: (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
2857: sizeof(integer8))
2858: {
2859: nanosleep(&attente, NULL);
2860: INCR_GRANULARITE(attente.tv_nsec);
2861: }
2862: }
2863: }
2864: else if ((*s_objet).type == VRL)
2865: {
2866: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2867: {
2868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2869: return(NULL);
2870: }
2871:
2872: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
2873:
2874: attente.tv_sec = 0;
2875: attente.tv_nsec = GRANULARITE_us * 1000;
2876:
2877: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2878: (*s_objet).objet)).taille),
2879: sizeof(unsigned long)) != sizeof(unsigned long))
2880: {
2881: nanosleep(&attente, NULL);
2882: INCR_GRANULARITE(attente.tv_nsec);
2883: }
2884:
2885: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2886: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2887: sizeof(real8))) == NULL)
2888: {
2889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2890: return(NULL);
2891: }
2892:
2893: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2894: {
2895: attente.tv_sec = 0;
2896: attente.tv_nsec = GRANULARITE_us * 1000;
2897:
2898: while(read_atomic(s_etat_processus, pipe,
2899: &(((real8 *) (*((struct_vecteur *)
2900: (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
2901: sizeof(real8))
2902: {
2903: nanosleep(&attente, NULL);
2904: INCR_GRANULARITE(attente.tv_nsec);
2905: }
2906: }
2907: }
2908: else if ((*s_objet).type == VCX)
2909: {
2910: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2911: {
2912: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2913: return(NULL);
2914: }
2915:
2916: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
2917:
2918: attente.tv_sec = 0;
2919: attente.tv_nsec = GRANULARITE_us * 1000;
2920:
2921: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2922: (*s_objet).objet)).taille),
2923: sizeof(unsigned long)) != sizeof(unsigned long))
2924: {
2925: nanosleep(&attente, NULL);
2926: INCR_GRANULARITE(attente.tv_nsec);
2927: }
2928:
2929: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2930: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2931: sizeof(complex16))) == NULL)
2932: {
2933: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2934: return(NULL);
2935: }
2936:
2937: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2938: {
2939: attente.tv_sec = 0;
2940: attente.tv_nsec = GRANULARITE_us * 1000;
2941:
2942: while(read_atomic(s_etat_processus, pipe,
2943: &(((complex16 *) (*((struct_vecteur *)
2944: (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
2945: sizeof(complex16))
2946: {
2947: nanosleep(&attente, NULL);
2948: INCR_GRANULARITE(attente.tv_nsec);
2949: }
2950: }
2951: }
2952: else if ((*s_objet).type == MIN)
2953: {
2954: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2955: {
2956: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2957: return(NULL);
2958: }
2959:
2960: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
2961:
2962: attente.tv_sec = 0;
2963: attente.tv_nsec = GRANULARITE_us * 1000;
2964:
2965: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2966: (*s_objet).objet)).nombre_lignes),
2967: sizeof(unsigned long)) != sizeof(unsigned long))
2968: {
2969: nanosleep(&attente, NULL);
2970: INCR_GRANULARITE(attente.tv_nsec);
2971: }
2972:
2973: attente.tv_sec = 0;
2974: attente.tv_nsec = GRANULARITE_us * 1000;
2975:
2976: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2977: (*s_objet).objet)).nombre_colonnes),
2978: sizeof(unsigned long)) != sizeof(unsigned long))
2979: {
2980: nanosleep(&attente, NULL);
2981: INCR_GRANULARITE(attente.tv_nsec);
2982: }
2983:
2984: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2985: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
2986: sizeof(integer8 *))) == NULL)
2987: {
2988: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2989: return(NULL);
2990: }
2991:
2992: for(i = 0; i < (*((struct_matrice *)
2993: (*s_objet).objet)).nombre_lignes; i++)
2994: {
2995: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2996: malloc((*((struct_matrice *) (*s_objet).objet))
2997: .nombre_colonnes * sizeof(integer8))) == NULL)
2998: {
2999: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3000: return(NULL);
3001: }
3002:
3003: for(j = 0; j < (*((struct_matrice *)
3004: (*s_objet).objet)).nombre_colonnes; j++)
3005: {
3006: attente.tv_sec = 0;
3007: attente.tv_nsec = GRANULARITE_us * 1000;
3008:
3009: while(read_atomic(s_etat_processus,
3010: pipe, &(((integer8 **) (*((struct_matrice *)
3011: (*s_objet).objet)).tableau)[i][j]),
3012: sizeof(integer8)) != sizeof(integer8))
3013: {
3014: nanosleep(&attente, NULL);
3015: INCR_GRANULARITE(attente.tv_nsec);
3016: }
3017: }
3018: }
3019: }
3020: else if ((*s_objet).type == MRL)
3021: {
3022: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3023: {
3024: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3025: return(NULL);
3026: }
3027:
3028: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
3029:
3030: attente.tv_sec = 0;
3031: attente.tv_nsec = GRANULARITE_us * 1000;
3032:
3033: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3034: (*s_objet).objet)).nombre_lignes),
3035: sizeof(unsigned long)) != sizeof(unsigned long))
3036: {
3037: nanosleep(&attente, NULL);
3038: INCR_GRANULARITE(attente.tv_nsec);
3039: }
3040:
3041: attente.tv_sec = 0;
3042: attente.tv_nsec = GRANULARITE_us * 1000;
3043:
3044: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3045: (*s_objet).objet)).nombre_colonnes),
3046: sizeof(unsigned long)) != sizeof(unsigned long))
3047: {
3048: nanosleep(&attente, NULL);
3049: INCR_GRANULARITE(attente.tv_nsec);
3050: }
3051:
3052: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3053: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3054: sizeof(real8 *))) == NULL)
3055: {
3056: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3057: return(NULL);
3058: }
3059:
3060: for(i = 0; i < (*((struct_matrice *)
3061: (*s_objet).objet)).nombre_lignes; i++)
3062: {
3063: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3064: malloc((*((struct_matrice *) (*s_objet).objet))
3065: .nombre_colonnes * sizeof(real8))) == NULL)
3066: {
3067: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3068: return(NULL);
3069: }
3070:
3071: for(j = 0; j < (*((struct_matrice *)
3072: (*s_objet).objet)).nombre_colonnes; j++)
3073: {
3074: attente.tv_sec = 0;
3075: attente.tv_nsec = GRANULARITE_us * 1000;
3076:
3077: while(read_atomic(s_etat_processus,
3078: pipe, &(((real8 **) (*((struct_matrice *)
3079: (*s_objet).objet)).tableau)[i][j]),
3080: sizeof(real8)) != sizeof(real8))
3081: {
3082: nanosleep(&attente, NULL);
3083: INCR_GRANULARITE(attente.tv_nsec);
3084: }
3085: }
3086: }
3087: }
3088: else if ((*s_objet).type == MCX)
3089: {
3090: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3091: {
3092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3093: return(NULL);
3094: }
3095:
3096: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
3097:
3098: attente.tv_sec = 0;
3099: attente.tv_nsec = GRANULARITE_us * 1000;
3100:
3101: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3102: (*s_objet).objet)).nombre_lignes),
3103: sizeof(unsigned long)) != sizeof(unsigned long))
3104: {
3105: nanosleep(&attente, NULL);
3106: INCR_GRANULARITE(attente.tv_nsec);
3107: }
3108:
3109: attente.tv_sec = 0;
3110: attente.tv_nsec = GRANULARITE_us * 1000;
3111:
3112: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3113: (*s_objet).objet)).nombre_colonnes),
3114: sizeof(unsigned long)) != sizeof(unsigned long))
3115: {
3116: nanosleep(&attente, NULL);
3117: INCR_GRANULARITE(attente.tv_nsec);
3118: }
3119:
3120: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3121: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3122: sizeof(complex16 *))) == NULL)
3123: {
3124: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3125: return(NULL);
3126: }
3127:
3128: for(i = 0; i < (*((struct_matrice *)
3129: (*s_objet).objet)).nombre_lignes; i++)
3130: {
3131: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3132: malloc((*((struct_matrice *) (*s_objet).objet))
3133: .nombre_colonnes * sizeof(complex16))) == NULL)
3134: {
3135: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3136: return(NULL);
3137: }
3138:
3139: for(j = 0; j < (*((struct_matrice *)
3140: (*s_objet).objet)).nombre_colonnes; j++)
3141: {
3142: attente.tv_sec = 0;
3143: attente.tv_nsec = GRANULARITE_us * 1000;
3144:
3145: while(read_atomic(s_etat_processus, pipe,
3146: &(((complex16 **) (*((struct_matrice *)
3147: (*s_objet).objet)).tableau)[i][j]),
3148: sizeof(complex16)) != sizeof(complex16))
3149: {
3150: nanosleep(&attente, NULL);
3151: INCR_GRANULARITE(attente.tv_nsec);
3152: }
3153: }
3154: }
3155: }
3156: else if ((*s_objet).type == BIN)
3157: {
3158: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
3159: {
3160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3161: return(NULL);
3162: }
3163:
3164: attente.tv_sec = 0;
3165: attente.tv_nsec = GRANULARITE_us * 1000;
3166:
3167: while(read_atomic(s_etat_processus, pipe,
3168: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
3169: {
3170: nanosleep(&attente, NULL);
3171: INCR_GRANULARITE(attente.tv_nsec);
3172: }
3173: }
3174: else if ((*s_objet).type == NOM)
3175: {
3176: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
3177: {
3178: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3179: return(NULL);
3180: }
3181:
3182: attente.tv_sec = 0;
3183: attente.tv_nsec = GRANULARITE_us * 1000;
3184:
3185: while(read_atomic(s_etat_processus,
3186: pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
3187: {
3188: nanosleep(&attente, NULL);
3189: INCR_GRANULARITE(attente.tv_nsec);
3190: }
3191:
3192: if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
3193: sizeof(unsigned char))) == NULL)
3194: {
3195: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3196: return(NULL);
3197: }
3198:
3199: attente.tv_sec = 0;
3200: attente.tv_nsec = GRANULARITE_us * 1000;
3201:
3202: while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
3203: (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
3204: {
3205: nanosleep(&attente, NULL);
3206: INCR_GRANULARITE(attente.tv_nsec);
3207: }
3208:
3209: attente.tv_sec = 0;
3210: attente.tv_nsec = GRANULARITE_us * 1000;
3211:
3212: while(read_atomic(s_etat_processus, pipe,
3213: &((*((struct_nom *) (*s_objet).objet)).symbole),
3214: sizeof(logical1)) != sizeof(logical1))
3215: {
3216: nanosleep(&attente, NULL);
3217: INCR_GRANULARITE(attente.tv_nsec);
3218: }
3219: }
3220: else if ((*s_objet).type == FCT)
3221: {
3222: if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
3223: {
3224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3225: return(NULL);
3226: }
3227:
3228: attente.tv_sec = 0;
3229: attente.tv_nsec = GRANULARITE_us * 1000;
3230:
3231: while(read_atomic(s_etat_processus, pipe,
3232: &longueur, sizeof(size_t)) != sizeof(size_t))
3233: {
3234: nanosleep(&attente, NULL);
3235: INCR_GRANULARITE(attente.tv_nsec);
3236: }
3237:
3238: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
3239: malloc(longueur * sizeof(unsigned char))) == NULL)
3240: {
3241: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3242: return(NULL);
3243: }
3244:
3245: attente.tv_sec = 0;
3246: attente.tv_nsec = GRANULARITE_us * 1000;
3247:
3248: while(read_atomic(s_etat_processus, pipe,
3249: (*((struct_fonction *) (*s_objet).objet))
3250: .nom_fonction, longueur) != (ssize_t) longueur)
3251: {
3252: nanosleep(&attente, NULL);
3253: INCR_GRANULARITE(attente.tv_nsec);
3254: }
3255:
3256: attente.tv_sec = 0;
3257: attente.tv_nsec = GRANULARITE_us * 1000;
3258:
3259: while(read_atomic(s_etat_processus, pipe,
3260: &((*((struct_fonction *) (*s_objet).objet))
3261: .nombre_arguments), sizeof(unsigned long)) !=
3262: sizeof(unsigned long))
3263: {
3264: nanosleep(&attente, NULL);
3265: INCR_GRANULARITE(attente.tv_nsec);
3266: }
3267:
3268: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
3269: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
3270: (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
3271: }
3272: else if ((*s_objet).type == CHN)
3273: {
3274: attente.tv_sec = 0;
3275: attente.tv_nsec = GRANULARITE_us * 1000;
3276:
3277: while(read_atomic(s_etat_processus, pipe,
3278: &longueur, sizeof(size_t)) != sizeof(size_t))
3279: {
3280: nanosleep(&attente, NULL);
3281: INCR_GRANULARITE(attente.tv_nsec);
3282: }
3283:
3284: if (((*s_objet).objet = malloc(longueur *
3285: sizeof(unsigned char))) == NULL)
3286: {
3287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3288: return(NULL);
3289: }
3290:
3291: attente.tv_sec = 0;
3292: attente.tv_nsec = GRANULARITE_us * 1000;
3293:
3294: while(read_atomic(s_etat_processus, pipe, (unsigned char *)
3295: (*s_objet).objet, longueur) != (ssize_t) longueur)
3296: {
3297: nanosleep(&attente, NULL);
3298: INCR_GRANULARITE(attente.tv_nsec);
3299: }
3300: }
3301: else if (((*s_objet).type == LST) ||
3302: ((*s_objet).type == ALG) ||
3303: ((*s_objet).type == RPN))
3304: {
3305: attente.tv_sec = 0;
3306: attente.tv_nsec = GRANULARITE_us * 1000;
3307:
3308: while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
3309: {
3310: nanosleep(&attente, NULL);
3311: INCR_GRANULARITE(attente.tv_nsec);
3312: }
3313:
3314: l_element_courant = NULL;
3315:
3316: for(i = 0; i < j; i++)
3317: {
3318: if (l_element_courant == NULL)
3319: {
3320: if ((l_element_courant =
3321: malloc(sizeof(struct_liste_chainee))) == NULL)
3322: {
3323: (*s_etat_processus).erreur_systeme =
3324: d_es_allocation_memoire;
3325: return(NULL);
3326: }
3327:
3328: (*s_objet).objet = l_element_courant;
3329: }
3330: else
3331: {
3332: if (((*l_element_courant).suivant =
3333: malloc(sizeof(struct_liste_chainee))) == NULL)
3334: {
3335: (*s_etat_processus).erreur_systeme =
3336: d_es_allocation_memoire;
3337: return(NULL);
3338: }
3339:
3340: l_element_courant = (*l_element_courant).suivant;
3341: (*l_element_courant).suivant = NULL;
3342: }
3343:
3344: attente.tv_sec = 0;
3345: attente.tv_nsec = GRANULARITE_us * 1000;
3346:
3347: while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
3348: pipe)) == NULL)
3349: {
3350: if ((*s_etat_processus).erreur_systeme != d_es)
3351: {
3352: return(NULL);
3353: }
3354:
3355: nanosleep(&attente, NULL);
3356: INCR_GRANULARITE(attente.tv_nsec);
3357: }
3358: }
3359:
3360: if (l_element_courant == NULL)
3361: {
3362: (*s_objet).objet = NULL;
3363: }
3364: else
3365: {
3366: (*l_element_courant).suivant = NULL;
3367: }
3368: }
3369: else if ((*s_objet).type == TBL)
3370: {
3371: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
3372: {
3373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3374: return(NULL);
3375: }
3376:
3377: attente.tv_sec = 0;
3378: attente.tv_nsec = GRANULARITE_us * 1000;
3379:
3380: while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
3381: (*s_objet).objet)).nombre_elements),
3382: sizeof(unsigned long)) != sizeof(unsigned long))
3383: {
3384: nanosleep(&attente, NULL);
3385: INCR_GRANULARITE(attente.tv_nsec);
3386: }
3387:
3388: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
3389: (*((struct_tableau *) (*s_objet).objet)).nombre_elements *
3390: sizeof(struct_objet *))) == NULL)
3391: {
3392: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3393: return(NULL);
3394: }
3395:
3396: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
3397: i++)
3398: {
3399: attente.tv_sec = 0;
3400: attente.tv_nsec = GRANULARITE_us * 1000;
3401:
3402: while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
3403: lecture_pipe(s_etat_processus, pipe)) == NULL)
3404: {
3405: if ((*s_etat_processus).erreur_systeme != d_es)
3406: {
3407: return(NULL);
3408: }
3409:
3410: nanosleep(&attente, NULL);
3411: INCR_GRANULARITE(attente.tv_nsec);
3412: }
3413: }
3414: }
3415:
3416: return(s_objet);
3417: }
3418:
3419:
3420: /*
3421: ================================================================================
3422: Fonction de scrutation des données injectées par le processus père
3423: ================================================================================
3424: Entrées : pointeur sur une structure
3425: --------------------------------------------------------------------------------
3426: Sorties :
3427: --------------------------------------------------------------------------------
3428: Effets de bord : néant
3429: ================================================================================
3430: */
3431:
3432: extern inline void
3433: scrutation_injection(struct_processus *s_etat_processus)
3434: {
3435: fd_set ensemble_descripteurs;
3436:
3437: # ifndef OpenBSD
3438: struct timespec timeout;
3439: # else
3440: struct timeval timeout;
3441: # endif
3442:
3443: unsigned char tampon;
3444:
3445: // Si on est dans le processus père, il n'y a rien à surveiller.
3446:
3447: if ((*s_etat_processus).var_volatile_processus_pere == 0)
3448: {
3449: FD_ZERO(&ensemble_descripteurs);
3450: FD_SET((*s_etat_processus).pipe_nombre_injections,
3451: &ensemble_descripteurs);
3452:
3453: # ifndef OpenBSD
3454: timeout.tv_sec = 0;
3455: timeout.tv_nsec = 0;
3456:
3457: if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
3458: &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
3459: # else
3460: timeout.tv_sec = 0;
3461: timeout.tv_usec = 0;
3462:
3463: if (select((*s_etat_processus).pipe_nombre_injections + 1,
3464: &ensemble_descripteurs, NULL, NULL, &timeout) > 0)
3465: # endif
3466: {
3467: if (read_atomic(s_etat_processus,
3468: (*s_etat_processus).pipe_nombre_injections,
3469: &tampon, sizeof(unsigned char)) == sizeof(unsigned char))
3470: {
3471: if (tampon == '-')
3472: {
3473: (*s_etat_processus).nombre_objets_injectes++;
3474: }
3475: else if (tampon == '+')
3476: {
3477: (*s_etat_processus).nombre_objets_envoyes_non_lus--;
3478:
3479: BUG((*s_etat_processus).nombre_objets_envoyes_non_lus < 0,
3480: printf("(*s_etat_processus).nombre_objets_envoyes_"
3481: "non_lus=%d\n", (*s_etat_processus)
3482: .nombre_objets_envoyes_non_lus));
3483: }
3484: else
3485: {
3486: BUG(1, printf("tampon='%c' (%d)\n", tampon, tampon));
3487: }
3488: }
3489: }
3490: }
3491:
3492: return;
3493: }
3494:
3495:
3496: /*
3497: ================================================================================
3498: Fonction de test du drapeau d'arrêt
3499: ================================================================================
3500: Entrées : pointeur sur une structure
3501: --------------------------------------------------------------------------------
3502: Sorties :
3503: --------------------------------------------------------------------------------
3504: Effets de bord : néant
3505: ================================================================================
3506: */
3507:
3508: inline int test_arret(struct_processus *s_etat_processus)
3509: {
3510: return((int) (*s_etat_processus).var_volatile_requete_arret);
3511: }
3512:
3513: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_processus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src