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 ...@@ -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_destroy (&reply_frame); /* Don't do anything with the reply code */
zframe_t *ret_code_frame = zmsg_pop (recv_msg); zframe_t *ret_code_frame = zmsg_pop (recv_msg);
if (ret_code_frame == NULL) { /* Check for malformed message */
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Interrupted or malformed message\n"); ASSERT_TEST(ret_code_frame != NULL, "Interrupted or malformed message",
/* Interrupted or malformed message */ err_recv_data);
goto err_recv_data;
}
/* Check if the frame has the number of bytes requested. /* Check if the frame has the number of bytes requested.
* For now, we consider a success only when the number of * For now, we consider a success only when the number of
* bytes requested is the same as the actually read*/ * bytes requested is the same as the actually read*/
if (zframe_size (ret_code_frame) != THSAFE_REPLY_SIZE) { ASSERT_TEST(zframe_size (ret_code_frame) == THSAFE_REPLY_SIZE, "Frame size is wrong",
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Frame size is wrong\n"); err_recv_data_size);
goto err_recv_data_size;
}
ret = *(THSAFE_REPLY_TYPE *) zframe_data (ret_code_frame); 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); DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received return code: %08X\n", ret);
err_recv_data_size: err_recv_data_size:
...@@ -426,25 +421,20 @@ static zmsg_t *_thsafe_zmq_client_recv_confirmation (smio_t *self) ...@@ -426,25 +421,20 @@ static zmsg_t *_thsafe_zmq_client_recv_confirmation (smio_t *self)
/* Message is: /* Message is:
* frame 0: Reply code */ * frame 0: Reply code */
if (reply_frame == NULL) { /* Check for interrupted or malformed message */
/* Interrupted or malformed message */ ASSERT_TEST(reply_frame != NULL, "Interrupted or malformed message",
goto err_recv_data; err_recv_data);
}
/* Check if the frame has the correct number of bytes */ /* Check if the frame has the correct number of bytes */
if (zframe_size (reply_frame) != THSAFE_REPLY_SIZE) { ASSERT_TEST(zframe_size (reply_frame) == THSAFE_REPLY_SIZE, "Frame size is wrong",
goto err_recv_data; err_recv_data);
}
uint8_t *raw_data = (uint8_t *) zframe_data (reply_frame); uint8_t *raw_data = (uint8_t *) zframe_data (reply_frame);
ASSERT_TEST(raw_data != NULL, "Could not receive confirmation code", err_null_raw_data); ASSERT_TEST(raw_data != NULL, "Could not receive confirmation code", err_null_raw_data);
uint32_t reply_code = *(uint32_t *) raw_data; uint32_t reply_code = *(uint32_t *) raw_data;
/* Check for confirmation */ /* Check for confirmation */
if (reply_code != THSAFE_OK) { ASSERT_TEST(reply_code == THSAFE_OK, "Received reply code NOT OK",
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received reply code OK\n"); err_reply_code_not_ok);
goto err_reply_code_not_ok;
}
/* Caller owns the message and is its responsability to destroy it */ /* Caller owns the message and is its responsability to destroy it */
return recv_msg; return recv_msg;
...@@ -473,11 +463,9 @@ static ssize_t _thsafe_zmq_client_recv_read (smio_t *self, uint8_t *data, ...@@ -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); zframe_t *return_frame = zmsg_pop (recv_msg);
ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame); ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);
/* Check for return frame size */
if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) { ASSERT_TEST(zframe_size (return_frame) == THSAFE_RETURN_SIZE,
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n"); "Return frame size is wrong", err_wrong_size_ret_frame);
goto err_wrong_size_ret_frame;
}
zframe_t *data_frame = zmsg_pop (recv_msg); zframe_t *data_frame = zmsg_pop (recv_msg);
ASSERT_TEST(data_frame != NULL, "Could not receive data", err_recv_data); 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, ...@@ -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. /* Check if the frame has the number of bytes requested.
* For now, we consider a success only when the number of * For now, we consider a success only when the number of
* bytes requested is the same as the actually read*/ * bytes requested is the same as the actually read*/
if ((ssize_t) zframe_size (data_frame) != *(THSAFE_RETURN_TYPE *) zframe_data (return_frame)) { ASSERT_TEST((ssize_t) zframe_size (data_frame) ==
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Data frame size is wrong\n"); *(THSAFE_RETURN_TYPE *) zframe_data (return_frame),
goto err_recv_data; "Received data frame size is wrong", err_recv_data);
}
uint8_t* raw_data = (uint8_t *) zframe_data (data_frame); uint8_t* raw_data = (uint8_t *) zframe_data (data_frame);
memcpy (data, raw_data, size); memcpy (data, raw_data, size);
...@@ -522,13 +509,11 @@ static ssize_t _thsafe_zmq_client_recv_write (smio_t *self) ...@@ -522,13 +509,11 @@ static ssize_t _thsafe_zmq_client_recv_write (smio_t *self)
zframe_t *return_frame = zmsg_pop (recv_msg); zframe_t *return_frame = zmsg_pop (recv_msg);
ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame); ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);
if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) { /* Check for return frame size */
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n"); ASSERT_TEST(zframe_size (return_frame) == THSAFE_RETURN_SIZE,
goto err_wrong_size_ret_frame; "Return frame size is wrong", err_wrong_size_ret_frame);
}
ret_size = *(THSAFE_RETURN_TYPE *) zframe_data (return_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); DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received code: %zd\n", ret_size);
err_wrong_size_ret_frame: 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) ...@@ -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, int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame); &data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg); ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
/* Check for received data size */
if (zframe_size (data_write_frame) != THSAFE_WRITE_16_DSIZE) { ASSERT_TEST(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"); "Wrong received data size", err_wrong_data_write_size);
goto err_wrong_data_write_size;
}
/* Call llio to perform the actual operation */ /* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_16 (self->llio, offset, (uint16_t *) zframe_data (data_write_frame)); 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) ...@@ -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, int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame); &data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg); ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
/* Check for received data size */
if (zframe_size (data_write_frame) != THSAFE_WRITE_32_DSIZE) { ASSERT_TEST(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"); "Wrong received data size", err_wrong_data_write_size);
goto err_wrong_data_write_size;
}
/* Call llio to perform the actual operation */ /* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_32 (self->llio, offset, (uint32_t *) zframe_data (data_write_frame)); 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) ...@@ -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, int zerr = _thsafe_zmq_server_recv_write (*server_args->msg, &offset,
&data_write_frame); &data_write_frame);
ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg); ASSERT_TEST(zerr == 0, "Could receive message", err_recv_msg);
/* Check for received data size */
if (zframe_size (data_write_frame) != THSAFE_WRITE_64_DSIZE) { ASSERT_TEST(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"); "Wrong received data size", err_wrong_data_write_size);
goto err_wrong_data_write_size;
}
/* Call llio to perform the actual operation */ /* Call llio to perform the actual operation */
int32_t llio_ret = llio_write_64 (self->llio, offset, (uint64_t *) zframe_data (data_write_frame)); 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) ...@@ -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) static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint32_t size, void *reply_to)
{ {
assert (llio_ret); assert (llio_ret);
int ret = 0; /* success */ int err = -1; /* error */
/* Send reply back to client */ /* Send reply back to client */
zmsg_t *send_msg = zmsg_new (); zmsg_t *send_msg = zmsg_new ();
ret = (send_msg == NULL) ? -1 : ret; ASSERT_ALLOC(send_msg, err_send_msg_alloc, -1 /* error */);
ASSERT_ALLOC(send_msg, err_send_msg_alloc);
THSAFE_REPLY_TYPE reply_code = THSAFE_OK; THSAFE_REPLY_TYPE reply_code = THSAFE_OK;
if (*llio_ret < 0) { if (*llio_ret < 0) {
...@@ -458,11 +451,14 @@ static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint3 ...@@ -458,11 +451,14 @@ static int _thsafe_zmq_server_send_read (int32_t *llio_ret, uint8_t *data, uint3
* frame 1: return code * frame 1: return code
* frame 2: data read */ * frame 2: data read */
int zerr = zmsg_addmem (send_msg, &reply_code, sizeof (reply_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)); 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); 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] Size: %d\n", size);
DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_server:zmq] Sending message:\n"); 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 ...@@ -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); debug_log_print_zmq_msg (send_msg);
#endif #endif
zerr = zmsg_send (&send_msg, reply_to); 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_send_msg:
err_data_send: err_data_send:
...@@ -478,7 +474,7 @@ err_ret_code: ...@@ -478,7 +474,7 @@ err_ret_code:
err_reply_code: err_reply_code:
zmsg_destroy (&send_msg); zmsg_destroy (&send_msg);
err_send_msg_alloc: 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) 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 * ...@@ -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); zframe_t *offset_frame = zmsg_pop (msg);
ASSERT_ALLOC(offset_frame, err_offset_alloc); ASSERT_ALLOC(offset_frame, err_offset_alloc);
if (zframe_size (offset_frame) != sizeof (loff_t)) { /* Check for wrong offset */
DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_server:zmq:read] Wrong offset size\n"); ASSERT_TEST(zframe_size (offset_frame) == sizeof (loff_t),
goto err_wrong_offset_size; "Wrong offset size", err_wrong_offset_size);
}
*offset = *(loff_t *) zframe_data (offset_frame); *offset = *(loff_t *) zframe_data (offset_frame);
zframe_destroy (&offset_frame); zframe_destroy (&offset_frame);
...@@ -525,12 +520,11 @@ err_offset_alloc: ...@@ -525,12 +520,11 @@ err_offset_alloc:
static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to) static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to)
{ {
assert (llio_ret); assert (llio_ret);
int ret = 0; /* success */ int err = -1; /* error */
/* Send reply back to client */ /* Send reply back to client */
zmsg_t *send_msg = zmsg_new (); zmsg_t *send_msg = zmsg_new ();
ret = (send_msg == NULL) ? -1 : ret; ASSERT_ALLOC(send_msg, err_send_msg_alloc, -1 /* error */);
ASSERT_ALLOC(send_msg, err_send_msg_alloc);
THSAFE_REPLY_TYPE reply_code = THSAFE_OK; THSAFE_REPLY_TYPE reply_code = THSAFE_OK;
if (*llio_ret < 0) { if (*llio_ret < 0) {
...@@ -541,23 +535,25 @@ static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to) ...@@ -541,23 +535,25 @@ static int _thsafe_zmq_server_send_write (int32_t *llio_ret, void *reply_to)
* frame 0: reply code * frame 0: reply code
* frame 1: return code */ * frame 1: return code */
int zerr = zmsg_addmem (send_msg, &reply_code, sizeof (reply_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)); 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"); DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_server:zmq] Sent message:\n");
#ifdef LOCAL_MSG_DBG #ifdef LOCAL_MSG_DBG
debug_log_print_zmq_msg (send_msg); debug_log_print_zmq_msg (send_msg);
#endif #endif
zerr = zmsg_send (&send_msg, reply_to); 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_send_msg:
err_ret_code: err_ret_code:
err_reply_code: err_reply_code:
zmsg_destroy (&send_msg); zmsg_destroy (&send_msg);
err_send_msg_alloc: err_send_msg_alloc:
return ret; return err;
} }
static int _thsafe_zmq_server_recv_write (zmsg_t *msg, loff_t *offset, 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