Changeset 9d9ffdd in mainline for uspace/lib/usb/src/debug.c

Timestamp:

2011-03-11T15:42:43Z (14 years ago)

Author:

Matej Klonfar <maklf@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0bd4810c

Parents:

60a228f (diff), a8def7d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge with hidd

File:

• uspace/lib/usb/src/debug.c (modified) (4 diffs)

uspace/lib/usb/src/debug.c

@@ -31 +31 @@
  */
 /** @file
- * @brief Debugging support.
+ * Debugging and logging support.
  */
 #include <adt/list.h>
@@ -40 +40 @@
 #include <usb/debug.h>
 
-/** Debugging tag. */
-typedef struct {
-        /** Linked list member. */
-        link_t link;
-        /** Tag name.
-         * We always have a private copy of the name.
-         */
-        char *tag;
-        /** Enabled level of debugging. */
-        int level;
-} usb_debug_tag_t;
-
-/** Get instance of usb_debug_tag_t from link_t. */
-#define USB_DEBUG_TAG_INSTANCE(iterator) \
-        list_get_instance(iterator, usb_debug_tag_t, link)
-
-/** List of all known tags. */
-static LIST_INITIALIZE(tag_list);
-/** Mutex guard for the list of all tags. */
-static FIBRIL_MUTEX_INITIALIZE(tag_list_guard);
-
 /** Level of logging messages. */
 static usb_log_level_t log_level = USB_LOG_LEVEL_WARNING;
+
 /** Prefix for logging messages. */
 static const char *log_prefix = "usb";
+
 /** Serialization mutex for logging functions. */
 static FIBRIL_MUTEX_INITIALIZE(log_serializer);
+
+/** File where to store the log. */
 static FILE *log_stream = NULL;
 
-/** Find or create new tag with given name.
- *
- * @param tagname Tag name.
- * @return Debug tag structure.
- * @retval NULL Out of memory.
- */
-static usb_debug_tag_t *get_tag(const char *tagname)
-{
-        link_t *link;
-        for (link = tag_list.next; \
-            link != &tag_list; \
-            link = link->next) {
-                usb_debug_tag_t *tag = USB_DEBUG_TAG_INSTANCE(link);
-                if (str_cmp(tag->tag, tagname) == 0) {
-                        return tag;
-                }
-        }
-
-        /*
-         * Tag not found, we will create a new one.
-         */
-        usb_debug_tag_t *new_tag = malloc(sizeof(usb_debug_tag_t));
-        int rc = asprintf(&new_tag->tag, "%s", tagname);
-        if (rc < 0) {
-                free(new_tag);
-                return NULL;
-        }
-        list_initialize(&new_tag->link);
-        new_tag->level = 1;
-
-        /*
-         * Append it to the end of known tags.
-         */
-        list_append(&new_tag->link, &tag_list);
-
-        return new_tag;
-}
-
-/** Print debugging information.
- * If the tag is used for the first time, its structures are automatically
- * created and initial verbosity level is set to 1.
- *
- * @param tagname Tag name.
- * @param level Level (verbosity) of the message.
- * @param format Formatting string for printf().
- */
-void usb_dprintf(const char *tagname, int level, const char *format, ...)
-{
-        fibril_mutex_lock(&tag_list_guard);
-        usb_debug_tag_t *tag = get_tag(tagname);
-        if (tag == NULL) {
-                printf("USB debug: FATAL ERROR - failed to create tag.\n");
-                goto leave;
-        }
-
-        if (tag->level < level) {
-                goto leave;
-        }
-
-        va_list args;
-        va_start(args, format);
-
-        printf("[%s:%d]: ", tagname, level);
-        vprintf(format, args);
-
-        va_end(args);
-
-leave:
-        fibril_mutex_unlock(&tag_list_guard);
-}
-
-/** Enable debugging prints for given tag.
- *
- * Setting level to <i>n</i> will cause that only printing messages
- * with level lower or equal to <i>n</i> will be printed.
- *
- * @param tagname Tag name.
- * @param level Enabled level.
- */
-void usb_dprintf_enable(const char *tagname, int level)
-{
-        fibril_mutex_lock(&tag_list_guard);
-        usb_debug_tag_t *tag = get_tag(tagname);
-        if (tag == NULL) {
-                printf("USB debug: FATAL ERROR - failed to create tag.\n");
-                goto leave;
-        }
-
-        tag->level = level;
-
-leave:
-        fibril_mutex_unlock(&tag_list_guard);
-}
 
 /** Enable logging.
@@ -182 +72 @@
 }
 
-
+/** Get log level name prefix.
+ *
+ * @param level Log level.
+ * @return String prefix for the message.
+ */
 static const char *log_level_name(usb_log_level_t level)
 {
@@ -252 +146 @@
 }
 
+
+#define REMAINDER_STR_FMT " (%zu)..."
+/* string + terminator + number width (enough for 4GB)*/
+#define REMAINDER_STR_LEN (5 + 1 + 10)
+
+/** How many bytes to group together. */
+#define BUFFER_DUMP_GROUP_SIZE 4
+
+/** Size of the string for buffer dumps. */
+#define BUFFER_DUMP_LEN 240 /* Ought to be enough for everybody ;-). */
+
+/** Fibril local storage for the dumped buffer. */
+static fibril_local char buffer_dump[BUFFER_DUMP_LEN];
+
+/** Dump buffer into string.
+ *
+ * The function dumps given buffer into hexadecimal format and stores it
+ * in a static fibril local string.
+ * That means that you do not have to deallocate the string (actually, you
+ * can not do that) and you do not have to guard it against concurrent
+ * calls to it.
+ * The only limitation is that each call rewrites the buffer again.
+ * Thus, it is necessary to copy the buffer elsewhere (that includes printing
+ * to screen or writing to file).
+ * Since this function is expected to be used for debugging prints only,
+ * that is not a big limitation.
+ *
+ * @warning You cannot use this function twice in the same printf
+ * (see detailed explanation).
+ *
+ * @param buffer Buffer to be printed (can be NULL).
+ * @param size Size of the buffer in bytes (can be zero).
+ * @param dumped_size How many bytes to actually dump (zero means all).
+ * @return Dumped buffer as a static (but fibril local) string.
+ */
+const char *usb_debug_str_buffer(const uint8_t *buffer, size_t size,
+    size_t dumped_size)
+{
+        /*
+         * Remove previous string (that might also reveal double usage of
+         * this function).
+         */
+        bzero(buffer_dump, BUFFER_DUMP_LEN);
+
+        if (buffer == NULL) {
+                return "(null)";
+        }
+        if (size == 0) {
+                return "(empty)";
+        }
+        if ((dumped_size == 0) || (dumped_size > size)) {
+                dumped_size = size;
+        }
+
+        /* How many bytes are available in the output buffer. */
+        size_t buffer_remaining_size = BUFFER_DUMP_LEN - 1 - REMAINDER_STR_LEN;
+        char *it = buffer_dump;
+
+        size_t index = 0;
+
+        while (index < size) {
+                /* Determine space before the number. */
+                const char *space_before;
+                if (index == 0) {
+                        space_before = "";
+                } else if ((index % BUFFER_DUMP_GROUP_SIZE) == 0) {
+                        space_before = "  ";
+                } else {
+                        space_before = " ";
+                }
+
+                /*
+                 * Add the byte as a hexadecimal number plus the space.
+                 * We do it into temporary buffer to ensure that always
+                 * the whole byte is printed.
+                 */
+                int val = buffer[index];
+                char current_byte[16];
+                int printed = snprintf(current_byte, 16,
+                    "%s%02x", space_before, val);
+                if (printed < 0) {
+                        break;
+                }
+
+                if ((size_t) printed > buffer_remaining_size) {
+                        break;
+                }
+
+                /* We can safely add 1, because space for end 0 is reserved. */
+                str_append(it, buffer_remaining_size + 1, current_byte);
+
+                buffer_remaining_size -= printed;
+                /* Point at the terminator 0. */
+                it += printed;
+                index++;
+
+                if (index >= dumped_size) {
+                        break;
+                }
+        }
+
+        /* Add how many bytes were not printed. */
+        if (index < size) {
+                snprintf(it, REMAINDER_STR_LEN,
+                    REMAINDER_STR_FMT, size - index);
+        }
+
+        return buffer_dump;
+}
+
+
 /**
  * @}