Changeset 04c418d in mainline for uspace/app

Timestamp:

2011-05-17T07:58:39Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

7d521e24

Parents:

e913cc9 (diff), 3375bd4 (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 development/ changes

Location:

uspace/app

Files:

• init/Makefile (modified) (1 diff)
• klog/klog.c (modified) (4 diffs)
• stats/stats.c (modified) (1 diff)
• tester/Makefile (modified) (1 diff)
• tester/mm/malloc2.c (added)
• tester/mm/malloc2.def (added)
• tester/tester.c (modified) (1 diff)
• tester/tester.h (modified) (1 diff)
• top/screen.c (modified) (2 diffs)
• vuhid/device.c (modified) (1 diff)

uspace/app/init/Makefile

@@ -30 +30 @@
 USPACE_PREFIX = ../..
 BINARY = init
+STATIC_NEEDED = y
 
 SOURCES = \

uspace/app/klog/klog.c

@@ -44 +44 @@
 #include <io/klog.h>
 #include <sysinfo.h>
+#include <malloc.h>
 #include <fibril_synch.h>
+#include <adt/list.h>
+#include <adt/prodcons.h>
 
 #define NAME       "klog"
 #define LOG_FNAME  "/log/klog"
+
+/* Producer/consumer buffers */
+typedef struct {
+        link_t link;
+        size_t length;
+        wchar_t *data;
+} item_t;
+
+static prodcons_t pc;
 
 /* Pointer to klog area */
@@ -53 +65 @@
 static size_t klog_length;
 
-static FILE *log;
-
-/* Serialize the output a bit. This will not avoid messed-up log completely
-   but chances for are pretty high (experimentally confirmed). */
-static FIBRIL_MUTEX_INITIALIZE(log_mutex);
-
-static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
-{
-        fibril_mutex_lock(&log_mutex);
+/* Notification mutex */
+static FIBRIL_MUTEX_INITIALIZE(mtx);
+
+/** Klog producer
+ *
+ * Copies the contents of a character buffer to local
+ * producer/consumer queue.
+ *
+ * @param length Number of characters to copy.
+ * @param data   Pointer to the kernel klog buffer.
+ *
+ */
+static void producer(size_t length, wchar_t *data)
+{
+        item_t *item = (item_t *) malloc(sizeof(item_t));
+        if (item == NULL)
+                return;
+        
+        size_t sz = sizeof(wchar_t) * length;
+        wchar_t *buf = (wchar_t *) malloc(sz);
+        if (data == NULL) {
+                free(item);
+                return;
+        }
+        
+        memcpy(buf, data, sz);
+        
+        link_initialize(&item->link);
+        item->length = length;
+        item->data = buf;
+        prodcons_produce(&pc, &item->link);
+}
+
+/** Klog consumer
+ *
+ * Waits in an infinite loop for the character data created by
+ * the producer and outputs them to stdout and optionally into
+ * a file.
+ *
+ * @param data Unused.
+ *
+ * @return Always EOK (unreachable).
+ *
+ */
+static int consumer(void *data)
+{
+        FILE *log = fopen(LOG_FNAME, "a");
+        if (log == NULL)
+                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
+                    str_error(errno));
+        
+        while (true) {
+                link_t *link = prodcons_consume(&pc);
+                item_t *item = list_get_instance(link, item_t, link);
+                
+                for (size_t i = 0; i < item->length; i++)
+                        putchar(item->data[i]);
+                
+                if (log != NULL) {
+                        for (size_t i = 0; i < item->length; i++)
+                                fputc(item->data[i], log);
+                        
+                        fflush(log);
+                        fsync(fileno(log));
+                }
+                
+                free(item->data);
+                free(item);
+        }
+        
+        fclose(log);
+        return EOK;
+}
+
+/** Kernel notification handler
+ *
+ * Receives kernel klog notifications.
+ *
+ * @param callid IPC call ID.
+ * @param call   IPC call structure.
+ *
+ */
+static void notification_received(ipc_callid_t callid, ipc_call_t *call)
+{
+        /*
+         * Make sure we process only a single notification
+         * at any time to limit the chance of the consumer
+         * starving.
+         *
+         * Note: Usually the automatic masking of the klog
+         * notifications on the kernel side does the trick
+         * of limiting the chance of accidentally copying
+         * the same data multiple times. However, due to
+         * the non-blocking architecture of klog notifications,
+         * this possibility cannot be generally avoided.
+         */
+        
+        fibril_mutex_lock(&mtx);
         
         size_t klog_start = (size_t) IPC_GET_ARG1(*call);
         size_t klog_len = (size_t) IPC_GET_ARG2(*call);
         size_t klog_stored = (size_t) IPC_GET_ARG3(*call);
-        size_t i;
-        
-        for (i = klog_len - klog_stored; i < klog_len; i++) {
-                wchar_t ch = klog[(klog_start + i) % klog_length];
-                
-                putchar(ch);
-                
-                if (log != NULL)
-                        fputc(ch, log);
-        }
-        
-        if (log != NULL) {
-                fflush(log);
-                fsync(fileno(log));
-        }
-        
-        fibril_mutex_unlock(&log_mutex);
+        
+        size_t offset = (klog_start + klog_len - klog_stored) % klog_length;
+        
+        /* Copy data from the ring buffer */
+        if (offset + klog_stored >= klog_length) {
+                size_t split = klog_length - offset;
+                
+                producer(split, klog + offset);
+                producer(klog_stored - split, klog);
+        } else
+                producer(klog_stored, klog + offset);
+        
+        event_unmask(EVENT_KLOG);
+        fibril_mutex_unlock(&mtx);
 }
 
@@ -120 +218 @@
         }
         
+        prodcons_initialize(&pc);
+        async_set_interrupt_received(notification_received);
         rc = event_subscribe(EVENT_KLOG, 0);
         if (rc != EOK) {
@@ -127 +227 @@
         }
         
-        /*
-         * Mode "a" would be definitively much better here, but it is
-         * not well supported by the FAT driver.
-         */
-        log = fopen(LOG_FNAME, "w");
-        if (log == NULL)
-                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
-                    str_error(errno));
-        
-        async_set_interrupt_received(interrupt_received);
+        fid_t fid = fibril_create(consumer, NULL);
+        if (!fid) {
+                fprintf(stderr, "%s: Unable to create consumer fibril\n",
+                    NAME);
+                return ENOMEM;
+        }
+        
+        fibril_add_ready(fid);
+        event_unmask(EVENT_KLOG);
         klog_update();
+        
+        task_retval(0);
         async_manager();
         

uspace/app/stats/stats.c

@@ -69 +69 @@
         size_t i;
         for (i = 0; i < count; i++) {
-                uint64_t resmem, virtmem, ucycles, kcycles;
-                char resmem_suffix, virtmem_suffix, usuffix, ksuffix;
-                
-                order_suffix(stats_tasks[i].resmem, &resmem, &resmem_suffix);
-                order_suffix(stats_tasks[i].virtmem, &virtmem, &virtmem_suffix);
+                uint64_t resmem;
+                uint64_t virtmem;
+                uint64_t ucycles;
+                uint64_t kcycles;
+                const char *resmem_suffix;
+                const char *virtmem_suffix;
+                char usuffix;
+                char ksuffix;
+                
+                bin_order_suffix(stats_tasks[i].resmem, &resmem, &resmem_suffix, true);
+                bin_order_suffix(stats_tasks[i].virtmem, &virtmem, &virtmem_suffix, true);
                 order_suffix(stats_tasks[i].ucycles, &ucycles, &usuffix);
                 order_suffix(stats_tasks[i].kcycles, &kcycles, &ksuffix);
                 
-                printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c %8" PRIu64 "%c"
+                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s %6" PRIu64 "%s"
                     " %8" PRIu64 "%c %8" PRIu64 "%c %s\n",
                     stats_tasks[i].task_id, stats_tasks[i].threads,

uspace/app/tester/Makefile

@@ -49 +49 @@
         loop/loop1.c \
         mm/malloc1.c \
+        mm/malloc2.c \
         mm/mapping1.c \
         devs/devman1.c \

uspace/app/tester/tester.c

@@ -62 +62 @@
 #include "loop/loop1.def"
 #include "mm/malloc1.def"
+#include "mm/malloc2.def"
 #include "mm/mapping1.def"
 #include "hw/serial/serial1.def"

uspace/app/tester/tester.h

@@ -78 +78 @@
 extern const char *test_loop1(void);
 extern const char *test_malloc1(void);
+extern const char *test_malloc2(void);
 extern const char *test_mapping1(void);
 extern const char *test_serial1(void);

uspace/app/top/screen.c

@@ -254 +254 @@
         uint64_t used;
         uint64_t free;
-        char total_suffix;
-        char unavail_suffix;
-        char used_suffix;
-        char free_suffix;
-        
-        order_suffix(data->physmem->total, &total, &total_suffix);
-        order_suffix(data->physmem->unavail, &unavail, &unavail_suffix);
-        order_suffix(data->physmem->used, &used, &used_suffix);
-        order_suffix(data->physmem->free, &free, &free_suffix);
-        
-        printf("memory: %" PRIu64 "%c total, %" PRIu64 "%c unavail, %"
-            PRIu64 "%c used, %" PRIu64 "%c free", total, total_suffix,
+        const char *total_suffix;
+        const char *unavail_suffix;
+        const char *used_suffix;
+        const char *free_suffix;
+        
+        bin_order_suffix(data->physmem->total, &total, &total_suffix, false);
+        bin_order_suffix(data->physmem->unavail, &unavail, &unavail_suffix, false);
+        bin_order_suffix(data->physmem->used, &used, &used_suffix, false);
+        bin_order_suffix(data->physmem->free, &free, &free_suffix, false);
+        
+        printf("memory: %" PRIu64 "%s total, %" PRIu64 "%s unavail, %"
+            PRIu64 "%s used, %" PRIu64 "%s free", total, total_suffix,
             unavail, unavail_suffix, used, used_suffix, free, free_suffix);
         screen_newline();
@@ -295 +295 @@
                 
                 uint64_t resmem;
-                char resmem_suffix;
-                order_suffix(task->resmem, &resmem, &resmem_suffix);
+                const char *resmem_suffix;
+                bin_order_suffix(task->resmem, &resmem, &resmem_suffix, true);
                 
                 uint64_t virtmem;
-                char virtmem_suffix;
-                order_suffix(task->virtmem, &virtmem, &virtmem_suffix);
-                
-                printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c ",
+                const char *virtmem_suffix;
+                bin_order_suffix(task->virtmem, &virtmem, &virtmem_suffix, true);
+                
+                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s ",
                     task->task_id, task->threads, resmem, resmem_suffix);
                 print_percent(perc->resmem, 2);
-                printf(" %8" PRIu64 "%c ", virtmem, virtmem_suffix);
+                printf(" %6" PRIu64 "%s ", virtmem, virtmem_suffix);
                 print_percent(perc->virtmem, 2);
                 puts(" ");

uspace/app/vuhid/device.c

@@ -36 +36 @@
 #include "virthid.h"
 #include <errno.h>
+#include <stdio.h>
 #include <str.h>
 #include <assert.h>