#include "kdbus-test.h"
/* maximum number of queued messages from the same individual user */
-#define KDBUS_CONN_MAX_MSGS 256
+#define KDBUS_CONN_MAX_MSGS 256U
/* maximum number of queued requests waiting for a reply */
-#define KDBUS_CONN_MAX_REQUESTS_PENDING 128
+#define KDBUS_CONN_MAX_REQUESTS_PENDING 1024U
/* maximum message payload size */
#define KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE (2 * 1024UL * 1024UL)
-int kdbus_test_message_basic(struct kdbus_test_env *env)
+wur int kdbus_test_message_basic(struct kdbus_test_env *env)
{
struct kdbus_conn *conn;
struct kdbus_conn *sender;
struct kdbus_msg *msg;
uint64_t cookie = 0x1234abcd5678eeff;
uint64_t offset;
- int ret;
- sender = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(sender != NULL);
+ ASSERT_NONZERO(sender = kdbus_hello(env->buspath, 0, NULL, 0));
/* create a 2nd connection */
- conn = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(conn != NULL);
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
- ret = kdbus_add_match_empty(conn);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_add_match_empty(conn));
- ret = kdbus_add_match_empty(sender);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_add_match_empty(sender));
/* send over 1st connection */
- ret = kdbus_msg_send(sender, NULL, cookie, 0, 0, 0,
- KDBUS_DST_ID_BROADCAST, 0, NULL);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_msg_send(sender, NULL, cookie, 0, 0, 0, KDBUS_DST_ID_BROADCAST));
- /* Make sure that we do not get our own broadcasts */
- ret = kdbus_msg_recv(sender, NULL, NULL);
- ASSERT_RETURN(ret == -EAGAIN);
+ /* Make sure that we do get our own broadcasts */
+ ASSERT_ZERO(kdbus_msg_recv(sender, &msg, &offset));
+ ASSERT_RETURN(msg->cookie,==,cookie);
+ kdbus_msg_free(msg);
/* ... and receive on the 2nd */
- ret = kdbus_msg_recv_poll(conn, 100, &msg, &offset);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(msg->cookie == cookie);
+ ASSERT_ZERO(kdbus_msg_recv_poll(conn, 100, &msg, &offset));
+ ASSERT_RETURN(msg->cookie,==,cookie);
kdbus_msg_free(msg);
/* Msgs that expect a reply must have timeout and cookie */
- ret = kdbus_msg_send(sender, NULL, 0, KDBUS_MSG_EXPECT_REPLY,
- 0, 0, conn->id, 0, NULL);
- ASSERT_RETURN(ret == -EINVAL);
+ ASSERT_RETURN(-EINVAL,==,kdbus_msg_send(sender, NULL, 0, KDBUS_MSG_EXPECT_REPLY, 1000000000, 0, conn->id)); /* no cookie */
+ ASSERT_RETURN(-EINVAL,==,kdbus_msg_send(sender, NULL, 1, KDBUS_MSG_EXPECT_REPLY, 0, 0, conn->id)); /* no timeout */
+ ASSERT_RETURN(-EINVAL,==,kdbus_msg_send(sender, NULL, 0, KDBUS_MSG_EXPECT_REPLY, 0, 0, conn->id)); /* neither cookie nor timeout */
- /* Faked replies with a valid reply cookie are rejected */
- ret = kdbus_msg_send_reply(conn, time(NULL) ^ cookie, sender->id);
- ASSERT_RETURN(ret == -EPERM);
+ /* Faked replies with a valid reply cookie are rejected iff not TIZEN */
+ ASSERT_RETURN(ONTIZEN(0,-EBADSLT),==,kdbus_msg_send_reply(conn, time(NULL) ^ cookie, sender->id));
- ret = kdbus_free(conn, offset);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_free(conn, offset));
kdbus_conn_free(sender);
kdbus_conn_free(conn);
return TEST_OK;
}
-static int msg_recv_prio(struct kdbus_conn *conn,
+static wur int msg_recv_prio(struct kdbus_conn *conn,
int64_t requested_prio,
int64_t expected_prio)
{
.priority = requested_prio,
};
struct kdbus_msg *msg;
- int ret;
+ int ret, dumpret;
ret = kdbus_cmd_recv(conn->fd, &recv);
if (ret < 0) {
}
msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset);
- kdbus_msg_dump(conn, msg);
+ dumpret = kdbus_msg_dump(msg);
if (msg->priority != expected_prio) {
kdbus_printf("expected message prio %lld, got %lld\n",
ret = kdbus_free(conn, recv.msg.offset);
if (ret < 0)
return ret;
+ if (dumpret)
+ return dumpret;
return 0;
}
-int kdbus_test_message_prio(struct kdbus_test_env *env)
+wur int kdbus_test_message_prio(struct kdbus_test_env *env)
{
struct kdbus_conn *a, *b;
uint64_t cookie = 0;
- int ret;
- a = kdbus_hello(env->buspath, 0, NULL, 0);
- b = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(a && b);
-
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 25, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -600, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -35, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -100, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 20, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -15, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -150, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, -10, a->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
-
- ASSERT_RETURN(msg_recv_prio(a, -200, -800) == 0);
- ASSERT_RETURN(msg_recv_prio(a, -100, -800) == 0);
- ASSERT_RETURN(msg_recv_prio(a, -400, -600) == 0);
- ASSERT_RETURN(msg_recv_prio(a, -400, -600) == -EAGAIN);
- ASSERT_RETURN(msg_recv_prio(a, 10, -150) == 0);
- ASSERT_RETURN(msg_recv_prio(a, 10, -100) == 0);
+ ASSERT_NONZERO(a = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(b = kdbus_hello(env->buspath, 0, NULL, 0));
+
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 25, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -600, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -35, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -100, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 20, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -15, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -150, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id));
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -10, a->id));
+
+ ASSERT_ZERO(msg_recv_prio(a, -200, -800));
+ ASSERT_ZERO(msg_recv_prio(a, -100, -800));
+ ASSERT_ZERO(msg_recv_prio(a, -400, -600));
+ ASSERT_RETURN(msg_recv_prio(a, -400, -600),==,-EAGAIN);
+ ASSERT_ZERO(msg_recv_prio(a, 10, -150));
+ ASSERT_ZERO(msg_recv_prio(a, 10, -100));
kdbus_printf("--- get priority (all)\n");
- ASSERT_RETURN(kdbus_msg_recv(a, NULL, NULL) == 0);
+ ASSERT_ZERO(kdbus_msg_recv(a, NULL, NULL));
kdbus_conn_free(a);
kdbus_conn_free(b);
return TEST_OK;
}
-static int kdbus_test_notify_kernel_quota(struct kdbus_test_env *env)
+static wur int kdbus_test_notify_kernel_quota(struct kdbus_test_env *env)
{
- int ret;
unsigned int i;
struct kdbus_conn *conn;
struct kdbus_conn *reader;
struct kdbus_msg *msg = NULL;
struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
- reader = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(reader);
-
- conn = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(conn);
+ ASSERT_NONZERO(reader = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
/* Register for ID signals */
- ret = kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD,
- KDBUS_MATCH_ID_ANY);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD, KDBUS_MATCH_ID_ANY));
- ret = kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE,
- KDBUS_MATCH_ID_ANY);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE, KDBUS_MATCH_ID_ANY));
/* Each iteration two notifications: add and remove ID */
for (i = 0; i < KDBUS_CONN_MAX_MSGS / 2; i++) {
struct kdbus_conn *notifier;
-
- notifier = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(notifier);
-
+ ASSERT_NONZERO(notifier = kdbus_hello(env->buspath, 0, NULL, 0));
kdbus_conn_free(notifier);
}
* Now the reader queue is full with kernel notfications,
* but as a user we still have room to push our messages.
*/
- ret = kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, 0, reader->id,
- 0, NULL);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, 0, reader->id));
/* More ID kernel notifications that will be lost */
kdbus_conn_free(conn);
- conn = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(conn);
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
kdbus_conn_free(conn);
* We lost only 3 packets since only signal msgs are
* accounted. The connection ID add/remove notification
*/
- ret = kdbus_cmd_recv(reader->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS);
- ASSERT_RETURN(recv.dropped_msgs == 3);
+ ASSERT_ZERO(kdbus_cmd_recv(reader->fd, &recv));
+ ASSERT_NONZERO(recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS);
+ ASSERT_RETURN(recv.dropped_msgs,==,3U);
msg = (struct kdbus_msg *)(reader->buf + recv.msg.offset);
kdbus_msg_free(msg);
memset(&recv, 0, sizeof(recv));
recv.size = sizeof(recv);
- ret = kdbus_cmd_recv(reader->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(!(recv.return_flags &
- KDBUS_RECV_RETURN_DROPPED_MSGS));
+ ASSERT_ZERO(kdbus_cmd_recv(reader->fd, &recv));
+ ASSERT_ZERO(recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS);
msg = (struct kdbus_msg *)(reader->buf + recv.msg.offset);
kdbus_msg_free(msg);
}
- ret = kdbus_msg_recv(reader, NULL, NULL);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_msg_recv(reader, NULL, NULL));
- ret = kdbus_msg_recv(reader, NULL, NULL);
- ASSERT_RETURN(ret == -EAGAIN);
+ ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(reader, NULL, NULL));
kdbus_conn_free(reader);
}
/* Return the number of message successfully sent */
-static int kdbus_fill_conn_queue(struct kdbus_conn *conn_src,
+static wur int kdbus_fill_conn_queue(struct kdbus_conn *conn_src,
uint64_t dst_id,
unsigned int max_msgs)
{
size = sizeof(struct kdbus_msg);
msg = malloc(size);
- ASSERT_RETURN_VAL(msg, -ENOMEM);
+ ASSERT_RETURN_VAL(msg,!=,NULL, -ENOMEM);
memset(msg, 0, size);
msg->size = size;
cmd.msg_address = (uintptr_t)msg;
for (i = 0; i < max_msgs; i++) {
- msg->cookie = cookie++;
+ msg->cookie = ++cookie;
ret = kdbus_cmd_send(conn_src->fd, &cmd);
- if (ret < 0)
+ if (ret < 0) {
+ /*print("fill_conn_queue_senderr(%d)", ret);*/
break;
+ }
}
free(msg);
return i;
}
-static int kdbus_test_activator_quota(struct kdbus_test_env *env)
+wur int kdbus_test_activator_quota(struct kdbus_test_env *env)
{
- int ret;
- unsigned int i;
- unsigned int activator_msgs_count = 0;
+ unsigned i, activator_msgs_count=0;
uint64_t cookie = time(NULL);
+ uint64_t flags = KDBUS_NAME_REPLACE_EXISTING;
struct kdbus_conn *conn;
struct kdbus_conn *sender;
struct kdbus_conn *activator;
struct kdbus_msg *msg;
- uint64_t flags = KDBUS_NAME_REPLACE_EXISTING;
struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
struct kdbus_policy_access access = {
.type = KDBUS_POLICY_ACCESS_USER,
.access = KDBUS_POLICY_OWN,
};
- activator = kdbus_hello_activator(env->buspath, "foo.test.activator",
- &access, 1);
- ASSERT_RETURN(activator);
-
- conn = kdbus_hello(env->buspath, 0, NULL, 0);
- sender = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(conn || sender);
-
- ret = kdbus_list(sender, KDBUS_LIST_NAMES |
- KDBUS_LIST_UNIQUE |
- KDBUS_LIST_ACTIVATORS |
- KDBUS_LIST_QUEUED);
- ASSERT_RETURN(ret == 0);
-
- for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) {
- ret = kdbus_msg_send(sender, "foo.test.activator",
- cookie++, 0, 0, 0,
- KDBUS_DST_ID_NAME,
- 0, NULL);
- if (ret < 0)
- break;
- activator_msgs_count++;
- }
+ ASSERT_NONZERO(activator = kdbus_hello_activator(env->buspath, "foo.test.activator", &access, 1));
+
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(sender = kdbus_hello(env->buspath, 0, NULL, 0));
+
+ ASSERT_ZERO(kdbus_list(sender, KDBUS_LIST_NAMES | KDBUS_LIST_UNIQUE | KDBUS_LIST_ACTIVATORS | KDBUS_LIST_QUEUED));
+
+#define EXHAUST(EXPECTERR,SENDOP) do {\
+ for (i = 0;; ++i) {\
+ int ret = (SENDOP);\
+ ASSERT_RETURN(i,<=,KDBUS_CONN_MAX_MSGS);\
+ if (0 > ret) {\
+ ASSERT_RETURN((EXPECTERR),==,ret);\
+ ASSERT_RETURN(i,<,KDBUS_CONN_MAX_MSGS);\
+ break;\
+ }\
+ }\
+} while (0)
+ EXHAUST(-ENOBUFS,kdbus_msg_send(sender, "foo.test.activator", ++cookie, 0, 0, 0, KDBUS_DST_ID_NAME));
+ activator_msgs_count = i;
/* we must have at least sent one message */
- ASSERT_RETURN_VAL(i > 0, -errno);
- ASSERT_RETURN(ret == -ENOBUFS);
+ ASSERT_RETURN_VAL(i,>,0U, -errno);
/* Good, activator queue is full now */
/* ENXIO on direct send (activators can never be addressed by ID) */
- ret = kdbus_msg_send(conn, NULL, cookie++, 0, 0, 0, activator->id,
- 0, NULL);
- ASSERT_RETURN(ret == -ENXIO);
+ ASSERT_RETURN(-ENXIO,==,kdbus_msg_send(conn, NULL, ++cookie, 0, 0, 0, activator->id));
/* can't queue more */
- ret = kdbus_msg_send(conn, "foo.test.activator", cookie++,
- 0, 0, 0, KDBUS_DST_ID_NAME, 0, NULL);
- ASSERT_RETURN(ret == -ENOBUFS);
+ ASSERT_RETURN(-ENOBUFS,==,kdbus_msg_send(conn, "foo.test.activator", ++cookie, 0, 0, 0, KDBUS_DST_ID_NAME));
/* no match installed, so the broadcast will not inc dropped_msgs */
- ret = kdbus_msg_send(sender, NULL, cookie++, 0, 0, 0,
- KDBUS_DST_ID_BROADCAST, 0, NULL);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_msg_send(conn, NULL, ++cookie, 0, 0, 0, KDBUS_DST_ID_BROADCAST));
/* Check activator queue */
- ret = kdbus_cmd_recv(activator->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv.dropped_msgs == 0);
-
- activator_msgs_count--;
+ ASSERT_ZERO(kdbus_cmd_recv(activator->fd, &recv));
+ ASSERT_ZERO(recv.dropped_msgs);
msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset);
+ ASSERT_RETURN(msg->src_id,==,sender->id);
+ ASSERT_RETURN(msg->dst_id,==,(typeof(msg->dst_id))KDBUS_DST_ID_NAME);
+ --activator_msgs_count;
kdbus_msg_free(msg);
/* Stage 1) of test check the pool memory quota */
/* Consume the connection pool memory */
- for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) {
- ret = kdbus_msg_send(sender, NULL,
- cookie++, 0, 0, 0, conn->id, 0, NULL);
- if (ret < 0)
- break;
- }
+ EXHAUST(-ENOBUFS,kdbus_msg_send(conn, NULL, ++cookie, 0, 0, 0, conn->id));
/* consume one message, so later at least one can be moved */
memset(&recv, 0, sizeof(recv));
recv.size = sizeof(recv);
- ret = kdbus_cmd_recv(conn->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv.dropped_msgs == 0);
+ ASSERT_ZERO(kdbus_cmd_recv(conn->fd, &recv));
+ ASSERT_ZERO(recv.dropped_msgs);
msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset);
kdbus_msg_free(msg);
/* Try to acquire the name now */
- ret = kdbus_name_acquire(conn, "foo.test.activator", &flags);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_name_acquire(conn, "foo.test.activator", &flags));
/* try to read messages and see if we have lost some */
memset(&recv, 0, sizeof(recv));
recv.size = sizeof(recv);
- ret = kdbus_cmd_recv(conn->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv.dropped_msgs != 0);
+ ASSERT_ZERO(kdbus_cmd_recv(conn->fd, &recv));
+ ASSERT_NONZERO(recv.dropped_msgs);
/* number of dropped msgs < received ones (at least one was moved) */
- ASSERT_RETURN(recv.dropped_msgs < activator_msgs_count);
+ ASSERT_RETURN(recv.dropped_msgs,<,activator_msgs_count);
/* Deduct the number of dropped msgs from the activator msgs */
activator_msgs_count -= recv.dropped_msgs;
msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset);
kdbus_msg_free(msg);
-
/*
* Release the name and hand it back to activator, now
* we should have 'activator_msgs_count' msgs again in
* the activator queue
*/
- ret = kdbus_name_release(conn, "foo.test.activator");
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_name_release(conn, "foo.test.activator"));
/* make sure that we got our previous activator msgs */
- ret = kdbus_msg_recv(activator, &msg, NULL);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(msg->src_id == sender->id);
-
- activator_msgs_count--;
-
+ ASSERT_ZERO(kdbus_msg_recv(activator, &msg, NULL));
+ ASSERT_RETURN(msg->src_id,==,sender->id);
+ ASSERT_RETURN(msg->dst_id,==,(typeof(msg->dst_id))KDBUS_DST_ID_NAME);
+ --activator_msgs_count;
kdbus_msg_free(msg);
/* Stage 2) of test check max message quota */
- /* Empty conn queue */
- for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) {
- ret = kdbus_msg_recv(conn, NULL, NULL);
- if (ret == -EAGAIN)
- break;
- }
-
- /* fill queue with max msgs quota */
- ret = kdbus_fill_conn_queue(sender, conn->id, KDBUS_CONN_MAX_MSGS);
- ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS);
+ /* Empty conn queue and refill it to the brink anew */
+ EXHAUST(-EAGAIN,kdbus_msg_recv(conn, NULL, NULL));
+ EXHAUST(-ENOBUFS,kdbus_msg_send(sender, NULL, ++cookie, 0, 0, 0, conn->id));
+#undef EXHAUST
- /* This one is lost but it is not accounted */
- ret = kdbus_msg_send(sender, NULL,
- cookie++, 0, 0, 0, conn->id, 0, NULL);
- ASSERT_RETURN(ret == -ENOBUFS);
+ if (!activator_msgs_count)
+ ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(activator, NULL, NULL));
/* Acquire the name again */
- ret = kdbus_name_acquire(conn, "foo.test.activator", &flags);
- ASSERT_RETURN(ret == 0);
+ flags = KDBUS_NAME_REPLACE_EXISTING;
+ ASSERT_ZERO(kdbus_name_acquire(conn, "foo.test.activator", &flags));
memset(&recv, 0, sizeof(recv));
recv.size = sizeof(recv);
* the activator messages due to quota checks. Our queue is
* already full.
*/
- ret = kdbus_cmd_recv(conn->fd, &recv);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv.dropped_msgs == activator_msgs_count);
+ ASSERT_ZERO(kdbus_cmd_recv(conn->fd, &recv));
+ ASSERT_RETURN(recv.dropped_msgs,==,activator_msgs_count);
msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset);
kdbus_msg_free(msg);
kdbus_conn_free(conn);
kdbus_conn_free(activator);
+ return TEST_OK;
+}
+
+#define TIMEOUT_CONNECTION_COUNT 8
+#define TIMEOUTS_PER_CONNECTION (MIN(KDBUS_CONN_MAX_REQUESTS_PENDING,KDBUS_CONN_MAX_MSGS)/TIMEOUT_CONNECTION_COUNT)
+
+static wur int kdbus_test_expected_reply_validate_timeouts(struct kdbus_conn *conn, uint64_t first_cookie, uint64_t type)
+{
+ uint64_t cookie_reply, seqnum, monotonic_ns, realtime_ns, prev_seqnum=0, prev_monotonic_ns=0, prev_realtime_ns=0;
+ unsigned i, next_cookie[TIMEOUT_CONNECTION_COUNT];
+ memset(next_cookie, 0, sizeof(next_cookie));
+ for (i=0; i < MIN(KDBUS_CONN_MAX_REQUESTS_PENDING,KDBUS_CONN_MAX_MSGS); i++) {
+ unsigned n, r;
+ ASSERT_ZERO(timeout_msg_recv(conn, type, &cookie_reply, &seqnum, &monotonic_ns, &realtime_ns));
+ #define A(W,R) do { ASSERT_RETURN(prev_##W,R,W); prev_##W = W; } while (0);
+ A(seqnum,<)
+ A(monotonic_ns,<=)
+ A(realtime_ns,<=)
+ #undef A
+ ASSERT_RETURN(first_cookie,<=,cookie_reply);
+ cookie_reply -= first_cookie;
+ n = cookie_reply % TIMEOUT_CONNECTION_COUNT;
+ r = cookie_reply / TIMEOUT_CONNECTION_COUNT;
+ ASSERT_RETURN(r,==,next_cookie[n]);
+ ++next_cookie[n];
+ }
+ ASSERT_NO_PENDING(conn);
return 0;
}
-static int kdbus_test_expected_reply_quota(struct kdbus_test_env *env)
+static wur int kdbus_test_expected_reply_timeouts_or_quota(struct kdbus_test_env *env)
{
- int ret;
- unsigned int i, n;
- unsigned int count;
- uint64_t cookie = 0x1234abcd5678eeff;
+ unsigned i, n;
+ uint64_t first_cookie = 0x1234abcd5678eeff;
struct kdbus_conn *conn;
- struct kdbus_conn *connections[9];
+ struct kdbus_conn *connections[1+TIMEOUT_CONNECTION_COUNT];
- conn = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(conn);
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
- for (i = 0; i < 9; i++) {
- connections[i] = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(connections[i]);
- }
+ for (i = 0; i < 1+TIMEOUT_CONNECTION_COUNT; i++)
+ ASSERT_NONZERO(connections[i] = kdbus_hello(env->buspath, 0, NULL, 0));
- count = 0;
- /* Send 16 messages to 8 different connections */
- for (i = 0; i < 8; i++) {
- for (n = 0; n < 16; n++) {
- ret = kdbus_msg_send(conn, NULL, cookie++,
- KDBUS_MSG_EXPECT_REPLY,
- 100000000ULL, 0,
- connections[i]->id,
- 0, NULL);
- if (ret < 0)
- break;
+ _Static_assert(!(KDBUS_CONN_MAX_REQUESTS_PENDING%TIMEOUT_CONNECTION_COUNT), "KDBUS_CONN_MAX_REQUESTS_PENDING) not a multitude of TIMEOUT_CONNECTION_COUNT - quota test needs to be modified to reflect that");
- count++;
+ /* Send messages to TIMEOUT_CONNECTION_COUNT different connections */
+ for (i = 0; i < TIMEOUT_CONNECTION_COUNT; i++)
+ for (n = 0; n < TIMEOUTS_PER_CONNECTION; n++) {
+ ASSERT_ZERO(kdbus_msg_send(conn, NULL, first_cookie + i + n*TIMEOUT_CONNECTION_COUNT,
+ KDBUS_MSG_EXPECT_REPLY,
+ 200000000ULL /* 0.2s */, 0,
+ connections[i]->id));
+ /* drain queue to avoid hitting KDBUS_CONN_MAX_MSGS */
+ ASSERT_ZERO(kdbus_msg_recv(connections[i], NULL, NULL));
}
- }
- /*
- * We should have queued at least
- * KDBUS_CONN_MAX_REQUESTS_PENDING method call
- */
- ASSERT_RETURN(count == KDBUS_CONN_MAX_REQUESTS_PENDING);
+ sleep(1); /* just to wait and see if timeout logic somehow destabilizes the system */
+
+ ASSERT_ZERO(kdbus_test_expected_reply_validate_timeouts(conn, first_cookie, KDBUS_ITEM_REPLY_TIMEOUT));
+
+ for (i = 0; i < 1+TIMEOUT_CONNECTION_COUNT; i++)
+ kdbus_conn_free(connections[i]);
+
+ kdbus_conn_free(conn);
+
+ return 0;
+}
+
+static wur int kdbus_test_expected_reply_quota(struct kdbus_test_env *env)
+{
+ unsigned i, n;
+ uint64_t first_cookie = 0x5678eeff1234abcd;
+ struct kdbus_conn *conn;
+ struct kdbus_conn *connections[1+TIMEOUT_CONNECTION_COUNT];
+
+ ASSERT_NONZERO(conn = kdbus_hello(env->buspath, 0, NULL, 0));
+
+ for (i = 0; i < 1+TIMEOUT_CONNECTION_COUNT; i++)
+ ASSERT_NONZERO(connections[i] = kdbus_hello(env->buspath, 0, NULL, 0));
+
+ /* Send messages to TIMEOUT_CONNECTION_COUNT different connections */
+ for (i = 0; i < TIMEOUT_CONNECTION_COUNT; i++)
+ for (n = 0; n < KDBUS_CONN_MAX_REQUESTS_PENDING/TIMEOUT_CONNECTION_COUNT; n++) {
+ ASSERT_ZERO(kdbus_msg_send(conn, NULL, first_cookie + i + n*TIMEOUT_CONNECTION_COUNT,
+ KDBUS_MSG_EXPECT_REPLY,
+ KDBUS_TIMEOUT_INFINITE, 0, /* massive timeout to make sure all pending replies do not timeout before quota check below */
+ connections[i]->id));
+ /* drain queue to avoid hitting KDBUS_CONN_MAX_MSGS */
+ ASSERT_ZERO(kdbus_msg_recv(connections[i], NULL, NULL));
+ }
/*
* Now try to send a message to the last connection,
* if we have reached KDBUS_CONN_MAX_REQUESTS_PENDING
* no further requests are allowed
*/
- ret = kdbus_msg_send(conn, NULL, cookie++, KDBUS_MSG_EXPECT_REPLY,
- 1000000000ULL, 0, connections[8]->id, 0, NULL);
- ASSERT_RETURN(ret == -EMLINK);
+ ASSERT_RETURN(-EMLINK,==,kdbus_msg_send(conn, NULL, first_cookie + TIMEOUT_CONNECTION_COUNT*TIMEOUTS_PER_CONNECTION, KDBUS_MSG_EXPECT_REPLY, 1000000000ULL, 0, connections[TIMEOUT_CONNECTION_COUNT]->id));
- for (i = 0; i < 9; i++)
+ for (i = 0; i < 1+TIMEOUT_CONNECTION_COUNT; i++)
kdbus_conn_free(connections[i]);
+ ASSERT_ZERO(kdbus_test_expected_reply_validate_timeouts(conn, first_cookie, KDBUS_ITEM_REPLY_DEAD));
+
kdbus_conn_free(conn);
return 0;
}
-int kdbus_test_pool_quota(struct kdbus_test_env *env)
+wur int kdbus_test_pool_quota(struct kdbus_test_env *env)
{
struct kdbus_conn *a, *b, *c;
struct kdbus_cmd_send cmd = {};
return 0;
payload = calloc(KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE, sizeof(char));
- ASSERT_RETURN_VAL(payload, -ENOMEM);
+ ASSERT_RETURN_VAL(payload,!=,NULL, -ENOMEM);
- a = kdbus_hello(env->buspath, 0, NULL, 0);
- b = kdbus_hello(env->buspath, 0, NULL, 0);
- c = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(a && b && c);
+ ASSERT_NONZERO(a = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(b = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(c = kdbus_hello(env->buspath, 0, NULL, 0));
size = sizeof(struct kdbus_msg);
size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec));
msg = malloc(size);
- ASSERT_RETURN_VAL(msg, -ENOMEM);
+ ASSERT_RETURN_VAL(msg,!=,NULL, -ENOMEM);
memset(msg, 0, size);
msg->size = size;
msg->cookie = cookie++;
ret = kdbus_cmd_send(a->fd, &cmd);
- ASSERT_RETURN_VAL(ret == 0, ret);
+ ASSERT_RETURN_VAL(ret,==,0, ret);
}
/* Try to get more than 33% */
msg->cookie = cookie++;
- ret = kdbus_cmd_send(a->fd, &cmd);
- ASSERT_RETURN(ret == -ENOBUFS);
+ ASSERT_RETURN(-ENOBUFS,==,kdbus_cmd_send(a->fd, &cmd));
/* We still can pass small messages */
- ret = kdbus_msg_send(b, NULL, cookie++, 0, 0, 0, c->id, 0, NULL);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_msg_send(b, NULL, cookie++, 0, 0, 0, c->id));
for (i = size; i < (POOL_SIZE / 2 / 3); i += size) {
- ret = kdbus_msg_recv(c, &recv_msg, NULL);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv_msg->src_id == a->id);
+ ASSERT_ZERO(kdbus_msg_recv(c, &recv_msg, NULL));
+ ASSERT_RETURN(recv_msg->src_id,==,a->id);
kdbus_msg_free(recv_msg);
}
- ret = kdbus_msg_recv(c, &recv_msg, NULL);
- ASSERT_RETURN(ret == 0);
- ASSERT_RETURN(recv_msg->src_id == b->id);
+ ASSERT_ZERO(kdbus_msg_recv(c, &recv_msg, NULL));
+ ASSERT_RETURN(recv_msg->src_id,==,b->id);
kdbus_msg_free(recv_msg);
- ret = kdbus_msg_recv(c, NULL, NULL);
- ASSERT_RETURN(ret == -EAGAIN);
+ ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(c, NULL, NULL));
free(msg);
free(payload);
return 0;
}
-int kdbus_test_message_quota(struct kdbus_test_env *env)
+wur int kdbus_test_message_quota(struct kdbus_test_env *env)
{
struct kdbus_conn *a, *b;
uint64_t cookie = 0;
- int ret;
- int i;
+ unsigned i;
- ret = kdbus_test_activator_quota(env);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_test_notify_kernel_quota(env));
- ret = kdbus_test_notify_kernel_quota(env);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_test_pool_quota(env));
- ret = kdbus_test_pool_quota(env);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_test_expected_reply_timeouts_or_quota(env));
- ret = kdbus_test_expected_reply_quota(env);
- ASSERT_RETURN(ret == 0);
+ ASSERT_ZERO(kdbus_test_expected_reply_quota(env));
a = kdbus_hello(env->buspath, 0, NULL, 0);
b = kdbus_hello(env->buspath, 0, NULL, 0);
- ret = kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS);
- ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS);
+ ASSERT_RETURN((typeof(kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS)))KDBUS_CONN_MAX_MSGS,==,kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS));
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id, 0, NULL);
- ASSERT_RETURN(ret == -ENOBUFS);
+ ASSERT_RETURN(-ENOBUFS,==,kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id));
- for (i = 0; i < KDBUS_CONN_MAX_MSGS; ++i) {
- ret = kdbus_msg_recv(a, NULL, NULL);
- ASSERT_RETURN(ret == 0);
- }
+ for (i = 0; i < KDBUS_CONN_MAX_MSGS; ++i)
+ ASSERT_ZERO(kdbus_msg_recv(a, NULL, NULL));
- ret = kdbus_msg_recv(a, NULL, NULL);
- ASSERT_RETURN(ret == -EAGAIN);
+ ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(a, NULL, NULL));
- ret = kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS + 1);
- ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS);
+ ASSERT_RETURN((typeof(kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS + 1)))KDBUS_CONN_MAX_MSGS,==,kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS + 1));
- ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id, 0, NULL);
- ASSERT_RETURN(ret == -ENOBUFS);
+ ASSERT_RETURN(-ENOBUFS,==,kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id));
kdbus_conn_free(a);
kdbus_conn_free(b);
return TEST_OK;
}
-int kdbus_test_memory_access(struct kdbus_test_env *env)
+wur int kdbus_test_memory_access(struct kdbus_test_env *env)
{
struct kdbus_conn *a, *b;
struct kdbus_cmd_send cmd = {};
char line[256];
uint64_t size;
FILE *f;
- int ret;
/*
* Search in /proc/kallsyms for the address of a kernel symbol that
if (!test_addr)
return TEST_SKIP;
- a = kdbus_hello(env->buspath, 0, NULL, 0);
- b = kdbus_hello(env->buspath, 0, NULL, 0);
- ASSERT_RETURN(a && b);
+ ASSERT_NONZERO(a = kdbus_hello(env->buspath, 0, NULL, 0));
+ ASSERT_NONZERO(b = kdbus_hello(env->buspath, 0, NULL, 0));
size = sizeof(struct kdbus_msg);
size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec));
msg = alloca(size);
- ASSERT_RETURN_VAL(msg, -ENOMEM);
+ ASSERT_RETURN_VAL(msg,!=,NULL, -ENOMEM);
memset(msg, 0, size);
msg->size = size;
cmd.size = sizeof(cmd);
cmd.msg_address = (uintptr_t)msg;
- ret = kdbus_cmd_send(a->fd, &cmd);
- ASSERT_RETURN(ret == -EFAULT);
+ ASSERT_RETURN(-EFAULT,==,kdbus_cmd_send(a->fd, &cmd));
kdbus_conn_free(b);
kdbus_conn_free(a);
projects / platform / kernel / linux-rpi.git / blobdiff