Changeset 63e27ef in mainline for kernel/genarch/src


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/genarch/src
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/src/acpi/acpi.c

    r7354b5e r63e27ef  
    3939#include <genarch/acpi/madt.h>
    4040#include <arch/bios/bios.h>
     41#include <debug.h>
    4142#include <mm/page.h>
    4243#include <mm/km.h>

  • kernel/genarch/src/acpi/madt.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <typedefs.h>
    3839#include <genarch/acpi/acpi.h>
    … …  
    4142#include <arch/smp/smp.h>
    4243#include <panic.h>
    43 #include <debug.h>
    4444#include <config.h>
    4545#include <log.h>
    … …  
    8282static uint8_t madt_cpu_apic_id(size_t i)
    8383{
    84         ASSERT(i < madt_l_apic_entry_cnt);
     84        assert(i < madt_l_apic_entry_cnt);
    8585       
    8686        return ((struct madt_l_apic *)
    … …  
    9090static bool madt_cpu_enabled(size_t i)
    9191{
    92         ASSERT(i < madt_l_apic_entry_cnt);
     92        assert(i < madt_l_apic_entry_cnt);
    9393       
    9494        /*
    … …  
    106106static bool madt_cpu_bootstrap(size_t i)
    107107{
    108         ASSERT(i < madt_l_apic_entry_cnt);
     108        assert(i < madt_l_apic_entry_cnt);
    109109       
    110110        return ((struct madt_l_apic *)
    … …  
    176176    size_t i)
    177177{
    178         ASSERT(override->source < sizeof(isa_irq_map) / sizeof(int));
     178        assert(override->source < sizeof(isa_irq_map) / sizeof(int));
    179179       
    180180        isa_irq_map[override->source] = override->global_int;

  • kernel/genarch/src/drivers/am335x/timer.c

    r7354b5e r63e27ef  
    3434 */
    3535
     36#include <assert.h>
    3637#include <genarch/drivers/am335x/timer.h>
    3738#include <mm/km.h>
    … …  
    9091        size_t size;
    9192
    92         ASSERT(id < TIMERS_MAX);
    93         ASSERT(timer != NULL);
     93        assert(id < TIMERS_MAX);
     94        assert(timer != NULL);
    9495
    9596        if (id == DMTIMER1_1MS)
    … …  
    100101
    101102        timer->regs = (void *) km_map(base_addr, size, PAGE_NOT_CACHEABLE);
    102         ASSERT(timer->regs != NULL);
     103        assert(timer->regs != NULL);
    103104
    104105        timer->id = id;

  • kernel/genarch/src/drivers/dsrln/dsrlnin.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/drivers/dsrln/dsrlnin.h>
    3839#include <console/chardev.h>
    … …  
    7576void dsrlnin_wire(dsrlnin_instance_t *instance, indev_t *srlnin)
    7677{
    77         ASSERT(instance);
    78         ASSERT(srlnin);
     78        assert(instance);
     79        assert(srlnin);
    7980       
    8081        instance->srlnin = srlnin;

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

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <debug.h>
    3738#include <genarch/drivers/ega/ega.h>
    3839#include <putchar.h>

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

    r7354b5e r63e27ef  
    3838 */
    3939
     40#include <assert.h>
    4041#include <genarch/drivers/i8042/i8042.h>
    4142#include <genarch/drivers/legacy/ia32/io.h>
    … …  
    124125void i8042_wire(i8042_instance_t *instance, indev_t *kbrdin)
    125126{
    126         ASSERT(instance);
    127         ASSERT(kbrdin);
     127        assert(instance);
     128        assert(kbrdin);
    128129       
    129130        i8042_clear_buffer(instance->i8042);

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

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/drivers/ns16550/ns16550.h>
    3839#include <ddi/irq.h>
    … …  
    157158void ns16550_wire(ns16550_instance_t *instance, indev_t *input)
    158159{
    159         ASSERT(instance);
    160         ASSERT(input);
     160        assert(instance);
     161        assert(input);
    161162       
    162163        instance->input = input;

  • kernel/genarch/src/drivers/omap/uart.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/drivers/omap/uart.h>
    3839#include <ddi/device.h>
    … …  
    8687    omap_uart_t *uart, inr_t interrupt, uintptr_t addr, size_t size)
    8788{
    88         ASSERT(uart);
     89        assert(uart);
    8990        uart->regs = (void *)km_map(addr, size, PAGE_NOT_CACHEABLE);
    9091
    91         ASSERT(uart->regs);
     92        assert(uart->regs);
    9293
    9394        /* Soft reset the port */
    … …  
    171172void omap_uart_input_wire(omap_uart_t *uart, indev_t *indev)
    172173{
    173         ASSERT(uart);
     174        assert(uart);
    174175        /* Set indev */
    175176        uart->indev = indev;

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

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/drivers/pl011/pl011.h>
    3839#include <console/chardev.h>
    … …  
    9899bool pl011_uart_init(pl011_uart_t *uart, inr_t interrupt, uintptr_t addr)
    99100{
    100         ASSERT(uart);
     101        assert(uart);
    101102        uart->regs = (void*)km_map(addr, sizeof(pl011_uart_regs_t),
    102103                                   PAGE_NOT_CACHEABLE);
    103         ASSERT(uart->regs);
     104        assert(uart->regs);
    104105
    105106        /* Disable UART */
    … …  
    137138void pl011_uart_input_wire(pl011_uart_t *uart, indev_t *indev)
    138139{
    139         ASSERT(uart);
    140         ASSERT(indev);
     140        assert(uart);
     141        assert(indev);
    141142
    142143        uart->indev = indev;

  • kernel/genarch/src/drivers/s3c24xx/uart.c

    r7354b5e r63e27ef  
    3838 */
    3939
     40#include <assert.h>
    4041#include <genarch/drivers/s3c24xx/uart.h>
    4142#include <console/chardev.h>
    … …  
    161162void s3c24xx_uart_input_wire(s3c24xx_uart_t *uart, indev_t *indev)
    162163{
    163         ASSERT(uart);
    164         ASSERT(indev);
     164        assert(uart);
     165        assert(indev);
    165166
    166167        uart->indev = indev;

  • kernel/genarch/src/drivers/via-cuda/cuda.c

    r7354b5e r63e27ef  
    3434 */
    3535
     36#include <assert.h>
    3637#include <genarch/drivers/via-cuda/cuda.h>
    3738#include <console/chardev.h>
    … …  
    123124        cuda_t *dev = instance->cuda;
    124125
    125         ASSERT(instance);
    126         ASSERT(kbrdin);
     126        assert(instance);
     127        assert(kbrdin);
    127128
    128129        instance->kbrdin = kbrdin;
    … …  
    341342        cuda_t *dev = instance->cuda;
    342343
    343         ASSERT(instance->xstate == cx_listen);
     344        assert(instance->xstate == cx_listen);
    344345
    345346        if (instance->snd_bytes == 0)

  • kernel/genarch/src/fb/bfb.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <debug.h>
    3738#include <typedefs.h>
    3839#include <genarch/fb/fb.h>

  • kernel/genarch/src/fb/fb.c

    r7354b5e r63e27ef  
    3434 */
    3535
     36#include <assert.h>
     37#include <debug.h>
    3638#include <genarch/fb/font-8x16.h>
    3739#include <genarch/fb/fb.h>
    … …  
    511513outdev_t *fb_init(fb_properties_t *props)
    512514{
    513         ASSERT(props);
    514         ASSERT(props->x > 0);
    515         ASSERT(props->y > 0);
    516         ASSERT(props->scan > 0);
     515        assert(props);
     516        assert(props->x > 0);
     517        assert(props->y > 0);
     518        assert(props->scan > 0);
    517519       
    518520        rgb_conv_t rgb_conv;

  • kernel/genarch/src/kbrd/kbrd.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/kbrd/kbrd.h>
    3839#include <genarch/kbrd/scanc.h>
    … …  
    194195indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
    195196{
    196         ASSERT(instance);
    197         ASSERT(sink);
     197        assert(instance);
     198        assert(sink);
    198199       
    199200        instance->sink = sink;

  • kernel/genarch/src/kbrd/kbrd_at.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/kbrd/kbrd.h>
    3839#include <genarch/kbrd/scanc.h>
    … …  
    192193indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
    193194{
    194         ASSERT(instance);
    195         ASSERT(sink);
     195        assert(instance);
     196        assert(sink);
    196197       
    197198        instance->sink = sink;

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

    r7354b5e r63e27ef  
    5757 */
    5858
     59#include <assert.h>
    5960#include <mm/asid.h>
    6061#include <mm/as.h>
    … …  
    6465#include <synch/mutex.h>
    6566#include <adt/list.h>
    66 #include <debug.h>
    6767
    6868static size_t asids_allocated = 0;
    … …  
    7878        as_t *as;
    7979
    80         ASSERT(interrupts_disabled());
    81         ASSERT(spinlock_locked(&asidlock));
     80        assert(interrupts_disabled());
     81        assert(spinlock_locked(&asidlock));
    8282
    8383        /*
    … …  
    9898                 */
    9999                tmp = list_first(&inactive_as_with_asid_list);
    100                 ASSERT(tmp != NULL);
     100                assert(tmp != NULL);
    101101                list_remove(tmp);
    102102               
    … …  
    108108                 */
    109109                asid = as->asid;
    110                 ASSERT(asid != ASID_INVALID);
     110                assert(asid != ASID_INVALID);
    111111
    112112                /*

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

    r7354b5e r63e27ef  
    4848#include <synch/spinlock.h>
    4949#include <arch.h>
    50 #include <debug.h>
     50#include <assert.h>
    5151#include <adt/hash_table.h>
    5252#include <align.h>
    … …  
    137137bool compare(sysarg_t key[], size_t keys, link_t *item)
    138138{
    139         ASSERT(item);
    140         ASSERT(keys > 0);
    141         ASSERT(keys <= PAGE_HT_KEYS);
     139        assert(item);
     140        assert(keys > 0);
     141        assert(keys <= PAGE_HT_KEYS);
    142142       
    143143        /*
    … …  
    161161void remove_callback(link_t *item)
    162162{
    163         ASSERT(item);
     163        assert(item);
    164164       
    165165        /*
    … …  
    191191        };
    192192
    193         ASSERT(page_table_locked(as));
     193        assert(page_table_locked(as));
    194194
    195195        irq_spinlock_lock(&page_ht_lock, true);
    … …  
    197197        if (!hash_table_find(&page_ht, key)) {
    198198                pte_t *pte = slab_alloc(pte_cache, FRAME_LOWMEM | FRAME_ATOMIC);
    199                 ASSERT(pte != NULL);
     199                assert(pte != NULL);
    200200               
    201201                pte->g = (flags & PAGE_GLOBAL) != 0;
    … …  
    241241        };
    242242
    243         ASSERT(page_table_locked(as));
     243        assert(page_table_locked(as));
    244244       
    245245        irq_spinlock_lock(&page_ht_lock, true);
    … …  
    261261        };
    262262
    263         ASSERT(nolock || page_table_locked(as));
     263        assert(nolock || page_table_locked(as));
    264264
    265265        link_t *cur = hash_table_find(&page_ht, key);
    … …  
    307307                panic("Updating non-existent PTE");
    308308       
    309         ASSERT(pte->as == t->as);
    310         ASSERT(pte->page == t->page);
    311         ASSERT(pte->frame == t->frame);
    312         ASSERT(pte->g == t->g);
    313         ASSERT(pte->x == t->x);
    314         ASSERT(pte->w == t->w);
    315         ASSERT(pte->k == t->k);
    316         ASSERT(pte->c == t->c);
    317         ASSERT(pte->p == t->p);
     309        assert(pte->as == t->as);
     310        assert(pte->page == t->page);
     311        assert(pte->frame == t->frame);
     312        assert(pte->g == t->g);
     313        assert(pte->x == t->x);
     314        assert(pte->w == t->w);
     315        assert(pte->k == t->k);
     316        assert(pte->c == t->c);
     317        assert(pte->p == t->p);
    318318
    319319        t->a = pte->a;

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

    r7354b5e r63e27ef  
    3636 */
    3737
     38#include <assert.h>
    3839#include <genarch/mm/page_pt.h>
    3940#include <mm/page.h>
    … …  
    8182        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
    8283
    83         ASSERT(page_table_locked(as));
     84        assert(page_table_locked(as));
    8485       
    8586        if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
    … …  
    159160void pt_mapping_remove(as_t *as, uintptr_t page)
    160161{
    161         ASSERT(page_table_locked(as));
     162        assert(page_table_locked(as));
    162163
    163164        /*
    … …  
    293294static pte_t *pt_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
    294295{
    295         ASSERT(nolock || page_table_locked(as));
     296        assert(nolock || page_table_locked(as));
    296297
    297298        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
    … …  
    358359                panic("Updating non-existent PTE");     
    359360
    360         ASSERT(PTE_VALID(t) == PTE_VALID(pte));
    361         ASSERT(PTE_PRESENT(t) == PTE_PRESENT(pte));
    362         ASSERT(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
    363         ASSERT(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
    364         ASSERT(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
     361        assert(PTE_VALID(t) == PTE_VALID(pte));
     362        assert(PTE_PRESENT(t) == PTE_PRESENT(pte));
     363        assert(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
     364        assert(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
     365        assert(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
    365366
    366367        *t = *pte;
    … …  
    398399void pt_mapping_make_global(uintptr_t base, size_t size)
    399400{
    400         ASSERT(size > 0);
     401        assert(size > 0);
    401402       
    402403        uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
    … …  
    416417            addr += ptl0_step) {
    417418                if (GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr)) != 0) {
    418                         ASSERT(overlaps(addr, ptl0_step,
     419                        assert(overlaps(addr, ptl0_step,
    419420                            config.identity_base, config.identity_size));
    420421

  • kernel/genarch/src/ofw/ebus.c

    r7354b5e r63e27ef  
    3636 */
    3737
     38#include <assert.h>
    3839#include <genarch/ofw/ofw_tree.h>
    3940#include <genarch/ofw/ebus.h>
    … …  
    4142#include <str.h>
    4243#include <panic.h>
    43 #include <debug.h>
    4444#include <macros.h>
    4545
    … …  
    9494        size_t count = prop->size / sizeof(ofw_ebus_intr_map_t);
    9595       
    96         ASSERT(count);
     96        assert(count);
    9797       
    9898        prop = ofw_tree_getprop(node, "interrupt-map-mask");
    … …  
    102102        ofw_ebus_intr_mask_t *intr_mask = prop->value;
    103103       
    104         ASSERT(prop->size == sizeof(ofw_ebus_intr_mask_t));
     104        assert(prop->size == sizeof(ofw_ebus_intr_mask_t));
    105105       
    106106        uint32_t space = reg->space & intr_mask->space_mask;

  • kernel/genarch/src/srln/srln.c

    r7354b5e r63e27ef  
    3535 */
    3636
     37#include <assert.h>
    3738#include <genarch/srln/srln.h>
    3839#include <console/chardev.h>
    … …  
    148149indev_t *srln_wire(srln_instance_t *instance, indev_t *sink)
    149150{
    150         ASSERT(instance);
    151         ASSERT(sink);
     151        assert(instance);
     152        assert(sink);
    152153       
    153154        instance->sink = sink;
Note: See TracChangeset for help on using the changeset viewer.