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
