(Geen kontroles word in hierdie samevatting verduidelik nie en sommige gevalle is weggelaat vir beknoptheid)
__libc_malloc probeer om 'n stuk uit die tcache te kry, indien nie, bel dit _int_malloc
_int_malloc :
Probeer om die arena te genereer as daar nie een is nie
As daar enige vinnige bin stuk van die korrekte grootte is, gebruik dit
Vul tcache met ander vinnige stukke
As daar enige klein bin stuk van die korrekte grootte is, gebruik dit
Vul tcache met ander stukke van daardie grootte
As die aangevraagde grootte nie vir klein bins is nie, konsolideer vinnige bin in onsortering bin
Kyk na die onsortering bin, gebruik die eerste stuk met genoeg spasie
As die gevonde stuk groter is, verdeel dit om 'n deel terug te gee en voeg die oorblyfsel terug by die onsortering bin
As 'n stuk dieselfde grootte as die aangevraagde grootte is, gebruik dit om die tcache te vul in plaas daarvan om dit terug te gee (totdat die tcache vol is, dan gee die volgende een terug)
Vir elke stuk van kleiner grootte wat nagegaan is, plaas dit in sy onderskeie klein of groot bin
Kyk na die groot bin in die indeks van die aangevraagde grootte
Begin kyk vanaf die eerste stuk wat groter is as die aangevraagde grootte, as daar enige gevind word, gee dit terug en voeg die oorblyfsels by die klein bin
Kyk na die groot bins vanaf die volgende indekse tot die einde
Van die volgende groter indeks, kyk vir enige stuk, verdeel die eerste gevonde stuk om dit te gebruik vir die aangevraagde grootte en voeg die oorblyfsel by die onsortering bin
As daar niks in die vorige bins gevind word nie, kry 'n stuk van die top stuk
As die top stuk nie groot genoeg was nie, vergroot dit met sysmalloc
__libc_malloc
Die malloc funksie roep eintlik __libc_malloc aan. Hierdie funksie sal die tcache nagaan om te sien of daar enige beskikbare stuk van die gewenste grootte is. As daar is, sal dit dit gebruik en as nie, sal dit kyk of dit 'n enkele draad is en in daardie geval sal dit _int_malloc in die hoofarena aanroep, en as nie, sal dit _int_malloc in die arena van die draad aanroep.
__libc_malloc kode
```c // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
victim = _int_malloc (ar_ptr, bytes); /* Retry with another arena only if we were able to find a usable arena before. */ if (!victim && ar_ptr != NULL) { LIBC_PROBE (memory_malloc_retry, 1, bytes); ar_ptr = arena_get_retry (ar_ptr, bytes); victim = _int_malloc (ar_ptr, bytes); }
if (ar_ptr != NULL) __libc_lock_unlock (ar_ptr->mutex);
</details>
Let op hoe dit altyd die teruggegee pointer met `tag_new_usable` sal merk, uit die kode:
```c
void *tag_new_usable (void *ptr)
Allocate a new random color and use it to color the user region of
a chunk; this may include data from the subsequent chunk's header
if tagging is sufficiently fine grained. Returns PTR suitably
recolored for accessing the memory there.
_int_malloc
Dit is die funksie wat geheue toewys deur die ander bins en top chunk te gebruik.
Begin
Dit begin om 'n paar veranderlikes te definieer en die werklike grootte wat die aangevraagde geheue ruimte moet hê, te verkry:
Fast Bin
As die nodige grootte binne die Fast Bins groottes is, probeer om 'n stuk uit die vinnige bin te gebruik. Basies, gebaseer op die grootte, sal dit die vinnige bin-indeks vind waar geldige stukke geleë moet wees, en as daar enige is, sal dit een van daardie teruggee.
Boonop, as tcache geaktiveer is, sal dit die tcache bin van daardie grootte met vinnige bins vul.
Terwyl hierdie aksies uitgevoer word, word 'n paar sekuriteitskontroles hier uitgevoer:
As die stuk verkeerd uitgelijnd is: malloc(): unaligned fastbin chunk detected 2
As die vorentoe stuk verkeerd uitgelijnd is: malloc(): unaligned fastbin chunk detected
As die teruggegee stuk 'n grootte het wat nie korrek is nie weens sy indeks in die vinnige bin: malloc(): memory corruption (fast)
As enige stuk wat gebruik is om die tcache te vul verkeerd uitgelijnd is: malloc(): unaligned fastbin chunk detected 3
malloc_consolidate
As dit nie 'n klein stuk was nie, is dit 'n groot stuk, en in hierdie geval word malloc_consolidate aangeroep om geheue fragmentasie te vermy.
Ongeordende bin
Dit is tyd om die ongeordende bin te kontroleer vir 'n potensieel geldige stuk om te gebruik.
Begin
Dit begin met 'n groot vir-lus wat die ongeordende bin in die bk rigting sal deurloop totdat dit by die einde (die arena struktuur) aankom met while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
Boonop word daar sekere sekuriteitskontroles uitgevoer elke keer as 'n nuwe stuk oorweeg word:
As die stukgrootte vreemd is (te klein of te groot): malloc(): invalid size (unsorted)
As die volgende stukgrootte vreemd is (te klein of te groot): malloc(): invalid next size (unsorted)
As die vorige grootte wat deur die volgende stuk aangedui word verskil van die grootte van die stuk: malloc(): mismatching next->prev_size (unsorted)
As nie victim->bck->fd == victim of nie victim->fd == av (arena): malloc(): unsorted double linked list corrupted
Aangesien ons altyd die laaste een kontroleer, moet dit fd altyd na die arena struktuur wys.
As die volgende stuk nie aandui dat die vorige in gebruik is nie: malloc(): invalid next->prev_inuse (unsorted)
As dit suksesvol was, teruggee die stuk en dit is oor, as nie, gaan voort om die funksie uit te voer...
as gelyke grootte
Gaan voort om die stuk uit die bin te verwyder, in die geval die aangevraagde grootte presies die een van die stuk is:
As die tcache nie vol is nie, voeg dit by die tcache en gaan voort om aan te dui dat daar 'n tcache stuk is wat gebruik kan word
As tcache vol is, gebruik dit net deur dit terug te gee
_int_malloc beperkings
Op hierdie punt, as 'n stuk in die tcache gestoor is wat gebruik kan word en die limiet bereik is, net terugkeer 'n tcache stuk.
Boonop, as MAX_ITERS bereik is, breek uit die lus en kry 'n stuk op 'n ander manier (top stuk).
As return_cached gestel was, net 'n stuk van die tcache teruggee om groter soektogte te vermy.
As 'n stuk nie geskik gevind word nie, gaan voort
Grosse Bins (volgende groter)
As daar in die presiese grosse bin nie 'n stuk was wat gebruik kon word nie, begin om deur al die volgende grosse bins te loop (begin by die onmiddellik groter) totdat een gevind word (indien enige).
Die oorblyfsel van die gesplete stuk word by die ongesorteerde bin gevoeg, last_reminder word opgedateer en dieselfde sekuriteitskontrole word uitgevoer:
bck->fd-> bk != bck: malloc(): beskadigde ongesorteerde stukke2
sysmalloc
sysmalloc begin
As arena null is of die aangevraagde grootte te groot is (en daar is mmaps oor om toegelaat te word) gebruik sysmalloc_mmap om ruimte toe te ken en dit terug te gee.
sysmalloc nie hoof arena nie
Dit sal eers probeer om die vorige heap te verleng vir hierdie heap. As dit nie moontlik is nie, probeer om 'n nuwe heap toe te ken en die punters op te dateer om dit te kan gebruik.
Laastens, as dit nie gewerk het nie, probeer om sysmalloc_mmap aan te roep.
sysmalloc hoofarena vorige fout 1
As die vorige teruggegee MORECORE_FAILURE was, probeer weer om geheue toe te ken met sysmalloc_mmap_fallback
sysmalloc finale
Voltooi die toewysing deur die arena-inligting op te dateer
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2921C3-L2943C12if ((unsignedlong) av->system_mem > (unsignedlong) (av->max_system_mem))av->max_system_mem = av->system_mem;check_malloc_state (av);/* finally, do the allocation */p = av->top;size =chunksize (p);/* check that one of the above allocation paths succeeded */if ((unsignedlong) (size) >= (unsignedlong) (nb + MINSIZE)){remainder_size = size - nb;remainder =chunk_at_offset (p, nb);av->top = remainder;set_head (p, nb | PREV_INUSE | (av !=&main_arena ? NON_MAIN_ARENA :0));set_head (remainder, remainder_size | PREV_INUSE);check_malloced_chunk (av, p, nb);returnchunk2mem (p);}/* catch all failure paths */__set_errno (ENOMEM);return0;
