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