Hello community, here is the log from the commit of package libqb for openSUSE:Factory checked in at 2014-03-31 20:43:09 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libqb (Old) and /work/SRC/openSUSE:Factory/.libqb.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "libqb" Changes: -------- --- /work/SRC/openSUSE:Factory/libqb/libqb.changes 2014-02-21 19:42:17.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.libqb.new/libqb.changes 2014-03-31 20:43:21.000000000 +0200 @@ -1,0 +2,6 @@ +Fri Mar 21 06:36:02 UTC 2014 - ygao@suse.com + +- ipcc: Properly timeout during recv when timeout value is provided +- Upstream version cs: c6f4fcd778248c41e5b108159d00cf1798a296d4 + +------------------------------------------------------------------- Old: ---- libqb-0.17.0+git20140219.78978d0.tar.bz2 New: ---- libqb-0.17.0+git20140312.c6f4fcd.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libqb.spec ++++++ --- /var/tmp/diff_new_pack.NwgMRi/_old 2014-03-31 20:43:22.000000000 +0200 +++ /var/tmp/diff_new_pack.NwgMRi/_new 2014-03-31 20:43:22.000000000 +0200 @@ -17,7 +17,7 @@ Name: libqb -Version: 0.17.0+git20140219.78978d0 +Version: 0.17.0+git20140312.c6f4fcd Release: 0 Summary: An IPC library for high performance servers License: LGPL-2.1+ ++++++ _service ++++++ --- /var/tmp/diff_new_pack.NwgMRi/_old 2014-03-31 20:43:22.000000000 +0200 +++ /var/tmp/diff_new_pack.NwgMRi/_new 2014-03-31 20:43:22.000000000 +0200 @@ -11,7 +11,7 @@ <param name="version">0.17.0</param> --> <param name="versionformat">0.17.0+git%cd.%h</param> - <param name="revision">78978d07ac2f19a801ebde61379ac55359cc17f3</param> + <param name="revision">c6f4fcd778248c41e5b108159d00cf1798a296d4</param> </service> <service name="recompress" mode="disabled"> ++++++ libqb-0.17.0+git20140219.78978d0.tar.bz2 -> libqb-0.17.0+git20140312.c6f4fcd.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libqb-0.17.0+git20140219.78978d0/lib/Makefile.am new/libqb-0.17.0+git20140312.c6f4fcd/lib/Makefile.am --- old/libqb-0.17.0+git20140219.78978d0/lib/Makefile.am 2014-02-20 12:24:04.000000000 +0100 +++ new/libqb-0.17.0+git20140312.c6f4fcd/lib/Makefile.am 2014-03-21 07:24:42.000000000 +0100 @@ -42,6 +42,8 @@ libqb_la_SOURCES = $(source_to_lint) unix.c libqb_la_LIBADD = @LTLIBOBJS@ +LDFLAGS = $(LDFLAGS_COPY:-Bsymbolic-functions=) + if HAVE_SEM_TIMEDWAIT else libqb_la_SOURCES+=rpl_sem.c diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libqb-0.17.0+git20140219.78978d0/lib/ipc_setup.c new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipc_setup.c --- old/libqb-0.17.0+git20140219.78978d0/lib/ipc_setup.c 2014-02-20 12:24:04.000000000 +0100 +++ new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipc_setup.c 2014-03-21 07:24:42.000000000 +0100 @@ -526,6 +526,9 @@ if (res == -EACCES) { qb_util_log(LOG_ERR, "Invalid IPC credentials (%s).", c->description); + } else if (res == -EAGAIN) { + qb_util_log(LOG_WARNING, "Denied connection, is not ready (%s)", + c->description); } else { errno = -res; qb_util_perror(LOG_ERR, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libqb-0.17.0+git20140219.78978d0/lib/ipc_socket.c new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipc_socket.c --- old/libqb-0.17.0+git20140219.78978d0/lib/ipc_socket.c 2014-02-20 12:24:04.000000000 +0100 +++ new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipc_socket.c 2014-03-21 07:24:42.000000000 +0100 @@ -387,13 +387,20 @@ MSG_NOSIGNAL | MSG_PEEK); if (result == -1) { - if (errno == EAGAIN && (time_waited < timeout || timeout == -1)) { - result = qb_ipc_us_ready(one_way, NULL, - time_to_wait, POLLIN); + if (errno != EAGAIN) { + return -errno; + } + + /* check to see if we have enough time left to try again */ + if (time_waited < timeout || timeout == -1) { + result = qb_ipc_us_ready(one_way, NULL, time_to_wait, POLLIN); + if (qb_ipc_us_sock_error_is_disconnected(result)) { + return result; + } time_waited += time_to_wait; goto retry_peek; - } else { - return -errno; + } else if (time_waited >= timeout) { + return -ETIMEDOUT; } } if (result >= sizeof(struct qb_ipc_request_header)) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libqb-0.17.0+git20140219.78978d0/lib/ipcc.c new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipcc.c --- old/libqb-0.17.0+git20140219.78978d0/lib/ipcc.c 2014-02-20 12:24:04.000000000 +0100 +++ new/libqb-0.17.0+git20140312.c6f4fcd/lib/ipcc.c 2014-03-21 07:24:42.000000000 +0100 @@ -118,8 +118,13 @@ res2, "(from socket) as a disconnect"); c->is_connected = QB_FALSE; + res = res2; + } else if (res != -ETIMEDOUT) { + /* if the result we're checking against is a TIMEOUT error. + * don't override that result with another error that does + * not imply a disconnect */ + res = res2; } - res = res2; } return res; } @@ -260,15 +265,27 @@ size_t msg_len, int32_t ms_timeout) { int32_t res = 0; + int32_t connect_res = 0; if (c == NULL) { return -EINVAL; } res = c->funcs.recv(&c->response, msg_ptr, msg_len, ms_timeout); - return _check_connection_state_with(c, res, + if (res >= 0) { + return res; + } + + /* if we didn't get a msg, check connection state */ + connect_res = _check_connection_state_with(c, res, _response_sock_one_way_get(c), ms_timeout, POLLIN); + + /* only report the connection state check result if an error is returned. */ + if (connect_res < 0) { + return connect_res; + } + return res; } ssize_t diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libqb-0.17.0+git20140219.78978d0/tests/check_ipc.c new/libqb-0.17.0+git20140312.c6f4fcd/tests/check_ipc.c --- old/libqb-0.17.0+git20140219.78978d0/tests/check_ipc.c 2014-02-20 12:24:04.000000000 +0100 +++ new/libqb-0.17.0+git20140312.c6f4fcd/tests/check_ipc.c 2014-03-21 07:24:42.000000000 +0100 @@ -139,6 +139,7 @@ int32_t m; int32_t num; struct qb_ipcs_connection_stats_2 *stats; + uint32_t max_size = MAX_MSG_SIZE; response.size = sizeof(struct qb_ipc_response_header); response.error = 0; @@ -148,8 +149,7 @@ free(stats); /* crazy large message */ - res = qb_ipcs_event_send(c, &response, - MAX_MSG_SIZE*10); + res = qb_ipcs_event_send(c, &response, max_size*10); ck_assert_int_eq(res, -EMSGSIZE); /* send one event before responding */ @@ -157,6 +157,11 @@ ck_assert_int_eq(res, sizeof(response)); response.id++; + /* There should be one more item in the event queue now. */ + stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE); + ck_assert_int_eq(stats->event_q_length - num, 1); + free(stats); + /* send response */ response.id = IPC_MSG_RES_BULK_EVENTS; res = qb_ipcs_response_send(c, &response, response.size); @@ -175,9 +180,6 @@ ck_assert_int_eq(res, sizeof(response)); response.id++; } - stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE); - ck_assert_int_eq(stats->event_q_length - num, num_bulk_events); - free(stats); } else if (req_pt->id == IPC_MSG_REQ_STRESS_EVENT) { struct { @@ -313,7 +315,7 @@ static void s1_connection_created(qb_ipcs_connection_t *c) { - int32_t max = MAX_MSG_SIZE; + uint32_t max = MAX_MSG_SIZE; if (send_event_on_created) { struct qb_ipc_response_header response; @@ -362,6 +364,7 @@ .dispatch_mod = my_dispatch_mod, .dispatch_del = my_dispatch_del, }; + uint32_t max_size = MAX_MSG_SIZE; qb_loop_signal_add(my_loop, QB_LOOP_HIGH, SIGSTOP, NULL, exit_handler, &handle); @@ -374,7 +377,7 @@ fail_if(s1 == 0); if (enforce_server_buffer) { - qb_ipcs_enforce_buffer_size(s1, MAX_MSG_SIZE); + qb_ipcs_enforce_buffer_size(s1, max_size); } qb_ipcs_poll_handlers_set(s1, &ph); @@ -402,13 +405,70 @@ return pid; } -static int32_t -stop_process(pid_t pid) +static void +request_server_exit(void) +{ + struct qb_ipc_request_header req_header; + struct qb_ipc_response_header res_header; + struct iovec iov[1]; + int32_t res; + + /* + * tell the server to exit + */ + req_header.id = IPC_MSG_REQ_SERVER_FAIL; + req_header.size = sizeof(struct qb_ipc_request_header); + + iov[0].iov_len = req_header.size; + iov[0].iov_base = &req_header; + + ck_assert_int_eq(QB_TRUE, qb_ipcc_is_connected(conn)); + + res = qb_ipcc_sendv_recv(conn, iov, 1, + &res_header, + sizeof(struct qb_ipc_response_header), -1); + /* + * confirm we get -ENOTCONN or ECONNRESET + */ + if (res != -ECONNRESET && res != -ENOTCONN) { + qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); + ck_assert_int_eq(res, -ENOTCONN); + } +} + +static void +kill_server(pid_t pid) { - /* wait a bit for the server to shutdown by it's self */ - usleep(100000); kill(pid, SIGTERM); waitpid(pid, NULL, 0); +} + +static int32_t +verify_graceful_stop(pid_t pid) +{ + int wait_rc = 0; + int status = 0; + int rc = 0; + int tries; + + /* We need the server to be able to exit by itself */ + for (tries = 10; tries >= 0; tries--) { + sleep(1); + wait_rc = waitpid(pid, &status, WNOHANG); + if (wait_rc > 0) { + break; + } + } + + ck_assert_int_eq(wait_rc, pid); + rc = WIFEXITED(status); + if (rc) { + rc = WEXITSTATUS(status); + ck_assert_int_eq(rc, 0); + } else { + fail_if(rc == 0); + } + return 0; } @@ -425,6 +485,7 @@ struct qb_ipc_response_header res_header; int32_t res; int32_t try_times = 0; + uint32_t max_size = MAX_MSG_SIZE; request.hdr.id = req_id; request.hdr.size = sizeof(struct qb_ipc_request_header) + size; @@ -432,7 +493,7 @@ /* check that we can't send a message that is too big * and we get the right return code. */ - res = qb_ipcc_send(conn, &request, MAX_MSG_SIZE*2); + res = qb_ipcc_send(conn, &request, max_size*2); ck_assert_int_eq(res, -EMSGSIZE); repeat_send: @@ -476,6 +537,62 @@ return res; } +static void +test_ipc_txrx_timeout(void) +{ + struct qb_ipc_request_header req_header; + struct qb_ipc_response_header res_header; + struct iovec iov[1]; + int32_t res; + int32_t c = 0; + int32_t j = 0; + pid_t pid; + uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { + conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); + sleep(1); + c++; + } + } while (conn == NULL && c < 5); + fail_if(conn == NULL); + + /* The dispatch response will only come over + * the event channel, we want to verify the receive times + * out when an event is returned with no response */ + req_header.id = IPC_MSG_REQ_DISPATCH; + req_header.size = sizeof(struct qb_ipc_request_header); + + iov[0].iov_len = req_header.size; + iov[0].iov_base = &req_header; + + res = qb_ipcc_sendv_recv(conn, iov, 1, + &res_header, + sizeof(struct qb_ipc_response_header), 5000); + + ck_assert_int_eq(res, -ETIMEDOUT); + + request_server_exit(); + verify_graceful_stop(pid); + + /* + * wait a bit for the server to die. + */ + sleep(1); + + /* + * this needs to free up the shared mem + */ + qb_ipcc_disconnect(conn); +} + static int32_t recv_timeout = -1; static void test_ipc_txrx(void) @@ -484,13 +601,14 @@ int32_t c = 0; size_t size; pid_t pid; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -503,7 +621,7 @@ size = QB_MIN(sizeof(struct qb_ipc_request_header), 64); for (j = 1; j < 19; j++) { size *= 2; - if (size >= MAX_MSG_SIZE) + if (size >= max_size) break; if (send_and_check(IPC_MSG_REQ_TX_RX, size, recv_timeout, QB_TRUE) < 0) { @@ -511,10 +629,17 @@ } } if (turn_on_fc) { + /* can't signal server to shutdown if flow control is on */ ck_assert_int_eq(fc_enabled, QB_TRUE); + qb_ipcc_disconnect(conn); + /* TODO - figure out why this sleep is necessary */ + sleep(1); + kill_server(pid); + } else { + request_server_exit(); + qb_ipcc_disconnect(conn); + verify_graceful_stop(pid); } - qb_ipcc_disconnect(conn); - stop_process(pid); } static void @@ -527,13 +652,14 @@ int32_t c = 0; int32_t j = 0; pid_t pid; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -554,8 +680,8 @@ sizeof(struct qb_ipc_response_header), -1); ck_assert_int_eq(res, sizeof(struct qb_ipc_response_header)); - /* kill the server */ - stop_process(pid); + request_server_exit(); + verify_graceful_stop(pid); /* * wait a bit for the server to die. @@ -590,6 +716,26 @@ } END_TEST +START_TEST(test_ipc_txrx_shm_timeout) +{ + qb_enter(); + ipc_type = QB_IPC_SHM; + ipc_name = __func__; + test_ipc_txrx_timeout(); + qb_leave(); +} +END_TEST + +START_TEST(test_ipc_txrx_us_timeout) +{ + qb_enter(); + ipc_type = QB_IPC_SOCKET; + ipc_name = __func__; + test_ipc_txrx_timeout(); + qb_leave(); +} +END_TEST + START_TEST(test_ipc_txrx_shm_tmo) { qb_enter(); @@ -674,13 +820,14 @@ int32_t c = 0; pid_t pid; int32_t size; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -693,7 +840,7 @@ size = QB_MIN(sizeof(struct qb_ipc_request_header), 64); for (j = 1; j < 19; j++) { size *= 2; - if (size >= MAX_MSG_SIZE) + if (size >= max_size) break; if (send_and_check(IPC_MSG_REQ_DISPATCH, size, recv_timeout, QB_TRUE) < 0) { @@ -701,8 +848,9 @@ } } + request_server_exit(); qb_ipcc_disconnect(conn); - stop_process(pid); + verify_graceful_stop(pid); } START_TEST(test_ipc_disp_us) @@ -781,22 +929,20 @@ static void test_ipc_bulk_events(void) { - struct qb_ipc_request_header req_header; - struct qb_ipc_response_header res_header; - struct iovec iov[1]; int32_t c = 0; int32_t j = 0; pid_t pid; int32_t res; qb_loop_t *cl; int32_t fd; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -823,21 +969,9 @@ qb_loop_run(cl); ck_assert_int_eq(events_received, num_bulk_events); - req_header.id = IPC_MSG_REQ_SERVER_FAIL; - req_header.size = sizeof(struct qb_ipc_request_header); - - iov[0].iov_len = req_header.size; - iov[0].iov_base = &req_header; - res = qb_ipcc_sendv_recv(conn, iov, 1, - &res_header, - sizeof(struct qb_ipc_response_header), -1); - if (res != -ECONNRESET && res != -ENOTCONN) { - qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); - ck_assert_int_eq(res, -ENOTCONN); - } - + request_server_exit(); qb_ipcc_disconnect(conn); - stop_process(pid); + verify_graceful_stop(pid); } static void @@ -857,13 +991,14 @@ int32_t res; qb_loop_t *cl; int32_t fd; + uint32_t max_size = MAX_MSG_SIZE; /* This looks strange, but it serves an important purpose. * This test forces the server to enforce the MAX_MSG_SIZE * limit from the server side, which overrides the client's * buffer limit. To verify this functionality is working * we set the client limit lower than what the server * is enforcing. */ - int32_t client_buf_size = MAX_MSG_SIZE - 1024; + int32_t client_buf_size = max_size - 1024; int32_t real_buf_size; enforce_server_buffer = 1; @@ -884,7 +1019,7 @@ fail_if(conn == NULL); real_buf_size = qb_ipcc_get_buffer_size(conn); - ck_assert_int_eq(real_buf_size, MAX_MSG_SIZE); + ck_assert_int_eq(real_buf_size, max_size); qb_log(LOG_DEBUG, "Testing %d iterations of EVENT msg passing.", num_stress_events); @@ -920,7 +1055,7 @@ } qb_ipcc_disconnect(conn); - stop_process(pid); + verify_graceful_stop(pid); } START_TEST(test_ipc_stress_test_us) @@ -954,6 +1089,7 @@ int32_t res; qb_loop_t *cl; int32_t fd; + uint32_t max_size = MAX_MSG_SIZE; num_bulk_events = 1; @@ -962,7 +1098,7 @@ sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -984,8 +1120,9 @@ qb_loop_run(cl); ck_assert_int_eq(events_received, num_bulk_events); + request_server_exit(); qb_ipcc_disconnect(conn); - stop_process(pid); + verify_graceful_stop(pid); } START_TEST(test_ipc_event_on_created_us) @@ -1009,13 +1146,14 @@ int32_t j = 0; pid_t pid; int32_t res; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -1046,7 +1184,7 @@ ck_assert_int_eq(QB_FALSE, qb_ipcc_is_connected(conn)); qb_ipcc_disconnect(conn); - stop_process(pid); + kill_server(pid); } START_TEST(test_ipc_disconnect_after_created_us) @@ -1063,20 +1201,17 @@ static void test_ipc_server_fail(void) { - struct qb_ipc_request_header req_header; - struct qb_ipc_response_header res_header; - struct iovec iov[1]; - int32_t res; int32_t j; int32_t c = 0; pid_t pid; + uint32_t max_size = MAX_MSG_SIZE; pid = run_function_in_new_process(run_ipc_server); fail_if(pid == -1); sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -1086,31 +1221,10 @@ } while (conn == NULL && c < 5); fail_if(conn == NULL); - /* - * tell the server to exit - */ - req_header.id = IPC_MSG_REQ_SERVER_FAIL; - req_header.size = sizeof(struct qb_ipc_request_header); - - iov[0].iov_len = req_header.size; - iov[0].iov_base = &req_header; - - ck_assert_int_eq(QB_TRUE, qb_ipcc_is_connected(conn)); - - res = qb_ipcc_sendv_recv(conn, iov, 1, - &res_header, - sizeof(struct qb_ipc_response_header), -1); - /* - * confirm we get -ENOTCONN or ECONNRESET - */ - if (res != -ECONNRESET && res != -ENOTCONN) { - qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); - ck_assert_int_eq(res, -ENOTCONN); - } + request_server_exit(); ck_assert_int_eq(QB_FALSE, qb_ipcc_is_connected(conn)); - qb_ipcc_disconnect(conn); - stop_process(pid); + verify_graceful_stop(pid); } START_TEST(test_ipc_server_fail_soc) @@ -1181,6 +1295,7 @@ int32_t c = 0; int32_t j = 0; pid_t pid; + uint32_t max_size = MAX_MSG_SIZE; reference_count_test = QB_TRUE; @@ -1189,7 +1304,7 @@ sleep(1); do { - conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); + conn = qb_ipcc_connect(ipc_name, max_size); if (conn == NULL) { j = waitpid(pid, NULL, WNOHANG); ck_assert_int_eq(j, 0); @@ -1201,8 +1316,7 @@ sleep(5); - qb_ipcc_disconnect(conn); - stop_process(pid); + kill_server(pid); } @@ -1263,24 +1377,29 @@ TCase *tc; Suite *s = suite_create("shm"); + tc = tcase_create("ipc_txrx_shm_timeout"); + tcase_add_test(tc, test_ipc_txrx_shm_timeout); + tcase_set_timeout(tc, 30); + suite_add_tcase(s, tc); + tc = tcase_create("ipc_server_fail_shm"); tcase_add_test(tc, test_ipc_server_fail_shm); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_txrx_shm_block"); tcase_add_test(tc, test_ipc_txrx_shm_block); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_txrx_shm_tmo"); tcase_add_test(tc, test_ipc_txrx_shm_tmo); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_fc_shm"); tcase_add_test(tc, test_ipc_fc_shm); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_dispatch_shm"); @@ -1300,11 +1419,12 @@ tc = tcase_create("ipc_exit_shm"); tcase_add_test(tc, test_ipc_exit_shm); - tcase_set_timeout(tc, 3); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_event_on_created_shm"); tcase_add_test(tc, test_ipc_event_on_created_shm); + tcase_set_timeout(tc, 10); suite_add_tcase(s, tc); tc = tcase_create("ipc_service_ref_count_shm"); @@ -1321,6 +1441,11 @@ Suite *s = suite_create("socket"); TCase *tc; + tc = tcase_create("ipc_txrx_us_timeout"); + tcase_add_test(tc, test_ipc_txrx_us_timeout); + tcase_set_timeout(tc, 30); + suite_add_tcase(s, tc); + tc = tcase_create("ipc_max_dgram_size"); tcase_add_test(tc, test_ipc_max_dgram_size); tcase_set_timeout(tc, 30); @@ -1328,27 +1453,27 @@ tc = tcase_create("ipc_server_fail_soc"); tcase_add_test(tc, test_ipc_server_fail_soc); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_txrx_us_block"); tcase_add_test(tc, test_ipc_txrx_us_block); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_txrx_us_tmo"); tcase_add_test(tc, test_ipc_txrx_us_tmo); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_fc_us"); tcase_add_test(tc, test_ipc_fc_us); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_exit_us"); tcase_add_test(tc, test_ipc_exit_us); - tcase_set_timeout(tc, 6); + tcase_set_timeout(tc, 8); suite_add_tcase(s, tc); tc = tcase_create("ipc_dispatch_us"); @@ -1368,10 +1493,12 @@ tc = tcase_create("ipc_event_on_created_us"); tcase_add_test(tc, test_ipc_event_on_created_us); + tcase_set_timeout(tc, 10); suite_add_tcase(s, tc); tc = tcase_create("ipc_disconnect_after_created_us"); tcase_add_test(tc, test_ipc_disconnect_after_created_us); + tcase_set_timeout(tc, 10); suite_add_tcase(s, tc); tc = tcase_create("ipc_service_ref_count_us"); -- To unsubscribe, e-mail: opensuse-commit+unsubscribe@opensuse.org For additional commands, e-mail: opensuse-commit+help@opensuse.org