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:[email protected]]
> Sent: Tuesday, October 18, 2016 10:48 AM
> To: Vo Minh Hoang <[email protected]>
> Cc: [email protected]; [email protected]
> 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:[email protected]]
>> Sent: Thursday, October 13, 2016 1:33 PM
>> To: Hoang Vo <[email protected]>; [email protected]
>> Cc: [email protected]
>> 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
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
