1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <stdint.h>
#include <errno.h>
#include <assert.h>
#include <poll.h>
#include <sys/ioctl.h>
#include "kdbus-util.h"
#include "kdbus-enum.h"
static uint64_t expected = 0;
int timeout_msg_recv(struct conn *conn)
{
struct kdbus_cmd_recv recv = {};
struct kdbus_msg *msg;
int ret;
ret = ioctl(conn->fd, KDBUS_CMD_MSG_RECV, &recv);
if (ret < 0) {
fprintf(stderr, "error receiving message: %d (%m)\n", ret);
return EXIT_FAILURE;
}
msg = (struct kdbus_msg *)(conn->buf + recv.offset);
expected &= ~(1ULL << msg->cookie_reply);
printf("Got message timeout for cookie %llu\n", msg->cookie_reply);
ret = ioctl(conn->fd, KDBUS_CMD_FREE, &recv.offset);
if (ret < 0) {
fprintf(stderr, "error free message: %d (%m)\n", ret);
return EXIT_FAILURE;
}
return 0;
}
static int run_test(void)
{
struct {
struct kdbus_cmd_make head;
/* bloom size item */
struct {
uint64_t size;
uint64_t type;
uint64_t bloom_size;
} bs;
/* name item */
uint64_t n_size;
uint64_t n_type;
char name[64];
} bus_make;
char *bus;
struct conn *conn_a, *conn_b;
struct pollfd fd;
int fdc, ret, i, n_msgs = 4;
printf("-- opening /dev/" KBUILD_MODNAME "/control\n");
fdc = open("/dev/" KBUILD_MODNAME "/control", O_RDWR|O_CLOEXEC);
if (fdc < 0) {
fprintf(stderr, "--- error %d (%m)\n", fdc);
return EXIT_FAILURE;
}
memset(&bus_make, 0, sizeof(bus_make));
bus_make.head.flags = KDBUS_MAKE_POLICY_OPEN;
bus_make.bs.size = sizeof(bus_make.bs);
bus_make.bs.type = KDBUS_ITEM_BLOOM_SIZE;
bus_make.bs.bloom_size = 64;
snprintf(bus_make.name, sizeof(bus_make.name), "%u-testbus", getuid());
bus_make.n_type = KDBUS_ITEM_MAKE_NAME;
bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1;
bus_make.head.size = sizeof(struct kdbus_cmd_make) +
sizeof(bus_make.bs) +
bus_make.n_size;
printf("-- creating bus '%s'\n", bus_make.name);
ret = ioctl(fdc, KDBUS_CMD_BUS_MAKE, &bus_make);
if (ret) {
fprintf(stderr, "--- error %d (%m)\n", ret);
return EXIT_FAILURE;
}
if (asprintf(&bus, "/dev/" KBUILD_MODNAME "/%s/bus", bus_make.name) < 0)
return EXIT_FAILURE;
conn_a = connect_to_bus(bus, 0);
conn_b = connect_to_bus(bus, 0);
if (!conn_a || !conn_b)
return EXIT_FAILURE;
fd.fd = conn_b->fd;
/* send messages that expect a reply (within 1 sec), but never answer it */
for (i = 0; i < n_msgs; i++) {
printf("Sending message with cookie %u ...\n", i);
msg_send(conn_b, NULL, i, KDBUS_MSG_FLAGS_EXPECT_REPLY, (i + 1) * 100ULL * 1000ULL, 0, conn_a->id);
expected |= 1ULL << i;
}
for (;;) {
fd.events = POLLIN | POLLPRI | POLLHUP;
fd.revents = 0;
ret = poll(&fd, 1, (n_msgs + 1) * 100);
if (ret == 0)
printf("--- timeout\n");
if (ret <= 0)
break;
if (fd.revents & POLLIN)
timeout_msg_recv(conn_b);
if (expected == 0)
break;
}
if (expected != 0) {
for (i = 0; i < 64; i++)
if (expected & (1ULL << i))
printf("No timeout notification received for cookie %u\n", i);
} else {
printf("Timeout notifications received for all messages. Good.\n");
}
close(conn_a->fd);
close(conn_b->fd);
free(conn_a);
free(conn_b);
close(fdc);
free(bus);
return expected ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
if (argc > 1)
while (run_test() == 0);
return run_test();
}
|
