Dear Mahesh, >> [AVM] A non-collated Ckpt will have two replicas on both Active and standby. Each node will receive one CPND_EVT_D2ND_CKPT_CREATE message so it handles swapping itself and does not affect each other nor another.
>> [AVM] piratically we can have large size data & transit time, if ckt pat has large data sham is file I/O operation >> not middle-ware controlled activity , swap time will vary depending on system. I am agree that this modification affects performance of create/open function so it need performance acceptance verification. Fortunately, shared mem is on memory so it is not heavily depend on OS or file system (unless on swap memory area). Maybe I am not understand your ideal here but I have not found a clear reason of handling try-again. Thank you and best regards, Hoang -----Original Message----- From: A V Mahesh [mailto:mahesh.va...@oracle.com] Sent: Tuesday, October 18, 2016 12:14 PM To: Vo Minh Hoang <hoang.m...@dektech.com.au> Cc: anders.wid...@ericsson.com; opensaf-devel@lists.sourceforge.net Subject: Re: [PATCH 1 of 1] cpnd: use shared memory based on ckpt name length [#2108] Hi Hoan, On 10/18/2016 9:59 AM, Vo Minh Hoang wrote: > Dear Mahesh, > > Thank you very much for your comments. > > I would like to explain my understanding and reason for this solution. > Please correct me if I am wrong. > > - This memory swapping works on single node alone, it will occur > maximum once per node in open/create checkpoint process. > - This swapping action just takes place in nodes that meet condition > and does not affect other node. [AVM] A non-collated Ckpt will have two replicas on both Active and standby . > - CPND handles open/create processes atomically in sequence in one > thread only. > > Because of that I think it is unnecessary to implement thread > synchronizing or `try-again` handling. [AVM] piratically we can have large size data & transit time, if ckt pat has large data sham is file I/O operation not middle-ware controlled activity , swap time will vary depending on system. > > Sincerely, > Hoang > > -----Original Message----- > From: A V Mahesh [mailto:mahesh.va...@oracle.com] > Sent: Tuesday, October 18, 2016 10:48 AM > To: Vo Minh Hoang <hoang.m...@dektech.com.au> > Cc: anders.wid...@ericsson.com; opensaf-devel@lists.sourceforge.net > Subject: Re: [PATCH 1 of 1] cpnd: use shared memory based on ckpt name > length [#2108] > > Hi Hoang, > > On 10/13/2016 12:44 PM, Vo Minh Hoang wrote: >> No, old checkpoint data is converted to `big format`. >> So all of them will be stored in `big format`. > [AVM] This approach is introducing NEW transit , so far application > are aware of switch-over & fail-over transit and TRY-AGAIN is > expected only in those case , now this solution is introducing a new > transit for the application which are accessioning the old (by the > way this patch didn't implemented TRY-AGAIN when shared memory > swapping action occurring) > > `small format shm`, up on some application creating `big format` ( > application impacting the HA behavior ) > not sure about the solution approach need to discussed ! > > -AVM > > On 10/13/2016 12:44 PM, Vo Minh Hoang wrote: >> Dear Mahesh, >> >> Because of keeping the consistent working behavior of existing >> function, only 1 shared memory at a time. If shared memory swapping >> action occurs, a new shared memory will replace old one. >> >> Here is the detailed answers to your questions: >>>> -The existing `small format shm` will continue to be small , is >>>> that >> right ? >>>> -Only newly created longDN checkpoint will be in `big format shm`, >>>> is >> that right ? >> No, old checkpoint data is converted to `big format`. >> So all of them will be stored in `big format`. >> >>>> - what will be the format of newly joined the PL-5 opens an >>>> existing >> `small format shm` >> PL-5 still use `small format`. >> Only when a long DN replica is added in this node, the shared memory >> is converted to `big format`. >>>> the what will be the new replica on new node `small format shm` >>>> or `big >> format shm` ? >> This implementation only affect the `header` shared memory >> (opensaf_CPND_CHECKPOINT_INFO_nodeid). It do not change replica >> shared memory (opensaf_ckptname_nodeid_n). >> >> About testing, because of above specification, I tested: >> - start new node >> - restart ckptnd with existing small shm >> - restart ckptnd with existing big shm >> - create first long dn (check all node) >> >> Thank you and best regards, >> Hoang >> >> -----Original Message----- >> From: A V Mahesh [mailto:mahesh.va...@oracle.com] >> Sent: Thursday, October 13, 2016 1:33 PM >> To: Hoang Vo <hoang.m...@dektech.com.au>; anders.wid...@ericsson.com >> Cc: opensaf-devel@lists.sourceforge.net >> Subject: Re: [PATCH 1 of 1] cpnd: use shared memory based on ckpt >> name length [#2108] >> >> Hi Hoang, >> >> >> - Run time cpnd keep using small format shm until first longDN >> checkpoint is created. >> >> After that cpnd use big format shm. >> >> While reviewing I am assuming following please confirm : >> >> -The existing `small format shm` will continue to be small , is >> that right ? >> -Only newly created longDN checkpoint will be in `big format shm`, is >> that right ? >> - what will be the format of newly joined the PL-5 opens an existing >> `small format shm` >> the what will be the new replica on new node `small format shm` >> or `big format shm` ? >> >> >> I hope you tested following : >> ========================== >> - combination of some `small format shm` and some `big format shm` >> ckpts >> - Joined a New node ( say PL-5) and then opened the existing `small >> format shm` ckpt from the new Node >> - Restating controller which has combination of `small format shm` >> and `big format shm` and how the restored non-collocated ckpt`s >> >> -AVM >> >> On 10/11/2016 1:15 PM, Hoang Vo wrote: >>> osaf/libs/common/cpsv/include/cpsv_shm.h | 9 +- >>> osaf/services/saf/cpsv/cpnd/cpnd_res.c | 565 >> ++++++++++++++++++++++++++++-- >>> 2 files changed, 536 insertions(+), 38 deletions(-) >>> >>> >>> problem: In the case of CKPT osafckptnd increased 3,5Mb - 240 >>> percent on all nodes CKPT_INFO size inscrease when support longDN >>> lead to total >> size increase. >>> solution: >>> - From start, cpnd use small format shm. >>> - Run time cpnd keep using small format shm until first longDN >>> checkpoint >> is created. >>> After that cpnd use big format shm. >>> >>> diff --git a/osaf/libs/common/cpsv/include/cpsv_shm.h >>> b/osaf/libs/common/cpsv/include/cpsv_shm.h >>> --- a/osaf/libs/common/cpsv/include/cpsv_shm.h >>> +++ b/osaf/libs/common/cpsv/include/cpsv_shm.h >>> @@ -27,7 +27,8 @@ >>> #define SHM_NEXT -3 >>> #define SHM_INIT -1 >>> >>> -#define CPSV_CPND_SHM_VERSION 1 >>> +#define CPSV_CPND_SHM_VERSION_SHORT_DN 0 >>> +#define CPSV_CPND_SHM_VERSION_LONG_DN 1 >>> >>> typedef struct cpsv_ckpt_hdr { >>> SaCkptCheckpointHandleT ckpt_id; /* Index for identifying the >> checkpoint */ >>> @@ -134,4 +135,10 @@ typedef enum cpnd_type_info { >>> CPND_CKPT_INFO >>> } CPND_TYPE_INFO; >>> >>> +#define cpsv_cpnd_shm_size(x) x == CPSV_CPND_SHM_VERSION_LONG_DN ? \ >>> + sizeof(CLIENT_HDR) + (MAX_CLIENTS * sizeof(CLIENT_INFO)) + >> \ >>> + sizeof(CKPT_HDR) + (MAX_CKPTS * sizeof(CKPT_INFO)) : >> \ >>> + sizeof(CLIENT_HDR) + (MAX_CLIENTS * sizeof(CLIENT_INFO)) + >> \ >>> + sizeof(CKPT_HDR) + (MAX_CKPTS * sizeof(CKPT_INFO_V0)) >> \ >>> + >>> #endif >>> diff --git a/osaf/services/saf/cpsv/cpnd/cpnd_res.c >>> b/osaf/services/saf/cpsv/cpnd/cpnd_res.c >>> --- a/osaf/services/saf/cpsv/cpnd/cpnd_res.c >>> +++ b/osaf/services/saf/cpsv/cpnd/cpnd_res.c >>> @@ -44,20 +44,34 @@ >>> >>> #define m_CPND_CKPTINFO_UPDATE(addr,ckpt_info,offset) >>> memcpy(addr+offset,&ckpt_info,sizeof(CKPT_INFO)) >>> >>> +#define m_CPND_CKPTINFO_V0_UPDATE(addr,ckpt_info,offset) >>> +memcpy(addr+offset,&ckpt_info,sizeof(CKPT_INFO_V0)) >>> + >>> #define m_CPND_CKPTHDR_UPDATE(ckpt_hdr,offset) >>> memcpy(offset,&ckpt_hdr,sizeof(CKPT_HDR)) >>> >>> +void *cpnd_restart_shm(NCS_OS_POSIX_SHM_REQ_INFO *cpnd_open_req, >>> +CPND_CB *cb, SaClmNodeIdT nodeid); uint32_t >>> +cpnd_update_ckpt_with_clienthdl_v1(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, SaCkptHandleT client_hdl); uint32_t >>> +cpnd_update_ckpt_with_clienthdl_v0(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, SaCkptHandleT client_hdl); uint32_t >>> +cpnd_write_ckpt_info_v1(CPND_CB *cb, CPND_CKPT_NODE *cp_node, >>> +int32_t offset, SaCkptHandleT client_hdl); uint32_t >>> +cpnd_write_ckpt_info_v0(CPND_CB *cb, CPND_CKPT_NODE *cp_node, >>> +int32_t offset, SaCkptHandleT client_hdl); >>> + >>> static uint32_t cpnd_res_ckpt_sec_add(CPND_CKPT_SECTION_INFO >>> *pSecPtr, >> CPND_CKPT_NODE *cp_node); >>> static bool cpnd_find_exact_ckptinfo(CPND_CB *cb, CKPT_INFO >>> *ckpt_info, >> uint32_t bitmap_offset, >>> uint32_t *offset, uint32_t >> *prev_offset); >>> +static bool cpnd_find_exact_ckptinfo_v0(CPND_CB *cb, CKPT_INFO_V0 >> *ckpt_info, uint32_t bitmap_offset, >>> + uint32_t *offset, uint32_t >> *prev_offset); >>> static void cpnd_clear_ckpt_info(CPND_CB *cb, CPND_CKPT_NODE >>> *cp_node, >> uint32_t curr_offset, uint32_t prev_offset); >>> static uint32_t cpnd_restore_client_info(CPND_CB *cb, uint8_t >> *cli_addr); >>> static uint32_t cpnd_restore_ckpt_info_v1(CPND_CB *cb, uint8_t >> *ckpt_addr, SaClmNodeIdT nodeid); >>> static uint32_t cpnd_restore_ckpt_info_v0(CPND_CB *cb, uint8_t >>> *ckpt_addr, SaClmNodeIdT nodeid); >>> +static void cpnd_restart_client_reset_v1(CPND_CB *cb, >>> +CPND_CKPT_NODE *cp_node, CPND_CKPT_CLIENT_NODE *cl_node); static >>> +void cpnd_restart_client_reset_v0(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, CPND_CKPT_CLIENT_NODE *cl_node); >>> static void >>> cpnd_destroy_shm_cpnd_cp_info(NCS_OS_POSIX_SHM_REQ_OPEN_INFO >> *open_req); >>> static void >>> *cpnd_create_shm_cpnd_cp_info(NCS_OS_POSIX_SHM_REQ_INFO >> *req_info); >>> static void cpnd_update_shm_cpnd_cp_info(CPND_CB *cb); >>> static void cpnd_convert_cp_info_v0(CKPT_INFO_V0 *cp_info_v0, >>> CKPT_INFO *cp_info); >>> >>> +static CPND_SHM_VERSION cpnd_shm_version; >>> + >>> >> /******************************************************************** >> * >> ****** >> **** * >>> * Name : cpnd_client_extract_bits >>> * >>> @@ -296,12 +310,21 @@ void cpnd_restart_update_timer(CPND_CB * >>> CKPT_INFO ckpt_info; >>> >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> - if (cp_node->offset >= 0) { >>> + if (cp_node->offset < 0) { >>> + return; >>> + } >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) >>> +{ >>> m_CPND_CKPTINFO_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> cp_node->offset * sizeof(CKPT_INFO)); >>> ckpt_info.close_time = closetime; >>> m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), >>> ckpt_info, cp_node->offset * >> sizeof(CKPT_INFO)); >>> + } else { >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> + ((CKPT_INFO_V0 *)(&ckpt_info))->close_time = closetime; >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), >>> + ckpt_info, cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> } >>> return; >>> } >>> @@ -321,25 +344,52 @@ void cpnd_restart_update_timer(CPND_CB * >>> shared memory and update the shared memory >>> as and >> when the database gets updated >>> * TBD : TO CHECK THE ERROR CONDITIONS >>> >>> ******************************************************************** >>> * >>> * >>> ******************************/ >>> +void *cpnd_restart_shm_create(NCS_OS_POSIX_SHM_REQ_INFO >>> +*cpnd_open_req, CPND_CB *cb, SaClmNodeIdT nodeid) { >>> + TRACE_ENTER(); >>> >>> -void *cpnd_restart_shm_create(NCS_OS_POSIX_SHM_REQ_INFO >>> *cpnd_open_req, CPND_CB *cb, SaClmNodeIdT nodeid) >>> + /* Initializing shared memory version */ >>> + memset(&cpnd_shm_version, '\0', sizeof(cpnd_shm_version)); >>> + /* From start always init shm for short DN version */ >>> + cpnd_shm_version.shm_version = CPSV_CPND_SHM_VERSION_SHORT_DN; >>> + >>> + void *ret = cpnd_restart_shm(cpnd_open_req, cb, nodeid); >>> + >>> + TRACE_LEAVE(); >>> + >>> + return ret; >>> +} >>> + >>> >> +/******************************************************************* >> +* >> +****** >> ************************** >>> + * Name : cpnd_restart_shm >>> + * >>> + * Description : To create the shared memory for CPND restart >>> + * >>> + * Arguments : NCS_OS_POSIX_SHM_REQ_INFO *open_req - Shared Memory >> Request Info pointer >>> + * CPND_CB *cb - CPND CB pointer >>> + * >>> + * Return Values : void * - Returns the starting address of the >>> + shared >> memory >>> + * Notes : If the shared memory is present - CPND has restarted >> , so CPND will update its database by >>> + reading the information from the shared memory >>> + If the shared memory is not present - CPND is >>> + coming >> up for the first time , so create a new >>> + shared memory and update the shared memory as >>> + and >> when the database gets updated >>> + * TBD : TO CHECK THE ERROR CONDITIONS >>> +******************************************************************* >>> +* >>> +* *******************************/ void >>> +*cpnd_restart_shm(NCS_OS_POSIX_SHM_REQ_INFO *cpnd_open_req, CPND_CB >>> +*cb, SaClmNodeIdT nodeid) >>> { >>> uint32_t rc = NCSCC_RC_SUCCESS; >>> char *buf = NULL, *buffer = NULL; >>> uint8_t size = 0, total_length; >>> GBL_SHM_PTR gbl_shm_addr = {0, 0, 0, 0, 0}; >>> - CPND_SHM_VERSION cpnd_shm_version; >>> >>> TRACE_ENTER(); >>> - /* Initializing shared memory version */ >>> - memset(&cpnd_shm_version, '\0', sizeof(cpnd_shm_version)); >>> - cpnd_shm_version.shm_version = CPSV_CPND_SHM_VERSION; >>> >>> size = strlen("CPND_CHECKPOINT_INFO"); >>> total_length = size + sizeof(nodeid) + 5; >>> buffer = m_MMGR_ALLOC_CPND_DEFAULT(total_length); >>> if (buffer == NULL) { >>> LOG_ER("cpnd default memory allocation failed in cpnd_open >> in >>> resart shm create"); >>> + TRACE_LEAVE(); >>> return NULL; >>> } >>> cb->cpnd_res_shm_name = (uint8_t*)buffer; @@ -349,9 +399,7 @@ >>> void *cpnd_restart_shm_create(NCS_OS_POS >>> >>> /* 1. FIRST TRYING TO OPEN IN RDWR MODE */ >>> cpnd_open_req->type = NCS_OS_POSIX_SHM_REQ_OPEN; >>> - cpnd_open_req->info.open.i_size = >>> - sizeof(CLIENT_HDR) + (MAX_CLIENTS * sizeof(CLIENT_INFO)) + >> sizeof(CKPT_HDR) + >>> - (MAX_CKPTS * sizeof(CKPT_INFO)); >>> + cpnd_open_req->info.open.i_size = >>> +cpsv_cpnd_shm_size(cpnd_shm_version.shm_version); >>> if (cb->shm_alloc_guaranteed == true) >>> cpnd_open_req->info.open.ensures_space = true; >>> else >>> @@ -370,12 +418,14 @@ void *cpnd_restart_shm_create(NCS_OS_POS >>> if (NULL == cpnd_create_shm_cpnd_cp_info(cpnd_open_req)) { >>> LOG_ER("cpnd open request fail for RDWR mode >> %s",buf); >>> m_MMGR_FREE_CPND_DEFAULT(buffer); >>> + TRACE_LEAVE(); >>> return NULL; >>> } >>> >>> cb->cpnd_first_time = true; >>> >>> TRACE_1("cpnd new shm create request success"); >>> + TRACE_LEAVE(); >>> return cpnd_open_req->info.open.o_addr; >>> } >>> >>> @@ -390,7 +440,7 @@ void *cpnd_restart_shm_create(NCS_OS_POS >>> >>> /* Already the shared memory exists */ >>> else { >>> - CPND_SHM_VERSION shm_version; >>> + CPND_SHM_VERSION shm_version; // Shm version of existing >> memory >>> TRACE_1("cpnd restart already shared memory exits"); >>> gbl_shm_addr.cli_addr = cpnd_open_req->info.open.o_addr + >> sizeof(cpnd_shm_version); /* Starting address of the shared memory */ >>> gbl_shm_addr.ckpt_addr = (void *)((char >> *)gbl_shm_addr.cli_addr + >>> sizeof(CLIENT_HDR) + @@ -403,10 +453,15 @@ void >> *cpnd_restart_shm_create(NCS_OS_POS >>> TRACE("CPND IS RESTARTING WITH VERSION %d", >> shm_version.shm_version); >>> cpnd_restore_client_info(cb, gbl_shm_addr.cli_addr); >>> switch (shm_version.shm_version) { >>> - case 0: >>> + case CPSV_CPND_SHM_VERSION_SHORT_DN: >>> { >>> cpnd_restore_ckpt_info_v0(cb, >> gbl_shm_addr.ckpt_addr, nodeid); >>> >>> + /* Keep v0 format if both have same version */ >>> + if (cpnd_shm_version.shm_version == >> shm_version.shm_version) { >>> + break; >>> + } >>> + >>> /* Destroy the CPND_CHECKPOINT_INFO version 0 */ >>> >> cpnd_destroy_shm_cpnd_cp_info(&cpnd_open_req->info.open); >>> >>> @@ -414,6 +469,7 @@ void *cpnd_restart_shm_create(NCS_OS_POS >>> if (NULL == >> cpnd_create_shm_cpnd_cp_info(cpnd_open_req)) { >>> LOG_ER("cpnd open request fail for RDWR mode >> %s",buf); >>> m_MMGR_FREE_CPND_DEFAULT(buffer); >>> + TRACE_LEAVE(); >>> return NULL; >>> } >>> >>> @@ -426,7 +482,8 @@ void *cpnd_restart_shm_create(NCS_OS_POS >>> >>> break; >>> } >>> - case 1: >>> + case CPSV_CPND_SHM_VERSION_LONG_DN: >>> + shm_version.shm_version = >> CPSV_CPND_SHM_VERSION_LONG_DN; >>> cpnd_restore_ckpt_info_v1(cb, >> gbl_shm_addr.ckpt_addr, nodeid); >>> break; >>> default: >>> @@ -505,8 +562,13 @@ int32_t cpnd_find_free_loc(CPND_CB *cb, >>> } >>> read_req.type = NCS_OS_POSIX_SHM_REQ_READ; >>> read_req.info.read.i_addr = (void *)((char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR)); >>> - read_req.info.read.i_read_size = sizeof(CKPT_INFO); >>> - read_req.info.read.i_offset = counter * >> sizeof(CKPT_INFO); >>> + if (cpnd_shm_version.shm_version == >> CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + read_req.info.read.i_read_size = >> sizeof(CKPT_INFO); >>> + read_req.info.read.i_offset = counter * >> sizeof(CKPT_INFO); >>> + } else { >>> + read_req.info.read.i_read_size = >> sizeof(CKPT_INFO_V0); >>> + read_req.info.read.i_offset = counter * >> sizeof(CKPT_INFO_V0); >>> + } >>> read_req.info.read.i_to_buff = (CKPT_INFO >> *)&ckpt_info; >>> rc = ncs_os_posix_shm(&read_req); >>> if (rc != NCSCC_RC_SUCCESS) { @@ -515,7 +577,8 @@ int32_t >>> cpnd_find_free_loc(CPND_CB *cb, >>> return -2; >>> } >>> >>> - if (1 == ((CKPT_INFO >> *)read_req.info.read.i_to_buff)->is_valid) { >>> + if ((cpnd_shm_version.shm_version == >> CPSV_CPND_SHM_VERSION_LONG_DN && 1 == ckpt_info.is_valid) || >>> + (cpnd_shm_version.shm_version == >> CPSV_CPND_SHM_VERSION_SHORT_DN >>> +&& 1 == ((CKPT_INFO_V0 *)(&ckpt_info))->is_valid)) { >>> counter++; >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> if (counter == MAX_CKPTS) { >>> @@ -738,25 +801,95 @@ bool cpnd_find_exact_ckptinfo(CPND_CB *c >>> >>> } >>> >>> >> +/******************************************************************* >> +* >> +****** >> ********************** >>> + * Name : cpnd_find_exact_ckptinfo_v0 >>> + * >>> + * Description : find if the checkpoint info v0 exists in the shared >> memory , >>> + then findout the matching bm_offset offset value >>> + * >>> + * Arguments : CPND_CKPT_NODE - ckpt node >>> + * >>> + * Return Values : The offset( if same bm_pffset present) /prev >>> + offset( >> if same bm_offset is not present ) >>> + where this checkpoint info is present >>> + * >>> +******************************************************************* >>> +* >>> +* >>> +*****************************/ >>> + >>> +bool cpnd_find_exact_ckptinfo_v0(CPND_CB *cb, CKPT_INFO_V0 >>> +*ckpt_info, >> uint32_t bitmap_offset, uint32_t *offset, >>> + uint32_t *prev_offset) >>> +{ >>> + int32_t next; >>> + CKPT_INFO_V0 prev_ckpt_info; >>> + uint64_t i_offset; >>> + bool found = false; >>> + >>> + TRACE_ENTER(); >>> + memset(&prev_ckpt_info, 0, sizeof(CKPT_INFO_V0)); >>> + memcpy(&prev_ckpt_info, ckpt_info, sizeof(CKPT_INFO_V0)); >>> + next = ckpt_info->offset; >>> + *prev_offset = prev_ckpt_info.offset; >>> + >>> + while (next >= 0) { >>> + memset(&prev_ckpt_info, 0, sizeof(CKPT_INFO_V0)); >>> + if ((next * sizeof(CKPT_INFO_V0)) > UINTMAX_MAX) { >>> + LOG_ER("cpnd exact_ckptinf failed,exceeded the write >> limits(UINT64_MAX) "); >>> + } >>> + i_offset = next * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(prev_ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), i_offset); >>> + if (prev_ckpt_info.bm_offset == bitmap_offset) { >>> + found = true; >>> + *offset = prev_ckpt_info.offset; >>> + break; >>> + } >>> + next = prev_ckpt_info.next; >>> + *prev_offset = prev_ckpt_info.offset; >>> + } >>> + TRACE_LEAVE(); >>> + return found; >>> + >>> +} >>> + >>> >> /******************************************************************** >> * >> ****** >> **************************** >>> * Name : cpnd_update_ckpt_with_clienthdl >>> * >>> * Description : To write the checkpoint data, which already exists > in >> the shared memory, here we just change the bitmap >>> * >>> - * Arguments : CPND_CKPT_NODE - ckpt node , offset - to update the >> respective ckpt , client_hdl >>> + * Arguments : CPND_CKPT_NODE - ckpt node , offset - to update the >> respective ckpt , client_hdl >>> * >>> * Return Values : Success / Error >>> - * >>> + * >>> * Notes : None >>> >>> ******************************************************************** >>> * >>> * >>> ********************************/ >>> >>> uint32_t cpnd_update_ckpt_with_clienthdl(CPND_CB *cb, >>> CPND_CKPT_NODE >> *cp_node, SaCkptHandleT client_hdl) >>> { >>> + uint32_t rc = NCSCC_RC_SUCCESS; >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + rc = cpnd_update_ckpt_with_clienthdl_v1(cb, cp_node, >> client_hdl); >>> + } else { >>> + rc = cpnd_update_ckpt_with_clienthdl_v0(cb, cp_node, >> client_hdl); >>> + } >>> + return rc; >>> +} >>> + >>> >> +/******************************************************************* >> +* >> +****** >> ***************************** >>> + * Name : cpnd_update_ckpt_with_clienthdl_v1 >>> + * >>> + * Description : To write the checkpoint data, which already exists in >> the shared memory, here we just change the bitmap >>> + * >>> + * Arguments : CPND_CKPT_NODE - ckpt node , offset - to update the >> respective ckpt , client_hdl >>> + * >>> + * Return Values : Success / Error >>> + * >>> + * Notes : None >>> + >>> +******************************************************************* >>> +* >>> +* >>> +*********************************/ >>> + >>> +uint32_t cpnd_update_ckpt_with_clienthdl_v1(CPND_CB *cb, >>> +CPND_CKPT_NODE *cp_node, SaCkptHandleT client_hdl) { >>> CKPT_INFO ckpt_info, prev_ckpt_info, new_ckpt_info; >>> uint32_t bitmap_offset = 0, bitmap_value = 0, prev_offset, >>> offset, >> rc = NCSCC_RC_SUCCESS; >>> bool found = false; >>> - uint64_t i_offset; >>> - >>> + uint64_t i_offset; >>> + >>> TRACE_ENTER(); >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> memset(&prev_ckpt_info, '\0', sizeof(CKPT_INFO)); @@ -837,20 >>> +970,139 @@ uint32_t cpnd_update_ckpt_with_clienthdl >>> return rc; >>> } >>> >>> -/****************************************************************** >>> * >>> * >>> **************************************** >>> >> +/******************************************************************* >> +* >> +****** >> ***************************** >>> + * Name : cpnd_update_ckpt_with_clienthdl_v0 >>> + * >>> + * Description : To write the checkpoint data, which already exists in >> the shared memory, here we just change the bitmap >>> + * >>> + * Arguments : CPND_CKPT_NODE - ckpt node , offset - to update the >> respective ckpt , client_hdl >>> + * >>> + * Return Values : Success / Error >>> + * >>> + * Notes : None >>> + >>> +******************************************************************* >>> +* >>> +* >>> +*********************************/ >>> + >>> +uint32_t cpnd_update_ckpt_with_clienthdl_v0(CPND_CB *cb, >>> +CPND_CKPT_NODE *cp_node, SaCkptHandleT client_hdl) { >>> + CKPT_INFO_V0 ckpt_info, prev_ckpt_info, new_ckpt_info; >>> + uint32_t bitmap_offset = 0, bitmap_value = 0, prev_offset, offset, >> rc = NCSCC_RC_SUCCESS; >>> + bool found = false; >>> + uint64_t i_offset; >>> + >>> + TRACE_ENTER(); >>> + memset(&ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + memset(&prev_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + memset(&new_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + >>> + /* Read the starting shared memory entry for this cp_node */ >>> + prev_offset = cp_node->offset; >>> + i_offset = prev_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char *)cb->shm_addr.ckpt_addr >>> ++ sizeof(CKPT_HDR), i_offset); >>> + >>> + /* Findout the bitmap offset and bitmap value for the input client >> handle */ >>> + bitmap_offset = client_hdl / 32; >>> + >>> + bitmap_value = cpnd_client_bitmap_set(client_hdl % 32); >>> + >>> + /*findout the ckpt_info with the exact bitmap_offset or findout >>> +prev >> ckpt_info if exact one not found */ >>> + found = cpnd_find_exact_ckptinfo_v0(cb, &ckpt_info, bitmap_offset, >>> +&offset, &prev_offset); >>> + >>> + if (!found) { >>> + CKPT_HDR ckpt_hdr; >>> + uint32_t no_ckpts = 0; >>> + /* Update the Next Location in the previous >> prev_ckpt_info.next as we have to find a new ckpt_info */ >>> + if ((prev_offset * sizeof(CKPT_INFO_V0)) > UINTMAX_MAX) { >>> + LOG_ER("cpnd update clienthdl failed,exceeded the >> write limits(UINT64_MAX) "); >>> + } >>> + i_offset = prev_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(prev_ckpt_info, (char >>> +*)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), i_offset); >>> + >>> + prev_ckpt_info.next = cpnd_find_free_loc(cb, >> CPND_CKPT_INFO); >>> + if (prev_ckpt_info.next == -1) { >>> + TRACE_4("cpnd client free block failed "); >>> + TRACE_LEAVE(); >>> + return NCSCC_RC_FAILURE; >>> + } >>> + if (prev_ckpt_info.next == -2) { >>> + TRACE_LEAVE(); >>> + return NCSCC_RC_FAILURE; >>> + /* SHARED MEMORY READ ERROR */ >>> + } >>> + >>> + /* Update the Header with incremented number of ckpt_info 's >> */ >>> + memset(&ckpt_hdr, '\0', sizeof(CKPT_HDR)); >>> + m_CPND_CKPTHDR_READ(ckpt_hdr, (char >> *)cb->shm_addr.ckpt_addr, 0); >>> + no_ckpts = ++(ckpt_hdr.num_ckpts); >>> + >>> + if (no_ckpts >= MAX_CKPTS) >>> + { >>> + TRACE_LEAVE(); >>> + return NCSCC_RC_FAILURE; >>> + } >>> + >>> + /* write the checkpoint info (number of ckpts)in the header >> */ >>> + cpnd_ckpt_write_header(cb, no_ckpts); >>> + >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >>> +sizeof(CKPT_HDR), prev_ckpt_info, i_offset); >>> + >>> + /* Allocate New ckpt_info information */ >>> + offset = prev_ckpt_info.next; >>> + /* bitmap_value = cpnd_client_bitmap_set((client_hdl%32)+1); >> */ >>> + memcpy(&new_ckpt_info, &prev_ckpt_info, >> sizeof(CKPT_INFO_V0)); >>> + new_ckpt_info.offset = offset; >>> + new_ckpt_info.client_bitmap = bitmap_value; >>> + new_ckpt_info.bm_offset = bitmap_offset; >>> + new_ckpt_info.is_valid = 1; >>> + new_ckpt_info.is_first = false; >>> + new_ckpt_info.next = SHM_NEXT; >>> + >>> + i_offset = offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >>> +sizeof(CKPT_HDR), new_ckpt_info, i_offset); >>> + >>> + } else { >>> + i_offset = offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(prev_ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), i_offset); >>> + prev_ckpt_info.client_bitmap = prev_ckpt_info.client_bitmap >> | bitmap_value; >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), prev_ckpt_info, i_offset); >>> + } >>> + TRACE_LEAVE(); >>> + return rc; >>> +}/***************************************************************** >>> +* >>> +* >>> +***************************************** >>> * Name : cpnd_write_ckpt_info >>> * >>> - * Description : To write checkpoint info >>> + * Description : To write checkpoint info >>> * >>> * Arguments : CPND_CKPT_NODE - ckpt node , offset - to write to >> corresponding ckpt , client_hdl >>> * >>> * Return Values : Success / Error >>> * >>> - * Notes : Check if the offset is less than 31 , if so then update >>> the information in the corresponding offset >>> + * Notes : Check if the offset is less than 31 , if so then update >>> + the information in the corresponding offset >>> else find the next free location and there update the >> checkpoint information >>> >>> ******************************************************************** >>> * >>> * **************************************/ >>> +uint32_t cpnd_write_ckpt_info(CPND_CB *cb, CPND_CKPT_NODE *cp_node, >>> +int32_t offset, SaCkptHandleT client_hdl) { >>> + uint32_t rc = NCSCC_RC_SUCCESS; >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + rc = cpnd_write_ckpt_info_v1(cb, cp_node, offset, >> client_hdl); >>> + } else { >>> + rc = cpnd_write_ckpt_info_v0(cb, cp_node, offset, >> client_hdl); >>> + } >>> + return rc; >>> +} >>> >>> -uint32_t cpnd_write_ckpt_info(CPND_CB *cb, CPND_CKPT_NODE *cp_node, >>> int32_t offset, SaCkptHandleT client_hdl) >>> >> +/******************************************************************* >> +* >> +****** >> ********************************** >>> + * Name : cpnd_write_ckpt_info_v1 >>> + * >>> + * Description : To write checkpoint info >>> + * >>> + * Arguments : CPND_CKPT_NODE - ckpt node , offset - to write to >> corresponding ckpt , client_hdl >>> + * >>> + * Return Values : Success / Error >>> + * >>> + * Notes : Check if the offset is less than 31 , if so then update >>> + the >> information in the corresponding offset >>> + else find the next free location and there update the >>> +checkpoint information >>> +******************************************************************* >>> +* >>> +* ***************************************/ >>> +uint32_t cpnd_write_ckpt_info_v1(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, int32_t offset, SaCkptHandleT client_hdl) >>> { >>> CKPT_INFO ckpt_info; >>> uint32_t rc = NCSCC_RC_SUCCESS; @@ -885,6 +1137,54 @@ uint32_t >>> cpnd_write_ckpt_info(CPND_CB *c >>> >>> } >>> >>> >> +/******************************************************************* >> +* >> +****** >> ********************************** >>> + * Name : cpnd_write_ckpt_info_v0 >>> + * >>> + * Description : To write checkpoint info v0 >>> + * >>> + * Arguments : CPND_CKPT_NODE - ckpt node , offset - to write to >> corresponding ckpt , client_hdl >>> + * >>> + * Return Values : Success / Error >>> + * >>> + * Notes : Check if the offset is less than 31 , if so then update >>> + the >> information in the corresponding offset >>> + else find the next free location and there update the >>> +checkpoint information >>> +******************************************************************* >>> +* >>> +* ***************************************/ >>> + >>> +uint32_t cpnd_write_ckpt_info_v0(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, int32_t offset, SaCkptHandleT client_hdl) { >>> + CKPT_INFO_V0 ckpt_info; >>> + uint32_t rc = NCSCC_RC_SUCCESS; >>> + uint64_t i_offset; >>> + >>> + TRACE_ENTER(); >>> + memset(&ckpt_info, 0, sizeof(CKPT_INFO_V0)); >>> + osaf_extended_name_lend(cp_node->ckpt_name, &ckpt_info.ckpt_name); >>> + ckpt_info.ckpt_id = cp_node->ckpt_id; >>> + ckpt_info.maxSections = cp_node->create_attrib.maxSections; >>> + ckpt_info.maxSecSize = cp_node->create_attrib.maxSectionSize; >>> + ckpt_info.cpnd_rep_create = cp_node->cpnd_rep_create; >>> + ckpt_info.offset = offset; >>> + ckpt_info.node_id = cb->nodeid; >>> + ckpt_info.is_first = true; >>> + >>> + if (client_hdl) { >>> + ckpt_info.bm_offset = client_hdl / 32; >>> + ckpt_info.client_bitmap = cpnd_client_bitmap_set(client_hdl >> % 32); >>> + } >>> + ckpt_info.is_valid = 1; >>> + ckpt_info.next = SHM_NEXT; >>> + >>> + if ((offset * sizeof(CKPT_INFO_V0)) > UINTMAX_MAX) { >>> + LOG_ER("cpnd write ckpt info failed,exceeded the write >> limits(UINT64_MAX) "); >>> + } >>> + i_offset = offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >>> +sizeof(CKPT_HDR), ckpt_info, i_offset); >>> + >>> + TRACE_LEAVE2("cpnd ckpt info write success >> ckpt_id:%llx",cp_node->ckpt_id); >>> + return rc; >>> + >>> +} >>> + >>> /******************************************************************** >>> * Name : cpnd_restart_shm_client_update >>> * >>> @@ -1062,11 +1362,18 @@ uint32_t cpnd_restart_shm_ckpt_free(CPND >>> if (((cp_node->offset) * sizeof(CKPT_INFO)) > UINTMAX_MAX) { >>> LOG_ER("cpnd ckpt free failed,exceeded the write >> limits(UINT64_MAX) "); >>> } >>> - i_offset = (cp_node->offset) * sizeof(CKPT_INFO); >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + i_offset = (cp_node->offset) * sizeof(CKPT_INFO); >>> + >>> + /*Update the prev & curr shared memory segments with the new >> data */ >>> + m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, i_offset); >>> + } else { >>> + i_offset = (cp_node->offset) * sizeof(CKPT_INFO_V0); >>> + >>> + /*Update the prev & curr shared memory segments with the new >> data */ >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, i_offset); >>> + } >>> cp_node->offset = SHM_INIT; >>> - >>> - /*Update the prev & curr shared memory segments with the new data */ >>> - m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, i_offset); >>> >>> TRACE_LEAVE(); >>> >>> @@ -1088,12 +1395,21 @@ void cpnd_restart_ckpt_name_length_reset >>> CKPT_INFO ckpt_info; >>> >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> - if (cp_node->offset >= 0) { >>> + if (cp_node->offset < 0) { >>> + return; >>> + } >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) >>> +{ >>> m_CPND_CKPTINFO_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> cp_node->offset * sizeof(CKPT_INFO)); >>> ckpt_info.is_unlink = true; >>> m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, >>> cp_node->offset * sizeof(CKPT_INFO)); >>> + } else { >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> + ((CKPT_INFO_V0 *)(&ckpt_info))->is_unlink = true; >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> } >>> return; >>> } >>> @@ -1112,12 +1428,21 @@ void cpnd_restart_set_close_flag(CPND_CB >>> CKPT_INFO ckpt_info; >>> >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> - if (cp_node->offset >= 0) { >>> + if (cp_node->offset < 0) { >>> + return; >>> + } >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) >>> +{ >>> m_CPND_CKPTINFO_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> cp_node->offset * sizeof(CKPT_INFO)); >>> ckpt_info.is_close = true; >>> m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, >>> cp_node->offset * sizeof(CKPT_INFO)); >>> + } else { >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> + ((CKPT_INFO_V0 *)(&ckpt_info))->is_close = true; >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), ckpt_info, >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> } >>> return; >>> } >>> @@ -1136,12 +1461,21 @@ void cpnd_restart_reset_close_flag(CPND_ >>> CKPT_INFO ckpt_info; >>> >>> memset(&ckpt_info, '\0', sizeof(CKPT_INFO)); >>> - if (cp_node->offset >= 0) { >>> + if (cp_node->offset < 0) { >>> + return; >>> + } >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) >>> +{ >>> m_CPND_CKPTINFO_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> cp_node->offset * sizeof(CKPT_INFO)); >>> ckpt_info.is_close = false; >>> m_CPND_CKPTINFO_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), >>> ckpt_info, cp_node->offset * >> sizeof(CKPT_INFO)); >>> + } else { >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> + ((CKPT_INFO_V0 *)(&ckpt_info))->is_close = false; >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), >>> + ckpt_info, cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> } >>> return; >>> } >>> @@ -1235,6 +1569,94 @@ void cpnd_clear_ckpt_info(CPND_CB *cb, C >>> } >>> >>> >>> /******************************************************************* >>> * >>> * >>> *************************************** >>> + * Name : cpnd_clear_ckpt_info_v0 >>> + * >>> + * Description : To start the timer and to reset the client >>> +information >>> + * >>> + * Arguments : >>> + * >>> + * Return Values: >>> +******************************************************************* >>> +* >>> +* ***************************************/ >>> +void cpnd_clear_ckpt_info_v0(CPND_CB *cb, CPND_CKPT_NODE *cp_node, >>> +uint32_t curr_offset, uint32_t prev_offset) { >>> + CKPT_INFO_V0 prev_ckpt_info, curr_ckpt_info, next_ckpt_info; >>> + uint64_t i_offset, no_ckpts; >>> + CKPT_HDR ckpt_hdr; >>> + >>> + TRACE_ENTER(); >>> + memset(&prev_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + memset(&curr_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + memset(&next_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + >>> + if (((prev_offset * sizeof(CKPT_INFO_V0)) > UINTMAX_MAX) || >> ((curr_offset * sizeof(CKPT_INFO_V0)) > UINTMAX_MAX)){ >>> + LOG_ER("cpnd clear ckpt info failed,exceeded the write >> limits(UINT64_MAX) "); >>> + } >>> + i_offset = prev_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(prev_ckpt_info, (char >>> +*)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), i_offset); >>> + >>> + i_offset = curr_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(curr_ckpt_info, (char >>> +*)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), i_offset); >>> + >>> + /* Update the Next Location in the previous prev_ckpt_info.next as >> we have to clear the curr ckpt_info */ >>> + if (cp_node->offset != curr_offset) { >>> + memset(&ckpt_hdr, '\0', sizeof(CKPT_HDR)); >>> + m_CPND_CKPTHDR_READ(ckpt_hdr, (char >> *)cb->shm_addr.ckpt_addr, 0); >>> + no_ckpts = --(ckpt_hdr.num_ckpts); >>> + /* write the checkpoint info (number of ckpts)in the header >> */ >>> + cpnd_ckpt_write_header(cb, no_ckpts); >>> + >>> + prev_ckpt_info.next = curr_ckpt_info.next; >>> + /*Update the prev & curr shared memory segments with the new >> data */ >>> + i_offset = prev_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >>> +sizeof(CKPT_HDR), prev_ckpt_info, i_offset); >>> + >>> + memset(&curr_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + i_offset = curr_offset * sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_UPDATE((char *)cb->shm_addr.ckpt_addr + >> sizeof(CKPT_HDR), curr_ckpt_info, i_offset); >>> + } else { /* This is the starting entry for this >> cp_node so update accordingly */ >>> + >>> + if (curr_ckpt_info.next >= 0) { >>> + memset(&ckpt_hdr, '\0', sizeof(CKPT_HDR)); >>> + m_CPND_CKPTHDR_READ(ckpt_hdr, (char >> *)cb->shm_addr.ckpt_addr, 0); >>> + no_ckpts = --(ckpt_hdr.num_ckpts); >>> + /* write the checkpoint info (number of ckpts)in the >> header */ >>> + cpnd_ckpt_write_header(cb, no_ckpts); >>> + >>> + cp_node->offset = curr_ckpt_info.next; >>> + >>> + i_offset = (curr_ckpt_info.next) * >> sizeof(CKPT_INFO_V0); >>> + if (((curr_ckpt_info.next) * sizeof(CKPT_INFO_V0)) > >> UINTMAX_MAX) { >>> + LOG_ER("cpnd clear ckpt info failed,exceeded >> the write limits(UINT64_MAX) "); >>> + } >>> + i_offset = (curr_ckpt_info.next) * >> sizeof(CKPT_INFO_V0); >>> + m_CPND_CKPTINFO_V0_READ(next_ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + i_offset); >>> + >>> + next_ckpt_info.is_close = curr_ckpt_info.is_close; >>> + next_ckpt_info.is_unlink = curr_ckpt_info.is_unlink; >>> + next_ckpt_info.close_time = >> curr_ckpt_info.close_time; >>> + next_ckpt_info.is_first = true; >>> + m_CPND_CKPTINFO_V0_UPDATE((char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), next_ckpt_info, >>> + i_offset); >>> + >>> + if (((curr_ckpt_info.offset) * sizeof(CKPT_INFO_V0)) >>> UINTMAX_MAX) { >>> + LOG_ER("cpnd clear ckpt info failed,exceeded >> the write limits(UINT64_MAX) "); >>> + } >>> + i_offset = (curr_ckpt_info.offset) * >> sizeof(CKPT_INFO_V0); >>> + memset(&curr_ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + >>> + m_CPND_CKPTINFO_V0_UPDATE((char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), curr_ckpt_info, >>> + i_offset); >>> + >>> + } else { >>> + /* There is only one ckpt_info is there for this >> cp_node so no need to delete this node as part of close >>> + This ckpt_info gets deleted as part of unlink & >> lcl_ref_cnt of cp_node == 0 / lcl_ref_cnt == 0 & ret_tmr expires */ >>> + } >>> + } >>> + TRACE_LEAVE(); >>> +} >>> + >>> +/****************************************************************** >>> +* >>> +* >>> +**************************************** >>> * Name : cpnd_restart_client_reset >>> * >>> * Description : To start the timer and to reset the client >>> information @@ -1245,6 +1667,23 @@ void cpnd_clear_ckpt_info(CPND_CB >>> *cb, >> C >> ********************************************************************* >> * >> ****** >> ********************************/ >>> void cpnd_restart_client_reset(CPND_CB *cb, CPND_CKPT_NODE >>> *cp_node, >> CPND_CKPT_CLIENT_NODE *cl_node) >>> { >>> + if (cpnd_shm_version.shm_version == CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + cpnd_restart_client_reset_v1(cb, cp_node, cl_node); >>> + } else { >>> + cpnd_restart_client_reset_v0(cb, cp_node, cl_node); >>> + } >>> +} >>> +/****************************************************************** >>> +* >>> +* >>> +**************************************** >>> + * Name : cpnd_restart_client_reset_v1 >>> + * >>> + * Description : To start the timer and to reset the client >>> +information >>> + * >>> + * Arguments : >>> + * >>> + * Return Values: >>> +******************************************************************* >>> +* >>> +* ***************************************/ >>> +void cpnd_restart_client_reset_v1(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, CPND_CKPT_CLIENT_NODE *cl_node) { >>> CKPT_INFO ckpt_info; >>> uint32_t bitmap_offset = 0, num_bitset = 0; >>> bool found = false; >>> @@ -1281,6 +1720,53 @@ void cpnd_restart_client_reset(CPND_CB * >>> return; >>> } >>> >>> +/****************************************************************** >>> +* >>> +* >>> +**************************************** >>> + * Name : cpnd_restart_client_reset_v0 >>> + * >>> + * Description : To start the timer and to reset the client >>> +information >>> + * >>> + * Arguments : >>> + * >>> + * Return Values: >>> +******************************************************************* >>> +* >>> +* ***************************************/ >>> +void cpnd_restart_client_reset_v0(CPND_CB *cb, CPND_CKPT_NODE >>> +*cp_node, CPND_CKPT_CLIENT_NODE *cl_node) { >>> + CKPT_INFO_V0 ckpt_info; >>> + uint32_t bitmap_offset = 0, num_bitset = 0; >>> + bool found = false; >>> + uint32_t offset, prev_offset; >>> + SaCkptHandleT client_hdl = cl_node->ckpt_app_hdl; >>> + >>> + >>> + TRACE_ENTER(); >>> + bitmap_offset = client_hdl / 32; >>> + >>> + memset(&ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + >>> + if (cp_node->offset >= 0) { >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + cp_node->offset * >> sizeof(CKPT_INFO_V0)); >>> + /* findour the exact ckpt_info matching the client_hdl */ >>> + found = cpnd_find_exact_ckptinfo_v0(cb, &ckpt_info, >> bitmap_offset, &offset, &prev_offset); >>> + if (found) { >>> + memset(&ckpt_info, '\0', sizeof(CKPT_INFO_V0)); >>> + m_CPND_CKPTINFO_V0_READ(ckpt_info, (char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + offset * sizeof(CKPT_INFO_V0)); >>> + client_bitmap_reset(&ckpt_info.client_bitmap, >> (client_hdl % 32)); >>> + m_CPND_CKPTINFO_V0_UPDATE((char >> *)cb->shm_addr.ckpt_addr + sizeof(CKPT_HDR), >>> + ckpt_info, offset * >> sizeof(CKPT_INFO_V0)); >>> + >>> + /* Delete the ckpt_info from shared memory if this >> ckpt_info's all 31 refs are closed */ >>> + num_bitset = >> client_bitmap_isset(ckpt_info.client_bitmap); >>> + if (!num_bitset) >>> + cpnd_clear_ckpt_info_v0(cb, cp_node, offset, >> prev_offset); >>> + >>> + } >>> + } >>> + TRACE_LEAVE(); >>> + return; >>> +} >>> + >>> >> /******************************************************************** >> * >> ****** >> ****************** >>> * Name : cpnd_restart_shm_ckpt_update >>> * >>> @@ -1304,6 +1790,14 @@ uint32_t cpnd_restart_shm_ckpt_update(CP >>> CKPT_HDR ckpt_hdr; >>> >>> TRACE_ENTER(); >>> + /* Check ckpt name input versus shm version and restart shm if >>> +need >> */ >>> + if (strlen(cp_node->ckpt_name) > SA_MAX_UNEXTENDED_NAME_LENGTH && >> cpnd_shm_version.shm_version != CPSV_CPND_SHM_VERSION_LONG_DN) { >>> + cpnd_shm_version.shm_version = >> CPSV_CPND_SHM_VERSION_LONG_DN; >>> + NCS_OS_POSIX_SHM_REQ_INFO cpnd_open_req; >>> + memset(&cpnd_open_req, 0, sizeof(cpnd_open_req)); >>> + cpnd_restart_shm(&cpnd_open_req, cb, cb->nodeid); >>> + } >>> + >>> /* check if the ckpt already exists */ >>> if (cp_node->offset == SHM_INIT) { /* if it is not there then >> find the free place to fit into */ >>> /* now find the free shm for placing the checkpoint info */ >> @@ >>> -1372,6 +1866,9 @@ static uint32_t cpnd_restore_client_info >>> n_clients = cli_hdr.num_clients; >>> TRACE_1("cpnd num clients read - n_clients = %d", n_clients); >>> >>> + /* Clean up before loading data*/ >>> + cpnd_client_node_tree_cleanup(cb); >>> + >>> /* ( DO - WHILE )- READ THE CLIENT INFO AND FILL THE DATABASE >>> OF >> CLIENT INFO */ >>> if (n_clients != 0) { >>> while (counter < MAX_CLIENTS) { @@ -1839,12 +2336,8 @@ static >>> void cpnd_destroy_shm_cpnd_cp_inf >>> static void >>> *cpnd_create_shm_cpnd_cp_info(NCS_OS_POSIX_SHM_REQ_INFO >> *req_info) >>> { >>> uint32_t rc = NCSCC_RC_SUCCESS; >>> - CPND_SHM_VERSION cpnd_shm_version; >>> >>> TRACE_ENTER(); >>> - /* Initializing shared memory version */ >>> - memset(&cpnd_shm_version, '\0', sizeof(cpnd_shm_version)); >>> - cpnd_shm_version.shm_version = CPSV_CPND_SHM_VERSION; >>> >>> /* Create the shared memory */ >>> req_info->info.open.i_flags = O_CREAT | O_RDWR; @@ -1855,9 >>> +2348,7 @@ static void *cpnd_create_shm_cpnd_cp_inf >>> } >>> >>> /* Initialize memory and set version */ >>> - memset(req_info->info.open.o_addr, 0, >>> - sizeof(CLIENT_HDR) + (MAX_CLIENTS * sizeof(CLIENT_INFO)) + >> sizeof(CKPT_HDR) + >>> - (MAX_CKPTS * sizeof(CKPT_INFO))); >>> + memset(req_info->info.open.o_addr, 0, >>> +cpsv_cpnd_shm_size(cpnd_shm_version.shm_version)); >>> memcpy(req_info->info.open.o_addr, &cpnd_shm_version, >>> sizeof(cpnd_shm_version)); >>> >>> TRACE_LEAVE(); >> >> > > > ------------------------------------------------------------------------------ Check out the vibrant tech community on one of the world's most engaging tech sites, SlashDot.org! http://sdm.link/slashdot _______________________________________________ Opensaf-devel mailing list Opensaf-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/opensaf-devel
