Linux0.11内核源码解析-malloc

malloc介绍

Linux内核版本0.11中的`malloc.c`文件实现了内存分配的功能。在这个版本的Linux内核中，`malloc.c`文件包含了内核级别的内存分配函数，用于分配和释放内核中的内存。这些函数可以帮助内核管理可用的内存，并允许内核动态地分配和释放内存，以便在运行时满足不同模块或进程的内存需求。基本上，它实现了类似C标准库中的`malloc()`和`free()`函数的功能，但是是针对内核级别的操作而设计的。

C标准库和内核中malloc区别

为了加以区分后面malloc命名为kmalloc，free命名为kfree

C标准库中的`malloc`函数和内核中的`malloc`函数之间存在一些关键区别：

1. **作用域不同**：C标准库中的`malloc`函数是用于用户空间程序的内存分配，而内核中的`malloc`函数是用于操作系统内核的内存管理。

2. **权限不同**：C标准库中的`malloc`函数只能操作用户空间的内存，而内核中的`malloc`函数可以直接操作系统的内存，包括内核空间的内存。

3. **实现不同**：C标准库中的`malloc`函数通常基于用户空间的堆实现，而内核中的`malloc`函数是基于内核空间的内存管理机制实现的，因此更加底层且复杂。

4. **用途不同**：C标准库中的`malloc`函数主要用于用户空间程序的动态内存分配，而内核中的`malloc`函数用于操作系统内核的动态内存分配，包括内核数据结构和缓冲区的分配。

bucket分配算法

Bucket（桶）内存分配算法是一种用于管理动态内存分配的方法，通常应用于用户空间的内存分配库。这种算法基于固定大小的内存块（或桶），每个桶大小相同，并且事先确定。这些桶可以是不同大小的内存块，以适应不同大小的内存需求。

其基本思想是将内存空间分割成预定义大小的桶（或块），例如8字节、16字节、32字节等。当程序请求分配一定大小的内存时，分配器会根据请求大小找到合适大小的桶，然后从这个桶中分配内存。如果某个桶中没有足够大小的内存可用，它会尝试从较大的桶中拆分出适当大小的内存块来满足请求。

这种算法的优点在于：

1. **降低内存碎片化**：通过使用预定义大小的桶，可以减少内存碎片化，因为每个桶大小是固定的，不会出现零散的小内存碎片。

2. **快速分配**：由于预定义了多个固定大小的桶，分配器只需根据请求大小找到对应的桶，因此分配速度相对较快。

不过，Bucket内存分配算法也有一些限制：

1. **内存浪费**：当需要的内存大小不完全匹配桶的大小时，可能会导致一定程度的内存浪费。

2. **固定桶大小**：由于每个桶大小是固定的，可能难以适应特定大小的内存需求。

结构体介绍

`struct bucket_desc`表示一个桶的描述符，包含以下字段：

- `void *page`：指向桶的起始地址。
- `struct bucket_desc *next`：指向下一个桶的描述符，用于构建链表。
- `void *freeptr`：指向桶中空闲内存的起始地址。
- `unsigned short refcnt`：引用计数，用于跟踪桶的使用情况。
- `unsigned short bucket_size`：桶的大小，表示每个桶可以分配的内存块大小。

`struct _bucket_dir`表示桶的目录，包含以下字段：

- `int size`：桶的目录大小，表示桶的数量。
- `struct bucket_desc *chain`：指向桶链表的头部，用于管理所有桶的分配情况。

这些结构体的设计是为了实现Bucket内存分配算法的核心功能。通过`struct bucket_desc`中的链表和引用计数，可以跟踪和管理每个桶的使用情况。而`struct _bucket_dir`中的链表头部和目录大小，可以帮助定位和管理所有桶的分配情况。

struct bucket_desc {	/* 16 bytes */
	void			*page;
	struct bucket_desc	*next;
	void			*freeptr;
	unsigned short		refcnt;
	unsigned short		bucket_size;
};

struct _bucket_dir {	/* 8 bytes */
	int			size;
	struct bucket_desc	*chain;
};


struct _bucket_dir bucket_dir[] = {
	{ 16,	(struct bucket_desc *) 0},
	{ 32,	(struct bucket_desc *) 0},
	{ 64,	(struct bucket_desc *) 0},
	{ 128,	(struct bucket_desc *) 0},
	{ 256,	(struct bucket_desc *) 0},
	{ 512,	(struct bucket_desc *) 0},
	{ 1024,	(struct bucket_desc *) 0},
	{ 2048, (struct bucket_desc *) 0},
	{ 4096, (struct bucket_desc *) 0},
	{ 0,    (struct bucket_desc *) 0}};   /* End of list marker */

/*
 * This contains a linked list of free bucket descriptor blocks
 */
struct bucket_desc *free_bucket_desc = (struct bucket_desc *) 0;

空闲存储桶

bucket结构体初始化

初始化桶描述符，建立空闲桶描述符链表

/*
 * This routine initializes a bucket description page.
 */
static inline void init_bucket_desc()
{
	struct bucket_desc *bdesc, *first;
	int	i;
	申请一页内存
	first = bdesc = (struct bucket_desc *) get_free_page();
	if (!bdesc)
		panic("Out of memory in init_bucket_desc()");
    计算一页内存可存放桶描述符数量
	for (i = PAGE_SIZE/sizeof(struct bucket_desc); i > 1; i--) {
		bdesc->next = bdesc+1;
		bdesc++;
	}
	/*
	 * This is done last, to avoid race conditions in case 
	 * get_free_page() sleeps and this routine gets called again....
	 */
    将空闲桶描述指针加入链表
	bdesc->next = free_bucket_desc;
	free_bucket_desc = first;
}

malloc函数

分配动态内存函数

void *malloc(unsigned int len)
{
	struct _bucket_dir	*bdir;
	struct bucket_desc	*bdesc;
	void			*retval;

	/*
	 * First we search the bucket_dir to find the right bucket change
	 * for this request.
	 */
    找到合适的桶
	for (bdir = bucket_dir; bdir->size; bdir++)
		if (bdir->size >= len)
			break;
	if (!bdir->size) {
		printk("malloc called with impossibly large argument (%d)\n",
			len);
		panic("malloc: bad arg");
	}
	/*
	 * Now we search for a bucket descriptor which has free space
	 */
	cli();	/* Avoid race conditions */
    寻找对应的桶空闲空间的桶描述符
	for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) 
		if (bdesc->freeptr)
			break;
	/*
	 * If we didn't find a bucket with free space, then we'll 
	 * allocate a new one.
	 */
	if (!bdesc) {
		char		*cp;
		int		i;

		if (!free_bucket_desc)	
			init_bucket_desc();
		bdesc = free_bucket_desc;
		free_bucket_desc = bdesc->next;
		bdesc->refcnt = 0;
		bdesc->bucket_size = bdir->size;
		bdesc->page = bdesc->freeptr = (void *) (cp = get_free_page());
		if (!cp)
			panic("Out of memory in kernel malloc()");
		/* Set up the chain of free objects */
		for (i=PAGE_SIZE/bdir->size; i > 1; i--) {
			*((char **) cp) = cp + bdir->size;
			cp += bdir->size;
		}
		*((char **) cp) = 0;
		bdesc->next = bdir->chain; /* OK, link it in! */
		bdir->chain = bdesc;
	}
    返回指针即等于该描述符对应页面的当前空闲指针
	retval = (void *) bdesc->freeptr;
    调整空闲指针指向下一个对象
	bdesc->freeptr = *((void **) retval);
    引用+1
	bdesc->refcnt++;
    开发中断
	sti();	/* OK, we're safe again */
	return(retval);
}

free释放内存

/*
 * Here is the free routine.  If you know the size of the object that you
 * are freeing, then free_s() will use that information to speed up the
 * search for the bucket descriptor.
 * 
 * We will #define a macro so that "free(x)" is becomes "free_s(x, 0)"
 */
void free_s(void *obj, int size)
{
	void		*page;
	struct _bucket_dir	*bdir;
	struct bucket_desc	*bdesc, *prev;
	bdesc = prev = 0;
	/* Calculate what page this object lives in */
	page = (void *)  ((unsigned long) obj & 0xfffff000);
	/* Now search the buckets looking for that page */
	for (bdir = bucket_dir; bdir->size; bdir++) {
		prev = 0;
		/* If size is zero then this conditional is always false */
		if (bdir->size < size)
			continue;
		for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) {
			if (bdesc->page == page) 
				goto found;
			prev = bdesc;
		}
	}
	panic("Bad address passed to kernel free_s()");
found:
	cli(); /* To avoid race conditions */
	*((void **)obj) = bdesc->freeptr;
	bdesc->freeptr = obj;
	bdesc->refcnt--;
	if (bdesc->refcnt == 0) {
		/*
		 * We need to make sure that prev is still accurate.  It
		 * may not be, if someone rudely interrupted us....
		 */
		if ((prev && (prev->next != bdesc)) ||
		    (!prev && (bdir->chain != bdesc)))
			for (prev = bdir->chain; prev; prev = prev->next)
				if (prev->next == bdesc)
					break;
		if (prev)
			prev->next = bdesc->next;
		else {
			if (bdir->chain != bdesc)
				panic("malloc bucket chains corrupted");
			bdir->chain = bdesc->next;
		}
		free_page((unsigned long) bdesc->page);
		bdesc->next = free_bucket_desc;
		free_bucket_desc = bdesc;
	}
	sti();
	return;
}