![]() ![]() | ![]() |
Commit après restauration de la sauvegarde.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.3 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 lancement d'un thread 29: ================================================================================ 30: Entrées : pointeur sur une structure 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void * 39: lancement_thread(void *argument) 40: { 41: int status; 42: 43: pid_t ppid; 44: 45: pthread_t tid_final; 46: 47: sig_atomic_t registre_stop; 48: 49: sigset_t set; 50: 51: ssize_t longueur_ecriture; 52: 53: struct_descripteur_thread *s_argument_thread; 54: 55: struct_liste_chainee *l_element_courant; 56: struct_liste_chainee *l_element_suivant; 57: 58: struct_objet *s_objet_temporaire; 59: 60: struct_processus *s_etat_processus; 61: 62: struct sigaction action; 63: struct sigaction registre; 64: 65: struct timespec attente; 66: 67: unsigned char *message; 68: 69: unsigned int erreur; 70: 71: unsigned long i; 72: 73: attente.tv_sec = 0; 74: attente.tv_nsec = GRANULARITE_us * 1000; 75: 76: s_argument_thread = (struct_descripteur_thread *) argument; 77: s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus; 78: (*s_argument_thread).tid = pthread_self(); 79: (*s_argument_thread).thread_actif = d_vrai; 80: 81: # ifndef SEMAPHORES_NOMMES 82: if (pthread_setspecific(semaphore_fork_processus_courant, 83: &((*s_etat_processus).semaphore_fork)) != 0) 84: # else 85: if (pthread_setspecific(semaphore_fork_processus_courant, 86: (*s_etat_processus).semaphore_fork) != 0) 87: # endif 88: { 89: (*s_etat_processus).erreur_systeme = d_es_processus; 90: 91: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 92: 93: pthread_mutex_lock(&((*s_argument_thread).mutex)); 94: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 95: 96: (*s_argument_thread).thread_actif = d_faux; 97: 98: tid_final = -2; 99: 100: while((longueur_ecriture = write_atomic(s_etat_processus, 101: (*s_argument_thread).pipe_nombre_interruptions_attente[1], 102: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 103: { 104: if (longueur_ecriture == -1) 105: { 106: break; 107: } 108: } 109: 110: while((longueur_ecriture = write_atomic(s_etat_processus, 111: (*s_argument_thread).pipe_nombre_objets_attente[1], 112: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 113: { 114: if (longueur_ecriture == -1) 115: { 116: break; 117: } 118: } 119: 120: pthread_exit(NULL); 121: } 122: 123: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 124: { 125: (*s_etat_processus).erreur_systeme = d_es_processus; 126: 127: pthread_mutex_lock(&((*s_argument_thread).mutex)); 128: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 129: 130: (*s_argument_thread).thread_actif = d_faux; 131: 132: tid_final = -2; 133: 134: while((longueur_ecriture = write_atomic(s_etat_processus, 135: (*s_argument_thread).pipe_nombre_interruptions_attente[1], 136: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 137: { 138: if (longueur_ecriture == -1) 139: { 140: break; 141: } 142: } 143: 144: while((longueur_ecriture = write_atomic(s_etat_processus, 145: (*s_argument_thread).pipe_nombre_objets_attente[1], 146: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 147: { 148: if (longueur_ecriture == -1) 149: { 150: break; 151: } 152: } 153: 154: pthread_exit(NULL); 155: } 156: 157: insertion_thread(s_etat_processus, d_faux); 158: 159: // Envoi d'une donnée pour signaler le démarrage du thread au thread 160: // de surveillance. 161: 162: if (write_atomic(s_etat_processus, 163: (*s_argument_thread).pipe_nombre_objets_attente[1], 164: "-", sizeof(unsigned char)) != sizeof(unsigned char)) 165: { 166: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 167: (*s_etat_processus).erreur_systeme = d_es_processus; 168: 169: pthread_mutex_lock(&((*s_argument_thread).mutex)); 170: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 171: 172: (*s_argument_thread).thread_actif = d_faux; 173: 174: tid_final = -2; 175: 176: while((longueur_ecriture = write_atomic(s_etat_processus, 177: (*s_argument_thread).pipe_nombre_interruptions_attente[1], 178: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 179: { 180: if (longueur_ecriture == -1) 181: { 182: break; 183: } 184: } 185: 186: while((longueur_ecriture = write_atomic(s_etat_processus, 187: (*s_argument_thread).pipe_nombre_objets_attente[1], 188: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 189: { 190: if (longueur_ecriture == -1) 191: { 192: break; 193: } 194: } 195: 196: pthread_exit(NULL); 197: } 198: 199: if ((*s_etat_processus).evaluation_expression_compilee == 'N') 200: { 201: free((*s_etat_processus).instruction_courante); 202: (*s_etat_processus).instruction_courante = NULL; 203: } 204: 205: set = (*s_argument_thread).set; 206: 207: if (sigpending(&set) != 0) 208: { 209: (*s_etat_processus).erreur_systeme = d_es_processus; 210: } 211: else if (sigismember(&set, SIGSTART) == 0) 212: { 213: while(sigismember(&set, SIGSTART) == 0) 214: { 215: if (sigpending(&set) != 0) 216: { 217: (*s_etat_processus).erreur_systeme = d_es_processus; 218: } 219: 220: nanosleep(&attente, NULL); 221: } 222: } 223: 224: if ((*s_etat_processus).debug == d_vrai) 225: if (((*s_etat_processus).type_debug & d_debug_processus) != 0) 226: { 227: if ((*s_etat_processus).langue == 'F') 228: { 229: printf("[%d] Lancement du thread %llu\n", (int) getpid(), 230: (unsigned long long) pthread_self()); 231: } 232: else 233: { 234: printf("[%d] Start thread %llu\n", (int) getpid(), 235: (unsigned long long) pthread_self()); 236: } 237: 238: fflush(stdout); 239: } 240: 241: if (pthread_sigmask(SIG_SETMASK, &((*s_argument_thread).oldset), NULL) != 0) 242: { 243: (*s_etat_processus).erreur_systeme = d_es_processus; 244: } 245: 246: sigpending(&set); 247: 248: (*s_etat_processus).pid_erreur_processus_fils = getpid(); 249: 250: // Évaluation de l'objet 251: 252: if ((*s_etat_processus).erreur_systeme == d_es) 253: { 254: if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E') 255: == d_erreur) 256: { 257: if (((*s_etat_processus).erreur_execution == d_ex) && 258: ((*s_etat_processus).erreur_systeme == d_es)) 259: { 260: (*s_etat_processus).erreur_execution = 261: d_ex_erreur_evaluation; 262: } 263: } 264: else 265: { 266: if (((*s_etat_processus).var_volatile_alarme == 0) 267: && ((*s_etat_processus).arret_depuis_abort == 0) 268: && ((*s_etat_processus).at_exit != NULL)) 269: { 270: (*s_etat_processus).var_volatile_requete_arret = 0; 271: (*s_etat_processus).var_volatile_traitement_retarde_stop = -1; 272: 273: if (evaluation(s_etat_processus, (*s_etat_processus).at_exit, 274: 'E') == d_erreur) 275: { 276: if (((*s_etat_processus).erreur_execution == d_ex) && 277: ((*s_etat_processus).erreur_systeme == d_es)) 278: { 279: (*s_etat_processus).erreur_execution = 280: d_ex_erreur_evaluation; 281: } 282: } 283: } 284: } 285: 286: if ((*s_argument_thread).destruction_objet == d_vrai) 287: { 288: liberation(s_etat_processus, (*s_argument_thread).argument); 289: } 290: } 291: 292: if ((*s_etat_processus).presence_fusible == d_vrai) 293: { 294: pthread_cancel((*s_etat_processus).thread_fusible); 295: } 296: 297: tid_final = -2; 298: 299: while((longueur_ecriture = write_atomic(s_etat_processus, 300: (*s_argument_thread).pipe_nombre_interruptions_attente[1], 301: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 302: { 303: if (longueur_ecriture == -1) 304: { 305: break; 306: } 307: } 308: 309: while((longueur_ecriture = write_atomic(s_etat_processus, 310: (*s_argument_thread).pipe_nombre_objets_attente[1], 311: &tid_final, sizeof(tid_final))) != sizeof(tid_final)) 312: { 313: if (longueur_ecriture == -1) 314: { 315: break; 316: } 317: } 318: 319: if ((*s_etat_processus).var_volatile_processus_pere != 0) 320: { 321: // Racine des processus atteinte 322: 323: erreur = d_ex; 324: 325: while((longueur_ecriture = write_atomic(s_etat_processus, 326: (*s_argument_thread).pipe_erreurs[1], &erreur, 327: sizeof((*s_etat_processus).erreur_execution))) != 328: sizeof((*s_etat_processus).erreur_execution)) 329: { 330: if (longueur_ecriture == -1) 331: { 332: break; 333: } 334: } 335: } 336: else 337: { 338: while((longueur_ecriture = write_atomic(s_etat_processus, 339: (*s_argument_thread).pipe_erreurs[1], 340: &((*s_etat_processus).erreur_execution), 341: sizeof((*s_etat_processus).erreur_execution))) != 342: sizeof((*s_etat_processus).erreur_execution)) 343: { 344: if (longueur_ecriture == -1) 345: { 346: break; 347: } 348: } 349: } 350: 351: if ((*s_etat_processus).var_volatile_processus_pere != 0) 352: { 353: // Racine des processus atteinte 354: 355: erreur = d_es; 356: 357: while((longueur_ecriture = write_atomic(s_etat_processus, 358: (*s_argument_thread).pipe_erreurs[1], &erreur, 359: sizeof((*s_etat_processus).erreur_systeme))) != 360: sizeof((*s_etat_processus).erreur_systeme)) 361: { 362: if (longueur_ecriture == -1) 363: { 364: break; 365: } 366: } 367: } 368: else 369: { 370: while((longueur_ecriture = write_atomic(s_etat_processus, 371: (*s_argument_thread).pipe_erreurs[1], 372: &((*s_etat_processus).erreur_systeme), 373: sizeof((*s_etat_processus).erreur_systeme))) != 374: sizeof((*s_etat_processus).erreur_systeme)) 375: { 376: if (longueur_ecriture == -1) 377: { 378: break; 379: } 380: } 381: } 382: 383: if ((*s_etat_processus).pid_erreur_processus_fils == 0) 384: { 385: ppid = getpid(); 386: 387: while((longueur_ecriture = write_atomic(s_etat_processus, 388: (*s_argument_thread).pipe_erreurs[1], 389: &ppid, sizeof(ppid))) != sizeof(ppid)) 390: { 391: if (longueur_ecriture == -1) 392: { 393: break; 394: } 395: } 396: } 397: else 398: { 399: while((longueur_ecriture = write_atomic(s_etat_processus, 400: (*s_argument_thread).pipe_erreurs[1], 401: &((*s_etat_processus).pid_erreur_processus_fils), 402: sizeof((*s_etat_processus).pid_erreur_processus_fils))) != 403: sizeof((*s_etat_processus).pid_erreur_processus_fils)) 404: { 405: if (longueur_ecriture == -1) 406: { 407: break; 408: } 409: } 410: } 411: 412: close((*s_argument_thread).pipe_erreurs[1]); 413: close((*s_argument_thread).pipe_interruptions[1]); 414: close((*s_argument_thread).pipe_nombre_interruptions_attente[1]); 415: close((*s_argument_thread).pipe_objets[1]); 416: close((*s_argument_thread).pipe_nombre_objets_attente[1]); 417: close((*s_argument_thread).pipe_injections[0]); 418: close((*s_argument_thread).pipe_nombre_injections[0]); 419: close((*s_argument_thread).pipe_acquittement[0]); 420: 421: l_element_courant = (*s_etat_processus).s_fichiers; 422: 423: while(l_element_courant != NULL) 424: { 425: l_element_suivant = (*l_element_courant).suivant; 426: 427: if ((*((struct_descripteur_fichier *) (*l_element_courant) 428: .donnee)).pid == getpid()) 429: { 430: fclose((*((struct_descripteur_fichier *) 431: (*l_element_courant).donnee)).descripteur_c); 432: 433: if ((*((struct_descripteur_fichier *) 434: (*l_element_courant).donnee)).type != 'C') 435: { 436: sqlite3_close((*((struct_descripteur_fichier *) 437: (*l_element_courant).donnee)).descripteur_sqlite); 438: } 439: 440: if ((*((struct_descripteur_fichier *) (*l_element_courant) 441: .donnee)).effacement == 'Y') 442: { 443: unlink((*((struct_descripteur_fichier *) 444: (*l_element_courant).donnee)).nom); 445: } 446: } 447: 448: free((*((struct_descripteur_fichier *) (*l_element_courant) 449: .donnee)).nom); 450: free((struct_descripteur_fichier *) (*l_element_courant).donnee); 451: free(l_element_courant); 452: 453: l_element_courant = l_element_suivant; 454: } 455: 456: pthread_mutex_lock(&((*s_etat_processus).mutex)); 457: 458: l_element_courant = (struct_liste_chainee *) 459: (*s_etat_processus).l_base_pile_processus; 460: 461: while(l_element_courant != NULL) 462: { 463: if ((*(*((struct_processus_fils *) (*(*l_element_courant).donnee) 464: .objet)).thread).processus_detache == d_vrai) 465: { 466: if ((*s_etat_processus).debug == d_vrai) 467: { 468: if (((*s_etat_processus).type_debug & d_debug_processus) != 0) 469: { 470: if ((*s_etat_processus).langue == 'F') 471: { 472: printf("[%d] Signalement pour arrêt du processus %d\n", 473: (int) getpid(), 474: (int) (*(*((struct_processus_fils *) 475: (*(*l_element_courant).donnee).objet)).thread) 476: .pid); 477: } 478: else 479: { 480: printf("[%d] Send stop signal to process %d\n", 481: (int) getpid(), 482: (int) (*(*((struct_processus_fils *) 483: (*(*l_element_courant).donnee).objet)).thread) 484: .pid); 485: } 486: } 487: } 488: 489: if ((*s_etat_processus).var_volatile_alarme != 0) 490: { 491: kill((*(*((struct_processus_fils *) (*(*l_element_courant) 492: .donnee).objet)).thread).pid, SIGURG); 493: } 494: else 495: { 496: if ((*s_etat_processus).arret_depuis_abort == -1) 497: { 498: kill((*(*((struct_processus_fils *) (*(*l_element_courant) 499: .donnee).objet)).thread).pid, SIGFABORT); 500: } 501: else 502: { 503: kill((*(*((struct_processus_fils *) (*(*l_element_courant) 504: .donnee).objet)).thread).pid, SIGFSTOP); 505: } 506: } 507: } 508: else 509: { 510: if ((*s_etat_processus).debug == d_vrai) 511: { 512: if (((*s_etat_processus).type_debug & d_debug_processus) != 0) 513: { 514: if ((*s_etat_processus).langue == 'F') 515: { 516: printf("[%d] Signalement pour arrêt du thread %llu\n", 517: (int) getpid(), (unsigned long long) 518: (*(*((struct_processus_fils *) 519: (*(*l_element_courant).donnee).objet)).thread) 520: .tid); 521: } 522: else 523: { 524: printf("[%d] Send stop signal to thread %llu\n", 525: (int) getpid(), (unsigned long long) 526: (*(*((struct_processus_fils *) 527: (*(*l_element_courant).donnee).objet)).thread) 528: .tid); 529: } 530: } 531: } 532: 533: if ((*s_etat_processus).var_volatile_alarme != 0) 534: { 535: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 536: (*(*l_element_courant).donnee).objet)).thread).mutex)) 537: != 0) 538: { 539: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 540: (*s_etat_processus).erreur_systeme = d_es_processus; 541: 542: pthread_mutex_lock(&((*s_argument_thread).mutex)); 543: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 544: 545: (*s_argument_thread).thread_actif = d_faux; 546: 547: pthread_exit(NULL); 548: } 549: 550: if ((*(*((struct_processus_fils *) 551: (*(*l_element_courant).donnee).objet)).thread) 552: .thread_actif == d_vrai) 553: { 554: pthread_kill((*(*((struct_processus_fils *) 555: (*(*l_element_courant).donnee).objet)).thread).tid, 556: SIGURG); 557: } 558: 559: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 560: (*(*l_element_courant).donnee).objet)).thread) 561: .mutex)) != 0) 562: { 563: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 564: (*s_etat_processus).erreur_systeme = d_es_processus; 565: 566: pthread_mutex_lock(&((*s_argument_thread).mutex)); 567: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 568: 569: (*s_argument_thread).thread_actif = d_faux; 570: 571: pthread_exit(NULL); 572: } 573: } 574: else 575: { 576: if (pthread_mutex_lock(&((*(*((struct_processus_fils *) 577: (*(*l_element_courant).donnee).objet)).thread).mutex)) 578: != 0) 579: { 580: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 581: (*s_etat_processus).erreur_systeme = d_es_processus; 582: 583: pthread_mutex_lock(&((*s_argument_thread).mutex)); 584: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 585: 586: (*s_argument_thread).thread_actif = d_faux; 587: 588: pthread_exit(NULL); 589: } 590: 591: if ((*(*((struct_processus_fils *) 592: (*(*l_element_courant).donnee).objet)).thread) 593: .thread_actif == d_vrai) 594: { 595: if ((*s_etat_processus).arret_depuis_abort == -1) 596: { 597: pthread_kill((*(*((struct_processus_fils *) 598: (*(*l_element_courant).donnee).objet)).thread) 599: .tid, SIGFABORT); 600: } 601: else 602: { 603: pthread_kill((*(*((struct_processus_fils *) 604: (*(*l_element_courant).donnee).objet)).thread) 605: .tid, SIGFSTOP); 606: } 607: } 608: 609: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) 610: (*(*l_element_courant).donnee).objet)).thread).mutex)) 611: != 0) 612: { 613: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 614: (*s_etat_processus).erreur_systeme = d_es_processus; 615: 616: pthread_mutex_lock(&((*s_argument_thread).mutex)); 617: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 618: 619: (*s_argument_thread).thread_actif = d_faux; 620: 621: pthread_exit(NULL); 622: } 623: } 624: } 625: 626: l_element_courant = (*l_element_courant).suivant; 627: } 628: 629: /* 630: * Attente de la fin de tous les processus fils 631: */ 632: 633: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; 634: (*s_etat_processus).masque_interruptions[i++] = 'I'); 635: 636: attente.tv_sec = 0; 637: attente.tv_nsec = GRANULARITE_us * 1000; 638: 639: while((*s_etat_processus).l_base_pile_processus != NULL) 640: { 641: status = 0; 642: 643: l_element_courant = (struct_liste_chainee *) 644: (*s_etat_processus).l_base_pile_processus; 645: 646: registre_stop = (*s_etat_processus) 647: .var_volatile_traitement_retarde_stop; 648: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1; 649: 650: for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *) 651: (*(*l_element_courant).donnee).objet)).thread) 652: .nombre_objets_dans_pipe; i++) 653: { 654: if ((s_objet_temporaire = lecture_pipe(s_etat_processus, 655: (*(*((struct_processus_fils *) (*(*l_element_courant) 656: .donnee).objet)).thread).pipe_objets[0])) != NULL) 657: { 658: liberation(s_etat_processus, s_objet_temporaire); 659: 660: (*(*((struct_processus_fils *) (*(*l_element_courant) 661: .donnee).objet)).thread).nombre_objets_dans_pipe--; 662: 663: action.sa_handler = SIG_IGN; 664: action.sa_flags = SA_ONSTACK; 665: 666: if (sigaction(SIGPIPE, &action, ®istre) != 0) 667: { 668: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 669: 670: if (registre_stop == 0) 671: { 672: if ((*s_etat_processus) 673: .var_volatile_traitement_retarde_stop 674: == -1) 675: { 676: (*s_etat_processus) 677: .var_volatile_requete_arret = -1; 678: } 679: 680: (*s_etat_processus) 681: .var_volatile_traitement_retarde_stop = 682: registre_stop; 683: } 684: 685: (*s_etat_processus).erreur_systeme = d_es_signal; 686: exit(EXIT_FAILURE); 687: } 688: 689: while((longueur_ecriture = write_atomic( 690: s_etat_processus, (*(*((struct_processus_fils *) 691: (*(*l_element_courant).donnee).objet)).thread) 692: .pipe_nombre_injections[1], "+", 693: sizeof(unsigned char))) != 694: sizeof(unsigned char)) 695: { 696: if (longueur_ecriture == -1) 697: { 698: // Le processus n'existe plus. 699: break; 700: } 701: } 702: 703: if (registre_stop == 0) 704: { 705: if ((*s_etat_processus) 706: .var_volatile_traitement_retarde_stop == -1) 707: { 708: (*s_etat_processus).var_volatile_requete_arret 709: = -1; 710: } 711: 712: (*s_etat_processus) 713: .var_volatile_traitement_retarde_stop = 714: registre_stop; 715: } 716: 717: if (sigaction(SIGPIPE, ®istre, NULL) != 0) 718: { 719: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 720: 721: (*s_etat_processus).erreur_systeme = d_es_signal; 722: exit(EXIT_FAILURE); 723: } 724: } 725: } 726: 727: if ((*(*((struct_processus_fils *) (*(*l_element_courant) 728: .donnee).objet)).thread).processus_detache == d_vrai) 729: { 730: if (waitpid((*(*((struct_processus_fils *) 731: (*(*l_element_courant).donnee).objet)).thread).pid, 732: &status, WNOHANG) < 0) 733: { 734: } 735: } 736: 737: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 738: 739: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) 740: { 741: affectation_interruptions_logicielles(s_etat_processus); 742: } 743: 744: nanosleep(&attente, NULL); 745: pthread_mutex_lock(&((*s_etat_processus).mutex)); 746: } 747: 748: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 749: 750: l_element_courant = (*s_etat_processus).s_sockets; 751: 752: while(l_element_courant != NULL) 753: { 754: l_element_suivant = (*l_element_courant).suivant; 755: 756: /* 757: * Fermeture des sockets créées dans le processus courant. 758: */ 759: 760: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet)) 761: .pid == getpid()) && (pthread_equal((*((struct_socket *) 762: (*(*l_element_courant).donnee).objet)).tid, pthread_self()) 763: != 0)) 764: { 765: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet)) 766: .socket_connectee == d_vrai) 767: { 768: shutdown((*((struct_socket *) (*(*l_element_courant).donnee) 769: .objet)).socket, SHUT_RDWR); 770: } 771: 772: close((*((struct_socket *) (*(*l_element_courant).donnee).objet)) 773: .socket); 774: 775: if ((*((struct_socket *) (*(*l_element_courant).donnee).objet)) 776: .effacement == 'Y') 777: { 778: unlink((*((struct_socket *) (*(*l_element_courant).donnee) 779: .objet)).adresse); 780: } 781: } 782: 783: liberation(s_etat_processus, (*((struct_liste_chainee *) 784: l_element_courant)).donnee); 785: free(l_element_courant); 786: 787: l_element_courant = l_element_suivant; 788: } 789: 790: l_element_courant = (*s_etat_processus).s_connecteurs_sql; 791: 792: while(l_element_courant != NULL) 793: { 794: l_element_suivant = (*l_element_courant).suivant; 795: 796: /* 797: * Fermeture des connecteurs créés dans le processus courant. 798: */ 799: 800: if (((*((struct_socket *) (*(*l_element_courant).donnee).objet)) 801: .pid == getpid()) && (pthread_equal((*((struct_socket *) 802: (*(*l_element_courant).donnee).objet)).tid, pthread_self()) 803: != 0)) 804: { 805: sqlclose((*l_element_courant).donnee); 806: } 807: 808: liberation(s_etat_processus, (*((struct_liste_chainee *) 809: l_element_courant)).donnee); 810: free(l_element_courant); 811: 812: l_element_courant = l_element_suivant; 813: } 814: 815: if ((((*s_etat_processus).erreur_execution != d_ex) || 816: ((*s_etat_processus).exception != d_ep) || 817: ((*s_etat_processus).erreur_systeme != d_es)) && 818: ((*s_etat_processus).var_volatile_traitement_sigint == 0)) 819: { 820: printf("%s [%d]\n", message = 821: messages(s_etat_processus), (int) getpid()); 822: free(message); 823: 824: if ((*s_etat_processus).core == d_vrai) 825: { 826: printf("\n"); 827: 828: if ((*s_etat_processus).langue == 'F') 829: { 830: printf("+++Information : Génération du fichier rpl-core " 831: "[%d]\n", (int) getpid()); 832: } 833: else 834: { 835: printf("+++Information : Writing rpl-core file [%d]\n", 836: (int) getpid()); 837: } 838: 839: rplcore(s_etat_processus); 840: 841: if ((*s_etat_processus).langue == 'F') 842: { 843: printf("+++Information : Processus tracé [%d]\n", 844: (int) getpid()); 845: } 846: else 847: { 848: printf("+++Information : Done [%d]\n", (int) getpid()); 849: } 850: 851: printf("\n"); 852: fflush(stdout); 853: } 854: } 855: 856: if ((*s_etat_processus).entree_standard != NULL) 857: { 858: pclose((*s_etat_processus).entree_standard); 859: (*s_etat_processus).entree_standard = NULL; 860: } 861: 862: if ((*s_etat_processus).fichiers_graphiques != NULL) 863: { 864: instruction_cllcd(s_etat_processus); 865: } 866: 867: liberation(s_etat_processus, (*s_etat_processus).indep); 868: liberation(s_etat_processus, (*s_etat_processus).depend); 869: 870: free((*s_etat_processus).label_x); 871: free((*s_etat_processus).label_y); 872: free((*s_etat_processus).label_z); 873: free((*s_etat_processus).titre); 874: free((*s_etat_processus).legende); 875: 876: liberation(s_etat_processus, 877: (*s_etat_processus).parametres_courbes_de_niveau); 878: 879: if ((*s_etat_processus).instruction_derniere_erreur != NULL) 880: { 881: free((*s_etat_processus).instruction_derniere_erreur); 882: (*s_etat_processus).instruction_derniere_erreur = NULL; 883: } 884: 885: liberation_arbre_variables(s_etat_processus, 886: (*s_etat_processus).s_arbre_variables, d_faux); 887: 888: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) 889: { 890: liberation(s_etat_processus, 891: (*s_etat_processus).s_liste_variables_statiques[i].objet); 892: free((*s_etat_processus).s_liste_variables_statiques[i].nom); 893: } 894: 895: free((*s_etat_processus).s_liste_variables_statiques); 896: 897: l_element_courant = (*s_etat_processus).l_base_pile; 898: while(l_element_courant != NULL) 899: { 900: l_element_suivant = (*l_element_courant).suivant; 901: 902: liberation(s_etat_processus, (*l_element_courant).donnee); 903: free(l_element_courant); 904: 905: l_element_courant = l_element_suivant; 906: } 907: 908: l_element_courant = (*s_etat_processus).l_base_pile_last; 909: while(l_element_courant != NULL) 910: { 911: l_element_suivant = (*l_element_courant).suivant; 912: 913: liberation(s_etat_processus, (*l_element_courant).donnee); 914: free(l_element_courant); 915: 916: l_element_courant = l_element_suivant; 917: } 918: 919: l_element_courant = (*s_etat_processus).l_base_pile_contextes; 920: while(l_element_courant != NULL) 921: { 922: l_element_suivant = (*l_element_courant).suivant; 923: 924: liberation(s_etat_processus, (*l_element_courant).donnee); 925: free(l_element_courant); 926: 927: l_element_courant = l_element_suivant; 928: } 929: 930: l_element_courant = (*s_etat_processus).l_base_pile_taille_contextes; 931: while(l_element_courant != NULL) 932: { 933: l_element_suivant = (*l_element_courant).suivant; 934: 935: liberation(s_etat_processus, (*l_element_courant).donnee); 936: free(l_element_courant); 937: 938: l_element_courant = l_element_suivant; 939: } 940: 941: l_element_courant = (struct_liste_chainee *) 942: (*s_etat_processus).l_base_pile_systeme; 943: while(l_element_courant != NULL) 944: { 945: l_element_suivant = (struct_liste_chainee *) 946: (*((struct_liste_pile_systeme *) 947: l_element_courant)).suivant; 948: 949: liberation(s_etat_processus, (*((struct_liste_pile_systeme *) 950: l_element_courant)).indice_boucle); 951: liberation(s_etat_processus, (*((struct_liste_pile_systeme *) 952: l_element_courant)).limite_indice_boucle); 953: liberation(s_etat_processus, (*((struct_liste_pile_systeme *) 954: l_element_courant)).objet_de_test); 955: 956: if ((*((struct_liste_pile_systeme *) 957: l_element_courant)).nom_variable != NULL) 958: { 959: free((*((struct_liste_pile_systeme *) 960: l_element_courant)).nom_variable); 961: } 962: 963: free((struct_liste_pile_systeme *) l_element_courant); 964: 965: l_element_courant = l_element_suivant; 966: } 967: 968: l_element_courant = (*s_etat_processus).s_bibliotheques; 969: 970: while(l_element_courant != NULL) 971: { 972: l_element_suivant = (*l_element_courant).suivant; 973: 974: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom); 975: 976: if (((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid 977: == getpid()) && (pthread_equal((*((struct_bibliotheque *) 978: (*l_element_courant).donnee)).tid, pthread_self()) != 0)) 979: { 980: dlclose((*((struct_bibliotheque *) (*l_element_courant).donnee)) 981: .descripteur); 982: } 983: 984: free((*l_element_courant).donnee); 985: free(l_element_courant); 986: 987: l_element_courant = l_element_suivant; 988: } 989: 990: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++) 991: { 992: free((*s_etat_processus).s_instructions_externes[i].nom); 993: free((*s_etat_processus).s_instructions_externes[i] 994: .nom_bibliotheque); 995: } 996: 997: if ((*s_etat_processus).nombre_instructions_externes != 0) 998: { 999: free((*s_etat_processus).s_instructions_externes); 1000: } 1001: 1002: if ((*s_etat_processus).debug == d_vrai) 1003: if (((*s_etat_processus).type_debug & d_debug_processus) != 0) 1004: { 1005: if ((*s_etat_processus).langue == 'F') 1006: { 1007: printf("[%d] Fin du thread %llu\n", (int) getpid(), 1008: (unsigned long long) pthread_self()); 1009: } 1010: else 1011: { 1012: printf("[%d] End of thread %llu\n", (int) getpid(), 1013: (unsigned long long) pthread_self()); 1014: } 1015: 1016: fflush(stdout); 1017: } 1018: 1019: liberation(s_etat_processus, (*s_argument_thread).argument); 1020: liberation(s_etat_processus, (*s_etat_processus).at_exit); 1021: liberation(s_etat_processus, (*s_etat_processus).at_poke); 1022: 1023: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) 1024: { 1025: liberation(s_etat_processus, 1026: (*s_etat_processus).corps_interruptions[i]); 1027: 1028: l_element_courant = (*s_etat_processus) 1029: .pile_origine_interruptions[i]; 1030: 1031: while(l_element_courant != NULL) 1032: { 1033: l_element_suivant = (*l_element_courant).suivant; 1034: 1035: liberation(s_etat_processus, (*l_element_courant).donnee); 1036: free(l_element_courant); 1037: 1038: l_element_courant = l_element_suivant; 1039: } 1040: } 1041: 1042: l_element_courant = (struct_liste_chainee *) (*s_etat_processus).s_marques; 1043: 1044: while(l_element_courant != NULL) 1045: { 1046: free((*((struct_marque *) l_element_courant)).label); 1047: free((*((struct_marque *) l_element_courant)).position); 1048: l_element_suivant = (struct_liste_chainee *) 1049: (*((struct_marque *) l_element_courant)).suivant; 1050: free((struct_marque *) l_element_courant); 1051: l_element_courant = l_element_suivant; 1052: } 1053: 1054: if ((*s_etat_processus).generateur_aleatoire != NULL) 1055: { 1056: liberation_generateur_aleatoire(s_etat_processus); 1057: } 1058: 1059: if ((*s_etat_processus).profilage == d_vrai) 1060: { 1061: ecriture_profil(s_etat_processus); 1062: liberation_profil(s_etat_processus); 1063: } 1064: 1065: liberation_allocateur(s_etat_processus); 1066: 1067: retrait_thread(s_etat_processus); 1068: pthread_mutex_destroy(&((*s_etat_processus).mutex)); 1069: pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); 1070: 1071: sem_destroy(&((*s_etat_processus).semaphore_fork)); 1072: 1073: liberation_contexte_cas(s_etat_processus); 1074: free((*s_etat_processus).localisation); 1075: free(s_etat_processus); 1076: 1077: pthread_mutex_lock(&((*s_argument_thread).mutex)); 1078: pthread_mutex_unlock(&((*s_argument_thread).mutex)); 1079: 1080: (*s_argument_thread).thread_actif = d_faux; 1081: pthread_exit(NULL); 1082: return(NULL); 1083: } 1084: 1085: // vim: ts=4