Changeset 63e27ef in mainline for kernel/generic/src/mm


Ignore:
Timestamp:
2017-06-19T21:47:42Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
deacc58d
Parents:
7354b5e
Message:

ASSERT → assert

Location:
kernel/generic/src/mm
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r7354b5e r63e27ef  
    6767#include <arch/asm.h>
    6868#include <panic.h>
    69 #include <debug.h>
     69#include <assert.h>
    7070#include <print.h>
    7171#include <mem.h>
    … …  
    189189        DEADLOCK_PROBE_INIT(p_asidlock);
    190190       
    191         ASSERT(as != AS);
    192         ASSERT(atomic_get(&as->refcount) == 0);
     191        assert(as != AS);
     192        assert(atomic_get(&as->refcount) == 0);
    193193       
    194194        /*
    … …  
    236236        bool cond = true;
    237237        while (cond) {
    238                 ASSERT(!list_empty(&as->as_area_btree.leaf_list));
     238                assert(!list_empty(&as->as_area_btree.leaf_list));
    239239               
    240240                btree_node_t *node =
    … …  
    298298    size_t count, bool guarded, as_area_t *avoid)
    299299{
    300         ASSERT((addr % PAGE_SIZE) == 0);
    301         ASSERT(mutex_locked(&as->lock));
     300        assert((addr % PAGE_SIZE) == 0);
     301        assert(mutex_locked(&as->lock));
    302302
    303303        /*
    … …  
    455455    size_t size, bool guarded)
    456456{
    457         ASSERT(mutex_locked(&as->lock));
     457        assert(mutex_locked(&as->lock));
    458458       
    459459        if (size == 0)
    … …  
    532532       
    533533        mutex_lock(&sh_info->lock);
    534         ASSERT(sh_info->refcount);
     534        assert(sh_info->refcount);
    535535       
    536536        if (--sh_info->refcount == 0) {
    … …  
    696696NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
    697697{
    698         ASSERT(mutex_locked(&as->lock));
     698        assert(mutex_locked(&as->lock));
    699699       
    700700        btree_node_t *leaf;
    … …  
    827827                bool cond = true;
    828828                while (cond) {
    829                         ASSERT(!list_empty(&area->used_space.leaf_list));
     829                        assert(!list_empty(&area->used_space.leaf_list));
    830830                       
    831831                        btree_node_t *node =
    … …  
    893893                                            ptr + P2SZ(i), false, &pte);
    894894                                       
    895                                         ASSERT(found);
    896                                         ASSERT(PTE_VALID(&pte));
    897                                         ASSERT(PTE_PRESENT(&pte));
     895                                        assert(found);
     896                                        assert(PTE_VALID(&pte));
     897                                        assert(PTE_PRESENT(&pte));
    898898                                       
    899899                                        if ((area->backend) &&
    … …  
    10081008                                     ptr + P2SZ(size), false, &pte);
    10091009                               
    1010                                 ASSERT(found);
    1011                                 ASSERT(PTE_VALID(&pte));
    1012                                 ASSERT(PTE_PRESENT(&pte));
     1010                                assert(found);
     1011                                assert(PTE_VALID(&pte));
     1012                                assert(PTE_PRESENT(&pte));
    10131013                               
    10141014                                if ((area->backend) &&
    … …  
    11941194NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
    11951195{
    1196         ASSERT(mutex_locked(&area->lock));
     1196        assert(mutex_locked(&area->lock));
    11971197       
    11981198        int flagmap[] = {
    … …  
    13211321                                    ptr + P2SZ(size), false, &pte);
    13221322                               
    1323                                 ASSERT(found);
    1324                                 ASSERT(PTE_VALID(&pte));
    1325                                 ASSERT(PTE_PRESENT(&pte));
     1323                                assert(found);
     1324                                assert(PTE_VALID(&pte));
     1325                                assert(PTE_PRESENT(&pte));
    13261326                               
    13271327                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
    … …  
    15411541         */
    15421542        if (old_as) {
    1543                 ASSERT(old_as->cpu_refcount);
     1543                assert(old_as->cpu_refcount);
    15441544               
    15451545                if ((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
    … …  
    15501550                         * ASID.
    15511551                         */
    1552                         ASSERT(old_as->asid != ASID_INVALID);
     1552                        assert(old_as->asid != ASID_INVALID);
    15531553                       
    15541554                        list_append(&old_as->inactive_as_with_asid_link,
    … …  
    15971597NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
    15981598{
    1599         ASSERT(mutex_locked(&area->lock));
     1599        assert(mutex_locked(&area->lock));
    16001600       
    16011601        return area_flags_to_page_flags(area->flags);
    … …  
    16151615NO_TRACE pte_t *page_table_create(unsigned int flags)
    16161616{
    1617         ASSERT(as_operations);
    1618         ASSERT(as_operations->page_table_create);
     1617        assert(as_operations);
     1618        assert(as_operations->page_table_create);
    16191619       
    16201620        return as_operations->page_table_create(flags);
    … …  
    16301630NO_TRACE void page_table_destroy(pte_t *page_table)
    16311631{
    1632         ASSERT(as_operations);
    1633         ASSERT(as_operations->page_table_destroy);
     1632        assert(as_operations);
     1633        assert(as_operations->page_table_destroy);
    16341634       
    16351635        as_operations->page_table_destroy(page_table);
    … …  
    16511651NO_TRACE void page_table_lock(as_t *as, bool lock)
    16521652{
    1653         ASSERT(as_operations);
    1654         ASSERT(as_operations->page_table_lock);
     1653        assert(as_operations);
     1654        assert(as_operations->page_table_lock);
    16551655       
    16561656        as_operations->page_table_lock(as, lock);
    … …  
    16651665NO_TRACE void page_table_unlock(as_t *as, bool unlock)
    16661666{
    1667         ASSERT(as_operations);
    1668         ASSERT(as_operations->page_table_unlock);
     1667        assert(as_operations);
     1668        assert(as_operations->page_table_unlock);
    16691669       
    16701670        as_operations->page_table_unlock(as, unlock);
    … …  
    16801680NO_TRACE bool page_table_locked(as_t *as)
    16811681{
    1682         ASSERT(as_operations);
    1683         ASSERT(as_operations->page_table_locked);
     1682        assert(as_operations);
     1683        assert(as_operations->page_table_locked);
    16841684
    16851685        return as_operations->page_table_locked(as);
    … …  
    17241724bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
    17251725{
    1726         ASSERT(mutex_locked(&area->lock));
    1727         ASSERT(IS_ALIGNED(page, PAGE_SIZE));
    1728         ASSERT(count);
     1726        assert(mutex_locked(&area->lock));
     1727        assert(IS_ALIGNED(page, PAGE_SIZE));
     1728        assert(count);
    17291729       
    17301730        btree_node_t *leaf = NULL;
    … …  
    17371737        }
    17381738
    1739         ASSERT(leaf != NULL);
     1739        assert(leaf != NULL);
    17401740       
    17411741        if (!leaf->keys) {
    … …  
    20102010bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
    20112011{
    2012         ASSERT(mutex_locked(&area->lock));
    2013         ASSERT(IS_ALIGNED(page, PAGE_SIZE));
    2014         ASSERT(count);
     2012        assert(mutex_locked(&area->lock));
     2013        assert(IS_ALIGNED(page, PAGE_SIZE));
     2014        assert(count);
    20152015       
    20162016        btree_node_t *leaf;
    … …  
    22572257                        as_area_t *area = node->value[i];
    22582258                       
    2259                         ASSERT(area_idx < area_cnt);
     2259                        assert(area_idx < area_cnt);
    22602260                        mutex_lock(&area->lock);
    22612261                       

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

    r7354b5e r63e27ef  
    3737 */
    3838
     39#include <assert.h>
    3940#include <mm/as.h>
    4041#include <mm/page.h>
    … …  
    113114void anon_share(as_area_t *area)
    114115{
    115         ASSERT(mutex_locked(&area->as->lock));
    116         ASSERT(mutex_locked(&area->lock));
    117         ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
     116        assert(mutex_locked(&area->as->lock));
     117        assert(mutex_locked(&area->lock));
     118        assert(!(area->flags & AS_AREA_LATE_RESERVE));
    118119
    119120        /*
    … …  
    138139                                    base + P2SZ(j), false, &pte);
    139140
    140                                 ASSERT(found);
    141                                 ASSERT(PTE_VALID(&pte));
    142                                 ASSERT(PTE_PRESENT(&pte));
     141                                assert(found);
     142                                assert(PTE_VALID(&pte));
     143                                assert(PTE_PRESENT(&pte));
    143144
    144145                                btree_insert(&area->sh_info->pagemap,
    … …  
    190191        uintptr_t frame;
    191192
    192         ASSERT(page_table_locked(AS));
    193         ASSERT(mutex_locked(&area->lock));
    194         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
     193        assert(page_table_locked(AS));
     194        assert(mutex_locked(&area->lock));
     195        assert(IS_ALIGNED(upage, PAGE_SIZE));
    195196
    196197        if (!as_area_check_access(area, access))
    … …  
    294295void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
    295296{
    296         ASSERT(page_table_locked(area->as));
    297         ASSERT(mutex_locked(&area->lock));
     297        assert(page_table_locked(area->as));
     298        assert(mutex_locked(&area->lock));
    298299
    299300        if (area->flags & AS_AREA_LATE_RESERVE) {

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

    r7354b5e r63e27ef  
    3737
    3838#include <lib/elf.h>
    39 #include <debug.h>
     39#include <assert.h>
    4040#include <typedefs.h>
    4141#include <mm/as.h>
    … …  
    142142        uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
    143143
    144         ASSERT(mutex_locked(&area->as->lock));
    145         ASSERT(mutex_locked(&area->lock));
     144        assert(mutex_locked(&area->as->lock));
     145        assert(mutex_locked(&area->lock));
    146146
    147147        /*
    … …  
    200200                                    base + P2SZ(j), false, &pte);
    201201
    202                                 ASSERT(found);
    203                                 ASSERT(PTE_VALID(&pte));
    204                                 ASSERT(PTE_PRESENT(&pte));
     202                                assert(found);
     203                                assert(PTE_VALID(&pte));
     204                                assert(PTE_PRESENT(&pte));
    205205
    206206                                btree_insert(&area->sh_info->pagemap,
    … …  
    261261        bool dirty = false;
    262262
    263         ASSERT(page_table_locked(AS));
    264         ASSERT(mutex_locked(&area->lock));
    265         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
     263        assert(page_table_locked(AS));
     264        assert(mutex_locked(&area->lock));
     265        assert(IS_ALIGNED(upage, PAGE_SIZE));
    266266
    267267        if (!as_area_check_access(area, access))
    … …  
    345345                            base + i * FRAME_SIZE, true, &pte);
    346346
    347                         ASSERT(found);
    348                         ASSERT(PTE_PRESENT(&pte));
     347                        assert(found);
     348                        assert(PTE_PRESENT(&pte));
    349349
    350350                        frame = PTE_GET_FRAME(&pte);
    … …  
    424424        uintptr_t start_anon;
    425425
    426         ASSERT(page_table_locked(area->as));
    427         ASSERT(mutex_locked(&area->lock));
    428 
    429         ASSERT(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
    430         ASSERT(page < entry->p_vaddr + entry->p_memsz);
     426        assert(page_table_locked(area->as));
     427        assert(mutex_locked(&area->lock));
     428
     429        assert(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
     430        assert(page < entry->p_vaddr + entry->p_memsz);
    431431
    432432        start_anon = entry->p_vaddr + entry->p_filesz;

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

    r7354b5e r63e27ef  
    3737 */
    3838
    39 #include <debug.h>
     39#include <assert.h>
    4040#include <typedefs.h>
    4141#include <mm/as.h>
    … …  
    9595void phys_share(as_area_t *area)
    9696{
    97         ASSERT(mutex_locked(&area->as->lock));
    98         ASSERT(mutex_locked(&area->lock));
     97        assert(mutex_locked(&area->as->lock));
     98        assert(mutex_locked(&area->lock));
    9999}
    100100
    … …  
    135135        uintptr_t base = area->backend_data.base;
    136136
    137         ASSERT(page_table_locked(AS));
    138         ASSERT(mutex_locked(&area->lock));
    139         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
     137        assert(page_table_locked(AS));
     138        assert(mutex_locked(&area->lock));
     139        assert(IS_ALIGNED(upage, PAGE_SIZE));
    140140
    141141        if (!as_area_check_access(area, access))
    142142                return AS_PF_FAULT;
    143143
    144         ASSERT(upage - area->base < area->backend_data.frames * FRAME_SIZE);
     144        assert(upage - area->base < area->backend_data.frames * FRAME_SIZE);
    145145        page_mapping_insert(AS, upage, base + (upage - area->base),
    146146            as_area_get_flags(area));

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

    r7354b5e r63e27ef  
    4646#include <typedefs.h>
    4747#include <align.h>
    48 #include <debug.h>
     48#include <assert.h>
    4949#include <errno.h>
    5050#include <log.h>
    … …  
    108108int user_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
    109109{
    110         ASSERT(page_table_locked(AS));
    111         ASSERT(mutex_locked(&area->lock));
    112         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
     110        assert(page_table_locked(AS));
     111        assert(mutex_locked(&area->lock));
     112        assert(IS_ALIGNED(upage, PAGE_SIZE));
    113113
    114114        if (!as_area_check_access(area, access))
    … …  
    162162void user_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
    163163{
    164         ASSERT(page_table_locked(area->as));
    165         ASSERT(mutex_locked(&area->lock));
     164        assert(page_table_locked(area->as));
     165        assert(mutex_locked(&area->lock));
    166166
    167167        pfn_t pfn = ADDR2PFN(frame);

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

    r7354b5e r63e27ef  
    4747#include <mm/as.h>
    4848#include <panic.h>
    49 #include <debug.h>
     49#include <assert.h>
    5050#include <adt/list.h>
    5151#include <synch/mutex.h>
    … …  
    349349NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t index)
    350350{
    351         ASSERT(index < zone->count);
     351        assert(index < zone->count);
    352352       
    353353        return &zone->frames[index];
    … …  
    370370    pfn_t constraint)
    371371{
    372         ASSERT(zone->flags & ZONE_AVAILABLE);
     372        assert(zone->flags & ZONE_AVAILABLE);
    373373       
    374374        /* Allocate frames from zone */
    … …  
    377377            FRAME_LOWPRIO, constraint, &index);
    378378       
    379         ASSERT(avail);
    380         ASSERT(index != (size_t) -1);
     379        assert(avail);
     380        assert(index != (size_t) -1);
    381381       
    382382        /* Update frame reference count */
    … …  
    384384                frame_t *frame = zone_get_frame(zone, index + i);
    385385               
    386                 ASSERT(frame->refcount == 0);
     386                assert(frame->refcount == 0);
    387387                frame->refcount = 1;
    388388        }
    … …  
    407407NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index)
    408408{
    409         ASSERT(zone->flags & ZONE_AVAILABLE);
     409        assert(zone->flags & ZONE_AVAILABLE);
    410410       
    411411        frame_t *frame = zone_get_frame(zone, index);
    412412       
    413         ASSERT(frame->refcount > 0);
     413        assert(frame->refcount > 0);
    414414       
    415415        if (!--frame->refcount) {
    … …  
    429429NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index)
    430430{
    431         ASSERT(zone->flags & ZONE_AVAILABLE);
     431        assert(zone->flags & ZONE_AVAILABLE);
    432432       
    433433        frame_t *frame = zone_get_frame(zone, index);
    … …  
    456456    void *confdata)
    457457{
    458         ASSERT(zones.info[z1].flags & ZONE_AVAILABLE);
    459         ASSERT(zones.info[z2].flags & ZONE_AVAILABLE);
    460         ASSERT(zones.info[z1].flags == zones.info[z2].flags);
    461         ASSERT(zones.info[z1].base < zones.info[z2].base);
    462         ASSERT(!overlaps(zones.info[z1].base, zones.info[z1].count,
     458        assert(zones.info[z1].flags & ZONE_AVAILABLE);
     459        assert(zones.info[z2].flags & ZONE_AVAILABLE);
     460        assert(zones.info[z1].flags == zones.info[z2].flags);
     461        assert(zones.info[z1].base < zones.info[z2].base);
     462        assert(!overlaps(zones.info[z1].base, zones.info[z1].count,
    463463            zones.info[z2].base, zones.info[z2].count));
    464464       
    … …  
    509509NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    510510{
    511         ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
     511        assert(zones.info[znum].flags & ZONE_AVAILABLE);
    512512       
    513513        size_t cframes = SIZE2FRAMES(zone_conf_size(count));
    … …  
    704704                 * the assert
    705705                 */
    706                 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
     706                assert(confframe != ADDR2PFN((uintptr_t ) NULL));
    707707               
    708708                /* Update the known end of physical memory. */
    … …  
    792792        size_t znum = find_zone(pfn, 1, hint);
    793793       
    794         ASSERT(znum != (size_t) -1);
     794        assert(znum != (size_t) -1);
    795795       
    796796        zone_get_frame(&zones.info[znum],
    … …  
    806806        size_t znum = find_zone(pfn, 1, hint);
    807807       
    808         ASSERT(znum != (size_t) -1);
     808        assert(znum != (size_t) -1);
    809809       
    810810        void *res = zone_get_frame(&zones.info[znum],
    … …  
    830830    uintptr_t constraint, size_t *pzone)
    831831{
    832         ASSERT(count > 0);
     832        assert(count > 0);
    833833       
    834834        size_t hint = pzone ? (*pzone) : 0;
    … …  
    970970                size_t znum = find_zone(pfn, 1, 0);
    971971               
    972                 ASSERT(znum != (size_t) -1);
     972                assert(znum != (size_t) -1);
    973973               
    974974                freed += zone_frame_free(&zones.info[znum],
    … …  
    10301030        size_t znum = find_zone(pfn, 1, 0);
    10311031       
    1032         ASSERT(znum != (size_t) -1);
     1032        assert(znum != (size_t) -1);
    10331033       
    10341034        zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
    … …  
    11531153    uint64_t *free)
    11541154{
    1155         ASSERT(total != NULL);
    1156         ASSERT(unavail != NULL);
    1157         ASSERT(busy != NULL);
    1158         ASSERT(free != NULL);
     1155        assert(total != NULL);
     1156        assert(unavail != NULL);
     1157        assert(busy != NULL);
     1158        assert(free != NULL);
    11591159       
    11601160        irq_spinlock_lock(&zones.lock, true);

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

    r7354b5e r63e27ef  
    3838#include <mm/km.h>
    3939#include <arch/mm/km.h>
     40#include <assert.h>
    4041#include <mm/page.h>
    4142#include <mm/frame.h>
    … …  
    4445#include <typedefs.h>
    4546#include <lib/ra.h>
    46 #include <debug.h>
    4747#include <arch.h>
    4848#include <align.h>
    … …  
    9595{
    9696        km_ni_arena = ra_arena_create();
    97         ASSERT(km_ni_arena != NULL);
     97        assert(km_ni_arena != NULL);
    9898        km_non_identity_arch_init();
    9999        config.non_identity_configured = true;
    … …  
    112112
    113113        span_added = ra_span_add(km_ni_arena, base, size);
    114         ASSERT(span_added);
     114        assert(span_added);
    115115}
    116116
    … …  
    132132        uintptr_t offs;
    133133
    134         ASSERT(ALIGN_DOWN(paddr, FRAME_SIZE) == paddr);
    135         ASSERT(ALIGN_UP(size, FRAME_SIZE) == size);
     134        assert(ALIGN_DOWN(paddr, FRAME_SIZE) == paddr);
     135        assert(ALIGN_UP(size, FRAME_SIZE) == size);
    136136
    137137        /* Enforce natural or at least PAGE_SIZE alignment. */
    … …  
    154154        ipl_t ipl;
    155155
    156         ASSERT(ALIGN_DOWN(vaddr, PAGE_SIZE) == vaddr);
    157         ASSERT(ALIGN_UP(size, PAGE_SIZE) == size);
     156        assert(ALIGN_DOWN(vaddr, PAGE_SIZE) == vaddr);
     157        assert(ALIGN_UP(size, PAGE_SIZE) == size);
    158158
    159159        page_table_lock(AS_KERNEL, true);
    … …  
    240240uintptr_t km_temporary_page_get(uintptr_t *framep, frame_flags_t flags)
    241241{
    242         ASSERT(THREAD);
    243         ASSERT(framep);
    244         ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
     242        assert(THREAD);
     243        assert(framep);
     244        assert(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
    245245       
    246246        /*
    … …  
    281281void km_temporary_page_put(uintptr_t page)
    282282{
    283         ASSERT(THREAD);
     283        assert(THREAD);
    284284
    285285        if (km_is_non_identity(page))

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

    r7354b5e r63e27ef  
    6969#include <typedefs.h>
    7070#include <arch/asm.h>
    71 #include <debug.h>
    7271#include <arch.h>
     72#include <assert.h>
    7373#include <syscall/copy.h>
    7474#include <errno.h>
    … …  
    9898    unsigned int flags)
    9999{
    100         ASSERT(page_table_locked(as));
    101        
    102         ASSERT(page_mapping_operations);
    103         ASSERT(page_mapping_operations->mapping_insert);
     100        assert(page_table_locked(as));
     101       
     102        assert(page_mapping_operations);
     103        assert(page_mapping_operations->mapping_insert);
    104104
    105105        page_mapping_operations->mapping_insert(as, ALIGN_DOWN(page, PAGE_SIZE),
    … …  
    122122NO_TRACE void page_mapping_remove(as_t *as, uintptr_t page)
    123123{
    124         ASSERT(page_table_locked(as));
    125        
    126         ASSERT(page_mapping_operations);
    127         ASSERT(page_mapping_operations->mapping_remove);
     124        assert(page_table_locked(as));
     125       
     126        assert(page_mapping_operations);
     127        assert(page_mapping_operations->mapping_remove);
    128128       
    129129        page_mapping_operations->mapping_remove(as,
    … …  
    147147    pte_t *pte)
    148148{
    149         ASSERT(nolock || page_table_locked(as));
    150        
    151         ASSERT(page_mapping_operations);
    152         ASSERT(page_mapping_operations->mapping_find);
     149        assert(nolock || page_table_locked(as));
     150       
     151        assert(page_mapping_operations);
     152        assert(page_mapping_operations->mapping_find);
    153153       
    154154        return page_mapping_operations->mapping_find(as,
    … …  
    168168    pte_t *pte)
    169169{
    170         ASSERT(nolock || page_table_locked(as));
    171        
    172         ASSERT(page_mapping_operations);
    173         ASSERT(page_mapping_operations->mapping_find);
     170        assert(nolock || page_table_locked(as));
     171       
     172        assert(page_mapping_operations);
     173        assert(page_mapping_operations->mapping_find);
    174174       
    175175        page_mapping_operations->mapping_update(as,
    … …  
    184184void page_mapping_make_global(uintptr_t base, size_t size)
    185185{
    186         ASSERT(page_mapping_operations);
    187         ASSERT(page_mapping_operations->mapping_make_global);
     186        assert(page_mapping_operations);
     187        assert(page_mapping_operations->mapping_make_global);
    188188       
    189189        return page_mapping_operations->mapping_make_global(base, size);

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

    r7354b5e r63e27ef  
    3636 */
    3737
     38#include <assert.h>
    3839#include <mm/reserve.h>
    3940#include <mm/frame.h>
    … …  
    4243#include <typedefs.h>
    4344#include <arch/types.h>
    44 #include <debug.h>
    4545
    4646static bool reserve_initialized = false;
    … …  
    7272        bool reserved = false;
    7373
    74         ASSERT(reserve_initialized);
     74        assert(reserve_initialized);
    7575
    7676        irq_spinlock_lock(&reserve_lock, true);

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

    r7354b5e r63e27ef  
    101101 */
    102102
     103#include <assert.h>
    103104#include <synch/spinlock.h>
    104105#include <mm/slab.h>
    … …  
    111112#include <arch.h>
    112113#include <panic.h>
    113 #include <debug.h>
    114114#include <bitops.h>
    115115#include <macros.h>
    … …  
    260260                slab = obj2slab(obj);
    261261       
    262         ASSERT(slab->cache == cache);
     262        assert(slab->cache == cache);
    263263       
    264264        size_t freed = 0;
    … …  
    268268       
    269269        irq_spinlock_lock(&cache->slablock, true);
    270         ASSERT(slab->available < cache->objects);
     270        assert(slab->available < cache->objects);
    271271       
    272272        *((size_t *) obj) = slab->nextavail;
    … …  
    417417        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    418418       
    419         ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
     419        assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    420420       
    421421        if (cmag) { /* First try local CPU magazines */
    … …  
    484484        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    485485       
    486         ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
     486        assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    487487       
    488488        if (cmag) {
    … …  
    586586NO_TRACE static bool make_magcache(slab_cache_t *cache)
    587587{
    588         ASSERT(_slab_initialized >= 2);
     588        assert(_slab_initialized >= 2);
    589589       
    590590        cache->mag_cache = malloc(sizeof(slab_mag_cache_t) * config.cpu_count,
    … …  
    610610    unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
    611611{
    612         ASSERT(size > 0);
     612        assert(size > 0);
    613613       
    614614        memsetb(cache, sizeof(*cache), 0);
    … …  
    948948void *malloc(size_t size, unsigned int flags)
    949949{
    950         ASSERT(_slab_initialized);
    951         ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
     950        assert(_slab_initialized);
     951        assert(size <= (1 << SLAB_MAX_MALLOC_W));
    952952       
    953953        if (size < (1 << SLAB_MIN_MALLOC_W))
    … …  
    961961void *realloc(void *ptr, size_t size, unsigned int flags)
    962962{
    963         ASSERT(_slab_initialized);
    964         ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
     963        assert(_slab_initialized);
     964        assert(size <= (1 << SLAB_MAX_MALLOC_W));
    965965       
    966966        void *new_ptr;

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

    r7354b5e r63e27ef  
    4343#include <mm/asid.h>
    4444#include <arch/mm/tlb.h>
     45#include <assert.h>
    4546#include <smp/ipi.h>
    4647#include <synch/spinlock.h>
    … …  
    5051#include <arch.h>
    5152#include <panic.h>
    52 #include <debug.h>
    5353#include <cpu.h>
    5454
    … …  
    152152void tlb_shootdown_ipi_recv(void)
    153153{
    154         ASSERT(CPU);
     154        assert(CPU);
    155155       
    156156        CPU->tlb_active = false;
    … …  
    159159       
    160160        irq_spinlock_lock(&CPU->lock, false);
    161         ASSERT(CPU->tlb_messages_count <= TLB_MESSAGE_QUEUE_LEN);
     161        assert(CPU->tlb_messages_count <= TLB_MESSAGE_QUEUE_LEN);
    162162       
    163163        size_t i;
    … …  
    176176                        break;
    177177                case TLB_INVL_PAGES:
    178                         ASSERT(count);
     178                        assert(count);
    179179                        tlb_invalidate_pages(asid, page, count);
    180180                        break;
Note: See TracChangeset for help on using the changeset viewer.