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