默写nginx并逐句分析 - ngx_palloc.c(部分待分析)

ngx_pool_t * ngx_create_pool(size_t  size, ngx_log_t *log){//size_t 它是一个unsigned整型,足以保证存储在内存中对象的大小,本方法用来生成一个空的内存对象ngx_pool_t
	ngx_pool_t * p;
	p = ngx_alloc(size, log);

	if(p == NULL){
		return NULL;
	}

	p->d.last = (u_char *)p + sizeof(ngx_pool_t);//ngx_pool_t结构有一个ngx_pool_data_t属性,记录内存池的开始,结束,失败
	p->d.end = (u_char *)p + size; 
	p->d.next = NULL;
	p->d.failed = 0;

 
	size = size - sizeof(ngx_pool_t);

	p->max  = size < NGX_MAX_ALLOC_FROM_POOL ? size : NGX_MAX_ALLOC_FROM_POOL;

	p->current  = p;
	p->chain = NULL;
	p->large = NULL;
	p->cleanup = NULL;
	p->log = log;

	return p;
}

void ngx_destroy_pool(ngx_pool_t *pool){//销毁内存池
	ngx_pool_t *p, *n;
	ngx_pool_cleanup_t *c;
	ngx_pool_large_t *l;

	for(c = pool->cleanup;  c; c=c->next){
		if(c->handler){
			c->handler(c->data);
		}
	}

	for(l = pool->large; l ; l = l->next){
		if(l->alloc)
			ngx_free(l->alloc);
	}

#if  (NGX_DEBUG)

	for(p = pool, n = pool->d.next; ; p = n, n = n->d.next){
		if(n == NULL){
			break;
		}
	}

#endif

	for(p = pool, n = pool->d.next; ; p=n, n = n->d.next){

		ngx_free(p);

		if(n == NULL){

			break;
		}
	}
}

void ngx_reset_pool(ngx_pool_t *pool){//重置一个内存池结构

	ngx_pool_t *p;

	ngx_pool_large_t *l;

	for(l=pool->large;l;l = l->next){

		if(l->alloc){

			ngx_free(l->alloc);
		}
	}

	pool->large = NULL;

	for(p = pool; p; p = p->d.next){

		p->d.last = (u_char *)p + sizeof(ngx_pool_t);
	}
}

 
void *ngx_palloc(ngx_pool_t *pool, size_t size){//从内存池pool中分配size大小的内存空间,前将内存对齐
	ngx_pool_t *p;
	u_char *m;
 
	if(size <= pool->max){//是否是小内存
		p = pool->current;
		do{
			m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);//内存对齐
			if((size_t)(p->d.end-m) >= size){
				d->d.last = m+size;
				return m;
			}
			p = p->d.next;//如果当前内存池不行,则移向下一个内存池
		}while(p);
 
		return ngx_palloc_block(pool, size);//pool链表已用完,还没分配好,则给pool链表申请内存
	}
 
	return ngx_palloc_large(pool, size);//分配大内存
}
 
void *ngx_pnalloc(ngx_pool_t *pool, size_t size){//申请一块内存,不对内存对齐
	ngx_pool_t *p;
	u_char *m;
	
	if(size<=pool->max){
		p = pool->current;
		do{
			m = p->d.last;
			if((size_t)(p->d.end-m) >= size){
				p->d.last = m+size;
				return m;
			}
			p = p->d.netx;
		}while(p);
		return ngx_palloc_block(pool, size);//分配大内存
	}
	return  ngx_palloc_large(pool, size);//分配大内存
}
 
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size){//为pool申请一块size大小的内存
	u_char *m
	size_t psize;
	ngx_pool_t *new, *current, *p;
 
	psize = (size_t)(pool->d.end - (u_char *)pool);//计算pool所占的内存
	m = ngx_alloc(psize, pool->log);
	if(m == NULL){
		return NULL;
	}
 
	new = (ngx_pool_t *)m;
	new->d.end = m+psize;
	new->d.next = NULL;
	new->d.failed = 0;
 
	m += sizeof(ngx_pool_data_t);//待使用的指针地址
	m = ngx_align_ptr(m, NGX_ALIGNMENT);
	new->d.last = m+size;//先分配size内存
	current = pool->current;
 
	for(p = current; p->d.netx; p = p->d.next){//如果一个内存池链表项多次因分配内存失败,则将当前内存池指针向下移动
		if(p->d.failed++ >4){
			current = p->d.next;
		}
	}
 
	p->d.next = new;
	pool->current = current ? current : new;
	return m;
}
 
static void *ngx_palloc_large(ngx_pool_t *pool, size_t size){//分配一块大内存地址,size
	void *p;
	ngx_int_t n;
	ngx_pool_large_t *large;
 
	p = ngx_alloc(size, pool->log);
	if(p == NULL){
		return NULL;
	}
 
	n = 0;
	for(large = pool->large; large; large = large->next){
		if(large->alloc == NULL){
			large->alloc = p;
			return p;
		}
		if(n++ > 3){
			break;
		}
	}
	
	large = ngx_palloc(pool, sizeof(ngx_pool_large_t) );
	if(large == NULL){
		return NULL;
	}
 
	large->alloc = p;//向链表加入一个元素
	large->next = pool->large;
	pool->large = large;
	
	return p;
}
 
void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment){//申请一块内存对齐的大内存,然后加在大内存链表上
	void *p;
	ngx_pool_large_t *large;
 
	p = ngx_memalign(alignment, size, pool->log);
	if(p == NULL){
		return NULL;
	}
 
	large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
	
	large->alloc = p;
	large->next = pool->large;
	pool->large = large;
 
	return p;
}
 
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p){//把大内存地址 == p的大内存清理掉
	ngx_pool_large_t *l;
	for(l == pool->large;l ; l = l->next){
		if(l->alloc == p){
			ngx_free(l->alloc);
			l->alloc = NULL;
			return NGX_OK;
		}
	}
	return NGX_DECLIEND;
}
 
void *ngx_pcalloc(ngx_pool_t *pool, size_t size){//从pool里分配一个size的内存并清0
	void *p;
	p = ngx_palloc(pool, size);
	if(p){
		p = ngx_memzero(p, size);
	}
	return p;
}
 
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size){//为内存池p新加一个cleanup对象
	ngx_pool_cleanup_t *c;
	c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
	if(c == NULL){
		return NULL;
	}
 
	if(size){
		c->data = ngx_palloc(p, size);
		if(c->data == NULL){
			return NULL;
		}
	}else{
		c->data = NULL;
	}
 
	c->handler = NULL;//
	c->next = p->cleanup;//加链表
	p->cleanup = c;
 
	return c;
}
 
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd){//如标题,在pool内存池里执行ngx_pool_cleanup_file方法
	ngx_pool_cleanup_file_t *cf;
	ngx_pool_cleanup_t *c;
	
	for(c=p->cleanup; c; c=c->next){
		if(c->handler == ngx_pool_cleanup_file){//c->handler需要满足要求
			cf = c->data;
			if(cf->fd == fd){//c-data数据也要满足要求
				c->handler(cf);
				c->handler = NULL;
				return;
			}
		}
	}
}
 
void ngx_pool_cleanup_file(void *data){//其实就是关闭文件句柄
	ngx_pool_cleanup_file_t *c = data;
	ngx_close_file(c->fd);
}
 
void ngx_pool_delete_file(void *data){
	ngx_pool_cleanup_file_t *c = data;
	ngx_delete_file(c->name);
	ngx_close_file(c->fd);
}
 
#if 0//以下待注释,因为cycle还没看

static void *
ngx_get_cached_block(size_t size)
{
    void                     *p;
    ngx_cached_block_slot_t  *slot;

    if (ngx_cycle->cache == NULL) {
        return NULL;
    }

    slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize];

    slot->tries++;

    if (slot->number) {
        p = slot->block;
        slot->block = slot->block->next;
        slot->number--;
        return p;
    }

    return NULL;
}

#endif