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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
/*
* libusb multi-thread test program
* Copyright 2022-2023 Tormod Volden
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <config.h>
#include <libusb.h>
#include <stdio.h>
#if defined(PLATFORM_POSIX)
#include <pthread.h>
typedef pthread_t thread_t;
typedef void * thread_return_t;
#define THREAD_RETURN_VALUE NULL
#define THREAD_CALL_TYPE
static inline int thread_create(thread_t *thread,
thread_return_t (*thread_entry)(void *arg), void *arg)
{
return pthread_create(thread, NULL, thread_entry, arg) == 0 ? 0 : -1;
}
static inline void thread_join(thread_t thread)
{
(void)pthread_join(thread, NULL);
}
#elif defined(PLATFORM_WINDOWS)
typedef HANDLE thread_t;
#define THREAD_RETURN_VALUE 0
#define THREAD_CALL_TYPE __stdcall
#if defined(__CYGWIN__)
typedef DWORD thread_return_t;
#else
#include <process.h>
typedef unsigned thread_return_t;
#endif
static inline int thread_create(thread_t *thread,
thread_return_t (__stdcall *thread_entry)(void *arg), void *arg)
{
#if defined(__CYGWIN__)
*thread = CreateThread(NULL, 0, thread_entry, arg, 0, NULL);
#else
*thread = (HANDLE)_beginthreadex(NULL, 0, thread_entry, arg, 0, NULL);
#endif
return *thread != NULL ? 0 : -1;
}
static inline void thread_join(thread_t thread)
{
(void)WaitForSingleObject(thread, INFINITE);
(void)CloseHandle(thread);
}
#endif /* PLATFORM_WINDOWS */
/* Test that creates and destroys contexts repeatedly */
#define NTHREADS 8
#define ITERS 64
struct thread_info {
int number;
int enumerate;
ssize_t devcount;
int err;
int iteration;
} tinfo[NTHREADS];
static thread_return_t THREAD_CALL_TYPE init_and_exit(void * arg)
{
struct thread_info *ti = (struct thread_info *) arg;
for (int i = 0; i < ITERS; ++i) {
libusb_context *ctx = NULL;
int r;
r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
if (r != LIBUSB_SUCCESS) {
ti->err = r;
ti->iteration = i;
return (thread_return_t) THREAD_RETURN_VALUE;
}
if (ti->enumerate) {
libusb_device **devs;
ti->devcount = libusb_get_device_list(ctx, &devs);
if (ti->devcount < 0) {
libusb_free_device_list(devs, 1);
ti->iteration = i;
break;
}
libusb_free_device_list(devs, 1);
}
libusb_exit(ctx);
}
return (thread_return_t) THREAD_RETURN_VALUE;
}
static int test_multi_init(int enumerate)
{
thread_t threadId[NTHREADS];
int errs = 0;
int t;
printf("Starting %d threads\n", NTHREADS);
for (t = 0; t < NTHREADS; t++) {
tinfo[t].number = t;
tinfo[t].enumerate = enumerate;
thread_create(&threadId[t], &init_and_exit, (void *) &tinfo[t]);
}
for (t = 0; t < NTHREADS; t++) {
thread_join(threadId[t]);
if (tinfo[t].err) {
errs++;
fprintf(stderr,
"Thread %d failed (iteration %d): %s\n",
tinfo[t].number,
tinfo[t].iteration,
libusb_error_name(tinfo[t].err));
} else if (enumerate) {
if (tinfo[t].devcount < 0) {
errs++;
fprintf(stderr,
"Thread %d failed to enumerate devices (iteration %d)\n",
tinfo[t].number,
tinfo[t].iteration);
} else {
printf("Thread %d discovered %ld devices\n",
tinfo[t].number,
(long int) tinfo[t].devcount);
}
}
}
return errs;
}
int main(void)
{
int errs = 0;
printf("Running multithreaded init/exit test...\n");
errs += test_multi_init(0);
printf("Running multithreaded init/exit test with enumeration...\n");
errs += test_multi_init(1);
printf("All done, %d errors\n", errs);
return errs != 0;
}
|
