Hi Canh Ack with comment see [Lennart] I will not review part 1 (implementation of filter callback) again since I acked that part in the previous review
Thanks Lennart > -----Original Message----- > From: Canh Van Truong [mailto:canh.v.tru...@dektech.com.au] > Sent: den 16 februari 2017 07:49 > To: Lennart Lund <lennart.l...@ericsson.com>; Vu Minh Nguyen > <vu.m.ngu...@dektech.com.au>; mahesh.va...@oracle.com > Cc: opensaf-devel@lists.sourceforge.net > Subject: [PATCH 2 of 3] log: Add minor version checking in log server [#2146] > > src/log/Makefile.am | 3 + > src/log/common/lgsv_defs.h | 4 + > src/log/common/lgsv_msg.h | 2 +- > src/log/logd/lgs_cb.h | 2 + > src/log/logd/lgs_evt.cc | 93 ++++++++++++++++----- > src/log/logd/lgs_mbcsv.cc | 181 ++++++++++++++++++++++++++++++---- > -------- > src/log/logd/lgs_mbcsv.h | 9 +- > src/log/logd/lgs_mbcsv_v6.cc | 169 > ++++++++++++++++++++++++++++++++++++++++ > src/log/logd/lgs_mbcsv_v6.h | 56 +++++++++++++ > src/log/logd/lgs_util.cc | 27 ++++- > 10 files changed, 462 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 > @@ -1,6 +1,7 @@ > # -*- OpenSAF -*- > # > # (C) Copyright 2016 The OpenSAF Foundation > +# Copyright Ericsson AB 2016, 2017 - All Rights Reserved. > # > # This program is distributed in the hope that it will be useful, but > # WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > @@ -71,6 +72,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 +119,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 > @@ -27,6 +27,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 > + > // 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 > @@ -130,7 +130,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 > @@ -1,6 +1,7 @@ > /* -*- OpenSAF -*- > * > * (C) Copyright 2008 The OpenSAF Foundation > + * Copyright Ericsson AB 2008, 2017 - All Rights Reserved. > * > * This program is distributed in the hope that it will be useful, but > * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > @@ -59,6 +60,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 > @@ -1,6 +1,7 @@ > /* -*- OpenSAF -*- > * > * (C) Copyright 2008 The OpenSAF Foundation > + * Copyright Ericsson AB 2008, 2017 - All Rights Reserved. > * > * This program is distributed in the hope that it will be useful, but > * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > @@ -23,16 +24,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); > @@ -60,6 +57,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 > + */ > +static bool is_log_version_valid(const SaVersionT *version) { > + return ((version->releaseCode == LOG_RELEASE_CODE) && > + (version->majorVersion <= LOG_MAJOR_VERSION) && > + (version->minorVersion <= LOG_MINOR_VERSION)); > +} > + > +/** > * Get client record from client ID > * @param client_id > * > @@ -607,6 +616,58 @@ done: > } > > /** > + * Stream initialize checkpointing > + * @param cb > + * @param logStream > + * @param open_sync_param > + * @return > + */ [Lennart] Naming is a bit confusing. It does not seems as if checkpointing is initialized which is what the description and function name says, instead this function is used to checkpoint data at an initialize event. > +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 > @@ -619,21 +680,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 (!is_log_version_valid(version)) { > ais_rc = SA_AIS_ERR_VERSION; > TRACE("version FAILED"); > goto snd_rsp; > @@ -650,15 +702,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 > @@ -1,6 +1,7 @@ > /* -*- OpenSAF -*- > * > * (C) Copyright 2008 The OpenSAF Foundation > + * Copyright Ericsson AB 2008, 2017 - All Rights Reserved. > * > * This program is distributed in the hope that it will be useful, but > * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > @@ -20,6 +21,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" > @@ -53,12 +55,11 @@ > * > * Version 5: Was introduced to avoid creating new checkpoint version if any > added/changed configuration parameters. > * > + * Version 6: Added client version to initialized message data structure. A > new data structure is lgsv_ckpt_msg_v6_t > + * which is used for checkpoint. > + * > */ > > -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 +361,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 +687,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 +710,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 +746,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 +767,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 +779,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 +1134,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 +1156,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 +1177,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 +1209,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 +1305,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 +1328,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 +1373,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 +1466,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 +1524,49 @@ 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; > + TRACE_ENTER(); > + 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("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->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("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); > + } > } > } > > @@ -2178,7 +2250,10 @@ uint32_t lgs_ckpt_send_async(lgs_cb_t *c > > TRACE_ENTER(); > > - 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()) { > @@ -2234,7 +2309,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); > @@ -2306,8 +2381,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 > @@ -2,6 +2,7 @@ > * File: lgs_mbcsv.h > * > * (C) Copyright 2008 The OpenSAF Foundation > + * Copyright Ericsson AB 2008, 2017 - All Rights Reserved. > * > * This program is distributed in the hope that it will be useful, but > * WITHOUT ANY WARRANTY; without even the implied warranty of > MERCHANTABILITY > @@ -38,9 +39,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 +108,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 +118,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 2017 The OpenSAF Foundation > + * Copyright Ericsson AB 2017 - All Rights Reserved. > + * > + * 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 -*- > + * > + * (C) Copyright 2017 The OpenSAF Foundation > + * Copyright Ericsson AB 2017 - All Rights Reserved. > + * > + * 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 > @@ -837,6 +837,20 @@ 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 > + */ > +static bool is_filter_supported(SaVersionT client_ver) { > + bool 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 > @@ -896,19 +910,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 Opensaf-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/opensaf-devel
