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