v4l2-compliance: Convert testBlockingDQBuf to pthreads
PATCH v2 1/1 v4l2-compliance: Convert testBlockingDQBuf to pthreads
The test to test that a blocked VIDIOC_QBUF call will not block a VIDIOC_STREAMOFF call uses different processes to make the calls. As it isn't very realistic for multiple processes to be controlling a single V4L2 device, convert the test to pthreads.
---
Changes in v2:
- wrap thread lifetime management in a class to simplify terminating and joining the threads in various success/failure combinations
--- utils/v4l2-compliance/v4l2-test-buffers.cpp | 174 +++++++++++++++----- 1 file changed, 135 insertions(+), 39 deletions(-)
utils/v4l2-compliance/v4l2-test-buffers.cpp +135 -39
@@ -32,8 +32,11 @@ #include <ctype.h> #include <errno.h> #include <poll.h> +#include <pthread.h> +#include <signal.h> #include <sys/ioctl.h> #include <netinet/in.h> +#include <atomic> #include <map> #include <vector> #include "v4l2-compliance.h"
@@ -2229,65 +2232,158 @@ int testRequests(struct node *node, bool test_streaming) return 0; } -static int testBlockingDQBuf(struct node *node, cv4l_queue &q) + +class BlockingThread { - int pid_dqbuf; - int pid_streamoff; - int pid; +public: + BlockingThread() : done(false), running(false) {} - fail_on_test(q.reqbufs(node, 2)); - fail_on_test(node->streamon(q.g_type())); + virtual ~BlockingThread() + { + stop(); + } - /* - * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block - * other ioctls. - */ - fflush(stdout); - pid_dqbuf = fork(); - fail_on_test(pid_dqbuf == -1); + int start() + { + int ret = pthread_create(&thread, NULL, startRoutine, this); + if (ret < 0) + return ret; + + running = true; + return 0; + } + + void stop() + { + if (!running) + return; + + /* + * If the thread is blocked on an ioctl, try to wake it up with + * a signal. + */ + if (!done) { + pthread_kill(thread, SIGUSR1); + usleep(100000); + } - if (pid_dqbuf == 0) { // Child /* - * In the child process we call VIDIOC_DQBUF and wait - * indefinitely since no buffers are queued. + * If the signal failed to interrupt the ioctl, use the heavy + * artillery and cancel the thread. */ - cv4l_buffer buf(q.g_type(), V4L2_MEMORY_MMAP); + if (!done) { + pthread_cancel(thread); + usleep(100000); + } + + pthread_join(thread, NULL); + running = false; + } + + void kill() + { + pthread_kill(thread, SIGUSR1); + } + + std::atomic<bool> done; + +private: + static void *startRoutine(void *arg) + { + BlockingThread *self = static_cast<BlockingThread *>(arg); + + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); + + self->run(); + + self->done = true; + return NULL; + } + + virtual void run() = 0; + + pthread_t thread; + std::atomic<bool> running; +}; +class DqbufThread : public BlockingThread +{ +public: + DqbufThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} + +private: + void run() override + { + /* + * In this thread we call VIDIOC_DQBUF and wait indefinitely + * since no buffers are queued. + */ + cv4l_buffer buf(queue->g_type(), V4L2_MEMORY_MMAP); node->dqbuf(buf); - std::exit(EXIT_SUCCESS); } - /* Wait for the child process to start and block */ - usleep(100000); - pid = waitpid(pid_dqbuf, NULL, WNOHANG); - /* Check that it is really blocking */ - fail_on_test(pid); + cv4l_queue *queue; + struct node *node; +}; - fflush(stdout); - pid_streamoff = fork(); - fail_on_test(pid_streamoff == -1); +class StreamoffThread : public BlockingThread +{ +public: + StreamoffThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} - if (pid_streamoff == 0) { // Child +private: + void run() override + { /* - * In the second child call STREAMOFF: this shouldn't + * In this thread call STREAMOFF; this shouldn't * be blocked by the DQBUF! */ - node->streamoff(q.g_type()); - std::exit(EXIT_SUCCESS); + node->streamoff(queue->g_type()); } - int wstatus_streamoff = 0; + cv4l_queue *queue; + struct node *node; +}; + +static void pthread_sighandle(int sig) +{ + return; +} + +static int testBlockingDQBuf(struct node *node, cv4l_queue &q) +{ + DqbufThread thread_dqbuf(&q, node); + StreamoffThread thread_streamoff(&q, node); + + /* + * SIGUSR1 is ignored by default, so install an empty signal handler + * so that we can use SIGUSR1 to wake up threads potentially blocked + * on ioctls. + */ + signal(SIGUSR1, pthread_sighandle); + + fail_on_test(q.reqbufs(node, 2)); + fail_on_test(node->streamon(q.g_type())); + + /* + * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block + * other ioctls. + */ + fflush(stdout); + thread_dqbuf.start(); + + /* Wait for the child thread to start and block */ + usleep(100000); + /* Check that it is really blocking */ + fail_on_test(thread_dqbuf.done); + + fflush(stdout); + thread_streamoff.start(); /* Wait for the second child to start and exit */ usleep(250000); - pid = waitpid(pid_streamoff, &wstatus_streamoff, WNOHANG); - kill(pid_dqbuf, SIGKILL); - fail_on_test(pid != pid_streamoff); - /* Test that the second child exited properly */ - if (!pid || !WIFEXITED(wstatus_streamoff)) { - kill(pid_streamoff, SIGKILL); - fail_on_test(!pid || !WIFEXITED(wstatus_streamoff)); - } + fail_on_test(!thread_streamoff.done); fail_on_test(node->streamoff(q.g_type())); fail_on_test(q.reqbufs(node, 0));
Signature · 1 line
2.27.0
Quoted 32 lines · Paul Elder
The test to test that a blocked
VIDIOC_QBUFcall will not block aVIDIOC_STREAMOFFcall uses different processes to make the calls. As it isn't very realistic for multiple processes to be controlling a single V4L2 device, convert the test to pthreads.Signed-off-by Paul Elder <[email protected]>---
Changes in v2:
- wrap thread lifetime management in a class to simplify terminating and joining the threads in various success/failure combinations--- utils/v4l2-compliance/v4l2-test-buffers.cpp | 174 +++++++++++++++----- 1 file changed, 135 insertions(+), 39 deletions(-)utils/v4l2-compliance/v4l2-test-buffers.cpp +3
-0@@ -32,8 +32,11 @@ #include <ctype.h> #include <errno.h> #include <poll.h> +#include <pthread.h> +#include <signal.h> #include <sys/ioctl.h> #include <netinet/in.h> +#include <atomic> #include <map> #include <vector> #include "v4l2-compliance.h"
utils/v4l2-compliance/v4l2-test-buffers.cpp int testRequests(struct node *node, bool test_streaming) · line 2236
Quoted 6 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +2
-1@@ -2229,65 +2232,158 @@ int testRequests(struct node *node, bool test_streaming) return 0; } -static int testBlockingDQBuf(struct node *node, cv4l_queue &q) + +class BlockingThread
This patch looks good, but can you document this class? Some high-level comments about what this class does should be sufficient.
Regards,
Hans
Quoted 192 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +130
-38{ - int pid_dqbuf; - int pid_streamoff; - int pid; +public: + BlockingThread() : done(false), running(false) {} - fail_on_test(q.reqbufs(node, 2)); - fail_on_test(node->streamon(q.g_type())); + virtual ~BlockingThread() + { + stop(); + } - /* - * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block - * other ioctls. - */ - fflush(stdout); - pid_dqbuf = fork(); - fail_on_test(pid_dqbuf == -1); + int start() + { + int ret = pthread_create(&thread, NULL, startRoutine, this); + if (ret < 0) + return ret; + + running = true; + return 0; + } + + void stop() + { + if (!running) + return; + + /* + * If the thread is blocked on an ioctl, try to wake it up with + * a signal. + */ + if (!done) { + pthread_kill(thread, SIGUSR1); + usleep(100000); + } - if (pid_dqbuf == 0) { // Child /* - * In the child process we call VIDIOC_DQBUF and wait - * indefinitely since no buffers are queued. + * If the signal failed to interrupt the ioctl, use the heavy + * artillery and cancel the thread. */ - cv4l_buffer buf(q.g_type(), V4L2_MEMORY_MMAP); + if (!done) { + pthread_cancel(thread); + usleep(100000); + } + + pthread_join(thread, NULL); + running = false; + } + + void kill() + { + pthread_kill(thread, SIGUSR1); + } + + std::atomic<bool> done; + +private: + static void *startRoutine(void *arg) + { + BlockingThread *self = static_cast<BlockingThread *>(arg); + + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); + + self->run(); + + self->done = true; + return NULL; + } + + virtual void run() = 0; + + pthread_t thread; + std::atomic<bool> running; +}; +class DqbufThread : public BlockingThread +{ +public: + DqbufThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} + +private: + void run() override + { + /* + * In this thread we call VIDIOC_DQBUF and wait indefinitely + * since no buffers are queued. + */ + cv4l_buffer buf(queue->g_type(), V4L2_MEMORY_MMAP); node->dqbuf(buf); - std::exit(EXIT_SUCCESS); } - /* Wait for the child process to start and block */ - usleep(100000); - pid = waitpid(pid_dqbuf, NULL, WNOHANG); - /* Check that it is really blocking */ - fail_on_test(pid); + cv4l_queue *queue; + struct node *node; +}; - fflush(stdout); - pid_streamoff = fork(); - fail_on_test(pid_streamoff == -1); +class StreamoffThread : public BlockingThread +{ +public: + StreamoffThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} - if (pid_streamoff == 0) { // Child +private: + void run() override + { /* - * In the second child call STREAMOFF: this shouldn't + * In this thread call STREAMOFF; this shouldn't * be blocked by the DQBUF! */ - node->streamoff(q.g_type()); - std::exit(EXIT_SUCCESS); + node->streamoff(queue->g_type()); } - int wstatus_streamoff = 0; + cv4l_queue *queue; + struct node *node; +}; + +static void pthread_sighandle(int sig) +{ + return; +} + +static int testBlockingDQBuf(struct node *node, cv4l_queue &q) +{ + DqbufThread thread_dqbuf(&q, node); + StreamoffThread thread_streamoff(&q, node); + + /* + * SIGUSR1 is ignored by default, so install an empty signal handler + * so that we can use SIGUSR1 to wake up threads potentially blocked + * on ioctls. + */ + signal(SIGUSR1, pthread_sighandle); + + fail_on_test(q.reqbufs(node, 2)); + fail_on_test(node->streamon(q.g_type())); + + /* + * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block + * other ioctls. + */ + fflush(stdout); + thread_dqbuf.start(); + + /* Wait for the child thread to start and block */ + usleep(100000); + /* Check that it is really blocking */ + fail_on_test(thread_dqbuf.done); + + fflush(stdout); + thread_streamoff.start(); /* Wait for the second child to start and exit */ usleep(250000); - pid = waitpid(pid_streamoff, &wstatus_streamoff, WNOHANG); - kill(pid_dqbuf, SIGKILL); - fail_on_test(pid != pid_streamoff); - /* Test that the second child exited properly */ - if (!pid || !WIFEXITED(wstatus_streamoff)) { - kill(pid_streamoff, SIGKILL); - fail_on_test(!pid || !WIFEXITED(wstatus_streamoff)); - } + fail_on_test(!thread_streamoff.done); fail_on_test(node->streamoff(q.g_type())); fail_on_test(q.reqbufs(node, 0));
Hi Paul,
Thank you for the patch.
Quoted 94 lines · Paul Elder
The test to test that a blocked
VIDIOC_QBUFcall will not block aVIDIOC_STREAMOFFcall uses different processes to make the calls. As it isn't very realistic for multiple processes to be controlling a single V4L2 device, convert the test to pthreads.Signed-off-by Paul Elder <[email protected]>---
Changes in v2:
- wrap thread lifetime management in a class to simplify terminating and joining the threads in various success/failure combinations--- utils/v4l2-compliance/v4l2-test-buffers.cpp | 174 +++++++++++++++----- 1 file changed, 135 insertions(+), 39 deletions(-)utils/v4l2-compliance/v4l2-test-buffers.cpp +39
-17@@ -32,8 +32,11 @@ #include <ctype.h> #include <errno.h> #include <poll.h> +#include <pthread.h> +#include <signal.h> #include <sys/ioctl.h> #include <netinet/in.h> +#include <atomic> #include <map> #include <vector> #include "v4l2-compliance.h"@@ -2229,65 +2232,158 @@ int testRequests(struct node *node, bool test_streaming) return 0; } -static int testBlockingDQBuf(struct node *node, cv4l_queue &q) + +class BlockingThread { - int pid_dqbuf; - int pid_streamoff; - int pid; +public: + BlockingThread() : done(false), running(false) {} - fail_on_test(q.reqbufs(node, 2)); - fail_on_test(node->streamon(q.g_type())); + virtual ~BlockingThread() + { + stop(); + } - /* - * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block - * other ioctls. - */ - fflush(stdout); - pid_dqbuf = fork(); - fail_on_test(pid_dqbuf == -1); + int start() + { + int ret = pthread_create(&thread, NULL, startRoutine, this); + if (ret < 0) + return ret; + + running = true; + return 0; + } + + void stop() + { + if (!running) + return; + + /* + * If the thread is blocked on an ioctl, try to wake it up with + * a signal. + */ + if (!done) { + pthread_kill(thread, SIGUSR1); + usleep(100000); + } - if (pid_dqbuf == 0) { // Child /* - * In the child process we call VIDIOC_DQBUF and wait - * indefinitely since no buffers are queued. + * If the signal failed to interrupt the ioctl, use the heavy + * artillery and cancel the thread. */ - cv4l_buffer buf(q.g_type(), V4L2_MEMORY_MMAP); + if (!done) { + pthread_cancel(thread); + usleep(100000);
utils/v4l2-compliance/v4l2-test-buffers.cpp int testRequests(struct node *node, bool test_streaming) · line 2286
Quoted 10 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +10
-0+ } + + pthread_join(thread, NULL); + running = false; + } + + void kill() + { + pthread_kill(thread, SIGUSR1); + }
This function isn't used, you can drop it.
Quoted 67 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +46
-12+ + std::atomic<bool> done; + +private: + static void *startRoutine(void *arg) + { + BlockingThread *self = static_cast<BlockingThread *>(arg); + + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); + + self->run(); + + self->done = true; + return NULL; + } + + virtual void run() = 0; + + pthread_t thread; + std::atomic<bool> running; +}; +class DqbufThread : public BlockingThread +{ +public: + DqbufThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} + +private: + void run() override + { + /* + * In this thread we call VIDIOC_DQBUF and wait indefinitely + * since no buffers are queued. + */ + cv4l_buffer buf(queue->g_type(), V4L2_MEMORY_MMAP); node->dqbuf(buf); - std::exit(EXIT_SUCCESS); } - /* Wait for the child process to start and block */ - usleep(100000); - pid = waitpid(pid_dqbuf, NULL, WNOHANG); - /* Check that it is really blocking */ - fail_on_test(pid); + cv4l_queue *queue; + struct node *node; +}; - fflush(stdout); - pid_streamoff = fork(); - fail_on_test(pid_streamoff == -1); +class StreamoffThread : public BlockingThread +{ +public: + StreamoffThread(cv4l_queue *q, struct node *n) : queue(q), node(n) {} - if (pid_streamoff == 0) { // Child +private: + void run() override + { /* - * In the second child call STREAMOFF: this shouldn't + * In this thread call STREAMOFF; this shouldn't * be blocked by the DQBUF! */ - node->streamoff(q.g_type());
utils/v4l2-compliance/v4l2-test-buffers.cpp int testRequests(struct node *node, bool test_streaming) · line 2349
Quoted 10 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +6
-2- std::exit(EXIT_SUCCESS); + node->streamoff(queue->g_type()); } - int wstatus_streamoff = 0; + cv4l_queue *queue; + struct node *node; +}; + +static void pthread_sighandle(int sig)
s/handle/handler/ ?
utils/v4l2-compliance/v4l2-test-buffers.cpp int testRequests(struct node *node, bool test_streaming) · line 2351
Quoted 2 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +2
-0+{ + return;
You can drop the return statement.
Quoted 46 lines
utils/v4l2-compliance/v4l2-test-buffers.cpp +32
-8+} + +static int testBlockingDQBuf(struct node *node, cv4l_queue &q) +{ + DqbufThread thread_dqbuf(&q, node); + StreamoffThread thread_streamoff(&q, node); + + /* + * SIGUSR1 is ignored by default, so install an empty signal handler + * so that we can use SIGUSR1 to wake up threads potentially blocked + * on ioctls. + */ + signal(SIGUSR1, pthread_sighandle); + + fail_on_test(q.reqbufs(node, 2)); + fail_on_test(node->streamon(q.g_type())); + + /* + * This test checks if a blocking wait in VIDIOC_DQBUF doesn't block + * other ioctls. + */ + fflush(stdout); + thread_dqbuf.start(); + + /* Wait for the child thread to start and block */ + usleep(100000); + /* Check that it is really blocking */ + fail_on_test(thread_dqbuf.done); + + fflush(stdout); + thread_streamoff.start(); /* Wait for the second child to start and exit */ usleep(250000); - pid = waitpid(pid_streamoff, &wstatus_streamoff, WNOHANG); - kill(pid_dqbuf, SIGKILL); - fail_on_test(pid != pid_streamoff); - /* Test that the second child exited properly */ - if (!pid || !WIFEXITED(wstatus_streamoff)) { - kill(pid_streamoff, SIGKILL); - fail_on_test(!pid || !WIFEXITED(wstatus_streamoff)); - } + fail_on_test(!thread_streamoff.done); fail_on_test(node->streamoff(q.g_type())); fail_on_test(q.reqbufs(node, 0));
Signature · 3 lines
Regards, Laurent Pinchart