Changeset 20235a3 in mainline for kernel


Ignore:
Timestamp:
2010-09-02T20:55:28Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0c39b96
Parents:
0c61955 (diff), 3249673 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
kernel
Files:
7 added
44 edited

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    r0c61955 r20235a3  
    120120ifeq ($(CONFIG_LTO),y)
    121121        GCC_CFLAGS += -flto
     122endif
     123
     124ifeq ($(CONFIG_LINE_DEBUG),y)
     125        GCC_CFLAGS += -g
     126        ICC_CFLAGS += -g
     127        SUNCC_CFLAGS += -g
     128        CLANG_CFLAGS += -g
    122129endif
    123130
    … …  
    401408
    402409$(DISASM): $(RAW)
     410ifeq ($(CONFIG_LINE_DEBUG),y)
     411        $(OBJDUMP) -d -S $< > $@
     412else
    403413        $(OBJDUMP) -d $< > $@
     414endif
    404415
    405416$(RAW): $(LINK) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(GENERIC_OBJECTS) $(SYMTAB_OBJECTS)

  • kernel/arch/amd64/_link.ld.in

    r0c61955 r20235a3  
    5353        }
    5454       
     55#ifdef CONFIG_LINE_DEBUG
     56        .comment 0 : { *(.comment); }
     57        .debug_abbrev 0 : { *(.debug_abbrev); }
     58        .debug_aranges 0 : { *(.debug_aranges); }
     59        .debug_info 0 : { *(.debug_info); }
     60        .debug_line 0 : { *(.debug_line); }
     61        .debug_loc 0 : { *(.debug_loc); }
     62        .debug_pubnames 0 : { *(.debug_pubnames); }
     63        .debug_pubtypes 0 : { *(.debug_pubtypes); }
     64        .debug_ranges 0 : { *(.debug_ranges); }
     65        .debug_str 0 : { *(.debug_str); }
     66#endif
     67       
    5568        /DISCARD/ : {
    5669                *(*);

  • kernel/arch/amd64/include/pm.h

    r0c61955 r20235a3  
    6565#endif /* CONFIG_FB */
    6666
    67 #define gdtselector(des)  ((des) << 3)
    68 #define idtselector(des)  ((des) << 4)
     67#define GDT_SELECTOR(des)  ((des) << 3)
    6968
    7069#define PL_KERNEL  0
    … …  
    168167
    169168extern ptr_16_64_t gdtr;
    170 extern ptr_16_32_t bootstrap_gdtr;
    171169extern ptr_16_32_t protected_ap_gdtr;
    172170

  • kernel/arch/amd64/src/asm.S

    r0c61955 r20235a3  
    244244         */
    245245        xorq %rdx, %rdx
    246         cmpq $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
     246        cmpq $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
    247247        cmovnzq %rdx, %rbp
    248248

  • kernel/arch/amd64/src/boot/boot.S

    r0c61955 r20235a3  
    8585       
    8686        /* Kernel data + stack */
    87         movw $gdtselector(KDATA_DES), %cx
     87        movw $GDT_SELECTOR(KDATA_DES), %cx
    8888        movw %cx, %es
    8989        movw %cx, %ds
    … …  
    9494         * when _visible_ part of GS does not point to user-mode segment.
    9595         */
    96         movw $gdtselector(UDATA_DES), %cx
     96        movw $GDT_SELECTOR(UDATA_DES), %cx
    9797        movw %cx, %fs
    9898        movw %cx, %gs
    9999       
    100         jmpl $gdtselector(KTEXT32_DES), $multiboot_meeting_point
     100        jmpl $GDT_SELECTOR(KTEXT32_DES), $multiboot_meeting_point
    101101        multiboot_meeting_point:
    102102       
    … …  
    182182       
    183183        /* At this point we are in compatibility mode */
    184         jmpl $gdtselector(KTEXT_DES), $start64
     184        jmpl $GDT_SELECTOR(KTEXT_DES), $start64
    185185
    186186/** Print string to EGA display (in light red) and halt.
    … …  
    645645.section K_DATA_START, "aw", @progbits
    646646
    647 .global bootstrap_gdtr
    648647bootstrap_gdtr:
    649         .word gdtselector(GDT_ITEMS)
     648        .word GDT_SELECTOR(GDT_ITEMS)
    650649        .long KA2PA(gdt)
    651650

  • kernel/arch/amd64/src/boot/vesa_ret.inc

    r0c61955 r20235a3  
    77       
    88        /* Kernel data + stack */
    9         movw $gdtselector(KDATA_DES), %cx
     9        movw $GDT_SELECTOR(KDATA_DES), %cx
    1010        movw %cx, %es
    1111        movw %cx, %ds
    … …  
    1717         */
    1818       
    19         movw $gdtselector(UDATA_DES), %cx
     19        movw $GDT_SELECTOR(UDATA_DES), %cx
    2020        movw %cx, %fs
    2121        movw %cx, %gs
    2222       
    23         jmpl $gdtselector(KTEXT32_DES), $vesa_meeting_point
     23        jmpl $GDT_SELECTOR(KTEXT32_DES), $vesa_meeting_point

  • kernel/arch/amd64/src/ddi/ddi.c

    r0c61955 r20235a3  
    153153        tss_descriptor_t *tss_desc = (tss_descriptor_t *) &gdt_p[TSS_DES];
    154154        tss_desc->type = AR_TSS;
    155         tr_load(gdtselector(TSS_DES));
     155        tr_load(GDT_SELECTOR(TSS_DES));
    156156       
    157157        /*

  • kernel/arch/amd64/src/pm.c

    r0c61955 r20235a3  
    171171
    172172                d->unused = 0;
    173                 d->selector = gdtselector(KTEXT_DES);
     173                d->selector = GDT_SELECTOR(KTEXT_DES);
    174174
    175175                d->present = 1;
    … …  
    291291         * to its own TSS. We just need to load the TR register.
    292292         */
    293         tr_load(gdtselector(TSS_DES));
     293        tr_load(GDT_SELECTOR(TSS_DES));
    294294}
    295295

  • kernel/arch/amd64/src/smp/ap.S

    r0c61955 r20235a3  
    6161        orl $1, %eax
    6262        movl %eax, %cr0     # switch to protected mode
    63         jmpl $gdtselector(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
     63        jmpl $GDT_SELECTOR(KTEXT32_DES), $jump_to_kernel - BOOT_OFFSET + AP_BOOT_OFFSET
    6464
    6565jump_to_kernel:
    6666.code32
    67         movw $gdtselector(KDATA_DES), %ax
     67        movw $GDT_SELECTOR(KDATA_DES), %ax
    6868        movw %ax, %ds
    6969        movw %ax, %es
    7070        movw %ax, %ss
    71         movw $gdtselector(UDATA_DES), %ax
     71        movw $GDT_SELECTOR(UDATA_DES), %ax
    7272        movw %ax, %gs
    7373       
    … …  
    9494       
    9595        # At this point we are in compatibility mode
    96         jmpl $gdtselector(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
     96        jmpl $GDT_SELECTOR(KTEXT_DES), $start64 - BOOT_OFFSET + AP_BOOT_OFFSET
    9797
    9898.code64

  • kernel/arch/amd64/src/syscall.c

    r0c61955 r20235a3  
    5858         */
    5959        write_msr(AMD_MSR_STAR,
    60             ((uint64_t)(gdtselector(KDATA_DES) | PL_USER) << 48) |
    61             ((uint64_t)(gdtselector(KTEXT_DES) | PL_KERNEL) << 32));
     60            ((uint64_t) (GDT_SELECTOR(KDATA_DES) | PL_USER) << 48) |
     61            ((uint64_t) (GDT_SELECTOR(KTEXT_DES) | PL_KERNEL) << 32));
    6262        write_msr(AMD_MSR_LSTAR, (uint64_t)syscall_entry);
    6363        /* Mask RFLAGS on syscall

  • kernel/arch/amd64/src/userspace.c

    r0c61955 r20235a3  
    6565                "xorq %%rdi, %%rdi\n"
    6666                "iretq\n"
    67                 :: [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
     67                :: [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
    6868                   [stack_size] "r" (kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
    6969                   [ipl] "r" (ipl),
    70                    [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
     70                   [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
    7171                   [entry] "r" (kernel_uarg->uspace_entry),
    7272                   [uarg] "r" (kernel_uarg->uspace_uarg)

  • kernel/arch/arm32/Makefile.inc

    r0c61955 r20235a3  
    6060        arch/$(KARCH)/src/ras.c
    6161
     62ifeq ($(MACHINE),gta02)
     63        ARCH_SOURCES += arch/$(KARCH)/src/mach/gta02/gta02.c
     64endif
     65
    6266ifeq ($(MACHINE),testarm)
    6367        ARCH_SOURCES += arch/$(KARCH)/src/mach/testarm/testarm.c

  • kernel/arch/arm32/_link.ld.in

    r0c61955 r20235a3  
    77 */
    88
     9#ifdef MACHINE_gta02
     10#define KERNEL_LOAD_ADDRESS 0xb0a08000
     11#else
    912#define KERNEL_LOAD_ADDRESS 0x80a00000
     13#endif
    1014
    1115OUTPUT_ARCH(arm)

  • kernel/arch/arm32/include/mach/integratorcp/integratorcp.h

    r0c61955 r20235a3  
    103103extern void icp_cpu_halt(void);
    104104extern void icp_irq_exception(unsigned int, istate_t *);
    105 extern uintptr_t icp_get_memory_size(void);
     105extern void icp_get_memory_extents(uintptr_t *, uintptr_t *);
    106106extern void icp_frame_init(void);
     107extern size_t icp_get_irq_count(void);
    107108
    108109extern struct arm_machine_ops icp_machine_ops;
     110
     111/** Size of IntegratorCP IRQ number range (starting from 0) */
     112#define ICP_IRQ_COUNT 8
    109113
    110114#endif

  • kernel/arch/arm32/include/mach/testarm/testarm.h

    r0c61955 r20235a3  
    4242#include <arch/machine_func.h>
    4343
    44 /** Last interrupt number (beginning from 0) whose status is probed
    45  * from interrupt controller
    46  */
    47 #define GXEMUL_IRQC_MAX_IRQ  8
    48 #define GXEMUL_KBD_IRQ       2
    49 #define GXEMUL_TIMER_IRQ     4
     44/** Size of GXemul IRQ number range (starting from 0) */
     45#define GXEMUL_IRQ_COUNT        32
     46#define GXEMUL_KBD_IRQ          2
     47#define GXEMUL_TIMER_IRQ        4
    5048
    5149/** Timer frequency */
    … …  
    7371extern void gxemul_cpu_halt(void);
    7472extern void gxemul_irq_exception(unsigned int, istate_t *);
    75 extern uintptr_t gxemul_get_memory_size(void);
     73extern void gxemul_get_memory_extents(uintptr_t *, uintptr_t *);
    7674extern void gxemul_frame_init(void);
     75extern size_t gxemul_get_irq_count(void);
    7776
    7877extern struct arm_machine_ops gxemul_machine_ops;

  • kernel/arch/arm32/include/machine_func.h

    r0c61955 r20235a3  
    4747
    4848struct arm_machine_ops {
    49         void            (*machine_init)(void);
    50         void            (*machine_timer_irq_start)(void);
    51         void            (*machine_cpu_halt)(void);
    52         uintptr_t       (*machine_get_memory_size)(void);
    53         void            (*machine_irq_exception)(unsigned int, istate_t*);
    54         void            (*machine_frame_init)(void);
    55         void            (*machine_output_init)(void);
    56         void            (*machine_input_init)(void);
     49        void (*machine_init)(void);
     50        void (*machine_timer_irq_start)(void);
     51        void (*machine_cpu_halt)(void);
     52        void (*machine_get_memory_extents)(uintptr_t *, uintptr_t *);
     53        void (*machine_irq_exception)(unsigned int, istate_t *);
     54        void (*machine_frame_init)(void);
     55        void (*machine_output_init)(void);
     56        void (*machine_input_init)(void);
     57        size_t (*machine_get_irq_count)(void);
    5758};
    5859
    … …  
    7475extern void machine_cpu_halt(void);
    7576
    76 
    77 /** Returns size of available memory.
     77/** Get extents of available memory.
    7878 *
    79  *  @return Size of available memory.
     79 * @param start         Place to store memory start address.
     80 * @param size          Place to store memory size.
    8081 */
    81 extern uintptr_t machine_get_memory_size(void);
    82 
     82extern void machine_get_memory_extents(uintptr_t *start, uintptr_t *size);
    8383
    8484/** Interrupt exception handler.
    … …  
    105105extern void machine_input_init(void);
    106106
     107extern size_t machine_get_irq_count(void);
     108
    107109#endif
    108110

  • kernel/arch/arm32/include/mm/frame.h

    r0c61955 r20235a3  
    4646
    4747#define BOOT_PAGE_TABLE_SIZE     0x4000
    48 #define BOOT_PAGE_TABLE_ADDRESS  0x8000
     48
     49#ifdef MACHINE_gta02
     50#define BOOT_PAGE_TABLE_ADDRESS  0x30010000
     51#else
     52#define BOOT_PAGE_TABLE_ADDRESS  0x00008000
     53#endif
    4954
    5055#define BOOT_PAGE_TABLE_START_FRAME     (BOOT_PAGE_TABLE_ADDRESS >> FRAME_WIDTH)
    5156#define BOOT_PAGE_TABLE_SIZE_IN_FRAMES  (BOOT_PAGE_TABLE_SIZE >> FRAME_WIDTH)
     57
     58#ifdef MACHINE_gta02
     59#define PHYSMEM_START_ADDR      0x30008000
     60#else
     61#define PHYSMEM_START_ADDR      0x00000000
     62#endif
    5263
    5364extern uintptr_t last_frame;

  • kernel/arch/arm32/src/exc_handler.S

    r0c61955 r20235a3  
    9696        ldmfd r3!, {r4-r7}
    9797        stmfd r13!, {r4-r7}
    98         stmfd r13!, {r13, lr}^
     98        mov r4, r13
     99        stmfd r4, {r13, lr}^
     100        nop                     /* Cannot access r13 immediately after stm(2) */
     101        sub r13, r13, #8
    99102        stmfd r13!, {r2}
    100103
    … …  
    137140
    138141        # return to user mode
    139         ldmfd r13!, {r13, lr}^
     142        mov r0, r13
     143        ldmfd r0, {r13, lr}^
     144        nop                     /* Cannot access r13 immediately after ldm(2) */
     145        add r13, r13, #8
    140146        b 2f
    141147

  • kernel/arch/arm32/src/interrupt.c

    r0c61955 r20235a3  
    4040#include <ddi/device.h>
    4141#include <interrupt.h>
    42 
    43 /** Initial size of a table holding interrupt handlers. */
    44 #define IRQ_COUNT 8
    4542
    4643/** Disable interrupts.
    … …  
    105102void interrupt_init(void)
    106103{
    107         irq_init(IRQ_COUNT, IRQ_COUNT);
     104        size_t irq_count;
     105
     106        irq_count = machine_get_irq_count();
     107        irq_init(irq_count, irq_count);
     108
    108109        machine_timer_irq_start();
    109110}

  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    r0c61955 r20235a3  
    6060        icp_timer_irq_start,
    6161        icp_cpu_halt,
    62         icp_get_memory_size,
     62        icp_get_memory_extents,
    6363        icp_irq_exception,
    6464        icp_frame_init,
    6565        icp_output_init,
    66         icp_input_init
     66        icp_input_init,
     67        icp_get_irq_count
    6768};
    6869
    … …  
    214215}
    215216
    216 /** Returns the size of emulated memory.
    217  *
    218  * @return Size in bytes.
    219  */
    220 size_t icp_get_memory_size(void)
    221 {
     217/** Get extents of available memory.
     218 *
     219 * @param start         Place to store memory start address.
     220 * @param size          Place to store memory size.
     221 */
     222void icp_get_memory_extents(uintptr_t *start, uintptr_t *size)
     223{
     224        *start = 0;
     225
    222226        if (hw_map_init_called) {
    223                 return (sdram[((*(uint32_t *)icp_hw_map.sdramcr & ICP_SDRAM_MASK) >> 2)]);
     227                *size = (sdram[((*(uint32_t *)icp_hw_map.sdramcr &
     228                    ICP_SDRAM_MASK) >> 2)]);
    224229        } else {
    225                 return SDRAM_SIZE;
    226         }
    227        
     230                *size = SDRAM_SIZE;
     231        }
    228232}
    229233
    … …  
    333337}
    334338
     339size_t icp_get_irq_count(void)
     340{
     341        return ICP_IRQ_COUNT;
     342}
    335343
    336344/** @}

  • kernel/arch/arm32/src/mach/testarm/testarm.c

    r0c61955 r20235a3  
    6060        gxemul_timer_irq_start,
    6161        gxemul_cpu_halt,
    62         gxemul_get_memory_size,
     62        gxemul_get_memory_extents,
    6363        gxemul_irq_exception,
    6464        gxemul_frame_init,
    6565        gxemul_output_init,
    66         gxemul_input_init
     66        gxemul_input_init,
     67        gxemul_get_irq_count
    6768};
    6869
    … …  
    126127}
    127128
     129size_t gxemul_get_irq_count(void)
     130{
     131        return GXEMUL_IRQ_COUNT;
     132}
     133
    128134/** Starts gxemul Real Time Clock device, which asserts regular interrupts.
    129135 *
    … …  
    185191}
    186192
    187 /** Returns the size of emulated memory.
    188  *
    189  * @return Size in bytes.
    190  */
    191 uintptr_t gxemul_get_memory_size(void)
    192 {
    193         return  *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
    194 }
    195 
     193/** Get extents of available memory.
     194 *
     195 * @param start         Place to store memory start address.
     196 * @param size          Place to store memory size.
     197 */
     198void gxemul_get_memory_extents(uintptr_t *start, uintptr_t *size)
     199{
     200        *start = 0;
     201        *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
     202}
    196203
    197204/** Returns the mask of active interrupts. */
    … …  
    210217        unsigned int i;
    211218
    212         for (i = 0; i < GXEMUL_IRQC_MAX_IRQ; i++) {
     219        for (i = 0; i < GXEMUL_IRQ_COUNT; i++) {
    213220                if (sources & (1 << i)) {
    214221                        irq_t *irq = irq_dispatch_and_lock(i);

  • kernel/arch/arm32/src/machine_func.c

    r0c61955 r20235a3  
    3939
    4040#include <arch/machine_func.h>
     41#include <arch/mach/gta02/gta02.h>
    4142#include <arch/mach/integratorcp/integratorcp.h>
    4243#include <arch/mach/testarm/testarm.h>
    … …  
    4849void machine_ops_init(void)
    4950{
    50 #if defined(MACHINE_testarm)
     51#if defined(MACHINE_gta02)
     52        machine_ops = &gta02_machine_ops;
     53#elif defined(MACHINE_testarm)
    5154        machine_ops = &gxemul_machine_ops;
    5255#elif defined(MACHINE_integratorcp)
    … …  
    7780}
    7881
    79 
    80 /** Returns size of available memory.
     82/** Get extents of available memory.
    8183 *
    82  *  @return Size of available memory.
     84 * @param start         Place to store memory start address.
     85 * @param size          Place to store memory size.
    8386 */
    84 uintptr_t machine_get_memory_size(void)
     87void machine_get_memory_extents(uintptr_t *start, uintptr_t *size)
    8588{
    86         return (machine_ops->machine_get_memory_size)();
     89        (machine_ops->machine_get_memory_extents)(start, size);
    8790}
    8891
    … …  
    122125}
    123126
     127/** Get IRQ number range used by machine. */
     128size_t machine_get_irq_count(void)
     129{
     130        return (machine_ops->machine_get_irq_count)();
     131}
     132
    124133/** @}
    125134 */

  • kernel/arch/arm32/src/mm/frame.c

    r0c61955 r20235a3  
    3838#include <arch/machine_func.h>
    3939#include <config.h>
     40#include <align.h>
    4041
    4142/** Address of the last frame in the memory. */
    … …  
    4546void frame_arch_init(void)
    4647{
    47         last_frame = machine_get_memory_size();
     48        uintptr_t mem_start, mem_size;
     49        uintptr_t first_frame;
     50        uintptr_t num_frames;
     51
     52        machine_get_memory_extents(&mem_start, &mem_size);
     53        first_frame = ALIGN_UP(mem_start, FRAME_SIZE);
     54        last_frame = ALIGN_DOWN(mem_start + mem_size, FRAME_SIZE);
     55        num_frames = (last_frame - first_frame) >> FRAME_WIDTH;
    4856       
    4957        /* All memory as one zone */
    50         zone_create(0, ADDR2PFN(last_frame),
     58        zone_create(first_frame >> FRAME_WIDTH, num_frames,
    5159            BOOT_PAGE_TABLE_START_FRAME + BOOT_PAGE_TABLE_SIZE_IN_FRAMES, 0);
    5260       

  • kernel/arch/arm32/src/mm/page.c

    r0c61955 r20235a3  
    5858        uintptr_t cur;
    5959        /* Kernel identity mapping */
    60         for (cur = 0; cur < last_frame; cur += FRAME_SIZE)
     60        for (cur = PHYSMEM_START_ADDR; cur < last_frame; cur += FRAME_SIZE)
    6161                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    6262       
    … …  
    6868#error "Only high exception vector supported now"
    6969#endif
     70        cur = ALIGN_DOWN(0x50008010, FRAME_SIZE);
     71        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    7072
    7173        page_table_unlock(AS_KERNEL, true);

  • kernel/arch/arm32/src/userspace.c

    r0c61955 r20235a3  
    9797                "mov sp, %[ustate]\n"
    9898                "msr spsr_c, %[user_mode]\n"
    99                 "ldmfd sp!, {r0-r12, sp, lr}^\n"
     99                "ldmfd sp, {r0-r12, sp, lr}^\n"
     100                "nop\n"         /* Cannot access sp immediately after ldm(2) */
     101                "add sp, sp, #(15*4)\n"
    100102                "ldmfd sp!, {pc}^\n"
    101103                :: [ustate] "r" (&ustate), [user_mode] "r" (user_mode)

  • kernel/arch/ia32/include/bios/bios.h

    r0c61955 r20235a3  
    3838#include <typedefs.h>
    3939
    40 #define BIOS_EBDA_PTR  0x40e
    41 
    4240extern uintptr_t ebda;
    4341

  • kernel/arch/ia32/include/mm/as.h

    r0c61955 r20235a3  
    2727 */
    2828
    29 /** @addtogroup ia32mm 
     29/** @addtogroup ia32mm
    3030 * @{
    3131 */

  • kernel/arch/ia32/include/mm/page.h

    r0c61955 r20235a3  
    2727 */
    2828
    29 /** @addtogroup ia32mm 
     29/** @addtogroup ia32mm
    3030 * @{
    3131 */
    … …  
    106106
    107107/* Set PTE flags accessors for each level. */
    108 #define SET_PTL1_FLAGS_ARCH(ptl0, i, x) \
     108#define SET_PTL1_FLAGS_ARCH(ptl0, i, x) \
    109109        set_pt_flags((pte_t *) (ptl0), (size_t) (i), (x))
    110110#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)

  • kernel/arch/ia32/include/pm.h

    r0c61955 r20235a3  
    5858#endif /* CONFIG_FB */
    5959
    60 #define gdtselector(des)  ((des) << 3)
     60#define GDT_SELECTOR(des)  ((des) << 3)
    6161
    6262#define PL_KERNEL  0
    … …  
    153153
    154154extern ptr_16_32_t gdtr;
    155 extern ptr_16_32_t bootstrap_gdtr;
    156155extern ptr_16_32_t protected_ap_gdtr;
    157156extern tss_t *tss_p;

  • kernel/arch/ia32/src/asm.S

    r0c61955 r20235a3  
    225225         * Switch to kernel selectors.
    226226         */
    227         movw $(gdtselector(KDATA_DES)), %ax
     227        movw $(GDT_SELECTOR(KDATA_DES)), %ax
    228228        movw %ax, %ds
    229229        movw %ax, %es
    … …  
    304304         * Switch to kernel selectors.
    305305         */
    306         movl $(gdtselector(KDATA_DES)), %eax
     306        movl $(GDT_SELECTOR(KDATA_DES)), %eax
    307307        movl %eax, %ds
    308308        movl %eax, %es
    … …  
    407407         * Switch to kernel selectors.
    408408         */
    409         movl $(gdtselector(KDATA_DES)), %eax
     409        movl $(GDT_SELECTOR(KDATA_DES)), %eax
    410410        movl %eax, %ds
    411411        movl %eax, %es
    … …  
    416416         */
    417417        xorl %eax, %eax
    418         cmpl $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
     418        cmpl $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
    419419        cmovnzl %eax, %ebp
    420420

  • kernel/arch/ia32/src/bios/bios.c

    r0c61955 r20235a3  
    3636#include <typedefs.h>
    3737
     38#define BIOS_EBDA_PTR  0x40e
     39
    3840uintptr_t ebda = 0;
    3941

  • kernel/arch/ia32/src/boot/boot.S

    r0c61955 r20235a3  
    7878       
    7979        /* Initialize Global Descriptor Table register */
    80         lgdtl KA2PA(bootstrap_gdtr)
     80        lgdtl bootstrap_gdtr
    8181       
    8282        /* Kernel data + stack */
    83         movw $gdtselector(KDATA_DES), %cx
     83        movw $GDT_SELECTOR(KDATA_DES), %cx
    8484        movw %cx, %es
    8585        movw %cx, %fs
    … …  
    8888        movw %cx, %ss
    8989       
    90         jmpl $gdtselector(KTEXT_DES), $multiboot_meeting_point
     90        jmpl $GDT_SELECTOR(KTEXT_DES), $multiboot_meeting_point
    9191        multiboot_meeting_point:
    9292       
    … …  
    514514page_directory:
    515515        .space 4096, 0
     516
     517bootstrap_gdtr:
     518        .word GDT_SELECTOR(GDT_ITEMS)
     519        .long KA2PA(gdt)
    516520
    517521grub_eax:

  • kernel/arch/ia32/src/boot/vesa_real.inc

    r0c61955 r20235a3  
    3030.code32
    3131vesa_init:
    32         jmp $gdtselector(VESA_INIT_DES), $vesa_init_real - vesa_init
     32        jmp $GDT_SELECTOR(VESA_INIT_DES), $vesa_init_real - vesa_init
    3333
    3434.code16
    … …  
    335335                vesa_leave_real2:
    336336               
    337                         ljmpl $gdtselector(KTEXT32_DES), $(vesa_init_protected - vesa_init + VESA_INIT_SEGMENT << 4)
     337                        ljmpl $GDT_SELECTOR(KTEXT32_DES), $(vesa_init_protected - vesa_init + VESA_INIT_SEGMENT << 4)
    338338       
    339339        no_mode:

  • kernel/arch/ia32/src/boot/vesa_ret.inc

    r0c61955 r20235a3  
    77       
    88        /* Kernel data + stack */
    9         movw $gdtselector(KDATA_DES), %cx
     9        movw $GDT_SELECTOR(KDATA_DES), %cx
    1010        movw %cx, %es
    1111        movw %cx, %fs
    … …  
    1414        movw %cx, %ss
    1515       
    16         jmpl $gdtselector(KTEXT_DES), $vesa_meeting_point
     16        jmpl $GDT_SELECTOR(KTEXT_DES), $vesa_meeting_point

  • kernel/arch/ia32/src/ddi/ddi.c

    r0c61955 r20235a3  
    153153         */
    154154        gdt_p[TSS_DES].access = AR_PRESENT | AR_TSS | DPL_KERNEL;
    155         tr_load(gdtselector(TSS_DES));
     155        tr_load(GDT_SELECTOR(TSS_DES));
    156156       
    157157        /*

  • kernel/arch/ia32/src/mm/frame.c

    r0c61955 r20235a3  
    131131                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
    132132                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
    133                 }
    134                
    135                 if (e820table[i].type == MEMMAP_MEMORY_RESERVED) {
     133                } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
     134                    (e820table[i].type == MEMMAP_MEMORY_NVS)) {
     135                        /* To be safe, make the firmware zone possibly larger */
     136                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
     137                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
     138                            FRAME_SIZE);
     139                       
     140                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
     141                            ZONE_FIRMWARE);
     142                } else {
    136143                        /* To be safe, make the reserved zone possibly larger */
    137144                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
    … …  
    141148                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
    142149                            ZONE_RESERVED);
    143                 }
    144                
    145                 if (e820table[i].type == MEMMAP_MEMORY_ACPI) {
    146                         /* To be safe, make the firmware zone possibly larger */
    147                         uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
    148                         uint64_t new_size = ALIGN_UP(size + (base - new_base),
    149                             FRAME_SIZE);
    150                        
    151                         zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
    152                             ZONE_FIRMWARE);
    153150                }
    154151        }
    … …  
    203200#ifdef CONFIG_SMP
    204201                /* Reserve AP real mode bootstrap memory */
    205                 frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH, 
     202                frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH,
    206203                    (hardcoded_unmapped_ktext_size +
    207204                    hardcoded_unmapped_kdata_size) >> FRAME_WIDTH);

  • kernel/arch/ia32/src/pm.c

    r0c61955 r20235a3  
    7575        /* VESA Init descriptor */
    7676#ifdef CONFIG_FB
    77         { 0xffff, 0, VESA_INIT_SEGMENT>>12, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
    78 #endif 
     77        { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
     78#endif
    7979};
    8080
    … …  
    8686
    8787/* gdtr is changed by kmp before next CPU is initialized */
    88 ptr_16_32_t bootstrap_gdtr = { .limit = sizeof(gdt), .base = KA2PA((uintptr_t) gdt) };
    89 ptr_16_32_t gdtr = { .limit = sizeof(gdt), .base = (uintptr_t) gdt };
     88ptr_16_32_t gdtr = {
     89        .limit = sizeof(gdt),
     90        .base = (uintptr_t) gdt
     91};
    9092
    9193void gdt_setbase(descriptor_t *d, uintptr_t base)
    … …  
    128130
    129131                d->unused = 0;
    130                 d->selector = gdtselector(KTEXT_DES);
     132                d->selector = GDT_SELECTOR(KTEXT_DES);
    131133
    132134                if (i == VECTOR_SYSCALL) {
    … …  
    283285         * to its own TSS. We just need to load the TR register.
    284286         */
    285         tr_load(gdtselector(TSS_DES));
     287        tr_load(GDT_SELECTOR(TSS_DES));
    286288       
    287289        clean_IOPL_NT_flags();    /* Disable I/O on nonprivileged levels and clear NT flag. */

  • kernel/arch/ia32/src/proc/scheduler.c

    r0c61955 r20235a3  
    6767        /* Set kernel stack for CPL3 -> CPL0 switch via interrupt */
    6868        CPU->arch.tss->esp0 = kstk;
    69         CPU->arch.tss->ss0 = gdtselector(KDATA_DES);
     69        CPU->arch.tss->ss0 = GDT_SELECTOR(KDATA_DES);
    7070       
    7171        /* Set up TLS in GS register */

  • kernel/arch/ia32/src/syscall.c

    r0c61955 r20235a3  
    4545
    4646        /* set kernel mode CS selector */
    47         write_msr(IA32_MSR_SYSENTER_CS, gdtselector(KTEXT_DES));
     47        write_msr(IA32_MSR_SYSENTER_CS, GDT_SELECTOR(KTEXT_DES));
    4848        /* set kernel mode entry point */
    4949        write_msr(IA32_MSR_SYSENTER_EIP, (uint32_t) sysenter_handler);

  • kernel/arch/ia32/src/userspace.c

    r0c61955 r20235a3  
    7575                "iret\n"
    7676                :
    77                 : [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
     77                : [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
    7878                  [stack_size] "r" ((uint8_t *) kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
    7979                  [ipl] "r" (ipl),
    80                   [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
     80                  [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
    8181                  [entry] "r" (kernel_uarg->uspace_entry),
    8282                  [uarg] "r" (kernel_uarg->uspace_uarg),
    83                   [tls_des] "r" (gdtselector(TLS_DES))
     83                  [tls_des] "r" (GDT_SELECTOR(TLS_DES))
    8484                : "eax");
    8585       

  • kernel/genarch/Makefile.inc

    r0c61955 r20235a3  
    9090endif
    9191
     92ifeq ($(CONFIG_S3C24XX_IRQC),y)
     93        GENARCH_SOURCES += \
     94                genarch/src/drivers/s3c24xx_irqc/s3c24xx_irqc.c
     95endif
     96
     97ifeq ($(CONFIG_S3C24XX_UART),y)
     98        GENARCH_SOURCES += \
     99                genarch/src/drivers/s3c24xx_uart/s3c24xx_uart.c
     100endif
     101
    92102ifeq ($(CONFIG_Z8530),y)
    93103        GENARCH_SOURCES += \

  • kernel/generic/include/macros.h

    r0c61955 r20235a3  
    4747 * @param s2  Start address of the second interval.
    4848 * @param sz2 Size of the second interval.
     49 *
    4950 */
    50 NO_TRACE static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2,
    51     size_t sz2)
     51NO_TRACE static inline int overlaps(uint64_t s1, uint64_t sz1, uint64_t s2,
     52    uint64_t sz2)
    5253{
    53         uintptr_t e1 = s1 + sz1;
    54         uintptr_t e2 = s2 + sz2;
     54        uint64_t e1 = s1 + sz1;
     55        uint64_t e2 = s2 + sz2;
    5556       
    5657        return ((s1 < e2) && (s2 < e1));
     58}
     59
     60/** Return true if the second interval is within the first interval.
     61 *
     62 * @param s1  Start address of the first interval.
     63 * @param sz1 Size of the first interval.
     64 * @param s2  Start address of the second interval.
     65 * @param sz2 Size of the second interval.
     66 *
     67 */
     68NO_TRACE static inline int iswithin(uint64_t s1, uint64_t sz1, uint64_t s2,
     69    uint64_t sz2)
     70{
     71        uint64_t e1 = s1 + sz1;
     72        uint64_t e2 = s2 + sz2;
     73       
     74        return ((s1 <= s2) && (e1 >= e2));
    5775}
    5876
    … …  
    7492
    7593/* Compute overlapping of physical addresses */
    76 #define PA_overlaps(x, szx, y, szy) \
     94#define PA_OVERLAPS(x, szx, y, szy) \
    7795        overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
    7896

  • kernel/generic/src/main/main.c

    r0c61955 r20235a3  
    147147        size_t i;
    148148        for (i = 0; i < init.cnt; i++) {
    149                 if (PA_overlaps(config.stack_base, config.stack_size,
     149                if (PA_OVERLAPS(config.stack_base, config.stack_size,
    150150                    init.tasks[i].addr, init.tasks[i].size))
    151151                        config.stack_base = ALIGN_UP(init.tasks[i].addr +
    … …  
    155155        /* Avoid placing stack on top of boot allocations. */
    156156        if (ballocs.size) {
    157                 if (PA_overlaps(config.stack_base, config.stack_size,
     157                if (PA_OVERLAPS(config.stack_base, config.stack_size,
    158158                    ballocs.base, ballocs.size))
    159159                        config.stack_base = ALIGN_UP(ballocs.base +

  • kernel/generic/src/mm/frame.c

    r0c61955 r20235a3  
    121121 *
    122122 */
    123 NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count)
     123NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
     124    zone_flags_t flags)
    124125{
    125126        if (zones.count + 1 == ZONES_MAX) {
    … …  
    131132        for (i = 0; i < zones.count; i++) {
    132133                /* Check for overlap */
    133                 if (overlaps(base, count,
    134                     zones.info[i].base, zones.info[i].count)) {
    135                         printf("Zone (%p, %p) overlaps with zone (%p, %p)!\n",
    136                             PFN2ADDR(base), PFN2ADDR(base + count),
    137                             PFN2ADDR(zones.info[i].base),
    138                             PFN2ADDR(zones.info[i].base + zones.info[i].count));
     134                if (overlaps(zones.info[i].base, zones.info[i].count,
     135                    base, count)) {
     136                       
     137                        /*
     138                         * If the overlaping zones are of the same type
     139                         * and the new zone is completely within the previous
     140                         * one, then quietly ignore the new zone.
     141                         *
     142                         */
     143                       
     144                        if ((zones.info[i].flags != flags) ||
     145                            (!iswithin(zones.info[i].base, zones.info[i].count,
     146                            base, count))) {
     147                                printf("Zone (%p, %p) overlaps with previous zone (%p, %p)!\n",
     148                                    PFN2ADDR(base), PFN2ADDR(count),
     149                                    PFN2ADDR(zones.info[i].base),
     150                                    PFN2ADDR(zones.info[i].count));
     151                        }
     152                       
    139153                        return (size_t) -1;
    140154                }
    … …  
    147161        for (j = zones.count; j > i; j--) {
    148162                zones.info[j] = zones.info[j - 1];
    149                 zones.info[j].buddy_system->data =
    150                     (void *) &zones.info[j - 1];
     163                if (zones.info[j].buddy_system != NULL)
     164                        zones.info[j].buddy_system->data =
     165                            (void *) &zones.info[j];
    151166        }
    152167       
    … …  
    748763        for (i = z2 + 1; i < zones.count; i++) {
    749764                zones.info[i - 1] = zones.info[i];
    750                 zones.info[i - 1].buddy_system->data =
    751                     (void *) &zones.info[i - 1];
     765                if (zones.info[i - 1].buddy_system != NULL)
     766                        zones.info[i - 1].buddy_system->data =
     767                            (void *) &zones.info[i - 1];
    752768        }
    753769       
    … …  
    898914                }
    899915               
    900                 size_t znum = zones_insert_zone(start, count);
     916                size_t znum = zones_insert_zone(start, count, flags);
    901917                if (znum == (size_t) -1) {
    902918                        irq_spinlock_unlock(&zones.lock, true);
    … …  
    921937       
    922938        /* Non-available zone */
    923         size_t znum = zones_insert_zone(start, count);
     939        size_t znum = zones_insert_zone(start, count, flags);
    924940        if (znum == (size_t) -1) {
    925941                irq_spinlock_unlock(&zones.lock, true);
Note: See TracChangeset for help on using the changeset viewer.