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