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