SSD6 Exercise3总结

SSD6 Exercise3学习报告

最近在系统级程序设计的实验课上，老师布置了这项作业，经过几天的尝试，终于做出来了。下面来简单的回顾一下这次作业。

最终结果

操作系统

• Macintosh

Tips

• 在开始做之前，由于实在Mac下进行的编码，所以说要将driver.c中的#include <windows.h>改为#include <unistd.h>
• 接着开始编码

具体流程

1

根据ex3.pdf中Implementation Details中所描述的，我们需要把memory block设计成如下所述的结构

所以说，最开始的雏形就有了

int allocatedSize = 0;			//存储总共分配的大小

typedef struct Header HEADER;
struct Header{
	int checkSum;		//判断是否发生了 ERROR #3
	int size;		//存储MALLOC()中的大小
	long fence;	//存储0xCCDEADCC 作为判断是否发生ERROR #1 
};

typedef struct Footer FOOTER;
struct Footer{
	long fence;  //存储0xCCDEADCC 作为判断是否发生了ERROR #2
};

typedef struct Block BLOCK;
struct Block{
	HEADER h; //头部信息
	void *ptr; //Payload
	FOOTER f; //尾部信息
	char *filename;
	int linenumber;
	BLOCK *next;
}

2

由于我们要为上述内容分配空间，所以说我们在进行如下操作

#define HEADERSIZE sizeof(HEADER)
#define FOOTERSIZE sizeof(FOOTER)
#define BLOCKSIZE sizeof(BLOCK)
#define BARRIER 0xCCDEADCC

3

下面我们开始思考如何实现MyMalloc,它的函数原型如下

void *MyMalloc(size_t size, char *filename, int linenumber)

由于内存地址对齐，所以说根据这个题，我先写一个函数来让size为8的整数倍，多出来的内容需要用BARRIER填充

int align2Eight(int size)
{
	if( (size & 00x7) == 0)         
	{
		return size;
	}
	else
	{
		return ((size >> 3) + 1) << 3;
	}
}

我的想法是先设定一个链表，存储BLOCK *,来管理这部分内容

所以说，我们这时候需要一个链表的头指针。

BLOCK *block_list_header = NULL

之后我们需要实现关于这个链表的增、删、查操作

查找最简单，所以我们先来实现查找

BLOCK *find_block(void *ptr)
{
	BLOCK *head = block_list_header;
	while(head)
	{
		if(head->ptr == ptr)
		{
			return head;
		}
		head = head->next;	
	}
	return NULL;	
}

然后我们需要实现增， 需要注意一点是由于BLOCK中包含char *filename，所以说别忘了为它分配内存和释放内存

int add_block(void *ptr, char *filename, int linenumber)
{
	//通过指针操作，来获取HEADER信息
	HEADER h = *((HEADER *)ptr - 1); 		//!注意 这里的-1操作其实是将ptr(地址值)减去了一个HEADERSIZE(16);
											// 如果你这样操作(char *)ptr - 1, 这样确实是让地址值减去了1。这里很关键，后面常用到
	int size = h->size;
	//通过指针操作获取FOOTER信息
	FOOTER f = *(FOOTER *)((char *)ptr + align2Eight(size));
	
	//为BLOCK分配内存
	BLOCK *curr = malloc(BLOCKSIZE);
	if(!curr)
	{
		return -1;
	}
	//为filename分配内存
	int len = strlen(filename) + 1; 	//存储''
	char *name = (char *)malloc((size_t)len);
	if(!name)
	{
		return -1;
	}
	strcpy(name, filename);
	
	curr->h = h;
	curr->ptr = ptr;
	curr->f = f;
	curr->filename = name;
	curr->linenumber = linenumber;
	curr->next = block_list_header;
	block_list_header = curr;
	
	return 0;
}

最后来实现一下删操作

int remove_block(void *ptr)
{
	BLOCK *head = block_list_header;
	BLOCK *last; 		//存储需删除的上一个指针
	while(head)
	{
		if(head->ptr == ptr)
		{
			if(last)	//如果不是表头结点
			{
				last->next = head->next;
			}
			else
			{
				//挪动表头结点
				block_list_header = block_list_header->next;
			}
			free(head->filename);
			free(head);
			return 0;
		}
		last = head;
		head = head->next;
	}
	return -1;	
}

最后，来写一下求checkSum的函数

int get_check_number(long num)
{
    int count = 0;
    int standard = 0x1;
    int i;
    for(i = 0; i < sizeof(long); i++)
    {
        if((num & standard) == 1)
        {
            count ++;
        }
        num = num >> 1;
    }

    return count;
}

4

到此为止，对于链表的基本操作都已经完成，下面我开始完成对MyMalloc函数的编写

void *MyMalloc(size_t size, char *filename, int linenumber) {
	char *header_begin;
	char *footer;
	HEADER h;
	FOOTER f;
	int extra_size; 		//内存对齐的填充大小
	long barrier = BARRIER:
	
	header_begin = (char *)malloc(HEADERSIZE + align2Eight((int)size) + FOOTERSIZE);
	if(!header_begin)
	{
		return NULL;
	}
	
	h.size = (int)size;
	h.fence = barrier;
	h.checkSum = get_check_number(h.size + h.fence);
	
	memcpy(header_begin, &h, HEADERSIZE);
	
	f.fence = barrier;
	footer = header_begin + HEADERSIZE + align2Eight(h.size);
	memcpy(footer, &f, FOOTERSIZE);
	
	//填充extra_size来判断是否越界
	extra_size = align2Eight(h.size) - h.size;
	if(extra_size <= 4)
	{
		strncpy(footer - extra_size, (char *) &barrier, (size_t)extra_size);
	}
	else
	{
		strncpy(footer - extra_size, (char *) &barrier, 4);
		strncpy(footer - extra_size + 4, (char *) &barrier, (size_t)(extra_size - 4));
	}
	
	if(add_block((void *)(header_begin + HEADERSIZE), filename, linenumber) == 0)
	{
		allocatedSize += h.size;
		return (void *)(header_begin + HEADERSIZE);
	}
	else
	{
		free(header_begin);
		return NULL;
	}
	
}

在实现MyFree(void *)之前，我们需要判断一下它是否有错误，所以说我们在写一个check_block(void *ptr)的函数。

int check_block(void *ptr)				//返回值为错误类型
{
	HEADER *h = (HEADER *)ptr - 1;
	long fence = BARRIER;
	int size = h->size;
	int checkSum = h->checkSum;
	long h_fence = h->fence;
	int extra_size = align2Eight(size) - size;
	
	FOOTER *f = (FOOTER *)(char *)ptr + align2Eight(size));
	long f_fence = f->fence;
	
	//先判断ERROR #2
	if (extra_size <= 4)
    {
        if(strncmp((char *)f - extra_size, (char *) &fence, (size_t)extra_size) != 0)
        {
            return 2;
        }
    }
    else{
        if(strncmp((char *)f - extra_size, (char *) &fence, 4) != 0
                || strncmp((char *)f - extra_size + 4, (char *)&fence, (size_t)(extra_size - 4)) != 0)
        {
            return 2;
        }
    }
    
    if(f_fence != BARRIER)
    {
    	return 2;
    }
   	 else if(h_fence != BARRIER)
   	 {
   	 	return 1;
   	 }
   	 else if(checkSum != get_check_number(size + h_fence))
   	 {
   	 	return 3;
   	 }
   	 
   	 return 0;
   
}

好了，我们最后来实现一下MyFree(void *)函数

void MyFree(void *ptr, char *filename, int linenumber) {
    int num;
    HEADER *h = (HEADER *)ptr - 1;
    BLOCK *curr = NULL;
    curr = find_block(ptr);
    if(!curr)
    {
        error(4, filename, linenumber);
    }
    else{
        num = check_block(ptr);
        if(num)
        {
            errorfl(num, curr->filename, curr->linenumber, filename, linenumber);
        }

        allocatedSize -= h->size;
        free(h);
        remove_block(ptr);
    }
}

5

截止到目前，大部分都已经完成，最后再把Bonus实现，便大功告成。

/* returns number of bytes allocated using MyMalloc/MyFree:
	used as a debugging tool to test for memory leaks */
int AllocatedSize() {
    return allocatedSize;
}



/* Optional functions */

/* Prints a list of all allocated blocks with the
	filename/line number when they were MALLOC'd */
void PrintAllocatedBlocks() {
    BLOCK *curr = block_list_header;
    while(curr)
    {
        PRINTBLOCK(curr->h.size, curr->filename, curr->linenumber);
        curr=curr->next;
    }
}

/* Goes through the currently allocated blocks and checks
	to see if they are all valid.
	Returns -1 if it receives an error, 0 if all blocks are
	okay.
*/
int HeapCheck() {
    BLOCK *curr = block_list_header;
    int result = 0, err;
    while(curr)
    {
        err = check_block(curr->ptr);
        if(err)
        {
            result = -1;
            PRINTERROR(err, curr->filename, curr->linenumber);
        }
        curr = curr->next;
    }
    return result;
}

Finish

OK, 到此为止，希望对你有帮助

补充

下面对一些具体的测试用例使用GDB调试观察地址及其内容

Test case2

我们知道，字符串str在分配内存时应分配8+1('')大小的内存。所以说这个BLOCK中Footer里面的fence应该被改写了，让我们来看一些内存中的内容

//首先生成可用gdb调试的版本
gcc -g *.c -o debugmalloc

在检查出错的函数check_block加入断点

使用-t参数运行第二个测试用例

我们看到断点发生在debugmalloc.c:135行，此时ptr的地址值为0x100300070

注意：因为对generic pointer(void *)强制转化为HEADER *，并且h_p = (HEADER *)ptr - 1，这里面的-1实际上减去了1 * sizeof(HEADER)，也就是减去了16

我们继续用n来让程序继续往下单步运行

由于该用例只分配了8个内存，并且8是8的整数倍，不需要分配额外的内存来使内存对齐，所以说我们看到的h_p的地址为0x100300078，比ptr高8字节，但是fence的值和f_fence的值不同，说明尾部信息被篡改了，即分配内存不足，接下来让我们继续运行程序，得到相应的结果

符合上面的正确答案。

---

再让我们看一个头部信息被改变的实例

Test case6

先看下面这行代码

//把ptr低8字节的地址中的int数据改为 8 + (1 << 31);
*((int *)(ptr - 8)) = 8 + (1 << 31);

这时候我们再看我们最初定义的Header结构

struct Header{
	int checkSum;
	int size;
	long fence;
}

很明显，他是想通过更改Header中的fence来出错，那让我们用gdb跟踪调试一下，看个究竟。

继续执行，得到最终结果

符合上面的答案。

---

最后补充

假设我们分配了两次，没有进行free，整个程序的内部结构大概为下图

by 一枝猪

转载请注明出处