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