From d90beb98606b61a4053f00675e1d7a5544e47e1a Mon Sep 17 00:00:00 2001 From: "Arnaud G. GIBERT" Date: Sat, 27 Apr 2024 20:00:00 +0200 Subject: [PATCH] - Succed to compile DS_DataStruct_Open_I() full implementation. Tests needed! --- include/datastr.h | 4 +- lib/libdatastr.c | 296 ++++++++++++++++++++++++++++++---------------- lib/libdatastr.h | 10 +- 3 files changed, 206 insertions(+), 104 deletions(-) diff --git a/include/datastr.h b/include/datastr.h index d0dfa12..1a5266c 100644 --- a/include/datastr.h +++ b/include/datastr.h @@ -134,8 +134,8 @@ typedef int DST_Flags; #define DSD_BOOL_VALUE_ASCII_GET( v) ( ( (v) == true) ? "TRUE" : "FALSE") -#define SDD_NAME_LEN ( short)SMD_NAME_SIZE -#define SDD_NAME_SIZE ( SDD_NAME_LEN + 1) +#define DSD_NAME_LEN ( short)SMD_NAME_LEN +#define DSD_NAME_SIZE ( DSD_NAME_LEN + 1) /* On utilise le pointeur 'User' de la racine de la struture pour y diff --git a/lib/libdatastr.c b/lib/libdatastr.c index d7dc689..69b2f03 100644 --- a/lib/libdatastr.c +++ b/lib/libdatastr.c @@ -206,11 +206,13 @@ DST_Status DS_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, char *DS_Name, NDT DST_Status status; SMT_Status sm_status; NDT_Status nd_status; + SMT_Heap *heap_ptr; SMT_DSH *dsh_ptr; + int locked, mode; DST_RootDesc *rootdesc_ptr, rootdesc_tmp; - DST_DataStruct *Opened_DataStruct; + DST_DataStruct *opened_datastruct_ptr; char *Prefixed_Name = DS_Name_Prefix( DS_Name); union semun Sem_Ctl; @@ -450,17 +452,17 @@ DST_Status DS_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, char *DS_Name, NDT /* On crée un sémaphore pour compter le nombre de processus qui ouvrent la structure */ -/* - rc = DS_Semaphore_Create (*Root); - if (rc != DSS_OK) + + if( ( status = DS_Semaphore_Create( *Root_Ptr_Ptr)) != DSS_OK) { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to create a semaphore for the data structure \"%s\"", DS_Name); - DS_Error_Print (); - SM_Heap_End (Prefixed_Name); - *Root = NULL; - return rc; + LG_LOG_ERROR_2( "Unable to create a semaphore for the data structure: [%s], error: (%d)", DS_Name, status); + + SM_Heap_End( Prefixed_Name); + *Root_Ptr_Ptr = NULL; + + return( status); } -*/ + break; } @@ -470,80 +472,115 @@ DST_Status DS_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, char *DS_Name, NDT } } + /* On incrémente le sémaphore qui compte le nombre de processus qui ouvrent la structure */ -/* - rc = DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Open, 1); - if (rc != DSS_OK) + + if( ( status = DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Open, 1)) != DSS_OK) { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to incremente the semaphore of data structure \"%s\"", DS_Name); - DS_Error_Print (); + LG_LOG_ERROR_2( "Unable to incremente the semaphore of data structure: [%s], error: (%d)", DS_Name, status); - if (Locked == TRUE) SM_Heap_Unlock (Heap); + if( locked == TRUE) SM_Heap_Unlock( heap_ptr); - if (Mode == 3) + if( mode == 3) { - semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); - SM_Heap_End (Prefixed_Name); + semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); + SM_Heap_End( Prefixed_Name); + } + else + { + DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); } - else DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Close, 1); - *Root = NULL; + *Root_Ptr_Ptr = NULL; - return rc; + return( status); } + /* On ajoute la data structure à la liste des structures ouvertes par le processus courant */ -/* - Opened_DataStruct = (DST_DataStruct *)malloc (sizeof (DST_DataStruct)); - Opened_DataStruct->Name = strdup (DS_Name); - Opened_DataStruct->Root = *Root; - rc = ND_Value_Add (OpenedDS_List, Opened_DataStruct); - if (rc != NDS_OK) + if( ( nd_status = ND_Value_Alloc( (void **)&opened_datastruct_ptr, OpenedDS_List, DS_Name, Root_Ptr_Ptr)) != NDS_OK) { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to add structure \"%s\" to the opened structure list", DS_Name); - DS_Error_Print (); + LG_LOG_ERROR_2( "Unable to alloc a new opened data structure element: [%s], error: (%d)", DS_Name, nd_status); - if (Locked == TRUE) SM_Heap_Unlock (Heap); + if( locked == TRUE) SM_Heap_Unlock( heap_ptr); - if (Mode == 3) + if( mode == 3) { - semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); - SM_Heap_End (Prefixed_Name); + semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); + SM_Heap_End( Prefixed_Name); + } + else + { + DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); } - else DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Close, 1); - *Root = NULL; + *Root_Ptr_Ptr = NULL; - return rc; + return( DSS_KO); + } + + if( ( nd_status = ND_DataStruct_Value_Add( OpenedDS_List, (void *)opened_datastruct_ptr)) != NDS_OK) + { + LG_LOG_ERROR_2( "Unable to add an new data structure element: [%s] to the opened structure list, error: (%d)", DS_Name, status); + + if( ( nd_status = ND_Value_Free( OpenedDS_List, (void *)opened_datastruct_ptr)) != NDS_OK) + { + LG_LOG_ERROR_2( "Unable to free a new opened data structure element: [%s], error: (%d)", DS_Name, nd_status); + } + + if( locked == TRUE) SM_Heap_Unlock( heap_ptr); + + if( mode == 3) + { + semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); + SM_Heap_End( Prefixed_Name); + } + else + { + DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); + } + + *Root_Ptr_Ptr = NULL; + + return( DSS_KO); } + /* Déverrouillage du heap */ -/* - if (Locked == TRUE) + + if( locked == TRUE) { - rc = SM_Heap_Unlock (Heap); - if (rc != SMS_OK) + if( sm_status = ( SM_Heap_Unlock( heap_ptr)) != SMS_OK) { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to unlock the data structure heap \"%s\"", Prefixed_Name); - DS_Error_Print (); + LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", Prefixed_Name, sm_status); - ND_Value_Remove (OpenedDS_List, Opened_DataStruct, (void **)&Opened_DataStruct); - ND_Value_Free (OpenedDS_List, Opened_DataStruct); - - if (Mode == 3) + if( ( nd_status = ND_DataStruct_Value_Remove( OpenedDS_List, opened_datastruct_ptr)) != NDS_OK) { - semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); - SM_Heap_End (Prefixed_Name); + LG_LOG_ERROR_2( "Unable to remove a data structure element: [%s] to the opened structure list, error: (%d)", DS_Name, status); + } + + if( ( nd_status = ND_Value_Free( OpenedDS_List, opened_datastruct_ptr)) != NDS_OK) + { + LG_LOG_ERROR_2( "Unable to free a new opened data structure element: [%s], error: (%d)", DS_Name, nd_status); + } + + if( mode == 3) + { + semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); + SM_Heap_End( Prefixed_Name); + } + else + { + DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); } - else DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Close, 1); - *Root = NULL; + *Root_Ptr_Ptr = NULL; - return rc; + return( DSS_KO); } } -*/ + return( DSS_OK); } @@ -643,7 +680,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) { /* On vérifie qu'aucun autre processus n'a ouvert la data structure */ /* - rc = DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Destroy, 2); + rc = DS_Semaphore_Operate (RootDesc->OpenSemId, DS_SemOp_Destroy, 2); if (rc != DSS_OK) { sprintf (DS_Error_Msg, "Error DS_DataStruct_Close : unable to destroy the data structure \"%s\" because it is opened by another process", DS_Name); @@ -666,7 +703,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) /* Suppression du sémaphore */ /* - semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); + semctl (RootDesc->OpenSemId, 0, IPC_RMID, Sem_Ctl); /* On supprime maintenant le heap */ /* @@ -704,7 +741,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) /* { /* On décrémente le sémaphore qui compte le nombre de processus ayant ouvert la data structure */ /* - rc = DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Close, 1); + rc = DS_Semaphore_Operate (RootDesc->OpenSemId, DS_SemOp_Close, 1); if (rc != DSS_OK) { sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to decremente the semaphore of data structure \"%s\"", DS_Name); @@ -3128,107 +3165,144 @@ static char *DS_Name_Prefix( const char *Name ) return( Prefixed); } + + /*----------------------------------------------------------------------------*/ /* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ /*----------------------------------------------------------------------------*/ -/* -DST_Status DS_Semaphore_Create ( NDT_Root * Root ) -{ - union semun Sem_Ctl; - DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); +DST_Status DS_Semaphore_Create ( NDT_Root *Root_Ptr) +{ + union semun sem_ctl; + DST_RootDesc *rootdesc_ptr = (DST_RootDesc *)(Root_Ptr->User_Ptr); + + /* Création du sémaphore */ -/* - RootDesc->OpenSemID = semget (IPC_PRIVATE, 1, 0777|IPC_CREAT|IPC_EXCL); - if (RootDesc->OpenSemID == -1) + + rootdesc_ptr->OpenSemId = semget( IPC_PRIVATE, 1, ( 0777 | IPC_CREAT | IPC_EXCL)); + if( rootdesc_ptr->OpenSemId == -1) { - switch (errno) + switch( errno) { case ENOMEM: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Create : the amount of memory is not sufficient to create a new semaphore"); + { + LG_LOG_ERROR_0( "Not enough memory to create a new semaphore"); + break; + } case ENOSPC: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Create : the number of semaphores exceeds the system-imposed limit"); + { + LG_LOG_ERROR_0( "The number of semaphores would exceeds the system-imposed limit"); + break; + } default: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Create : unknown error (%d) while creating a semaphore", errno); + { + LG_LOG_ERROR_1( "Unknown error: (%d) while creating a semaphore", errno); + break; + } } - DS_Error_Print (); - - return DSS_ERRSEM; + return( DSS_ERRSEM); } + /* Initialisation du sémaphore à 0 */ -/* - Sem_Ctl.val = 0; - if (semctl (RootDesc->OpenSemID, 0, SETVAL, Sem_Ctl)) + + sem_ctl.val = 0; + + if( semctl( rootdesc_ptr->OpenSemId, 0, SETVAL, sem_ctl)) { - sprintf (DS_Error_Msg, "Error DS_Semaphore_Create : unable to initialize the value of the semaphore %x", RootDesc->OpenSemID); - DS_Error_Print (); + LG_LOG_ERROR_1( "Unable to initialize the value of the semaphore: (%x)", rootdesc_ptr->OpenSemId); - semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); + semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, sem_ctl); - return DSS_ERRSEM; + return( DSS_ERRSEM); } - return DSS_OK; + return( DSS_OK); } + + /*----------------------------------------------------------------------------*/ /* Opération sur un sémaphore */ /*----------------------------------------------------------------------------*/ -/* -DST_Status DS_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned int Nb_Oper) + +DST_Status DS_Semaphore_Operate( int SemID, struct sembuf *Operations, unsigned int Nb_Oper) { - if (semop (SemID, Operations, Nb_Oper) == -1) + if( semop( SemID, Operations, Nb_Oper) == -1) { - switch (errno) + switch( errno) { case EAGAIN: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : the operation would result in suspension of the calling process but the operations have been defined in no wait mode"); + { + LG_LOG_ERROR_0( "The operation would result in suspension of the calling process but the operations have been defined in no wait mode"); + break; + } case EACCES: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : current process is not allowed to operate on semaphore %x", SemID); + { + LG_LOG_ERROR_1( "Current process is not allowed to operate on semaphore: (%x)", SemID); + break; + } case EIDRM: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : semaphore %x does not exist", SemID); + { + LG_LOG_ERROR_1( "Semaphore: (%x) does not exist", SemID); + break; + } case EINTR: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : a signal was received while operating on semaphore %x", SemID); - return DSS_ERRSIG; + { + LG_LOG_ERROR_1( "A signal was received while operating on semaphore: (%x)", SemID); + + return( DSS_ERRSIG); + } case EINVAL: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : the semaphore key %x is incorrect or the number of operations which can be done in UNDO mode exceeds the system-imposed limit", SemID); + { + LG_LOG_ERROR_1( "The semaphore key: (%x) is incorrect or the number of operations which can be done in UNDO mode exceeds the system-imposed limit", SemID); + break; + } case ENOSPC: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : the maximum number of process which can operate on semaphore in UNDO mode has been reached"); + { + LG_LOG_ERROR_0( "The maximum number of process which can operate on semaphore in UNDO mode has been reached"); + break; + } case ERANGE: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate: the value of semaphore %x has reached the system-imposed limit", SemID); + { + LG_LOG_ERROR_1( "The value of semaphore: (%x) has reached the system-imposed limit", SemID); + break; + } default: - sprintf (DS_Error_Msg, "Error DS_Semaphore_Operate : unknown error %d while operating on semaphore %x", errno, SemID); + { + LG_LOG_ERROR_2( "Unknown error: (%d) while operating on semaphore: (%x)", errno, SemID); + break; + } } - DS_Error_Print (); - - return DSS_ERRSEM; + return( DSS_ERRSEM); } - return DSS_OK; + return( DSS_OK); } + + /*----------------------------------------------------------------------------*/ /* Fonction manager de la liste des DS ouvertes */ /*----------------------------------------------------------------------------*/ @@ -3307,12 +3381,33 @@ NDT_Status DS_OpenedDS_List_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id ND_VA_LIST_CLOSE( user_args); */ + ND_VA_ARG_GET( Opened_DataStruct_Ptr_Ptr, *Args_Ptr, DST_DataStruct **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( DS_Name, user_args, char *); + ND_VA_ARG_GET( Root_Ptr, user_args, NDT_Root *); + + ND_VA_LIST_CLOSE( user_args); + Command_Name = "NDD_CMD_VALUE_ALLOC"; - LG_LOG_TRACE_0( LGD_LOG_LEVEL_DEFAULT, "CMD_VALUE_ALLOC called..."); + LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name); - return( DSS_OK); + if( ( *Opened_DataStruct_Ptr_Ptr = (DST_DataStruct *)malloc( sizeof( DST_DataStruct))) == NULL) + { + LG_LOG_ERROR_1( "Can't allocate value zise: (%d)", sizeof( DST_DataStruct)); + + return( DSS_KO); + } + else + { + ( *Opened_DataStruct_Ptr_Ptr)->Name = DS_Name; + ( *Opened_DataStruct_Ptr_Ptr)->Root_Ptr = Root_Ptr; + + return( DSS_OK); + } } case NDD_CMD_VALUE_FREE: @@ -3328,11 +3423,14 @@ NDT_Status DS_OpenedDS_List_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id ND_VA_LIST_CLOSE( user_args); */ - ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Opened_DataStruct_Ptr, *Args_Ptr, DST_DataStruct *); Command_Name = "NDD_CMD_VALUE_FREE"; + LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name); + + free( Opened_DataStruct_Ptr); /* DS_Free( Root_Ptr, Value_Ptr); */ diff --git a/lib/libdatastr.h b/lib/libdatastr.h index dcb964a..2923d7c 100644 --- a/lib/libdatastr.h +++ b/lib/libdatastr.h @@ -94,8 +94,8 @@ NDT_Root *OpenedDS_List; typedef struct DST_DataStruct { - NDT_Root *Root_Ptr; char *Name; + NDT_Root *Root_Ptr; } DST_DataStruct; @@ -109,12 +109,16 @@ typedef struct DST_DataStruct /*----------------------------------------------------------------------------*/ /* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ /*----------------------------------------------------------------------------*/ -DST_Status DS_Semaphore_Create (NDT_Root * Root); + +DST_Status DS_Semaphore_Create( NDT_Root *); + + /*----------------------------------------------------------------------------*/ /* Opération sur un sémaphore */ /*----------------------------------------------------------------------------*/ -DST_Status DS_Semaphore_Operate (int, struct sembuf *, unsigned int); + +DST_Status DS_Semaphore_Operate (int, struct sembuf *, unsigned int);