From e1239cc0467cc792b0ebc8d89d335532849e5e66 Mon Sep 17 00:00:00 2001 From: Benjamin Berg Date: Tue, 22 Feb 2022 12:05:43 +0100 Subject: [PATCH] Add umockdev based tests See https://github.com/libusb/libusb/pull/1078 --- ...-tests-Add-some-umockdev-based-tests.patch | 1038 +++++++++++++++++ libusb1.spec | 6 + tests/run.sh | 1 + 3 files changed, 1045 insertions(+) create mode 100644 0001-tests-Add-some-umockdev-based-tests.patch diff --git a/0001-tests-Add-some-umockdev-based-tests.patch b/0001-tests-Add-some-umockdev-based-tests.patch new file mode 100644 index 0000000..8aba02d --- /dev/null +++ b/0001-tests-Add-some-umockdev-based-tests.patch @@ -0,0 +1,1038 @@ +From 87976d513fbb35e13cbcd8cb00d2abc1cac0dd54 Mon Sep 17 00:00:00 2001 +From: Benjamin Berg +Date: Fri, 18 Feb 2022 16:26:29 +0100 +Subject: [PATCH 1/2] tests: Add some umockdev based tests + +Add some basic umockdev tests. The setup in this case is all in one +process, but umockdev in principle could also work between processes. + +This is just a start, more tests would make sense. +--- + configure.ac | 7 + + tests/Makefile.am | 13 +- + tests/umockdev.c | 965 ++++++++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 984 insertions(+), 1 deletion(-) + create mode 100644 tests/umockdev.c + +diff --git a/configure.ac b/configure.ac +index f6cf2f9..5336463 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -177,6 +177,12 @@ linux) + dnl system has udev. use it or fail! + AC_CHECK_HEADER([libudev.h], [], [AC_MSG_ERROR([udev support requested but libudev header not installed])]) + AC_CHECK_LIB([udev], [udev_new], [], [AC_MSG_ERROR([udev support requested but libudev not installed])]) ++ ++ # We can build umockdev tests (if available) ++ PKG_PROG_PKG_CONFIG ++ PKG_CHECK_MODULES(UMOCKDEV, umockdev-1.0 >= 0.16.0, ac_have_umockdev=yes, ac_have_umockdev=no) ++ AC_SUBST(UMOCKDEV_CFLAGS) ++ AC_SUBST(UMOCKDEV_LIBS) + else + AC_CHECK_HEADERS([asm/types.h]) + AC_CHECK_HEADER([linux/netlink.h], [], [AC_MSG_ERROR([Linux netlink header not found])]) +@@ -356,6 +362,7 @@ AC_ARG_ENABLE([tests-build], + + AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$build_examples" != xno]) + AM_CONDITIONAL([BUILD_TESTS], [test "x$build_tests" != xno]) ++AM_CONDITIONAL([BUILD_UMOCKDEV_TEST], [test "x$ac_have_umockdev" = xyes -a "x$log_enabled" != xno]) + AM_CONDITIONAL([CREATE_IMPORT_LIB], [test "x$create_import_lib" = xyes]) + AM_CONDITIONAL([OS_DARWIN], [test "x$backend" = xdarwin]) + AM_CONDITIONAL([OS_HAIKU], [test "x$backend" = xhaiku]) +diff --git a/tests/Makefile.am b/tests/Makefile.am +index cb8fad9..cf6237e 100644 +--- a/tests/Makefile.am ++++ b/tests/Makefile.am +@@ -2,6 +2,17 @@ AM_CPPFLAGS = -I$(top_srcdir)/libusb + LDADD = ../libusb/libusb-1.0.la + LIBS = + ++stress_SOURCES = stress.c libusb_testlib.h testlib.c ++ + noinst_PROGRAMS = stress + +-stress_SOURCES = stress.c libusb_testlib.h testlib.c ++if BUILD_UMOCKDEV_TEST ++# NOTE: We add libumockdev-preload.so so that we can run tests in-process ++# We also use -Wl,-lxxx as the compiler doesn't need it and libtool ++# would reorder the flags otherwise. ++umockdev_CPPFLAGS = ${UMOCKDEV_CFLAGS} -I$(top_srcdir)/libusb ++umockdev_LDFLAGS = -Wl,--push-state,--no-as-needed -Wl,-lumockdev-preload -Wl,--pop-state ${UMOCKDEV_LIBS} ++umockdev_SOURCES = umockdev.c ++ ++noinst_PROGRAMS += umockdev ++endif +diff --git a/tests/umockdev.c b/tests/umockdev.c +new file mode 100644 +index 0000000..c026b51 +--- /dev/null ++++ b/tests/umockdev.c +@@ -0,0 +1,965 @@ ++/* ++ * libusb umockdev based tests ++ * ++ * Copyright (C) 2022 Benjamin Berg ++ * ++ * 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 program; If not, see . ++ */ ++ ++#define _GNU_SOURCE ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "libusb.h" ++ ++#include "umockdev.h" ++ ++#define UNUSED_DATA __attribute__ ((unused)) gconstpointer unused_data ++ ++/* avoid leak reports inside assertions; leaking stuff on assertion failures does not matter in tests */ ++#if !defined(__clang__) ++#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak" ++#pragma GCC diagnostic ignored "-Wanalyzer-file-leak" ++#endif ++ ++typedef struct { ++ pid_t thread; ++ libusb_context *ctx; ++ enum libusb_log_level level; ++ char *str; ++} LogMessage; ++ ++static void ++log_message_free(LogMessage *msg) ++{ ++ g_free(msg->str); ++ g_free(msg); ++} ++G_DEFINE_AUTOPTR_CLEANUP_FUNC(LogMessage, log_message_free) ++ ++typedef struct _UsbChat UsbChat; ++ ++struct _UsbChat { ++ gboolean submit; ++ gboolean reap; ++ UsbChat *reaps; ++ UsbChat *next; ++ ++ /* struct usbdevfs_urb */ ++ unsigned char type; ++ unsigned char endpoint; ++ int status; ++ unsigned int flags; ++ const unsigned char *buffer; ++ int buffer_length; ++ int actual_length; ++ ++ /* */ ++ UMockdevIoctlData *submit_urb; ++}; ++ ++typedef struct { ++ UMockdevTestbed *testbed; ++ UMockdevIoctlBase *handler; ++ struct libusb_context *ctx; ++ ++ gchar *root_dir; ++ gchar *sys_dir; ++ ++ gboolean libusb_log_silence; ++ GList *libusb_log; ++ ++ UsbChat *chat; ++ GList *flying_urbs; ++ GList *discarded_urbs; ++ ++ /* GMutex confuses tsan unecessarily */ ++ pthread_mutex_t mutex; ++} UMockdevTestbedFixture; ++ ++/* Global for log handler */ ++static UMockdevTestbedFixture *cur_fixture = NULL; ++ ++static void ++log_handler(libusb_context *ctx, enum libusb_log_level level, const char *str) ++{ ++ /* May be called from different threads without synchronization! */ ++ LogMessage *msg; ++ pid_t tid = gettid(); ++ ++ g_assert (cur_fixture != NULL); ++ g_assert(pthread_mutex_lock(&cur_fixture->mutex) == 0); ++ ++ msg = g_new0(LogMessage, 1); ++ msg->ctx = ctx; ++ msg->level = level; ++ msg->str = g_strchomp (g_strdup(str)); ++ msg->thread = tid; ++ ++ if (!cur_fixture->libusb_log_silence) ++ g_printerr("%s\n", msg->str); ++ ++ cur_fixture->libusb_log = g_list_append(cur_fixture->libusb_log, msg); ++ pthread_mutex_unlock(&cur_fixture->mutex); ++} ++ ++static void ++log_handler_null(libusb_context *ctx, enum libusb_log_level level, const char *str) ++{ ++ (void) ctx; ++ (void) level; ++ (void) str; ++} ++ ++static void ++clear_libusb_log(UMockdevTestbedFixture * fixture, enum libusb_log_level level) ++{ ++ g_assert(pthread_mutex_lock(&fixture->mutex) == 0); ++ ++ while (fixture->libusb_log) { ++ LogMessage *msg = fixture->libusb_log->data; ++ ++ g_assert(msg->ctx == fixture->ctx); ++ ++ if (msg->level < level) { ++ pthread_mutex_unlock(&fixture->mutex); ++ return; ++ } ++ ++ fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); ++ log_message_free(msg); ++ } ++ pthread_mutex_unlock(&fixture->mutex); ++} ++ ++static void ++assert_libusb_log_msg(UMockdevTestbedFixture * fixture, enum libusb_log_level level, const char *re) ++{ ++ g_assert(pthread_mutex_lock(&fixture->mutex) == 0); ++ ++ while (fixture->libusb_log) { ++ g_autoptr(LogMessage) msg = NULL; ++ ++ if (fixture->libusb_log == NULL) ++ g_error ("No level %d message found searching for %s", level, re); ++ ++ msg = fixture->libusb_log->data; ++ fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); ++ ++ if (msg->ctx != fixture->ctx) ++ g_error ("Saw unexpected message \"%s\" from context %p while %p was expected", ++ msg->str, msg->ctx, fixture->ctx); ++ ++ if (msg->level == level && g_regex_match_simple(re, msg->str, 0, 0)) { ++ pthread_mutex_unlock(&fixture->mutex); ++ return; ++ } ++ ++ /* Allow skipping INFO and DEBUG messages */ ++ if (msg->level >= LIBUSB_LOG_LEVEL_INFO) ++ continue; ++ ++ g_error ("Searched for \"%s\" (%d) but found \"%s\" (%d)", re, level, msg->str, msg->level); ++ } ++ ++ pthread_mutex_unlock(&fixture->mutex); ++ g_error ("Searched for \"%s\" (%d) but no message matched", re, level); ++} ++ ++#if 0 ++static void ++assert_libusb_no_log_msg(UMockdevTestbedFixture * fixture, enum libusb_log_level level, const char *re) ++{ ++ g_assert(pthread_mutex_lock(&fixture->mutex) == 0); ++ ++ while (fixture->libusb_log) { ++ g_autoptr(LogMessage) msg = NULL; ++ gboolean matching; ++ ++ msg = fixture->libusb_log->data; ++ fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); ++ ++ g_assert(msg->ctx == fixture->ctx); ++ ++ matching = (msg->level == level && g_regex_match_simple(re, msg->str, 0, 0)); ++ ++ /* Allow skipping INFO and DEBUG messages */ ++ if (!matching && msg->level >= LIBUSB_LOG_LEVEL_INFO) ++ continue; ++ ++ g_error ("Asserting \"%s\" (%d) not logged and found \"%s\" (%d)", re, level, msg->str, msg->level); ++ } ++ ++ pthread_mutex_unlock(&fixture->mutex); ++} ++#endif ++ ++static void ++dump_buffer(const unsigned char *buffer, int len) ++{ ++ g_autoptr(GString) line = NULL; ++ ++ line = g_string_new (""); ++ for (gint i = 0; i < len; i++) { ++ g_string_append_printf(line, "%02x ", buffer[i]); ++ if ((i + 1) % 16 == 0) { ++ g_printerr(" %s\n", line->str); ++ g_string_set_size(line, 0); ++ } ++ } ++ ++ if (line->len) ++ g_printerr(" %s\n", line->str); ++} ++ ++static gint ++cmp_ioctl_data_addr(const void *data, const void *addr) ++{ ++ return ((const UMockdevIoctlData*) data)->client_addr != (gulong) addr; ++} ++ ++static gboolean ++handle_ioctl_cb (UMockdevIoctlBase *handler, UMockdevIoctlClient *client, UMockdevTestbedFixture *fixture) ++{ ++ UMockdevIoctlData *ioctl_arg; ++ long int request; ++ struct usbdevfs_urb *urb; ++ ++ (void) handler; ++ ++ request = umockdev_ioctl_client_get_request (client); ++ ioctl_arg = umockdev_ioctl_client_get_arg (client); ++ ++ /* NOTE: We share the address space, dereferencing pointers *will* work. ++ * However, to make tsan work, we still stick to the API that resolves ++ * the data into a local copy! */ ++ ++ switch (request) { ++ case USBDEVFS_GET_CAPABILITIES: { ++ g_autoptr(UMockdevIoctlData) d = NULL; ++ d = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(guint32), NULL); ++ ++ *(guint32*) d->data = USBDEVFS_CAP_BULK_SCATTER_GATHER | ++ USBDEVFS_CAP_BULK_CONTINUATION | ++ USBDEVFS_CAP_NO_PACKET_SIZE_LIM | ++ USBDEVFS_CAP_REAP_AFTER_DISCONNECT | ++ USBDEVFS_CAP_ZERO_PACKET; ++ ++ umockdev_ioctl_client_complete(client, 0, 0); ++ return TRUE; ++ } ++ ++ case USBDEVFS_CLAIMINTERFACE: ++ case USBDEVFS_RELEASEINTERFACE: ++ case USBDEVFS_CLEAR_HALT: ++ case USBDEVFS_RESET: ++ case USBDEVFS_RESETEP: ++ umockdev_ioctl_client_complete(client, 0, 0); ++ return TRUE; ++ ++ case USBDEVFS_SUBMITURB: { ++ g_autoptr(UMockdevIoctlData) urb_buffer = NULL; ++ g_autoptr(UMockdevIoctlData) urb_data = NULL; ++ gsize buflen; ++ ++ if (!fixture->chat || !fixture->chat->submit) ++ return FALSE; ++ ++ buflen = fixture->chat->buffer_length; ++ if (fixture->chat->type == USBDEVFS_URB_TYPE_CONTROL) ++ buflen = 8; ++ ++ urb_data = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(struct usbdevfs_urb), NULL); ++ urb = (struct usbdevfs_urb*) urb_data->data; ++ urb_buffer = umockdev_ioctl_data_resolve(urb_data, G_STRUCT_OFFSET(struct usbdevfs_urb, buffer), urb->buffer_length, NULL); ++ ++ if (fixture->chat->type == urb->type && ++ fixture->chat->endpoint == urb->endpoint && ++ fixture->chat->buffer_length == urb->buffer_length && ++ (fixture->chat->buffer == NULL || memcmp (fixture->chat->buffer, urb_buffer->data, buflen) == 0)) { ++ fixture->flying_urbs = g_list_append (fixture->flying_urbs, umockdev_ioctl_data_ref(urb_data)); ++ ++ if (fixture->chat->reaps) ++ fixture->chat->reaps->submit_urb = urb_data; ++ ++ if (fixture->chat->status) ++ umockdev_ioctl_client_complete(client, -1, -fixture->chat->status); ++ else ++ umockdev_ioctl_client_complete(client, 0, 0); ++ ++ if (fixture->chat->next) ++ fixture->chat = fixture->chat->next; ++ else ++ fixture->chat += 1; ++ return TRUE; ++ } ++ ++ /* chat message didn't match, don't accept it */ ++ g_printerr("Could not process submit urb:\n"); ++ g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", ++ urb->type, urb->endpoint, urb->actual_length, urb->buffer_length); ++ if (urb->type == USBDEVFS_URB_TYPE_CONTROL || urb->endpoint & LIBUSB_ENDPOINT_IN) ++ dump_buffer(urb->buffer, urb->buffer_length); ++ g_printerr("Looking for:\n"); ++ g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", ++ fixture->chat->type, fixture->chat->endpoint, ++ fixture->chat->actual_length, fixture->chat->buffer_length); ++ if (fixture->chat->buffer) ++ dump_buffer(fixture->chat->buffer, buflen); ++ ++ return FALSE; ++ } ++ ++ case USBDEVFS_REAPURB: ++ case USBDEVFS_REAPURBNDELAY: { ++ g_autoptr(UMockdevIoctlData) urb_ptr = NULL; ++ g_autoptr(UMockdevIoctlData) urb_data = NULL; ++ ++ if (fixture->discarded_urbs) { ++ urb_data = fixture->discarded_urbs->data; ++ urb = (struct usbdevfs_urb*) urb_data->data; ++ fixture->discarded_urbs = g_list_delete_link(fixture->discarded_urbs, fixture->discarded_urbs); ++ urb->status = -ENOENT; ++ ++ urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL); ++ umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data); ++ ++ umockdev_ioctl_client_complete(client, 0, 0); ++ return TRUE; ++ } ++ ++ if (fixture->chat && fixture->chat->reap) { ++ GList *l = g_list_find(fixture->flying_urbs, fixture->chat->submit_urb); ++ ++ if (l) { ++ fixture->flying_urbs = g_list_remove_link(fixture->flying_urbs, fixture->flying_urbs); ++ ++ urb_data = fixture->chat->submit_urb; ++ urb = (struct usbdevfs_urb*) urb_data->data; ++ urb->actual_length = fixture->chat->actual_length; ++ if (urb->type == USBDEVFS_URB_TYPE_CONTROL && urb->actual_length) ++ urb->actual_length -= 8; ++ if (fixture->chat->buffer) ++ memcpy(urb->buffer, fixture->chat->buffer, fixture->chat->actual_length); ++ urb->status = fixture->chat->status; ++ ++ urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL); ++ umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data); ++ if (fixture->chat->next) ++ fixture->chat = fixture->chat->next; ++ else ++ fixture->chat += 1; ++ umockdev_ioctl_client_complete(client, 0, 0); ++ return TRUE; ++ } ++ } ++ ++ /* Nothing to reap */ ++ umockdev_ioctl_client_complete(client, -1, EAGAIN); ++ return TRUE; ++ } ++ ++ case USBDEVFS_DISCARDURB: { ++ GList *l = g_list_find_custom(fixture->flying_urbs, *(void**) ioctl_arg->data, cmp_ioctl_data_addr); ++ ++ if (l) { ++ fixture->discarded_urbs = g_list_append(fixture->discarded_urbs, l->data); ++ fixture->flying_urbs = g_list_delete_link(fixture->flying_urbs, l); ++ umockdev_ioctl_client_complete(client, 0, 0); ++ } else { ++ umockdev_ioctl_client_complete(client, -1, EINVAL); ++ } ++ ++ return TRUE; ++ } ++ ++ default: ++ return FALSE; ++ } ++} ++ ++static void ++test_fixture_add_canon(UMockdevTestbedFixture * fixture) ++{ ++ /* Setup first, so we can be sure libusb_open works when the add uevent ++ * happens. ++ */ ++ g_assert_cmpint(umockdev_testbed_attach_ioctl(fixture->testbed, "/dev/bus/usb/001/001", fixture->handler, NULL), ==, 1); ++ ++ /* NOTE: add_device would not create a file, needed for device emulation */ ++ /* XXX: Racy, see https://github.com/martinpitt/umockdev/issues/173 */ ++ umockdev_testbed_add_from_string(fixture->testbed, ++ "P: /devices/usb1\n" ++ "N: bus/usb/001/001\n" ++ "E: SUBSYSTEM=usb\n" ++ "E: DRIVER=usb\n" ++ "E: BUSNUM=001\n" ++ "E: DEVNUM=001\n" ++ "E: DEVNAME=/dev/bus/usb/001/001\n" ++ "E: DEVTYPE=usb_device\n" ++ "A: bConfigurationValue=1\\n\n" ++ "A: busnum=1\\n\n" ++ "A: devnum=1\\n\n" ++ "A: bConfigurationValue=1\\n\n" ++ "A: speed=480\\n\n" ++ /* descriptor from a Canon PowerShot SX200; VID 04a9 PID 31c0 */ ++ "H: descriptors=" ++ "1201000200000040a904c03102000102" ++ "030109022700010100c0010904000003" ++ "06010100070581020002000705020200" ++ "020007058303080009\n", ++ NULL); ++} ++ ++static void ++test_fixture_setup_libusb(UMockdevTestbedFixture * fixture, int devcount) ++{ ++ libusb_device **devs = NULL; ++ ++ libusb_init (&fixture->ctx); ++ ++ /* Supress global log messages completely ++ * (though, in some tests it might be interesting to check there are no real ones). ++ */ ++ libusb_set_log_cb (NULL, log_handler_null, LIBUSB_LOG_CB_GLOBAL); ++ libusb_set_option (fixture->ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG); ++ g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, devcount); ++ libusb_free_device_list(devs, TRUE); ++ libusb_set_log_cb (fixture->ctx, log_handler, LIBUSB_LOG_CB_CONTEXT); ++} ++ ++static void ++test_fixture_setup_common(UMockdevTestbedFixture * fixture) ++{ ++ g_assert(cur_fixture == NULL); ++ cur_fixture = fixture; ++ ++ pthread_mutex_init(&fixture->mutex, NULL); ++ ++ fixture->testbed = umockdev_testbed_new(); ++ g_assert(fixture->testbed != NULL); ++ fixture->root_dir = umockdev_testbed_get_root_dir(fixture->testbed); ++ fixture->sys_dir = umockdev_testbed_get_sys_dir(fixture->testbed); ++ ++ fixture->handler = umockdev_ioctl_base_new(); ++ g_object_connect(fixture->handler, "signal-after::handle-ioctl", handle_ioctl_cb, fixture, NULL); ++} ++ ++#if 0 ++static void ++test_fixture_setup_empty(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ /* XXX: Racy, see https://github.com/martinpitt/umockdev/issues/173 */ ++ test_fixture_setup_common(fixture); ++ ++ test_fixture_setup_libusb(fixture, 0); ++} ++#endif ++ ++static void ++test_fixture_setup_with_canon(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ test_fixture_setup_common(fixture); ++ ++ test_fixture_add_canon(fixture); ++ ++ test_fixture_setup_libusb(fixture, 1); ++} ++ ++static void ++test_fixture_teardown(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ g_assert(cur_fixture == fixture); ++ ++ /* libusb_exit logs */ ++ if (fixture->ctx) ++ libusb_exit (fixture->ctx); ++ libusb_set_log_cb (NULL, NULL, LIBUSB_LOG_CB_GLOBAL); ++ cur_fixture = NULL; ++ ++ /* Abort if there are any warnings/errors in the log */ ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO); ++ fixture->ctx = NULL; ++ g_assert_null(fixture->libusb_log); ++ ++ g_clear_object(&fixture->handler); ++ g_clear_object(&fixture->testbed); ++ ++ /* verify that temp dir gets cleaned up properly */ ++ g_assert(!g_file_test(fixture->root_dir, G_FILE_TEST_EXISTS)); ++ g_free(fixture->root_dir); ++ g_free(fixture->sys_dir); ++ ++ while (fixture->flying_urbs) { ++ umockdev_ioctl_data_unref (fixture->flying_urbs->data); ++ fixture->flying_urbs = g_list_delete_link (fixture->flying_urbs, fixture->flying_urbs); ++ } ++ ++ pthread_mutex_destroy(&fixture->mutex); ++} ++ ++static void ++test_open_close(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ libusb_device **devs = NULL; ++ struct libusb_device_descriptor desc; ++ libusb_device_handle *handle = NULL; ++ ++ g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 1); ++ /* The linux_enumerate_device may happen from a different thread */ ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_list"); ++ /* We have exactly one device */ ++ g_assert_cmpint(libusb_get_bus_number(devs[0]), ==, 1); ++ g_assert_cmpint(libusb_get_device_address(devs[0]), ==, 1); ++ ++ /* Get/Check descriptor */ ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO); ++ libusb_get_device_descriptor (devs[0], &desc); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_descriptor"); ++ g_assert_cmpint(desc.idVendor, ==, 0x04a9); ++ g_assert_cmpint(desc.idProduct, ==, 0x31c0); ++ ++ /* Open and close */ ++ g_assert_cmpint(libusb_open(devs[0], &handle), ==, 0); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_add_event_source"); ++ g_assert_nonnull(handle); ++ libusb_close(handle); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_remove_event_source"); ++ ++ libusb_free_device_list(devs, TRUE); ++ ++ /* Open and close using vid/pid */ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ libusb_close(handle); ++} ++ ++static void ++test_close_flying(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ UsbChat chat[] = { ++ { ++ .submit = TRUE, ++ .type = USBDEVFS_URB_TYPE_BULK, ++ .endpoint = LIBUSB_ENDPOINT_OUT, ++ .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, ++ .buffer_length = 4, ++ }, ++ { .submit = FALSE } ++ }; ++ libusb_device_handle *handle = NULL; ++ struct libusb_transfer *transfer = NULL; ++ ++ fixture->chat = chat; ++ ++ /* Open */ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ transfer = libusb_alloc_transfer(0); ++ libusb_fill_bulk_transfer(transfer, ++ handle, ++ LIBUSB_ENDPOINT_OUT, ++ (unsigned char*) chat[0].buffer, ++ chat[0].buffer_length, ++ NULL, ++ NULL, ++ 1); ++ ++ /* Submit */ ++ libusb_submit_transfer(transfer); ++ ++ /* Closing logs fat error (two lines) */ ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ libusb_close(handle); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know"); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*cancellation hasn't even been scheduled"); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer"); ++ ++ /* Free'ing the transfer works, and logs to the right context */ ++ libusb_free_transfer(transfer); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[libusb_free_transfer\\]"); ++} ++ ++static void ++test_close_cancelled(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ UsbChat chat[] = { ++ { ++ .submit = TRUE, ++ .type = USBDEVFS_URB_TYPE_BULK, ++ .endpoint = LIBUSB_ENDPOINT_OUT, ++ .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, ++ .buffer_length = 4, ++ }, ++ { .submit = FALSE } ++ }; ++ libusb_device_handle *handle = NULL; ++ struct libusb_transfer *transfer = NULL; ++ ++ fixture->chat = chat; ++ ++ /* Open */ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ transfer = libusb_alloc_transfer(0); ++ libusb_fill_bulk_transfer(transfer, ++ handle, ++ LIBUSB_ENDPOINT_OUT, ++ (unsigned char*) chat[0].buffer, ++ chat[0].buffer_length, ++ NULL, ++ NULL, ++ 1); ++ ++ /* Submit */ ++ libusb_submit_transfer(transfer); ++ libusb_cancel_transfer(transfer); ++ ++ /* Closing logs fat error (two lines) */ ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ libusb_close(handle); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know"); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[do_close\\] .*cancellation.*hasn't completed"); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer"); ++ ++ libusb_free_transfer(transfer); ++} ++ ++static void ++test_ctx_destroy(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ UsbChat chat[] = { ++ { ++ .submit = TRUE, ++ .type = USBDEVFS_URB_TYPE_BULK, ++ .endpoint = LIBUSB_ENDPOINT_OUT, ++ .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, ++ .buffer_length = 4, ++ }, ++ { .submit = FALSE } ++ }; ++ libusb_device_handle *handle = NULL; ++ struct libusb_transfer *transfer = NULL; ++ ++ fixture->chat = chat; ++ ++ /* Open */ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ transfer = libusb_alloc_transfer(0); ++ libusb_fill_bulk_transfer(transfer, ++ handle, ++ LIBUSB_ENDPOINT_OUT, ++ (unsigned char*) chat[0].buffer, ++ chat[0].buffer_length, ++ NULL, ++ NULL, ++ 1); ++ ++ /* Submit */ ++ libusb_submit_transfer(transfer); ++ ++ /* Now we are evil and destroy the ctx! */ ++ libusb_exit(fixture->ctx); ++ ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] device.*still referenced"); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] application left some devices open"); ++ ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ fixture->ctx = NULL; ++ ++ /* XXX: Closing crashes the application as it unref's the NULL pointer */ ++ /* libusb_close(handle); */ ++ ++ libusb_free_transfer(transfer); ++} ++ ++static void ++test_get_string_descriptor(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ unsigned char data[255] = { 0, }; ++ libusb_device_handle *handle = NULL; ++ UsbChat chat[] = { ++ { ++ .submit = TRUE, ++ .reaps = &chat[1], ++ .type = USBDEVFS_URB_TYPE_CONTROL, ++ .buffer_length = 12, /* 8 byte out*/ ++ .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", ++ }, { ++ /* String with content 0x0409 (en_US) */ ++ .reap = TRUE, ++ .actual_length = 12, ++ .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00\x04\x03\x09\x04", ++ }, { ++ .submit = TRUE, ++ .reaps = &chat[3], ++ .type = USBDEVFS_URB_TYPE_CONTROL, ++ .buffer_length = 263, /* 8 byte out*/ ++ .buffer = (const unsigned char*) "\x80\x06\x01\x03\x09\x04\xff\x00", ++ }, { ++ /* 4 byte string, "ab" */ ++ .reap = TRUE, ++ .actual_length = 14, ++ .buffer = (const unsigned char*) "\x80\x06\x01\x03\x09\x04\xff\x00\x06\x03\x61\x00\x62\x00", ++ }, { ++ .submit = TRUE, ++ .reaps = &chat[5], ++ .type = USBDEVFS_URB_TYPE_CONTROL, ++ .buffer_length = 12, /* 8 byte out*/ ++ .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", ++ }, { ++ .reap = TRUE, ++ .status = -ENOENT, ++ }, { ++ .submit = TRUE, ++ .status = -ENOENT, ++ .type = USBDEVFS_URB_TYPE_CONTROL, ++ .buffer_length = 12, /* 8 byte out*/ ++ .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", ++ }, { ++ .submit = FALSE, ++ } ++ }; ++ ++ fixture->chat = chat; ++ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ /* The chat allows us to fetch the descriptor */ ++ g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, 2); ++ g_assert_cmpint(memcmp(data, "ab", 2), ==, 0); ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ ++ /* Again, but the URB fails with ENOENT when reaping */ ++ g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1); ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ ++ /* Again, but the URB fails to submit with ENOENT */ ++ g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1); ++ assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[submit_control_transfer\\] submiturb failed, errno=2"); ++ clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); ++ ++ libusb_close(handle); ++} ++ ++static void ++transfer_cb_inc_user_data(struct libusb_transfer *transfer) ++{ ++ *(int*)transfer->user_data += 1; ++} ++ ++static void ++test_timeout(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ UsbChat chat[] = { ++ { ++ .submit = TRUE, ++ .type = USBDEVFS_URB_TYPE_BULK, ++ .endpoint = LIBUSB_ENDPOINT_OUT, ++ .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, ++ .buffer_length = 4, ++ }, ++ { ++ .submit = FALSE, ++ } ++ }; ++ int completed = 0; ++ libusb_device_handle *handle = NULL; ++ struct libusb_transfer *transfer = NULL; ++ ++ fixture->chat = chat; ++ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ transfer = libusb_alloc_transfer(0); ++ libusb_fill_bulk_transfer(transfer, ++ handle, ++ LIBUSB_ENDPOINT_OUT, ++ (unsigned char*) chat[0].buffer, ++ chat[0].buffer_length, ++ transfer_cb_inc_user_data, ++ &completed, ++ 10); ++ ++ libusb_submit_transfer(transfer); ++ while (!completed) { ++ g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &completed), ==, 0); ++ /* Silence after one iteration. */ ++ fixture->libusb_log_silence = TRUE; ++ } ++ fixture->libusb_log_silence = FALSE; ++ ++ g_assert_cmpint(transfer->status, ==, LIBUSB_TRANSFER_TIMED_OUT); ++ libusb_free_transfer(transfer); ++ ++ libusb_close(handle); ++} ++ ++#define THREADED_SUBMIT_URB_SETS 64 ++#define THREADED_SUBMIT_URB_IN_FLIGHT 64 ++typedef struct { ++ struct libusb_transfer *transfers[THREADED_SUBMIT_URB_IN_FLIGHT * THREADED_SUBMIT_URB_SETS]; ++ int submitted; ++ int completed; ++ int done; ++ UMockdevTestbedFixture *fixture; ++} TestThreadedSubmit; ++ ++static gpointer ++transfer_submit_all_retry(TestThreadedSubmit *data) ++{ ++ for (guint i = 0; i < G_N_ELEMENTS(data->transfers); i++) { ++ while (libusb_submit_transfer(data->transfers[i]) < 0) { ++ assert_libusb_log_msg(data->fixture, LIBUSB_LOG_LEVEL_ERROR, "submit_bulk_transfer"); ++ continue; ++ } ++ ++ data->submitted += 1; ++ } ++ ++ return NULL; ++} ++ ++static void ++test_threaded_submit_transfer_cb(struct libusb_transfer *transfer) ++{ ++ TestThreadedSubmit *data = transfer->user_data; ++ ++ /* We should only be receiving packets in the main thread */ ++ g_assert_cmpint (getpid(), ==, gettid()); ++ ++ /* Check that the transfer buffer has the expected value */ ++ g_assert_cmpint (*(int*)transfer->buffer, ==, data->completed); ++ data->completed += 1; ++ ++ if (data->completed == G_N_ELEMENTS(data->transfers)) ++ data->done = TRUE; ++} ++ ++static void ++test_threaded_submit(UMockdevTestbedFixture * fixture, UNUSED_DATA) ++{ ++ GThread *thread = NULL; ++ TestThreadedSubmit data = { .fixture = fixture }; ++ UsbChat out_msg = { ++ .submit = TRUE, ++ .type = USBDEVFS_URB_TYPE_BULK, ++ .endpoint = LIBUSB_ENDPOINT_IN, ++ .buffer_length = sizeof(int), ++ }; ++ UsbChat in_msg = { ++ .reap = TRUE, ++ .actual_length = 4, ++ }; ++ UsbChat *c; ++ libusb_device_handle *handle = NULL; ++ int urb; ++ ++ handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); ++ g_assert_nonnull(handle); ++ ++ fixture->libusb_log_silence = TRUE; ++ ++ c = fixture->chat = g_new0(UsbChat, G_N_ELEMENTS(data.transfers) * 2 + 1); ++ urb = 0; ++ for (int i = 0; i < THREADED_SUBMIT_URB_SETS; i++) { ++ for (int j = 0; j < THREADED_SUBMIT_URB_IN_FLIGHT; j++) { ++ c[i*2*THREADED_SUBMIT_URB_IN_FLIGHT + j] = out_msg; ++ c[i*2*THREADED_SUBMIT_URB_IN_FLIGHT + j].reaps = &c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j]; ++ c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j] = in_msg; ++ c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer = (unsigned char*) g_new0(int, 1); ++ *(int*) c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer = urb; ++ ++ data.transfers[urb] = libusb_alloc_transfer(0); ++ libusb_fill_bulk_transfer(data.transfers[urb], ++ handle, ++ LIBUSB_ENDPOINT_IN, ++ g_malloc(out_msg.buffer_length), ++ out_msg.buffer_length, ++ test_threaded_submit_transfer_cb, ++ &data, ++ G_MAXUINT); ++ data.transfers[urb]->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER; ++ urb++; ++ } ++ } ++ ++ thread = g_thread_new("transfer all", (GThreadFunc) transfer_submit_all_retry, &data); ++ ++ while (!data.done) ++ g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &data.done), ==, 0); ++ ++ g_thread_join(thread); ++ ++ fixture->libusb_log_silence = FALSE; ++ libusb_close(handle); ++ ++ for (int i = 0; i < 2 * THREADED_SUBMIT_URB_SETS * THREADED_SUBMIT_URB_SETS; i++) ++ g_clear_pointer ((void**) &c->buffer, g_free); ++ g_free (c); ++} ++ ++int ++main(int argc, char **argv) ++{ ++ g_test_init(&argc, &argv, NULL); ++ ++ g_test_add("/libusb/open-close", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_open_close, ++ test_fixture_teardown); ++ ++ g_test_add("/libusb/close-flying", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_close_flying, ++ test_fixture_teardown); ++ g_test_add("/libusb/close-cancelled", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_close_cancelled, ++ test_fixture_teardown); ++ ++ g_test_add("/libusb/ctx-destroy", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_ctx_destroy, ++ test_fixture_teardown); ++ ++ g_test_add("/libusb/string-descriptor", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_get_string_descriptor, ++ test_fixture_teardown); ++ ++ g_test_add("/libusb/timeout", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_timeout, ++ test_fixture_teardown); ++ ++ g_test_add("/libusb/threaded-submit", UMockdevTestbedFixture, NULL, ++ test_fixture_setup_with_canon, ++ test_threaded_submit, ++ test_fixture_teardown); ++ ++ return g_test_run(); ++} +-- +2.35.1 + diff --git a/libusb1.spec b/libusb1.spec index 901fbd2..0602138 100644 --- a/libusb1.spec +++ b/libusb1.spec @@ -6,6 +6,7 @@ Source0: https://github.com/libusb/libusb/releases/download/v%{version}/l License: LGPLv2+ URL: http://libusb.info BuildRequires: systemd-devel doxygen libtool +BuildRequires: umockdev-devel BuildRequires: make BuildRequires: gcc # libusbx was removed in F34 @@ -17,6 +18,8 @@ Obsoletes: libusbx < %{version}-%{release} Patch0001: https://github.com/libusb/libusb/pull/1058.patch # Fix a crash if a transfer outlives closing the device Patch0002: https://github.com/libusb/libusb/pull/1073.patch +# Add umockdev based tests from https://github.com/libusb/libusb/pull/1078 +Patch0003: 0001-tests-Add-some-umockdev-based-tests.patch %description This package provides a way for applications to access USB devices. @@ -82,6 +85,7 @@ popd %{make_install} mkdir -p $RPM_BUILD_ROOT%{_bindir} install -m 755 tests/.libs/stress $RPM_BUILD_ROOT%{_bindir}/libusb-test-stress +install -m 755 tests/.libs/umockdev $RPM_BUILD_ROOT%{_bindir}/libusb-test-umockdev install -m 755 examples/.libs/testlibusb \ $RPM_BUILD_ROOT%{_bindir}/libusb-test-libusb # Some examples are very device-specific / require specific hw and miss --help @@ -96,6 +100,7 @@ rm $RPM_BUILD_ROOT%{_libdir}/*.la %check LD_LIBRARY_PATH=libusb/.libs ldd $RPM_BUILD_ROOT%{_bindir}/libusb-test-stress LD_LIBRARY_PATH=libusb/.libs $RPM_BUILD_ROOT%{_bindir}/libusb-test-stress +LD_LIBRARY_PATH=libusb/.libs $RPM_BUILD_ROOT%{_bindir}/libusb-test-umockdev LD_LIBRARY_PATH=libusb/.libs $RPM_BUILD_ROOT%{_bindir}/libusb-test-libusb LD_LIBRARY_PATH=libusb/.libs $RPM_BUILD_ROOT%{_bindir}/libusb-example-listdevs @@ -121,6 +126,7 @@ LD_LIBRARY_PATH=libusb/.libs $RPM_BUILD_ROOT%{_bindir}/libusb-example-listdevs %{_bindir}/libusb-example-listdevs %{_bindir}/libusb-example-xusb %{_bindir}/libusb-test-stress +%{_bindir}/libusb-test-umockdev %{_bindir}/libusb-test-libusb diff --git a/tests/run.sh b/tests/run.sh index 440092c..36c9ae3 100644 --- a/tests/run.sh +++ b/tests/run.sh @@ -4,5 +4,6 @@ set -e ldd /usr/bin/libusb-test-stress /usr/bin/libusb-test-stress +/usr/bin/libusb-test-umockdev /usr/bin/libusb-test-libusb /usr/bin/libusb-example-listdevs