1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.16
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: (*(*((struct_processus_fils *) (*(*l_element_courant)
1777: .donnee).objet)).thread).nombre_references--;
1778:
1779: // Cette référence ne peut être nulle car l'objet est encore
1780: // référencé par la liste des threads de surveillance.
1781:
1782: BUG((*(*((struct_processus_fils *) (*(*l_element_courant)
1783: .donnee).objet)).thread).nombre_references <= 0,
1784: uprintf("(*(*((struct_processus_fils *) "
1785: "(*(*l_element_courant).donnee).objet)).thread)"
1786: ".nombre_references = %d\n",
1787: (*(*((struct_processus_fils *)
1788: (*(*l_element_courant).donnee).objet)).thread)
1789: .nombre_references));
1790:
1791: free((*(*l_element_courant).donnee).objet);
1792: free((*l_element_courant).donnee);
1793: free(l_element_courant);
1794:
1795: l_element_courant = (struct_liste_chainee *)
1796: (*s_etat_processus).l_base_pile_processus;
1797: }
1798: else
1799: {
1800: (*l_element_precedent).suivant =
1801: (*l_element_courant).suivant;
1802:
1803: (*(*((struct_processus_fils *) (*(*l_element_courant)
1804: .donnee).objet)).thread).nombre_references--;
1805:
1806: // Cette référence ne peut être nulle car l'objet est encore
1807: // référencé par la liste des threads de surveillance.
1808:
1809: BUG((*(*((struct_processus_fils *) (*(*l_element_courant)
1810: .donnee).objet)).thread).nombre_references <= 0,
1811: uprintf("(*(*((struct_processus_fils *) "
1812: "(*(*l_element_courant).donnee).objet)).thread)"
1813: ".nombre_references = %d\n",
1814: (*(*((struct_processus_fils *)
1815: (*(*l_element_courant).donnee).objet)).thread)
1816: .nombre_references));
1817:
1818: free((*(*l_element_courant).donnee).objet);
1819: free((*l_element_courant).donnee);
1820: free(l_element_courant);
1821: }
1822:
1823: break;
1824: }
1825: else
1826: {
1827: l_element_precedent = l_element_courant;
1828: l_element_courant = (*l_element_courant).suivant;
1829: }
1830: }
1831:
1832: if ((*s_etat_processus).debug == d_vrai)
1833: if (((*s_etat_processus).type_debug &
1834: d_debug_processus) != 0)
1835: {
1836: if ((*s_argument_thread).processus_detache == d_vrai)
1837: {
1838: if ((*s_etat_processus).langue == 'F')
1839: {
1840: printf("[%d] Arrêt du thread de surveillance du"
1841: " processus %d\n", (int) getpid(),
1842: (int) (*s_argument_thread).pid);
1843: }
1844: else
1845: {
1846: printf("[%d] Stop monitoring of process %d", (int) getpid(),
1847: (int) (*s_argument_thread).pid);
1848: }
1849: }
1850: else
1851: {
1852: if ((*s_etat_processus).langue == 'F')
1853: {
1854: printf("[%d] Arrêt du thread de surveillance du"
1855: " thread %llu\n", (int) getpid(),
1856: (unsigned long long) (*s_argument_thread)
1857: .tid);
1858: }
1859: else
1860: {
1861: printf("[%d] Stop monitoring of thread %llu",
1862: (int) getpid(),
1863: (unsigned long long) (*s_argument_thread)
1864: .tid);
1865: }
1866: }
1867:
1868: fflush(stdout);
1869: }
1870:
1871: retrait_thread_surveillance(s_etat_processus, s_argument_thread);
1872:
1873: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1874: {
1875: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1876: }
1877: }
1878:
1879: pthread_exit(NULL);
1880: }
1881:
1882:
1883: /*
1884: ================================================================================
1885: Fonction d'écriture dans un pipe
1886: ================================================================================
1887: Entrées : pointeur sur une structure de description du processus,
1888: numéro du pipe et objet à écrire
1889: --------------------------------------------------------------------------------
1890: Sorties :
1891: --------------------------------------------------------------------------------
1892: Effets de bord : néant
1893: ================================================================================
1894: */
1895:
1896: logical1
1897: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
1898: struct_objet *s_objet)
1899: {
1900: struct_liste_chainee *l_element_courant;
1901:
1902: struct timespec attente;
1903:
1904: unsigned long i;
1905: unsigned long j;
1906:
1907: size_t longueur;
1908: ssize_t longueur_ecriture;
1909:
1910: if ((*s_objet).type == INT)
1911: {
1912: attente.tv_sec = 0;
1913: attente.tv_nsec = GRANULARITE_us * 1000;
1914:
1915: while((longueur_ecriture = write_atomic(s_etat_processus,
1916: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1917: sizeof((*s_objet).type))
1918: {
1919: if (longueur_ecriture == -1)
1920: {
1921: return(d_erreur);
1922: }
1923:
1924: nanosleep(&attente, NULL);
1925: INCR_GRANULARITE(attente.tv_nsec);
1926: }
1927:
1928: attente.tv_sec = 0;
1929: attente.tv_nsec = GRANULARITE_us * 1000;
1930:
1931: while((longueur_ecriture = write_atomic(s_etat_processus,
1932: pipe, (integer8 *)
1933: (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
1934: {
1935: if (longueur_ecriture == -1)
1936: {
1937: return(d_erreur);
1938: }
1939:
1940: nanosleep(&attente, NULL);
1941: INCR_GRANULARITE(attente.tv_nsec);
1942: }
1943: }
1944: else if ((*s_objet).type == REL)
1945: {
1946: attente.tv_sec = 0;
1947: attente.tv_nsec = GRANULARITE_us * 1000;
1948:
1949: while((longueur_ecriture = write_atomic(s_etat_processus,
1950: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1951: sizeof((*s_objet).type))
1952: {
1953: if (longueur_ecriture == -1)
1954: {
1955: return(d_erreur);
1956: }
1957:
1958: nanosleep(&attente, NULL);
1959: INCR_GRANULARITE(attente.tv_nsec);
1960: }
1961:
1962: attente.tv_sec = 0;
1963: attente.tv_nsec = GRANULARITE_us * 1000;
1964:
1965: while((longueur_ecriture = write_atomic(s_etat_processus,
1966: pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
1967: sizeof(real8))
1968: {
1969: if (longueur_ecriture == -1)
1970: {
1971: return(d_erreur);
1972: }
1973:
1974: nanosleep(&attente, NULL);
1975: INCR_GRANULARITE(attente.tv_nsec);
1976: }
1977: }
1978: else if ((*s_objet).type == CPL)
1979: {
1980: attente.tv_sec = 0;
1981: attente.tv_nsec = GRANULARITE_us * 1000;
1982:
1983: while((longueur_ecriture = write_atomic(s_etat_processus,
1984: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1985: sizeof((*s_objet).type))
1986: {
1987: if (longueur_ecriture == -1)
1988: {
1989: return(d_erreur);
1990: }
1991:
1992: nanosleep(&attente, NULL);
1993: INCR_GRANULARITE(attente.tv_nsec);
1994: }
1995:
1996: attente.tv_sec = 0;
1997: attente.tv_nsec = GRANULARITE_us * 1000;
1998:
1999: while((longueur_ecriture = write_atomic(s_etat_processus,
2000: pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
2001: != sizeof(complex16))
2002: {
2003: if (longueur_ecriture == -1)
2004: {
2005: return(d_erreur);
2006: }
2007:
2008: nanosleep(&attente, NULL);
2009: INCR_GRANULARITE(attente.tv_nsec);
2010: }
2011: }
2012: else if ((*s_objet).type == VIN)
2013: {
2014: attente.tv_sec = 0;
2015: attente.tv_nsec = GRANULARITE_us * 1000;
2016:
2017: while((longueur_ecriture = write_atomic(s_etat_processus,
2018: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2019: sizeof((*s_objet).type))
2020: {
2021: if (longueur_ecriture == -1)
2022: {
2023: return(d_erreur);
2024: }
2025:
2026: nanosleep(&attente, NULL);
2027: INCR_GRANULARITE(attente.tv_nsec);
2028: }
2029:
2030: attente.tv_sec = 0;
2031: attente.tv_nsec = GRANULARITE_us * 1000;
2032:
2033: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2034: &((*((struct_vecteur *) (*s_objet).objet))
2035: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
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: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2047: {
2048: attente.tv_sec = 0;
2049: attente.tv_nsec = GRANULARITE_us * 1000;
2050:
2051: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2052: &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
2053: .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
2054: {
2055: if (longueur_ecriture == -1)
2056: {
2057: return(d_erreur);
2058: }
2059:
2060: nanosleep(&attente, NULL);
2061: INCR_GRANULARITE(attente.tv_nsec);
2062: }
2063: }
2064: }
2065: else if ((*s_objet).type == VRL)
2066: {
2067: attente.tv_sec = 0;
2068: attente.tv_nsec = GRANULARITE_us * 1000;
2069:
2070: while((longueur_ecriture = write_atomic(s_etat_processus,
2071: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2072: sizeof((*s_objet).type))
2073: {
2074: if (longueur_ecriture == -1)
2075: {
2076: return(d_erreur);
2077: }
2078:
2079: nanosleep(&attente, NULL);
2080: INCR_GRANULARITE(attente.tv_nsec);
2081: }
2082:
2083: attente.tv_sec = 0;
2084: attente.tv_nsec = GRANULARITE_us * 1000;
2085:
2086: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2087: &((*((struct_vecteur *) (*s_objet).objet))
2088: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
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: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2100: {
2101: attente.tv_sec = 0;
2102: attente.tv_nsec = GRANULARITE_us * 1000;
2103:
2104: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2105: &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
2106: .tableau)[i]), sizeof(real8))) != sizeof(real8))
2107: {
2108: if (longueur_ecriture == -1)
2109: {
2110: return(d_erreur);
2111: }
2112:
2113: nanosleep(&attente, NULL);
2114: INCR_GRANULARITE(attente.tv_nsec);
2115: }
2116: }
2117: }
2118: else if ((*s_objet).type == VCX)
2119: {
2120: attente.tv_sec = 0;
2121: attente.tv_nsec = GRANULARITE_us * 1000;
2122:
2123: while((longueur_ecriture = write_atomic(s_etat_processus,
2124: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2125: sizeof((*s_objet).type))
2126: {
2127: if (longueur_ecriture == -1)
2128: {
2129: return(d_erreur);
2130: }
2131:
2132: nanosleep(&attente, NULL);
2133: INCR_GRANULARITE(attente.tv_nsec);
2134: }
2135:
2136: attente.tv_sec = 0;
2137: attente.tv_nsec = GRANULARITE_us * 1000;
2138:
2139: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2140: &((*((struct_vecteur *) (*s_objet).objet))
2141: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
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: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2153: {
2154: attente.tv_sec = 0;
2155: attente.tv_nsec = GRANULARITE_us * 1000;
2156:
2157: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2158: &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
2159: .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
2160: {
2161: if (longueur_ecriture == -1)
2162: {
2163: return(d_erreur);
2164: }
2165:
2166: nanosleep(&attente, NULL);
2167: INCR_GRANULARITE(attente.tv_nsec);
2168: }
2169: }
2170: }
2171: else if ((*s_objet).type == MIN)
2172: {
2173: attente.tv_sec = 0;
2174: attente.tv_nsec = GRANULARITE_us * 1000;
2175:
2176: while((longueur_ecriture = write_atomic(s_etat_processus,
2177: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2178: sizeof((*s_objet).type))
2179: {
2180: if (longueur_ecriture == -1)
2181: {
2182: return(d_erreur);
2183: }
2184:
2185: nanosleep(&attente, NULL);
2186: INCR_GRANULARITE(attente.tv_nsec);
2187: }
2188:
2189: attente.tv_sec = 0;
2190: attente.tv_nsec = GRANULARITE_us * 1000;
2191:
2192: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2193: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2194: sizeof(unsigned long))) != sizeof(unsigned long))
2195: {
2196: if (longueur_ecriture == -1)
2197: {
2198: return(d_erreur);
2199: }
2200:
2201: nanosleep(&attente, NULL);
2202: INCR_GRANULARITE(attente.tv_nsec);
2203: }
2204:
2205: attente.tv_sec = 0;
2206: attente.tv_nsec = GRANULARITE_us * 1000;
2207:
2208: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2209: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2210: sizeof(unsigned long))) != sizeof(unsigned long))
2211: {
2212: if (longueur_ecriture == -1)
2213: {
2214: return(d_erreur);
2215: }
2216:
2217: nanosleep(&attente, NULL);
2218: INCR_GRANULARITE(attente.tv_nsec);
2219: }
2220:
2221: for(i = 0; i < (*((struct_matrice *)
2222: (*s_objet).objet)).nombre_lignes; i++)
2223: {
2224: for(j = 0; j < (*((struct_matrice *)
2225: (*s_objet).objet)).nombre_colonnes; j++)
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: &(((integer8 **) (*((struct_matrice *)
2232: (*s_objet).objet)).tableau)[i][j]),
2233: sizeof(integer8))) != sizeof(integer8))
2234: {
2235: if (longueur_ecriture == -1)
2236: {
2237: return(d_erreur);
2238: }
2239:
2240: nanosleep(&attente, NULL);
2241: INCR_GRANULARITE(attente.tv_nsec);
2242: }
2243: }
2244: }
2245: }
2246: else if ((*s_objet).type == MRL)
2247: {
2248: attente.tv_sec = 0;
2249: attente.tv_nsec = GRANULARITE_us * 1000;
2250:
2251: while((longueur_ecriture = write_atomic(s_etat_processus,
2252: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2253: sizeof((*s_objet).type))
2254: {
2255: if (longueur_ecriture == -1)
2256: {
2257: return(d_erreur);
2258: }
2259:
2260: nanosleep(&attente, NULL);
2261: INCR_GRANULARITE(attente.tv_nsec);
2262: }
2263:
2264: attente.tv_sec = 0;
2265: attente.tv_nsec = GRANULARITE_us * 1000;
2266:
2267: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2268: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2269: sizeof(unsigned long))) != sizeof(unsigned long))
2270: {
2271: if (longueur_ecriture == -1)
2272: {
2273: return(d_erreur);
2274: }
2275:
2276: nanosleep(&attente, NULL);
2277: INCR_GRANULARITE(attente.tv_nsec);
2278: }
2279:
2280: attente.tv_sec = 0;
2281: attente.tv_nsec = GRANULARITE_us * 1000;
2282:
2283: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2284: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2285: sizeof(unsigned long))) != sizeof(unsigned long))
2286: {
2287: if (longueur_ecriture == -1)
2288: {
2289: return(d_erreur);
2290: }
2291:
2292: nanosleep(&attente, NULL);
2293: INCR_GRANULARITE(attente.tv_nsec);
2294: }
2295:
2296: for(i = 0; i < (*((struct_matrice *)
2297: (*s_objet).objet)).nombre_lignes; i++)
2298: {
2299: for(j = 0; j < (*((struct_matrice *)
2300: (*s_objet).objet)).nombre_colonnes; j++)
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: &(((real8 **) (*((struct_matrice *)
2307: (*s_objet).objet)).tableau)[i][j]),
2308: sizeof(real8))) != sizeof(real8))
2309: {
2310: if (longueur_ecriture == -1)
2311: {
2312: return(d_erreur);
2313: }
2314:
2315: nanosleep(&attente, NULL);
2316: INCR_GRANULARITE(attente.tv_nsec);
2317: }
2318: }
2319: }
2320: }
2321: else if ((*s_objet).type == MCX)
2322: {
2323: attente.tv_sec = 0;
2324: attente.tv_nsec = GRANULARITE_us * 1000;
2325:
2326: while((longueur_ecriture = write_atomic(s_etat_processus,
2327: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2328: sizeof((*s_objet).type))
2329: {
2330: if (longueur_ecriture == -1)
2331: {
2332: return(d_erreur);
2333: }
2334:
2335: nanosleep(&attente, NULL);
2336: INCR_GRANULARITE(attente.tv_nsec);
2337: }
2338:
2339: attente.tv_sec = 0;
2340: attente.tv_nsec = GRANULARITE_us * 1000;
2341:
2342: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2343: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2344: sizeof(unsigned long))) != sizeof(unsigned long))
2345: {
2346: if (longueur_ecriture == -1)
2347: {
2348: return(d_erreur);
2349: }
2350:
2351: nanosleep(&attente, NULL);
2352: INCR_GRANULARITE(attente.tv_nsec);
2353: }
2354:
2355: attente.tv_sec = 0;
2356: attente.tv_nsec = GRANULARITE_us * 1000;
2357:
2358: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2359: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2360: sizeof(unsigned long))) != sizeof(unsigned long))
2361: {
2362: if (longueur_ecriture == -1)
2363: {
2364: return(d_erreur);
2365: }
2366:
2367: nanosleep(&attente, NULL);
2368: INCR_GRANULARITE(attente.tv_nsec);
2369: }
2370:
2371: for(i = 0; i < (*((struct_matrice *)
2372: (*s_objet).objet)).nombre_lignes; i++)
2373: {
2374: for(j = 0; j < (*((struct_matrice *)
2375: (*s_objet).objet)).nombre_colonnes; j++)
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: &(((complex16 **) (*((struct_matrice *)
2382: (*s_objet).objet)).tableau)[i][j]),
2383: sizeof(complex16))) != sizeof(complex16))
2384: {
2385: if (longueur_ecriture == -1)
2386: {
2387: return(d_erreur);
2388: }
2389:
2390: nanosleep(&attente, NULL);
2391: INCR_GRANULARITE(attente.tv_nsec);
2392: }
2393: }
2394: }
2395: }
2396: else if ((*s_objet).type == BIN)
2397: {
2398: attente.tv_sec = 0;
2399: attente.tv_nsec = GRANULARITE_us * 1000;
2400:
2401: while((longueur_ecriture = write_atomic(s_etat_processus,
2402: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2403: sizeof((*s_objet).type))
2404: {
2405: if (longueur_ecriture == -1)
2406: {
2407: return(d_erreur);
2408: }
2409:
2410: nanosleep(&attente, NULL);
2411: INCR_GRANULARITE(attente.tv_nsec);
2412: }
2413:
2414: attente.tv_sec = 0;
2415: attente.tv_nsec = GRANULARITE_us * 1000;
2416:
2417: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2418: (integer8 *) (*s_objet).objet,
2419: sizeof(integer8))) != sizeof(integer8))
2420: {
2421: if (longueur_ecriture == -1)
2422: {
2423: return(d_erreur);
2424: }
2425:
2426: nanosleep(&attente, NULL);
2427: INCR_GRANULARITE(attente.tv_nsec);
2428: }
2429: }
2430: else if ((*s_objet).type == NOM)
2431: {
2432: attente.tv_sec = 0;
2433: attente.tv_nsec = GRANULARITE_us * 1000;
2434:
2435: while((longueur_ecriture = write_atomic(s_etat_processus,
2436: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2437: sizeof((*s_objet).type))
2438: {
2439: if (longueur_ecriture == -1)
2440: {
2441: return(d_erreur);
2442: }
2443:
2444: nanosleep(&attente, NULL);
2445: INCR_GRANULARITE(attente.tv_nsec);
2446: }
2447:
2448: longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
2449:
2450: attente.tv_sec = 0;
2451: attente.tv_nsec = GRANULARITE_us * 1000;
2452:
2453: while((longueur_ecriture = write_atomic(s_etat_processus,
2454: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2455: {
2456: if (longueur_ecriture == -1)
2457: {
2458: return(d_erreur);
2459: }
2460:
2461: nanosleep(&attente, NULL);
2462: INCR_GRANULARITE(attente.tv_nsec);
2463: }
2464:
2465: attente.tv_sec = 0;
2466: attente.tv_nsec = GRANULARITE_us * 1000;
2467:
2468: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2469: (*((struct_nom *) (*s_objet).objet)).nom,
2470: longueur)) != (ssize_t) longueur)
2471: {
2472: if (longueur_ecriture == -1)
2473: {
2474: return(d_erreur);
2475: }
2476:
2477: nanosleep(&attente, NULL);
2478: INCR_GRANULARITE(attente.tv_nsec);
2479: }
2480:
2481: attente.tv_sec = 0;
2482: attente.tv_nsec = GRANULARITE_us * 1000;
2483:
2484: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2485: &((*((struct_nom *) (*s_objet).objet))
2486: .symbole), sizeof(logical1))) != sizeof(logical1))
2487: {
2488: if (longueur_ecriture == -1)
2489: {
2490: return(d_erreur);
2491: }
2492:
2493: nanosleep(&attente, NULL);
2494: INCR_GRANULARITE(attente.tv_nsec);
2495: }
2496: }
2497: else if ((*s_objet).type == FCT)
2498: {
2499: attente.tv_sec = 0;
2500: attente.tv_nsec = GRANULARITE_us * 1000;
2501:
2502: while((longueur_ecriture = write_atomic(s_etat_processus,
2503: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2504: sizeof((*s_objet).type))
2505: {
2506: if (longueur_ecriture == -1)
2507: {
2508: return(d_erreur);
2509: }
2510:
2511: nanosleep(&attente, NULL);
2512: INCR_GRANULARITE(attente.tv_nsec);
2513: }
2514:
2515: longueur = strlen((*((struct_fonction *)
2516: (*s_objet).objet)).nom_fonction) + 1;
2517:
2518: attente.tv_sec = 0;
2519: attente.tv_nsec = GRANULARITE_us * 1000;
2520:
2521: while((longueur_ecriture = write_atomic(s_etat_processus,
2522: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2523: {
2524: if (longueur_ecriture == -1)
2525: {
2526: return(d_erreur);
2527: }
2528:
2529: nanosleep(&attente, NULL);
2530: INCR_GRANULARITE(attente.tv_nsec);
2531: }
2532:
2533: attente.tv_sec = 0;
2534: attente.tv_nsec = GRANULARITE_us * 1000;
2535:
2536: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2537: (*((struct_fonction *) (*s_objet).objet))
2538: .nom_fonction, longueur)) != (ssize_t) longueur)
2539: {
2540: if (longueur_ecriture == -1)
2541: {
2542: return(d_erreur);
2543: }
2544:
2545: nanosleep(&attente, NULL);
2546: INCR_GRANULARITE(attente.tv_nsec);
2547: }
2548:
2549: attente.tv_sec = 0;
2550: attente.tv_nsec = GRANULARITE_us * 1000;
2551:
2552: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2553: &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
2554: sizeof(unsigned long))) != sizeof(unsigned long))
2555: {
2556: if (longueur_ecriture == -1)
2557: {
2558: return(d_erreur);
2559: }
2560:
2561: nanosleep(&attente, NULL);
2562: INCR_GRANULARITE(attente.tv_nsec);
2563: }
2564: }
2565: else if ((*s_objet).type == CHN)
2566: {
2567: attente.tv_sec = 0;
2568: attente.tv_nsec = GRANULARITE_us * 1000;
2569:
2570: while((longueur_ecriture = write_atomic(s_etat_processus,
2571: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2572: sizeof((*s_objet).type))
2573: {
2574: if (longueur_ecriture == -1)
2575: {
2576: return(d_erreur);
2577: }
2578:
2579: nanosleep(&attente, NULL);
2580: INCR_GRANULARITE(attente.tv_nsec);
2581: }
2582:
2583: longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
2584:
2585: attente.tv_sec = 0;
2586: attente.tv_nsec = GRANULARITE_us * 1000;
2587:
2588: while((longueur_ecriture = write_atomic(s_etat_processus,
2589: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2590: {
2591: if (longueur_ecriture == -1)
2592: {
2593: return(d_erreur);
2594: }
2595:
2596: nanosleep(&attente, NULL);
2597: INCR_GRANULARITE(attente.tv_nsec);
2598: }
2599:
2600: attente.tv_sec = 0;
2601: attente.tv_nsec = GRANULARITE_us * 1000;
2602:
2603: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2604: (unsigned char *) (*s_objet).objet,
2605: longueur)) != (ssize_t) longueur)
2606: {
2607: if (longueur_ecriture == -1)
2608: {
2609: return(d_erreur);
2610: }
2611:
2612: nanosleep(&attente, NULL);
2613: INCR_GRANULARITE(attente.tv_nsec);
2614: }
2615: }
2616: else if (((*s_objet).type == LST) ||
2617: ((*s_objet).type == ALG) ||
2618: ((*s_objet).type == RPN))
2619: {
2620: attente.tv_sec = 0;
2621: attente.tv_nsec = GRANULARITE_us * 1000;
2622:
2623: while((longueur_ecriture = write_atomic(s_etat_processus,
2624: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2625: sizeof((*s_objet).type))
2626: {
2627: if (longueur_ecriture == -1)
2628: {
2629: return(d_erreur);
2630: }
2631:
2632: nanosleep(&attente, NULL);
2633: INCR_GRANULARITE(attente.tv_nsec);
2634: }
2635:
2636: l_element_courant = (*s_objet).objet;
2637: i = 0;
2638:
2639: while(l_element_courant != NULL)
2640: {
2641: i++;
2642: l_element_courant = (*l_element_courant).suivant;
2643: }
2644:
2645: attente.tv_sec = 0;
2646: attente.tv_nsec = GRANULARITE_us * 1000;
2647:
2648: while((longueur_ecriture = write_atomic(s_etat_processus,
2649: pipe, &i, sizeof(i))) != sizeof(i))
2650: {
2651: if (longueur_ecriture == -1)
2652: {
2653: return(d_erreur);
2654: }
2655:
2656: nanosleep(&attente, NULL);
2657: INCR_GRANULARITE(attente.tv_nsec);
2658: }
2659:
2660: l_element_courant = (*s_objet).objet;
2661:
2662: while(l_element_courant != NULL)
2663: {
2664: if (ecriture_pipe(s_etat_processus, pipe,
2665: (*l_element_courant).donnee) == d_erreur)
2666: {
2667: return(d_erreur);
2668: }
2669:
2670: l_element_courant = (*l_element_courant).suivant;
2671: }
2672: }
2673: else if ((*s_objet).type == TBL)
2674: {
2675: attente.tv_sec = 0;
2676: attente.tv_nsec = GRANULARITE_us * 1000;
2677:
2678: while((longueur_ecriture = write_atomic(s_etat_processus,
2679: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2680: sizeof((*s_objet).type))
2681: {
2682: if (longueur_ecriture == -1)
2683: {
2684: return(d_erreur);
2685: }
2686:
2687: nanosleep(&attente, NULL);
2688: INCR_GRANULARITE(attente.tv_nsec);
2689: }
2690:
2691: attente.tv_sec = 0;
2692: attente.tv_nsec = GRANULARITE_us * 1000;
2693:
2694: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2695: &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
2696: sizeof(unsigned long))) != sizeof(unsigned long))
2697: {
2698: if (longueur_ecriture == -1)
2699: {
2700: return(d_erreur);
2701: }
2702:
2703: nanosleep(&attente, NULL);
2704: INCR_GRANULARITE(attente.tv_nsec);
2705: }
2706:
2707: for(i = 0; i < (*((struct_tableau *)
2708: (*s_objet).objet)).nombre_elements; i++)
2709: {
2710: if (ecriture_pipe(s_etat_processus, pipe,
2711: (*((struct_tableau *) (*s_objet).objet)).elements[i])
2712: == d_erreur)
2713: {
2714: return(d_erreur);
2715: }
2716: }
2717: }
2718: else
2719: {
2720: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2721: return(d_erreur);
2722: }
2723:
2724: return(d_absence_erreur);
2725: }
2726:
2727:
2728: /*
2729: ================================================================================
2730: Fonction de lecture dans un pipe
2731: ================================================================================
2732: Entrées : pointeur sur une structure de description du processus,
2733: numéro du pipe et objet à écrire
2734: --------------------------------------------------------------------------------
2735: Sorties :
2736: --------------------------------------------------------------------------------
2737: Effets de bord : néant
2738: ================================================================================
2739: */
2740:
2741: struct_objet *
2742: lecture_pipe(struct_processus *s_etat_processus, int pipe)
2743: {
2744: size_t longueur;
2745:
2746: struct_liste_chainee *l_element_courant;
2747:
2748: struct_objet *s_objet;
2749:
2750: struct timespec attente;
2751:
2752: unsigned long i;
2753: unsigned long j;
2754:
2755: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
2756: {
2757: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2758: return(NULL);
2759: }
2760:
2761: attente.tv_sec = 0;
2762: attente.tv_nsec = GRANULARITE_us * 1000;
2763:
2764: while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
2765: sizeof((*s_objet).type)) != sizeof((*s_objet).type))
2766: {
2767: nanosleep(&attente, NULL);
2768: INCR_GRANULARITE(attente.tv_nsec);
2769: }
2770:
2771: if ((*s_objet).type == INT)
2772: {
2773: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2774: {
2775: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2776: return(NULL);
2777: }
2778:
2779: attente.tv_sec = 0;
2780: attente.tv_nsec = GRANULARITE_us * 1000;
2781:
2782: while(read_atomic(s_etat_processus, pipe,
2783: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2784: {
2785: nanosleep(&attente, NULL);
2786: INCR_GRANULARITE(attente.tv_nsec);
2787: }
2788: }
2789: else if ((*s_objet).type == REL)
2790: {
2791: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
2792: {
2793: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2794: return(NULL);
2795: }
2796:
2797: attente.tv_sec = 0;
2798: attente.tv_nsec = GRANULARITE_us * 1000;
2799:
2800: while(read_atomic(s_etat_processus, pipe,
2801: (*s_objet).objet, sizeof(real8)) != sizeof(real8))
2802: {
2803: nanosleep(&attente, NULL);
2804: INCR_GRANULARITE(attente.tv_nsec);
2805: }
2806: }
2807: else if ((*s_objet).type == CPL)
2808: {
2809: if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
2810: {
2811: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2812: return(NULL);
2813: }
2814:
2815: attente.tv_sec = 0;
2816: attente.tv_nsec = GRANULARITE_us * 1000;
2817:
2818: while(read_atomic(s_etat_processus, pipe,
2819: (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
2820: {
2821: nanosleep(&attente, NULL);
2822: INCR_GRANULARITE(attente.tv_nsec);
2823: }
2824: }
2825: else if ((*s_objet).type == VIN)
2826: {
2827: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2828: {
2829: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2830: return(NULL);
2831: }
2832:
2833: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
2834:
2835: attente.tv_sec = 0;
2836: attente.tv_nsec = GRANULARITE_us * 1000;
2837:
2838: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2839: (*s_objet).objet)).taille),
2840: sizeof(unsigned long)) != sizeof(unsigned long))
2841: {
2842: nanosleep(&attente, NULL);
2843: INCR_GRANULARITE(attente.tv_nsec);
2844: }
2845:
2846: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2847: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2848: sizeof(integer8))) == NULL)
2849: {
2850: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2851: return(NULL);
2852: }
2853:
2854: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2855: {
2856: attente.tv_sec = 0;
2857: attente.tv_nsec = GRANULARITE_us * 1000;
2858:
2859: while(read_atomic(s_etat_processus, pipe,
2860: &(((integer8 *) (*((struct_vecteur *)
2861: (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
2862: sizeof(integer8))
2863: {
2864: nanosleep(&attente, NULL);
2865: INCR_GRANULARITE(attente.tv_nsec);
2866: }
2867: }
2868: }
2869: else if ((*s_objet).type == VRL)
2870: {
2871: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2872: {
2873: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2874: return(NULL);
2875: }
2876:
2877: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
2878:
2879: attente.tv_sec = 0;
2880: attente.tv_nsec = GRANULARITE_us * 1000;
2881:
2882: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2883: (*s_objet).objet)).taille),
2884: sizeof(unsigned long)) != sizeof(unsigned long))
2885: {
2886: nanosleep(&attente, NULL);
2887: INCR_GRANULARITE(attente.tv_nsec);
2888: }
2889:
2890: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2891: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2892: sizeof(real8))) == NULL)
2893: {
2894: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2895: return(NULL);
2896: }
2897:
2898: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2899: {
2900: attente.tv_sec = 0;
2901: attente.tv_nsec = GRANULARITE_us * 1000;
2902:
2903: while(read_atomic(s_etat_processus, pipe,
2904: &(((real8 *) (*((struct_vecteur *)
2905: (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
2906: sizeof(real8))
2907: {
2908: nanosleep(&attente, NULL);
2909: INCR_GRANULARITE(attente.tv_nsec);
2910: }
2911: }
2912: }
2913: else if ((*s_objet).type == VCX)
2914: {
2915: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2916: {
2917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2918: return(NULL);
2919: }
2920:
2921: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
2922:
2923: attente.tv_sec = 0;
2924: attente.tv_nsec = GRANULARITE_us * 1000;
2925:
2926: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2927: (*s_objet).objet)).taille),
2928: sizeof(unsigned long)) != sizeof(unsigned long))
2929: {
2930: nanosleep(&attente, NULL);
2931: INCR_GRANULARITE(attente.tv_nsec);
2932: }
2933:
2934: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2935: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2936: sizeof(complex16))) == NULL)
2937: {
2938: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2939: return(NULL);
2940: }
2941:
2942: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2943: {
2944: attente.tv_sec = 0;
2945: attente.tv_nsec = GRANULARITE_us * 1000;
2946:
2947: while(read_atomic(s_etat_processus, pipe,
2948: &(((complex16 *) (*((struct_vecteur *)
2949: (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
2950: sizeof(complex16))
2951: {
2952: nanosleep(&attente, NULL);
2953: INCR_GRANULARITE(attente.tv_nsec);
2954: }
2955: }
2956: }
2957: else if ((*s_objet).type == MIN)
2958: {
2959: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2960: {
2961: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2962: return(NULL);
2963: }
2964:
2965: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
2966:
2967: attente.tv_sec = 0;
2968: attente.tv_nsec = GRANULARITE_us * 1000;
2969:
2970: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2971: (*s_objet).objet)).nombre_lignes),
2972: sizeof(unsigned long)) != sizeof(unsigned long))
2973: {
2974: nanosleep(&attente, NULL);
2975: INCR_GRANULARITE(attente.tv_nsec);
2976: }
2977:
2978: attente.tv_sec = 0;
2979: attente.tv_nsec = GRANULARITE_us * 1000;
2980:
2981: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2982: (*s_objet).objet)).nombre_colonnes),
2983: sizeof(unsigned long)) != sizeof(unsigned long))
2984: {
2985: nanosleep(&attente, NULL);
2986: INCR_GRANULARITE(attente.tv_nsec);
2987: }
2988:
2989: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2990: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
2991: sizeof(integer8 *))) == NULL)
2992: {
2993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2994: return(NULL);
2995: }
2996:
2997: for(i = 0; i < (*((struct_matrice *)
2998: (*s_objet).objet)).nombre_lignes; i++)
2999: {
3000: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3001: malloc((*((struct_matrice *) (*s_objet).objet))
3002: .nombre_colonnes * sizeof(integer8))) == NULL)
3003: {
3004: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3005: return(NULL);
3006: }
3007:
3008: for(j = 0; j < (*((struct_matrice *)
3009: (*s_objet).objet)).nombre_colonnes; j++)
3010: {
3011: attente.tv_sec = 0;
3012: attente.tv_nsec = GRANULARITE_us * 1000;
3013:
3014: while(read_atomic(s_etat_processus,
3015: pipe, &(((integer8 **) (*((struct_matrice *)
3016: (*s_objet).objet)).tableau)[i][j]),
3017: sizeof(integer8)) != sizeof(integer8))
3018: {
3019: nanosleep(&attente, NULL);
3020: INCR_GRANULARITE(attente.tv_nsec);
3021: }
3022: }
3023: }
3024: }
3025: else if ((*s_objet).type == MRL)
3026: {
3027: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3028: {
3029: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3030: return(NULL);
3031: }
3032:
3033: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
3034:
3035: attente.tv_sec = 0;
3036: attente.tv_nsec = GRANULARITE_us * 1000;
3037:
3038: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3039: (*s_objet).objet)).nombre_lignes),
3040: sizeof(unsigned long)) != sizeof(unsigned long))
3041: {
3042: nanosleep(&attente, NULL);
3043: INCR_GRANULARITE(attente.tv_nsec);
3044: }
3045:
3046: attente.tv_sec = 0;
3047: attente.tv_nsec = GRANULARITE_us * 1000;
3048:
3049: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3050: (*s_objet).objet)).nombre_colonnes),
3051: sizeof(unsigned long)) != sizeof(unsigned long))
3052: {
3053: nanosleep(&attente, NULL);
3054: INCR_GRANULARITE(attente.tv_nsec);
3055: }
3056:
3057: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3058: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3059: sizeof(real8 *))) == NULL)
3060: {
3061: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3062: return(NULL);
3063: }
3064:
3065: for(i = 0; i < (*((struct_matrice *)
3066: (*s_objet).objet)).nombre_lignes; i++)
3067: {
3068: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3069: malloc((*((struct_matrice *) (*s_objet).objet))
3070: .nombre_colonnes * sizeof(real8))) == NULL)
3071: {
3072: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3073: return(NULL);
3074: }
3075:
3076: for(j = 0; j < (*((struct_matrice *)
3077: (*s_objet).objet)).nombre_colonnes; j++)
3078: {
3079: attente.tv_sec = 0;
3080: attente.tv_nsec = GRANULARITE_us * 1000;
3081:
3082: while(read_atomic(s_etat_processus,
3083: pipe, &(((real8 **) (*((struct_matrice *)
3084: (*s_objet).objet)).tableau)[i][j]),
3085: sizeof(real8)) != sizeof(real8))
3086: {
3087: nanosleep(&attente, NULL);
3088: INCR_GRANULARITE(attente.tv_nsec);
3089: }
3090: }
3091: }
3092: }
3093: else if ((*s_objet).type == MCX)
3094: {
3095: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3096: {
3097: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3098: return(NULL);
3099: }
3100:
3101: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
3102:
3103: attente.tv_sec = 0;
3104: attente.tv_nsec = GRANULARITE_us * 1000;
3105:
3106: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3107: (*s_objet).objet)).nombre_lignes),
3108: sizeof(unsigned long)) != sizeof(unsigned long))
3109: {
3110: nanosleep(&attente, NULL);
3111: INCR_GRANULARITE(attente.tv_nsec);
3112: }
3113:
3114: attente.tv_sec = 0;
3115: attente.tv_nsec = GRANULARITE_us * 1000;
3116:
3117: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3118: (*s_objet).objet)).nombre_colonnes),
3119: sizeof(unsigned long)) != sizeof(unsigned long))
3120: {
3121: nanosleep(&attente, NULL);
3122: INCR_GRANULARITE(attente.tv_nsec);
3123: }
3124:
3125: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3126: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3127: sizeof(complex16 *))) == NULL)
3128: {
3129: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3130: return(NULL);
3131: }
3132:
3133: for(i = 0; i < (*((struct_matrice *)
3134: (*s_objet).objet)).nombre_lignes; i++)
3135: {
3136: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3137: malloc((*((struct_matrice *) (*s_objet).objet))
3138: .nombre_colonnes * sizeof(complex16))) == NULL)
3139: {
3140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3141: return(NULL);
3142: }
3143:
3144: for(j = 0; j < (*((struct_matrice *)
3145: (*s_objet).objet)).nombre_colonnes; j++)
3146: {
3147: attente.tv_sec = 0;
3148: attente.tv_nsec = GRANULARITE_us * 1000;
3149:
3150: while(read_atomic(s_etat_processus, pipe,
3151: &(((complex16 **) (*((struct_matrice *)
3152: (*s_objet).objet)).tableau)[i][j]),
3153: sizeof(complex16)) != sizeof(complex16))
3154: {
3155: nanosleep(&attente, NULL);
3156: INCR_GRANULARITE(attente.tv_nsec);
3157: }
3158: }
3159: }
3160: }
3161: else if ((*s_objet).type == BIN)
3162: {
3163: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
3164: {
3165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3166: return(NULL);
3167: }
3168:
3169: attente.tv_sec = 0;
3170: attente.tv_nsec = GRANULARITE_us * 1000;
3171:
3172: while(read_atomic(s_etat_processus, pipe,
3173: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
3174: {
3175: nanosleep(&attente, NULL);
3176: INCR_GRANULARITE(attente.tv_nsec);
3177: }
3178: }
3179: else if ((*s_objet).type == NOM)
3180: {
3181: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
3182: {
3183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3184: return(NULL);
3185: }
3186:
3187: attente.tv_sec = 0;
3188: attente.tv_nsec = GRANULARITE_us * 1000;
3189:
3190: while(read_atomic(s_etat_processus,
3191: pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
3192: {
3193: nanosleep(&attente, NULL);
3194: INCR_GRANULARITE(attente.tv_nsec);
3195: }
3196:
3197: if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
3198: sizeof(unsigned char))) == NULL)
3199: {
3200: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3201: return(NULL);
3202: }
3203:
3204: attente.tv_sec = 0;
3205: attente.tv_nsec = GRANULARITE_us * 1000;
3206:
3207: while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
3208: (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
3209: {
3210: nanosleep(&attente, NULL);
3211: INCR_GRANULARITE(attente.tv_nsec);
3212: }
3213:
3214: attente.tv_sec = 0;
3215: attente.tv_nsec = GRANULARITE_us * 1000;
3216:
3217: while(read_atomic(s_etat_processus, pipe,
3218: &((*((struct_nom *) (*s_objet).objet)).symbole),
3219: sizeof(logical1)) != sizeof(logical1))
3220: {
3221: nanosleep(&attente, NULL);
3222: INCR_GRANULARITE(attente.tv_nsec);
3223: }
3224: }
3225: else if ((*s_objet).type == FCT)
3226: {
3227: if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
3228: {
3229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3230: return(NULL);
3231: }
3232:
3233: attente.tv_sec = 0;
3234: attente.tv_nsec = GRANULARITE_us * 1000;
3235:
3236: while(read_atomic(s_etat_processus, pipe,
3237: &longueur, sizeof(size_t)) != sizeof(size_t))
3238: {
3239: nanosleep(&attente, NULL);
3240: INCR_GRANULARITE(attente.tv_nsec);
3241: }
3242:
3243: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
3244: malloc(longueur * sizeof(unsigned char))) == NULL)
3245: {
3246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3247: return(NULL);
3248: }
3249:
3250: attente.tv_sec = 0;
3251: attente.tv_nsec = GRANULARITE_us * 1000;
3252:
3253: while(read_atomic(s_etat_processus, pipe,
3254: (*((struct_fonction *) (*s_objet).objet))
3255: .nom_fonction, longueur) != (ssize_t) longueur)
3256: {
3257: nanosleep(&attente, NULL);
3258: INCR_GRANULARITE(attente.tv_nsec);
3259: }
3260:
3261: attente.tv_sec = 0;
3262: attente.tv_nsec = GRANULARITE_us * 1000;
3263:
3264: while(read_atomic(s_etat_processus, pipe,
3265: &((*((struct_fonction *) (*s_objet).objet))
3266: .nombre_arguments), sizeof(unsigned long)) !=
3267: sizeof(unsigned long))
3268: {
3269: nanosleep(&attente, NULL);
3270: INCR_GRANULARITE(attente.tv_nsec);
3271: }
3272:
3273: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
3274: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
3275: (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
3276: }
3277: else if ((*s_objet).type == CHN)
3278: {
3279: attente.tv_sec = 0;
3280: attente.tv_nsec = GRANULARITE_us * 1000;
3281:
3282: while(read_atomic(s_etat_processus, pipe,
3283: &longueur, sizeof(size_t)) != sizeof(size_t))
3284: {
3285: nanosleep(&attente, NULL);
3286: INCR_GRANULARITE(attente.tv_nsec);
3287: }
3288:
3289: if (((*s_objet).objet = malloc(longueur *
3290: sizeof(unsigned char))) == NULL)
3291: {
3292: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3293: return(NULL);
3294: }
3295:
3296: attente.tv_sec = 0;
3297: attente.tv_nsec = GRANULARITE_us * 1000;
3298:
3299: while(read_atomic(s_etat_processus, pipe, (unsigned char *)
3300: (*s_objet).objet, longueur) != (ssize_t) longueur)
3301: {
3302: nanosleep(&attente, NULL);
3303: INCR_GRANULARITE(attente.tv_nsec);
3304: }
3305: }
3306: else if (((*s_objet).type == LST) ||
3307: ((*s_objet).type == ALG) ||
3308: ((*s_objet).type == RPN))
3309: {
3310: attente.tv_sec = 0;
3311: attente.tv_nsec = GRANULARITE_us * 1000;
3312:
3313: while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
3314: {
3315: nanosleep(&attente, NULL);
3316: INCR_GRANULARITE(attente.tv_nsec);
3317: }
3318:
3319: l_element_courant = NULL;
3320:
3321: for(i = 0; i < j; i++)
3322: {
3323: if (l_element_courant == NULL)
3324: {
3325: if ((l_element_courant =
3326: malloc(sizeof(struct_liste_chainee))) == NULL)
3327: {
3328: (*s_etat_processus).erreur_systeme =
3329: d_es_allocation_memoire;
3330: return(NULL);
3331: }
3332:
3333: (*s_objet).objet = l_element_courant;
3334: }
3335: else
3336: {
3337: if (((*l_element_courant).suivant =
3338: malloc(sizeof(struct_liste_chainee))) == NULL)
3339: {
3340: (*s_etat_processus).erreur_systeme =
3341: d_es_allocation_memoire;
3342: return(NULL);
3343: }
3344:
3345: l_element_courant = (*l_element_courant).suivant;
3346: (*l_element_courant).suivant = NULL;
3347: }
3348:
3349: attente.tv_sec = 0;
3350: attente.tv_nsec = GRANULARITE_us * 1000;
3351:
3352: while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
3353: pipe)) == NULL)
3354: {
3355: if ((*s_etat_processus).erreur_systeme != d_es)
3356: {
3357: return(NULL);
3358: }
3359:
3360: nanosleep(&attente, NULL);
3361: INCR_GRANULARITE(attente.tv_nsec);
3362: }
3363: }
3364:
3365: if (l_element_courant == NULL)
3366: {
3367: (*s_objet).objet = NULL;
3368: }
3369: else
3370: {
3371: (*l_element_courant).suivant = NULL;
3372: }
3373: }
3374: else if ((*s_objet).type == TBL)
3375: {
3376: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
3377: {
3378: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3379: return(NULL);
3380: }
3381:
3382: attente.tv_sec = 0;
3383: attente.tv_nsec = GRANULARITE_us * 1000;
3384:
3385: while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
3386: (*s_objet).objet)).nombre_elements),
3387: sizeof(unsigned long)) != sizeof(unsigned long))
3388: {
3389: nanosleep(&attente, NULL);
3390: INCR_GRANULARITE(attente.tv_nsec);
3391: }
3392:
3393: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
3394: (*((struct_tableau *) (*s_objet).objet)).nombre_elements *
3395: sizeof(struct_objet *))) == NULL)
3396: {
3397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3398: return(NULL);
3399: }
3400:
3401: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
3402: i++)
3403: {
3404: attente.tv_sec = 0;
3405: attente.tv_nsec = GRANULARITE_us * 1000;
3406:
3407: while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
3408: lecture_pipe(s_etat_processus, pipe)) == NULL)
3409: {
3410: if ((*s_etat_processus).erreur_systeme != d_es)
3411: {
3412: return(NULL);
3413: }
3414:
3415: nanosleep(&attente, NULL);
3416: INCR_GRANULARITE(attente.tv_nsec);
3417: }
3418: }
3419: }
3420:
3421: return(s_objet);
3422: }
3423:
3424:
3425: /*
3426: ================================================================================
3427: Fonction de scrutation des données injectées par le processus père
3428: ================================================================================
3429: Entrées : pointeur sur une structure
3430: --------------------------------------------------------------------------------
3431: Sorties :
3432: --------------------------------------------------------------------------------
3433: Effets de bord : néant
3434: ================================================================================
3435: */
3436:
3437: extern inline void
3438: scrutation_injection(struct_processus *s_etat_processus)
3439: {
3440: fd_set ensemble_descripteurs;
3441:
3442: # ifndef OpenBSD
3443: struct timespec timeout;
3444: # else
3445: struct timeval timeout;
3446: # endif
3447:
3448: unsigned char tampon;
3449:
3450: // Si on est dans le processus père, il n'y a rien à surveiller.
3451:
3452: if ((*s_etat_processus).var_volatile_processus_pere == 0)
3453: {
3454: FD_ZERO(&ensemble_descripteurs);
3455: FD_SET((*s_etat_processus).pipe_nombre_injections,
3456: &ensemble_descripteurs);
3457:
3458: # ifndef OpenBSD
3459: timeout.tv_sec = 0;
3460: timeout.tv_nsec = 0;
3461:
3462: if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
3463: &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
3464: # else
3465: timeout.tv_sec = 0;
3466: timeout.tv_usec = 0;
3467:
3468: if (select((*s_etat_processus).pipe_nombre_injections + 1,
3469: &ensemble_descripteurs, NULL, NULL, &timeout) > 0)
3470: # endif
3471: {
3472: if (read_atomic(s_etat_processus,
3473: (*s_etat_processus).pipe_nombre_injections,
3474: &tampon, sizeof(unsigned char)) == sizeof(unsigned char))
3475: {
3476: if (tampon == '-')
3477: {
3478: (*s_etat_processus).nombre_objets_injectes++;
3479: }
3480: else if (tampon == '+')
3481: {
3482: (*s_etat_processus).nombre_objets_envoyes_non_lus--;
3483:
3484: BUG((*s_etat_processus).nombre_objets_envoyes_non_lus < 0,
3485: printf("(*s_etat_processus).nombre_objets_envoyes_"
3486: "non_lus=%d\n", (*s_etat_processus)
3487: .nombre_objets_envoyes_non_lus));
3488: }
3489: else
3490: {
3491: BUG(1, printf("tampon='%c' (%d)\n", tampon, tampon));
3492: }
3493: }
3494: }
3495: }
3496:
3497: return;
3498: }
3499:
3500:
3501: /*
3502: ================================================================================
3503: Fonction de test du drapeau d'arrêt
3504: ================================================================================
3505: Entrées : pointeur sur une structure
3506: --------------------------------------------------------------------------------
3507: Sorties :
3508: --------------------------------------------------------------------------------
3509: Effets de bord : néant
3510: ================================================================================
3511: */
3512:
3513: inline int test_arret(struct_processus *s_etat_processus)
3514: {
3515: return((int) (*s_etat_processus).var_volatile_requete_arret);
3516: }
3517:
3518: // 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