Skip to content

B
Beam Positoning Monitor - Software
Commit 47c648c5 authored by Lucas Russo's avatar Lucas Russo
Browse files
Options

hal/msg/*: convert error check to ASSERT macros 

Now, instead of a "custom" error checking we use the
new verison of ASSERT macros (introduced in commit
d1cb7681) which allow us to set the "err" variable
in a more generic way.

This together with commit b487515e fixes #15 github
issue.
parent b487515e
Hide whitespace changes
Inline Side-by-side
Showing with 51 additions and 70 deletions
hal/msg/smio_thsafe_ops/smio_thsafe_zmq_client.c
View file @ 47c648c5
......@@ -252,22 +252,17 @@ int _thsafe_zmq_client_open_release (smio_t *self, llio_endpoint_t *endpoint, ui
zframe_destroy (&reply_frame); /* Don't do anything with the reply code */
zframe_t *ret_code_frame = zmsg_pop (recv_msg);
if (ret_code_frame == NULL) {
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Interrupted or malformed message\n");
/* Interrupted or malformed message */
goto err_recv_data;
}
/* Check for malformed message */
ASSERT_TEST(ret_code_frame != NULL, "Interrupted or malformed message",
err_recv_data);
/* Check if the frame has the number of bytes requested.
* For now, we consider a success only when the number of
* bytes requested is the same as the actually read*/
if (zframe_size (ret_code_frame) != THSAFE_REPLY_SIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Frame size is wrong\n");
goto err_recv_data_size;
}
ASSERT_TEST(zframe_size (ret_code_frame) == THSAFE_REPLY_SIZE, "Frame size is wrong",
err_recv_data_size);
ret = *(THSAFE_REPLY_TYPE *) zframe_data (ret_code_frame);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received return code: %08X\n", ret);
err_recv_data_size:
......@@ -426,25 +421,20 @@ static zmsg_t *_thsafe_zmq_client_recv_confirmation (smio_t *self)
/* Message is:
* frame 0: Reply code */
if (reply_frame == NULL) {
/* Interrupted or malformed message */
goto err_recv_data;
}
/* Check for interrupted or malformed message */
ASSERT_TEST(reply_frame != NULL, "Interrupted or malformed message",
err_recv_data);
/* Check if the frame has the correct number of bytes */
if (zframe_size (reply_frame) != THSAFE_REPLY_SIZE) {
goto err_recv_data;
}
ASSERT_TEST(zframe_size (reply_frame) == THSAFE_REPLY_SIZE, "Frame size is wrong",
err_recv_data);
uint8_t *raw_data = (uint8_t *) zframe_data (reply_frame);
ASSERT_TEST(raw_data != NULL, "Could not receive confirmation code", err_null_raw_data);
uint32_t reply_code = *(uint32_t *) raw_data;
/* Check for confirmation */
if (reply_code != THSAFE_OK) {
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received reply code OK\n");
goto err_reply_code_not_ok;
}
ASSERT_TEST(reply_code == THSAFE_OK, "Received reply code NOT OK",
err_reply_code_not_ok);
/* Caller owns the message and is its responsability to destroy it */
return recv_msg;
......@@ -473,11 +463,9 @@ static ssize_t _thsafe_zmq_client_recv_read (smio_t *self, uint8_t *data,
zframe_t *return_frame = zmsg_pop (recv_msg);
ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);
if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n");
goto err_wrong_size_ret_frame;
}
/* Check for return frame size */
ASSERT_TEST(zframe_size (return_frame) == THSAFE_RETURN_SIZE,
"Return frame size is wrong", err_wrong_size_ret_frame);
zframe_t *data_frame = zmsg_pop (recv_msg);
ASSERT_TEST(data_frame != NULL, "Could not receive data", err_recv_data);
......@@ -485,10 +473,9 @@ static ssize_t _thsafe_zmq_client_recv_read (smio_t *self, uint8_t *data,
/* Check if the frame has the number of bytes requested.
* For now, we consider a success only when the number of
* bytes requested is the same as the actually read*/
if ((ssize_t) zframe_size (data_frame) != *(THSAFE_RETURN_TYPE *) zframe_data (return_frame)) {
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Data frame size is wrong\n");
goto err_recv_data;
}
ASSERT_TEST((ssize_t) zframe_size (data_frame) ==
*(THSAFE_RETURN_TYPE *) zframe_data (return_frame),
"Received data frame size is wrong", err_recv_data);
uint8_t* raw_data = (uint8_t *) zframe_data (data_frame);
memcpy (data, raw_data, size);
......@@ -522,13 +509,11 @@ static ssize_t _thsafe_zmq_client_recv_write (smio_t *self)
zframe_t *return_frame = zmsg_pop (recv_msg);
ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);
if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n");
goto err_wrong_size_ret_frame;
}
/* Check for return frame size */
ASSERT_TEST(zframe_size (return_frame) == THSAFE_RETURN_SIZE,
"Return frame size is wrong", err_wrong_size_ret_frame);
ret_size = *(THSAFE_RETURN_TYPE *) zframe_data (return_frame);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received code: %zd\n", ret_size);
err_wrong_size_ret_frame:
......
hal/msg/smio_thsafe_ops/smio_thsafe_zmq_server.c
View file @ 47c648c5
......@@ -258,11 +258,9 @@ void *thsafe_zmq_server_write_16 (void *owner, void *args)
int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
if (zframe_size (data_write_frame) != THSAFE_WRITE_16_DSIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_server:zmq] Wrong received data size\n");
goto err_wrong_data_write_size;
}
/* Check for received data size */
ASSERT_TEST(zframe_size (data_write_frame) == THSAFE_WRITE_16_DSIZE,
"Wrong received data size", err_wrong_data_write_size);
/* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_16 (self->llio, offset, (uint16_t *) zframe_data (data_write_frame));
......@@ -293,11 +291,9 @@ void *thsafe_zmq_server_write_32 (void *owner, void *args)
int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
if (zframe_size (data_write_frame) != THSAFE_WRITE_32_DSIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_server:zmq] Wrong received data size\n");
goto err_wrong_data_write_size;
}
/* Check for received data size */
ASSERT_TEST(zframe_size (data_write_frame) == THSAFE_WRITE_32_DSIZE,
"Wrong received data size", err_wrong_data_write_size);
/* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_32 (self->llio, offset, (uint32_t *) zframe_data (data_write_frame));
......@@ -328,11 +324,9 @@ void *thsafe_zmq_server_write_64 (void *owner, void *args)
int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
if (zframe_size (data_write_frame) != THSAFE_WRITE_64_DSIZE) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_server:zmq] Wrong received data size\n");
goto err_wrong_data_write_size;
}
/* Check for received data size */
ASSERT_TEST(zframe_size (data_write_frame) == THSAFE_WRITE_64_DSIZE,
"Wrong received data size", err_wrong_data_write_size);
/* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_64 (self->llio, offset, (uint64_t *) zframe_data (data_write_frame));
......@@ -441,12 +435,11 @@ void *thsafe_zmq_server_write_dma (void *owner, void *args)
static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint32_t size, void *reply_to)
{
assert (llio_ret);
int ret = 0; /* success */
int err = -1; /* error */
/* Send reply back to client */
zmsg_t *send_msg = zmsg_new ();
ret = (send_msg == NULL) ? -1 : ret;
ASSERT_ALLOC(send_msg, err_send_msg_alloc);
ASSERT_ALLOC(send_msg, err_send_msg_alloc, -1 /* error */);
THSAFE_REPLY_TYPE reply_code = THSAFE_OK;
if (*llio_ret < 0) {
......@@ -458,11 +451,14 @@ static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint3
* frame 1: return code
* frame 2: data read */
int zerr = zmsg_addmem (send_msg, &reply_code, sizeof (reply_code));
ASSERT_TEST(zerr == 0, "Could not add reply code in message", err_reply_code);
ASSERT_TEST(zerr == 0, "Could not add reply code in message", err_reply_code,
-1 /* error */);
zerr = zmsg_addmem (send_msg, llio_ret, sizeof (*llio_ret));
ASSERT_TEST(zerr == 0, "Could not add number of bytes read in message", err_ret_code);
ASSERT_TEST(zerr == 0, "Could not add number of bytes read in message", err_ret_code,
-1 /* error */);
zerr = zmsg_addmem (send_msg, data, size);
ASSERT_TEST(zerr == 0, "Could not add read data in message", err_data_send);
ASSERT_TEST(zerr == 0, "Could not add read data in message", err_data_send,
-1 /* error */);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_server:zmq] Size: %d\n", size);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_server:zmq] Sending message:\n");
......@@ -470,7 +466,7 @@ static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint3
debug_log_print_zmq_msg (send_msg);
#endif
zerr = zmsg_send (&send_msg, reply_to);
ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg);
ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg, -1 /* error */);
err_send_msg:
err_data_send:
......@@ -478,7 +474,7 @@ err_ret_code:
err_reply_code:
zmsg_destroy (&send_msg);
err_send_msg_alloc:
return ret;
return err;
}
static int _thsafe_zmq_server_recv_read (zmsg_t *msg, loff_t *offset, uint32_t *read_bsize)
......@@ -497,10 +493,9 @@ static int _thsafe_zmq_server_recv_read (zmsg_t *msg, loff_t *offset, uint32_t *
zframe_t *offset_frame = zmsg_pop (msg);
ASSERT_ALLOC(offset_frame, err_offset_alloc);
if (zframe_size (offset_frame) != sizeof (loff_t)) {
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_server:zmq:read] Wrong offset size\n");
goto err_wrong_offset_size;
}
/* Check for wrong offset */
ASSERT_TEST(zframe_size (offset_frame) == sizeof (loff_t),
"Wrong offset size", err_wrong_offset_size);
*offset = *(loff_t *) zframe_data (offset_frame);
zframe_destroy (&offset_frame);
......@@ -525,12 +520,11 @@ err_offset_alloc:
static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to)
{
assert (llio_ret);
int ret = 0; /* success */
int err = -1; /* error */
/* Send reply back to client */
zmsg_t *send_msg = zmsg_new ();
ret = (send_msg == NULL) ? -1 : ret;
ASSERT_ALLOC(send_msg, err_send_msg_alloc);
ASSERT_ALLOC(send_msg, err_send_msg_alloc, -1 /* error */);
THSAFE_REPLY_TYPE reply_code = THSAFE_OK;
if (*llio_ret < 0) {
......@@ -541,23 +535,25 @@ static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to)
* frame 0: reply code
* frame 1: return code */
int zerr = zmsg_addmem (send_msg, &reply_code, sizeof (reply_code));
ASSERT_TEST(zerr == 0, "Could not add reply code in message", err_reply_code);
ASSERT_TEST(zerr == 0, "Could not add reply code in message", err_reply_code,
-1 /* error */);
zerr = zmsg_addmem (send_msg, llio_ret, sizeof (*llio_ret));
ASSERT_TEST(zerr == 0, "Could not add number of bytes read in message", err_ret_code);
ASSERT_TEST(zerr == 0, "Could not add number of bytes read in message", err_ret_code,
-1 /* error */);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_server:zmq] Sent message:\n");
#ifdef LOCAL_MSG_DBG
debug_log_print_zmq_msg (send_msg);
#endif
zerr = zmsg_send (&send_msg, reply_to);
ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg);
ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg, -1 /* error */);
err_send_msg:
err_ret_code:
err_reply_code:
zmsg_destroy (&send_msg);
err_send_msg_alloc:
return ret;
return err;
}
static int _thsafe_zmq_server_recv_write (zmsg_t *msg, loff_t *offset,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment