Changeset a35b458 in mainline for kernel/generic/src/mm/slab.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    186186{
    187187        size_t zone = 0;
    188        
     188
    189189        uintptr_t data_phys =
    190190            frame_alloc_generic(cache->frames, flags, 0, &zone);
    191191        if (!data_phys)
    192192                return NULL;
    193        
     193
    194194        void *data = (void *) PA2KA(data_phys);
    195        
     195
    196196        slab_t *slab;
    197197        size_t fsize;
    198        
     198
    199199        if (!(cache->flags & SLAB_CACHE_SLINSIDE)) {
    200200                slab = slab_alloc(slab_extern_cache, flags);
    … …  
    207207                slab = data + fsize - sizeof(*slab);
    208208        }
    209        
     209
    210210        /* Fill in slab structures */
    211211        size_t i;
    212212        for (i = 0; i < cache->frames; i++)
    213213                frame_set_parent(ADDR2PFN(KA2PA(data)) + i, slab, zone);
    214        
     214
    215215        slab->start = data;
    216216        slab->available = cache->objects;
    217217        slab->nextavail = 0;
    218218        slab->cache = cache;
    219        
     219
    220220        for (i = 0; i < cache->objects; i++)
    221221                *((size_t *) (slab->start + i * cache->size)) = i + 1;
    222        
     222
    223223        atomic_inc(&cache->allocated_slabs);
    224224        return slab;
    … …  
    235235        if (!(cache->flags & SLAB_CACHE_SLINSIDE))
    236236                slab_free(slab_extern_cache, slab);
    237        
     237
    238238        atomic_dec(&cache->allocated_slabs);
    239        
     239
    240240        return cache->frames;
    241241}
    … …  
    263263        if (!slab)
    264264                slab = obj2slab(obj);
    265        
     265
    266266        assert(slab->cache == cache);
    267        
     267
    268268        size_t freed = 0;
    269        
     269
    270270        if (cache->destructor)
    271271                freed = cache->destructor(obj);
    272        
     272
    273273        irq_spinlock_lock(&cache->slablock, true);
    274274        assert(slab->available < cache->objects);
    275        
     275
    276276        *((size_t *) obj) = slab->nextavail;
    277277        slab->nextavail = (obj - slab->start) / cache->size;
    278278        slab->available++;
    279        
     279
    280280        /* Move it to correct list */
    281281        if (slab->available == cache->objects) {
    … …  
    283283                list_remove(&slab->link);
    284284                irq_spinlock_unlock(&cache->slablock, true);
    285                
     285
    286286                return freed + slab_space_free(cache, slab);
    287287        } else if (slab->available == 1) {
    … …  
    290290                list_prepend(&slab->link, &cache->partial_slabs);
    291291        }
    292        
     292
    293293        irq_spinlock_unlock(&cache->slablock, true);
    294294        return freed;
    … …  
    303303{
    304304        irq_spinlock_lock(&cache->slablock, true);
    305        
     305
    306306        slab_t *slab;
    307        
     307
    308308        if (list_empty(&cache->partial_slabs)) {
    309309                /*
    … …  
    319319                if (!slab)
    320320                        return NULL;
    321                
     321
    322322                irq_spinlock_lock(&cache->slablock, true);
    323323        } else {
    … …  
    326326                list_remove(&slab->link);
    327327        }
    328        
     328
    329329        void *obj = slab->start + slab->nextavail * cache->size;
    330330        slab->nextavail = *((size_t *) obj);
    331331        slab->available--;
    332        
     332
    333333        if (!slab->available)
    334334                list_prepend(&slab->link, &cache->full_slabs);
    335335        else
    336336                list_prepend(&slab->link, &cache->partial_slabs);
    337        
     337
    338338        irq_spinlock_unlock(&cache->slablock, true);
    339        
     339
    340340        if ((cache->constructor) && (cache->constructor(obj, flags) != EOK)) {
    341341                /* Bad, bad, construction failed */
    … …  
    343343                return NULL;
    344344        }
    345        
     345
    346346        return obj;
    347347}
    … …  
    361361        slab_magazine_t *mag = NULL;
    362362        link_t *cur;
    363        
     363
    364364        irq_spinlock_lock(&cache->maglock, true);
    365365        if (!list_empty(&cache->magazines)) {
    … …  
    368368                else
    369369                        cur = list_last(&cache->magazines);
    370                
     370
    371371                mag = list_get_instance(cur, slab_magazine_t, link);
    372372                list_remove(&mag->link);
    … …  
    385385{
    386386        irq_spinlock_lock(&cache->maglock, true);
    387        
     387
    388388        list_prepend(&mag->link, &cache->magazines);
    389389        atomic_inc(&cache->magazine_counter);
    390        
     390
    391391        irq_spinlock_unlock(&cache->maglock, true);
    392392}
    … …  
    402402        size_t i;
    403403        size_t frames = 0;
    404        
     404
    405405        for (i = 0; i < mag->busy; i++) {
    406406                frames += slab_obj_destroy(cache, mag->objs[i], NULL);
    407407                atomic_dec(&cache->cached_objs);
    408408        }
    409        
     409
    410410        slab_free(&mag_cache, mag);
    411        
     411
    412412        return frames;
    413413}
    … …  
    420420        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
    421421        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    422        
     422
    423423        assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    424        
     424
    425425        if (cmag) { /* First try local CPU magazines */
    426426                if (cmag->busy)
    427427                        return cmag;
    428                
     428
    429429                if ((lastmag) && (lastmag->busy)) {
    430430                        cache->mag_cache[CPU->id].current = lastmag;
    … …  
    433433                }
    434434        }
    435        
     435
    436436        /* Local magazines are empty, import one from magazine list */
    437437        slab_magazine_t *newmag = get_mag_from_cache(cache, 1);
    438438        if (!newmag)
    439439                return NULL;
    440        
     440
    441441        if (lastmag)
    442442                magazine_destroy(cache, lastmag);
    443        
     443
    444444        cache->mag_cache[CPU->id].last = cmag;
    445445        cache->mag_cache[CPU->id].current = newmag;
    446        
     446
    447447        return newmag;
    448448}
    … …  
    457457        if (!CPU)
    458458                return NULL;
    459        
     459
    460460        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
    461        
     461
    462462        slab_magazine_t *mag = get_full_current_mag(cache);
    463463        if (!mag) {
    … …  
    465465                return NULL;
    466466        }
    467        
     467
    468468        void *obj = mag->objs[--mag->busy];
    469469        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    470        
     470
    471471        atomic_dec(&cache->cached_objs);
    472        
     472
    473473        return obj;
    474474}
    … …  
    487487        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
    488488        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    489        
     489
    490490        assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    491        
     491
    492492        if (cmag) {
    493493                if (cmag->busy < cmag->size)
    494494                        return cmag;
    495                
     495
    496496                if ((lastmag) && (lastmag->busy < lastmag->size)) {
    497497                        cache->mag_cache[CPU->id].last = cmag;
    … …  
    500500                }
    501501        }
    502        
     502
    503503        /* current | last are full | nonexistent, allocate new */
    504        
     504
    505505        /*
    506506         * We do not want to sleep just because of caching,
    … …  
    513513        if (!newmag)
    514514                return NULL;
    515        
     515
    516516        newmag->size = SLAB_MAG_SIZE;
    517517        newmag->busy = 0;
    518        
     518
    519519        /* Flush last to magazine list */
    520520        if (lastmag)
    521521                put_mag_to_cache(cache, lastmag);
    522        
     522
    523523        /* Move current as last, save new as current */
    524524        cache->mag_cache[CPU->id].last = cmag;
    525525        cache->mag_cache[CPU->id].current = newmag;
    526        
     526
    527527        return newmag;
    528528}
    … …  
    537537        if (!CPU)
    538538                return -1;
    539        
     539
    540540        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
    541        
     541
    542542        slab_magazine_t *mag = make_empty_current_mag(cache);
    543543        if (!mag) {
    … …  
    545545                return -1;
    546546        }
    547        
     547
    548548        mag->objs[mag->busy++] = obj;
    549        
     549
    550550        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    551        
     551
    552552        atomic_inc(&cache->cached_objs);
    553        
     553
    554554        return 0;
    555555}
    … …  
    578578        size_t objects = comp_objects(cache);
    579579        size_t ssize = FRAMES2SIZE(cache->frames);
    580        
     580
    581581        if (cache->flags & SLAB_CACHE_SLINSIDE)
    582582                ssize -= sizeof(slab_t);
    583        
     583
    584584        return ssize - objects * cache->size;
    585585}
    … …  
    591591{
    592592        assert(_slab_initialized >= 2);
    593        
     593
    594594        cache->mag_cache = slab_alloc(&slab_mag_cache, FRAME_ATOMIC);
    595595        if (!cache->mag_cache)
    596596                return false;
    597        
     597
    598598        size_t i;
    599599        for (i = 0; i < config.cpu_count; i++) {
    … …  
    602602                    "slab.cache.mag_cache[].lock");
    603603        }
    604        
     604
    605605        return true;
    606606}
    … …  
    614614{
    615615        assert(size > 0);
    616        
     616
    617617        memsetb(cache, sizeof(*cache), 0);
    618618        cache->name = name;
    619        
     619
    620620        if (align < sizeof(sysarg_t))
    621621                align = sizeof(sysarg_t);
    622        
     622
    623623        size = ALIGN_UP(size, align);
    624        
     624
    625625        cache->size = size;
    626626        cache->constructor = constructor;
    627627        cache->destructor = destructor;
    628628        cache->flags = flags;
    629        
     629
    630630        list_initialize(&cache->full_slabs);
    631631        list_initialize(&cache->partial_slabs);
    632632        list_initialize(&cache->magazines);
    633        
     633
    634634        irq_spinlock_initialize(&cache->slablock, "slab.cache.slablock");
    635635        irq_spinlock_initialize(&cache->maglock, "slab.cache.maglock");
    636        
     636
    637637        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
    638638                (void) make_magcache(cache);
    639        
     639
    640640        /* Compute slab sizes, object counts in slabs etc. */
    641641        if (cache->size < SLAB_INSIDE_SIZE)
    642642                cache->flags |= SLAB_CACHE_SLINSIDE;
    643        
     643
    644644        /* Minimum slab frames */
    645645        cache->frames = SIZE2FRAMES(cache->size);
    646        
     646
    647647        while (badness(cache) > SLAB_MAX_BADNESS(cache))
    648648                cache->frames <<= 1;
    649        
     649
    650650        cache->objects = comp_objects(cache);
    651        
     651
    652652        /* If info fits in, put it inside */
    653653        if (badness(cache) > sizeof(slab_t))
    654654                cache->flags |= SLAB_CACHE_SLINSIDE;
    655        
     655
    656656        /* Add cache to cache list */
    657657        irq_spinlock_lock(&slab_cache_lock, true);
    … …  
    670670        _slab_cache_create(cache, name, size, align, constructor, destructor,
    671671            flags);
    672        
     672
    673673        return cache;
    674674}
    … …  
    685685        if (cache->flags & SLAB_CACHE_NOMAGAZINE)
    686686                return 0; /* Nothing to do */
    687        
     687
    688688        /*
    689689         * We count up to original magazine count to avoid
    … …  
    691691         */
    692692        atomic_count_t magcount = atomic_get(&cache->magazine_counter);
    693        
     693
    694694        slab_magazine_t *mag;
    695695        size_t frames = 0;
    696        
     696
    697697        while ((magcount--) && (mag = get_mag_from_cache(cache, 0))) {
    698698                frames += magazine_destroy(cache, mag);
    … …  
    700700                        break;
    701701        }
    702        
     702
    703703        if (flags & SLAB_RECLAIM_ALL) {
    704704                /* Free cpu-bound magazines */
    … …  
    707707                for (i = 0; i < config.cpu_count; i++) {
    708708                        irq_spinlock_lock(&cache->mag_cache[i].lock, true);
    709                        
     709
    710710                        mag = cache->mag_cache[i].current;
    711711                        if (mag)
    712712                                frames += magazine_destroy(cache, mag);
    713713                        cache->mag_cache[i].current = NULL;
    714                        
     714
    715715                        mag = cache->mag_cache[i].last;
    716716                        if (mag)
    717717                                frames += magazine_destroy(cache, mag);
    718718                        cache->mag_cache[i].last = NULL;
    719                        
     719
    720720                        irq_spinlock_unlock(&cache->mag_cache[i].lock, true);
    721721                }
    722722        }
    723        
     723
    724724        return frames;
    725725}
    … …  
    731731{
    732732        ipl_t ipl = interrupts_disable();
    733        
     733
    734734        if ((cache->flags & SLAB_CACHE_NOMAGAZINE) ||
    735735            (magazine_obj_put(cache, obj)))
    736736                slab_obj_destroy(cache, obj, slab);
    737        
     737
    738738        interrupts_restore(ipl);
    739739        atomic_dec(&cache->allocated_objs);
    … …  
    753753        list_remove(&cache->link);
    754754        irq_spinlock_unlock(&slab_cache_lock, true);
    755        
     755
    756756        /*
    757757         * Do not lock anything, we assume the software is correct and
    … …  
    759759         *
    760760         */
    761        
     761
    762762        /* Destroy all magazines */
    763763        _slab_reclaim(cache, SLAB_RECLAIM_ALL);
    764        
     764
    765765        /* All slabs must be empty */
    766766        if ((!list_empty(&cache->full_slabs)) ||
    767767            (!list_empty(&cache->partial_slabs)))
    768768                panic("Destroying cache that is not empty.");
    769        
     769
    770770        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE)) {
    771771                slab_t *mag_slab = obj2slab(cache->mag_cache);
    772772                _slab_free(mag_slab->cache, cache->mag_cache, mag_slab);
    773773        }
    774        
     774
    775775        slab_free(&slab_cache_cache, cache);
    776776}
    … …  
    783783        /* Disable interrupts to avoid deadlocks with interrupt handlers */
    784784        ipl_t ipl = interrupts_disable();
    785        
     785
    786786        void *result = NULL;
    787        
     787
    788788        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
    789789                result = magazine_obj_get(cache);
    790        
     790
    791791        if (!result)
    792792                result = slab_obj_create(cache, flags);
    793        
     793
    794794        interrupts_restore(ipl);
    795        
     795
    796796        if (result)
    797797                atomic_inc(&cache->allocated_objs);
    798        
     798
    799799        return result;
    800800}
    … …  
    812812{
    813813        irq_spinlock_lock(&slab_cache_lock, true);
    814        
     814
    815815        size_t frames = 0;
    816816        list_foreach(slab_cache_list, link, slab_cache_t, cache) {
    817817                frames += _slab_reclaim(cache, flags);
    818818        }
    819        
     819
    820820        irq_spinlock_unlock(&slab_cache_lock, true);
    821        
     821
    822822        return frames;
    823823}
    … …  
    828828        printf("[cache name      ] [size  ] [pages ] [obj/pg] [slabs ]"
    829829            " [cached] [alloc ] [ctl]\n");
    830        
     830
    831831        size_t skip = 0;
    832832        while (true) {
    … …  
    853853                 * statistics.
    854854                 */
    855                
     855
    856856                irq_spinlock_lock(&slab_cache_lock, true);
    857                
     857
    858858                link_t *cur;
    859859                size_t i;
    … …  
    861861                    (i < skip) && (cur != &slab_cache_list.head);
    862862                    i++, cur = cur->next);
    863                
     863
    864864                if (cur == &slab_cache_list.head) {
    865865                        irq_spinlock_unlock(&slab_cache_lock, true);
    866866                        break;
    867867                }
    868                
     868
    869869                skip++;
    870                
     870
    871871                slab_cache_t *cache = list_get_instance(cur, slab_cache_t, link);
    872                
     872
    873873                const char *name = cache->name;
    874874                size_t frames = cache->frames;
    … …  
    879879                long allocated_objs = atomic_get(&cache->allocated_objs);
    880880                unsigned int flags = cache->flags;
    881                
     881
    882882                irq_spinlock_unlock(&slab_cache_lock, true);
    883                
     883
    884884                printf("%-18s %8zu %8zu %8zu %8ld %8ld %8ld %-5s\n",
    885885                    name, size, frames, objects, allocated_slabs,
    … …  
    896896            sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
    897897            SLAB_CACHE_SLINSIDE);
    898        
     898
    899899        /* Initialize slab_cache cache */
    900900        _slab_cache_create(&slab_cache_cache, "slab_cache_cache",
    901901            sizeof(slab_cache_cache), sizeof(uintptr_t), NULL, NULL,
    902902            SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
    903        
     903
    904904        /* Initialize external slab cache */
    905905        slab_extern_cache = slab_cache_create("slab_t", sizeof(slab_t), 0,
    906906            NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
    907        
     907
    908908        /* Initialize structures for malloc */
    909909        size_t i;
    910910        size_t size;
    911        
     911
    912912        for (i = 0, size = (1 << SLAB_MIN_MALLOC_W);
    913913            i < (SLAB_MAX_MALLOC_W - SLAB_MIN_MALLOC_W + 1);
    … …  
    916916                    NULL, NULL, SLAB_CACHE_MAGDEFERRED);
    917917        }
    918        
     918
    919919#ifdef CONFIG_DEBUG
    920920        _slab_initialized = 1;
    … …  
    934934        _slab_initialized = 2;
    935935#endif
    936        
     936
    937937        _slab_cache_create(&slab_mag_cache, "slab_mag_cache",
    938938            sizeof(slab_mag_cache_t) * config.cpu_count, sizeof(uintptr_t),
    939939            NULL, NULL, SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
    940        
     940
    941941        irq_spinlock_lock(&slab_cache_lock, false);
    942        
     942
    943943        list_foreach(slab_cache_list, link, slab_cache_t, slab) {
    944944                if ((slab->flags & SLAB_CACHE_MAGDEFERRED) !=
    945945                    SLAB_CACHE_MAGDEFERRED)
    946946                        continue;
    947                
     947
    948948                (void) make_magcache(slab);
    949949                slab->flags &= ~SLAB_CACHE_MAGDEFERRED;
    950950        }
    951        
     951
    952952        irq_spinlock_unlock(&slab_cache_lock, false);
    953953}
    … …  
    957957        assert(_slab_initialized);
    958958        assert(size <= (1 << SLAB_MAX_MALLOC_W));
    959        
     959
    960960        if (size < (1 << SLAB_MIN_MALLOC_W))
    961961                size = (1 << SLAB_MIN_MALLOC_W);
    962        
     962
    963963        uint8_t idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
    964        
     964
    965965        return slab_alloc(malloc_caches[idx], flags);
    966966}
    … …  
    970970        assert(_slab_initialized);
    971971        assert(size <= (1 << SLAB_MAX_MALLOC_W));
    972        
     972
    973973        void *new_ptr;
    974        
     974
    975975        if (size > 0) {
    976976                if (size < (1 << SLAB_MIN_MALLOC_W))
    977977                        size = (1 << SLAB_MIN_MALLOC_W);
    978978                uint8_t idx = fnzb(size - 1) - SLAB_MIN_MALLOC_W + 1;
    979                
     979
    980980                new_ptr = slab_alloc(malloc_caches[idx], flags);
    981981        } else
    982982                new_ptr = NULL;
    983        
     983
    984984        if ((new_ptr != NULL) && (ptr != NULL)) {
    985985                slab_t *slab = obj2slab(ptr);
    986986                memcpy(new_ptr, ptr, min(size, slab->cache->size));
    987987        }
    988        
     988
    989989        if (ptr != NULL)
    990990                free(ptr);
    991        
     991
    992992        return new_ptr;
    993993}
    … …  
    997997        if (!ptr)
    998998                return;
    999        
     999
    10001000        slab_t *slab = obj2slab(ptr);
    10011001        _slab_free(slab->cache, ptr, slab);
Note: See TracChangeset for help on using the changeset viewer.