Massive indent run, tabs to space -linux -nut -ts4 -i4
authorJack Miller <jack@codezen.org>
Tue, 29 Mar 2016 05:03:52 +0000 (00:03 -0500)
committerJack Miller <jack@codezen.org>
Tue, 29 Mar 2016 05:03:52 +0000 (00:03 -0500)
36 files changed:
boot/grub_sig.c
include/acpi.h
include/apic.h
include/asm/cpuid.h
include/asm/mmio.h
include/asm/msr.h
include/asm/realmode.h
include/asm/regs.h
include/asm/spinlock.h
include/console.h
include/domain.h
include/errno.h
include/grub.h
include/irq.h
include/kernel.h
include/map.h
include/memmap.h
include/objcache.h
include/page_alloc.h
include/paging.h
include/smp.h
include/types.h
kernel/acpi.c
kernel/apic.c
kernel/console.c
kernel/cpuid.c
kernel/irq.c
kernel/main.c
kernel/smp.c
kernel/string.c
kernel/vga.c
mm/domain.c
mm/map.c
mm/objcache.c
mm/page_alloc.c
mm/vsalloc.c

index cb35bae..09730d6 100644 (file)
@@ -1,5 +1,5 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #include <grub.h>
 
-struct grub_signature gs __attribute__ ((section (".grub_sig"))) =
-       { GRUB_MAGIC, GRUB_FLAGS, GRUB_CHECKSUM };
+struct grub_signature gs __attribute__ ((section(".grub_sig"))) = {
+GRUB_MAGIC, GRUB_FLAGS, GRUB_CHECKSUM};
index f9edee1..69aa75f 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #pragma once
 
index db29ba8..1bc562b 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 struct apic {
@@ -6,18 +6,17 @@ struct apic {
     void (*eoi) (void);
     void (*wake_secondary) (u8 apic_id);
     void (*start_timer) (void);
-       u8 (*get_id) (void);
-       u32 (*read) (u32 offset);
-       void (*write) (u32 offset, u32 val);
-       void (*write_icr) (u32 dest, u32 val);
-       void (*wait) (void);
+     u8(*get_id) (void);
+     u32(*read) (u32 offset);
+    void (*write) (u32 offset, u32 val);
+    void (*write_icr) (u32 dest, u32 val);
+    void (*wait) (void);
 };
 
 static inline void disable_pic(void)
 {
-       asm volatile ("mov $0xff, %%al \n"
-                                 "out %%al, $0xa1 \n"
-                                 "out %%al, $0x21" : : : "al");
+    asm volatile ("mov $0xff, %%al \n"
+                  "out %%al, $0xa1 \n" "out %%al, $0x21":::"al");
 }
 
 int apic_init(void);
index cccf006..bcc5a7c 100644 (file)
@@ -1,9 +1,10 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 static inline void cpuid(u32 eax, u32 regs[4])
 {
-    asm volatile("cpuid" : "=a"(regs[0]), "=b"(regs[1]), "=c"(regs[2]), "=d" (regs[3]) : "a"(eax));
+    asm volatile ("cpuid":"=a" (regs[0]), "=b"(regs[1]), "=c"(regs[2]),
+                  "=d"(regs[3]):"a"(eax));
 }
 
 int cpuid_init(void);
index bcbcfb5..0d8ecae 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 /* Inline MMIO helpers. These exist because when you're writing MMIO areas, you
 
 static inline void mmio_write(const volatile void *addr, u32 offset, u32 val)
 {
-       asm volatile("movl %0,%1": : "r"(val), "m" (*(volatile u32 *) ((u64) addr + offset)));
+    asm volatile ("movl %0,%1"::"r" (val),
+                  "m"(*(volatile u32 *)((u64) addr + offset)));
 }
 
 static inline u32 mmio_read(const volatile void *addr, u32 offset)
 {
-       u32 ret;
-       asm volatile("movl %1,%0": "=r"(ret) : "m" (*(volatile u32 *) ((u64) addr + offset)) : "memory");
-       return ret;
+    u32 ret;
+    asm volatile ("movl %1,%0":"=r" (ret):"m"
+                  (*(volatile u32 *)((u64) addr + offset)):"memory");
+    return ret;
 }
index 5d6ebb8..5f64152 100644 (file)
@@ -4,12 +4,12 @@ static inline u64 rdmsr(u32 msr)
 {
     u32 eax, edx;
 
-    asm volatile("rdmsr" : "=a" (eax), "=d" (edx) : "c" (msr));
+    asm volatile ("rdmsr":"=a" (eax), "=d"(edx):"c"(msr));
 
     return (((u64) edx << 32) | eax);
 }
 
 static inline void wrmsr(u32 msr, u64 val)
 {
-    asm volatile("wrmsr" : : "c" (msr), "d" ((u32) (val >> 32)), "a" ((u32) val));
+    asm volatile ("wrmsr"::"c" (msr), "d"((u32) (val >> 32)), "a"((u32) val));
 }
index c5caf5b..31090b4 100644 (file)
@@ -9,12 +9,12 @@ extern u64 end_realmode_bin;
 #define REALMODE_BIN_LEN (((u64) &end_realmode_bin) - ((u64) &realmode_bin))
 
 struct rm_header {
-       u8   jmp[2]; /* Two bytes for the jump over data */
-       u32  cr3;
-       u64  gdtr;
-       u64  sp;
-       u64  kernel_entry;
-} __attribute__((packed));
+    u8 jmp[2];                  /* Two bytes for the jump over data */
+    u32 cr3;
+    u64 gdtr;
+    u64 sp;
+    u64 kernel_entry;
+} __attribute__ ((packed));
 
 extern u64 GDTR_64;
 #endif
index c1d9af1..21ca17d 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #pragma once
 
 
 struct regs {
 
-       /* we pushed these */
-
-       u64 r15;
-       u64 r14;
-       u64 r13;
-       u64 r12;
-       u64 rbp;
-       u64 rbx;
-       u64 r11;
-       u64 r10;
-       u64 rax;
-       u64 r9;
-       u64 r8;
-       u64 rcx;
-       u64 rdx;
-       u64 rsi;
-       u64 rdi;
-       u64 vector;
-
-       /* the processor pushed these (or we did for error code stub) */
-
-       u64     error_code;
-       u64 rip;
-       u64 cs;
-       u64 rflags;
-       u64 rsp;
-       u64 ss;
+    /* we pushed these */
+
+    u64 r15;
+    u64 r14;
+    u64 r13;
+    u64 r12;
+    u64 rbp;
+    u64 rbx;
+    u64 r11;
+    u64 r10;
+    u64 rax;
+    u64 r9;
+    u64 r8;
+    u64 rcx;
+    u64 rdx;
+    u64 rsi;
+    u64 rdi;
+    u64 vector;
+
+    /* the processor pushed these (or we did for error code stub) */
+
+    u64 error_code;
+    u64 rip;
+    u64 cs;
+    u64 rflags;
+    u64 rsp;
+    u64 ss;
 };
 
 static inline u64 get_cr3(void)
 {
     u64 ret;
 
-    asm volatile("mov %%cr3, %0" : "=r" (ret));
+    asm volatile ("mov %%cr3, %0":"=r" (ret));
 
     return ret;
 }
@@ -57,7 +57,7 @@ static inline u64 get_cr2(void)
 {
     u64 ret;
 
-    asm volatile("mov %%cr2, %0" : "=r" (ret));
+    asm volatile ("mov %%cr2, %0":"=r" (ret));
 
     return ret;
 }
@@ -66,6 +66,5 @@ static inline u64 get_cr2(void)
 
 static inline void reset_cr3(void)
 {
-    asm volatile("mov %%cr3, %%rax \n"
-                                "mov %%rax, %%cr3" : : : "%rax");
+    asm volatile ("mov %%cr3, %%rax \n" "mov %%rax, %%cr3":::"%rax");
 }
index b49c424..3ce677b 100644 (file)
@@ -2,7 +2,7 @@
 
 struct spinlock {
     u32 lock;
-} __attribute__((aligned(8)));
+} __attribute__ ((aligned(8)));
 
 #define SPINLOCK_UNLOCKED { .lock = 0 }
 #define SPINLOCK_LOCKED { .lock = 1 }
@@ -15,7 +15,7 @@ static inline void spinlock_lock(struct spinlock *lock)
 {
     u32 lock_val = 1;
     do {
-        asm volatile("xchg %0, %1" : "+r"(lock_val), "+m"(lock->lock));
+        asm volatile ("xchg %0, %1":"+r" (lock_val), "+m"(lock->lock));
     } while (lock_val);
 }
 
index de09182..7c4fb17 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 void console_init(void);
index 7c64518..ed63f12 100644 (file)
@@ -14,7 +14,7 @@ struct domain {
     u64 min;
     u64 max;
 
-    DEFINE_SPINLOCK(lock);
+     DEFINE_SPINLOCK(lock);
 
     s64 free_offset;
     s64 used_offset;
@@ -28,8 +28,10 @@ struct domain {
 void domain_init(struct domain *domain, u64 min, u64 max);
 
 struct domain_block *domain_alloc(struct domain *domain, u64 size, void *priv);
-struct domain_block *domain_alloc_near(struct domain *domain, u64 address, u64 size, void *priv);
-struct domain_block *domain_alloc_address(struct domain *domain, u64 address, u64 size, void *priv);
+struct domain_block *domain_alloc_near(struct domain *domain, u64 address,
+                                       u64 size, void *priv);
+struct domain_block *domain_alloc_address(struct domain *domain, u64 address,
+                                          u64 size, void *priv);
 
 struct domain_block *domain_search(struct domain *domain, u64 address);
 
index b796529..74c0ed9 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 /* Oh no copyright infringment. Come at me, SCO. */
index 4c6c09d..7fed31f 100644 (file)
@@ -1,12 +1,12 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 #include <types.h>
 
 struct grub_signature {
-       u32 magic;
-       u32 flags;
-       u32 checksum;
+    u32 magic;
+    u32 flags;
+    u32 checksum;
 };
 
 #define GRUB_MAGIC 0x1BADB002
@@ -62,32 +62,32 @@ struct grub_signature {
  */
 
 struct grub_info {
-       u32 flags;
-       u32 mem_lower;
-       u32 mem_upper;
-       u32 boot_device;
-       u32 cmdline;
-       u32 mods_count;
-       u32 mods_addr;
-       u32 syms[4];
-       u32 mmap_length;
-       u32 mmap_addr;
-       u32 drives_length;
-       u32 drives_addr;
-       u32 config_table;
-       u32 boot_loader_name;
-       u32 apm_table;
-       u32 vbe_control_info;
-       u32 vbe_mode_info;
-       u16 vbe_mode;
-       u16 vbe_interface_seg;
-       u16 vbe_interface_off;
-       u16 vbe_interface_len;
+    u32 flags;
+    u32 mem_lower;
+    u32 mem_upper;
+    u32 boot_device;
+    u32 cmdline;
+    u32 mods_count;
+    u32 mods_addr;
+    u32 syms[4];
+    u32 mmap_length;
+    u32 mmap_addr;
+    u32 drives_length;
+    u32 drives_addr;
+    u32 config_table;
+    u32 boot_loader_name;
+    u32 apm_table;
+    u32 vbe_control_info;
+    u32 vbe_mode_info;
+    u16 vbe_mode;
+    u16 vbe_interface_seg;
+    u16 vbe_interface_off;
+    u16 vbe_interface_len;
 } __attribute__ ((packed));
 
 struct grub_mmap {
-       u32 size;
-       u64 base;
-       u64 length;
-       u32 type;
+    u32 size;
+    u64 base;
+    u64 length;
+    u32 type;
 } __attribute__ ((packed));
index 26a507b..65982d8 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 #include <regs.h>
index 3781b5d..9388edb 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 #include <types.h>
index 47a3e0c..99c187c 100644 (file)
@@ -1,9 +1,9 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 #include <types.h>
 
-void *map_page_early(u64 virtual, u64 physical, u64 *alloc_base);
+void *map_page_early(u64 virtual, u64 physical, u64 * alloc_base);
 
 int map_pages(u64 virtual, u64 physical, u64 num_pages);
 int map_pages_nocache(u64 virtual, u64 physical, u64 num_pages);
index 072e354..8d8f73a 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 #include <paging.h>
 
 #include <types.h>
 
-static inline void __clear_page(u64 *addr)
+static inline void __clear_page(u64 * addr)
 {
-       int i;
+    int i;
 
-       addr = (u64 *) ((u64) addr & ~PAGE_MASK);
+    addr = (u64 *) ((u64) addr & ~PAGE_MASK);
 
-       for (i = 0; i < (PAGE_SIZE / sizeof(u64)); i++)
-               addr[i] = 0;
+    for (i = 0; i < (PAGE_SIZE / sizeof(u64)); i++)
+        addr[i] = 0;
 }
 
 #endif
index e1d4481..d02cfb9 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #pragma once
 
@@ -9,9 +9,9 @@
 struct objcache {
     u32 obj_size;
 
-       void *start_page;
+    void *start_page;
 
-       DEFINE_SPINLOCK(lock);  
+     DEFINE_SPINLOCK(lock);
 };
 
 #define MIN_OBJ_SIZE 8
index 83cd56a..88e59af 100644 (file)
@@ -3,7 +3,7 @@
 #include <grub.h>
 #include <types.h>
 
-int page_alloc_init (struct grub_info *info_phys, u64 end_structures);
+int page_alloc_init(struct grub_info *info_phys, u64 end_structures);
 
 /* These deal only in physical addresses */
 u64 page_alloc_phys(u32 order);
index 4b1aaea..0828515 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 #pragma once
 
 /* 4k page size */
index adb6abd..860550f 100644 (file)
@@ -1,4 +1,4 @@
 #pragma once
 
-int smp_prepare(void); 
+int smp_prepare(void);
 void smp_wake(u32 apic_id);
index 81da225..b1887ff 100644 (file)
@@ -1,15 +1,15 @@
 #ifndef TYPES_H
 #define TYPES_H
 
-typedef unsigned long  u64;
-typedef unsigned int   u32;
-typedef unsigned short u16;
-typedef unsigned char  u8;
+typedef unsigned long u64;
+typedef unsigned int u32;
+typedef unsigned short u16;
+typedef unsigned char u8;
 
-typedef signed long    s64;
-typedef signed int     s32;
-typedef signed short   s16;
-typedef signed char    s8;
+typedef signed long s64;
+typedef signed int s32;
+typedef signed short s16;
+typedef signed char s8;
 
 #define NULL   ((void *) 0x0)
 #define MAXLONG ((unsigned long) -1)
index 7c3cec0..632cada 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <types.h>
 #include <vsalloc.h>
@@ -8,27 +8,27 @@
 #include <smp.h>
 
 struct rsdp {
-       char sig[8];
-       u8 checksum;
-       char oem_id[6];
-       u8 rev;
-       u32 rsdt_pa;
-       u32 length;
-       u64 xsdt_pa;
-       u8 extd_checksum;
-} __attribute__((packed));
+    char sig[8];
+    u8 checksum;
+    char oem_id[6];
+    u8 rev;
+    u32 rsdt_pa;
+    u32 length;
+    u64 xsdt_pa;
+    u8 extd_checksum;
+} __attribute__ ((packed));
 
 struct description_header {
-       char sig[4];
-       u32 length;
-       u8 revision;
-       u8 checksum;
-       char oem_id[6];
-       char oem_table_id[8];
-       u32 oem_revision;
-       u32 creator_id;
-       u32 creator_revision;           /* 36 */
-} __attribute__((packed));
+    char sig[4];
+    u32 length;
+    u8 revision;
+    u8 checksum;
+    char oem_id[6];
+    char oem_table_id[8];
+    u32 oem_revision;
+    u32 creator_id;
+    u32 creator_revision;       /* 36 */
+} __attribute__ ((packed));
 
 #define APIC_TYPE_LAPIC                0
 #define APIC_TYPE_IOAPIC       1
@@ -48,69 +48,69 @@ struct description_header {
 #define APIC_TYPE_GICITS       15
 
 char *apic_types[] = {
-       "LAPIC", "IOAPIC", "ISO", "NMI", "LAPIC_NMI", "LAPIC_AO", "IOSAPIC",
-       "LSAPIC", "PLATIS", "X2APIC", "X2NMI",
-       "GICC", "GICD", "GICMSI", "GICR", "GICITS"
+    "LAPIC", "IOAPIC", "ISO", "NMI", "LAPIC_NMI", "LAPIC_AO", "IOSAPIC",
+    "LSAPIC", "PLATIS", "X2APIC", "X2NMI",
+    "GICC", "GICD", "GICMSI", "GICR", "GICITS"
 };
 
 struct apic_entry {
-       u32 lapic_addr;
-       u32 flags;
-} __attribute__((packed));
+    u32 lapic_addr;
+    u32 flags;
+} __attribute__ ((packed));
 
 #define APIC_FLAG_PCAT_COMPAT 1
 
 struct lapic_entry {
-       u8 type;
-       u8 len;
-       u8 apic_uid;
-       u8 apic_id;
-       u32 flags;
-} __attribute__((packed));
+    u8 type;
+    u8 len;
+    u8 apic_uid;
+    u8 apic_id;
+    u32 flags;
+} __attribute__ ((packed));
 
 #define LAPIC_FLAGS_ENABLED 1
 
 void acpi_apic_handler(struct description_header *hdr, void *entry_ptr)
 {
-       struct apic_entry *entry = entry_ptr;
-       int cpus = 0;
+    struct apic_entry *entry = entry_ptr;
+    int cpus = 0;
 
-       u8 *intcons = (u8 *) (((u64) entry) + sizeof(struct apic_entry));
-       int length = hdr->length - (sizeof(struct description_header) + sizeof(struct apic_entry));
-       int cur_byte = 0;
+    u8 *intcons = (u8 *) (((u64) entry) + sizeof(struct apic_entry));
+    int length =
+        hdr->length - (sizeof(struct description_header) +
+                       sizeof(struct apic_entry));
+    int cur_byte = 0;
 
-       while (cur_byte < length) {
-               u8 type = intcons[cur_byte];
+    while (cur_byte < length) {
+        u8 type = intcons[cur_byte];
 
-               if (type == APIC_TYPE_LAPIC) {
-                       struct lapic_entry *lapic = (void *) &intcons[cur_byte];
+        if (type == APIC_TYPE_LAPIC) {
+            struct lapic_entry *lapic = (void *)&intcons[cur_byte];
 
-                       if (lapic->flags & LAPIC_FLAGS_ENABLED) {
-                               smp_wake(lapic->apic_id);
-                               cpus++;
-                       }
-               }
+            if (lapic->flags & LAPIC_FLAGS_ENABLED) {
+                smp_wake(lapic->apic_id);
+                cpus++;
+            }
+        }
 
-               cur_byte += intcons[cur_byte + 1];
-       }
+        cur_byte += intcons[cur_byte + 1];
+    }
 
-       printk("%d CPUs detected\n", cpus);
+    printk("%d CPUs detected\n", cpus);
 }
 
 struct acpi_section_handler {
-       char match_sig[4];
-       void (*handler) (struct description_header *hdr, void *end_ptr);
+    char match_sig[4];
+    void (*handler) (struct description_header * hdr, void *end_ptr);
 };
 
-struct acpi_section_handler handlers[] =
-{
-       {
-               .match_sig = { 'A', 'P', 'I', 'C' },
-               .handler = acpi_apic_handler,
-       },
-       {
-               .handler = NULL
-       }
+struct acpi_section_handler handlers[] = {
+    {
+     .match_sig = {'A', 'P', 'I', 'C'},
+     .handler = acpi_apic_handler,
+     },
+    {
+     .handler = NULL}
 };
 
 /* Long version of "RSD PTR " */
@@ -122,90 +122,95 @@ struct acpi_section_handler handlers[] =
 #define BIOS_ROM_PAGES PAGE_ALIGN_UP(BIOS_ROM_LENGTH)
 #define BIOS_ROM_16BYTES (BIOS_ROM_LENGTH / 16)
 
-struct rsdp *__acpi_find_rsdp(u64 *bios_mem)
+struct rsdp *__acpi_find_rsdp(u64 * bios_mem)
 {
-       int i;
+    int i;
 
-       /* Search the entire page on 16 byte boundaries */
-       for (i = 0; i < (BIOS_ROM_LENGTH / 16); i++) {
+    /* Search the entire page on 16 byte boundaries */
+    for (i = 0; i < (BIOS_ROM_LENGTH / 16); i++) {
 
-               /* x2 because we're indexing into an 8 byte type at 16 byte offsets */
-               if (bios_mem[i * 2] == RSD_PTR_)
-                       return (struct rsdp *) &bios_mem[i * 2];
-       }
+        /* x2 because we're indexing into an 8 byte type at 16 byte offsets */
+        if (bios_mem[i * 2] == RSD_PTR_)
+            return (struct rsdp *)&bios_mem[i * 2];
+    }
 
-       return NULL;
+    return NULL;
 }
 
 void __acpi_handle_table(u32 pa)
 {
-       void *allocation = vsalloc("ACPI", 0, 1);
-       struct description_header *hdr;
-       struct acpi_section_handler *cur = handlers;
-
-       map_pages((u64) allocation, pa, 1);
-       hdr = (struct description_header *)  ((u64) allocation + PAGE_ALIGN_OFF(pa));
-
-       while(cur->handler) {
-               if ((hdr->sig[0] == cur->match_sig[0]) &&
-                       (hdr->sig[1] == cur->match_sig[1]) &&
-                       (hdr->sig[2] == cur->match_sig[2]) &&
-                       (hdr->sig[3] == cur->match_sig[3])) {
-
-                       cur->handler(hdr, (void *) ((u64) hdr + sizeof(struct description_header)));
-
-                       break;
-               }
-               cur++;
-       }
-
-       unmap_pages((u64) allocation, 1);
-       vfree(allocation);
+    void *allocation = vsalloc("ACPI", 0, 1);
+    struct description_header *hdr;
+    struct acpi_section_handler *cur = handlers;
+
+    map_pages((u64) allocation, pa, 1);
+    hdr = (struct description_header *)((u64) allocation + PAGE_ALIGN_OFF(pa));
+
+    while (cur->handler) {
+        if ((hdr->sig[0] == cur->match_sig[0]) &&
+            (hdr->sig[1] == cur->match_sig[1]) &&
+            (hdr->sig[2] == cur->match_sig[2]) &&
+            (hdr->sig[3] == cur->match_sig[3])) {
+
+            cur->handler(hdr,
+                         (void *)((u64) hdr +
+                                  sizeof(struct description_header)));
+
+            break;
+        }
+        cur++;
+    }
+
+    unmap_pages((u64) allocation, 1);
+    vfree(allocation);
 }
 
 int acpi_init(void)
 {
-       struct description_header *hdr;
-       struct rsdp *rsdp;
-       u32 *entries;
+    struct description_header *hdr;
+    struct rsdp *rsdp;
+    u32 *entries;
 
-       int ret = 0;
-       int i;
+    int ret = 0;
+    int i;
 
-       u64 *mem = vsalloc("ACPI", 0, BIOS_ROM_PAGES);
+    u64 *mem = vsalloc("ACPI", 0, BIOS_ROM_PAGES);
 
-       if(map_pages((u64) mem, BIOS_ROM_START, BIOS_ROM_PAGES)) {
-               printk("Failed to map.\n");
-               ret = -1;
-               goto cleanup_virt;
-       }
+    if (map_pages((u64) mem, BIOS_ROM_START, BIOS_ROM_PAGES)) {
+        printk("Failed to map.\n");
+        ret = -1;
+        goto cleanup_virt;
+    }
 
-       rsdp = __acpi_find_rsdp(mem);
+    rsdp = __acpi_find_rsdp(mem);
 
-       if (rsdp)
-               printk("ACPI detected\n");
-       else {
-               ret = -1;
-               goto cleanup;
-       }
+    if (rsdp)
+        printk("ACPI detected\n");
+    else {
+        ret = -1;
+        goto cleanup;
+    }
 
-       hdr = vsalloc("ACPI", 0, PAGE_SIZE);
+    hdr = vsalloc("ACPI", 0, PAGE_SIZE);
 
-       map_pages((u64) hdr, rsdp->rsdt_pa, 1);
-       hdr = (struct description_header *)  ((u64) hdr + PAGE_ALIGN_OFF(rsdp->rsdt_pa));
+    map_pages((u64) hdr, rsdp->rsdt_pa, 1);
+    hdr =
+        (struct description_header *)((u64) hdr +
+                                      PAGE_ALIGN_OFF(rsdp->rsdt_pa));
 
-       entries = (u32 *) ((u64) hdr + sizeof(struct description_header));
-       for (i = 0; i < ((hdr->length - sizeof(struct description_header)) / 4); i++)
-               __acpi_handle_table(entries[i]);
+    entries = (u32 *) ((u64) hdr + sizeof(struct description_header));
+    for (i = 0; i < ((hdr->length - sizeof(struct description_header)) / 4);
+         i++)
+        __acpi_handle_table(entries[i]);
 
-       unmap_pages((u64) hdr, 1);
-       vfree(hdr);
+    unmap_pages((u64) hdr, 1);
+    vfree(hdr);
 
-cleanup:
-       unmap_pages((u64) mem, BIOS_ROM_PAGES);
+ cleanup:
+    unmap_pages((u64) mem, BIOS_ROM_PAGES);
 
-cleanup_virt:
-       vfree(mem);
+ cleanup_virt:
+    vfree(mem);
 
-       return ret;
+    return ret;
 }
index 13593b4..d489c4b 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 /* Support for the built-in xAPIC, or x2APIC. We don't bother with the old 386
  * PIC except to disable it because xAPIC is a foundation technology of the
@@ -83,188 +83,189 @@ static volatile u64 *mmio_mem = NULL;
 
 static void apic_init_common(void)
 {
-       apic->write(APIC_SVR, SVR_APIC_EN);
-       apic->write(APIC_LVT3, LVT_VECTOR(34));
+    apic->write(APIC_SVR, SVR_APIC_EN);
+    apic->write(APIC_LVT3, LVT_VECTOR(34));
 }
 
 static void apic_start_timer(void)
 {
-       u32 lvt;
+    u32 lvt;
 
-       /* Divide by 1 */
-       apic->write(APIC_TIMER_DIV, 0x11);
+    /* Divide by 1 */
+    apic->write(APIC_TIMER_DIV, 0x11);
 
-       /* Setup a periodic timer interrupt */
-       lvt = apic->read(APIC_LVT_TIMER);
+    /* Setup a periodic timer interrupt */
+    lvt = apic->read(APIC_LVT_TIMER);
 
-       lvt &= ~LVT_MASKED;
-       lvt |= LVT_VECTOR(32) | LVT_TIMER_PERIODIC;
+    lvt &= ~LVT_MASKED;
+    lvt |= LVT_VECTOR(32) | LVT_TIMER_PERIODIC;
 
-       apic->write(APIC_LVT_TIMER, lvt);
+    apic->write(APIC_LVT_TIMER, lvt);
 
-       /* Set the initial count, which will start the timer */
-       apic->write(APIC_TIMER_INIT_CT, 0x1000);
+    /* Set the initial count, which will start the timer */
+    apic->write(APIC_TIMER_INIT_CT, 0x1000);
 }
 
 static void apic_eoi(void)
 {
-       /* Allow another interrupt to come through when we re-enable
-        * them (exiting through exception)
-        */
-       apic->write(APIC_EOI, 0);
+    /* Allow another interrupt to come through when we re-enable
+     * them (exiting through exception)
+     */
+    apic->write(APIC_EOI, 0);
 }
 
 static void apic_wake_secondary(u8 apic_id)
 {
-       u32 lo;
+    u32 lo;
 
-       lo = ICRL_MT(MT_INIT) | ICRL_ASSERT | ICRL_TRIGGER_LEVEL;
+    lo = ICRL_MT(MT_INIT) | ICRL_ASSERT | ICRL_TRIGGER_LEVEL;
 
-       apic->write_icr(apic_id, lo);
+    apic->write_icr(apic_id, lo);
 
-       apic->wait();
+    apic->wait();
 
-       lo = ICRL_MT(MT_INIT) | ICRL_TRIGGER_LEVEL;
+    lo = ICRL_MT(MT_INIT) | ICRL_TRIGGER_LEVEL;
 
-       apic->write_icr(apic_id, lo);
+    apic->write_icr(apic_id, lo);
 
-       apic->wait();
+    apic->wait();
 
-       lo = ICRL_MT(MT_STARTUP) | ICRL_ASSERT | 2;
+    lo = ICRL_MT(MT_STARTUP) | ICRL_ASSERT | 2;
 
-       apic->write_icr(apic_id, lo);
+    apic->write_icr(apic_id, lo);
 
-       apic->wait();
+    apic->wait();
 
-       lo = ICRL_MT(MT_STARTUP) | ICRL_ASSERT | 2;
+    lo = ICRL_MT(MT_STARTUP) | ICRL_ASSERT | 2;
 
-       apic->write_icr(apic_id, lo);
+    apic->write_icr(apic_id, lo);
 
-       apic->wait();
+    apic->wait();
 }
 
 static void xapic_init(void)
 {
-       u64 msr;
+    u64 msr;
 
-       /* Make sure the APIC is actually enabled */
-       msr = rdmsr(MSR_IA32_APIC_BASE);
-       wrmsr(MSR_IA32_APIC_BASE, msr | XAPIC_ENABLE);
+    /* Make sure the APIC is actually enabled */
+    msr = rdmsr(MSR_IA32_APIC_BASE);
+    wrmsr(MSR_IA32_APIC_BASE, msr | XAPIC_ENABLE);
 
-       /* Get a nocache virtual memory of the base memory */
-       mmio_mem = vsalloc("APIC", VSALLOC_HEAP_VIRTUAL, PAGE_SIZE);
+    /* Get a nocache virtual memory of the base memory */
+    mmio_mem = vsalloc("APIC", VSALLOC_HEAP_VIRTUAL, PAGE_SIZE);
 
-       map_page_nocache((u64) mmio_mem, msr & ~(0xFFFUL));
+    map_page_nocache((u64) mmio_mem, msr & ~(0xFFFUL));
 
-       apic_init_common();
+    apic_init_common();
 }
 
 static void xapic_mmio_write(u32 offset, u32 val)
 {
-       mmio_write(mmio_mem, MMIO_OFFSET(offset), val);
+    mmio_write(mmio_mem, MMIO_OFFSET(offset), val);
 }
 
 static u32 xapic_mmio_read(u32 offset)
 {
-       return mmio_read(mmio_mem, MMIO_OFFSET(offset));
+    return mmio_read(mmio_mem, MMIO_OFFSET(offset));
 }
 
 static void xapic_ipi_wait(void)
 {
-       while(apic->read(APIC_ICRL) & ICRL_BUSY) {}
+    while (apic->read(APIC_ICRL) & ICRL_BUSY) {
+    }
 }
 
 static void xapic_write_icr(u32 dest, u32 val)
 {
-       apic->write(APIC_ICRH, ICRH_DEST(dest));
-       apic->write(APIC_ICRL, val);
+    apic->write(APIC_ICRH, ICRH_DEST(dest));
+    apic->write(APIC_ICRL, val);
 }
 
 static u8 xapic_get_id(void)
 {
-       return ID(apic->read(APIC_ID));
+    return ID(apic->read(APIC_ID));
 }
 
 struct apic xapic = {
-       .init = xapic_init,
-       .eoi = apic_eoi,
-       .wake_secondary = apic_wake_secondary,
-       .start_timer = apic_start_timer,
-       .get_id = xapic_get_id,
-       .write = xapic_mmio_write,
-       .write_icr = xapic_write_icr,
-       .read = xapic_mmio_read,
-       .wait = xapic_ipi_wait,
+    .init = xapic_init,
+    .eoi = apic_eoi,
+    .wake_secondary = apic_wake_secondary,
+    .start_timer = apic_start_timer,
+    .get_id = xapic_get_id,
+    .write = xapic_mmio_write,
+    .write_icr = xapic_write_icr,
+    .read = xapic_mmio_read,
+    .wait = xapic_ipi_wait,
 };
 
 static void x2apic_init(void)
 {
-       u64 msr;
+    u64 msr;
 
-       /* Make sure the APIC is actually enabled */
-       msr = rdmsr(MSR_IA32_APIC_BASE);
+    /* Make sure the APIC is actually enabled */
+    msr = rdmsr(MSR_IA32_APIC_BASE);
 
-       /* Need EXTD flag to use MSR interface */
-       wrmsr(MSR_IA32_APIC_BASE, msr | XAPIC_ENABLE | XAPIC_EXTD);
+    /* Need EXTD flag to use MSR interface */
+    wrmsr(MSR_IA32_APIC_BASE, msr | XAPIC_ENABLE | XAPIC_EXTD);
 
-       apic_init_common();
+    apic_init_common();
 }
 
 static void x2apic_msr_write(u32 offset, u32 val)
 {
-       wrmsr(MSR_OFFSET(offset), val);
+    wrmsr(MSR_OFFSET(offset), val);
 }
 
 static u32 x2apic_msr_read(u32 offset)
 {
-       return rdmsr(MSR_OFFSET(offset));
+    return rdmsr(MSR_OFFSET(offset));
 }
 
 static void x2apic_ipi_wait(void)
 {
-       return;
+    return;
 }
 
 static void x2apic_write_icr(u32 dest, u32 val)
 {
-       wrmsr(MSR_OFFSET(APIC_ICRL), ((u64) dest << 32) | val);
+    wrmsr(MSR_OFFSET(APIC_ICRL), ((u64) dest << 32) | val);
 }
 
 static u8 x2apic_get_id(void)
 {
-       return apic->read(APIC_ID);
+    return apic->read(APIC_ID);
 }
 
 struct apic x2apic = {
-       .init = x2apic_init,
-       .eoi = apic_eoi,
-       .wake_secondary = apic_wake_secondary,
-       .start_timer = apic_start_timer,
-       .get_id = x2apic_get_id,
-       .read = x2apic_msr_read,
-       .write = x2apic_msr_write,
-       .write_icr = x2apic_write_icr,
-       .wait = x2apic_ipi_wait,
+    .init = x2apic_init,
+    .eoi = apic_eoi,
+    .wake_secondary = apic_wake_secondary,
+    .start_timer = apic_start_timer,
+    .get_id = x2apic_get_id,
+    .read = x2apic_msr_read,
+    .write = x2apic_msr_write,
+    .write_icr = x2apic_write_icr,
+    .wait = x2apic_ipi_wait,
 };
 
 int apic_init(void)
 {
-       u32 regs[4];
-
-       cpuid(0x1, regs);
-
-       if(regs[2] & CPUID_X2APIC) {
-               printk("x2apic detected\n");
-               apic = &x2apic;
-       } else if (regs[3] & CPUID_LAPIC) {
-               printk("xapic detected\n");
-               apic = &xapic;
-       } else {
-               printk("no APIC detected\n");
-               return -1;
-       }
-
-       apic->init();
+    u32 regs[4];
+
+    cpuid(0x1, regs);
+
+    if (regs[2] & CPUID_X2APIC) {
+        printk("x2apic detected\n");
+        apic = &x2apic;
+    } else if (regs[3] & CPUID_LAPIC) {
+        printk("xapic detected\n");
+        apic = &xapic;
+    } else {
+        printk("no APIC detected\n");
+        return -1;
+    }
+
+    apic->init();
 
     return 0;
 }
index 6ca5568..b055ddf 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 
@@ -18,44 +18,44 @@ DEFINE_SPINLOCK(console_lock) = SPINLOCK_UNLOCKED;
 
 void console_init(void)
 {
-       console_mem = page_alloc(CONSOLE_ORDER);
+    console_mem = page_alloc(CONSOLE_ORDER);
 }
 
 static void console_putchar(char c)
 {
-       console_mem[console_end] = c;
-       console_end++;
+    console_mem[console_end] = c;
+    console_end++;
 
-       if(console_end >= CONSOLE_SIZE) {
-               console_wrapped = 1;
-               console_end = 0;
-       }
+    if (console_end >= CONSOLE_SIZE) {
+        console_wrapped = 1;
+        console_end = 0;
+    }
 
-       vga_putchar(c);
+    vga_putchar(c);
 }
 
 void console_puts(char *string)
 {
-       int i;
+    int i;
 
-       spinlock_lock(&console_lock);
+    spinlock_lock(&console_lock);
 
-       for (i = 0; string[i]; i++)
-               console_putchar(string[i]);
+    for (i = 0; string[i]; i++)
+        console_putchar(string[i]);
 
-       spinlock_unlock(&console_lock);
+    spinlock_unlock(&console_lock);
 }
 
 void printk(char *format, ...)
 {
-       char buf[255];
-       va_list ap;
+    char buf[255];
+    va_list ap;
 
-       va_start(ap, format);
+    va_start(ap, format);
 
-       vsnprintf(buf, 255, format, ap);
+    vsnprintf(buf, 255, format, ap);
 
-       va_end(ap);
+    va_end(ap);
 
-       console_puts(buf);
+    console_puts(buf);
 }
index ef82de1..8c7e42c 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 
@@ -6,35 +6,35 @@
 
 int cpuid_init(void)
 {
-       char vendor[13];
-       u32 regs[4];
+    char vendor[13];
+    u32 regs[4];
 
     cpuid(0x0, regs);
 
-       /* regs[0] - eax
-        * regs[1] - ebx
-        * regs[2] - ecx
-        * regs[3] - edx
-        */
+    /* regs[0] - eax
+     * regs[1] - ebx
+     * regs[2] - ecx
+     * regs[3] - edx
+     */
 
-       vendor[0] = ((char *) &regs[1])[0];
-       vendor[1] = ((char *) &regs[1])[1];
-       vendor[2] = ((char *) &regs[1])[2];
-       vendor[3] = ((char *) &regs[1])[3];
+    vendor[0] = ((char *)&regs[1])[0];
+    vendor[1] = ((char *)&regs[1])[1];
+    vendor[2] = ((char *)&regs[1])[2];
+    vendor[3] = ((char *)&regs[1])[3];
 
-       vendor[4] = ((char *) &regs[3])[0];
-       vendor[5] = ((char *) &regs[3])[1];
-       vendor[6] = ((char *) &regs[3])[2];
-       vendor[7] = ((char *) &regs[3])[3];
+    vendor[4] = ((char *)&regs[3])[0];
+    vendor[5] = ((char *)&regs[3])[1];
+    vendor[6] = ((char *)&regs[3])[2];
+    vendor[7] = ((char *)&regs[3])[3];
 
-       vendor[8] = ((char *) &regs[2])[0];
-       vendor[9] = ((char *) &regs[2])[1];
-       vendor[10] = ((char *) &regs[2])[2];
-       vendor[11] = ((char *) &regs[2])[3];
+    vendor[8] = ((char *)&regs[2])[0];
+    vendor[9] = ((char *)&regs[2])[1];
+    vendor[10] = ((char *)&regs[2])[2];
+    vendor[11] = ((char *)&regs[2])[3];
 
-       vendor[12] = 0;
+    vendor[12] = 0;
 
-       printk("%s\n", vendor);
+    printk("%s\n", vendor);
 
     return 0;
 }
index a5f6bc3..ac2326d 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 #include <apic.h>
@@ -8,52 +8,52 @@
 #define NAMED_EXCEPTIONS 20
 
 char *exception_names[NAMED_EXCEPTIONS] = {
-       "Divide by Zero",
-       "Debug",
-       "NMI",
-       "Breakpoint",
-       "Overflow",
-       "Bound",
-       "Illegal Instruction",
-       "FPU Unavailable",
-       "Double Fault",
-       "RESERVED",
-       "Invalid TSS",
-       "Segment Not Present",
-       "General Protection",
-       "Stack",
-       "Page Fault",
-       "RESERVED",
-       "FPU Error",
-       "Alignment Check",
-       "Machine Check",
-       "SIMD Error"
+    "Divide by Zero",
+    "Debug",
+    "NMI",
+    "Breakpoint",
+    "Overflow",
+    "Bound",
+    "Illegal Instruction",
+    "FPU Unavailable",
+    "Double Fault",
+    "RESERVED",
+    "Invalid TSS",
+    "Segment Not Present",
+    "General Protection",
+    "Stack",
+    "Page Fault",
+    "RESERVED",
+    "FPU Error",
+    "Alignment Check",
+    "Machine Check",
+    "SIMD Error"
 };
 
 void dump_exception(struct regs *regs)
 {
-       if (regs->vector < 32) {
-               if (regs->vector < NAMED_EXCEPTIONS)
-                       printk("-- %s --\n", exception_names[regs->vector]);
-               else
-                       printk("-- IRQ %d --\n", regs->vector);
+    if (regs->vector < 32) {
+        if (regs->vector < NAMED_EXCEPTIONS)
+            printk("-- %s --\n", exception_names[regs->vector]);
+        else
+            printk("-- IRQ %d --\n", regs->vector);
 
-               printk("RIP 0x%016lx ERR 0x%lx\n", regs->rip, regs->error_code);
-               printk("RSP 0x%016lx RBP 0x%016lx\n", regs->rsp, regs->rbp);
-               printk("RAX 0x%016lx RBX 0x%016lx\n", regs->rax, regs->rbx);
-               printk("RCX 0x%016lx RDX 0x%016lx\n", regs->rcx, regs->rdx);
-               printk("RDI 0x%016lx RSI 0x%016lx\n", regs->rdi, regs->rsi);
-               printk("R8  0x%016lx R9  0x%016lx\n", regs->r8, regs->r9);
-               printk("R10 0x%016lx R11 0x%016lx\n", regs->r10, regs->r11);
-               printk("R12 0x%016lx R13 0x%016lx\n", regs->r12, regs->r13);
-               printk("R14 0x%016lx R15 0x%016lx\n", regs->r14, regs->r15);
-               printk("CR2 0x%016lx\n", get_cr2());
-               printk("RFLAGS 0x%016lx\n", regs->rflags);
+        printk("RIP 0x%016lx ERR 0x%lx\n", regs->rip, regs->error_code);
+        printk("RSP 0x%016lx RBP 0x%016lx\n", regs->rsp, regs->rbp);
+        printk("RAX 0x%016lx RBX 0x%016lx\n", regs->rax, regs->rbx);
+        printk("RCX 0x%016lx RDX 0x%016lx\n", regs->rcx, regs->rdx);
+        printk("RDI 0x%016lx RSI 0x%016lx\n", regs->rdi, regs->rsi);
+        printk("R8  0x%016lx R9  0x%016lx\n", regs->r8, regs->r9);
+        printk("R10 0x%016lx R11 0x%016lx\n", regs->r10, regs->r11);
+        printk("R12 0x%016lx R13 0x%016lx\n", regs->r12, regs->r13);
+        printk("R14 0x%016lx R15 0x%016lx\n", regs->r14, regs->r15);
+        printk("CR2 0x%016lx\n", get_cr2());
+        printk("RFLAGS 0x%016lx\n", regs->rflags);
 
-               while(1);
-       } else {
-               if (regs->vector > 32)
-                       printk("IRQ %d\n", regs->vector);
-               apic->eoi();
-       }
+        while (1) ;
+    } else {
+        if (regs->vector > 32)
+            printk("IRQ %d\n", regs->vector);
+        apic->eoi();
+    }
 }
index 58c4ae9..45222ea 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 
 
 #include <objcache.h>
 
-void main (void *info_phys, unsigned long end_structures)
+void main(void *info_phys, unsigned long end_structures)
 {
-       page_alloc_init(info_phys, end_structures);
+    page_alloc_init(info_phys, end_structures);
 
-       vga_init();
+    vga_init();
 
-       console_init();
+    console_init();
 
-       printk("Viridis %d.%d-g%s\n", __MAJOR_VERSION__,__MINOR_VERSION__, __GIT_VERSION__);
+    printk("Viridis %d.%d-g%s\n", __MAJOR_VERSION__, __MINOR_VERSION__,
+           __GIT_VERSION__);
 
-       cpuid_init();
+    cpuid_init();
 
-       disable_pic();
+    disable_pic();
 
-       apic_init();
+    apic_init();
 
-       /* Prepare the realmode landing zone */
-       smp_prepare();
+    /* Prepare the realmode landing zone */
+    smp_prepare();
 
-       /* ACPI init probes ACPI tables and generates smp_wake calls */
-       acpi_init();
+    /* ACPI init probes ACPI tables and generates smp_wake calls */
+    acpi_init();
 
-       test_objcache();
+    test_objcache();
 
      asm ("sti" : : );
asm("sti": :);
 
      asm ("hlt" : : );
asm("hlt": :);
 }
index 6e21304..2462847 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 #include <map.h>
@@ -14,36 +14,36 @@ static struct rm_header *realboot = NULL;
 
 void secondary_start(void)
 {
-       printk("Here\n");
-       while(1);
+    printk("Here\n");
+    while (1) ;
 }
 
 void smp_wake(u32 apic_id)
 {
-       int my_lapic = apic->get_id();
+    int my_lapic = apic->get_id();
 
-       if (apic_id != my_lapic) {
+    if (apic_id != my_lapic) {
 
-               /* kernel stacks are part of the big kernel virtual space, so no need
-                * to inform vsalloc */
+        /* kernel stacks are part of the big kernel virtual space, so no need
+         * to inform vsalloc */
 
-               page_alloc_to_virtual(STACK_ADDR_CPU(apic_id), STACK_PAGES_ORDER);
+        page_alloc_to_virtual(STACK_ADDR_CPU(apic_id), STACK_PAGES_ORDER);
 
-               realboot->sp = STACK_TOP_CPU(apic_id);
-               apic->wake_secondary(apic_id);
-       }
+        realboot->sp = STACK_TOP_CPU(apic_id);
+        apic->wake_secondary(apic_id);
+    }
 }
 
-int smp_prepare(void) 
+int smp_prepare(void)
 {
-       map_page(REALMODE_PA, REALMODE_PA);
-    realboot = (void *) REALMODE_PA;
+    map_page(REALMODE_PA, REALMODE_PA);
+    realboot = (void *)REALMODE_PA;
 
-       memcpy(realboot, &realmode_bin, REALMODE_BIN_LEN);
+    memcpy(realboot, &realmode_bin, REALMODE_BIN_LEN);
 
-       realboot->gdtr = (VIRT_BASE + (u64) &GDTR_64);
-       realboot->cr3 = get_cr3();
-       realboot->kernel_entry = (u64) secondary_start;
+    realboot->gdtr = (VIRT_BASE + (u64) & GDTR_64);
+    realboot->cr3 = get_cr3();
+    realboot->kernel_entry = (u64) secondary_start;
 
     return 0;
 }
index 9abd95e..3629a89 100644 (file)
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <types.h>
 #include <stdarg.h>
 
 void memcpy(void *dest, void *src, u32 size)
 {
-       int i;
-       for (i = 0; i < size; i++)
-               ((char *)dest)[i] = ((char *)src)[i];
+    int i;
+    for (i = 0; i < size; i++)
+        ((char *)dest)[i] = ((char *)src)[i];
 }
 
 char *strncpy(char *dest, char *src, u32 size)
 {
-       int i;
-       for(i = 0; i < size && src[i]; i++)
-               dest[i] = src[i];
-       if (i < size)
-               src[i] = 0;
-       return dest;
+    int i;
+    for (i = 0; i < size && src[i]; i++)
+        dest[i] = src[i];
+    if (i < size)
+        src[i] = 0;
+    return dest;
 }
 
 int strlen(char *src)
 {
-       int i = 0;
-       while (src[i])
-               i++;
-       return i;
+    int i = 0;
+    while (src[i])
+        i++;
+    return i;
 }
 
 /* Convert a single value into ASCII */
 
-static int convert(char *buf, char fill, u32 rem, s32 fieldwidth, unsigned long long val, u32 base)
+static int convert(char *buf, char fill, u32 rem, s32 fieldwidth,
+                   unsigned long long val, u32 base)
 {
-       char conv[] = "0123456789abcdef";
-       /* Largest possible ull in decimal is 39 digits */
-       char tmp[39];
-       int digits = 0;
-       int i = 0;
+    char conv[] = "0123456789abcdef";
+    /* Largest possible ull in decimal is 39 digits */
+    char tmp[39];
+    int digits = 0;
+    int i = 0;
 
-       if (fieldwidth > -1 && fieldwidth < rem)
-               rem = fieldwidth;
+    if (fieldwidth > -1 && fieldwidth < rem)
+        rem = fieldwidth;
 
-       /* Write the digits into tmp, backwards because it's easiest to calculate
-        * the smallest digits first */
+    /* Write the digits into tmp, backwards because it's easiest to calculate
+     * the smallest digits first */
 
-       do {
-               tmp[digits] = conv[val % base];
-               val /= base;
-               digits++;
-       } while (val > 0);
+    do {
+        tmp[digits] = conv[val % base];
+        val /= base;
+        digits++;
+    } while (val > 0);
 
-       /* Pad out tmp to fieldwidth */
+    /* Pad out tmp to fieldwidth */
 
-       i = 0;
-       if (fieldwidth != -1) {
-               for(i = 0; i < (rem - digits); i++)
-                       buf[i] = fill;
-       }
+    i = 0;
+    if (fieldwidth != -1) {
+        for (i = 0; i < (rem - digits); i++)
+            buf[i] = fill;
+    }
 
-       /* Then reverse the digits into buf */
+    /* Then reverse the digits into buf */
 
-       while (digits && rem) {
-               buf[i++] = tmp[digits - 1];
-               digits--;
-               rem--;
-       }
+    while (digits && rem) {
+        buf[i++] = tmp[digits - 1];
+        digits--;
+        rem--;
+    }
 
-       return i;
+    return i;
 }
 
 void vsnprintf(char *buf, u32 size, char *format, va_list ap)
 {
-       char *str = buf;
-       char qualifier[2];
-       char padding[16];
-       char fill;
-       char *s;
-       char c;
-
-       unsigned long long val;
-       s32 fieldwidth = -1;
-       s32 p_len = 0;
-       u32 escaped = 0;
-       u32 tmp;
-       u32 i;
-
-       /* size - 1, so we have room for the null byte regardless */
-
-       for(i = 0; i < (size - 1) && format[i]; i++) {
-               if (format[i] == '%') {
-                       if (escaped) {
-                               *str++ = '%';
-                               escaped = 0;
-                       }
-                       else
-                               escaped = 1;
-                       continue;
-               }
-
-               if (escaped) {
-                       switch(format[i]) {
-                               case 'c': c = (char) va_arg(ap, int);
-                                                 *str++ = c;
-                                                 fieldwidth = -1;
-                                                 escaped = 0;
-                                                 break;
-                               case 's': s = va_arg(ap, char *);
-                                                 if(fieldwidth == -1)
-                                                         fieldwidth = (size - i);
-                                                 while ((fieldwidth--) && (*s)) {
-                                                         *str++ = *s++;
-                                                         size--;
-                                                 }
-
-                                                 fieldwidth = -1;
-                                                 escaped = 0;
-                                                 size++;
-                                                 break;
-                               case 'l': if (qualifier[0] == 'l')
-                                                         qualifier[1] = 'l';
-                                                 else {
-                                                         qualifier[0] = 'l';
-                                                         qualifier[1] = 0;
-                                                 }
-
-                                                 size++;
-                                                 break;
-                               case '0':
-                               case '1':
-                               case '2':
-                               case '3':
-                               case '4':
-                               case '5':
-                               case '6':
-                               case '7':
-                               case '8':
-                               case '9':
-                                                 if (p_len < 16)
-                                                         padding[p_len++] = format[i] - '0';
-                                                 size++;
-                                                 break;
-                               case 'd':
-                               case 'x': if (qualifier[0] == 'l') {
-                                                         if(qualifier[1] == 'l')
-                                                                 val = va_arg(ap, unsigned long long);
-                                                         else
-                                                                 val = va_arg(ap, unsigned long);
-                                                 } else
-                                                         val = va_arg(ap, unsigned int);
-
-                                                 if (p_len) {
-                                                         if (padding[0] == 0)
-                                                                 fill = '0';
-                                                         else
-                                                                 fill = ' ';
-
-                                                         tmp = p_len;
-
-                                                         fieldwidth = 0;
-                                                         while(p_len) {
-                                                                 fieldwidth *= 10;
-                                                                 fieldwidth += padding[tmp - p_len];
-                                                                 p_len--;
-                                                         }
-                                                 }
-
-                                                 if (format[i] == 'x')
-                                                         tmp = convert(str, fill, (size - i), fieldwidth, val, 16);
-                                                 else
-                                                         tmp = convert(str, fill, (size - i), fieldwidth, val, 10);
-                                                 str += tmp;
-
-                                                 /* tmp were printed, but the format string shouldn't
-                                                  * count against size */
-
-                                                 size -= (tmp - 1);
-
-                                                 escaped = 0;
-                                                 qualifier[0] = 0;
-                                                 p_len = 0;
-                                                 fieldwidth = -1;
-                                                 break;
-                       }
-               }
-               else
-                       *str++ = format[i];
-       }
-       *str = 0;
+    char *str = buf;
+    char qualifier[2];
+    char padding[16];
+    char fill;
+    char *s;
+    char c;
+
+    unsigned long long val;
+    s32 fieldwidth = -1;
+    s32 p_len = 0;
+    u32 escaped = 0;
+    u32 tmp;
+    u32 i;
+
+    /* size - 1, so we have room for the null byte regardless */
+
+    for (i = 0; i < (size - 1) && format[i]; i++) {
+        if (format[i] == '%') {
+            if (escaped) {
+                *str++ = '%';
+                escaped = 0;
+            } else
+                escaped = 1;
+            continue;
+        }
+
+        if (escaped) {
+            switch (format[i]) {
+            case 'c':
+                c = (char)va_arg(ap, int);
+                *str++ = c;
+                fieldwidth = -1;
+                escaped = 0;
+                break;
+            case 's':
+                s = va_arg(ap, char *);
+                if (fieldwidth == -1)
+                    fieldwidth = (size - i);
+                while ((fieldwidth--) && (*s)) {
+                    *str++ = *s++;
+                    size--;
+                }
+
+                fieldwidth = -1;
+                escaped = 0;
+                size++;
+                break;
+            case 'l':
+                if (qualifier[0] == 'l')
+                    qualifier[1] = 'l';
+                else {
+                    qualifier[0] = 'l';
+                    qualifier[1] = 0;
+                }
+
+                size++;
+                break;
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                if (p_len < 16)
+                    padding[p_len++] = format[i] - '0';
+                size++;
+                break;
+            case 'd':
+            case 'x':
+                if (qualifier[0] == 'l') {
+                    if (qualifier[1] == 'l')
+                        val = va_arg(ap, unsigned long long);
+                    else
+                        val = va_arg(ap, unsigned long);
+                } else
+                    val = va_arg(ap, unsigned int);
+
+                if (p_len) {
+                    if (padding[0] == 0)
+                        fill = '0';
+                    else
+                        fill = ' ';
+
+                    tmp = p_len;
+
+                    fieldwidth = 0;
+                    while (p_len) {
+                        fieldwidth *= 10;
+                        fieldwidth += padding[tmp - p_len];
+                        p_len--;
+                    }
+                }
+
+                if (format[i] == 'x')
+                    tmp = convert(str, fill, (size - i), fieldwidth, val, 16);
+                else
+                    tmp = convert(str, fill, (size - i), fieldwidth, val, 10);
+                str += tmp;
+
+                /* tmp were printed, but the format string shouldn't
+                 * count against size */
+
+                size -= (tmp - 1);
+
+                escaped = 0;
+                qualifier[0] = 0;
+                p_len = 0;
+                fieldwidth = -1;
+                break;
+            }
+        } else
+            *str++ = format[i];
+    }
+    *str = 0;
 }
index 9386145..8b37e47 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <vsalloc.h>
 #include <memmap.h>
@@ -14,46 +14,45 @@ u8 vga_max_y = 25;
 
 static inline void __vga_clear_coord(u8 y, u8 x)
 {
-       vga_mem[((y * vga_max_x) + x) * 2] = ' ';
-       vga_mem[(((y * vga_max_x) + x) * 2) + 1] = 0xf;
+    vga_mem[((y * vga_max_x) + x) * 2] = ' ';
+    vga_mem[(((y * vga_max_x) + x) * 2) + 1] = 0xf;
 }
 
 static inline void __vga_clear_line(u8 y)
 {
-       int i;
-       for (i = 0; i < vga_max_x; i++)
-               __vga_clear_coord(y, i);
+    int i;
+    for (i = 0; i < vga_max_x; i++)
+        __vga_clear_coord(y, i);
 }
 
 void vga_putchar(char c)
 {
-       if ((c == '\n') || (vga_x >= vga_max_x))
-       {
-               vga_x = 0;
-               vga_y++;
-               return;
-       }
-
-       if (vga_y >= vga_max_y) {
-               vga_y--;
-               memcpy(vga_mem, &vga_mem[vga_max_x * 2],  (vga_max_x * vga_y * 2));
-               __vga_clear_line(vga_y);
-       }
-
-       vga_mem[((vga_max_x * vga_y) + vga_x) * 2] = c;
-       vga_x++;
+    if ((c == '\n') || (vga_x >= vga_max_x)) {
+        vga_x = 0;
+        vga_y++;
+        return;
+    }
+
+    if (vga_y >= vga_max_y) {
+        vga_y--;
+        memcpy(vga_mem, &vga_mem[vga_max_x * 2], (vga_max_x * vga_y * 2));
+        __vga_clear_line(vga_y);
+    }
+
+    vga_mem[((vga_max_x * vga_y) + vga_x) * 2] = c;
+    vga_x++;
 }
 
 void vga_clear(void)
 {
-       int i;
-       for(i = 0; i < vga_max_y; i++)
-               __vga_clear_line(i);
+    int i;
+    for (i = 0; i < vga_max_y; i++)
+        __vga_clear_line(i);
 }
 
 void vga_init(void)
 {
-       vga_mem = vsalloc("VGA mem", 0, PAGE_SIZE);
-       map_page((u64) vga_mem, 0xB8000);
-       vga_clear();
+    vga_mem = vsalloc("VGA mem", 0, PAGE_SIZE);
+    map_page((u64) vga_mem, 0xB8000);
+    vga_clear();
 }
index dbda9e4..a494f7e 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 /* The domain allocator is a generalized way to break up any range of numbers
  * into allocated and free, along with hanging a pointer on that info.
 
 static int __bump_allocation(struct domain *domain)
 {
-       int start = MAX_BLOCK(domain) + 1;
-       int i;
+    int start = MAX_BLOCK(domain) + 1;
+    int i;
 
-       /* For vsalloc, we pre-init domain->blocks to avoid calling itself, for
-        * everyone else, we get heap vspace on the first allocation
-        */
+    /* For vsalloc, we pre-init domain->blocks to avoid calling itself, for
+     * everyone else, we get heap vspace on the first allocation
+     */
 
-       if (domain->blocks == (void *) VSALLOC_HEAP_VIRTUAL) {
-               if(page_alloc_to_virtual(ALLOC_END(domain), 0) == NULL)
-                       return -1;
-       } else {
-               domain->blocks = page_vrealloc(NULL, 0, domain->pages++);
-               if (!domain->blocks)
-                       return -1;
-       }
+    if (domain->blocks == (void *)VSALLOC_HEAP_VIRTUAL) {
+        if (page_alloc_to_virtual(ALLOC_END(domain), 0) == NULL)
+            return -1;
+    } else {
+        domain->blocks = page_vrealloc(NULL, 0, domain->pages++);
+        if (!domain->blocks)
+            return -1;
+    }
 
-       /* Append a page to the end of blocks */
-       domain->pages++;
+    /* Append a page to the end of blocks */
+    domain->pages++;
 
-       for (i = start; i < (MAX_BLOCK(domain) - 1); i++)
-               domain->blocks[i].next = i + 1;
+    for (i = start; i < (MAX_BLOCK(domain) - 1); i++)
+        domain->blocks[i].next = i + 1;
 
-       /* domain->free_offset should probably be -1, but just in case
-        * prepend on domain->free_offset instead of assuming
-        */
+    /* domain->free_offset should probably be -1, but just in case
+     * prepend on domain->free_offset instead of assuming
+     */
 
-       domain->blocks[i].next = domain->free_offset;
-       domain->free_offset = start;
+    domain->blocks[i].next = domain->free_offset;
+    domain->free_offset = start;
 
-       return 0;
+    return 0;
 }
 
 static inline int __bounds_ok(struct domain *domain, u64 address, u64 end)
 {
-       return ((address >= domain->min)&&(end <= domain->max));
+    return ((address >= domain->min) && (end <= domain->max));
 }
 
-static struct domain_block *__search(struct domain *domain, u64 address, u64 size, s64 *sb, struct domain_block **prev)
+static struct domain_block *__search(struct domain *domain, u64 address,
+                                     u64 size, s64 * sb,
+                                     struct domain_block **prev)
 {
-       struct domain_block *ret;
+    struct domain_block *ret;
 
-       s64 ret_idx;
-       s64 prev_idx = -1;
+    s64 ret_idx;
+    s64 prev_idx = -1;
 
-       if ((!sb)||(*sb = -1))
-               ret_idx = domain->used_offset;
-       else
-               ret_idx = *sb;
+    if ((!sb) || (*sb = -1))
+        ret_idx = domain->used_offset;
+    else
+        ret_idx = *sb;
 
-       u64 end = address + size - 1; // -1 because 0 counts (0x1000 at 0x0 = 0x->0xFFF)
+    u64 end = address + size - 1;   // -1 because 0 counts (0x1000 at 0x0 = 0x->0xFFF)
 
-       for (; ret_idx != -1; prev_idx = ret_idx, ret_idx = ret->next) {
-               ret = DB(ret_idx);
+    for (; ret_idx != -1; prev_idx = ret_idx, ret_idx = ret->next) {
+        ret = DB(ret_idx);
 
-               if (sb)
-                       *sb = ret->next;
+        if (sb)
+            *sb = ret->next;
 
-               /* cur still lower than where we need to be */
+        /* cur still lower than where we need to be */
 
-               if(address > ret->end)
-                       continue;
+        if (address > ret->end)
+            continue;
 
-               /* cur is higher than we need */
+        /* cur is higher than we need */
 
-               if (end < ret->address) {
-                       *prev = ret;
-                       return NULL;
-               }
+        if (end < ret->address) {
+            *prev = ret;
+            return NULL;
+        }
 
-               goto found;
-       }
+        goto found;
+    }
 
-       /* If we fell out of the above loop, prev_idx has already been
-        * set, and there is no collision
-        */
+    /* If we fell out of the above loop, prev_idx has already been
+     * set, and there is no collision
+     */
 
-       ret = NULL;
+    ret = NULL;
 
-found:
-       if(prev_idx >= 0)
-               *prev = DB(prev_idx);
-       else
-               *prev = NULL;
+ found:
+    if (prev_idx >= 0)
+        *prev = DB(prev_idx);
+    else
+        *prev = NULL;
 
-       return ret;
+    return ret;
 }
 
-static struct domain_block *__alloc(struct domain *domain, u64 address, u64 size, u32 near_ok, void *priv)
+static struct domain_block *__alloc(struct domain *domain, u64 address,
+                                    u64 size, u32 near_ok, void *priv)
 {
-       struct domain_block *cur, *prev, *free;
-       u64 end, free_idx;
-       s64 save = -1;
+    struct domain_block *cur, *prev, *free;
+    u64 end, free_idx;
+    s64 save = -1;
 
-       do {
-               end = address + size - 1; // -1 because 0 counts (0x1000 at 0x0 = 0x->0xFFF)
+    do {
+        end = address + size - 1;   // -1 because 0 counts (0x1000 at 0x0 = 0x->0xFFF)
 
-               if (!__bounds_ok(domain, address, end))
-                       return NULL;
+        if (!__bounds_ok(domain, address, end))
+            return NULL;
 
-               cur = __search(domain, address, size, &save, &prev);
+        cur = __search(domain, address, size, &save, &prev);
 
-               if (cur) {
-                       if(!near_ok)
-                               return NULL;
-                       address = cur->end + 1;
-               }
-       } while(cur);
+        if (cur) {
+            if (!near_ok)
+                return NULL;
+            address = cur->end + 1;
+        }
+    } while (cur);
 
-       if ((domain->free_offset == -1) && (__bump_allocation(domain)))
-               return NULL;
+    if ((domain->free_offset == -1) && (__bump_allocation(domain)))
+        return NULL;
 
-       free_idx = domain->free_offset;
-       free = DB(free_idx);
+    free_idx = domain->free_offset;
+    free = DB(free_idx);
 
-       free->address = address;
-       free->end = end;
-       free->priv = priv;
+    free->address = address;
+    free->end = end;
+    free->priv = priv;
 
-       domain->free_offset = free->next;
+    domain->free_offset = free->next;
 
-       if (prev) {
-               free->next = prev->next;
-               prev->next = free_idx;
-       } else {
-               free->next = domain->used_offset;
-               domain->used_offset = free_idx;
-       }
+    if (prev) {
+        free->next = prev->next;
+        prev->next = free_idx;
+    } else {
+        free->next = domain->used_offset;
+        domain->used_offset = free_idx;
+    }
 
-       return free;
+    return free;
 }
 
-static struct domain_block *__alloc_locked(struct domain *domain, u64 address, u64 size, u32 near_ok, void *priv)
+static struct domain_block *__alloc_locked(struct domain *domain, u64 address,
+                                           u64 size, u32 near_ok, void *priv)
 {
-       struct domain_block *ret;
+    struct domain_block *ret;
 
-       spinlock_lock(&domain->lock);
+    spinlock_lock(&domain->lock);
 
-       ret = __alloc(domain, address, size, near_ok, priv);
+    ret = __alloc(domain, address, size, near_ok, priv);
 
-       spinlock_unlock(&domain->lock);
+    spinlock_unlock(&domain->lock);
 
-       return ret;
+    return ret;
 }
 
 void domain_free(struct domain *domain, u64 address)
 {
-       struct domain_block *cur, *prev;
+    struct domain_block *cur, *prev;
 
-       s64 cur_idx;
+    s64 cur_idx;
 
-       spinlock_lock(&domain->lock);
+    spinlock_lock(&domain->lock);
 
-       cur = __search(domain, address, 1, NULL, &prev);
+    cur = __search(domain, address, 1, NULL, &prev);
 
-       if (cur) {
-               if(prev) {
-                       cur_idx = prev->next;
-                       prev->next = cur->next;
-                       cur->next = domain->free_offset;
-                       domain->free_offset = cur_idx;
-               } else {
-                       cur_idx = domain->used_offset;
-                       domain->used_offset = cur->next;
-                       cur->next = domain->free_offset;
-                       domain->free_offset = cur_idx;
-               }
-       }
+    if (cur) {
+        if (prev) {
+            cur_idx = prev->next;
+            prev->next = cur->next;
+            cur->next = domain->free_offset;
+            domain->free_offset = cur_idx;
+        } else {
+            cur_idx = domain->used_offset;
+            domain->used_offset = cur->next;
+            cur->next = domain->free_offset;
+            domain->free_offset = cur_idx;
+        }
+    }
 
-       spinlock_unlock(&domain->lock);
+    spinlock_unlock(&domain->lock);
 }
 
 struct domain_block *domain_search(struct domain *domain, u64 address)
 {
-       struct domain_block *cur;
-       struct domain_block *prev;
+    struct domain_block *cur;
+    struct domain_block *prev;
 
-       spinlock_lock(&domain->lock);
+    spinlock_lock(&domain->lock);
 
-       cur = __search(domain, address, 1, NULL, &prev);
+    cur = __search(domain, address, 1, NULL, &prev);
 
-       spinlock_unlock(&domain->lock);
+    spinlock_unlock(&domain->lock);
 
-       return cur;
+    return cur;
 }
 
 struct domain_block *domain_alloc(struct domain *domain, u64 size, void *priv)
 {
-       return __alloc_locked(domain, domain->min, size, 1, priv);
+    return __alloc_locked(domain, domain->min, size, 1, priv);
 }
 
-struct domain_block *domain_alloc_near(struct domain *domain, u64 address, u64 size, void *priv)
+struct domain_block *domain_alloc_near(struct domain *domain, u64 address,
+                                       u64 size, void *priv)
 {
-       return __alloc_locked(domain, address, size, 1, priv);
+    return __alloc_locked(domain, address, size, 1, priv);
 }
 
-struct domain_block *domain_alloc_address(struct domain *domain, u64 address, u64 size, void *priv)
+struct domain_block *domain_alloc_address(struct domain *domain, u64 address,
+                                          u64 size, void *priv)
 {
-       return __alloc_locked(domain, address, size, 0, priv);
+    return __alloc_locked(domain, address, size, 0, priv);
 }
 
 void domain_init(struct domain *domain, u64 min, u64 max)
 {
-       domain->min = min;
-       domain->max = max;
+    domain->min = min;
+    domain->max = max;
 
-       domain->pages = 0;
-       domain->free_offset = -1;
-       domain->used_offset = -1;
-       domain->blocks = NULL;
+    domain->pages = 0;
+    domain->free_offset = -1;
+    domain->used_offset = -1;
+    domain->blocks = NULL;
 }
 
 #ifdef TEST_DOMAIN
@@ -257,79 +263,79 @@ static struct domain td = DOMAIN(DOM_MIN, DOM_MAX);
 
 static void __test_bounds(struct domain_block *ret)
 {
-       /* Check that the return is sane and not 0 sized */
-       if (ret->address >= ret->end)
-               while(1);
-
-       /* Check that it's inside the test domain bounds */
-       if (ret->address < DOM_MIN)
-               while(1);
-       if (ret->address > DOM_MAX)
-               while(1);
-       if (ret->end < DOM_MIN)
-               while(1);
-       if (ret->end > DOM_MAX)
-               while(1);
+    /* Check that the return is sane and not 0 sized */
+    if (ret->address >= ret->end)
+        while (1) ;
+
+    /* Check that it's inside the test domain bounds */
+    if (ret->address < DOM_MIN)
+        while (1) ;
+    if (ret->address > DOM_MAX)
+        while (1) ;
+    if (ret->end < DOM_MIN)
+        while (1) ;
+    if (ret->end > DOM_MAX)
+        while (1) ;
 }
 
 static void __test_overlap(struct domain_block *a, struct domain_block *b)
 {
-       /* a->end is in b */
-       if ((a->end >= b->address) && (a->end <= b->end))
-               while(1);
+    /* a->end is in b */
+    if ((a->end >= b->address) && (a->end <= b->end))
+        while (1) ;
 
-       /* a->address is in b */
-       if ((a->address >= b->address) && (a->address <= b->end))
-               while(1);
+    /* a->address is in b */
+    if ((a->address >= b->address) && (a->address <= b->end))
+        while (1) ;
 
-       /* b->end is in a */
-       if ((b->end >= a->address) && (b->end <= a->end))
-               while(1);
+    /* b->end is in a */
+    if ((b->end >= a->address) && (b->end <= a->end))
+        while (1) ;
 
-       /* b->address is in a */
-       if ((b->address >= a->address) && (b->address <= a->end))
-               while(1);
+    /* b->address is in a */
+    if ((b->address >= a->address) && (b->address <= a->end))
+        while (1) ;
 }
 
 void test_domain(void)
 {
-       struct domain_block *ret;
-       struct domain_block *ret2;
+    struct domain_block *ret;
+    struct domain_block *ret2;
 
-       /* vsalloc's not inited but we can borrow it's big virtual address for a moment */
+    /* vsalloc's not inited but we can borrow it's big virtual address for a moment */
 
-       td.blocks = (void *) VSALLOC_HEAP_VIRTUAL;
+    td.blocks = (void *)VSALLOC_HEAP_VIRTUAL;
 
-       /* Test bounding */
+    /* Test bounding */
 
-       ret = domain_alloc(&td, 4096, NULL);
-       __test_bounds(ret);
+    ret = domain_alloc(&td, 4096, NULL);
+    __test_bounds(ret);
 
-       /* Test non-overlapping */
+    /* Test non-overlapping */
 
-       ret2 = domain_alloc(&td, 100, NULL);
-       __test_overlap(ret, ret2);
+    ret2 = domain_alloc(&td, 100, NULL);
+    __test_overlap(ret, ret2);
 
-       /* Searching for a sub set range should still return conflict */
+    /* Searching for a sub set range should still return conflict */
 
-       ret2 = domain_search(&td, 3);
+    ret2 = domain_search(&td, 3);
 
-       if(ret != ret2)
-               while(1);
+    if (ret != ret2)
+        while (1) ;
 
-       domain_free(&td, ret->address);
+    domain_free(&td, ret->address);
 
-       /* This should now be free */
-       ret2 = domain_search(&td, 3);
+    /* This should now be free */
+    ret2 = domain_search(&td, 3);
 
-       if(ret2)
-               while(1);
+    if (ret2)
+        while (1) ;
 
-       /* Cleanup Test Domain */
-       while (td.pages) {
-               page_alloc_free_from_virtual((u64) td.blocks);
-               td.blocks = (void *) (((u64) td.blocks) + PAGE_SIZE);
-               td.pages--;
-       }
+    /* Cleanup Test Domain */
+    while (td.pages) {
+        page_alloc_free_from_virtual((u64) td.blocks);
+        td.blocks = (void *)(((u64) td.blocks) + PAGE_SIZE);
+        td.pages--;
+    }
 }
 #endif
index fd06076..82ec7ea 100644 (file)
--- a/mm/map.c
+++ b/mm/map.c
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 #include <kernel.h>
 
 #include <asm/regs.h>
 
-static void __early_map_check(u64 *entry, u64 *target, u64 *alloc_base)
+static void __early_map_check(u64 * entry, u64 * target, u64 * alloc_base)
 {
-       if (!(*entry & PF_P)) {
-               *entry = (*alloc_base) | (PF_RW | PF_P);
+    if (!(*entry & PF_P)) {
+        *entry = (*alloc_base) | (PF_RW | PF_P);
 
-               /* reset_cr3 so the newly mapped page is accessible, zero it, then
-                * reset cr3 again to make sure no crap mappings are in there. */
+        /* reset_cr3 so the newly mapped page is accessible, zero it, then
+         * reset cr3 again to make sure no crap mappings are in there. */
 
-               reset_cr3();
-               __clear_page(target);
-               reset_cr3();
+        reset_cr3();
+        __clear_page(target);
+        reset_cr3();
 
-               *alloc_base = (*alloc_base) + PAGE_SIZE;
-       }
+        *alloc_base = (*alloc_base) + PAGE_SIZE;
+    }
 }
 
-void *map_page_early(u64 virtual, u64 physical, u64 *alloc_base)
+void *map_page_early(u64 virtual, u64 physical, u64 * alloc_base)
 {
-       u64 *pml4e = (u64 *) PML4E_ADDR(virtual);
-       u64 *pdpe = (u64 *) PDPE_ADDR(virtual);
-       u64 *pde = (u64 *) PDE_ADDR(virtual);
-       u64 *pte = (u64 *) PTE_ADDR(virtual);
+    u64 *pml4e = (u64 *) PML4E_ADDR(virtual);
+    u64 *pdpe = (u64 *) PDPE_ADDR(virtual);
+    u64 *pde = (u64 *) PDE_ADDR(virtual);
+    u64 *pte = (u64 *) PTE_ADDR(virtual);
 
-       /* Make sure all of these structures exist, and if not, alloc and zero them */
+    /* Make sure all of these structures exist, and if not, alloc and zero them */
 
-       __early_map_check(pml4e, pdpe, alloc_base);
-       __early_map_check(pdpe, pde, alloc_base);
-       __early_map_check(pde, pte, alloc_base);
+    __early_map_check(pml4e, pdpe, alloc_base);
+    __early_map_check(pdpe, pde, alloc_base);
+    __early_map_check(pde, pte, alloc_base);
 
-       *pte = PAGE_ALIGN(physical) | PF_RW | PF_P;
+    *pte = PAGE_ALIGN(physical) | PF_RW | PF_P;
 
-       reset_cr3();
+    reset_cr3();
 
-       return (void *) virtual;
+    return (void *)virtual;
 }
 
 /* Similar to __early_map_check, except it can use page_alloc_phys, and check
  * its return value*/
 
-static int __map_check(u64 *entry, u64 *target)
+static int __map_check(u64 * entry, u64 * target)
 {
-       u64 phys = 0;
+    u64 phys = 0;
 
-       if (!(*entry & PF_P)) {
-               phys = page_alloc_phys(0);
-               if(phys == 0)
-                       return -ENOMEM;
+    if (!(*entry & PF_P)) {
+        phys = page_alloc_phys(0);
+        if (phys == 0)
+            return -ENOMEM;
 
-               *entry = (page_alloc_phys(0) | PF_RW | PF_P);
+        *entry = (page_alloc_phys(0) | PF_RW | PF_P);
 
-               /* reset_cr3 so the newly mapped page is accessible, zero it, then
-                * reset cr3 again to make sure no crap mappings are in there. */
+        /* reset_cr3 so the newly mapped page is accessible, zero it, then
+         * reset cr3 again to make sure no crap mappings are in there. */
 
-               reset_cr3();
-               __clear_page(target);
-               reset_cr3();
-               return 1;
-       }
+        reset_cr3();
+        __clear_page(target);
+        reset_cr3();
+        return 1;
+    }
 
-       return 0;
+    return 0;
 }
 
 int __map_page_flags(u64 virtual, u64 physical, u8 flags)
 {
-       u64 *pml4e,*pdpe,*pde,*pte = NULL;
-       int ret, allocd = 0;
+    u64 *pml4e, *pdpe, *pde, *pte = NULL;
+    int ret, allocd = 0;
 
-       pml4e = (u64 *) PML4E_ADDR(virtual);
-       pdpe = (u64 *) PDPE_ADDR(virtual);
-       pde = (u64 *) PDE_ADDR(virtual);
-       pte = (u64 *) PTE_ADDR(virtual);
+    pml4e = (u64 *) PML4E_ADDR(virtual);
+    pdpe = (u64 *) PDPE_ADDR(virtual);
+    pde = (u64 *) PDE_ADDR(virtual);
+    pte = (u64 *) PTE_ADDR(virtual);
 
-       /* Make sure all of these structures exist, and if not, alloc and zero them */
+    /* Make sure all of these structures exist, and if not, alloc and zero them */
 
-       ret = __map_check(pml4e, pdpe);
-       if (ret < 0)
-               return -ENOMEM;
+    ret = __map_check(pml4e, pdpe);
+    if (ret < 0)
+        return -ENOMEM;
 
-       allocd += ret;
+    allocd += ret;
 
-       ret = __map_check(pdpe, pde);
-       if (ret < 0)
-               goto cleanup_pml4e;
+    ret = __map_check(pdpe, pde);
+    if (ret < 0)
+        goto cleanup_pml4e;
 
-       allocd += ret;
+    allocd += ret;
 
-       ret = __map_check(pde, pte);
-       if (ret < 0)
-               goto cleanup_pdpe;
+    ret = __map_check(pde, pte);
+    if (ret < 0)
+        goto cleanup_pdpe;
 
-       *pte = PAGE_ALIGN(physical) | PF_P | flags;
+    *pte = PAGE_ALIGN(physical) | PF_P | flags;
 
-       return 0;
+    return 0;
 
-cleanup_pdpe:
-       if (allocd) {
-               page_alloc_free_phys(PAGE_ALIGN(*pdpe));
-               *pdpe = 0;
-               allocd--;
-       }
-cleanup_pml4e:
-       if (allocd) {
-               page_alloc_free_phys(PAGE_ALIGN(*pml4e));
-               *pml4e = 0;
-       }
+ cleanup_pdpe:
+    if (allocd) {
+        page_alloc_free_phys(PAGE_ALIGN(*pdpe));
+        *pdpe = 0;
+        allocd--;
+    }
+ cleanup_pml4e:
+    if (allocd) {
+        page_alloc_free_phys(PAGE_ALIGN(*pml4e));
+        *pml4e = 0;
+    }
 
-       reset_cr3();
+    reset_cr3();
 
-       return -ENOMEM;
+    return -ENOMEM;
 }
 
-int __table_empty(u64 *table)
+int __table_empty(u64 * table)
 {
-       int i;
-       for(i = 0; i < 512; i++) {
-               if (table[i] & PF_P)
-                       return 0;
-       }
+    int i;
+    for (i = 0; i < 512; i++) {
+        if (table[i] & PF_P)
+            return 0;
+    }
 
-       return 1;
+    return 1;
 }
 
 void __unmap_page(u64 virtual)
 {
-       u64 *pml4e,*pdpe,*pde,*pte = NULL;
-       u64 *pdp, *pd, *pt;
-
-       pml4e = (u64 *) PML4E_ADDR(virtual);
-       pdpe = (u64 *) PDPE_ADDR(virtual);
-       pde = (u64 *) PDE_ADDR(virtual);
-       pte = (u64 *) PTE_ADDR(virtual);
-
-       pdp = (u64 *) PAGE_ALIGN((u64) pdpe);
-       pd = (u64 *) PAGE_ALIGN((u64) pde);
-       pt = (u64 *) PAGE_ALIGN((u64) pte);
-
-       /* If the mapping doesn't exist, get out */
-       if (!(*pml4e & PF_P))
-               return;
-       if (!(*pdpe & PF_P))
-               return;
-       if (!(*pde & PF_P))
-               return;
-       if (!(*pte & PF_P))
-               return;
-
-       *pte = 0;
-       if(__table_empty(pt)) {
-               page_alloc_free_phys(PAGE_ALIGN(*pde));
-               *pde = 0;
-
-               if(__table_empty(pd)) {
-                       page_alloc_free_phys(PAGE_ALIGN(*pdpe));
-                       *pdpe = 0;
-
-                       if(__table_empty(pdp)) {
-                               page_alloc_free_phys(PAGE_ALIGN(*pml4e));
-                               *pml4e = 0;
-                       }
-               }
-       }
+    u64 *pml4e, *pdpe, *pde, *pte = NULL;
+    u64 *pdp, *pd, *pt;
+
+    pml4e = (u64 *) PML4E_ADDR(virtual);
+    pdpe = (u64 *) PDPE_ADDR(virtual);
+    pde = (u64 *) PDE_ADDR(virtual);
+    pte = (u64 *) PTE_ADDR(virtual);
+
+    pdp = (u64 *) PAGE_ALIGN((u64) pdpe);
+    pd = (u64 *) PAGE_ALIGN((u64) pde);
+    pt = (u64 *) PAGE_ALIGN((u64) pte);
+
+    /* If the mapping doesn't exist, get out */
+    if (!(*pml4e & PF_P))
+        return;
+    if (!(*pdpe & PF_P))
+        return;
+    if (!(*pde & PF_P))
+        return;
+    if (!(*pte & PF_P))
+        return;
+
+    *pte = 0;
+    if (__table_empty(pt)) {
+        page_alloc_free_phys(PAGE_ALIGN(*pde));
+        *pde = 0;
+
+        if (__table_empty(pd)) {
+            page_alloc_free_phys(PAGE_ALIGN(*pdpe));
+            *pdpe = 0;
+
+            if (__table_empty(pdp)) {
+                page_alloc_free_phys(PAGE_ALIGN(*pml4e));
+                *pml4e = 0;
+            }
+        }
+    }
 }
 
 void unmap_pages(u64 virtual, u64 num_pages)
 {
-       while (num_pages) {
-               __unmap_page(virtual);
-               virtual += PAGE_SIZE;
-               num_pages--;
-       }
+    while (num_pages) {
+        __unmap_page(virtual);
+        virtual += PAGE_SIZE;
+        num_pages--;
+    }
 }
 
 int __map_pages_flags(u64 virtual, u64 physical, u64 num_pages, u8 flags)
 {
-       int i, j, ret;
+    int i, j, ret;
 
-       for ( i = 0; i < num_pages; i++) {
-               ret = __map_page_flags(virtual, physical, flags);
+    for (i = 0; i < num_pages; i++) {
+        ret = __map_page_flags(virtual, physical, flags);
 
-               if (ret) {
-                       for (j = i; j > 0; j--) {
-                               virtual -= PAGE_SIZE;
-                               physical -= PAGE_SIZE;
-                               unmap_pages(virtual, 1);
-                       }
-                       return ret;
-               }
+        if (ret) {
+            for (j = i; j > 0; j--) {
+                virtual -= PAGE_SIZE;
+                physical -= PAGE_SIZE;
+                unmap_pages(virtual, 1);
+            }
+            return ret;
+        }
 
-               virtual += PAGE_SIZE;
-               physical += PAGE_SIZE;
-       }
+        virtual += PAGE_SIZE;
+        physical += PAGE_SIZE;
+    }
 
-       return 0;
+    return 0;
 }
 
 int map_pages(u64 virtual, u64 physical, u64 num_pages)
 {
-       int ret = __map_pages_flags(virtual, physical, num_pages, PF_RW);
-       reset_cr3();
-       return ret;
+    int ret = __map_pages_flags(virtual, physical, num_pages, PF_RW);
+    reset_cr3();
+    return ret;
 }
 
 int map_pages_nocache(u64 virtual, u64 physical, u64 num_pages)
 {
-       int ret = __map_pages_flags(virtual, physical, num_pages, PF_RW | PF_DISABLE_CACHE);
-       reset_cr3();
-       return ret;
+    int ret =
+        __map_pages_flags(virtual, physical, num_pages,
+                          PF_RW | PF_DISABLE_CACHE);
+    reset_cr3();
+    return ret;
 }
 
 u64 map_virt_to_phys(u64 virtual)
 {
-       u64 *pml4e = (u64 *) PML4E_ADDR(virtual);
-       u64 *pdpe = (u64 *) PDPE_ADDR(virtual);
-       u64 *pde = (u64 *) PDE_ADDR(virtual);
-       u64 *pte = (u64 *) PTE_ADDR(virtual);
-
-       if(!(*pml4e & PF_P))
-               return 0;
-       if(!(*pdpe & PF_P))
-               return 0;
-       if(!(*pde & PF_P))
-               return 0;
-       if(!(*pte & PF_P))
-               return 0;
-       return PAGE_ALIGN(*pte);
+    u64 *pml4e = (u64 *) PML4E_ADDR(virtual);
+    u64 *pdpe = (u64 *) PDPE_ADDR(virtual);
+    u64 *pde = (u64 *) PDE_ADDR(virtual);
+    u64 *pte = (u64 *) PTE_ADDR(virtual);
+
+    if (!(*pml4e & PF_P))
+        return 0;
+    if (!(*pdpe & PF_P))
+        return 0;
+    if (!(*pde & PF_P))
+        return 0;
+    if (!(*pte & PF_P))
+        return 0;
+    return PAGE_ALIGN(*pte);
 }
 
 void map_page_summarize(u64 virtual)
 {
-       u64 phys = map_virt_to_phys(virtual);
+    u64 phys = map_virt_to_phys(virtual);
 
-       printk("M: 0x%lx -> 0x%lx\n", virtual, phys);
+    printk("M: 0x%lx -> 0x%lx\n", virtual, phys);
 }
index 3cb1b88..a56aa05 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 /* Objcache is an implementation of a localized general memory allocator */
 
 
 static inline int __bitmap_first_zero(u64 val)
 {
-       int ret = 0;
+    int ret = 0;
 
-       if (val == ((u64) -1))
-               return -1;
+    if (val == ((u64) - 1))
+        return -1;
 
-       while (val % 2) {
-               val >>= 1;
-               ret++;
-       }
+    while (val % 2) {
+        val >>= 1;
+        ret++;
+    }
 
-       return ret;
+    return ret;
 }
 
 static inline int __bitmap_first_zero_in_page(int bitmap_longs, void *ptr)
 {
-       u64 *page = ptr;
-       int i, ret;
+    u64 *page = ptr;
+    int i, ret;
 
-       for (i = 0; i < bitmap_longs; i++) {
-               ret = __bitmap_first_zero(page[i]);
-               if (ret >= 0)
-                       return (i * 64) + ret;
-       }
+    for (i = 0; i < bitmap_longs; i++) {
+        ret = __bitmap_first_zero(page[i]);
+        if (ret >= 0)
+            return (i * 64) + ret;
+    }
 
-       return -1;
+    return -1;
 }
 
 static int __bitmap_overall_first_zero(struct objcache *objcache, void **retptr)
 {
-       int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
-       int ret;
-       void *cur;
+    int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
+    int ret;
+    void *cur;
 
-       cur = objcache->start_page;
+    cur = objcache->start_page;
 
-       while(cur) {
-               ret = __bitmap_first_zero_in_page(bitmap_longs, cur);
+    while (cur) {
+        ret = __bitmap_first_zero_in_page(bitmap_longs, cur);
 
-               if (ret >= 0) {
-                       *retptr = cur;
-                       return ret;
-               }
+        if (ret >= 0) {
+            *retptr = cur;
+            return ret;
+        }
 
-               cur = (void *) (((u64 *) cur)[bitmap_longs]);
-       }
+        cur = (void *)(((u64 *) cur)[bitmap_longs]);
+    }
 
-       return -1;
+    return -1;
 }
 
 static int __oc_bump_allocation(struct objcache *objcache, void **page)
 {
-       int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
-       u64 *new_page = page_alloc(0);
-       u64 *cur;
-       int i;
+    int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
+    u64 *new_page = page_alloc(0);
+    u64 *cur;
+    int i;
 
-       if (!new_page)
-               return -1;
+    if (!new_page)
+        return -1;
 
-       /* Init bitmap and next ptr */
+    /* Init bitmap and next ptr */
 
-       new_page[0] = INITIAL_MASK(objcache);
-       for (i = 1; i <= bitmap_longs; i++)
-               new_page[i] = 0;
+    new_page[0] = INITIAL_MASK(objcache);
+    for (i = 1; i <= bitmap_longs; i++)
+        new_page[i] = 0;
 
-       *page = new_page;
+    *page = new_page;
 
-       if (!objcache->start_page) {
-               objcache->start_page = new_page;
-               return 0;
-       }
+    if (!objcache->start_page) {
+        objcache->start_page = new_page;
+        return 0;
+    }
 
-       cur = objcache->start_page;
-       while (cur) {
-               if (cur[bitmap_longs] == 0) {
-                       cur[bitmap_longs] = (u64) new_page;
-                       break;
-               }
+    cur = objcache->start_page;
+    while (cur) {
+        if (cur[bitmap_longs] == 0) {
+            cur[bitmap_longs] = (u64) new_page;
+            break;
+        }
 
-               cur = (void *) ((u64) cur[bitmap_longs]);
-       }
+        cur = (void *)((u64) cur[bitmap_longs]);
+    }
 
-       return 0;
+    return 0;
 }
 
-static int __oc_page_empty(struct objcache *objcache, u64 *page)
+static int __oc_page_empty(struct objcache *objcache, u64 * page)
 {
-       int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
-       int i;
+    int bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
+    int i;
 
-       if (page[0] != INITIAL_MASK(objcache))
-               return 0;
+    if (page[0] != INITIAL_MASK(objcache))
+        return 0;
 
-       for (i = 1; i < bitmap_longs; i++) {
-               if (page[i] != 0)
-                       return 0;
-       }
+    for (i = 1; i < bitmap_longs; i++) {
+        if (page[i] != 0)
+            return 0;
+    }
 
-       return 1;
+    return 1;
 }
 
 void *objcache_get(struct objcache *objcache)
 {
-       u64 *page;
-       int ret;
+    u64 *page;
+    int ret;
 
-       ret = __bitmap_overall_first_zero(objcache, (void **) &page);
+    ret = __bitmap_overall_first_zero(objcache, (void **)&page);
 
-       if (ret == -1) {
-               if (__oc_bump_allocation(objcache, (void **) &page))
-                       return NULL;
-               ret = OVERHEAD_OBJECTS(objcache);
-       }
+    if (ret == -1) {
+        if (__oc_bump_allocation(objcache, (void **)&page))
+            return NULL;
+        ret = OVERHEAD_OBJECTS(objcache);
+    }
 
-       page[ret / 64] |= (1UL << (ret % 64));
+    page[ret / 64] |= (1UL << (ret % 64));
 
-       return (void *) (((u64) page) + (ret * objcache->obj_size));
+    return (void *)(((u64) page) + (ret * objcache->obj_size));
 }
 
 void objcache_free(struct objcache *objcache, void *obj)
 {
-       u64 bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
-       u64 *page = objcache->start_page;
-       u64 *prev = NULL;
-       int idx;
-
-       while(page) {
-               if (PAGE_ALIGN((u64) obj) == (u64) page) {
-                       idx = ((u64) obj - (u64) page) / objcache->obj_size;
-                       page[idx / 64] &= ~(1UL << (idx % 64));
-
-                       if (__oc_page_empty(objcache, page)) {
-                               if(prev)
-                                       prev[bitmap_longs] = page[bitmap_longs];
-                               else
-                                       objcache->start_page = (void *) page[bitmap_longs];
-                               page_alloc_free(page);
-                       }
-                       break;
-               }
-
-               prev = page;
-               page = (void *) page[bitmap_longs];
-       }
+    u64 bitmap_longs = OVERHEAD_LONGS(objcache) - 1;
+    u64 *page = objcache->start_page;
+    u64 *prev = NULL;
+    int idx;
+
+    while (page) {
+        if (PAGE_ALIGN((u64) obj) == (u64) page) {
+            idx = ((u64) obj - (u64) page) / objcache->obj_size;
+            page[idx / 64] &= ~(1UL << (idx % 64));
+
+            if (__oc_page_empty(objcache, page)) {
+                if (prev)
+                    prev[bitmap_longs] = page[bitmap_longs];
+                else
+                    objcache->start_page = (void *)page[bitmap_longs];
+                page_alloc_free(page);
+            }
+            break;
+        }
+
+        prev = page;
+        page = (void *)page[bitmap_longs];
+    }
 }
 
 void objcache_init(struct objcache *objcache, u32 obj_size)
@@ -177,10 +177,10 @@ void objcache_init(struct objcache *objcache, u32 obj_size)
 #ifdef TEST_OBJCACHE
 
 struct test_struct {
-       u64 a;
-       u64 b;
-       u64 c;
-       u64 d;
+    u64 a;
+    u64 b;
+    u64 c;
+    u64 d;
 };
 
 DEFINE_OBJCACHE(test_cache, struct test_struct);
index f8f0bbe..dbbad55 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 /* Physical and virtual page allocator */
 
@@ -26,8 +26,8 @@
 #include <asm/spinlock.h>
 
 struct page_block {
-       u64 address;
-       struct page_block *next;
+    u64 address;
+    struct page_block *next;
 };
 
 u64 total_mem;
@@ -54,136 +54,138 @@ u64 total_mem;
 
 struct page_block *free_pages[MAX_ORDER + 1] = { 0 };
 struct page_block *used_pages[MAX_ORDER + 1] = { 0 };
+
 struct page_block *unused_page_blocks = NULL;
 
 DEFINE_SPINLOCK(page_alloc_lock) = SPINLOCK_UNLOCKED;
 
-static inline void __setprev(struct page_block **head, struct page_block *prev, struct page_block *next)
+static inline void __setprev(struct page_block **head, struct page_block *prev,
+                             struct page_block *next)
 {
-       if (prev)
-               prev->next = next;
-       else
-               *head = next;
+    if (prev)
+        prev->next = next;
+    else
+        *head = next;
 }
 
 static void __page_list_add(struct page_block **head, struct page_block *new)
 {
-       struct page_block *cur, *prev;
+    struct page_block *cur, *prev;
 
-       /* Insert sorted by address */
+    /* Insert sorted by address */
 
-       prev = NULL;
-       for (cur = *head; cur; prev = cur, cur = cur->next) {
-               if (cur->address > new->address) {
-                       new->next = cur;
-                       __setprev(head, prev, new);
-                       return;
-               }
-       }
+    prev = NULL;
+    for (cur = *head; cur; prev = cur, cur = cur->next) {
+        if (cur->address > new->address) {
+            new->next = cur;
+            __setprev(head, prev, new);
+            return;
+        }
+    }
 
-       __setprev(head, prev, new);
-       new->next = cur;
+    __setprev(head, prev, new);
+    new->next = cur;
 }
 
 static struct page_block *__pop_unused_page_block(void)
 {
-       struct page_block *ret = unused_page_blocks;
+    struct page_block *ret = unused_page_blocks;
 
-       if (ret != NULL) {
-               unused_page_blocks = ret->next;
-               ret->next = NULL;
-       }
+    if (ret != NULL) {
+        unused_page_blocks = ret->next;
+        ret->next = NULL;
+    }
 
-       return ret;
+    return ret;
 }
 
 static void __push_unused_page_block(struct page_block *block)
 {
-       block->next = unused_page_blocks;
-       unused_page_blocks = block;
+    block->next = unused_page_blocks;
+    unused_page_blocks = block;
 }
 
 /* Similar to __page_list_add, except it will actual perform the merge */
 
 static void __free_phys(struct page_block *phys, u32 order)
 {
-       struct page_block *cur, *prev;
-       u64 buddy_address;
-       u32 merge;
-
-       if (free_pages[order] == NULL) {
-               free_pages[order] = phys;
-               return;
-       }
-
-       prev = NULL;
-
-       /* For orders under MAX_ORDER, attempt to find buddies, and merge them as
-        * up as far as possible.*/
-
-       for (order = order; order < MAX_ORDER; order++) {
-               buddy_address = (phys->address ^ (1 << (order + PAGE_SHIFT)));
-               merge = 0;
-               for (cur = free_pages[order]; cur; prev = cur, cur = cur->next) {
-
-                       if (cur->address > phys->address) {
-
-                               /* Found a buddy that's bigger than us, so we have the valid
-                                * address, patch cur out of the current order, break to try
-                                * and "free" phys on the next higher order */
-
-                               if (cur->address == buddy_address) {
-                                       __setprev(&free_pages[order], prev, cur->next);
-                                       cur->next = NULL;
-
-                                       __push_unused_page_block(cur);
-                                       merge = 1;
-                                       break;
-
-                               /* Not a buddy, just patch phys into the order. */
-                               } else {
-                                       __setprev(&free_pages[order], prev, phys);
-                                       phys->next = cur;
-                                       return;
-                               }
-                       }
-
-                       /* If address is smaller, we only care if it's a buddy, and
-                        * if it is, it has the valid address*/
-
-                       else if(cur->address == buddy_address) {
-                               __setprev(&free_pages[order], prev, cur->next);
-                               phys->address = cur->address;
-                               __push_unused_page_block(cur);
-                               merge = 1;
-                               break;
-                       }
-               }
-
-               /* If merge is set, we need to advance to the next highest order
-                * to attempt to integrate phys into it.
-                */
-               if(merge)
-                       continue;
-
-               /* If merge is unset, it means that we didn't find a buddy, but we
-                * made it to the end of the order list without finding a greater
-                * page block address, so just tack it on.
-                */
-
-               if (cur)
-                       cur->next = phys;
-               else
-                       free_pages[order] = phys;
-
-               return;
-       }
-
-       /* If we get here, it means that we're at MAX_ORDER, no merging
-        * is possible, so just insert it with __page_list_add
-        */
-
-       __page_list_add(&free_pages[order], phys);
+    struct page_block *cur, *prev;
+    u64 buddy_address;
+    u32 merge;
+
+    if (free_pages[order] == NULL) {
+        free_pages[order] = phys;
+        return;
+    }
+
+    prev = NULL;
+
+    /* For orders under MAX_ORDER, attempt to find buddies, and merge them as
+     * up as far as possible.*/
+
+    for (order = order; order < MAX_ORDER; order++) {
+        buddy_address = (phys->address ^ (1 << (order + PAGE_SHIFT)));
+        merge = 0;
+        for (cur = free_pages[order]; cur; prev = cur, cur = cur->next) {
+
+            if (cur->address > phys->address) {
+
+                /* Found a buddy that's bigger than us, so we have the valid
+                 * address, patch cur out of the current order, break to try
+                 * and "free" phys on the next higher order */
+
+                if (cur->address == buddy_address) {
+                    __setprev(&free_pages[order], prev, cur->next);
+                    cur->next = NULL;
+
+                    __push_unused_page_block(cur);
+                    merge = 1;
+                    break;
+
+                    /* Not a buddy, just patch phys into the order. */
+                } else {
+                    __setprev(&free_pages[order], prev, phys);
+                    phys->next = cur;
+                    return;
+                }
+            }
+
+            /* If address is smaller, we only care if it's a buddy, and
+             * if it is, it has the valid address*/
+
+            else if (cur->address == buddy_address) {
+                __setprev(&free_pages[order], prev, cur->next);
+                phys->address = cur->address;
+                __push_unused_page_block(cur);
+                merge = 1;
+                break;
+            }
+        }
+
+        /* If merge is set, we need to advance to the next highest order
+         * to attempt to integrate phys into it.
+         */
+        if (merge)
+            continue;
+
+        /* If merge is unset, it means that we didn't find a buddy, but we
+         * made it to the end of the order list without finding a greater
+         * page block address, so just tack it on.
+         */
+
+        if (cur)
+            cur->next = phys;
+        else
+            free_pages[order] = phys;
+
+        return;
+    }
+
+    /* If we get here, it means that we're at MAX_ORDER, no merging
+     * is possible, so just insert it with __page_list_add
+     */
+
+    __page_list_add(&free_pages[order], phys);
 }
 
 /* Get a physical address of a block of (1 << order) pages
@@ -193,59 +195,59 @@ static void __free_phys(struct page_block *phys, u32 order)
 
 u64 page_alloc_phys(u32 order)
 {
-       struct page_block *new;
-       u64 end, left_over_pages, pages;
-       u64 ret = 0;
-       int i,j;
+    struct page_block *new;
+    u64 end, left_over_pages, pages;
+    u64 ret = 0;
+    int i, j;
 
-       if (order > MAX_ORDER)
-               return 0;
+    if (order > MAX_ORDER)
+        return 0;
 
-       spinlock_lock(&page_alloc_lock);
+    spinlock_lock(&page_alloc_lock);
 
-       for (i = order; i <= MAX_ORDER; i++) {
-               if (free_pages[i] == NULL)
-                       continue;
+    for (i = order; i <= MAX_ORDER; i++) {
+        if (free_pages[i] == NULL)
+            continue;
 
-               new = free_pages[i];
-               ret = new->address;
-               free_pages[i] = new->next;
+        new = free_pages[i];
+        ret = new->address;
+        free_pages[i] = new->next;
 
-               __page_list_add(&used_pages[order], new);
+        __page_list_add(&used_pages[order], new);
 
-               /* If it's just the right size, we're done */
+        /* If it's just the right size, we're done */
 
-               if (i == order)
-                       goto done;
+        if (i == order)
+            goto done;
 
-               /* Otherwise, we need to split the block up */
+        /* Otherwise, we need to split the block up */
 
-               /* Example, 1M order, being fulfilled by an 8M block The 8M block needs
-                * to be broken in 1M, 1M, 2M, 4M blocks.
-                */
+        /* Example, 1M order, being fulfilled by an 8M block The 8M block needs
+         * to be broken in 1M, 1M, 2M, 4M blocks.
+         */
 
-               left_over_pages = (1 << i) - (1 << order);
-               end = ret + (1 << (i + PAGE_SHIFT));
+        left_over_pages = (1 << i) - (1 << order);
+        end = ret + (1 << (i + PAGE_SHIFT));
 
-               for(j = i - 1; j >= 0; j--) {
-                       pages = (1 << j);
-                       while (left_over_pages >= pages) {
-                               new = __pop_unused_page_block();
-                               new->address = end - (pages << PAGE_SHIFT);
-                               end = new->address;
-                               __free_phys(new, j);
+        for (j = i - 1; j >= 0; j--) {
+            pages = (1 << j);
+            while (left_over_pages >= pages) {
+                new = __pop_unused_page_block();
+                new->address = end - (pages << PAGE_SHIFT);
+                end = new->address;
+                __free_phys(new, j);
 
-                               left_over_pages -= pages;
-                       }
-               }
+                left_over_pages -= pages;
+            }
+        }
 
-               break;
-       }
+        break;
+    }
 
-done:
-       spinlock_unlock(&page_alloc_lock);
+ done:
+    spinlock_unlock(&page_alloc_lock);
 
-       return ret;
+    return ret;
 }
 
 /* Counterpart to page_alloc_phys, unlike __free_phys, it will search for its
@@ -255,97 +257,95 @@ done:
 
 s64 page_alloc_free_phys(u64 phys)
 {
-       struct page_block *cur, *prev;
-       s64 ret = -EINVAL;
-       int i;
-
-       spinlock_lock(&page_alloc_lock);
-
-       prev = NULL;
-       for (i = 0; i < MAX_ORDER; i++) {
-               for(cur = used_pages[i]; cur; prev = cur, cur = cur->next) {
-                       if (cur->address == phys) {
-                               __setprev(&used_pages[i], prev, cur->next);
-                               __free_phys(cur, i);
-                               ret = i;
-                               goto done;
-                       } else if (cur->address > phys)
-                               break;
-               }
-       }
-
-done:
-       spinlock_unlock(&page_alloc_lock);
-
-       return ret;
+    struct page_block *cur, *prev;
+    s64 ret = -EINVAL;
+    int i;
+
+    spinlock_lock(&page_alloc_lock);
+
+    prev = NULL;
+    for (i = 0; i < MAX_ORDER; i++) {
+        for (cur = used_pages[i]; cur; prev = cur, cur = cur->next) {
+            if (cur->address == phys) {
+                __setprev(&used_pages[i], prev, cur->next);
+                __free_phys(cur, i);
+                ret = i;
+                goto done;
+            } else if (cur->address > phys)
+                break;
+        }
+    }
+
+ done:
+    spinlock_unlock(&page_alloc_lock);
+
+    return ret;
 }
 
-
 /* Allocate a page to a given virtual address. */
 /* Expects virtual address to be pre-allocated as well. */
 
 void *page_alloc_to_virtual(u64 virtual, u32 order)
 {
-       u64 physical = page_alloc_phys(order);
-       u64 start_virt = virtual;
-       u64 end_virt = virtual + (1 << (order + PAGE_SHIFT));
+    u64 physical = page_alloc_phys(order);
+    u64 start_virt = virtual;
+    u64 end_virt = virtual + (1 << (order + PAGE_SHIFT));
 
-       if (physical == 0)
-               return NULL;
+    if (physical == 0)
+        return NULL;
 
-       while (start_virt < end_virt) {
-               map_page(start_virt, physical);
-               start_virt += PAGE_SIZE;
-               physical += PAGE_SIZE;
-       }
+    while (start_virt < end_virt) {
+        map_page(start_virt, physical);
+        start_virt += PAGE_SIZE;
+        physical += PAGE_SIZE;
+    }
 
-       return (void *) virtual;
+    return (void *)virtual;
 
 }
 
 s64 page_alloc_free_from_virtual(u64 virtual)
 {
-       u64 phys = map_virt_to_phys(virtual);
-       u32 order;
+    u64 phys = map_virt_to_phys(virtual);
+    u32 order;
 
-       if (phys) {
-               order = page_alloc_free_phys(phys);
-               if (order >= 0)
-                       unmap_pages(virtual, 1 << order);
-               return order;
-       }
+    if (phys) {
+        order = page_alloc_free_phys(phys);
+        if (order >= 0)
+            unmap_pages(virtual, 1 << order);
+        return order;
+    }
 
-       return -1;
+    return -1;
 }
 
 void *page_alloc(u32 order)
 {
-       void *virtual;
-       void *ret;
+    void *virtual;
+    void *ret;
 
-       if (order > MAX_ORDER)
-               return NULL;
+    if (order > MAX_ORDER)
+        return NULL;
 
-       virtual = vsalloc("page heap", 0, (1 << (order + PAGE_SHIFT)));
+    virtual = vsalloc("page heap", 0, (1 << (order + PAGE_SHIFT)));
 
-       if (virtual == NULL)
-               return NULL;
+    if (virtual == NULL)
+        return NULL;
 
-       ret = page_alloc_to_virtual((u64) virtual, order);
+    ret = page_alloc_to_virtual((u64) virtual, order);
 
-       if (ret == NULL) {
-               vfree(virtual);
-               return NULL;
-       }
+    if (ret == NULL) {
+        vfree(virtual);
+        return NULL;
+    }
 
-       return ret;
+    return ret;
 }
 
-
 void page_alloc_free(void *virtual)
 {
-       vfree(virtual);
-       page_alloc_free_from_virtual((u64) virtual);
+    vfree(virtual);
+    page_alloc_free_from_virtual((u64) virtual);
 }
 
 /* vmalloc functions give finer grain control of the allocation size, but you
@@ -355,64 +355,63 @@ void page_alloc_free(void *virtual)
 
 void page_vmalloc_free(void *virtual, u32 pages)
 {
-       s64 order;
-       u32 size;
+    s64 order;
+    u32 size;
 
-       while(pages) {
-               order = page_alloc_free_from_virtual((u64) virtual);
-               size = (1 << order);
+    while (pages) {
+        order = page_alloc_free_from_virtual((u64) virtual);
+        size = (1 << order);
 
-               pages -= size;
-               virtual = (void *) ((u64) virtual + (pages << PAGE_SHIFT));
-       }
+        pages -= size;
+        virtual = (void *)((u64) virtual + (pages << PAGE_SHIFT));
+    }
 }
 
-
 void *page_vmalloc(u32 pages)
 {
-       void *virtual;
-       u32 allocd_pages = 0;
-       u32 size;
-       int i;
+    void *virtual;
+    u32 allocd_pages = 0;
+    u32 size;
+    int i;
 
-       virtual = vsalloc("page vmalloc", 0, (pages << PAGE_SHIFT));
+    virtual = vsalloc("page vmalloc", 0, (pages << PAGE_SHIFT));
 
-       if (virtual == NULL)
-               return NULL;
+    if (virtual == NULL)
+        return NULL;
 
-       for (i = MAX_ORDER; pages; i--) {
-               size = (1 << i);
-               while (pages >= size) {
-                       if(page_alloc_to_virtual((u64) virtual, i) == NULL)
-                               goto undo;
+    for (i = MAX_ORDER; pages; i--) {
+        size = (1 << i);
+        while (pages >= size) {
+            if (page_alloc_to_virtual((u64) virtual, i) == NULL)
+                goto undo;
 
-                       virtual = (void *) ((u64) virtual + (size << PAGE_SHIFT));
-                       pages -= size;
-                       allocd_pages += size;
-               }
-       }
+            virtual = (void *)((u64) virtual + (size << PAGE_SHIFT));
+            pages -= size;
+            allocd_pages += size;
+        }
+    }
 
-       return virtual;
+    return virtual;
 
-undo:
-       page_vmalloc_free(virtual, allocd_pages);
+ undo:
+    page_vmalloc_free(virtual, allocd_pages);
 
-       return NULL;
+    return NULL;
 }
 
 void *page_vrealloc(void *virtual, u32 cur_pages, u32 want_pages)
 {
-       void *new_alloc = page_vmalloc(want_pages);
+    void *new_alloc = page_vmalloc(want_pages);
 
-       if(!new_alloc)
-               return NULL;
+    if (!new_alloc)
+        return NULL;
 
-       if(virtual) {
-               memcpy(new_alloc, virtual, cur_pages << PAGE_SHIFT);
-               page_vmalloc_free(virtual, cur_pages);
-       }
+    if (virtual) {
+        memcpy(new_alloc, virtual, cur_pages << PAGE_SHIFT);
+        page_vmalloc_free(virtual, cur_pages);
+    }
 
-       return new_alloc;
+    return new_alloc;
 }
 
 /* INIT STUFF BEYOND THIS POINT */
@@ -424,25 +423,25 @@ void *page_vrealloc(void *virtual, u32 cur_pages, u32 want_pages)
 
 static void __init_free_region(u64 address, u64 pages)
 {
-       struct page_block *new;
-       u32 order, size;
+    struct page_block *new;
+    u32 order, size;
 
-       for(order = MAX_ORDER; pages ; order--) {
+    for (order = MAX_ORDER; pages; order--) {
 
-               // size in pages
-               size = 1 << order;
+        // size in pages
+        size = 1 << order;
 
-               while(pages >= size) {
-                       new = __pop_unused_page_block();
+        while (pages >= size) {
+            new = __pop_unused_page_block();
 
-                       new->address = address;
-                       new->next = NULL;
-                       __page_list_add(&free_pages[order], new);
+            new->address = address;
+            new->next = NULL;
+            __page_list_add(&free_pages[order], new);
 
-                       address += (size << PAGE_SHIFT);
-                       pages -= size;
-               }
-       }
+            address += (size << PAGE_SHIFT);
+            pages -= size;
+        }
+    }
 }
 
 /* After unused_page_blocks has been properly converted to a virtual pointer,
@@ -452,11 +451,11 @@ static void __init_free_region(u64 address, u64 pages)
 
 static void __init_unused_page_blocks(u64 max_page_blocks)
 {
-       int i;
+    int i;
 
-       for(i=0;i < (max_page_blocks - 1); i++)
-               unused_page_blocks[i].next = &unused_page_blocks[i + 1];
-       unused_page_blocks[i].next = NULL;
+    for (i = 0; i < (max_page_blocks - 1); i++)
+        unused_page_blocks[i].next = &unused_page_blocks[i + 1];
+    unused_page_blocks[i].next = NULL;
 }
 
 /* Determine how many extra pages of page structures we'll need for an
@@ -469,24 +468,24 @@ static void __init_unused_page_blocks(u64 max_page_blocks)
 
 static u32 __overhead_pages(u64 start, u64 num_pages)
 {
-       u64 pdp_pages, pd_pages, pt_pages;
-       u64 end = start + (num_pages * PAGE_SIZE);
+    u64 pdp_pages, pd_pages, pt_pages;
+    u64 end = start + (num_pages * PAGE_SIZE);
 
-       pdp_pages = PML4E(end) - PML4E(start);
+    pdp_pages = PML4E(end) - PML4E(start);
 
-       if (pdp_pages) {
-               pd_pages = (512 - PDPE(start)) + PDPE(end);
-           pd_pages += (pdp_pages - 1) * 512;
-       } else
-               pd_pages = PDPE(end) - PDPE(start);
+    if (pdp_pages) {
+        pd_pages = (512 - PDPE(start)) + PDPE(end);
+        pd_pages += (pdp_pages - 1) * 512;
+    } else
+        pd_pages = PDPE(end) - PDPE(start);
 
-       if (pd_pages) {
-               pt_pages = (512 - PDE(start)) + PDE(end);
-               pt_pages += (pd_pages - 1) * 512;
-       } else
-               pt_pages = PDE(end) - PDE(start);
+    if (pd_pages) {
+        pt_pages = (512 - PDE(start)) + PDE(end);
+        pt_pages += (pd_pages - 1) * 512;
+    } else
+        pt_pages = PDE(end) - PDE(start);
 
-       return (pdp_pages + pd_pages + pt_pages);
+    return (pdp_pages + pd_pages + pt_pages);
 }
 
 /* Remove pages from the free list, without adding them to the used list, so
@@ -497,90 +496,91 @@ static u32 __overhead_pages(u64 start, u64 num_pages)
 
 static void __reserve_region(u64 address, u64 pages)
 {
-       struct page_block *cur = NULL;
-       struct page_block *prev;
-       u64 last_pages;
+    struct page_block *cur = NULL;
+    struct page_block *prev;
+    u64 last_pages;
 
-       if(PAGE_ALIGN_OFF(address))
-               pages++;
+    if (PAGE_ALIGN_OFF(address))
+        pages++;
 
-       address = PAGE_ALIGN(address);
+    address = PAGE_ALIGN(address);
 
-       int order, size_pages, size, num_free;
+    int order, size_pages, size, num_free;
 
-       while (pages > 0) {
-               last_pages = pages;
-               for(order = MAX_ORDER; order >= 0; order--) {
-                       size_pages = 1 << order;
-                       size = size_pages << PAGE_SHIFT;
+    while (pages > 0) {
+        last_pages = pages;
+        for (order = MAX_ORDER; order >= 0; order--) {
+            size_pages = 1 << order;
+            size = size_pages << PAGE_SHIFT;
 
-                       /* First, find the free block that contains address. */
+            /* First, find the free block that contains address. */
 
-                       prev = NULL;
-                       for (cur = free_pages[order]; cur; prev = cur, cur = cur->next) {
-                               if (cur->address <= address && (cur->address + size) > address)
-                                       break;
-                               if (cur->address > address) {
-                                       cur = NULL;
-                                       break;
-                               }
-                       }
+            prev = NULL;
+            for (cur = free_pages[order]; cur; prev = cur, cur = cur->next) {
+                if (cur->address <= address && (cur->address + size) > address)
+                    break;
+                if (cur->address > address) {
+                    cur = NULL;
+                    break;
+                }
+            }
 
-                       /* Didn't find relevant chunk */
-                       if(!cur)
-                               continue;
+            /* Didn't find relevant chunk */
+            if (!cur)
+                continue;
 
-                       /* Okay, we've found the block, let's break it up */
+            /* Okay, we've found the block, let's break it up */
 
-                       /* First, patch it out of the current order list */
+            /* First, patch it out of the current order list */
 
-                       __setprev(&free_pages[order], prev, cur->next);
-                       cur->next = NULL;
+            __setprev(&free_pages[order], prev, cur->next);
+            cur->next = NULL;
 
-                       /* If our address is somewhere inside the block, free
-                        * all of the memory before it and shrink sizes.
-                        */
+            /* If our address is somewhere inside the block, free
+             * all of the memory before it and shrink sizes.
+             */
 
-                       if (address != cur->address) {
-                               num_free = (address - cur->address) >> PAGE_SHIFT;
-                               __init_free_region(cur->address, num_free);
+            if (address != cur->address) {
+                num_free = (address - cur->address) >> PAGE_SHIFT;
+                __init_free_region(cur->address, num_free);
 
-                               size_pages -= num_free;
-                               size = (size_pages << PAGE_SHIFT);
-                       }
+                size_pages -= num_free;
+                size = (size_pages << PAGE_SHIFT);
+            }
 
-                       /* If the remaining block is bigger or equal to what we're freeing,
-                        * then just discard this page_block and start again with the
-                        * remaining free block */
+            /* If the remaining block is bigger or equal to what we're freeing,
+             * then just discard this page_block and start again with the
+             * remaining free block */
 
-                       if ( pages >= size_pages) {
-                               __push_unused_page_block(cur);
-                               pages -= size_pages;
-                               address += size;
-                               break;
-                       }
+            if (pages >= size_pages) {
+                __push_unused_page_block(cur);
+                pages -= size_pages;
+                address += size;
+                break;
+            }
 
-                       /* Otherwise, we know we have pages at the end to free as well */
+            /* Otherwise, we know we have pages at the end to free as well */
 
-                       __init_free_region(address + (pages << PAGE_SHIFT), size_pages - pages);
+            __init_free_region(address + (pages << PAGE_SHIFT),
+                               size_pages - pages);
 
-                       /* Finally, discard cur */
+            /* Finally, discard cur */
 
-                       __push_unused_page_block(cur);
-                       return;
-               }
+            __push_unused_page_block(cur);
+            return;
+        }
 
-               /* If we searched everywhere for this address but didn't find it,
-                * then go ahead and advance. This can happen when you have overlapping
-                * reserves. For example, trying to reserve GRUB info that's already
-                * been reserved in the mmap.
-                */
+        /* If we searched everywhere for this address but didn't find it,
+         * then go ahead and advance. This can happen when you have overlapping
+         * reserves. For example, trying to reserve GRUB info that's already
+         * been reserved in the mmap.
+         */
 
-               if (last_pages == pages) {
-                       pages--;
-                       address += PAGE_SIZE;
-               }
-       }
+        if (last_pages == pages) {
+            pages--;
+            address += PAGE_SIZE;
+        }
+    }
 }
 
 /* Given physical grub info address, and physical end of head.asm allocated
@@ -592,358 +592,361 @@ static struct grub_mmap *mmap = NULL;
 
 int page_alloc_init(struct grub_info *info_phys, u64 end_structures)
 {
-       u64 max_phys_address, max_pages, page_block_pages;
-       u64 base, length, end;
-       u64 alloc_address, alloc_size, free_pages_address;
-       u64 virtual, physical;
-
-       u64 kernel_size, stack_size;
+    u64 max_phys_address, max_pages, page_block_pages;
+    u64 base, length, end;
+    u64 alloc_address, alloc_size, free_pages_address;
+    u64 virtual, physical;
 
-       struct grub_mmap *cur;
-       u32 overhead, i;
+    u64 kernel_size, stack_size;
 
-       /* Map will increase end_structures if it has to map additional structures,
-        * but it shouldn't have to */
+    struct grub_mmap *cur;
+    u32 overhead, i;
 
-       info = (struct grub_info *)
-               map_page_early(VIRT_BASE | ((long) info_phys), (long) info_phys, &end_structures);
+    /* Map will increase end_structures if it has to map additional structures,
+     * but it shouldn't have to */
 
-       /* Make sure GRUB was able to create a memory map */
+    info = (struct grub_info *)
+        map_page_early(VIRT_BASE | ((long)info_phys), (long)info_phys,
+                       &end_structures);
 
-       if (!(info->flags & GF_MMAP_PRESENT)) {
-               return -1;
-       }
+    /* Make sure GRUB was able to create a memory map */
 
-       /* This is likely the same set as above, but map to be sure. This also
-        * relies on the fact that __map_one will return an unaligned virtual
-        * address
-        */
+    if (!(info->flags & GF_MMAP_PRESENT)) {
+        return -1;
+    }
 
-       mmap = (struct grub_mmap *)
-               map_page_early(VIRT_BASE | ((long) info->mmap_addr), (long) info->mmap_addr, &end_structures);
+    /* This is likely the same set as above, but map to be sure. This also
+     * relies on the fact that __map_one will return an unaligned virtual
+     * address
+     */
 
-       /* For some reason the grub memmap size field doesn't include
-        * the size field itself, so we add 4.
-        */
+    mmap = (struct grub_mmap *)
+        map_page_early(VIRT_BASE | ((long)info->mmap_addr),
+                       (long)info->mmap_addr, &end_structures);
 
-       max_phys_address = 0;
-       for (i = 0; i < info->mmap_length; i += cur->size + 4) {
-               cur = (struct grub_mmap *) (((long) mmap) + i);
-               end = cur->base + cur->length;
+    /* For some reason the grub memmap size field doesn't include
+     * the size field itself, so we add 4.
+     */
 
-               if ((cur->type == 1) && (end > max_phys_address))
-                       max_phys_address = end;
+    max_phys_address = 0;
+    for (i = 0; i < info->mmap_length; i += cur->size + 4) {
+        cur = (struct grub_mmap *)(((long)mmap) + i);
+        end = cur->base + cur->length;
 
-               total_mem += cur->length;
-       }
+        if ((cur->type == 1) && (end > max_phys_address))
+            max_phys_address = end;
 
-       /* max_page_blocks describes how many page_block structs we'd have if the
-        * entirety of physical memory was allocated in 4k chunks (maximum
-        * fragmentation).
-        */
+        total_mem += cur->length;
+    }
 
-       max_pages = max_phys_address >> PAGE_SHIFT;
+    /* max_page_blocks describes how many page_block structs we'd have if the
+     * entirety of physical memory was allocated in 4k chunks (maximum
+     * fragmentation).
+     */
 
-       /* page_block_pages describes how many pages we need to reserve if we are
-        * going to store max_page_blocks.
-        */
+    max_pages = max_phys_address >> PAGE_SHIFT;
 
-       page_block_pages = ((max_pages * sizeof(struct page_block)) >> PAGE_SHIFT) + 1;
+    /* page_block_pages describes how many pages we need to reserve if we are
+     * going to store max_page_blocks.
+     */
 
-       /* Search the mmap for a chunk of contiguous memory that we can use */
+    page_block_pages =
+        ((max_pages * sizeof(struct page_block)) >> PAGE_SHIFT) + 1;
 
-       /* Because there should be a large chunk of free memory >1M this should
-        * never fail in practice, but if it does, we're fucked
-        */
+    /* Search the mmap for a chunk of contiguous memory that we can use */
 
-       alloc_address = MAXLONG;
-       stack_size = STACK_PAGES << PAGE_SHIFT;
+    /* Because there should be a large chunk of free memory >1M this should
+     * never fail in practice, but if it does, we're fucked
+     */
 
-       for (i = 0; i < info->mmap_length; i += cur->size + 4) {
-               cur = (struct grub_mmap *) (((long) mmap) + i);
-               end = cur->base + cur->length;
+    alloc_address = MAXLONG;
+    stack_size = STACK_PAGES << PAGE_SHIFT;
 
-               /* We don't care about reserved memory */
+    for (i = 0; i < info->mmap_length; i += cur->size + 4) {
+        cur = (struct grub_mmap *)(((long)mmap) + i);
+        end = cur->base + cur->length;
 
-               if (cur->type != 1)
-                       continue;
+        /* We don't care about reserved memory */
 
-               /* If this is the block our binary is in, then adjust its
-                * base and length to avoid the binary and the page structures
-                * we allocated immediately afterward.
-                */
+        if (cur->type != 1)
+            continue;
 
-               /* Assume that GRUB put us in a contiguous block of memory
-                * that started before or at KERNEL_START and ended after
-                * our page structures. If this isn't true then we shouldn't
-                * have gotten this far.
-                */
+        /* If this is the block our binary is in, then adjust its
+         * base and length to avoid the binary and the page structures
+         * we allocated immediately afterward.
+         */
 
-               if (cur->base <= KERNEL_START && (end >= end_structures)) {
-                       base = end_structures;
-                       length = end - base;
-               }
-               else if (cur->base <= STACK_PAGES_PHYS &&
-                               (end >= (STACK_PAGES_PHYS + stack_size))) {
-                       base = STACK_PAGES_PHYS + stack_size;
-                       length = end - base;
-               }
-               else {
-                       base = cur->base;
-                       length = cur->length;
-               }
+        /* Assume that GRUB put us in a contiguous block of memory
+         * that started before or at KERNEL_START and ended after
+         * our page structures. If this isn't true then we shouldn't
+         * have gotten this far.
+         */
 
-               /* Round up to page size, adjust length accordingly */
-               length -= PAGE_ALIGN_OFF(base);
-               base = PAGE_ALIGN(base);
+        if (cur->base <= KERNEL_START && (end >= end_structures)) {
+            base = end_structures;
+            length = end - base;
+        } else if (cur->base <= STACK_PAGES_PHYS &&
+                   (end >= (STACK_PAGES_PHYS + stack_size))) {
+            base = STACK_PAGES_PHYS + stack_size;
+            length = end - base;
+        } else {
+            base = cur->base;
+            length = cur->length;
+        }
 
-               /* If we allocated at this address, find out how many page structure
-                * pages we'd need to add to get it all allocated*/
+        /* Round up to page size, adjust length accordingly */
+        length -= PAGE_ALIGN_OFF(base);
+        base = PAGE_ALIGN(base);
 
-               overhead = __overhead_pages(base, page_block_pages);
-               alloc_size = ((page_block_pages + overhead) * PAGE_SIZE);
+        /* If we allocated at this address, find out how many page structure
+         * pages we'd need to add to get it all allocated*/
 
-               /* Too short, skip to the next block*/
-               if (length < alloc_size)
-                       continue;
+        overhead = __overhead_pages(base, page_block_pages);
+        alloc_size = ((page_block_pages + overhead) * PAGE_SIZE);
 
-               /* We're page-aligned, non clobbering and large enough, done! */
-               alloc_address = base;
-               break;
-       }
+        /* Too short, skip to the next block */
+        if (length < alloc_size)
+            continue;
 
-       /* We couldn't find a large enough block, we're fucked. */
+        /* We're page-aligned, non clobbering and large enough, done! */
+        alloc_address = base;
+        break;
+    }
 
-       if(alloc_address == MAXLONG)
-               return -1;
+    /* We couldn't find a large enough block, we're fucked. */
 
-       /* big_alloc is now a physical pointer to a contiguous piece of
-        * memory that can hold enough page_block structs to control all of our
-        * pages at maximum fragmentation, as well as the page structures needed to
-        * map them
-        *
-        * We also know we need `overhead` pages of structures (at most).
-        */
+    if (alloc_address == MAXLONG)
+        return -1;
 
-       unused_page_blocks = (struct page_block *) (alloc_address + (overhead << PAGE_SHIFT));
+    /* big_alloc is now a physical pointer to a contiguous piece of
+     * memory that can hold enough page_block structs to control all of our
+     * pages at maximum fragmentation, as well as the page structures needed to
+     * map them
+     *
+     * We also know we need `overhead` pages of structures (at most).
+     */
 
+    unused_page_blocks =
+        (struct page_block *)(alloc_address + (overhead << PAGE_SHIFT));
 
-       free_pages_address = alloc_address;
+    free_pages_address = alloc_address;
 
-       physical = (u64) unused_page_blocks;
-       virtual = (VIRT_BASE | physical);
+    physical = (u64) unused_page_blocks;
+    virtual = (VIRT_BASE | physical);
 
-       for (i = 0; i < page_block_pages; i++) {
-               map_page_early(virtual, physical, &free_pages_address);
-               __clear_page((u64 *) virtual);
-               physical += PAGE_SIZE;
-               virtual += PAGE_SIZE;
-       }
+    for (i = 0; i < page_block_pages; i++) {
+        map_page_early(virtual, physical, &free_pages_address);
+        __clear_page((u64 *) virtual);
+        physical += PAGE_SIZE;
+        virtual += PAGE_SIZE;
+    }
 
-       /* Convert to a virtual pointer */
-       unused_page_blocks = (struct page_block *) (VIRT_BASE | ((long) unused_page_blocks));
+    /* Convert to a virtual pointer */
+    unused_page_blocks =
+        (struct page_block *)(VIRT_BASE | ((long)unused_page_blocks));
 
-       __init_unused_page_blocks(max_pages);
+    __init_unused_page_blocks(max_pages);
 
-       test_page_alloc(max_pages);
+    test_page_alloc(max_pages);
 
-       /* Now put that reserved memory to use */
-       __init_free_region(0, max_pages);
+    /* Now put that reserved memory to use */
+    __init_free_region(0, max_pages);
 
-       /* Now iterate once more on the memmap and alloc all the unavailable pages */
+    /* Now iterate once more on the memmap and alloc all the unavailable pages */
 
-       for (i = 0; i < info->mmap_length; i += cur->size + 4) {
-               cur = (struct grub_mmap *) (((long) mmap) + i);
+    for (i = 0; i < info->mmap_length; i += cur->size + 4) {
+        cur = (struct grub_mmap *)(((long)mmap) + i);
 
-               if (cur->type == 1)
-                       continue;
+        if (cur->type == 1)
+            continue;
 
-               /* Partial pages are useless to us, so -expand- bad sections by
-                * page aligning base and rounding the length up to a multiple
-                * of page size
-                */
+        /* Partial pages are useless to us, so -expand- bad sections by
+         * page aligning base and rounding the length up to a multiple
+         * of page size
+         */
 
-               base = PAGE_ALIGN(cur->base);
-               length = cur->length + PAGE_ALIGN_OFF(cur->base);
-               if(!PAGE_ALIGNED(length))
-                       length = PAGE_ALIGN(length) + PAGE_SIZE;
+        base = PAGE_ALIGN(cur->base);
+        length = cur->length + PAGE_ALIGN_OFF(cur->base);
+        if (!PAGE_ALIGNED(length))
+            length = PAGE_ALIGN(length) + PAGE_SIZE;
 
-               /* Mark the physical addresses as allocated */
+        /* Mark the physical addresses as allocated */
 
-               __reserve_region(base, length >> PAGE_SHIFT);
-       }
+        __reserve_region(base, length >> PAGE_SHIFT);
+    }
 
-       /* Finally, mark our own pages as allocated */
+    /* Finally, mark our own pages as allocated */
 
-       kernel_size = (end_structures - KERNEL_START);
-       stack_size = (STACK_PAGES << PAGE_SHIFT);
+    kernel_size = (end_structures - KERNEL_START);
+    stack_size = (STACK_PAGES << PAGE_SHIFT);
 
-       __reserve_region((u64) info_phys, 1);
-       __reserve_region(info->mmap_addr, 1);
-       __reserve_region(STACK_PAGES_PHYS, STACK_PAGES);
-       __reserve_region(KERNEL_START, kernel_size >> PAGE_SHIFT);
-       __reserve_region(alloc_address, alloc_size >> PAGE_SHIFT);
+    __reserve_region((u64) info_phys, 1);
+    __reserve_region(info->mmap_addr, 1);
+    __reserve_region(STACK_PAGES_PHYS, STACK_PAGES);
+    __reserve_region(KERNEL_START, kernel_size >> PAGE_SHIFT);
+    __reserve_region(alloc_address, alloc_size >> PAGE_SHIFT);
 
-       /* page_alloc_to_virtual has to be working before now */
+    /* page_alloc_to_virtual has to be working before now */
 
-       /* potentially test domain code before we start relying on vsalloc */
+    /* potentially test domain code before we start relying on vsalloc */
 
-       test_domain();
+    test_domain();
 
-       vsalloc_init();
+    vsalloc_init();
 
-       return 0;
+    return 0;
 }
 
 #ifdef TEST_PAGE_ALLOC
-static inline void test_orders(struct page_block **head, u64 *orders)
+static inline void test_orders(struct page_block **head, u64 * orders)
 {
-       struct page_block *block;
-       int counter = 0;
-       int i = 0;
+    struct page_block *block;
+    int counter = 0;
+    int i = 0;
 
-       for(i = 0; i <= MAX_ORDER; i++) {
-               counter = 0;
-               for (block = head[i]; block; block = block->next)
-                       counter++;
+    for (i = 0; i <= MAX_ORDER; i++) {
+        counter = 0;
+        for (block = head[i]; block; block = block->next)
+            counter++;
 
-               if (counter != orders[i])
-                       while(1);
-       }
+        if (counter != orders[i])
+            while (1) ;
+    }
 
 }
 
-static inline void test_order_index(struct page_block *block, u32 index, u64 address, u32 nextnull)
+static inline void test_order_index(struct page_block *block, u32 index,
+                                    u64 address, u32 nextnull)
 {
-       int i;
+    int i;
 
-       for (i = 0; i < index; i++)
-               block = block->next;
+    for (i = 0; i < index; i++)
+        block = block->next;
 
-       if(block->address != address)
-               while(1);
-       if(nextnull && block->next)
-               while(1);
-       if(!nextnull && !block->next)
-               while(1);
+    if (block->address != address)
+        while (1) ;
+    if (nextnull && block->next)
+        while (1) ;
+    if (!nextnull && !block->next)
+        while (1) ;
 }
 
 static void test_page_alloc(u64 max_pages)
 {
-       struct page_block *upb_bak = unused_page_blocks;
-       int i;
+    struct page_block *upb_bak = unused_page_blocks;
+    int i;
 
-       u64 free_orders[MAX_ORDER + 1] = { 0 };
-       u64 used_orders[MAX_ORDER + 1] = { 0 };
+    u64 free_orders[MAX_ORDER + 1] = { 0 };
+    u64 used_orders[MAX_ORDER + 1] = { 0 };
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       /* Alloc 1GB of memory */
+    /* Alloc 1GB of memory */
 
-       __init_free_region(0, (1 * 1024 * 1024 * 1024) >> PAGE_SHIFT);
+    __init_free_region(0, (1 * 1024 * 1024 * 1024) >> PAGE_SHIFT);
 
-       /* Should create 128 blocks of 8M */
-       /* No allocations, obviously */
+    /* Should create 128 blocks of 8M */
+    /* No allocations, obviously */
 
-       free_orders[MAX_ORDER] = 128;
+    free_orders[MAX_ORDER] = 128;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       test_order_index(free_pages[MAX_ORDER], 0, 0, 0);
-       test_order_index(free_pages[MAX_ORDER], 1, 0x800000, 0);
-       test_order_index(free_pages[MAX_ORDER], 2, 0x1000000, 0);
+    test_order_index(free_pages[MAX_ORDER], 0, 0, 0);
+    test_order_index(free_pages[MAX_ORDER], 1, 0x800000, 0);
+    test_order_index(free_pages[MAX_ORDER], 2, 0x1000000, 0);
 
-       /* Reserve 0 - 4M, should split 1 8M block in 2 4M */
-       /* reserve_region won't record it on used_pages */
+    /* Reserve 0 - 4M, should split 1 8M block in 2 4M */
+    /* reserve_region won't record it on used_pages */
 
-       __reserve_region(0, 0x400);
+    __reserve_region(0, 0x400);
 
-       free_orders[MAX_ORDER] = 127;
-       free_orders[MAX_ORDER - 1] = 1;
+    free_orders[MAX_ORDER] = 127;
+    free_orders[MAX_ORDER - 1] = 1;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       test_order_index(free_pages[MAX_ORDER], 0, 0x800000, 0);
-       test_order_index(free_pages[MAX_ORDER], 1, 0x1000000, 0);
-       test_order_index(free_pages[MAX_ORDER - 1], 0, 0x400000, 1);
+    test_order_index(free_pages[MAX_ORDER], 0, 0x800000, 0);
+    test_order_index(free_pages[MAX_ORDER], 1, 0x1000000, 0);
+    test_order_index(free_pages[MAX_ORDER - 1], 0, 0x400000, 1);
 
-       /* Reserve 12M - 13M, should split the 8M - 16M
-        * block into 1 more 4M, 1 1M, and 1 2M block */
+    /* Reserve 12M - 13M, should split the 8M - 16M
+     * block into 1 more 4M, 1 1M, and 1 2M block */
 
-       __reserve_region(0xc00000, 0x100);
+    __reserve_region(0xc00000, 0x100);
 
-       free_orders[MAX_ORDER] = 126;
-       free_orders[MAX_ORDER - 1] = 2;
-       free_orders[MAX_ORDER - 2] = 1;
-       free_orders[MAX_ORDER - 3] = 1;
+    free_orders[MAX_ORDER] = 126;
+    free_orders[MAX_ORDER - 1] = 2;
+    free_orders[MAX_ORDER - 2] = 1;
+    free_orders[MAX_ORDER - 3] = 1;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       test_order_index(free_pages[MAX_ORDER], 0, 0x1000000, 0);
-       test_order_index(free_pages[MAX_ORDER], 1, 0x1800000, 0);
-       test_order_index(free_pages[MAX_ORDER - 1], 0, 0x400000, 0);
-       test_order_index(free_pages[MAX_ORDER - 1], 1, 0x800000, 1);
+    test_order_index(free_pages[MAX_ORDER], 0, 0x1000000, 0);
+    test_order_index(free_pages[MAX_ORDER], 1, 0x1800000, 0);
+    test_order_index(free_pages[MAX_ORDER - 1], 0, 0x400000, 0);
+    test_order_index(free_pages[MAX_ORDER - 1], 1, 0x800000, 1);
 
-       /* Now using page_alloc_phys should return the first two already
-        * split blocks
-        */
+    /* Now using page_alloc_phys should return the first two already
+     * split blocks
+     */
 
-       if(page_alloc_phys(MAX_ORDER - 1) != 0x400000)
-               while(1);
+    if (page_alloc_phys(MAX_ORDER - 1) != 0x400000)
+        while (1) ;
 
-       if(page_alloc_phys(MAX_ORDER - 1) != 0x800000)
-               while(1);
+    if (page_alloc_phys(MAX_ORDER - 1) != 0x800000)
+        while (1) ;
 
-       free_orders[MAX_ORDER - 1] = 0;
-       used_orders[MAX_ORDER - 1] = 2;
+    free_orders[MAX_ORDER - 1] = 0;
+    used_orders[MAX_ORDER - 1] = 2;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       /* A third 4M alloc should split an 8M block and return its
-        * lower address
-        */
+    /* A third 4M alloc should split an 8M block and return its
+     * lower address
+     */
 
-       if(page_alloc_phys(MAX_ORDER - 1) != 0x1000000)
-               while(1);
+    if (page_alloc_phys(MAX_ORDER - 1) != 0x1000000)
+        while (1) ;
 
-       free_orders[MAX_ORDER] -= 1;
-       free_orders[MAX_ORDER - 1] = 1;
+    free_orders[MAX_ORDER] -= 1;
+    free_orders[MAX_ORDER - 1] = 1;
 
-       used_orders[MAX_ORDER - 1] = 3;
+    used_orders[MAX_ORDER - 1] = 3;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       test_order_index(free_pages[MAX_ORDER], 0, 0x1800000, 0);
-       test_order_index(free_pages[MAX_ORDER - 1], 0, 0x1400000, 1);
+    test_order_index(free_pages[MAX_ORDER], 0, 0x1800000, 0);
+    test_order_index(free_pages[MAX_ORDER - 1], 0, 0x1400000, 1);
 
-       /* Now a free should properly reconstitute the 8M block */
+    /* Now a free should properly reconstitute the 8M block */
 
-       page_alloc_free_phys(0x1000000);
+    page_alloc_free_phys(0x1000000);
 
-       free_orders[MAX_ORDER] += 1;
-       free_orders[MAX_ORDER - 1] = 0;
+    free_orders[MAX_ORDER] += 1;
+    free_orders[MAX_ORDER - 1] = 0;
 
-       used_orders[MAX_ORDER - 1] = 2;
+    used_orders[MAX_ORDER - 1] = 2;
 
-       test_orders(free_pages, free_orders);
-       test_orders(used_pages, used_orders);
+    test_orders(free_pages, free_orders);
+    test_orders(used_pages, used_orders);
 
-       test_order_index(free_pages[MAX_ORDER], 0, 0x1000000, 0);
+    test_order_index(free_pages[MAX_ORDER], 0, 0x1000000, 0);
 
-       /* We're done, now reset our structures */
+    /* We're done, now reset our structures */
 
-       unused_page_blocks = upb_bak;
-       __init_unused_page_blocks(max_pages);
+    unused_page_blocks = upb_bak;
+    __init_unused_page_blocks(max_pages);
 
-       for (i = 0; i <= MAX_ORDER; i++) {
-               free_pages[i] = NULL;
-               used_pages[i] = NULL;
-       }
+    for (i = 0; i <= MAX_ORDER; i++) {
+        free_pages[i] = NULL;
+        used_pages[i] = NULL;
+    }
 }
 #endif
index 7adc1f3..9fddca3 100644 (file)
@@ -1,4 +1,4 @@
-/* vim: set ts=4 sw=4 sts=4 noet : */
+/* vim: set ts=4 sw=4 sts=4 et : */
 
 /* Virtual address space allocator */
 
@@ -10,25 +10,25 @@ static struct domain vs_domain = DOMAIN(KERNEL_VIRT_END, 0xFFFFFFFFFFFFFFFF);
 
 void *vsalloc(char *name, u64 address_hint, u64 size)
 {
-       struct domain_block *ret;
+    struct domain_block *ret;
 
-       if (address_hint == 0)
-               address_hint = KERNEL_VIRT_END;
+    if (address_hint == 0)
+        address_hint = KERNEL_VIRT_END;
 
-       ret = domain_alloc_near(&vs_domain, address_hint, size, name);
+    ret = domain_alloc_near(&vs_domain, address_hint, size, name);
 
-       if(ret)
-               return (void *) ret->address;
-       return NULL;
+    if (ret)
+        return (void *)ret->address;
+    return NULL;
 }
 
 void vfree(void *address)
 {
-       domain_free(&vs_domain, (u64) address);
+    domain_free(&vs_domain, (u64) address);
 }
 
 void vsalloc_init(void)
 {
-       /* pre-initing blocks keeps the domain call from calling us */
-       vs_domain.blocks = (void *) VSALLOC_HEAP_VIRTUAL;
+    /* pre-initing blocks keeps the domain call from calling us */
+    vs_domain.blocks = (void *)VSALLOC_HEAP_VIRTUAL;
 }