CLEANUP: Remove trailing whitespace throughout the kernel.
authorDan Cross <crossd@gmail.com>
Thu, 19 May 2016 18:06:26 +0000 (14:06 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 20 May 2016 19:21:47 +0000 (15:21 -0400)
This isn't a "trivial change for testing Git" change so much
as continuation of work due to observations made when making
those (earlier) changes: We may as well remove trailing
whitespace wherever it appears in the kernel in one go.

This change was generated by:

    : spitfire; sed -i '' 's/[  ]*$//' **/*.[chsS]

Change-Id: I9f8361f120eec25985e7d12b2bf9909d802cffdf
Tested: N/A (Whitespace only)
Signed-off-by: Dan Cross <crossd@gmail.com>
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
119 files changed:
kern/arch/riscv/arch.h
kern/arch/riscv/bitmask.h
kern/arch/riscv/boot.S
kern/arch/riscv/colored_caches.c
kern/arch/riscv/colored_page_alloc.h
kern/arch/riscv/fpu.c
kern/arch/riscv/init.c
kern/arch/riscv/page_alloc.c
kern/arch/riscv/setjmp.S
kern/arch/riscv/trap.c
kern/arch/x86/arch.h
kern/arch/x86/atomic.h
kern/arch/x86/bitmask.h
kern/arch/x86/bitops.h
kern/arch/x86/boot/boot.S
kern/arch/x86/boot/main.c
kern/arch/x86/colored_caches.c
kern/arch/x86/colored_page_alloc.h
kern/arch/x86/console.c
kern/arch/x86/entry64.S
kern/arch/x86/fixup.h
kern/arch/x86/io.h
kern/arch/x86/ioapic.c
kern/arch/x86/ioapic.h
kern/arch/x86/kdebug.c
kern/arch/x86/msi.c
kern/arch/x86/page_alloc.c
kern/arch/x86/pci.c
kern/arch/x86/pci.h
kern/arch/x86/pmap.c
kern/arch/x86/rdtsc_test.c
kern/arch/x86/setjmp64.S
kern/arch/x86/smp.c
kern/arch/x86/smp_entry64.S
kern/arch/x86/trap64.c
kern/arch/x86/usb.c
kern/drivers/dev/alarm.c
kern/drivers/dev/pci.c
kern/drivers/dev/root.c
kern/drivers/net/bnx2x/bnx2x_dev.c
kern/drivers/net/bnx2x/bnx2x_main.c
kern/drivers/net/ether8169.c
kern/drivers/net/etherigbe.c
kern/drivers/net/udrvr/compat.c
kern/include/alarm.h
kern/include/apipe.h
kern/include/arsc_server.h
kern/include/bitmask.h
kern/include/bitops.h
kern/include/bits/netinet.h
kern/include/colored_caches.h
kern/include/colored_page_alloc.h
kern/include/debug.h
kern/include/env.h
kern/include/frontend.h
kern/include/hashtable.h
kern/include/ip.h
kern/include/kmalloc.h
kern/include/ktest.h
kern/include/list.h
kern/include/mm.h
kern/include/multiboot.h
kern/include/page_alloc.h
kern/include/pagemap.h
kern/include/pmap.h
kern/include/process.h
kern/include/ros/atomic.h
kern/include/ros/bcq.h
kern/include/ros/bcq_struct.h
kern/include/ros/bits/syscall.h
kern/include/ros/fs.h
kern/include/ros/ring_buffer.h
kern/include/ros/ring_syscall.h
kern/include/ros/sysevent.h
kern/include/ros/ucq.h
kern/include/rwlock.h
kern/include/slab.h
kern/include/taskqueue.h
kern/include/test_infrastructure.h
kern/include/umem.h
kern/include/vfs.h
kern/include/zconf.h
kern/include/zlib.h
kern/lib/zlib_deflate/deflate.c
kern/lib/zlib_deflate/deftree.c
kern/lib/zlib_deflate/defutil.h
kern/lib/zlib_inflate/infutil.h
kern/src/alarm.c
kern/src/apipe.c
kern/src/arsc.c
kern/src/atomic.c
kern/src/bitmap.c
kern/src/blockdev.c
kern/src/colored_caches.c
kern/src/devfs.c
kern/src/elf.c
kern/src/env.c
kern/src/ext2fs.c
kern/src/frontend.c
kern/src/hashtable.c
kern/src/kmalloc.c
kern/src/ktest/pb_ktests.c
kern/src/kthread.c
kern/src/manager.c
kern/src/mm.c
kern/src/monitor.c
kern/src/multiboot.c
kern/src/net/udp.c
kern/src/ns/convM2D.c
kern/src/ns/convM2kdirent.c
kern/src/ns/qio.c
kern/src/ns/sysfile.c
kern/src/page_alloc.c
kern/src/pmap.c
kern/src/radix.c
kern/src/schedule.c
kern/src/slab.c
kern/src/string.c
kern/src/syscall.c

index db28f28..fdfaa86 100644 (file)
@@ -25,7 +25,7 @@ static __inline void tlbflush(void)
 }
 
 static __inline void invlpg(void *addr)
-{ 
+{
        tlbflush();
 }
 
@@ -101,7 +101,7 @@ static __inline void disable_irqsave(int8_t* state)
 {
        if ((*state == 0) && irq_is_enabled())
                disable_irq();
-       else 
+       else
                (*state)--;
 }
 
index f8a5cdd..d7123f7 100644 (file)
@@ -14,7 +14,7 @@
 #define BYTES_FOR_BITMASK_WITH_CHECK(size) \
        ((size) ? ((size) - (1)) / (8) + (1) : (0))
 
-static bool GET_BITMASK_BIT(uint8_t* name, size_t bit) 
+static bool GET_BITMASK_BIT(uint8_t* name, size_t bit)
 {
        return (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0);
 }
@@ -31,13 +31,13 @@ static void SET_BITMASK_BIT(uint8_t* name, size_t bit)
 #define CLR_BITMASK_BIT(name, bit) \
        ((name)[(bit)/8] &= ~(1 << ((bit) % 8)));
 /*
-static void CLR_BITMASK_BIT(uint8_t* name, size_t bit) 
+static void CLR_BITMASK_BIT(uint8_t* name, size_t bit)
 {
        ((name)[(bit)/8] &= ~(1 << ((bit) % 8)));
 }
 */
 
-static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit) 
+static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit)
 {
        (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))));
 }
@@ -54,7 +54,7 @@ static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit)
 ({ \
        memset((void*)((uintptr_t)(name)), 255, BYTES_FOR_BITMASK((size))); \
        (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
-}) 
+})
 
 #define COPY_BITMASK(newmask, oldmask, size) \
 ({ \
index b6354f4..7875200 100644 (file)
@@ -7,7 +7,7 @@
 
 ///////////////////////////////////////////////////////////////////
 // The kernel (this code) is linked at address 0xFFFFFFFF80000000,
-// but we tell the bootloader to load it at physical address 
+// but we tell the bootloader to load it at physical address
 // 0x00000000, which is the start of extended memory.
 // (See kernel.ld)
 ///////////////////////////////////////////////////////////////////
@@ -85,7 +85,7 @@ notcore0:
   add    sp, sp, a6
   li     a7, KERN_LOAD_ADDR
   sub    sp, sp, a7
-  
+
   jal    enable_mmu
 
   // relocate stack and call into C code
index 95f42aa..ce4a714 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 
 #include <colored_caches.h>
@@ -14,10 +14,10 @@ cache_t* llc_cache;
 available_caches_t available_caches;
 
 /************** Cache Related Functions  *****************/
-void cache_init() 
+void cache_init()
 {
        // Initialize the caches available on this system.
-       // TODO: Should call out to something reading the acpi tables from 
+       // TODO: Should call out to something reading the acpi tables from
        // memory, or something similar.  For now, just initialize them inline
        available_caches.l1 = &l1;
        available_caches.l2 = &l2;
index 54a591c..0b629f1 100644 (file)
@@ -1,12 +1,12 @@
 /*
- * Copyright (c) 2009 The Regents of the University  of California.  
- * See the COPYRIGHT files at the top of this source tree for full 
+ * Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
  */
 /**
  * @author Kevin Klues <klueska@cs.berkeley.edu>
  */
+
 #pragma once
 
 /********** Page Coloring Related Macros ************/
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l1)                  \
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l2)                  \
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
+
 #define DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LISTS()        \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l1)           \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l2)           \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
+
 #define DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTIONS()          \
        DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l1)             \
        DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l2)             \
@@ -41,7 +41,7 @@
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l1)       \
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l2)       \
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l3)
-       
+
 #define INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LISTS(page)      \
        INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l1)       \
        INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l2)       \
index e66b1f9..e2b0c2e 100644 (file)
@@ -108,7 +108,7 @@ static int emulate_fpu_silly(struct hw_trapframe *state,
        */
        else
          return 1;
-       
+
        silly->fsr = sf.float_rounding_mode << 5 | sf.float_exception_flags;
        return 0;
 }
index d810da7..1c53b15 100644 (file)
@@ -5,7 +5,7 @@
 #include <arch/console.h>
 
 void arch_init()
-{              
+{
        smp_boot();
        proc_init();
 }
index c2f207b..111e977 100644 (file)
@@ -1,10 +1,10 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
+
 #include <sys/queue.h>
 #include <page_alloc.h>
 #include <pmap.h>
@@ -18,8 +18,8 @@ spinlock_t colored_page_free_list_lock = SPINLOCK_INITIALIZER_IRQSAVE;
 /*
  * Initialize the memory free lists.
  * After this point, ONLY use the functions below
- * to allocate and deallocate physical memory via the 
- * page_free_lists. 
+ * to allocate and deallocate physical memory via the
+ * page_free_lists.
  */
 void page_alloc_init(struct multiboot_info *mbi)
 {
@@ -31,7 +31,7 @@ void page_alloc_init(struct multiboot_info *mbi)
        size_t num_colors = llc_cache->num_colors;
        for (size_t i = 0; i < num_colors; i++)
                BSD_LIST_INIT(&lists[i]);
-       
+
        uintptr_t first_free_page = ROUNDUP(boot_freemem, PGSIZE);
        uintptr_t first_invalid_page = LA2PPN(boot_freelimit);
        assert(first_invalid_page == max_nr_pages);
@@ -39,7 +39,7 @@ void page_alloc_init(struct multiboot_info *mbi)
        // mark kernel pages as in-use
        for (uintptr_t page = 0; page < first_free_page; page++)
                page_setref(&pages[page], 1);
-       
+
        // append other pages to the free lists
        for (uintptr_t page = first_free_page; page < first_invalid_page; page++)
        {
index 56f867d..c46f8d4 100644 (file)
@@ -10,7 +10,7 @@
 .type slim_setjmp, @function
 slim_setjmp:
        ret
-       
+
 .size slim_setjmp,.-slim_setjmp
 
 .text
@@ -19,5 +19,5 @@ slim_setjmp:
 .type longjmp, @function
 longjmp:
        ret
-       
+
 .size longjmp,.-longjmp
index b41cd3e..ed6fa7e 100644 (file)
@@ -94,14 +94,14 @@ format_trapframe(struct hw_trapframe *hw_tf, char* buf, int bufsz)
          "v0", "v1", "a0", "a1", "a2", "a3", "a4", "a5",
          "a6", "a7", "a8", "a9", "aA", "aB", "aC", "aD"
        };
-       
+
        hw_tf->gpr[0] = 0;
-       
+
        for(int i = 0; i < 32; i+=4)
        {
                for(int j = 0; j < 4; j++)
                        len += snprintf(buf+len, bufsz-len,
-                                       "%s %016lx%c", regnames[i+j], hw_tf->gpr[i+j], 
+                                       "%s %016lx%c", regnames[i+j], hw_tf->gpr[i+j],
                                        j < 3 ? ' ' : '\n');
        }
        len += snprintf(buf+len, bufsz-len,
@@ -316,7 +316,7 @@ handle_trap(struct hw_trapframe *hw_tf)
          [IRQ_HOST] = handle_host_interrupt,
          [IRQ_IPI] = handle_interprocessor_interrupt,
        };
-       
+
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        if (hw_tf->cause < 0)
        {
@@ -347,7 +347,7 @@ handle_trap(struct hw_trapframe *hw_tf)
                #warning "if a trap wasn't handled fully, like an MCP pf, reflect it
                reflect_unhandled_trap(hw_tf->tf_trapno, hw_tf->tf_err, aux);
        }
-       
+
        extern void pop_hw_tf(struct hw_trapframe *tf); /* in asm */
        /* Return to the current process, which should be runnable.  If we're the
         * kernel, we should just return naturally.  Note that current and tf need
index aeb9cb5..20efdf9 100644 (file)
@@ -121,7 +121,7 @@ static inline void disable_irqsave(int8_t *state)
 {
        if ((*state == 0) && irq_is_enabled())
                disable_irq();
-       else 
+       else
                (*state)--;
 }
 
index 2aebdba..ca8ebfa 100644 (file)
@@ -133,7 +133,7 @@ static inline void __spin_lock_raw(volatile uint32_t *rlock)
                        "       je 2f;                "
                        "       pause;                "
                        "       jmp 1b;               "
-                       "2:                       " 
+                       "2:                       "
                        "       movb $1, %1;          "
                        "       xchgb %1, %0;         "
                        "       cmpb $0, %1;          "
index 10738d3..be6e6be 100644 (file)
@@ -14,7 +14,7 @@
 #define BYTES_FOR_BITMASK_WITH_CHECK(size) \
        ((size) ? ((size) - (1)) / (8) + (1) : (0))
 
-static bool GET_BITMASK_BIT(uint8_t* name, size_t bit) 
+static bool GET_BITMASK_BIT(uint8_t* name, size_t bit)
 {
        return (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0);
 }
@@ -31,13 +31,13 @@ static void SET_BITMASK_BIT(uint8_t* name, size_t bit)
 #define CLR_BITMASK_BIT(name, bit) \
        ((name)[(bit)/8] &= ~(1 << ((bit) % 8)));
 /*
-static void CLR_BITMASK_BIT(uint8_t* name, size_t bit) 
+static void CLR_BITMASK_BIT(uint8_t* name, size_t bit)
 {
        ((name)[(bit)/8] &= ~(1 << ((bit) % 8)));
 }
 */
 
-static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit) 
+static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit)
 {
        (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))));
 }
@@ -54,7 +54,7 @@ static void SET_BITMASK_BIT_ATOMIC(uint8_t* name, size_t bit)
 ({ \
        memset((void*)((uintptr_t)(name)), 255, BYTES_FOR_BITMASK((size))); \
        (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
-}) 
+})
 
 #define COPY_BITMASK(newmask, oldmask, size) \
 ({ \
index 86b12ac..e113e31 100644 (file)
@@ -87,7 +87,7 @@ static inline void __set_bit(int nr, volatile unsigned long *addr)
  * not contain a memory barrier, so if it is used for locking purposes,
  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  * in order to ensure changes are visible on other processors.
- * 
+ *
  * Note from brho: I think the use of LOCK_PREFIX (assuming it is "lock")
  * provides a memory barrier against hardware reordering accesses around the
  * LOCK ("lock" serializes).  This lacks a cmb() (called a barrier() in Linux),
index 22c2fef..4064d4d 100644 (file)
@@ -1,23 +1,23 @@
 #include <arch/mmu.h>
-       
+
 .set PROT_MODE_CSEG,0x8                # code segment selector
 .set PROT_MODE_DSEG,0x10        # data segment selector
 .set CR0_PE_ON,0x1             # protected mode enable flag
-       
+
 ###############################################################################
-# ENTRY POINT  
+# ENTRY POINT
 #   This code should be stored in the first sector of the hard disk.
 #   After the BIOS initializes the hardware on startup or system reset,
 #   it loads this code at physical address 0x7c00 - 0x7d00 (512 bytes).
 #   Then the BIOS jumps to the beginning of it, address 0x7c00,
 #   while running in 16-bit real-mode (8086 compatibility mode).
 #   The Code Segment register (CS) is initially zero on entry.
-#      
+#
 # This code switches into 32-bit protected mode so that all of
 # memory can accessed, then calls into C.
 ###############################################################################
-       
-.globl start                                   # Entry point   
+
+.globl start                                   # Entry point
 start:         .code16                         # This runs in real mode
                cli                             # Disable interrupts
                cld                             # String operations increment
@@ -30,7 +30,7 @@ start:                .code16                         # This runs in real mode
 
                # Set up the stack pointer, growing downward from 0x7c00.
                movw    $start,%sp              # Stack Pointer
-       
+
 # Enable A20:
 #   For fascinating historical reasons (related to the fact that
 #   the earliest 8086-based PCs could only address 1MB of physical memory
@@ -38,7 +38,7 @@ start:                .code16                         # This runs in real mode
 #   physical address line 20 is tied to low when the machine boots.
 #   Obviously this a bit of a drag for us, especially when trying to
 #   address memory above 1MB.  This code undoes this.
-       
+
 seta20.1:      inb     $0x64,%al               # Get status
                testb   $0x2,%al                # Busy?
                jnz     seta20.1                # Yes
@@ -73,7 +73,7 @@ real_to_prot: cli                     # Don't allow interrupts: mandatory,
                # instruction, but simultaneously loads CS with
                # $PROT_MODE_CSEG.
                ljmp    $PROT_MODE_CSEG, $protcseg
-       
+
                # we've switched to 32-bit protected mode; tell the assembler
                # to generate code for that mode
 protcseg:      .code32
@@ -84,15 +84,15 @@ protcseg:   .code32
                movw    %ax, %fs                # -> FS
                movw    %ax, %gs                # -> GS
                movw    %ax, %ss                # -> SS: Stack Segment
-       
+
                call cmain                      # finish the boot load from C.
                                                # cmain() should not return
 spin:          jmp spin                        # ..but in case it does, spin
-       
+
                .p2align 2                      # force 4 byte alignment
 gdt:           SEG_NULL                                # null seg
                SEG(STA_X|STA_R, 0x0, 0xffffffff)       # code seg
                SEG(STA_W, 0x0, 0xffffffff)             # data seg
-       
+
 gdtdesc:       .word   0x17                    # sizeof(gdt) - 1
                .long   gdt                     # address gdt
index c05a00d..a42d289 100644 (file)
@@ -9,16 +9,16 @@
  * DISK LAYOUT
  *  * This program(boot.S and main.c) is the bootloader.  It should
  *    be stored in the first sector of the disk.
- * 
+ *
  *  * The 2nd sector onward holds the kernel image.
- *     
+ *
  *  * The kernel image must be in ELF format.
  *
- * BOOT UP STEPS       
+ * BOOT UP STEPS
  *  * when the CPU boots it loads the BIOS into memory and executes it
  *
  *  * the BIOS intializes devices, sets of the interrupt routines, and
- *    reads the first sector of the boot device(e.g., hard-drive) 
+ *    reads the first sector of the boot device(e.g., hard-drive)
  *    into memory and jumps to it.
  *
  *  * Assuming this boot loader is stored in the first sector of the
@@ -74,7 +74,7 @@ readseg(uint32_t va, uint32_t count, uint32_t offset)
 
        va &= 0x0FFFFFFF;
        end_va = va + count;
-       
+
        // round down to sector boundary
        va &= ~(SECTSIZE - 1);
 
@@ -105,9 +105,9 @@ readsect(void *dst, uint32_t offset)
        // wait for disk to be ready
        waitdisk();
 
-       /* the ISA uses a specified block of memory, 
-          addresses 0x1F0-0x1F7, that can use the special 
-          instructions inb/outb, as demonstrated in the 
+       /* the ISA uses a specified block of memory,
+          addresses 0x1F0-0x1F7, that can use the special
+          instructions inb/outb, as demonstrated in the
           following code in order to access the disk
           Offset is 28 bytes long
        */
index c07637a..11c4259 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 
 #include <error.h>
@@ -20,10 +20,10 @@ cache_t* llc_cache;
 available_caches_t available_caches;
 
 /************** Cache Related Functions  *****************/
-void cache_init() 
+void cache_init()
 {
        // Initialize the caches available on this system.
-       // TODO: Should call out to something reading the acpi tables from 
+       // TODO: Should call out to something reading the acpi tables from
        // memory, or something similar.  For now, just initialize them inline
        available_caches.l1 = &l1;
        available_caches.l2 = &l2;
index 54a591c..0b629f1 100644 (file)
@@ -1,12 +1,12 @@
 /*
- * Copyright (c) 2009 The Regents of the University  of California.  
- * See the COPYRIGHT files at the top of this source tree for full 
+ * Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
  */
 /**
  * @author Kevin Klues <klueska@cs.berkeley.edu>
  */
+
 #pragma once
 
 /********** Page Coloring Related Macros ************/
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l1)                  \
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l2)                  \
        DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
+
 #define DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LISTS()        \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l1)           \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l2)           \
        DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
+
 #define DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTIONS()          \
        DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l1)             \
        DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l2)             \
@@ -41,7 +41,7 @@
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l1)       \
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l2)       \
        REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l3)
-       
+
 #define INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LISTS(page)      \
        INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l1)       \
        INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l2)       \
index 59503ee..680471d 100644 (file)
@@ -150,7 +150,7 @@ static char *__serial_detect_type(int com)
 }
 
 /* Helper: attempts to initialize the serial device cdev with COM com.  If it
- * succeeds, the cdev will be on the cdev_list. */ 
+ * succeeds, the cdev will be on the cdev_list. */
 static void serial_com_init(struct cons_dev *cdev, int com)
 {
        cdev->model = __serial_detect_type(com);
@@ -274,7 +274,7 @@ cga_init(void)
                *cp = was;
                addr_6845 = CGA_BASE;
        }
-       
+
        /* Extract cursor location */
        outb(addr_6845, 14);
        pos = inb(addr_6845 + 1) << 8;
@@ -292,7 +292,7 @@ static void set_screen(uint8_t screen_num)
 {
        uint16_t leftovers = (scrolling_crt_pos % CRT_COLS);
        leftovers = (leftovers) ? CRT_COLS - leftovers : 0;
-       
+
        int offset = scrolling_crt_pos + leftovers - (screen_num + 1)*CRT_SIZE;
        offset = (offset > 0) ? offset : 0;
 
@@ -308,7 +308,7 @@ static void scroll_screen_up(void)
 
 static void scroll_screen_down(void)
 {
-       if(current_crt_buf > 0) 
+       if(current_crt_buf > 0)
                current_crt_buf--;
        set_screen(current_crt_buf);
 }
@@ -377,7 +377,7 @@ cga_putc(int c)
        if (scrolling_crt_pos >= SCROLLING_CRT_SIZE) {
                int i;
 
-               memcpy(scrolling_crt_buf, scrolling_crt_buf + CRT_COLS, 
+               memcpy(scrolling_crt_buf, scrolling_crt_buf + CRT_COLS,
                       (SCROLLING_CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
                for (i = SCROLLING_CRT_SIZE - CRT_COLS; i < SCROLLING_CRT_SIZE; i++)
                        scrolling_crt_buf[i] = 0x0700 | ' ';
@@ -407,7 +407,7 @@ cga_putc(int c)
 
 #define E0ESC          (1<<6)
 
-static uint8_t shiftcode[256] = 
+static uint8_t shiftcode[256] =
 {
        [0x1D] CTL,
        [0x2A] SHIFT,
@@ -417,7 +417,7 @@ static uint8_t shiftcode[256] =
        [0xB8] ALT
 };
 
-static uint8_t togglecode[256] = 
+static uint8_t togglecode[256] =
 {
        [0x3A] CAPSLOCK,
        [0x45] NUMLOCK,
@@ -445,7 +445,7 @@ static uint8_t normalmap[256] =
        [0xD2] KEY_INS,         [0xD3] KEY_DEL
 };
 
-static uint8_t shiftmap[256] = 
+static uint8_t shiftmap[256] =
 {
        NO,   033,  '!',  '@',  '#',  '$',  '%',  '^',  // 0x00
        '&',  '*',  '(',  ')',  '_',  '+',  '\b', '\t',
@@ -468,13 +468,13 @@ static uint8_t shiftmap[256] =
 
 #define C(x) (x - '@')
 
-static uint8_t ctlmap[256] = 
+static uint8_t ctlmap[256] =
 {
-       NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO, 
-       NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO, 
+       NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO,
+       NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO,
        C('Q'),  C('W'),  C('E'),  C('R'),  C('T'),  C('Y'),  C('U'),  C('I'),
        C('O'),  C('P'),  NO,      NO,      '\r',    NO,      C('A'),  C('S'),
-       C('D'),  C('F'),  C('G'),  C('H'),  C('J'),  C('K'),  C('L'),  NO, 
+       C('D'),  C('F'),  C('G'),  C('H'),  C('J'),  C('K'),  C('L'),  NO,
        NO,      NO,      NO,      C('\\'), C('Z'),  C('X'),  C('C'),  C('V'),
        C('B'),  C('N'),  C('M'),  NO,      NO,      C('/'),  NO,      NO,
        [0x97] KEY_HOME,
index e71629f..65141c9 100644 (file)
@@ -44,7 +44,7 @@ multiboot_header:
 /* Helper: creates count mappings in the PML3 for 1GB jumbo pages for the given
  * vaddr to paddr range in physical memory.  Then it puts that PML3's addr in
  * the PML4's appropriate slot.  Using a macro mostly to help with 64 bit
- * argument marshalling.  
+ * argument marshalling.
  *
  * This will clobber ax, dx, cx, di, si.
  *
@@ -95,7 +95,7 @@ map_gb_pages:
        call    insert_pml3
        pop             %ebx
        ret
-       
+
 # Fills pml3 with "count" jumbo entries, mapping from vaddr -> paddr.
 # pml3s are responsible for bits 38..30 of vaddr space and 30 bit paddr entries
 #
@@ -127,7 +127,7 @@ fill_jpml3:
        jnz             1b
        pop             %ebx
        ret
-       
+
 #define MAP_2MB_PAGES(pml3, vaddr, paddr, count, pml2base)                     \
        movl    $(pml2base), %eax;                                                 \
        push    %eax;                                                              \
@@ -169,7 +169,7 @@ map_2mb_pages:
        call    insert_pml3
        pop             %ebx
        ret
-       
+
 # Fills pml3 with "count" pml2 entries, mapping from vaddr -> paddr.
 # pml3s are responsible for bits 38..30 of vaddr space and 30 bit paddr entries
 #
@@ -331,8 +331,8 @@ post_mapping:
        # Setup cr0.  PE and PG are critical for now.  The others are similar to
        # what we want in general (-AM with 64 bit, it's useless).
        movl    %cr0, %eax
-       orl             $(CR0_PE | CR0_PG | CR0_WP | CR0_NE | CR0_MP), %eax  
-       andl    $(~(CR0_AM | CR0_TS | CR0_EM | CR0_CD | CR0_NW)), %eax  
+       orl             $(CR0_PE | CR0_PG | CR0_WP | CR0_NE | CR0_MP), %eax
+       andl    $(~(CR0_AM | CR0_TS | CR0_EM | CR0_CD | CR0_NW)), %eax
        movl    %eax, %cr0
        pop             %ebx                            # restore multiboot info
        # load the 64bit GDT and jump to long mode
index c9fcc85..dce9b91 100644 (file)
@@ -21,4 +21,4 @@
     " .popsection\n"
 
 #define ASM_STAC
-#define ASM_CLAC
\ No newline at end of file
+#define ASM_CLAC
index 342dd2a..b077731 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
index b0ccff9..128aa78 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
index eff662e..a04ed91 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
index 2d3ba0d..9254765 100644 (file)
@@ -97,10 +97,10 @@ stab_binsearch(const stab_t *stabs,
               int type, uintptr_t addr)
 {
        int l = *region_left, r = *region_right, any_matches = 0;
-       
+
        while (l <= r) {
                int true_m = (l + r) / 2, m = true_m;
-               
+
                // search for earliest stab with right type
                while (m >= l && stabs[m].n_type != type)
                        m--;
@@ -202,7 +202,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        // 'eip'.  First, we find the basic source file containing 'eip'.
        // Then, we look in that source file for the function.  Then we look
        // for the line number.
-       
+
        // Search the entire set of stabs for the source file (type N_SO).
        lfile = 0;
        rfile = (stab_end - stabs) - 1;
@@ -235,7 +235,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        }
        // Ignore stuff after the colon.
        info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
-       
+
        // Search within [lline, rline] for the line number stab.
        // If found, set info->eip_line to the right line number.
        // If not found, return -1.
@@ -247,12 +247,12 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        // Your code here.
 
        stab_binsearch(stabs, stab_end, &lline, &rline, N_SLINE, addr);
-       if (lline <= rline) 
+       if (lline <= rline)
                // stabs[lline] points to the line number
                info->eip_line = stabs[lline].n_value;
        else
                return -1;
-       
+
        // Search backwards from the line number for the relevant filename
        // stab.
        // We can't just use the "lfile" stab because inlined functions
@@ -274,7 +274,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
                while (stabs[lfun++].n_type == N_PSYM)
                        info->eip_fn_narg++;
        }
-       
+
        return 0;
 }
 
index e792f2e..3e704d9 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
@@ -172,7 +172,7 @@ int pci_msi_enable(struct pci_device *p, uint64_t vec)
                return -1;
        }
 
-       /* read it, clear out the Mmesgmsk bits. 
+       /* read it, clear out the Mmesgmsk bits.
         * This means that there will be no multiple
         * messages enabled.
         */
@@ -236,7 +236,7 @@ static uintptr_t msix_get_capbar_paddr(struct pci_device *p, int offset)
 {
        uint32_t bir, capbar_off;
        uintptr_t membar;
-       
+
        bir = pcidev_read32(p, offset);
        capbar_off = bir & ~0x7;
        bir &= 0x7;
index da3d8b0..2729e49 100644 (file)
@@ -1,7 +1,7 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
+ *
  * Barret Rhoden <brho@cs.berkeley.edu>
  * Kevin Klues <klueska@cs.berkeley.edu> */
 
index c9caebe..127be3e 100644 (file)
@@ -196,7 +196,7 @@ void pci_init(void)
                                dev_id = result >> 16;
                                ven_id = result & 0xffff;
                                /* Skip invalid IDs (not a device) */
-                               if (ven_id == INVALID_VENDOR_ID) 
+                               if (ven_id == INVALID_VENDOR_ID)
                                        break;  /* skip functions too, they won't exist */
                                pcidev = kzmalloc(sizeof(struct pci_device), 0);
                                /* we don't need to lock it til we post the pcidev to the list*/
index 262a6d5..a1f40b9 100644 (file)
@@ -11,7 +11,7 @@
 #include <atomic.h>
 #include <arch/pci_regs.h>
 
-#define pci_debug(...)  printk(__VA_ARGS__)  
+#define pci_debug(...)  printk(__VA_ARGS__)
 
 #define PCI_CONFIG_ADDR     0xCF8
 #define PCI_CONFIG_DATA     0xCFC
index 54c58a1..b0c0e69 100644 (file)
@@ -85,18 +85,18 @@ static void pat_init(void)
 }
 
 // could consider having an API to allow these to dynamically change
-// MTRRs are for physical, static ranges.  PAT are linear, more granular, and 
+// MTRRs are for physical, static ranges.  PAT are linear, more granular, and
 // more dynamic
 void setup_default_mtrrs(barrier_t* smp_barrier)
 {
        // disable interrupts
        int8_t state = 0;
        disable_irqsave(&state);
-       // barrier - if we're meant to do this for all cores, we'll be 
+       // barrier - if we're meant to do this for all cores, we'll be
        // passed a pointer to an initialized barrier
        if (smp_barrier)
                waiton_barrier(smp_barrier);
-       
+
        // disable caching      cr0: set CD and clear NW
        lcr0((rcr0() | CR0_CD) & ~CR0_NW);
        // flush caches
@@ -104,7 +104,7 @@ void setup_default_mtrrs(barrier_t* smp_barrier)
        // flush tlb
        tlb_flush_global();
        // disable MTRRs, and sets default type to WB (06)
-#ifndef CONFIG_NOMTRRS 
+#ifndef CONFIG_NOMTRRS
        write_msr(IA32_MTRR_DEF_TYPE, 0x00000006);
 
        // Now we can actually safely adjust the MTRRs
@@ -117,8 +117,8 @@ void setup_default_mtrrs(barrier_t* smp_barrier)
        write_msr(IA32_MTRR_PHYSBASE1, PTE_ADDR(DEVPHYSMEM) | 0x00);
        write_msr(IA32_MTRR_PHYSMASK1, 0x0000000ffffc0800);
        // APIC/IOAPIC holes
-       /* Going to skip them, since we set their mode using PAT when we 
-        * map them in 
+       /* Going to skip them, since we set their mode using PAT when we
+        * map them in
         */
        // make sure all other MTRR ranges are disabled (should be unnecessary)
        write_msr(IA32_MTRR_PHYSMASK2, 0);
@@ -130,7 +130,7 @@ void setup_default_mtrrs(barrier_t* smp_barrier)
 
        // keeps default type to WB (06), turns MTRRs on, and turns off fixed ranges
        write_msr(IA32_MTRR_DEF_TYPE, 0x00000806);
-#endif 
+#endif
        pat_init();
        // reflush caches and TLB
        cache_flush();
index 7d2f1ee..c591d35 100644 (file)
  * min is less than 'normal', means that we could get negative numbers for some
  * measurements (the goal is to determine the overhead and subtract that from
  * our total measurement, and if we think the overhead is 32 but was actually 28
- * for a run, we could have issues). 
+ * for a run, we could have issues).
  *
  * But wait, there's more:
- * 
+ *
  * When we add code around (and inside) the measurement, things get even worse:
  * - If we put variable (a volatile btw) = j + i; in the loop, there's no real
  *   change.  I checked cases 1, 4 and 5, 1 being the intel recommended, 4 being
  * the cost of instructions regardless of whether or not the first or last
  * commands are rdtscp (I'm more concerned with the end time call, which is
  * where this hiding may be happening).  Perhaps the pipeline needs to be
- * drained (or something), and it takes a certain amount of time to do so, 
+ * drained (or something), and it takes a certain amount of time to do so,
  * regardless of a few extra instructions squeezed in.  Meaning we can't tell
  * the difference between 0 and a few cycles, and probably a few cycles are
- * 'free' / hidden by the rdtsc call. 
+ * 'free' / hidden by the rdtsc call.
  *
  * Bottom line?  Our measurements are inexact, despite the stable minimum and
  * low variance.  Everything will be +/- our max deviation, as well as
  * within their execution.  rdtsc probably takes its measurement earlier in the
  * instruction (~16-20 cycles/ticks earlier perhaps?), based on the 48->28
  * back-side step and the front-side 28->44 step.
- *             
+ *
  * Anyway, what matters is a relatively stable method without a lot of variance
  * that has a solid floor/min that we can detect at runtime (to run tests on a
  * given machine).  Using rdtscp for the start measurement seems unreliable
@@ -460,10 +460,10 @@ static inline void filltimes(uint64_t **times, unsigned int loop_bound,
                                                 :
                                                 : "%eax", "%ebx", "%ecx", "%edx");
                        #endif
-                       
+
                        start = ( ((uint64_t)start_high << 32) | start_low );
                        end = ( ((uint64_t)end_high << 32) | end_low );
-                       
+
                        if ( (int64_t)(end - start) < 0) {
                                printk("CRITICAL ERROR IN TAKING THE TIME!!!!!!\n"
                        "loop(%d) stat(%d) start = %llu, end = %llu, "
@@ -520,9 +520,9 @@ int test_rdtsc(unsigned int loop_bound, unsigned int stat_size)
        uint64_t tot_var = 0, max_dev_all = 0, var_of_vars = 0, var_of_mins = 0;
        loop_bound = loop_bound ?: LOOP_BOUND_DEF;
        stat_size = stat_size ?: STAT_SIZE_DEF;
-       
+
        printk("Running rdtsc tests...\n");
-       
+
        times = kmalloc(loop_bound * sizeof(uint64_t*), 0);
        if (!times) {
                printk("unable to allocate memory for times\n");
@@ -538,21 +538,21 @@ int test_rdtsc(unsigned int loop_bound, unsigned int stat_size)
                        return 0;
                }
        }
-       
+
        variances = kmalloc(loop_bound * sizeof(uint64_t), 0);
        if (!variances) {
                printk("unable to allocate memory for variances\n");
                // not bothering to free **times
                return 0;
        }
-       
+
        min_values = kmalloc(loop_bound * sizeof(uint64_t), 0);
        if (!min_values) {
                printk("unable to allocate memory for min_values\n");
                // not bothering to free **times or variances
                return 0;
        }
-       
+
        disable_irqsave(&state);
 
        filltimes(times, loop_bound, stat_size);
@@ -563,7 +563,7 @@ int test_rdtsc(unsigned int loop_bound, unsigned int stat_size)
                max_dev = 0;
                min_time = 0;
                max_time = 0;
-       
+
                for (i = 0; i < stat_size; i++) {
                        if ((min_time == 0) || (min_time > times[j][i]))
                                min_time = times[j][i];
@@ -578,23 +578,23 @@ int test_rdtsc(unsigned int loop_bound, unsigned int stat_size)
                        max_dev_all = max_dev;
                variances[j] = var_calc(times[j], stat_size);
                tot_var += variances[j];
-               
+
                printk("loop_size:%d >>>> variance(cycles): %llu; "
                "max_deviation: %llu; min time: %llu\n", j, variances[j],
                max_dev, min_time);
                prev_min = min_time;
        }
-       
+
        var_of_vars = var_calc(variances, loop_bound);
        var_of_mins = var_calc(min_values, loop_bound);
-       
+
        printk("total number of spurious min values = %d\n", spurious);
        /* is this next one the mean variance, not the total? */
        printk("total variance = %llu\n", (tot_var/loop_bound));
        printk("absolute max deviation = %llu\n", max_dev_all);
        printk("variance of variances = %llu\n", var_of_vars);
        printk("variance of minimum values = %llu\n", var_of_mins);
-       
+
        for (j = 0; j < loop_bound; j++) {
                kfree(times[j]);
        }
@@ -625,7 +625,7 @@ bool check_timing_stability(void)
        /* 2mil detected an SMI about 95% of the time on my nehalem. */
        for (int i = 0; i < 3000000; i++) {
                start = read_tsc_serialized();
-               for (int j = 0; j < 500; j++) 
+               for (int j = 0; j < 500; j++)
                        dummy = j;
                end = read_tsc_serialized();
                if ((int64_t)(end - start) < 0) {
index 22ce081..37d67f1 100644 (file)
@@ -22,10 +22,10 @@ slim_setjmp:
        pop  %rsi          # Temporarily grab the return address and adjust %rsp
        movq %rsi,(%rdi)   # Save the return address
        movq %rsp,8(%rdi)  # The adjusted %rsp is the post-return %rsp (see longjmp)
-       movq %rbp,16(%rdi) 
+       movq %rbp,16(%rdi)
        push %rsi          # Restore stuff to make the call/return stack happy
        ret
-       
+
 .size slim_setjmp,.-slim_setjmp
 
 .text
@@ -37,5 +37,5 @@ longjmp:
        movq 16(%rdi),%rbp
        movq 8(%rdi),%rsp  # Set the post-return %rsp
        jmp *(%rdi)        # Jump back to setjmp callsite (no ret necessary)
-       
+
 .size longjmp,.-longjmp
index cba0cf4..1020112 100644 (file)
@@ -168,7 +168,7 @@ int smp_call_function_single(uint32_t dest, isr_t handler, void *data,
 }
 
 // If you want to wait, pass the address of a pointer up above, then call
-// this to do the actual waiting.  Be somewhat careful about uninitialized 
+// this to do the actual waiting.  Be somewhat careful about uninitialized
 // or old wrapper pointers.
 int smp_call_wait(handler_wrapper_t* wrapper)
 {
index 4255690..6c9e350 100644 (file)
@@ -59,8 +59,8 @@ protcseg:
        # Setup cr0.  PE and PG are critical for now.  The others are similar to
        # what we want in general (-AM with 64 bit, it's useless).
        movl    %cr0, %eax
-       orl             $(CR0_PE | CR0_PG | CR0_WP | CR0_NE | CR0_MP), %eax  
-       andl    $(~(CR0_AM | CR0_TS | CR0_EM | CR0_CD | CR0_NW)), %eax  
+       orl             $(CR0_PE | CR0_PG | CR0_WP | CR0_NE | CR0_MP), %eax
+       andl    $(~(CR0_AM | CR0_TS | CR0_EM | CR0_CD | CR0_NW)), %eax
        movl    %eax, %cr0
        # load the 64bit GDT and jump to long mode (symbol from entry64)
        lgdt    gdt64desc
@@ -117,6 +117,6 @@ smp_boot_lock:                                                      # this lock word will be only used from
        .word   0                                                       # its spot in the trampoline (0x1000)
 .globl                 smp_semaphore
 smp_semaphore:                                                 # poor man's polling semaphore
-       .word   0                                                       
+       .word   0
 .globl                 smp_entry_end
 smp_entry_end:
index 2d7c14f..9d51285 100644 (file)
@@ -69,7 +69,7 @@ void print_trapframe(struct hw_trapframe *hw_tf)
        pcpui->__lock_checking_enabled++;
 
        /* Used in trapentry64.S */
-       static_assert(offsetof(struct hw_trapframe, tf_cs) - 
+       static_assert(offsetof(struct hw_trapframe, tf_cs) -
                      offsetof(struct hw_trapframe, tf_rax) == 0x90);
        static_assert(offsetof(struct hw_trapframe, tf_padding0) -
                      offsetof(struct hw_trapframe, tf_rax) == 0xac);
index 1555bae..83ad56d 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
index a50e65e..dc8b0a9 100644 (file)
@@ -169,7 +169,7 @@ static int alarmgen(struct chan *c, char *entry_name,
                        }
                        s--;    /* 1 -> 0th element, 2 -> 1st element, etc */
                        /* Gets the s-th element (0 index)
-                        * 
+                        *
                         * I would like to take advantage of the state machine and our
                         * previous answer to get the sth element of the list.  We can get
                         * at our previous run of gen from dp (struct dir), and use that to
index 52953e2..ab1618b 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
index 75c924d..85a5f7b 100644 (file)
@@ -78,12 +78,12 @@ int inumber = 13;
  * *sizep is a pointer for reasons not understood.
  * next is the sibling. For a dir, it's the first element after '.'.
  *     int     dotdot;
- *      int     child; 
+ *      int     child;
  *     void    *ptr;
  *     int     size;
  *     int     *sizep;
- * 
- * entry is empty if type is 0. We look in roottab to determine that. 
+ *
+ * entry is empty if type is 0. We look in roottab to determine that.
 */
 /* we pack the qid as follows: path is the index, vers is ., and type is type */
 
@@ -367,7 +367,7 @@ static void rootcreate(struct chan *c, char *name, int omode, uint32_t perm)
        /* need to filter openmode so that it gets only the access-type bits */
        omode = openmode(omode);
        c->mode = openmode(omode);
-       printd("rootcreate: c %p, name %s, omode %o, perm %x\n", 
+       printd("rootcreate: c %p, name %s, omode %o, perm %x\n",
               c, name, omode, perm);
        /* find an empty slot */
        int path = c->qid.path;
index b86b582..99a8804 100644 (file)
@@ -112,7 +112,7 @@ static long bnx2x_ctl(struct ether *edev, void *buf, long n)
 
        /* TODO: handle ctl command somehow.  igbe did the following: */
        //ct = lookupcmd(cb, igbectlmsg, ARRAY_SIZE(igbectlmsg));
-       
+
        kfree(cb);
        poperror();
        return n;
@@ -429,7 +429,7 @@ static void bnx2x_pci(void)
 
                ctlr->pcidev = pcidev;
                ctlr->pci_id = pci_id;
-               
+
                spin_lock(&bnx2x_tq_lock);
                TAILQ_INSERT_TAIL(&bnx2x_tq, ctlr, link9ns);
                spin_unlock(&bnx2x_tq_lock);
@@ -467,7 +467,7 @@ static int bnx2x_pnp(struct ether *edev)
                           ctlr->pcidev->func);
        edev->mbps = 1000;
        memmove(edev->ea, ctlr->link_params.mac_addr, Eaddrlen);
-       
+
        /*
         * Linkage to the generic ethernet driver.
         */
index 899e6fe..1026113 100644 (file)
@@ -8735,7 +8735,7 @@ static void bnx2x_dump_q_state_params(struct bnx2x_queue_state_params *q_params)
                q_params->params.setup.gen_params.cos    );
        pr_info("qsp setup.gen.fp_hsi  %p\n",
                q_params->params.setup.gen_params.fp_hsi );
-       
+
        pr_info("qsp setup.rxq.dscr_map             %p\n",
                q_params->params.setup.rxq_params.dscr_map             );
        pr_info("qsp setup.rxq.sge_map              %p\n",
@@ -8772,7 +8772,7 @@ static void bnx2x_dump_q_state_params(struct bnx2x_queue_state_params *q_params)
                q_params->params.setup.rxq_params.silent_removal_value );
        pr_info("qsp setup.rxq.silent_removal_mask  %p\n",
                q_params->params.setup.rxq_params.silent_removal_mask  );
-       
+
        pr_info("qsp setup.txq.dscr_map          %p\n",
                q_params->params.setup.txq_params.dscr_map          );
        pr_info("qsp setup.txq.fw_sb_id          %p\n",
@@ -8787,7 +8787,7 @@ static void bnx2x_dump_q_state_params(struct bnx2x_queue_state_params *q_params)
                q_params->params.setup.txq_params.tss_leading_cl_id );
        pr_info("qsp setup.txq.default_vlan      %p\n",
                q_params->params.setup.txq_params.default_vlan      );
-       
+
        pr_info("qsp setup.pau.bd_th_lo  %p\n",
                q_params->params.setup.pause_params.bd_th_lo  );
        pr_info("qsp setup.pau.bd_th_hi  %p\n",
index 7efc181..4bdce2d 100644 (file)
@@ -713,7 +713,7 @@ rtl8169init(struct ether* edev)
                 */
                printk("untested\n");
                break;
-#if 0        
+#if 0
                r = csr8r(ctlr, Config2) & 0x07;
                if(r == 0x01)                           /* 66MHz PCI */
                        csr32w(ctlr, 0x7C, 0x0007FFFF); /* magic */
index 7cad744..3bcf79f 100644 (file)
@@ -1971,7 +1971,7 @@ igbepci(void)
                       pcidev->ven_id, pcidev->dev_id,
                       pcidev->bus, pcidev->dev, pcidev->func);
 
-               mmio_paddr = pcidev->bar[0].mmio_base32 ? pcidev->bar[0].mmio_base32 : 
+               mmio_paddr = pcidev->bar[0].mmio_base32 ? pcidev->bar[0].mmio_base32 :
                                                          pcidev->bar[0].mmio_base64;
                mem = (void*)vmap_pmem_nocache(mmio_paddr, pcidev->bar[0].mmio_sz);
                if(mem == NULL){
index 2f3935e..6db258d 100644 (file)
@@ -632,7 +632,7 @@ static ssize_t compat(struct ib_uverbs_file *file, size_t count,
        copy_to_user(dst, &tmpbuf[6], sizeof(struct ib_uverbs_qp_dest));
        dst += sizeof(struct ib_uverbs_qp_dest);
        copy_to_user(dst, &tmpbuf[11], 48);
-       
+
 
        return ib_uverbs_modify_qp(file, buf, insz, outsz);
 }
index 7b0bb16..2b62360 100644 (file)
@@ -34,8 +34,8 @@
  * fire (sitting in an RKM queue).  It will fire at some point, but perhaps it
  * has not fired yet.  It is also possibly (though extremely unlikely) that if
  * you reset an RKM alarm that the new alarm actually happens before the old one
- * (if the new RKM was sent to another core).  
- * 
+ * (if the new RKM was sent to another core).
+ *
  * To use an IRQ alarm, init the waiter with init_awaiter_irq().
  *
  * Quick howto, using the pcpu tchains:
@@ -72,7 +72,7 @@
 
 /* These structures allow code to block or defer work for a certain amount of
  * time.  Timer chains (like off a per-core timer) are made of lists/trees of
- * these. 
+ * these.
  *
  * If you have a func pointer, that handler will run when the alarm goes off.
  * If you don't have a func pointer, you sleep on the semaphore and block your
index 3826494..3c62f37 100644 (file)
@@ -18,7 +18,7 @@
  *             ret = apipe_read(&ap, &to_local_struct, 1);
  *             apipe_close_writer(&ap);
  *             apipe_close_reader(&ap);
- *     
+ *
  * Read and write return the number of elements copied.  If they copied any
  * amount, they will return.  They will block if the pipe is empty/full,
  * and there exist corresponding writers/readers.
index 5a4de11..2103f97 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2009 The Regents of the University  of California.  
- * See the COPYRIGHT files at the top of this source tree for full 
+ * Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
  */
 
index 87e5e4a..8b8d079 100644 (file)
@@ -35,7 +35,7 @@ static inline void CLR_BITMASK_RANGE(uint8_t* m, size_t beg, size_t end)
 }
 
 /* Runs *work on every bit in the bitmask, passing *work the value of the bit
- * that is set.  Optionally clears the bit from the bitmask. 
+ * that is set.  Optionally clears the bit from the bitmask.
  *
  * We need this to be a macro, so that the calling code doesn't need the
  * address for work_fn.  This matters for code that has nested functions that
@@ -51,4 +51,4 @@ static inline void CLR_BITMASK_RANGE(uint8_t* m, size_t beg, size_t end)
                if (present)                                                           \
                        (work_fn)(i);                                                      \
        }                                                                          \
-}                                                                              
+}
index bd87e66..e60e198 100644 (file)
@@ -111,7 +111,7 @@ static inline void CLR_BITMASK_RANGE(uint8_t* m, size_t beg, size_t end)
 
 
 /* Runs *work on every bit in the bitmask, passing *work the value of the bit
- * that is set.  Optionally clears the bit from the bitmask. 
+ * that is set.  Optionally clears the bit from the bitmask.
  *
  * We need this to be a macro, so that the calling code doesn't need the
  * address for work_fn.  This matters for code that has nested functions that
@@ -127,5 +127,5 @@ static inline void CLR_BITMASK_RANGE(uint8_t* m, size_t beg, size_t end)
                if (present)                                                           \
                        (work_fn)(i);                                                      \
        }                                                                          \
-}                                                                              
+}
 #endif
index 73e45a0..58b4be1 100644 (file)
@@ -46,7 +46,7 @@
 #define IP_HDR_SZ 20
 
 
-/* modified to be consistent with linux and our user space tool chain 
+/* modified to be consistent with linux and our user space tool chain
  * we need to make our mind up about bsd/linux structs
  */
 #define        INADDR_ANY                      (struct in_addr) {0x00000000}
  * Default local port range, used by IP_PORTRANGE_DEFAULT
  */
 #define IPPORT_EPHEMERALFIRST  10000
-#define IPPORT_EPHEMERALLAST   65535 
+#define IPPORT_EPHEMERALLAST   65535
+
 /*
  * Dynamic port range, used by IP_PORTRANGE_HIGH.
  */
                                                         (((uint32_t)(i) & 0xffff0000) == 0xc0a80000))
 
 #define        IN_LOCAL_GROUP(i)       (((uint32_t)(i) & 0xffffff00) == 0xe0000000)
+
 #define        IN_ANY_LOCAL(i)         (IN_LINKLOCAL(i) || IN_LOCAL_GROUP(i))
 
 #define        INADDR_LOOPBACK                 (uint32_t)0x7f000001
index 3727e44..45d05a8 100644 (file)
@@ -1,10 +1,10 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
+
 #pragma once
 
 #include <ros/common.h>
@@ -17,7 +17,7 @@ typedef struct Cache {
        size_t sz_k;
        size_t clsz;
        uint8_t* free_colors_map;
-       
+
        //Added as optimization (derived from above);
        size_t num_colors;
 } cache_t;
@@ -49,7 +49,7 @@ static inline size_t get_page_color(uintptr_t page, cache_t *c) {
 uint8_t* cache_colors_map_alloc();
 void cache_colors_map_free(uint8_t* colors_map);
 error_t cache_color_alloc(cache_t* c, uint8_t* colors_map);
-error_t cache_color_alloc_specific(size_t color, cache_t* c, 
+error_t cache_color_alloc_specific(size_t color, cache_t* c,
                                          uint8_t* colors_map);
 void cache_color_free(cache_t* c, uint8_t* colors_map);
 void cache_color_free_specific(size_t color, cache_t* c, uint8_t* colors_map);
index 4ec1fa9..dce91af 100644 (file)
@@ -1,29 +1,29 @@
 /*
- * Copyright (c) 2009 The Regents of the University  of California.  
- * See the COPYRIGHT files at the top of this source tree for full 
+ * Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
  */
 /**
  * @author Kevin Klues <klueska@cs.berkeley.edu>
  */
+
 #pragma once
 
 #include <colored_caches.h>
 #include <arch/colored_page_alloc.h>
 #include <stdio.h>
-       
+
 #define DECLARE_CACHE_COLORED_PAGE_LINK(_cache)                               \
        page_list_entry_t _cache##_cache_colored_pg_link;
-       
+
 #define DECLARE_CACHE_COLORED_PAGE_FREE_LIST(_cache)                          \
        uint8_t _cache##_num_colors = 0;                                          \
        page_list_t *_cache##_cache_colored_page_list = NULL;
-       
+
 #define DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(_cache)                   \
     extern uint8_t _cache##_num_colors;                                       \
        extern page_list_t *_cache##_cache_colored_page_list;
-       
+
 #define DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(_cache)                     \
 error_t _cache##_page_alloc(page_t** page, size_t color)                      \
 {                                                                             \
index bcfd90b..4c3fb7b 100644 (file)
@@ -1,8 +1,8 @@
 /*
  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
- * All rights reserved. 
- * 
- * Redistribution and use in source and binary forms, with or without modification, 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission. 
+ *    derived from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
- * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
  * This file is part of the lwIP TCP/IP stack.
- * 
+ *
  * Author: Adam Dunkels <adam@sics.se>
- *  
+ *
  *
  */
 #pragma once
@@ -65,7 +65,7 @@
 #define LWIP_ASSERT(message, assertion) do { if(!(assertion)) \
   LWIP_PLATFORM_ASSERT(message); } while(0)
 #else  /* LWIP_NOASSERT */
-#define LWIP_ASSERT(message, assertion) 
+#define LWIP_ASSERT(message, assertion)
 #endif /* LWIP_NOASSERT */
 
 /** if "expression" isn't true, then print "message" and execute "handler" expression */
@@ -90,5 +90,5 @@
                              } while(0)
 
 #else  /* LWIP_DEBUG */
-#define LWIP_DEBUGF(debug, message) 
+#define LWIP_DEBUGF(debug, message)
 #endif /* LWIP_DEBUG */
index 4630787..9dad848 100644 (file)
@@ -69,7 +69,7 @@ struct proc {
        uint8_t* cache_colors_map;
        size_t next_cache_color;
 
-       /* Keeps track of this process's current memory allocation 
+       /* Keeps track of this process's current memory allocation
      * (i.e. its heap pointer) */
        void *heap_top;
 
@@ -90,11 +90,11 @@ struct proc {
        // Per process info and data pages
        procinfo_t *procinfo;       // KVA of per-process shared info table (RO)
        procdata_t *procdata;       // KVA of per-process shared data table (RW)
-       
+
        // The backring pointers for processing asynchronous system calls from the user
        // Note this is the actual backring, not a pointer to it somewhere else
        syscall_back_ring_t syscallbackring;
-       
+
        // The front ring pointers for pushing asynchronous system events out to the user
        // Note this is the actual frontring, not a pointer to it somewhere else
        sysevent_front_ring_t syseventfrontring;
index 18ed892..7946657 100644 (file)
 void frontend_proc_init(struct proc* p);
 void frontend_proc_free(struct proc* p);
 
-int32_t frontend_syscall(pid_t pid, int32_t syscall_num, 
-                         uint32_t arg0, uint32_t arg1, uint32_t arg2, 
+int32_t frontend_syscall(pid_t pid, int32_t syscall_num,
+                         uint32_t arg0, uint32_t arg1, uint32_t arg2,
                          uint32_t arg3, int32_t* errno);
 
-int frontend_syscall_errno(struct proc* p, int n, int a0, 
+int frontend_syscall_errno(struct proc* p, int n, int a0,
                            int a1, int a2, int a3);
 
 void file_init(void);
index cfbe5f9..3e94257 100644 (file)
@@ -1,5 +1,5 @@
 /* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk>
- * 
+ *
  * Modified 2009 by Barret Rhoden <brho@cs.berkeley.edu>
  * Changes include:
  *   - No longer frees keys or values.  It's up to the client to do that.
@@ -53,7 +53,7 @@ static inline size_t indexFor(unsigned int tablelength, unsigned int hashvalue)
  *      v = (struct some_value *)   kmalloc(sizeof(struct some_value));
  *
  *      (initialise k and v to suitable values)
- * 
+ *
  *      if (! hashtable_insert(h,k,v) )
  *      {     panic("Hashtable broken...\n");       }
  *
@@ -67,7 +67,7 @@ static inline size_t indexFor(unsigned int tablelength, unsigned int hashvalue)
 
 /* Macros may be used to define type-safe(r) hashtable access functions, with
  * methods specialized to take known key and value types as parameters.
- * 
+ *
  * Example:
  *
  * Insert this at the start of your file:
@@ -104,7 +104,7 @@ ssize_t __generic_eq(void *k1, void *k2);
 
 /*****************************************************************************
  * create_hashtable
-   
+
  * @name                    create_hashtable
  * @param   minsize         minimum initial size of hashtable
  * @param   hashfunction    function for hashing keys
@@ -119,7 +119,7 @@ create_hashtable(size_t minsize,
 
 /*****************************************************************************
  * hashtable_insert
-   
+
  * @name        hashtable_insert
  * @param   h   the hashtable to insert into
  * @param   k   the key
@@ -136,7 +136,7 @@ create_hashtable(size_t minsize,
  * If in doubt, remove before insert.
  */
 
-ssize_t 
+ssize_t
 hashtable_insert(hashtable_t *h, void *k, void *v);
 
 #define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \
@@ -147,7 +147,7 @@ ssize_t fnname (hashtable_t *h, keytype *k, valuetype *v) \
 
 /*****************************************************************************
  * hashtable_search
-   
+
  * @name        hashtable_search
  * @param   h   the hashtable to search
  * @param   k   the key to search for
@@ -165,7 +165,7 @@ valuetype * fnname (hashtable_t *h, keytype *k) \
 
 /*****************************************************************************
  * hashtable_remove
-   
+
  * @name        hashtable_remove
  * @param   h   the hashtable to remove the item from
  * @param   k   the key to search for
@@ -186,7 +186,7 @@ valuetype * fnname (hashtable_t *h, keytype *k) \
 
 /*****************************************************************************
  * hashtable_count
-   
+
  * @name        hashtable_count
  * @param   h   the hashtable
  * @return      the number of items stored in the hashtable
@@ -198,7 +198,7 @@ hashtable_count(hashtable_t *h);
 
 /*****************************************************************************
  * hashtable_destroy
-   
+
  * @name        hashtable_destroy
  * @param   h   the hashtable
  *
@@ -295,23 +295,23 @@ void hash_for_each_remove(struct hashtable *hash, void func(void *, void *),
 /*
  * Copyright (c) 2002, 2004, Christopher Clark
  * All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 
+ *
  * * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
- * 
+ *
  * * Redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
- * 
+ *
  * * Neither the name of the original author; nor the names of any contributors
  * may be used to endorse or promote products derived from this software
  * without specific prior written permission.
- * 
- * 
+ *
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
index 66bf259..dd1edcc 100644 (file)
@@ -244,7 +244,7 @@ struct Ipifc {
 
        uint8_t sendra6;                        /* == 1 => send router advs on this ifc */
        uint8_t recvra6;                        /* == 1 => recv router advs on this ifc */
-       struct routerparams rp;         /* router parameters as in RFC 2461, pp.40--43. 
+       struct routerparams rp;         /* router parameters as in RFC 2461, pp.40--43.
                                                                   used only if node is router */
 };
 
@@ -399,7 +399,7 @@ void Fsstdannounce(struct conv *, char **, int);
 void Fsstdbind(struct conv *, char **, int);
 uint32_t scalednconv(void);
 
-/* 
+/*
  *  logging
  */
 enum {
index 0ea26d0..88766d3 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009 The Regents of the University of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 
 #pragma once
index d95a26d..a06e17d 100644 (file)
@@ -14,7 +14,7 @@
 #include <time.h>
 #include <sys/queue.h>
 
-/* Macros for assertions. 
+/* Macros for assertions.
  */
 #define KT_ASSERT(test)                                                          \
        KT_ASSERT_M("", test)
index b32fc46..118cd63 100644 (file)
@@ -33,7 +33,7 @@ struct hlist_head {
 
 struct hlist_node {
     struct hlist_node *next, **pprev;
-}; 
+};
 
 /*
  * Simple doubly linked list implementation.
index 4ac5949..6d7ab1c 100644 (file)
@@ -27,8 +27,8 @@ struct vm_region {
        struct proc                                     *vm_proc;       /* owning process, for now */
        uintptr_t                                       vm_base;
        uintptr_t                                       vm_end;
-       int                                                     vm_prot;        
-       int                                                     vm_flags;       
+       int                                                     vm_prot;
+       int                                                     vm_flags;
        struct file                                     *vm_file;
        size_t                                          vm_foff;
 };
index 5bc5151..60ea82c 100644 (file)
@@ -102,20 +102,20 @@ struct multiboot_header
 {
        /* Must be MULTIBOOT_MAGIC - see above. */
        multiboot_uint32_t magic;
-       
+
        /* Feature flags. */
        multiboot_uint32_t flags;
-       
+
        /* The above fields plus this one must equal 0 mod 2^32. */
        multiboot_uint32_t checksum;
-       
+
        /* These are only valid if MULTIBOOT_AOUT_KLUDGE is set. */
        multiboot_uint32_t header_addr;
        multiboot_uint32_t load_addr;
        multiboot_uint32_t load_end_addr;
        multiboot_uint32_t bss_end_addr;
        multiboot_uint32_t entry_addr;
-       
+
        /* These are only valid if MULTIBOOT_VIDEO_MODE is set. */
        multiboot_uint32_t mode_type;
        multiboot_uint32_t width;
@@ -148,43 +148,43 @@ struct multiboot_info
 {
        /* Multiboot info version number */
        multiboot_uint32_t flags;
-       
+
        /* Available memory from BIOS */
        multiboot_uint32_t mem_lower;
        multiboot_uint32_t mem_upper;
-       
+
        /* "root" partition */
        multiboot_uint32_t boot_device;
-       
+
        /* Kernel command line */
        multiboot_uint32_t cmdline;
-       
+
        /* Boot-Module list */
        multiboot_uint32_t mods_count;
        multiboot_uint32_t mods_addr;
-       
+
        union {
                multiboot_aout_symbol_table_t aout_sym;
                multiboot_elf_section_header_table_t elf_sec;
        } u;
-       
+
        /* Memory Mapping buffer */
        multiboot_uint32_t mmap_length;
        multiboot_uint32_t mmap_addr;
-       
+
        /* Drive Info buffer */
        multiboot_uint32_t drives_length;
        multiboot_uint32_t drives_addr;
-       
+
        /* ROM configuration table */
        multiboot_uint32_t config_table;
-       
+
        /* Boot Loader Name */
        multiboot_uint32_t boot_loader_name;
-       
+
        /* APM table */
        multiboot_uint32_t apm_table;
-       
+
        /* Video */
        multiboot_uint32_t vbe_control_info;
        multiboot_uint32_t vbe_mode_info;
@@ -212,10 +212,10 @@ struct multiboot_mod_list
        /* the memory used goes from bytes 'mod_start' to 'mod_end-1' inclusive */
        multiboot_uint32_t mod_start;
        multiboot_uint32_t mod_end;
-       
+
        /* Module command line */
        multiboot_uint32_t cmdline;
-       
+
        /* padding to take it to 16 bytes (must be zero) */
        multiboot_uint32_t pad;
 };
index d84e9d0..ad9c0fa 100644 (file)
@@ -1,10 +1,10 @@
-/* Copyright (c) 2009, 2010 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009, 2010 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  * Barret Rhoden <brho@cs.berkeley.edu> */
+
 #pragma once
 
 #include <atomic.h>
index 8c5ee04..c1def83 100644 (file)
@@ -52,7 +52,7 @@ struct page_map_operations {
        commit_write: complete a write (disk backed pages)
        bmap: get a logical block number from a file block index
        invalidate page: invalidate, part of truncating
-       release page: prepare to release 
+       release page: prepare to release
        direct_io: bypass the page cache */
 };
 
index 72c79cb..7ed29ad 100644 (file)
@@ -91,7 +91,7 @@ void  page_decref(page_t *pp);
 
 void   tlb_invalidate(pgdir_t pgdir, void *ga);
 void tlb_flush_global(void);
-bool regions_collide_unsafe(uintptr_t start1, uintptr_t end1, 
+bool regions_collide_unsafe(uintptr_t start1, uintptr_t end1,
                             uintptr_t start2, uintptr_t end2);
 
 /* Arch specific implementations for these */
@@ -141,12 +141,12 @@ static inline void *ppn2kva(size_t pp)
        return page2kva(ppn2page(pp));
 }
 
-static inline page_t* kva2page(void* addr) 
+static inline page_t* kva2page(void* addr)
 {
        return pa2page(PADDR(addr));
 }
 
-static inline ppn_t kva2ppn(void* addr) 
+static inline ppn_t kva2ppn(void* addr)
 {
        return page2ppn(kva2page(addr));
 }
index 23ae35c..6c2537e 100644 (file)
@@ -114,7 +114,7 @@ struct vcore *vcoreid2vcore(struct proc *p, uint32_t vcoreid);
  *
  * These are internal functions.  Error checking is to catch bugs, and you
  * shouldn't call these functions with parameters you are not sure about (like
- * an invalid corelist).  
+ * an invalid corelist).
  *
  * WARNING: YOU MUST HOLD THE PROC_LOCK BEFORE CALLING THESE! */
 /* Gives process p the additional num cores listed in corelist */
index 943c242..f13d5a5 100644 (file)
@@ -37,5 +37,5 @@ static inline bool seq_is_locked(seq_ctr_t seq_ctr)
 static inline bool seqctr_retry(seq_ctr_t old_ctr, seq_ctr_t new_ctr)
 {
        rmb();  /* don't allow protected reads to reorder after the check */
-       return (seq_is_locked(old_ctr)) || (old_ctr != new_ctr);        
+       return (seq_is_locked(old_ctr)) || (old_ctr != new_ctr);
 }
index c6edee0..4bf7222 100644 (file)
@@ -63,7 +63,7 @@
  * enough so the producer knows the item is free.  If pub_idx was their item,
  * they move it forward to the next item.  If it is not, currently, they spin
  * and wait until the previous consumer finishes, and then move it forward.
- * This isn't ideal, and we can deal with this in the future.  
+ * This isn't ideal, and we can deal with this in the future.
  *
  * Enqueue will enqueue the item pointed to by elem.  Dequeue will write an
  * item into the memory pointed to by elem.
@@ -108,7 +108,7 @@ struct bcq_header {
 
 #endif
 
-/* Functions */                                                                
+/* Functions */
 #define bcq_init(_bcq, _ele_type, _num_elems)                                  \
 ({                                                                             \
        memset((_bcq), 0, sizeof(*(_bcq)));                                        \
index d476271..13420b7 100644 (file)
@@ -27,4 +27,4 @@ struct __name##_bcq_wrap {                                                     \
 struct __name##_bcq {                                                          \
        struct bcq_header hdr;                                                     \
        struct __name##_bcq_wrap wraps[__num_elems];                               \
-};                                                                             
+};
index 1042913..8cae072 100644 (file)
@@ -93,7 +93,7 @@
 #define SYS_fd2path                            149
 
 /* Syscalls we plan to remove someday */
-#define SYS_cache_buster        200 
+#define SYS_cache_buster        200
 
 /* For Buster Measurement Flags */
 #define BUSTER_SHARED                  0x0001
index 8088c1c..c2debed 100644 (file)
@@ -86,7 +86,7 @@ struct kstat {
 /* TODO: have userpsace use our stuff from bits/stats.h */
 #ifdef ROS_KERNEL
 #define stat kstat
-#define dirent kdirent 
+#define dirent kdirent
 
 /* File creation modes (access controls) */
 #define S_IRWXU 00700  /* user (file owner) has read, write and execute perms */
index 8531541..76288da 100644 (file)
@@ -1,6 +1,6 @@
 /******************************************************************************
  * ring.h
- * 
+ *
  * Shared producer-consumer ring macros.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -50,7 +50,7 @@ typedef unsigned int RING_IDX;
 /*
  * Calculate size of a shared ring, given the total available space for the
  * ring and indexes (_sz), and the name tag of the request/response structure.
- * A ring contains as many entries as will fit, rounded down to the nearest 
+ * A ring contains as many entries as will fit, rounded down to the nearest
  * power of two (so we can mask with (size-1) to loop around).
  */
 #define __CONST_RING_SIZE(_s, _sz) \
@@ -64,7 +64,7 @@ typedef unsigned int RING_IDX;
 
 /*
  * Macros to make the correct C datatypes for a new kind of ring.
- * 
+ *
  * To make a new ring datatype, you need to have two message structures,
  * let's say request_t, and response_t already defined.
  *
@@ -74,7 +74,7 @@ typedef unsigned int RING_IDX;
  *
  * These expand out to give you a set of types, as you can see below.
  * The most important of these are:
- * 
+ *
  *     mytag_sring_t      - The shared ring.
  *     mytag_front_ring_t - The 'front' half of the ring.
  *     mytag_back_ring_t  - The 'back' half of the ring.
@@ -142,15 +142,15 @@ typedef struct __name##_back_ring __name##_back_ring_t
 
 /*
  * Macros for manipulating rings.
- * 
- * FRONT_RING_whatever works on the "front end" of a ring: here 
+ *
+ * FRONT_RING_whatever works on the "front end" of a ring: here
  * requests are pushed on to the ring and responses taken off it.
- * 
- * BACK_RING_whatever works on the "back end" of a ring: here 
+ *
+ * BACK_RING_whatever works on the "back end" of a ring: here
  * requests are taken off the ring and responses put on.
- * 
- * N.B. these macros do NO INTERLOCKS OR FLOW CONTROL. 
- * This is OK in 1-for-1 request-response situations where the 
+ *
+ * N.B. these macros do NO INTERLOCKS OR FLOW CONTROL.
+ * This is OK in 1-for-1 request-response situations where the
  * requestor (front end) never has more than RING_SIZE()-1
  * outstanding requests.
  */
@@ -249,26 +249,26 @@ typedef struct __name##_back_ring __name##_back_ring_t
 
 /*
  * Notification hold-off (req_event and rsp_event):
- * 
+ *
  * When queueing requests or responses on a shared ring, it may not always be
  * necessary to notify the remote end. For example, if requests are in flight
  * in a backend, the front may be able to queue further requests without
  * notifying the back (if the back checks for new requests when it queues
  * responses).
- * 
+ *
  * When enqueuing requests or responses:
- * 
+ *
  *  Use RING_PUSH_{REQUESTS,RESPONSES}_AND_CHECK_NOTIFY(). The second argument
  *  is a boolean return value. True indicates that the receiver requires an
  *  asynchronous notification.
- * 
+ *
  * After dequeuing requests or responses (before sleeping the connection):
- * 
+ *
  *  Use RING_FINAL_CHECK_FOR_REQUESTS() or RING_FINAL_CHECK_FOR_RESPONSES().
  *  The second argument is a boolean return value. True indicates that there
  *  are pending messages on the ring (i.e., the connection should not be put
  *  to sleep).
- * 
+ *
  *  These macros will set the req_event/rsp_event field to trigger a
  *  notification on the very next message that is enqueued. If you want to
  *  create batches of work (i.e., only receive a notification after several
index f374248..522a4c6 100644 (file)
@@ -11,7 +11,7 @@ typedef enum {
        RES_free,  // The response has been digested by the user space, can be reallocated
        REQ_alloc, // Space fo request is allocated
        REQ_ready, // The request is populated by the caller
-       REQ_processing, // The request is being processed, 
+       REQ_processing, // The request is being processed,
                                        // or a kernel thread is going to pick up the stack to process this later.
 
        RES_ready // The response is ready to be picked up
index ca5146d..5011de7 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009 The Regents of the University of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 
 #pragma once
@@ -13,9 +13,9 @@
 
 typedef enum {
        SYS_begofevents, //Should always be first
-       
-       SYS_shared_page_alloc_event, 
-       SYS_shared_page_free_event, 
+
+       SYS_shared_page_alloc_event,
+       SYS_shared_page_free_event,
 
        SYS_endofevents //Should always be last
 } sysevent_type_t;
index 3b76585..4563f1f 100644 (file)
@@ -6,7 +6,7 @@
  * size chunks.  The pages/buffers are linked together by an info struct at the
  * beginning of the page.  Producers and consumers sync on the idxes when
  * operating in a page, and page swaps are synced via the proc* for the kernel
- * and via the ucq's u_lock for the user. 
+ * and via the ucq's u_lock for the user.
  *
  * There's a bunch of details and issues discussed in the Documentation.
  *
index de096d4..e33273b 100644 (file)
@@ -5,7 +5,7 @@
  * Reader-writer queue locks (sleeping locks).
  *
  * Readers favor readers; writers favor writers.  Check out rwlock.c for more
- * info. 
+ * info.
  *
  * One consequence of this: "if some reader holds a rwlock, then any other
  * thread (including itself) can get an rlock". */
index 8d5e106..395cb39 100644 (file)
@@ -8,7 +8,7 @@
  *
  * There is a list of kmem_cache, which are the caches of objects of a given
  * size.  This list is sorted in order of size.  Each kmem_cache has three
- * lists of slabs: full, partial, and empty.  
+ * lists of slabs: full, partial, and empty.
  *
  * For large objects, the kmem_slabs point to bufctls, which have the address
  * of their large buffers.  These slabs can consist of more than one contiguous
index 0d3613a..acbb413 100644 (file)
@@ -5,8 +5,8 @@
  * Hacked BSD taskqueues.  In lieu of actually running a kproc or something that
  * sleeps on a queue of tasks, we'll just blast out a kmsg.  We can always
  * change the implementation if we need more control.
- * 
- * 
+ *
+ *
  * Linux workqueue wrappers:
  *
  * Caveats:
index 185acde..b84d74f 100644 (file)
@@ -9,8 +9,8 @@
 #include <stdio.h>
 #include <kmalloc.h>
 
-/* Macros for assertions. 
- * They depend on <stdbool.h> and printk() to be included in the source file. 
+/* Macros for assertions.
+ * They depend on <stdbool.h> and printk() to be included in the source file.
  */
 #define KT_ASSERT_M(message, test)                                               \
        do {                                                                         \
index 88b2807..1bd7c0f 100644 (file)
@@ -55,7 +55,7 @@ int memcpy_to_user(struct proc *p, void *dest, const void *src, size_t len);
 /* Same as above, but sets errno */
 int memcpy_from_user_errno(struct proc *p, void *dst, const void *src, int len);
 int memcpy_to_user_errno(struct proc *p, void *dst, const void *src, int len);
-                 
+
 /* Creates a buffer (kmalloc) and safely copies into it from va.  Can return an
  * error code.  Check its response with IS_ERR().  Must be paired with
  * user_memdup_free() if this succeeded. */
index 276a372..1f8e0ab 100644 (file)
@@ -69,7 +69,7 @@ TAILQ_HEAD(file_tailq, file);
 TAILQ_HEAD(io_wb_tailq, io_writeback);
 TAILQ_HEAD(event_poll_tailq, event_poll);
 TAILQ_HEAD(vfsmount_tailq, vfsmount);
-TAILQ_HEAD(fs_type_tailq, fs_type); 
+TAILQ_HEAD(fs_type_tailq, fs_type);
 
 /* Linux's quickstring - saves recomputing the hash and length.  Note the length
  * is the non-null-terminated length, as you'd get from strlen(). (for now) */
index b5d01b7..1e14ae3 100644 (file)
@@ -1,6 +1,6 @@
 /* zconf.h -- configuration of the zlib compression library
  * Copyright (C) 1995-1998 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h 
+ * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
 /* @(#) $Id$ */
index 5195595..5bb6595 100644 (file)
@@ -48,7 +48,7 @@
       zlib_inflate itself to inflate the data.
 */
 
-/* 
+/*
      The 'zlib' compression library provides in-memory compression and
   decompression functions, including integrity checks of the uncompressed
   data.  This version of the library supports only one compression method
@@ -190,7 +190,7 @@ extern int zlib_deflate_workspacesize (int windowBits, int memLevel);
    exceed those passed here.
 */
 
-/* 
+/*
 extern int deflateInit (z_streamp strm, int level);
 
      Initializes the internal stream state for compression. The fields
@@ -268,7 +268,7 @@ extern int zlib_deflate (z_streamp strm, int flush);
   more input data, until it returns with Z_STREAM_END or an error. After
   deflate has returned Z_STREAM_END, the only possible operations on the
   stream are deflateReset or deflateEnd.
-  
+
     Z_FINISH can be used immediately after deflateInit if all the compression
   is to be done in a single step. In this case, avail_out must be at least
   0.1% larger than avail_in plus 12 bytes.  If deflate does not return
@@ -312,7 +312,7 @@ extern int zlib_inflate_workspacesize (void);
    returned in stream->workspace before calling zlib_inflateInit().
 */
 
-/* 
+/*
 extern int zlib_inflateInit (z_streamp strm);
 
      Initializes the internal stream state for decompression. The fields
@@ -449,7 +449,7 @@ extern int zlib_inflateEnd (z_streamp strm);
     The following functions are needed only in some special applications.
 */
 
-/*   
+/*
 extern int deflateInit2 (z_streamp strm,
                                      int  level,
                                      int  method,
@@ -509,7 +509,7 @@ static inline unsigned long deflateBound(unsigned long s)
        return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
 }
 
-/*   
+/*
 extern int inflateInit2 (z_streamp strm, int  windowBits);
 
      This is another version of inflateInit with an extra parameter. The
index 393f0ae..9e999c4 100644 (file)
@@ -1,7 +1,7 @@
 /* +++ deflate.c */
 /* deflate.c -- compress data using the deflation algorithm
  * Copyright (C) 1995-1996 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h 
+ * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
 /*
@@ -255,7 +255,7 @@ int zlib_deflateReset(
 )
 {
     deflate_state *s;
-    
+
     if (strm == NULL || strm->state == NULL)
         return Z_STREAM_ERROR;
 
@@ -292,7 +292,7 @@ static void putShortMSB(
 {
     put_byte(s, (Byte)(b >> 8));
     put_byte(s, (Byte)(b & 0xff));
-}   
+}
 
 /* =========================================================================
  * Flush as much pending output as possible. All deflate() output goes
@@ -972,7 +972,7 @@ static block_state deflate_fast(
                      * always MIN_MATCH bytes ahead.
                      */
                 } while (--s->match_length != 0);
-                s->strstart++; 
+                s->strstart++;
             } else {
                 s->strstart += s->match_length;
                 s->match_length = 0;
@@ -990,7 +990,7 @@ static block_state deflate_fast(
             Tracevv((stderr,"%c", s->window[s->strstart]));
             bflush = zlib_tr_tally (s, 0, s->window[s->strstart]);
             s->lookahead--;
-            s->strstart++; 
+            s->strstart++;
         }
         if (bflush) FLUSH_BLOCK(s, 0);
     }
index 7f9888a..cb46683 100644 (file)
@@ -1,7 +1,7 @@
 /* +++ trees.c */
 /* trees.c -- output deflated data using Huffman coding
  * Copyright (C) 1995-1996 Jean-loup Gailly
- * For conditions of distribution and use, see copyright notice in zlib.h 
+ * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
 /*
@@ -1097,7 +1097,7 @@ static void copy_block(
     s->last_eob_len = 8; /* enough lookahead for inflate */
 
     if (header) {
-        put_short(s, (ush)len);   
+        put_short(s, (ush)len);
         put_short(s, (ush)~len);
 #ifdef DEBUG_ZLIB
         s->bits_sent += 2*16;
index b640b64..33aa33d 100644 (file)
@@ -1,11 +1,11 @@
 
 
 
-#define Assert(err, str) 
-#define Trace(dummy) 
-#define Tracev(dummy) 
-#define Tracecv(err, dummy) 
-#define Tracevv(dummy) 
+#define Assert(err, str)
+#define Trace(dummy)
+#define Tracev(dummy)
+#define Tracecv(err, dummy)
+#define Tracevv(dummy)
 
 
 
index 2899fa8..6d4b523 100644 (file)
@@ -1,6 +1,6 @@
 /* infutil.h -- types and macros common to blocks and codes
  * Copyright (C) 1995-1998 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h 
+ * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
 /* WARNING: this file should *not* be used by applications. It is
index 4712288..1fbf7d2 100644 (file)
@@ -377,7 +377,7 @@ int sleep_on_awaiter(struct alarm_waiter *waiter)
  *     - Make sure the interrupt is on and will go off when we want
  *     - Make sure the interrupt source can find tchain
  *     - Make sure the interrupt handler calls __trigger_tchain(tchain)
- *     - Make sure you don't clobber an old tchain here (a bug) 
+ *     - Make sure you don't clobber an old tchain here (a bug)
  * This implies the function knows how to find its timer source/void
  *
  * Called with the tchain lock held, and IRQs disabled.  However, we could be
index 372c48f..c97333d 100644 (file)
@@ -176,7 +176,7 @@ void *apipe_head(struct atomic_pipe *ap)
        return ap->ap_buf + (ap->ap_rd_off & (ap->ap_ring_sz - 1)) * ap->ap_elem_sz;
 }
 
-/* 
+/*
  * Read data from the pipe until a condition is satisfied.
  * f is the function that determines the condition. f saves its
  * state in arg. When f returns non-zero, this function exits,
index d97cd1a..85ea128 100644 (file)
@@ -62,11 +62,11 @@ void arsc_server(uint32_t srcid, long a0, long a1, long a2)
        while (1) {
                while (TAILQ_EMPTY(&arsc_proc_list))
                        cpu_relax();
-               
+
                TAILQ_FOREACH(p, &arsc_proc_list, proc_arsc_link) {
                        /* Probably want to try to process a dying process's syscalls.  If
                         * not, just move it to an else case */
-                       process_generic_syscalls (p, MAX_ASRC_BATCH); 
+                       process_generic_syscalls (p, MAX_ASRC_BATCH);
                        if (p->state == PROC_DYING) {
                                TAILQ_REMOVE(&arsc_proc_list, p, proc_arsc_link);
                                proc_decref(p);
@@ -84,8 +84,8 @@ static intreg_t process_generic_syscalls(struct proc *p, size_t max)
        syscall_back_ring_t* sysbr = &p->syscallbackring;
        struct per_cpu_info* pcpui = &per_cpu_info[core_id()];
        uintptr_t old_proc;
-       // looking at a process not initialized to perform arsc. 
-       if (sysbr == NULL) 
+       // looking at a process not initialized to perform arsc.
+       if (sysbr == NULL)
                return count;
        /* Bail out if there is nothing to do */
        if (!RING_HAS_UNCONSUMED_REQUESTS(sysbr))
@@ -94,7 +94,7 @@ static intreg_t process_generic_syscalls(struct proc *p, size_t max)
         * pointers, etc. */
        old_proc = switch_to(p);
        // max is the most we'll process.  max = 0 means do as many as possible
-       // TODO: check for initialization of the ring. 
+       // TODO: check for initialization of the ring.
        while (RING_HAS_UNCONSUMED_REQUESTS(sysbr) && ((!max)||(count < max)) ) {
                // ASSUME: one queue per process
                count++;
@@ -105,10 +105,10 @@ static intreg_t process_generic_syscalls(struct proc *p, size_t max)
                syscall_rsp_t rsp;
                // this assumes we get our answer immediately for the syscall.
                syscall_req_t* req = RING_GET_REQUEST(sysbr, ++sysbr->req_cons);
-               
+
                pcpui->cur_kthread->sysc = req->sc;
                run_local_syscall(req->sc); // TODO: blocking call will block arcs as well.
-               
+
                // need to keep the slot in the ring buffer if it is blocked
                (sysbr->rsp_prod_pvt)++;
                req->status = RES_ready;
index f05a3b7..5669baa 100644 (file)
@@ -229,7 +229,7 @@ int commit_checklist_wait(checklist_t* list, checklist_mask_t* mask)
                cpu_relax();
 
        // list is ours and clear, set it to the settings of our list
-       COPY_BITMASK(list->mask.bits, mask->bits, mask->size); 
+       COPY_BITMASK(list->mask.bits, mask->bits, mask->size);
        return 0;
 }
 
@@ -246,21 +246,21 @@ int commit_checklist_nowait(checklist_t* list, checklist_mask_t* mask)
 // what if two different actors are waiting on the list, but for different reasons?
 // part of the problem is we are doing both set and check via the same path
 //
-// aside: we made this a lot more difficult than the usual barriers or even 
+// aside: we made this a lot more difficult than the usual barriers or even
 // the RCU grace-period checkers, since we have to worry about this construct
 // being used by others before we are done with it.
 //
 // how about this: if we want to wait on this later, we just don't release the
 // lock.  if we release it, then we don't care who comes in and grabs and starts
-// checking the list.  
-//     - regardless, there are going to be issues with people looking for a free 
-//     item.  even if they grab the lock, they may end up waiting a while and 
-//     wantint to bail (like test for a while, give up, move on, etc).  
+// checking the list.
+//     - regardless, there are going to be issues with people looking for a free
+//     item.  even if they grab the lock, they may end up waiting a while and
+//     wantint to bail (like test for a while, give up, move on, etc).
 //     - still limited in that only the setter can check, and only one person
 //     can spinwait / check for completion.  if someone else tries to wait (wanting
 //     completion), they may miss it if someone else comes in and grabs the lock
 //     to use it for a new checklist
-//             - if we had the ability to sleep and get woken up, we could have a 
+//             - if we had the ability to sleep and get woken up, we could have a
 //             queue.  actually, we could do a queue anyway, but they all spin
 //             and it's the bosses responsibility to *wake* them
 
index fecf491..9b3619c 100644 (file)
@@ -343,7 +343,7 @@ again:
 #define CHUNKSZ                                32
 #define nbits_to_hold_value(val)       fls(val)
 #define BASEDEC 10             /* fancier cpuset lists input in decimal */
-#if 0 
+#if 0
 later
 /**
  * bitmap_scnprintf - convert bitmap to an ASCII hex string.
index 94f2fac..ea6a064 100644 (file)
@@ -186,7 +186,7 @@ struct buffer_head *bdev_get_buffer(struct block_device *bdev,
        if (!blk_num)
                warn("Asking for the 0th block of a bdev...");
        /* Make sure there's a page in the page cache.  Should always be one. */
-       error = pm_load_page(pm, blk_num / blk_per_pg, &page); 
+       error = pm_load_page(pm, blk_num / blk_per_pg, &page);
        if (error)
                panic("Failed to load page! (%d)", error);
        my_buf = page2kva(page) + blk_offset;
index 354a61e..22b650f 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 
 #include <ros/common.h>
@@ -35,7 +35,7 @@ inline void init_cache_properties(cache_t *c, size_t sz_k, size_t wa, size_t cls
 #endif
 }
 
-inline void init_free_cache_colors_map(cache_t* c) 
+inline void init_free_cache_colors_map(cache_t* c)
 {
        // Initialize the free colors map
        c->free_colors_map = kmalloc(c->num_colors, 0);
@@ -88,24 +88,24 @@ inline size_t get_cache_num_offset_bits(cache_t *c) {
        return (LOG2_UP(get_cache_line_size_bytes(c)));
 }
 inline size_t get_cache_num_index_bits(cache_t *c) {
-       return (LOG2_UP(get_cache_size_bytes(c) 
+       return (LOG2_UP(get_cache_size_bytes(c)
                    / get_cache_ways_associative(c)
                    / get_cache_line_size_bytes(c)));
 }
 inline size_t get_cache_num_tag_bits(cache_t *c) {
-       return (NUM_ADDR_BITS - get_cache_num_offset_bits(c) 
+       return (NUM_ADDR_BITS - get_cache_num_offset_bits(c)
                           - get_cache_num_index_bits(c));
 }
 inline size_t get_cache_num_page_color_bits(cache_t *c) {
-       return (get_cache_num_offset_bits(c) 
-                  + get_cache_num_index_bits(c) 
-                  - PGSHIFT); 
+       return (get_cache_num_offset_bits(c)
+                  + get_cache_num_index_bits(c)
+                  - PGSHIFT);
 }
 inline size_t get_cache_bytes_per_line(cache_t *c) {
        return (1 << get_cache_num_offset_bits(c));
 }
 inline size_t get_cache_num_lines(cache_t *c) {
-       return (get_cache_size_bytes(c)/get_cache_bytes_per_line(c));  
+       return (get_cache_size_bytes(c)/get_cache_bytes_per_line(c));
 }
 inline size_t get_cache_num_sets(cache_t *c) {
        return (get_cache_num_lines(c)/get_cache_ways_associative(c));
@@ -118,10 +118,10 @@ inline size_t get_cache_lines_per_page(cache_t *c) {
 }
 inline size_t get_cache_bytes_per_way(cache_t *c) {
        return (get_cache_size_bytes(c)/get_cache_ways_associative(c));
-} 
+}
 inline size_t get_cache_lines_per_way(cache_t *c) {
        return (get_cache_num_lines(c)/get_cache_ways_associative(c));
-} 
+}
 inline size_t get_cache_pages_per_way(cache_t *c) {
        return (get_cache_lines_per_way(c)/get_cache_lines_per_page(c));
 }
@@ -129,7 +129,7 @@ inline size_t get_cache_num_page_colors(cache_t *c) {
        return get_cache_pages_per_way(c);
 }
 
-static inline void set_color_range(uint16_t color, uint8_t* map, 
+static inline void set_color_range(uint16_t color, uint8_t* map,
                                    cache_t* smaller, cache_t* bigger)
 {
        size_t base, r;
@@ -141,13 +141,13 @@ static inline void set_color_range(uint16_t color, uint8_t* map,
        else {
                r = smaller->num_colors / bigger->num_colors;
                base = color/r;
-               if(BITMASK_IS_SET_IN_RANGE(smaller->free_colors_map, 
+               if(BITMASK_IS_SET_IN_RANGE(smaller->free_colors_map,
                                           base*r, base*r+r-1))
                        SET_BITMASK_BIT(map, base);
        }
 }
 
-static inline void clr_color_range(uint16_t color, uint8_t* map, 
+static inline void clr_color_range(uint16_t color, uint8_t* map,
                                    cache_t* smaller, cache_t* bigger)
 {
        size_t base, r;
@@ -163,12 +163,12 @@ static inline void clr_color_range(uint16_t color, uint8_t* map,
        }
 }
 
-static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c, 
-                                                         uint8_t* colors_map) 
+static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c,
+                                                         uint8_t* colors_map)
 {
        if(!GET_BITMASK_BIT(c->free_colors_map, color))
-               return -ENOCACHE;       
-       
+               return -ENOCACHE;
+
        if(l1)
                clr_color_range(color, l1->free_colors_map, c, l1);
        if(l2)
@@ -180,10 +180,10 @@ static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c,
        return ESUCCESS;
 }
 
-static inline error_t __cache_color_alloc(cache_t* c, uint8_t* colors_map) 
+static inline error_t __cache_color_alloc(cache_t* c, uint8_t* colors_map)
 {
        if(BITMASK_IS_CLEAR(c->free_colors_map, c->num_colors))
-               return -ENOCACHE;       
+               return -ENOCACHE;
 
        int color=0;
        do {
@@ -191,11 +191,11 @@ static inline error_t __cache_color_alloc(cache_t* c, uint8_t* colors_map)
                        break;
        } while(++color);
 
-       return __cache_color_alloc_specific(color, c, colors_map);      
+       return __cache_color_alloc_specific(color, c, colors_map);
 }
 
-static inline void __cache_color_free_specific(size_t color, cache_t* c, 
-                                                     uint8_t* colors_map) 
+static inline void __cache_color_free_specific(size_t color, cache_t* c,
+                                                     uint8_t* colors_map)
 {
        if(GET_BITMASK_BIT(c->free_colors_map, color))
                return;
@@ -216,10 +216,10 @@ static inline void __cache_color_free_specific(size_t color, cache_t* c,
        clr_color_range(color, colors_map, c, llc_cache);
 }
 
-static inline void __cache_color_free(cache_t* c, uint8_t* colors_map) 
+static inline void __cache_color_free(cache_t* c, uint8_t* colors_map)
 {
        if(BITMASK_IS_FULL(c->free_colors_map, c->num_colors))
-               return; 
+               return;
 
        int color=0;
        do {
@@ -233,7 +233,7 @@ static inline void __cache_color_free(cache_t* c, uint8_t* colors_map)
        if(color == c->num_colors)
                return;
 
-       __cache_color_free_specific(color, c, colors_map);      
+       __cache_color_free_specific(color, c, colors_map);
 }
 
 uint8_t* cache_colors_map_alloc() {
@@ -253,14 +253,14 @@ void cache_colors_map_free(uint8_t* colors_map) {
 #endif
 }
 
-error_t cache_color_alloc(cache_t* c, uint8_t* colors_map) 
+error_t cache_color_alloc(cache_t* c, uint8_t* colors_map)
 {
        spin_lock_irqsave(&cache_colors_lock);
        error_t e = __cache_color_alloc(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
        return e;
 }
-error_t cache_color_alloc_specific(size_t color, cache_t* c, uint8_t* colors_map) 
+error_t cache_color_alloc_specific(size_t color, cache_t* c, uint8_t* colors_map)
 {
        spin_lock_irqsave(&cache_colors_lock);
        error_t e = __cache_color_alloc_specific(color, c, colors_map);
@@ -268,13 +268,13 @@ error_t cache_color_alloc_specific(size_t color, cache_t* c, uint8_t* colors_map
        return e;
 }
 
-void cache_color_free(cache_t* c, uint8_t* colors_map) 
+void cache_color_free(cache_t* c, uint8_t* colors_map)
 {
        spin_lock_irqsave(&cache_colors_lock);
        __cache_color_free(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
 }
-void cache_color_free_specific(size_t color, cache_t* c, uint8_t* colors_map) 
+void cache_color_free_specific(size_t color, cache_t* c, uint8_t* colors_map)
 {
        spin_lock_irqsave(&cache_colors_lock);
        __cache_color_free_specific(color, c, colors_map);
index 7bcdb51..f2dcbb5 100644 (file)
@@ -27,7 +27,7 @@ void devfs_init(void)
 {
        int mode;
        /* Make sure there is a dev directory */
-       struct dentry *dentry = lookup_dentry("/dev/", 0);      
+       struct dentry *dentry = lookup_dentry("/dev/", 0);
        if (!dentry) {
                assert(!do_mkdir("/dev/", S_IRWXU | S_IRWXG | S_IRWXO));
        } else {
index 8a16cbd..3f3afe7 100644 (file)
@@ -145,7 +145,7 @@ static int load_one_elf(struct proc *p, struct file *f, uintptr_t pg_num,
        off64_t f_off = 0;
        void* phdrs = 0;
        int mm_perms, mm_flags = MAP_FIXED;
-       
+
        /* When reading on behalf of the kernel, we need to switch to a ktask so
         * the VFS (and maybe other places) know. (TODO: KFOP) */
        uintptr_t old_ret = switch_to_ktask();
index 80c87f5..c43f01e 100644 (file)
@@ -69,7 +69,7 @@ int env_setup_vm(env_t *e)
        }
        /* Finally, set up the Global Shared Data page for all processes.  Can't be
         * trusted, but still very useful at this stage for us.  Consider removing
-        * when we have real processes (TODO). 
+        * when we have real processes (TODO).
         *
         * Note the page is alloced only the first time through, and its ref is
         * stored in shared_page. */
index 18c4ad9..5c7476f 100644 (file)
@@ -486,7 +486,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
        blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
        blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
        num_blk_group = num_blks / blks_per_group + (num_blks % blks_per_group ? 1 : 0);
-       
+
        if (print) {
                printk("EXT2 info:\n-------------------------\n");
                printk("Total Inodes:     %8d\n", le32_to_cpu(e2sb->s_inodes_cnt));
@@ -516,7 +516,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
                printk("Volume name:      %s\n", e2sb->s_volume_name);
                printk("\nBlock Group Info:\n----------------------\n");
        }
-       
+
        for (int i = 0; i < num_blk_group; i++) {
                sum_blks += le16_to_cpu(bg[i].bg_free_blocks_cnt);
                sum_inodes += le16_to_cpu(bg[i].bg_free_inodes_cnt);
@@ -530,7 +530,7 @@ void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
                        printk("Used Dirs:   %8d\n", le16_to_cpu(bg[i].bg_used_dirs_cnt));
                }
        }
-       
+
        /* Sanity Assertions.  A good ext2 will always pass these. */
        inodes_per_grp = le32_to_cpu(e2sb->s_inodes_per_group);
        blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
@@ -1160,7 +1160,7 @@ struct dentry *ext2_lookup(struct inode *dir, struct dentry *dentry,
        struct ext2_dirent *dir_buf, *dir_i;
        if (!ext2_foreach_dirent(dir, lookup_each_func, (long)dentry, 0, 0))
                return dentry;
-       printd("EXT2: Not Found, %s\n", dentry->d_name.name);   
+       printd("EXT2: Not Found, %s\n", dentry->d_name.name);
        return 0;
 }
 
@@ -1349,7 +1349,7 @@ int ext2_readdir(struct file *dir, struct dirent *dirent)
        assert(e2dir->dir_namelen <= MAX_FILENAME_SZ);
        strlcpy(dirent->d_name, (char*)e2dir->dir_name, e2dir->dir_namelen + 1);
        ext2_put_metablock(dir->f_dentry->d_sb, blk_buf);
-       
+
        /* At the end of the directory, sort of.  ext2 often preallocates blocks, so
         * this will cause us to walk along til the end, which isn't quite right. */
        if (dir->f_dentry->d_inode->i_size == dirent->d_off)
index c978053..6dccae5 100644 (file)
@@ -132,8 +132,8 @@ int frontend_syscall_errno(struct proc* p, int n, int a0, int a1, int a2, int a3
        return ret;
 }
 
-int32_t frontend_syscall(pid_t pid, int32_t syscall_num, 
-                         uint32_t arg0, uint32_t arg1, 
+int32_t frontend_syscall(pid_t pid, int32_t syscall_num,
+                         uint32_t arg0, uint32_t arg1,
                          uint32_t arg2, uint32_t arg3, int32_t* errno)
 {
 #ifndef CONFIG_APPSERVER
index e582853..5f24cc0 100644 (file)
@@ -1,5 +1,5 @@
 /* Copyright (C) 2002, 2004 Christopher Clark  <firstname.lastname@cl.cam.ac.uk>
- * 
+ *
  * Modified 2009 by Barret Rhoden <brho@cs.berkeley.edu>
  * Changes include:
  *   - No longer frees keys or values.  It's up to the client to do that.
@@ -49,7 +49,7 @@ size_t __generic_hash(void *k)
        /* 0x9e370001UL used by Linux (32 bit)
         * (prime approx to the golden ratio to the max integer, IAW Knuth)
         */
-       return (size_t)k * 0x9e370001UL;        
+       return (size_t)k * 0x9e370001UL;
 }
 
 ssize_t __generic_eq(void *k1, void *k2)
@@ -130,7 +130,7 @@ hashtable_expand(hashtable_t *h)
         h->table = newtable;
     }
     /* Plan B: realloc instead */
-    else 
+    else
     {
         newtable = (hash_entry_t**)
                    krealloc(h->table, newsize*sizeof(hash_entry_t*), 0);
@@ -447,23 +447,23 @@ void hash_for_each_remove(struct hashtable *hash, void func(void *, void *),
 /*
  * Copyright (c) 2002, 2004, Christopher Clark
  * All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 
+ *
  * * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
- * 
+ *
  * * Redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
- * 
+ *
  * * Neither the name of the original author; nor the names of any contributors
  * may be used to endorse or promote products derived from this software
  * without specific prior written permission.
- * 
- * 
+ *
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
index 863f8aa..48a19e6 100644 (file)
@@ -1,9 +1,9 @@
-/* Copyright (c) 2009 The Regents of the University of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009 The Regents of the University of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
+ *
  * Barret Rhoden <brho@cs.berkeley.edu>
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ * Kevin Klues <klueska@cs.berkeley.edu>
  */
 #include <ros/common.h>
 #include <error.h>
@@ -39,7 +39,7 @@ void kmalloc_init(void)
        }
 }
 
-void *kmalloc(size_t size, int flags) 
+void *kmalloc(size_t size, int flags)
 {
        // reserve space for bookkeeping and preserve alignment
        size_t ksize = size + sizeof(struct kmalloc_tag);
@@ -78,7 +78,7 @@ void *kmalloc(size_t size, int flags)
        return buf + sizeof(struct kmalloc_tag);
 }
 
-void *kzmalloc(size_t size, int flags) 
+void *kzmalloc(size_t size, int flags)
 {
        void *v = kmalloc(size, flags);
        if (!v)
index 99c1626..9008f37 100644 (file)
@@ -121,11 +121,11 @@ bool test_pic_reception(void)
 
 #endif // CONFIG_X86
 
-// TODO: Add assertions. Possibly the way to go is to extract relevant info 
-//       from cache properties and make assertions on the colored pages lists 
+// TODO: Add assertions. Possibly the way to go is to extract relevant info
+//       from cache properties and make assertions on the colored pages lists
 //       based on those.
 // TODO: The test was commented out. Figure out why was it like that and fix it.
-bool test_page_coloring(void) 
+bool test_page_coloring(void)
 {
        /*
        //Print the different cache properties of our machine
@@ -140,7 +140,7 @@ bool test_page_coloring(void)
        cprintf("Max Address: %llu\n", MAX_VADDR);
        cprintf("Num Pages: %u\n", npages);
 
-       //Declare a local variable for allocating pages 
+       //Declare a local variable for allocating pages
        page_t* page;
 
        cprintf("Contents of the page free list:\n");
@@ -161,7 +161,7 @@ bool test_page_coloring(void)
 
        //Put all the pages back by reinitializing
        page_init();
-       
+
        //Run through and allocate all pages through l2_page_alloc
        cprintf("Allocating from L2 page colors:\n");
        for(int i=0; i<get_cache_num_page_colors(l2); i++) {
@@ -172,7 +172,7 @@ bool test_page_coloring(void)
 
        //Put all the pages back by reinitializing
        page_init();
-       
+
        //Run through and allocate all pages through l3_page_alloc
        cprintf("Allocating from L3 page colors:\n");
        for(int i=0; i<get_cache_num_page_colors(l3); i++) {
@@ -180,19 +180,19 @@ bool test_page_coloring(void)
                while(colored_page_alloc(l3, &page, i) != -ENOMEM)
                        cprintf("    Page: %d\n", page2ppn(page));
        }
-       
+
        //Put all the pages back by reinitializing
        page_init();
-       
+
        //Run through and allocate all pages through page_alloc
        cprintf("Allocating from global allocator:\n");
        while(upage_alloc(&page) != -ENOMEM)
                cprintf("    Page: %d\n", page2ppn(page));
-       
+
        if(colored_page_alloc(l2, &page, 0) != -ENOMEM)
                cprintf("Should not get here, all pages should already be gone!\n");
        cprintf("All pages gone for sure...\n");
-       
+
        //Now lets put a few pages back using page_free..
        cprintf("Reinserting pages via page_free and reallocating them...\n");
        page_free(&pages[0]);
@@ -202,8 +202,8 @@ bool test_page_coloring(void)
        page_free(&pages[4]);
 
        while(upage_alloc(&page) != -ENOMEM)
-               cprintf("Page: %d\n", page2ppn(page));  
-       
+               cprintf("Page: %d\n", page2ppn(page));
+
        page_init();
        */
        return true;
@@ -264,7 +264,7 @@ bool test_barrier(void)
        return true;
 }
 
-// TODO: Maybe remove all the printing statements and instead use the 
+// TODO: Maybe remove all the printing statements and instead use the
 //       KT_ASSERT_M macro to include a message on assertions.
 bool test_interrupts_irqsave(void)
 {
@@ -385,11 +385,11 @@ bool test_bitmasks(void)
        KT_ASSERT_M("Bit 11 should be 0", 0 == GET_BITMASK_BIT(mask, 11));
        FILL_BITMASK(mask, masksize);
 //     PRINT_BITMASK(mask, masksize);
-       KT_ASSERT_M("Bitmask should not be clear after calling FILL_BITMASK", 
+       KT_ASSERT_M("Bitmask should not be clear after calling FILL_BITMASK",
                    0 == BITMASK_IS_CLEAR(mask,masksize));
        CLR_BITMASK(mask, masksize);
 //     PRINT_BITMASK(mask, masksize);
-       KT_ASSERT_M("Bitmask should be clear after calling CLR_BITMASK", 
+       KT_ASSERT_M("Bitmask should be clear after calling CLR_BITMASK",
                    1 == BITMASK_IS_CLEAR(mask,masksize));
        return true;
 }
@@ -655,7 +655,7 @@ bool test_circ_buffer(void)
                FOR_CIRC_BUFFER(i, 5, j)
                        printk("Starting with current = %d, each value = %d\n", i, j);
        }
-       
+
        return true;
 }
 
@@ -698,7 +698,7 @@ bool test_kernel_messages(void)
                                    KMSG_ROUTINE);
        }
        udelay(5000000);
-       
+
        return true;
 }
 #endif // CONFIG_X86
@@ -745,7 +745,7 @@ bool test_slab(void)
 bool test_kmalloc(void)
 {
        printk("Testing Kmalloc\n");
-       void *bufs[NUM_KMALLOC_CACHES + 1];     
+       void *bufs[NUM_KMALLOC_CACHES + 1];
        size_t size;
        for (int i = 0; i < NUM_KMALLOC_CACHES + 1; i++){
                size = (KMALLOC_SMALLEST << i) - sizeof(struct kmalloc_tag);
@@ -780,58 +780,58 @@ bool test_hashtable(void)
        struct test *v = &tstruct[0];
 
        h = create_hashtable(32, __generic_hash, __generic_eq);
-       
+
        // test inserting one item, then finding it again
-       KT_ASSERT_M("It should be possible to insert items to a hashtable", 
+       KT_ASSERT_M("It should be possible to insert items to a hashtable",
                    hashtable_insert(h, (void*)k, v));
        v = NULL;
-       KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable", 
+       KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable",
                    (v = hashtable_search(h, (void*)k)));
 
-       KT_ASSERT_M("The extracted element should be the same we inserted", 
+       KT_ASSERT_M("The extracted element should be the same we inserted",
                    (v == &tstruct[0]));
 
        v = NULL;
 
-       KT_ASSERT_M("It should be possible to remove an existing element", 
+       KT_ASSERT_M("It should be possible to remove an existing element",
                    (v = hashtable_remove(h, (void*)k)));
 
-       KT_ASSERT_M("An element should not remain in a hashtable after deletion", 
+       KT_ASSERT_M("An element should not remain in a hashtable after deletion",
                    !(v = hashtable_search(h, (void*)k)));
 
        /* Testing a bunch of items, insert, search, and removal */
        for (int i = 0; i < 10; i++) {
                k = i; // vary the key, we don't do KEY collisions
-               KT_ASSERT_M("It should be possible to insert elements to a hashtable", 
+               KT_ASSERT_M("It should be possible to insert elements to a hashtable",
                            (hashtable_insert(h, (void*)k, &tstruct[i])));
        }
        // read out the 10 items
        for (int i = 0; i < 10; i++) {
                k = i;
-               KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable", 
+               KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable",
                            (v = hashtable_search(h, (void*)k)));
-               KT_ASSERT_M("The extracted element should be the same we inserted", 
+               KT_ASSERT_M("The extracted element should be the same we inserted",
                            (v == &tstruct[i]));
        }
 
-       KT_ASSERT_M("The total count of number of elements should be 10", 
+       KT_ASSERT_M("The total count of number of elements should be 10",
                    (10 == hashtable_count(h)));
 
        // remove the 10 items
        for (int i = 0; i < 10; i++) {
                k = i;
-               KT_ASSERT_M("It should be possible to remove an existing element", 
+               KT_ASSERT_M("It should be possible to remove an existing element",
                            (v = hashtable_remove(h, (void*)k)));
 
        }
        // make sure they are all gone
        for (int i = 0; i < 10; i++) {
                k = i;
-               KT_ASSERT_M("An element should not remain in a hashtable after deletion", 
+               KT_ASSERT_M("An element should not remain in a hashtable after deletion",
                            !(v = hashtable_search(h, (void*)k)));
        }
 
-       KT_ASSERT_M("The hashtable should be empty", 
+       KT_ASSERT_M("The hashtable should be empty",
                    (0 == hashtable_count(h)));
 
        hashtable_destroy(h);
@@ -843,36 +843,36 @@ bool test_hashtable(void)
        for (int i = 0; i < 10; i++) {
                k = i; // vary the key, we don't do KEY collisions
 
-               KT_ASSERT_M("It should be possible to insert elements to a hashtable", 
+               KT_ASSERT_M("It should be possible to insert elements to a hashtable",
                            (hashtable_insert(h, (void*)k, &tstruct[i])));
        }
        // read out the 10 items
        for (int i = 0; i < 10; i++) {
                k = i;
-               KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable", 
+               KT_ASSERT_M("It should be possible to find inserted stuff in a hashtable",
                            (v = hashtable_search(h, (void*)k)));
-               KT_ASSERT_M("The extracted element should be the same we inserted", 
+               KT_ASSERT_M("The extracted element should be the same we inserted",
                            (v == &tstruct[i]));
        }
 
-       KT_ASSERT_M("The total count of number of elements should be 10", 
+       KT_ASSERT_M("The total count of number of elements should be 10",
                    (10 == hashtable_count(h)));
 
        // remove the 10 items
        for (int i = 0; i < 10; i++) {
                k = i;
-               KT_ASSERT_M("It should be possible to remove an existing element", 
+               KT_ASSERT_M("It should be possible to remove an existing element",
                            (v = hashtable_remove(h, (void*)k)));
        }
        // make sure they are all gone
        for (int i = 0; i < 10; i++) {
                k = i;
 
-               KT_ASSERT_M("An element should not remain in a hashtable after deletion", 
+               KT_ASSERT_M("An element should not remain in a hashtable after deletion",
                            !(v = hashtable_search(h, (void*)k)));
        }
 
-       KT_ASSERT_M("The hashtable should be empty", 
+       KT_ASSERT_M("The hashtable should be empty",
                    (0 == hashtable_count(h)));
 
        hashtable_destroy(h);
@@ -967,26 +967,26 @@ bool test_bcq(void)
                int y;
        };
        struct my_struct in_struct, out_struct;
-       
+
        DEFINE_BCQ_TYPES(test, struct my_struct, 16);
        struct test_bcq t_bcq;
        bcq_init(&t_bcq, struct my_struct, 16);
-       
+
        in_struct.x = 4;
        in_struct.y = 5;
        out_struct.x = 1;
        out_struct.y = 2;
-       
+
        bcq_enqueue(&t_bcq, &in_struct, 16, 5);
        bcq_dequeue(&t_bcq, &out_struct, 16);
        printk("out x %d. out y %d\n", out_struct.x, out_struct.y);
-       
+
        /* Tests the BCQ a bit more, esp with overflow */
        #define NR_ELEM_A_BCQ 8 /* NOTE: this must be a power of 2! */
        DEFINE_BCQ_TYPES(my, int, NR_ELEM_A_BCQ);
        struct my_bcq a_bcq;
        bcq_init(&a_bcq, int, NR_ELEM_A_BCQ);
-       
+
        int y = 2;
        int output[100];
        int retval[100];
@@ -1011,27 +1011,27 @@ bool test_bcq(void)
                printk("enqueued: %d, had retval %d \n", y, retval[i]);
        }
        //print_a_bcq(&a_bcq);
-       
+
        /* Try to dequeue more than we put in */
        for (int i = 0; i < 15; i++) {
                retval[i] = bcq_dequeue(&a_bcq, &output[i], NR_ELEM_A_BCQ);
                printk("dequeued: %d with retval %d\n", output[i], retval[i]);
        }
        //print_a_bcq(&a_bcq);
-       
+
        /* Put in some it should be able to take */
        for (int i = 0; i < 3; i++) {
                y = i;
                retval[i] = bcq_enqueue(&a_bcq, &y, NR_ELEM_A_BCQ, 10);
                printk("enqueued: %d, had retval %d \n", y, retval[i]);
        }
-       
+
        /* Take those, and then a couple extra */
        for (int i = 0; i < 5; i++) {
                retval[i] = bcq_dequeue(&a_bcq, &output[i], NR_ELEM_A_BCQ);
                printk("dequeued: %d with retval %d\n", output[i], retval[i]);
        }
-       
+
        /* Try some one-for-one */
        for (int i = 0; i < 5; i++) {
                y = i;
@@ -1122,8 +1122,8 @@ bool test_ucq(void)
        /* Just spawn the program */
        struct file *program;
        program = do_file_open("/bin/ucq", O_READ, 0);
-       
-       KT_ASSERT_M("We should be able to find /bin/ucq", 
+
+       KT_ASSERT_M("We should be able to find /bin/ucq",
                    program);
 
        struct proc *p = proc_create(program, NULL, NULL);
@@ -1137,7 +1137,7 @@ bool test_ucq(void)
         * around that are runnable */
        run_scheduler();
        smp_idle();
-       
+
        KT_ASSERT_M("We should never return from schedule",
                    false);
 
@@ -1157,8 +1157,8 @@ bool test_vm_regions(void)
        TAILQ_INIT(&p->vm_regions);
 
        struct vmr_summary {
-               uintptr_t base; 
-               uintptr_t end; 
+               uintptr_t base;
+               uintptr_t end;
        };
        int check_vmrs(struct proc *p, struct vmr_summary *results, int len, int n)
        {
@@ -1194,7 +1194,7 @@ bool test_vm_regions(void)
        results[0].end = 0x4000;
        check_vmrs(p, results, 1, n++);
        /* Grow it poorly */
-       KT_ASSERT_M("It should pass bad grow test", 
+       KT_ASSERT_M("It should pass bad grow test",
                    (-1 == grow_vmr(vmrs[0], 0x3000)));
        check_vmrs(p, results, 1, n++);
        /* Make another right next to it */
@@ -1203,7 +1203,7 @@ bool test_vm_regions(void)
        results[1].end = 0x5000;
        check_vmrs(p, results, 2, n++);
        /* try to grow through it */
-       KT_ASSERT_M("It should pass bad grow test", 
+       KT_ASSERT_M("It should pass bad grow test",
                    (-1 == grow_vmr(vmrs[0], 0x5000)));
        check_vmrs(p, results, 2, n++);
        /* Merge them */
@@ -1217,7 +1217,7 @@ bool test_vm_regions(void)
        results[1].end = 0xa000;
        check_vmrs(p, results, 2, n++);
        /* try to merge unmergables (just testing ranges) */
-       KT_ASSERT_M("It should pass bad merge test", 
+       KT_ASSERT_M("It should pass bad merge test",
                    (-1 == merge_vmr(vmrs[0], vmrs[1])));
        check_vmrs(p, results, 2, n++);
        vmrs[2] = split_vmr(vmrs[1], 0x8000);
@@ -1235,13 +1235,13 @@ bool test_vm_regions(void)
        results[1].base = 0x8000;
        results[1].end = 0x9000;
        check_vmrs(p, results, 2, n++); /* 10 */
-       KT_ASSERT_M("We should be able to find the right vmr", 
+       KT_ASSERT_M("We should be able to find the right vmr",
                    (vmrs[2] == find_vmr(p, 0x8500)));
-       KT_ASSERT_M("We should be able to find the right vmr", 
+       KT_ASSERT_M("We should be able to find the right vmr",
                    (vmrs[2] == find_first_vmr(p, 0x8500)));
-       KT_ASSERT_M("We should be able to find the right vmr", 
+       KT_ASSERT_M("We should be able to find the right vmr",
                    (vmrs[2] == find_first_vmr(p, 0x7500)));
-       KT_ASSERT_M("We shouldn't be able to find a vmr", 
+       KT_ASSERT_M("We shouldn't be able to find a vmr",
                    !(find_first_vmr(p, 0x9500)));
        /* grow up to another */
        grow_vmr(vmrs[0], 0x8000);
@@ -1250,7 +1250,7 @@ bool test_vm_regions(void)
        vmrs[0]->vm_prot = 88;
        vmrs[2]->vm_prot = 77;
        /* should be unmergeable due to perms */
-       KT_ASSERT_M("It should pass bad merge test", 
+       KT_ASSERT_M("It should pass bad merge test",
                    -1 == merge_vmr(vmrs[0], vmrs[2]));
        check_vmrs(p, results, 2, n++);
        /* should merge now */
@@ -1296,13 +1296,13 @@ bool test_radix_tree(void)
        struct radix_tree *tree = &real_tree;
        void *retval;
 
-       KT_ASSERT_M("It should be possible to insert at 0", 
+       KT_ASSERT_M("It should be possible to insert at 0",
                    !radix_insert(tree, 0, (void*)0xdeadbeef, 0));
        radix_delete(tree, 0);
-       KT_ASSERT_M("It should be possible to re-insert at 0", 
+       KT_ASSERT_M("It should be possible to re-insert at 0",
                    !radix_insert(tree, 0, (void*)0xdeadbeef, 0));
 
-       KT_ASSERT_M("It should be possible to insert first", 
+       KT_ASSERT_M("It should be possible to insert first",
                    !radix_insert(tree, 3, (void*)0xdeadbeef, 0));
        radix_insert(tree, 4, (void*)0x04040404, 0);
        KT_ASSERT((void*)0xdeadbeef == radix_lookup(tree, 3));
@@ -1313,13 +1313,13 @@ bool test_radix_tree(void)
                        print_radix_tree(tree);
                        monitor(0);
                }
-       KT_ASSERT_M("It should be possible to insert a two-tier", 
+       KT_ASSERT_M("It should be possible to insert a two-tier",
                    !radix_insert(tree, 65, (void*)0xcafebabe, 0));
-       KT_ASSERT_M("It should not be possible to reinsert", 
+       KT_ASSERT_M("It should not be possible to reinsert",
                    radix_insert(tree, 4, (void*)0x03030303, 0));
-       KT_ASSERT_M("It should be possible to insert a two-tier boundary", 
+       KT_ASSERT_M("It should be possible to insert a two-tier boundary",
                    !radix_insert(tree, 4095, (void*)0x4095, 0));
-       KT_ASSERT_M("It should be possible to insert a three-tier", 
+       KT_ASSERT_M("It should be possible to insert a three-tier",
                    !radix_insert(tree, 4096, (void*)0x4096, 0));
        //print_radix_tree(tree);
        radix_delete(tree, 65);
@@ -1337,26 +1337,26 @@ bool test_radix_tree(void)
 bool test_random_fs(void)
 {
        int retval = do_symlink("/dir1/sym", "/bin/hello", S_IRWXU);
-       KT_ASSERT_M("symlink1 should be created successfully", 
+       KT_ASSERT_M("symlink1 should be created successfully",
                    (!retval));
        retval = do_symlink("/symdir", "/dir1/dir1-1", S_IRWXU);
-       KT_ASSERT_M("symlink1 should be created successfully", 
+       KT_ASSERT_M("symlink1 should be created successfully",
                    (!retval));
        retval = do_symlink("/dir1/test.txt", "/dir2/test2.txt", S_IRWXU);
-       KT_ASSERT_M("symlink2 should be created successfully", 
+       KT_ASSERT_M("symlink2 should be created successfully",
                    (!retval));
        retval = do_symlink("/dir1/dir1-1/up", "../../", S_IRWXU);
-       KT_ASSERT_M("symlink3 should be created successfully", 
+       KT_ASSERT_M("symlink3 should be created successfully",
                    (!retval));
        retval = do_symlink("/bin/hello-sym", "hello", S_IRWXU);
-       KT_ASSERT_M("symlink4 should be created successfully", 
+       KT_ASSERT_M("symlink4 should be created successfully",
                    (!retval));
 
        struct dentry *dentry;
        struct nameidata nd_r = {0}, *nd = &nd_r;
        retval = path_lookup("/dir1/sym", 0, nd);
-       KT_ASSERT_M("symlink lookup should work for an existing symlink", 
-                   (!retval)); 
+       KT_ASSERT_M("symlink lookup should work for an existing symlink",
+                   (!retval));
        char *symname = nd->dentry->d_inode->i_op->readlink(nd->dentry);
        printk("Pathlookup got %s (sym)\n", nd->dentry->d_name.name);
        if (!symname)
@@ -1367,33 +1367,33 @@ bool test_random_fs(void)
        /* try with follow */
        memset(nd, 0, sizeof(struct nameidata));
        retval = path_lookup("/dir1/sym", LOOKUP_FOLLOW, nd);
-       
-       KT_ASSERT_M("symlink lookup should work for an existing symlink", 
+
+       KT_ASSERT_M("symlink lookup should work for an existing symlink",
                    (!retval));
        printk("Pathlookup got %s (hello)\n", nd->dentry->d_name.name);
        path_release(nd);
-       
+
        /* try with a directory */
        memset(nd, 0, sizeof(struct nameidata));
        retval = path_lookup("/symdir/f1-1.txt", 0, nd);
-       KT_ASSERT_M("symlink lookup should work for an existing symlink", 
+       KT_ASSERT_M("symlink lookup should work for an existing symlink",
                    (!retval));
        printk("Pathlookup got %s (f1-1.txt)\n", nd->dentry->d_name.name);
        path_release(nd);
-       
+
        /* try with a rel path */
        printk("Try with a rel path\n");
        memset(nd, 0, sizeof(struct nameidata));
        retval = path_lookup("/symdir/up/hello.txt", 0, nd);
-       KT_ASSERT_M("symlink lookup should work for an existing symlink", 
+       KT_ASSERT_M("symlink lookup should work for an existing symlink",
                    (!retval));
        printk("Pathlookup got %s (hello.txt)\n", nd->dentry->d_name.name);
        path_release(nd);
-       
+
        printk("Try for an ELOOP\n");
        memset(nd, 0, sizeof(struct nameidata));
        retval = path_lookup("/symdir/up/symdir/up/symdir/up/symdir/up/hello.txt", 0, nd);
-       KT_ASSERT_M("symlink lookup should fail for a non existing symlink", 
+       KT_ASSERT_M("symlink lookup should fail for a non existing symlink",
                    (retval));
        path_release(nd);
 
@@ -1460,7 +1460,7 @@ bool test_kref(void)
 {
        struct kref local_kref;
        bool done = FALSE;
-       
+
        kref_init(&local_kref, fake_release, 1);
        send_kernel_message(2, __test_kref_2, (long)&local_kref, (long)&done, 0,
                            KMSG_ROUTINE);
@@ -1515,9 +1515,9 @@ bool test_atomics(void)
                do {
                        old_num = atomic_read(&actual_num);
                        /* First time, try to fail */
-                       if (attempt == 0) 
+                       if (attempt == 0)
                                old_num++;
-                       attempt++;      
+                       attempt++;
                } while (!atomic_cas(&actual_num, old_num, old_num + 10));
                if (atomic_read(&actual_num) != init_val + 10) {
                        return false;
@@ -1684,19 +1684,19 @@ bool test_cv(void)
 bool test_memset(void)
 {
        #define ARR_SZ 256
-       
+
        void print_array(char *c, size_t len)
        {
                for (int i = 0; i < len; i++)
                        printk("%04d: %02x\n", i, *c++);
        }
-       
+
        bool check_array(char *c, char x, size_t len)
        {
                for (int i = 0; i < len; i++) {
                        #define ASSRT_SIZE 64
                        char *assrt_msg = (char*) kmalloc(ASSRT_SIZE, 0);
-                       snprintf(assrt_msg, ASSRT_SIZE, 
+                       snprintf(assrt_msg, ASSRT_SIZE,
                                     "Char %d is %c (%02x), should be %c (%02x)", i, *c, *c,
                                     x, x);
                        KT_ASSERT_M(assrt_msg, (*c == x));
@@ -1704,7 +1704,7 @@ bool test_memset(void)
                }
                return true;
        }
-       
+
        bool run_check(char *arr, int ch, size_t len)
        {
                char *c = arr;
@@ -1734,7 +1734,7 @@ void __attribute__((noinline)) __longjmp_wrapper(struct jmpbuf* jb)
        printk("Starting: %s\n", __FUNCTION__);
        longjmp(jb, 1);
        // Should never get here
-       printk("Exiting: %s\n", __FUNCTION__); 
+       printk("Exiting: %s\n", __FUNCTION__);
 }
 
 // TODO: Add assertions.
@@ -1892,7 +1892,7 @@ bool test_rwlock(void)
                /* signal to allow core 0 to finish */
                atomic_dec(&rwlock_counter);
        }
-               
+
        /* send 4 messages to each non core 0 */
        atomic_init(&rwlock_counter, (num_cores - 1) * 4);
        for (int i = 1; i < num_cores; i++)
index 173722d..53aca31 100644 (file)
@@ -118,7 +118,7 @@ static void __launch_kthread(uint32_t srcid, long a0, long a1, long a2)
        struct kthread *kthread = (struct kthread*)a0;
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        struct proc *cur_proc = pcpui->cur_proc;
-       
+
        /* Make sure we are a routine kmsg */
        assert(in_early_rkmsg_ctx(pcpui));
        if (pcpui->owning_proc && pcpui->owning_proc != kthread->proc) {
@@ -381,7 +381,7 @@ void sem_down(struct semaphore *sem)
                proc_incref(kthread->proc, 1);
        } else {
                kthread->proc = 0;
-       } 
+       }
        if (setjmp(&kthread->context))
                goto block_return_path;
        spin_lock(&sem->lock);
index 92f5612..fe442ad 100644 (file)
@@ -113,7 +113,7 @@ void manager_brho(void)
        static bool first = TRUE;
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 
-       if (first) {    
+       if (first) {
                printk("*** IRQs must be enabled for input emergency codes ***\n");
                #ifdef CONFIG_X86
                printk("*** Hit ctrl-g to enter the monitor. ***\n");
@@ -222,7 +222,7 @@ void manager_brho(void)
 }
 
 void manager_jenkins()
-{ 
+{
        #ifdef CONFIG_KERNEL_TESTING
                printk("<-- BEGIN_KERNEL_TESTS -->\n");
                run_registered_ktest_suites();
@@ -279,7 +279,7 @@ void manager_waterman()
 
 void manager_yuzhu()
 {
-       
+
        static uint8_t progress = 0;
        static struct proc *p;
 
index bf6ed35..9476deb 100644 (file)
@@ -364,8 +364,8 @@ int duplicate_vmrs(struct proc *p, struct proc *new_p)
                vmr->vm_proc = new_p;
                vmr->vm_base = vm_i->vm_base;
                vmr->vm_end = vm_i->vm_end;
-               vmr->vm_prot = vm_i->vm_prot;   
-               vmr->vm_flags = vm_i->vm_flags; 
+               vmr->vm_prot = vm_i->vm_prot;
+               vmr->vm_flags = vm_i->vm_flags;
                vmr->vm_file = vm_i->vm_file;
                vmr->vm_foff = vm_i->vm_foff;
                if (vm_i->vm_file) {
index d1398fe..85a56bd 100644 (file)
@@ -288,7 +288,7 @@ int mon_bin_ls(int argc, char **argv, struct hw_trapframe *hw_tf)
        }
        printk("Files in /bin:\n-------------------------------\n");
        do {
-               retval = bin_dir->f_op->readdir(bin_dir, &dir); 
+               retval = bin_dir->f_op->readdir(bin_dir, &dir);
                printk("%s\n", dir.d_name);
        } while (retval == 1);
        kref_put(&bin_dir->f_kref);
@@ -548,7 +548,7 @@ int mon_measure(int argc, char **argv, struct hw_trapframe *hw_tf)
 #ifdef CONFIG_APPSERVER
                /* Won't be that accurate, since it's not actually going through the
                 * __proc_free() path. */
-               spin_on(kref_refcnt(&p->p_kref) != end_refcnt); 
+               spin_on(kref_refcnt(&p->p_kref) != end_refcnt);
 #else
                /* this is a little ghetto. it's not fully free yet, but we are also
                 * slowing it down by messing with it, esp with the busy waiting on a
@@ -734,7 +734,7 @@ int mon_trace(int argc, char **argv, struct hw_trapframe *hw_tf)
                        pcpui_type = 0;
                printk("\nRunning PCPUI Trace Ring handlers for type %d\n", pcpui_type);
                if (argc >= 4) {
-                       pcpui_coreid = strtol(argv[3], 0, 0); 
+                       pcpui_coreid = strtol(argv[3], 0, 0);
                        pcpui_tr_foreach(pcpui_coreid, pcpui_type);
                } else {
                        pcpui_tr_foreach_all(pcpui_type);
index 89346d9..2803eeb 100644 (file)
@@ -1,7 +1,7 @@
 /* Copyright (c) 2009,13 The Regents of the University of California
  * Barret Rhoden <brho@cs.berkeley.edu>
  * Kevin Klues <klueska@cs.berkeley.edu>
- * See LICENSE for details. 
+ * See LICENSE for details.
  *
  * Multiboot parsing and helper functions. */
 
index 9d6b8bb..658c1b9 100644 (file)
@@ -325,7 +325,7 @@ void udpkick(void *x, struct block *bp)
                        if (bp == NULL)
                                return;
 
-                       // using the v6 ip header to create pseudo header 
+                       // using the v6 ip header to create pseudo header
                        // first then reset it to the normal ip header
                        uh6 = (Udp6hdr *) (bp->rp);
                        memset(uh6, 0, 8);
@@ -388,7 +388,7 @@ void udpiput(struct Proto *udp, struct Ipifc *ifc, struct block *bp)
        version = ((uh4->vihl & 0xF0) == IP_VER6) ? V6 : V4;
 
        /*
-        * Put back pseudo header for checksum 
+        * Put back pseudo header for checksum
         * (remember old values for icmpnoconv())
         */
        switch (version) {
index e702c18..59b4573 100644 (file)
@@ -49,7 +49,7 @@ int statcheck(uint8_t * buf, unsigned int nbuf)
 
        if (nbuf < STATFIXLEN || nbuf != BIT16SZ + GBIT16(buf)){
                printk("nbuf %d, STATFIXLEN %d ", nbuf, STATFIXLEN);
-               printk("BIT16SZ %d, GBIT16(buf) %d ", 
+               printk("BIT16SZ %d, GBIT16(buf) %d ",
                        BIT16SZ, GBIT16(buf));
                printk("This is bad!\n");
                return -1;
index 4475b9e..5f89b8f 100644 (file)
@@ -68,7 +68,7 @@ unsigned int convM2kdirent(uint8_t * buf, unsigned int nbuf, struct kdirent *kd,
        /* for now, uids in akaros are ints. Does not
         * matter; kdirents are limited in what they tell you.
         * get the name, ignore the rest. Maybe we can
-        * fix this later. 
+        * fix this later.
         */
        for (i = 0; i < 4; i++) {
                if (p + BIT16SZ > ebuf)
@@ -149,7 +149,7 @@ unsigned int convM2kstat(uint8_t * buf, unsigned int nbuf, struct kstat *ks)
        ks->st_blksize = 512;
        ks->st_blocks = ROUNDUP(ks->st_size, ks->st_blksize) / ks->st_blksize;
 
-       ks->st_nlink = 2;       // links make no sense any more. 
+       ks->st_nlink = 2;       // links make no sense any more.
        ks->st_uid = ks->st_gid = 0;
 
        return p - buf;
index 69f4f5e..fa984dd 100644 (file)
@@ -932,7 +932,7 @@ struct block *packblock(struct block *bp)
 }
 
 /* Add an extra_data entry to newb at newb_idx pointing to b's body, starting at
- * body_rp, for up to len.  Returns the len consumed. 
+ * body_rp, for up to len.  Returns the len consumed.
  *
  * The base is 'b', so that we can kfree it later.  This currently ties us to
  * using kfree for the release method for all extra_data.
@@ -1255,7 +1255,7 @@ static size_t read_from_block(struct block *b, uint8_t *to, size_t amt)
 {
        size_t copy_amt, retval = 0;
        struct extra_bdata *ebd;
-       
+
        copy_amt = MIN(BHLEN(b), amt);
        memcpy(to, b->rp, copy_amt);
        /* advance the rp, since this block not be completely consumed and future
index 1cd310c..72cfeea 100644 (file)
@@ -848,7 +848,7 @@ int64_t sysseek(int fd, int64_t off, int whence)
 
 void validstat(uint8_t * s, int n, int slashok)
 {
-       
+
        int m;
        char buf[64];
 
@@ -900,7 +900,7 @@ int sysfstat(int fd, uint8_t *buf, int n)
 
 int sysfstatakaros(int fd, struct kstat *ks)
 {
-       
+
        int n = 4096;
        uint8_t *buf;
        buf = kmalloc(n, MEM_WAIT);
@@ -939,7 +939,7 @@ int sysstat(char *path, uint8_t *buf, int n)
 
 int sysstatakaros(char *path, struct kstat *ks)
 {
-       
+
        int n = 4096;
        uint8_t *buf;
        buf = kmalloc(n, MEM_WAIT);
@@ -1138,7 +1138,7 @@ struct dir *sysdirfstat(int fd)
 
 int sysdirwstat(char *name, struct dir *dir)
 {
-       
+
        uint8_t *buf;
        int r;
 
@@ -1152,7 +1152,7 @@ int sysdirwstat(char *name, struct dir *dir)
 
 int sysdirfwstat(int fd, struct dir *dir)
 {
-       
+
        uint8_t *buf;
        int r;
 
@@ -1166,7 +1166,7 @@ int sysdirfwstat(int fd, struct dir *dir)
 
 static long dirpackage(uint8_t * buf, long ts, struct kdirent **d)
 {
-       
+
        char *s;
        long ss, i, n, nn, m = 0;
 
@@ -1261,7 +1261,7 @@ int sysiounit(int fd)
 
 void print_chaninfo(struct chan *c)
 {
-       
+
        char buf[64] = { 0 };
        bool has_dev = c->type != -1;
        if (has_dev && !devtab[c->type].chaninfo) {
@@ -1284,7 +1284,7 @@ void print_chaninfo(struct chan *c)
  * the pgrp. */
 int plan9setup(struct proc *new_proc, struct proc *parent, int flags)
 {
-       
+
        struct kref *new_dot_ref;
        ERRSTACK(1);
        if (waserror()) {
index ac3b1ce..9609f8d 100644 (file)
@@ -1,8 +1,8 @@
-/* Copyright (c) 2009, 2010 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
+/* Copyright (c) 2009, 2010 The Regents of the University  of California.
+ * See the COPYRIGHT files at the top of this source tree for full
  * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
+ *
+ * Kevin Klues <klueska@cs.berkeley.edu>
  * Barret Rhoden <brho@cs.berkeley.edu> */
 
 #include <ros/errno.h>
@@ -35,7 +35,7 @@ size_t global_next_color = 0;
 
 void colored_page_alloc_init()
 {
-       global_cache_colors_map = 
+       global_cache_colors_map =
               kmalloc(BYTES_FOR_BITMASK(llc_cache->num_colors), 0);
        CLR_BITMASK(global_cache_colors_map, llc_cache->num_colors);
        for(int i = 0; i < llc_cache->num_colors/NUM_KERNEL_COLORS; i++)
@@ -68,27 +68,27 @@ static void __page_init(struct page *page)
        }                                                                       \
        return -ENOMEM;
 
-static ssize_t __page_alloc_from_color_range(page_t** page,  
+static ssize_t __page_alloc_from_color_range(page_t** page,
                                            uint16_t base_color,
-                                           uint16_t range) 
+                                           uint16_t range)
 {
-       __PAGE_ALLOC_FROM_RANGE_GENERIC(page, base_color, range, 
+       __PAGE_ALLOC_FROM_RANGE_GENERIC(page, base_color, range,
                         !BSD_LIST_EMPTY(&colored_page_free_list[i]));
 }
 
-static ssize_t __page_alloc_from_color_map_range(page_t** page, uint8_t* map, 
+static ssize_t __page_alloc_from_color_map_range(page_t** page, uint8_t* map,
                                               size_t base_color, size_t range)
-{  
-       __PAGE_ALLOC_FROM_RANGE_GENERIC(page, base_color, range, 
+{
+       __PAGE_ALLOC_FROM_RANGE_GENERIC(page, base_color, range,
                    GET_BITMASK_BIT(map, i) &&
                        !BSD_LIST_EMPTY(&colored_page_free_list[i]))
 }
 
-static ssize_t __colored_page_alloc(uint8_t* map, page_t** page, 
+static ssize_t __colored_page_alloc(uint8_t* map, page_t** page,
                                                size_t next_color)
 {
        ssize_t ret;
-       if((ret = __page_alloc_from_color_map_range(page, map, 
+       if((ret = __page_alloc_from_color_map_range(page, map,
                                   next_color, llc_cache->num_colors - next_color)) < 0)
                ret = __page_alloc_from_color_map_range(page, map, 0, next_color);
        return ret;
@@ -126,7 +126,7 @@ static error_t __page_alloc_specific(page_t** page, size_t ppn)
 error_t upage_alloc(struct proc* p, page_t** page, int zero)
 {
        spin_lock_irqsave(&colored_page_free_list_lock);
-       ssize_t ret = __colored_page_alloc(p->cache_colors_map, 
+       ssize_t ret = __colored_page_alloc(p->cache_colors_map,
                                             page, p->next_cache_color);
        spin_unlock_irqsave(&colored_page_free_list_lock);
 
@@ -140,20 +140,20 @@ error_t upage_alloc(struct proc* p, page_t** page, int zero)
 }
 
 /* Allocates a refcounted page of memory for the kernel's use */
-error_t kpage_alloc(page_t** page) 
+error_t kpage_alloc(page_t** page)
 {
        ssize_t ret;
        spin_lock_irqsave(&colored_page_free_list_lock);
-       if ((ret = __page_alloc_from_color_range(page, global_next_color, 
+       if ((ret = __page_alloc_from_color_range(page, global_next_color,
                                    llc_cache->num_colors - global_next_color)) < 0)
                ret = __page_alloc_from_color_range(page, 0, global_next_color);
 
        if (ret >= 0) {
-               global_next_color = ret;        
+               global_next_color = ret;
                ret = ESUCCESS;
        }
        spin_unlock_irqsave(&colored_page_free_list_lock);
-       
+
        return ret;
 }
 
@@ -186,7 +186,7 @@ void *kpage_zalloc_addr(void)
  */
 void *get_cont_pages(size_t order, int flags)
 {
-       size_t npages = 1 << order;     
+       size_t npages = 1 << order;
 
        size_t naddrpages = max_paddr / PGSIZE;
        // Find 'npages' free consecutive pages
@@ -283,7 +283,7 @@ void *get_cont_phys_pages_at(size_t order, physaddr_t at, int flags)
 
 void free_cont_pages(void *buf, size_t order)
 {
-       size_t npages = 1 << order;     
+       size_t npages = 1 << order;
        spin_lock_irqsave(&colored_page_free_list_lock);
        for (size_t i = kva2ppn(buf); i < kva2ppn(buf) + npages; i++) {
                page_t* page = ppn2page(i);
@@ -291,7 +291,7 @@ void free_cont_pages(void *buf, size_t order)
                assert(page_is_free(i));
        }
        spin_unlock_irqsave(&colored_page_free_list_lock);
-       return; 
+       return;
 }
 
 /*
@@ -300,12 +300,12 @@ void free_cont_pages(void *buf, size_t order)
  * the caller must do that if necessary.
  *
  * ppn         -- the page number to allocate
- * *page       -- is set to point to the Page struct 
+ * *page       -- is set to point to the Page struct
  *                of the newly allocated page
  *
- * RETURNS 
+ * RETURNS
  *   ESUCCESS  -- on success
- *   -ENOMEM   -- otherwise 
+ *   -ENOMEM   -- otherwise
  */
 error_t upage_alloc_specific(struct proc* p, page_t** page, size_t ppn)
 {
@@ -376,7 +376,7 @@ static void page_release(struct kref *kref)
  * code).  Sets the reference count on a page to a specific value, usually 1. */
 void page_setref(page_t *page, size_t val)
 {
-       kref_init(&page->pg_kref, page_release, val); 
+       kref_init(&page->pg_kref, page_release, val);
 }
 
 /* Attempts to get a lock on the page for IO operations.  If it is already
index b16020f..749f245 100644 (file)
@@ -1,6 +1,6 @@
 /* Copyright (c) 2009,13 The Regents of the University of California
  * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details. 
+ * See LICENSE for details.
  *
  * Arch independent physical memory and page table management.
  *
@@ -98,7 +98,7 @@ static void set_largest_freezone(struct multiboot_mmap_entry *entry, void *data)
  * "end" is a symbol marking the end of the kernel.  This covers anything linked
  * in with the kernel (KFS, etc).  However, 'end' is a kernel load address,
  * which differs from kernbase addrs in 64 bit.  We need to use the kernbase
- * mapping for anything dynamic (because it could go beyond 1 GB). 
+ * mapping for anything dynamic (because it could go beyond 1 GB).
  *
  * Ideally, we'll use the largest mmap zone, as reported by multiboot.  If we
  * don't have one (riscv), we'll just use the memory after the kernel.
@@ -175,25 +175,25 @@ void *boot_zalloc(size_t amt, size_t align)
        return v;
 }
 
-/** 
+/**
  * @brief Map the physical page 'pp' into the virtual address 'va' in page
  *        directory 'pgdir'
  *
  * Map the physical page 'pp' at virtual address 'va'.
  * The permissions (the low 12 bits) of the page table
  * entry should be set to 'perm|PTE_P'.
- * 
+ *
  * Details:
  *   - If there is already a page mapped at 'va', it is page_remove()d.
- *   - If necessary, on demand, allocates a page table and inserts it into 
+ *   - If necessary, on demand, allocates a page table and inserts it into
  *     'pgdir'.
- *   - page_incref() should be called if the insertion succeeds. 
+ *   - page_incref() should be called if the insertion succeeds.
  *   - The TLB must be invalidated if a page was formerly present at 'va'.
  *     (this is handled in page_remove)
  *
  * No support for jumbos here.  We will need to be careful when trying to
  * insert regular pages into something that was already jumbo.  We will
- * also need to be careful with our overloading of the PTE_PS and 
+ * also need to be careful with our overloading of the PTE_PS and
  * PTE_PAT flags...
  *
  * @param[in] pgdir the page directory to insert the page into
@@ -201,7 +201,7 @@ void *boot_zalloc(size_t amt, size_t align)
  *                  physical page that should be inserted.
  * @param[in] va    the virtual address where the page should be
  *                  inserted.
- * @param[in] perm  the permition bits with which to set up the 
+ * @param[in] perm  the permition bits with which to set up the
  *                  virtual mapping.
  *
  * @return ESUCCESS  on success
@@ -209,7 +209,7 @@ void *boot_zalloc(size_t amt, size_t align)
  *                   into which the page should be inserted
  *
  */
-int page_insert(pgdir_t pgdir, struct page *page, void *va, int perm) 
+int page_insert(pgdir_t pgdir, struct page *page, void *va, int perm)
 {
        pte_t pte = pgdir_walk(pgdir, va, 1);
        if (!pte_walk_okay(pte))
@@ -228,7 +228,7 @@ int page_insert(pgdir_t pgdir, struct page *page, void *va, int perm)
 }
 
 /**
- * @brief Return the page mapped at virtual address 'va' in 
+ * @brief Return the page mapped at virtual address 'va' in
  * page directory 'pgdir'.
  *
  * If pte_store is not NULL, then we store in it the address
@@ -258,7 +258,7 @@ page_t *page_lookup(pgdir_t pgdir, void *va, pte_t *pte_store)
  * @brief Unmaps the physical page at virtual address 'va' in page directory
  * 'pgdir'.
  *
- * If there is no physical page at that address, this function silently 
+ * If there is no physical page at that address, this function silently
  * does nothing.
  *
  * Details:
@@ -268,10 +268,10 @@ page_t *page_lookup(pgdir_t pgdir, void *va, pte_t *pte_store)
  *     (if such a PTE exists)
  *   - The TLB is invalidated if an entry is removes from the pg dir/pg table.
  *
- * This may be wonky wrt Jumbo pages and decref.  
+ * This may be wonky wrt Jumbo pages and decref.
  *
  * @param pgdir the page directory from with the page sholuld be removed
- * @param va    the virtual address at which the page we are trying to 
+ * @param va    the virtual address at which the page we are trying to
  *              remove is mapped
  * TODO: consider deprecating this, or at least changing how it works with TLBs.
  * Might want to have the caller need to manage the TLB.  Also note it is used
@@ -306,7 +306,7 @@ void page_remove(pgdir_t pgdir, void *va)
  *
  * TODO: (TLB) Need to sort this for cross core lovin'
  *
- * @param pgdir the page directory assocaited with the tlb entry 
+ * @param pgdir the page directory assocaited with the tlb entry
  *              we are trying to invalidate
  * @param va    the virtual address associated with the tlb entry
  *              we are trying to invalidate
@@ -321,7 +321,7 @@ void tlb_invalidate(pgdir_t pgdir, void *va)
 /* Helper, returns true if any part of (start1, end1) is within (start2, end2).
  * Equality of endpoints (like end1 == start2) is okay.
  * Assumes no wrap-around. */
-bool regions_collide_unsafe(uintptr_t start1, uintptr_t end1, 
+bool regions_collide_unsafe(uintptr_t start1, uintptr_t end1,
                             uintptr_t start2, uintptr_t end2)
 {
        if (start1 <= start2) {
index 9434dc3..ee15ad2 100644 (file)
@@ -123,7 +123,7 @@ void *radix_delete(struct radix_tree *tree, unsigned long key)
        slot = &r_node->items[key & (NR_RNODE_SLOTS - 1)];
        retval = *slot;
        if (retval) {
-               __radix_remove_slot(r_node, (struct radix_node**)slot); 
+               __radix_remove_slot(r_node, (struct radix_node**)slot);
        } else {
                /* it's okay to delete an empty, but i want to know about it for now */
                warn("Tried to remove a non-existant item from a radix tree!");
index 0bc5bf0..aeceb1b 100644 (file)
@@ -42,7 +42,7 @@ static uint32_t get_cores_needed(struct proc *p);
 /* poke-style ksched - ensures the MCP ksched only runs once at a time.  since
  * only one mcp ksched runs at a time, while this is set, the ksched knows no
  * cores are being allocated by other code (though they could be dealloc, due to
- * yield). 
+ * yield).
  *
  * The main value to this sync method is to make the 'make sure the ksched runs
  * only once at a time and that it actually runs' invariant/desire wait-free, so
@@ -325,7 +325,7 @@ static bool __schedule_scp(void)
                         * proc_run_s would pick it up.  This way is a bit safer for
                         * future changes, but has an extra (empty) TLB flush.  */
                        abandon_core();
-               } 
+               }
                /* Run the new proc */
                switch_lists(p, &runnable_scps, &unrunnable_scps);
                printd("PID of the SCP i'm running: %d\n", p->pid);
@@ -436,7 +436,7 @@ static void __run_mcp_ksched(void *arg)
 }
 
 /* Something has changed, and for whatever reason the scheduler should
- * reevaluate things. 
+ * reevaluate things.
  *
  * Don't call this if you are processing a syscall or otherwise care about your
  * kthread variables, cur_proc/owning_proc, etc.
index 397bb28..4cc6f13 100644 (file)
@@ -46,7 +46,7 @@ static void __kmem_cache_create(struct kmem_cache *kc, const char *name,
        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;
        spin_lock_irqsave(&kmem_caches_lock);
@@ -75,10 +75,10 @@ void kmem_cache_init(void)
                            __alignof__(struct kmem_cache), 0, NULL, NULL);
        /* Build the slab and bufctl caches */
        kmem_slab_cache = kmem_cache_create("kmem_slab", sizeof(struct kmem_slab),
-                              __alignof__(struct kmem_slab), 0, NULL, NULL); 
+                              __alignof__(struct kmem_slab), 0, NULL, NULL);
        kmem_bufctl_cache = kmem_cache_create("kmem_bufctl",
                                 sizeof(struct kmem_bufctl),
-                                __alignof__(struct kmem_bufctl), 0, NULL, NULL); 
+                                __alignof__(struct kmem_bufctl), 0, NULL, NULL);
 }
 
 /* Cache management */
@@ -149,7 +149,7 @@ void kmem_cache_destroy(struct kmem_cache *cp)
        spin_lock_irqsave(&kmem_caches_lock);
        SLIST_REMOVE(&kmem_caches, cp, kmem_cache, link);
        spin_unlock_irqsave(&kmem_caches_lock);
-       kmem_cache_free(&kmem_cache_cache, cp); 
+       kmem_cache_free(&kmem_cache_cache, cp);
        spin_unlock_irqsave(&cp->cache_lock);
 }
 
@@ -175,7 +175,7 @@ void *kmem_cache_alloc(struct kmem_cache *cp, int flags)
                a_slab = TAILQ_FIRST(&cp->empty_slab_list);
                TAILQ_REMOVE(&cp->empty_slab_list, a_slab, link);
                TAILQ_INSERT_HEAD(&cp->partial_slab_list, a_slab, link);
-       } 
+       }
        // have a partial now (a_slab), get an item, return item
        if (cp->obj_size <= SLAB_LARGE_CUTOFF) {
                retval = a_slab->free_small_obj;
@@ -307,7 +307,7 @@ static bool kmem_cache_grow(struct kmem_cache *cp)
                        // Initialize the object, if necessary
                        if (cp->ctor)
                                cp->ctor(buf, cp->obj_size);
-                       a_bufctl = kmem_cache_alloc(kmem_bufctl_cache, 0);      
+                       a_bufctl = kmem_cache_alloc(kmem_bufctl_cache, 0);
                        TAILQ_INSERT_HEAD(&a_slab->bufctl_freelist, a_bufctl, link);
                        a_bufctl->buf_addr = buf;
                        a_bufctl->my_slab = a_slab;
@@ -328,7 +328,7 @@ static bool kmem_cache_grow(struct kmem_cache *cp)
 void kmem_cache_reap(struct kmem_cache *cp)
 {
        struct kmem_slab *a_slab, *next;
-       
+
        // Destroy all empty slabs.  Refer to the notes about the while loop
        spin_lock_irqsave(&cp->cache_lock);
        a_slab = TAILQ_FIRST(&cp->empty_slab_list);
index 483417e..30a6986 100644 (file)
@@ -301,7 +301,7 @@ memmove(void *dst, const void *src, size_t _n)
        const char *s;
        char *d;
        size_t n = _n;
-       
+
        s = src;
        d = dst;
        if (s < d && s + n > d) {
index 32a0ff0..7246bff 100644 (file)
@@ -278,7 +278,7 @@ static void finish_sysc(struct syscall *sysc, struct proc *p)
         * to not muck with the flags while we're signalling. */
        atomic_or(&sysc->flags, SC_K_LOCK | SC_DONE);
        __signal_syscall(sysc, p);
-       atomic_and(&sysc->flags, ~SC_K_LOCK); 
+       atomic_and(&sysc->flags, ~SC_K_LOCK);
 }
 
 /* Helper that "finishes" the current async syscall.  This should be used with
@@ -917,7 +917,7 @@ static int execargs_stringer(struct proc *p, char *d, size_t slen,
  * argv and envp are magically bundled in procinfo for now.  Keep in sync with
  * glibc's sysdeps/ros/execve.c.  Once past a certain point, this function won't
  * return.  It assumes (and checks) that it is current.  Don't give it an extra
- * refcnt'd *p (syscall won't do that). 
+ * refcnt'd *p (syscall won't do that).
  * Note: if someone batched syscalls with this call, they could clobber their
  * old memory (and will likely PF and die).  Don't do it... */
 static int sys_exec(struct proc *p, char *path, size_t path_l,
@@ -1466,7 +1466,7 @@ static int sys_vmm_poke_guest(struct proc *p, int guest_pcoreid)
 
 /* Pokes the ksched for the given resource for target_pid.  If the target pid
  * == 0, we just poke for the calling process.  The common case is poking for
- * self, so we avoid the lookup. 
+ * self, so we avoid the lookup.
  *
  * Not sure if you could harm someone via asking the kernel to look at them, so
  * we'll do a 'controls' check for now.  In the future, we might have something
@@ -2393,7 +2393,7 @@ intreg_t sys_rename(struct proc *p, char *old_path, size_t old_path_l,
        printd("Newchan: %C\n", newchan);
        printd("Newchan: mchan %C\n", newchan->mchan);
 
-       if ((newchan->dev != oldchan->dev) || 
+       if ((newchan->dev != oldchan->dev) ||
                (newchan->type != oldchan->type)) {
                printd("Old chan and new chan do not match\n");
                set_errno(ENODEV);
@@ -2448,7 +2448,7 @@ intreg_t sys_rename(struct proc *p, char *old_path, size_t old_path_l,
        };
        printk("syswstat returns %d\n", retval);
 
-done: 
+done:
        free_path(p, from_path);
        free_path(p, to_path);
        cclose(oldchan);