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
+
// 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));
+}
+
+/**
* 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 @@
*
*/
-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);
+ 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;
+}
/**
* 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
