Changeset 0b9ac3c in mainline for kernel/generic


Ignore:
Timestamp:
2010-02-23T19:03:28Z (16 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c62d2e1
Parents:
1ccafee (diff), 5e50394 (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/generic
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/atomic.h

    r1ccafee r0b9ac3c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ATOMIC_H_
    3737
     38#include <arch/types.h>
     39
    3840typedef struct atomic {
    39         volatile long count;
     41        volatile atomic_count_t count;
    4042} atomic_t;
    4143
    4244#include <arch/atomic.h>
    4345
    44 static inline void atomic_set(atomic_t *val, long i)
     46static inline void atomic_set(atomic_t *val, atomic_count_t i)
    4547{
    4648        val->count = i;
    4749}
    4850
    49 static inline long atomic_get(atomic_t *val)
     51static inline atomic_count_t atomic_get(atomic_t *val)
    5052{
    5153        return val->count;

  • kernel/generic/include/console/console.h

    r1ccafee r0b9ac3c  
    4141extern indev_t *stdin;
    4242extern outdev_t *stdout;
    43 extern bool silent;
    4443
    4544extern indev_t *stdin_wire(void);

  • kernel/generic/include/context.h

    r1ccafee r0b9ac3c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3939#include <arch/context.h>
    4040
     41#define context_set_generic(ctx, _pc, stack, size) \
     42        (ctx)->pc = (uintptr_t) (_pc); \
     43        (ctx)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
    4144
    42 #ifndef context_set
    43 #define context_set(c, _pc, stack, size)        \
    44         (c)->pc = (uintptr_t) (_pc);            \
    45         (c)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
    46 #endif /* context_set */
    47 
    48 extern int context_save_arch(context_t *c) __attribute__ ((returns_twice));
    49 extern void context_restore_arch(context_t *c) __attribute__ ((noreturn));
     45extern int context_save_arch(context_t *ctx) __attribute__((returns_twice));
     46extern void context_restore_arch(context_t *ctx) __attribute__((noreturn));
    5047
    5148/** Save register context.
    … …  
    7370 * saved like that would therefore lead to a disaster.
    7471 *
    75  * @param c             Context structure.
     72 * @param ctx Context structure.
    7673 *
    77  * @return              context_save() returns 1, context_restore() returns 0.
     74 * @return context_save() returns 1, context_restore() returns 0.
     75 *
    7876 */
    79 #define context_save(c)   context_save_arch(c)
     77#define context_save(ctx)  context_save_arch(ctx)
    8078
    8179/** Restore register context.
    … …  
    8886 * being return value.
    8987 *
    90  * @param c             Context structure.
     88 * @param ctx Context structure.
    9189 */
    92 static inline void context_restore(context_t *c)
     90static inline void context_restore(context_t *ctx)
    9391{
    94         context_restore_arch(c);
     92        context_restore_arch(ctx);
    9593}
    9694

  • kernel/generic/include/cpu.h

    r1ccafee r0b9ac3c  
    4848 * There is one structure like this for every processor.
    4949 */
    50 typedef struct {
     50typedef struct cpu {
    5151        SPINLOCK_DECLARE(lock);
    5252

  • kernel/generic/include/func.h

    r1ccafee r0b9ac3c  
    4141extern atomic_t haltstate;
    4242
    43 extern void halt(void);
     43extern void halt(void) __attribute__((noreturn));
    4444extern unative_t atoi(const char *text);
    4545extern void order(const uint64_t val, uint64_t *rv, char *suffix);

  • kernel/generic/include/interrupt.h

    r1ccafee r0b9ac3c  
    5151void exc_init(void);
    5252
     53extern void irq_initialize_arch(irq_t *irq);
     54
    5355#endif
    5456

  • kernel/generic/include/ipc/ipc.h

    r1ccafee r0b9ac3c  
    227227#ifdef KERNEL
    228228
    229 #define IPC_MAX_PHONES  16
     229#define IPC_MAX_PHONES  32
    230230
    231231#include <synch/spinlock.h>

  • kernel/generic/include/macros.h

    r1ccafee r0b9ac3c  
    8484#define STRING_ARG(arg)  #arg
    8585
    86 #define LOWER32(arg)  ((arg) & 0xffffffff)
    87 #define UPPER32(arg)  (((arg) >> 32) & 0xffffffff)
     86#define LOWER32(arg)  (((uint64_t) (arg)) & 0xffffffff)
     87#define UPPER32(arg)  (((((uint64_t) arg)) >> 32) & 0xffffffff)
    8888
    8989#define MERGE_LOUP32(lo, up) \

  • kernel/generic/include/panic.h

    r1ccafee r0b9ac3c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3636#define KERN_PANIC_H_
    3737
     38#include <typedefs.h>
    3839#include <stacktrace.h>
    3940#include <print.h>
    … …  
    4243#       define panic(format, ...) \
    4344                do { \
     45                        silent = false; \
    4446                        printf("Kernel panic in %s() at %s:%u.\n", \
    4547                            __func__, __FILE__, __LINE__); \
    … …  
    5052#else
    5153#       define panic(format, ...) \
    52                 panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__);
     54                do { \
     55                        silent = false; \
     56                        panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__); \
     57                } while (0)
    5358#endif
     59
     60extern bool silent;
    5461
    5562extern void panic_printf(char *fmt, ...) __attribute__((noreturn));

  • kernel/generic/include/smp/ipi.h

    r1ccafee r0b9ac3c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3737
    3838#ifdef CONFIG_SMP
    39 extern void ipi_broadcast(int ipi);
    40 extern void ipi_broadcast_arch(int ipi);
     39
     40extern void ipi_broadcast(int);
     41extern void ipi_broadcast_arch(int);
     42
    4143#else
    42 #define ipi_broadcast(x)        ;
     44
     45        #define ipi_broadcast(ipi)
     46
    4347#endif /* CONFIG_SMP */
    4448

  • kernel/generic/include/stacktrace.h

    r1ccafee r0b9ac3c  
    6060 */
    6161extern uintptr_t frame_pointer_get(void);
    62 extern uintptr_t program_counter_get();
     62extern uintptr_t program_counter_get(void);
    6363
    6464extern bool kernel_frame_pointer_validate(uintptr_t);

  • kernel/generic/src/console/console.c

    r1ccafee r0b9ac3c  
    4545#include <ipc/irq.h>
    4646#include <arch.h>
     47#include <panic.h>
    4748#include <print.h>
    4849#include <putchar.h>

  • kernel/generic/src/ddi/ddi.c

    r1ccafee r0b9ac3c  
    146146                    (btree_key_t) pf, &nodep);
    147147               
    148                 if ((!parea) || (parea->frames < pages))
     148                if ((!parea) || (parea->frames < pages)) {
     149                        spinlock_unlock(&parea_lock);
    149150                        goto err;
     151                }
    150152               
    151153                spinlock_unlock(&parea_lock);
    … …  
    153155        }
    154156       
     157        spinlock_unlock(&zones.lock);
    155158err:
    156         spinlock_unlock(&zones.lock);
    157159        interrupts_restore(ipl);
    158160        return ENOENT;

  • kernel/generic/src/ddi/irq.c

    r1ccafee r0b9ac3c  
    7474#include <synch/spinlock.h>
    7575#include <console/console.h>
     76#include <interrupt.h>
    7677#include <memstr.h>
    7778#include <arch.h>
    … …  
    169170        irq->inr = -1;
    170171        irq->devno = -1;
     172
     173        irq_initialize_arch(irq);
    171174}
    172175

  • kernel/generic/src/ipc/ipc.c

    r1ccafee r0b9ac3c  
    212212 *
    213213 * @param call          Call structure to be answered.
    214  */
    215 static void _ipc_answer_free_call(call_t *call)
     214 * @param selflocked    If true, then TASK->answebox is locked.
     215 */
     216static void _ipc_answer_free_call(call_t *call, bool selflocked)
    216217{
    217218        answerbox_t *callerbox = call->callerbox;
     219        bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
    218220
    219221        call->flags |= IPC_CALL_ANSWERED;
    … …  
    226228        }
    227229
    228         spinlock_lock(&callerbox->lock);
     230        if (do_lock)
     231                spinlock_lock(&callerbox->lock);
    229232        list_append(&call->link, &callerbox->answers);
    230         spinlock_unlock(&callerbox->lock);
     233        if (do_lock)
     234                spinlock_unlock(&callerbox->lock);
    231235        waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
    232236}
    … …  
    244248        spinlock_unlock(&box->lock);
    245249        /* Send back answer */
    246         _ipc_answer_free_call(call);
     250        _ipc_answer_free_call(call, false);
    247251}
    248252
    … …  
    261265        atomic_inc(&phone->active_calls);
    262266        IPC_SET_RETVAL(call->data, err);
    263         _ipc_answer_free_call(call);
     267        _ipc_answer_free_call(call, false);
    264268}
    265269
    … …  
    300304                if (call->flags & IPC_CALL_FORWARDED) {
    301305                        IPC_SET_RETVAL(call->data, EFORWARD);
    302                         _ipc_answer_free_call(call);
     306                        _ipc_answer_free_call(call, false);
    303307                } else {
    304308                        if (phone->state == IPC_PHONE_HUNGUP)
    … …  
    455459
    456460                IPC_SET_RETVAL(call->data, EHANGUP);
    457                 _ipc_answer_free_call(call);
     461                _ipc_answer_free_call(call, true);
    458462        }
    459463}

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

    r1ccafee r0b9ac3c  
    9494void kinit(void *arg)
    9595{
    96 
    9796#if defined(CONFIG_SMP) || defined(CONFIG_KCONSOLE)
    9897        thread_t *thread;
    … …  
    217216                }
    218217        }
    219        
     218
    220219        /*
    221220         * Run user tasks.
    … …  
    225224                        program_ready(&programs[i]);
    226225        }
    227        
     226
    228227#ifdef CONFIG_KCONSOLE
    229228        if (!stdin) {

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

    r1ccafee r0b9ac3c  
    952952        if (!THREAD)
    953953                return AS_PF_FAULT;
    954                
    955         ASSERT(AS);
    956 
     954       
     955        if (!AS)
     956                return AS_PF_FAULT;
     957       
    957958        mutex_lock(&AS->lock);
    958         area = find_area_and_lock(AS, page);   
     959        area = find_area_and_lock(AS, page);
    959960        if (!area) {
    960961                /*

  • kernel/generic/src/proc/scheduler.c

    r1ccafee r0b9ac3c  
    542542{
    543543        thread_t *t;
    544         int count, average, j, k = 0;
     544        int count;
     545        atomic_count_t average;
    545546        unsigned int i;
     547        int j;
     548        int k = 0;
    546549        ipl_t ipl;
    547550

  • kernel/generic/src/smp/ipi.c

    r1ccafee r0b9ac3c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3333/**
    3434 * @file
    35  * @brief       Generic IPI interface.
     35 * @brief Generic IPI interface.
    3636 */
    37  
     37
    3838#ifdef CONFIG_SMP
    3939
    4040#include <smp/ipi.h>
    4141#include <config.h>
    42 
    4342
    4443/** Broadcast IPI message
    … …  
    4948 *
    5049 * @bug The decision whether to actually send the IPI must be based
    51  *      on a different criterion. The current version has
    52  *      problems when some of the detected CPUs are marked
    53  *      disabled in machine configuration.
     50 *      on a different criterion. The current version has
     51 *      problems when some of the detected CPUs are marked
     52 *      disabled in machine configuration.
    5453 */
    5554void ipi_broadcast(int ipi)
    … …  
    6059         * - if there is only one CPU but the kernel was compiled with CONFIG_SMP
    6160         */
    62 
     61       
    6362        if ((config.cpu_active > 1) && (config.cpu_active == config.cpu_count))
    6463                ipi_broadcast_arch(ipi);
Note: See TracChangeset for help on using the changeset viewer.