Changeset df29f24 in mainline for kernel/generic


Ignore:
Timestamp:
2011-06-01T09:04:08Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0a7627b, c9f0975
Parents:
e51a514 (diff), 5d1b3aa (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

Conflicts - trivial to solve
In kernel/generic/src/mm/page.c - sys_page_find_mapping does
not use locking when accessing page tables (hope that is correct).

Location:
kernel/generic
Files:
37 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/adt/list.h

    re51a514 rdf29f24  
    4141/** Doubly linked list head and link type. */
    4242typedef struct link {
    43         struct link *prev;      /**< Pointer to the previous item in the list. */
    44         struct link *next;      /**< Pointer to the next item in the list. */
     43        struct link *prev;  /**< Pointer to the previous item in the list. */
     44        struct link *next;  /**< Pointer to the next item in the list. */
    4545} link_t;
    4646
    … …  
    4848 *
    4949 * @param name Name of the new statically allocated list.
     50 *
    5051 */
    5152#define LIST_INITIALIZE(name) \
    52         link_t name = { .prev = &name, .next = &name }
     53        link_t name = { \
     54                .prev = &name, \
     55                .next = &name \
     56        }
     57
     58#define list_get_instance(link, type, member) \
     59        ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
     60
     61#define list_foreach(list, iterator) \
     62        for (link_t *iterator = (list).next; \
     63            iterator != &(list); iterator = iterator->next)
    5364
    5465/** Initialize doubly-linked circular list link
    … …  
    5768 *
    5869 * @param link Pointer to link_t structure to be initialized.
     70 *
    5971 */
    6072NO_TRACE static inline void link_initialize(link_t *link)
    … …  
    6880 * Initialize doubly-linked circular list.
    6981 *
    70  * @param head Pointer to link_t structure representing head of the list.
    71  */
    72 NO_TRACE static inline void list_initialize(link_t *head)
    73 {
    74         head->prev = head;
    75         head->next = head;
     82 * @param list Pointer to link_t structure representing the list.
     83 *
     84 */
     85NO_TRACE static inline void list_initialize(link_t *list)
     86{
     87        list->prev = list;
     88        list->next = list;
    7689}
    7790
    … …  
    8194 *
    8295 * @param link Pointer to link_t structure to be added.
    83  * @param head Pointer to link_t structure representing head of the list.
    84  */
    85 NO_TRACE static inline void list_prepend(link_t *link, link_t *head)
    86 {
    87         link->next = head->next;
    88         link->prev = head;
    89         head->next->prev = link;
    90         head->next = link;
     96 * @param list Pointer to link_t structure representing the list.
     97 *
     98 */
     99NO_TRACE static inline void list_prepend(link_t *link, link_t *list)
     100{
     101        link->next = list->next;
     102        link->prev = list;
     103        list->next->prev = link;
     104        list->next = link;
    91105}
    92106
    … …  
    96110 *
    97111 * @param link Pointer to link_t structure to be added.
    98  * @param head Pointer to link_t structure representing head of the list.
    99  */
    100 NO_TRACE static inline void list_append(link_t *link, link_t *head)
    101 {
    102         link->prev = head->prev;
    103         link->next = head;
    104         head->prev->next = link;
    105         head->prev = link;
     112 * @param list Pointer to link_t structure representing the list.
     113 *
     114 */
     115NO_TRACE static inline void list_append(link_t *link, link_t *list)
     116{
     117        link->prev = list->prev;
     118        link->next = list;
     119        list->prev->next = link;
     120        list->prev = link;
     121}
     122
     123/** Insert item before another item in doubly-linked circular list.
     124 *
     125 */
     126static inline void list_insert_before(link_t *link, link_t *list)
     127{
     128        list_append(link, list);
     129}
     130
     131/** Insert item after another item in doubly-linked circular list.
     132 *
     133 */
     134static inline void list_insert_after(link_t *link, link_t *list)
     135{
     136        list_prepend(list, link);
    106137}
    107138
    … …  
    110141 * Remove item from doubly-linked circular list.
    111142 *
    112  * @param link  Pointer to link_t structure to be removed from the list it is
    113  *              contained in.
     143 * @param link Pointer to link_t structure to be removed from the list
     144 *             it is contained in.
     145 *
    114146 */
    115147NO_TRACE static inline void list_remove(link_t *link)
    … …  
    124156 * Query emptiness of doubly-linked circular list.
    125157 *
    126  * @param head Pointer to link_t structure representing head of the list.
    127  */
    128 NO_TRACE static inline bool list_empty(link_t *head)
    129 {
    130         return head->next == head ? true : false;
    131 }
    132 
     158 * @param list Pointer to link_t structure representing the list.
     159 *
     160 */
     161NO_TRACE static inline int list_empty(link_t *list)
     162{
     163        return (list->next == list);
     164}
     165
     166/** Get head item of a list.
     167 *
     168 * @param list Pointer to link_t structure representing the list.
     169 *
     170 * @return Head item of the list.
     171 * @return NULL if the list is empty.
     172 *
     173 */
     174static inline link_t *list_head(link_t *list)
     175{
     176        return ((list->next == list) ? NULL : list->next);
     177}
    133178
    134179/** Split or concatenate headless doubly-linked circular list
    … …  
    139184 * concatenates splitted lists and splits concatenated lists.
    140185 *
    141  * @param part1 Pointer to link_t structure leading the first (half of the
    142  *              headless) list.
    143  * @param part2 Pointer to link_t structure leading the second (half of the
    144  *              headless) list.
     186 * @param part1 Pointer to link_t structure leading the first
     187 *              (half of the headless) list.
     188 * @param part2 Pointer to link_t structure leading the second
     189 *              (half of the headless) list.
     190 *
    145191 */
    146192NO_TRACE static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
    147193{
    148         link_t *hlp;
    149 
    150194        part1->prev->next = part2;
    151         part2->prev->next = part1;     
    152         hlp = part1->prev;
     195        part2->prev->next = part1;
     196       
     197        link_t *hlp = part1->prev;
     198       
    153199        part1->prev = part2->prev;
    154200        part2->prev = hlp;
    155201}
    156202
    157 
    158203/** Split headless doubly-linked circular list
    159204 *
    160205 * Split headless doubly-linked circular list.
    161206 *
    162  * @param part1 Pointer to link_t structure leading the first half of the
    163  *              headless list.
    164  * @param part2 Pointer to link_t structure leading the second half of the
    165  *              headless list.
     207 * @param part1 Pointer to link_t structure leading
     208 *              the first half of the headless list.
     209 * @param part2 Pointer to link_t structure leading
     210 *              the second half of the headless list.
     211 *
    166212 */
    167213NO_TRACE static inline void headless_list_split(link_t *part1, link_t *part2)
    … …  
    174220 * Concatenate two headless doubly-linked circular lists.
    175221 *
    176  * @param part1 Pointer to link_t structure leading the first headless list.
    177  * @param part2 Pointer to link_t structure leading the second headless list.
     222 * @param part1 Pointer to link_t structure leading
     223 *              the first headless list.
     224 * @param part2 Pointer to link_t structure leading
     225 *              the second headless list.
     226 *
    178227 */
    179228NO_TRACE static inline void headless_list_concat(link_t *part1, link_t *part2)
    … …  
    182231}
    183232
    184 #define list_get_instance(link, type, member) \
    185         ((type *)(((uint8_t *)(link)) - ((uint8_t *)&(((type *)NULL)->member))))
    186 
    187 extern bool list_member(const link_t *link, const link_t *head);
    188 extern void list_concat(link_t *head1, link_t *head2);
     233/** Get n-th item of a list.
     234 *
     235 * @param list Pointer to link_t structure representing the list.
     236 * @param n    Item number (indexed from zero).
     237 *
     238 * @return n-th item of the list.
     239 * @return NULL if no n-th item found.
     240 *
     241 */
     242static inline link_t *list_nth(link_t *list, unsigned int n)
     243{
     244        unsigned int cnt = 0;
     245       
     246        list_foreach(*list, link) {
     247                if (cnt == n)
     248                        return link;
     249               
     250                cnt++;
     251        }
     252       
     253        return NULL;
     254}
     255
     256extern int list_member(const link_t *, const link_t *);
     257extern void list_concat(link_t *, link_t *);
     258extern unsigned int list_count(const link_t *);
    189259
    190260#endif

  • kernel/generic/include/arch.h

    re51a514 rdf29f24  
    4141#include <mm/as.h>
    4242
    43 #define DEFAULT_CONTEXT  0
     43/*
     44 * THE is not an abbreviation, but the English definite article written in
     45 * capital letters. It means the current pointer to something, e.g. thread,
     46 * processor or address space. Kind reader of this comment shall appreciate
     47 * the wit of constructs like THE->thread and similar.
     48 */
     49#define THE  ((the_t * )(get_stack_base()))
    4450
    4551#define CPU                  THE->cpu
    … …  
    4753#define TASK                 THE->task
    4854#define AS                   THE->as
    49 #define CONTEXT              (THE->task ? THE->task->context : DEFAULT_CONTEXT)
    5055#define PREEMPTION_DISABLED  THE->preemption_disabled
     56#define MAGIC                UINT32_C(0xfacefeed)
    5157
    52 #define context_check(ctx1, ctx2)  ((ctx1) == (ctx2))
     58#define container_check(ctn1, ctn2)  ((ctn1) == (ctn2))
     59
     60#define DEFAULT_CONTAINER  0
     61#define CONTAINER \
     62        ((THE->task) ? (THE->task->container) : (DEFAULT_CONTAINER))
    5363
    5464/**
    … …  
    6373        cpu_t *cpu;                  /**< Executing cpu. */
    6474        as_t *as;                    /**< Current address space. */
     75        uint32_t magic;              /**< Magic value */
    6576} the_t;
    66 
    67 /*
    68  * THE is not an abbreviation, but the English definite article written in
    69  * capital letters. It means the current pointer to something, e.g. thread,
    70  * processor or address space. Kind reader of this comment shall appreciate
    71  * the wit of constructs like THE->thread and similar.
    72  */
    73 #define THE  ((the_t * )(get_stack_base()))
    7477
    7578extern void the_initialize(the_t *);

  • kernel/generic/include/config.h

    re51a514 rdf29f24  
    3636#define KERN_CONFIG_H_
    3737
    38 #include <typedefs.h>
    3938#include <arch/mm/page.h>
    4039
    41 #define STACK_SIZE  PAGE_SIZE
     40#define ONE_FRAME    0
     41#define TWO_FRAMES   1
     42#define FOUR_FRAMES  2
     43
     44#define STACK_FRAMES  TWO_FRAMES
     45#define STACK_SIZE    ((1 << STACK_FRAMES) << PAGE_WIDTH)
    4246
    4347#define CONFIG_INIT_TASKS        32
    4448#define CONFIG_TASK_NAME_BUFLEN  32
     49
     50#ifndef __ASM__
     51
     52#include <typedefs.h>
    4553
    4654typedef struct {
    … …  
    8088extern ballocs_t ballocs;
    8189
     90#endif /* __ASM__ */
     91
    8292#endif
    8393

  • kernel/generic/include/cpu.h

    re51a514 rdf29f24  
    4141#include <arch/cpu.h>
    4242#include <arch/context.h>
    43 
    44 #define CPU_STACK_SIZE  STACK_SIZE
    4543
    4644/** CPU structure.

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

    re51a514 rdf29f24  
    4141#include <ipc/ipc.h>
    4242
     43typedef void (*event_callback_t)(void);
     44
    4345/** Event notification structure. */
    4446typedef struct {
    … …  
    5153        /** Counter. */
    5254        size_t counter;
     55       
    5356        /** Masked flag. */
    5457        bool masked;
    5558        /** Unmask callback. */
    56         void (*unmask_cb)(void);
     59        event_callback_t unmask_callback;
    5760} event_t;
    5861
    5962extern void event_init(void);
    6063extern void event_cleanup_answerbox(answerbox_t *);
    61 extern void event_set_unmask_callback(event_type_t, void (*)(void));
     64extern void event_set_unmask_callback(event_type_t, event_callback_t);
    6265
    6366#define event_notify_0(e, m) \

  • kernel/generic/include/mm/as.h

    re51a514 rdf29f24  
    8484#define USER_ADDRESS_SPACE_END      USER_ADDRESS_SPACE_END_ARCH
    8585
    86 #define USTACK_ADDRESS  USTACK_ADDRESS_ARCH
     86#ifdef USTACK_ADDRESS_ARCH
     87        #define USTACK_ADDRESS  USTACK_ADDRESS_ARCH
     88#else
     89        #define USTACK_ADDRESS  (USER_ADDRESS_SPACE_END - (STACK_SIZE - 1))
     90#endif
    8791
    8892/** Kernel address space. */

  • kernel/generic/include/mm/frame.h

    re51a514 rdf29f24  
    4444#include <arch/mm/page.h>
    4545#include <arch/mm/frame.h>
    46 
    47 #define ONE_FRAME    0
    48 #define TWO_FRAMES   1
    49 #define FOUR_FRAMES  2
    50 
    51 
    52 #ifdef ARCH_STACK_FRAMES
    53         #define STACK_FRAMES  ARCH_STACK_FRAMES
    54 #else
    55         #define STACK_FRAMES  ONE_FRAME
    56 #endif
    5746
    5847/** Maximum number of zones in the system. */

  • kernel/generic/include/mm/page.h

    re51a514 rdf29f24  
    3939#include <proc/task.h>
    4040#include <mm/as.h>
    41 #include <memstr.h>
     41#include <arch/mm/page.h>
     42
     43#define P2SZ(pages) \
     44        ((pages) << PAGE_WIDTH)
    4245
    4346/** Operations to manipulate page mappings. */
    … …  
    4548        void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
    4649        void (* mapping_remove)(as_t *, uintptr_t);
    47         pte_t *(* mapping_find)(as_t *, uintptr_t);
     50        pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
    4851} page_mapping_operations_t;
    4952
    … …  
    5659extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5760extern void page_mapping_remove(as_t *, uintptr_t);
    58 extern pte_t *page_mapping_find(as_t *, uintptr_t);
     61extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
    5962extern pte_t *page_table_create(unsigned int);
    6063extern void page_table_destroy(pte_t *);

  • kernel/generic/include/mm/tlb.h

    re51a514 rdf29f24  
    8686extern void tlb_invalidate_asid(asid_t);
    8787extern void tlb_invalidate_pages(asid_t, uintptr_t, size_t);
     88
    8889#endif
    8990

  • kernel/generic/include/proc/task.h

    re51a514 rdf29f24  
    7878        /** Unique identity of task. */
    7979        task_id_t taskid;
    80         /** Task security context. */
    81         context_id_t context;
     80        /** Task security container. */
     81        container_id_t container;
    8282       
    8383        /** Number of references (i.e. threads). */

  • kernel/generic/include/proc/thread.h

    re51a514 rdf29f24  
    4949#include <sysinfo/abi.h>
    5050
    51 #define THREAD_STACK_SIZE   STACK_SIZE
    5251#define THREAD_NAME_BUFLEN  20
    5352

  • kernel/generic/include/proc/uarg.h

    re51a514 rdf29f24  
    4040        void *uspace_entry;
    4141        void *uspace_stack;
    42 
     42       
    4343        void (* uspace_thread_function)();
    4444        void *uspace_thread_arg;

  • kernel/generic/include/synch/waitq.h

    re51a514 rdf29f24  
    6262        int missed_wakeups;
    6363       
    64         /** List of sleeping threads for wich there was no missed_wakeup. */
     64        /** List of sleeping threads for which there was no missed_wakeup. */
    6565        link_t head;
    6666} waitq_t;

  • kernel/generic/include/typedefs.h

    re51a514 rdf29f24  
    6464typedef uint64_t thread_id_t;
    6565typedef uint64_t task_id_t;
    66 typedef uint32_t context_id_t;
     66typedef uint32_t container_id_t;
    6767
    6868typedef int32_t inr_t;

  • kernel/generic/src/adt/list.c

    re51a514 rdf29f24  
    5252 *
    5353 */
    54 bool list_member(const link_t *link, const link_t *head)
     54int list_member(const link_t *link, const link_t *head)
    5555{
    5656        bool found = false;

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

    re51a514 rdf29f24  
    5555#define KLOG_PAGES    8
    5656#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
    57 #define KLOG_LATENCY  8
    5857
    5958/** Kernel log cyclic buffer */
    … …  
    6160
    6261/** Kernel log initialized */
    63 static bool klog_inited = false;
     62static atomic_t klog_inited = {false};
    6463
    6564/** First kernel log characters */
    … …  
    7675
    7776/** Kernel log spinlock */
    78 SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "*klog_lock");
     77SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
    7978
    8079/** Physical memory area used for klog buffer */
    … …  
    165164        sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr);
    166165        sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
    167 
     166       
    168167        event_set_unmask_callback(EVENT_KLOG, klog_update);
    169        
    170         spinlock_lock(&klog_lock);
    171         klog_inited = true;
    172         spinlock_unlock(&klog_lock);
     168        atomic_set(&klog_inited, true);
    173169}
    174170
    … …  
    265261void klog_update(void)
    266262{
     263        if (!atomic_get(&klog_inited))
     264                return;
     265       
    267266        spinlock_lock(&klog_lock);
    268267       
    269         if ((klog_inited) && (klog_uspace > 0)) {
     268        if (klog_uspace > 0) {
    270269                if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len,
    271270                    klog_uspace) == EOK)
    … …  
    278277void putchar(const wchar_t ch)
    279278{
     279        bool ordy = ((stdout) && (stdout->op->write));
     280       
    280281        spinlock_lock(&klog_lock);
    281282       
    282         if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
    283                 /* Print charaters stored in kernel log */
    284                 size_t i;
    285                 for (i = klog_len - klog_stored; i < klog_len; i++)
    286                         stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
    287                 klog_stored = 0;
     283        /* Print charaters stored in kernel log */
     284        if (ordy) {
     285                while (klog_stored > 0) {
     286                        wchar_t tmp = klog[(klog_start + klog_len - klog_stored) % KLOG_LENGTH];
     287                        klog_stored--;
     288                       
     289                        /*
     290                         * We need to give up the spinlock for
     291                         * the physical operation of writting out
     292                         * the character.
     293                         */
     294                        spinlock_unlock(&klog_lock);
     295                        stdout->op->write(stdout, tmp, silent);
     296                        spinlock_lock(&klog_lock);
     297                }
    288298        }
    289299       
    … …  
    295305                klog_start = (klog_start + 1) % KLOG_LENGTH;
    296306       
    297         if ((stdout) && (stdout->op->write))
     307        if (!ordy) {
     308                if (klog_stored < klog_len)
     309                        klog_stored++;
     310        }
     311       
     312        /* The character is stored for uspace */
     313        if (klog_uspace < klog_len)
     314                klog_uspace++;
     315       
     316        spinlock_unlock(&klog_lock);
     317       
     318        if (ordy) {
     319                /*
     320                 * Output the character. In this case
     321                 * it should be no longer buffered.
     322                 */
    298323                stdout->op->write(stdout, ch, silent);
    299         else {
     324        } else {
    300325                /*
    301326                 * No standard output routine defined yet.
    … …  
    307332                 * Note that the early_putc() function might be
    308333                 * a no-op on certain hardware configurations.
    309                  *
    310334                 */
    311335                early_putchar(ch);
    312                
    313                 if (klog_stored < klog_len)
    314                         klog_stored++;
    315         }
    316        
    317         /* The character is stored for uspace */
    318         if (klog_uspace < klog_len)
    319                 klog_uspace++;
    320        
    321         /* Check notify uspace to update */
    322         bool update;
    323         if ((klog_uspace > KLOG_LATENCY) || (ch == '\n'))
    324                 update = true;
    325         else
    326                 update = false;
    327        
    328         spinlock_unlock(&klog_lock);
    329        
    330         if (update)
     336        }
     337       
     338        /* Force notification on newline */
     339        if (ch == '\n')
    331340                klog_update();
    332341}

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

    re51a514 rdf29f24  
    224224        task_t *task = task_find_by_id(id);
    225225       
    226         if ((!task) || (!context_check(CONTEXT, task->context))) {
     226        if ((!task) || (!container_check(CONTAINER, task->container))) {
    227227                /*
    228228                 * There is no task with the specified ID

  • kernel/generic/src/debug/panic.c

    re51a514 rdf29f24  
    9595        printf("\n");
    9696       
     97        printf("THE=%p: ", THE);
     98        if (THE != NULL) {
     99                printf("pe=%" PRIun " thr=%p task=%p cpu=%p as=%p"
     100                    " magic=%#" PRIx32 "\n", THE->preemption_disabled,
     101                    THE->thread, THE->task, THE->cpu, THE->as, THE->magic);
     102        } else
     103                printf("invalid\n");
     104       
    97105        if (istate) {
    98106                istate_decode(istate);

  • kernel/generic/src/interrupt/interrupt.c

    re51a514 rdf29f24  
    205205         * stack.
    206206         */
    207         return (istate_t *) ((uint8_t *) thread->kstack + THREAD_STACK_SIZE -
    208             sizeof(istate_t));
     207        return (istate_t *) ((uint8_t *)
     208            thread->kstack + STACK_SIZE - sizeof(istate_t));
    209209}
    210210

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

    re51a514 rdf29f24  
    5959                events[i].imethod = 0;
    6060                events[i].masked = false;
    61                 events[i].unmask_cb = NULL;
     61                events[i].unmask_callback = NULL;
    6262        }
    6363}
    … …  
    8686/** Define a callback function for the event unmask event.
    8787 *
    88  * @param evno Event type.
    89  * @param cb   Callback function to be called when the event is unmasked.
    90  *
    91  */
    92 void event_set_unmask_callback(event_type_t evno, void (*cb)(void))
    93 {
    94         ASSERT(evno < EVENT_END);
    95        
    96         spinlock_lock(&events[evno].lock);
    97         events[evno].unmask_cb = cb;
     88 * @param evno     Event type.
     89 * @param callback Callback function to be called when
     90 *                 the event is unmasked.
     91 *
     92 */
     93void event_set_unmask_callback(event_type_t evno, event_callback_t callback)
     94{
     95        ASSERT(evno < EVENT_END);
     96       
     97        spinlock_lock(&events[evno].lock);
     98        events[evno].unmask_callback = callback;
    9899        spinlock_unlock(&events[evno].lock);
    99100}
    … …  
    206207static void event_unmask(event_type_t evno)
    207208{
    208         void (*cb)(void);
    209209        ASSERT(evno < EVENT_END);
    210210       
    211211        spinlock_lock(&events[evno].lock);
    212212        events[evno].masked = false;
    213         cb = events[evno].unmask_cb;
     213        event_callback_t callback = events[evno].unmask_callback;
    214214        spinlock_unlock(&events[evno].lock);
    215215       
    216216        /*
    217          * Check if there is an unmask callback function defined for this event.
     217         * Check if there is an unmask callback
     218         * function defined for this event.
    218219         */
    219         if (cb)
    220             cb();
     220        if (callback != NULL)
     221                callback();
    221222}
    222223

  • kernel/generic/src/lib/elf.c

    re51a514 rdf29f24  
    114114        }
    115115       
    116         /* Inspect all section headers and proccess them. */
     116        /* Inspect all section headers and process them. */
    117117        for (i = 0; i < header->e_shnum; i++) {
    118118                elf_section_header_t *sechdr =

  • kernel/generic/src/lib/memfnc.c

    re51a514 rdf29f24  
    5656void *memset(void *dst, int val, size_t cnt)
    5757{
    58         size_t i;
    59         uint8_t *ptr = (uint8_t *) dst;
     58        uint8_t *dp = (uint8_t *) dst;
    6059       
    61         for (i = 0; i < cnt; i++)
    62                 ptr[i] = val;
     60        while (cnt-- != 0)
     61                *dp++ = val;
    6362       
    6463        return dst;
    … …  
    8382       
    8483        while (cnt-- != 0)
    85                         *dp++ = *sp++;
     84                *dp++ = *sp++;
    8685       
    8786        return dst;

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

    re51a514 rdf29f24  
    118118#endif
    119119
    120 #define CONFIG_STACK_SIZE  ((1 << STACK_FRAMES) * STACK_SIZE)
    121 
    122120/** Main kernel routine for bootstrap CPU.
    123121 *
    … …  
    139137        config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
    140138            hardcoded_kdata_size, PAGE_SIZE);
    141         config.stack_size = CONFIG_STACK_SIZE;
     139        config.stack_size = STACK_SIZE;
    142140       
    143141        /* Initialy the stack is placed just after the kernel */
    … …  
    165163       
    166164        context_save(&ctx);
    167         context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base,
    168             THREAD_STACK_SIZE);
     165        context_set(&ctx, FADDR(main_bsp_separated_stack),
     166            config.stack_base, STACK_SIZE);
    169167        context_restore(&ctx);
    170168        /* not reached */
    … …  
    323321        context_save(&CPU->saved_context);
    324322        context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
    325             (uintptr_t) CPU->stack, CPU_STACK_SIZE);
     323            (uintptr_t) CPU->stack, STACK_SIZE);
    326324        context_restore(&CPU->saved_context);
    327325        /* not reached */

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

    re51a514 rdf29f24  
    3333/**
    3434 * @file
    35  * @brief       Userspace bootstrap thread.
     35 * @brief Userspace bootstrap thread.
    3636 *
    3737 * This file contains uinit kernel thread wich is used to start every
    … …  
    4040 * @see SYS_THREAD_CREATE
    4141 */
    42  
     42
    4343#include <main/uinit.h>
    4444#include <typedefs.h>
    … …  
    4848#include <arch.h>
    4949#include <udebug/udebug.h>
    50 
    5150
    5251/** Thread used to bring up userspace thread.
    … …  
    5857{
    5958        uspace_arg_t uarg;
    60 
     59       
    6160        /*
    6261         * So far, we don't have a use for joining userspace threads so we
    … …  
    6867         */
    6968        thread_detach(THREAD);
    70 
     69       
    7170#ifdef CONFIG_UDEBUG
    7271        udebug_stoppable_end();
    … …  
    7877        uarg.uspace_thread_function = NULL;
    7978        uarg.uspace_thread_arg = NULL;
    80 
     79       
    8180        free((uspace_arg_t *) arg);
    8281       

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

    re51a514 rdf29f24  
    302302         * We don't want any area to have conflicts with NULL page.
    303303         */
    304         if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
     304        if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
    305305                return false;
    306306       
    … …  
    329329                        mutex_lock(&area->lock);
    330330                       
    331                         if (overlaps(addr, count << PAGE_WIDTH,
    332                             area->base, area->pages << PAGE_WIDTH)) {
     331                        if (overlaps(addr, P2SZ(count), area->base,
     332                            P2SZ(area->pages))) {
    333333                                mutex_unlock(&area->lock);
    334334                                return false;
    … …  
    346346                        mutex_lock(&area->lock);
    347347                       
    348                         if (overlaps(addr, count << PAGE_WIDTH,
    349                             area->base, area->pages << PAGE_WIDTH)) {
     348                        if (overlaps(addr, P2SZ(count), area->base,
     349                            P2SZ(area->pages))) {
    350350                                mutex_unlock(&area->lock);
    351351                                return false;
    … …  
    366366                mutex_lock(&area->lock);
    367367               
    368                 if (overlaps(addr, count << PAGE_WIDTH,
    369                     area->base, area->pages << PAGE_WIDTH)) {
     368                if (overlaps(addr, P2SZ(count), area->base,
     369                    P2SZ(area->pages))) {
    370370                        mutex_unlock(&area->lock);
    371371                        return false;
    … …  
    380380         */
    381381        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    382                 return !overlaps(addr, count << PAGE_WIDTH,
    383                     KERNEL_ADDRESS_SPACE_START,
     382                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
    384383                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    385384        }
    … …  
    474473       
    475474        btree_node_t *leaf;
    476         as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
     475        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
     476            &leaf);
    477477        if (area) {
    478478                /* va is the base address of an address space area */
    … …  
    482482       
    483483        /*
    484          * Search the leaf node and the righmost record of its left neighbour
     484         * Search the leaf node and the rightmost record of its left neighbour
    485485         * to find out whether this is a miss or va belongs to an address
    486486         * space area found there.
    … …  
    494494               
    495495                mutex_lock(&area->lock);
    496                
     496
    497497                if ((area->base <= va) &&
    498                     (va < area->base + (area->pages << PAGE_WIDTH)))
     498                    (va <= area->base + (P2SZ(area->pages) - 1)))
    499499                        return area;
    500500               
    … …  
    506506         * Because of its position in the B+tree, it must have base < va.
    507507         */
    508         btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
     508        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree,
     509            leaf);
    509510        if (lnode) {
    510511                area = (as_area_t *) lnode->value[lnode->keys - 1];
    … …  
    512513                mutex_lock(&area->lock);
    513514               
    514                 if (va < area->base + (area->pages << PAGE_WIDTH))
     515                if (va <= area->base + (P2SZ(area->pages) - 1))
    515516                        return area;
    516517               
    … …  
    577578       
    578579        if (pages < area->pages) {
    579                 uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
     580                uintptr_t start_free = area->base + P2SZ(pages);
    580581               
    581582                /*
    … …  
    590591                 */
    591592                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    592                     area->base + (pages << PAGE_WIDTH), area->pages - pages);
     593                    area->base + P2SZ(pages), area->pages - pages);
    593594               
    594595                /*
    … …  
    613614                                size_t i = 0;
    614615                               
    615                                 if (overlaps(ptr, size << PAGE_WIDTH, area->base,
    616                                     pages << PAGE_WIDTH)) {
     616                                if (overlaps(ptr, P2SZ(size), area->base,
     617                                    P2SZ(pages))) {
    617618                                       
    618                                         if (ptr + (size << PAGE_WIDTH) <= start_free) {
     619                                        if (ptr + P2SZ(size) <= start_free) {
    619620                                                /*
    620621                                                 * The whole interval fits
    … …  
    647648                               
    648649                                for (; i < size; i++) {
    649                                         pte_t *pte = page_mapping_find(as, ptr +
    650                                             (i << PAGE_WIDTH));
     650                                        pte_t *pte = page_mapping_find(as,
     651                                            ptr + P2SZ(i), false);
    651652                                       
    652653                                        ASSERT(pte);
    … …  
    657658                                            (area->backend->frame_free)) {
    658659                                                area->backend->frame_free(area,
    659                                                     ptr + (i << PAGE_WIDTH),
     660                                                    ptr + P2SZ(i),
    660661                                                    PTE_GET_FRAME(pte));
    661662                                        }
    662663                                       
    663                                         page_mapping_remove(as, ptr +
    664                                             (i << PAGE_WIDTH));
     664                                        page_mapping_remove(as, ptr + P2SZ(i));
    665665                                }
    666666                        }
    … …  
    671671                 */
    672672               
    673                 tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
     673                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
    674674                    area->pages - pages);
    675675               
    676676                /*
    677                  * Invalidate software translation caches (e.g. TSB on sparc64).
    678                  */
    679                 as_invalidate_translation_cache(as, area->base +
    680                     (pages << PAGE_WIDTH), area->pages - pages);
     677                 * Invalidate software translation caches
     678                 * (e.g. TSB on sparc64, PHT on ppc32).
     679                 */
     680                as_invalidate_translation_cache(as, area->base + P2SZ(pages),
     681                    area->pages - pages);
    681682                tlb_shootdown_finalize(ipl);
    682683               
    … …  
    797798                       
    798799                        for (size = 0; size < (size_t) node->value[i]; size++) {
    799                                 pte_t *pte =
    800                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     800                                pte_t *pte = page_mapping_find(as,
     801                                     ptr + P2SZ(size), false);
    801802                               
    802803                                ASSERT(pte);
    … …  
    807808                                    (area->backend->frame_free)) {
    808809                                        area->backend->frame_free(area,
    809                                             ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
     810                                            ptr + P2SZ(size),
     811                                            PTE_GET_FRAME(pte));
    810812                                }
    811813                               
    812                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     814                                page_mapping_remove(as, ptr + P2SZ(size));
    813815                        }
    814816                }
    … …  
    822824       
    823825        /*
    824          * Invalidate potential software translation caches (e.g. TSB on
    825          * sparc64).
     826         * Invalidate potential software translation caches
     827         * (e.g. TSB on sparc64, PHT on ppc32).
    826828         */
    827829        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    897899        }
    898900       
    899         size_t src_size = src_area->pages << PAGE_WIDTH;
     901        size_t src_size = P2SZ(src_area->pages);
    900902        unsigned int src_flags = src_area->flags;
    901903        mem_backend_t *src_backend = src_area->backend;
    … …  
    10941096        for (cur = area->used_space.leaf_head.next;
    10951097            cur != &area->used_space.leaf_head; cur = cur->next) {
    1096                 btree_node_t *node
    1097                     = list_get_instance(cur, btree_node_t, leaf_link);
     1098                btree_node_t *node = list_get_instance(cur, btree_node_t,
     1099                    leaf_link);
    10981100                btree_key_t i;
    10991101               
    … …  
    11031105                       
    11041106                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1105                                 pte_t *pte =
    1106                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     1107                                pte_t *pte = page_mapping_find(as,
     1108                                    ptr + P2SZ(size), false);
    11071109                               
    11081110                                ASSERT(pte);
    … …  
    11131115                               
    11141116                                /* Remove old mapping */
    1115                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     1117                                page_mapping_remove(as, ptr + P2SZ(size));
    11161118                        }
    11171119                }
    … …  
    11251127       
    11261128        /*
    1127          * Invalidate potential software translation caches (e.g. TSB on
    1128          * sparc64).
     1129         * Invalidate potential software translation caches
     1130         * (e.g. TSB on sparc64, PHT on ppc32).
    11291131         */
    11301132        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11591161                               
    11601162                                /* Insert the new mapping */
    1161                                 page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
     1163                                page_mapping_insert(as, ptr + P2SZ(size),
    11621164                                    old_frame[frame_idx++], page_flags);
    11631165                               
    … …  
    12401242         */
    12411243        pte_t *pte;
    1242         if ((pte = page_mapping_find(AS, page))) {
     1244        if ((pte = page_mapping_find(AS, page, false))) {
    12431245                if (PTE_PRESENT(pte)) {
    12441246                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    … …  
    14811483       
    14821484        if (src_area) {
    1483                 size = src_area->pages << PAGE_WIDTH;
     1485                size = P2SZ(src_area->pages);
    14841486                mutex_unlock(&src_area->lock);
    14851487        } else
    … …  
    15361538                if (page >= right_pg) {
    15371539                        /* Do nothing. */
    1538                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1539                     left_cnt << PAGE_WIDTH)) {
     1540                } else if (overlaps(page, P2SZ(count), left_pg,
     1541                    P2SZ(left_cnt))) {
    15401542                        /* The interval intersects with the left interval. */
    15411543                        return false;
    1542                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1543                     right_cnt << PAGE_WIDTH)) {
     1544                } else if (overlaps(page, P2SZ(count), right_pg,
     1545                    P2SZ(right_cnt))) {
    15441546                        /* The interval intersects with the right interval. */
    15451547                        return false;
    1546                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1547                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1548                } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1549                    (page + P2SZ(count) == right_pg)) {
    15481550                        /*
    15491551                         * The interval can be added by merging the two already
    … …  
    15531555                        btree_remove(&area->used_space, right_pg, leaf);
    15541556                        goto success;
    1555                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1557                } else if (page == left_pg + P2SZ(left_cnt)) {
    15561558                        /*
    15571559                         * The interval can be added by simply growing the left
    … …  
    15601562                        node->value[node->keys - 1] += count;
    15611563                        goto success;
    1562                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1564                } else if (page + P2SZ(count) == right_pg) {
    15631565                        /*
    15641566                         * The interval can be addded by simply moving base of
    … …  
    15871589                 */
    15881590               
    1589                 if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1590                     right_cnt << PAGE_WIDTH)) {
     1591                if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
    15911592                        /* The interval intersects with the right interval. */
    15921593                        return false;
    1593                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1594                } else if (page + P2SZ(count) == right_pg) {
    15941595                        /*
    15951596                         * The interval can be added by moving the base of the
    … …  
    16261627                if (page < left_pg) {
    16271628                        /* Do nothing. */
    1628                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1629                     left_cnt << PAGE_WIDTH)) {
     1629                } else if (overlaps(page, P2SZ(count), left_pg,
     1630                    P2SZ(left_cnt))) {
    16301631                        /* The interval intersects with the left interval. */
    16311632                        return false;
    1632                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1633                     right_cnt << PAGE_WIDTH)) {
     1633                } else if (overlaps(page, P2SZ(count), right_pg,
     1634                    P2SZ(right_cnt))) {
    16341635                        /* The interval intersects with the right interval. */
    16351636                        return false;
    1636                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1637                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1637                } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1638                    (page + P2SZ(count) == right_pg)) {
    16381639                        /*
    16391640                         * The interval can be added by merging the two already
    … …  
    16431644                        btree_remove(&area->used_space, right_pg, node);
    16441645                        goto success;
    1645                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1646                } else if (page == left_pg + P2SZ(left_cnt)) {
    16461647                        /*
    16471648                         * The interval can be added by simply growing the left
    … …  
    16501651                        leaf->value[leaf->keys - 1] += count;
    16511652                        goto success;
    1652                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1653                } else if (page + P2SZ(count) == right_pg) {
    16531654                        /*
    16541655                         * The interval can be addded by simply moving base of
    … …  
    16771678                 */
    16781679               
    1679                 if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1680                     left_cnt << PAGE_WIDTH)) {
     1680                if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
    16811681                        /* The interval intersects with the left interval. */
    16821682                        return false;
    1683                 } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
     1683                } else if (left_pg + P2SZ(left_cnt) == page) {
    16841684                        /*
    16851685                         * The interval can be added by growing the left
    … …  
    17161716                         */
    17171717                       
    1718                         if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1719                             left_cnt << PAGE_WIDTH)) {
     1718                        if (overlaps(page, P2SZ(count), left_pg,
     1719                            P2SZ(left_cnt))) {
    17201720                                /*
    17211721                                 * The interval intersects with the left
    … …  
    17231723                                 */
    17241724                                return false;
    1725                         } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1726                             right_cnt << PAGE_WIDTH)) {
     1725                        } else if (overlaps(page, P2SZ(count), right_pg,
     1726                            P2SZ(right_cnt))) {
    17271727                                /*
    17281728                                 * The interval intersects with the right
    … …  
    17301730                                 */
    17311731                                return false;
    1732                         } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1733                             (page + (count << PAGE_WIDTH) == right_pg)) {
     1732                        } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1733                            (page + P2SZ(count) == right_pg)) {
    17341734                                /*
    17351735                                 * The interval can be added by merging the two
    … …  
    17391739                                btree_remove(&area->used_space, right_pg, leaf);
    17401740                                goto success;
    1741                         } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1741                        } else if (page == left_pg + P2SZ(left_cnt)) {
    17421742                                /*
    17431743                                 * The interval can be added by simply growing
    … …  
    17461746                                leaf->value[i - 1] += count;
    17471747                                goto success;
    1748                         } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1748                        } else if (page + P2SZ(count) == right_pg) {
    17491749                                /*
    17501750                                 * The interval can be addded by simply moving
    … …  
    18121812                        for (i = 0; i < leaf->keys; i++) {
    18131813                                if (leaf->key[i] == page) {
    1814                                         leaf->key[i] += count << PAGE_WIDTH;
     1814                                        leaf->key[i] += P2SZ(count);
    18151815                                        leaf->value[i] -= count;
    18161816                                        goto success;
    … …  
    18221822        }
    18231823       
    1824         btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
     1824        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
     1825            leaf);
    18251826        if ((node) && (page < leaf->key[0])) {
    18261827                uintptr_t left_pg = node->key[node->keys - 1];
    18271828                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18281829               
    1829                 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1830                     count << PAGE_WIDTH)) {
    1831                         if (page + (count << PAGE_WIDTH) ==
    1832                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1830                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
     1831                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
    18331832                                /*
    18341833                                 * The interval is contained in the rightmost
    … …  
    18391838                                node->value[node->keys - 1] -= count;
    18401839                                goto success;
    1841                         } else if (page + (count << PAGE_WIDTH) <
    1842                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1840                        } else if (page + P2SZ(count) <
     1841                            left_pg + P2SZ(left_cnt)) {
     1842                                size_t new_cnt;
     1843
    18431844                                /*
    18441845                                 * The interval is contained in the rightmost
    … …  
    18481849                                 * new interval.
    18491850                                 */
    1850                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1851                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1851                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1852                                    (page + P2SZ(count))) >> PAGE_WIDTH;
    18521853                                node->value[node->keys - 1] -= count + new_cnt;
    18531854                                btree_insert(&area->used_space, page +
    1854                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1855                                    P2SZ(count), (void *) new_cnt, leaf);
    18551856                                goto success;
    18561857                        }
    … …  
    18651866                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    18661867               
    1867                 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1868                     count << PAGE_WIDTH)) {
    1869                         if (page + (count << PAGE_WIDTH) ==
    1870                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1868                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
     1869                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
    18711870                                /*
    18721871                                 * The interval is contained in the rightmost
    … …  
    18761875                                leaf->value[leaf->keys - 1] -= count;
    18771876                                goto success;
    1878                         } else if (page + (count << PAGE_WIDTH) < left_pg +
    1879                             (left_cnt << PAGE_WIDTH)) {
     1877                        } else if (page + P2SZ(count) < left_pg +
     1878                            P2SZ(left_cnt)) {
     1879                                size_t new_cnt;
     1880
    18801881                                /*
    18811882                                 * The interval is contained in the rightmost
    … …  
    18851886                                 * interval.
    18861887                                 */
    1887                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1888                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1888                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1889                                    (page + P2SZ(count))) >> PAGE_WIDTH;
    18891890                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    18901891                                btree_insert(&area->used_space, page +
    1891                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1892                                    P2SZ(count), (void *) new_cnt, leaf);
    18921893                                goto success;
    18931894                        }
    … …  
    19111912                         * to (i - 1) and i.
    19121913                         */
    1913                         if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1914                             count << PAGE_WIDTH)) {
    1915                                 if (page + (count << PAGE_WIDTH) ==
    1916                                     left_pg + (left_cnt << PAGE_WIDTH)) {
     1914                        if (overlaps(left_pg, P2SZ(left_cnt), page,
     1915                            P2SZ(count))) {
     1916                                if (page + P2SZ(count) ==
     1917                                    left_pg + P2SZ(left_cnt)) {
    19171918                                        /*
    19181919                                         * The interval is contained in the
    … …  
    19231924                                        leaf->value[i - 1] -= count;
    19241925                                        goto success;
    1925                                 } else if (page + (count << PAGE_WIDTH) <
    1926                                     left_pg + (left_cnt << PAGE_WIDTH)) {
     1926                                } else if (page + P2SZ(count) <
     1927                                    left_pg + P2SZ(left_cnt)) {
     1928                                        size_t new_cnt;
     1929
    19271930                                        /*
    19281931                                         * The interval is contained in the
    … …  
    19321935                                         * also inserting a new interval.
    19331936                                         */
    1934                                         size_t new_cnt = ((left_pg +
    1935                                             (left_cnt << PAGE_WIDTH)) -
    1936                                             (page + (count << PAGE_WIDTH))) >>
     1937                                        new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1938                                            (page + P2SZ(count))) >>
    19371939                                            PAGE_WIDTH;
    19381940                                        leaf->value[i - 1] -= count + new_cnt;
    19391941                                        btree_insert(&area->used_space, page +
    1940                                             (count << PAGE_WIDTH), (void *) new_cnt,
     1942                                            P2SZ(count), (void *) new_cnt,
    19411943                                            leaf);
    19421944                                        goto success;
    … …  
    20342036                btree_key_t i;
    20352037                for (i = 0; (ret == 0) && (i < node->keys); i++) {
     2038                        uintptr_t addr;
     2039
    20362040                        as_area_t *area = (as_area_t *) node->value[i];
    20372041                       
    20382042                        mutex_lock(&area->lock);
    20392043                       
    2040                         uintptr_t addr =
    2041                             ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
     2044                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
    20422045                            PAGE_SIZE);
    20432046                       
    … …  
    20982101                       
    20992102                        info[area_idx].start_addr = area->base;
    2100                         info[area_idx].size = FRAMES2SIZE(area->pages);
     2103                        info[area_idx].size = P2SZ(area->pages);
    21012104                        info[area_idx].flags = area->flags;
    21022105                        ++area_idx;
    … …  
    21362139                            " (%p - %p)\n", area, (void *) area->base,
    21372140                            area->pages, (void *) area->base,
    2138                             (void *) (area->base + FRAMES2SIZE(area->pages)));
     2141                            (void *) (area->base + P2SZ(area->pages)));
    21392142                        mutex_unlock(&area->lock);
    21402143                }

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

    re51a514 rdf29f24  
    5050#include <typedefs.h>
    5151#include <align.h>
     52#include <memstr.h>
    5253#include <arch.h>
    5354
    … …  
    121122                                page_table_lock(area->as, false);
    122123                                pte = page_mapping_find(area->as,
    123                                     base + j * PAGE_SIZE);
     124                                    base + P2SZ(j), false);
    124125                                ASSERT(pte && PTE_VALID(pte) &&
    125126                                    PTE_PRESENT(pte));
    126127                                btree_insert(&area->sh_info->pagemap,
    127                                     (base + j * PAGE_SIZE) - area->base,
     128                                    (base + P2SZ(j)) - area->base,
    128129                                    (void *) PTE_GET_FRAME(pte), NULL);
    129130                                page_table_unlock(area->as, false);

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

    re51a514 rdf29f24  
    170170                        if (!(area->flags & AS_AREA_WRITE))
    171171                                if (base >= entry->p_vaddr &&
    172                                     base + count * PAGE_SIZE <= start_anon)
     172                                    base + P2SZ(count) <= start_anon)
    173173                                        continue;
    174174                       
    … …  
    182182                                if (!(area->flags & AS_AREA_WRITE))
    183183                                        if (base >= entry->p_vaddr &&
    184                                             base + (j + 1) * PAGE_SIZE <=
    185                                             start_anon)
     184                                            base + P2SZ(j + 1) <= start_anon)
    186185                                                continue;
    187186                               
    188187                                page_table_lock(area->as, false);
    189188                                pte = page_mapping_find(area->as,
    190                                     base + j * PAGE_SIZE);
     189                                    base + P2SZ(j), false);
    191190                                ASSERT(pte && PTE_VALID(pte) &&
    192191                                    PTE_PRESENT(pte));
    193192                                btree_insert(&area->sh_info->pagemap,
    194                                     (base + j * PAGE_SIZE) - area->base,
     193                                    (base + P2SZ(j)) - area->base,
    195194                                    (void *) PTE_GET_FRAME(pte), NULL);
    196195                                page_table_unlock(area->as, false);

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

    re51a514 rdf29f24  
    112112 * using flags. Allocate and setup any missing page tables.
    113113 *
    114  * @param as    Address space to wich page belongs.
     114 * @param as    Address space to which page belongs.
    115115 * @param page  Virtual address of the page to be mapped.
    116116 * @param frame Physical address of memory frame to which the mapping is
    … …  
    139139 * this call visible.
    140140 *
    141  * @param as   Address space to wich page belongs.
     141 * @param as   Address space to which page belongs.
    142142 * @param page Virtual address of the page to be demapped.
    143143 *
    … …  
    156156}
    157157
    158 /** Find mapping for virtual page
    159  *
    160  * Find mapping for virtual page.
    161  *
    162  * @param as   Address space to wich page belongs.
    163  * @param page Virtual page.
     158/** Find mapping for virtual page.
     159 *
     160 * @param as     Address space to which page belongs.
     161 * @param page   Virtual page.
     162 * @param nolock True if the page tables need not be locked.
    164163 *
    165164 * @return NULL if there is no such mapping; requested mapping
    … …  
    167166 *
    168167 */
    169 NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
    170 {
    171         ASSERT(page_table_locked(as));
     168NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
     169{
     170        ASSERT(nolock || page_table_locked(as));
    172171       
    173172        ASSERT(page_mapping_operations);
    174173        ASSERT(page_mapping_operations->mapping_find);
    175174       
    176         return page_mapping_operations->mapping_find(as, page);
     175        return page_mapping_operations->mapping_find(as, page, nolock);
    177176}
    178177
    … …  
    188187        mutex_lock(&AS->lock);
    189188       
    190         pte_t *pte = page_mapping_find(AS, virt_address);
     189        pte_t *pte = page_mapping_find(AS, virt_address, true);
    191190        if (!PTE_VALID(pte) || !PTE_PRESENT(pte)) {
    192191                mutex_unlock(&AS->lock);

  • kernel/generic/src/printf/vprintf.c

    re51a514 rdf29f24  
    4141#include <typedefs.h>
    4242#include <str.h>
    43 
    44 IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(printf_lock, "*printf_lock");
    4543
    4644static int vprintf_str_write(const char *str, size_t size, void *data)
    … …  
    9391        };
    9492       
    95         irq_spinlock_lock(&printf_lock, true);
    96         int ret = printf_core(fmt, &ps, ap);
    97         irq_spinlock_unlock(&printf_lock, true);
    98        
    99         return ret;
     93        return printf_core(fmt, &ps, ap);
    10094}
    10195

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

    re51a514 rdf29f24  
    5454#include <proc/program.h>
    5555
    56 #ifndef LOADED_PROG_STACK_PAGES_NO
    57 #define LOADED_PROG_STACK_PAGES_NO 1
    58 #endif
    59 
    6056/**
    6157 * Points to the binary image used as the program loader. All non-initial
    … …  
    9086       
    9187        /*
    92          * Create the data address space area.
     88         * Create the stack address space area.
    9389         */
    9490        as_area_t *area = as_area_create(as,
    9591            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
    96             LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
    97             AS_AREA_ATTR_NONE, &anon_backend, NULL);
     92            STACK_SIZE, USTACK_ADDRESS, AS_AREA_ATTR_NONE,
     93            &anon_backend, NULL);
    9894        if (!area)
    9995                return ENOMEM;

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

    re51a514 rdf29f24  
    376376        context_save(&CPU->saved_context);
    377377        context_set(&CPU->saved_context, FADDR(scheduler_separated_stack),
    378             (uintptr_t) CPU->stack, CPU_STACK_SIZE);
     378            (uintptr_t) CPU->stack, STACK_SIZE);
    379379        context_restore(&CPU->saved_context);
    380380       

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

    re51a514 rdf29f24  
    190190        str_cpy(task->name, TASK_NAME_BUFLEN, name);
    191191       
    192         task->context = CONTEXT;
     192        task->container = CONTAINER;
    193193        task->capabilities = 0;
    194194        task->ucycles = 0;
    … …  
    211211       
    212212        if ((ipc_phone_0) &&
    213             (context_check(ipc_phone_0->task->context, task->context)))
     213            (container_check(ipc_phone_0->task->container, task->container)))
    214214                ipc_phone_connect(&task->phones[0], ipc_phone_0);
    215215       
    … …  
    584584                printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
    585585                    " %9" PRIu64 "%c %9" PRIu64 "%c\n", task->taskid,
    586                     task->name, task->context, task, task->as,
     586                    task->name, task->container, task, task->as,
    587587                    ucycles, usuffix, kcycles, ksuffix);
    588588#endif
    … …  
    595595        else
    596596                printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",
    597                     task->taskid, task->name, task->context, task, task->as);
     597                    task->taskid, task->name, task->container, task, task->as);
    598598#endif
    599599       
    … …  
    625625                printf("[id    ] [threads] [calls] [callee\n");
    626626        else
    627                 printf("[id    ] [name        ] [ctx] [address ] [as      ]"
     627                printf("[id    ] [name        ] [ctn] [address ] [as      ]"
    628628                    " [ucycles ] [kcycles ]\n");
    629629#endif
    … …  
    634634                    " [callee\n");
    635635        else
    636                 printf("[id    ] [name        ] [ctx] [address         ]"
     636                printf("[id    ] [name        ] [ctn] [address         ]"
    637637                    " [as              ]\n");
    638638#endif

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

    re51a514 rdf29f24  
    5858        the->task = NULL;
    5959        the->as = NULL;
     60        the->magic = MAGIC;
    6061}
    6162
    … …  
    7071NO_TRACE void the_copy(the_t *src, the_t *dst)
    7172{
     73        ASSERT(src->magic == MAGIC);
    7274        *dst = *src;
    7375}

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

    re51a514 rdf29f24  
    6868#include <errno.h>
    6969
    70 
    71 #ifndef LOADED_PROG_STACK_PAGES_NO
    72 #define LOADED_PROG_STACK_PAGES_NO 1
    73 #endif
    74 
    75 
    7670/** Thread states */
    7771const char *thread_states[] = {
    … …  
    300294       
    301295        /* Not needed, but good for debugging */
    302         memsetb(thread->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
     296        memsetb(thread->kstack, STACK_SIZE, 0);
    303297       
    304298        irq_spinlock_lock(&tidlock, true);
    … …  
    308302        context_save(&thread->saved_context);
    309303        context_set(&thread->saved_context, FADDR(cushion),
    310             (uintptr_t) thread->kstack, THREAD_STACK_SIZE);
     304            (uintptr_t) thread->kstack, STACK_SIZE);
    311305       
    312306        the_initialize((the_t *) thread->kstack);
    … …  
    605599                printf("%-8" PRIu64 " %-14s %10p %-8s %10p %-5" PRIu32 "\n",
    606600                    thread->tid, name, thread, thread_states[thread->state],
    607                     thread->task, thread->task->context);
     601                    thread->task, thread->task->container);
    608602#endif
    609603       
    … …  
    617611                printf("%-8" PRIu64 " %-14s %18p %-8s %18p %-5" PRIu32 "\n",
    618612                    thread->tid, name, thread, thread_states[thread->state],
    619                     thread->task, thread->task->context);
     613                    thread->task, thread->task->container);
    620614#endif
    621615       
    … …  
    658652        else
    659653                printf("[id    ] [name        ] [address ] [state ] [task    ]"
    660                     " [ctx]\n");
     654                    " [ctn]\n");
    661655#endif
    662656       
    … …  
    667661        } else
    668662                printf("[id    ] [name        ] [address         ] [state ]"
    669                     " [task            ] [ctx]\n");
     663                    " [task            ] [ctn]\n");
    670664#endif
    671665       

  • kernel/generic/src/security/cap.c

    re51a514 rdf29f24  
    9292        task_t *task = task_find_by_id(taskid);
    9393       
    94         if ((!task) || (!context_check(CONTEXT, task->context))) {
     94        if ((!task) || (!container_check(CONTAINER, task->container))) {
    9595                irq_spinlock_unlock(&tasks_lock, true);
    9696                return (sysarg_t) ENOENT;
    … …  
    121121       
    122122        task_t *task = task_find_by_id(taskid);
    123         if ((!task) || (!context_check(CONTEXT, task->context))) {
     123        if ((!task) || (!container_check(CONTAINER, task->container))) {
    124124                irq_spinlock_unlock(&tasks_lock, true);
    125125                return (sysarg_t) ENOENT;

  • kernel/generic/src/synch/futex.c

    re51a514 rdf29f24  
    119119         */
    120120        page_table_lock(AS, true);
    121         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
     121        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
    122122        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    123123                page_table_unlock(AS, true);
    … …  
    155155         */
    156156        page_table_lock(AS, true);
    157         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
     157        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
    158158        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    159159                page_table_unlock(AS, true);

  • kernel/generic/src/synch/spinlock.c

    re51a514 rdf29f24  
    9696                 * run in a simulator) that caused problems with both
    9797                 * printf_lock and the framebuffer lock.
    98                  *
    9998                 */
    10099                if (lock->name[0] == '*')
Note: See TracChangeset for help on using the changeset viewer.