Changeset 82d515e9 in mainline


Ignore:
Timestamp:
2017-12-05T11:30:02Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9af1c61
Parents:
9a09212
git-author:
Jakub Jermar <jakub@…> (2017-12-05 11:25:41)
git-committer:
Jakub Jermar <jakub@…> (2017-12-05 11:30:02)
Message:

Fix terminology

Objects of slab_cache_t type are caches, not slabs.

Location:
kernel/generic
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/ddi/irq.h

    r9a09212 r82d515e9  
    132132extern hash_table_t irq_uspace_hash_table;
    133133
    134 extern slab_cache_t *irq_slab;
     134extern slab_cache_t *irq_cache;
    135135
    136136extern inr_t last_inr;

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

    r9a09212 r82d515e9  
    173173} call_t;
    174174
    175 extern slab_cache_t *phone_slab;
     175extern slab_cache_t *phone_cache;
    176176
    177177extern answerbox_t *ipc_phone_0;

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

    r9a09212 r82d515e9  
    272272
    273273/** Fpu context slab cache. */
    274 extern slab_cache_t *fpu_context_slab;
     274extern slab_cache_t *fpu_context_cache;
    275275
    276276/* Thread syscall prototypes. */

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

    r9a09212 r82d515e9  
    5555#include <trace.h>
    5656
    57 static slab_cache_t *btree_node_slab;
     57static slab_cache_t *btree_node_cache;
    5858
    5959#define ROOT_NODE(n)   (!(n)->parent)
    … …  
    7171void btree_init(void)
    7272{
    73         btree_node_slab = slab_cache_create("btree_node_t",
     73        btree_node_cache = slab_cache_create("btree_node_t",
    7474            sizeof(btree_node_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
    7575}
    … …  
    109109{
    110110        list_initialize(&t->leaf_list);
    111         t->root = (btree_node_t *) slab_alloc(btree_node_slab, 0);
     111        t->root = (btree_node_t *) slab_alloc(btree_node_cache, 0);
    112112        node_initialize(t->root);
    113113        list_append(&t->root->leaf_link, &t->leaf_list);
    … …  
    130130        }
    131131       
    132         slab_free(btree_node_slab, root);
     132        slab_free(btree_node_cache, root);
    133133}
    134134
    … …  
    516516         * Allocate and initialize new right sibling.
    517517         */
    518         rnode = (btree_node_t *) slab_alloc(btree_node_slab, 0);
     518        rnode = (btree_node_t *) slab_alloc(btree_node_cache, 0);
    519519        node_initialize(rnode);
    520520        rnode->parent = node->parent;
    … …  
    595595                         * We split the root node. Create new root.
    596596                         */
    597                         t->root = (btree_node_t *) slab_alloc(btree_node_slab, 0);
     597                        t->root = (btree_node_t *) slab_alloc(btree_node_cache, 0);
    598598                        node->parent = t->root;
    599599                        rnode->parent = t->root;
    … …  
    779779                        t->root = node->subtree[0];
    780780                        t->root->parent = NULL;
    781                         slab_free(btree_node_slab, node);
     781                        slab_free(btree_node_cache, node);
    782782                } else {
    783783                        /*
    … …  
    838838                idx = find_key_by_subtree(parent, rnode, true);
    839839                assert((int) idx != -1);
    840                 slab_free(btree_node_slab, rnode);
     840                slab_free(btree_node_cache, rnode);
    841841                _btree_remove(t, parent->key[idx], parent);
    842842        }

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

    r9a09212 r82d515e9  
    8787#define CAPS_LAST       (CAPS_SIZE - 1)
    8888
    89 static slab_cache_t *cap_slab;
     89static slab_cache_t *cap_cache;
    9090
    9191static size_t caps_hash(const ht_link_t *item)
    … …  
    116116void caps_init(void)
    117117{
    118         cap_slab = slab_cache_create("cap_t", sizeof(cap_t), 0, NULL,
     118        cap_cache = slab_cache_create("cap_t", sizeof(cap_t), 0, NULL,
    119119            NULL, 0);
    120120}
    … …  
    277277         */
    278278        if (!cap) {
    279                 cap = slab_alloc(cap_slab, FRAME_ATOMIC);
     279                cap = slab_alloc(cap_cache, FRAME_ATOMIC);
    280280                if (!cap) {
    281281                        mutex_unlock(&task->cap_info->lock);
    … …  
    284284                uintptr_t hbase;
    285285                if (!ra_alloc(task->cap_info->handles, 1, 1, &hbase)) {
    286                         slab_free(cap_slab, cap);
     286                        slab_free(cap_cache, cap);
    287287                        mutex_unlock(&task->cap_info->lock);
    288288                        return ENOMEM;
    … …  
    371371        hash_table_remove_item(&task->cap_info->caps, &cap->caps_link);
    372372        ra_free(task->cap_info->handles, handle, 1);
    373         slab_free(cap_slab, cap);
     373        slab_free(cap_cache, cap);
    374374        mutex_unlock(&task->cap_info->lock);
    375375}

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

    r9a09212 r82d515e9  
    497497};
    498498
    499 static int cmd_slabs(cmd_arg_t *argv);
    500 static cmd_info_t slabs_info = {
    501         .name = "slabs",
     499static int cmd_caches(cmd_arg_t *argv);
     500static cmd_info_t caches_info = {
     501        .name = "caches",
    502502        .description = "List slab caches.",
    503         .func = cmd_slabs,
     503        .func = cmd_caches,
    504504        .argc = 0
    505505};
    … …  
    605605        &call0_info,
    606606        &mcall0_info,
     607        &caches_info,
    607608        &call1_info,
    608609        &call2_info,
    … …  
    620621        &sched_info,
    621622        &set4_info,
    622         &slabs_info,
    623623        &symaddr_info,
    624624        &sysinfo_info,
    … …  
    12141214}
    12151215
    1216 /** Command for listings SLAB caches
    1217  *
    1218  * @param argv Ignores
     1216/** Command for listing slab allocator caches
     1217 *
     1218 * @param argv Ignored
    12191219 *
    12201220 * @return Always 1
    12211221 */
    1222 int cmd_slabs(cmd_arg_t *argv)
     1222int cmd_caches(cmd_arg_t *argv)
    12231223{
    12241224        slab_print_list();

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

    r9a09212 r82d515e9  
    5050#include <arch.h>
    5151
    52 slab_cache_t *irq_slab = NULL;
     52slab_cache_t *irq_cache = NULL;
    5353
    5454/** Spinlock protecting the kernel IRQ hash table
    … …  
    9797        last_inr = inrs - 1;
    9898
    99         irq_slab = slab_cache_create("irq_t", sizeof(irq_t), 0, NULL, NULL,
     99        irq_cache = slab_cache_create("irq_t", sizeof(irq_t), 0, NULL, NULL,
    100100            FRAME_ATOMIC);
    101         assert(irq_slab);
     101        assert(irq_cache);
    102102
    103103        hash_table_create(&irq_uspace_hash_table, chains, 0, &irq_ht_ops);

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

    r9a09212 r82d515e9  
    6666answerbox_t *ipc_phone_0 = NULL;
    6767
    68 static slab_cache_t *call_slab;
    69 static slab_cache_t *answerbox_slab;
    70 
    71 slab_cache_t *phone_slab = NULL;
     68static slab_cache_t *call_cache;
     69static slab_cache_t *answerbox_cache;
     70
     71slab_cache_t *phone_cache = NULL;
    7272
    7373/** Initialize a call structure.
    … …  
    9595        if (call->caller_phone)
    9696                kobject_put(call->caller_phone->kobject);
    97         slab_free(call_slab, call);
     97        slab_free(call_cache, call);
    9898}
    9999
    … …  
    115115call_t *ipc_call_alloc(unsigned int flags)
    116116{
    117         call_t *call = slab_alloc(call_slab, flags);
     117        call_t *call = slab_alloc(call_cache, flags);
    118118        if (!call)
    119119                return NULL;
    120120        kobject_t *kobj = (kobject_t *) malloc(sizeof(kobject_t), flags);
    121121        if (!kobj) {
    122                 slab_free(call_slab, call);
     122                slab_free(call_cache, call);
    123123                return NULL;
    124124        }
    … …  
    210210int ipc_call_sync(phone_t *phone, call_t *request)
    211211{
    212         answerbox_t *mybox = slab_alloc(answerbox_slab, 0);
     212        answerbox_t *mybox = slab_alloc(answerbox_cache, 0);
    213213        ipc_answerbox_init(mybox, TASK);
    214214       
    … …  
    218218        int rc = ipc_call(phone, request);
    219219        if (rc != EOK) {
    220                 slab_free(answerbox_slab, mybox);
     220                slab_free(answerbox_cache, mybox);
    221221                return rc;
    222222        }
    … …  
    265265        assert(!answer || request == answer);
    266266       
    267         slab_free(answerbox_slab, mybox);
     267        slab_free(answerbox_cache, mybox);
    268268        return rc;
    269269}
    … …  
    906906void ipc_init(void)
    907907{
    908         call_slab = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
     908        call_cache = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
    909909            NULL, 0);
    910         phone_slab = slab_cache_create("phone_t", sizeof(phone_t), 0, NULL,
     910        phone_cache = slab_cache_create("phone_t", sizeof(phone_t), 0, NULL,
    911911            NULL, 0);
    912         answerbox_slab = slab_cache_create("answerbox_t", sizeof(answerbox_t),
     912        answerbox_cache = slab_cache_create("answerbox_t", sizeof(answerbox_t),
    913913            0, NULL, NULL, 0);
    914914}

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

    r9a09212 r82d515e9  
    153153{
    154154        phone_t *phone = (phone_t *) arg;
    155         slab_free(phone_slab, phone);
     155        slab_free(phone_cache, phone);
    156156}
    157157
    … …  
    173173        cap_handle_t handle = cap_alloc(task);
    174174        if (handle >= 0) {
    175                 phone_t *phone = slab_alloc(phone_slab, FRAME_ATOMIC);
     175                phone_t *phone = slab_alloc(phone_cache, FRAME_ATOMIC);
    176176                if (!phone) {
    177177                        cap_free(TASK, handle);
    … …  
    181181                if (!kobject) {
    182182                        cap_free(TASK, handle);
    183                         slab_free(phone_slab, phone);
     183                        slab_free(phone_cache, phone);
    184184                        return ENOMEM;
    185185                }

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

    r9a09212 r82d515e9  
    294294        /* Free up the IRQ code and associated structures. */
    295295        code_free(irq->notif_cfg.code);
    296         slab_free(irq_slab, irq);
     296        slab_free(irq_cache, irq);
    297297}
    298298
    … …  
    333333                return handle;
    334334       
    335         irq_t *irq = (irq_t *) slab_alloc(irq_slab, FRAME_ATOMIC);
     335        irq_t *irq = (irq_t *) slab_alloc(irq_cache, FRAME_ATOMIC);
    336336        if (!irq) {
    337337                cap_free(TASK, handle);
    … …  
    342342        if (!kobject) {
    343343                cap_free(TASK, handle);
    344                 slab_free(irq_slab, irq);
     344                slab_free(irq_cache, irq);
    345345                return ENOMEM;
    346346        }

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

    r9a09212 r82d515e9  
    9090 *
    9191 */
    92 static slab_cache_t *as_slab;
     92static slab_cache_t *as_cache;
    9393
    9494/** ASID subsystem lock.
    … …  
    131131        as_arch_init();
    132132       
    133         as_slab = slab_cache_create("as_t", sizeof(as_t), 0,
     133        as_cache = slab_cache_create("as_t", sizeof(as_t), 0,
    134134            as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
    135135       
    … …  
    153153as_t *as_create(unsigned int flags)
    154154{
    155         as_t *as = (as_t *) slab_alloc(as_slab, 0);
     155        as_t *as = (as_t *) slab_alloc(as_cache, 0);
    156156        (void) as_create_arch(as, 0);
    157157       
    … …  
    254254#endif
    255255       
    256         slab_free(as_slab, as);
     256        slab_free(as_cache, as);
    257257}
    258258

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

    r9a09212 r82d515e9  
    818818}
    819819
    820 /* Print list of slabs
    821  *
    822  */
     820/* Print list of caches */
    823821void slab_print_list(void)
    824822{
    825         printf("[slab name       ] [size  ] [pages ] [obj/pg] [slabs ]"
     823        printf("[cache name      ] [size  ] [pages ] [obj/pg] [slabs ]"
    826824            " [cached] [alloc ] [ctl]\n");
    827825       

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

    r9a09212 r82d515e9  
    163163                        irq_spinlock_unlock(&CPU->lock, false);
    164164                        THREAD->saved_fpu_context =
    165                             (fpu_context_t *) slab_alloc(fpu_context_slab, 0);
     165                            (fpu_context_t *) slab_alloc(fpu_context_cache, 0);
    166166                       
    167167                        /* We may have switched CPUs during slab_alloc */

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

    r9a09212 r82d515e9  
    7979static task_id_t task_counter = 0;
    8080
    81 static slab_cache_t *task_slab;
     81static slab_cache_t *task_cache;
    8282
    8383/* Forward declarations. */
    … …  
    9393        TASK = NULL;
    9494        avltree_create(&tasks_tree);
    95         task_slab = slab_cache_create("task_t", sizeof(task_t), 0,
     95        task_cache = slab_cache_create("task_t", sizeof(task_t), 0,
    9696            tsk_constructor, tsk_destructor, 0);
    9797}
    … …  
    206206task_t *task_create(as_t *as, const char *name)
    207207{
    208         task_t *task = (task_t *) slab_alloc(task_slab, 0);
     208        task_t *task = (task_t *) slab_alloc(task_cache, 0);
    209209        task_create_arch(task);
    210210       
    … …  
    295295        as_release(task->as);
    296296       
    297         slab_free(task_slab, task);
     297        slab_free(task_cache, task);
    298298}
    299299

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

    r9a09212 r82d515e9  
    103103static thread_id_t last_tid = 0;
    104104
    105 static slab_cache_t *thread_slab;
     105static slab_cache_t *thread_cache;
    106106
    107107#ifdef CONFIG_FPU
    108 slab_cache_t *fpu_context_slab;
     108slab_cache_t *fpu_context_cache;
    109109#endif
    110110
    … …  
    169169        thread->saved_fpu_context = NULL;
    170170#else /* CONFIG_FPU_LAZY */
    171         thread->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
     171        thread->saved_fpu_context = slab_alloc(fpu_context_cache, kmflags);
    172172        if (!thread->saved_fpu_context)
    173173                return -1;
    … …  
    199199#ifdef CONFIG_FPU
    200200                if (thread->saved_fpu_context)
    201                         slab_free(fpu_context_slab, thread->saved_fpu_context);
     201                        slab_free(fpu_context_cache, thread->saved_fpu_context);
    202202#endif
    203203                return -1;
    … …  
    225225#ifdef CONFIG_FPU
    226226        if (thread->saved_fpu_context)
    227                 slab_free(fpu_context_slab, thread->saved_fpu_context);
     227                slab_free(fpu_context_cache, thread->saved_fpu_context);
    228228#endif
    229229       
    … …  
    241241       
    242242        atomic_set(&nrdy, 0);
    243         thread_slab = slab_cache_create("thread_t", sizeof(thread_t), 0,
     243        thread_cache = slab_cache_create("thread_t", sizeof(thread_t), 0,
    244244            thr_constructor, thr_destructor, 0);
    245245       
    246246#ifdef CONFIG_FPU
    247         fpu_context_slab = slab_cache_create("fpu_context_t",
     247        fpu_context_cache = slab_cache_create("fpu_context_t",
    248248            sizeof(fpu_context_t), FPU_CONTEXT_ALIGN, NULL, NULL, 0);
    249249#endif
    … …  
    341341    thread_flags_t flags, const char *name)
    342342{
    343         thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
     343        thread_t *thread = (thread_t *) slab_alloc(thread_cache, 0);
    344344        if (!thread)
    345345                return NULL;
    … …  
    457457         */
    458458        task_release(thread->task);
    459         slab_free(thread_slab, thread);
     459        slab_free(thread_cache, thread);
    460460}
    461461
    … …  
    974974                                 * We can safely deallocate it.
    975975                                 */
    976                                 slab_free(thread_slab, thread);
     976                                slab_free(thread_cache, thread);
    977977                                free(kernel_uarg);
    978978                               

  • kernel/generic/src/sysinfo/sysinfo.c

    r9a09212 r82d515e9  
    5353
    5454/** Sysinfo SLAB cache */
    55 static slab_cache_t *sysinfo_item_slab;
     55static slab_cache_t *sysinfo_item_cache;
    5656
    5757/** Sysinfo lock */
    … …  
    9898void sysinfo_init(void)
    9999{
    100         sysinfo_item_slab = slab_cache_create("sysinfo_item_t",
     100        sysinfo_item_cache = slab_cache_create("sysinfo_item_t",
    101101            sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
    102102            sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
    … …  
    204204               
    205205                *psubtree =
    206                     (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
     206                    (sysinfo_item_t *) slab_alloc(sysinfo_item_cache, 0);
    207207                assert(*psubtree);
    208208               
    … …  
    268268                       
    269269                        sysinfo_item_t *item =
    270                             (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
     270                            (sysinfo_item_t *) slab_alloc(sysinfo_item_cache, 0);
    271271                        assert(item);
    272272                       
Note: See TracChangeset for help on using the changeset viewer.