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