Hi Vu, Your comments seems Ok
Thanks Lennart From: Canh Truong [mailto:[email protected]] Sent: den 15 februari 2017 08:50 To: Lennart Lund <[email protected]>; Vu Minh Nguyen <[email protected]>; [email protected] Cc: [email protected] Subject: FW: [PATCH 2 of 3] log: Add minor version checking in log server [#2146] Hi Lennart, Thanks for your comments. Please see my comments with [Canh] Regards Canh -----Original Message----- From: Lennart Lund [mailto:[email protected]] Sent: Tuesday, February 14, 2017 6:59 PM To: Canh Van Truong; Vu Minh Nguyen; [email protected]<mailto:[email protected]> Cc: [email protected]<mailto:[email protected]>; Lennart Lund Subject: RE: [PATCH 2 of 3] log: Add minor version checking in log server [#2146] Hi Canh See comments inline tagged [Lennart] A general comment. There is a lot of version checking going on both inline and there are several version checking functions. This should be improved and simplified. As is it is very likely that new problems with version handling will occur when new version handled features are added in the future. However there may be no time to fix for this release but a ticket may be written. See also replies for the other parts Thanks Lennart > -----Original Message----- > From: Canh Van Truong > Sent: den 19 januari 2017 12:29 > To: Lennart Lund > <[email protected]<mailto:[email protected]>>; Vu Minh Nguyen > <[email protected]<mailto:[email protected]>>; > [email protected]<mailto:[email protected]> > Cc: > [email protected]<mailto:[email protected]> > Subject: [PATCH 2 of 3] log: Add minor version checking in log server > [#2146] > > src/log/Makefile.am | 2 + > src/log/common/lgsv_defs.h | 4 + > src/log/common/lgsv_msg.h | 2 +- > src/log/logd/lgs_cb.h | 1 + > src/log/logd/lgs_evt.cc | 92 ++++++++++++++++----- > src/log/logd/lgs_mbcsv.cc | 176 ++++++++++++++++++++++++++++++---- > -------- > src/log/logd/lgs_mbcsv.h | 8 +- > src/log/logd/lgs_mbcsv_v6.cc | 169 > +++++++++++++++++++++++++++++++++++++++++ > src/log/logd/lgs_mbcsv_v6.h | 56 +++++++++++++ > src/log/logd/lgs_util.cc | 30 +++++- > 10 files changed, 456 insertions(+), 84 deletions(-) > > > Checking minor version and return version error if major/minor version > is higher than supported major/minor > > Add client_version to log_client_t and checkpoint struct in lgs > > Increase checkpoint version and checkpoint client_ver to stand by > > Only send filter callback to client that initialized with minor > version > 3 > > diff --git a/src/log/Makefile.am b/src/log/Makefile.am > --- a/src/log/Makefile.am > +++ b/src/log/Makefile.am > @@ -71,6 +71,7 @@ noinst_HEADERS += \ > src/log/logd/lgs_mbcsv_v2.h \ > src/log/logd/lgs_mbcsv_v3.h \ > src/log/logd/lgs_mbcsv_v5.h \ > +src/log/logd/lgs_mbcsv_v6.h \ > src/log/logd/lgs_recov.h \ > src/log/logd/lgs_stream.h \ > src/log/logd/lgs_util.h > @@ -117,6 +118,7 @@ bin_osaflogd_SOURCES = \ > src/log/logd/lgs_mbcsv_v2.cc \ src/log/logd/lgs_mbcsv_v3.cc \ > src/log/logd/lgs_mbcsv_v5.cc \ > +src/log/logd/lgs_mbcsv_v6.cc \ > src/log/logd/lgs_mds.cc \ > src/log/logd/lgs_recov.cc \ > src/log/logd/lgs_stream.cc \ > diff --git a/src/log/common/lgsv_defs.h b/src/log/common/lgsv_defs.h > --- a/src/log/common/lgsv_defs.h > +++ b/src/log/common/lgsv_defs.h > @@ -26,6 +26,10 @@ > #define LOG_MAJOR_VERSION_0 2 > #define LOG_MINOR_VERSION_0 1 > > +#define LOG_RELEASE_CODE_1 'A' > +#define LOG_MAJOR_VERSION_1 2 > +#define LOG_MINOR_VERSION_1 3 [Lennart] Why is this needed? Is the same as: [Canh] This is needed because when lgs checks if the version is supported for severity callback then send callback to client. So it need to compare A.02.03. We cannot use below macro because the version may increase in the future. #define LOG_RELEASE_CODE 'A' #define LOG_MAJOR_VERSION 2 #define LOG_MINOR_VERSION 3 > + > // Waiting time in library for sync send, unit 10ms #define > LGS_WAIT_TIME 1000 > > diff --git a/src/log/common/lgsv_msg.h b/src/log/common/lgsv_msg.h > --- a/src/log/common/lgsv_msg.h > +++ b/src/log/common/lgsv_msg.h > @@ -129,7 +129,7 @@ typedef struct logsv_loga_clm_status_par } > logsv_lga_clm_status_cbk_t; > > typedef struct { > -SaLogSeverityFlagsT log_severity; > + SaLogSeverityFlagsT log_severity; > } lgsv_severity_filter_callback_t; > > /* wrapper structure for all the callbacks */ diff --git > a/src/log/logd/lgs_cb.h b/src/log/logd/lgs_cb.h > --- a/src/log/logd/lgs_cb.h > +++ b/src/log/logd/lgs_cb.h > @@ -59,6 +59,7 @@ typedef struct { > NCS_PATRICIA_NODE pat_node; > uint32_t client_id; > uint32_t client_id_net; > + SaVersionT client_ver; > MDS_DEST mds_dest; > lgs_stream_list_t *stream_list_root; } log_client_t; diff --git > a/src/log/logd/lgs_evt.cc b/src/log/logd/lgs_evt.cc > --- a/src/log/logd/lgs_evt.cc > +++ b/src/log/logd/lgs_evt.cc > @@ -21,16 +21,12 @@ > > #include "lgs_mbcsv_v1.h" > #include "lgs_mbcsv_v2.h" > +#include "lgs_mbcsv_v6.h" > #include "lgs_recov.h" > #include "lgs_imm_gcfg.h" > #include "base/osaf_extended_name.h" > #include "lgs_clm.h" > > -/* Macro to validate the version */ > -#define m_LOG_VER_IS_VALID(ver) \ > - ( (ver->releaseCode == LOG_RELEASE_CODE) && \ > - (ver->majorVersion == LOG_MAJOR_VERSION || ver->minorVersion == > LOG_MINOR_VERSION)) > - > static uint32_t process_api_evt(lgsv_lgs_evt_t *evt); static > uint32_t proc_lga_updn_mds_msg(lgsv_lgs_evt_t *evt); static uint32_t > proc_mds_quiesced_ack_msg(lgsv_lgs_evt_t *evt); @@ -58,6 +54,18 @@ > LGSV_LGS_LGA_API_MSG_HANDLER lgs_lga_api }; > > /** > + * Check if the log version is valid > + * @param version > + * > + * @return true if log version is valid */ bool > +log_version_is_valid(SaVersionT *version) { > + return ((version->releaseCode == LOG_RELEASE_CODE) && > + (version->majorVersion <= LOG_MAJOR_VERSION) && > + (version->minorVersion <= LOG_MINOR_VERSION)); } [Lennart] Make static. Is only used internally in this file > + > +/** > * Get client record from client ID > * @param client_id > * > @@ -605,6 +613,58 @@ done: > } > > /** > + * Stream initialize checkpointing > + * @param cb > + * @param logStream > + * @param open_sync_param > + * @return > + */ > +static uint32_t lgs_ckpt_initialize(lgs_cb_t *cb, MDS_DEST mds_dest, > + log_client_t *client) { > + uint32_t async_rc = NCSCC_RC_SUCCESS; > + lgsv_ckpt_msg_v1_t ckpt_v1; > + lgsv_ckpt_msg_v6_t ckpt_v6; > + void *ckpt_ptr = NULL; > + lgsv_ckpt_header_t *header_ptr = NULL; > + > + TRACE_ENTER(); > + > + if (cb->ha_state == SA_AMF_HA_ACTIVE) { > + if (lgs_is_peer_v6()) { > + lgs_ckpt_initialize_msg_v6_t *ckpt_rec_ptr; > + memset(&ckpt_v6, 0, sizeof(ckpt_v6)); > + header_ptr = &ckpt_v6.header; > + ckpt_rec_ptr = &ckpt_v6.ckpt_rec.initialize_client; > + ckpt_ptr = &ckpt_v6; > + > + ckpt_rec_ptr->client_id = client->client_id; > + ckpt_rec_ptr->mds_dest = mds_dest; > + ckpt_rec_ptr->client_ver = client->client_ver; > + } else { > + lgs_ckpt_initialize_msg_t *ckpt_rec_ptr; > + memset(&ckpt_v1, 0, sizeof(ckpt_v1)); > + header_ptr = &ckpt_v1.header; > + ckpt_rec_ptr = &ckpt_v1.ckpt_rec.initialize_client; > + ckpt_ptr = &ckpt_v1; > + > + ckpt_rec_ptr->client_id = client->client_id; > + ckpt_rec_ptr->mds_dest = mds_dest; > + } > + > + header_ptr->ckpt_rec_type = LGS_CKPT_CLIENT_INITIALIZE; > + header_ptr->num_ckpt_records = 1; > + header_ptr->data_len = 1; > + async_rc = lgs_ckpt_send_async(cb, ckpt_ptr, NCS_MBCSV_ACT_ADD); > + if (async_rc == NCSCC_RC_SUCCESS) { > + TRACE_4("ASYNC UPDATE SEND SUCCESS for INITIALIZE .."); > + } > + } > + > + TRACE_LEAVE2("async_rc = %d",async_rc); > + return async_rc; > +} > + > +/** > * Handle a initialize message > * @param cb > * @param evt > @@ -617,21 +677,12 @@ static uint32_t proc_initialize_msg(lgs_ > SaVersionT *version; > lgsv_msg_t msg; > log_client_t *client = NULL; > - lgsv_ckpt_msg_v1_t ckpt_v1; > - void *ckpt_ptr; > - lgsv_ckpt_header_t *header_ptr; > - lgs_ckpt_initialize_msg_t *ckpt_rec_ptr; > > TRACE_ENTER2("dest %" PRIx64, evt->fr_dest); > > - memset(&ckpt_v1, 0, sizeof(ckpt_v1)); > - header_ptr = &ckpt_v1.header; > - ckpt_rec_ptr = &ckpt_v1.ckpt_rec.initialize_client; > - ckpt_ptr = &ckpt_v1; > - > /* Validate the version */ > version = &(evt->info.msg.info.api_info.param.init.version); > - if (!m_LOG_VER_IS_VALID(version)) { > + if (!log_version_is_valid(version)) { > ais_rc = SA_AIS_ERR_VERSION; > TRACE("version FAILED"); > goto snd_rsp; > @@ -648,15 +699,10 @@ static uint32_t proc_initialize_msg(lgs_ > goto snd_rsp; > } > > + client->client_ver = *version; > + > /* Checkpoint */ > - if (cb->ha_state == SA_AMF_HA_ACTIVE) { > - header_ptr->ckpt_rec_type = LGS_CKPT_CLIENT_INITIALIZE; > - header_ptr->num_ckpt_records = 1; > - header_ptr->data_len = 1; > - ckpt_rec_ptr->client_id = cb->last_client_id; > - ckpt_rec_ptr->mds_dest = evt->fr_dest; > - (void)lgs_ckpt_send_async(cb, ckpt_ptr, NCS_MBCSV_ACT_ADD); > - } > + lgs_ckpt_initialize(cb, evt->fr_dest, client); > > snd_rsp: > msg.type = LGSV_LGA_API_RESP_MSG; > diff --git a/src/log/logd/lgs_mbcsv.cc b/src/log/logd/lgs_mbcsv.cc > --- a/src/log/logd/lgs_mbcsv.cc > +++ b/src/log/logd/lgs_mbcsv.cc > @@ -20,6 +20,7 @@ > #include "base/ncssysf_mem.h" > #include "base/osaf_time.h" > > +#include "lgs_mbcsv_v6.h" > #include "lgs_mbcsv_v5.h" > #include "lgs_mbcsv_v3.h" > #include "lgs_mbcsv_v2.h" > @@ -55,10 +56,6 @@ > * > */ > [Lennart] /** * Note on MBCSV checkpoint versions for log service configuration * --------------------------------------------------------------- * Version 2: Only log root directory and close timestamp are checkpointed. * The data structure is `lgsv_ckpt_msg_v2_t` which is used to replicate to standby node. * * Version 3: No change in the checkpoint data structure. Means `lgsv_ckpt_msg_v2_t` is re-used. * This version was introduced to handle the rule on changing mailbox limits. * Therefore, the data processing for checkpoint version 3 is same as version 2's. * * Version 4: Added group name to data structure. A new data structure was introduced `lgsv_ckpt_msg_v3_t`. * * Version 5: Was introduced to avoid creating new checkpoint version if any added/changed configuration parameters. * */ This comment is not updated with information about Version 6: > -static uint32_t edp_ed_stream_list(EDU_HDL *edu_hdl, EDU_TKN > *edu_tkn, > - NCSCONTEXT ptr, uint32_t *ptr_data_len, > - EDU_BUF_ENV *buf_env, EDP_OP_TYPE op, > EDU_ERR > *o_err); > - > static uint32_t ckpt_proc_initialize_client(lgs_cb_t *cb, void > *data); static uint32_t ckpt_proc_finalize_client(lgs_cb_t *cb, void > *data); static uint32_t ckpt_proc_agent_down(lgs_cb_t *cb, void > *data); @@ -360,6 +357,18 @@ bool lgs_is_peer_v5() { } > > /** > + * Check if peer is version 6 (or later) > + * @return bool > + */ > +bool lgs_is_peer_v6() { > + if (lgs_cb->mbcsv_peer_version >= LGS_MBCSV_VERSION_6) { > + return true; > + } else { > + return false; > + } > +} > + > +/** > * Check if configured for split file system. > * If other node is version 1 split file system mode is not applicable. > * > @@ -674,26 +683,21 @@ static uint32_t edu_enc_streams(lgs_cb_t > > static uint32_t edu_enc_reg_list(lgs_cb_t *cb, NCS_UBAID *uba) { > log_client_t *client = NULL; > - lgs_ckpt_initialize_msg_t *ckpt_reg_rec; > + lgs_ckpt_initialize_msg_t ckpt_reg_rec ; > + lgs_ckpt_initialize_msg_v6_t ckpt_reg_rec_v6; void > + *ckpt_client_reg; > EDU_ERR ederror; > uint32_t rc = NCSCC_RC_SUCCESS, num_rec = 0; > uint8_t *pheader = NULL; > lgsv_ckpt_header_t ckpt_hdr; > + EDU_PROG_HANDLER edp_function_reg = NULL; > > TRACE_ENTER(); > > - /* Prepare reg. structure to encode */ > - ckpt_reg_rec = static_cast<lgs_ckpt_initialize_msg_t > *>(malloc(sizeof(lgs_ckpt_initialize_msg_t))); > - if (ckpt_reg_rec == NULL) { > - LOG_WA("malloc FAILED"); > - return (NCSCC_RC_FAILURE); > - } > - > /*Reserve space for "Checkpoint Header" */ > pheader = ncs_enc_reserve_space(uba, sizeof(lgsv_ckpt_header_t)); > if (pheader == NULL) { > TRACE(" ncs_enc_reserve_space FAILED"); > - free(ckpt_reg_rec); > return (rc = EDU_ERR_MEM_FAIL); > } > ncs_enc_claim_space(uba, sizeof(lgsv_ckpt_header_t)); @@ -702,16 > +706,26 @@ static uint32_t edu_enc_reg_list(lgs_cb_ > > /* Walk through the reg list and encode record by record */ > while (client != NULL) { > - ckpt_reg_rec->client_id = client->client_id; > - ckpt_reg_rec->mds_dest = client->mds_dest; > - ckpt_reg_rec->stream_list = client->stream_list_root; > + if (lgs_is_peer_v6()) { > + ckpt_reg_rec_v6.client_id = client->client_id; > + ckpt_reg_rec_v6.mds_dest = client->mds_dest; > + ckpt_reg_rec_v6.stream_list = client->stream_list_root; > + ckpt_reg_rec_v6.client_ver = client->client_ver; > + ckpt_client_reg = &ckpt_reg_rec_v6; > + edp_function_reg = edp_ed_reg_rec_v6; > + } else { > + ckpt_reg_rec.client_id = client->client_id; > + ckpt_reg_rec.mds_dest = client->mds_dest; > + ckpt_reg_rec.stream_list = client->stream_list_root; > + ckpt_client_reg = &ckpt_reg_rec; > + edp_function_reg = edp_ed_reg_rec; > + } > > - rc = m_NCS_EDU_EXEC(&cb->edu_hdl, edp_ed_reg_rec, uba, > EDP_OP_TYPE_ENC, ckpt_reg_rec, &ederror); > + rc = m_NCS_EDU_EXEC(&cb->edu_hdl, edp_function_reg, uba, > EDP_OP_TYPE_ENC, ckpt_client_reg, &ederror); > > if (rc != NCSCC_RC_SUCCESS) { > m_NCS_EDU_PRINT_ERROR_STRING(ederror); > TRACE(" m_NCS_EDU_EXEC FAILED"); > - free(ckpt_reg_rec); > return rc; > } > ++num_rec; > @@ -728,7 +742,6 @@ static uint32_t edu_enc_reg_list(lgs_cb_ > > enc_ckpt_header(pheader, ckpt_hdr); > > - free(ckpt_reg_rec); > TRACE_LEAVE(); > return NCSCC_RC_SUCCESS; > } /* End edu_enc_reg_list() */ > @@ -750,6 +763,7 @@ static uint32_t edu_enc_reg_list(lgs_cb_ > > ********************************************************** > ******************/ > > static uint32_t ckpt_encode_async_update(lgs_cb_t *lgs_cb, EDU_HDL > edu_hdl, NCS_MBCSV_CB_ARG *cbk_arg) { > + lgsv_ckpt_msg_v6_t *data_v6 = NULL; > lgsv_ckpt_msg_v5_t *data_v5 = NULL; > lgsv_ckpt_msg_v3_t *data_v3 = NULL; > lgsv_ckpt_msg_v2_t *data_v2 = NULL; @@ -761,7 +775,12 @@ static > uint32_t ckpt_encode_async_update > > TRACE_ENTER(); > /* Set reo_hdl from callback arg to ckpt_rec */ > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + data_v6 = reinterpret_cast<lgsv_ckpt_msg_v6_t *>( > + static_cast<long>(cbk_arg->info.encode.io_reo_hdl)); > + vdata = data_v6; > + edp_function = edp_ed_ckpt_msg_v6; } else if (lgs_is_peer_v5()) > + { > data_v5 = reinterpret_cast<lgsv_ckpt_msg_v5_t *>( > static_cast<long>(cbk_arg->info.encode.io_reo_hdl)); > vdata = data_v5; > @@ -1111,11 +1130,14 @@ static uint32_t ckpt_decode_async_update > lgsv_ckpt_msg_v3_t *ckpt_msg_v3 = &msg_v3; > lgsv_ckpt_msg_v5_t msg_v5; > lgsv_ckpt_msg_v5_t *ckpt_msg_v5 = &msg_v5; > + lgsv_ckpt_msg_v6_t msg_v6; > + lgsv_ckpt_msg_v6_t *ckpt_msg_v6 = &msg_v6; > void *ckpt_msg; > lgsv_ckpt_header_t hdr, *hdr_ptr = &hdr; > > + void *reg_rec; > + EDU_PROG_HANDLER edp_function_reg = NULL; > /* Same in all versions */ > - lgs_ckpt_initialize_msg_t *reg_rec; > lgs_ckpt_stream_open_t *stream_open; > > TRACE_ENTER(); > @@ -1130,7 +1152,10 @@ static uint32_t ckpt_decode_async_update > > TRACE_2("\tckpt_rec_type: %d ", (int)hdr_ptr->ckpt_rec_type); > > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + ckpt_msg_v6->header = hdr; > + ckpt_msg = ckpt_msg_v6; > + } else if (lgs_is_peer_v5()) { > ckpt_msg_v5->header = hdr; > ckpt_msg = ckpt_msg_v5; > } else if (lgs_is_peer_v4()) { > @@ -1148,17 +1173,24 @@ static uint32_t ckpt_decode_async_update > switch (hdr_ptr->ckpt_rec_type) { > case LGS_CKPT_CLIENT_INITIALIZE: > TRACE_2("\tINITIALIZE REC: UPDATE"); > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + reg_rec = &ckpt_msg_v6->ckpt_rec.initialize_client; > + edp_function_reg = edp_ed_reg_rec_v6; > + } else if (lgs_is_peer_v5()) { > reg_rec = &ckpt_msg_v5->ckpt_rec.initialize_client; > + edp_function_reg = edp_ed_reg_rec; > } else if (lgs_is_peer_v4()) { > reg_rec = &ckpt_msg_v3->ckpt_rec.initialize_client; > + edp_function_reg = edp_ed_reg_rec; > } else if (lgs_is_peer_v2()) { > reg_rec = &ckpt_msg_v2->ckpt_rec.initialize_client; > + edp_function_reg = edp_ed_reg_rec; > } else { > reg_rec = &ckpt_msg_v1->ckpt_rec.initialize_client; > + edp_function_reg = edp_ed_reg_rec; > } > > - rc = ckpt_decode_log_struct(cb, cbk_arg, ckpt_msg, reg_rec, > edp_ed_reg_rec); > + rc = ckpt_decode_log_struct(cb, cbk_arg, ckpt_msg, reg_rec, > edp_function_reg); > if (rc != NCSCC_RC_SUCCESS) { > goto done; > } > @@ -1173,7 +1205,9 @@ static uint32_t ckpt_decode_async_update > > case LGS_CKPT_OPEN_STREAM: /* 4 */ > TRACE_2("\tSTREAM OPEN: UPDATE"); > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + stream_open = &ckpt_msg_v6->ckpt_rec.stream_open; > + } else if (lgs_is_peer_v5()) { > stream_open = &ckpt_msg_v5->ckpt_rec.stream_open; > } else if (lgs_is_peer_v4()) { > stream_open = &ckpt_msg_v3->ckpt_rec.stream_open; > @@ -1267,19 +1301,21 @@ static uint32_t ckpt_decode_cold_sync(lg > EDU_ERR ederror; > lgsv_ckpt_msg_v1_t msg_v1; > lgsv_ckpt_msg_v2_t msg_v2; > + lgsv_ckpt_msg_v6_t msg_v6; > uint32_t num_rec = 0; > - lgs_ckpt_initialize_msg_t *reg_rec = NULL; > + void *reg_rec = NULL; > lgs_ckpt_stream_open_t *stream_rec = NULL; > uint32_t num_of_async_upd; > uint8_t *ptr; > uint8_t data_cnt[16]; > > lgsv_ckpt_header_t *header; > - lgs_ckpt_initialize_msg_t *initialize_client_rec_ptr; > + void *initialize_client_rec_ptr; > lgs_ckpt_stream_open_t *stream_open_rec_ptr; > void *vckpt_rec; > size_t ckpt_rec_size; > void *vdata; > + EDU_PROG_HANDLER edp_function_reg = edp_ed_reg_rec; > > TRACE_ENTER(); > /* > @@ -1288,7 +1324,16 @@ static uint32_t ckpt_decode_cold_sync(lg > ------------------------------------------------- > */ > > - if (lgs_is_peer_v2()) { > + if (lgs_is_peer_v6()) { > + lgsv_ckpt_msg_v6_t *data_v6 = &msg_v6; > + header = &data_v6->header; > + initialize_client_rec_ptr = &data_v6->ckpt_rec.initialize_client; > + stream_open_rec_ptr = &data_v6->ckpt_rec.stream_open; > + vdata = data_v6; > + vckpt_rec = &data_v6->ckpt_rec; > + ckpt_rec_size = sizeof(data_v6->ckpt_rec); > + edp_function_reg = edp_ed_reg_rec_v6; } else if > + (lgs_is_peer_v2()) { > lgsv_ckpt_msg_v2_t *data_v2 = &msg_v2; > header = &data_v2->header; > initialize_client_rec_ptr = &data_v2->ckpt_rec.initialize_client; > @@ -1324,7 +1369,7 @@ static uint32_t ckpt_decode_cold_sync(lg > TRACE("regid: num_rec = %u", num_rec); > while (num_rec) { > reg_rec = initialize_client_rec_ptr; > - rc = m_NCS_EDU_EXEC(&cb->edu_hdl, edp_ed_reg_rec, &cbk_arg- > >info.decode.i_uba, > + rc = m_NCS_EDU_EXEC(&cb->edu_hdl, edp_function_reg, &cbk_arg- > >info.decode.i_uba, > EDP_OP_TYPE_DEC, ®_rec, &ederror); > > if (rc != NCSCC_RC_SUCCESS) { > @@ -1417,13 +1462,17 @@ static uint32_t process_ckpt_data(lgs_cb > lgsv_ckpt_msg_v2_t *data_v2; > lgsv_ckpt_msg_v3_t *data_v3; > lgsv_ckpt_msg_v5_t *data_v5; > + lgsv_ckpt_msg_v6_t *data_v6; > > if ((!cb) || (data == NULL)) { > TRACE("%s - FAILED: (!cb) || (data == NULL)", __FUNCTION__); > return (rc = NCSCC_RC_FAILURE); > } > > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + data_v6 = static_cast<lgsv_ckpt_msg_v6_t *>(data); > + lgsv_ckpt_msg_type = data_v6->header.ckpt_rec_type; } else if > + (lgs_is_peer_v5()) { > data_v5 = static_cast<lgsv_ckpt_msg_v5_t *>(data); > lgsv_ckpt_msg_type = data_v5->header.ckpt_rec_type; > } else if (lgs_is_peer_v4()) { > @@ -1471,30 +1520,48 @@ static uint32_t process_ckpt_data(lgs_cb > > static uint32_t ckpt_proc_initialize_client(lgs_cb_t *cb, void *data) { > log_client_t *client; > - lgs_ckpt_initialize_msg_t *param; > > - if (lgs_is_peer_v2()) { > - lgsv_ckpt_msg_v2_t *data_v2 = static_cast<lgsv_ckpt_msg_v2_t > *>(data); > - param = &data_v2->ckpt_rec.initialize_client; > + if (lgs_is_peer_v6()) { > + lgs_ckpt_initialize_msg_v6_t *param; > + lgsv_ckpt_msg_v6_t *data_v6 = static_cast<lgsv_ckpt_msg_v6_t > *>(data); > + param = &data_v6->ckpt_rec.initialize_client; > + > + TRACE_ENTER2("client ID: %d", param->client_id); [Lennart] TRACE_ENTER in wrong place. Shall always be placed first and in the outer most scope of a function. It shall also only be used once in a function. This is especially important when compiling with C++ compiler since the TRACE_ENTER/TRACE_LEAVE handling is handled by a C++ class. TRACE_LEAVE will be done automatically and does not have to be inserted in the code when TRACE_ENTER goes out of scope. This comment is applicable for all log server code. TRACE_ENTER as used in this function will cause compiler error. > + client = lgs_client_get_by_id(param->client_id); > + if (client == NULL) { > + /* Client does not exist, create new one */ > + if ((client = lgs_client_new(param->mds_dest, param->client_id, > + param- > >stream_list)) == NULL) { > + /* Do not allow standby to get out of sync */ > + lgs_exit("Could not create new client", > SA_AMF_COMPONENT_RESTART); > + } else { > + client->client_ver = param->client_ver; > + } > + } else { > + /* Client with ID already exist, check other attributes */ > + if (client->mds_dest != param->mds_dest) { > + /* Do not allow standby to get out of sync */ > + lgs_exit("Client attributes differ", SA_AMF_COMPONENT_RESTART); > + } > + } > } else { > + lgs_ckpt_initialize_msg_t *param; > lgsv_ckpt_msg_v1_t *data_v1 = static_cast<lgsv_ckpt_msg_v1_t > *>(data); > param = &data_v1->ckpt_rec.initialize_client; > - } > > - TRACE_ENTER2("client ID: %d", param->client_id); > - > - client = lgs_client_get_by_id(param->client_id); > - if (client == NULL) { > - /* Client does not exist, create new one */ > - if ((client = lgs_client_new(param->mds_dest, param->client_id, param- > >stream_list)) == NULL) { > - /* Do not allow standby to get out of sync */ > - lgs_exit("Could not create new client", > SA_AMF_COMPONENT_RESTART); > - } > - } else { > - /* Client with ID already exist, check other attributes */ > - if (client->mds_dest != param->mds_dest) { > - /* Do not allow standby to get out of sync */ > - lgs_exit("Client attributes differ", SA_AMF_COMPONENT_RESTART); > + TRACE_ENTER2("client ID: %d", param->client_id); > + client = lgs_client_get_by_id(param->client_id); > + if (client == NULL) { > + /* Client does not exist, create new one */ > + if ((client = lgs_client_new(param->mds_dest, param->client_id, > + param- > >stream_list)) == NULL) { > + /* Do not allow standby to get out of sync */ > + lgs_exit("Could not create new client", > SA_AMF_COMPONENT_RESTART); > + } > + } else { > + /* Client with ID already exist, check other attributes */ > + if (client->mds_dest != param->mds_dest) { > + /* Do not allow standby to get out of sync */ > + lgs_exit("Client attributes differ", SA_AMF_COMPONENT_RESTART); > + } > } > } > > @@ -2176,7 +2243,10 @@ uint32_t lgs_ckpt_send_async(lgs_cb_t *c > NCS_MBCSV_ARG mbcsv_arg; > lgsv_ckpt_msg_type_t ckpt_rec_type; > > - if (lgs_is_peer_v5()) { > + if (lgs_is_peer_v6()) { > + lgsv_ckpt_msg_v6_t *ckpt_rec_v6 = static_cast<lgsv_ckpt_msg_v6_t > *>(ckpt_rec); > + ckpt_rec_type = ckpt_rec_v6->header.ckpt_rec_type; > + } else if (lgs_is_peer_v5()) { > lgsv_ckpt_msg_v5_t *ckpt_rec_v5 = static_cast<lgsv_ckpt_msg_v5_t > *>(ckpt_rec); > ckpt_rec_type = ckpt_rec_v5->header.ckpt_rec_type; > } else if (lgs_is_peer_v4()) { > @@ -2232,7 +2302,7 @@ static uint32_t ckpt_peer_info_cbk_handl > > lgs_cb->mbcsv_peer_version = arg->info.peer.i_peer_version; > if (lgs_cb->mbcsv_peer_version < LGS_MBCSV_VERSION_MIN) { > - TRACE("peer_version not correct!!\n"); > + TRACE("peer_version (%d) not correct!!\n", lgs_cb- > >mbcsv_peer_version); > return NCSCC_RC_FAILURE; > } > TRACE("%s - peer_version = %d",__FUNCTION__, lgs_cb- > >mbcsv_peer_version); > @@ -2304,8 +2374,8 @@ static uint32_t ckpt_err_ind_cbk_handler > * @param o_err > * @return > */ > -static uint32_t edp_ed_stream_list(EDU_HDL *edu_hdl, EDU_TKN > *edu_tkn, > - NCSCONTEXT ptr, uint32_t *ptr_data_len, > EDU_BUF_ENV > *buf_env, EDP_OP_TYPE op, EDU_ERR *o_err) { > +uint32_t edp_ed_stream_list(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > +EDU_BUF_ENV > *buf_env, EDP_OP_TYPE op, EDU_ERR *o_err) { > uint32_t rc = NCSCC_RC_SUCCESS; > lgs_stream_list_t *ckpt_stream_list_msg_ptr = NULL, > **ckpt_stream_list_msg_dec_ptr; > > diff --git a/src/log/logd/lgs_mbcsv.h b/src/log/logd/lgs_mbcsv.h > --- a/src/log/logd/lgs_mbcsv.h > +++ b/src/log/logd/lgs_mbcsv.h > @@ -38,9 +38,10 @@ > #define LGS_MBCSV_VERSION_2 2 > #define LGS_MBCSV_VERSION_4 4 > #define LGS_MBCSV_VERSION_5 5 > +#define LGS_MBCSV_VERSION_6 6 > > /* Current version */ > -#define LGS_MBCSV_VERSION 5 > +#define LGS_MBCSV_VERSION 6 > #define LGS_MBCSV_VERSION_MIN 1 > > /* Checkpoint message types(Used as 'reotype' w.r.t mbcsv) */ @@ > -106,6 +107,7 @@ bool lgs_is_peer_v2(); bool lgs_is_peer_v3(); bool > lgs_is_peer_v4(); bool lgs_is_peer_v5(); > +bool lgs_is_peer_v6(); > bool lgs_is_split_file_system(); > uint32_t lgs_mbcsv_dispatch(NCS_MBCSV_HDL mbcsv_hdl); void > lgs_free_edu_mem(char *ptr); @@ -115,6 +117,10 @@ uint32_t > edp_ed_header_rec(EDU_HDL *edu_ > NCSCONTEXT ptr, uint32_t *ptr_data_len, > EDU_BUF_ENV *buf_env, EDP_OP_TYPE op, > EDU_ERR *o_err); int32_t ckpt_msg_test_type(NCSCONTEXT arg); > + > +uint32_t edp_ed_stream_list(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > + EDU_BUF_ENV *buf_env, EDP_OP_TYPE op, > +EDU_ERR > *o_err); > uint32_t edp_ed_reg_rec(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > NCSCONTEXT ptr, uint32_t *ptr_data_len, > EDU_BUF_ENV *buf_env, > EDP_OP_TYPE op, EDU_ERR *o_err); diff --git > a/src/log/logd/lgs_mbcsv_v6.cc b/src/log/logd/lgs_mbcsv_v6.cc new file > mode 100644 > --- /dev/null > +++ b/src/log/logd/lgs_mbcsv_v6.cc > @@ -0,0 +1,169 @@ > +/* -*- OpenSAF -*- > + * > + * (C) Copyright 2015 The OpenSAF Foundation > + * File: lgs_mbcsv_v5.c > + * > + * This program is distributed in the hope that it will be useful, > +but > + * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are > licensed > + * under the GNU Lesser General Public License Version 2.1, February 1999. > + * The complete license can be accessed from the following location: > + * http://opensource.org/licenses/lgpl-license.php > + * See the Copying file included with the OpenSAF distribution for > + full > + * licensing terms. > + * > + * Author(s): Ericsson AB > + * > + */ > + > +#include "lgs_mbcsv_v6.h" > + > + > +/********************************************************* > ******************* > + * Name : edp_ed_reg_rec_v6 > + * > + * Description : This function is an EDU program for encoding/decoding > + * lgsv checkpoint registration rec. > + * > + * Arguments : EDU_HDL - pointer to edu handle, > + * EDU_TKN - internal edu token to help encode/decode, > + * POINTER to the structure to encode/decode from/to, > + * data length specifying number of structures, > + * EDU_BUF_ENV - pointer to buffer for encoding/decoding. > + * op - operation type being encode/decode. > + * EDU_ERR - out param to indicate errors in processing. > + * > + * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE > + * > + * Notes : None. > + > ********************************************************** > *******************/ > +uint32_t edp_ed_reg_rec_v6(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > + EDU_BUF_ENV *buf_env, EDP_OP_TYPE op, > +EDU_ERR > *o_err) { > + uint32_t rc = NCSCC_RC_SUCCESS; > + lgs_ckpt_initialize_msg_t *ckpt_reg_msg_ptr = NULL, > **ckpt_reg_msg_dec_ptr; > + > + EDU_INST_SET ckpt_reg_rec_ed_rules[] = { > + {EDU_START, edp_ed_reg_rec_v6, 0, 0, 0, > sizeof(lgs_ckpt_initialize_msg_v6_t), 0, NULL}, > + {EDU_EXEC, ncs_edp_uns32, 0, 0, 0, > (long)&((lgs_ckpt_initialize_msg_v6_t *)0)->client_id, 0, NULL}, > + {EDU_EXEC, ncs_edp_mds_dest, 0, 0, 0, > (long)&((lgs_ckpt_initialize_msg_v6_t *)0)->mds_dest, 0, NULL}, > + {EDU_EXEC, edp_ed_stream_list, EDQ_POINTER, 0, 0, > (long)&((lgs_ckpt_initialize_msg_v6_t *)0)->stream_list, > + 0, NULL}, > + {EDU_EXEC, ncs_edp_uns32, 0, 0, 0, > (long)&((lgs_ckpt_initialize_msg_v6_t *)0)->client_ver, 0, NULL}, > + {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, }; > + > + if (op == EDP_OP_TYPE_ENC) { > + ckpt_reg_msg_ptr = static_cast<lgs_ckpt_initialize_msg_t *>(ptr); > + } else if (op == EDP_OP_TYPE_DEC) { > + ckpt_reg_msg_dec_ptr = static_cast<lgs_ckpt_initialize_msg_t > + **>(ptr); > + > + if (*ckpt_reg_msg_dec_ptr == NULL) { > + *o_err = EDU_ERR_MEM_FAIL; > + return NCSCC_RC_FAILURE; > + } > + memset(*ckpt_reg_msg_dec_ptr, '\0', sizeof(lgs_ckpt_initialize_msg_t)); > + ckpt_reg_msg_ptr = *ckpt_reg_msg_dec_ptr; } else { > + ckpt_reg_msg_ptr = static_cast<lgs_ckpt_initialize_msg_t *>(ptr); > + } > + > + rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, > + ckpt_reg_rec_ed_rules, > + ckpt_reg_msg_ptr, > + ptr_data_len, > + buf_env, op, o_err); > + return rc; > +} /* End edp_ed_reg_rec */ > + > +/********************************************************* > ******************* > + * Name : edp_ed_ckpt_msg_v6 > + * > + * Description : This function is an EDU program for encoding/decoding > + * lgsv checkpoint messages. This program runs the > + * edp_ed_hdr_rec program first to decide the > + * checkpoint message type based on which it will call the > + * appropriate EDU programs for the different checkpoint > + * messages. > + * > + * Arguments : EDU_HDL - pointer to edu handle, > + * EDU_TKN - internal edu token to help encode/decode, > + * POINTER to the structure to encode/decode from/to, > + * data length specifying number of structures, > + * EDU_BUF_ENV - pointer to buffer for encoding/decoding. > + * op - operation type being encode/decode. > + * EDU_ERR - out param to indicate errors in processing. > + * > + * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE > + * > + * Notes : None. > + > ********************************************************** > *******************/ > + > +uint32_t edp_ed_ckpt_msg_v6(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > +EDU_BUF_ENV > *buf_env, > + EDP_OP_TYPE op, EDU_ERR *o_err) { > + uint32_t rc = NCSCC_RC_SUCCESS; lgsv_ckpt_msg_v6_t *ckpt_msg_ptr = > + NULL, **ckpt_msg_dec_ptr; > + > + EDU_INST_SET ckpt_msg_ed_rules[] = { > + {EDU_START, edp_ed_ckpt_msg_v6, 0, 0, 0, > + sizeof(lgsv_ckpt_msg_v6_t), > 0, NULL}, > + {EDU_EXEC, edp_ed_header_rec, 0, 0, 0, > + (long)&((lgsv_ckpt_msg_v6_t > *)0)->header, 0, NULL}, > + > + {EDU_TEST, ncs_edp_uns32, 0, 0, 0, (long)&((lgsv_ckpt_msg_v6_t > + *)0)- > >header, 0, > + (EDU_EXEC_RTINE)ckpt_msg_test_type}, > + > + /* Reg Record */ > + {EDU_EXEC, edp_ed_reg_rec_v6, 0, 0, static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.initialize_client, 0, > + NULL}, > + > + /* Finalize record */ > + {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.finalize_client, 0, > + NULL}, > + > + /* write log Record */ > + {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.write_log, 0, NULL}, > + > + /* Open stream */ > + {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.stream_open, 0, > + NULL}, > + > + /* Close stream */ > + {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, > static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.stream_close, 0, > + NULL}, > + > + /* Agent dest */ > + {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, > static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.stream_cfg, 0, NULL}, > + > + /* Cfg stream */ > + {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, > static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.stream_cfg, 0, NULL}, > + > + /* Lgs cfg */ > + {EDU_EXEC, edp_ed_lgs_cfg_rec_v5, 0, 0, static_cast<int>(EDU_EXIT), > + (long)&((lgsv_ckpt_msg_v6_t *)0)->ckpt_rec.lgs_cfg, 0, NULL}, > + > + {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, }; > + > + if (op == EDP_OP_TYPE_ENC) { > + ckpt_msg_ptr = static_cast<lgsv_ckpt_msg_v6_t *>(ptr); } else if > + (op == EDP_OP_TYPE_DEC) { > + ckpt_msg_dec_ptr = static_cast<lgsv_ckpt_msg_v6_t **>(ptr); > + if (*ckpt_msg_dec_ptr == NULL) { > + *o_err = EDU_ERR_MEM_FAIL; > + return NCSCC_RC_FAILURE; > + } > + memset(*ckpt_msg_dec_ptr, '\0', sizeof(lgsv_ckpt_msg_v6_t)); > + ckpt_msg_ptr = *ckpt_msg_dec_ptr; } else { > + ckpt_msg_ptr = static_cast<lgsv_ckpt_msg_v6_t *>(ptr); } > + > + rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, ckpt_msg_ed_rules, > + ckpt_msg_ptr, ptr_data_len, buf_env, op, > + o_err); > + > + return rc; > + > +} /* End edu_enc_dec_ckpt_msg() */ > diff --git a/src/log/logd/lgs_mbcsv_v6.h b/src/log/logd/lgs_mbcsv_v6.h > new file mode 100644 > --- /dev/null > +++ b/src/log/logd/lgs_mbcsv_v6.h > @@ -0,0 +1,56 @@ > +/* -*- OpenSAF -*- > + * File: lgs_mbcsv_v4.h > + * > + * (C) Copyright 2015 The OpenSAF Foundation > + * > + * This program is distributed in the hope that it will be useful, > +but > + * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are > licensed > + * under the GNU Lesser General Public License Version 2.1, February 1999. > + * The complete license can be accessed from the following location: > + * http://opensource.org/licenses/lgpl-license.php > + * See the Copying file included with the OpenSAF distribution for > + full > + * licensing terms. > + * > + * Author(s): Ericsson AB > + * > + */ > + > +#ifndef LOG_LOGD_LGS_MBCSV_V6_H_ > +#define LOG_LOGD_LGS_MBCSV_V6_H_ > + > +#include "log/logd/lgs.h" > +#include "lgs_config.h" > +#include "lgs_mbcsv_v2.h" > +#include "lgs_mbcsv_v5.h" > + > +/* Initialize checkpoint record, used in cold/async checkpoint > +updates */ typedef struct { > + uint32_t client_id; /* Client Id at Active */ > + MDS_DEST mds_dest; /* Handy when an LGA instance goes away */ > + lgs_stream_list_t *stream_list; > + SaVersionT client_ver; /* Version of client that was initialized > +*/ } lgs_ckpt_initialize_msg_v6_t; > + > +typedef struct { > + lgsv_ckpt_header_t header; > + union { > + lgs_ckpt_initialize_msg_v6_t initialize_client; > + lgs_ckpt_finalize_msg_v2_t finalize_client; > + lgs_ckpt_write_log_v2_t write_log; > + lgs_ckpt_agent_down_v2_t agent_down; > + lgs_ckpt_stream_open_t stream_open; > + lgs_ckpt_stream_close_v2_t stream_close; > + lgs_ckpt_stream_cfg_v2_t stream_cfg; > + lgs_ckpt_lgs_cfg_v5_t lgs_cfg; > + } ckpt_rec; > +} lgsv_ckpt_msg_v6_t; > + > +uint32_t edp_ed_reg_rec_v6(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > + EDU_BUF_ENV *buf_env, EDP_OP_TYPE op, > +EDU_ERR > *o_err); > +uint32_t edp_ed_ckpt_msg_v6(EDU_HDL *edu_hdl, EDU_TKN *edu_tkn, > + NCSCONTEXT ptr, uint32_t *ptr_data_len, > +EDU_BUF_ENV > *buf_env, > + EDP_OP_TYPE op, EDU_ERR *o_err); > + > +#endif // LOG_LOGD_LGS_MBCSV_V6_H_ > diff --git a/src/log/logd/lgs_util.cc b/src/log/logd/lgs_util.cc > --- a/src/log/logd/lgs_util.cc > +++ b/src/log/logd/lgs_util.cc > @@ -835,6 +835,23 @@ bool lgs_is_extended_name_valid(const Sa > return true; > } > > +/** > + * Check if severity filter is supported for client > + * > + * @param client_ver > + * @return: true if severity filter is supported for client */ bool > +is_filter_supported(SaVersionT client_ver) { > + if ((client_ver.releaseCode > LOG_RELEASE_CODE_1) || > + ((client_ver.releaseCode == LOG_RELEASE_CODE_1 && > + client_ver.majorVersion > LOG_MAJOR_VERSION_1)) || > + ((client_ver.releaseCode == LOG_RELEASE_CODE_1 && > + client_ver.majorVersion == LOG_MAJOR_VERSION_1 && > + client_ver.minorVersion >= LOG_MINOR_VERSION_1))) { > + return true; > + } else > + return false; > +} [Lennart] I think this version check is incorrect. What you probably want to do is to verify that minor version is at least 3 if release code and major version is current version. If major version or release code is stepped up then all minor versions support "filter callback". This means that: if (releaseCode > A) OR (majorVersion > 2) { Minor version does not matter so we can always return OK } else if (minorVersion >= 3) { We can return OK at least if releaseCode and majorVersion is not lower than current version. This can however never happen since no such versions exist. } else { return FAIL } [Canh] This checking will be fixed as below: is_filter_supported(SaVersionT client_ver) { rc = true; if (client_ver.releaseCode == LOG_RELEASE_CODE_1 && client_ver.majorVersion == LOG_MAJOR_VERSION_1 && client_ver.minorVersion < LOG_MINOR_VERSION_1) rc = false; return rc; } > > /** > * Send a severity callback callback message to a client @@ -894,19 > +911,20 @@ void lgs_send_severity_filter_to_clients > > rp = reinterpret_cast<log_client_t *> > (ncs_patricia_tree_getnext(&lgs_cb->client_tree, NULL)); > - > while (rp != NULL) { > /* Store the client_id_net for getting next */ > client_id_net = rp->client_id_net; > /* Do not send to all client. Send to clients that need filter > callback and associate with this stream */ > stream = rp->stream_list_root; > - while (stream != NULL) { > - if (stream->stream_id == stream_id) { > - lgs_send_filter_msg(rp->client_id, stream_id, severity_filter, rp- > >mds_dest); > - break; > + if (is_filter_supported(rp->client_ver)) { > + while (stream != NULL) { > + if (stream->stream_id == stream_id) { > + lgs_send_filter_msg(rp->client_id, stream_id, > + severity_filter, rp- > >mds_dest); > + break; > + } > + stream = stream->next; > } > - stream = stream->next; > } > rp = reinterpret_cast<log_client_t *>(ncs_patricia_tree_getnext( > &lgs_cb->client_tree, reinterpret_cast<uint8_t > *>(&client_id_net))); ------------------------------------------------------------------------------ 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
