Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 1066041 in mainline


Ignore:
Timestamp:
2012-07-11T07:58:03Z (10 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial
Children:
935e28c
Parents:
b68ae24
Message:

preemption_disable: Turned functions into macros. Moved THREAD, AS, TASK, CPU into thread.h, as.h, task.h, cpu.h to fix the include hell that ensued.

Location:
kernel
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia32/src/interrupt.c

    rb68ae24 r1066041  
    5555#include <stacktrace.h>
    5656#include <smp/smp_call.h>
     57#include <proc/task.h>
    5758
    5859/*
  • kernel/generic/include/arch.h

    rb68ae24 r1066041  
    3636#define KERN_ARCH_H_
    3737
    38 #include <arch/arch.h>
    39 #include <proc/thread.h>
    40 #include <proc/task.h>
    41 #include <mm/as.h>
     38#include <arch/arch.h>  /* arch_pre_main() */
     39#include <arch/asm.h>   /* get_stack_base() */
     40
    4241
    4342/*
     
    4948#define THE  ((the_t * )(get_stack_base()))
    5049
    51 #define CPU                  THE->cpu
    52 #define THREAD               THE->thread
    53 #define TASK                 THE->task
    54 #define AS                   THE->as
    55 #define PREEMPTION_DISABLED  (0 != THE->preemption_disabled)
    56 #define PREEMPTION_ENABLED   (0 == THE->preemption_disabled)
    5750#define MAGIC                UINT32_C(0xfacefeed)
    5851
     
    6356        ((THE->task) ? (THE->task->container) : (DEFAULT_CONTAINER))
    6457
     58/* Fwd decl. to avoid include hell. */
     59struct thread;
     60struct task;
     61struct cpu;
     62struct as;
     63
    6564/**
    6665 * For each possible kernel stack, structure
     
    6968 */
    7069typedef struct {
    71         size_t preemption_disabled;  /**< Preemption disabled counter. */
    72         thread_t *thread;            /**< Current thread. */
    73         task_t *task;                /**< Current task. */
    74         cpu_t *cpu;                  /**< Executing cpu. */
    75         as_t *as;                    /**< Current address space. */
    76         uint32_t magic;              /**< Magic value */
     70        size_t preemption;     /**< Preemption disabled counter and flag. */
     71        struct thread *thread; /**< Current thread. */
     72        struct task *task;     /**< Current task. */
     73        struct cpu *cpu;       /**< Executing cpu. */
     74        struct as *as;         /**< Current address space. */
     75        uint32_t magic;        /**< Magic value */
    7776} the_t;
    7877
     
    9291extern void *arch_construct_function(fncptr_t *, void *, void *);
    9392
     93
    9494#endif
    9595
  • kernel/generic/include/cpu.h

    rb68ae24 r1066041  
    4343#include <arch/context.h>
    4444#include <adt/list.h>
     45#include <arch.h>
     46
     47#define CPU                  THE->cpu
     48
    4549
    4650/** CPU structure.
  • kernel/generic/include/mm/as.h

    rb68ae24 r1066041  
    4848#include <adt/btree.h>
    4949#include <lib/elf.h>
     50#include <arch.h>
     51
     52#define AS                   THE->as
     53
    5054
    5155/**
  • kernel/generic/include/preemption.h

    rb68ae24 r1066041  
    3636#define KERN_PREEMPTION_H_
    3737
    38 extern void preemption_disable(void);
    39 extern void preemption_enable(void);
    40 extern void preemption_enable_noresched(void);
    41 extern void preemption_enabled_scheduler(void);
     38#include <arch.h>
     39#include <compiler/barrier.h>
     40#include <debug.h>
     41
     42#define PREEMPTION_INC         (1 << 1)
     43#define PREEMPTION_NEEDED_FLAG (1 << 0)
     44#define PREEMPTION_NEEDED      (THE->preemption & PREEMPTION_NEEDED_FLAG)
     45#define PREEMPTION_DISABLED    (PREEMPTION_INC <= THE->preemption)
     46#define PREEMPTION_ENABLED     (!PREEMPTION_DISABLED)
     47
     48/** Increment preemption disabled counter. */
     49#define preemption_disable() \
     50        do { \
     51                THE->preemption += PREEMPTION_INC; \
     52                compiler_barrier(); \
     53        } while (0)
     54
     55/** Restores preemption and reschedules if out time slice already elapsed.*/
     56#define preemption_enable() \
     57        do { \
     58                preemption_enable_noresched(); \
     59                \
     60                if (PREEMPTION_ENABLED && PREEMPTION_NEEDED) { \
     61                        preemption_enabled_scheduler(); \
     62                } \
     63        } while (0)
     64
     65/** Restores preemption but never reschedules. */
     66#define preemption_enable_noresched() \
     67        do { \
     68                ASSERT(PREEMPTION_DISABLED); \
     69                compiler_barrier(); \
     70                THE->preemption -= PREEMPTION_INC; \
     71        } while (0)
    4272
    4373
     74extern void preemption_enabled_scheduler(void);
     75extern void preemption_set_needed(void);
     76extern void preemption_clear_needed(void);
    4477
    4578#endif
  • kernel/generic/include/proc/task.h

    rb68ae24 r1066041  
    5757#include <mm/as.h>
    5858#include <abi/sysinfo.h>
     59#include <arch.h>
     60
     61#define TASK                 THE->task
     62
    5963
    6064struct thread;
  • kernel/generic/include/proc/thread.h

    rb68ae24 r1066041  
    4949#include <udebug/udebug.h>
    5050#include <abi/sysinfo.h>
     51#include <arch.h>
     52
     53
     54#define THREAD              THE->thread
    5155
    5256#define THREAD_NAME_BUFLEN  20
     
    155159        state_t state;
    156160       
    157         /** The thread would have been rescheduled had it not disabled preemption.*/
    158         bool need_resched;
    159        
    160161        /** Thread CPU. */
    161162        cpu_t *cpu;
  • kernel/generic/src/console/chardev.c

    rb68ae24 r1066041  
    3939#include <print.h>
    4040#include <func.h>
    41 #include <arch.h>
     41#include <cpu.h>
    4242
    4343/** Initialize input character device.
  • kernel/generic/src/console/console.c

    rb68ae24 r1066041  
    5252#include <errno.h>
    5353#include <str.h>
     54#include <mm/frame.h> /* SIZE2FRAMES */
     55#include <mm/slab.h>  /* malloc */
    5456
    5557#define KLOG_PAGES    8
  • kernel/generic/src/console/kconsole.c

    rb68ae24 r1066041  
    5959#include <putchar.h>
    6060#include <str.h>
     61#include <mm/slab.h>
    6162
    6263/** Simple kernel console.
  • kernel/generic/src/debug/panic.c

    rb68ae24 r1066041  
    9797        if (THE != NULL) {
    9898                printf("pe=%" PRIun " thr=%p task=%p cpu=%p as=%p"
    99                     " magic=%#" PRIx32 "\n", THE->preemption_disabled,
     99                    " magic=%#" PRIx32 "\n", THE->preemption,
    100100                    THE->thread, THE->task, THE->cpu, THE->as, THE->magic);
    101101        } else
  • kernel/generic/src/ipc/kbox.c

    rb68ae24 r1066041  
    4444#include <ipc/kbox.h>
    4545#include <print.h>
     46#include <proc/thread.h>
    4647
    4748void ipc_kbox_cleanup(void)
  • kernel/generic/src/lib/str.c

    rb68ae24 r1066041  
    111111#include <debug.h>
    112112#include <macros.h>
     113#include <mm/slab.h>
    113114
    114115/** Check the condition if wchar_t is signed */
  • kernel/generic/src/main/shutdown.c

    rb68ae24 r1066041  
    3737
    3838#include <arch.h>
     39#include <proc/task.h>
    3940#include <func.h>
    4041#include <print.h>
  • kernel/generic/src/mm/frame.c

    rb68ae24 r1066041  
    6161#include <config.h>
    6262#include <str.h>
     63#include <proc/thread.h> /* THREAD */
    6364
    6465zones_t zones;
  • kernel/generic/src/mm/km.c

    rb68ae24 r1066041  
    4949#include <macros.h>
    5050#include <bitops.h>
     51#include <proc/thread.h>
    5152
    5253static ra_arena_t *km_ni_arena;
  • kernel/generic/src/mm/slab.c

    rb68ae24 r1066041  
    114114#include <bitops.h>
    115115#include <macros.h>
     116#include <cpu.h>
    116117
    117118IRQ_SPINLOCK_STATIC_INITIALIZE(slab_cache_lock);
  • kernel/generic/src/preempt/preemption.c

    rb68ae24 r1066041  
    3737
    3838#include <preemption.h>
    39 #include <arch.h>
    40 #include <compiler/barrier.h>
    41 #include <debug.h>
    4239#include <proc/scheduler.h>
    4340
    44 /** Increment preemption disabled counter. */
    45 void preemption_disable(void)
    46 {
    47         THE->preemption_disabled++;
    48         compiler_barrier();
    49 }
    50 
    51 /** Decrement preemption disabled counter. */
    52 void preemption_enable(void)
    53 {
    54         preemption_enable_noresched();
    55        
    56         if (PREEMPTION_ENABLED && THREAD && THREAD->need_resched) {
    57                 preemption_enabled_scheduler();
    58         }
    59 }
    60 
    61 /** Decrement preemption disabled counter. */
    62 void preemption_enable_noresched(void)
    63 {
    64         ASSERT(PREEMPTION_DISABLED);
    65         compiler_barrier();
    66         THE->preemption_disabled--;
    67 }
    6841
    6942/** Preemption was enabled. Calls scheduler(). */
     
    7144{
    7245        ASSERT(PREEMPTION_ENABLED);
     46        ASSERT(PREEMPTION_NEEDED);
    7347       
    7448        /*
     
    8559}
    8660
     61/** Sets a flag to reschedule the next time preemption is enabled. */
     62void preemption_set_needed(void)
     63{
     64        /* No need to disable interrupts. */
     65        THE->preemption |= PREEMPTION_NEEDED_FLAG;
     66}
     67
     68/** Instructs not to reschedule immediately when preemption is enabled. */
     69void preemption_clear_needed(void)
     70{
     71        /* No need to disable interrupts. */
     72        THE->preemption &= ~PREEMPTION_NEEDED_FLAG;
     73}
     74
    8775/** @}
    8876 */
  • kernel/generic/src/proc/scheduler.c

    rb68ae24 r1066041  
    6565#include <debug.h>
    6666#include <stacktrace.h>
     67#include <cpu.h>
    6768
    6869static void scheduler_separated_stack(void);
     
    421422                after_thread_ran();
    422423               
    423                 THREAD->need_resched = false;
     424                preemption_clear_needed();
    424425               
    425426                switch (THREAD->state) {
  • kernel/generic/src/proc/the.c

    rb68ae24 r1066041  
    4343
    4444#include <arch.h>
     45#include <debug.h>
    4546
    4647/** Initialize THE structure
     
    5354void the_initialize(the_t *the)
    5455{
    55         the->preemption_disabled = 0;
     56        the->preemption = 0;
    5657        the->cpu = NULL;
    5758        the->thread = NULL;
  • kernel/generic/src/proc/thread.c

    rb68ae24 r1066041  
    375375        thread->nomigrate = 0;
    376376        thread->state = Entering;
    377         thread->need_resched = false;
    378377       
    379378        timeout_initialize(&thread->sleep_timeout);
  • kernel/generic/src/smp/smp_call.c

    rb68ae24 r1066041  
    3737
    3838#include <smp/smp_call.h>
     39#include <arch/barrier.h>
     40#include <arch/asm.h>  /* interrupt_disable */
    3941#include <arch.h>
    4042#include <config.h>
    4143#include <preemption.h>
    42 #include <arch/barrier.h>
    43 #include <arch/asm.h>  /* interrupt_disable */
    44 
     44#include <debug.h>
     45#include <cpu.h>
    4546
    4647static void call_start(smp_call_t *call_info, smp_call_func_t func, void *arg);
  • kernel/generic/src/synch/mutex.c

    rb68ae24 r1066041  
    4141#include <arch.h>
    4242#include <stacktrace.h>
     43#include <cpu.h>
     44#include <proc/thread.h>
    4345
    4446/** Initialize mutex.
  • kernel/generic/src/synch/smc.c

    rb68ae24 r1066041  
    4141#include <arch/barrier.h>
    4242#include <synch/smc.h>
     43#include <mm/as.h>
    4344
    4445sysarg_t sys_smc_coherence(uintptr_t va, size_t size)
  • kernel/generic/src/synch/spinlock.c

    rb68ae24 r1066041  
    4545#include <symtab.h>
    4646#include <stacktrace.h>
     47#include <cpu.h>
    4748
    4849#ifdef CONFIG_SMP
  • kernel/generic/src/time/clock.c

    rb68ae24 r1066041  
    225225#endif
    226226                        } else {
    227                                 THREAD->need_resched = true;
     227                                preemption_set_needed();
    228228                        }
    229229                }
  • kernel/generic/src/udebug/udebug.c

    rb68ae24 r1066041  
    4444#include <print.h>
    4545#include <arch.h>
     46#include <proc/task.h>
     47#include <proc/thread.h>
    4648
    4749/** Initialize udebug part of task structure.
  • kernel/test/smpcall/smpcall1.c

    rb68ae24 r1066041  
    1111#include <config.h>
    1212#include <arch.h>
     13#include <proc/thread.h>
    1314
    1415/*
Note: See TracChangeset for help on using the changeset viewer.