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