Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
selftests: ntsync: Add some tests for mutex state.
Test mutex-specific ioctls NTSYNC_IOC_MUTEX_UNLOCK and NTSYNC_IOC_MUTEX_READ,
and waiting on mutexes.
Signed-off-by: Elizabeth Figura <zfigura@codeweavers.com>
Link: https://lore.kernel.org/r/20241213193511.457338-18-zfigura@codeweavers.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
authored by
Elizabeth Figura
and committed by
Greg Kroah-Hartman
ae071aef
7f853a25
+187
+187
tools/testing/selftests/drivers/ntsync/ntsync.c
+187
tools/testing/selftests/drivers/ntsync/ntsync.c
···
40
40
return ioctl(sem, NTSYNC_IOC_SEM_RELEASE, count);
41
41
}
42
42
43
+
static int read_mutex_state(int mutex, __u32 *count, __u32 *owner)
44
+
{
45
+
struct ntsync_mutex_args args;
46
+
int ret;
47
+
48
+
memset(&args, 0xcc, sizeof(args));
49
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &args);
50
+
*count = args.count;
51
+
*owner = args.owner;
52
+
return ret;
53
+
}
54
+
55
+
#define check_mutex_state(mutex, count, owner) \
56
+
({ \
57
+
__u32 __count, __owner; \
58
+
int ret = read_mutex_state((mutex), &__count, &__owner); \
59
+
EXPECT_EQ(0, ret); \
60
+
EXPECT_EQ((count), __count); \
61
+
EXPECT_EQ((owner), __owner); \
62
+
})
63
+
64
+
static int unlock_mutex(int mutex, __u32 owner, __u32 *count)
65
+
{
66
+
struct ntsync_mutex_args args;
67
+
int ret;
68
+
69
+
args.owner = owner;
70
+
args.count = 0xdeadbeef;
71
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_UNLOCK, &args);
72
+
*count = args.count;
73
+
return ret;
74
+
}
75
+
43
76
static int wait_any(int fd, __u32 count, const int *objs, __u32 owner, __u32 *index)
44
77
{
45
78
struct ntsync_wait_args args = {0};
···
171
138
check_sem_state(sem, 1, 2);
172
139
173
140
close(sem);
141
+
142
+
close(fd);
143
+
}
144
+
145
+
TEST(mutex_state)
146
+
{
147
+
struct ntsync_mutex_args mutex_args;
148
+
__u32 owner, count, index;
149
+
struct timespec timeout;
150
+
int fd, ret, mutex;
151
+
152
+
clock_gettime(CLOCK_MONOTONIC, &timeout);
153
+
154
+
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
155
+
ASSERT_LE(0, fd);
156
+
157
+
mutex_args.owner = 123;
158
+
mutex_args.count = 0;
159
+
mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
160
+
EXPECT_EQ(-1, mutex);
161
+
EXPECT_EQ(EINVAL, errno);
162
+
163
+
mutex_args.owner = 0;
164
+
mutex_args.count = 2;
165
+
mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
166
+
EXPECT_EQ(-1, mutex);
167
+
EXPECT_EQ(EINVAL, errno);
168
+
169
+
mutex_args.owner = 123;
170
+
mutex_args.count = 2;
171
+
mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
172
+
EXPECT_LE(0, mutex);
173
+
check_mutex_state(mutex, 2, 123);
174
+
175
+
ret = unlock_mutex(mutex, 0, &count);
176
+
EXPECT_EQ(-1, ret);
177
+
EXPECT_EQ(EINVAL, errno);
178
+
179
+
ret = unlock_mutex(mutex, 456, &count);
180
+
EXPECT_EQ(-1, ret);
181
+
EXPECT_EQ(EPERM, errno);
182
+
check_mutex_state(mutex, 2, 123);
183
+
184
+
ret = unlock_mutex(mutex, 123, &count);
185
+
EXPECT_EQ(0, ret);
186
+
EXPECT_EQ(2, count);
187
+
check_mutex_state(mutex, 1, 123);
188
+
189
+
ret = unlock_mutex(mutex, 123, &count);
190
+
EXPECT_EQ(0, ret);
191
+
EXPECT_EQ(1, count);
192
+
check_mutex_state(mutex, 0, 0);
193
+
194
+
ret = unlock_mutex(mutex, 123, &count);
195
+
EXPECT_EQ(-1, ret);
196
+
EXPECT_EQ(EPERM, errno);
197
+
198
+
ret = wait_any(fd, 1, &mutex, 456, &index);
199
+
EXPECT_EQ(0, ret);
200
+
EXPECT_EQ(0, index);
201
+
check_mutex_state(mutex, 1, 456);
202
+
203
+
ret = wait_any(fd, 1, &mutex, 456, &index);
204
+
EXPECT_EQ(0, ret);
205
+
EXPECT_EQ(0, index);
206
+
check_mutex_state(mutex, 2, 456);
207
+
208
+
ret = unlock_mutex(mutex, 456, &count);
209
+
EXPECT_EQ(0, ret);
210
+
EXPECT_EQ(2, count);
211
+
check_mutex_state(mutex, 1, 456);
212
+
213
+
ret = wait_any(fd, 1, &mutex, 123, &index);
214
+
EXPECT_EQ(-1, ret);
215
+
EXPECT_EQ(ETIMEDOUT, errno);
216
+
217
+
owner = 0;
218
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
219
+
EXPECT_EQ(-1, ret);
220
+
EXPECT_EQ(EINVAL, errno);
221
+
222
+
owner = 123;
223
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
224
+
EXPECT_EQ(-1, ret);
225
+
EXPECT_EQ(EPERM, errno);
226
+
check_mutex_state(mutex, 1, 456);
227
+
228
+
owner = 456;
229
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
230
+
EXPECT_EQ(0, ret);
231
+
232
+
memset(&mutex_args, 0xcc, sizeof(mutex_args));
233
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
234
+
EXPECT_EQ(-1, ret);
235
+
EXPECT_EQ(EOWNERDEAD, errno);
236
+
EXPECT_EQ(0, mutex_args.count);
237
+
EXPECT_EQ(0, mutex_args.owner);
238
+
239
+
memset(&mutex_args, 0xcc, sizeof(mutex_args));
240
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
241
+
EXPECT_EQ(-1, ret);
242
+
EXPECT_EQ(EOWNERDEAD, errno);
243
+
EXPECT_EQ(0, mutex_args.count);
244
+
EXPECT_EQ(0, mutex_args.owner);
245
+
246
+
ret = wait_any(fd, 1, &mutex, 123, &index);
247
+
EXPECT_EQ(-1, ret);
248
+
EXPECT_EQ(EOWNERDEAD, errno);
249
+
EXPECT_EQ(0, index);
250
+
check_mutex_state(mutex, 1, 123);
251
+
252
+
owner = 123;
253
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
254
+
EXPECT_EQ(0, ret);
255
+
256
+
memset(&mutex_args, 0xcc, sizeof(mutex_args));
257
+
ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
258
+
EXPECT_EQ(-1, ret);
259
+
EXPECT_EQ(EOWNERDEAD, errno);
260
+
EXPECT_EQ(0, mutex_args.count);
261
+
EXPECT_EQ(0, mutex_args.owner);
262
+
263
+
ret = wait_any(fd, 1, &mutex, 123, &index);
264
+
EXPECT_EQ(-1, ret);
265
+
EXPECT_EQ(EOWNERDEAD, errno);
266
+
EXPECT_EQ(0, index);
267
+
check_mutex_state(mutex, 1, 123);
268
+
269
+
close(mutex);
270
+
271
+
mutex_args.owner = 0;
272
+
mutex_args.count = 0;
273
+
mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
274
+
EXPECT_LE(0, mutex);
275
+
check_mutex_state(mutex, 0, 0);
276
+
277
+
ret = wait_any(fd, 1, &mutex, 123, &index);
278
+
EXPECT_EQ(0, ret);
279
+
EXPECT_EQ(0, index);
280
+
check_mutex_state(mutex, 1, 123);
281
+
282
+
close(mutex);
283
+
284
+
mutex_args.owner = 123;
285
+
mutex_args.count = ~0u;
286
+
mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
287
+
EXPECT_LE(0, mutex);
288
+
check_mutex_state(mutex, ~0u, 123);
289
+
290
+
ret = wait_any(fd, 1, &mutex, 123, &index);
291
+
EXPECT_EQ(-1, ret);
292
+
EXPECT_EQ(ETIMEDOUT, errno);
293
+
294
+
close(mutex);
174
295
175
296
close(fd);
176
297
}