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