WebSVN – HelenOS – Path Comparison – / – /branches/rcu/kernel/arch/ Rev 2306 and /branches/rcu/kernel/arch/ Rev 2307

Ignore whitespace Rev 2306 → Rev 2307

/branches/rcu/kernel/arch/sparc64/include/types.h
62,6 → 62,7
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/sparc64/include/trap/mmu.h
 ,7 → 129,21
     wrpr %g0, 1, %tl
 .endif
+    /*
+     * Switch from the MM globals.
+     */
     wrpr %g0, PSTATE_PRIV_BIT | PSTATE_AG_BIT, %pstate
+    /*
+     * Read the Tag Access register for the higher-level handler.
+     * This is necessary to survive nested DTLB misses.
+     */
+    mov VA_DMMU_TAG_ACCESS, %g2
+    ldxa [%g2] ASI_DMMU, %g2
+    /*
+     * g2 will be passed as an argument to fast_data_access_mmu_miss().
+     */
     PREEMPTIBLE_HANDLER fast_data_access_mmu_miss
 .endm
 ,7 → 156,21
     wrpr %g0, 1, %tl
 .endif
+    /*
+     * Switch from the MM globals.
+     */
     wrpr %g0, PSTATE_PRIV_BIT | PSTATE_AG_BIT, %pstate
+    /*
+     * Read the Tag Access register for the higher-level handler.
+     * This is necessary to survive nested DTLB misses.
+     */
+    mov VA_DMMU_TAG_ACCESS, %g2
+    ldxa [%g2] ASI_DMMU, %g2
+    /*
+     * g2 will be passed as an argument to fast_data_access_mmu_miss().
+     */
     PREEMPTIBLE_HANDLER fast_data_access_protection
 .endm

 /branches/rcu/kernel/arch/sparc64/include/mm/tlb.h
 ,9 → 428,9
     membar();
 }
-extern void fast_instruction_access_mmu_miss(int n, istate_t *istate);
-extern void fast_data_access_mmu_miss(int n, istate_t *istate);
-extern void fast_data_access_protection(int n, istate_t *istate);
+extern void fast_instruction_access_mmu_miss(unative_t unused, istate_t *istate);
+extern void fast_data_access_mmu_miss(tlb_tag_access_reg_t tag, istate_t *istate);
+extern void fast_data_access_protection(tlb_tag_access_reg_t tag , istate_t *istate);
 extern void dtlb_insert_mapping(uintptr_t page, uintptr_t frame, int pagesize, bool locked, bool cacheable);

 /branches/rcu/kernel/arch/sparc64/include/barrier.h
 ,12 → 39,12
  * Our critical section barriers are prepared for the weakest RMO memory model.
  */
 #define CS_ENTER_BARRIER()              \
-    asm volatile (              \
+    asm volatile (                  \
         "membar #LoadLoad | #LoadStore\n"   \
         ::: "memory"                \
     )
 #define CS_LEAVE_BARRIER()              \
-    asm volatile (              \
+    asm volatile (                  \
         "membar #StoreStore\n"          \
         "membar #LoadStore\n"           \
         ::: "memory"                \

 /branches/rcu/kernel/arch/sparc64/src/smp/smp.c
 ,7 → 100,7
         if (waitq_sleep_timeout(&ap_completion_wq, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT)
             printf("%s: waiting for processor (mid = %d) timed out\n",
-                __FUNCTION__, mid);
+                __FUNCTION__, mid);
     }
 }

 /branches/rcu/kernel/arch/sparc64/src/smp/ipi.c
 ,8 → 74,8
         panic("Interrupt Dispatch Status busy bit set\n");
     do {
-        asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_0, (uintptr_t)
-            func);
+        asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_0,
+            (uintptr_t) func);
         asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_1, 0);
         asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_2, 0);
         asi_u64_write(ASI_UDB_INTR_W,

 /branches/rcu/kernel/arch/sparc64/src/asm.S
 ,7 → 273,7
     flushw
     wrpr %g0, 0, %cleanwin      ! avoid information leak
-    mov %i3, %o0            ! uarg
+    mov %i2, %o0            ! uarg
     clr %i2
     clr %i3

 /branches/rcu/kernel/arch/sparc64/src/proc/scheduler.c
 ,9 → 62,8
          * - preemptible trap handler switches to alternate globals
          *   before it explicitly uses %g7.
          */
-        uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE
-            - (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE,
-            STACK_ALIGNMENT));
+        uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
+            (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
         write_to_ig_g6(sp);
         write_to_ag_g6(sp);
         write_to_ag_g7((uintptr_t) THREAD->arch.uspace_window_buffer);

 /branches/rcu/kernel/arch/sparc64/src/proc/thread.c
 ,7 → 55,7
          * belonging to a killed thread.
          */
         frame_free(KA2PA(ALIGN_DOWN((uintptr_t)
-            t->arch.uspace_window_buffer, PAGE_SIZE)));
+            t->arch.uspace_window_buffer, PAGE_SIZE)));
     }
 }
 ,8 → 75,8
          * Mind the possible alignment of the userspace window buffer
          * belonging to a killed thread.
          */
-         t->arch.uspace_window_buffer = (uint8_t *) ALIGN_DOWN(uw_buf,
-            PAGE_SIZE);
+        t->arch.uspace_window_buffer = (uint8_t *) ALIGN_DOWN(uw_buf,
+            PAGE_SIZE);
     }
 }

 /branches/rcu/kernel/arch/sparc64/src/sparc64.c
 ,5 → 155,11
     /* not reached */
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

 /branches/rcu/kernel/arch/sparc64/src/cpu/cpu.c
 ,10 → 63,10
             mid = *((uint32_t *) prop->value);
             if (mid == CPU->arch.mid) {
                 prop = ofw_tree_getprop(node,
-                    "clock-frequency");
+                    "clock-frequency");
                 if (prop && prop->value)
                     clock_frequency = *((uint32_t *)
-                        prop->value);
+                        prop->value);
             }
         }
         node = ofw_tree_find_peer_by_device_type(node, "cpu");

 /branches/rcu/kernel/arch/sparc64/src/mm/tlb.c
 ,7 → 198,7
 }
 /** ITLB miss handler. */
-void fast_instruction_access_mmu_miss(int n, istate_t *istate)
+void fast_instruction_access_mmu_miss(unative_t unused, istate_t *istate)
 {
     uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
     index_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
 ,15 → 234,18
  *
  * Note that some faults (e.g. kernel faults) were already resolved by the
  * low-level, assembly language part of the fast_data_access_mmu_miss handler.
+ *
+ * @param tag Content of the TLB Tag Access register as it existed when the
+ *    trap happened. This is to prevent confusion created by clobbered
+ *    Tag Access register during a nested DTLB miss.
+ * @param istate Interrupted state saved on the stack.
  */
-void fast_data_access_mmu_miss(int n, istate_t *istate)
+void fast_data_access_mmu_miss(tlb_tag_access_reg_t tag, istate_t *istate)
 {
-    tlb_tag_access_reg_t tag;
     uintptr_t va;
     index_t index;
     pte_t *t;
-    tag.value = dtlb_tag_access_read();
     va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     index = tag.vpn % MMU_PAGES_PER_PAGE;
 ,15 → 285,19
     }
 }
-/** DTLB protection fault handler. */
-void fast_data_access_protection(int n, istate_t *istate)
+/** DTLB protection fault handler.
+ *
+ * @param tag Content of the TLB Tag Access register as it existed when the
+ *    trap happened. This is to prevent confusion created by clobbered
+ *    Tag Access register during a nested DTLB miss.
+ * @param istate Interrupted state saved on the stack.
+ */
+void fast_data_access_protection(tlb_tag_access_reg_t tag, istate_t *istate)
 {
-    tlb_tag_access_reg_t tag;
     uintptr_t va;
     index_t index;
     pte_t *t;
-    tag.value = dtlb_tag_access_read();
     va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
 ,9 → 378,10
     uintptr_t va;
     va = tag.vpn << MMU_PAGE_WIDTH;
-    fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
-        tag.context);
+    if (tag.context) {
+        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
+            tag.context);
+    }
     dump_istate(istate);
     printf("Faulting page: %p, ASID=%d\n", va, tag.context);
     panic("%s\n", str);
 ,8 → 394,10
     va = tag.vpn << MMU_PAGE_WIDTH;
-    fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
-        tag.context);
+    if (tag.context) {
+        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
+            tag.context);
+    }
     printf("Faulting page: %p, ASID=%d\n", va, tag.context);
     dump_istate(istate);
     panic("%s\n", str);

/branches/rcu/kernel/arch/sparc64/src/mm/as.c
66,6 → 66,7
*/
int order = fnzb32(((ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) *
sizeof(tsb_entry_t)) >> FRAME_WIDTH);

uintptr_t tsb = (uintptr_t) frame_alloc(order, flags \| FRAME_KA);

if (!tsb)
74,6 → 75,7
as->arch.itsb = (tsb_entry_t *) tsb;
as->arch.dtsb = (tsb_entry_t ) (tsb + ITSB_ENTRY_COUNT
sizeof(tsb_entry_t));

memsetb((uintptr_t) as->arch.itsb,
(ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) * sizeof(tsb_entry_t), 0);
#endif

 /branches/rcu/kernel/arch/sparc64/src/mm/cache.S
 ,8 → 45,10
     subcc %g1, DCACHE_LINE_SIZE, %g1
     bnz,pt %xcc, 0b
     stxa %g0, [%g1] ASI_DCACHE_TAG
+    membar #Sync
     retl
-    membar #Sync
+    ! beware SF Erratum #51, do not put the MEMBAR here
+    nop
 /** Flush only D-cache lines of one virtual color.
  *

 /branches/rcu/kernel/arch/sparc64/src/mm/tsb.c
 ,6 → 61,8
     ASSERT(as->arch.itsb && as->arch.dtsb);
     i0 = (page >> MMU_PAGE_WIDTH) & TSB_INDEX_MASK;
+    ASSERT(i0 < ITSB_ENTRY_COUNT && i0 < DTSB_ENTRY_COUNT);
     if (pages == (count_t) -1 || (pages * 2) > ITSB_ENTRY_COUNT)
         cnt = ITSB_ENTRY_COUNT;
     else
 ,9 → 86,12
     as_t *as;
     tsb_entry_t *tsb;
     index_t entry;
+    ASSERT(index <= 1);
     as = t->as;
     entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
+    ASSERT(entry < ITSB_ENTRY_COUNT);
     tsb = &as->arch.itsb[entry];
     /*
 ,8 → 107,8
     write_barrier();
     tsb->tag.context = as->asid;
-    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
-        VA_TAG_PAGE_SHIFT;
+    /* the shift is bigger than PAGE_WIDTH, do not bother with index  */
+    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
     tsb->data.value = 0;
     tsb->data.size = PAGESIZE_8K;
     tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
 ,8 → 133,11
     tsb_entry_t *tsb;
     index_t entry;
+    ASSERT(index <= 1);
     as = t->as;
     entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
+    ASSERT(entry < DTSB_ENTRY_COUNT);
     tsb = &as->arch.dtsb[entry];
     /*
 ,8 → 153,8
     write_barrier();
     tsb->tag.context = as->asid;
-    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
-        VA_TAG_PAGE_SHIFT;
+    /* the shift is bigger than PAGE_WIDTH, do not bother with index */
+    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
     tsb->data.value = 0;
     tsb->data.size = PAGESIZE_8K;
     tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;

 /branches/rcu/kernel/arch/sparc64/src/mm/frame.c
 ,10 → 65,10
             if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
                 confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
             zone_create(ADDR2PFN(start),
-                SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
-                confdata, 0);
+                SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
+                confdata, 0);
             last_frame = max(last_frame, start + ALIGN_UP(size,
-                FRAME_SIZE));
+                FRAME_SIZE));
         }
         /*

/branches/rcu/kernel/arch/ia64/include/types.h
70,6 → 70,7
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ia64/src/ia64.c
 ,5 → 176,11
 #endif
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

/branches/rcu/kernel/arch/arm32/include/types.h
62,6 → 62,7
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/arm32/src/arm32.c
 ,5 → 82,11
     /* TODO */
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

/branches/rcu/kernel/arch/ppc32/include/types.h
62,6 → 62,7
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ppc32/src/mm/page.c
 ,7 → 53,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/ppc32/src/interrupt.c
 ,11 → 60,19
     int inum;
     while ((inum = pic_get_pending()) != -1) {
+        bool ack = false;
         irq_t *irq = irq_dispatch_and_lock(inum);
         if (irq) {
             /*
              * The IRQ handler was found.
              */
+            if (irq->preack) {
+                /* Acknowledge the interrupt before processing */
+                pic_ack_interrupt(inum);
+                ack = true;
+            }
             irq->handler(irq, irq->arg);
             spinlock_unlock(&irq->lock);
         } else {
 ,7 → 83,9
             printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
         }
-        pic_ack_interrupt(inum);
+        if (!ack)
+            pic_ack_interrupt(inum);
     }
 }

 /branches/rcu/kernel/arch/ppc32/src/drivers/cuda.c
 ,7 → 48,8
 #define PACKET_ADB  0x00
 #define PACKET_CUDA 0x01
-#define CUDA_POWERDOWN 0x0a
+#define CUDA_POWERDOWN  0x0a
+#define CUDA_RESET      0x11
 #define RS 0x200
 #define B (0 * RS)
 ,9 → 192,6
 };
-void send_packet(const uint8_t kind, index_t count, ...);
 static void receive_packet(uint8_t *kind, index_t count, uint8_t data[])
 {
     cuda[B] = cuda[B] & ~TIP;
 ,7 → 314,7
 }
-void send_packet(const uint8_t kind, index_t count, ...)
+static void send_packet(const uint8_t kind, count_t count, ...)
 {
     index_t i;
     va_list va;
 ,13 → 339,17
 void cpu_halt(void) {
-#ifdef CONFIG_POWEROFF
-    send_packet(PACKET_CUDA, 1, CUDA_POWERDOWN);
-#endif
     asm volatile (
         "b 0\n"
     );
 }
+void arch_reboot(void) {
+    send_packet(PACKET_CUDA, 1, CUDA_RESET);
+    asm volatile (
+        "b 0\n"
+    );
+}
 /** @}
  */

/branches/rcu/kernel/arch/ia32xen/include/types.h
62,6 → 62,7
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ia32xen/src/ia32xen.c
 ,5 → 211,11
 {
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

 /branches/rcu/kernel/arch/ia32xen/src/smp/smp.c
 ,13 → 80,13
     if (config.cpu_count > 1) {
         page_mapping_insert(AS_KERNEL, l_apic_address, (uintptr_t) l_apic,
-                  PAGE_NOT_CACHEABLE);
+                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
         page_mapping_insert(AS_KERNEL, io_apic_address, (uintptr_t) io_apic,
-                  PAGE_NOT_CACHEABLE);
+                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
         l_apic = (uint32_t *) l_apic_address;
         io_apic = (uint32_t *) io_apic_address;
-        }
+    }
 }
 /*

 /branches/rcu/kernel/arch/ia32xen/src/interrupt.c
 ,14 → 176,21
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
+    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
+        if (irq->preack) {
+            /* Send EOI before processing the interrupt */
+            trap_virtual_eoi();
+            ack = true;
+        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,7 → 201,9
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    trap_virtual_eoi();
+    if (!ack)
+        trap_virtual_eoi();
 }
 void interrupt_init(void)

/branches/rcu/kernel/arch/amd64/include/types.h
62,6 → 62,7
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/amd64/include/asm.h
 ,10 → 55,17
     return v;
 }
-static inline void cpu_sleep(void) { __asm__ volatile ("hlt\n"); };
-static inline void cpu_halt(void) { __asm__ volatile ("hlt\n"); };
+static inline void cpu_sleep(void)
+{
+    asm volatile ("hlt\n");
+};
+static inline void cpu_halt(void)
+{
+    asm volatile ("hlt\n");
+};
 /** Byte from port
  *
  * Get byte from port

 /branches/rcu/kernel/arch/amd64/src/pm.c
 ,6 → 33,7
 /** @file
  */
+#include <arch.h>
 #include <arch/pm.h>
 #include <arch/asm.h>
 #include <mm/as.h>
 ,5 → 228,24
     tr_load(gdtselector(TSS_DES));
 }
+/* Reboot the machine by initiating
+ * a triple fault
+ */
+void arch_reboot(void)
+{
+    preemption_disable();
+    ipl_t ipl = interrupts_disable();
+    memsetb((uintptr_t) idt, sizeof(idt), 0);
+    idtr_load(&idtr);
+    interrupts_restore(ipl);
+    asm volatile (
+        "int $0x03\n"
+        "cli\n"
+        "hlt\n"
+    );
+}
 /** @}
  */

/branches/rcu/kernel/arch/amd64/src/boot/vga323.pal
0,0 → 1,0
link ../../../ia32/src/boot/vga323.pal

 /branches/rcu/kernel/arch/amd64/src/boot/boot.S
 ,8 → 72,26
     movl %eax, grub_eax                         # save parameters from GRUB
     movl %ebx, grub_ebx
+    # Protected 32-bit. We want to reuse the code-seg descriptor,
+    # the Default operand size must not be 1 when entering long mode
+    movl $0x80000000, %eax
+    cpuid
+    cmp $0x80000000, %eax                       # any function > 80000000h?
+    jbe long_mode_unsupported
+    movl $(AMD_CPUID_EXTENDED), %eax            # Extended function code 80000001
+    cpuid
+    bt $29, %edx                                # Test if long mode is supported.
+    jc long_mode_supported
+    long_mode_unsupported:
+        movl $long_mode_msg, %esi
+        jmp error_halt
+    long_mode_supported:
 #ifdef CONFIG_FB
-    mov $vesa_init, %esi;
+    mov $vesa_init, %esi
     mov $VESA_INIT_SEGMENT << 4, %edi
     mov $e_vesa_init - vesa_init, %ecx
     cld
 ,25 → 110,7
     shr $16, %ebx
     mov %bx, KA2PA(vesa_bpp)
 #endif
-    # Protected 32-bit. We want to reuse the code-seg descriptor,
-    # the Default operand size must not be 1 when entering long mode
-    movl $0x80000000, %eax
-    cpuid
-    cmp $0x80000000, %eax                       # any function > 80000000h?
-    jbe long_mode_unsupported
-    movl $(AMD_CPUID_EXTENDED), %eax            # Extended function code 80000001
-    cpuid
-    bt $29, %edx                                # Test if long mode is supported.
-    jc long_mode_supported
-    long_mode_unsupported:
-        cli
-        hlt
-    long_mode_supported:
     # Enable 64-bit page transaltion entries - CR4.PAE = 1.
     # Paging is not enabled until after long mode is enabled
 ,11 → 303,12
 #define VESA_INFO_SIZE 1024
+#define VESA_MODE_ATTRIBUTES_OFFSET 0
 #define VESA_MODE_LIST_PTR_OFFSET 14
+#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_WIDTH_OFFSET 18
 #define VESA_MODE_HEIGHT_OFFSET 20
 #define VESA_MODE_BPP_OFFSET 25
-#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_PHADDR_OFFSET 40
 #define VESA_END_OF_MODES 0xffff
 ,14 → 318,14
 #define VESA_GET_INFO 0x4f00
 #define VESA_GET_MODE_INFO 0x4f01
 #define VESA_SET_MODE 0x4f02
+#define VESA_SET_PALETTE 0x4f09
 #define CONFIG_VESA_BPP_a 255
 #if CONFIG_VESA_BPP == 24
-#undef CONFIG_VESA_BPP_a
-#define CONFIG_VESA_BPP_a 32
+#define CONFIG_VESA_BPP_VARIANT 32
 #endif
     mov $VESA_GET_INFO, %ax
     mov $e_vesa_init - vesa_init, %di
     push %di
 ,7 → 340,7
     mov VESA_MODE_LIST_PTR_OFFSET(%di), %si
     add $VESA_INFO_SIZE, %di
 :# Try next mode
     mov %gs:(%si), %cx
     cmp $VESA_END_OF_MODES, %cx
 ,10 → 370,13
     mov $CONFIG_VESA_BPP, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
+#ifdef CONFIG_VESA_BPP_VARIANT
     jz 2f
-    mov $CONFIG_VESA_BPP_a, %al
+    mov $CONFIG_VESA_BPP_VARIANT, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
+#endif
     jnz 1b
 :
 ,7 → 390,60
     pop %di
     cmp $VESA_OK, %al
     jnz 0f
+#if CONFIG_VESA_BPP == 8
+    # Set 3:2:3 VGA palette
+    mov VESA_MODE_ATTRIBUTES_OFFSET(%di), %ax
+    push %di
+    mov $vga323 - vesa_init, %di
+    mov $0x100, %ecx
+    bt $5, %ax                          # Test if VGA compatible registers are present
+    jnc vga_compat
+        # Try VESA routine to set palette
+        mov $VESA_SET_PALETTE, %ax
+        xor %bl, %bl
+        xor %dx, %dx
+        int $0x10
+        jmp vga_not_compat
+    vga_compat:
+        # Try VGA registers to set palette
+        movw $0x3c6, %dx                        # Set palette mask
+        movb $0xff, %al
+        outb %al, %dx
+        movw $0x3c8, %dx                        # First index to set
+        xor %al, %al
+        outb %al, %dx
+        movw $0x3c9, %dx                        # Data port
+        vga_loop:
+            movb %es:2(%di), %al
+            outb %al, %dx
+            movb %es:1(%di), %al
+            outb %al, %dx
+            movb %es:(%di), %al
+            outb %al, %dx
+            addw $4, %di
+            loop vga_loop
+    vga_not_compat:
+    pop %di
+#endif
     mov VESA_MODE_PHADDR_OFFSET(%di), %esi
     mov VESA_MODE_WIDTH_OFFSET(%di), %ax
     shl $16, %eax
 ,8 → 484,10
     mov $0xffffffff, %edi       # EGA text mode used, because of problems with VESA
     xor %ax, %ax
     jz 8b                       # Force relative jump
+vga323:
+#include "vga323.pal"
 .code32
 vesa_init_protect:
     movw $gdtselector(KDATA_DES), %cx
 ,11 → 500,73
     movw %cx, %fs
     movw %cx, %gs
+    movl $START_STACK, %esp         # initialize stack pointer
     jmpl $gdtselector(KTEXT32_DES), $vesa_meeting_point
 .align 4
 e_vesa_init:
-#endif
+#endif
+# Print string from %esi to EGA display (in red) and halt
+error_halt:
+    movl $0xb8000, %edi                     # base of EGA text mode memory
+    xorl %eax, %eax
+    movw $0x3d4, %dx                        # read bits 8 - 15 of the cursor address
+    movb $0xe, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    inb %dx, %al
+    shl $8, %ax
+    movw $0x3d4, %dx                        # read bits 0 - 7 of the cursor address
+    movb $0xf, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    inb %dx, %al
+    cmp $1920, %ax
+    jbe cursor_ok
+        movw $1920, %ax                     # sanity check for the cursor on the last line
+    cursor_ok:
+    movw %ax, %bx
+    shl $1, %eax
+    addl %eax, %edi
+    movw $0x0c00, %ax                       # black background, light red foreground
+    cld
+    ploop:
+        lodsb
+        cmp $0, %al
+        je ploop_end
+        stosw
+        inc %bx
+        jmp ploop
+    ploop_end:
+    movw $0x3d4, %dx                        # write bits 8 - 15 of the cursor address
+    movb $0xe, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    movb %bh, %al
+    outb %al, %dx
+    movw $0x3d4, %dx                        # write bits 0 - 7 of the cursor address
+    movb $0xf, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    movb %bl, %al
+    outb %al, %dx
+    cli
+    hlt
 .section K_DATA_START, "aw", @progbits
 .align 4096
 ,3 → 634,6
 grub_ebx:
     .long 0
+long_mode_msg:
+    .asciz "64 bit long mode not supported. System halted."

 /branches/rcu/kernel/arch/amd64/src/mm/page.c
 ,7 → 83,7
 {
     uintptr_t cur;
     int i;
-    int identity_flags = PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL;
+    int identity_flags = PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
     if (config.cpu_active == 1) {
         page_mapping_operations = &pt_mapping_operations;
 ,10 → 112,8
         exc_register(14, "page_fault", (iroutine) page_fault);
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    }
-    else {
+    } else
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    }
 }
 ,7 → 206,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/amd64/src/interrupt.c
 ,14 → 156,21
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
+    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
+        if (irq->preack) {
+            /* Send EOI before processing the interrupt */
+            trap_virtual_eoi();
+            ack = true;
+        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,7 → 181,9
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    trap_virtual_eoi();
+    if (!ack)
+        trap_virtual_eoi();
 }
 void interrupt_init(void)

/branches/rcu/kernel/arch/ppc64/include/types.h
62,6 → 62,7
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ppc64/src/mm/page.c
 ,10 → 264,8
         uintptr_t cur;
         int flags;
-        /* Frames below 128 MB are mapped using BAT,
-           map rest of the physical memory */
         for (cur = 128 << 20; cur < last_frame; cur += FRAME_SIZE) {
-            flags = PAGE_CACHEABLE;
+            flags = PAGE_CACHEABLE | PAGE_WRITE;
             if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
                 flags |= PAGE_GLOBAL;
             page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
 ,7 → 294,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/ppc64/src/interrupt.c
 ,11 → 60,19
     int inum;
     while ((inum = pic_get_pending()) != -1) {
+        bool ack = false;
         irq_t *irq = irq_dispatch_and_lock(inum);
         if (irq) {
             /*
              * The IRQ handler was found.
              */
+            if (irq->preack) {
+                /* Acknowledge the interrupt before processing */
+                pic_ack_interrupt(inum);
+                ack = true;
+            }
             irq->handler(irq, irq->arg);
             spinlock_unlock(&irq->lock);
         } else {
 ,7 → 83,9
             printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
         }
-        pic_ack_interrupt(inum);
+        if (!ack)
+            pic_ack_interrupt(inum);
     }
 }

 /branches/rcu/kernel/arch/ppc64/src/ppc64.c
 ,6 → 128,7
 void arch_grab_console(void)
 {
 }
 /** Return console to userspace
  *
  */
 ,5 → 136,11
 {
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

 /branches/rcu/kernel/arch/mips32/_link.ld.in
 ,7 → 10,7
 OUTPUT_ARCH(mips)
-ENTRY(kernel_image_start)
+ENTRY(kernel_image_start)
 SECTIONS {
     . = KERNEL_LOAD_ADDRESS;
 ,9 → 31,10
         *(.rodata*);
         *(.sdata);
         *(.reginfo);
-        /* Unfortunately IRIX does not allow us
-             * to include this as a last section :-(
-         * BSS/SBSS addresses will be wrong */
+        *(.sbss);
+        *(.scommon);
+        *(.bss);        /* uninitialized static variables */
+        *(COMMON);      /* global variables */
         symbol_table = .;
         *(symtab.*);
     }
 ,14 → 41,6
     _gp = . + 0x8000;
     .lit8 : { *(.lit8) }
     .lit4 : { *(.lit4) }
-    .sbss : {
-        *(.sbss);
-        *(.scommon);
-    }
-    .bss : {
-        *(.bss);        /* uninitialized static variables */
-        *(COMMON);      /* global variables */
-    }
     kdata_end = .;

/branches/rcu/kernel/arch/mips32/include/types.h
62,6 → 62,7
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/mips32/src/mips32.c
 ,5 → 178,11
     return 0;
 }
+void arch_reboot(void)
+{
+    ___halt();
+    while (1);
+}
 /** @}
  */

/branches/rcu/kernel/arch/ia32/include/types.h
62,6 → 62,7
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ia32/include/asm.h
 ,12 → 59,12
  */
 static inline void cpu_halt(void)
 {
-    asm("hlt\n");
+    asm volatile ("hlt\n");
 };
 static inline void cpu_sleep(void)
 {
-    asm("hlt\n");
+    asm volatile ("hlt\n");
 };
 #define GEN_READ_REG(reg) static inline unative_t read_ ##reg (void) \

 /branches/rcu/kernel/arch/ia32/src/pm.c
 ,7 → 121,7
 void idt_init(void)
 {
     idescriptor_t *d;
-    int i;
+    unsigned int i;
     for (i = 0; i < IDT_ITEMS; i++) {
         d = &idt[i];
 ,5 → 230,28
     gdtr_load(&cpugdtr);
 }
+/* Reboot the machine by initiating
+ * a triple fault
+ */
+void arch_reboot(void)
+{
+    preemption_disable();
+    ipl_t ipl = interrupts_disable();
+    memsetb((uintptr_t) idt, sizeof(idt), 0);
+    ptr_16_32_t idtr;
+    idtr.limit = sizeof(idt);
+    idtr.base = (uintptr_t) idt;
+    idtr_load(&idtr);
+    interrupts_restore(ipl);
+    asm volatile (
+        "int $0x03\n"
+        "cli\n"
+        "hlt\n"
+    );
+}
 /** @}
  */

 /branches/rcu/kernel/arch/ia32/src/smp/smp.c
 ,13 → 82,13
     if (config.cpu_count > 1) {
         page_mapping_insert(AS_KERNEL, l_apic_address, (uintptr_t) l_apic,
-                  PAGE_NOT_CACHEABLE);
+                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
         page_mapping_insert(AS_KERNEL, io_apic_address, (uintptr_t) io_apic,
-                  PAGE_NOT_CACHEABLE);
+                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
         l_apic = (uint32_t *) l_apic_address;
         io_apic = (uint32_t *) io_apic_address;
-        }
+    }
 }
 /*

 /branches/rcu/kernel/arch/ia32/src/smp/apic.c
 ,7 → 139,14
 static void l_apic_timer_irq_handler(irq_t *irq, void *arg, ...)
 {
+    /*
+     * Holding a spinlock could prevent clock() from preempting
+     * the current thread. In this case, we don't need to hold the
+     * irq->lock so we just unlock it and then lock it again.
+     */
+    spinlock_unlock(&irq->lock);
     clock();
+    spinlock_lock(&irq->lock);
 }
 /** Initialize APIC on BSP. */
 ,6 → 169,7
     io_apic_disable_irqs(0xffff);
     irq_initialize(&l_apic_timer_irq);
+    l_apic_timer_irq.preack = true;
     l_apic_timer_irq.devno = device_assign_devno();
     l_apic_timer_irq.inr = IRQ_CLK;
     l_apic_timer_irq.claim = l_apic_timer_claim;

 /branches/rcu/kernel/arch/ia32/src/boot/vga323.pal
 ,0 → 1,256
+    .byte 0x00, 0x00, 0x00, 0x00
+    .byte 0x09, 0x00, 0x00, 0x00
+    .byte 0x12, 0x00, 0x00, 0x00
+    .byte 0x1b, 0x00, 0x00, 0x00
+    .byte 0x24, 0x00, 0x00, 0x00
+    .byte 0x2d, 0x00, 0x00, 0x00
+    .byte 0x36, 0x00, 0x00, 0x00
+    .byte 0x3f, 0x00, 0x00, 0x00
+    .byte 0x00, 0x15, 0x00, 0x00
+    .byte 0x09, 0x15, 0x00, 0x00
+    .byte 0x12, 0x15, 0x00, 0x00
+    .byte 0x1b, 0x15, 0x00, 0x00
+    .byte 0x24, 0x15, 0x00, 0x00
+    .byte 0x2d, 0x15, 0x00, 0x00
+    .byte 0x36, 0x15, 0x00, 0x00
+    .byte 0x3f, 0x15, 0x00, 0x00
+    .byte 0x00, 0x2a, 0x00, 0x00
+    .byte 0x09, 0x2a, 0x00, 0x00
+    .byte 0x12, 0x2a, 0x00, 0x00
+    .byte 0x1b, 0x2a, 0x00, 0x00
+    .byte 0x24, 0x2a, 0x00, 0x00
+    .byte 0x2d, 0x2a, 0x00, 0x00
+    .byte 0x36, 0x2a, 0x00, 0x00
+    .byte 0x3f, 0x2a, 0x00, 0x00
+    .byte 0x00, 0x3f, 0x00, 0x00
+    .byte 0x09, 0x3f, 0x00, 0x00
+    .byte 0x12, 0x3f, 0x00, 0x00
+    .byte 0x1b, 0x3f, 0x00, 0x00
+    .byte 0x24, 0x3f, 0x00, 0x00
+    .byte 0x2d, 0x3f, 0x00, 0x00
+    .byte 0x36, 0x3f, 0x00, 0x00
+    .byte 0x3f, 0x3f, 0x00, 0x00
+    .byte 0x00, 0x00, 0x09, 0x00
+    .byte 0x09, 0x00, 0x09, 0x00
+    .byte 0x12, 0x00, 0x09, 0x00
+    .byte 0x1b, 0x00, 0x09, 0x00
+    .byte 0x24, 0x00, 0x09, 0x00
+    .byte 0x2d, 0x00, 0x09, 0x00
+    .byte 0x36, 0x00, 0x09, 0x00
+    .byte 0x3f, 0x00, 0x09, 0x00
+    .byte 0x00, 0x15, 0x09, 0x00
+    .byte 0x09, 0x15, 0x09, 0x00
+    .byte 0x12, 0x15, 0x09, 0x00
+    .byte 0x1b, 0x15, 0x09, 0x00
+    .byte 0x24, 0x15, 0x09, 0x00
+    .byte 0x2d, 0x15, 0x09, 0x00
+    .byte 0x36, 0x15, 0x09, 0x00
+    .byte 0x3f, 0x15, 0x09, 0x00
+    .byte 0x00, 0x2a, 0x09, 0x00
+    .byte 0x09, 0x2a, 0x09, 0x00
+    .byte 0x12, 0x2a, 0x09, 0x00
+    .byte 0x1b, 0x2a, 0x09, 0x00
+    .byte 0x24, 0x2a, 0x09, 0x00
+    .byte 0x2d, 0x2a, 0x09, 0x00
+    .byte 0x36, 0x2a, 0x09, 0x00
+    .byte 0x3f, 0x2a, 0x09, 0x00
+    .byte 0x00, 0x3f, 0x09, 0x00
+    .byte 0x09, 0x3f, 0x09, 0x00
+    .byte 0x12, 0x3f, 0x09, 0x00
+    .byte 0x1b, 0x3f, 0x09, 0x00
+    .byte 0x24, 0x3f, 0x09, 0x00
+    .byte 0x2d, 0x3f, 0x09, 0x00
+    .byte 0x36, 0x3f, 0x09, 0x00
+    .byte 0x3f, 0x3f, 0x09, 0x00
+    .byte 0x00, 0x00, 0x12, 0x00
+    .byte 0x09, 0x00, 0x12, 0x00
+    .byte 0x12, 0x00, 0x12, 0x00
+    .byte 0x1b, 0x00, 0x12, 0x00
+    .byte 0x24, 0x00, 0x12, 0x00
+    .byte 0x2d, 0x00, 0x12, 0x00
+    .byte 0x36, 0x00, 0x12, 0x00
+    .byte 0x3f, 0x00, 0x12, 0x00
+    .byte 0x00, 0x15, 0x12, 0x00
+    .byte 0x09, 0x15, 0x12, 0x00
+    .byte 0x12, 0x15, 0x12, 0x00
+    .byte 0x1b, 0x15, 0x12, 0x00
+    .byte 0x24, 0x15, 0x12, 0x00
+    .byte 0x2d, 0x15, 0x12, 0x00
+    .byte 0x36, 0x15, 0x12, 0x00
+    .byte 0x3f, 0x15, 0x12, 0x00
+    .byte 0x00, 0x2a, 0x12, 0x00
+    .byte 0x09, 0x2a, 0x12, 0x00
+    .byte 0x12, 0x2a, 0x12, 0x00
+    .byte 0x1b, 0x2a, 0x12, 0x00
+    .byte 0x24, 0x2a, 0x12, 0x00
+    .byte 0x2d, 0x2a, 0x12, 0x00
+    .byte 0x36, 0x2a, 0x12, 0x00
+    .byte 0x3f, 0x2a, 0x12, 0x00
+    .byte 0x00, 0x3f, 0x12, 0x00
+    .byte 0x09, 0x3f, 0x12, 0x00
+    .byte 0x12, 0x3f, 0x12, 0x00
+    .byte 0x1b, 0x3f, 0x12, 0x00
+    .byte 0x24, 0x3f, 0x12, 0x00
+    .byte 0x2d, 0x3f, 0x12, 0x00
+    .byte 0x36, 0x3f, 0x12, 0x00
+    .byte 0x3f, 0x3f, 0x12, 0x00
+    .byte 0x00, 0x00, 0x1b, 0x00
+    .byte 0x09, 0x00, 0x1b, 0x00
+    .byte 0x12, 0x00, 0x1b, 0x00
+    .byte 0x1b, 0x00, 0x1b, 0x00
+    .byte 0x24, 0x00, 0x1b, 0x00
+    .byte 0x2d, 0x00, 0x1b, 0x00
+    .byte 0x36, 0x00, 0x1b, 0x00
+    .byte 0x3f, 0x00, 0x1b, 0x00
+    .byte 0x00, 0x15, 0x1b, 0x00
+    .byte 0x09, 0x15, 0x1b, 0x00
+    .byte 0x12, 0x15, 0x1b, 0x00
+    .byte 0x1b, 0x15, 0x1b, 0x00
+    .byte 0x24, 0x15, 0x1b, 0x00
+    .byte 0x2d, 0x15, 0x1b, 0x00
+    .byte 0x36, 0x15, 0x1b, 0x00
+    .byte 0x3f, 0x15, 0x1b, 0x00
+    .byte 0x00, 0x2a, 0x1b, 0x00
+    .byte 0x09, 0x2a, 0x1b, 0x00
+    .byte 0x12, 0x2a, 0x1b, 0x00
+    .byte 0x1b, 0x2a, 0x1b, 0x00
+    .byte 0x24, 0x2a, 0x1b, 0x00
+    .byte 0x2d, 0x2a, 0x1b, 0x00
+    .byte 0x36, 0x2a, 0x1b, 0x00
+    .byte 0x3f, 0x2a, 0x1b, 0x00
+    .byte 0x00, 0x3f, 0x1b, 0x00
+    .byte 0x09, 0x3f, 0x1b, 0x00
+    .byte 0x12, 0x3f, 0x1b, 0x00
+    .byte 0x1b, 0x3f, 0x1b, 0x00
+    .byte 0x24, 0x3f, 0x1b, 0x00
+    .byte 0x2d, 0x3f, 0x1b, 0x00
+    .byte 0x36, 0x3f, 0x1b, 0x00
+    .byte 0x3f, 0x3f, 0x1b, 0x00
+    .byte 0x00, 0x00, 0x24, 0x00
+    .byte 0x09, 0x00, 0x24, 0x00
+    .byte 0x12, 0x00, 0x24, 0x00
+    .byte 0x1b, 0x00, 0x24, 0x00
+    .byte 0x24, 0x00, 0x24, 0x00
+    .byte 0x2d, 0x00, 0x24, 0x00
+    .byte 0x36, 0x00, 0x24, 0x00
+    .byte 0x3f, 0x00, 0x24, 0x00
+    .byte 0x00, 0x15, 0x24, 0x00
+    .byte 0x09, 0x15, 0x24, 0x00
+    .byte 0x12, 0x15, 0x24, 0x00
+    .byte 0x1b, 0x15, 0x24, 0x00
+    .byte 0x24, 0x15, 0x24, 0x00
+    .byte 0x2d, 0x15, 0x24, 0x00
+    .byte 0x36, 0x15, 0x24, 0x00
+    .byte 0x3f, 0x15, 0x24, 0x00
+    .byte 0x00, 0x2a, 0x24, 0x00
+    .byte 0x09, 0x2a, 0x24, 0x00
+    .byte 0x12, 0x2a, 0x24, 0x00
+    .byte 0x1b, 0x2a, 0x24, 0x00
+    .byte 0x24, 0x2a, 0x24, 0x00
+    .byte 0x2d, 0x2a, 0x24, 0x00
+    .byte 0x36, 0x2a, 0x24, 0x00
+    .byte 0x3f, 0x2a, 0x24, 0x00
+    .byte 0x00, 0x3f, 0x24, 0x00
+    .byte 0x09, 0x3f, 0x24, 0x00
+    .byte 0x12, 0x3f, 0x24, 0x00
+    .byte 0x1b, 0x3f, 0x24, 0x00
+    .byte 0x24, 0x3f, 0x24, 0x00
+    .byte 0x2d, 0x3f, 0x24, 0x00
+    .byte 0x36, 0x3f, 0x24, 0x00
+    .byte 0x3f, 0x3f, 0x24, 0x00
+    .byte 0x00, 0x00, 0x2d, 0x00
+    .byte 0x09, 0x00, 0x2d, 0x00
+    .byte 0x12, 0x00, 0x2d, 0x00
+    .byte 0x1b, 0x00, 0x2d, 0x00
+    .byte 0x24, 0x00, 0x2d, 0x00
+    .byte 0x2d, 0x00, 0x2d, 0x00
+    .byte 0x36, 0x00, 0x2d, 0x00
+    .byte 0x3f, 0x00, 0x2d, 0x00
+    .byte 0x00, 0x15, 0x2d, 0x00
+    .byte 0x09, 0x15, 0x2d, 0x00
+    .byte 0x12, 0x15, 0x2d, 0x00
+    .byte 0x1b, 0x15, 0x2d, 0x00
+    .byte 0x24, 0x15, 0x2d, 0x00
+    .byte 0x2d, 0x15, 0x2d, 0x00
+    .byte 0x36, 0x15, 0x2d, 0x00
+    .byte 0x3f, 0x15, 0x2d, 0x00
+    .byte 0x00, 0x2a, 0x2d, 0x00
+    .byte 0x09, 0x2a, 0x2d, 0x00
+    .byte 0x12, 0x2a, 0x2d, 0x00
+    .byte 0x1b, 0x2a, 0x2d, 0x00
+    .byte 0x24, 0x2a, 0x2d, 0x00
+    .byte 0x2d, 0x2a, 0x2d, 0x00
+    .byte 0x36, 0x2a, 0x2d, 0x00
+    .byte 0x3f, 0x2a, 0x2d, 0x00
+    .byte 0x00, 0x3f, 0x2d, 0x00
+    .byte 0x09, 0x3f, 0x2d, 0x00
+    .byte 0x12, 0x3f, 0x2d, 0x00
+    .byte 0x1b, 0x3f, 0x2d, 0x00
+    .byte 0x24, 0x3f, 0x2d, 0x00
+    .byte 0x2d, 0x3f, 0x2d, 0x00
+    .byte 0x36, 0x3f, 0x2d, 0x00
+    .byte 0x3f, 0x3f, 0x2d, 0x00
+    .byte 0x00, 0x00, 0x36, 0x00
+    .byte 0x09, 0x00, 0x36, 0x00
+    .byte 0x12, 0x00, 0x36, 0x00
+    .byte 0x1b, 0x00, 0x36, 0x00
+    .byte 0x24, 0x00, 0x36, 0x00
+    .byte 0x2d, 0x00, 0x36, 0x00
+    .byte 0x36, 0x00, 0x36, 0x00
+    .byte 0x3f, 0x00, 0x36, 0x00
+    .byte 0x00, 0x15, 0x36, 0x00
+    .byte 0x09, 0x15, 0x36, 0x00
+    .byte 0x12, 0x15, 0x36, 0x00
+    .byte 0x1b, 0x15, 0x36, 0x00
+    .byte 0x24, 0x15, 0x36, 0x00
+    .byte 0x2d, 0x15, 0x36, 0x00
+    .byte 0x36, 0x15, 0x36, 0x00
+    .byte 0x3f, 0x15, 0x36, 0x00
+    .byte 0x00, 0x2a, 0x36, 0x00
+    .byte 0x09, 0x2a, 0x36, 0x00
+    .byte 0x12, 0x2a, 0x36, 0x00
+    .byte 0x1b, 0x2a, 0x36, 0x00
+    .byte 0x24, 0x2a, 0x36, 0x00
+    .byte 0x2d, 0x2a, 0x36, 0x00
+    .byte 0x36, 0x2a, 0x36, 0x00
+    .byte 0x3f, 0x2a, 0x36, 0x00
+    .byte 0x00, 0x3f, 0x36, 0x00
+    .byte 0x09, 0x3f, 0x36, 0x00
+    .byte 0x12, 0x3f, 0x36, 0x00
+    .byte 0x1b, 0x3f, 0x36, 0x00
+    .byte 0x24, 0x3f, 0x36, 0x00
+    .byte 0x2d, 0x3f, 0x36, 0x00
+    .byte 0x36, 0x3f, 0x36, 0x00
+    .byte 0x3f, 0x3f, 0x36, 0x00
+    .byte 0x00, 0x00, 0x3f, 0x00
+    .byte 0x09, 0x00, 0x3f, 0x00
+    .byte 0x12, 0x00, 0x3f, 0x00
+    .byte 0x1b, 0x00, 0x3f, 0x00
+    .byte 0x24, 0x00, 0x3f, 0x00
+    .byte 0x2d, 0x00, 0x3f, 0x00
+    .byte 0x36, 0x00, 0x3f, 0x00
+    .byte 0x3f, 0x00, 0x3f, 0x00
+    .byte 0x00, 0x15, 0x3f, 0x00
+    .byte 0x09, 0x15, 0x3f, 0x00
+    .byte 0x12, 0x15, 0x3f, 0x00
+    .byte 0x1b, 0x15, 0x3f, 0x00
+    .byte 0x24, 0x15, 0x3f, 0x00
+    .byte 0x2d, 0x15, 0x3f, 0x00
+    .byte 0x36, 0x15, 0x3f, 0x00
+    .byte 0x3f, 0x15, 0x3f, 0x00
+    .byte 0x00, 0x2a, 0x3f, 0x00
+    .byte 0x09, 0x2a, 0x3f, 0x00
+    .byte 0x12, 0x2a, 0x3f, 0x00
+    .byte 0x1b, 0x2a, 0x3f, 0x00
+    .byte 0x24, 0x2a, 0x3f, 0x00
+    .byte 0x2d, 0x2a, 0x3f, 0x00
+    .byte 0x36, 0x2a, 0x3f, 0x00
+    .byte 0x3f, 0x2a, 0x3f, 0x00
+    .byte 0x00, 0x3f, 0x3f, 0x00
+    .byte 0x09, 0x3f, 0x3f, 0x00
+    .byte 0x12, 0x3f, 0x3f, 0x00
+    .byte 0x1b, 0x3f, 0x3f, 0x00
+    .byte 0x24, 0x3f, 0x3f, 0x00
+    .byte 0x2d, 0x3f, 0x3f, 0x00
+    .byte 0x36, 0x3f, 0x3f, 0x00
+    .byte 0x3f, 0x3f, 0x3f, 0x00

 /branches/rcu/kernel/arch/ia32/src/boot/boot.S
 ,9 → 63,24
     jmpl $selector(KTEXT_DES), $multiboot_meeting_point
     multiboot_meeting_point:
-    pushl %ebx                          # save parameters from GRUB
-    pushl %eax
+    movl %eax, grub_eax                 # save parameters from GRUB
+    movl %ebx, grub_ebx
+    xorl %eax, %eax
+    cpuid
+    cmp $0x0, %eax                      # any function > 0?
+    jbe pse_unsupported
+    movl $0x1, %eax                     # Basic function code 1
+    cpuid
+    bt $3, %edx                         # Test if PSE is supported
+    jc pse_supported
+    pse_unsupported:
+        movl $pse_msg, %esi
+        jmp error_halt
+    pse_supported:
 #ifdef CONFIG_FB
     mov $vesa_init, %esi
     mov $VESA_INIT_SEGMENT << 4, %edi
 ,8 → 104,8
     call map_kernel                         # map kernel and turn paging on
-    popl %eax
-    popl %ebx
+    movl grub_eax, %eax
+    movl grub_ebx, %ebx
     cmpl $MULTIBOOT_LOADER_MAGIC, %eax              # compare GRUB signature
     je valid_boot
 ,7 → 224,7
     rep movsb
 #endif
     call main_bsp                               # never returns
     cli
 ,19 → 237,20
     # For simplicity, we map the entire 4G space.
     #
     movl %cr4, %ecx
-    orl $(1<<4), %ecx
-    movl %ecx, %cr4                         # turn PSE on
+    orl $(1 << 4), %ecx                         # turn PSE on
+    andl $(~(1 << 5)), %ecx                     # turn PAE off
+    movl %ecx, %cr4
-    movl $(page_directory+0), %esi
-    movl $(page_directory+2048), %edi
+    movl $(page_directory + 0), %esi
+    movl $(page_directory + 2048), %edi
     xorl %ecx, %ecx
     xorl %ebx, %ebx
 :
-    movl $((1<<7)|(1<<0)), %eax
+    movl $((1 << 7) | (1 << 1) | (1 << 0)), %eax
     orl %ebx, %eax
-    movl %eax, (%esi,%ecx,4)                    # mapping 0x00000000+%ecx*4M => 0x00000000+%ecx*4M
-    movl %eax, (%edi,%ecx,4)                    # mapping 0x80000000+%ecx*4M => 0x00000000+%ecx*4M
-    addl $(4*1024*1024), %ebx
+    movl %eax, (%esi, %ecx, 4)                  # mapping 0x00000000 + %ecx * 4M => 0x00000000 + %ecx * 4M
+    movl %eax, (%edi, %ecx, 4)                  # mapping 0x80000000 + %ecx * 4M => 0x00000000 + %ecx * 4M
+    addl $(4 * 1024 * 1024), %ebx
     incl %ecx
     cmpl $512, %ecx
 ,12 → 258,71
     movl %esi, %cr3
-    # turn paging on
     movl %cr0, %ebx
-    orl $(1<<31), %ebx
+    orl $(1 << 31), %ebx                        # turn paging on
     movl %ebx, %cr0
     ret
+# Print string from %esi to EGA display (in red) and halt
+error_halt:
+    movl $0xb8000, %edi                     # base of EGA text mode memory
+    xorl %eax, %eax
+    movw $0x3d4, %dx                        # read bits 8 - 15 of the cursor address
+    movb $0xe, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    inb %dx, %al
+    shl $8, %ax
+    movw $0x3d4, %dx                        # read bits 0 - 7 of the cursor address
+    movb $0xf, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    inb %dx, %al
+    cmp $1920, %ax
+    jbe cursor_ok
+        movw $1920, %ax                     # sanity check for the cursor on the last line
+    cursor_ok:
+    movw %ax, %bx
+    shl $1, %eax
+    addl %eax, %edi
+    movw $0x0c00, %ax                       # black background, light red foreground
+    cld
+    ploop:
+        lodsb
+        cmp $0, %al
+        je ploop_end
+        stosw
+        inc %bx
+        jmp ploop
+    ploop_end:
+    movw $0x3d4, %dx                        # write bits 8 - 15 of the cursor address
+    movb $0xe, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    movb %bh, %al
+    outb %al, %dx
+    movw $0x3d4, %dx                        # write bits 0 - 7 of the cursor address
+    movb $0xf, %al
+    outb %al, %dx
+    movw $0x3d5, %dx
+    movb %bl, %al
+    outb %al, %dx
+    cli
+    hlt
 #ifdef CONFIG_FB
 vesa_init:
     jmp $selector(VESA_INIT_DES), $vesa_init_real - vesa_init
 ,11 → 353,12
 #define VESA_INFO_SIZE 1024
+#define VESA_MODE_ATTRIBUTES_OFFSET 0
 #define VESA_MODE_LIST_PTR_OFFSET 14
+#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_WIDTH_OFFSET 18
 #define VESA_MODE_HEIGHT_OFFSET 20
 #define VESA_MODE_BPP_OFFSET 25
-#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_PHADDR_OFFSET 40
 #define VESA_END_OF_MODES 0xffff
 ,12 → 368,10
 #define VESA_GET_INFO 0x4f00
 #define VESA_GET_MODE_INFO 0x4f01
 #define VESA_SET_MODE 0x4f02
+#define VESA_SET_PALETTE 0x4f09
-#define CONFIG_VESA_BPP_a 255
 #if CONFIG_VESA_BPP == 24
-#undef CONFIG_VESA_BPP_a
-#define CONFIG_VESA_BPP_a 32
+#define CONFIG_VESA_BPP_VARIANT 32
 #endif
     mov $VESA_GET_INFO, %ax
 ,18 → 412,21
     cmp VESA_MODE_WIDTH_OFFSET(%di), %ax
     jnz 1b
-    mov $CONFIG_VESA_HEIGHT,%ax
+    mov $CONFIG_VESA_HEIGHT, %ax
     cmp VESA_MODE_HEIGHT_OFFSET(%di), %ax
     jnz 1b
     mov $CONFIG_VESA_BPP, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
+#ifdef CONFIG_VESA_BPP_VARIANT
     jz 2f
-    mov $CONFIG_VESA_BPP_a, %al
+    mov $CONFIG_VESA_BPP_VARIANT, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
+#endif
     jnz 1b
 :
     mov %cx, %bx
 ,7 → 438,60
     pop %di
     cmp $VESA_OK, %al
     jnz 0f
+#if CONFIG_VESA_BPP == 8
+    # Set 3:2:3 VGA palette
+    mov VESA_MODE_ATTRIBUTES_OFFSET(%di), %ax
+    push %di
+    mov $vga323 - vesa_init, %di
+    mov $0x100, %ecx
+    bt $5, %ax                          # Test if VGA compatible registers are present
+    jnc vga_compat
+        # Try VESA routine to set palette
+        mov $VESA_SET_PALETTE, %ax
+        xor %bl, %bl
+        xor %dx, %dx
+        int $0x10
+        jmp vga_not_compat
+    vga_compat:
+        # Try VGA registers to set palette
+        movw $0x3c6, %dx                        # Set palette mask
+        movb $0xff, %al
+        outb %al, %dx
+        movw $0x3c8, %dx                        # First index to set
+        xor %al, %al
+        outb %al, %dx
+        movw $0x3c9, %dx                        # Data port
+        vga_loop:
+            movb %es:2(%di), %al
+            outb %al, %dx
+            movb %es:1(%di), %al
+            outb %al, %dx
+            movb %es:(%di), %al
+            outb %al, %dx
+            addw $4, %di
+            loop vga_loop
+    vga_not_compat:
+    pop %di
+#endif
     mov VESA_MODE_PHADDR_OFFSET(%di), %esi
     mov VESA_MODE_WIDTH_OFFSET(%di), %ax
     shl $16, %eax
 ,12 → 532,12
     mov $0xffffffff, %edi       # EGA text mode used, because of problems with VESA
     xor %ax, %ax
     jz 8b                       # Force relative jump
+vga323:
+#include "vga323.pal"
 .code32
 vesa_init_protect:
-    popl %esp
     movw $selector(KDATA_DES), %cx
     movw %cx, %es
     movw %cx, %fs
 ,6 → 545,8
     movw %cx, %ds                   # kernel data + stack
     movw %cx, %ss
+    movl $START_STACK, %esp         # initialize stack pointer
     jmpl $selector(KTEXT_DES), $vesa_meeting_point
 .align 4
 ,3 → 558,12
 .align 4096
 page_directory:
     .space 4096, 0
+grub_eax:
+    .long 0
+grub_ebx:
+    .long 0
+pse_msg:
+    .asciz "Page Size Extension not supported. System halted."

 /branches/rcu/kernel/arch/ia32/src/mm/page.c
 ,7 → 61,7
          * PA2KA(identity) mapping for all frames until last_frame.
          */
         for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
-            flags = PAGE_CACHEABLE;
+            flags = PAGE_CACHEABLE | PAGE_WRITE;
             if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
                 flags |= PAGE_GLOBAL;
             page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
 ,10 → 69,8
         exc_register(14, "page_fault", (iroutine) page_fault);
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    }
-    else {
+    } else
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    }
     paging_on();
 }
 ,7 → 84,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
 ,12 → 93,12
 void page_fault(int n, istate_t *istate)
 {
-        uintptr_t page;
+    uintptr_t page;
     pf_access_t access;
-        page = read_cr2();
+    page = read_cr2();
-        if (istate->error_word & PFERR_CODE_RSVD)
+    if (istate->error_word & PFERR_CODE_RSVD)
         panic("Reserved bit set in page directory.\n");
     if (istate->error_word & PFERR_CODE_RW)
 ,14 → 105,14
         access = PF_ACCESS_WRITE;
     else
         access = PF_ACCESS_READ;
-        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
+    if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
         fault_if_from_uspace(istate, "Page fault: %#x", page);
-                decode_istate(istate);
-                printf("page fault address: %#x\n", page);
-                panic("page fault\n");
-        }
+        decode_istate(istate);
+        printf("page fault address: %#x\n", page);
+        panic("page fault\n");
+    }
 }
 /** @}

 /branches/rcu/kernel/arch/ia32/src/interrupt.c
 ,14 → 176,21
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
+    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
+        if (irq->preack) {
+            /* Send EOI before processing the interrupt */
+            trap_virtual_eoi();
+            ack = true;
+        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,7 → 201,9
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    trap_virtual_eoi();
+    if (!ack)
+        trap_virtual_eoi();
 }
 void interrupt_init(void)

/branches/rcu/kernel/arch/ia32/src/drivers/i8254.c
82,6 → 82,7
void i8254_init(void)
{
irq_initialize(&i8254_irq);
i8254_irq.preack = true;
i8254_irq.devno = device_assign_devno();
i8254_irq.inr = IRQ_CLK;
i8254_irq.claim = i8254_claim;

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2306 → Rev 2307