Helpful debugging additions
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 18 May 2011 23:14:27 +0000 (16:14 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:36:03 +0000 (17:36 -0700)
Just some minor changes to the print output of slab / alarm code.  Also
removed some useless asserts from kthread, which should have gone away
when we put cur_tf in pcpui.

kern/include/slab.h
kern/src/alarm.c
kern/src/kthread.c
kern/src/slab.c

index b89f49d..7e094b4 100644 (file)
@@ -80,6 +80,7 @@ struct kmem_cache {
        struct kmem_slab_list empty_slab_list;
        void (*ctor)(void *, size_t);
        void (*dtor)(void *, size_t);
+       unsigned long nr_cur_alloc;
 };
 
 /* List of all kmem_caches, sorted in order of size */
index 01a16c8..68936bc 100644 (file)
@@ -278,7 +278,10 @@ void print_chain(struct timer_chain *tchain)
               tchain->earliest_time,
               tchain->latest_time);
        TAILQ_FOREACH(i, &tchain->waiters, next) {
-               printk("\tWaiter %08p, time: %llu\n", i, i->wake_up_time);
+               struct kthread *kthread = TAILQ_FIRST(&i->sem.waiters);
+               printk("\tWaiter %08p, time: %llu, kthread: %08p (%08p)\n", i,
+                      i->wake_up_time, kthread, (kthread ? kthread->proc : 0));
+
        }
 }
 
index 8d360fa..29bdca5 100644 (file)
@@ -91,9 +91,6 @@ void sleep_on(struct semaphore *sem)
        /* Switch to the core's default stack.  After this, don't use local
         * variables.  TODO: we shouldn't be using new_stacktop either, can't always
         * trust the register keyword (AFAIK). */
-       /* TODO: we shouldn't do this if new_stacktop is on the same page as cur_tf */
-       assert(ROUNDDOWN((uintptr_t)current_tf, PGSIZE) !=
-              kthread->stacktop - PGSIZE);
        set_stack_pointer(new_stacktop);
        smp_idle();
        /* smp_idle never returns */
@@ -134,10 +131,6 @@ void restart_kthread(struct kthread *kthread)
         * free our current kthread *before* popping it, nor can we free the current
         * stack until we pop to the kthread's stack). */
        if (pcpui->spare) {
-               /* this should never happen now.  it probably only was a concern because
-                * i accidentally free kthread's stacktop (the one i was jumping too) */
-               assert(ROUNDDOWN((uintptr_t)current_tf, PGSIZE) !=
-                      pcpui->spare->stacktop - PGSIZE);
                /* this should probably have a rounddown, since it's not always the top,
                 * or even always PGSIZE... */
                page_decref(kva2page((void*)pcpui->spare->stacktop - PGSIZE));
@@ -196,6 +189,7 @@ void __launch_kthread(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
                                            0, 0, KMSG_ROUTINE);
                        return;
                }
+               /* TODO: this whole area needs serious work */
                if (cur_proc != kthread->proc) {
                        /* we're running the kthread from a different proc.  For now, we
                         * can't be _M, since that would be taking away someone's vcore to
index 930c7e6..855c5a0 100644 (file)
@@ -45,6 +45,7 @@ static void __kmem_cache_create(struct kmem_cache *kc, const char *name,
        TAILQ_INIT(&kc->empty_slab_list);
        kc->ctor = ctor;
        kc->dtor = dtor;
+       kc->nr_cur_alloc = 0;
        
        /* put in cache list based on it's size */
        struct kmem_cache *i, *prev = NULL;
@@ -185,6 +186,7 @@ void *kmem_cache_alloc(struct kmem_cache *cp, int flags)
                TAILQ_REMOVE(&cp->partial_slab_list, a_slab, link);
                TAILQ_INSERT_HEAD(&cp->full_slab_list, a_slab, link);
        }
+       cp->nr_cur_alloc++;
        spin_unlock_irqsave(&cp->cache_lock);
        return retval;
 }
@@ -217,6 +219,7 @@ void kmem_cache_free(struct kmem_cache *cp, void *buf)
                TAILQ_INSERT_HEAD(&a_slab->bufctl_freelist, a_bufctl, link);
        }
        a_slab->num_busy_obj--;
+       cp->nr_cur_alloc--;
        // if it was full, move it to partial
        if (a_slab->num_busy_obj + 1 == a_slab->num_total_obj) {
                TAILQ_REMOVE(&cp->full_slab_list, a_slab, link);
@@ -332,6 +335,7 @@ void print_kmem_cache(struct kmem_cache *cp)
        printk("Slab Full: 0x%08x\n", cp->full_slab_list);
        printk("Slab Partial: 0x%08x\n", cp->partial_slab_list);
        printk("Slab Empty: 0x%08x\n", cp->empty_slab_list);
+       printk("Current Allocations: %d\n", cp->nr_cur_alloc);
        spin_unlock_irqsave(&cp->cache_lock);
 }