312 lines
13 KiB
C
312 lines
13 KiB
C
/*----------------------------------------------------------------------------*/
|
|
/* libshmem.h */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* This file is part of LibShMem */
|
|
/* */
|
|
/* LibShMem is free software: you can redistribute it and/or modify it */
|
|
/* under the terms of the GNU Lesser General Public License as published */
|
|
/* by the Free Software Foundation, either version 3 of the License, or */
|
|
/* (at your option) any later version. */
|
|
/* */
|
|
/* LibShMem is distributed in the hope that it will be useful, */
|
|
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
|
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
|
/* GNU Lesser General Public License for more details. */
|
|
/* */
|
|
/* You should have received a copy of the GNU Lesser General Public */
|
|
/* License along with Drummer. If not, see */
|
|
/* <https://www.gnu.org/licenses/>. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
|
|
#include <sys/sem.h>
|
|
#include <sys/shm.h>
|
|
#include <sys/ipc.h>
|
|
|
|
#include <shmem.h>
|
|
|
|
#include <execinfo.h>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Compteur d'ouverture de la librairie */
|
|
|
|
unsigned int SM_Open_Counter = 0;
|
|
|
|
|
|
/* Flux de sortie des messages d'erreur générés par la librairie */
|
|
|
|
FILE * SM_stderr;
|
|
|
|
extern char * strdup (const char *);
|
|
|
|
#define max(A,B) ((A < B) ? B : A)
|
|
|
|
|
|
/* Limite supérieure d'adressage */
|
|
|
|
#define MEM_LIMIT 1000000000
|
|
|
|
|
|
//#define SMD_CMD_VALUE_SUM (NDT_Command)65
|
|
#define NDD_CMD_VALUE_SUM (NDT_Command)NDD_CMD_USER_TRAVERSE
|
|
|
|
|
|
/* Taille d'un segment = 100 Ko par défaut */
|
|
|
|
#define K 1024
|
|
#define NB_BLOCS 100
|
|
#define SEGMENT_DEFAULT_SIZE NB_BLOCS * K
|
|
|
|
char Info_Msg [256];
|
|
|
|
|
|
/* Etats possibles pour un heap */
|
|
|
|
#define SMD_STATE_VALID 0
|
|
#define SMD_STATE_UNVALIDATED 1
|
|
#define SMD_STATE_CORRUPTED 2
|
|
|
|
/* Référence sur le heap système */
|
|
|
|
SMT_Heap * System_Heap;
|
|
|
|
/* Liste des heaps ouverts par le processus courant */
|
|
|
|
NDT_Root * Opened_Heap_List;
|
|
|
|
/*
|
|
Taille par défaut des chunks alloués dans le heap système :
|
|
Cette taille est fixée à la taille maximale des chunks pouvant
|
|
y être alloué (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH)
|
|
*/
|
|
|
|
#define DEFAULT_CHUNK_SIZE max(max(sizeof(NDT_Root), sizeof(NDT_Node)), max(sizeof(SMT_MHH), sizeof(SMT_DSH)))
|
|
|
|
/*
|
|
Nombre de chunk libre minimum avant extension du heap système par un
|
|
nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment
|
|
nécessite l'allocation de 2 chunks (un noeud et une entête de segment).
|
|
*/
|
|
|
|
#define FREE_CHUNK_LIMIT 3
|
|
|
|
int SM_Instance;
|
|
char * SM_Context;
|
|
|
|
/* Contexte et instance d'utilisation de la librairie */
|
|
|
|
#define DEFAULT_INSTANCE 1000
|
|
#define INSTANCE_ENV_VAR "INSTANCE"
|
|
|
|
#define DEFAULT_CONTEXT "CTX"
|
|
#define CONTEXT_ENV_VAR "CONTEXT"
|
|
|
|
/*
|
|
Variable globale permettant d'indiquer que l'on est en train
|
|
d'étendre le heap système par ajout d'un nouveau segment.
|
|
*/
|
|
|
|
unsigned int Adding_Segment = FALSE;
|
|
|
|
SMT_Chunk * Tmp_Chunk;
|
|
SMT_MHH * Tmp_MHH;
|
|
|
|
/*
|
|
Définition des opérations de verouillage et de déverrouillage
|
|
NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé
|
|
*/
|
|
|
|
/* Pose d'un verrou en lecture : 2 opérations : ( -1 puis +2 ) */
|
|
|
|
struct sembuf SM_SemOp_SSL [2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} };
|
|
|
|
/* Libération d'un verrou en lecture : 2 opérations ( -2 puis +1 ) */
|
|
|
|
struct sembuf SM_SemOp_RSL [2] = { {0, -2, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
|
|
|
/* Pose d'un verrou en écriture : 2 opérations ( -1 puis 0 ) */
|
|
|
|
struct sembuf SM_SemOp_SEL [2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} };
|
|
|
|
/* Libération d'un verrou en écriture : 2 opérations ( 0 puis +1 ) */
|
|
|
|
struct sembuf SM_SemOp_REL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
|
|
|
/* Transformation d'un verrou en écriture en un verrou en lecture : 2 opérations ( 0 puis +2 ) */
|
|
|
|
struct sembuf SM_SemOp_TSL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 2, SEM_UNDO|IPC_NOWAIT} };
|
|
|
|
typedef union semun
|
|
{
|
|
int val;
|
|
struct semid_ds * buf;
|
|
unsigned short int * array;
|
|
} semun;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Allocation de mémoire dans la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_Base_Alloc( void **, size_t, void *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Désallocation de mémoire dans la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_Base_Free( void *, void *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Allocation de mémoire dans le heap système */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_System_Alloc( void **, size_t, void *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Désallocation de mémoire dans le heap système */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_System_Free( void *, void *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Initialisation de la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_Init (void);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Terminaison de la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_End (void);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Ouverture de la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_Open (void);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fermeture de la base */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_Close (void);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Pose d'un verrou sur la base : */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_Lock (SMT_Flags);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Libération d'un verrou sur la base : */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Base_Unlock (SMT_Flags);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fonction manager de la liste des heaps ouverts */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_Opened_Heap_List_Manager ( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fonction manager du MHR (Memory Heap Root) */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status MHR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Destruction d'un MHH (Memory Heap Header) */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_MHH_End (SMT_MHH *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fonction manager pour un DSR (Data Segment Root) */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_DSR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Ouverture d'un segment de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_DataSegment_Open (SMT_DSH *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fermeture d'un segment de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_DataSegment_Close (SMT_DSH *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Compression d'un segment de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
size_t SM_DataSegment_Compress (SMT_DSH *, NDT_Root *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fonction manager pour un ACR (Allocated Chunk Root) */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_ACR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fonction manager pour un FCR (Free Chunk Root) */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status SM_FCR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Pose d'un verrou sur un heap : */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Heap_Lock_Set (SMT_MHH *, SMT_Flags);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Changement d'un verrou sur un heap : */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Heap_Lock_Change (SMT_MHH *, SMT_Flags);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Libération d'un verrou sur un heap : */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Heap_Lock_Release (SMT_MHH *, SMT_Flags);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Opération sur un sémaphore */
|
|
/*------------------------------------------------------------------------------*/
|
|
SMT_Status SM_Semaphore_Operate (int, struct sembuf *, unsigned int);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupère sous forme explicite l'état d'un verrou */
|
|
/*------------------------------------------------------------------------------*/
|
|
char * SM_Lock_Status_Get (const char *, void *);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Routine d'affichage d'un message d'erreur */
|
|
/*------------------------------------------------------------------------------*/
|
|
void SM_Error_Print (void);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Add context prefix to heap name */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (O) Prefixed: Prefixed heap name */
|
|
/* (I) Unprefixed: Unprefixed heap name */
|
|
/*------------------------------------------------------------------------------*/
|
|
|
|
SMT_Status SM_Name_Prefix( char *, const char *);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Print stack trace */
|
|
/*------------------------------------------------------------------------------*/
|
|
|
|
void SM_stack_trace_print( void);
|