1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#define INTERNAL_SIZE_T size_t   // 内部大小类型，通常为 size_t

struct malloc_chunk {
    // ----- 以下两个字段总是存在（无论是空闲还是占用） -----
    INTERNAL_SIZE_T      prev_size;  // 前一个 chunk 的大小（如果前一个 chunk 是空闲的）
                                     // 如果当前 chunk 的 size 字段中 PREV_INUSE 位为 0，
                                     // 则该字段有效，用于向前合并。
    INTERNAL_SIZE_T      size;       // 当前 chunk 的大小（包括元数据头部），低 3 位为标志位：
                                     // - PREV_INUSE (0x1): 前一个 chunk 是否在使用
                                     // - IS_MMAPPED (0x2): 是否由 mmap 分配
                                     // - NON_MAIN_ARENA (0x4): 是否不属于主分配区

    // ----- 以下字段仅当 chunk 空闲时才用于管理 -----
    // （被占用时，这部分空间完全属于用户数据，可被覆盖）
    struct malloc_chunk* fd;         // 前向指针，指向空闲链表（bin）中的下一个空闲 chunk
    struct malloc_chunk* bk;         // 后向指针，指向空闲链表中的上一个空闲 chunk

    // ----- 以下字段仅用于 large bins（大小 >= 512 字节的空闲块）-----
    // 用于在同一个 bin 中按大小排序，方便快速查找
    struct malloc_chunk* fd_nextsize; // 指向下一个不同大小的空闲 chunk
    struct malloc_chunk* bk_nextsize; // 指向上一个不同大小的空闲 chunk
};

typedef struct malloc_chunk* mchunkptr;  // 指向 malloc_chunk 的指针类型

1
2

size & 0x7 // 取标志位
size & ~0x7 // 取大小

1

char* b = malloc(0x256);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

struct malloc_state
{
    /* 线程锁，用于多线程环境互斥访问该 arena */
    mutex_t mutex;

    /* 该 arena 的标志位，记录一些状态（如是否使用了 mmap 等） */
    int flags;

    /* Fast bins 数组，每个槽是一个单链表头，存放固定大小的小块空闲内存。
     * NFASTBINS 通常为 10，对应 16 字节到 80 字节（64位系统）的块。
     * Fast bin 中的块不会合并，以提升性能。
     */
    mfastbinptr fastbinsY[NFASTBINS];

    /* 指向 top chunk 的指针。top chunk 位于 arena 的顶端，
     * 当所有 bin 都没有合适大小的空闲块时，malloc 会从 top chunk 切割新块。
     */
    mchunkptr top;

    /* 最近一次从 large bin 或 unsorted bin 中分割后剩余的“余块”。
     * 用于优化连续申请小块内存时的缓存命中率，减少碎片。
     */
    mchunkptr last_remainder;

    /* 常规 bins 数组（双链表结构），总共有 NBINS 个 bin。
     * bin 0 未被使用，bin 1 是 unsorted bin，bin 2 ~ 63 是 small bins，
     * bin 64 ~ 126 是 large bins。
     * 数组每个 bin 实际需要两个指针（fd, bk），因此长度是 NBINS * 2 - 2。
     */
    mchunkptr bins[NBINS * 2 - 2];

    /* 位图，用于快速标示哪些 bin 非空，加速分配时对 bins 的扫描。
     * BINMAPSIZE 通常为 4（在 32/64 位下）。
     */
    unsigned int binmap[BINMAPSIZE];

    /* 指向下一个 arena 的指针，所有 arena 通过 next 字段连接成环形链表。 */
    struct malloc_state *next;

    /* 指向下一个空闲的 arena 链表，用于动态分配新 arena 时快速获取未使用的 arena。
     * (某些 glibc 版本中可能不存在或用途略有差异，但主流版本保留)
     */
    struct malloc_state *next_free;

    /* 当前 arena 正在服务的线程数量（包括主线程和子线程）。
     * 用于判断 arena 是否繁忙，决定是否创建新的 arena。
     */
    INTERNAL_SIZE_T attached_threads;

    /* 当前 arena 已向操作系统申请的总内存量（字节）。 */
    INTERNAL_SIZE_T system_mem;

    /* 系统内存的历史最大值，用于统计和调整。 */
    INTERNAL_SIZE_T max_system_mem;
};

1

mfastbinptr fastbinsY[NFASTBINS];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

typedef struct tcache_entry
{
  struct tcache_entry *next;
/*  uintptr_t key; glibc 2.32 添加 key 来防 double free*/
} tcache_entry;

typedef struct tcache_perthread_struct
{
  char counts[TCACHE_MAX_BINS];
  tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
  assert (tc_idx < TCACHE_MAX_BINS);
  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

static __always_inline void *
tcache_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  assert (tc_idx < TCACHE_MAX_BINS);
  assert (tcache->entries[tc_idx] > 0);
  tcache->entries[tc_idx] = e->next;
  --(tcache->counts[tc_idx]);
  return (void *) e;
}

1
2

tcachebins
0x30 [  2]: 0x56490bff82d0 —▸ 0x56490bff82a0 ◂— 0

1

0x30 [  2]: 0x56490bff82d0(chunk1) —▸ 0x56490bff82a0(chunk0) ◂— 0