# dskfmt_tool

**Repository Path**: moriere/dskfmt_tool

## Basic Information

- **Project Name**: dskfmt_tool
- **Description**: dskfmt_tool 工具用来将一个文件系统, 格式化到多种不同类型的外部存储上去 。
可以向 dskfmt_tool 注册文件系统类型，也可以向 dskfmt_tool 注册外部存储类型，来建立不同的文件系统到外部存储的格式化。
- **Primary Language**: C
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-08-04
- **Last Updated**: 2022-08-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# dskfmt_tool 一个通用的dsk格式化工具

## 简介
dskfmt_tool 工具用来将一个文件系统, 格式化到多种不同类型的外部存储上去 。
可以向 dskfmt_tool 注册文件系统类型，也可以向 dskfmt_tool 注册外部存储类型，来建立不同的文件系统到外部存储的格式化。

## 编程指南
dskfmt_tool 包含三种抽象 fs_obj, fmt_instance, dsk_obj:

fs_obj 对应一种具体的文件系统类型

dsk_obj 对应一种具体的外部存储类型。

fmt_instance 对应一个格式化实例， 也就是将某一个具体的 fs_obj 同某一个具体的 dsk_obj，
建立起一次格式化。


### 一、fs_obj
fs_obj 是文件系统抽象， 主要作用为按照对应的文件系统规范初始化各个扇区， 也就是 fmt_instance 传递给它的 sector_list。
它的功能函数为 fs_sector_init。
```c
struct fs_ops_struct
{
    int32_t (* fs_sector_init)(struct sector_list* list, uint32_t dsk_size);
};
```
sector_list 是一个单向链表， 其成员为 sector_node 如下:
```c
struct sector_node
{
    uint32_t sector;        // 扇区号
    void* data;             // 扇区数据
    uint32_t count;         // 扇区数据长度
    struct sector_node *next;   // 下一个 sector_node
};
```

### 二、dsk_obj
dsk_obj 是外部存储抽象， 主要作用为提供向该外部存储的扇区读写功能。
fmt_instance 首先调用 fs_obj 的 fs_sector_init 初始化完所有的 sector_list 后，
就会开始将 sector_list 中所有的 sector_node 写入到 dsk_obj 对应的扇区去。
```c
struct dsk_ops_struct
{
    void (* write_sector)(uint32_t sector, void* buf, uint32_t count);
    void (* read_sector)(uint32_t sector, void* buf, uint32_t count);
    uint32_t (* get_sector_size)();
    uint32_t (* get_dsk_size)();
};
```

### 三、fmt_instance
fmt_instance 是具体的一个格式化实例, 包含两个具体的 dsk_obj / fs_obj 类型。
并且进行格式化。
其中 fs_type_enum 和 dsk_type_enum 是前面 fs_obj 和 dsk_obj 注册的对应的类型。
通过 create_fmt_instance 可以很好的对不同的 fs 和 dsk 进行组装。
而 flush_fmt_instance 则是进行格式化操作。
```c
struct fmt_instance_struct* create_fmt_instance(enum fs_type_enum fs, enum dsk_type_enum dsk);
void  flush_fmt_instance(struct fmt_instance_struct* fmt_instance);
```

## 用例
### fs 注册 FAT32_IMG 类型的 fs_obj
```c
#include <stdio.h>
#include "fs.h"
#include "sector_node.h"
#include "fmt_prt.h"

#define FAT32_IMG_FILE  "../image/fat32_image"

static int32_t fat32_img_init(struct sector_list* list)
{
    FILE *fp;
    struct sector_node* node;
    uint32_t sector;
    uint32_t read;

    sector = 1;
    fp = fopen(FAT32_IMG_FILE, "rb");
    if(!fp) {
        //
        fmt_printf("%s: %s fopen failed\n", __func__, FAT32_IMG_FILE);
        return -1;
    }
    fmt_printf("%s: %s fopen success\n", __func__, FAT32_IMG_FILE);

    while (!feof(fp))
    {
        node = alloc_sector_node(list, sector++);
        read = fread(node->data, list->sector_size, 1, fp);
        if(!read) break;
    }
    fmt_printf("%s: %s write to dsk finished\n", __func__, FAT32_IMG_FILE);
    fclose(fp);
}

static struct fs_ops_struct fat32_img_ops = {
    .fs_sector_init = fat32_img_init,
};

void init_fat32_img()
{
    struct fs_obj_struct* fs_obj;

    fs_obj = create_fs_obj();
    if(!fs_obj) {
        //
        return;
    }

    fs_obj->type = FAT32_IMG;
    fs_obj->ops = &fat32_img_ops;
    register_fs_obj(fs_obj);
}
```

### dsk 注册 DFL_DSK 类型的 dsk_obj
```c
#include "dsk.h"
#include "fmt_prt.h"

void dfl_write_sector(uint32_t sector, void* buf, uint32_t count)
{
    //fmt_printf("%s: sector = %u, count = %u\n", __func__, sector, count);
}

void dfl_read_sector(uint32_t sector, void* buf, uint32_t count)
{
    fmt_printf("%s: sector = %u, count = %u\n", __func__, sector, count);
}

uint32_t dfl_get_sector_size()
{
    fmt_printf("%s: sector_size = 512\n", __func__);
    return 512;
}

static struct dsk_ops_struct dfl_dsk_ops = {
    .get_sector_size = dfl_get_sector_size,
    .read_sector = dfl_read_sector,
    .write_sector = dfl_write_sector,
};

void init_dfl_dsk()
{
    struct dsk_obj_struct* dsk_obj;

    dsk_obj = create_dsk_obj();
    if(!dsk_obj) {
        //
        fmt_printf("%s: create_dsk_obj failed\n", __func__);
        return;
    }

    dsk_obj->type = DFL_DSK;
    dsk_obj->ops = &dfl_dsk_ops;
    register_dsk_obj(dsk_obj);
}
```

### 使用
```c
#include <stdio.h>
#include "fmt.h"
#include "fmt_prt.h"

extern void init_fat32_img();
extern void init_dfl_dsk();

static void init()
{
    init_fat32_img();
    init_dfl_dsk();
}

int main(int argc, char**argv)
{
    init();
    flush_fmt_instance(create_fmt_instance( FAT32_IMG, DFL_DSK));
    return 0;
}
```