Cosmos OpenSSD--greedy_ftl1.2.0（一）

从主函数跳到ReqHandler，在ReqHandler内先初始化SSD--InitNandReset，然后建立映射表InitFtlMapTable

void InitNandReset()
{
    //    reset SSD
    int i, j;
    for(i=0; i<CHANNEL_NUM; ++i)
    {
        for(j=0; j<WAY_NUM; ++j)
        {
            WaitWayFree(i, j);
            SsdReset(i, j);
        }
    }
    
    //    change SSD mode
    for(i=0; i<CHANNEL_NUM; ++i)
    {
        for(j=0; j<WAY_NUM; ++j)
        {
            WaitWayFree(i, j);
            SsdModeChange(i, j);
        }
    }

    print("
[ ssd NAND device reset complete. ]
");
}

遍历每条channel每条way来重启，change mode

接下来来看怎么建立映射表InitFtlMapTable

void InitFtlMapTable()
{
    InitPageMap();
    InitBlockMap();
    InitDieBlock();

    InitGcMap();
}

这里有四步，我们一步一步来分析

---

 首先是页表建立，InitPageMap

#define RAM_DISK_BASE_ADDR 0x10000000

#define PAGE_MAP_ADDR (RAM_DISK_BASE_ADDR + (0x1 << 27))　　　　//PAGE_MAP_ADDR =0x18000000

•#define  CHANNEL_NUM  4　　　　　　　　　　　　　　　　　　　　　　　　//4个channel

•#define  WAY_NUM  4　　　　　　　　　　　　　　　　　　　　　　　　　　//每个channel4条way

•#define  DIE_NUM  (CHANNEL_NUM * WAY_NUM) =16　　　　　　　　　　//每条way上连着一个die

•

•#define   PAGE_NUM_PER_BLOCK  256　　　　　　　　　　　　　　　　　　//每个块256个page

•#define  BLOCK_NUM_PER_DIE  4096　　　　　　　　　　　　　　　　　　//每个die4096个block

#define  PAGE_NUM_PER_DIE  (PAGE_NUM_PER_BLOCK * BLOCK_NUM_PER_DIE)　

struct pmEntry {
　　u32 ppn; // Physical Page Number (PPN) to which a logical page is mapped

　　u32 valid : 1; // validity of a physical page
　　u32 lpn : 31; // Logical Page Number (LPN) of a physical page
};

每个entry页表构造如下图

 每个入口8Byte

struct pmArray {
　　struct pmEntry pmEntry[DIE_NUM][PAGE_NUM_PER_DIE];　　　　//页表entry个数为DIE_NUM * PAGE_NUM_PER_DIE = 16*4096*256 = 2²⁴
};

这样页表大小就为 2²⁴ * 8Byte = 128MB

void InitPageMap()
{
    pageMap = (struct pmArray*)(PAGE_MAP_ADDR);

    // page status initialization, allows lpn, ppn access
    int i, j;
    for(i=0 ; i<DIE_NUM ; i++)
    {
        for(j=0 ; j<PAGE_NUM_PER_DIE ; j++)
        {
            pageMap->pmEntry[i][j].ppn = 0xffffffff;

            pageMap->pmEntry[i][j].valid = 1;
            pageMap->pmEntry[i][j].lpn = 0x7fffffff;
        }
    }

    xil_printf("[ ssd page map initialized. ]
");
}

 这里将设置每个页表entry的初始值，

---

 接下来分析InitBlockMap

#define BLOCK_MAP_ADDR (PAGE_MAP_ADDR + sizeof(struct pmEntry) * PAGE_NUM_PER_SSD)　　//块表是在页表之后继续建立

struct bmEntry {
　　u32 bad : 1;
　　u32 free : 1;
　　u32 eraseCnt : 30;
　　u32 invalidPageCnt : 16;
　　u32 currentPage : 16;
　　u32 prevBlock;
　　u32 nextBlock;
};

每个块entry构造图如下，占据16Byte

struct bmArray {
　　struct bmEntry bmEntry[DIE_NUM][BLOCK_NUM_PER_DIE];　　　　//块表入口数为 16 * 4096 = 2¹⁶，所以块表大小为2¹⁶ * 16Byte = 1MB
};

分配块表之后，首先先检测坏块--CheckBadBlock

　　 blockMap = (struct bmArray*)(BLOCK_MAP_ADDR);
    u32 dieNo, diePpn, blockNo, tempBuffer, badBlockCount;
    u8* shifter;
    u8* markPointer;
    int loop;

    markPointer = (u8*)(RAM_DISK_BASE_ADDR + BAD_BLOCK_MARK_POSITION);

#define BAD_BLOCK_MARK_POSITION (7972)　　//代表着坏块标记的偏移量

    //read badblock marks
    loop = DIE_NUM *BLOCK_NUM_PER_DIE;
    dieNo = METADATA_BLOCK_PPN % DIE_NUM;
    diePpn = METADATA_BLOCK_PPN / DIE_NUM;

    tempBuffer = RAM_DISK_BASE_ADDR;
    while(loop > 0)
    {
        SsdRead(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM, diePpn, tempBuffer);
        WaitWayFree(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM);

        diePpn++;
        tempBuffer += PAGE_SIZE;
        loop -= PAGE_SIZE;
    }

疑问：dieNo =0，diePpn=0，进入循环之后，读取channel0，way0的第01234567页存在tempbuffer里面，8页大小为64KB，一个字节记录一个块的信息的话，那么大小也为1Byte*16*4096=64KB，其中因为第一个块厂家保证是好的，所以不需要保存是否为坏块，所以里面可以存一个标记位，表示是否有现成的坏块信息表

    if(*shifter == EMPTY_BYTE)    //check whether badblock marks exist
    {
        // static bad block management
        for(blockNo=0; blockNo < BLOCK_NUM_PER_DIE; blockNo++)
            for(dieNo=0; dieNo < DIE_NUM; dieNo++)
            {
                blockMap->bmEntry[dieNo][blockNo].bad = 0;

                SsdRead(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM, (blockNo*PAGE_NUM_PER_BLOCK+1), RAM_DISK_BASE_ADDR);
                WaitWayFree(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM);

                if(CountBits(*markPointer)<4)
                {
                    xil_printf("Bad block is detected on: Ch %d Way %d Block %d 
",dieNo%CHANNEL_NUM, dieNo/CHANNEL_NUM, blockNo);
                    blockMap->bmEntry[dieNo][blockNo].bad = 1;
                    badBlockCount++;
                }
                shifter= (u8*)(GC_BUFFER_ADDR + blockNo + dieNo *BLOCK_NUM_PER_DIE );//gather badblock mark at GC buffer
                *shifter = blockMap->bmEntry[dieNo][blockNo].bad;
            }

        // save bad block mark
        loop = DIE_NUM *BLOCK_NUM_PER_DIE;
        dieNo = METADATA_BLOCK_PPN % DIE_NUM;
        diePpn = METADATA_BLOCK_PPN / DIE_NUM;
        blockNo = diePpn / PAGE_NUM_PER_BLOCK;

        SsdErase(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM, blockNo);
        WaitWayFree(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM);

        tempBuffer = GC_BUFFER_ADDR;
        while(loop>0)
        {
            WaitWayFree(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM);
            SsdProgram(dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM, diePpn, tempBuffer);
            diePpn++;
            tempBuffer += PAGE_SIZE;
            loop -= PAGE_SIZE;
        }
        xil_printf("[ Bad block Marks are saved. ]
");
    }

第九行为什么是读取每个块第一页的内容而不是第零页的内容？

12行位数小于4位就是坏块？

    else    //read existing bad block marks
    {
        for(blockNo=0; blockNo<BLOCK_NUM_PER_DIE; blockNo++)
            for(dieNo=0; dieNo<DIE_NUM; dieNo++)
            {
                shifter = (u8*)(RAM_DISK_BASE_ADDR + blockNo + dieNo *BLOCK_NUM_PER_DIE );
                blockMap->bmEntry[dieNo][blockNo].bad = *shifter;
                if(blockMap->bmEntry[dieNo][blockNo].bad)
                {
                    xil_printf("Bad block mark is checked at: Ch %d Way %d Block %d  
",dieNo % CHANNEL_NUM, dieNo / CHANNEL_NUM, blockNo );
                    badBlockCount++;
                }
            }

        xil_printf("[ Bad blocks are checked. ]
");
    }

    // save bad block size
    BAD_BLOCK_SIZE = badBlockCount * BLOCK_SIZE_MB;

 接下来是InitBlockMap的代码

    blockMap = (struct bmArray*)(BLOCK_MAP_ADDR);

    CheckBadBlock();

    // block status initialization except bad block marks, allows only physical access
    int i, j;
    for(i=0 ; i<BLOCK_NUM_PER_DIE ; i++)
    {
        for(j=0 ; j<DIE_NUM ; j++)
        {
            blockMap->bmEntry[j][i].free = 1;
            blockMap->bmEntry[j][i].eraseCnt = 0;
            blockMap->bmEntry[j][i].invalidPageCnt = 0;
            blockMap->bmEntry[j][i].currentPage = 0x0;
            blockMap->bmEntry[j][i].prevBlock = 0xffffffff;
            blockMap->bmEntry[j][i].nextBlock = 0xffffffff;
        }
    }

初始化块表的一些值

    for (i = 0; i < BLOCK_NUM_PER_DIE; ++i)
        for (j = 0; j < DIE_NUM; ++j)
            if (!blockMap->bmEntry[j][i].bad && ((i != METADATA_BLOCK_PPN % DIE_NUM)|| (j != (METADATA_BLOCK_PPN / DIE_NUM) / PAGE_NUM_PER_BLOCK)))
            {
                // initial block erase
                WaitWayFree(j % CHANNEL_NUM, j / CHANNEL_NUM);
                SsdErase(j % CHANNEL_NUM, j / CHANNEL_NUM, i);
            }
　　xil_printf("[ ssd entire block erasure completed. ]
");

 除了die0的block0之外，全部擦除

    for(i=0 ; i<DIE_NUM ; i++)
    {
        // initially, 0th block of each die is allocated for storage start point
        blockMap->bmEntry[i][0].free = 0;
        blockMap->bmEntry[i][0].currentPage = 0xffff;
        // initially, the last block of each die is reserved as free block for GC migration
        blockMap->bmEntry[i][BLOCK_NUM_PER_DIE-1].free = 0;
    }
    //block0 of die0 is metadata block
    blockMap->bmEntry[0][1].free = 0;
    blockMap->bmEntry[0][1].currentPage = 0xffff;

    xil_printf("[ ssd block map initialized. ]
");

因为die0的第一个block是用来存储元数据，所以他开始的块指针为第一块

每个die的开始和最后一块都不能用，die0的第一块也不让用

---

#define DIE_MAP_ADDR (BLOCK_MAP_ADDR + sizeof(struct bmEntry) * BLOCK_NUM_PER_SSD)

struct dieEntry {
u32 currentBlock;
u32 freeBlock;
};

struct dieArray {
struct dieEntry dieEntry[DIE_NUM];
};

void InitDieBlock()
{
    dieBlock = (struct dieArray*)(DIE_MAP_ADDR);

//    xil_printf("DIE_MAP_ADDR : %8x
", DIE_MAP_ADDR);

    int i;
    for(i=0 ; i<DIE_NUM ; i++)
    {
        if(i==0) // prevent to write at meta data block
            dieBlock->dieEntry[i].currentBlock = 1;
        else
            dieBlock->dieEntry[i].currentBlock = 0;
        dieBlock->dieEntry[i].freeBlock = BLOCK_NUM_PER_DIE - 1;
    }

    xil_printf("[ ssd die map initialized. ]
");
}

 freeblock用作垃圾回收

---

struct gcEntry {
u32 head;
u32 tail;
};

struct gcArray {
struct gcEntry gcEntry[DIE_NUM][PAGE_NUM_PER_BLOCK+1];
};

void InitGcMap()
{
    gcMap = (struct gcArray*)(GC_MAP_ADDR);

//    xil_printf("GC_MAP_ADDR : %8x
", GC_MAP_ADDR);

    // gc table status initialization
    int i, j;
    for(i=0 ; i<DIE_NUM ; i++)
    {
        for(j=0 ; j<PAGE_NUM_PER_BLOCK+1 ; j++)
        {
            gcMap->gcEntry[i][j].head = 0xffffffff;
            gcMap->gcEntry[i][j].tail = 0xffffffff;
        }
    }

    xil_printf("[ ssd gc map initialized. ]
");
}