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