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