diff --git a/include/shmem.h b/include/shmem.h index 4b6da51..2f01b55 100644 --- a/include/shmem.h +++ b/include/shmem.h @@ -1,10 +1,10 @@ /*---------------------------------------------------------------------------------*/ /* $RCSfile: shmem.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.1 $ */ +/* $Revision: 2.2 $ */ /* $Name: $ */ -/* $Date: 2005/01/24 23:24:30 $ */ -/* $Author: agibert $ */ +/* $Date: 2005/02/23 23:31:06 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -175,13 +175,13 @@ extern "C" { /*------------------------------------------------------------------------------*/ typedef struct { - int SysMemID; /* ID de la 1ère zone de mémoire partagée de la base */ - int DataMemID; /* ID de la 2ème zone de mémoire partagée de la base */ + int SysMemId; /* Id de la 1ère zone de mémoire partagée de la base */ + int DataMemId; /* Id de la 2ème zone de mémoire partagée de la base */ size_t Size; /* Taille de la zone de mémoire partagée */ - int SemID; /* ID du sémaphore pour la gestion des verrous */ + int SemId; /* Id du sémaphore pour la gestion des verrous */ NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */ - pid_t Creator; /* ID du processus créateur de la base */ - pid_t Writer; /* ID du dernier processus ayant accédé en écriture à la base */ + pid_t Creator; /* Id du processus créateur de la base */ + pid_t Writer; /* Id du dernier processus ayant accédé en écriture à la base */ void * Free; /* Pointeur sur la première zone libre de la base */ void * Attach; /* Adresse du dernier attachement */ size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */ @@ -198,11 +198,11 @@ extern "C" { typedef struct { char Name [256]; /* Nom du heap */ - int SemID; /* ID du sémaphore pour la gestion des verrous */ + int SemId; /* Id du sémaphore pour la gestion des verrous */ NDT_Root * DSR; /* Data Segment Root */ NDT_Root * ACR; /* Allocated Chunks Root */ NDT_Root * FCR; /* Free Chunks Root */ - pid_t Writer; /* ID du processus ayant accédé en dernier au MHH en écriture */ + pid_t Writer; /* Id du processus ayant accédé en dernier au MHH en écriture */ int State; /* Etat d'un heap (valide, non validé ou corrompu) */ size_t Segment_Size; /* Taille des segments de mémoire composant le heap */ size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */ @@ -224,7 +224,7 @@ extern "C" { /*------------------------------------------------------------------------------*/ typedef struct { - int MemID; /* ID de la zone de mémoire partagée */ + int MemId; /* Id de la zone de mémoire partagée */ size_t Size; /* Taille de la zone de mémoire partagée */ void * Start; /* Adresse de début de la zone de mémoire partagée */ } SMT_DSH; diff --git a/lib/libshmem.c b/lib/libshmem.c index 888495c..5245643 100644 --- a/lib/libshmem.c +++ b/lib/libshmem.c @@ -1,10 +1,10 @@ /*---------------------------------------------------------------------------------*/ /* $RCSfile: libshmem.c,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.1 $ */ +/* $Revision: 2.2 $ */ /* $Name: $ */ -/* $Date: 2005/01/24 23:10:09 $ */ -/* $Author: agibert $ */ +/* $Date: 2005/02/23 23:31:06 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -36,7 +36,7 @@ #include #ifdef _LIBVER_SUPPORT -VER_INFO_EXPORT(libshmem,"$Revision: 2.1 $", "$Name: $",__FILE__,"$Author: agibert $") +VER_INFO_EXPORT(libshmem,"$Revision: 2.2 $", "$Name: $",__FILE__,"$Author: agibert $") #endif /*------------------------------------------------------------------------------*/ @@ -359,8 +359,8 @@ SMT_Status SM_Library_Dump_I( FILE *Out) { /* Affichage des informations sur la base */ - fprintf( Out, "Base [%d/%s] :\n\t- Size = %d bytes\n\t- Creator pid = %ld\n\t- Last write access pid = %ld\n\t- ID Mem = %d (+%d)\n\t- ID Sem = %d\n\t- Status = %s\n\n", - SM_Instance, SM_Context, SM_Base->Size, SM_Base->Creator, SM_Base->Writer, SM_Base->SysMemID, SM_Base->DataMemID, SM_Base->SemID, SM_Lock_Status_Get( "base", SM_Base)); + fprintf( Out, "Base [%d/%s] :\n\t- Size = %d bytes\n\t- Creator pid = %ld\n\t- Last write access pid = %ld\n\t- Id Mem = %d (+%d)\n\t- Id Sem = %d\n\t- Status = %s\n\n", + SM_Instance, SM_Context, SM_Base->Size, SM_Base->Creator, SM_Base->Writer, SM_Base->SysMemId, SM_Base->DataMemId, SM_Base->SemId, SM_Lock_Status_Get( "base", SM_Base)); /* Affichage des informations du MHR */ @@ -390,7 +390,7 @@ SMT_Status SM_Library_Unlock_I( void) Sem_Ctl.val = 1; - if( semctl( SM_Base->SemID, 0, SETVAL, Sem_Ctl)) + if( semctl( SM_Base->SemId, 0, SETVAL, Sem_Ctl)) { sprintf( SM_Error_Msg, "SM_Library_Free : unable to unlock the shared memory base"); SM_Error_Print(); @@ -408,7 +408,7 @@ SMT_Status SM_Library_Unlock_I( void) MHH = (SMT_MHH *)( Node->Value); - if( semctl( MHH->SemID, 0, SETVAL, Sem_Ctl)) + if( semctl( MHH->SemId, 0, SETVAL, Sem_Ctl)) { sprintf( SM_Error_Msg, "SM_Library_Free : unable to unlock heap \"%s\"", MHH->Name); SM_Error_Print(); @@ -516,7 +516,7 @@ SMT_Status SM_Heap_Open_I( const char *Heap_Name, SMT_Heap **Heap, size_t Se SMT_DSH *New_DSH; char *Prefixed_Name; union semun Sem_Ctl; - int SemID; + int SemId; SMT_Status rc; NDT_Index_Type index_type = ( NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO); @@ -648,8 +648,8 @@ SMT_Status SM_Heap_Open_I( const char *Heap_Name, SMT_Heap **Heap, size_t Se /* Création du sémaphore pour gérer les verrous sur le nouveau MHH */ - SemID = semget( IPC_PRIVATE, 1, 0777 | IPC_CREAT | IPC_EXCL); - if( SemID == -1) + SemId = semget( IPC_PRIVATE, 1, 0777 | IPC_CREAT | IPC_EXCL); + if( SemId == -1) { switch( errno) { @@ -681,9 +681,9 @@ SMT_Status SM_Heap_Open_I( const char *Heap_Name, SMT_Heap **Heap, size_t Se Sem_Ctl.val = 1; - if( semctl( SemID, 0, SETVAL, Sem_Ctl)) + if( semctl( SemId, 0, SETVAL, Sem_Ctl)) { - sprintf( SM_Error_Msg, "SM_Heap_Open : unable to initialize the value of the semaphore %d", SemID); + sprintf( SM_Error_Msg, "SM_Heap_Open : unable to initialize the value of the semaphore %d", SemId); SM_Error_Print(); rc = SMS_ERRSEM; @@ -705,7 +705,7 @@ SMT_Status SM_Heap_Open_I( const char *Heap_Name, SMT_Heap **Heap, size_t Se strcpy( MHH->Name, Prefixed_Name); MHH->Writer = getpid(); - MHH->SemID = SemID; + MHH->SemId = SemId; MHH->State = SMD_STATE_UNVALIDATED; MHH->Segment_Size = ( ( Seg_Size > 0) ? Seg_Size : SEGMENT_DEFAULT_SIZE); MHH->Limit_Size = SMD_UNLIMITED; @@ -869,7 +869,7 @@ SMT_Status SM_Heap_Open_I( const char *Heap_Name, SMT_Heap **Heap, size_t Se ND_Desallocator_Exec( MHH, SM_Base->MHR->Desallocator_Name, SM_Base->MHR->Desallocator_Ptr, NULL); Error3: - semctl( SemID, 0, IPC_RMID, Sem_Ctl); + semctl( SemId, 0, IPC_RMID, Sem_Ctl); return( rc); @@ -1267,7 +1267,7 @@ SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... ) { /* On contrôle que la limite fixée est inférieure à la taille actuelle du heap */ - rc = ND_DataStruct_Traverse (Heap->MHH->DSR, SMD_CMD_VALUE_SUM, (void *)&Current_Size); + rc = ND_DataStruct_Traverse (Heap->MHH->DSR, NDD_CMD_VALUE_SUM, (void *)&Current_Size); if (rc != NDS_OK) return rc; if (Current_Size > Size) @@ -2269,7 +2269,7 @@ SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... ) { /* On contrôle que la limite fixée est inférieure à la taille actuelle du heap */ - rc = ND_DataStruct_Traverse (Heap->MHH->DSR, SMD_CMD_VALUE_SUM, (void *)&Current_Size); + rc = ND_DataStruct_Traverse (Heap->MHH->DSR, NDD_CMD_VALUE_SUM, (void *)&Current_Size); if (rc != NDS_OK) return rc; if (Current_Size > Limit_Size) @@ -2537,9 +2537,9 @@ NDT_Status SM_System_Free( void *Ptr, void *Data_Ptr) SMT_Status SM_Base_Init ( void ) { SMT_Status rc; - int SemID; - int SysMemID; - int DataMemID; + int SemId; + int SysMemId; + int DataMemId; union semun Sem_Ctl; size_t Size; int Locked; @@ -2548,8 +2548,8 @@ SMT_Status SM_Base_Init ( void ) /* Création du sémaphore pour la gestion des verrous sur la base */ - SemID = semget (IPC_PRIVATE, 1, 0777|IPC_CREAT|IPC_EXCL); - if (SemID == -1) + SemId = semget (IPC_PRIVATE, 1, 0777|IPC_CREAT|IPC_EXCL); + if (SemId == -1) { switch (errno) { @@ -2575,9 +2575,9 @@ SMT_Status SM_Base_Init ( void ) Sem_Ctl.val = 1; - if (semctl (SemID, 0, SETVAL, Sem_Ctl )) + if (semctl (SemId, 0, SETVAL, Sem_Ctl )) { - sprintf (SM_Error_Msg, "SM_Base_Init : unable to initialize the value of semaphore %d", SemID); + sprintf (SM_Error_Msg, "SM_Base_Init : unable to initialize the value of semaphore %d", SemId); SM_Error_Print (); rc = SMS_ERRSEM; @@ -2589,8 +2589,8 @@ SMT_Status SM_Base_Init ( void ) Ce segment peut être attaché à n'importe quelle adresse. */ - SysMemID = shmget (SM_Instance, (int) sizeof (SMT_Base), 0777|IPC_CREAT|IPC_EXCL); - if (SysMemID == -1) + SysMemId = shmget (SM_Instance, (int) sizeof (SMT_Base), 0777|IPC_CREAT|IPC_EXCL); + if (SysMemId == -1) { switch (errno) { @@ -2624,7 +2624,7 @@ SMT_Status SM_Base_Init ( void ) /* On attache le segment de mémoire partagée au processus courant */ errno = 0; - SM_Base = shmat (SysMemID, 0, 0); + SM_Base = shmat (SysMemId, 0, 0); if (errno) { sprintf (SM_Error_Msg, "SM_Base_Init : unable to attach the first shared memory segment to the current process (error %d)", errno); @@ -2657,8 +2657,8 @@ SMT_Status SM_Base_Init ( void ) Size = sizeof (NDT_Root) + sizeof (NDT_Node) + sizeof (SMT_MHH) + 3 * sizeof (NDT_Root) + sizeof (NDT_Node) + sizeof (SMT_DSH); - DataMemID = shmget (IPC_PRIVATE, Size, 0777|IPC_CREAT|IPC_EXCL); - if (DataMemID == -1) + DataMemId = shmget (IPC_PRIVATE, Size, 0777|IPC_CREAT|IPC_EXCL); + if (DataMemId == -1) { switch (errno) { @@ -2687,9 +2687,9 @@ SMT_Status SM_Base_Init ( void ) /* Initialisation des informations rattachées à la base */ - SM_Base->SemID = SemID; - SM_Base->SysMemID = SysMemID; - SM_Base->DataMemID = DataMemID; + SM_Base->SemId = SemId; + SM_Base->SysMemId = SysMemId; + SM_Base->DataMemId = DataMemId; SM_Base->Size = Size; SM_Base->Creator = getpid (); SM_Base->Writer = SM_Base->Creator; @@ -2703,7 +2703,7 @@ SMT_Status SM_Base_Init ( void ) */ errno = 0; - SM_Base->Free = shmat (DataMemID, (void *)((size_t)(SM_Base->Attach) - Size), SHM_RND); + SM_Base->Free = shmat (DataMemId, (void *)((size_t)(SM_Base->Attach) - Size), SHM_RND); if (errno) { sprintf (SM_Error_Msg, "SM_Base_Init : unable to attach the second shared memory segment to the current process (error %d)", errno); @@ -2784,13 +2784,13 @@ SMT_Status SM_Base_Init ( void ) Error4: shmdt ((void *)(SM_Base->Free)); Error3: - shmctl (DataMemID, IPC_RMID, 0); + shmctl (DataMemId, IPC_RMID, 0); Error2: shmdt ((void *)SM_Base); - shmctl (SysMemID, IPC_RMID, 0); + shmctl (SysMemId, IPC_RMID, 0); SM_Base = NULL; Error1: - semctl (SemID, 0, IPC_RMID, Sem_Ctl); + semctl (SemId, 0, IPC_RMID, Sem_Ctl); return rc; } @@ -2805,8 +2805,8 @@ SMT_Status SM_Base_Init ( void ) SMT_Status SM_Base_End ( void ) { - int SemID; - int SysMemID, DataMemID; + int SemId; + int SysMemId, DataMemId; SMT_Status rc; union semun Sem_Ctl; NDT_Node * Node, * Previous_Node; @@ -2891,26 +2891,26 @@ SMT_Status SM_Base_End ( void ) Node = Previous_Node; } - SemID = SM_Base->SemID; - SysMemID = SM_Base->SysMemID; - DataMemID = SM_Base->DataMemID; + SemId = SM_Base->SemId; + SysMemId = SM_Base->SysMemId; + DataMemId = SM_Base->DataMemId; /* Destruction des segments de mémoire partagée de la base */ - if (shmctl (DataMemID, IPC_RMID, 0) == -1 || shmctl (SysMemID, IPC_RMID, 0) == -1) + if (shmctl (DataMemId, IPC_RMID, 0) == -1 || shmctl (SysMemId, IPC_RMID, 0) == -1) { switch (errno) { case EPERM: - sprintf (SM_Error_Msg, "SM_Base_End : current process (%d) is not allowed to destroy the shared memory segment %d or %d", (int)getpid (), SysMemID, DataMemID); + sprintf (SM_Error_Msg, "SM_Base_End : current process (%d) is not allowed to destroy the shared memory segment %d or %d", (int)getpid (), SysMemId, DataMemId); break; case EINVAL: - sprintf (SM_Error_Msg, "SM_Base_End : no shared memory segment exists for identifier %d or %d", SysMemID, DataMemID); + sprintf (SM_Error_Msg, "SM_Base_End : no shared memory segment exists for identifier %d or %d", SysMemId, DataMemId); break; default : - sprintf (SM_Error_Msg, "SM_Base_End : unknown error (%d) while destroying the shared memory segment %d or %d", errno, SysMemID, DataMemID); + sprintf (SM_Error_Msg, "SM_Base_End : unknown error (%d) while destroying the shared memory segment %d or %d", errno, SysMemId, DataMemId); break; } @@ -2926,20 +2926,20 @@ SMT_Status SM_Base_End ( void ) /* Destruction du sémaphore de gestion des verrous sur la base */ - if (semctl (SemID, 0, IPC_RMID, Sem_Ctl) == -1) + if (semctl (SemId, 0, IPC_RMID, Sem_Ctl) == -1) { switch (errno) { case EPERM: - sprintf (SM_Error_Msg, "SM_Base_End : current process (%d) is not allowed to destroy semaphore %d", (int)getpid (), SemID); + sprintf (SM_Error_Msg, "SM_Base_End : current process (%d) is not allowed to destroy semaphore %d", (int)getpid (), SemId); break; case EINVAL: - sprintf (SM_Error_Msg, "SM_Base_End : no semaphore corresponds to the identifier %d", SemID); + sprintf (SM_Error_Msg, "SM_Base_End : no semaphore corresponds to the identifier %d", SemId); break; default : - sprintf (SM_Error_Msg, "SM_Base_End : unknown error (%d) while destroying semaphore %d", errno, SemID); + sprintf (SM_Error_Msg, "SM_Base_End : unknown error (%d) while destroying semaphore %d", errno, SemId); break; } @@ -2963,7 +2963,7 @@ SMT_Status SM_Base_Open ( void ) { SMT_Status rc; void * Ptr; - int MemID; + int MemId; int Locked; @@ -2971,8 +2971,8 @@ SMT_Status SM_Base_Open ( void ) /* Récupération de l'identifiant du segment de mémoire partagée de la base */ - MemID = shmget (SM_Instance, 0, 0); - if (MemID == -1) + MemId = shmget (SM_Instance, 0, 0); + if (MemId == -1) { switch (errno) { @@ -3001,7 +3001,7 @@ SMT_Status SM_Base_Open ( void ) /* On attache les segments de mémoire partagée de la base */ errno = 0; - SM_Base = shmat (MemID, 0, 0); + SM_Base = shmat (MemId, 0, 0); if (errno) { sprintf (SM_Error_Msg, "SM_Base_Open : unable to attach the shared memory segment to the current process (error %d)", errno); @@ -3013,7 +3013,7 @@ SMT_Status SM_Base_Open ( void ) } errno = 0; - Ptr = shmat (SM_Base->DataMemID, SM_Base->MHR, 0); + Ptr = shmat (SM_Base->DataMemId, SM_Base->MHR, 0); if (errno) { sprintf (SM_Error_Msg, "SM_Base_Open : unable to attach the shared memory segment to the current process at the specified address %p (error %d)", SM_Base->MHR, errno); @@ -3121,7 +3121,7 @@ SMT_Status SM_Base_Lock ( SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_READ) { - rc = SM_Semaphore_Operate (SM_Base->SemID, SM_SemOp_SSL, 2); + rc = SM_Semaphore_Operate (SM_Base->SemId, SM_SemOp_SSL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Base_Lock : unable to lock the library base for reading"); @@ -3133,7 +3133,7 @@ SMT_Status SM_Base_Lock ( SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_WRITE) { - rc = SM_Semaphore_Operate (SM_Base->SemID, SM_SemOp_SEL, 2); + rc = SM_Semaphore_Operate (SM_Base->SemId, SM_SemOp_SEL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Base_Lock : unable to lock the library base for writing"); @@ -3160,7 +3160,7 @@ SMT_Status SM_Base_Unlock ( SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_READ) { - rc = SM_Semaphore_Operate (SM_Base->SemID, SM_SemOp_RSL, 2); + rc = SM_Semaphore_Operate (SM_Base->SemId, SM_SemOp_RSL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Base_Unlock : unable to unlock the library base which had been locked for reading"); @@ -3172,7 +3172,7 @@ SMT_Status SM_Base_Unlock ( SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_WRITE) { - rc = SM_Semaphore_Operate (SM_Base->SemID, SM_SemOp_REL, 2); + rc = SM_Semaphore_Operate (SM_Base->SemId, SM_SemOp_REL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Base_Unlock : unable to unlock the library base which had been locked for writing"); @@ -3193,40 +3193,223 @@ SMT_Status SM_Base_Unlock ( SMT_Flags Lock_Mode ) /* Fonction manager de la liste des heaps ouverts */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_Opened_Heap_List_Manager (va_list Args) +NDT_Status SM_Opened_Heap_List_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) { - NDT_Command Command = (NDT_Command)va_arg (Args, NDT_Command); + NDT_Command_Name Command_Name; - if (Command == NDD_CMD_VALUE_COMP) + switch( Command) { - SMT_Heap * Heap1, * Heap2; - long comp; + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); - Heap1 = (SMT_Heap *)va_arg (Args, void *); - Heap2 = (SMT_Heap *)va_arg (Args, void *); - va_end (Args); + Command_Name = "NDD_CMD_MANAGER_VERSION"; - comp = strcmp (Heap1->Name, Heap2->Name); + *Version_Name_Ptr = "$Revision: 2.2 $ $Name: $ $Date: 2005/02/23 23:31:06 $ $Author: agibert $"; - if (comp < 0) return NDS_LOWER; + return( NDS_OK); + } - if (comp > 0) return NDS_GREATER; + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ - return NDS_EQUAL; + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch( Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_Heap *Heap_Ptr = (SMT_Heap *)va_arg( Args, SMT_Heap *); + + + Command_Name = "NDD_CMD_VALUE_FREE"; + + free( Heap_Ptr->Name); + free( Heap_Ptr); + + return( NDS_OK); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_Heap *Heap1_Ptr = (SMT_Heap *)va_arg( Args, SMT_Heap *); + SMT_Heap *Heap2_Ptr = (SMT_Heap *)va_arg( Args, SMT_Heap *); + + long comp; + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + comp = strcmp( Heap1_Ptr->Name, Heap2_Ptr->Name); + + if( comp < 0) return( NDS_LOWER); + + if( comp > 0) return( NDS_GREATER); + + return( NDS_EQUAL); + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + SMT_Heap *Heap_Ptr = ( SMT_Heap *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + fprintf( Out, "Heap_Name: [%s]/[%s] Heap_Addr: (%p) MHH_Ptr: (%p) Lock_Mode: (%d) Seg_Nb: (%d)\n", + SM_Context, Heap_Ptr->Name, Heap_Ptr, Heap_Ptr->MHH, Heap_Ptr->Lock_Mode, Heap_Ptr->Nb_Seg); + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + return( NDS_OK); + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); + } } - if (Command == NDD_CMD_VALUE_FREE) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - SMT_Heap * Heap = (SMT_Heap *) va_arg (Args, void *); - - free (Heap->Name); - free (Heap); - } - - return NDS_OK; + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -3237,103 +3420,284 @@ NDT_Status SM_Opened_Heap_List_Manager (va_list Args) /* Fonction manager du MHR (Memory Heap Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status MHR_Manager (va_list Args) +NDT_Status MHR_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) { - SMT_Status rc; - NDT_Command Command = (NDT_Command)va_arg (Args, NDT_Command); + NDT_Command_Name Command_Name; - if (Command == NDD_CMD_VALUE_PRINT) + + switch( Command) { - SMT_MHH * MHH = (SMT_MHH *)va_arg (Args, void *); - FILE * Out = va_arg (Args, FILE *); - size_t Segment_Size; - size_t Alloc_Size; - size_t Free_Size; - int Nb_Segment; - int Nb_Alloc_Chunk; - int Nb_Free_Chunk; - SMT_Heap * Heap; - int Locked; - char * ptr; + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); - /* On n'affiche le heap que s'il fait partie du contexte courant */ - ptr = strstr (MHH->Name, SM_Context); - if (ptr) ptr += strlen (SM_Context) + 1; - else if (!strcmp (HEAP_SYSTEM, MHH->Name)) ptr = MHH->Name; - else return SMS_KO; + Command_Name = "NDD_CMD_MANAGER_VERSION"; - if (MHH->State == SMD_STATE_CORRUPTED) + *Version_Name_Ptr = "$Revision: 2.2 $ $Name: $ $Date: 2005/02/23 23:31:06 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: { - fprintf (Out, "Heap \"%s\" : *** CORRUPTED *** (checked by process %ld)", MHH->Name, MHH->Writer); + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ - return NDS_OK; + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch( Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); } - rc = SM_Heap_Open_I (ptr, &Heap, 0, SMD_OPEN | SMD_READ, &Locked); - if (rc != SMS_OK) + case NDD_CMD_VALUE_ALLOC: { - sprintf (SM_Error_Msg, "Error MHR_Manager : unable to open heap \"%s\" for reading", MHH->Name); - SM_Error_Print (); + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ - return rc; + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); } - Nb_Segment = MHH->DSR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; - ND_DataStruct_Traverse (MHH->DSR, SMD_CMD_VALUE_SUM, (void *)&Segment_Size); + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ - Nb_Alloc_Chunk = MHH->ACR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; - ND_DataStruct_Traverse (MHH->ACR, SMD_CMD_VALUE_SUM, (void *)&Alloc_Size); + SMT_MHH *MHH_Ptr = (SMT_MHH *)va_arg( Args, SMT_MHH *); - Nb_Free_Chunk = MHH->FCR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; - ND_DataStruct_Traverse (MHH->FCR, SMD_CMD_VALUE_SUM, (void *)&Free_Size); - fprintf (Out, "Heap \"%s\" :\n\t- Last write access pid = %ld\n\t- ID Sem = %d\n\t- Status = %s\n\t- Data = %d segment(s) - %d bytes\n\t- Allocated = %d chunk(s) - %d bytes\n\t- Free = %d chunk(s) - %d bytes", - ptr, MHH->Writer, MHH->SemID, SM_Lock_Status_Get ("heap", MHH), Nb_Segment, Segment_Size, Nb_Alloc_Chunk, Alloc_Size, Nb_Free_Chunk, Free_Size); + Command_Name = "NDD_CMD_VALUE_FREE"; - if (Locked == TRUE) SM_Heap_Unlock_I (Heap); - return NDS_OK; + return( SM_MHH_End( MHH_Ptr)); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_MHH *MHH1_Ptr = (SMT_MHH *)va_arg( Args, SMT_MHH *); + SMT_MHH *MHH2_Ptr = (SMT_MHH *)va_arg( Args, SMT_MHH *); + + long comp; + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + comp = strcmp( MHH1_Ptr->Name, MHH2_Ptr->Name); + + if( comp < 0) return( NDS_LOWER); + + if( comp > 0) return( NDS_GREATER); + + return( NDS_EQUAL); + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + SMT_MHH *MHH_Ptr = (SMT_MHH *)( Node_Ptr->Value); + + SMT_Status status; + size_t segment_size, alloc_size, free_size; + int segment_nb, alloc_chunk_nb, free_chunk_nb; + SMT_Heap *heap_ptr; + char *heap_name; + int locked; + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + /* On n'affiche le heap que s'il fait partie du contexte courant */ + + if( ( heap_name = strstr( MHH_Ptr->Name, SM_Context)) != 0) + { + heap_name += strlen( SM_Context) + 1; + } + else + { + if( strcmp( HEAP_SYSTEM, MHH_Ptr->Name) == 0) + { + heap_name = MHH_Ptr->Name; + } + else + { + return( NDS_OK); + } + } + + if( MHH_Ptr->State == SMD_STATE_CORRUPTED) + { + fprintf( Out, "Heap_Name: [%s]/[%s] Heap_Addr: (%lx) *** CORRUPTED *** Checker_PId: (%ld)\n", + SM_Context, MHH_Ptr->Name, MHH_Ptr, MHH_Ptr->Writer); + + return( NDS_OK); + } + + if( status = ( SM_Heap_Open_I( heap_name, &heap_ptr, 0, ( SMD_OPEN | SMD_READ), &locked)) != SMS_OK) + { + sprintf( SM_Error_Msg, "Error MHR_Manager : unable to open Heap_Name: [%s] for reading", MHH_Ptr->Name); + SM_Error_Print(); + + return( status); + } + + segment_nb = MHH_Ptr->DSR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; + ND_DataStruct_Traverse( MHH_Ptr->DSR, NDD_CMD_VALUE_SUM, (void *)&segment_size); + + alloc_chunk_nb = MHH_Ptr->ACR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; + ND_DataStruct_Traverse( MHH_Ptr->ACR, NDD_CMD_VALUE_SUM, (void *)&alloc_size); + + free_chunk_nb = MHH_Ptr->FCR->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; + ND_DataStruct_Traverse( MHH_Ptr->FCR, NDD_CMD_VALUE_SUM, (void *)&free_size); + + fprintf( Out, "Heap_Name: [%s]/[%s] Heap_Addr: (%p) Sem_Id: (%d) Lock_Status: [%s]\n\tWriter_PId: (%ld) Size_Limit: (%ld) Auto_Compress: (%d) Seg_Nb: (%d) Heap_Size: (%ld)\n\tAlloc_Chunk_Nb: (%d) Alloc_Size: (%ld) Free_Chunk_Nb: (%d) Free_Size: (%ld)\n\n", + SM_Context, heap_name, MHH_Ptr, MHH_Ptr->SemId, SM_Lock_Status_Get( "heap", MHH_Ptr), MHH_Ptr->Writer, MHH_Ptr->Limit_Size, MHH_Ptr->Auto_Compress, + segment_nb, segment_size, alloc_chunk_nb, alloc_size, free_chunk_nb, free_size); + + if( locked == TRUE) + { + SM_Heap_Unlock_I( heap_ptr); + } + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + return( NDS_OK); + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); + } } - if (Command == NDD_CMD_INFO_PRINT) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, SM_Root_Description_Get ("Memory Heap Root", Root)); - - return NDS_OK; - } - - if (Command == NDD_CMD_VALUE_COMP) - { - SMT_MHH * MHH1, * MHH2; - long comp; - - MHH1 = (SMT_MHH *)va_arg (Args, void *); - MHH2 = (SMT_MHH *)va_arg (Args, void *); - - va_end (Args); - - comp = strcmp (MHH1->Name, MHH2->Name); - - if (comp < 0)return NDS_LOWER; - - if (comp > 0) return NDS_GREATER; - - return NDS_EQUAL; - } - - if (Command == NDD_CMD_VALUE_FREE) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - SMT_MHH * MHH = (SMT_MHH *)va_arg (Args, void *); - - return SM_MHH_End (MHH); - } - - return NDS_OK; + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -3344,13 +3708,14 @@ NDT_Status MHR_Manager (va_list Args) /* Destruction d'un MHH (Memory Heap Header) */ /*------------------------------------------------------------------------------*/ -SMT_Status SM_MHH_End ( SMT_MHH * MHH) +SMT_Status SM_MHH_End( SMT_MHH *MHH) { SMT_Status rc; SMT_Heap To_Find; union semun Sem_Ctl; SMT_Heap * Opened_Heap; + /* Destruction de la structure DSR (et de toutes ses valeurs) */ if (!strcmp (MHH->Name, HEAP_SYSTEM)) @@ -3466,7 +3831,7 @@ SMT_Status SM_MHH_End ( SMT_MHH * MHH) /* Destruction du sémaphore attaché au heap */ - semctl (MHH->SemID, 0, IPC_RMID, Sem_Ctl); + semctl (MHH->SemId, 0, IPC_RMID, Sem_Ctl); /* Désallocation de la structure du MHH */ @@ -3496,68 +3861,254 @@ SMT_Status SM_MHH_End ( SMT_MHH * MHH) /* Fonction manager pour un DSR (Data Segment Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_DSR_Manager (va_list Args) +NDT_Status SM_DSR_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) { - NDT_Command Command = (NDT_Command)va_arg (Args, NDT_Command); + NDT_Command_Name Command_Name; - if (Command == SMD_CMD_VALUE_SUM) + + switch( Command) { - SMT_DSH * DSH = (SMT_DSH *)va_arg (Args, void *); - int * Total_Size = (int *)va_arg (Args, int *); + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); - (*Total_Size) += DSH->Size; - return NDS_OK; + Command_Name = "NDD_CMD_MANAGER_VERSION"; + + *Version_Name_Ptr = "$Revision: 2.2 $ $Name: $ $Date: 2005/02/23 23:31:06 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ + + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch( Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_DSH *DSH_Ptr = (SMT_DSH *)va_arg( Args, SMT_DSH *); + + + Command_Name = "NDD_CMD_VALUE_FREE"; + + + return( SM_DataSegment_End( Root_Ptr, DSH_Ptr)); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_DSH *DSH1_Ptr = (SMT_DSH *)va_arg( Args, SMT_DSH *); + SMT_DSH *DSH2_Ptr = (SMT_DSH *)va_arg( Args, SMT_DSH *); + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + if( DSH1_Ptr->MemId < DSH2_Ptr->MemId) return( NDS_LOWER); + + if( DSH1_Ptr->MemId > DSH2_Ptr->MemId) return( NDS_GREATER); + + return( NDS_EQUAL); + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + SMT_DSH *DSH_Ptr = (SMT_DSH *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + fprintf( Out, "Data Segment Header: Mem_Id: (%d) Start: (%p) Size: (%ld)\n", + DSH_Ptr->MemId, DSH_Ptr->Start, DSH_Ptr->Size); + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_SUM: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list user_args = (va_list)va_arg( Args, va_list); + size_t *Total_Size = (size_t *)va_arg( user_args, size_t *); + + SMT_DSH *DSH_Ptr = (SMT_DSH *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_SUM"; + + *Total_Size += DSH_Ptr->Size; + + return( NDS_OK); + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); + } } - if (Command == NDD_CMD_VALUE_PRINT) - { - SMT_DSH * DSH = (SMT_DSH *)va_arg (Args, void *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, "Data Segment Header :\n\t- ID Mem = %d\n\t- Start = %p\n\t- Size = %d bytes", - DSH->MemID, DSH->Start, DSH->Size); - - return NDS_OK; - } - - if (Command == NDD_CMD_INFO_PRINT) - { - NDT_Root * Root = Root = va_arg (Args, NDT_Root *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, SM_Root_Description_Get ("Data Segment Root", Root)); - - return NDS_OK; - - } - - if (Command == NDD_CMD_VALUE_COMP) - { - int comp; - - SMT_DSH * DSH1 = (SMT_DSH *)va_arg (Args, void *); - SMT_DSH * DSH2 = (SMT_DSH *)va_arg (Args, void *); - - va_end (Args); - - comp = (unsigned int)DSH1 - (unsigned int)DSH2; - - if (comp < 0) return NDS_LOWER; - if (comp > 0) return NDS_GREATER; - return NDS_EQUAL; - - } - - if (Command == NDD_CMD_VALUE_FREE) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - SMT_DSH * DSH = (SMT_DSH *)va_arg (Args, void *); - - return SM_DataSegment_End (Root, DSH); - } - - return NDS_OK; + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -3580,7 +4131,7 @@ SMT_DSH * SM_DataSegment_Init ( SMT_MHH * MHH, size_t Segment_Size) { size_t Current_Size; - ND_DataStruct_Traverse (MHH->DSR, SMD_CMD_VALUE_SUM, (void *)&Current_Size); + ND_DataStruct_Traverse (MHH->DSR, NDD_CMD_VALUE_SUM, (void *)&Current_Size); if (Current_Size + Segment_Size > MHH->Limit_Size) { @@ -3603,7 +4154,7 @@ SMT_DSH * SM_DataSegment_Init ( SMT_MHH * MHH, size_t Segment_Size) /* Création d'un segment de mémoire partagée */ - if ((New_DSH->MemID = shmget (IPC_PRIVATE, Segment_Size, 0777|IPC_CREAT|IPC_EXCL)) == -1) + if ((New_DSH->MemId = shmget (IPC_PRIVATE, Segment_Size, 0777|IPC_CREAT|IPC_EXCL)) == -1) { switch (errno) { @@ -3634,13 +4185,13 @@ SMT_DSH * SM_DataSegment_Init ( SMT_MHH * MHH, size_t Segment_Size) /* On attache le segment de mémoire partagée au processus courant */ errno = 0; - New_DSH->Start = shmat (New_DSH->MemID, (void *)((size_t)(SM_Base->Attach) - Segment_Size), SHM_RND); + New_DSH->Start = shmat (New_DSH->MemId, (void *)((size_t)(SM_Base->Attach) - Segment_Size), SHM_RND); if (errno) { sprintf (SM_Error_Msg, "SM_DataSegment_Init : unable to attach the shared memory segment to the current process (error %d)", errno); SM_Error_Print (); - shmctl (New_DSH->MemID, IPC_RMID, 0); + shmctl (New_DSH->MemId, IPC_RMID, 0); ND_Desallocator_Exec( New_DSH, MHH->DSR->Desallocator_Name, MHH->DSR->Desallocator_Ptr, NULL); @@ -3672,7 +4223,7 @@ SMT_DSH * SM_DataSegment_Init ( SMT_MHH * MHH, size_t Segment_Size) sprintf (SM_Error_Msg, "SM_DataSegment_Init : unable to add a first chunk to the FCR structure of heap \"%s\"", MHH->Name); SM_Error_Print (); - shmctl (New_DSH->MemID, IPC_RMID, 0); + shmctl (New_DSH->MemId, IPC_RMID, 0); ND_Desallocator_Exec( New_DSH, MHH->DSR->Desallocator_Name, MHH->DSR->Desallocator_Ptr, NULL); @@ -3696,20 +4247,20 @@ SMT_Status SM_DataSegment_End (NDT_Root * Root, SMT_DSH *DSH) /* Destruction du segment de mémoire partagée du segment de données */ - if (shmctl (DSH->MemID, IPC_RMID, 0) == -1) + if (shmctl (DSH->MemId, IPC_RMID, 0) == -1) { switch (errno) { case EPERM: - sprintf (SM_Error_Msg, "SM_DataSegment_End : current process (%d) is not allowed to destroy the shared memory segment %d", (int)getpid (), DSH->MemID); + sprintf (SM_Error_Msg, "SM_DataSegment_End : current process (%d) is not allowed to destroy the shared memory segment %d", (int)getpid (), DSH->MemId); break; case EINVAL: - sprintf (SM_Error_Msg, "SM_DataSegment_End : no shared memory segment exists for identifier %d", DSH->MemID); + sprintf (SM_Error_Msg, "SM_DataSegment_End : no shared memory segment exists for identifier %d", DSH->MemId); break; default : - sprintf (SM_Error_Msg, "SM_DataSegment_End : unknown error %d while destroying the shared memory segment %d", errno, DSH->MemID); + sprintf (SM_Error_Msg, "SM_DataSegment_End : unknown error %d while destroying the shared memory segment %d", errno, DSH->MemId); break; } @@ -3755,7 +4306,7 @@ SMT_Status SM_DataSegment_Open ( SMT_DSH *DSH) shmdt ((void *)DSH->Start); errno = 0; - Ptr = shmat (DSH->MemID, DSH->Start, 0); + Ptr = shmat (DSH->MemId, DSH->Start, 0); if (errno) { sprintf (SM_Error_Msg, "SM_DataSegment_Open : unable to attach the shared memory segment at the specified address %p (error %d)", DSH->Start, errno); @@ -3870,58 +4421,252 @@ size_t SM_DataSegment_Compress ( SMT_DSH *DSH, NDT_Root *FCR) /* Fonction manager pour un ACR (Allocated Chunk Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_ACR_Manager (va_list Args) +NDT_Status SM_ACR_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) { - NDT_Command Command = (NDT_Command)va_arg (Args, NDT_Command); + NDT_Command_Name Command_Name; - if (Command == SMD_CMD_VALUE_SUM) + + switch( Command) { - SMT_Chunk * Chunk = (SMT_Chunk *)va_arg (Args, void *); - int * Total_Size = (int *)va_arg (Args, int *); + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); - (*Total_Size) += Chunk->Size; - return NDS_OK; + Command_Name = "NDD_CMD_MANAGER_VERSION"; + + *Version_Name_Ptr = "$Revision: 2.2 $ $Name: $ $Date: 2005/02/23 23:31:06 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ + + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch( Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + Command_Name = "NDD_CMD_VALUE_FREE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_Chunk *Chunk1_Ptr = (SMT_Chunk *)va_arg( Args, SMT_Chunk *); + SMT_Chunk *Chunk2_Ptr = (SMT_Chunk *)va_arg( Args, SMT_Chunk *); + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + /* Les chunks alloués sont triés sur le champ (adresse d'allocation) */ + + if( Chunk1_Ptr->Data < Chunk1_Ptr->Data) return( NDS_LOWER); + + if( Chunk1_Ptr->Data > Chunk2_Ptr->Data) return( NDS_GREATER); + + return( NDS_EQUAL); + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + SMT_Chunk *Chunk_Ptr = (SMT_Chunk *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + fprintf( Out, "Allocated Chunk: Chunk_Addr: (%p) Data_Addr: (%p) Data_Size: (%ld)\n", + Chunk_Ptr, Chunk_Ptr->Data, Chunk_Ptr->Size); + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_SUM: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list user_args = (va_list)va_arg( Args, va_list); + size_t *Total_Size = (size_t *)va_arg( user_args, size_t *); + + SMT_Chunk *Chunk_Ptr = (SMT_Chunk *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_SUM"; + + *Total_Size += Chunk_Ptr->Size; + + return( NDS_OK); + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); + } } - if (Command == NDD_CMD_VALUE_PRINT) - { - SMT_Chunk *Chunk = (SMT_Chunk *)va_arg (Args, void *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, "Allocated chunk :\n\t- Size = %d\n\t- Data = %p", Chunk->Size, Chunk->Data); - - return NDS_OK; - } - - if (Command == NDD_CMD_INFO_PRINT) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, SM_Root_Description_Get ("Allocated Chunk Root", Root)); - - return NDS_OK; - } - - if (Command == NDD_CMD_VALUE_COMP) - { - int comp; - SMT_Chunk *Chunk1 = (SMT_Chunk *)va_arg (Args, void *); - SMT_Chunk *Chunk2 = (SMT_Chunk *)va_arg (Args, void *); - - va_end (Args); - - /* Les chunks alloués sont triés sur le champ (adresse d'allocation) */ - - comp = (unsigned int)Chunk1->Data - (unsigned int)Chunk2->Data; - - if (comp < 0) return NDS_LOWER; - if (comp > 0) return NDS_GREATER; - return NDS_EQUAL; - } - - return NDS_OK; + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -3932,61 +4677,255 @@ NDT_Status SM_ACR_Manager (va_list Args) /* Fonction manager pour un FCR (Free Chunk Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_FCR_Manager (va_list Args) +NDT_Status SM_FCR_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) { - NDT_Command Command = (NDT_Command)va_arg (Args, NDT_Command); + NDT_Command_Name Command_Name; - if (Command == SMD_CMD_VALUE_SUM) + + switch( Command) { - SMT_Chunk * Chunk = (SMT_Chunk *)va_arg (Args, void *); - int * Total_Size = (int *)va_arg (Args, int *); + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); - (*Total_Size) += Chunk->Size; - return NDS_OK; + Command_Name = "NDD_CMD_MANAGER_VERSION"; + + *Version_Name_Ptr = "$Revision: 2.2 $ $Name: $ $Date: 2005/02/23 23:31:06 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ + + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch( Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + Command_Name = "NDD_CMD_VALUE_FREE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + SMT_Chunk *Chunk1_Ptr = (SMT_Chunk *)va_arg( Args, SMT_Chunk *); + SMT_Chunk *Chunk2_Ptr = (SMT_Chunk *)va_arg( Args, SMT_Chunk *); + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + /* + La comparaison des chunks libres porte sur le champ + pour faciliter la compression des heaps. + */ + + if( Chunk1_Ptr->Data < Chunk1_Ptr->Data) return( NDS_LOWER); + + if( Chunk1_Ptr->Data > Chunk2_Ptr->Data) return( NDS_GREATER); + + return( NDS_EQUAL); + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + SMT_Chunk *Chunk_Ptr = (SMT_Chunk *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + fprintf( Out, "Free Chunk: Chunk_Addr: (%p) Data_Ptr: (%p) Size: (%ld)\n", Chunk_Ptr, Chunk_Ptr->Data, Chunk_Ptr->Size); + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + + return( NDS_OK); + } + + case NDD_CMD_VALUE_SUM: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list user_args = (va_list)va_arg( Args, va_list); + size_t *Total_Size = (size_t *)va_arg( user_args, size_t *); + + SMT_Chunk *Chunk_Ptr = (SMT_Chunk *)( Node_Ptr->Value); + + + Command_Name = "NDD_CMD_VALUE_SUM"; + + *Total_Size += Chunk_Ptr->Size; + + return( NDS_OK); + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); + } } - if (Command == NDD_CMD_VALUE_PRINT) - { - SMT_Chunk * Chunk = (SMT_Chunk *)va_arg (Args, void *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, "Free Chunk :\n\t- Size = %d\n\t- Data = %p", Chunk->Size, Chunk->Data); - - return NDS_OK; - } - - if (Command == NDD_CMD_INFO_PRINT) - { - NDT_Root * Root = va_arg (Args, NDT_Root *); - FILE * Out = va_arg (Args, FILE *); - - fprintf (Out, SM_Root_Description_Get ("Free Chunk Root", Root)); - - return NDS_OK; - } - - if (Command == NDD_CMD_VALUE_COMP) - { - int comp; - SMT_Chunk *Chunk1 = (SMT_Chunk *)va_arg (Args, void *); - SMT_Chunk *Chunk2 = (SMT_Chunk *)va_arg (Args, void *); - - va_end (Args); - - /* - La comparaison des chunks libres porte sur le champ - pour faciliter la compression des heaps. - */ - - comp = (unsigned int)(Chunk1->Data) - (unsigned int)(Chunk2->Data); - - if (comp < 0) return NDS_LOWER; - if (comp > 0) return NDS_GREATER; - return NDS_EQUAL; - } - - return SMS_OK; + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -4003,7 +4942,7 @@ SMT_Status SM_Heap_Lock_Set ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_READ) { - rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_SSL, 2); + rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_SSL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Set : unable to lock the heap for reading"); @@ -4015,7 +4954,7 @@ SMT_Status SM_Heap_Lock_Set ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_WRITE) { - rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_SEL, 2); + rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_SEL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Set : unable to lock the heap for writing"); @@ -4050,7 +4989,7 @@ SMT_Status SM_Heap_Lock_Change ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) => On passe donc par un déverrouillage intermédiaire. */ - if ((rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_RSL, 2)) != SMS_OK) + if ((rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_RSL, 2)) != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Change : unable to transform the heap lock for writing"); SM_Error_Print (); @@ -4058,21 +4997,21 @@ SMT_Status SM_Heap_Lock_Change ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) return rc; } - if ((rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_SEL, 2)) != SMS_OK) + if ((rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_SEL, 2)) != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Change : unable to transform the heap lock for writing"); SM_Error_Print (); /* On tente de revenir à l'état de verrouillage précédent */ - SM_Semaphore_Operate (MHH->SemID, SM_SemOp_SSL, 2); + SM_Semaphore_Operate (MHH->SemId, SM_SemOp_SSL, 2); return rc; } } else if (Lock_Mode & SMD_READ) { - rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_TSL, 2); + rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_TSL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Change : unable to transform the heap lock for reading"); @@ -4099,7 +5038,7 @@ SMT_Status SM_Heap_Lock_Release ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_READ) { - rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_RSL, 2); + rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_RSL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Release : unable to unlock the heap which had been locked for reading"); @@ -4111,7 +5050,7 @@ SMT_Status SM_Heap_Lock_Release ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) if (Lock_Mode & SMD_WRITE) { - rc = SM_Semaphore_Operate (MHH->SemID, SM_SemOp_REL, 2); + rc = SM_Semaphore_Operate (MHH->SemId, SM_SemOp_REL, 2); if (rc != SMS_OK) { sprintf (SM_Error_Msg, "SM_Heap_Lock_Release : unable to unlock the heap which had been locked for writing"); @@ -4132,9 +5071,9 @@ SMT_Status SM_Heap_Lock_Release ( SMT_MHH * MHH, SMT_Flags Lock_Mode ) /* Opération sur un sémaphore */ /*------------------------------------------------------------------------------*/ -SMT_Status SM_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned int Nb_Oper) +SMT_Status SM_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) { @@ -4144,20 +5083,20 @@ SMT_Status SM_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned break; case EACCES: - sprintf (SM_Error_Msg, "SM_Semaphore_Operate : current process is not allowed to operate on semaphore %d", SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate : current process is not allowed to operate on semaphore %d", SemId); break; case EIDRM: - sprintf (SM_Error_Msg, "SM_Semaphore_Operate : semaphore %d does not exist", SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate : semaphore %d does not exist", SemId); break; case EINTR: - sprintf (SM_Error_Msg, "SM_Semaphore_Operate : a signal was received while operating on semaphore %d", SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate : a signal was received while operating on semaphore %d", SemId); return SMS_ERRSIG; break; case EINVAL: - sprintf (SM_Error_Msg, "SM_Semaphore_Operate : the semaphore identifier %d is incorrect or the number of operations which can be done in UNDO mode exceeds the system-imposed limit", SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate : the semaphore identifier %d is incorrect or the number of operations which can be done in UNDO mode exceeds the system-imposed limit", SemId); break; case ENOSPC: @@ -4165,11 +5104,11 @@ SMT_Status SM_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned break; case ERANGE: - sprintf (SM_Error_Msg, "SM_Semaphore_Operate: the value of semaphore %d has reached the system-imposed limit", SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate: the value of semaphore %d has reached the system-imposed limit", SemId); break; default : - sprintf (SM_Error_Msg, "SM_Semaphore_Operate : unknown error %d while operating on semaphore %d", errno, SemID); + sprintf (SM_Error_Msg, "SM_Semaphore_Operate : unknown error %d while operating on semaphore %d", errno, SemId); break; } @@ -4189,74 +5128,66 @@ SMT_Status SM_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned /* Récupère sous forme explicite l'état d'un verrou */ /*------------------------------------------------------------------------------*/ -char * SM_Lock_Status_Get ( const char * Type, void * Struct) +char *SM_Lock_Status_Get( const char *Type_Name, void *Struct_Ptr) { - static char Status [50]; - int i, SemID; - pid_t Writer; - union semun Sem_Ctl; + static char status[50]; + int i, sem_id; + pid_t writer; + union semun sem_ctl; - if (!strcmp (Type, "base")) - { - SemID = SM_Base->SemID; - Writer = SM_Base->Writer; - } - else if (!strcmp (Type, "heap")) - { - SMT_MHH * MHH = (SMT_MHH *)Struct; - SemID = MHH->SemID; - Writer = MHH->Writer; - } - else + if( !strcmp( Type_Name, "base")) { - strcpy (Status, "unknown"); - return Status; + sem_id = SM_Base->SemId; + writer = SM_Base->Writer; + } + else + { + if( !strcmp( Type_Name, "heap")) + { + SMT_MHH *MHH_Ptr = (SMT_MHH *)Struct_Ptr; + + sem_id = MHH_Ptr->SemId; + writer = MHH_Ptr->Writer; + } + else + { + strcpy( status, "Unknown"); + return( status); + } } - i = semctl (SemID, 0, GETVAL, Sem_Ctl); + i = semctl( sem_id, 0, GETVAL, sem_ctl); - switch (i) + switch( i) { case 0: - sprintf (Status, "exclusive lock (process id = %ld)", Writer); + { + sprintf( status, "Exclusive Lock for PId: (%ld)", writer); break; + } case 1: - sprintf (Status, "unlocked"); + { + sprintf( status, "Unlocked"); break; + } default : - if (i < 0) - sprintf (Status, "anormal status (%d)", i); + { + if( i < 0) + { + sprintf( status, "Abnormal Status: (%d)", i); + } else - sprintf (Status, "share lock (%d process)", i - 1); + { + sprintf( status, "Shared Lock Process_Nb: (%d)", i - 1); + } break; + } } - return Status; -} - - - - - -/*------------------------------------------------------------------------------*/ -/* Récupère sous forme explicite la description d'une racine de structure */ -/*------------------------------------------------------------------------------*/ - -char * SM_Root_Description_Get ( const char * Root_Label, NDT_Root * Root ) -{ - static char Root_Info [256]; - - - sprintf (Root_Info, "%s :\n\t- Structure type = %s:%s\n\t- Node number = %ld\n", - Root_Label, - ND_INDEX_TYPE_ASCII_GET( Root, NDD_INDEX_PRIMARY), - ND_INDEX_SUBTYPE_ASCII_GET( Root, NDD_INDEX_PRIMARY), - Root->Index_Tab[NDD_INDEX_PRIMARY].Node_Number); - - return( Root_Info); + return( status); } diff --git a/lib/libshmem.h b/lib/libshmem.h index 5a9f015..934e749 100644 --- a/lib/libshmem.h +++ b/lib/libshmem.h @@ -1,9 +1,9 @@ /*---------------------------------------------------------------------------------*/ /* $RCSfile: libshmem.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.1 $ */ +/* $Revision: 2.2 $ */ /* $Name: $ */ -/* $Date: 2005/01/24 23:10:09 $ */ +/* $Date: 2005/02/23 23:31:06 $ */ /* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ @@ -68,7 +68,8 @@ extern char * strdup (const char *); #define MEM_LIMIT 1000000000 -#define SMD_CMD_VALUE_SUM (NDT_Command)65 +//#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 */ @@ -216,12 +217,12 @@ SMT_Status SM_Base_Unlock (SMT_Flags); /*------------------------------------------------------------------------------*/ /* Fonction manager de la liste des heaps ouverts */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_Opened_Heap_List_Manager (va_list); +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 (va_list); +NDT_Status MHR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); /*------------------------------------------------------------------------------*/ /* Destruction d'un MHH (Memory Heap Header) */ @@ -231,7 +232,7 @@ SMT_Status SM_MHH_End (SMT_MHH *); /*------------------------------------------------------------------------------*/ /* Fonction manager pour un DSR (Data Segment Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_DSR_Manager (va_list); +NDT_Status SM_DSR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); /*------------------------------------------------------------------------------*/ /* Initialisation d'un nouveau segment de données (noeud du DSR) */ @@ -261,12 +262,12 @@ size_t SM_DataSegment_Compress (SMT_DSH *, NDT_Root *); /*------------------------------------------------------------------------------*/ /* Fonction manager pour un ACR (Allocated Chunk Root) */ /*------------------------------------------------------------------------------*/ -NDT_Status SM_ACR_Manager (va_list); +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(va_list); +NDT_Status SM_FCR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); /*------------------------------------------------------------------------------*/ /* Pose d'un verrou sur un heap : */ @@ -293,11 +294,6 @@ SMT_Status SM_Semaphore_Operate (int, struct sembuf *, unsigned int); /*------------------------------------------------------------------------------*/ char * SM_Lock_Status_Get (const char *, void *); -/*------------------------------------------------------------------------------*/ -/* Récupère sous forme explicite la description d'une racine de structure */ -/*------------------------------------------------------------------------------*/ -char * SM_Root_Description_Get (const char *, NDT_Root *); - /*------------------------------------------------------------------------------*/ /* Routine d'affichage d'un message d'erreur */ /*------------------------------------------------------------------------------*/