Changes in / [50cd285:72cd53d] in mainline

Files:

• HelenOS.config (modified) (1 diff)
• uspace/app/lsusb/main.c (modified) (2 diffs)
• uspace/drv/usbhid/main.c (modified) (1 diff)
• uspace/drv/vhc/conndev.c (modified) (3 diffs)
• uspace/drv/vhc/transfer.c (modified) (4 diffs)
• uspace/lib/c/generic/devman.c (modified) (1 diff)
• uspace/lib/usb/include/usb/debug.h (modified) (1 diff)
• uspace/lib/usb/src/debug.c (modified) (2 diffs)
• uspace/lib/usbvirt/include/usbvirt/ipc.h (modified) (1 diff)

HelenOS.config

@@ -555 +555 @@
 ! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
 
+# USB settings 
+
+% USB release build (less logging)
+! CONFIG_USB_RELEASE_BUILD (n/y)
+
 % Start virtual USB host controller
 ! CONFIG_RUN_VIRTUAL_USB_HC (n/y)

uspace/app/lsusb/main.c

@@ -49 +49 @@
 #define NAME "lsusb"
 
+#define MAX_USB_ADDRESS USB11_ADDRESS_MAX
 #define MAX_FAILED_ATTEMPTS 10
 #define MAX_PATH_LENGTH 1024
@@ -76 +77 @@
         }
         usb_address_t addr;
-        for (addr = 1; addr < 5; addr++) {
+        for (addr = 1; addr < MAX_USB_ADDRESS; addr++) {
                 devman_handle_t dev_handle;
                 rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);

uspace/drv/usbhid/main.c

@@ -202 +202 @@
         printf(NAME ": HelenOS USB HID driver.\n");
 
-        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
+        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
 
         return usb_driver_main(&usb_hid_driver);

uspace/drv/vhc/conndev.c

@@ -37 +37 @@
 #include <errno.h>
 #include <ddf/driver.h>
+#include <usbvirt/ipc.h>
 #include "conn.h"
 
 static fibril_local uintptr_t plugged_device_handle = 0;
+#define PLUGGED_DEVICE_NAME_MAXLEN 256
+static fibril_local char plugged_device_name[PLUGGED_DEVICE_NAME_MAXLEN + 1] = "<unknown>";
+
+/** Receive device name.
+ *
+ * @warning Errors are silently ignored.
+ *
+ * @param phone Phone to the virtual device.
+ */
+static void receive_device_name(int phone)
+{
+        aid_t opening_request = async_send_0(phone, IPC_M_USBVIRT_GET_NAME, NULL);
+        if (opening_request == 0) {
+                return;
+        }
+
+
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(phone,
+             plugged_device_name, PLUGGED_DEVICE_NAME_MAXLEN,
+             &data_request_call);
+
+        if (data_request == 0) {
+                async_wait_for(opening_request, NULL);
+                return;
+        }
+
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(opening_request, &opening_request_rc);
+
+        if ((data_request_rc != EOK) || (opening_request_rc != EOK)) {
+                return;
+        }
+
+        size_t len = IPC_GET_ARG2(data_request_call);
+        plugged_device_name[len] = 0;
+}
 
 /** Default handler for IPC methods not handled by DDF.
@@ -65 +105 @@
                 async_answer_0(icallid, EOK);
 
-                usb_log_info("New virtual device `%s' (id = %" PRIxn ").\n",
-                    rc == EOK ? "XXX" : "<unknown>", plugged_device_handle);
+                receive_device_name(callback);
+
+                usb_log_info("New virtual device `%s' (id: %" PRIxn ").\n",
+                    plugged_device_name, plugged_device_handle);
 
                 return;
@@ -85 +127 @@
 
         if (plugged_device_handle != 0) {
-                usb_log_info("Virtual device disconnected (id = %" PRIxn ").\n",
-                    plugged_device_handle);
+                usb_log_info("Virtual device `%s' disconnected (id: %" PRIxn ").\n",
+                    plugged_device_name, plugged_device_handle);
                 vhc_virtdev_unplug(vhc, plugged_device_handle);
         }

uspace/drv/vhc/transfer.c

@@ -161 +161 @@
 }
 
+static vhc_transfer_t *dequeue_first_transfer(vhc_virtdev_t *dev)
+{
+        assert(fibril_mutex_is_locked(&dev->guard));
+        assert(!list_empty(&dev->transfer_queue));
+
+        vhc_transfer_t *transfer = list_get_instance(dev->transfer_queue.next,
+            vhc_transfer_t, link);
+        list_remove(&transfer->link);
+
+        return transfer;
+}
+
+
+static void execute_transfer_callback_and_free(vhc_transfer_t *transfer,
+    size_t data_transfer_size, int outcome)
+{
+        assert(outcome != ENAK);
+
+        usb_log_debug2("Transfer %p ended: %s.\n",
+            transfer, str_error(outcome));
+
+        if (transfer->direction == USB_DIRECTION_IN) {
+                transfer->callback_in(transfer->ddf_fun, outcome,
+                    data_transfer_size, transfer->callback_arg);
+        } else {
+                assert(transfer->direction == USB_DIRECTION_OUT);
+                transfer->callback_out(transfer->ddf_fun, outcome,
+                    transfer->callback_arg);
+        }
+
+        free(transfer);
+}
 
 int vhc_transfer_queue_processor(void *arg)
@@ -174 +206 @@
                 }
 
-                vhc_transfer_t *transfer = list_get_instance(dev->transfer_queue.next,
-                    vhc_transfer_t, link);
-                list_remove(&transfer->link);
+                vhc_transfer_t *transfer = dequeue_first_transfer(dev);
                 fibril_mutex_unlock(&dev->guard);
 
@@ -214 +244 @@
 
                 if (rc != ENAK) {
-                        usb_log_debug2("Transfer %p ended: %s.\n",
-                            transfer, str_error(rc));
-                        if (transfer->direction == USB_DIRECTION_IN) {
-                                transfer->callback_in(transfer->ddf_fun, rc,
-                                    data_transfer_size, transfer->callback_arg);
-                        } else {
-                                assert(transfer->direction == USB_DIRECTION_OUT);
-                                transfer->callback_out(transfer->ddf_fun, rc,
-                                    transfer->callback_arg);
-                        }
-                        free(transfer);
+                        execute_transfer_callback_and_free(transfer,
+                            data_transfer_size, rc);
                 }
 
@@ -231 +252 @@
         }
 
+        /* Immediately fail all remaining transfers. */
+        while (!list_empty(&dev->transfer_queue)) {
+                vhc_transfer_t *transfer = dequeue_first_transfer(dev);
+                execute_transfer_callback_and_free(transfer, 0, EBADCHECKSUM);
+        }
+
         fibril_mutex_unlock(&dev->guard);
 
-        // TODO - destroy pending transfers
-
         return EOK;
 }

uspace/lib/c/generic/devman.c

@@ -415 +415 @@
         }
 
+        /* To be on the safe-side. */
         path[path_size - 1] = 0;
 
-        if (IPC_GET_ARG2(data_request_call) >= path_size) {
+        size_t transferred_size = IPC_GET_ARG2(data_request_call);
+
+        if (transferred_size >= path_size) {
                 return ELIMIT;
         }
+
+        /* Terminate the string (trailing 0 not send over IPC). */
+        path[transferred_size] = 0;
 
         return EOK;

uspace/lib/usb/include/usb/debug.h

@@ -81 +81 @@
 
 /** Default log level. */
-#define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
-
+#ifdef CONFIG_USB_RELEASE_BUILD
+#  define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_INFO
+#else
+#  define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
+#endif
 
 void usb_log_enable(usb_log_level_t, const char *);

uspace/lib/usb/src/debug.c

@@ -116 +116 @@
         /*
          * Serialize access to log files.
-         * Always print to log file, to screen print only when the enabled
-         * log level is high enough.
+         * Print to screen only messages with higher level than the one
+         * specified during logging initialization.
+         * Print also to file, to it print one more (lower) level as well.
          */
         fibril_mutex_lock(&log_serializer);
@@ -123 +124 @@
         const char *level_name = log_level_name(level);
 
-        if (log_stream != NULL) {
+        if ((log_stream != NULL) && (level <= log_level + 1)) {
                 va_start(args, format);
 

uspace/lib/usbvirt/include/usbvirt/ipc.h

@@ -39 +39 @@
 #include <usb/usb.h>
 #include <bool.h>
+#include <usbvirt/device.h>
 
 /** IPC methods communication between host controller and virtual device. */