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