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