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