1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.19
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: }
930: else
931: {
932: (*s_etat_processus).erreur_systeme_processus_fils =
933: d_es_processus;
934: }
935: }
936:
937: if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
938: {
939: (*s_etat_processus).erreur_systeme = d_es_processus;
940: }
941:
942: if ((*s_argument_thread).thread_actif == d_faux)
943: {
944: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
945: {
946: (*s_etat_processus).erreur_systeme = d_es_processus;
947: }
948:
949: pthread_join((*s_argument_thread).tid, NULL);
950: drapeau_fin_scrutation = (0 != 0);
951: }
952: else
953: {
954: if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
955: {
956: (*s_etat_processus).erreur_systeme = d_es_processus;
957: }
958:
959: drapeau_fin_scrutation = (0 == 0);
960: }
961: }
962: } while(drapeau_fin_scrutation);
963:
964: /*
965: * Le processus fils est terminé. On s'assure qu'il ne
966: * reste plus rien dans les tuyaux...
967: */
968:
969: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
970: {
971: (*s_etat_processus).erreur_systeme_processus_fils =
972: d_es_processus;
973: }
974: else
975: {
976: if ((*s_etat_processus).debug == d_vrai)
977: if (((*s_etat_processus).type_debug &
978: d_debug_processus) != 0)
979: {
980: if ((*s_argument_thread).processus_detache == d_vrai)
981: {
982: if ((*s_etat_processus).langue == 'F')
983: {
984: printf("[%d] Surveillance des tuyaux du processus %d\n",
985: (int) getpid(), (int) (*s_argument_thread).pid);
986: fflush(stdout);
987: }
988: else
989: {
990: printf("[%d] Check remaining pipes of process %d\n",
991: (int) getpid(), (int) (*s_argument_thread).pid);
992: fflush(stdout);
993: }
994: }
995: else
996: {
997: if ((*s_etat_processus).langue == 'F')
998: {
999: printf("[%d] Surveillance des tuyaux du thread %llu\n",
1000: (int) getpid(), (unsigned long long)
1001: (*s_argument_thread).tid);
1002: fflush(stdout);
1003: }
1004: else
1005: {
1006: printf("[%d] Check remaining pipes of thread %llu\n",
1007: (int) getpid(), (unsigned long long)
1008: (*s_argument_thread).tid);
1009: fflush(stdout);
1010: }
1011: }
1012: }
1013:
1014: l_element_courant = (struct_liste_chainee *)
1015: (*s_etat_processus).l_base_pile_processus;
1016:
1017: if (drapeau_objets_traites == d_faux)
1018: {
1019: if ((*s_argument_thread).processus_detache == d_vrai)
1020: {
1021: while(l_element_courant != NULL)
1022: {
1023: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1024: .donnee).objet)).thread).processus_detache
1025: == d_faux)
1026: {
1027: l_element_courant = (*l_element_courant).suivant;
1028: continue;
1029: }
1030:
1031: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1032: .donnee).objet)).thread).pid ==
1033: (*s_argument_thread).pid)
1034: {
1035: while(read_atomic(s_etat_processus, (*s_argument_thread)
1036: .pipe_nombre_objets_attente[0],
1037: &pid_candidat, sizeof(pid_candidat)) ==
1038: sizeof(pid_candidat))
1039: {
1040: /*
1041: * -1 est renvoyé par l'instruction SWI
1042: */
1043:
1044: if (pid_candidat == -2)
1045: {
1046: break;
1047: }
1048: else if (pid_candidat == -1)
1049: {
1050: }
1051: else if (read_atomic(s_etat_processus,
1052: (*s_argument_thread)
1053: .pipe_nombre_objets_attente[0],
1054: &pid_candidat, sizeof(pid_candidat)) ==
1055: sizeof(pid_candidat))
1056: {
1057: if ((*s_etat_processus).debug == d_vrai)
1058: if (((*s_etat_processus).type_debug &
1059: d_debug_processus) != 0)
1060: {
1061: if ((*s_etat_processus).langue == 'F')
1062: {
1063: printf("[%d] Données en provenance du "
1064: "processus %d (processus "
1065: "arrêté)\n", (int) getpid(),
1066: (int) (*s_argument_thread).pid);
1067: fflush(stdout);
1068: }
1069: else
1070: {
1071: printf("[%d] Data from process %d "
1072: "(processus stopped)\n",
1073: (int) getpid(),
1074: (int) (*s_argument_thread).pid);
1075: fflush(stdout);
1076: }
1077: }
1078:
1079: if (pthread_mutex_lock(
1080: &((*(*((struct_processus_fils *)
1081: (*(*l_element_courant).donnee).objet))
1082: .thread).mutex)) != 0)
1083: {
1084: (*s_etat_processus).erreur_systeme =
1085: d_es_processus;
1086: }
1087:
1088: (*(*((struct_processus_fils *)
1089: (*(*l_element_courant).donnee).objet))
1090: .thread).nombre_objets_dans_pipe++;
1091:
1092: if (pthread_mutex_unlock(
1093: &((*(*((struct_processus_fils *)
1094: (*(*l_element_courant).donnee).objet))
1095: .thread).mutex)) != 0)
1096: {
1097: (*s_etat_processus).erreur_systeme =
1098: d_es_processus;
1099: }
1100: }
1101: }
1102:
1103: break;
1104: }
1105:
1106: l_element_courant = (*l_element_courant).suivant;
1107: }
1108: }
1109: else
1110: {
1111: while(l_element_courant != NULL)
1112: {
1113: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1114: .donnee).objet)).thread).processus_detache
1115: == d_vrai)
1116: {
1117: l_element_courant = (*l_element_courant).suivant;
1118: continue;
1119: }
1120:
1121: if (pthread_equal((*(*((struct_processus_fils *)
1122: (*(*l_element_courant).donnee).objet)).thread).tid,
1123: (*s_argument_thread).tid) != 0)
1124: {
1125: while(read_atomic(s_etat_processus, (*s_argument_thread)
1126: .pipe_nombre_objets_attente[0],
1127: &tid_candidat, sizeof(tid_candidat)) ==
1128: sizeof(tid_candidat))
1129: {
1130: /*
1131: * -1 est renvoyé par l'instruction SWI
1132: */
1133:
1134: if (tid_candidat == (pthread_t) -2)
1135: {
1136: break;
1137: }
1138: else if (tid_candidat == (pthread_t) -1)
1139: {
1140: }
1141: else if (read_atomic(s_etat_processus,
1142: (*s_argument_thread)
1143: .pipe_nombre_objets_attente[0],
1144: &tid_candidat, sizeof(tid_candidat)) ==
1145: sizeof(tid_candidat))
1146: {
1147: if ((*s_etat_processus).debug == d_vrai)
1148: if (((*s_etat_processus).type_debug &
1149: d_debug_processus) != 0)
1150: {
1151: if ((*s_etat_processus).langue == 'F')
1152: {
1153: printf("[%d] Données en provenance du "
1154: "thread %llu (thread "
1155: "arrêté)\n", (int) getpid(),
1156: (unsigned long long)
1157: (*s_argument_thread).tid);
1158: fflush(stdout);
1159: }
1160: else
1161: {
1162: printf("[%d] Data from thread %llu "
1163: "(thread stopped)\n",
1164: (int) getpid(),
1165: (unsigned long long)
1166: (*s_argument_thread).tid);
1167: fflush(stdout);
1168: }
1169: }
1170:
1171: if (pthread_mutex_lock(
1172: &((*(*((struct_processus_fils *)
1173: (*(*l_element_courant).donnee).objet))
1174: .thread).mutex)) != 0)
1175: {
1176: (*s_etat_processus).erreur_systeme =
1177: d_es_processus;
1178: }
1179:
1180: (*(*((struct_processus_fils *)
1181: (*(*l_element_courant).donnee).objet))
1182: .thread).nombre_objets_dans_pipe++;
1183:
1184: if (pthread_mutex_unlock(
1185: &((*(*((struct_processus_fils *)
1186: (*(*l_element_courant).donnee).objet))
1187: .thread).mutex)) != 0)
1188: {
1189: (*s_etat_processus).erreur_systeme =
1190: d_es_processus;
1191: }
1192: }
1193: }
1194:
1195: break;
1196: }
1197:
1198: l_element_courant = (*l_element_courant).suivant;
1199: }
1200: }
1201: }
1202:
1203: l_element_courant = (struct_liste_chainee *)
1204: (*s_etat_processus).l_base_pile_processus;
1205:
1206: if (drapeau_interruptions_traitees == d_faux)
1207: {
1208: if ((*s_argument_thread).processus_detache == d_vrai)
1209: {
1210: while(l_element_courant != NULL)
1211: {
1212: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1213: .donnee).objet)).thread).processus_detache
1214: == d_faux)
1215: {
1216: l_element_courant = (*l_element_courant).suivant;
1217: continue;
1218: }
1219:
1220: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1221: .donnee).objet)).thread).pid ==
1222: (*s_argument_thread).pid)
1223: {
1224: while(read_atomic(s_etat_processus, (*s_argument_thread)
1225: .pipe_nombre_interruptions_attente[0],
1226: &pid_candidat, sizeof(pid_candidat)) ==
1227: sizeof(pid_candidat))
1228: {
1229: if (pid_candidat == -2)
1230: {
1231: break;
1232: }
1233: else if (pid_candidat == -1)
1234: {
1235: }
1236: else if (read_atomic(s_etat_processus,
1237: (*s_argument_thread)
1238: .pipe_nombre_interruptions_attente[0],
1239: &pid_candidat, sizeof(pid_candidat)) ==
1240: sizeof(pid_candidat))
1241: {
1242: if ((*s_etat_processus).debug == d_vrai)
1243: if (((*s_etat_processus).type_debug &
1244: d_traitement_interruption) != 0)
1245: {
1246: if ((*s_etat_processus).langue == 'F')
1247: {
1248: printf("[%d] Interruption logicielle "
1249: "en provenance du processus %d"
1250: " (processus arrêté)\n",
1251: (int) getpid(),
1252: (int) (*s_argument_thread).pid);
1253: fflush(stdout);
1254: }
1255: else
1256: {
1257: printf("[%d] Software interrupt "
1258: "from process %d (processus "
1259: "stopped)\n", (int) getpid(),
1260: (int) (*s_argument_thread).pid);
1261: fflush(stdout);
1262: }
1263: }
1264:
1265: if (pthread_mutex_lock(
1266: &((*(*((struct_processus_fils *)
1267: (*(*l_element_courant).donnee).objet))
1268: .thread).mutex)) != 0)
1269: {
1270: (*s_etat_processus).erreur_systeme =
1271: d_es_processus;
1272: }
1273:
1274: (*(*((struct_processus_fils *)
1275: (*(*l_element_courant).donnee)
1276: .objet)).thread)
1277: .nombre_interruptions_dans_pipe++;
1278:
1279: if (pthread_mutex_unlock(
1280: &((*(*((struct_processus_fils *)
1281: (*(*l_element_courant).donnee).objet))
1282: .thread).mutex)) != 0)
1283: {
1284: (*s_etat_processus).erreur_systeme =
1285: d_es_processus;
1286: }
1287:
1288: (*s_etat_processus)
1289: .nombre_interruptions_non_affectees++;
1290: }
1291: }
1292:
1293: break;
1294: }
1295:
1296: l_element_courant = (*l_element_courant).suivant;
1297: }
1298: }
1299: else
1300: {
1301: while(l_element_courant != NULL)
1302: {
1303: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1304: .donnee).objet)).thread).processus_detache
1305: == d_vrai)
1306: {
1307: l_element_courant = (*l_element_courant).suivant;
1308: continue;
1309: }
1310:
1311: if (pthread_equal((*(*((struct_processus_fils *)
1312: (*(*l_element_courant).donnee).objet)).thread).tid,
1313: (*s_argument_thread).tid) != 0)
1314: {
1315: while(read_atomic(s_etat_processus, (*s_argument_thread)
1316: .pipe_nombre_interruptions_attente[0],
1317: &tid_candidat, sizeof(tid_candidat)) ==
1318: sizeof(tid_candidat))
1319: {
1320: if (tid_candidat == (pthread_t) -2)
1321: {
1322: break;
1323: }
1324: else if (tid_candidat == (pthread_t) -1)
1325: {
1326: }
1327: else if (read_atomic(s_etat_processus,
1328: (*s_argument_thread)
1329: .pipe_nombre_interruptions_attente[0],
1330: &tid_candidat, sizeof(tid_candidat)) ==
1331: sizeof(tid_candidat))
1332: {
1333: if ((*s_etat_processus).debug == d_vrai)
1334: if (((*s_etat_processus).type_debug &
1335: d_traitement_interruption) != 0)
1336: {
1337: if ((*s_etat_processus).langue == 'F')
1338: {
1339: printf("[%d] Interruption logicielle "
1340: "en provenance du thread %llu"
1341: " (thread arrêté)\n",
1342: (int) getpid(),
1343: (unsigned long long)
1344: (*s_argument_thread).tid);
1345: fflush(stdout);
1346: }
1347: else
1348: {
1349: printf("[%d] Software interrupt "
1350: "from thread %llu (thread "
1351: "stopped)\n", (int) getpid(),
1352: (unsigned long long)
1353: (*s_argument_thread).tid);
1354: fflush(stdout);
1355: }
1356: }
1357:
1358: if (pthread_mutex_lock(
1359: &((*(*((struct_processus_fils *)
1360: (*(*l_element_courant).donnee).objet))
1361: .thread).mutex)) != 0)
1362: {
1363: (*s_etat_processus).erreur_systeme =
1364: d_es_processus;
1365: }
1366:
1367: (*(*((struct_processus_fils *)
1368: (*(*l_element_courant).donnee)
1369: .objet)).thread)
1370: .nombre_interruptions_dans_pipe++;
1371:
1372: if (pthread_mutex_unlock(
1373: &((*(*((struct_processus_fils *)
1374: (*(*l_element_courant).donnee).objet))
1375: .thread).mutex)) != 0)
1376: {
1377: (*s_etat_processus).erreur_systeme =
1378: d_es_processus;
1379: }
1380:
1381: (*s_etat_processus)
1382: .nombre_interruptions_non_affectees++;
1383: }
1384: }
1385:
1386: break;
1387: }
1388:
1389: l_element_courant = (*l_element_courant).suivant;
1390: }
1391: }
1392: }
1393:
1394: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1395: {
1396: (*s_etat_processus).erreur_systeme_processus_fils =
1397: d_es_processus;
1398: }
1399: }
1400:
1401: /*
1402: * Traitement des interruptions et des erreurs.
1403: */
1404:
1405: if ((*s_etat_processus).debug == d_vrai)
1406: if (((*s_etat_processus).type_debug &
1407: d_debug_processus) != 0)
1408: {
1409: if ((*s_argument_thread).processus_detache == d_vrai)
1410: {
1411: if ((*s_etat_processus).langue == 'F')
1412: {
1413: printf("[%d] Récupération des erreurs du processus "
1414: "%d\n", (int) getpid(),
1415: (int) (*s_argument_thread).pid);
1416: fflush(stdout);
1417: }
1418: else
1419: {
1420: printf("[%d] Check errors from process %d\n", (int) getpid(),
1421: (int) (*s_argument_thread).pid);
1422: fflush(stdout);
1423: }
1424: }
1425: else
1426: {
1427: if ((*s_etat_processus).langue == 'F')
1428: {
1429: printf("[%d] Récupération des erreurs du thread "
1430: "%llu\n", (int) getpid(), (unsigned long long)
1431: (*s_argument_thread).tid);
1432: fflush(stdout);
1433: }
1434: else
1435: {
1436: printf("[%d] Check errors from process %llu\n", (int) getpid(),
1437: (unsigned long long) (*s_argument_thread).tid);
1438: fflush(stdout);
1439: }
1440: }
1441: }
1442:
1443: attente.tv_sec = 0;
1444: attente.tv_nsec = GRANULARITE_us * 1000;
1445:
1446: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1447: &tampon_erreur_execution,
1448: sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
1449: sizeof((*s_etat_processus).erreur_execution_processus_fils))
1450: {
1451: nanosleep(&attente, NULL);
1452: INCR_GRANULARITE(attente.tv_nsec);
1453: }
1454:
1455: attente.tv_sec = 0;
1456: attente.tv_nsec = GRANULARITE_us * 1000;
1457:
1458: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1459: &tampon_erreur_systeme,
1460: sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
1461: sizeof((*s_etat_processus).erreur_systeme_processus_fils))
1462: {
1463: nanosleep(&attente, NULL);
1464: INCR_GRANULARITE(attente.tv_nsec);
1465: }
1466:
1467: attente.tv_sec = 0;
1468: attente.tv_nsec = GRANULARITE_us * 1000;
1469:
1470: while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
1471: &pid_erreur,
1472: sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
1473: sizeof((*s_etat_processus).pid_erreur_processus_fils))
1474: {
1475: nanosleep(&attente, NULL);
1476: INCR_GRANULARITE(attente.tv_nsec);
1477: }
1478:
1479: /*
1480: * Retrait du processus de la pile des processus
1481: */
1482:
1483: if (close((*s_argument_thread).pipe_erreurs[0]) != 0)
1484: {
1485: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1486: }
1487:
1488: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1489: {
1490: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1491: }
1492: else
1493: {
1494: (*s_etat_processus).erreur_execution_processus_fils =
1495: tampon_erreur_execution;
1496: (*s_etat_processus).erreur_systeme_processus_fils =
1497: tampon_erreur_systeme;
1498: (*s_etat_processus).pid_erreur_processus_fils = pid_erreur;
1499:
1500: /*
1501: * Si une erreur est déclarée dans le processus fils, le message
1502: * d'erreur a déjà été affiché.
1503: */
1504:
1505: if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
1506: ((*s_etat_processus).erreur_execution_processus_fils != d_ex))
1507: {
1508: (*s_etat_processus).erreur_processus_fils = d_vrai;
1509: (*s_etat_processus).invalidation_message_erreur = d_vrai;
1510: }
1511:
1512: do
1513: {
1514: drapeau_fin = d_faux;
1515: l_element_courant = (struct_liste_chainee *)
1516: (*s_etat_processus).l_base_pile_processus;
1517: nombre_donnees = -1;
1518:
1519: while(l_element_courant != NULL)
1520: {
1521: if ((*s_argument_thread).processus_detache == d_vrai)
1522: {
1523: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1524: .donnee).objet)).thread).processus_detache
1525: == d_vrai)
1526: {
1527: if ((*s_argument_thread).pid ==
1528: (*(*((struct_processus_fils *)
1529: (*(*l_element_courant)
1530: .donnee).objet)).thread).pid)
1531: {
1532: if (pthread_mutex_lock(
1533: &((*(*((struct_processus_fils *)
1534: (*(*l_element_courant).donnee).objet))
1535: .thread).mutex)) != 0)
1536: {
1537: (*s_etat_processus).erreur_systeme =
1538: d_es_processus;
1539: }
1540:
1541: nombre_donnees = (*(*((struct_processus_fils *)
1542: (*(*l_element_courant).donnee).objet))
1543: .thread).nombre_objets_dans_pipe +
1544: (*(*((struct_processus_fils *)
1545: (*(*l_element_courant).donnee).objet))
1546: .thread).nombre_interruptions_dans_pipe;
1547:
1548: if (pthread_mutex_unlock(
1549: &((*(*((struct_processus_fils *)
1550: (*(*l_element_courant).donnee).objet))
1551: .thread).mutex)) != 0)
1552: {
1553: (*s_etat_processus).erreur_systeme =
1554: d_es_processus;
1555: }
1556:
1557: break;
1558: }
1559: }
1560: }
1561: else
1562: {
1563: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
1564: .donnee).objet)).thread).processus_detache
1565: == d_faux)
1566: {
1567: if (pthread_equal((*s_argument_thread).tid,
1568: (*(*((struct_processus_fils *)
1569: (*(*l_element_courant)
1570: .donnee).objet)).thread).tid) != 0)
1571: {
1572: if (pthread_mutex_lock(
1573: &((*(*((struct_processus_fils *)
1574: (*(*l_element_courant).donnee).objet))
1575: .thread).mutex)) != 0)
1576: {
1577: (*s_etat_processus).erreur_systeme =
1578: d_es_processus;
1579: }
1580:
1581: nombre_donnees = (*(*((struct_processus_fils *)
1582: (*(*l_element_courant).donnee).objet))
1583: .thread).nombre_objets_dans_pipe +
1584: (*(*((struct_processus_fils *)
1585: (*(*l_element_courant).donnee).objet))
1586: .thread).nombre_interruptions_dans_pipe;
1587:
1588: if (pthread_mutex_unlock(
1589: &((*(*((struct_processus_fils *)
1590: (*(*l_element_courant).donnee).objet))
1591: .thread).mutex)) != 0)
1592: {
1593: (*s_etat_processus).erreur_systeme =
1594: d_es_processus;
1595: }
1596:
1597: break;
1598: }
1599: }
1600: }
1601:
1602: l_element_courant = (*l_element_courant).suivant;
1603: }
1604:
1605: if (nombre_donnees == -1)
1606: {
1607: (*s_etat_processus).erreur_systeme_processus_fils =
1608: d_es_processus;
1609: drapeau_fin = d_vrai;
1610: BUG(1, printf("Process or thread not found"));
1611: }
1612: else if ((nombre_donnees == 0) ||
1613: ((*s_etat_processus).var_volatile_requete_arret == -1))
1614: {
1615: if ((*s_etat_processus).debug == d_vrai)
1616: if (((*s_etat_processus).type_debug &
1617: d_debug_processus) != 0)
1618: {
1619: if ((*s_argument_thread).processus_detache == d_vrai)
1620: {
1621: if ((*s_etat_processus).langue == 'F')
1622: {
1623: printf("[%d] Fermeture des tuyaux du processus "
1624: "%d\n", (int) getpid(), (int)
1625: (*s_argument_thread).pid);
1626: fflush(stdout);
1627: }
1628: else
1629: {
1630: printf("[%d] Close remaining pipes "
1631: "of process %d\n", (int) getpid(),
1632: (int) (*s_argument_thread).pid);
1633: fflush(stdout);
1634: }
1635: }
1636: else
1637: {
1638: if ((*s_etat_processus).langue == 'F')
1639: {
1640: printf("[%d] Fermeture des tuyaux du thread "
1641: "%llu\n", (int) getpid(),
1642: (unsigned long long)
1643: (*s_argument_thread).tid);
1644: fflush(stdout);
1645: }
1646: else
1647: {
1648: printf("[%d] Close remaining pipes "
1649: "of thread %llu\n", (int) getpid(),
1650: (unsigned long long) (*s_argument_thread)
1651: .tid);
1652: fflush(stdout);
1653: }
1654: }
1655: }
1656:
1657: if (close((*s_argument_thread).pipe_objets[0]) != 0)
1658: {
1659: (*s_etat_processus).erreur_systeme_processus_fils =
1660: d_es_processus;
1661: }
1662:
1663: if (close((*s_argument_thread).pipe_acquittement[1]) != 0)
1664: {
1665: (*s_etat_processus).erreur_systeme_processus_fils =
1666: d_es_processus;
1667: }
1668:
1669: if (close((*s_argument_thread).pipe_injections[1]) != 0)
1670: {
1671: (*s_etat_processus).erreur_systeme_processus_fils =
1672: d_es_processus;
1673: }
1674:
1675: if (close((*s_argument_thread).pipe_nombre_injections[1]) != 0)
1676: {
1677: (*s_etat_processus).erreur_systeme_processus_fils =
1678: d_es_processus;
1679: }
1680:
1681: if (close((*s_argument_thread)
1682: .pipe_nombre_objets_attente[0]) != 0)
1683: {
1684: (*s_etat_processus).erreur_systeme_processus_fils =
1685: d_es_processus;
1686: }
1687:
1688: if (close((*s_argument_thread)
1689: .pipe_interruptions[0]) != 0)
1690: {
1691: (*s_etat_processus).erreur_systeme_processus_fils =
1692: d_es_processus;
1693: }
1694:
1695: if (close((*s_argument_thread)
1696: .pipe_nombre_interruptions_attente[0]) != 0)
1697: {
1698: (*s_etat_processus).erreur_systeme_processus_fils =
1699: d_es_processus;
1700: }
1701:
1702: drapeau_fin = d_vrai;
1703: }
1704: else
1705: {
1706: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1707: {
1708: (*s_etat_processus).erreur_systeme_processus_fils =
1709: d_es_processus;
1710: drapeau_fin = d_vrai;
1711: }
1712:
1713: nanosleep(&attente, NULL);
1714: INCR_GRANULARITE(attente.tv_nsec);
1715:
1716: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
1717: {
1718: (*s_etat_processus).erreur_systeme_processus_fils =
1719: d_es_processus;
1720: drapeau_fin = d_vrai;
1721: }
1722: }
1723: } while(drapeau_fin == d_faux);
1724:
1725: l_element_courant = (struct_liste_chainee *)
1726: (*s_etat_processus).l_base_pile_processus;
1727: l_element_precedent = NULL;
1728:
1729: while(l_element_courant != NULL)
1730: {
1731: drapeau = d_faux;
1732:
1733: if ((*s_argument_thread).processus_detache ==
1734: (*(*((struct_processus_fils *) (*(*l_element_courant)
1735: .donnee).objet)).thread).processus_detache)
1736: {
1737: if ((*s_argument_thread).processus_detache == d_vrai)
1738: {
1739: if ((*(*((struct_processus_fils *)
1740: (*(*l_element_courant).donnee).objet))
1741: .thread).pid == (*s_argument_thread).pid)
1742: {
1743: drapeau = d_vrai;
1744: }
1745: else
1746: {
1747: drapeau = d_faux;
1748: }
1749: }
1750: else
1751: {
1752: if (pthread_equal((*(*((struct_processus_fils *)
1753: (*(*l_element_courant).donnee).objet))
1754: .thread).tid, (*s_argument_thread).tid) != 0)
1755: {
1756: drapeau = d_vrai;
1757: }
1758: else
1759: {
1760: drapeau = d_faux;
1761: }
1762: }
1763: }
1764: else
1765: {
1766: drapeau = d_faux;
1767: }
1768:
1769: if (drapeau == d_vrai)
1770: {
1771: if (l_element_precedent == NULL)
1772: {
1773: (*s_etat_processus).l_base_pile_processus =
1774: (*l_element_courant).suivant;
1775: }
1776: else
1777: {
1778: (*l_element_precedent).suivant =
1779: (*l_element_courant).suivant;
1780: }
1781:
1782: liberation(s_etat_processus, (*l_element_courant).donnee);
1783: free(l_element_courant);
1784:
1785: break;
1786: }
1787: else
1788: {
1789: l_element_precedent = l_element_courant;
1790: l_element_courant = (*l_element_courant).suivant;
1791: }
1792: }
1793:
1794: if ((*s_etat_processus).debug == d_vrai)
1795: if (((*s_etat_processus).type_debug &
1796: d_debug_processus) != 0)
1797: {
1798: if ((*s_argument_thread).processus_detache == d_vrai)
1799: {
1800: if ((*s_etat_processus).langue == 'F')
1801: {
1802: printf("[%d] Arrêt du thread de surveillance du"
1803: " processus %d\n", (int) getpid(),
1804: (int) (*s_argument_thread).pid);
1805: }
1806: else
1807: {
1808: printf("[%d] Stop monitoring of process %d", (int) getpid(),
1809: (int) (*s_argument_thread).pid);
1810: }
1811: }
1812: else
1813: {
1814: if ((*s_etat_processus).langue == 'F')
1815: {
1816: printf("[%d] Arrêt du thread de surveillance du"
1817: " thread %llu\n", (int) getpid(),
1818: (unsigned long long) (*s_argument_thread)
1819: .tid);
1820: }
1821: else
1822: {
1823: printf("[%d] Stop monitoring of thread %llu",
1824: (int) getpid(),
1825: (unsigned long long) (*s_argument_thread)
1826: .tid);
1827: }
1828: }
1829:
1830: fflush(stdout);
1831: }
1832:
1833: retrait_thread_surveillance(s_etat_processus, s_argument_thread);
1834:
1835: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1836: {
1837: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1838: }
1839: }
1840:
1841: pthread_exit(NULL);
1842: return(NULL);
1843: }
1844:
1845:
1846: /*
1847: ================================================================================
1848: Fonction d'écriture dans un pipe
1849: ================================================================================
1850: Entrées : pointeur sur une structure de description du processus,
1851: numéro du pipe et objet à écrire
1852: --------------------------------------------------------------------------------
1853: Sorties :
1854: --------------------------------------------------------------------------------
1855: Effets de bord : néant
1856: ================================================================================
1857: */
1858:
1859: logical1
1860: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
1861: struct_objet *s_objet)
1862: {
1863: struct_liste_chainee *l_element_courant;
1864:
1865: struct timespec attente;
1866:
1867: unsigned long i;
1868: unsigned long j;
1869:
1870: size_t longueur;
1871: ssize_t longueur_ecriture;
1872:
1873: if ((*s_objet).type == INT)
1874: {
1875: attente.tv_sec = 0;
1876: attente.tv_nsec = GRANULARITE_us * 1000;
1877:
1878: while((longueur_ecriture = write_atomic(s_etat_processus,
1879: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1880: sizeof((*s_objet).type))
1881: {
1882: if (longueur_ecriture == -1)
1883: {
1884: return(d_erreur);
1885: }
1886:
1887: nanosleep(&attente, NULL);
1888: INCR_GRANULARITE(attente.tv_nsec);
1889: }
1890:
1891: attente.tv_sec = 0;
1892: attente.tv_nsec = GRANULARITE_us * 1000;
1893:
1894: while((longueur_ecriture = write_atomic(s_etat_processus,
1895: pipe, (integer8 *)
1896: (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
1897: {
1898: if (longueur_ecriture == -1)
1899: {
1900: return(d_erreur);
1901: }
1902:
1903: nanosleep(&attente, NULL);
1904: INCR_GRANULARITE(attente.tv_nsec);
1905: }
1906: }
1907: else if ((*s_objet).type == REL)
1908: {
1909: attente.tv_sec = 0;
1910: attente.tv_nsec = GRANULARITE_us * 1000;
1911:
1912: while((longueur_ecriture = write_atomic(s_etat_processus,
1913: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1914: sizeof((*s_objet).type))
1915: {
1916: if (longueur_ecriture == -1)
1917: {
1918: return(d_erreur);
1919: }
1920:
1921: nanosleep(&attente, NULL);
1922: INCR_GRANULARITE(attente.tv_nsec);
1923: }
1924:
1925: attente.tv_sec = 0;
1926: attente.tv_nsec = GRANULARITE_us * 1000;
1927:
1928: while((longueur_ecriture = write_atomic(s_etat_processus,
1929: pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
1930: sizeof(real8))
1931: {
1932: if (longueur_ecriture == -1)
1933: {
1934: return(d_erreur);
1935: }
1936:
1937: nanosleep(&attente, NULL);
1938: INCR_GRANULARITE(attente.tv_nsec);
1939: }
1940: }
1941: else if ((*s_objet).type == CPL)
1942: {
1943: attente.tv_sec = 0;
1944: attente.tv_nsec = GRANULARITE_us * 1000;
1945:
1946: while((longueur_ecriture = write_atomic(s_etat_processus,
1947: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1948: sizeof((*s_objet).type))
1949: {
1950: if (longueur_ecriture == -1)
1951: {
1952: return(d_erreur);
1953: }
1954:
1955: nanosleep(&attente, NULL);
1956: INCR_GRANULARITE(attente.tv_nsec);
1957: }
1958:
1959: attente.tv_sec = 0;
1960: attente.tv_nsec = GRANULARITE_us * 1000;
1961:
1962: while((longueur_ecriture = write_atomic(s_etat_processus,
1963: pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
1964: != sizeof(complex16))
1965: {
1966: if (longueur_ecriture == -1)
1967: {
1968: return(d_erreur);
1969: }
1970:
1971: nanosleep(&attente, NULL);
1972: INCR_GRANULARITE(attente.tv_nsec);
1973: }
1974: }
1975: else if ((*s_objet).type == VIN)
1976: {
1977: attente.tv_sec = 0;
1978: attente.tv_nsec = GRANULARITE_us * 1000;
1979:
1980: while((longueur_ecriture = write_atomic(s_etat_processus,
1981: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1982: sizeof((*s_objet).type))
1983: {
1984: if (longueur_ecriture == -1)
1985: {
1986: return(d_erreur);
1987: }
1988:
1989: nanosleep(&attente, NULL);
1990: INCR_GRANULARITE(attente.tv_nsec);
1991: }
1992:
1993: attente.tv_sec = 0;
1994: attente.tv_nsec = GRANULARITE_us * 1000;
1995:
1996: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1997: &((*((struct_vecteur *) (*s_objet).objet))
1998: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
1999: {
2000: if (longueur_ecriture == -1)
2001: {
2002: return(d_erreur);
2003: }
2004:
2005: nanosleep(&attente, NULL);
2006: INCR_GRANULARITE(attente.tv_nsec);
2007: }
2008:
2009: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2010: {
2011: attente.tv_sec = 0;
2012: attente.tv_nsec = GRANULARITE_us * 1000;
2013:
2014: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2015: &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
2016: .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
2017: {
2018: if (longueur_ecriture == -1)
2019: {
2020: return(d_erreur);
2021: }
2022:
2023: nanosleep(&attente, NULL);
2024: INCR_GRANULARITE(attente.tv_nsec);
2025: }
2026: }
2027: }
2028: else if ((*s_objet).type == VRL)
2029: {
2030: attente.tv_sec = 0;
2031: attente.tv_nsec = GRANULARITE_us * 1000;
2032:
2033: while((longueur_ecriture = write_atomic(s_etat_processus,
2034: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2035: sizeof((*s_objet).type))
2036: {
2037: if (longueur_ecriture == -1)
2038: {
2039: return(d_erreur);
2040: }
2041:
2042: nanosleep(&attente, NULL);
2043: INCR_GRANULARITE(attente.tv_nsec);
2044: }
2045:
2046: attente.tv_sec = 0;
2047: attente.tv_nsec = GRANULARITE_us * 1000;
2048:
2049: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2050: &((*((struct_vecteur *) (*s_objet).objet))
2051: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2052: {
2053: if (longueur_ecriture == -1)
2054: {
2055: return(d_erreur);
2056: }
2057:
2058: nanosleep(&attente, NULL);
2059: INCR_GRANULARITE(attente.tv_nsec);
2060: }
2061:
2062: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2063: {
2064: attente.tv_sec = 0;
2065: attente.tv_nsec = GRANULARITE_us * 1000;
2066:
2067: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2068: &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
2069: .tableau)[i]), sizeof(real8))) != sizeof(real8))
2070: {
2071: if (longueur_ecriture == -1)
2072: {
2073: return(d_erreur);
2074: }
2075:
2076: nanosleep(&attente, NULL);
2077: INCR_GRANULARITE(attente.tv_nsec);
2078: }
2079: }
2080: }
2081: else if ((*s_objet).type == VCX)
2082: {
2083: attente.tv_sec = 0;
2084: attente.tv_nsec = GRANULARITE_us * 1000;
2085:
2086: while((longueur_ecriture = write_atomic(s_etat_processus,
2087: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2088: sizeof((*s_objet).type))
2089: {
2090: if (longueur_ecriture == -1)
2091: {
2092: return(d_erreur);
2093: }
2094:
2095: nanosleep(&attente, NULL);
2096: INCR_GRANULARITE(attente.tv_nsec);
2097: }
2098:
2099: attente.tv_sec = 0;
2100: attente.tv_nsec = GRANULARITE_us * 1000;
2101:
2102: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2103: &((*((struct_vecteur *) (*s_objet).objet))
2104: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2105: {
2106: if (longueur_ecriture == -1)
2107: {
2108: return(d_erreur);
2109: }
2110:
2111: nanosleep(&attente, NULL);
2112: INCR_GRANULARITE(attente.tv_nsec);
2113: }
2114:
2115: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2116: {
2117: attente.tv_sec = 0;
2118: attente.tv_nsec = GRANULARITE_us * 1000;
2119:
2120: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2121: &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
2122: .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
2123: {
2124: if (longueur_ecriture == -1)
2125: {
2126: return(d_erreur);
2127: }
2128:
2129: nanosleep(&attente, NULL);
2130: INCR_GRANULARITE(attente.tv_nsec);
2131: }
2132: }
2133: }
2134: else if ((*s_objet).type == MIN)
2135: {
2136: attente.tv_sec = 0;
2137: attente.tv_nsec = GRANULARITE_us * 1000;
2138:
2139: while((longueur_ecriture = write_atomic(s_etat_processus,
2140: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2141: sizeof((*s_objet).type))
2142: {
2143: if (longueur_ecriture == -1)
2144: {
2145: return(d_erreur);
2146: }
2147:
2148: nanosleep(&attente, NULL);
2149: INCR_GRANULARITE(attente.tv_nsec);
2150: }
2151:
2152: attente.tv_sec = 0;
2153: attente.tv_nsec = GRANULARITE_us * 1000;
2154:
2155: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2156: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2157: sizeof(unsigned long))) != sizeof(unsigned long))
2158: {
2159: if (longueur_ecriture == -1)
2160: {
2161: return(d_erreur);
2162: }
2163:
2164: nanosleep(&attente, NULL);
2165: INCR_GRANULARITE(attente.tv_nsec);
2166: }
2167:
2168: attente.tv_sec = 0;
2169: attente.tv_nsec = GRANULARITE_us * 1000;
2170:
2171: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2172: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2173: sizeof(unsigned long))) != sizeof(unsigned long))
2174: {
2175: if (longueur_ecriture == -1)
2176: {
2177: return(d_erreur);
2178: }
2179:
2180: nanosleep(&attente, NULL);
2181: INCR_GRANULARITE(attente.tv_nsec);
2182: }
2183:
2184: for(i = 0; i < (*((struct_matrice *)
2185: (*s_objet).objet)).nombre_lignes; i++)
2186: {
2187: for(j = 0; j < (*((struct_matrice *)
2188: (*s_objet).objet)).nombre_colonnes; j++)
2189: {
2190: attente.tv_sec = 0;
2191: attente.tv_nsec = GRANULARITE_us * 1000;
2192:
2193: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2194: &(((integer8 **) (*((struct_matrice *)
2195: (*s_objet).objet)).tableau)[i][j]),
2196: sizeof(integer8))) != sizeof(integer8))
2197: {
2198: if (longueur_ecriture == -1)
2199: {
2200: return(d_erreur);
2201: }
2202:
2203: nanosleep(&attente, NULL);
2204: INCR_GRANULARITE(attente.tv_nsec);
2205: }
2206: }
2207: }
2208: }
2209: else if ((*s_objet).type == MRL)
2210: {
2211: attente.tv_sec = 0;
2212: attente.tv_nsec = GRANULARITE_us * 1000;
2213:
2214: while((longueur_ecriture = write_atomic(s_etat_processus,
2215: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2216: sizeof((*s_objet).type))
2217: {
2218: if (longueur_ecriture == -1)
2219: {
2220: return(d_erreur);
2221: }
2222:
2223: nanosleep(&attente, NULL);
2224: INCR_GRANULARITE(attente.tv_nsec);
2225: }
2226:
2227: attente.tv_sec = 0;
2228: attente.tv_nsec = GRANULARITE_us * 1000;
2229:
2230: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2231: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2232: sizeof(unsigned long))) != sizeof(unsigned long))
2233: {
2234: if (longueur_ecriture == -1)
2235: {
2236: return(d_erreur);
2237: }
2238:
2239: nanosleep(&attente, NULL);
2240: INCR_GRANULARITE(attente.tv_nsec);
2241: }
2242:
2243: attente.tv_sec = 0;
2244: attente.tv_nsec = GRANULARITE_us * 1000;
2245:
2246: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2247: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2248: sizeof(unsigned long))) != sizeof(unsigned long))
2249: {
2250: if (longueur_ecriture == -1)
2251: {
2252: return(d_erreur);
2253: }
2254:
2255: nanosleep(&attente, NULL);
2256: INCR_GRANULARITE(attente.tv_nsec);
2257: }
2258:
2259: for(i = 0; i < (*((struct_matrice *)
2260: (*s_objet).objet)).nombre_lignes; i++)
2261: {
2262: for(j = 0; j < (*((struct_matrice *)
2263: (*s_objet).objet)).nombre_colonnes; j++)
2264: {
2265: attente.tv_sec = 0;
2266: attente.tv_nsec = GRANULARITE_us * 1000;
2267:
2268: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2269: &(((real8 **) (*((struct_matrice *)
2270: (*s_objet).objet)).tableau)[i][j]),
2271: sizeof(real8))) != sizeof(real8))
2272: {
2273: if (longueur_ecriture == -1)
2274: {
2275: return(d_erreur);
2276: }
2277:
2278: nanosleep(&attente, NULL);
2279: INCR_GRANULARITE(attente.tv_nsec);
2280: }
2281: }
2282: }
2283: }
2284: else if ((*s_objet).type == MCX)
2285: {
2286: attente.tv_sec = 0;
2287: attente.tv_nsec = GRANULARITE_us * 1000;
2288:
2289: while((longueur_ecriture = write_atomic(s_etat_processus,
2290: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2291: sizeof((*s_objet).type))
2292: {
2293: if (longueur_ecriture == -1)
2294: {
2295: return(d_erreur);
2296: }
2297:
2298: nanosleep(&attente, NULL);
2299: INCR_GRANULARITE(attente.tv_nsec);
2300: }
2301:
2302: attente.tv_sec = 0;
2303: attente.tv_nsec = GRANULARITE_us * 1000;
2304:
2305: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2306: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2307: sizeof(unsigned long))) != sizeof(unsigned long))
2308: {
2309: if (longueur_ecriture == -1)
2310: {
2311: return(d_erreur);
2312: }
2313:
2314: nanosleep(&attente, NULL);
2315: INCR_GRANULARITE(attente.tv_nsec);
2316: }
2317:
2318: attente.tv_sec = 0;
2319: attente.tv_nsec = GRANULARITE_us * 1000;
2320:
2321: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2322: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2323: sizeof(unsigned long))) != sizeof(unsigned long))
2324: {
2325: if (longueur_ecriture == -1)
2326: {
2327: return(d_erreur);
2328: }
2329:
2330: nanosleep(&attente, NULL);
2331: INCR_GRANULARITE(attente.tv_nsec);
2332: }
2333:
2334: for(i = 0; i < (*((struct_matrice *)
2335: (*s_objet).objet)).nombre_lignes; i++)
2336: {
2337: for(j = 0; j < (*((struct_matrice *)
2338: (*s_objet).objet)).nombre_colonnes; j++)
2339: {
2340: attente.tv_sec = 0;
2341: attente.tv_nsec = GRANULARITE_us * 1000;
2342:
2343: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2344: &(((complex16 **) (*((struct_matrice *)
2345: (*s_objet).objet)).tableau)[i][j]),
2346: sizeof(complex16))) != sizeof(complex16))
2347: {
2348: if (longueur_ecriture == -1)
2349: {
2350: return(d_erreur);
2351: }
2352:
2353: nanosleep(&attente, NULL);
2354: INCR_GRANULARITE(attente.tv_nsec);
2355: }
2356: }
2357: }
2358: }
2359: else if ((*s_objet).type == BIN)
2360: {
2361: attente.tv_sec = 0;
2362: attente.tv_nsec = GRANULARITE_us * 1000;
2363:
2364: while((longueur_ecriture = write_atomic(s_etat_processus,
2365: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2366: sizeof((*s_objet).type))
2367: {
2368: if (longueur_ecriture == -1)
2369: {
2370: return(d_erreur);
2371: }
2372:
2373: nanosleep(&attente, NULL);
2374: INCR_GRANULARITE(attente.tv_nsec);
2375: }
2376:
2377: attente.tv_sec = 0;
2378: attente.tv_nsec = GRANULARITE_us * 1000;
2379:
2380: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2381: (integer8 *) (*s_objet).objet,
2382: sizeof(integer8))) != sizeof(integer8))
2383: {
2384: if (longueur_ecriture == -1)
2385: {
2386: return(d_erreur);
2387: }
2388:
2389: nanosleep(&attente, NULL);
2390: INCR_GRANULARITE(attente.tv_nsec);
2391: }
2392: }
2393: else if ((*s_objet).type == NOM)
2394: {
2395: attente.tv_sec = 0;
2396: attente.tv_nsec = GRANULARITE_us * 1000;
2397:
2398: while((longueur_ecriture = write_atomic(s_etat_processus,
2399: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2400: sizeof((*s_objet).type))
2401: {
2402: if (longueur_ecriture == -1)
2403: {
2404: return(d_erreur);
2405: }
2406:
2407: nanosleep(&attente, NULL);
2408: INCR_GRANULARITE(attente.tv_nsec);
2409: }
2410:
2411: longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
2412:
2413: attente.tv_sec = 0;
2414: attente.tv_nsec = GRANULARITE_us * 1000;
2415:
2416: while((longueur_ecriture = write_atomic(s_etat_processus,
2417: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2418: {
2419: if (longueur_ecriture == -1)
2420: {
2421: return(d_erreur);
2422: }
2423:
2424: nanosleep(&attente, NULL);
2425: INCR_GRANULARITE(attente.tv_nsec);
2426: }
2427:
2428: attente.tv_sec = 0;
2429: attente.tv_nsec = GRANULARITE_us * 1000;
2430:
2431: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2432: (*((struct_nom *) (*s_objet).objet)).nom,
2433: longueur)) != (ssize_t) longueur)
2434: {
2435: if (longueur_ecriture == -1)
2436: {
2437: return(d_erreur);
2438: }
2439:
2440: nanosleep(&attente, NULL);
2441: INCR_GRANULARITE(attente.tv_nsec);
2442: }
2443:
2444: attente.tv_sec = 0;
2445: attente.tv_nsec = GRANULARITE_us * 1000;
2446:
2447: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2448: &((*((struct_nom *) (*s_objet).objet))
2449: .symbole), sizeof(logical1))) != sizeof(logical1))
2450: {
2451: if (longueur_ecriture == -1)
2452: {
2453: return(d_erreur);
2454: }
2455:
2456: nanosleep(&attente, NULL);
2457: INCR_GRANULARITE(attente.tv_nsec);
2458: }
2459: }
2460: else if ((*s_objet).type == FCT)
2461: {
2462: attente.tv_sec = 0;
2463: attente.tv_nsec = GRANULARITE_us * 1000;
2464:
2465: while((longueur_ecriture = write_atomic(s_etat_processus,
2466: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2467: sizeof((*s_objet).type))
2468: {
2469: if (longueur_ecriture == -1)
2470: {
2471: return(d_erreur);
2472: }
2473:
2474: nanosleep(&attente, NULL);
2475: INCR_GRANULARITE(attente.tv_nsec);
2476: }
2477:
2478: longueur = strlen((*((struct_fonction *)
2479: (*s_objet).objet)).nom_fonction) + 1;
2480:
2481: attente.tv_sec = 0;
2482: attente.tv_nsec = GRANULARITE_us * 1000;
2483:
2484: while((longueur_ecriture = write_atomic(s_etat_processus,
2485: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2486: {
2487: if (longueur_ecriture == -1)
2488: {
2489: return(d_erreur);
2490: }
2491:
2492: nanosleep(&attente, NULL);
2493: INCR_GRANULARITE(attente.tv_nsec);
2494: }
2495:
2496: attente.tv_sec = 0;
2497: attente.tv_nsec = GRANULARITE_us * 1000;
2498:
2499: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2500: (*((struct_fonction *) (*s_objet).objet))
2501: .nom_fonction, longueur)) != (ssize_t) longueur)
2502: {
2503: if (longueur_ecriture == -1)
2504: {
2505: return(d_erreur);
2506: }
2507:
2508: nanosleep(&attente, NULL);
2509: INCR_GRANULARITE(attente.tv_nsec);
2510: }
2511:
2512: attente.tv_sec = 0;
2513: attente.tv_nsec = GRANULARITE_us * 1000;
2514:
2515: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2516: &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
2517: sizeof(unsigned long))) != sizeof(unsigned long))
2518: {
2519: if (longueur_ecriture == -1)
2520: {
2521: return(d_erreur);
2522: }
2523:
2524: nanosleep(&attente, NULL);
2525: INCR_GRANULARITE(attente.tv_nsec);
2526: }
2527: }
2528: else if ((*s_objet).type == CHN)
2529: {
2530: attente.tv_sec = 0;
2531: attente.tv_nsec = GRANULARITE_us * 1000;
2532:
2533: while((longueur_ecriture = write_atomic(s_etat_processus,
2534: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2535: sizeof((*s_objet).type))
2536: {
2537: if (longueur_ecriture == -1)
2538: {
2539: return(d_erreur);
2540: }
2541:
2542: nanosleep(&attente, NULL);
2543: INCR_GRANULARITE(attente.tv_nsec);
2544: }
2545:
2546: longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
2547:
2548: attente.tv_sec = 0;
2549: attente.tv_nsec = GRANULARITE_us * 1000;
2550:
2551: while((longueur_ecriture = write_atomic(s_etat_processus,
2552: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2553: {
2554: if (longueur_ecriture == -1)
2555: {
2556: return(d_erreur);
2557: }
2558:
2559: nanosleep(&attente, NULL);
2560: INCR_GRANULARITE(attente.tv_nsec);
2561: }
2562:
2563: attente.tv_sec = 0;
2564: attente.tv_nsec = GRANULARITE_us * 1000;
2565:
2566: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2567: (unsigned char *) (*s_objet).objet,
2568: longueur)) != (ssize_t) longueur)
2569: {
2570: if (longueur_ecriture == -1)
2571: {
2572: return(d_erreur);
2573: }
2574:
2575: nanosleep(&attente, NULL);
2576: INCR_GRANULARITE(attente.tv_nsec);
2577: }
2578: }
2579: else if (((*s_objet).type == LST) ||
2580: ((*s_objet).type == ALG) ||
2581: ((*s_objet).type == RPN))
2582: {
2583: attente.tv_sec = 0;
2584: attente.tv_nsec = GRANULARITE_us * 1000;
2585:
2586: while((longueur_ecriture = write_atomic(s_etat_processus,
2587: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2588: sizeof((*s_objet).type))
2589: {
2590: if (longueur_ecriture == -1)
2591: {
2592: return(d_erreur);
2593: }
2594:
2595: nanosleep(&attente, NULL);
2596: INCR_GRANULARITE(attente.tv_nsec);
2597: }
2598:
2599: l_element_courant = (*s_objet).objet;
2600: i = 0;
2601:
2602: while(l_element_courant != NULL)
2603: {
2604: i++;
2605: l_element_courant = (*l_element_courant).suivant;
2606: }
2607:
2608: attente.tv_sec = 0;
2609: attente.tv_nsec = GRANULARITE_us * 1000;
2610:
2611: while((longueur_ecriture = write_atomic(s_etat_processus,
2612: pipe, &i, sizeof(i))) != sizeof(i))
2613: {
2614: if (longueur_ecriture == -1)
2615: {
2616: return(d_erreur);
2617: }
2618:
2619: nanosleep(&attente, NULL);
2620: INCR_GRANULARITE(attente.tv_nsec);
2621: }
2622:
2623: l_element_courant = (*s_objet).objet;
2624:
2625: while(l_element_courant != NULL)
2626: {
2627: if (ecriture_pipe(s_etat_processus, pipe,
2628: (*l_element_courant).donnee) == d_erreur)
2629: {
2630: return(d_erreur);
2631: }
2632:
2633: l_element_courant = (*l_element_courant).suivant;
2634: }
2635: }
2636: else if ((*s_objet).type == TBL)
2637: {
2638: attente.tv_sec = 0;
2639: attente.tv_nsec = GRANULARITE_us * 1000;
2640:
2641: while((longueur_ecriture = write_atomic(s_etat_processus,
2642: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2643: sizeof((*s_objet).type))
2644: {
2645: if (longueur_ecriture == -1)
2646: {
2647: return(d_erreur);
2648: }
2649:
2650: nanosleep(&attente, NULL);
2651: INCR_GRANULARITE(attente.tv_nsec);
2652: }
2653:
2654: attente.tv_sec = 0;
2655: attente.tv_nsec = GRANULARITE_us * 1000;
2656:
2657: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2658: &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
2659: sizeof(unsigned long))) != sizeof(unsigned long))
2660: {
2661: if (longueur_ecriture == -1)
2662: {
2663: return(d_erreur);
2664: }
2665:
2666: nanosleep(&attente, NULL);
2667: INCR_GRANULARITE(attente.tv_nsec);
2668: }
2669:
2670: for(i = 0; i < (*((struct_tableau *)
2671: (*s_objet).objet)).nombre_elements; i++)
2672: {
2673: if (ecriture_pipe(s_etat_processus, pipe,
2674: (*((struct_tableau *) (*s_objet).objet)).elements[i])
2675: == d_erreur)
2676: {
2677: return(d_erreur);
2678: }
2679: }
2680: }
2681: else
2682: {
2683: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2684: return(d_erreur);
2685: }
2686:
2687: return(d_absence_erreur);
2688: }
2689:
2690:
2691: /*
2692: ================================================================================
2693: Fonction de lecture dans un pipe
2694: ================================================================================
2695: Entrées : pointeur sur une structure de description du processus,
2696: numéro du pipe et objet à écrire
2697: --------------------------------------------------------------------------------
2698: Sorties :
2699: --------------------------------------------------------------------------------
2700: Effets de bord : néant
2701: ================================================================================
2702: */
2703:
2704: struct_objet *
2705: lecture_pipe(struct_processus *s_etat_processus, int pipe)
2706: {
2707: size_t longueur;
2708:
2709: struct_liste_chainee *l_element_courant;
2710:
2711: struct_objet *s_objet;
2712:
2713: struct timespec attente;
2714:
2715: unsigned long i;
2716: unsigned long j;
2717:
2718: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
2719: {
2720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2721: return(NULL);
2722: }
2723:
2724: attente.tv_sec = 0;
2725: attente.tv_nsec = GRANULARITE_us * 1000;
2726:
2727: while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
2728: sizeof((*s_objet).type)) != sizeof((*s_objet).type))
2729: {
2730: nanosleep(&attente, NULL);
2731: INCR_GRANULARITE(attente.tv_nsec);
2732: }
2733:
2734: if ((*s_objet).type == INT)
2735: {
2736: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2737: {
2738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2739: return(NULL);
2740: }
2741:
2742: attente.tv_sec = 0;
2743: attente.tv_nsec = GRANULARITE_us * 1000;
2744:
2745: while(read_atomic(s_etat_processus, pipe,
2746: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2747: {
2748: nanosleep(&attente, NULL);
2749: INCR_GRANULARITE(attente.tv_nsec);
2750: }
2751: }
2752: else if ((*s_objet).type == REL)
2753: {
2754: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
2755: {
2756: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2757: return(NULL);
2758: }
2759:
2760: attente.tv_sec = 0;
2761: attente.tv_nsec = GRANULARITE_us * 1000;
2762:
2763: while(read_atomic(s_etat_processus, pipe,
2764: (*s_objet).objet, sizeof(real8)) != sizeof(real8))
2765: {
2766: nanosleep(&attente, NULL);
2767: INCR_GRANULARITE(attente.tv_nsec);
2768: }
2769: }
2770: else if ((*s_objet).type == CPL)
2771: {
2772: if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
2773: {
2774: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2775: return(NULL);
2776: }
2777:
2778: attente.tv_sec = 0;
2779: attente.tv_nsec = GRANULARITE_us * 1000;
2780:
2781: while(read_atomic(s_etat_processus, pipe,
2782: (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
2783: {
2784: nanosleep(&attente, NULL);
2785: INCR_GRANULARITE(attente.tv_nsec);
2786: }
2787: }
2788: else if ((*s_objet).type == VIN)
2789: {
2790: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2791: {
2792: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2793: return(NULL);
2794: }
2795:
2796: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
2797:
2798: attente.tv_sec = 0;
2799: attente.tv_nsec = GRANULARITE_us * 1000;
2800:
2801: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2802: (*s_objet).objet)).taille),
2803: sizeof(unsigned long)) != sizeof(unsigned long))
2804: {
2805: nanosleep(&attente, NULL);
2806: INCR_GRANULARITE(attente.tv_nsec);
2807: }
2808:
2809: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2810: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2811: sizeof(integer8))) == NULL)
2812: {
2813: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2814: return(NULL);
2815: }
2816:
2817: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2818: {
2819: attente.tv_sec = 0;
2820: attente.tv_nsec = GRANULARITE_us * 1000;
2821:
2822: while(read_atomic(s_etat_processus, pipe,
2823: &(((integer8 *) (*((struct_vecteur *)
2824: (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
2825: sizeof(integer8))
2826: {
2827: nanosleep(&attente, NULL);
2828: INCR_GRANULARITE(attente.tv_nsec);
2829: }
2830: }
2831: }
2832: else if ((*s_objet).type == VRL)
2833: {
2834: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2835: {
2836: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2837: return(NULL);
2838: }
2839:
2840: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
2841:
2842: attente.tv_sec = 0;
2843: attente.tv_nsec = GRANULARITE_us * 1000;
2844:
2845: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2846: (*s_objet).objet)).taille),
2847: sizeof(unsigned long)) != sizeof(unsigned long))
2848: {
2849: nanosleep(&attente, NULL);
2850: INCR_GRANULARITE(attente.tv_nsec);
2851: }
2852:
2853: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2854: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2855: sizeof(real8))) == NULL)
2856: {
2857: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2858: return(NULL);
2859: }
2860:
2861: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2862: {
2863: attente.tv_sec = 0;
2864: attente.tv_nsec = GRANULARITE_us * 1000;
2865:
2866: while(read_atomic(s_etat_processus, pipe,
2867: &(((real8 *) (*((struct_vecteur *)
2868: (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
2869: sizeof(real8))
2870: {
2871: nanosleep(&attente, NULL);
2872: INCR_GRANULARITE(attente.tv_nsec);
2873: }
2874: }
2875: }
2876: else if ((*s_objet).type == VCX)
2877: {
2878: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2879: {
2880: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2881: return(NULL);
2882: }
2883:
2884: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
2885:
2886: attente.tv_sec = 0;
2887: attente.tv_nsec = GRANULARITE_us * 1000;
2888:
2889: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2890: (*s_objet).objet)).taille),
2891: sizeof(unsigned long)) != sizeof(unsigned long))
2892: {
2893: nanosleep(&attente, NULL);
2894: INCR_GRANULARITE(attente.tv_nsec);
2895: }
2896:
2897: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2898: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2899: sizeof(complex16))) == NULL)
2900: {
2901: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2902: return(NULL);
2903: }
2904:
2905: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2906: {
2907: attente.tv_sec = 0;
2908: attente.tv_nsec = GRANULARITE_us * 1000;
2909:
2910: while(read_atomic(s_etat_processus, pipe,
2911: &(((complex16 *) (*((struct_vecteur *)
2912: (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
2913: sizeof(complex16))
2914: {
2915: nanosleep(&attente, NULL);
2916: INCR_GRANULARITE(attente.tv_nsec);
2917: }
2918: }
2919: }
2920: else if ((*s_objet).type == MIN)
2921: {
2922: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2923: {
2924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2925: return(NULL);
2926: }
2927:
2928: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
2929:
2930: attente.tv_sec = 0;
2931: attente.tv_nsec = GRANULARITE_us * 1000;
2932:
2933: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2934: (*s_objet).objet)).nombre_lignes),
2935: sizeof(unsigned long)) != sizeof(unsigned long))
2936: {
2937: nanosleep(&attente, NULL);
2938: INCR_GRANULARITE(attente.tv_nsec);
2939: }
2940:
2941: attente.tv_sec = 0;
2942: attente.tv_nsec = GRANULARITE_us * 1000;
2943:
2944: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2945: (*s_objet).objet)).nombre_colonnes),
2946: sizeof(unsigned long)) != sizeof(unsigned long))
2947: {
2948: nanosleep(&attente, NULL);
2949: INCR_GRANULARITE(attente.tv_nsec);
2950: }
2951:
2952: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2953: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
2954: sizeof(integer8 *))) == NULL)
2955: {
2956: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2957: return(NULL);
2958: }
2959:
2960: for(i = 0; i < (*((struct_matrice *)
2961: (*s_objet).objet)).nombre_lignes; i++)
2962: {
2963: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2964: malloc((*((struct_matrice *) (*s_objet).objet))
2965: .nombre_colonnes * sizeof(integer8))) == NULL)
2966: {
2967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2968: return(NULL);
2969: }
2970:
2971: for(j = 0; j < (*((struct_matrice *)
2972: (*s_objet).objet)).nombre_colonnes; j++)
2973: {
2974: attente.tv_sec = 0;
2975: attente.tv_nsec = GRANULARITE_us * 1000;
2976:
2977: while(read_atomic(s_etat_processus,
2978: pipe, &(((integer8 **) (*((struct_matrice *)
2979: (*s_objet).objet)).tableau)[i][j]),
2980: sizeof(integer8)) != sizeof(integer8))
2981: {
2982: nanosleep(&attente, NULL);
2983: INCR_GRANULARITE(attente.tv_nsec);
2984: }
2985: }
2986: }
2987: }
2988: else if ((*s_objet).type == MRL)
2989: {
2990: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2991: {
2992: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2993: return(NULL);
2994: }
2995:
2996: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
2997:
2998: attente.tv_sec = 0;
2999: attente.tv_nsec = GRANULARITE_us * 1000;
3000:
3001: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3002: (*s_objet).objet)).nombre_lignes),
3003: sizeof(unsigned long)) != sizeof(unsigned long))
3004: {
3005: nanosleep(&attente, NULL);
3006: INCR_GRANULARITE(attente.tv_nsec);
3007: }
3008:
3009: attente.tv_sec = 0;
3010: attente.tv_nsec = GRANULARITE_us * 1000;
3011:
3012: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3013: (*s_objet).objet)).nombre_colonnes),
3014: sizeof(unsigned long)) != sizeof(unsigned long))
3015: {
3016: nanosleep(&attente, NULL);
3017: INCR_GRANULARITE(attente.tv_nsec);
3018: }
3019:
3020: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3021: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3022: sizeof(real8 *))) == NULL)
3023: {
3024: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3025: return(NULL);
3026: }
3027:
3028: for(i = 0; i < (*((struct_matrice *)
3029: (*s_objet).objet)).nombre_lignes; i++)
3030: {
3031: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3032: malloc((*((struct_matrice *) (*s_objet).objet))
3033: .nombre_colonnes * sizeof(real8))) == NULL)
3034: {
3035: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3036: return(NULL);
3037: }
3038:
3039: for(j = 0; j < (*((struct_matrice *)
3040: (*s_objet).objet)).nombre_colonnes; j++)
3041: {
3042: attente.tv_sec = 0;
3043: attente.tv_nsec = GRANULARITE_us * 1000;
3044:
3045: while(read_atomic(s_etat_processus,
3046: pipe, &(((real8 **) (*((struct_matrice *)
3047: (*s_objet).objet)).tableau)[i][j]),
3048: sizeof(real8)) != sizeof(real8))
3049: {
3050: nanosleep(&attente, NULL);
3051: INCR_GRANULARITE(attente.tv_nsec);
3052: }
3053: }
3054: }
3055: }
3056: else if ((*s_objet).type == MCX)
3057: {
3058: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3059: {
3060: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3061: return(NULL);
3062: }
3063:
3064: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
3065:
3066: attente.tv_sec = 0;
3067: attente.tv_nsec = GRANULARITE_us * 1000;
3068:
3069: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3070: (*s_objet).objet)).nombre_lignes),
3071: sizeof(unsigned long)) != sizeof(unsigned long))
3072: {
3073: nanosleep(&attente, NULL);
3074: INCR_GRANULARITE(attente.tv_nsec);
3075: }
3076:
3077: attente.tv_sec = 0;
3078: attente.tv_nsec = GRANULARITE_us * 1000;
3079:
3080: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3081: (*s_objet).objet)).nombre_colonnes),
3082: sizeof(unsigned long)) != sizeof(unsigned long))
3083: {
3084: nanosleep(&attente, NULL);
3085: INCR_GRANULARITE(attente.tv_nsec);
3086: }
3087:
3088: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3089: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3090: sizeof(complex16 *))) == NULL)
3091: {
3092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3093: return(NULL);
3094: }
3095:
3096: for(i = 0; i < (*((struct_matrice *)
3097: (*s_objet).objet)).nombre_lignes; i++)
3098: {
3099: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3100: malloc((*((struct_matrice *) (*s_objet).objet))
3101: .nombre_colonnes * sizeof(complex16))) == NULL)
3102: {
3103: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3104: return(NULL);
3105: }
3106:
3107: for(j = 0; j < (*((struct_matrice *)
3108: (*s_objet).objet)).nombre_colonnes; j++)
3109: {
3110: attente.tv_sec = 0;
3111: attente.tv_nsec = GRANULARITE_us * 1000;
3112:
3113: while(read_atomic(s_etat_processus, pipe,
3114: &(((complex16 **) (*((struct_matrice *)
3115: (*s_objet).objet)).tableau)[i][j]),
3116: sizeof(complex16)) != sizeof(complex16))
3117: {
3118: nanosleep(&attente, NULL);
3119: INCR_GRANULARITE(attente.tv_nsec);
3120: }
3121: }
3122: }
3123: }
3124: else if ((*s_objet).type == BIN)
3125: {
3126: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
3127: {
3128: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3129: return(NULL);
3130: }
3131:
3132: attente.tv_sec = 0;
3133: attente.tv_nsec = GRANULARITE_us * 1000;
3134:
3135: while(read_atomic(s_etat_processus, pipe,
3136: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
3137: {
3138: nanosleep(&attente, NULL);
3139: INCR_GRANULARITE(attente.tv_nsec);
3140: }
3141: }
3142: else if ((*s_objet).type == NOM)
3143: {
3144: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
3145: {
3146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3147: return(NULL);
3148: }
3149:
3150: attente.tv_sec = 0;
3151: attente.tv_nsec = GRANULARITE_us * 1000;
3152:
3153: while(read_atomic(s_etat_processus,
3154: pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
3155: {
3156: nanosleep(&attente, NULL);
3157: INCR_GRANULARITE(attente.tv_nsec);
3158: }
3159:
3160: if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
3161: sizeof(unsigned char))) == NULL)
3162: {
3163: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3164: return(NULL);
3165: }
3166:
3167: attente.tv_sec = 0;
3168: attente.tv_nsec = GRANULARITE_us * 1000;
3169:
3170: while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
3171: (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
3172: {
3173: nanosleep(&attente, NULL);
3174: INCR_GRANULARITE(attente.tv_nsec);
3175: }
3176:
3177: attente.tv_sec = 0;
3178: attente.tv_nsec = GRANULARITE_us * 1000;
3179:
3180: while(read_atomic(s_etat_processus, pipe,
3181: &((*((struct_nom *) (*s_objet).objet)).symbole),
3182: sizeof(logical1)) != sizeof(logical1))
3183: {
3184: nanosleep(&attente, NULL);
3185: INCR_GRANULARITE(attente.tv_nsec);
3186: }
3187: }
3188: else if ((*s_objet).type == FCT)
3189: {
3190: if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
3191: {
3192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3193: return(NULL);
3194: }
3195:
3196: attente.tv_sec = 0;
3197: attente.tv_nsec = GRANULARITE_us * 1000;
3198:
3199: while(read_atomic(s_etat_processus, pipe,
3200: &longueur, sizeof(size_t)) != sizeof(size_t))
3201: {
3202: nanosleep(&attente, NULL);
3203: INCR_GRANULARITE(attente.tv_nsec);
3204: }
3205:
3206: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
3207: malloc(longueur * sizeof(unsigned char))) == NULL)
3208: {
3209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3210: return(NULL);
3211: }
3212:
3213: attente.tv_sec = 0;
3214: attente.tv_nsec = GRANULARITE_us * 1000;
3215:
3216: while(read_atomic(s_etat_processus, pipe,
3217: (*((struct_fonction *) (*s_objet).objet))
3218: .nom_fonction, longueur) != (ssize_t) longueur)
3219: {
3220: nanosleep(&attente, NULL);
3221: INCR_GRANULARITE(attente.tv_nsec);
3222: }
3223:
3224: attente.tv_sec = 0;
3225: attente.tv_nsec = GRANULARITE_us * 1000;
3226:
3227: while(read_atomic(s_etat_processus, pipe,
3228: &((*((struct_fonction *) (*s_objet).objet))
3229: .nombre_arguments), sizeof(unsigned long)) !=
3230: sizeof(unsigned long))
3231: {
3232: nanosleep(&attente, NULL);
3233: INCR_GRANULARITE(attente.tv_nsec);
3234: }
3235:
3236: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
3237: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
3238: (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
3239: }
3240: else if ((*s_objet).type == CHN)
3241: {
3242: attente.tv_sec = 0;
3243: attente.tv_nsec = GRANULARITE_us * 1000;
3244:
3245: while(read_atomic(s_etat_processus, pipe,
3246: &longueur, sizeof(size_t)) != sizeof(size_t))
3247: {
3248: nanosleep(&attente, NULL);
3249: INCR_GRANULARITE(attente.tv_nsec);
3250: }
3251:
3252: if (((*s_objet).objet = malloc(longueur *
3253: sizeof(unsigned char))) == NULL)
3254: {
3255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3256: return(NULL);
3257: }
3258:
3259: attente.tv_sec = 0;
3260: attente.tv_nsec = GRANULARITE_us * 1000;
3261:
3262: while(read_atomic(s_etat_processus, pipe, (unsigned char *)
3263: (*s_objet).objet, longueur) != (ssize_t) longueur)
3264: {
3265: nanosleep(&attente, NULL);
3266: INCR_GRANULARITE(attente.tv_nsec);
3267: }
3268: }
3269: else if (((*s_objet).type == LST) ||
3270: ((*s_objet).type == ALG) ||
3271: ((*s_objet).type == RPN))
3272: {
3273: attente.tv_sec = 0;
3274: attente.tv_nsec = GRANULARITE_us * 1000;
3275:
3276: while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
3277: {
3278: nanosleep(&attente, NULL);
3279: INCR_GRANULARITE(attente.tv_nsec);
3280: }
3281:
3282: l_element_courant = NULL;
3283:
3284: for(i = 0; i < j; i++)
3285: {
3286: if (l_element_courant == NULL)
3287: {
3288: if ((l_element_courant =
3289: malloc(sizeof(struct_liste_chainee))) == NULL)
3290: {
3291: (*s_etat_processus).erreur_systeme =
3292: d_es_allocation_memoire;
3293: return(NULL);
3294: }
3295:
3296: (*s_objet).objet = l_element_courant;
3297: }
3298: else
3299: {
3300: if (((*l_element_courant).suivant =
3301: malloc(sizeof(struct_liste_chainee))) == NULL)
3302: {
3303: (*s_etat_processus).erreur_systeme =
3304: d_es_allocation_memoire;
3305: return(NULL);
3306: }
3307:
3308: l_element_courant = (*l_element_courant).suivant;
3309: (*l_element_courant).suivant = NULL;
3310: }
3311:
3312: attente.tv_sec = 0;
3313: attente.tv_nsec = GRANULARITE_us * 1000;
3314:
3315: while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
3316: pipe)) == NULL)
3317: {
3318: if ((*s_etat_processus).erreur_systeme != d_es)
3319: {
3320: return(NULL);
3321: }
3322:
3323: nanosleep(&attente, NULL);
3324: INCR_GRANULARITE(attente.tv_nsec);
3325: }
3326: }
3327:
3328: if (l_element_courant == NULL)
3329: {
3330: (*s_objet).objet = NULL;
3331: }
3332: else
3333: {
3334: (*l_element_courant).suivant = NULL;
3335: }
3336: }
3337: else if ((*s_objet).type == TBL)
3338: {
3339: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
3340: {
3341: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3342: return(NULL);
3343: }
3344:
3345: attente.tv_sec = 0;
3346: attente.tv_nsec = GRANULARITE_us * 1000;
3347:
3348: while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
3349: (*s_objet).objet)).nombre_elements),
3350: sizeof(unsigned long)) != sizeof(unsigned long))
3351: {
3352: nanosleep(&attente, NULL);
3353: INCR_GRANULARITE(attente.tv_nsec);
3354: }
3355:
3356: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
3357: (*((struct_tableau *) (*s_objet).objet)).nombre_elements *
3358: sizeof(struct_objet *))) == NULL)
3359: {
3360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3361: return(NULL);
3362: }
3363:
3364: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
3365: i++)
3366: {
3367: attente.tv_sec = 0;
3368: attente.tv_nsec = GRANULARITE_us * 1000;
3369:
3370: while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
3371: lecture_pipe(s_etat_processus, pipe)) == NULL)
3372: {
3373: if ((*s_etat_processus).erreur_systeme != d_es)
3374: {
3375: return(NULL);
3376: }
3377:
3378: nanosleep(&attente, NULL);
3379: INCR_GRANULARITE(attente.tv_nsec);
3380: }
3381: }
3382: }
3383:
3384: return(s_objet);
3385: }
3386:
3387:
3388: /*
3389: ================================================================================
3390: Fonction de scrutation des données injectées par le processus père
3391: ================================================================================
3392: Entrées : pointeur sur une structure
3393: --------------------------------------------------------------------------------
3394: Sorties :
3395: --------------------------------------------------------------------------------
3396: Effets de bord : néant
3397: ================================================================================
3398: */
3399:
3400: #ifndef OS2
3401: extern inline
3402: #endif
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_pere == 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: inline int test_arret(struct_processus *s_etat_processus)
3617: {
3618: return((int) (*s_etat_processus).var_volatile_requete_arret);
3619: }
3620:
3621: // 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