malloc & sysmalloc

हैकट्रिक्स का समर्थन करें

सदस्यता योजनाएं की जाँच करें!
शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह या हमें ट्विटर 🐦 @hacktricks_live** पर फॉलो** करें।
हैकिंग ट्रिक्स साझा करें, हैकट्रिक्स](https://github.com/carlospolop/hacktricks) और हैकट्रिक्स क्लाउड github रेपो में PR जमा करके।

आवंटन क्रम सारांश

(इस सारांश में कोई जांच नहीं की गई है और कुछ मामले संक्षेप के लिए छोड़ दिए गए हैं)

__libc_malloc टीकैश से एक चंक प्राप्त करने का प्रयास करता है, अगर नहीं तो वह _int_malloc को कॉल करता है
_int_malloc :
एरीना उत्पन्न करने का प्रयास करता है अगर कोई नहीं है
यदि कोई सही आकार का फास्ट बिन चंक है, तो उसका उपयोग करें
अन्य फास्ट चंक के साथ टीकैश भरें
यदि कोई छोटा बिन चंक सही आकार का है, तो उसका उपयोग करें
उस आकार के अन्य चंक के साथ टीकैश भरें
यदि अनुरोधित आकार छोटे बिनों के लिए नहीं है, तो फास्ट बिन को अनसॉर्टेड बिन में समेटें
अनसॉर्टेड बिन की जांच करें, पहला चंक उपयुक्त स्थान के साथ उपयोग करें
यदि पाया गया चंक बड़ा है, तो उसे विभाजित करके एक हिस्सा वापस करने और बाकी को अनसॉर्टेड बिन में जोड़ने के लिए
यदि एक चंक अनुरोधित आकार के समान है, तो इसे वापस देने की बजाय टीकैश भरने के लिए उपयोग करें (जब तक टीकैश भरा नहीं होता, तो अगला वापस करें)
छोटे या बड़े आकार के प्रत्येक चंक के लिए जांच करने पर, उसे उसके संबंधित छोटे या बड़े बिन में डालें
अनुरोधित आकार के सूचकांक में बड़े बिन की जांच करें
अनुरोधित आकार से बड़ा पहला चंक से देखना शुरू करें, यदि कोई मिलता है तो उसे वापस करें और बाकी को छोटे बिन में जोड़ें
अंत तक बड़े बिन की जांच करें
अगले बड़े सूचकांक से किसी भी चंक की जांच करें, पहला पाया गया चंक उपयोग करने के लिए विभाजित करें और बाकी को अनसॉर्टेड बिन में जोड़ें
पिछले बिनों में कुछ भी नहीं मिला हो, तो ऊपर से एक चंक प्राप्त करें
यदि ऊपर से प्राप्त चंक पर्याप्त बड़ा नहीं था, तो sysmalloc के साथ इसे बड़ा करें

__libc_malloc

malloc फ़ंक्शन वास्तव में __libc_malloc को कॉल करता है। यह फ़ंक्शन टीकैश की जांच करेगा कि क्या चाहिए गए आकार का कोई उपलब्ध चंक है। यदि हां, तो यह उसका उपयोग करेगा और यदि नहीं, तो यह देखेगा कि क्या यह एकल धागा है और उस मामले में यह मुख्य एरीना में _int_malloc को कॉल करेगा, और यदि नहीं, तो यह धागे के एरीना में _int_malloc को कॉल करेगा।

__libc_malloc कोड

```c // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c

#if IS_IN (libc) void * __libc_malloc (size_t bytes) { mstate ar_ptr; void *victim;

_Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2, "PTRDIFF_MAX is not more than half of SIZE_MAX");

if (!__malloc_initialized) ptmalloc_init (); #if USE_TCACHE /* int_free also calls request2size, be careful to not pad twice. */ size_t tbytes = checked_request2size (bytes); if (tbytes == 0) { __set_errno (ENOMEM); return NULL; } size_t tc_idx = csize2tidx (tbytes);

MAYBE_INIT_TCACHE ();

DIAG_PUSH_NEEDS_COMMENT; if (tc_idx < mp_.tcache_bins && tcache != NULL && tcache->counts[tc_idx] > 0) { victim = tcache_get (tc_idx); return tag_new_usable (victim); } DIAG_POP_NEEDS_COMMENT; #endif

if (SINGLE_THREAD_P) { victim = tag_new_usable (_int_malloc (&main_arena, bytes)); assert (!victim || chunk_is_mmapped (mem2chunk (victim)) || &main_arena == arena_for_chunk (mem2chunk (victim))); return victim; }

arena_get (ar_ptr, bytes);

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);

victim = tag_new_usable (victim);

assert (!victim || chunk_is_mmapped (mem2chunk (victim)) || ar_ptr == arena_for_chunk (mem2chunk (victim))); return victim; }

</details>

नोट करें कि यह हमेशा वापस आने वाले पॉइंटर को `tag_new_usable` के साथ टैग करेगा, कोड से:
```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

यह फ़ंक्शन अन्य बिन और शीर्ष चंक का उपयोग करके मेमोरी का आवंटन करता है।

प्रारंभ

यह कुछ वेरिएबल्स की परिभाषा शुरू करता है और अनुरोधित मेमोरी स्थान की वास्तविक साइज़ प्राप्त करता है:

// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3847
static void *
_int_malloc (mstate av, size_t bytes)
{
INTERNAL_SIZE_T nb;               /* normalized request size */
unsigned int idx;                 /* associated bin index */
mbinptr bin;                      /* associated bin */

mchunkptr victim;                 /* inspected/selected chunk */
INTERNAL_SIZE_T size;             /* its size */
int victim_index;                 /* its bin index */

mchunkptr remainder;              /* remainder from a split */
unsigned long remainder_size;     /* its size */

unsigned int block;               /* bit map traverser */
unsigned int bit;                 /* bit map traverser */
unsigned int map;                 /* current word of binmap */

mchunkptr fwd;                    /* misc temp for linking */
mchunkptr bck;                    /* misc temp for linking */

#if USE_TCACHE
size_t tcache_unsorted_count;	    /* count of unsorted chunks processed */
#endif

/*
Convert request size to internal form by adding SIZE_SZ bytes
overhead plus possibly more to obtain necessary alignment and/or
to obtain a size of at least MINSIZE, the smallest allocatable
size. Also, checked_request2size returns false for request sizes
that are so large that they wrap around zero when padded and
aligned.
*/

nb = checked_request2size (bytes);
if (nb == 0)
{
__set_errno (ENOMEM);
return NULL;
}

क्षेत्र

यदि उपयोगी क्षेत्र नहीं है, तो sysmalloc का उपयोग करके mmap से टुकड़ा प्राप्त करने के लिए इसका उपयोग करता है:

// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3885C3-L3893C6
/* There are no usable arenas.  Fall back to sysmalloc to get a chunk from
mmap.  */
if (__glibc_unlikely (av == NULL))
{
void *p = sysmalloc (nb, av);
if (p != NULL)
alloc_perturb (p, bytes);
return p;
}

त्वरित बिन

यदि आवश्यक आकार त्वरित बिन आकारों के अंदर है, तो त्वरित बिन से एक चंक का उपयोग करने का प्रयास करें। मूल रूप से, आकार के आधार पर, यह वैध चंक कहाँ स्थित होने चाहिए, उस त्वरित बिन सूचकांक को खोजेगा, और यदि कोई हो, तो वह उनमें से एक लौटाएगा। इसके अतिरिक्त, यदि टीकैश चालू है, तो यह उस आकार के टीकैश बिन को त्वरित बिन के साथ भरेगा।

जब ये क्रियाएँ की जाती हैं, तो यहाँ कुछ सुरक्षा जांचें की जाती हैं:

यदि चंक गलत रूप से स्थित है: malloc(): unaligned fastbin chunk detected 2
यदि आगे का चंक गलत रूप से स्थित है: malloc(): unaligned fastbin chunk detected
यदि लौटाया गया चंक उस आकार का है जो त्वरित बिन में उसके सूचकांक के कारण सही नहीं है: malloc(): memory corruption (fast)
यदि कोई भी चंक जो टीकैश भरने के लिए उपयोग किया गया है, गलत रूप से स्थित है: malloc(): unaligned fastbin chunk detected 3

_int_malloc fast bin

```c // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3895C3-L3967C6 /* If the size qualifies as a fastbin, first check corresponding bin. This code is safe to execute even if av is not yet initialized, so we can try it without checking, which saves some time on this fast path. */

#define REMOVE_FB(fb, victim, pp) do { victim = pp; if (victim == NULL) break; pp = REVEAL_PTR (victim->fd); if (__glibc_unlikely (pp != NULL && misaligned_chunk (pp))) malloc_printerr ("malloc(): unaligned fastbin chunk detected"); } while ((pp = catomic_compare_and_exchange_val_acq (fb, pp, victim)) != victim); \

if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ())) { idx = fastbin_index (nb); mfastbinptr *fb = &fastbin (av, idx); mchunkptr pp; victim = *fb;

if (victim != NULL) { if (__glibc_unlikely (misaligned_chunk (victim))) malloc_printerr ("malloc(): unaligned fastbin chunk detected 2");

if (SINGLE_THREAD_P) fb = REVEAL_PTR (victim->fd); else REMOVE_FB (fb, pp, victim); if (__glibc_likely (victim != NULL)) { size_t victim_idx = fastbin_index (chunksize (victim)); if (__builtin_expect (victim_idx != idx, 0)) malloc_printerr ("malloc(): memory corruption (fast)"); check_remalloced_chunk (av, victim, nb); #if USE_TCACHE / While we're here, if we see other chunks of the same size, stash them in the tcache. */ size_t tc_idx = csize2tidx (nb); if (tcache != NULL && tc_idx < mp_.tcache_bins) { mchunkptr tc_victim;

/* While bin not empty and tcache not full, copy chunks. */ while (tcache->counts[tc_idx] < mp_.tcache_count && (tc_victim = *fb) != NULL) { if (__glibc_unlikely (misaligned_chunk (tc_victim))) malloc_printerr ("malloc(): unaligned fastbin chunk detected 3"); if (SINGLE_THREAD_P) *fb = REVEAL_PTR (tc_victim->fd); else { REMOVE_FB (fb, pp, tc_victim); if (__glibc_unlikely (tc_victim == NULL)) break; } tcache_put (tc_victim, tc_idx); } } #endif void *p = chunk2mem (victim); alloc_perturb (p, bytes); return p; } } }

</details>

### छोटा बिन

एक टिप्पणी में इंडिकेट किया गया है कि छोटे बिन्स प्रति इंडेक्स एक साइज़ धारित करते हैं, इसलिए यदि एक वैध चंक उपलब्ध है तो उसे जांचना बहुत तेजी से होता है, इसलिए फास्ट बिन्स के बाद, छोटे बिन्स की जांच की जाती है।

पहली जांच यह है कि क्या अनुरोधित साइज़ एक छोटे बिन में हो सकता है। उस मामले में, छोटे बिन के अंदर संबंधित **इंडेक्स** प्राप्त करें और देखें कि क्या **कोई उपलब्ध चंक** है।

फिर, एक सुरक्षा जांच की जाती है जिसमें निम्नलिखित शामिल है:

* &#x20;यदि `victim->bk->fd = victim`. देखने के लिए कि क्या दोनों चंक सही ढंग से लिंक हैं।

उस मामले में, चंक **को `inuse` बिट मिलता है,** डबल लिंक्ड सूची ठीक हो जाती है ताकि यह चंक उससे गायब हो जाता है (क्योंकि इसका उपयोग किया जाएगा), और गैर मुख्य एरिना बिट सेट किया जाता है यदि आवश्यक हो।

अंततः, **अनुरोधित साइज़ के tcache इंडेक्स को** छोटे बिन के अंदर अन्य चंक्स से भरें (यदि कोई हो)।

<details>

<summary>_int_malloc small bin</summary>
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3895C3-L3967C6

/*
If a small request, check regular bin.  Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/

if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);

if ((victim = last (bin)) != bin)
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;

if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache.  */
size_t tc_idx = csize2tidx (nb);
if (tcache != NULL && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;

/* While bin not empty and tcache not full, copy chunks over.  */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;

tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}

malloc_consolidate

अगर यह एक छोटा चंक नहीं था, तो यह एक बड़ा चंक है, और इस मामले में malloc_consolidate को मेमोरी फ्रेगमेंटेशन से बचने के लिए कॉल किया जाता है।

malloc_consolidate कॉल

```c /* If this is a large request, consolidate fastbins before continuing. While it might look excessive to kill all fastbins before even seeing if there is space available, this avoids fragmentation problems normally associated with fastbins. Also, in practice, programs tend to have runs of either small or large requests, but less often mixtures, so consolidation is not invoked all that often in most programs. And the programs that it is called frequently in otherwise tend to fragment. */

else { idx = largebin_index (nb); if (atomic_load_relaxed (&av->have_fastchunks)) malloc_consolidate (av); }

</details>

malloc समेकन कार्यक्षमता बुनियादी रूप से तेज बिन से टुकड़े हटाती है और उन्हें असंगठित बिन में रखती है। अगले malloc के बाद ये टुकड़े अपने संबंधित छोटे/तेज बिनों में संगठित हो जाएंगे।

ध्यान दें कि जब इन टुकड़ों को हटाते समय, अगर उन्हें पिछले या अगले टुकड़ों के साथ पाया जाता है जो उपयोग में नहीं हैं, तो वे अंत में टुकड़े को असंगठित बिन में रखने से पहले **अलाइक और मर्ज** किए जाएंगे।

प्रत्येक तेज बिन टुकड़े के लिए कुछ सुरक्षा जांचें की जाती हैं:

* अगर टुकड़ा अअलाइन्ड है तो ट्रिगर करें: `malloc_consolidate(): unaligned fastbin chunk detected`
* अगर टुकड़ा उस आकार का नहीं है जो इंडेक्स के कारण होना चाहिए: `malloc_consolidate(): invalid chunk size`
* अगर पिछला टुकड़ा उपयोग में नहीं है और पिछले टुकड़े का आकार `prev_chunk` द्वारा निर्दिष्ट आकार से भिन्न है: `corrupted size vs. prev_size in fastbins`

<details>

<summary>malloc_consolidate कार्यक्षमता</summary>
```c
// https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L4810C1-L4905C2

static void malloc_consolidate(mstate av)
{
mfastbinptr*    fb;                 /* current fastbin being consolidated */
mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
mchunkptr       p;                  /* current chunk being consolidated */
mchunkptr       nextp;              /* next chunk to consolidate */
mchunkptr       unsorted_bin;       /* bin header */
mchunkptr       first_unsorted;     /* chunk to link to */

/* These have same use as in free() */
mchunkptr       nextchunk;
INTERNAL_SIZE_T size;
INTERNAL_SIZE_T nextsize;
INTERNAL_SIZE_T prevsize;
int             nextinuse;

atomic_store_relaxed (&av->have_fastchunks, false);

unsorted_bin = unsorted_chunks(av);

/*
Remove each chunk from fast bin and consolidate it, placing it
then in unsorted bin. Among other reasons for doing this,
placing in unsorted bin avoids needing to calculate actual bins
until malloc is sure that chunks aren't immediately going to be
reused anyway.
*/

maxfb = &fastbin (av, NFASTBINS - 1);
fb = &fastbin (av, 0);
do {
p = atomic_exchange_acquire (fb, NULL);
if (p != 0) {
do {
{
if (__glibc_unlikely (misaligned_chunk (p)))
malloc_printerr ("malloc_consolidate(): "
"unaligned fastbin chunk detected");

unsigned int idx = fastbin_index (chunksize (p));
if ((&fastbin (av, idx)) != fb)
malloc_printerr ("malloc_consolidate(): invalid chunk size");
}

check_inuse_chunk(av, p);
nextp = REVEAL_PTR (p->fd);

/* Slightly streamlined version of consolidation code in free() */
size = chunksize (p);
nextchunk = chunk_at_offset(p, size);
nextsize = chunksize(nextchunk);

if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr ("corrupted size vs. prev_size in fastbins");
unlink_chunk (av, p);
}

if (nextchunk != av->top) {
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);

if (!nextinuse) {
size += nextsize;
unlink_chunk (av, nextchunk);
} else
clear_inuse_bit_at_offset(nextchunk, 0);

first_unsorted = unsorted_bin->fd;
unsorted_bin->fd = p;
first_unsorted->bk = p;

if (!in_smallbin_range (size)) {
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}

set_head(p, size | PREV_INUSE);
p->bk = unsorted_bin;
p->fd = first_unsorted;
set_foot(p, size);
}

else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
}

} while ( (p = nextp) != 0);

}
} while (fb++ != maxfb);
}

अनक्रमित बिन

यह समय है अनक्रमित बिन की जांच करने के लिए एक संभावित वैध चंक का उपयोग करने के लिए।

प्रारंभ

यह एक बड़े फॉर लुक के साथ शुरू होता है जो अनक्रमित बिन को bk दिशा में घूमेगा जब तक यह समाप्त नहीं हो जाता है (एरीना संरचना के साथ) while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))

इसके अतिरिक्त, कुछ सुरक्षा जांच हर बार की जाती है जब एक नया चंक विचार किया जाता है:

यदि चंक का आकार अजीब है (बहुत छोटा या बहुत बड़ा): malloc(): invalid size (unsorted)
यदि अगले चंक का आकार अजीब है (बहुत छोटा या बहुत बड़ा): malloc(): invalid next size (unsorted)
यदि पिछले चंक द्वारा सूचित आकार चंक के आकार से भिन्न है: malloc(): mismatching next->prev_size (unsorted)
यदि नहीं victim->bck->fd == victim या नहीं victim->fd == av (एरीना): malloc(): unsorted double linked list corrupted
हम हमेशा अंतिम चेक कर रहे हैं, इसका fd हमेशा एरीना संरचना की ओर इशारा करना चाहिए।
यदि अगला चंक सूचित नहीं कर रहा है कि पिछला उपयोग में है: malloc(): invalid next->prev_inuse (unsorted)

_int_malloc अनक्रमित बिन प्रारंभ

```c /* Process recently freed or remaindered chunks, taking one only if it is exact fit, or, if this a small request, the chunk is remainder from the most recent non-exact fit. Place other traversed chunks in bins. Note that this step is the only place in any routine where chunks are placed in bins.

The outer loop here is needed because we might not realize until near the end of malloc that we should have consolidated, so must do so and retry. This happens at most once, and only when we would otherwise need to expand memory to service a "small" request. */

#if USE_TCACHE INTERNAL_SIZE_T tcache_nb = 0; size_t tc_idx = csize2tidx (nb); if (tcache != NULL && tc_idx < mp_.tcache_bins) tcache_nb = nb; int return_cached = 0;

tcache_unsorted_count = 0; #endif

for (;; ) { int iters = 0; while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av)) { bck = victim->bk; size = chunksize (victim); mchunkptr next = chunk_at_offset (victim, size);

if (__glibc_unlikely (size <= CHUNK_HDR_SZ) || __glibc_unlikely (size > av->system_mem)) malloc_printerr ("malloc(): invalid size (unsorted)"); if (__glibc_unlikely (chunksize_nomask (next) < CHUNK_HDR_SZ) || __glibc_unlikely (chunksize_nomask (next) > av->system_mem)) malloc_printerr ("malloc(): invalid next size (unsorted)"); if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size)) malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)"); if (__glibc_unlikely (bck->fd != victim) || __glibc_unlikely (victim->fd != unsorted_chunks (av))) malloc_printerr ("malloc(): unsorted double linked list corrupted"); if (__glibc_unlikely (prev_inuse (next))) malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");

</details>

#### यदि `in_smallbin_range`

यदि चंक अनुरोधित आकार से बड़ा है तो इसका उपयोग करें, और चंक स्थान का शेष अंश अव्यवस्थित सूची में डालें और `last_remainder` को इसके साथ अपडेट करें।

<details>

<summary><code>_int_malloc</code> अव्यवस्थित बिन <code>in_smallbin_range</code></summary>
```c
// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4090C11-L4124C14

/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin.  This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/

if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}

set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);

check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}

यदि यह सफल रहा, तो टुकड़ा और खत्म हो गया, अगर नहीं, तो कार्य को जारी रखें...

यदि बराबर आकार है

चंक को बिन से हटाना जारी रखें, मामले में अगर चंक का आवश्यक आकार बिल्कुल उसी है:

यदि टीकैश भरा नहीं है, तो इसे टीकैश में जोड़ें और जारी रखें कि एक टीकैश चंक है जो प्रयोग किया जा सकता है
यदि टीकैश भरा है, तो इसे उपयोग करें और इसे वापस करें।

_int_malloc अनसॉर्टेड बिन बराबर आकार

```c // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4126C11-L4157C14

/* remove from unsorted list */ unsorted_chunks (av)->bk = bck; bck->fd = unsorted_chunks (av);

/* Take now instead of binning if exact fit */

if (size == nb) { set_inuse_bit_at_offset (victim, size); if (av != &main_arena) set_non_main_arena (victim); #if USE_TCACHE /* Fill cache first, return to user only if cache fills. We may return one of these chunks later. */ if (tcache_nb > 0 && tcache->counts[tc_idx] < mp_.tcache_count) { tcache_put (victim, tc_idx); return_cached = 1; continue; } else { #endif check_malloced_chunk (av, victim, nb); void *p = chunk2mem (victim); alloc_perturb (p, bytes); return p; #if USE_TCACHE } #endif }

</details>

यदि चंक वापस नहीं लौटाया गया या टीकैच में जोड़ा नहीं गया है, कोड के साथ जारी रखें...

#### बिन में चंक रखें

चेक किए गए चंक को छोटे बिन में या बड़े बिन में रखें चंक के आकार के अनुसार (बड़े बिन को ठीक से संगठित रखते हुए)।

यहाँ सुनिश्चित करने के लिए सुरक्षा जांचें की जा रही हैं कि क्या बड़े बिन डबल लिंक्ड सूची को कोरप्ट किया गया है:

* यदि `fwd->bk_nextsize->fd_nextsize != fwd`: `malloc(): largebin double linked list corrupted (nextsize)`
* यदि `fwd->bk->fd != fwd`: `malloc(): largebin double linked list corrupted (bk)`

<details>

<summary><code>_int_malloc</code> बिन में चंक रखें</summary>
```c
/* place chunk in bin */

if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;

/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size)
< (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;

victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}

if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position.  */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}

mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;

`_int_malloc` सीमाएँ

इस बिंदु पर, यदि कुछ चंक tcache में संग्रहित किया गया था जो उपयोग किया जा सकता है और सीमा पहुंच गई है, तो एक tcache चंक वापस लौटाएं।

इसके अतिरिक्त, यदि MAX_ITERS पहुंच गया है, तो लूप से बाहर निकलें और एक अलग तरीके से चंक प्राप्त करें (शीर्ष चंक)।

यदि return_cached सेट किया गया था, तो बड़ी खोजों से बचने के लिए बस tcache से एक चंक वापस लौटाएं।

_int_malloc सीमाएँ

```c // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4227C1-L4250C7

#if USE_TCACHE /* If we've processed as many chunks as we're allowed while filling the cache, return one of the cached ones. */ ++tcache_unsorted_count; if (return_cached && mp_.tcache_unsorted_limit > 0 && tcache_unsorted_count > mp_.tcache_unsorted_limit) { return tcache_get (tc_idx); } #endif

#define MAX_ITERS 10000 if (++iters >= MAX_ITERS) break; }

#if USE_TCACHE /* If all the small chunks we found ended up cached, return one now. */ if (return_cached) { return tcache_get (tc_idx); } #endif

</details>

यदि सीमाएँ नहीं पहुंची हैं, तो कोड के साथ जारी रखें...

### बड़ा बिन (इंडेक्स द्वारा)

यदि अनुरोध बड़ा है (छोटे बिन में नहीं है) और हमने अब तक कोई भी टुकड़ा वापस नहीं किया है, तो **बड़े बिन** में अनुरोधित आकार का **इंडेक्स** प्राप्त करें, जांचें कि क्या यह **खाली नहीं है** या क्या **इस बिन में सबसे बड़ा टुकड़ा अनुरोधित आकार से बड़ा है** और उस मामले में **उस छोटे टुकड़े को खोजें जो अनुरोधित आकार के लिए उपयोग किया जा सकता है**।

अंत में उपयोग किए गए टुकड़े से शेष स्थान एक नए टुकड़े के लिए हो सकता है, तो इसे अव्यवस्थित बिन में जोड़ें और lsast\_reminder अपडेट किया जाता है।

जब अव्यवस्थित बिन में याददाश्त जोड़ी जाती है, तो एक सुरक्षा जांच की जाती है:

* `bck->fd-> bk != bck`: `malloc(): corrupted unsorted chunks`

<details>

<summary><code>_int_malloc</code> बड़ा बिन (इंडेक्स द्वारा)</summary>
```c
// From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4252C7-L4317C10

/*
If a large request, scan through the chunks of current bin in