int inode_write(struct inode *in, uint32_t offset, char * buf, int len)
{
    int result=0;
    struct ssu_fs * fs = in->sn_fs;
    uint32_t blkoff = offset / SSU_BLOCK_SIZE;
    uint32_t res_off = offset % SSU_BLOCK_SIZE;

    if(offset > in->sn_size)
        return -1;

    uint32_t lbn_start = blkoff;
    uint32_t lbn_end = blkoff;
    int tmplen=0; //이태까지 파일에 쓴 데이터의 길이를 저장할 변수
    int pbn=-1; //lbn_to_pbn()의 결과값을 저장하는 변수

    while(tmplen < len){
        /*Get Page Block Number*/
        pbn = lbn_to_pbn(in, blkoff);
        blkoff++;
        if(pbn == -1){
            printk("ERROR::Can't access Data Block!\n");
            if(in->sn_size < offset+tmplen)
                in->sn_size = offset+tmplen;
            sync_inode(fs, in);
            return -1;
        }
        /*Get Page Block*/
        memset(tmpblock, 0, SSU_BLOCK_SIZE);
        fs_readblock(fs, pbn, tmpblock);

        /*Write at Page Block*/
        if((res_off + len - tmplen) <= SSU_BLOCK_SIZE){
            memcpy(tmpblock + res_off, buf + tmplen, len-tmplen);
            tmplen += len-tmplen;
        }
        else{
            memcpy(tmpblock + res_off, buf + tmplen, SSU_BLOCK_SIZE);
            tmplen += SSU_BLOCK_SIZE;
        }
        fs_writeblock(fs, pbn, tmpblock);
        res_off = 0;
    }

    if(in->sn_size < offset+len)
        in->sn_size = offset+len;
    sync_inode(fs, in);

    /*print info*/
    lbn_end = blkoff-1;
    printk("start blkoff = %d\n", lbn_start);
    printk("end blkoff = %d\n", lbn_end);
    printk("physical start blkoff = %d\n", lbn_to_pbn(in, lbn_start));
    printk("physical end bkoff = %d\n", lbn_to_pbn(in, lbn_end));
    /**/

    return result;
}

int inode_read(struct inode * in, uint32_t offset, char * buf, int len)
{
    int result=0;
    struct ssu_fs * fs = in->sn_fs;
    uint32_t blkoff = offset / SSU_BLOCK_SIZE;
    uint32_t res_off = offset % SSU_BLOCK_SIZE;

    if(offset > in->sn_size)
        return -1;

    uint32_t lbn_start = blkoff;
    uint32_t lbn_end = blkoff;
    int tmplen = 0;
    int pbn = -1;
    while(tmplen < len){
        /*Get Page Block Number*/
        pbn = lbn_to_pbn(in, blkoff);
        blkoff++;
        if(pbn < 0){
            printk("ERROR::Can't access Data Block!\n");
            return -1;
        }

        memset(tmpblock, 0, SSU_BLOCK_SIZE);
        fs_readblock(fs, pbn, tmpblock);
        /*Read Page Block*/
        if((res_off + len - tmplen) <= SSU_BLOCK_SIZE){
            memcpy(buf+tmplen, tmpblock + res_off, len-tmplen);
            tmplen += len-tmplen;
        }
        else{
            memcpy(buf+tmplen, tmpblock+res_off, SSU_BLOCK_SIZE);
            tmplen += SSU_BLOCK_SIZE;
        }
        res_off = 0;
    }

    /*print info*/
    lbn_end = blkoff-1;
    if(lbn_start < lbn_end){
        printk("start blkoff = %d\n", lbn_start);
        printk("end blkoff = %d\n", lbn_end);
        printk("physical start blkoff = %d\n", lbn_to_pbn(in, lbn_start));
        printk("physical end bkoff = %d\n", lbn_to_pbn(in, lbn_end));
    }
    /**/

    return result;
}

int lbn_to_pbn(struct inode * in, uint32_t lbn)
{
    struct ssu_fs * fs = in->sn_fs;
    int pbn=0;

    if(lbn < 2){
        /*Get Page Direct Block*/
        if(lbn < in->sn_nlink){
            pbn = in->sn_directblock[lbn];
        }
        else{
            balloc(fs->fs_blkmap, &pbn);
            in->sn_nlink++;
            sync_bitmapblock(fs);
            in->sn_directblock[lbn] = pbn;
        }
        return pbn;
    }

    /*Get Page Indirect Block*/
    int ilbn = (lbn-2)/1024;
    int dlbn = (lbn-2)%1024;
    memset(tmpblock_indirect, 0, SSU_BLOCK_SIZE);
    if(ilbn < in->cnt_data_block)
    {
        //nothing
    }
    else{
        balloc(fs->fs_blkmap, &(in->sn_indirectblock[ilbn]));
        in->cnt_data_block++;
        in->sn_nlink++;
        sync_bitmapblock(fs);
    }

    /*Get Page Block from Indirect Block*/
    fs_readblock(fs, in->sn_indirectblock[ilbn], tmpblock_indirect);
    int nbuf=-1;
    if(lbn < (in->sn_nlink - in->cnt_data_block))
    {
        memcpy(&nbuf, tmpblock_indirect + 4*dlbn, 4);
        pbn = nbuf;
    }
    else{
        balloc(fs->fs_blkmap, &pbn);
        in->sn_nlink++;
        sync_bitmapblock(fs);

        memcpy(tmpblock_indirect + 4*dlbn, &pbn, 4);
        fs_writeblock(fs, in->sn_indirectblock[ilbn], tmpblock_indirect);
        sync_inode(fs, in);

        memcpy(&nbuf, tmpblock_indirect + 4*dlbn, 4);
    }
    return pbn;
}