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