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