Changeset 26684

Timestamp:

07/30/08 06:03:22 (4 months ago)

Author:

axeld

Message:

* Made struct ring_buffer public (within the kernel).
* Added "syslog" command that dumps the contents of the syslog ring buffer into

KDL. Use the '-n' option to only show what hasn't been sent to the syslog
daemon yet.

* When entering the kernel debugger, the current thread ID and name are also

printed (not only the current CPU).

Location:

haiku/trunk

Files:

• headers/private/kernel/util/ring_buffer.h (modified) (1 diff)
• src/system/kernel/debug/debug.cpp (modified) (5 diffs)
• src/system/kernel/util/ring_buffer.cpp (modified) (3 diffs)

haiku/trunk/headers/private/kernel/util/ring_buffer.h

@@ -10 +10 @@
 
 
-struct ring_buffer;
+struct ring_buffer {
+        int32           first;
+        int32           in;
+        int32           size;
+        uint8           buffer[0];
+};
+
 
 #ifdef __cplusplus

haiku/trunk/src/system/kernel/debug/debug.cpp

@@ -1 +1 @@
 /*
- * Copyright 2002-2008, Axel Dörfler, axeld@pinc-software.de
+ * Copyright 2002-2008, Axel Dörfler, axeld@pinc-software.de.
  * Distributed under the terms of the MIT License.
  *
@@ -651 +651 @@
         sDebuggerOnCPU = smp_get_current_cpu();
 
-        // set a few temporary debug variables
+        kprintf("Welcome to Kernel Debugging Land...\n");
+
         if (struct thread* thread = thread_get_current_thread()) {
+                // set a few temporary debug variables
                 set_debug_variable("_thread", (uint64)(addr_t)thread);
                 set_debug_variable("_threadID", thread->id);
@@ -658 +660 @@
                 set_debug_variable("_teamID", thread->team->id);
                 set_debug_variable("_cpu", sDebuggerOnCPU);
-        }
-
-        kprintf("Welcome to Kernel Debugging Land...\n");
-        kprintf("Running on CPU %ld\n", sDebuggerOnCPU);
+
+                kprintf("Thread %ld \"%s\" running on CPU %ld\n", thread->id,
+                        thread->name, sDebuggerOnCPU);
+        } else
+                kprintf("Running on CPU %ld\n", sDebuggerOnCPU);
 
         int32 continuableLine = -1;
@@ -719 +722 @@
 
 
+static int
+cmd_dump_syslog(int argc, char **argv)
+{
+        if (!sSyslogOutputEnabled) {
+                kprintf("Syslog is not enabled.\n");
+                return 0;
+        }
+
+        bool currentOnly = false;
+        if (argc > 1) {
+                if (!strcmp(argv[1], "-n"))
+                        currentOnly = true;
+                else {
+                        print_debugger_command_usage(argv[0]);
+                        return 0;
+                }
+        }
+
+        uint32 start = sSyslogBuffer->first;
+        size_t end = start + sSyslogBuffer->in;
+        if (!currentOnly) {
+                // Start the buffer after the current end (we don't really know if
+                // this part has been written to already).
+                start = (start + sSyslogBuffer->in) % sSyslogBuffer->size;
+                end = start + sSyslogBuffer->size;
+        } else if (!ring_buffer_readable(sSyslogBuffer)) {
+                kprintf("Syslog is empty.\n");
+                return 0;
+        }
+
+        // break it down to lines to make it grep'able
+
+        bool newLine = false;
+        char line[256];
+        size_t linePos = 0;
+        for (int32 i = start; i < end; i++) {
+                char c = sSyslogBuffer->buffer[i % sSyslogBuffer->size];
+                if (c == '\0' || (uint8)c == 0xcc)
+                        continue;
+
+                line[linePos++] = c;
+                newLine = false;
+
+                if (c == '\n' || linePos == sizeof(line) - 1) {
+                        newLine = c == '\n';
+                        line[linePos] = '\0';
+                        linePos = 0;
+                        kprintf(line);
+                }
+        }
+        if (!newLine)
+                kprintf("\n");
+
+        return 0;
+}
+
+
 static status_t
 syslog_sender(void *data)
@@ -880 +940 @@
                 get_haiku_revision());
         syslog_write(revisionBuffer, length);
+
+        add_debugger_command_etc("syslog", &cmd_dump_syslog,
+                "Dumps the syslog buffer.\n",
+                "[-n]\nDumps the whole syslog buffer, or, if -n is specified, only "
+                "the part that hasn't been send yet.\n", 0);
         return B_OK;
 

haiku/trunk/src/system/kernel/util/ring_buffer.cpp

@@ -1 +1 @@
 /*
- * Copyright 2005-2006, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Copyright 2005-2008, Axel Dörfler, axeld@pinc-software.de.
  * Distributed under the terms of the MIT License.
  */
@@ -19 +19 @@
 #endif
 
-/**     This is a light-weight ring_buffer implementation.
+/*!     This is a light-weight ring_buffer implementation.
  *      It does not provide any locking - you are supposed to ensure thread-safety
  *      with the restrictions you choose. Unless you are passing in unsafe buffers,
@@ -26 +26 @@
  *      They also don't use malloc() or any kind of locking after initialization.
  */
-
-struct ring_buffer {
-        int32           first;
-        int32           in;
-        int32           size;
-        uint8           buffer[0];
-};