Changes in / [864a081:5c460cc] in mainline


Ignore:
Files:
1 added
2 deleted
43 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/ppc32/src/asm.S

    r864a081 r5c460cc  
    5656        tlbsync
    5757        sync
    58 .endm
    59 
    60 .macro BAT_COMPUTE base size mask lower upper
    61         # less than 128 KB -> no BAT
    62        
    63         lis \upper, 0x0002
    64         cmpw \size, \upper
    65         blt no_bat
    66        
    67         # mask = total >> 18
    68        
    69         li \upper, 18
    70         srw \mask, \size, \upper
    71        
    72         # create Block Length mask by replicating
    73         # the leading logical one 14 times
    74        
    75         li \upper, 14
    76         mtctr \mask
    77         li \upper, 1
    78        
    79         0:
    80                 # mask = (mask >> 1) | mask
    81                
    82                 srw \lower, \mask, \upper
    83                 or \mask, \mask, \lower
    84                
    85                 bdnz 0b
    86        
    87         # mask = mask & 0x07ff
    88         # (BAT can map up to 256 MB)
    89        
    90         andi. \mask, \mask, 0x07ff
    91        
    92         # mask = (mask << 2) | 0x0002
    93         # (priviledged access only)
    94        
    95         li \upper, 2
    96         slw \mask, \mask, \upper
    97         ori \mask, \mask, 0x0002
    98        
    99         lis \upper, (0x8000 + \base)
    100         or \upper, \upper, \mask
    101        
    102         lis \lower, \base
    103         ori \lower, \lower, 0x0002
    10458.endm
    10559
    … …  
    293247        lwz r31, 4(r3)                # r31 = memory size
    294248       
    295         lis r30, 268435456@h
    296         ori r30, r30, 268435456@l     # r30 = 256 MB
    297        
    298         # BAT0
    299        
    300         # r29 = min(r31, r30)
    301        
    302         cmpw r31, r30
    303         blt bat0_r31
    304        
    305                 mr r29, r30
    306                 b bat0_r30
    307        
    308         bat0_r31:
    309        
    310                 mr r29, r31
    311        
    312         bat0_r30:
    313        
    314         BAT_COMPUTE 0x0000 r29 r28 r27 r26
    315         mtspr ibat0u, r26
    316         mtspr ibat0l, r27
    317        
    318         mtspr dbat0u, r26
    319         mtspr dbat0l, r27
    320        
    321         # BAT1
    322        
    323         sub r31, r31, r29             # r31 = r31 - r29
    324        
    325         # r29 = min(r31, r30)
    326        
    327         cmpw r31, r30
    328         blt bat1_r31
    329        
    330                 mr r29, r30
    331                 b bat1_r30
    332        
    333         bat1_r31:
    334        
    335                 mr r29, r31
    336        
    337         bat1_r30:
    338        
    339         BAT_COMPUTE 0x1000 r29 r28 r27 r26
    340         mtspr ibat1u, r26
    341         mtspr ibat1l, r27
    342        
    343         mtspr dbat1u, r26
    344         mtspr dbat1l, r27
    345        
    346         # BAT2
    347        
    348         sub r31, r31, r29             # r31 = r31 - r29
    349        
    350         # r29 = min(r31, r30)
    351        
    352         cmpw r31, r30
    353         blt bat2_r31
    354        
    355                 mr r29, r30
    356                 b bat2_r30
    357        
    358         bat2_r31:
    359        
    360                 mr r29, r31
    361        
    362         bat2_r30:
    363        
    364         BAT_COMPUTE 0x2000 r29 r28 r27 r26
    365         mtspr ibat2u, r26
    366         mtspr ibat2l, r27
    367        
    368         mtspr dbat2u, r26
    369         mtspr dbat2l, r27
    370        
    371         # BAT3
    372        
    373         sub r31, r31, r29             # r31 = r31 - r29
    374        
    375         # r29 = min(r31, r30)
    376        
    377         cmpw r31, r30
    378         blt bat3_r31
    379        
    380                 mr r29, r30
    381                 b bat3_r30
    382        
    383         bat3_r31:
    384        
    385                 mr r29, r31
    386        
    387         bat3_r30:
    388        
    389         BAT_COMPUTE 0x3000 r29 r28 r27 r26
    390         mtspr ibat3u, r26
    391         mtspr ibat3l, r27
    392        
    393         mtspr dbat3u, r26
    394         mtspr dbat3l, r27
     249        lis r29, 0x0002
     250        cmpw r31, r29
     251        blt no_bat                    # less than 128 KB -> no BAT
     252       
     253        li r29, 18
     254        srw r31, r31, r29             # r31 = total >> 18
     255       
     256        # create Block Length mask by replicating
     257        # the leading logical one 14 times
     258       
     259        li r29, 14
     260        mtctr r31
     261        li r29, 1
     262       
     263        bat_mask:
     264                srw r30, r31, r29         # r30 = mask >> 1
     265                or r31, r31, r30          # mask = mask | r30
     266               
     267                bdnz bat_mask
     268       
     269        andi. r31, r31, 0x07ff        # mask = mask & 0x07ff (BAT can map up to 256 MB)
     270       
     271        li r29, 2
     272        slw r31, r31, r29             # mask = mask << 2
     273        ori r31, r31, 0x0002          # mask = mask | 0x0002 (priviledged access only)
     274       
     275        lis r29, 0x8000
     276        or r29, r29, r31
     277       
     278        lis r30, 0x0000
     279        ori r30, r30, 0x0002
     280       
     281        mtspr ibat0u, r29
     282        mtspr ibat0l, r30
     283       
     284        mtspr dbat0u, r29
     285        mtspr dbat0l, r30
    395286       
    396287        no_bat:

  • contrib/conf/arm32-qe.sh

    r864a081 r5c460cc  
    11#!/bin/sh
    22
    3 qemu-system-arm $@ -M integratorcp --kernel image.boot
     3qemu-system-arm -M integratorcp --kernel image.boot

  • contrib/conf/ia32-qe.sh

    r864a081 r5c460cc  
    88fi
    99
    10 qemu $@ -m 32 -hda "$DISK_IMG" -cdrom image.iso -boot d
     10qemu -m 32 -hda "$DISK_IMG" -cdrom image.iso -boot d

  • contrib/conf/ppc32-qe.sh

    r864a081 r5c460cc  
    11#!/bin/sh
    22
    3 qemu-system-ppc $@ -M mac99 -boot d -cdrom image.iso
     3qemu-system-ppc -M mac99 -boot d -cdrom image.iso

  • kernel/arch/ia64/src/mm/tlb.c

    r864a081 r5c460cc  
    481481       
    482482        page_table_lock(AS, true);
    483         t = page_mapping_find(AS, va, true);
     483        t = page_mapping_find(AS, va);
    484484        if (t) {
    485485                /*
    … …  
    599599       
    600600        page_table_lock(AS, true);
    601         pte_t *entry = page_mapping_find(AS, va, true);
     601        pte_t *entry = page_mapping_find(AS, va);
    602602        if (entry) {
    603603                /*
    … …  
    651651       
    652652        page_table_lock(AS, true);
    653         t = page_mapping_find(AS, va, true);
     653        t = page_mapping_find(AS, va);
    654654        ASSERT((t) && (t->p));
    655655        if ((t) && (t->p) && (t->w)) {
    … …  
    684684       
    685685        page_table_lock(AS, true);
    686         t = page_mapping_find(AS, va, true);
     686        t = page_mapping_find(AS, va);
    687687        ASSERT((t) && (t->p));
    688688        if ((t) && (t->p) && (t->x)) {
    … …  
    717717       
    718718        page_table_lock(AS, true);
    719         t = page_mapping_find(AS, va, true);
     719        t = page_mapping_find(AS, va);
    720720        ASSERT((t) && (t->p));
    721721        if ((t) && (t->p)) {
    … …  
    753753         */
    754754        page_table_lock(AS, true);
    755         t = page_mapping_find(AS, va, true);
     755        t = page_mapping_find(AS, va);
    756756        ASSERT((t) && (t->p));
    757757        ASSERT(!t->w);
    … …  
    778778       
    779779        page_table_lock(AS, true);
    780         t = page_mapping_find(AS, va, true);
     780        t = page_mapping_find(AS, va);
    781781        ASSERT(t);
    782782       

  • kernel/arch/mips32/src/mm/tlb.c

    r864a081 r5c460cc  
    100100        mutex_unlock(&AS->lock);
    101101       
     102        page_table_lock(AS, true);
     103       
    102104        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
    103105        if (!pte) {
    … …  
    111113                         * or copy_to_uspace().
    112114                         */
     115                        page_table_unlock(AS, true);
    113116                        return;
    114117                default:
    … …  
    141144        tlbwr();
    142145
     146        page_table_unlock(AS, true);
    143147        return;
    144148       
    145149fail:
     150        page_table_unlock(AS, true);
    146151        tlb_refill_fail(istate);
    147152}
    … …  
    171176        index.value = cp0_index_read();
    172177
     178        page_table_lock(AS, true);     
     179       
    173180        /*
    174181         * Fail if the entry is not in TLB.
    … …  
    190197                         * or copy_to_uspace().
    191198                         */
     199                        page_table_unlock(AS, true);                     
    192200                        return;
    193201                default:
    … …  
    219227        tlbwi();
    220228
     229        page_table_unlock(AS, true);
    221230        return;
    222231       
    223232fail:
     233        page_table_unlock(AS, true);
    224234        tlb_invalid_fail(istate);
    225235}
    … …  
    249259        index.value = cp0_index_read();
    250260
     261        page_table_lock(AS, true);     
     262       
    251263        /*
    252264         * Fail if the entry is not in TLB.
    … …  
    268280                         * or copy_to_uspace().
    269281                         */
     282                        page_table_unlock(AS, true);                     
    270283                        return;
    271284                default:
    … …  
    298311        tlbwi();
    299312
     313        page_table_unlock(AS, true);
    300314        return;
    301315       
    302316fail:
     317        page_table_unlock(AS, true);
    303318        tlb_modified_fail(istate);
    304319}
    … …  
    349364        pte_t *pte;
    350365
     366        ASSERT(mutex_locked(&AS->lock));
     367
    351368        hi.value = cp0_entry_hi_read();
    352369
    … …  
    362379         * Check if the mapping exists in page tables.
    363380         */     
    364         pte = page_mapping_find(AS, badvaddr, true);
     381        pte = page_mapping_find(AS, badvaddr);
    365382        if (pte && pte->p && (pte->w || access != PF_ACCESS_WRITE)) {
    366383                /*
    … …  
    376393                 * Resort to higher-level page fault handler.
    377394                 */
     395                page_table_unlock(AS, true);
    378396                switch (rc = as_page_fault(badvaddr, access, istate)) {
    379397                case AS_PF_OK:
    … …  
    382400                         * The mapping ought to be in place.
    383401                         */
    384                         pte = page_mapping_find(AS, badvaddr, true);
     402                        page_table_lock(AS, true);
     403                        pte = page_mapping_find(AS, badvaddr);
    385404                        ASSERT(pte && pte->p);
    386405                        ASSERT(pte->w || access != PF_ACCESS_WRITE);
    … …  
    388407                        break;
    389408                case AS_PF_DEFER:
     409                        page_table_lock(AS, true);
    390410                        *pfrc = AS_PF_DEFER;
    391411                        return NULL;
    392412                        break;
    393413                case AS_PF_FAULT:
     414                        page_table_lock(AS, true);
    394415                        *pfrc = AS_PF_FAULT;
    395416                        return NULL;

  • kernel/arch/ppc32/Makefile.inc

    r864a081 r5c460cc  
    5555        arch/$(KARCH)/src/mm/frame.c \
    5656        arch/$(KARCH)/src/mm/page.c \
    57         arch/$(KARCH)/src/mm/pht.c \
    5857        arch/$(KARCH)/src/mm/tlb.c \
    5958        arch/$(KARCH)/src/drivers/pic.c

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

    r864a081 r5c460cc  
    3636#define KERN_ppc32_AS_H_
    3737
    38 #include <arch/mm/pht.h>
    39 
    4038#define KERNEL_ADDRESS_SPACE_SHADOWED_ARCH  0
    4139
    … …  
    5452#define as_create_arch(as, flags)       (as != as)
    5553#define as_deinstall_arch(as)
    56 
    57 #define as_invalidate_translation_cache(as, page, cnt) \
    58         pht_invalidate((as), (page), (cnt))
     54#define as_invalidate_translation_cache(as, page, cnt)
    5955
    6056extern void as_arch_init(void);

  • kernel/arch/ppc32/include/mm/tlb.h

    r864a081 r5c460cc  
    3737
    3838#include <arch/interrupt.h>
     39#include <typedefs.h>
    3940
    4041#define WIMG_GUARDED    0x01
    … …  
    7475} ptelo_t;
    7576
     77extern void pht_init(void);
     78extern void pht_refill(unsigned int, istate_t *);
    7679extern void tlb_refill(unsigned int, istate_t *);
    7780

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

    r864a081 r5c460cc  
    4242#include <arch/drivers/pic.h>
    4343#include <arch/mm/tlb.h>
    44 #include <arch/mm/pht.h>
    4544#include <print.h>
    4645

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

    r864a081 r5c460cc  
    4343        if (config.cpu_active == 1)
    4444                page_mapping_operations = &pt_mapping_operations;
    45         as_switch(NULL, AS_KERNEL);
    4645}
    4746

  • kernel/arch/ppc32/src/mm/tlb.c

    r864a081 r5c460cc  
    3333 */
    3434
     35#include <mm/tlb.h>
    3536#include <arch/mm/tlb.h>
     37#include <arch/interrupt.h>
    3638#include <interrupt.h>
    37 #include <typedefs.h>
     39#include <mm/as.h>
     40#include <mm/page.h>
     41#include <arch.h>
     42#include <print.h>
     43#include <macros.h>
     44#include <symtab.h>
     45
     46static unsigned int seed = 42;
     47
     48/** Try to find PTE for faulting address
     49 *
     50 * @param as       Address space.
     51 * @param lock     Lock/unlock the address space.
     52 * @param badvaddr Faulting virtual address.
     53 * @param access   Access mode that caused the fault.
     54 * @param istate   Pointer to interrupted state.
     55 * @param pfrc     Pointer to variable where as_page_fault() return code
     56 *                 will be stored.
     57 *
     58 * @return PTE on success, NULL otherwise.
     59 *
     60 */
     61static pte_t *find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
     62    istate_t *istate, int *pfrc)
     63{
     64        ASSERT(mutex_locked(&as->lock));
     65
     66        /*
     67         * Check if the mapping exists in page tables.
     68         */
     69        pte_t *pte = page_mapping_find(as, badvaddr);
     70        if ((pte) && (pte->present)) {
     71                /*
     72                 * Mapping found in page tables.
     73                 * Immediately succeed.
     74                 */
     75                return pte;
     76        } else {
     77                /*
     78                 * Mapping not found in page tables.
     79                 * Resort to higher-level page fault handler.
     80                 */
     81                page_table_unlock(as, true);
     82               
     83                int rc = as_page_fault(badvaddr, access, istate);
     84                switch (rc) {
     85                case AS_PF_OK:
     86                        /*
     87                         * The higher-level page fault handler succeeded,
     88                         * The mapping ought to be in place.
     89                         */
     90                        page_table_lock(as, true);
     91                        pte = page_mapping_find(as, badvaddr);
     92                        ASSERT((pte) && (pte->present));
     93                        *pfrc = 0;
     94                        return pte;
     95                case AS_PF_DEFER:
     96                        page_table_lock(as, true);
     97                        *pfrc = rc;
     98                        return NULL;
     99                case AS_PF_FAULT:
     100                        page_table_lock(as, true);
     101                        *pfrc = rc;
     102                        return NULL;
     103                default:
     104                        panic("Unexpected rc (%d).", rc);
     105                }
     106        }
     107}
     108
     109static void pht_refill_fail(uintptr_t badvaddr, istate_t *istate)
     110{
     111        fault_if_from_uspace(istate, "PHT Refill Exception on %p.",
     112            (void *) badvaddr);
     113        panic_memtrap(istate, PF_ACCESS_UNKNOWN, badvaddr,
     114            "PHT Refill Exception.");
     115}
     116
     117static void pht_insert(const uintptr_t vaddr, const pte_t *pte)
     118{
     119        uint32_t page = (vaddr >> 12) & 0xffff;
     120        uint32_t api = (vaddr >> 22) & 0x3f;
     121       
     122        uint32_t vsid = sr_get(vaddr);
     123        uint32_t sdr1 = sdr1_get();
     124       
     125        // FIXME: compute size of PHT exactly
     126        phte_t *phte = (phte_t *) PA2KA(sdr1 & 0xffff0000);
     127       
     128        /* Primary hash (xor) */
     129        uint32_t h = 0;
     130        uint32_t hash = vsid ^ page;
     131        uint32_t base = (hash & 0x3ff) << 3;
     132        uint32_t i;
     133        bool found = false;
     134       
     135        /* Find colliding PTE in PTEG */
     136        for (i = 0; i < 8; i++) {
     137                if ((phte[base + i].v)
     138                    && (phte[base + i].vsid == vsid)
     139                    && (phte[base + i].api == api)
     140                    && (phte[base + i].h == 0)) {
     141                        found = true;
     142                        break;
     143                }
     144        }
     145       
     146        if (!found) {
     147                /* Find unused PTE in PTEG */
     148                for (i = 0; i < 8; i++) {
     149                        if (!phte[base + i].v) {
     150                                found = true;
     151                                break;
     152                        }
     153                }
     154        }
     155       
     156        if (!found) {
     157                /* Secondary hash (not) */
     158                uint32_t base2 = (~hash & 0x3ff) << 3;
     159               
     160                /* Find colliding PTE in PTEG */
     161                for (i = 0; i < 8; i++) {
     162                        if ((phte[base2 + i].v)
     163                            && (phte[base2 + i].vsid == vsid)
     164                            && (phte[base2 + i].api == api)
     165                            && (phte[base2 + i].h == 1)) {
     166                                found = true;
     167                                base = base2;
     168                                h = 1;
     169                                break;
     170                        }
     171                }
     172               
     173                if (!found) {
     174                        /* Find unused PTE in PTEG */
     175                        for (i = 0; i < 8; i++) {
     176                                if (!phte[base2 + i].v) {
     177                                        found = true;
     178                                        base = base2;
     179                                        h = 1;
     180                                        break;
     181                                }
     182                        }
     183                }
     184               
     185                if (!found)
     186                        i = RANDI(seed) % 8;
     187        }
     188       
     189        phte[base + i].v = 1;
     190        phte[base + i].vsid = vsid;
     191        phte[base + i].h = h;
     192        phte[base + i].api = api;
     193        phte[base + i].rpn = pte->pfn;
     194        phte[base + i].r = 0;
     195        phte[base + i].c = 0;
     196        phte[base + i].wimg = (pte->page_cache_disable ? WIMG_NO_CACHE : 0);
     197        phte[base + i].pp = 2; // FIXME
     198}
     199
     200/** Process Instruction/Data Storage Exception
     201 *
     202 * @param n      Exception vector number.
     203 * @param istate Interrupted register context.
     204 *
     205 */
     206void pht_refill(unsigned int n, istate_t *istate)
     207{
     208        as_t *as = (AS == NULL) ? AS_KERNEL : AS;
     209        uintptr_t badvaddr;
     210       
     211        if (n == VECTOR_DATA_STORAGE)
     212                badvaddr = istate->dar;
     213        else
     214                badvaddr = istate->pc;
     215       
     216        page_table_lock(as, true);
     217       
     218        int pfrc;
     219        pte_t *pte = find_mapping_and_check(as, badvaddr,
     220            PF_ACCESS_READ /* FIXME */, istate, &pfrc);
     221       
     222        if (!pte) {
     223                switch (pfrc) {
     224                case AS_PF_FAULT:
     225                        page_table_unlock(as, true);
     226                        pht_refill_fail(badvaddr, istate);
     227                        return;
     228                case AS_PF_DEFER:
     229                        /*
     230                         * The page fault came during copy_from_uspace()
     231                         * or copy_to_uspace().
     232                         */
     233                        page_table_unlock(as, true);
     234                        return;
     235                default:
     236                        panic("Unexpected pfrc (%d).", pfrc);
     237                }
     238        }
     239       
     240        /* Record access to PTE */
     241        pte->accessed = 1;
     242        pht_insert(badvaddr, pte);
     243       
     244        page_table_unlock(as, true);
     245}
    38246
    39247void tlb_refill(unsigned int n, istate_t *istate)
    … …  
    81289void tlb_invalidate_all(void)
    82290{
     291        uint32_t index;
     292       
    83293        asm volatile (
     294                "li %[index], 0\n"
    84295                "sync\n"
    85         );
    86        
    87         for (unsigned int i = 0; i < 0x00040000; i += 0x00001000) {
    88                 asm volatile (
    89                         "tlbie %[i]\n"
    90                         :: [i] "r" (i)
    91                 );
    92         }
    93        
    94         asm volatile (
     296               
     297                ".rept 64\n"
     298                "       tlbie %[index]\n"
     299                "       addi %[index], %[index], 0x1000\n"
     300                ".endr\n"
     301               
    95302                "eieio\n"
    96303                "tlbsync\n"
    97304                "sync\n"
     305                : [index] "=r" (index)
    98306        );
    99307}
    … …  
    101309void tlb_invalidate_asid(asid_t asid)
    102310{
     311        uint32_t sdr1 = sdr1_get();
     312       
     313        // FIXME: compute size of PHT exactly
     314        phte_t *phte = (phte_t *) PA2KA(sdr1 & 0xffff0000);
     315       
     316        size_t i;
     317        for (i = 0; i < 8192; i++) {
     318                if ((phte[i].v) && (phte[i].vsid >= (asid << 4)) &&
     319                    (phte[i].vsid < ((asid << 4) + 16)))
     320                        phte[i].v = 0;
     321        }
     322       
    103323        tlb_invalidate_all();
    104324}
    … …  
    106326void tlb_invalidate_pages(asid_t asid, uintptr_t page, size_t cnt)
    107327{
     328        // TODO
    108329        tlb_invalidate_all();
    109330}

  • kernel/arch/sparc64/src/mm/sun4u/as.c

    r864a081 r5c460cc  
    4747#include <bitops.h>
    4848#include <macros.h>
    49 #include <memstr.h>
    5049
    5150#endif /* CONFIG_TSB */

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r864a081 r5c460cc  
    207207
    208208        page_table_lock(AS, true);
    209         t = page_mapping_find(AS, page_16k, true);
     209        t = page_mapping_find(AS, page_16k);
    210210        if (t && PTE_EXECUTABLE(t)) {
    211211                /*
    … …  
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, page_16k, true);
     277        t = page_mapping_find(AS, page_16k);
    278278        if (t) {
    279279                /*
    … …  
    319319
    320320        page_table_lock(AS, true);
    321         t = page_mapping_find(AS, page_16k, true);
     321        t = page_mapping_find(AS, page_16k);
    322322        if (t && PTE_WRITABLE(t)) {
    323323                /*

  • kernel/arch/sparc64/src/mm/sun4v/as.c

    r864a081 r5c460cc  
    5050#include <bitops.h>
    5151#include <macros.h>
    52 #include <memstr.h>
    5352
    5453#endif /* CONFIG_TSB */

  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r864a081 r5c460cc  
    219219
    220220        page_table_lock(AS, true);
    221         t = page_mapping_find(AS, va, true);
     221        t = page_mapping_find(AS, va);
    222222
    223223        if (t && PTE_EXECUTABLE(t)) {
    … …  
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, va, true);
     277        t = page_mapping_find(AS, va);
    278278        if (t) {
    279279                /*
    … …  
    317317
    318318        page_table_lock(AS, true);
    319         t = page_mapping_find(AS, va, true);
     319        t = page_mapping_find(AS, va);
    320320        if (t && PTE_WRITABLE(t)) {
    321321                /*

  • kernel/genarch/include/mm/page_pt.h

    r864a081 r5c460cc  
    129129
    130130extern void page_mapping_insert_pt(as_t *, uintptr_t, uintptr_t, unsigned int);
    131 extern pte_t *page_mapping_find_pt(as_t *, uintptr_t, bool);
     131extern pte_t *page_mapping_find_pt(as_t *, uintptr_t);
    132132
    133133#endif

  • kernel/genarch/src/drivers/ega/ega.c

    r864a081 r5c460cc  
    4141#include <mm/slab.h>
    4242#include <arch/mm/page.h>
     43#include <synch/spinlock.h>
    4344#include <typedefs.h>
    4445#include <arch/asm.h>

  • kernel/genarch/src/mm/page_ht.c

    r864a081 r5c460cc  
    5858static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5959static void ht_mapping_remove(as_t *, uintptr_t);
    60 static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
     60static pte_t *ht_mapping_find(as_t *, uintptr_t);
    6161
    6262/**
    … …  
    214214 * this call visible.
    215215 *
    216  * @param as   Address space to which page belongs.
     216 * @param as   Address space to wich page belongs.
    217217 * @param page Virtual address of the page to be demapped.
    218218 *
    … …  
    237237/** Find mapping for virtual page in page hash table.
    238238 *
    239  * @param as     Address space to which page belongs.
    240  * @param page   Virtual page.
    241  * @param nolock True if the page tables need not be locked.
     239 * Find mapping for virtual page.
     240 *
     241 * @param as   Address space to wich page belongs.
     242 * @param page Virtual page.
    242243 *
    243244 * @return NULL if there is no such mapping; requested mapping otherwise.
    244245 *
    245246 */
    246 pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
     247pte_t *ht_mapping_find(as_t *as, uintptr_t page)
    247248{
    248249        sysarg_t key[2] = {
    … …  
    251252        };
    252253
    253         ASSERT(nolock || page_table_locked(as));
     254        ASSERT(page_table_locked(as));
    254255       
    255256        link_t *cur = hash_table_find(&page_ht, key);

  • kernel/genarch/src/mm/page_pt.c

    r864a081 r5c460cc  
    4848static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    4949static void pt_mapping_remove(as_t *, uintptr_t);
    50 static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
     50static pte_t *pt_mapping_find(as_t *, uintptr_t);
    5151
    5252page_mapping_operations_t pt_mapping_operations = {
    … …  
    238238/** Find mapping for virtual page in hierarchical page tables.
    239239 *
    240  * @param as     Address space to which page belongs.
    241  * @param page   Virtual page.
    242  * @param nolock True if the page tables need not be locked.
     240 * Find mapping for virtual page.
     241 *
     242 * @param as   Address space to which page belongs.
     243 * @param page Virtual page.
    243244 *
    244245 * @return NULL if there is no such mapping; entry from PTL3 describing
    … …  
    246247 *
    247248 */
    248 pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
     249pte_t *pt_mapping_find(as_t *as, uintptr_t page)
    249250{
    250         ASSERT(nolock || page_table_locked(as));
     251        ASSERT(page_table_locked(as));
    251252
    252253        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);

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

    r864a081 r5c460cc  
    3838#include <typedefs.h>
    3939#include <mm/as.h>
    40 #include <arch/mm/page.h>
    41 
    42 #define P2SZ(pages) \
    43         ((pages) << PAGE_WIDTH)
     40#include <memstr.h>
    4441
    4542/** Operations to manipulate page mappings. */
    … …  
    4744        void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
    4845        void (* mapping_remove)(as_t *, uintptr_t);
    49         pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
     46        pte_t *(* mapping_find)(as_t *, uintptr_t);
    5047} page_mapping_operations_t;
    5148
    … …  
    5855extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5956extern void page_mapping_remove(as_t *, uintptr_t);
    60 extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
     57extern pte_t *page_mapping_find(as_t *, uintptr_t);
    6158extern pte_t *page_table_create(unsigned int);
    6259extern void page_table_destroy(pte_t *);

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

    r864a081 r5c460cc  
    8686extern void tlb_invalidate_asid(asid_t);
    8787extern void tlb_invalidate_pages(asid_t, uintptr_t, size_t);
    88 
    8988#endif
    9089

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

    r864a081 r5c460cc  
    6060
    6161/** Kernel log initialized */
    62 static atomic_t klog_inited = {false};
     62static bool klog_inited = false;
    6363
    6464/** First kernel log characters */
    … …  
    7575
    7676/** Kernel log spinlock */
    77 SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
     77SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "*klog_lock");
    7878
    7979/** Physical memory area used for klog buffer */
    … …  
    166166       
    167167        event_set_unmask_callback(EVENT_KLOG, klog_update);
    168         atomic_set(&klog_inited, true);
     168       
     169        spinlock_lock(&klog_lock);
     170        klog_inited = true;
     171        spinlock_unlock(&klog_lock);
    169172}
    170173
    … …  
    261264void klog_update(void)
    262265{
    263         if (!atomic_get(&klog_inited))
    264                 return;
    265        
    266266        spinlock_lock(&klog_lock);
    267267       
    268         if (klog_uspace > 0) {
     268        if ((klog_inited) && (klog_uspace > 0)) {
    269269                if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len,
    270270                    klog_uspace) == EOK)
    … …  
    277277void putchar(const wchar_t ch)
    278278{
    279         bool ordy = ((stdout) && (stdout->op->write));
    280        
    281279        spinlock_lock(&klog_lock);
    282280       
    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                 }
     281        if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
     282                /* Print charaters stored in kernel log */
     283                size_t i;
     284                for (i = klog_len - klog_stored; i < klog_len; i++)
     285                        stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
     286                klog_stored = 0;
    298287        }
    299288       
    … …  
    305294                klog_start = (klog_start + 1) % KLOG_LENGTH;
    306295       
    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                  */
     296        if ((stdout) && (stdout->op->write))
    323297                stdout->op->write(stdout, ch, silent);
    324         } else {
     298        else {
    325299                /*
    326300                 * No standard output routine defined yet.
    … …  
    332306                 * Note that the early_putc() function might be
    333307                 * a no-op on certain hardware configurations.
     308                 *
    334309                 */
    335310                early_putchar(ch);
    336         }
     311               
     312                if (klog_stored < klog_len)
     313                        klog_stored++;
     314        }
     315       
     316        /* The character is stored for uspace */
     317        if (klog_uspace < klog_len)
     318                klog_uspace++;
     319       
     320        spinlock_unlock(&klog_lock);
    337321       
    338322        /* Force notification on newline */

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

    r864a081 r5c460cc  
    302302         * We don't want any area to have conflicts with NULL page.
    303303         */
    304         if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
     304        if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
    305305                return false;
    306306       
    … …  
    329329                        mutex_lock(&area->lock);
    330330                       
    331                         if (overlaps(addr, P2SZ(count), area->base,
    332                             P2SZ(area->pages))) {
     331                        if (overlaps(addr, count << PAGE_WIDTH,
     332                            area->base, area->pages << PAGE_WIDTH)) {
    333333                                mutex_unlock(&area->lock);
    334334                                return false;
    … …  
    346346                        mutex_lock(&area->lock);
    347347                       
    348                         if (overlaps(addr, P2SZ(count), area->base,
    349                             P2SZ(area->pages))) {
     348                        if (overlaps(addr, count << PAGE_WIDTH,
     349                            area->base, area->pages << PAGE_WIDTH)) {
    350350                                mutex_unlock(&area->lock);
    351351                                return false;
    … …  
    366366                mutex_lock(&area->lock);
    367367               
    368                 if (overlaps(addr, P2SZ(count), area->base,
    369                     P2SZ(area->pages))) {
     368                if (overlaps(addr, count << PAGE_WIDTH,
     369                    area->base, area->pages << PAGE_WIDTH)) {
    370370                        mutex_unlock(&area->lock);
    371371                        return false;
    … …  
    380380         */
    381381        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    382                 return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
     382                return !overlaps(addr, count << PAGE_WIDTH,
     383                    KERNEL_ADDRESS_SPACE_START,
    383384                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    384385        }
    … …  
    473474       
    474475        btree_node_t *leaf;
    475         as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
    476             &leaf);
     476        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
    477477        if (area) {
    478478                /* va is the base address of an address space area */
    … …  
    495495                mutex_lock(&area->lock);
    496496
    497                 if ((area->base <= va) &&
    498                     (va <= area->base + (P2SZ(area->pages) - 1)))
     497                size_t size = area->pages << PAGE_WIDTH;
     498                if ((area->base <= va) && (va <= area->base + (size - 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,
    509             leaf);
     508        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
    510509        if (lnode) {
    511510                area = (as_area_t *) lnode->value[lnode->keys - 1];
    … …  
    513512                mutex_lock(&area->lock);
    514513               
    515                 if (va <= area->base + (P2SZ(area->pages) - 1))
     514                if (va < area->base + (area->pages << PAGE_WIDTH))
    516515                        return area;
    517516               
    … …  
    578577       
    579578        if (pages < area->pages) {
    580                 uintptr_t start_free = area->base + P2SZ(pages);
     579                uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
    581580               
    582581                /*
    … …  
    591590                 */
    592591                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    593                     area->base + P2SZ(pages), area->pages - pages);
     592                    area->base + (pages << PAGE_WIDTH), area->pages - pages);
    594593               
    595594                /*
    … …  
    614613                                size_t i = 0;
    615614                               
    616                                 if (overlaps(ptr, P2SZ(size), area->base,
    617                                     P2SZ(pages))) {
     615                                if (overlaps(ptr, size << PAGE_WIDTH, area->base,
     616                                    pages << PAGE_WIDTH)) {
    618617                                       
    619                                         if (ptr + P2SZ(size) <= start_free) {
     618                                        if (ptr + (size << PAGE_WIDTH) <= start_free) {
    620619                                                /*
    621620                                                 * The whole interval fits
    … …  
    648647                               
    649648                                for (; i < size; i++) {
    650                                         pte_t *pte = page_mapping_find(as,
    651                                             ptr + P2SZ(i), false);
     649                                        pte_t *pte = page_mapping_find(as, ptr +
     650                                            (i << PAGE_WIDTH));
    652651                                       
    653652                                        ASSERT(pte);
    … …  
    658657                                            (area->backend->frame_free)) {
    659658                                                area->backend->frame_free(area,
    660                                                     ptr + P2SZ(i),
     659                                                    ptr + (i << PAGE_WIDTH),
    661660                                                    PTE_GET_FRAME(pte));
    662661                                        }
    663662                                       
    664                                         page_mapping_remove(as, ptr + P2SZ(i));
     663                                        page_mapping_remove(as, ptr +
     664                                            (i << PAGE_WIDTH));
    665665                                }
    666666                        }
    … …  
    671671                 */
    672672               
    673                 tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
     673                tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
    674674                    area->pages - pages);
    675675               
    676676                /*
    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);
     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);
    682681                tlb_shootdown_finalize(ipl);
    683682               
    … …  
    798797                       
    799798                        for (size = 0; size < (size_t) node->value[i]; size++) {
    800                                 pte_t *pte = page_mapping_find(as,
    801                                      ptr + P2SZ(size), false);
     799                                pte_t *pte =
     800                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    802801                               
    803802                                ASSERT(pte);
    … …  
    808807                                    (area->backend->frame_free)) {
    809808                                        area->backend->frame_free(area,
    810                                             ptr + P2SZ(size),
    811                                             PTE_GET_FRAME(pte));
     809                                            ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
    812810                                }
    813811                               
    814                                 page_mapping_remove(as, ptr + P2SZ(size));
     812                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    815813                        }
    816814                }
    … …  
    824822       
    825823        /*
    826          * Invalidate potential software translation caches
    827          * (e.g. TSB on sparc64, PHT on ppc32).
     824         * Invalidate potential software translation caches (e.g. TSB on
     825         * sparc64).
    828826         */
    829827        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    899897        }
    900898       
    901         size_t src_size = P2SZ(src_area->pages);
     899        size_t src_size = src_area->pages << PAGE_WIDTH;
    902900        unsigned int src_flags = src_area->flags;
    903901        mem_backend_t *src_backend = src_area->backend;
    … …  
    10961094        for (cur = area->used_space.leaf_head.next;
    10971095            cur != &area->used_space.leaf_head; cur = cur->next) {
    1098                 btree_node_t *node = list_get_instance(cur, btree_node_t,
    1099                     leaf_link);
     1096                btree_node_t *node
     1097                    = list_get_instance(cur, btree_node_t, leaf_link);
    11001098                btree_key_t i;
    11011099               
    … …  
    11051103                       
    11061104                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1107                                 pte_t *pte = page_mapping_find(as,
    1108                                     ptr + P2SZ(size), false);
     1105                                pte_t *pte =
     1106                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    11091107                               
    11101108                                ASSERT(pte);
    … …  
    11151113                               
    11161114                                /* Remove old mapping */
    1117                                 page_mapping_remove(as, ptr + P2SZ(size));
     1115                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    11181116                        }
    11191117                }
    … …  
    11271125       
    11281126        /*
    1129          * Invalidate potential software translation caches
    1130          * (e.g. TSB on sparc64, PHT on ppc32).
     1127         * Invalidate potential software translation caches (e.g. TSB on
     1128         * sparc64).
    11311129         */
    11321130        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11611159                               
    11621160                                /* Insert the new mapping */
    1163                                 page_mapping_insert(as, ptr + P2SZ(size),
     1161                                page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
    11641162                                    old_frame[frame_idx++], page_flags);
    11651163                               
    … …  
    12421240         */
    12431241        pte_t *pte;
    1244         if ((pte = page_mapping_find(AS, page, false))) {
     1242        if ((pte = page_mapping_find(AS, page))) {
    12451243                if (PTE_PRESENT(pte)) {
    12461244                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    … …  
    14831481       
    14841482        if (src_area) {
    1485                 size = P2SZ(src_area->pages);
     1483                size = src_area->pages << PAGE_WIDTH;
    14861484                mutex_unlock(&src_area->lock);
    14871485        } else
    … …  
    15381536                if (page >= right_pg) {
    15391537                        /* Do nothing. */
    1540                 } else if (overlaps(page, P2SZ(count), left_pg,
    1541                     P2SZ(left_cnt))) {
     1538                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1539                    left_cnt << PAGE_WIDTH)) {
    15421540                        /* The interval intersects with the left interval. */
    15431541                        return false;
    1544                 } else if (overlaps(page, P2SZ(count), right_pg,
    1545                     P2SZ(right_cnt))) {
     1542                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1543                    right_cnt << PAGE_WIDTH)) {
    15461544                        /* The interval intersects with the right interval. */
    15471545                        return false;
    1548                 } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1549                     (page + P2SZ(count) == right_pg)) {
     1546                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1547                    (page + (count << PAGE_WIDTH) == right_pg)) {
    15501548                        /*
    15511549                         * The interval can be added by merging the two already
    … …  
    15551553                        btree_remove(&area->used_space, right_pg, leaf);
    15561554                        goto success;
    1557                 } else if (page == left_pg + P2SZ(left_cnt)) {
     1555                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    15581556                        /*
    15591557                         * The interval can be added by simply growing the left
    … …  
    15621560                        node->value[node->keys - 1] += count;
    15631561                        goto success;
    1564                 } else if (page + P2SZ(count) == right_pg) {
     1562                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    15651563                        /*
    15661564                         * The interval can be addded by simply moving base of
    … …  
    15891587                 */
    15901588               
    1591                 if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
     1589                if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1590                    right_cnt << PAGE_WIDTH)) {
    15921591                        /* The interval intersects with the right interval. */
    15931592                        return false;
    1594                 } else if (page + P2SZ(count) == right_pg) {
     1593                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    15951594                        /*
    15961595                         * The interval can be added by moving the base of the
    … …  
    16271626                if (page < left_pg) {
    16281627                        /* Do nothing. */
    1629                 } else if (overlaps(page, P2SZ(count), left_pg,
    1630                     P2SZ(left_cnt))) {
     1628                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1629                    left_cnt << PAGE_WIDTH)) {
    16311630                        /* The interval intersects with the left interval. */
    16321631                        return false;
    1633                 } else if (overlaps(page, P2SZ(count), right_pg,
    1634                     P2SZ(right_cnt))) {
     1632                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1633                    right_cnt << PAGE_WIDTH)) {
    16351634                        /* The interval intersects with the right interval. */
    16361635                        return false;
    1637                 } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1638                     (page + P2SZ(count) == right_pg)) {
     1636                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1637                    (page + (count << PAGE_WIDTH) == right_pg)) {
    16391638                        /*
    16401639                         * The interval can be added by merging the two already
    … …  
    16441643                        btree_remove(&area->used_space, right_pg, node);
    16451644                        goto success;
    1646                 } else if (page == left_pg + P2SZ(left_cnt)) {
     1645                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    16471646                        /*
    16481647                         * The interval can be added by simply growing the left
    … …  
    16511650                        leaf->value[leaf->keys - 1] += count;
    16521651                        goto success;
    1653                 } else if (page + P2SZ(count) == right_pg) {
     1652                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    16541653                        /*
    16551654                         * The interval can be addded by simply moving base of
    … …  
    16781677                 */
    16791678               
    1680                 if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
     1679                if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1680                    left_cnt << PAGE_WIDTH)) {
    16811681                        /* The interval intersects with the left interval. */
    16821682                        return false;
    1683                 } else if (left_pg + P2SZ(left_cnt) == page) {
     1683                } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
    16841684                        /*
    16851685                         * The interval can be added by growing the left
    … …  
    17161716                         */
    17171717                       
    1718                         if (overlaps(page, P2SZ(count), left_pg,
    1719                             P2SZ(left_cnt))) {
     1718                        if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1719                            left_cnt << PAGE_WIDTH)) {
    17201720                                /*
    17211721                                 * The interval intersects with the left
    … …  
    17231723                                 */
    17241724                                return false;
    1725                         } else if (overlaps(page, P2SZ(count), right_pg,
    1726                             P2SZ(right_cnt))) {
     1725                        } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1726                            right_cnt << PAGE_WIDTH)) {
    17271727                                /*
    17281728                                 * The interval intersects with the right
    … …  
    17301730                                 */
    17311731                                return false;
    1732                         } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1733                             (page + P2SZ(count) == right_pg)) {
     1732                        } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1733                            (page + (count << PAGE_WIDTH) == 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 + P2SZ(left_cnt)) {
     1741                        } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    17421742                                /*
    17431743                                 * The interval can be added by simply growing
    … …  
    17461746                                leaf->value[i - 1] += count;
    17471747                                goto success;
    1748                         } else if (page + P2SZ(count) == right_pg) {
     1748                        } else if (page + (count << PAGE_WIDTH) == 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] += P2SZ(count);
     1814                                        leaf->key[i] += count << PAGE_WIDTH;
    18151815                                        leaf->value[i] -= count;
    18161816                                        goto success;
    … …  
    18221822        }
    18231823       
    1824         btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
    1825             leaf);
     1824        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
    18261825        if ((node) && (page < leaf->key[0])) {
    18271826                uintptr_t left_pg = node->key[node->keys - 1];
    18281827                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18291828               
    1830                 if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
    1831                         if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
     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)) {
    18321833                                /*
    18331834                                 * The interval is contained in the rightmost
    … …  
    18381839                                node->value[node->keys - 1] -= count;
    18391840                                goto success;
    1840                         } else if (page + P2SZ(count) <
    1841                             left_pg + P2SZ(left_cnt)) {
    1842                                 size_t new_cnt;
    1843 
     1841                        } else if (page + (count << PAGE_WIDTH) <
     1842                            left_pg + (left_cnt << PAGE_WIDTH)) {
    18441843                                /*
    18451844                                 * The interval is contained in the rightmost
    … …  
    18491848                                 * new interval.
    18501849                                 */
    1851                                 new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1852                                     (page + P2SZ(count))) >> PAGE_WIDTH;
     1850                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1851                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    18531852                                node->value[node->keys - 1] -= count + new_cnt;
    18541853                                btree_insert(&area->used_space, page +
    1855                                     P2SZ(count), (void *) new_cnt, leaf);
     1854                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    18561855                                goto success;
    18571856                        }
    … …  
    18661865                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    18671866               
    1868                 if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
    1869                         if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
     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)) {
    18701871                                /*
    18711872                                 * The interval is contained in the rightmost
    … …  
    18751876                                leaf->value[leaf->keys - 1] -= count;
    18761877                                goto success;
    1877                         } else if (page + P2SZ(count) < left_pg +
    1878                             P2SZ(left_cnt)) {
    1879                                 size_t new_cnt;
    1880 
     1878                        } else if (page + (count << PAGE_WIDTH) < left_pg +
     1879                            (left_cnt << PAGE_WIDTH)) {
    18811880                                /*
    18821881                                 * The interval is contained in the rightmost
    … …  
    18861885                                 * interval.
    18871886                                 */
    1888                                 new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1889                                     (page + P2SZ(count))) >> PAGE_WIDTH;
     1887                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1888                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    18901889                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    18911890                                btree_insert(&area->used_space, page +
    1892                                     P2SZ(count), (void *) new_cnt, leaf);
     1891                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    18931892                                goto success;
    18941893                        }
    … …  
    19121911                         * to (i - 1) and i.
    19131912                         */
    1914                         if (overlaps(left_pg, P2SZ(left_cnt), page,
    1915                             P2SZ(count))) {
    1916                                 if (page + P2SZ(count) ==
    1917                                     left_pg + P2SZ(left_cnt)) {
     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)) {
    19181917                                        /*
    19191918                                         * The interval is contained in the
    … …  
    19241923                                        leaf->value[i - 1] -= count;
    19251924                                        goto success;
    1926                                 } else if (page + P2SZ(count) <
    1927                                     left_pg + P2SZ(left_cnt)) {
    1928                                         size_t new_cnt;
    1929 
     1925                                } else if (page + (count << PAGE_WIDTH) <
     1926                                    left_pg + (left_cnt << PAGE_WIDTH)) {
    19301927                                        /*
    19311928                                         * The interval is contained in the
    … …  
    19351932                                         * also inserting a new interval.
    19361933                                         */
    1937                                         new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1938                                             (page + P2SZ(count))) >>
     1934                                        size_t new_cnt = ((left_pg +
     1935                                            (left_cnt << PAGE_WIDTH)) -
     1936                                            (page + (count << PAGE_WIDTH))) >>
    19391937                                            PAGE_WIDTH;
    19401938                                        leaf->value[i - 1] -= count + new_cnt;
    19411939                                        btree_insert(&area->used_space, page +
    1942                                             P2SZ(count), (void *) new_cnt,
     1940                                            (count << PAGE_WIDTH), (void *) new_cnt,
    19431941                                            leaf);
    19441942                                        goto success;
    … …  
    20362034                btree_key_t i;
    20372035                for (i = 0; (ret == 0) && (i < node->keys); i++) {
    2038                         uintptr_t addr;
    2039 
    20402036                        as_area_t *area = (as_area_t *) node->value[i];
    20412037                       
    20422038                        mutex_lock(&area->lock);
    20432039                       
    2044                         addr = ALIGN_UP(area->base + P2SZ(area->pages),
     2040                        uintptr_t addr =
     2041                            ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
    20452042                            PAGE_SIZE);
    20462043                       
    … …  
    21012098                       
    21022099                        info[area_idx].start_addr = area->base;
    2103                         info[area_idx].size = P2SZ(area->pages);
     2100                        info[area_idx].size = FRAMES2SIZE(area->pages);
    21042101                        info[area_idx].flags = area->flags;
    21052102                        ++area_idx;
    … …  
    21392136                            " (%p - %p)\n", area, (void *) area->base,
    21402137                            area->pages, (void *) area->base,
    2141                             (void *) (area->base + P2SZ(area->pages)));
     2138                            (void *) (area->base + FRAMES2SIZE(area->pages)));
    21422139                        mutex_unlock(&area->lock);
    21432140                }

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

    r864a081 r5c460cc  
    5050#include <typedefs.h>
    5151#include <align.h>
    52 #include <memstr.h>
    5352#include <arch.h>
    5453
    … …  
    122121                                page_table_lock(area->as, false);
    123122                                pte = page_mapping_find(area->as,
    124                                     base + P2SZ(j), false);
     123                                    base + j * PAGE_SIZE);
    125124                                ASSERT(pte && PTE_VALID(pte) &&
    126125                                    PTE_PRESENT(pte));
    127126                                btree_insert(&area->sh_info->pagemap,
    128                                     (base + P2SZ(j)) - area->base,
     127                                    (base + j * PAGE_SIZE) - area->base,
    129128                                    (void *) PTE_GET_FRAME(pte), NULL);
    130129                                page_table_unlock(area->as, false);

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

    r864a081 r5c460cc  
    170170                        if (!(area->flags & AS_AREA_WRITE))
    171171                                if (base >= entry->p_vaddr &&
    172                                     base + P2SZ(count) <= start_anon)
     172                                    base + count * PAGE_SIZE <= start_anon)
    173173                                        continue;
    174174                       
    … …  
    182182                                if (!(area->flags & AS_AREA_WRITE))
    183183                                        if (base >= entry->p_vaddr &&
    184                                             base + P2SZ(j + 1) <= start_anon)
     184                                            base + (j + 1) * PAGE_SIZE <=
     185                                            start_anon)
    185186                                                continue;
    186187                               
    187188                                page_table_lock(area->as, false);
    188189                                pte = page_mapping_find(area->as,
    189                                     base + P2SZ(j), false);
     190                                    base + j * PAGE_SIZE);
    190191                                ASSERT(pte && PTE_VALID(pte) &&
    191192                                    PTE_PRESENT(pte));
    192193                                btree_insert(&area->sh_info->pagemap,
    193                                     (base + P2SZ(j)) - area->base,
     194                                    (base + j * PAGE_SIZE) - area->base,
    194195                                    (void *) PTE_GET_FRAME(pte), NULL);
    195196                                page_table_unlock(area->as, false);

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

    r864a081 r5c460cc  
    108108 * using flags. Allocate and setup any missing page tables.
    109109 *
    110  * @param as    Address space to which page belongs.
     110 * @param as    Address space to wich page belongs.
    111111 * @param page  Virtual address of the page to be mapped.
    112112 * @param frame Physical address of memory frame to which the mapping is
    … …  
    135135 * this call visible.
    136136 *
    137  * @param as   Address space to which page belongs.
     137 * @param as   Address space to wich page belongs.
    138138 * @param page Virtual address of the page to be demapped.
    139139 *
    … …  
    152152}
    153153
    154 /** Find mapping for virtual page.
     154/** Find mapping for virtual page
    155155 *
    156  * @param as     Address space to which page belongs.
    157  * @param page   Virtual page.
    158  * @param nolock True if the page tables need not be locked.
     156 * Find mapping for virtual page.
     157 *
     158 * @param as   Address space to wich page belongs.
     159 * @param page Virtual page.
    159160 *
    160161 * @return NULL if there is no such mapping; requested mapping
    … …  
    162163 *
    163164 */
    164 NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
     165NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
    165166{
    166         ASSERT(nolock || page_table_locked(as));
     167        ASSERT(page_table_locked(as));
    167168       
    168169        ASSERT(page_mapping_operations);
    169170        ASSERT(page_mapping_operations->mapping_find);
    170171       
    171         return page_mapping_operations->mapping_find(as, page, nolock);
     172        return page_mapping_operations->mapping_find(as, page);
    172173}
    173174

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

    r864a081 r5c460cc  
    4141#include <typedefs.h>
    4242#include <str.h>
     43
     44IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(printf_lock, "*printf_lock");
    4345
    4446static int vprintf_str_write(const char *str, size_t size, void *data)
    … …  
    9193        };
    9294       
    93         return printf_core(fmt, &ps, ap);
     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;
    94100}
    95101

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

    r864a081 r5c460cc  
    119119         */
    120120        page_table_lock(AS, true);
    121         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
     121        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
    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), false);
     157        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
    158158        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    159159                page_table_unlock(AS, true);

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

    r864a081 r5c460cc  
    9696                 * run in a simulator) that caused problems with both
    9797                 * printf_lock and the framebuffer lock.
     98                 *
    9899                 */
    99100                if (lock->name[0] == '*')

  • kernel/test/mm/mapping1.c

    r864a081 r5c460cc  
    3535#include <typedefs.h>
    3636#include <debug.h>
    37 #include <arch.h>
    3837
    3938#define PAGE0  0x10000000
    … …  
    5958        *((uint32_t *) frame1) = VALUE1;
    6059       
    61         page_table_lock(AS, true);
    62 
    6360        TPRINTF("Mapping virtual address %p to physical address %p.\n",
    6461            (void *) PAGE0, (void *) KA2PA(frame0));
    … …  
    6865            (void *) PAGE1, (void *) KA2PA(frame1));
    6966        page_mapping_insert(AS_KERNEL, PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE);
    70 
    71         page_table_unlock(AS, true);
    7267       
    7368        v0 = *((uint32_t *) PAGE0);

  • uspace/app/tester/mm/common.c

    r864a081 r5c460cc  
    135135}
    136136
    137 static void check_consistency(const char *loc)
    138 {
    139         /* Check heap consistency */
    140         void *prob = heap_check();
    141         if (prob != NULL) {
    142                 TPRINTF("\nError: Heap inconsistency at %p in %s.\n",
    143                     prob, loc);
    144                 TSTACKTRACE();
    145                 error_flag = true;
    146         }
    147 }
    148 
    149137/** Checked malloc
    150138 *
    … …  
    165153        /* Allocate the chunk of memory */
    166154        data = malloc(size);
    167         check_consistency("checked_malloc");
    168155        if (data == NULL)
    169156                return NULL;
    … …  
    173160                TPRINTF("\nError: Allocated block overlaps with another "
    174161                    "previously allocated block.\n");
    175                 TSTACKTRACE();
    176162                error_flag = true;
    177163        }
    … …  
    212198        if (block->addr == NULL) {
    213199                free(block);
    214                 check_consistency("alloc_block");
    215200                return NULL;
    216201        }
    … …  
    243228        /* Free the memory */
    244229        free(block->addr);
    245         check_consistency("free_block (a)");
    246230        free(block);
    247         check_consistency("free_block (b)");
    248231}
    249232
    … …  
    274257            pos < end; pos++)
    275258                *pos = block_expected_value(block, pos);
    276        
    277         check_consistency("fill_block");
    278259}
    279260
    … …  
    292273                if (*pos != block_expected_value(block, pos)) {
    293274                        TPRINTF("\nError: Corrupted content of a data block.\n");
    294                         TSTACKTRACE();
    295275                        error_flag = true;
    296276                        return;
    … …  
    316296        if (entry == NULL) {
    317297                TPRINTF("\nError: Corrupted list of allocated memory blocks.\n");
    318                 TSTACKTRACE();
    319298                error_flag = true;
    320299        }
    … …  
    346325        if (addr == NULL) {
    347326                free(area);
    348                 check_consistency("map_area (a)");
    349327                return NULL;
    350328        }
    … …  
    353331        if (area->addr == (void *) -1) {
    354332                free(area);
    355                 check_consistency("map_area (b)");
    356333                return NULL;
    357334        }
    … …  
    384361       
    385362        free(area);
    386         check_consistency("unmap_area");
    387363}
    388364
    … …  
    413389            pos < end; pos++)
    414390                *pos = area_expected_value(area, pos);
    415        
    416         check_consistency("fill_area");
    417 }
     391}

  • uspace/app/tester/mm/malloc1.c

    r864a081 r5c460cc  
    241241                                TPRINTF("A");
    242242                                fill_block(blk);
    243                                 RETURN_IF_ERROR;
    244243                        }
    245244                       

  • uspace/app/tester/mm/malloc3.c

    r864a081 r5c460cc  
    232232                                TPRINTF("A");
    233233                                fill_block(blk);
    234                                 RETURN_IF_ERROR;
    235234                               
    236235                                if ((mem_blocks_count % AREA_GRANULARITY) == 0) {
    237236                                        mem_area_t *area = map_area(AREA_SIZE);
    238237                                        RETURN_IF_ERROR;
    239                                        
    240238                                        if (area != NULL) {
    241239                                                TPRINTF("*");
    242240                                                fill_area(area);
    243                                                 RETURN_IF_ERROR;
    244241                                        } else
    245242                                                TPRINTF("F(*)");

  • uspace/app/tester/tester.h

    r864a081 r5c460cc  
    3838#include <sys/types.h>
    3939#include <bool.h>
    40 #include <stacktrace.h>
    4140
    4241#define IPC_TEST_SERVICE  10240
    … …  
    6059                if (!test_quiet) { \
    6160                        fprintf(stderr, (format), ##__VA_ARGS__); \
    62                 } \
    63         } while (0)
    64 
    65 #define TSTACKTRACE() \
    66         do { \
    67                 if (!test_quiet) { \
    68                         stacktrace_print(); \
    6961                } \
    7062        } while (0)

  • uspace/lib/c/arch/ppc32/_link.ld.in

    r864a081 r5c460cc  
    1010#endif
    1111        data PT_LOAD FLAGS(6);
    12         debug PT_NOTE;
    1312}
    1413
    … …  
    5655        } :data
    5756       
    58 #ifdef CONFIG_LINE_DEBUG
    59         .comment 0 : { *(.comment); } :debug
    60         .debug_abbrev 0 : { *(.debug_abbrev); } :debug
    61         .debug_aranges 0 : { *(.debug_aranges); } :debug
    62         .debug_info 0 : { *(.debug_info); } :debug
    63         .debug_line 0 : { *(.debug_line); } :debug
    64         .debug_loc 0 : { *(.debug_loc); } :debug
    65         .debug_pubnames 0 : { *(.debug_pubnames); } :debug
    66         .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
    67         .debug_ranges 0 : { *(.debug_ranges); } :debug
    68         .debug_str 0 : { *(.debug_str); } :debug
    69 #endif
    70        
    7157        /DISCARD/ : {
    7258                *(*);

  • uspace/lib/c/generic/assert.c

    r864a081 r5c460cc  
    3333#include <assert.h>
    3434#include <stdio.h>
    35 #include <io/klog.h>
    3635#include <stdlib.h>
    37 #include <atomic.h>
    3836#include <stacktrace.h>
    39 #include <stdint.h>
    40 
    41 static atomic_t failed_asserts = {0};
    4237
    4338void assert_abort(const char *cond, const char *file, unsigned int line)
    4439{
    45         /*
    46          * Send the message safely to klog. Nested asserts should not occur.
    47          */
    48         klog_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
    49             cond, file, line);
    50        
    51         /*
    52          * Check if this is a nested or parallel assert.
    53          */
    54         if (atomic_postinc(&failed_asserts))
    55                 abort();
    56        
    57         /*
    58          * Attempt to print the message to standard output and display
    59          * the stack trace. These operations can theoretically trigger nested
    60          * assertions.
    61          */
    6240        printf("Assertion failed (%s) in file \"%s\", line %u.\n",
    6341            cond, file, line);
    6442        stacktrace_print();
    65        
    6643        abort();
    6744}

  • uspace/lib/c/generic/io/klog.c

    r864a081 r5c460cc  
    3838#include <sys/types.h>
    3939#include <unistd.h>
    40 #include <errno.h>
    4140#include <io/klog.h>
    42 #include <io/printf_core.h>
    4341
    4442size_t klog_write(const void *buf, size_t size)
    … …  
    5755}
    5856
    59 /** Print formatted text to klog.
    60  *
    61  * @param fmt Format string
    62  *
    63  * \see For more details about format string see printf_core.
    64  *
    65  */
    66 int klog_printf(const char *fmt, ...)
    67 {
    68         va_list args;
    69         va_start(args, fmt);
    70        
    71         int ret = klog_vprintf(fmt, args);
    72        
    73         va_end(args);
    74        
    75         return ret;
    76 }
    77 
    78 static int klog_vprintf_str_write(const char *str, size_t size, void *data)
    79 {
    80         size_t wr = klog_write(str, size);
    81         return str_nlength(str, wr);
    82 }
    83 
    84 static int klog_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
    85 {
    86         size_t offset = 0;
    87         size_t chars = 0;
    88        
    89         while (offset < size) {
    90                 char buf[STR_BOUNDS(1)];
    91                 size_t sz = 0;
    92                
    93                 if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
    94                         klog_write(buf, sz);
    95                
    96                 chars++;
    97                 offset += sizeof(wchar_t);
    98         }
    99        
    100         return chars;
    101 }
    102 
    103 /** Print formatted text to klog.
    104  *
    105  * @param fmt Format string
    106  * @param ap  Format parameters
    107  *
    108  * \see For more details about format string see printf_core.
    109  *
    110  */
    111 int klog_vprintf(const char *fmt, va_list ap)
    112 {
    113         printf_spec_t ps = {
    114                 klog_vprintf_str_write,
    115                 klog_vprintf_wstr_write,
    116                 NULL
    117         };
    118        
    119         return printf_core(fmt, &ps, ap);
    120 }
    121 
    12257/** @}
    12358 */

  • uspace/lib/c/generic/io/vprintf.c

    r864a081 r5c460cc  
    9696/** Print formatted text to stdout.
    9797 *
    98  * @param fmt Format string
    99  * @param ap  Format parameters
     98 * @param file Output stream
     99 * @param fmt  Format string
     100 * @param ap   Format parameters
    100101 *
    101102 * \see For more details about format string see printf_core.

  • uspace/lib/c/generic/malloc.c

    r864a081 r5c460cc  
    7979        (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
    8080
    81 /** Overhead of each area. */
    82 #define AREA_OVERHEAD(size) \
    83         (ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
    84 
    8581/** Calculate real size of a heap block.
    8682 *
    … …  
    187183
    188184/** Next heap block to examine (next fit algorithm) */
    189 static heap_block_head_t *next_fit = NULL;
     185static heap_block_head_t *next = NULL;
    190186
    191187/** Futex for thread-safe heap manipulation */
    192188static futex_t malloc_futex = FUTEX_INITIALIZER;
    193 
    194 #ifndef NDEBUG
    195 
    196 #define malloc_assert(expr) \
    197         do { \
    198                 if (!(expr)) {\
    199                         futex_up(&malloc_futex); \
    200                         assert_abort(#expr, __FILE__, __LINE__); \
    201                 } \
    202         } while (0)
    203 
    204 #else /* NDEBUG */
    205 
    206 #define malloc_assert(expr)
    207 
    208 #endif /* NDEBUG */
    209189
    210190/** Initialize a heap block
    … …  
    248228        heap_block_head_t *head = (heap_block_head_t *) addr;
    249229       
    250         malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
     230        assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
    251231       
    252232        heap_block_foot_t *foot = BLOCK_FOOT(head);
    253233       
    254         malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
    255         malloc_assert(head->size == foot->size);
     234        assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
     235        assert(head->size == foot->size);
    256236}
    257237
    … …  
    267247        heap_area_t *area = (heap_area_t *) addr;
    268248       
    269         malloc_assert(area->magic == HEAP_AREA_MAGIC);
    270         malloc_assert(addr == area->start);
    271         malloc_assert(area->start < area->end);
    272         malloc_assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
    273         malloc_assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
     249        assert(area->magic == HEAP_AREA_MAGIC);
     250        assert(addr == area->start);
     251        assert(area->start < area->end);
     252        assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
     253        assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
    274254}
    275255
    … …  
    382362       
    383363        /* Eventually try to create a new area */
    384         return area_create(AREA_OVERHEAD(size));
     364        return area_create(AREA_FIRST_BLOCK_HEAD(size));
    385365}
    386366
    … …  
    402382       
    403383        block_check((void *) last_head);
    404         malloc_assert(last_head->area == area);
     384        assert(last_head->area == area);
    405385       
    406386        if (last_head->free) {
    … …  
    415395               
    416396                block_check((void *) first_head);
    417                 malloc_assert(first_head->area == area);
     397                assert(first_head->area == area);
    418398               
    419399                size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
    … …  
    459439                        /* Update heap area parameters */
    460440                        area->end = end;
    461                         size_t excess = ((size_t) area->end) - ((size_t) last_head);
     441                       
     442                        /* Update block layout */
     443                        void *last = (void *) last_head;
     444                        size_t excess = (size_t) (area->end - last);
    462445                       
    463446                        if (excess > 0) {
    … …  
    468451                                         * create a new free block.
    469452                                         */
    470                                         block_init((void *) last_head, excess, true, area);
     453                                        block_init(last, excess, true, area);
    471454                                } else {
    472455                                        /*
    … …  
    487470        }
    488471       
    489         next_fit = NULL;
     472        next = NULL;
    490473}
    491474
    … …  
    514497static void split_mark(heap_block_head_t *cur, const size_t size)
    515498{
    516         malloc_assert(cur->size >= size);
     499        assert(cur->size >= size);
    517500       
    518501        /* See if we should split the block. */
    … …  
    550533{
    551534        area_check((void *) area);
    552         malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
    553         malloc_assert((void *) first_block < area->end);
     535        assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     536        assert((void *) first_block < area->end);
    554537       
    555538        for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
    … …  
    576559                                split_mark(cur, real_size);
    577560                               
    578                                 next_fit = cur;
     561                                next = cur;
    579562                                return addr;
    580563                        } else {
    … …  
    628611                                                split_mark(next_head, real_size);
    629612                                               
    630                                                 next_fit = next_head;
     613                                                next = next_head;
    631614                                                return aligned;
    632615                                        } else {
    … …  
    654637                                                        split_mark(cur, real_size);
    655638                                                       
    656                                                         next_fit = cur;
     639                                                        next = cur;
    657640                                                        return aligned;
    658641                                                }
    … …  
    678661static void *malloc_internal(const size_t size, const size_t align)
    679662{
    680         malloc_assert(first_heap_area != NULL);
     663        assert(first_heap_area != NULL);
    681664       
    682665        if (align == 0)
    … …  
    692675       
    693676        /* Try the next fit approach */
    694         split = next_fit;
     677        split = next;
    695678       
    696679        if (split != NULL) {
    … …  
    803786       
    804787        block_check(head);
    805         malloc_assert(!head->free);
     788        assert(!head->free);
    806789       
    807790        heap_area_t *area = head->area;
    808791       
    809792        area_check(area);
    810         malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
    811         malloc_assert((void *) head < area->end);
     793        assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     794        assert((void *) head < area->end);
    812795       
    813796        void *ptr = NULL;
    … …  
    848831                       
    849832                        ptr = ((void *) head) + sizeof(heap_block_head_t);
    850                         next_fit = NULL;
     833                        next = NULL;
    851834                } else
    852835                        reloc = true;
    … …  
    880863       
    881864        block_check(head);
    882         malloc_assert(!head->free);
     865        assert(!head->free);
    883866       
    884867        heap_area_t *area = head->area;
    885868       
    886869        area_check(area);
    887         malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
    888         malloc_assert((void *) head < area->end);
     870        assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     871        assert((void *) head < area->end);
    889872       
    890873        /* Mark the block itself as free. */
    … …  
    921904}
    922905
    923 void *heap_check(void)
    924 {
    925         futex_down(&malloc_futex);
    926        
    927         if (first_heap_area == NULL) {
    928                 futex_up(&malloc_futex);
    929                 return (void *) -1;
    930         }
    931        
    932         /* Walk all heap areas */
    933         for (heap_area_t *area = first_heap_area; area != NULL;
    934             area = area->next) {
    935                
    936                 /* Check heap area consistency */
    937                 if ((area->magic != HEAP_AREA_MAGIC) ||
    938                     ((void *) area != area->start) ||
    939                     (area->start >= area->end) ||
    940                     (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
    941                     (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
    942                         futex_up(&malloc_futex);
    943                         return (void *) area;
    944                 }
    945                
    946                 /* Walk all heap blocks */
    947                 for (heap_block_head_t *head = (heap_block_head_t *)
    948                     AREA_FIRST_BLOCK_HEAD(area); (void *) head < area->end;
    949                     head = (heap_block_head_t *) (((void *) head) + head->size)) {
    950                        
    951                         /* Check heap block consistency */
    952                         if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
    953                                 futex_up(&malloc_futex);
    954                                 return (void *) head;
    955                         }
    956                        
    957                         heap_block_foot_t *foot = BLOCK_FOOT(head);
    958                        
    959                         if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
    960                             (head->size != foot->size)) {
    961                                 futex_up(&malloc_futex);
    962                                 return (void *) foot;
    963                         }
    964                 }
    965         }
    966        
    967         futex_up(&malloc_futex);
    968        
    969         return NULL;
    970 }
    971 
    972906/** @}
    973907 */

  • uspace/lib/c/generic/thread.c

    r864a081 r5c460cc  
    4444
    4545#ifndef THREAD_INITIAL_STACK_PAGES_NO
    46 #define THREAD_INITIAL_STACK_PAGES_NO   2
     46#define THREAD_INITIAL_STACK_PAGES_NO 1
    4747#endif
    4848

  • uspace/lib/c/include/io/klog.h

    r864a081 r5c460cc  
    3737
    3838#include <sys/types.h>
    39 #include <stdarg.h>
    4039
    4140extern size_t klog_write(const void *, size_t);
    4241extern void klog_update(void);
    43 extern int klog_printf(const char *, ...);
    44 extern int klog_vprintf(const char *, va_list);
    4542
    4643#endif

  • uspace/lib/c/include/malloc.h

    r864a081 r5c460cc  
    4646extern void *realloc(const void *addr, const size_t size);
    4747extern void free(const void *addr);
    48 extern void *heap_check(void);
    4948
    5049#endif
Note: See TracChangeset for help on using the changeset viewer.