Changeset 11b285d in mainline for kernel/genarch/src


Ignore:
Timestamp:
2018-05-13T15:19:32Z (7 years ago)
Author:
Jiří Zárevúcky <jiri.zarevucky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ad896eb
Parents:
13db2044
git-author:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-05-13 14:59:01)
git-committer:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-05-13 15:19:32)
Message:

Use standard signature for malloc() in kernel.

The remaining instances of blocking allocation are replaced with
a new separate function named nfmalloc (short for non-failing malloc).

Location:
kernel/genarch/src
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r13db2044 r11b285d  
    197197        /* Create MADT APIC entries index array */
    198198        madt_entries_index = (struct madt_apic_header **)
    199             malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header *),
    200             FRAME_ATOMIC);
     199            malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header *));
    201200        if (!madt_entries_index)
    202201                panic("Memory allocation error.");

  • kernel/genarch/src/ddi/ddi-bitmap.c

    r13db2044 r11b285d  
    6868                 */
    6969
    70                 void *store = malloc(bitmap_size(elements), FRAME_ATOMIC);
     70                void *store = malloc(bitmap_size(elements));
    7171                if (!store)
    7272                        return ENOMEM;

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

    r13db2044 r11b285d  
    5757{
    5858        dsrlnin_instance_t *instance =
    59             malloc(sizeof(dsrlnin_instance_t), FRAME_ATOMIC);
     59            malloc(sizeof(dsrlnin_instance_t));
    6060        if (instance) {
    6161                instance->dsrlnin = dev;

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

    r13db2044 r11b285d  
    7070outdev_t *dsrlnout_init(ioport8_t *base)
    7171{
    72         outdev_t *dsrlndev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
     72        outdev_t *dsrlndev = malloc(sizeof(outdev_t));
    7373        if (!dsrlndev)
    7474                return NULL;
    7575
    76         dsrlnout_instance_t *instance = malloc(sizeof(dsrlnout_instance_t),
    77             FRAME_ATOMIC);
     76        dsrlnout_instance_t *instance = malloc(sizeof(dsrlnout_instance_t));
    7877        if (!instance) {
    7978                free(dsrlndev);

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

    r13db2044 r11b285d  
    584584outdev_t *ega_init(ioport8_t *base, uintptr_t addr)
    585585{
    586         outdev_t *egadev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
     586        outdev_t *egadev = malloc(sizeof(outdev_t));
    587587        if (!egadev)
    588588                return NULL;
    589589
    590         ega_instance_t *instance = malloc(sizeof(ega_instance_t), FRAME_ATOMIC);
     590        ega_instance_t *instance = malloc(sizeof(ega_instance_t));
    591591        if (!instance) {
    592592                free(egadev);
    … …  
    609609        }
    610610
    611         instance->backbuf = (uint8_t *) malloc(EGA_VRAM_SIZE, FRAME_ATOMIC);
     611        instance->backbuf = (uint8_t *) malloc(EGA_VRAM_SIZE);
    612612        if (!instance->backbuf) {
    613613                LOG("Unable to allocate backbuffer.");

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

    r13db2044 r11b285d  
    106106{
    107107        i8042_instance_t *instance =
    108             malloc(sizeof(i8042_instance_t), FRAME_ATOMIC);
     108            malloc(sizeof(i8042_instance_t));
    109109        if (instance) {
    110110                instance->i8042 = dev;

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

    r13db2044 r11b285d  
    129129{
    130130        ns16550_instance_t *instance =
    131             malloc(sizeof(ns16550_instance_t), FRAME_ATOMIC);
     131            malloc(sizeof(ns16550_instance_t));
    132132        if (instance) {
    133133                instance->ns16550 = dev;
    … …  
    137137
    138138                if (output) {
    139                         instance->output = malloc(sizeof(outdev_t),
    140                             FRAME_ATOMIC);
     139                        instance->output = malloc(sizeof(outdev_t));
    141140                        if (!instance->output) {
    142141                                free(instance);

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

    r13db2044 r11b285d  
    7777
    7878        pl050_instance_t *instance =
    79             malloc(sizeof(pl050_instance_t), FRAME_ATOMIC);
     79            malloc(sizeof(pl050_instance_t));
    8080
    8181        pl050 = dev;

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

    r13db2044 r11b285d  
    102102outdev_t *s3c24xx_uart_init(uintptr_t paddr, inr_t inr)
    103103{
    104         outdev_t *uart_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
     104        outdev_t *uart_dev = malloc(sizeof(outdev_t));
    105105        if (!uart_dev)
    106106                return NULL;
    107107
    108108        s3c24xx_uart_t *uart =
    109             malloc(sizeof(s3c24xx_uart_t), FRAME_ATOMIC);
     109            malloc(sizeof(s3c24xx_uart_t));
    110110        if (!uart) {
    111111                free(uart_dev);

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

    r13db2044 r11b285d  
    9191{
    9292        cuda_instance_t *instance =
    93             malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
     93            malloc(sizeof(cuda_instance_t));
    9494        if (instance) {
    9595                instance->cuda = dev;

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

    r13db2044 r11b285d  
    571571        }
    572572
    573         outdev_t *fbdev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
     573        outdev_t *fbdev = malloc(sizeof(outdev_t));
    574574        if (!fbdev)
    575575                return NULL;
    576576
    577         fb_instance_t *instance = malloc(sizeof(fb_instance_t), FRAME_ATOMIC);
     577        fb_instance_t *instance = malloc(sizeof(fb_instance_t));
    578578        if (!instance) {
    579579                free(fbdev);
    … …  
    618618        }
    619619
    620         instance->backbuf = (uint16_t *) malloc(bbsize, FRAME_ATOMIC);
     620        instance->backbuf = (uint16_t *) malloc(bbsize);
    621621        if (!instance->backbuf) {
    622622                LOG("Unable to allocate backbuffer.");
    … …  
    626626        }
    627627
    628         instance->glyphs = (uint8_t *) malloc(glyphsize, FRAME_ATOMIC);
     628        instance->glyphs = (uint8_t *) malloc(glyphsize);
    629629        if (!instance->glyphs) {
    630630                LOG("Unable to allocate glyphs.");
    … …  
    635635        }
    636636
    637         instance->bgscan = malloc(instance->bgscanbytes, FRAME_ATOMIC);
     637        instance->bgscan = malloc(instance->bgscanbytes);
    638638        if (!instance->bgscan) {
    639639                LOG("Unable to allocate background pixel.");

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

    r13db2044 r11b285d  
    172172{
    173173        kbrd_instance_t *instance =
    174             malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
     174            malloc(sizeof(kbrd_instance_t));
    175175        if (instance) {
    176176                instance->thread = thread_create(kkbrd, (void *) instance,

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

    r13db2044 r11b285d  
    170170        kbrd_instance_t *instance;
    171171
    172         instance = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
     172        instance = malloc(sizeof(kbrd_instance_t));
    173173        if (instance) {
    174174                instance->thread = thread_create(kkbrd, (void *) instance, TASK, 0,

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

    r13db2044 r11b285d  
    348348                return NULL;
    349349
    350         void *dump = malloc(*size, FRAME_ATOMIC);
     350        void *dump = malloc(*size);
    351351        if (dump == NULL) {
    352352                *size = 0;
    … …  
    386386static void ofw_tree_node_sysinfo(ofw_tree_node_t *node, const char *path)
    387387{
    388         char *cur_path = (char *) malloc(PATH_MAX_LEN, 0);
     388        char *cur_path = (char *) nfmalloc(PATH_MAX_LEN);
    389389
    390390        for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {

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

    r13db2044 r11b285d  
    130130{
    131131        srln_instance_t *instance =
    132             malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
     132            malloc(sizeof(srln_instance_t));
    133133        if (instance) {
    134134                instance->thread = thread_create(ksrln, (void *) instance,
Note: See TracChangeset for help on using the changeset viewer.