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