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