Rx3/libdatastr
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

- Succed to compile DS_DataStruct_Open_I() full implementation. Tests needed!

Browse Source
This commit is contained in:
Arnaud G. GIBERT 2024-04-27 20:00:00 +02:00
parent 0c06f14b49
commit d90beb9860
3 changed files with 206 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/datastr.h
View File

@ -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

296
lib/libdatastr.c
View File

@ -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);
*/

10
lib/libdatastr.h
View File

@ -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);