linux0.12 內核學習 （buffer.c）

linux文件系統之高速緩衝區

linux高速緩存區是採用hash數組的格式對緩存頭信息進行管理。經過一個free_list指針指向空閒的緩存頭節點，緩存頭節點間使用雙向鏈表進行鏈接，而且採用lru緩存管理算法對數據進行維護。
大體見以下筆記圖:

fs/buffer.c源碼瀏覽

extern int end;  // linux內核代碼的末端，高速緩存的起始位置在內核代碼的末端位置。
struct buffer_head * start_buffer = (struct buffer_head *) &end; // 首個buffer_head 的結構
struct buffer_head * hash_table[NR_HASH];  // hash數組表，對應上圖。其中NR_HASH爲307項
static struct buffer_head * free_list; // 空閒的首緩存頭指針
static struct task_struct * buffer_wait = NULL; //等待空閒緩存塊而睡眠的任務隊列頭指針，用於申請一個緩存塊時無可用的空閒緩存塊而進行等待加入隊列。
int NR_BUFFERS = 0;
複製代碼

wait_on_buffer

static inline void wait_on_buffer(struct buffer_head * bh) {
	cli(); // 關中斷，設置進程不可中斷地睡眠在該緩存區的b_wait 中。
	while (bh->b_lock)
		sleep_on(&bh->b_wait);   // 須要wake_up明確的進行喚醒。
	sti(); // 開中斷
}
複製代碼

static int sync_dev(int dev) {
        /**** **** 對設備的緩存進行入盤操做 **** ****/
    
	int i;
	struct buffer_head * bh;

	bh = start_buffer;  // 遍歷NR_BUFFERS對應的全部緩存頭
	for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
		if (bh->b_dev != dev)
			continue;
		wait_on_buffer(bh); // wait for b_lock util get lock. 
		if (bh->b_dirt) 
			ll_rw_block(WRITE,bh);  // refresh dirty content to disk
	}
	return 0;
}

複製代碼

#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
該宏定義的是hash算法，經過對dev和block進行冪次計算，而後計算其所屬於的數組位置。

#define hash(dev,block) hash_table[_hashfn(dev,block)]
返回hash表的首指針位置
複製代碼

remove_from_queues 從緩存中摘除該緩存頭

static inline void remove_from_queues(struct buffer_head * bh) {
/* remove from hash-queue */
	if (bh->b_next)
		bh->b_next->b_prev = bh->b_prev;
	if (bh->b_prev)
		bh->b_prev->b_next = bh->b_next;
	// 調整先後指針
	if (hash(bh->b_dev,bh->b_blocknr) == bh)
		hash(bh->b_dev,bh->b_blocknr) = bh->b_next;
	// 假設指針爲第一個數組指向的指針，則調節數組的指向
	
/* remove from free list */
	if (!(bh->b_prev_free) || !(bh->b_next_free))
		panic("Free block list corrupted");
	bh->b_prev_free->b_next_free = bh->b_next_free;
	bh->b_next_free->b_prev_free = bh->b_prev_free;
	// 調整bh先後的free node，且當其等於free_list時，進行更正
	if (free_list == bh)
		free_list = bh->b_next_free;
}

複製代碼

insert_into_queues

static inline void insert_into_queues(struct buffer_head * bh) {
/* put at end of free list */
	bh->b_next_free = free_list;
	bh->b_prev_free = free_list->b_prev_free;
	free_list->b_prev_free->b_next_free = bh;
	free_list->b_prev_free = bh;
	// 將buffer_head插入到free_list的最後一個位置，同時更新各個指針的指向
/* put the buffer in new hash-queue if it has a device */
	bh->b_prev = NULL;
	bh->b_next = NULL;
	if (!bh->b_dev)
		return;
	bh->b_next = hash(bh->b_dev,bh->b_blocknr);
	//插入到hash對應dev項的第一個位置
	hash(bh->b_dev,bh->b_blocknr) = bh;
	bh->b_next->b_prev = bh;
}


複製代碼

find_buffer

static struct buffer_head * find_buffer(int dev, int block) {		
	struct buffer_head * tmp;

	for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
		if (tmp->b_dev==dev && tmp->b_blocknr==block)
			return tmp;
	return NULL;
}

複製代碼

get_hash_table 找到合適的hash table buffer

/* * Why like this, I hear you say... The reason is race-conditions. * As we don't lock buffers (unless we are readint them, that is), * something might happen to it while we sleep (ie a read-error * will force it bad). This shouldn't really happen currently, but * the code is ready. */
struct buffer_head * get_hash_table(int dev, int block) {
	struct buffer_head * bh;

repeat:
	if (!(bh=find_buffer(dev,block)))
		return NULL;
	bh->b_count++;
	wait_on_buffer(bh);
	if (bh->b_dev != dev || bh->b_blocknr != block) {
	    // if bh is not current block,then release it.
		brelse(bh);
		goto repeat;
	}
	return bh;
}

複製代碼

get_blk 找尋一塊合適的緩存頭塊

struct buffer_head * getblk(int dev,int block) {
	struct buffer_head * tmp;

repeat:
	if (tmp=get_hash_table(dev,block))
		return tmp;
	tmp = free_list;
	// 遍歷free_list鏈表，找到知足count爲0後嘗試上鎖，以後進行上鎖等待，解鎖後探測是否被引用
	do {
		if (!tmp->b_count) {
			wait_on_buffer(tmp);	/* we still have to wait */
			if (!tmp->b_count)	/* on it, it might be dirty */
				break;
		}
		tmp = tmp->b_next_free;
	} while (tmp != free_list || (tmp=NULL));
	/* Kids, don't try THIS at home ^^^^^. Magic */
	
	// 假設沒有合適的bufferr,等待buffer_wait的釋放
	if (!tmp) {
		printk("Sleeping on free buffer ..");
		sleep_on(&buffer_wait);
		printk("ok\n");
		goto repeat;
	}
	tmp->b_count++;
	remove_from_queues(tmp);
/* * Now, when we know nobody can get to this node (as it's removed from the * free list), we write it out. We can sleep here without fear of race- * conditions. */
	if (tmp->b_dirt)
		sync_dev(tmp->b_dev);
/* update buffer contents */
	tmp->b_dev=dev;
	tmp->b_blocknr=block;
	tmp->b_dirt=0;
	tmp->b_uptodate=0;
/* NOTE!! While we possibly slept in sync_dev(), somebody else might have * added "this" block already, so check for that. Thank God for goto's. */
	if (find_buffer(dev,block)) {
		tmp->b_dev=0;		/* ok, someone else has beaten us */
		tmp->b_blocknr=0;	/* to it - free this block and */
		tmp->b_count=0;		/* try again */
		insert_into_queues(tmp);
		goto repeat;
	}
/* and then insert into correct position */
	insert_into_queues(tmp);
	return tmp;
}

複製代碼

brelse 釋放緩存塊並釋放全局buffer_wait

void brelse(struct buffer_head * buf) {
	if (!buf)
		return;
	wait_on_buffer(buf);
	if (!(buf->b_count--))
		panic("Trying to free free buffer");
	wake_up(&buffer_wait);
}

複製代碼

buffer初始化

void buffer_init(void) {
	struct buffer_head * h = start_buffer;
	void * b = (void *) BUFFER_END;
	int i;

	while ( (b -= BLOCK_SIZE) >= ((void *) (h+1)) ) {
		h->b_dev = 0;
		h->b_dirt = 0;
		h->b_count = 0;
		h->b_lock = 0;
		h->b_uptodate = 0;
		h->b_wait = NULL;
		h->b_next = NULL;
		h->b_prev = NULL;
		h->b_data = (char *) b;
		h->b_prev_free = h-1;
		h->b_next_free = h+1;
		h++;
		NR_BUFFERS++;
		if (b == (void *) 0x100000)
			b = (void *) 0xA0000;
	}
	h--;
	free_list = start_buffer;
	free_list->b_prev_free = h;
	h->b_next_free = free_list;
	for (i=0;i<NR_HASH;i++)
		hash_table[i]=NULL;
}	
複製代碼

copyblk彙編指令

#define COPYBLK(from, to) \
__asm__("cld\n\t" \
        "rep\n\t" \
        "movsl\n\t"\
        ::"c" (BLOCK_SIZE/4)， "S" (from), "D" (to) \
        : "cx", "di","si")
)


複製代碼