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 ((*s_etat_processus).debug == d_vrai)
1784: if (((*s_etat_processus).type_debug &
1785: d_debug_processus) != 0)
1786: {
1787: if ((*s_argument_thread).processus_detache == d_vrai)
1788: {
1789: if ((*s_etat_processus).langue == 'F')
1790: {
1791: printf("[%d] Arrêt du thread de surveillance du"
1792: " processus %d\n", (int) getpid(),
1793: (int) (*s_argument_thread).pid);
1794: }
1795: else
1796: {
1797: printf("[%d] Stop monitoring of process %d", (int) getpid(),
1798: (int) (*s_argument_thread).pid);
1799: }
1800: }
1801: else
1802: {
1803: if ((*s_etat_processus).langue == 'F')
1804: {
1805: printf("[%d] Arrêt du thread de surveillance du"
1806: " thread %llu\n", (int) getpid(),
1807: (unsigned long long) (*s_argument_thread)
1808: .tid);
1809: }
1810: else
1811: {
1812: printf("[%d] Stop monitoring of thread %llu",
1813: (int) getpid(),
1814: (unsigned long long) (*s_argument_thread)
1815: .tid);
1816: }
1817: }
1818:
1819: fflush(stdout);
1820: }
1821:
1822: retrait_thread_surveillance(s_etat_processus, s_argument_thread);
1823:
1824: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1825: {
1826: (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
1827: }
1828: }
1829:
1830: pthread_exit(NULL);
1831: }
1832:
1833:
1834: /*
1835: ================================================================================
1836: Fonction d'écriture dans un pipe
1837: ================================================================================
1838: Entrées : pointeur sur une structure de description du processus,
1839: numéro du pipe et objet à écrire
1840: --------------------------------------------------------------------------------
1841: Sorties :
1842: --------------------------------------------------------------------------------
1843: Effets de bord : néant
1844: ================================================================================
1845: */
1846:
1847: logical1
1848: ecriture_pipe(struct_processus *s_etat_processus, int pipe,
1849: struct_objet *s_objet)
1850: {
1851: struct_liste_chainee *l_element_courant;
1852:
1853: struct timespec attente;
1854:
1855: unsigned long i;
1856: unsigned long j;
1857:
1858: size_t longueur;
1859: ssize_t longueur_ecriture;
1860:
1861: if ((*s_objet).type == INT)
1862: {
1863: attente.tv_sec = 0;
1864: attente.tv_nsec = GRANULARITE_us * 1000;
1865:
1866: while((longueur_ecriture = write_atomic(s_etat_processus,
1867: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1868: sizeof((*s_objet).type))
1869: {
1870: if (longueur_ecriture == -1)
1871: {
1872: return(d_erreur);
1873: }
1874:
1875: nanosleep(&attente, NULL);
1876: INCR_GRANULARITE(attente.tv_nsec);
1877: }
1878:
1879: attente.tv_sec = 0;
1880: attente.tv_nsec = GRANULARITE_us * 1000;
1881:
1882: while((longueur_ecriture = write_atomic(s_etat_processus,
1883: pipe, (integer8 *)
1884: (*s_objet).objet, sizeof(integer8))) != sizeof(integer8))
1885: {
1886: if (longueur_ecriture == -1)
1887: {
1888: return(d_erreur);
1889: }
1890:
1891: nanosleep(&attente, NULL);
1892: INCR_GRANULARITE(attente.tv_nsec);
1893: }
1894: }
1895: else if ((*s_objet).type == REL)
1896: {
1897: attente.tv_sec = 0;
1898: attente.tv_nsec = GRANULARITE_us * 1000;
1899:
1900: while((longueur_ecriture = write_atomic(s_etat_processus,
1901: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1902: sizeof((*s_objet).type))
1903: {
1904: if (longueur_ecriture == -1)
1905: {
1906: return(d_erreur);
1907: }
1908:
1909: nanosleep(&attente, NULL);
1910: INCR_GRANULARITE(attente.tv_nsec);
1911: }
1912:
1913: attente.tv_sec = 0;
1914: attente.tv_nsec = GRANULARITE_us * 1000;
1915:
1916: while((longueur_ecriture = write_atomic(s_etat_processus,
1917: pipe, (real8 *) (*s_objet).objet, sizeof(real8))) !=
1918: sizeof(real8))
1919: {
1920: if (longueur_ecriture == -1)
1921: {
1922: return(d_erreur);
1923: }
1924:
1925: nanosleep(&attente, NULL);
1926: INCR_GRANULARITE(attente.tv_nsec);
1927: }
1928: }
1929: else if ((*s_objet).type == CPL)
1930: {
1931: attente.tv_sec = 0;
1932: attente.tv_nsec = GRANULARITE_us * 1000;
1933:
1934: while((longueur_ecriture = write_atomic(s_etat_processus,
1935: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1936: sizeof((*s_objet).type))
1937: {
1938: if (longueur_ecriture == -1)
1939: {
1940: return(d_erreur);
1941: }
1942:
1943: nanosleep(&attente, NULL);
1944: INCR_GRANULARITE(attente.tv_nsec);
1945: }
1946:
1947: attente.tv_sec = 0;
1948: attente.tv_nsec = GRANULARITE_us * 1000;
1949:
1950: while((longueur_ecriture = write_atomic(s_etat_processus,
1951: pipe, (real8 *) (*s_objet).objet, sizeof(complex16)))
1952: != sizeof(complex16))
1953: {
1954: if (longueur_ecriture == -1)
1955: {
1956: return(d_erreur);
1957: }
1958:
1959: nanosleep(&attente, NULL);
1960: INCR_GRANULARITE(attente.tv_nsec);
1961: }
1962: }
1963: else if ((*s_objet).type == VIN)
1964: {
1965: attente.tv_sec = 0;
1966: attente.tv_nsec = GRANULARITE_us * 1000;
1967:
1968: while((longueur_ecriture = write_atomic(s_etat_processus,
1969: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
1970: sizeof((*s_objet).type))
1971: {
1972: if (longueur_ecriture == -1)
1973: {
1974: return(d_erreur);
1975: }
1976:
1977: nanosleep(&attente, NULL);
1978: INCR_GRANULARITE(attente.tv_nsec);
1979: }
1980:
1981: attente.tv_sec = 0;
1982: attente.tv_nsec = GRANULARITE_us * 1000;
1983:
1984: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
1985: &((*((struct_vecteur *) (*s_objet).objet))
1986: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
1987: {
1988: if (longueur_ecriture == -1)
1989: {
1990: return(d_erreur);
1991: }
1992:
1993: nanosleep(&attente, NULL);
1994: INCR_GRANULARITE(attente.tv_nsec);
1995: }
1996:
1997: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1998: {
1999: attente.tv_sec = 0;
2000: attente.tv_nsec = GRANULARITE_us * 1000;
2001:
2002: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2003: &(((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
2004: .tableau)[i]), sizeof(integer8))) != sizeof(integer8))
2005: {
2006: if (longueur_ecriture == -1)
2007: {
2008: return(d_erreur);
2009: }
2010:
2011: nanosleep(&attente, NULL);
2012: INCR_GRANULARITE(attente.tv_nsec);
2013: }
2014: }
2015: }
2016: else if ((*s_objet).type == VRL)
2017: {
2018: attente.tv_sec = 0;
2019: attente.tv_nsec = GRANULARITE_us * 1000;
2020:
2021: while((longueur_ecriture = write_atomic(s_etat_processus,
2022: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2023: sizeof((*s_objet).type))
2024: {
2025: if (longueur_ecriture == -1)
2026: {
2027: return(d_erreur);
2028: }
2029:
2030: nanosleep(&attente, NULL);
2031: INCR_GRANULARITE(attente.tv_nsec);
2032: }
2033:
2034: attente.tv_sec = 0;
2035: attente.tv_nsec = GRANULARITE_us * 1000;
2036:
2037: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2038: &((*((struct_vecteur *) (*s_objet).objet))
2039: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2040: {
2041: if (longueur_ecriture == -1)
2042: {
2043: return(d_erreur);
2044: }
2045:
2046: nanosleep(&attente, NULL);
2047: INCR_GRANULARITE(attente.tv_nsec);
2048: }
2049:
2050: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2051: {
2052: attente.tv_sec = 0;
2053: attente.tv_nsec = GRANULARITE_us * 1000;
2054:
2055: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2056: &(((real8 *) (*((struct_vecteur *) (*s_objet).objet))
2057: .tableau)[i]), sizeof(real8))) != sizeof(real8))
2058: {
2059: if (longueur_ecriture == -1)
2060: {
2061: return(d_erreur);
2062: }
2063:
2064: nanosleep(&attente, NULL);
2065: INCR_GRANULARITE(attente.tv_nsec);
2066: }
2067: }
2068: }
2069: else if ((*s_objet).type == VCX)
2070: {
2071: attente.tv_sec = 0;
2072: attente.tv_nsec = GRANULARITE_us * 1000;
2073:
2074: while((longueur_ecriture = write_atomic(s_etat_processus,
2075: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2076: sizeof((*s_objet).type))
2077: {
2078: if (longueur_ecriture == -1)
2079: {
2080: return(d_erreur);
2081: }
2082:
2083: nanosleep(&attente, NULL);
2084: INCR_GRANULARITE(attente.tv_nsec);
2085: }
2086:
2087: attente.tv_sec = 0;
2088: attente.tv_nsec = GRANULARITE_us * 1000;
2089:
2090: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2091: &((*((struct_vecteur *) (*s_objet).objet))
2092: .taille), sizeof(unsigned long))) != sizeof(unsigned long))
2093: {
2094: if (longueur_ecriture == -1)
2095: {
2096: return(d_erreur);
2097: }
2098:
2099: nanosleep(&attente, NULL);
2100: INCR_GRANULARITE(attente.tv_nsec);
2101: }
2102:
2103: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2104: {
2105: attente.tv_sec = 0;
2106: attente.tv_nsec = GRANULARITE_us * 1000;
2107:
2108: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2109: &(((complex16 *) (*((struct_vecteur *) (*s_objet).objet))
2110: .tableau)[i]), sizeof(complex16))) != sizeof(complex16))
2111: {
2112: if (longueur_ecriture == -1)
2113: {
2114: return(d_erreur);
2115: }
2116:
2117: nanosleep(&attente, NULL);
2118: INCR_GRANULARITE(attente.tv_nsec);
2119: }
2120: }
2121: }
2122: else if ((*s_objet).type == MIN)
2123: {
2124: attente.tv_sec = 0;
2125: attente.tv_nsec = GRANULARITE_us * 1000;
2126:
2127: while((longueur_ecriture = write_atomic(s_etat_processus,
2128: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2129: sizeof((*s_objet).type))
2130: {
2131: if (longueur_ecriture == -1)
2132: {
2133: return(d_erreur);
2134: }
2135:
2136: nanosleep(&attente, NULL);
2137: INCR_GRANULARITE(attente.tv_nsec);
2138: }
2139:
2140: attente.tv_sec = 0;
2141: attente.tv_nsec = GRANULARITE_us * 1000;
2142:
2143: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2144: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2145: sizeof(unsigned long))) != sizeof(unsigned long))
2146: {
2147: if (longueur_ecriture == -1)
2148: {
2149: return(d_erreur);
2150: }
2151:
2152: nanosleep(&attente, NULL);
2153: INCR_GRANULARITE(attente.tv_nsec);
2154: }
2155:
2156: attente.tv_sec = 0;
2157: attente.tv_nsec = GRANULARITE_us * 1000;
2158:
2159: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2160: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2161: sizeof(unsigned long))) != sizeof(unsigned long))
2162: {
2163: if (longueur_ecriture == -1)
2164: {
2165: return(d_erreur);
2166: }
2167:
2168: nanosleep(&attente, NULL);
2169: INCR_GRANULARITE(attente.tv_nsec);
2170: }
2171:
2172: for(i = 0; i < (*((struct_matrice *)
2173: (*s_objet).objet)).nombre_lignes; i++)
2174: {
2175: for(j = 0; j < (*((struct_matrice *)
2176: (*s_objet).objet)).nombre_colonnes; j++)
2177: {
2178: attente.tv_sec = 0;
2179: attente.tv_nsec = GRANULARITE_us * 1000;
2180:
2181: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2182: &(((integer8 **) (*((struct_matrice *)
2183: (*s_objet).objet)).tableau)[i][j]),
2184: sizeof(integer8))) != sizeof(integer8))
2185: {
2186: if (longueur_ecriture == -1)
2187: {
2188: return(d_erreur);
2189: }
2190:
2191: nanosleep(&attente, NULL);
2192: INCR_GRANULARITE(attente.tv_nsec);
2193: }
2194: }
2195: }
2196: }
2197: else if ((*s_objet).type == MRL)
2198: {
2199: attente.tv_sec = 0;
2200: attente.tv_nsec = GRANULARITE_us * 1000;
2201:
2202: while((longueur_ecriture = write_atomic(s_etat_processus,
2203: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2204: sizeof((*s_objet).type))
2205: {
2206: if (longueur_ecriture == -1)
2207: {
2208: return(d_erreur);
2209: }
2210:
2211: nanosleep(&attente, NULL);
2212: INCR_GRANULARITE(attente.tv_nsec);
2213: }
2214:
2215: attente.tv_sec = 0;
2216: attente.tv_nsec = GRANULARITE_us * 1000;
2217:
2218: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2219: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2220: sizeof(unsigned long))) != sizeof(unsigned long))
2221: {
2222: if (longueur_ecriture == -1)
2223: {
2224: return(d_erreur);
2225: }
2226:
2227: nanosleep(&attente, NULL);
2228: INCR_GRANULARITE(attente.tv_nsec);
2229: }
2230:
2231: attente.tv_sec = 0;
2232: attente.tv_nsec = GRANULARITE_us * 1000;
2233:
2234: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2235: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2236: sizeof(unsigned long))) != sizeof(unsigned long))
2237: {
2238: if (longueur_ecriture == -1)
2239: {
2240: return(d_erreur);
2241: }
2242:
2243: nanosleep(&attente, NULL);
2244: INCR_GRANULARITE(attente.tv_nsec);
2245: }
2246:
2247: for(i = 0; i < (*((struct_matrice *)
2248: (*s_objet).objet)).nombre_lignes; i++)
2249: {
2250: for(j = 0; j < (*((struct_matrice *)
2251: (*s_objet).objet)).nombre_colonnes; j++)
2252: {
2253: attente.tv_sec = 0;
2254: attente.tv_nsec = GRANULARITE_us * 1000;
2255:
2256: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2257: &(((real8 **) (*((struct_matrice *)
2258: (*s_objet).objet)).tableau)[i][j]),
2259: sizeof(real8))) != sizeof(real8))
2260: {
2261: if (longueur_ecriture == -1)
2262: {
2263: return(d_erreur);
2264: }
2265:
2266: nanosleep(&attente, NULL);
2267: INCR_GRANULARITE(attente.tv_nsec);
2268: }
2269: }
2270: }
2271: }
2272: else if ((*s_objet).type == MCX)
2273: {
2274: attente.tv_sec = 0;
2275: attente.tv_nsec = GRANULARITE_us * 1000;
2276:
2277: while((longueur_ecriture = write_atomic(s_etat_processus,
2278: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2279: sizeof((*s_objet).type))
2280: {
2281: if (longueur_ecriture == -1)
2282: {
2283: return(d_erreur);
2284: }
2285:
2286: nanosleep(&attente, NULL);
2287: INCR_GRANULARITE(attente.tv_nsec);
2288: }
2289:
2290: attente.tv_sec = 0;
2291: attente.tv_nsec = GRANULARITE_us * 1000;
2292:
2293: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2294: &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
2295: sizeof(unsigned long))) != sizeof(unsigned long))
2296: {
2297: if (longueur_ecriture == -1)
2298: {
2299: return(d_erreur);
2300: }
2301:
2302: nanosleep(&attente, NULL);
2303: INCR_GRANULARITE(attente.tv_nsec);
2304: }
2305:
2306: attente.tv_sec = 0;
2307: attente.tv_nsec = GRANULARITE_us * 1000;
2308:
2309: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2310: &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
2311: sizeof(unsigned long))) != sizeof(unsigned long))
2312: {
2313: if (longueur_ecriture == -1)
2314: {
2315: return(d_erreur);
2316: }
2317:
2318: nanosleep(&attente, NULL);
2319: INCR_GRANULARITE(attente.tv_nsec);
2320: }
2321:
2322: for(i = 0; i < (*((struct_matrice *)
2323: (*s_objet).objet)).nombre_lignes; i++)
2324: {
2325: for(j = 0; j < (*((struct_matrice *)
2326: (*s_objet).objet)).nombre_colonnes; j++)
2327: {
2328: attente.tv_sec = 0;
2329: attente.tv_nsec = GRANULARITE_us * 1000;
2330:
2331: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2332: &(((complex16 **) (*((struct_matrice *)
2333: (*s_objet).objet)).tableau)[i][j]),
2334: sizeof(complex16))) != sizeof(complex16))
2335: {
2336: if (longueur_ecriture == -1)
2337: {
2338: return(d_erreur);
2339: }
2340:
2341: nanosleep(&attente, NULL);
2342: INCR_GRANULARITE(attente.tv_nsec);
2343: }
2344: }
2345: }
2346: }
2347: else if ((*s_objet).type == BIN)
2348: {
2349: attente.tv_sec = 0;
2350: attente.tv_nsec = GRANULARITE_us * 1000;
2351:
2352: while((longueur_ecriture = write_atomic(s_etat_processus,
2353: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2354: sizeof((*s_objet).type))
2355: {
2356: if (longueur_ecriture == -1)
2357: {
2358: return(d_erreur);
2359: }
2360:
2361: nanosleep(&attente, NULL);
2362: INCR_GRANULARITE(attente.tv_nsec);
2363: }
2364:
2365: attente.tv_sec = 0;
2366: attente.tv_nsec = GRANULARITE_us * 1000;
2367:
2368: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2369: (integer8 *) (*s_objet).objet,
2370: sizeof(integer8))) != sizeof(integer8))
2371: {
2372: if (longueur_ecriture == -1)
2373: {
2374: return(d_erreur);
2375: }
2376:
2377: nanosleep(&attente, NULL);
2378: INCR_GRANULARITE(attente.tv_nsec);
2379: }
2380: }
2381: else if ((*s_objet).type == NOM)
2382: {
2383: attente.tv_sec = 0;
2384: attente.tv_nsec = GRANULARITE_us * 1000;
2385:
2386: while((longueur_ecriture = write_atomic(s_etat_processus,
2387: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2388: sizeof((*s_objet).type))
2389: {
2390: if (longueur_ecriture == -1)
2391: {
2392: return(d_erreur);
2393: }
2394:
2395: nanosleep(&attente, NULL);
2396: INCR_GRANULARITE(attente.tv_nsec);
2397: }
2398:
2399: longueur = strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1;
2400:
2401: attente.tv_sec = 0;
2402: attente.tv_nsec = GRANULARITE_us * 1000;
2403:
2404: while((longueur_ecriture = write_atomic(s_etat_processus,
2405: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2406: {
2407: if (longueur_ecriture == -1)
2408: {
2409: return(d_erreur);
2410: }
2411:
2412: nanosleep(&attente, NULL);
2413: INCR_GRANULARITE(attente.tv_nsec);
2414: }
2415:
2416: attente.tv_sec = 0;
2417: attente.tv_nsec = GRANULARITE_us * 1000;
2418:
2419: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2420: (*((struct_nom *) (*s_objet).objet)).nom,
2421: longueur)) != (ssize_t) longueur)
2422: {
2423: if (longueur_ecriture == -1)
2424: {
2425: return(d_erreur);
2426: }
2427:
2428: nanosleep(&attente, NULL);
2429: INCR_GRANULARITE(attente.tv_nsec);
2430: }
2431:
2432: attente.tv_sec = 0;
2433: attente.tv_nsec = GRANULARITE_us * 1000;
2434:
2435: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2436: &((*((struct_nom *) (*s_objet).objet))
2437: .symbole), sizeof(logical1))) != sizeof(logical1))
2438: {
2439: if (longueur_ecriture == -1)
2440: {
2441: return(d_erreur);
2442: }
2443:
2444: nanosleep(&attente, NULL);
2445: INCR_GRANULARITE(attente.tv_nsec);
2446: }
2447: }
2448: else if ((*s_objet).type == FCT)
2449: {
2450: attente.tv_sec = 0;
2451: attente.tv_nsec = GRANULARITE_us * 1000;
2452:
2453: while((longueur_ecriture = write_atomic(s_etat_processus,
2454: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2455: sizeof((*s_objet).type))
2456: {
2457: if (longueur_ecriture == -1)
2458: {
2459: return(d_erreur);
2460: }
2461:
2462: nanosleep(&attente, NULL);
2463: INCR_GRANULARITE(attente.tv_nsec);
2464: }
2465:
2466: longueur = strlen((*((struct_fonction *)
2467: (*s_objet).objet)).nom_fonction) + 1;
2468:
2469: attente.tv_sec = 0;
2470: attente.tv_nsec = GRANULARITE_us * 1000;
2471:
2472: while((longueur_ecriture = write_atomic(s_etat_processus,
2473: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2474: {
2475: if (longueur_ecriture == -1)
2476: {
2477: return(d_erreur);
2478: }
2479:
2480: nanosleep(&attente, NULL);
2481: INCR_GRANULARITE(attente.tv_nsec);
2482: }
2483:
2484: attente.tv_sec = 0;
2485: attente.tv_nsec = GRANULARITE_us * 1000;
2486:
2487: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2488: (*((struct_fonction *) (*s_objet).objet))
2489: .nom_fonction, longueur)) != (ssize_t) longueur)
2490: {
2491: if (longueur_ecriture == -1)
2492: {
2493: return(d_erreur);
2494: }
2495:
2496: nanosleep(&attente, NULL);
2497: INCR_GRANULARITE(attente.tv_nsec);
2498: }
2499:
2500: attente.tv_sec = 0;
2501: attente.tv_nsec = GRANULARITE_us * 1000;
2502:
2503: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2504: &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
2505: sizeof(unsigned long))) != sizeof(unsigned long))
2506: {
2507: if (longueur_ecriture == -1)
2508: {
2509: return(d_erreur);
2510: }
2511:
2512: nanosleep(&attente, NULL);
2513: INCR_GRANULARITE(attente.tv_nsec);
2514: }
2515: }
2516: else if ((*s_objet).type == CHN)
2517: {
2518: attente.tv_sec = 0;
2519: attente.tv_nsec = GRANULARITE_us * 1000;
2520:
2521: while((longueur_ecriture = write_atomic(s_etat_processus,
2522: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2523: sizeof((*s_objet).type))
2524: {
2525: if (longueur_ecriture == -1)
2526: {
2527: return(d_erreur);
2528: }
2529:
2530: nanosleep(&attente, NULL);
2531: INCR_GRANULARITE(attente.tv_nsec);
2532: }
2533:
2534: longueur = strlen((unsigned char *) (*s_objet).objet) + 1;
2535:
2536: attente.tv_sec = 0;
2537: attente.tv_nsec = GRANULARITE_us * 1000;
2538:
2539: while((longueur_ecriture = write_atomic(s_etat_processus,
2540: pipe, &longueur, sizeof(size_t))) != sizeof(size_t))
2541: {
2542: if (longueur_ecriture == -1)
2543: {
2544: return(d_erreur);
2545: }
2546:
2547: nanosleep(&attente, NULL);
2548: INCR_GRANULARITE(attente.tv_nsec);
2549: }
2550:
2551: attente.tv_sec = 0;
2552: attente.tv_nsec = GRANULARITE_us * 1000;
2553:
2554: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2555: (unsigned char *) (*s_objet).objet,
2556: longueur)) != (ssize_t) longueur)
2557: {
2558: if (longueur_ecriture == -1)
2559: {
2560: return(d_erreur);
2561: }
2562:
2563: nanosleep(&attente, NULL);
2564: INCR_GRANULARITE(attente.tv_nsec);
2565: }
2566: }
2567: else if (((*s_objet).type == LST) ||
2568: ((*s_objet).type == ALG) ||
2569: ((*s_objet).type == RPN))
2570: {
2571: attente.tv_sec = 0;
2572: attente.tv_nsec = GRANULARITE_us * 1000;
2573:
2574: while((longueur_ecriture = write_atomic(s_etat_processus,
2575: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2576: sizeof((*s_objet).type))
2577: {
2578: if (longueur_ecriture == -1)
2579: {
2580: return(d_erreur);
2581: }
2582:
2583: nanosleep(&attente, NULL);
2584: INCR_GRANULARITE(attente.tv_nsec);
2585: }
2586:
2587: l_element_courant = (*s_objet).objet;
2588: i = 0;
2589:
2590: while(l_element_courant != NULL)
2591: {
2592: i++;
2593: l_element_courant = (*l_element_courant).suivant;
2594: }
2595:
2596: attente.tv_sec = 0;
2597: attente.tv_nsec = GRANULARITE_us * 1000;
2598:
2599: while((longueur_ecriture = write_atomic(s_etat_processus,
2600: pipe, &i, sizeof(i))) != sizeof(i))
2601: {
2602: if (longueur_ecriture == -1)
2603: {
2604: return(d_erreur);
2605: }
2606:
2607: nanosleep(&attente, NULL);
2608: INCR_GRANULARITE(attente.tv_nsec);
2609: }
2610:
2611: l_element_courant = (*s_objet).objet;
2612:
2613: while(l_element_courant != NULL)
2614: {
2615: if (ecriture_pipe(s_etat_processus, pipe,
2616: (*l_element_courant).donnee) == d_erreur)
2617: {
2618: return(d_erreur);
2619: }
2620:
2621: l_element_courant = (*l_element_courant).suivant;
2622: }
2623: }
2624: else if ((*s_objet).type == TBL)
2625: {
2626: attente.tv_sec = 0;
2627: attente.tv_nsec = GRANULARITE_us * 1000;
2628:
2629: while((longueur_ecriture = write_atomic(s_etat_processus,
2630: pipe, &((*s_objet).type), sizeof((*s_objet).type))) !=
2631: sizeof((*s_objet).type))
2632: {
2633: if (longueur_ecriture == -1)
2634: {
2635: return(d_erreur);
2636: }
2637:
2638: nanosleep(&attente, NULL);
2639: INCR_GRANULARITE(attente.tv_nsec);
2640: }
2641:
2642: attente.tv_sec = 0;
2643: attente.tv_nsec = GRANULARITE_us * 1000;
2644:
2645: while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
2646: &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
2647: sizeof(unsigned long))) != sizeof(unsigned long))
2648: {
2649: if (longueur_ecriture == -1)
2650: {
2651: return(d_erreur);
2652: }
2653:
2654: nanosleep(&attente, NULL);
2655: INCR_GRANULARITE(attente.tv_nsec);
2656: }
2657:
2658: for(i = 0; i < (*((struct_tableau *)
2659: (*s_objet).objet)).nombre_elements; i++)
2660: {
2661: if (ecriture_pipe(s_etat_processus, pipe,
2662: (*((struct_tableau *) (*s_objet).objet)).elements[i])
2663: == d_erreur)
2664: {
2665: return(d_erreur);
2666: }
2667: }
2668: }
2669: else
2670: {
2671: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2672: return(d_erreur);
2673: }
2674:
2675: return(d_absence_erreur);
2676: }
2677:
2678:
2679: /*
2680: ================================================================================
2681: Fonction de lecture dans un pipe
2682: ================================================================================
2683: Entrées : pointeur sur une structure de description du processus,
2684: numéro du pipe et objet à écrire
2685: --------------------------------------------------------------------------------
2686: Sorties :
2687: --------------------------------------------------------------------------------
2688: Effets de bord : néant
2689: ================================================================================
2690: */
2691:
2692: struct_objet *
2693: lecture_pipe(struct_processus *s_etat_processus, int pipe)
2694: {
2695: size_t longueur;
2696:
2697: struct_liste_chainee *l_element_courant;
2698:
2699: struct_objet *s_objet;
2700:
2701: struct timespec attente;
2702:
2703: unsigned long i;
2704: unsigned long j;
2705:
2706: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
2707: {
2708: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2709: return(NULL);
2710: }
2711:
2712: attente.tv_sec = 0;
2713: attente.tv_nsec = GRANULARITE_us * 1000;
2714:
2715: while(read_atomic(s_etat_processus, pipe, &((*s_objet).type),
2716: sizeof((*s_objet).type)) != sizeof((*s_objet).type))
2717: {
2718: nanosleep(&attente, NULL);
2719: INCR_GRANULARITE(attente.tv_nsec);
2720: }
2721:
2722: if ((*s_objet).type == INT)
2723: {
2724: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
2725: {
2726: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2727: return(NULL);
2728: }
2729:
2730: attente.tv_sec = 0;
2731: attente.tv_nsec = GRANULARITE_us * 1000;
2732:
2733: while(read_atomic(s_etat_processus, pipe,
2734: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
2735: {
2736: nanosleep(&attente, NULL);
2737: INCR_GRANULARITE(attente.tv_nsec);
2738: }
2739: }
2740: else if ((*s_objet).type == REL)
2741: {
2742: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
2743: {
2744: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2745: return(NULL);
2746: }
2747:
2748: attente.tv_sec = 0;
2749: attente.tv_nsec = GRANULARITE_us * 1000;
2750:
2751: while(read_atomic(s_etat_processus, pipe,
2752: (*s_objet).objet, sizeof(real8)) != sizeof(real8))
2753: {
2754: nanosleep(&attente, NULL);
2755: INCR_GRANULARITE(attente.tv_nsec);
2756: }
2757: }
2758: else if ((*s_objet).type == CPL)
2759: {
2760: if (((*s_objet).objet = malloc(sizeof(complex16))) == NULL)
2761: {
2762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2763: return(NULL);
2764: }
2765:
2766: attente.tv_sec = 0;
2767: attente.tv_nsec = GRANULARITE_us * 1000;
2768:
2769: while(read_atomic(s_etat_processus, pipe,
2770: (*s_objet).objet, sizeof(complex16)) != sizeof(complex16))
2771: {
2772: nanosleep(&attente, NULL);
2773: INCR_GRANULARITE(attente.tv_nsec);
2774: }
2775: }
2776: else if ((*s_objet).type == VIN)
2777: {
2778: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2779: {
2780: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2781: return(NULL);
2782: }
2783:
2784: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
2785:
2786: attente.tv_sec = 0;
2787: attente.tv_nsec = GRANULARITE_us * 1000;
2788:
2789: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2790: (*s_objet).objet)).taille),
2791: sizeof(unsigned long)) != sizeof(unsigned long))
2792: {
2793: nanosleep(&attente, NULL);
2794: INCR_GRANULARITE(attente.tv_nsec);
2795: }
2796:
2797: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2798: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2799: sizeof(integer8))) == NULL)
2800: {
2801: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2802: return(NULL);
2803: }
2804:
2805: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2806: {
2807: attente.tv_sec = 0;
2808: attente.tv_nsec = GRANULARITE_us * 1000;
2809:
2810: while(read_atomic(s_etat_processus, pipe,
2811: &(((integer8 *) (*((struct_vecteur *)
2812: (*s_objet).objet)).tableau)[i]), sizeof(integer8)) !=
2813: sizeof(integer8))
2814: {
2815: nanosleep(&attente, NULL);
2816: INCR_GRANULARITE(attente.tv_nsec);
2817: }
2818: }
2819: }
2820: else if ((*s_objet).type == VRL)
2821: {
2822: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2823: {
2824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2825: return(NULL);
2826: }
2827:
2828: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
2829:
2830: attente.tv_sec = 0;
2831: attente.tv_nsec = GRANULARITE_us * 1000;
2832:
2833: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2834: (*s_objet).objet)).taille),
2835: sizeof(unsigned long)) != sizeof(unsigned long))
2836: {
2837: nanosleep(&attente, NULL);
2838: INCR_GRANULARITE(attente.tv_nsec);
2839: }
2840:
2841: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2842: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2843: sizeof(real8))) == NULL)
2844: {
2845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2846: return(NULL);
2847: }
2848:
2849: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2850: {
2851: attente.tv_sec = 0;
2852: attente.tv_nsec = GRANULARITE_us * 1000;
2853:
2854: while(read_atomic(s_etat_processus, pipe,
2855: &(((real8 *) (*((struct_vecteur *)
2856: (*s_objet).objet)).tableau)[i]), sizeof(real8)) !=
2857: sizeof(real8))
2858: {
2859: nanosleep(&attente, NULL);
2860: INCR_GRANULARITE(attente.tv_nsec);
2861: }
2862: }
2863: }
2864: else if ((*s_objet).type == VCX)
2865: {
2866: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
2867: {
2868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2869: return(NULL);
2870: }
2871:
2872: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
2873:
2874: attente.tv_sec = 0;
2875: attente.tv_nsec = GRANULARITE_us * 1000;
2876:
2877: while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
2878: (*s_objet).objet)).taille),
2879: sizeof(unsigned long)) != sizeof(unsigned long))
2880: {
2881: nanosleep(&attente, NULL);
2882: INCR_GRANULARITE(attente.tv_nsec);
2883: }
2884:
2885: if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
2886: malloc((*((struct_vecteur *) (*s_objet).objet)).taille *
2887: sizeof(complex16))) == NULL)
2888: {
2889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2890: return(NULL);
2891: }
2892:
2893: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
2894: {
2895: attente.tv_sec = 0;
2896: attente.tv_nsec = GRANULARITE_us * 1000;
2897:
2898: while(read_atomic(s_etat_processus, pipe,
2899: &(((complex16 *) (*((struct_vecteur *)
2900: (*s_objet).objet)).tableau)[i]), sizeof(complex16)) !=
2901: sizeof(complex16))
2902: {
2903: nanosleep(&attente, NULL);
2904: INCR_GRANULARITE(attente.tv_nsec);
2905: }
2906: }
2907: }
2908: else if ((*s_objet).type == MIN)
2909: {
2910: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2911: {
2912: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2913: return(NULL);
2914: }
2915:
2916: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
2917:
2918: attente.tv_sec = 0;
2919: attente.tv_nsec = GRANULARITE_us * 1000;
2920:
2921: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2922: (*s_objet).objet)).nombre_lignes),
2923: sizeof(unsigned long)) != sizeof(unsigned long))
2924: {
2925: nanosleep(&attente, NULL);
2926: INCR_GRANULARITE(attente.tv_nsec);
2927: }
2928:
2929: attente.tv_sec = 0;
2930: attente.tv_nsec = GRANULARITE_us * 1000;
2931:
2932: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2933: (*s_objet).objet)).nombre_colonnes),
2934: sizeof(unsigned long)) != sizeof(unsigned long))
2935: {
2936: nanosleep(&attente, NULL);
2937: INCR_GRANULARITE(attente.tv_nsec);
2938: }
2939:
2940: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
2941: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
2942: sizeof(integer8 *))) == NULL)
2943: {
2944: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2945: return(NULL);
2946: }
2947:
2948: for(i = 0; i < (*((struct_matrice *)
2949: (*s_objet).objet)).nombre_lignes; i++)
2950: {
2951: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
2952: malloc((*((struct_matrice *) (*s_objet).objet))
2953: .nombre_colonnes * sizeof(integer8))) == NULL)
2954: {
2955: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2956: return(NULL);
2957: }
2958:
2959: for(j = 0; j < (*((struct_matrice *)
2960: (*s_objet).objet)).nombre_colonnes; j++)
2961: {
2962: attente.tv_sec = 0;
2963: attente.tv_nsec = GRANULARITE_us * 1000;
2964:
2965: while(read_atomic(s_etat_processus,
2966: pipe, &(((integer8 **) (*((struct_matrice *)
2967: (*s_objet).objet)).tableau)[i][j]),
2968: sizeof(integer8)) != sizeof(integer8))
2969: {
2970: nanosleep(&attente, NULL);
2971: INCR_GRANULARITE(attente.tv_nsec);
2972: }
2973: }
2974: }
2975: }
2976: else if ((*s_objet).type == MRL)
2977: {
2978: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
2979: {
2980: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2981: return(NULL);
2982: }
2983:
2984: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
2985:
2986: attente.tv_sec = 0;
2987: attente.tv_nsec = GRANULARITE_us * 1000;
2988:
2989: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
2990: (*s_objet).objet)).nombre_lignes),
2991: sizeof(unsigned long)) != sizeof(unsigned long))
2992: {
2993: nanosleep(&attente, NULL);
2994: INCR_GRANULARITE(attente.tv_nsec);
2995: }
2996:
2997: attente.tv_sec = 0;
2998: attente.tv_nsec = GRANULARITE_us * 1000;
2999:
3000: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3001: (*s_objet).objet)).nombre_colonnes),
3002: sizeof(unsigned long)) != sizeof(unsigned long))
3003: {
3004: nanosleep(&attente, NULL);
3005: INCR_GRANULARITE(attente.tv_nsec);
3006: }
3007:
3008: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3009: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3010: sizeof(real8 *))) == NULL)
3011: {
3012: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3013: return(NULL);
3014: }
3015:
3016: for(i = 0; i < (*((struct_matrice *)
3017: (*s_objet).objet)).nombre_lignes; i++)
3018: {
3019: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3020: malloc((*((struct_matrice *) (*s_objet).objet))
3021: .nombre_colonnes * sizeof(real8))) == NULL)
3022: {
3023: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3024: return(NULL);
3025: }
3026:
3027: for(j = 0; j < (*((struct_matrice *)
3028: (*s_objet).objet)).nombre_colonnes; j++)
3029: {
3030: attente.tv_sec = 0;
3031: attente.tv_nsec = GRANULARITE_us * 1000;
3032:
3033: while(read_atomic(s_etat_processus,
3034: pipe, &(((real8 **) (*((struct_matrice *)
3035: (*s_objet).objet)).tableau)[i][j]),
3036: sizeof(real8)) != sizeof(real8))
3037: {
3038: nanosleep(&attente, NULL);
3039: INCR_GRANULARITE(attente.tv_nsec);
3040: }
3041: }
3042: }
3043: }
3044: else if ((*s_objet).type == MCX)
3045: {
3046: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
3047: {
3048: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3049: return(NULL);
3050: }
3051:
3052: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
3053:
3054: attente.tv_sec = 0;
3055: attente.tv_nsec = GRANULARITE_us * 1000;
3056:
3057: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3058: (*s_objet).objet)).nombre_lignes),
3059: sizeof(unsigned long)) != sizeof(unsigned long))
3060: {
3061: nanosleep(&attente, NULL);
3062: INCR_GRANULARITE(attente.tv_nsec);
3063: }
3064:
3065: attente.tv_sec = 0;
3066: attente.tv_nsec = GRANULARITE_us * 1000;
3067:
3068: while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
3069: (*s_objet).objet)).nombre_colonnes),
3070: sizeof(unsigned long)) != sizeof(unsigned long))
3071: {
3072: nanosleep(&attente, NULL);
3073: INCR_GRANULARITE(attente.tv_nsec);
3074: }
3075:
3076: if (((*((struct_matrice *) (*s_objet).objet)).tableau =
3077: malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
3078: sizeof(complex16 *))) == NULL)
3079: {
3080: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3081: return(NULL);
3082: }
3083:
3084: for(i = 0; i < (*((struct_matrice *)
3085: (*s_objet).objet)).nombre_lignes; i++)
3086: {
3087: if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] =
3088: malloc((*((struct_matrice *) (*s_objet).objet))
3089: .nombre_colonnes * sizeof(complex16))) == NULL)
3090: {
3091: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3092: return(NULL);
3093: }
3094:
3095: for(j = 0; j < (*((struct_matrice *)
3096: (*s_objet).objet)).nombre_colonnes; j++)
3097: {
3098: attente.tv_sec = 0;
3099: attente.tv_nsec = GRANULARITE_us * 1000;
3100:
3101: while(read_atomic(s_etat_processus, pipe,
3102: &(((complex16 **) (*((struct_matrice *)
3103: (*s_objet).objet)).tableau)[i][j]),
3104: sizeof(complex16)) != sizeof(complex16))
3105: {
3106: nanosleep(&attente, NULL);
3107: INCR_GRANULARITE(attente.tv_nsec);
3108: }
3109: }
3110: }
3111: }
3112: else if ((*s_objet).type == BIN)
3113: {
3114: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
3115: {
3116: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3117: return(NULL);
3118: }
3119:
3120: attente.tv_sec = 0;
3121: attente.tv_nsec = GRANULARITE_us * 1000;
3122:
3123: while(read_atomic(s_etat_processus, pipe,
3124: (*s_objet).objet, sizeof(integer8)) != sizeof(integer8))
3125: {
3126: nanosleep(&attente, NULL);
3127: INCR_GRANULARITE(attente.tv_nsec);
3128: }
3129: }
3130: else if ((*s_objet).type == NOM)
3131: {
3132: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
3133: {
3134: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3135: return(NULL);
3136: }
3137:
3138: attente.tv_sec = 0;
3139: attente.tv_nsec = GRANULARITE_us * 1000;
3140:
3141: while(read_atomic(s_etat_processus,
3142: pipe, &longueur, sizeof(size_t)) != sizeof(size_t))
3143: {
3144: nanosleep(&attente, NULL);
3145: INCR_GRANULARITE(attente.tv_nsec);
3146: }
3147:
3148: if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(longueur *
3149: sizeof(unsigned char))) == NULL)
3150: {
3151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3152: return(NULL);
3153: }
3154:
3155: attente.tv_sec = 0;
3156: attente.tv_nsec = GRANULARITE_us * 1000;
3157:
3158: while(read_atomic(s_etat_processus, pipe, (*((struct_nom *)
3159: (*s_objet).objet)).nom, longueur) != (ssize_t) longueur)
3160: {
3161: nanosleep(&attente, NULL);
3162: INCR_GRANULARITE(attente.tv_nsec);
3163: }
3164:
3165: attente.tv_sec = 0;
3166: attente.tv_nsec = GRANULARITE_us * 1000;
3167:
3168: while(read_atomic(s_etat_processus, pipe,
3169: &((*((struct_nom *) (*s_objet).objet)).symbole),
3170: sizeof(logical1)) != sizeof(logical1))
3171: {
3172: nanosleep(&attente, NULL);
3173: INCR_GRANULARITE(attente.tv_nsec);
3174: }
3175: }
3176: else if ((*s_objet).type == FCT)
3177: {
3178: if (((*s_objet).objet = allocation(s_etat_processus, FCT)) == NULL)
3179: {
3180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3181: return(NULL);
3182: }
3183:
3184: attente.tv_sec = 0;
3185: attente.tv_nsec = GRANULARITE_us * 1000;
3186:
3187: while(read_atomic(s_etat_processus, pipe,
3188: &longueur, sizeof(size_t)) != sizeof(size_t))
3189: {
3190: nanosleep(&attente, NULL);
3191: INCR_GRANULARITE(attente.tv_nsec);
3192: }
3193:
3194: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
3195: malloc(longueur * sizeof(unsigned char))) == NULL)
3196: {
3197: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3198: return(NULL);
3199: }
3200:
3201: attente.tv_sec = 0;
3202: attente.tv_nsec = GRANULARITE_us * 1000;
3203:
3204: while(read_atomic(s_etat_processus, pipe,
3205: (*((struct_fonction *) (*s_objet).objet))
3206: .nom_fonction, longueur) != (ssize_t) longueur)
3207: {
3208: nanosleep(&attente, NULL);
3209: INCR_GRANULARITE(attente.tv_nsec);
3210: }
3211:
3212: attente.tv_sec = 0;
3213: attente.tv_nsec = GRANULARITE_us * 1000;
3214:
3215: while(read_atomic(s_etat_processus, pipe,
3216: &((*((struct_fonction *) (*s_objet).objet))
3217: .nombre_arguments), sizeof(unsigned long)) !=
3218: sizeof(unsigned long))
3219: {
3220: nanosleep(&attente, NULL);
3221: INCR_GRANULARITE(attente.tv_nsec);
3222: }
3223:
3224: (*((struct_fonction *) (*s_objet).objet)).fonction = NULL;
3225: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
3226: (*((struct_fonction *) (*s_objet).objet)).prediction_execution = d_faux;
3227: }
3228: else if ((*s_objet).type == CHN)
3229: {
3230: attente.tv_sec = 0;
3231: attente.tv_nsec = GRANULARITE_us * 1000;
3232:
3233: while(read_atomic(s_etat_processus, pipe,
3234: &longueur, sizeof(size_t)) != sizeof(size_t))
3235: {
3236: nanosleep(&attente, NULL);
3237: INCR_GRANULARITE(attente.tv_nsec);
3238: }
3239:
3240: if (((*s_objet).objet = malloc(longueur *
3241: sizeof(unsigned char))) == NULL)
3242: {
3243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3244: return(NULL);
3245: }
3246:
3247: attente.tv_sec = 0;
3248: attente.tv_nsec = GRANULARITE_us * 1000;
3249:
3250: while(read_atomic(s_etat_processus, pipe, (unsigned char *)
3251: (*s_objet).objet, longueur) != (ssize_t) longueur)
3252: {
3253: nanosleep(&attente, NULL);
3254: INCR_GRANULARITE(attente.tv_nsec);
3255: }
3256: }
3257: else if (((*s_objet).type == LST) ||
3258: ((*s_objet).type == ALG) ||
3259: ((*s_objet).type == RPN))
3260: {
3261: attente.tv_sec = 0;
3262: attente.tv_nsec = GRANULARITE_us * 1000;
3263:
3264: while(read_atomic(s_etat_processus, pipe, &j, sizeof(j)) != sizeof(j))
3265: {
3266: nanosleep(&attente, NULL);
3267: INCR_GRANULARITE(attente.tv_nsec);
3268: }
3269:
3270: l_element_courant = NULL;
3271:
3272: for(i = 0; i < j; i++)
3273: {
3274: if (l_element_courant == NULL)
3275: {
3276: if ((l_element_courant =
3277: malloc(sizeof(struct_liste_chainee))) == NULL)
3278: {
3279: (*s_etat_processus).erreur_systeme =
3280: d_es_allocation_memoire;
3281: return(NULL);
3282: }
3283:
3284: (*s_objet).objet = l_element_courant;
3285: }
3286: else
3287: {
3288: if (((*l_element_courant).suivant =
3289: malloc(sizeof(struct_liste_chainee))) == NULL)
3290: {
3291: (*s_etat_processus).erreur_systeme =
3292: d_es_allocation_memoire;
3293: return(NULL);
3294: }
3295:
3296: l_element_courant = (*l_element_courant).suivant;
3297: (*l_element_courant).suivant = NULL;
3298: }
3299:
3300: attente.tv_sec = 0;
3301: attente.tv_nsec = GRANULARITE_us * 1000;
3302:
3303: while(((*l_element_courant).donnee = lecture_pipe(s_etat_processus,
3304: pipe)) == NULL)
3305: {
3306: if ((*s_etat_processus).erreur_systeme != d_es)
3307: {
3308: return(NULL);
3309: }
3310:
3311: nanosleep(&attente, NULL);
3312: INCR_GRANULARITE(attente.tv_nsec);
3313: }
3314: }
3315:
3316: if (l_element_courant == NULL)
3317: {
3318: (*s_objet).objet = NULL;
3319: }
3320: else
3321: {
3322: (*l_element_courant).suivant = NULL;
3323: }
3324: }
3325: else if ((*s_objet).type == TBL)
3326: {
3327: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
3328: {
3329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3330: return(NULL);
3331: }
3332:
3333: attente.tv_sec = 0;
3334: attente.tv_nsec = GRANULARITE_us * 1000;
3335:
3336: while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
3337: (*s_objet).objet)).nombre_elements),
3338: sizeof(unsigned long)) != sizeof(unsigned long))
3339: {
3340: nanosleep(&attente, NULL);
3341: INCR_GRANULARITE(attente.tv_nsec);
3342: }
3343:
3344: if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
3345: (*((struct_tableau *) (*s_objet).objet)).nombre_elements *
3346: sizeof(struct_objet *))) == NULL)
3347: {
3348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3349: return(NULL);
3350: }
3351:
3352: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)).nombre_elements;
3353: i++)
3354: {
3355: attente.tv_sec = 0;
3356: attente.tv_nsec = GRANULARITE_us * 1000;
3357:
3358: while(((*((struct_tableau *) (*s_objet).objet)).elements[i] =
3359: lecture_pipe(s_etat_processus, pipe)) == NULL)
3360: {
3361: if ((*s_etat_processus).erreur_systeme != d_es)
3362: {
3363: return(NULL);
3364: }
3365:
3366: nanosleep(&attente, NULL);
3367: INCR_GRANULARITE(attente.tv_nsec);
3368: }
3369: }
3370: }
3371:
3372: return(s_objet);
3373: }
3374:
3375:
3376: /*
3377: ================================================================================
3378: Fonction de scrutation des données injectées par le processus père
3379: ================================================================================
3380: Entrées : pointeur sur une structure
3381: --------------------------------------------------------------------------------
3382: Sorties :
3383: --------------------------------------------------------------------------------
3384: Effets de bord : néant
3385: ================================================================================
3386: */
3387:
3388: extern inline void
3389: scrutation_injection(struct_processus *s_etat_processus)
3390: {
3391: fd_set ensemble_descripteurs;
3392:
3393: # ifndef OpenBSD
3394: struct timespec timeout;
3395: # else
3396: struct timeval timeout;
3397: # endif
3398:
3399: unsigned char tampon;
3400:
3401: // Si on est dans le processus père, il n'y a rien à surveiller.
3402:
3403: if ((*s_etat_processus).var_volatile_processus_pere == 0)
3404: {
3405: FD_ZERO(&ensemble_descripteurs);
3406: FD_SET((*s_etat_processus).pipe_nombre_injections,
3407: &ensemble_descripteurs);
3408:
3409: # ifndef OpenBSD
3410: timeout.tv_sec = 0;
3411: timeout.tv_nsec = 0;
3412:
3413: if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
3414: &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
3415: # else
3416: timeout.tv_sec = 0;
3417: timeout.tv_usec = 0;
3418:
3419: if (select((*s_etat_processus).pipe_nombre_injections + 1,
3420: &ensemble_descripteurs, NULL, NULL, &timeout) > 0)
3421: # endif
3422: {
3423: if (read_atomic(s_etat_processus,
3424: (*s_etat_processus).pipe_nombre_injections,
3425: &tampon, sizeof(unsigned char)) == sizeof(unsigned char))
3426: {
3427: if (tampon == '-')
3428: {
3429: (*s_etat_processus).nombre_objets_injectes++;
3430: }
3431: else if (tampon == '+')
3432: {
3433: (*s_etat_processus).nombre_objets_envoyes_non_lus--;
3434:
3435: BUG((*s_etat_processus).nombre_objets_envoyes_non_lus < 0,
3436: printf("(*s_etat_processus).nombre_objets_envoyes_"
3437: "non_lus=%d\n", (*s_etat_processus)
3438: .nombre_objets_envoyes_non_lus));
3439: }
3440: else
3441: {
3442: BUG(1, printf("tampon='%c' (%d)\n", tampon, tampon));
3443: }
3444: }
3445: }
3446: }
3447:
3448: return;
3449: }
3450:
3451:
3452: /*
3453: ================================================================================
3454: Fonction de test du drapeau d'arrêt
3455: ================================================================================
3456: Entrées : pointeur sur une structure
3457: --------------------------------------------------------------------------------
3458: Sorties :
3459: --------------------------------------------------------------------------------
3460: Effets de bord : néant
3461: ================================================================================
3462: */
3463:
3464: inline int test_arret(struct_processus *s_etat_processus)
3465: {
3466: return((int) (*s_etat_processus).var_volatile_requete_arret);
3467: }
3468:
3469: // 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