/* bitmap.c contains the code that handles the inode and block bitmaps */
#include <string.h>

#include <linux/sched.h>
#include <linux/kernel.h>

#define clear_block(addr) \
//此內嵌匯編的意思為：
//	movl	0	%eax
//	movl	BLOCK_size/4	%edi
//	movl	*addr	%edi
//	cld
//	rep stosl	//將eax傳送到es:edi
__asm__("cld\n\t" \
        "rep\n\t" \
        "stosl" \
        ::"a" (0),"c" (BLOCK_SIZE/4),"D" ((long) (addr)):"cx","di")

#define set_bit(nr,addr) ({\
register int res __asm__("ax"); \
//此內嵌匯編的意思為：
        //	movl	0	%eax
        //	movl	nr	%ebx
        //	movl	*addr	%edx
        //	btsl	%ebx	%edx	//測試位，將該位送CF，并將該位置1
        //	setb	%al		//CF=1，則al=1，反之為0
        //	movl	%eax	res
        __asm__("btsl %2,%3\n\tsetb %%al":"=a" (res):"0" (0),"r" (nr),"m" (*(addr))); \
res;})

#define clear_bit(nr,addr) ({\
register int res __asm__("ax"); \
//此內嵌匯編的意思為：
//	movl	0	%eax
//	movl	nr	%ebx
//	movl	*addr	%ecx
//	btrl	%ebx	%ecx
//	setnb	%al		//CF=0,al=1,反之為0
//	movl	%eax	res
__asm__("btrl %2,%3\n\tsetnb %%al":"=a" (res):"0" (0),"r" (nr),"m" (*(addr))); \
        res;})

#define find_first_zero(addr) ({ \
int __res; \
//此內嵌匯編的意思為：
//	movl	0	%ecx
//	movl	*addr	%esi
//	cld
//	1:	lodsl		//將esi送入eax
//		notl	%eax	//求反
//		bsfl	%eax	%edx	//測試eax中的各位，當遇到有1的位，ZF=0，且將該位的序號存入edx，如果eax中所有位為0，則ZF=1，且edx中的值無意義
//		je	2f
//		addl	%edx	%ecx
//		jmp	3f
//	2:	addl	$32	%ecx
//		cmpl	$8192	%ecx		//$8192==8K
//		jl	1b
//	3:	movl	%eax	_res
__asm__("cld\n" \
        "1:\tlodsl\n\t" \
        "notl %%eax\n\t" \
        "bsfl %%eax,%%edx\n\t" \
        "je 2f\n\t" \
        "addl %%edx,%%ecx\n\t" \
        "jmp 3f\n" \
        "2:\taddl $32,%%ecx\n\t" \
        "cmpl $8192,%%ecx\n\t" \
        "jl 1b\n" \
        "3:" \
        :"=c" (__res):"c" (0),"S" (addr):"ax","dx","si"); \
        __res;})

void free_block(int dev, int block)
{
    struct super_block * sb;
    struct buffer_head * bh;

    if (!(sb = get_super(dev)))		//在超級塊表中找包括dev的超級塊
        panic("trying to free block on nonexistent device");
    if (block < sb->s_firstdatazone || block >= sb->s_nzones)	//這個塊是否小于超級所表示的第一數據區域或該塊是否超過了超級塊所表示的最大數據區域
        panic("trying to free block not in datazone");
    bh = get_hash_table(dev,block);
    if (bh) {
        if (bh->b_count != 1) {	//如果這個bh是共享的，就不釋放
            printk("trying to free block (%04x:%d), count=%d\n",
                   dev,block,bh->b_count);
            return;
        }
        bh->b_dirt=0;
        bh->b_uptodate=0;
        brelse(bh);		//釋放此bh
    }
    block -= sb->s_firstdatazone - 1 ;		//此時塊代表在超級塊的相對區域，即在超級塊中的第幾塊區域
    if (clear_bit(block&8191,sb->s_zmap[block/8192]->b_data)) {	//測試該相對塊位置在超級塊中的區域映射中表示的數據位是否為1，并從映射中清除該位，即表示該塊不在內存的區域MAP中
        printk("block (%04x:%d) ",dev,block+sb->s_firstdatazone-1);
        panic("free_block: bit already cleared");
    }
    sb->s_zmap[block/8192]->b_dirt = 1;	//表示已修改了超級塊區域映射表，需要寫盤
}

int new_block(int dev)
{
    struct buffer_head * bh;
    struct super_block * sb;
    int i,j;

    if (!(sb = get_super(dev)))		//取得該設備文件的超級塊
        panic("trying to get new block from nonexistant device");
    j = 8192;				//8192==8K
    for (i=0 ; i<8 ; i++)
        if (bh=sb->s_zmap[i])
            if ((j=find_first_zero(bh->b_data))<8192)		//在s_zmap中尋找一個空的表項
                break;
    if (i>=8 || !bh || j>=8192)		//未找到合法的表項，返回0
        return 0;
    if (set_bit(j,bh->b_data))		//設置這個剛尋找到的空位，標識其已分配
        panic("new_block: bit already set");
    bh->b_dirt = 1;			//需要寫盤
    j += i*8192 + sb->s_firstdatazone-1;	//計算出此塊在磁盤中的實際位置
    if (j >= sb->s_nzones)		//不能超過超級塊的范圍
        return 0;
    if (!(bh=getblk(dev,j)))		//分配一個buffer為這個dev文件新塊
        panic("new_block: cannot get block");
    if (bh->b_count != 1)
        panic("new block: count is != 1");
    clear_block(bh->b_data);		//將此buffer數據區清0
    bh->b_uptodate = 1;
    bh->b_dirt = 1;
    brelse(bh);				//釋放該BUFFER
    return j;
}

void free_inode(struct m_inode * inode)
{
    struct super_block * sb;
    struct buffer_head * bh;

    if (!inode)
        return;
    if (!inode->i_dev) {			//如果這是一個EMPTY INODE
        memset(inode,0,sizeof(*inode));	//將此節點的各位初始化為0
        return;
    }
    if (inode->i_count>1) {		//如果是共享節點，出錯
        printk("trying to free inode with count=%d\n",inode->i_count);
        panic("free_inode");
    }
    if (inode->i_nlinks)
        panic("trying to free inode with links");
    if (!(sb = get_super(inode->i_dev)))
        panic("trying to free inode on nonexistent device");
    if (inode->i_num < 1 || inode->i_num > sb->s_ninodes)
        panic("trying to free inode 0 or nonexistant inode");
    if (!(bh=sb->s_imap[inode->i_num>>13]))		//除以8K
        panic("nonexistent imap in superblock");
    if (clear_bit(inode->i_num&8191,bh->b_data))	//在s_imap表中清除該號的節點影像
        panic("free_inode: bit already cleared");
    bh->b_dirt = 1;			//要寫盤
    memset(inode,0,sizeof(*inode));
}

struct m_inode * new_inode(int dev)
{
    struct m_inode * inode;
    struct super_block * sb;
    struct buffer_head * bh;
    int i,j;

    if (!(inode=get_empty_inode()))	//在內存節點緩沖組中取一個空閑的節點
        return NULL;
    if (!(sb = get_super(dev)))		//取DEV文件的超級塊
        panic("new_inode with unknown device");
    j = 8192;				//==8K
    for (i=0 ; i<8 ; i++)
        if (bh=sb->s_imap[i])	//在s_imap中發現一個空位置
            if ((j=find_first_zero(bh->b_data))<8192)
                break;
    if (!bh || j >= 8192 || j+i*8192 > sb->s_ninodes) {
        iput(inode);
        return NULL;
    }
    if (set_bit(j,bh->b_data))		//將在s_imap中發現的空位置置1，也就是標記在用
        panic("new_inode: bit already set");
    bh->b_dirt = 1;			//要寫盤
    inode->i_count=1;
    inode->i_nlinks=1;
    inode->i_dev=dev;
    inode->i_dirt=1;
    inode->i_num = j + i*8192;		//計算出此節點的在磁盤中相應塊號
    inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
    return inode;
}