1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 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_threads_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: if (pthread_mutex_unlock(&((*s_etat_processus)
1433: .mutex_pile_processus)) != 0)
1434: {
1435: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1436: }
1437:
1438: retrait_thread_surveillance(s_etat_processus, s_argument_thread);
1439:
1440: if (pthread_mutex_lock(&((*s_etat_processus)
1441: .mutex_pile_processus)) != 0)
1442: {
1443: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1444: }
1445:
1446: nombre_threads_surveillance_processus--;
1447:
1448: if (pthread_mutex_unlock(&((*s_etat_processus)
1449: .mutex_pile_processus)) != 0)
1450: {
1451: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1452: }
1453: }
1454:
1455: pthread_exit(NULL);
1456: }
1457:
1458:
1459: /*
1460: ================================================================================
1461: Fonction d'écriture dans un pipe
1462: ================================================================================
1463: Entrées : pointeur sur une structure de description du processus,
1464: numéro du pipe et objet à écrire
1465: --------------------------------------------------------------------------------
1466: Sorties :
1467: --------------------------------------------------------------------------------
1468: Effets de bord : néant
1469: ================================================================================
1470: */
1471:
1472: logical1
1473: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
1474: struct_objet *s_objet)
1475: {
1476: struct_liste_chainee *l_element_courant;
1477:
1478: struct timespec attente;
1479:
1480: integer8 i;
1481: integer8 j;
1482:
1483: size_t longueur;
1484: ssize_t longueur_ecriture;
1485:
1486: if ((*s_objet).type == INT)
1487: {
1488: attente.tv_sec = 0;
1489: attente.tv_nsec = GRANULARITE_us * 1000;
1490:
1491: while((longueur_ecriture = write_atomic(s_etat_processus,
1492: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1493: sizeof((*s_objet).type))
1494: {
1495: if (longueur_ecriture == -1)
1496: {
1497: return(d_erreur);
1498: }
1499:
1500: nanosleep(&attente, NULL);
1501: INCR_GRANULARITE(attente.tv_nsec);
1502: }
1503:
1504: attente.tv_sec = 0;
1505: attente.tv_nsec = GRANULARITE_us * 1000;
1506:
1507: while((longueur_ecriture = write_atomic(s_etat_processus,
1508: pipe, (integer8 *)
1509: (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
1510: {
1511: if (longueur_ecriture == -1)
1512: {
1513: return(d_erreur);
1514: }
1515:
1516: nanosleep(&attente, NULL);
1517: INCR_GRANULARITE(attente.tv_nsec);
1518: }
1519: }
1520: else if ((*s_objet).type == REL)
1521: {
1522: attente.tv_sec = 0;
1523: attente.tv_nsec = GRANULARITE_us * 1000;
1524:
1525: while((longueur_ecriture = write_atomic(s_etat_processus,
1526: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1527: sizeof((*s_objet).type))
1528: {
1529: if (longueur_ecriture == -1)
1530: {
1531: return(d_erreur);
1532: }
1533:
1534: nanosleep(&attente, NULL);
1535: INCR_GRANULARITE(attente.tv_nsec);
1536: }
1537:
1538: attente.tv_sec = 0;
1539: attente.tv_nsec = GRANULARITE_us * 1000;
1540:
1541: while((longueur_ecriture = write_atomic(s_etat_processus,
1542: pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
1543: sizeof(real8))
1544: {
1545: if (longueur_ecriture == -1)
1546: {
1547: return(d_erreur);
1548: }
1549:
1550: nanosleep(&attente, NULL);
1551: INCR_GRANULARITE(attente.tv_nsec);
1552: }
1553: }
1554: else if ((*s_objet).type == CPL)
1555: {
1556: attente.tv_sec = 0;
1557: attente.tv_nsec = GRANULARITE_us * 1000;
1558:
1559: while((longueur_ecriture = write_atomic(s_etat_processus,
1560: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1561: sizeof((*s_objet).type))
1562: {
1563: if (longueur_ecriture == -1)
1564: {
1565: return(d_erreur);
1566: }
1567:
1568: nanosleep(&attente, NULL);
1569: INCR_GRANULARITE(attente.tv_nsec);
1570: }
1571:
1572: attente.tv_sec = 0;
1573: attente.tv_nsec = GRANULARITE_us * 1000;
1574:
1575: while((longueur_ecriture = write_atomic(s_etat_processus,
1576: pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
1577: != sizeof(complex16))
1578: {
1579: if (longueur_ecriture == -1)
1580: {
1581: return(d_erreur);
1582: }
1583:
1584: nanosleep(&attente, NULL);
1585: INCR_GRANULARITE(attente.tv_nsec);
1586: }
1587: }
1588: else if ((*s_objet).type == VIN)
1589: {
1590: attente.tv_sec = 0;
1591: attente.tv_nsec = GRANULARITE_us * 1000;
1592:
1593: while((longueur_ecriture = write_atomic(s_etat_processus,
1594: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1595: sizeof((*s_objet).type))
1596: {
1597: if (longueur_ecriture == -1)
1598: {
1599: return(d_erreur);
1600: }
1601:
1602: nanosleep(&attente, NULL);
1603: INCR_GRANULARITE(attente.tv_nsec);
1604: }
1605:
1606: attente.tv_sec = 0;
1607: attente.tv_nsec = GRANULARITE_us * 1000;
1608:
1609: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1610: &((*((struct_vecteur *) (*s_objet).objet))
1611: .taille), sizeof(integer8))) != sizeof(integer8))
1612: {
1613: if (longueur_ecriture == -1)
1614: {
1615: return(d_erreur);
1616: }
1617:
1618: nanosleep(&attente, NULL);
1619: INCR_GRANULARITE(attente.tv_nsec);
1620: }
1621:
1622: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1623: {
1624: attente.tv_sec = 0;
1625: attente.tv_nsec = GRANULARITE_us * 1000;
1626:
1627: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1628: &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
1629: .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
1630: {
1631: if (longueur_ecriture == -1)
1632: {
1633: return(d_erreur);
1634: }
1635:
1636: nanosleep(&attente, NULL);
1637: INCR_GRANULARITE(attente.tv_nsec);
1638: }
1639: }
1640: }
1641: else if ((*s_objet).type == VRL)
1642: {
1643: attente.tv_sec = 0;
1644: attente.tv_nsec = GRANULARITE_us * 1000;
1645:
1646: while((longueur_ecriture = write_atomic(s_etat_processus,
1647: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1648: sizeof((*s_objet).type))
1649: {
1650: if (longueur_ecriture == -1)
1651: {
1652: return(d_erreur);
1653: }
1654:
1655: nanosleep(&attente, NULL);
1656: INCR_GRANULARITE(attente.tv_nsec);
1657: }
1658:
1659: attente.tv_sec = 0;
1660: attente.tv_nsec = GRANULARITE_us * 1000;
1661:
1662: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1663: &((*((struct_vecteur *) (*s_objet).objet))
1664: .taille), sizeof(integer8))) != sizeof(integer8))
1665: {
1666: if (longueur_ecriture == -1)
1667: {
1668: return(d_erreur);
1669: }
1670:
1671: nanosleep(&attente, NULL);
1672: INCR_GRANULARITE(attente.tv_nsec);
1673: }
1674:
1675: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1676: {
1677: attente.tv_sec = 0;
1678: attente.tv_nsec = GRANULARITE_us * 1000;
1679:
1680: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1681: &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
1682: .tableau)[i]), sizeof(real8))) != sizeof(real8))
1683: {
1684: if (longueur_ecriture == -1)
1685: {
1686: return(d_erreur);
1687: }
1688:
1689: nanosleep(&attente, NULL);
1690: INCR_GRANULARITE(attente.tv_nsec);
1691: }
1692: }
1693: }
1694: else if ((*s_objet).type == VCX)
1695: {
1696: attente.tv_sec = 0;
1697: attente.tv_nsec = GRANULARITE_us * 1000;
1698:
1699: while((longueur_ecriture = write_atomic(s_etat_processus,
1700: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1701: sizeof((*s_objet).type))
1702: {
1703: if (longueur_ecriture == -1)
1704: {
1705: return(d_erreur);
1706: }
1707:
1708: nanosleep(&attente, NULL);
1709: INCR_GRANULARITE(attente.tv_nsec);
1710: }
1711:
1712: attente.tv_sec = 0;
1713: attente.tv_nsec = GRANULARITE_us * 1000;
1714:
1715: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1716: &((*((struct_vecteur *) (*s_objet).objet))
1717: .taille), sizeof(integer8))) != sizeof(integer8))
1718: {
1719: if (longueur_ecriture == -1)
1720: {
1721: return(d_erreur);
1722: }
1723:
1724: nanosleep(&attente, NULL);
1725: INCR_GRANULARITE(attente.tv_nsec);
1726: }
1727:
1728: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1729: {
1730: attente.tv_sec = 0;
1731: attente.tv_nsec = GRANULARITE_us * 1000;
1732:
1733: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1734: &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
1735: .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
1736: {
1737: if (longueur_ecriture == -1)
1738: {
1739: return(d_erreur);
1740: }
1741:
1742: nanosleep(&attente, NULL);
1743: INCR_GRANULARITE(attente.tv_nsec);
1744: }
1745: }
1746: }
1747: else if ((*s_objet).type == MIN)
1748: {
1749: attente.tv_sec = 0;
1750: attente.tv_nsec = GRANULARITE_us * 1000;
1751:
1752: while((longueur_ecriture = write_atomic(s_etat_processus,
1753: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1754: sizeof((*s_objet).type))
1755: {
1756: if (longueur_ecriture == -1)
1757: {
1758: return(d_erreur);
1759: }
1760:
1761: nanosleep(&attente, NULL);
1762: INCR_GRANULARITE(attente.tv_nsec);
1763: }
1764:
1765: attente.tv_sec = 0;
1766: attente.tv_nsec = GRANULARITE_us * 1000;
1767:
1768: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1769: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
1770: sizeof(integer8))) != sizeof(integer8))
1771: {
1772: if (longueur_ecriture == -1)
1773: {
1774: return(d_erreur);
1775: }
1776:
1777: nanosleep(&attente, NULL);
1778: INCR_GRANULARITE(attente.tv_nsec);
1779: }
1780:
1781: attente.tv_sec = 0;
1782: attente.tv_nsec = GRANULARITE_us * 1000;
1783:
1784: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1785: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
1786: sizeof(integer8))) != sizeof(integer8))
1787: {
1788: if (longueur_ecriture == -1)
1789: {
1790: return(d_erreur);
1791: }
1792:
1793: nanosleep(&attente, NULL);
1794: INCR_GRANULARITE(attente.tv_nsec);
1795: }
1796:
1797: for(i = 0; i < (*((struct_matrice *)
1798: (*s_objet).objet)).nombre_lignes; i++)
1799: {
1800: for(j = 0; j < (*((struct_matrice *)
1801: (*s_objet).objet)).nombre_colonnes; j++)
1802: {
1803: attente.tv_sec = 0;
1804: attente.tv_nsec = GRANULARITE_us * 1000;
1805:
1806: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1807: &(((integer8 **) (*((struct_matrice *)
1808: (*s_objet).objet)).tableau)[i][j]),
1809: sizeof(integer8))) != sizeof(integer8))
1810: {
1811: if (longueur_ecriture == -1)
1812: {
1813: return(d_erreur);
1814: }
1815:
1816: nanosleep(&attente, NULL);
1817: INCR_GRANULARITE(attente.tv_nsec);
1818: }
1819: }
1820: }
1821: }
1822: else if ((*s_objet).type == MRL)
1823: {
1824: attente.tv_sec = 0;
1825: attente.tv_nsec = GRANULARITE_us * 1000;
1826:
1827: while((longueur_ecriture = write_atomic(s_etat_processus,
1828: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1829: sizeof((*s_objet).type))
1830: {
1831: if (longueur_ecriture == -1)
1832: {
1833: return(d_erreur);
1834: }
1835:
1836: nanosleep(&attente, NULL);
1837: INCR_GRANULARITE(attente.tv_nsec);
1838: }
1839:
1840: attente.tv_sec = 0;
1841: attente.tv_nsec = GRANULARITE_us * 1000;
1842:
1843: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1844: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
1845: sizeof(integer8))) != sizeof(integer8))
1846: {
1847: if (longueur_ecriture == -1)
1848: {
1849: return(d_erreur);
1850: }
1851:
1852: nanosleep(&attente, NULL);
1853: INCR_GRANULARITE(attente.tv_nsec);
1854: }
1855:
1856: attente.tv_sec = 0;
1857: attente.tv_nsec = GRANULARITE_us * 1000;
1858:
1859: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1860: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
1861: sizeof(integer8))) != sizeof(integer8))
1862: {
1863: if (longueur_ecriture == -1)
1864: {
1865: return(d_erreur);
1866: }
1867:
1868: nanosleep(&attente, NULL);
1869: INCR_GRANULARITE(attente.tv_nsec);
1870: }
1871:
1872: for(i = 0; i < (*((struct_matrice *)
1873: (*s_objet).objet)).nombre_lignes; i++)
1874: {
1875: for(j = 0; j < (*((struct_matrice *)
1876: (*s_objet).objet)).nombre_colonnes; j++)
1877: {
1878: attente.tv_sec = 0;
1879: attente.tv_nsec = GRANULARITE_us * 1000;
1880:
1881: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1882: &(((real8 **) (*((struct_matrice *)
1883: (*s_objet).objet)).tableau)[i][j]),
1884: sizeof(real8))) != sizeof(real8))
1885: {
1886: if (longueur_ecriture == -1)
1887: {
1888: return(d_erreur);
1889: }
1890:
1891: nanosleep(&attente, NULL);
1892: INCR_GRANULARITE(attente.tv_nsec);
1893: }
1894: }
1895: }
1896: }
1897: else if ((*s_objet).type == MCX)
1898: {
1899: attente.tv_sec = 0;
1900: attente.tv_nsec = GRANULARITE_us * 1000;
1901:
1902: while((longueur_ecriture = write_atomic(s_etat_processus,
1903: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1904: sizeof((*s_objet).type))
1905: {
1906: if (longueur_ecriture == -1)
1907: {
1908: return(d_erreur);
1909: }
1910:
1911: nanosleep(&attente, NULL);
1912: INCR_GRANULARITE(attente.tv_nsec);
1913: }
1914:
1915: attente.tv_sec = 0;
1916: attente.tv_nsec = GRANULARITE_us * 1000;
1917:
1918: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1919: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
1920: sizeof(integer8))) != sizeof(integer8))
1921: {
1922: if (longueur_ecriture == -1)
1923: {
1924: return(d_erreur);
1925: }
1926:
1927: nanosleep(&attente, NULL);
1928: INCR_GRANULARITE(attente.tv_nsec);
1929: }
1930:
1931: attente.tv_sec = 0;
1932: attente.tv_nsec = GRANULARITE_us * 1000;
1933:
1934: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1935: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
1936: sizeof(integer8))) != sizeof(integer8))
1937: {
1938: if (longueur_ecriture == -1)
1939: {
1940: return(d_erreur);
1941: }
1942:
1943: nanosleep(&attente, NULL);
1944: INCR_GRANULARITE(attente.tv_nsec);
1945: }
1946:
1947: for(i = 0; i < (*((struct_matrice *)
1948: (*s_objet).objet)).nombre_lignes; i++)
1949: {
1950: for(j = 0; j < (*((struct_matrice *)
1951: (*s_objet).objet)).nombre_colonnes; j++)
1952: {
1953: attente.tv_sec = 0;
1954: attente.tv_nsec = GRANULARITE_us * 1000;
1955:
1956: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1957: &(((complex16 **) (*((struct_matrice *)
1958: (*s_objet).objet)).tableau)[i][j]),
1959: sizeof(complex16))) != sizeof(complex16))
1960: {
1961: if (longueur_ecriture == -1)
1962: {
1963: return(d_erreur);
1964: }
1965:
1966: nanosleep(&attente, NULL);
1967: INCR_GRANULARITE(attente.tv_nsec);
1968: }
1969: }
1970: }
1971: }
1972: else if ((*s_objet).type == BIN)
1973: {
1974: attente.tv_sec = 0;
1975: attente.tv_nsec = GRANULARITE_us * 1000;
1976:
1977: while((longueur_ecriture = write_atomic(s_etat_processus,
1978: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1979: sizeof((*s_objet).type))
1980: {
1981: if (longueur_ecriture == -1)
1982: {
1983: return(d_erreur);
1984: }
1985:
1986: nanosleep(&attente, NULL);
1987: INCR_GRANULARITE(attente.tv_nsec);
1988: }
1989:
1990: attente.tv_sec = 0;
1991: attente.tv_nsec = GRANULARITE_us * 1000;
1992:
1993: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1994: (integer8 *) (*s_objet).objet,
1995: sizeof(integer8))) != sizeof(integer8))
1996: {
1997: if (longueur_ecriture == -1)
1998: {
1999: return(d_erreur);
2000: }
2001:
2002: nanosleep(&attente, NULL);
2003: INCR_GRANULARITE(attente.tv_nsec);
2004: }
2005: }
2006: else if ((*s_objet).type == NOM)
2007: {
2008: attente.tv_sec = 0;
2009: attente.tv_nsec = GRANULARITE_us * 1000;
2010:
2011: while((longueur_ecriture = write_atomic(s_etat_processus,
2012: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2013: sizeof((*s_objet).type))
2014: {
2015: if (longueur_ecriture == -1)
2016: {
2017: return(d_erreur);
2018: }
2019:
2020: nanosleep(&attente, NULL);
2021: INCR_GRANULARITE(attente.tv_nsec);
2022: }
2023:
2024: longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
2025:
2026: attente.tv_sec = 0;
2027: attente.tv_nsec = GRANULARITE_us * 1000;
2028:
2029: while((longueur_ecriture = write_atomic(s_etat_processus,
2030: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2031: {
2032: if (longueur_ecriture == -1)
2033: {
2034: return(d_erreur);
2035: }
2036:
2037: nanosleep(&attente, NULL);
2038: INCR_GRANULARITE(attente.tv_nsec);
2039: }
2040:
2041: attente.tv_sec = 0;
2042: attente.tv_nsec = GRANULARITE_us * 1000;
2043:
2044: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2045: (*((struct_nom *) (*s_objet).objet)).nom,
2046: longueur)) != (ssize_t) longueur)
2047: {
2048: if (longueur_ecriture == -1)
2049: {
2050: return(d_erreur);
2051: }
2052:
2053: nanosleep(&attente, NULL);
2054: INCR_GRANULARITE(attente.tv_nsec);
2055: }
2056:
2057: attente.tv_sec = 0;
2058: attente.tv_nsec = GRANULARITE_us * 1000;
2059:
2060: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2061: &((*((struct_nom *) (*s_objet).objet))
2062: .symbole), sizeof(logical1))) != sizeof(logical1))
2063: {
2064: if (longueur_ecriture == -1)
2065: {
2066: return(d_erreur);
2067: }
2068:
2069: nanosleep(&attente, NULL);
2070: INCR_GRANULARITE(attente.tv_nsec);
2071: }
2072: }
2073: else if ((*s_objet).type == FCT)
2074: {
2075: attente.tv_sec = 0;
2076: attente.tv_nsec = GRANULARITE_us * 1000;
2077:
2078: while((longueur_ecriture = write_atomic(s_etat_processus,
2079: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2080: sizeof((*s_objet).type))
2081: {
2082: if (longueur_ecriture == -1)
2083: {
2084: return(d_erreur);
2085: }
2086:
2087: nanosleep(&attente, NULL);
2088: INCR_GRANULARITE(attente.tv_nsec);
2089: }
2090:
2091: longueur = strlen((*((struct_fonction *)
2092: (*s_objet).objet)).nom_fonction) + 1;
2093:
2094: attente.tv_sec = 0;
2095: attente.tv_nsec = GRANULARITE_us * 1000;
2096:
2097: while((longueur_ecriture = write_atomic(s_etat_processus,
2098: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2099: {
2100: if (longueur_ecriture == -1)
2101: {
2102: return(d_erreur);
2103: }
2104:
2105: nanosleep(&attente, NULL);
2106: INCR_GRANULARITE(attente.tv_nsec);
2107: }
2108:
2109: attente.tv_sec = 0;
2110: attente.tv_nsec = GRANULARITE_us * 1000;
2111:
2112: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2113: (*((struct_fonction *) (*s_objet).objet))
2114: .nom_fonction, longueur)) != (ssize_t) longueur)
2115: {
2116: if (longueur_ecriture == -1)
2117: {
2118: return(d_erreur);
2119: }
2120:
2121: nanosleep(&attente, NULL);
2122: INCR_GRANULARITE(attente.tv_nsec);
2123: }
2124:
2125: attente.tv_sec = 0;
2126: attente.tv_nsec = GRANULARITE_us * 1000;
2127:
2128: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2129: &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
2130: sizeof(integer8))) != sizeof(integer8))
2131: {
2132: if (longueur_ecriture == -1)
2133: {
2134: return(d_erreur);
2135: }
2136:
2137: nanosleep(&attente, NULL);
2138: INCR_GRANULARITE(attente.tv_nsec);
2139: }
2140: }
2141: else if ((*s_objet).type == CHN)
2142: {
2143: attente.tv_sec = 0;
2144: attente.tv_nsec = GRANULARITE_us * 1000;
2145:
2146: while((longueur_ecriture = write_atomic(s_etat_processus,
2147: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2148: sizeof((*s_objet).type))
2149: {
2150: if (longueur_ecriture == -1)
2151: {
2152: return(d_erreur);
2153: }
2154:
2155: nanosleep(&attente, NULL);
2156: INCR_GRANULARITE(attente.tv_nsec);
2157: }
2158:
2159: longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
2160:
2161: attente.tv_sec = 0;
2162: attente.tv_nsec = GRANULARITE_us * 1000;
2163:
2164: while((longueur_ecriture = write_atomic(s_etat_processus,
2165: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2166: {
2167: if (longueur_ecriture == -1)
2168: {
2169: return(d_erreur);
2170: }
2171:
2172: nanosleep(&attente, NULL);
2173: INCR_GRANULARITE(attente.tv_nsec);
2174: }
2175:
2176: attente.tv_sec = 0;
2177: attente.tv_nsec = GRANULARITE_us * 1000;
2178:
2179: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2180: (unsigned char *) (*s_objet).objet,
2181: longueur)) != (ssize_t) longueur)
2182: {
2183: if (longueur_ecriture == -1)
2184: {
2185: return(d_erreur);
2186: }
2187:
2188: nanosleep(&attente, NULL);
2189: INCR_GRANULARITE(attente.tv_nsec);
2190: }
2191: }
2192: else if (((*s_objet).type == LST) ||
2193: ((*s_objet).type == ALG) ||
2194: ((*s_objet).type == RPN))
2195: {
2196: attente.tv_sec = 0;
2197: attente.tv_nsec = GRANULARITE_us * 1000;
2198:
2199: while((longueur_ecriture = write_atomic(s_etat_processus,
2200: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2201: sizeof((*s_objet).type))
2202: {
2203: if (longueur_ecriture == -1)
2204: {
2205: return(d_erreur);
2206: }
2207:
2208: nanosleep(&attente, NULL);
2209: INCR_GRANULARITE(attente.tv_nsec);
2210: }
2211:
2212: l_element_courant = (*s_objet).objet;
2213: i = 0;
2214:
2215: while(l_element_courant != NULL)
2216: {
2217: i++;
2218: l_element_courant = (*l_element_courant).suivant;
2219: }
2220:
2221: attente.tv_sec = 0;
2222: attente.tv_nsec = GRANULARITE_us * 1000;
2223:
2224: while((longueur_ecriture = write_atomic(s_etat_processus,
2225: pipe, &i, sizeof(i))) != sizeof(i))
2226: {
2227: if (longueur_ecriture == -1)
2228: {
2229: return(d_erreur);
2230: }
2231:
2232: nanosleep(&attente, NULL);
2233: INCR_GRANULARITE(attente.tv_nsec);
2234: }
2235:
2236: l_element_courant = (*s_objet).objet;
2237:
2238: while(l_element_courant != NULL)
2239: {
2240: if (ecriture_pipe(s_etat_processus, pipe,
2241: (*l_element_courant).donnee) == d_erreur)
2242: {
2243: return(d_erreur);
2244: }
2245:
2246: l_element_courant = (*l_element_courant).suivant;
2247: }
2248: }
2249: else if ((*s_objet).type == TBL)
2250: {
2251: attente.tv_sec = 0;
2252: attente.tv_nsec = GRANULARITE_us * 1000;
2253:
2254: while((longueur_ecriture = write_atomic(s_etat_processus,
2255: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2256: sizeof((*s_objet).type))
2257: {
2258: if (longueur_ecriture == -1)
2259: {
2260: return(d_erreur);
2261: }
2262:
2263: nanosleep(&attente, NULL);
2264: INCR_GRANULARITE(attente.tv_nsec);
2265: }
2266:
2267: attente.tv_sec = 0;
2268: attente.tv_nsec = GRANULARITE_us * 1000;
2269:
2270: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2271: &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
2272: sizeof(integer8))) != sizeof(integer8))
2273: {
2274: if (longueur_ecriture == -1)
2275: {
2276: return(d_erreur);
2277: }
2278:
2279: nanosleep(&attente, NULL);
2280: INCR_GRANULARITE(attente.tv_nsec);
2281: }
2282:
2283: for(i = 0; i < (*((struct_tableau *)
2284: (*s_objet).objet)).nombre_elements; i++)
2285: {
2286: if (ecriture_pipe(s_etat_processus, pipe,
2287: (*((struct_tableau *) (*s_objet).objet)).elements[i])
2288: == d_erreur)
2289: {
2290: return(d_erreur);
2291: }
2292: }
2293: }
2294: else
2295: {
2296: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2297: return(d_erreur);
2298: }
2299:
2300: return(d_absence_erreur);
2301: }
2302:
2303:
2304: /*
2305: ================================================================================
2306: Fonction de lecture dans un pipe
2307: ================================================================================
2308: Entrées : pointeur sur une structure de description du processus,
2309: numéro du pipe et objet à écrire
2310: --------------------------------------------------------------------------------
2311: Sorties :
2312: --------------------------------------------------------------------------------
2313: Effets de bord : néant
2314: ================================================================================
2315: */
2316:
2317: struct_objet *
2318: lecture_pipe(struct_processus *s_etat_processus, int pipe)
2319: {
2320: size_t longueur;
2321:
2322: struct_liste_chainee *l_element_courant;
2323:
2324: struct_objet *s_objet;
2325:
2326: struct timespec attente;
2327:
2328: integer8 i;
2329: integer8 j;
2330:
2331: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
2332: {
2333: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2334: return(NULL);
2335: }
2336:
2337: attente.tv_sec = 0;
2338: attente.tv_nsec = GRANULARITE_us * 1000;
2339:
2340: while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
2341: sizeof((*s_objet).type)) != sizeof((*s_objet).type))
2342: {
2343: nanosleep(&attente, NULL);
2344: INCR_GRANULARITE(attente.tv_nsec);
2345: }
2346:
2347: if ((*s_objet).type == INT)
2348: {
2349: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2350: {
2351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2352: return(NULL);
2353: }
2354:
2355: attente.tv_sec = 0;
2356: attente.tv_nsec = GRANULARITE_us * 1000;
2357:
2358: while(read_atomic(s_etat_processus, pipe,
2359: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2360: {
2361: nanosleep(&attente, NULL);
2362: INCR_GRANULARITE(attente.tv_nsec);
2363: }
2364: }
2365: else if ((*s_objet).type == REL)
2366: {
2367: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
2368: {
2369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2370: return(NULL);
2371: }
2372:
2373: attente.tv_sec = 0;
2374: attente.tv_nsec = GRANULARITE_us * 1000;
2375:
2376: while(read_atomic(s_etat_processus, pipe,
2377: (*s_objet).objet, sizeof(real8)) != sizeof(real8))
2378: {
2379: nanosleep(&attente, NULL);
2380: INCR_GRANULARITE(attente.tv_nsec);
2381: }
2382: }
2383: else if ((*s_objet).type == CPL)
2384: {
2385: if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
2386: {
2387: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2388: return(NULL);
2389: }
2390:
2391: attente.tv_sec = 0;
2392: attente.tv_nsec = GRANULARITE_us * 1000;
2393:
2394: while(read_atomic(s_etat_processus, pipe,
2395: (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
2396: {
2397: nanosleep(&attente, NULL);
2398: INCR_GRANULARITE(attente.tv_nsec);
2399: }
2400: }
2401: else if ((*s_objet).type == VIN)
2402: {
2403: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2404: {
2405: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2406: return(NULL);
2407: }
2408:
2409: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
2410:
2411: attente.tv_sec = 0;
2412: attente.tv_nsec = GRANULARITE_us * 1000;
2413:
2414: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2415: (*s_objet).objet)).taille),
2416: sizeof(integer8)) != sizeof(integer8))
2417: {
2418: nanosleep(&attente, NULL);
2419: INCR_GRANULARITE(attente.tv_nsec);
2420: }
2421:
2422: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2423: malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
2424: .taille) * sizeof(integer8))) == NULL)
2425: {
2426: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2427: return(NULL);
2428: }
2429:
2430: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2431: {
2432: attente.tv_sec = 0;
2433: attente.tv_nsec = GRANULARITE_us * 1000;
2434:
2435: while(read_atomic(s_etat_processus, pipe,
2436: &(((integer8 *) (*((struct_vecteur *)
2437: (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
2438: sizeof(integer8))
2439: {
2440: nanosleep(&attente, NULL);
2441: INCR_GRANULARITE(attente.tv_nsec);
2442: }
2443: }
2444: }
2445: else if ((*s_objet).type == VRL)
2446: {
2447: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2448: {
2449: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2450: return(NULL);
2451: }
2452:
2453: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
2454:
2455: attente.tv_sec = 0;
2456: attente.tv_nsec = GRANULARITE_us * 1000;
2457:
2458: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2459: (*s_objet).objet)).taille),
2460: sizeof(integer8)) != sizeof(integer8))
2461: {
2462: nanosleep(&attente, NULL);
2463: INCR_GRANULARITE(attente.tv_nsec);
2464: }
2465:
2466: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2467: malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
2468: .taille) * sizeof(real8))) == NULL)
2469: {
2470: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2471: return(NULL);
2472: }
2473:
2474: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2475: {
2476: attente.tv_sec = 0;
2477: attente.tv_nsec = GRANULARITE_us * 1000;
2478:
2479: while(read_atomic(s_etat_processus, pipe,
2480: &(((real8 *) (*((struct_vecteur *)
2481: (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
2482: sizeof(real8))
2483: {
2484: nanosleep(&attente, NULL);
2485: INCR_GRANULARITE(attente.tv_nsec);
2486: }
2487: }
2488: }
2489: else if ((*s_objet).type == VCX)
2490: {
2491: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2492: {
2493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2494: return(NULL);
2495: }
2496:
2497: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
2498:
2499: attente.tv_sec = 0;
2500: attente.tv_nsec = GRANULARITE_us * 1000;
2501:
2502: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2503: (*s_objet).objet)).taille),
2504: sizeof(integer8)) != sizeof(integer8))
2505: {
2506: nanosleep(&attente, NULL);
2507: INCR_GRANULARITE(attente.tv_nsec);
2508: }
2509:
2510: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2511: malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet))
2512: .taille) * sizeof(complex16))) == NULL)
2513: {
2514: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2515: return(NULL);
2516: }
2517:
2518: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2519: {
2520: attente.tv_sec = 0;
2521: attente.tv_nsec = GRANULARITE_us * 1000;
2522:
2523: while(read_atomic(s_etat_processus, pipe,
2524: &(((complex16 *) (*((struct_vecteur *)
2525: (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
2526: sizeof(complex16))
2527: {
2528: nanosleep(&attente, NULL);
2529: INCR_GRANULARITE(attente.tv_nsec);
2530: }
2531: }
2532: }
2533: else if ((*s_objet).type == MIN)
2534: {
2535: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2536: {
2537: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2538: return(NULL);
2539: }
2540:
2541: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
2542:
2543: attente.tv_sec = 0;
2544: attente.tv_nsec = GRANULARITE_us * 1000;
2545:
2546: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2547: (*s_objet).objet)).nombre_lignes),
2548: sizeof(integer8)) != sizeof(integer8))
2549: {
2550: nanosleep(&attente, NULL);
2551: INCR_GRANULARITE(attente.tv_nsec);
2552: }
2553:
2554: attente.tv_sec = 0;
2555: attente.tv_nsec = GRANULARITE_us * 1000;
2556:
2557: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2558: (*s_objet).objet)).nombre_colonnes),
2559: sizeof(integer8)) != sizeof(integer8))
2560: {
2561: nanosleep(&attente, NULL);
2562: INCR_GRANULARITE(attente.tv_nsec);
2563: }
2564:
2565: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2566: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2567: .nombre_lignes) * sizeof(integer8 *))) == NULL)
2568: {
2569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2570: return(NULL);
2571: }
2572:
2573: for(i = 0; i < (*((struct_matrice *)
2574: (*s_objet).objet)).nombre_lignes; i++)
2575: {
2576: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2577: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2578: .nombre_colonnes) * sizeof(integer8))) == NULL)
2579: {
2580: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2581: return(NULL);
2582: }
2583:
2584: for(j = 0; j < (*((struct_matrice *)
2585: (*s_objet).objet)).nombre_colonnes; j++)
2586: {
2587: attente.tv_sec = 0;
2588: attente.tv_nsec = GRANULARITE_us * 1000;
2589:
2590: while(read_atomic(s_etat_processus,
2591: pipe, &(((integer8 **) (*((struct_matrice *)
2592: (*s_objet).objet)).tableau)[i][j]),
2593: sizeof(integer8)) != sizeof(integer8))
2594: {
2595: nanosleep(&attente, NULL);
2596: INCR_GRANULARITE(attente.tv_nsec);
2597: }
2598: }
2599: }
2600: }
2601: else if ((*s_objet).type == MRL)
2602: {
2603: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2604: {
2605: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2606: return(NULL);
2607: }
2608:
2609: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
2610:
2611: attente.tv_sec = 0;
2612: attente.tv_nsec = GRANULARITE_us * 1000;
2613:
2614: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2615: (*s_objet).objet)).nombre_lignes),
2616: sizeof(integer8)) != sizeof(integer8))
2617: {
2618: nanosleep(&attente, NULL);
2619: INCR_GRANULARITE(attente.tv_nsec);
2620: }
2621:
2622: attente.tv_sec = 0;
2623: attente.tv_nsec = GRANULARITE_us * 1000;
2624:
2625: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2626: (*s_objet).objet)).nombre_colonnes),
2627: sizeof(integer8)) != sizeof(integer8))
2628: {
2629: nanosleep(&attente, NULL);
2630: INCR_GRANULARITE(attente.tv_nsec);
2631: }
2632:
2633: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2634: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2635: .nombre_lignes) * sizeof(real8 *))) == NULL)
2636: {
2637: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2638: return(NULL);
2639: }
2640:
2641: for(i = 0; i < (*((struct_matrice *)
2642: (*s_objet).objet)).nombre_lignes; i++)
2643: {
2644: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2645: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2646: .nombre_colonnes) * sizeof(real8))) == NULL)
2647: {
2648: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2649: return(NULL);
2650: }
2651:
2652: for(j = 0; j < (*((struct_matrice *)
2653: (*s_objet).objet)).nombre_colonnes; j++)
2654: {
2655: attente.tv_sec = 0;
2656: attente.tv_nsec = GRANULARITE_us * 1000;
2657:
2658: while(read_atomic(s_etat_processus,
2659: pipe, &(((real8 **) (*((struct_matrice *)
2660: (*s_objet).objet)).tableau)[i][j]),
2661: sizeof(real8)) != sizeof(real8))
2662: {
2663: nanosleep(&attente, NULL);
2664: INCR_GRANULARITE(attente.tv_nsec);
2665: }
2666: }
2667: }
2668: }
2669: else if ((*s_objet).type == MCX)
2670: {
2671: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2672: {
2673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2674: return(NULL);
2675: }
2676:
2677: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
2678:
2679: attente.tv_sec = 0;
2680: attente.tv_nsec = GRANULARITE_us * 1000;
2681:
2682: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2683: (*s_objet).objet)).nombre_lignes),
2684: sizeof(integer8)) != sizeof(integer8))
2685: {
2686: nanosleep(&attente, NULL);
2687: INCR_GRANULARITE(attente.tv_nsec);
2688: }
2689:
2690: attente.tv_sec = 0;
2691: attente.tv_nsec = GRANULARITE_us * 1000;
2692:
2693: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2694: (*s_objet).objet)).nombre_colonnes),
2695: sizeof(integer8)) != sizeof(integer8))
2696: {
2697: nanosleep(&attente, NULL);
2698: INCR_GRANULARITE(attente.tv_nsec);
2699: }
2700:
2701: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2702: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2703: .nombre_lignes) * sizeof(complex16 *))) == NULL)
2704: {
2705: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2706: return(NULL);
2707: }
2708:
2709: for(i = 0; i < (*((struct_matrice *)
2710: (*s_objet).objet)).nombre_lignes; i++)
2711: {
2712: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2713: malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
2714: .nombre_colonnes) * sizeof(complex16))) == NULL)
2715: {
2716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2717: return(NULL);
2718: }
2719:
2720: for(j = 0; j < (*((struct_matrice *)
2721: (*s_objet).objet)).nombre_colonnes; j++)
2722: {
2723: attente.tv_sec = 0;
2724: attente.tv_nsec = GRANULARITE_us * 1000;
2725:
2726: while(read_atomic(s_etat_processus, pipe,
2727: &(((complex16 **) (*((struct_matrice *)
2728: (*s_objet).objet)).tableau)[i][j]),
2729: sizeof(complex16)) != sizeof(complex16))
2730: {
2731: nanosleep(&attente, NULL);
2732: INCR_GRANULARITE(attente.tv_nsec);
2733: }
2734: }
2735: }
2736: }
2737: else if ((*s_objet).type == BIN)
2738: {
2739: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2740: {
2741: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2742: return(NULL);
2743: }
2744:
2745: attente.tv_sec = 0;
2746: attente.tv_nsec = GRANULARITE_us * 1000;
2747:
2748: while(read_atomic(s_etat_processus, pipe,
2749: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2750: {
2751: nanosleep(&attente, NULL);
2752: INCR_GRANULARITE(attente.tv_nsec);
2753: }
2754: }
2755: else if ((*s_objet).type == NOM)
2756: {
2757: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
2758: {
2759: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2760: return(NULL);
2761: }
2762:
2763: attente.tv_sec = 0;
2764: attente.tv_nsec = GRANULARITE_us * 1000;
2765:
2766: while(read_atomic(s_etat_processus,
2767: pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
2768: {
2769: nanosleep(&attente, NULL);
2770: INCR_GRANULARITE(attente.tv_nsec);
2771: }
2772:
2773: if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
2774: sizeof(unsigned char))) == NULL)
2775: {
2776: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2777: return(NULL);
2778: }
2779:
2780: attente.tv_sec = 0;
2781: attente.tv_nsec = GRANULARITE_us * 1000;
2782:
2783: while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
2784: (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
2785: {
2786: nanosleep(&attente, NULL);
2787: INCR_GRANULARITE(attente.tv_nsec);
2788: }
2789:
2790: attente.tv_sec = 0;
2791: attente.tv_nsec = GRANULARITE_us * 1000;
2792:
2793: while(read_atomic(s_etat_processus, pipe,
2794: &((*((struct_nom *) (*s_objet).objet)).symbole),
2795: sizeof(logical1)) != sizeof(logical1))
2796: {
2797: nanosleep(&attente, NULL);
2798: INCR_GRANULARITE(attente.tv_nsec);
2799: }
2800: }
2801: else if ((*s_objet).type == FCT)
2802: {
2803: if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
2804: {
2805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2806: return(NULL);
2807: }
2808:
2809: attente.tv_sec = 0;
2810: attente.tv_nsec = GRANULARITE_us * 1000;
2811:
2812: while(read_atomic(s_etat_processus, pipe,
2813: &longueur, sizeof(size_t)) != sizeof(size_t))
2814: {
2815: nanosleep(&attente, NULL);
2816: INCR_GRANULARITE(attente.tv_nsec);
2817: }
2818:
2819: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
2820: malloc(longueur * sizeof(unsigned char))) == NULL)
2821: {
2822: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2823: return(NULL);
2824: }
2825:
2826: attente.tv_sec = 0;
2827: attente.tv_nsec = GRANULARITE_us * 1000;
2828:
2829: while(read_atomic(s_etat_processus, pipe,
2830: (*((struct_fonction *) (*s_objet).objet))
2831: .nom_fonction, longueur) != (ssize_t) longueur)
2832: {
2833: nanosleep(&attente, NULL);
2834: INCR_GRANULARITE(attente.tv_nsec);
2835: }
2836:
2837: attente.tv_sec = 0;
2838: attente.tv_nsec = GRANULARITE_us * 1000;
2839:
2840: while(read_atomic(s_etat_processus, pipe,
2841: &((*((struct_fonction *) (*s_objet).objet))
2842: .nombre_arguments), sizeof(integer8)) !=
2843: sizeof(integer8))
2844: {
2845: nanosleep(&attente, NULL);
2846: INCR_GRANULARITE(attente.tv_nsec);
2847: }
2848:
2849: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
2850: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
2851: (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
2852: }
2853: else if ((*s_objet).type == CHN)
2854: {
2855: attente.tv_sec = 0;
2856: attente.tv_nsec = GRANULARITE_us * 1000;
2857:
2858: while(read_atomic(s_etat_processus, pipe,
2859: &longueur, sizeof(size_t)) != sizeof(size_t))
2860: {
2861: nanosleep(&attente, NULL);
2862: INCR_GRANULARITE(attente.tv_nsec);
2863: }
2864:
2865: if (((*s_objet).objet = malloc(longueur *
2866: sizeof(unsigned char))) == NULL)
2867: {
2868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2869: return(NULL);
2870: }
2871:
2872: attente.tv_sec = 0;
2873: attente.tv_nsec = GRANULARITE_us * 1000;
2874:
2875: while(read_atomic(s_etat_processus, pipe, (unsigned char *)
2876: (*s_objet).objet, longueur) != (ssize_t) longueur)
2877: {
2878: nanosleep(&attente, NULL);
2879: INCR_GRANULARITE(attente.tv_nsec);
2880: }
2881: }
2882: else if (((*s_objet).type == LST) ||
2883: ((*s_objet).type == ALG) ||
2884: ((*s_objet).type == RPN))
2885: {
2886: attente.tv_sec = 0;
2887: attente.tv_nsec = GRANULARITE_us * 1000;
2888:
2889: while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
2890: {
2891: nanosleep(&attente, NULL);
2892: INCR_GRANULARITE(attente.tv_nsec);
2893: }
2894:
2895: l_element_courant = NULL;
2896:
2897: for(i = 0; i < j; i++)
2898: {
2899: if (l_element_courant == NULL)
2900: {
2901: if ((l_element_courant =
2902: malloc(sizeof(struct_liste_chainee))) == NULL)
2903: {
2904: (*s_etat_processus).erreur_systeme =
2905: d_es_allocation_memoire;
2906: return(NULL);
2907: }
2908:
2909: (*s_objet).objet = l_element_courant;
2910: }
2911: else
2912: {
2913: if (((*l_element_courant).suivant =
2914: malloc(sizeof(struct_liste_chainee))) == NULL)
2915: {
2916: (*s_etat_processus).erreur_systeme =
2917: d_es_allocation_memoire;
2918: return(NULL);
2919: }
2920:
2921: l_element_courant = (*l_element_courant).suivant;
2922: (*l_element_courant).suivant = NULL;
2923: }
2924:
2925: attente.tv_sec = 0;
2926: attente.tv_nsec = GRANULARITE_us * 1000;
2927:
2928: while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
2929: pipe)) == NULL)
2930: {
2931: if ((*s_etat_processus).erreur_systeme != d_es)
2932: {
2933: return(NULL);
2934: }
2935:
2936: nanosleep(&attente, NULL);
2937: INCR_GRANULARITE(attente.tv_nsec);
2938: }
2939: }
2940:
2941: if (l_element_courant == NULL)
2942: {
2943: (*s_objet).objet = NULL;
2944: }
2945: else
2946: {
2947: (*l_element_courant).suivant = NULL;
2948: }
2949: }
2950: else if ((*s_objet).type == TBL)
2951: {
2952: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
2953: {
2954: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2955: return(NULL);
2956: }
2957:
2958: attente.tv_sec = 0;
2959: attente.tv_nsec = GRANULARITE_us * 1000;
2960:
2961: while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
2962: (*s_objet).objet)).nombre_elements),
2963: sizeof(integer8)) != sizeof(integer8))
2964: {
2965: nanosleep(&attente, NULL);
2966: INCR_GRANULARITE(attente.tv_nsec);
2967: }
2968:
2969: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
2970: ((size_t) (*((struct_tableau *) (*s_objet).objet))
2971: .nombre_elements) * sizeof(struct_objet *))) == NULL)
2972: {
2973: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2974: return(NULL);
2975: }
2976:
2977: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
2978: i++)
2979: {
2980: attente.tv_sec = 0;
2981: attente.tv_nsec = GRANULARITE_us * 1000;
2982:
2983: while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
2984: lecture_pipe(s_etat_processus, pipe)) == NULL)
2985: {
2986: if ((*s_etat_processus).erreur_systeme != d_es)
2987: {
2988: return(NULL);
2989: }
2990:
2991: nanosleep(&attente, NULL);
2992: INCR_GRANULARITE(attente.tv_nsec);
2993: }
2994: }
2995: }
2996:
2997: return(s_objet);
2998: }
2999:
3000:
3001: /*
3002: ================================================================================
3003: Fonction de scrutation des données injectées par le processus père
3004: ================================================================================
3005: Entrées : pointeur sur une structure
3006: --------------------------------------------------------------------------------
3007: Sorties :
3008: --------------------------------------------------------------------------------
3009: Effets de bord : néant
3010: ================================================================================
3011: */
3012:
3013: void
3014: scrutation_injection(struct_processus *s_etat_processus)
3015: {
3016: logical1 drapeau_erreur;
3017: logical1 registre_arret_si_exception;
3018:
3019: struct pollfd fds;
3020:
3021: unsigned char tampon;
3022: unsigned char tampon_profilage[20];
3023:
3024: scrutation_interruptions(s_etat_processus);
3025:
3026: // Si on est dans le processus père, il n'y a rien à surveiller.
3027:
3028: if ((*s_etat_processus).var_volatile_processus_racine == 0)
3029: {
3030: fds.fd = (*s_etat_processus).pipe_nombre_injections;
3031: fds.events = POLLIN;
3032: fds.revents = 0;
3033:
3034: if (poll(&fds, 1, 0) > 0)
3035: {
3036: if (read_atomic(s_etat_processus,
3037: (*s_etat_processus).pipe_nombre_injections,
3038: &tampon, sizeof(unsigned char)) == sizeof(unsigned char))
3039: {
3040: if (tampon == '-')
3041: {
3042: (*s_etat_processus).nombre_objets_injectes++;
3043: }
3044: else if (tampon == '+')
3045: {
3046: (*s_etat_processus).nombre_objets_envoyes_non_lus--;
3047:
3048: BUG((*s_etat_processus).nombre_objets_envoyes_non_lus < 0,
3049: printf("(*s_etat_processus).nombre_objets_envoyes_"
3050: "non_lus=%d\n", (*s_etat_processus)
3051: .nombre_objets_envoyes_non_lus));
3052: }
3053: else
3054: {
3055: BUG(1, printf("tampon='%c' (%d)\n", tampon, tampon));
3056: }
3057: }
3058: }
3059:
3060: /*
3061: * Traitement de l'interruption d'injection
3062: */
3063:
3064: if (((*s_etat_processus).nombre_objets_injectes != 0) &&
3065: ((*s_etat_processus).traitement_at_poke == 'N'))
3066: {
3067: if ((*s_etat_processus).at_poke != NULL)
3068: {
3069: registre_arret_si_exception =
3070: (*s_etat_processus).arret_si_exception;
3071: (*s_etat_processus).arret_si_exception = d_vrai;
3072:
3073: if ((*s_etat_processus).debug == d_vrai)
3074: if (((*s_etat_processus).type_debug &
3075: d_traitement_interruption) != 0)
3076: {
3077: if ((*s_etat_processus).langue == 'F')
3078: {
3079: printf("[%d] Traitement de l'interruption "
3080: "d'injection\n", (int) getpid());
3081: }
3082: else
3083: {
3084: printf("[%d] Start injection interrupt\n",
3085: (int) getpid());
3086: }
3087:
3088: fflush(stdout);
3089: }
3090:
3091: if ((*s_etat_processus).profilage == d_vrai)
3092: {
3093: sprintf(tampon_profilage, "Injection interrupt");
3094: profilage(s_etat_processus, tampon_profilage);
3095:
3096: if ((*s_etat_processus).erreur_systeme != d_es)
3097: {
3098: return;
3099: }
3100: }
3101:
3102: (*s_etat_processus).traitement_at_poke = 'Y';
3103: drapeau_erreur = evaluation(s_etat_processus,
3104: (*s_etat_processus).at_poke, 'E');
3105: (*s_etat_processus).traitement_at_poke = 'N';
3106:
3107: if ((*s_etat_processus).profilage == d_vrai)
3108: {
3109: profilage(s_etat_processus, NULL);
3110: }
3111:
3112: if (drapeau_erreur == d_absence_erreur)
3113: {
3114: (*s_etat_processus).arret_si_exception =
3115: registre_arret_si_exception;
3116: }
3117: else
3118: {
3119: if ((((*s_etat_processus).erreur_execution != d_ex) ||
3120: ((*s_etat_processus).exception != d_ep) ||
3121: ((*s_etat_processus).erreur_systeme != d_es)) &&
3122: ((*s_etat_processus).core == d_vrai) &&
3123: ((*s_etat_processus)
3124: .var_volatile_traitement_sigint == 0))
3125: {
3126: printf("\n");
3127:
3128: if ((*s_etat_processus).langue == 'F')
3129: {
3130: printf("+++Information : "
3131: "Génération du fichier rpl-core "
3132: "[%d]\n", (int) getpid());
3133: }
3134: else
3135: {
3136: printf("+++Information : "
3137: "Writing rpl-core file [%d]\n",
3138: (int) getpid());
3139: }
3140:
3141: rplcore(s_etat_processus);
3142:
3143: if ((*s_etat_processus).langue == 'F')
3144: {
3145: printf("+++Information : "
3146: "Processus tracé [%d]\n",
3147: (int) getpid());
3148: }
3149: else
3150: {
3151: printf("+++Information : Done [%d]\n",
3152: (int) getpid());
3153: }
3154:
3155: printf("\n");
3156: fflush(stdout);
3157: }
3158:
3159: }
3160:
3161: if ((*s_etat_processus).debug == d_vrai)
3162: if (((*s_etat_processus).type_debug &
3163: d_traitement_interruption) != 0)
3164: {
3165: if ((*s_etat_processus).langue == 'F')
3166: {
3167: printf("[%d] Fin de l'interruption d'injection\n",
3168: (int) getpid());
3169: }
3170: else
3171: {
3172: printf("[%d] Stop injection interrupt\n",
3173: (int) getpid());
3174: }
3175:
3176: fflush(stdout);
3177: }
3178:
3179: if ((drapeau_erreur == d_erreur) &&
3180: ((*s_etat_processus).erreur_execution == d_ex))
3181: {
3182: if (((*s_etat_processus).erreur_execution == d_ex) &&
3183: ((*s_etat_processus).erreur_systeme == d_es))
3184: {
3185: (*s_etat_processus).erreur_execution =
3186: d_ex_erreur_evaluation;
3187: }
3188: }
3189: }
3190: }
3191: }
3192:
3193: return;
3194: }
3195:
3196:
3197: /*
3198: ================================================================================
3199: Fonction de test du drapeau d'arrêt
3200: ================================================================================
3201: Entrées : pointeur sur une structure
3202: --------------------------------------------------------------------------------
3203: Sorties :
3204: --------------------------------------------------------------------------------
3205: Effets de bord : néant
3206: ================================================================================
3207: */
3208:
3209: int
3210: test_arret(struct_processus *s_etat_processus)
3211: {
3212: return((int) (*s_etat_processus).var_volatile_requete_arret);
3213: }
3214:
3215: // 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