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