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