Replaces %08p with %p
authorBarret Rhoden <brho@cs.berkeley.edu>
Mon, 27 May 2013 18:21:53 +0000 (11:21 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 27 May 2013 18:21:53 +0000 (11:21 -0700)
I also changed %ps to %x when dealing with ints (flag vars).  In
general, I still use %p on things that techincally aren't pointers (like
uintptr_t).

25 files changed:
kern/arch/i686/apic.c
kern/arch/i686/cpuinfo.c
kern/arch/i686/e1000.c
kern/arch/i686/mptables.c
kern/arch/i686/pmap.c
kern/arch/i686/trap.c
kern/arch/sparc/cpuinfo.c
kern/src/alarm.c
kern/src/atomic.c
kern/src/blockdev.c
kern/src/eth_audio.c
kern/src/event.c
kern/src/ext2fs.c
kern/src/mm.c
kern/src/monitor.c
kern/src/page_alloc.c
kern/src/process.c
kern/src/radix.c
kern/src/schedule.c
kern/src/slab.c
kern/src/syscall.c
kern/src/testing.c
kern/src/trap.c
kern/src/ucq.c
kern/src/vfs.c

index 7a6267e..06ec86b 100644 (file)
@@ -94,11 +94,11 @@ void lapic_print_isr(void)
 {
        printk("LAPIC ISR on core %d\n--------------\n", core_id());
        for (int i = 7; i >= 0; i--)
-               printk("%3d-%3d: %08p\n", (i + 1) * 32 - 1, i * 32,
+               printk("%3d-%3d: %p\n", (i + 1) * 32 - 1, i * 32,
                       *(uint32_t*)(LAPIC_ISR + i * 0x10));
        printk("LAPIC IRR on core %d\n--------------\n", core_id());
        for (int i = 7; i >= 0; i--)
-               printk("%3d-%3d: %08p\n", (i + 1) * 32 - 1, i * 32,
+               printk("%3d-%3d: %p\n", (i + 1) * 32 - 1, i * 32,
                       *(uint32_t*)(LAPIC_IRR + i * 0x10));
 }
 
index 341e0c3..83ca0ca 100644 (file)
@@ -158,17 +158,17 @@ void show_mapping(uintptr_t start, size_t size)
        printk("--------------------------------------------\n");
        for(i = 0; i < size; i += PGSIZE, start += PGSIZE) {
                pte = pgdir_walk(pgdir, (void*)start, 0);
-               printk("%08p  ", start);
+               printk("%p  ", start);
                if (pte) {
                        pde = &pgdir[PDX(start)];
                        /* for a jumbo, pde = pte and PTE_PS (better be) = 1 */
-                       printk("%08p  %1d  %1d  %1d  %1d  %1d  %1d %1d %1d\n",
+                       printk("%p  %1d  %1d  %1d  %1d  %1d  %1d %1d %1d\n",
                               PTE_ADDR(*pte), (*pte & PTE_PS) >> 7, (*pte & PTE_D) >> 6,
                               (*pte & PTE_A) >> 5, (*pte & PTE_PCD) >> 4,
                               (*pte & PTE_PWT) >> 3, (*pte & *pde & PTE_U) >> 2,
                               (*pte & *pde & PTE_W) >> 1, (*pte & PTE_P));
                } else {
-                       printk("%08p\n", 0);
+                       printk("%p\n", 0);
                }
        }
 }
index e96a393..bb372e1 100644 (file)
@@ -229,7 +229,7 @@ int e1000_scan_pci(void)
                                        e1000_debug("-->IO PORT MODE\n");
                                        panic("IO PORT MODE NOT SUPPORTED\n");
                                } else {
-                                       e1000_debug("-->MMIO Mode, Base: %08p\n", result);
+                                       e1000_debug("-->MMIO Mode, Base: %p\n", result);
                                        // Deal with the MMIO base, mapping, and size.
                                        e1000_handle_bar0(result);
                                }                                               
index 74faff4..9cd58ec 100644 (file)
@@ -172,7 +172,7 @@ void mptables_parse() {
                panic("MPTABLES Not found. IOAPIC and interrupts will not function properly. <Insert whale held up by smaller birds here>");
        }
        
-       mptables_info("-->MPTables Floating Pointer Structure found @ KVA %08p.\n", mpfps);
+       mptables_info("-->MPTables Floating Pointer Structure found @ KVA %p.\n", mpfps);
        
        mptables_info("-->Current Interrupt Mode: ");
        // Identify our interrupt mode
index 128d11b..91ed978 100644 (file)
@@ -304,7 +304,7 @@ vm_init(void)
        boot_pgdir = pgdir;
        boot_cr3 = PADDR(pgdir);
        // helpful if you want to manually walk with kvm / bochs
-       //printk("pgdir va = %08p, pgdir pa = %08p\n\n", pgdir, PADDR(pgdir));
+       //printk("pgdir va = %p, pgdir pa = %p\n\n", pgdir, PADDR(pgdir));
 
        //////////////////////////////////////////////////////////////////////
        // Recursively insert PD in itself as a page table, to form
index 45330b3..1e23671 100644 (file)
@@ -99,7 +99,7 @@ uintptr_t get_stack_top(void)
                return ROUNDUP(read_esp(), PGSIZE);
        stacktop = pcpui->tss->ts_esp0;
        if (stacktop != ROUNDUP(read_esp(), PGSIZE))
-               panic("Bad stacktop: %08p esp one is %08p\n", stacktop,
+               panic("Bad stacktop: %p esp one is %p\n", stacktop,
                      ROUNDUP(read_esp(), PGSIZE));
        return stacktop;
 }
@@ -304,7 +304,7 @@ static void trap_dispatch(struct hw_trapframe *hw_tf)
                        pcpui->__lock_depth_disabled++;
                        print_trapframe(hw_tf);
                        char *fn_name = get_fn_name(hw_tf->tf_eip);
-                       printk("Core %d is at %08p (%s)\n", core_id(), hw_tf->tf_eip,
+                       printk("Core %d is at %p (%s)\n", core_id(), hw_tf->tf_eip,
                               fn_name);
                        kfree(fn_name);
                        print_kmsgs(core_id());
@@ -323,7 +323,7 @@ static void trap_dispatch(struct hw_trapframe *hw_tf)
                         * the same).  See set_current_ctx() for more info. */
                        if (!in_kernel(hw_tf))
                                hw_tf = &pcpui->cur_ctx->tf.hw_tf;
-                       printd("bad opcode, eip: %08p, next 3 bytes: %x %x %x\n",
+                       printd("bad opcode, eip: %p, next 3 bytes: %x %x %x\n",
                               hw_tf->tf_eip, 
                               *(uint8_t*)(hw_tf->tf_eip + 0), 
                               *(uint8_t*)(hw_tf->tf_eip + 1), 
@@ -596,8 +596,8 @@ void page_fault_handler(struct hw_trapframe *hw_tf)
                       hw_tf->tf_eip, core_id(), err);
                print_trapframe(hw_tf);
                /* Turn this on to help debug bad function pointers */
-               printd("esp %08p\n\t 0(esp): %08p\n\t 4(esp): %08p\n\t 8(esp): %08p\n"
-                      "\t12(esp): %08p\n", hw_tf->tf_esp,
+               printd("esp %p\n\t 0(esp): %p\n\t 4(esp): %p\n\t 8(esp): %p\n"
+                      "\t12(esp): %p\n", hw_tf->tf_esp,
                       *(uintptr_t*)(hw_tf->tf_esp +  0),
                       *(uintptr_t*)(hw_tf->tf_esp +  4),
                       *(uintptr_t*)(hw_tf->tf_esp +  8),
index cf2960e..9e89d21 100644 (file)
@@ -69,15 +69,15 @@ void show_mapping(uintptr_t start, size_t size)
        for(i = 0; i < size; i += PGSIZE, start += PGSIZE)
        {
                page = page_lookup(l1_page_table,(void*)start,&pte);
-               cprintf("%08p  ",start);
+               cprintf("%p  ",start);
                if(page)
                {
-                       cprintf("%08p  %1d %1d %1d  %1x  %1d\n",page2pa(page),
+                       cprintf("%p  %1d %1d %1d  %1x  %1d\n",page2pa(page),
                                !!(*pte & PTE_C),!!(*pte & PTE_M),
                                !!(*pte & PTE_R),(*pte & PTE_ACC) >> 2,
                                !!(*pte & PTE_PTE));
                }
                else
-                       cprintf("%08p\n",0);
+                       cprintf("%p\n",0);
        }
 }
index 7a73b6b..d49bd7b 100644 (file)
@@ -122,7 +122,7 @@ void trigger_tchain(struct timer_chain *tchain)
        bool changed_list = FALSE;
        assert(!irq_is_enabled());
        TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
-               printd("Trying to wake up %08p who is due at %llu and now is %llu\n",
+               printd("Trying to wake up %p who is due at %llu and now is %llu\n",
                       i, i->wake_up_time, now);
                /* TODO: Could also do something in cases where we're close to now */
                if (i->wake_up_time <= now) {
@@ -187,7 +187,7 @@ void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
                        goto no_reset_out;
                }
        }
-       panic("Could not find a spot for awaiter %08p\n", waiter);
+       panic("Could not find a spot for awaiter %p\n", waiter);
 reset_out:
        reset_tchain_interrupt(tchain);
 no_reset_out:
@@ -228,7 +228,7 @@ int sleep_on_awaiter(struct alarm_waiter *waiter)
 {
        int8_t irq_state = 0;
        if (waiter->func)
-               panic("Tried blocking on a waiter %08p with a func %08p!", waiter,
+               panic("Tried blocking on a waiter %p with a func %p!", waiter,
                      waiter->func);
        /* Put the kthread to sleep.  TODO: This can fail (or at least it will be
         * able to in the future) and we'll need to handle that. */
@@ -263,7 +263,7 @@ void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
                        rel_usec = tsc2usec(time - now);
                rel_usec = MAX(rel_usec, 1);
                printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
-                      "tchain %08p\n", time, now, rel_usec, pcpui_tchain);
+                      "tchain %p\n", time, now, rel_usec, pcpui_tchain);
                /* Note that sparc doesn't honor the one-shot setting, so you might get
                 * spurious interrupts. */
                set_core_timer(rel_usec, FALSE);
@@ -281,13 +281,13 @@ void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
 void print_chain(struct timer_chain *tchain)
 {
        struct alarm_waiter *i;
-       printk("Chain %08p is%s empty, early: %llu latest: %llu\n", tchain,
+       printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
               TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
               tchain->earliest_time,
               tchain->latest_time);
        TAILQ_FOREACH(i, &tchain->waiters, next) {
                struct kthread *kthread = TAILQ_FIRST(&i->sem.waiters);
-               printk("\tWaiter %08p, time: %llu, kthread: %08p (%08p)\n", i,
+               printk("\tWaiter %p, time: %llu, kthread: %p (%p)\n", i,
                       i->wake_up_time, kthread, (kthread ? kthread->proc : 0));
 
        }
index 6a30d8f..24448bb 100644 (file)
@@ -36,14 +36,14 @@ void spin_lock(spinlock_t *lock)
                if (!can_spinwait_irq(pcpui)) {
                        pcpui->__lock_depth_disabled++;
                        print_kctx_depths("IRQOK");
-                       panic("Lock %08p tried to spin when it shouldn't\n", lock);
+                       panic("Lock %p tried to spin when it shouldn't\n", lock);
                        pcpui->__lock_depth_disabled--;
                }
        } else {
                if (!can_spinwait_noirq(pcpui)) {
                        pcpui->__lock_depth_disabled++;
                        print_kctx_depths("NOIRQ");
-                       panic("Lock %08p tried to spin when it shouldn't\n", lock);
+                       panic("Lock %p tried to spin when it shouldn't\n", lock);
                        pcpui->__lock_depth_disabled--;
                }
        }
index ec86543..d83066a 100644 (file)
@@ -135,7 +135,7 @@ void generic_breq_done(struct block_request *breq)
        int8_t irq_state = 0;
        if (!sem_up_irqsave(&breq->sem, &irq_state)) {
                /* This shouldn't happen anymore.  Let brho know if it does. */
-               warn("[kernel] no one waiting on breq %08p", breq);
+               warn("[kernel] no one waiting on breq %p", breq);
        }
 }
 
@@ -146,7 +146,7 @@ void sleep_on_breq(struct block_request *breq)
 {
        int8_t irq_state = 0;
        /* Since printk takes a while, this may make you lose the race */
-       printd("Sleeping on breq %08p\n", breq);
+       printd("Sleeping on breq %p\n", breq);
        assert(irq_is_enabled());
        sem_down_irqsave(&breq->sem, &irq_state);
 }
index 2d59ecb..3a1539a 100644 (file)
@@ -111,7 +111,7 @@ static void eth_audio_prep_response(struct ethaud_udp_packet *incoming,
        /* Debugging */
        static int once = 0;
        if (!once++)
-               printd("I will send %d bytes from %08p:%d to %08p:%d, iplen %04p, "
+               printd("I will send %d bytes from %p:%d to %p:%d, iplen %04p, "
                       "udplen %04p\n",
                       ntohs(outgoing->udp_hdr.length),
                       ntohl(outgoing->ip_hdr.src_addr),
index f835423..314c706 100644 (file)
@@ -71,7 +71,7 @@ static void set_vcore_msgable(uint32_t vcoreid)
 static void post_ev_msg(struct proc *p, struct event_mbox *mbox,
                         struct event_msg *msg, int ev_flags)
 {
-       printd("[kernel] Sending event type %d to mbox %08p\n", msg->ev_type, mbox);
+       printd("[kernel] Sending event type %d to mbox %p\n", msg->ev_type, mbox);
        /* Sanity check */
        assert(p);
        /* If they just want a bit (NOMSG), just set the bit */
@@ -343,7 +343,7 @@ void send_event(struct proc *p, struct event_queue *ev_q, struct event_msg *msg,
        struct proc *old_proc;
        struct event_mbox *ev_mbox = 0;
        assert(p);
-       printd("[kernel] sending msg to proc %08p, ev_q %08p\n", p, ev_q);
+       printd("[kernel] sending msg to proc %p, ev_q %p\n", p, ev_q);
        if (!ev_q) {
                warn("[kernel] Null ev_q - kernel code should check before sending!");
                return;
@@ -357,7 +357,7 @@ void send_event(struct proc *p, struct event_queue *ev_q, struct event_msg *msg,
         * kernel PFs on the user's behalf.  For now, we catch common userspace bugs
         * (had this happen a few times). */
        if (!PTE_ADDR(ev_q)) {
-               printk("[kernel] Bad addr %08p for ev_q\n", ev_q);
+               printk("[kernel] Bad addr %p for ev_q\n", ev_q);
                return;
        }
        /* ev_q is a user pointer, so we need to make sure we're in the right
index 94e8467..02ea162 100644 (file)
@@ -462,7 +462,7 @@ void *ext2_get_ino_metablock(struct inode *inode, unsigned long ino_block)
  * the 2x and 3x walks are jacked up. */
 void ext2_print_ino_blocks(struct inode *inode)
 {
-       printk("Inode %08p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
+       printk("Inode %p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
               inode->i_size, inode->i_blocks);
        for (int i = 0; i < inode->i_blocks * (inode->i_sb->s_blocksize / 512); i++)
                printk("# %03d, Block %03d\n", i, ext2_find_inoblock(inode, i));
@@ -521,7 +521,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
                sum_blks += le16_to_cpu(bg[i].bg_free_blocks_cnt);
                sum_inodes += le16_to_cpu(bg[i].bg_free_inodes_cnt);
                if (print) {
-                       printk("*** BG %d at %08p\n", i, &bg[i]);
+                       printk("*** BG %d at %p\n", i, &bg[i]);
                        printk("Block bitmap:%8d\n", le32_to_cpu(bg[i].bg_block_bitmap));
                        printk("Inode bitmap:%8d\n", le32_to_cpu(bg[i].bg_inode_bitmap));
                        printk("Inode table: %8d\n", le32_to_cpu(bg[i].bg_inode_table));
index e221188..4d0e99c 100644 (file)
@@ -88,7 +88,7 @@ struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
                vmr->vm_end = vmr->vm_base + len;
        }
        if (!vmr)
-               warn("Not making a VMR, wanted %08p, + %p = %p", va, len, va + len);
+               warn("Not making a VMR, wanted %p, + %p = %p", va, len, va + len);
        return vmr;
 }
 
@@ -255,7 +255,7 @@ static int copy_pages(struct proc *p, struct proc *new_p, uintptr_t va_start,
            (PGOFF(va_end)) ||
            (va_end < va_start) ||      /* now, start > UMAPTOP -> end > UMAPTOP */
            (va_end > UMAPTOP)) {
-               warn("VMR mapping is probably screwed up (%08p - %08p)", va_start,
+               warn("VMR mapping is probably screwed up (%p - %p)", va_start,
                     va_end);
                return -EINVAL;
        }
@@ -278,7 +278,7 @@ static int copy_pages(struct proc *p, struct proc *new_p, uintptr_t va_start,
                         * original PTE */
                        panic("Swapping not supported!");
                } else {
-                       panic("Weird PTE %08p in %s!", *pte, __FUNCTION__);
+                       panic("Weird PTE %p in %s!", *pte, __FUNCTION__);
                }
                return 0;
        }
@@ -310,7 +310,7 @@ static int copy_pages(struct proc *p, struct proc *new_p, uintptr_t va_start,
                         * original PTE */
                        panic("Swapping not supported!");
                } else {
-                       panic("Weird PTE %08p in %s!", *old_pte, __FUNCTION__);
+                       panic("Weird PTE %p in %s!", *old_pte, __FUNCTION__);
                }
        }
        return 0;
@@ -357,7 +357,7 @@ void print_vmrs(struct proc *p)
        struct vm_region *vmr;
        printk("VM Regions for proc %d\n", p->pid);
        TAILQ_FOREACH(vmr, &p->vm_regions, vm_link)
-               printk("%02d: (0x%08x - 0x%08x): %08p, %08p, %08p, %08p\n", count++,
+               printk("%02d: (%p - %p): 0x%08x, 0x%08x, %p, %p\n", count++,
                       vmr->vm_base, vmr->vm_end, vmr->vm_prot, vmr->vm_flags,
                       vmr->vm_file, vmr->vm_foff);
 }
@@ -504,7 +504,7 @@ void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
                __do_munmap(p, addr, len);
        vmr = create_vmr(p, addr, len);
        if (!vmr) {
-               printk("[kernel] do_mmap() aborted for %08p + %d!\n", addr, len);
+               printk("[kernel] do_mmap() aborted for %p + %d!\n", addr, len);
                set_errno(ENOMEM);
                return MAP_FAILED;              /* TODO: error propagation for mmap() */
        }
@@ -548,7 +548,7 @@ void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
                for (int i = 0; i < num_pages; i++) {
                        retval = __handle_page_fault(p, addr + i * PGSIZE, vmr->vm_prot);
                        if (retval) {
-                               warn("do_mmap() failing (%d) on addr %08p with prot %p",
+                               warn("do_mmap() failing (%d) on addr %p with prot 0x%x",
                                     retval, addr + i * PGSIZE,  vmr->vm_prot);
                                destroy_vmr(vmr);
                                set_errno(-retval);
@@ -564,7 +564,7 @@ void *__do_mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags,
 
 int mprotect(struct proc *p, uintptr_t addr, size_t len, int prot)
 {
-       printd("mprotect: (addr %08p, len %08p, prot %08p)\n", addr, len, prot);
+       printd("mprotect: (addr %p, len %p, prot 0x%x)\n", addr, len, prot);
        if (!len)
                return 0;
        if ((addr % PGSIZE) || (addr < MMAP_LOWEST_VA)) {
@@ -775,7 +775,7 @@ int __handle_page_fault(struct proc *p, uintptr_t va, int prot)
                        /* Debugging */
                        if (!(vmr->vm_prot & PROT_WRITE))
                                printd("[kernel] private, but unwritable file mapping of %s "
-                                      "at va %08p\n", file_name(vmr->vm_file), va);
+                                      "at va %p\n", file_name(vmr->vm_file), va);
                }
                /* if this is an executable page, we might have to flush the instruction
                 * cache if our HW requires it. */
@@ -853,7 +853,7 @@ int map_vmap_segment(uintptr_t vaddr, uintptr_t paddr, unsigned long num_pages,
                }
                /* You probably should have unmapped first */
                if (*pte)
-                       warn("Existing PTE value %08p\n", *pte);
+                       warn("Existing PTE value %p\n", *pte);
                *pte = PTE(pa2ppn(paddr + i * PGSIZE), perm);
        }
        spin_unlock(&dyn_vmap_lock);
index afc335e..6830ec4 100644 (file)
@@ -190,13 +190,13 @@ int mon_setmapperm(int argc, char **argv, struct hw_trapframe *hw_tf)
        pde = &pgdir[PDX(va)];
        cprintf("   Virtual    Physical  Ps Dr Ac CD WT U W\n");
        cprintf("------------------------------------------\n");
-       cprintf("%08p  %08p  %1d  %1d  %1d  %1d  %1d  %1d %1d\n", va, page2pa(page),
+       cprintf("%p  %p  %1d  %1d  %1d  %1d  %1d  %1d %1d\n", va, page2pa(page),
               (*pte & PTE_PS) >> 7, (*pte & PTE_D) >> 6, (*pte & PTE_A) >> 5,
               (*pte & PTE_PCD) >> 4, (*pte & PTE_PWT) >> 3, (*pte & *pde & PTE_U) >> 2,
               (*pte & *pde & PTE_W) >> 1);
        *pte = PTE_ADDR(*pte) | (*pte & PTE_PS) |
               (PGOFF(strtol(argv[2], 0, 16)) & ~PTE_PS ) | PTE_P;
-       cprintf("%08p  %08p  %1d  %1d  %1d  %1d  %1d  %1d %1d\n", va, page2pa(page),
+       cprintf("%p  %p  %1d  %1d  %1d  %1d  %1d  %1d %1d\n", va, page2pa(page),
               (*pte & PTE_PS) >> 7, (*pte & PTE_D) >> 6, (*pte & PTE_A) >> 5,
               (*pte & PTE_PCD) >> 4, (*pte & PTE_PWT) >> 3, (*pte & *pde & PTE_U) >> 2,
               (*pte & *pde & PTE_W) >> 1);
@@ -812,7 +812,7 @@ int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf)
                TAILQ_FOREACH(sb, &super_blocks, s_list) {
                        printk("Superblock for %s\n", sb->s_name);
                        TAILQ_FOREACH(file, &sb->s_files, f_list)
-                               printk("File: %08p, %s, Refs: %d, Drefs: %d, Irefs: %d\n", file,
+                               printk("File: %p, %s, Refs: %d, Drefs: %d, Irefs: %d\n", file,
                                       file_name(file), kref_refcnt(&file->f_kref),
                                       kref_refcnt(&file->f_dentry->d_kref),
                                       kref_refcnt(&file->f_dentry->d_inode->i_kref));
@@ -822,11 +822,11 @@ int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf)
                TAILQ_FOREACH(sb, &super_blocks, s_list) {
                        printk("Superblock for %s\n", sb->s_name);
                        TAILQ_FOREACH(inode, &sb->s_inodes, i_sb_list) {
-                               printk("Inode: %08p, Refs: %d, Nlinks: %d, Size(B): %d\n",
+                               printk("Inode: %p, Refs: %d, Nlinks: %d, Size(B): %d\n",
                                       inode, kref_refcnt(&inode->i_kref), inode->i_nlink,
                                       inode->i_size);
                                TAILQ_FOREACH(dentry, &inode->i_dentry, d_alias)
-                                       printk("\t%s: Dentry: %08p, Refs: %d\n",
+                                       printk("\t%s: Dentry: %p, Refs: %d\n",
                                               dentry->d_name.name, dentry,
                                               kref_refcnt(&dentry->d_kref));
                        }
@@ -841,7 +841,7 @@ int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf)
                        void print_dcache_entry(void *item)
                        {
                                struct dentry *d_i = (struct dentry*)item;
-                               printk("%08p %08p %02d     %s\n", d_i, d_i->d_flags,
+                               printk("%p %p %02d     %s\n", d_i, d_i->d_flags,
                                       kref_refcnt(&d_i->d_kref), d_i->d_name.name);
                        }
                        hash_for_each(sb->s_dcache, print_dcache_entry);
@@ -853,7 +853,7 @@ int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf)
                        TAILQ_FOREACH(sb, &super_blocks, s_list) {
                                printk("Superblock for %s\n", sb->s_name);
                                TAILQ_FOREACH(dentry, &sb->s_lru_d, d_lru)
-                                       printk("Dentry: %08p, Name: %s\n", dentry,
+                                       printk("Dentry: %p, Name: %s\n", dentry,
                                               dentry->d_name.name);
                        }
                } else if (!strcmp(argv[2], "prune")) {
index 00653e8..075b492 100644 (file)
@@ -322,17 +322,17 @@ void print_pageinfo(struct page *page)
                printk("Null page\n");
                return;
        }
-       printk("Page %d (%08p), Flags: %08p Refcnt: %d\n", page2ppn(page), page2kva(page),
-              page->pg_flags, kref_refcnt(&page->pg_kref));
+       printk("Page %d (%p), Flags: 0x%08x Refcnt: %d\n", page2ppn(page),
+              page2kva(page), page->pg_flags, kref_refcnt(&page->pg_kref));
        if (page->pg_mapping) {
-               printk("\tMapped into object %08p at index %d\n",
+               printk("\tMapped into object %p at index %d\n",
                       page->pg_mapping->pm_host, page->pg_index);
        }
        if (page->pg_flags & PG_BUFFER) {
                struct buffer_head *bh = (struct buffer_head*)page->pg_private;
                i = 0;
                while (bh) {
-                       printk("\tBH %d: buffer: %08p, sector: %d, nr_sector: %d\n", i,
+                       printk("\tBH %d: buffer: %p, sector: %d, nr_sector: %d\n", i,
                               bh->bh_buffer, bh->bh_sector, bh->bh_nr_sector);
                        i++;
                        bh = bh->bh_next;
index df222e8..d67b83a 100644 (file)
@@ -2105,7 +2105,7 @@ void print_proc_info(pid_t pid)
        printk("State: %s (%p)\n", procstate2str(p->state), p->state);
        printk("Refcnt: %d\n", atomic_read(&p->p_kref.refcount) - 1);
        printk("Flags: 0x%08x\n", p->env_flags);
-       printk("CR3(phys): 0x%08x\n", p->env_cr3);
+       printk("CR3(phys): %p\n", p->env_cr3);
        printk("Num Vcores: %d\n", p->procinfo->num_vcores);
        printk("Vcore Lists (may be in flux w/o locking):\n----------------------\n");
        printk("Online:\n");
@@ -2126,14 +2126,14 @@ void print_proc_info(pid_t pid)
        spin_lock(&files->lock);
        for (int i = 0; i < files->max_files; i++)
                if (files->fd_array[i].fd_file) {
-                       printk("\tFD: %02d, File: %08p, File name: %s\n", i,
+                       printk("\tFD: %02d, File: %p, File name: %s\n", i,
                               files->fd_array[i].fd_file,
                               file_name(files->fd_array[i].fd_file));
                }
        spin_unlock(&files->lock);
        printk("Children: (PID (struct proc *))\n");
        TAILQ_FOREACH(child, &p->children, sibling_link)
-               printk("\t%d (%08p)\n", child->pid, child);
+               printk("\t%d (%p)\n", child->pid, child);
        /* no locking / unlocking or refcnting */
        // spin_unlock(&p->proc_lock);
        proc_decref(p);
@@ -2158,7 +2158,7 @@ void check_my_owner(void)
                                 * interrupts, which should cause us to skip cpu_halt() */
                                if (!STAILQ_EMPTY(&pcpui->immed_amsgs))
                                        continue;
-                               printk("Owned pcore (%d) has no owner, by %08p, vc %d!\n",
+                               printk("Owned pcore (%d) has no owner, by %p, vc %d!\n",
                                       core_id(), p, vcore2vcoreid(p, vc_i));
                                spin_unlock(&p->proc_lock);
                                spin_unlock(&pid_hash_lock);
index ccd2020..7543943 100644 (file)
@@ -46,7 +46,7 @@ void radix_tree_destroy(struct radix_tree *tree)
  * out of memory, EEXIST if an item is already in the tree. */
 int radix_insert(struct radix_tree *tree, unsigned long key, void *item)
 {
-       printd("RADIX: insert %08p at %d\n", item, key);
+       printd("RADIX: insert %p at %d\n", item, key);
        struct radix_node *r_node;
        void **slot;
        /* Is the tree tall enough?  if not, it needs to grow a level.  This will
@@ -251,7 +251,7 @@ int radix_tag_gang_lookup(struct radix_tree *tree, void **results,
 
 void print_radix_tree(struct radix_tree *tree)
 {
-       printk("Tree %08p, Depth: %d, Bound: %d\n", tree, tree->depth,
+       printk("Tree %p, Depth: %d, Bound: %d\n", tree, tree->depth,
               tree->upper_bound);
 
        void print_rnode(struct radix_node *r_node, int depth)
@@ -261,14 +261,14 @@ void print_radix_tree(struct radix_tree *tree)
                char buf[32] = {0};
                for (int i = 0; i < depth; i++)
                        buf[i] = '\t';
-               printk("%sRnode %08p, parent %08p, myslot %08p, %d items, leaf? %d\n",
+               printk("%sRnode %p, parent %p, myslot %p, %d items, leaf? %d\n",
                       buf, r_node, r_node->parent, r_node->my_slot, r_node->num_items,
                       r_node->leaf);
                for (int i = 0; i < NR_RNODE_SLOTS; i++) {
                        if (!r_node->items[i])
                                continue;
                        if (r_node->leaf)
-                               printk("\t%sRnode Item %d: %08p\n", buf, i, r_node->items[i]);
+                               printk("\t%sRnode Item %d: %p\n", buf, i, r_node->items[i]);
                        else
                                print_rnode(r_node->items[i], depth + 1);
                }
index a229b5d..3e59e9a 100644 (file)
@@ -848,7 +848,7 @@ void print_idlecoremap(void)
        /* not locking, so we can look at this without deadlocking. */
        printk("Idle cores (unlocked!):\n");
        TAILQ_FOREACH(spc_i, &idlecores, alloc_next)
-               printk("Core %d, prov to %d (%08p)\n", spc2pcoreid(spc_i),
+               printk("Core %d, prov to %d (%p)\n", spc2pcoreid(spc_i),
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc);
 }
 
@@ -881,7 +881,7 @@ void print_prov_map(void)
        printk("Which cores are provisioned to which procs:\n------------------\n");
        for (int i = 0; i < num_cpus; i++) {
                spc_i = pcoreid2spc(i);
-               printk("Core %02d, prov: %d(%08p) alloc: %d(%08p)\n", i,
+               printk("Core %02d, prov: %d(%p) alloc: %d(%p)\n", i,
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc,
                       spc_i->alloc_proc ? spc_i->alloc_proc->pid : 0,
                       spc_i->alloc_proc);
@@ -893,12 +893,12 @@ void print_proc_prov(struct proc *p)
        struct sched_pcore *spc_i;
        if (!p)
                return;
-       printk("Prov cores alloced to proc %d (%08p)\n----------\n", p->pid, p);
+       printk("Prov cores alloced to proc %d (%p)\n----------\n", p->pid, p);
        TAILQ_FOREACH(spc_i, &p->ksched_data.prov_alloc_me, prov_next)
                printk("Pcore %d\n", spc2pcoreid(spc_i));
-       printk("Prov cores not alloced to proc %d (%08p)\n----------\n", p->pid, p);
+       printk("Prov cores not alloced to proc %d (%p)\n----------\n", p->pid, p);
        TAILQ_FOREACH(spc_i, &p->ksched_data.prov_not_alloc_me, prov_next)
-               printk("Pcore %d (alloced to %d (%08p))\n", spc2pcoreid(spc_i),
+               printk("Pcore %d (alloced to %d (%p))\n", spc2pcoreid(spc_i),
                       spc_i->alloc_proc ? spc_i->alloc_proc->pid : 0,
                       spc_i->alloc_proc);
 }
index 676751b..6d2b313 100644 (file)
@@ -338,11 +338,11 @@ void print_kmem_cache(struct kmem_cache *cp)
        printk("Objsize: %d\n", cp->obj_size);
        printk("Align: %d\n", cp->align);
        printk("Flags: 0x%08x\n", cp->flags);
-       printk("Constructor: 0x%08x\n", cp->ctor);
-       printk("Destructor: 0x%08x\n", cp->dtor);
-       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("Constructor: %p\n", cp->ctor);
+       printk("Destructor: %p\n", cp->dtor);
+       printk("Slab Full: %p\n", cp->full_slab_list);
+       printk("Slab Partial: %p\n", cp->partial_slab_list);
+       printk("Slab Empty: %p\n", cp->empty_slab_list);
        printk("Current Allocations: %d\n", cp->nr_cur_alloc);
        spin_unlock_irqsave(&cp->cache_lock);
 }
@@ -354,10 +354,10 @@ void print_kmem_slab(struct kmem_slab *slab)
        printk("NumBusy: %d\n", slab->num_busy_obj);
        printk("Num_total: %d\n", slab->num_total_obj);
        if (slab->obj_size + sizeof(uintptr_t) < SLAB_LARGE_CUTOFF) {
-               printk("Free Small obj: 0x%08x\n", slab->free_small_obj);
+               printk("Free Small obj: %p\n", slab->free_small_obj);
                void *buf = slab->free_small_obj;
                for (int i = 0; i < slab->num_total_obj; i++) {
-                       printk("Addr of buf: 0x%08x, Addr of next: 0x%08x\n", buf,
+                       printk("Addr of buf: %p, Addr of next: %p\n", buf,
                               *((uintptr_t**)buf));
                        buf += slab->obj_size;
                }
index dd38582..4509b26 100644 (file)
@@ -843,7 +843,7 @@ static int sys_self_notify(struct proc *p, uint32_t vcoreid,
        }
        if (local_msg.ev_type >= MAX_NR_EVENT) {
                printk("[kernel] received self-notify for vcoreid %d, ev_type %d, "
-                      "u_msg %08p, u_msg->type %d\n", vcoreid, ev_type, u_msg,
+                      "u_msg %p, u_msg->type %d\n", vcoreid, ev_type, u_msg,
                       u_msg ? u_msg->ev_type : 0);
                return -1;
        }
@@ -1663,8 +1663,8 @@ intreg_t syscall(struct proc *p, uintreg_t sc_num, uintreg_t a0, uintreg_t a1,
                        coreid = core_id();
                        vcoreid = proc_get_vcoreid(p);
                        if (systrace_flags & SYSTRACE_LOUD) {
-                               printk("[%16llu] Syscall %3d (%12s):(%08p, %08p, %08p, %08p, "
-                                      "%08p, %08p) proc: %d core: %d vcore: %d\n", read_tsc(),
+                               printk("[%16llu] Syscall %3d (%12s):(%p, %p, %p, %p, "
+                                      "%p, %p) proc: %d core: %d vcore: %d\n", read_tsc(),
                                       sc_num, syscall_table[sc_num].name, a0, a1, a2, a3,
                                       a4, a5, p->pid, coreid, vcoreid);
                        } else {
@@ -1837,8 +1837,8 @@ void systrace_print(bool all, struct proc *p)
         * timestamp and loop around.  Careful of concurrent writes. */
        for (int i = 0; i < systrace_bufsize; i++)
                if (systrace_buffer[i].timestamp)
-                       printk("[%16llu] Syscall %3d (%12s):(%08p, %08p, %08p, %08p, %08p,"
-                              "%08p) proc: %d core: %d vcore: %d\n",
+                       printk("[%16llu] Syscall %3d (%12s):(%p, %p, %p, %p, %p,"
+                              "%p) proc: %d core: %d vcore: %d\n",
                               systrace_buffer[i].timestamp,
                               systrace_buffer[i].syscallno,
                               syscall_table[systrace_buffer[i].syscallno].name,
index bc76616..ffaa939 100644 (file)
@@ -578,7 +578,7 @@ void test_hello_world_handler(struct hw_trapframe *hw_tf, void *data)
        trapno = 0;
        #endif
 
-       cprintf("Incoming IRQ, ISR: %d on core %d with tf at 0x%08x\n",
+       cprintf("Incoming IRQ, ISR: %d on core %d with tf at %p\n",
                trapno, core_id(), hw_tf);
 }
 
@@ -673,8 +673,8 @@ void test_circ_buffer(void)
 
 static void test_km_handler(uint32_t srcid, long a0, long a1, long a2)
 {
-       printk("Received KM on core %d from core %d: arg0= 0x%08x, arg1 = "
-              "0x%08x, arg2 = 0x%08x\n", core_id(), srcid, a0, a1, a2);
+       printk("Received KM on core %d from core %d: arg0= %p, arg1 = %p, "
+              "arg2 = %p\n", core_id(), srcid, a0, a1, a2);
        return;
 }
 
@@ -905,10 +905,10 @@ void test_bcq(void)
        /* Helpful debugger */
        void print_a_bcq(struct my_bcq *bcq)
        {
-               printk("A BCQ (made of ints): %08p\n", bcq);
-               printk("\tprod_idx: %08p\n", bcq->hdr.prod_idx);
-               printk("\tcons_pub_idx: %08p\n", bcq->hdr.cons_pub_idx);
-               printk("\tcons_pvt_idx: %08p\n", bcq->hdr.cons_pvt_idx);
+               printk("A BCQ (made of ints): %p\n", bcq);
+               printk("\tprod_idx: %p\n", bcq->hdr.prod_idx);
+               printk("\tcons_pub_idx: %p\n", bcq->hdr.cons_pub_idx);
+               printk("\tcons_pvt_idx: %p\n", bcq->hdr.cons_pvt_idx);
                for (int i = 0; i < NR_ELEM_A_BCQ; i++) {
                        printk("Element %d, rdy_for_cons: %02p\n", i,
                               bcq->wraps[i].rdy_for_cons);
@@ -1211,7 +1211,7 @@ void test_radix_tree(void)
        assert((void*)0xdeadbeef == radix_lookup(tree, 3));
        for (int i = 5; i < 100; i++)
                if ((retval = radix_lookup(tree, i))) {
-                       printk("Extra item %08p at slot %d in tree %08p\n", retval, i,
+                       printk("Extra item %p at slot %d in tree %p\n", retval, i,
                               tree);
                        print_radix_tree(tree);
                        monitor(0);
@@ -1302,7 +1302,7 @@ void test_random_fs(void)
 static void __test_up_sem(uint32_t srcid, long a0, long a1, long a2)
 {
        struct semaphore *sem = (struct semaphore*)a0;
-       printk("[kmsg] Upping the sem to start the kthread, stacktop is %08p\n",
+       printk("[kmsg] Upping the sem to start the kthread, stacktop is %p\n",
                   get_stack_top());
        if (!sem_up(sem)) {
                printk("[kmsg] Crap, the sem didn't have a kthread waiting!\n");
@@ -1319,7 +1319,7 @@ void test_kthreads(void)
 {
        struct semaphore sem;
        sem_init(&sem, 1);              /* set to 1 to test the unwind */
-       printk("We're a kthread!  Stacktop is %08p.  Testing suspend, etc...\n",
+       printk("We're a kthread!  Stacktop is %p.  Testing suspend, etc...\n",
               get_stack_top());
        /* So we have something that will wake us up.  Routine messages won't get
         * serviced in the kernel right away. */
@@ -1332,7 +1332,7 @@ void test_kthreads(void)
        /* This one is for real, yo.  Run and tell that. */
        printk("About to sleep for real\n");
        sem_down(&sem);
-       printk("Kthread restarted!, Stacktop is %08p.\n", get_stack_top());
+       printk("Kthread restarted!, Stacktop is %p.\n", get_stack_top());
 }
 
 /* Second player's kmsg */
index e88c5ab..01bd896 100644 (file)
@@ -154,7 +154,7 @@ void print_kmsgs(uint32_t coreid)
                struct kernel_message *kmsg_i;
                STAILQ_FOREACH(kmsg_i, list, link) {
                        fn_name = get_fn_name((long)kmsg_i->pc);
-                       printk("%s KMSG on %d from %d to run %08p(%s)\n", type,
+                       printk("%s KMSG on %d from %d to run %p(%s)\n", type,
                               kmsg_i->dstid, kmsg_i->srcid, kmsg_i->pc, fn_name); 
                        kfree(fn_name);
                }
@@ -182,20 +182,20 @@ void kmsg_queue_stat(void)
                        printk("Immed msg on core %d:\n", i);
                        printk("\tsrc:  %d\n", kmsg->srcid);
                        printk("\tdst:  %d\n", kmsg->dstid);
-                       printk("\tpc:   %08p\n", kmsg->pc);
-                       printk("\targ0: %08p\n", kmsg->arg0);
-                       printk("\targ1: %08p\n", kmsg->arg1);
-                       printk("\targ2: %08p\n", kmsg->arg2);
+                       printk("\tpc:   %p\n", kmsg->pc);
+                       printk("\targ0: %p\n", kmsg->arg0);
+                       printk("\targ1: %p\n", kmsg->arg1);
+                       printk("\targ2: %p\n", kmsg->arg2);
                }
                if (!routine_emp) {
                        kmsg = STAILQ_FIRST(&per_cpu_info[i].routine_amsgs);
                        printk("Routine msg on core %d:\n", i);
                        printk("\tsrc:  %d\n", kmsg->srcid);
                        printk("\tdst:  %d\n", kmsg->dstid);
-                       printk("\tpc:   %08p\n", kmsg->pc);
-                       printk("\targ0: %08p\n", kmsg->arg0);
-                       printk("\targ1: %08p\n", kmsg->arg1);
-                       printk("\targ2: %08p\n", kmsg->arg2);
+                       printk("\tpc:   %p\n", kmsg->pc);
+                       printk("\targ0: %p\n", kmsg->arg0);
+                       printk("\targ1: %p\n", kmsg->arg1);
+                       printk("\targ2: %p\n", kmsg->arg2);
                }
                        
        }
index 59d49c7..aca23ca 100644 (file)
@@ -22,7 +22,7 @@ void send_ucq_msg(struct ucq *ucq, struct proc *p, struct event_msg *msg)
        /* So we can try to send ucqs to _Ss before they initialize */
        if (!ucq->ucq_ready) {
                if (p->state & (PROC_RUNNING_M | PROC_RUNNABLE_M))
-                       warn("proc %d is _M with an uninitialized ucq %08p\n", p->pid, ucq);
+                       warn("proc %d is _M with an uninitialized ucq %p\n", p->pid, ucq);
                return;
        }
        /* Bypass fetching/incrementing the counter if we're overflowing, helps
@@ -62,7 +62,7 @@ grab_lock:
        if (!new_page) {
                /* Warn if we have a ridiculous amount of pages in the ucq */
                if (atomic_fetch_and_add(&ucq->nr_extra_pgs, 1) > UCQ_WARN_THRESH)
-                       warn("Over %d pages in ucq %08p for pid %d!\n", UCQ_WARN_THRESH,
+                       warn("Over %d pages in ucq %p for pid %d!\n", UCQ_WARN_THRESH,
                             ucq, p->pid);
                /* Giant warning: don't ask for anything other than anonymous memory at
                 * a non-fixed location.  o/w, it may cause a TLB shootdown, which grabs
@@ -136,10 +136,10 @@ void print_ucq(struct proc *p, struct ucq *ucq)
        struct ucq_page *ucq_pg;
        struct proc *old_proc = switch_to(p);
 
-       printk("UCQ %08p\n", ucq);
-       printk("prod_idx: %08p, cons_idx: %08p\n", atomic_read(&ucq->prod_idx),
+       printk("UCQ %p\n", ucq);
+       printk("prod_idx: %p, cons_idx: %p\n", atomic_read(&ucq->prod_idx),
               atomic_read(&ucq->cons_idx));
-       printk("spare_pg: %08p, nr_extra_pgs: %d\n", atomic_read(&ucq->spare_pg),
+       printk("spare_pg: %p, nr_extra_pgs: %d\n", atomic_read(&ucq->spare_pg),
               atomic_read(&ucq->nr_extra_pgs));
        printk("prod_overflow: %d\n", ucq->prod_overflow);
        /* Try to see our previous ucqs */
@@ -148,12 +148,12 @@ void print_ucq(struct proc *p, struct ucq *ucq)
                /* only attempt to print messages on the same page */
                if (PTE_ADDR(i) != PTE_ADDR(atomic_read(&ucq->prod_idx)))
                        break;
-               printk("Prod idx %08p message ready is %08p\n", i, slot2msg(i)->ready);
+               printk("Prod idx %p message ready is %p\n", i, slot2msg(i)->ready);
        }
        /* look at the chain, starting from cons_idx */
        ucq_pg = (struct ucq_page*)PTE_ADDR(atomic_read(&ucq->cons_idx));
        for (int i = 0; i < 10 && ucq_pg; i++) {
-               printk("#%02d: Cons page: %08p, nr_cons: %d, next page: %08p\n", i,
+               printk("#%02d: Cons page: %p, nr_cons: %d, next page: %p\n", i,
                       ucq_pg, ucq_pg->header.nr_cons, ucq_pg->header.cons_next_pg);
                ucq_pg = (struct ucq_page*)(ucq_pg->header.cons_next_pg);
        }
index c3c3df6..1b88761 100644 (file)
@@ -243,7 +243,7 @@ static int follow_symlink(struct nameidata *nd)
                return 0;
        if (nd->depth > MAX_SYMLINK_DEPTH)
                return -ELOOP;
-       printd("Following symlink for dentry %08p %s\n", nd->dentry,
+       printd("Following symlink for dentry %p %s\n", nd->dentry,
               nd->dentry->d_name.name);
        nd->depth++;
        symname = nd->dentry->d_inode->i_op->readlink(nd->dentry);
@@ -668,7 +668,7 @@ void dentry_release(struct kref *kref)
 {
        struct dentry *dentry = container_of(kref, struct dentry, d_kref);
 
-       printd("'Releasing' dentry %08p: %s\n", dentry, dentry->d_name.name);
+       printd("'Releasing' dentry %p: %s\n", dentry, dentry->d_name.name);
        /* DYING dentries (recently unlinked / rmdir'd) just get freed */
        if (dentry->d_flags & DENTRY_DYING) {
                __dentry_free(dentry);
@@ -707,7 +707,7 @@ void dentry_release(struct kref *kref)
 void __dentry_free(struct dentry *dentry)
 {
        if (dentry->d_inode)
-               printk("Freeing dentry %08p: %s\n", dentry, dentry->d_name.name);
+               printk("Freeing dentry %p: %s\n", dentry, dentry->d_name.name);
        assert(dentry->d_op);   /* catch bugs.  a while back, some lacked d_op */
        dentry->d_op->d_release(dentry);
        /* TODO: check/test the boundaries on this. */