blobstore&blobfs

class BlobStore {
  public:
    typedef void *completion_t;

    int open();
    void close();

    int put(const char *key, const char *val, uint64_t expire);
    int get(const char *key, char *val, uint64_t off, size_t len);
    int delete(const char *key);

    int async_put(const char *key, const char *val, uint64_t expire, completion_t comp);
    int async_get(const char *key, char *val, uint64_t off, size_t len, completion_t comp);
    int async_delete(const char *key, completion_t comp);
};

/*
 * We'll use this struct to gather housekeeping hello_context to pass between
 * our events and callbacks.
 */
//该类为收集信息，并作为事件回调的存储信息介质
struct hello_context_t {
	struct spdk_blob_store *bs;
	struct spdk_blob *blob;
	spdk_blob_id blobid;
	struct spdk_io_channel *channel;
	uint8_t *read_buff;
	uint8_t *write_buff;
	uint64_t io_unit_size;
	int rc;
};

/*
 * Free up memory that we allocated.
 */
static void
hello_cleanup(struct hello_context_t *hello_context)
{
	spdk_free(hello_context->read_buff);
	spdk_free(hello_context->write_buff);
	free(hello_context);
}

/*
 * Callback routine for the blobstore unload.
 */
static void
unload_complete(void *cb_arg, int bserrno)
{
	struct hello_context_t *hello_context = cb_arg;

	spdk_app_stop(hello_context->rc);
}

/*
 * Unload the blobstore, cleaning up as needed.
 */
static void
unload_bs(struct hello_context_t *hello_context, char *msg, int bserrno)
{
	if (hello_context->bs) {
		if (hello_context->channel) {
			spdk_bs_free_io_channel(hello_context->channel);
		}
		spdk_bs_unload(hello_context->bs, unload_complete, hello_context);
	} else {
		spdk_app_stop(bserrno);
	}
}

/*
 * Callback routine for the deletion of a blob.
 */
//13、删除blob完成
static void
delete_complete(void *arg1, int bserrno)
{
	struct hello_context_t *hello_context = arg1;

	SPDK_NOTICELOG("entry\n");
	/* We're all done, we can unload the blobstore. */
	unload_bs(hello_context, "", 0);
}

/*
 * Function for deleting a blob.
 */
//12、删除blob
static void
delete_blob(void *arg1, int bserrno)
{
	struct hello_context_t *hello_context = arg1;
	//先关闭blob，然后再删除该blob
	spdk_bs_delete_blob(hello_context->bs, hello_context->blobid,
			    delete_complete, hello_context);
}

/*
 * Callback function for reading a blob.
 */
//11 、读blob完成后回调
static void
read_complete(void *arg1, int bserrno)
{
	struct hello_context_t *hello_context = arg1;
	int match_res = -1;

	/* Now let's make sure things match. */
	//我们测试一下看读到的数据和我们写入的数据是否相同
	match_res = memcmp(hello_context->write_buff, hello_context->read_buff,
			   hello_context->io_unit_size);
	if (match_res) {
		unload_bs(hello_context, "Error in data compare", -1);
		return;
	} else {
		SPDK_NOTICELOG("read SUCCESS and data matches!\n");
	}

	//关闭blob，我们写完数据了，这时也就是说我们已经将数据写入到硬盘了，那么我们可以将blob关闭了。
	spdk_blob_close(hello_context->blob, delete_blob, hello_context);
}

/*
 * Function for reading a blob.
 */
//10、读blob中的数据
static void
read_blob(struct hello_context_t *hello_context)
{

	//还是分配一块内存给readbuffer
	hello_context->read_buff = spdk_malloc(hello_context->io_unit_size,
					       0x1000, NULL, SPDK_ENV_LCORE_ID_ANY,
					       SPDK_MALLOC_DMA);

	/* Issue the read and compare the results in the callback. */
	//从blob中读取数据，将读到的数据放入readbuffer
	spdk_blob_io_read(hello_context->blob, hello_context->channel,
			  hello_context->read_buff, 0, 1, read_complete,
			  hello_context);
}

/*
 * Callback function for writing a blob.
 */
//10：写数据完成后回调
static void
write_complete(void *arg1, int bserrno)
{
	struct hello_context_t *hello_context = arg1;
	/* Now let's read back what we wrote and make sure it matches. */
	//写完我们可以试一下读blob中的数据
	read_blob(hello_context);
}

/*
 * Function for writing to a blob.
 */
//9. 将数据写入blob
static void
blob_write(struct hello_context_t *hello_context)
{
	SPDK_NOTICELOG("entry\n");

	//要写的数据先要放到一个buffer中，所以我们需要分配一块内存给buffer
	hello_context->write_buff = spdk_malloc(hello_context->io_unit_size,
						0x1000, NULL, SPDK_ENV_LCORE_ID_ANY,
						SPDK_MALLOC_DMA);

	//使用c语言中memset函数，内存空间初始化
	//memset（地址指针， 值， 大小）将地址指向的区域连续大小的内存区域填充为值
	//这一步是我们将writebuffer中的数据都填充为0x5a
	memset(hello_context->write_buff, 0x5a, hello_context->io_unit_size);

	//在写操作钱我们需要分配IO
	//在分配IO的时候我们需要将IO分配到channel上
	hello_context->channel = spdk_bs_alloc_io_channel(hello_context->bs);

	/* Let's perform the write, 1 io_unit at offset 0. */
	//执行blob写操作，将writebuffer中的数据写入blob
	spdk_blob_io_write(hello_context->blob, hello_context->channel,
			   hello_context->write_buff,
			   0, 1, write_complete, hello_context);
}

/*
 * Callback function for sync'ing metadata.
 */
static void
sync_complete(void *arg1, int bserrno)
{
	struct hello_context_t *hello_context = arg1;

	//blob创建并且打开，并resize了，现在我们可以想blob中写入数据了
	blob_write(hello_context);
}

// 7：blob大小设置完成回调函数
static void
resize_complete(void *cb_arg, int bserrno)
{
	struct hello_context_t *hello_context = cb_arg;
	uint64_t total = 0;

	//拿到该blob的大小，看他大小是多少个cluster
	total = spdk_blob_get_num_clusters(hello_context->blob);
	SPDK_NOTICELOG("resized blob now has USED clusters of %" PRIu64 "\n",
		       total);

	//手动同步blob中的元数据，当blob关闭时也会自动完成该动作。
	spdk_blob_sync_md(hello_context->blob, sync_complete, hello_context);
}

// 6
/*
 * Callback function for opening a blob.
 */
static void
open_complete(void *cb_arg, struct spdk_blob *blob, int bserrno)
{
	struct hello_context_t *hello_context = cb_arg;
	uint64_t free = 0;

	hello_context->blob = blob;
	//先查看blobstore中free cluster的数量，也就是实际容量抽象为多少个cluster
	free = spdk_bs_free_cluster_count(hello_context->bs);

	//在使用该blob之前我们需要resize一下，因为他的初始大小为0
	//第一个参数为需要重置的blob，第二个参数为设置这个blob的大小，设置的单位是cluster，也就是
	//需要设置这个blob有多少个cluster
	//这个例子中我们将blobstore中剩余的cluster整个都放入一个blob。
	spdk_blob_resize(hello_context->blob, free, resize_complete, hello_context);
}

// 5 
/*
 * Callback function for creating a blob. 
 */
static void
blob_create_complete(void *arg1, spdk_blob_id blobid, int bserrno)
{
	struct hello_context_t *hello_context = arg1;
	//创建blob后系统会返回blobID
	hello_context->blobid = blobid;
	SPDK_NOTICELOG("new blob id %" PRIu64 "\n", hello_context->blobid);
	//创建完blob后，如果要操作这个blob首先我们需要打开这个blob，打开成功后回调
	spdk_bs_open_blob(hello_context->bs, hello_context->blobid,
			  open_complete, hello_context);
}
// 4
/*
 * Function for creating a blob.
 */
static void
create_blob(struct hello_context_t *hello_context)
{
	SPDK_NOTICELOG("entry\n");
	//调用创建blob的接口函数，创建完成回调
	spdk_bs_create_blob(hello_context->bs, blob_create_complete, hello_context);
}

// 3 
/*
 * Callback function for initializing the blobstore.
 */
static void
bs_init_complete(void *cb_arg, struct spdk_blob_store *bs,
		 int bserrno)
{
	struct hello_context_t *hello_context = cb_arg;

	//Get the io unit size in bytes.
	//拿到io的单位大小
	hello_context->io_unit_size = spdk_bs_get_io_unit_size(hello_context->bs);

	//blobstore就已经初始化完成了，下面进行创建blob
	create_blob(hello_context);
}

static void
base_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
		   void *event_ctx)
{
	SPDK_WARNLOG("Unsupported bdev event: type %d\n", type);
}

// 2。入口函数
/*
 * Our initial event that kicks off everything from main().
 */
static void
hello_start(void *arg1)
{
	//此时传入的参数是hello_context
	struct hello_context_t *hello_context = arg1;
	struct spdk_bs_dev *bs_dev = NULL;
	int rc;

	SPDK_NOTICELOG("entry\n");

	//第一个参数指定bdev的名称，bdev可以是nvme，文件IO，或者内存
	//bdev就是决定下层使用的存储介质，比如nvme或者malloc，或者文件IO
	rc = spdk_bdev_create_bs_dev_ext("Malloc0", base_bdev_event_cb, NULL, &bs_dev);

	//创建完bdev之后，我们需要创建blobstore，与指定的bdev设备关联上
	spdk_bs_init(bs_dev, NULL, bs_init_complete, hello_context);
}

//1
int
main(int argc, char **argv)
{
	struct spdk_app_opts opts = {};
	int rc = 0;
	struct hello_context_t *hello_context = NULL;

	SPDK_NOTICELOG("entry\n");

	/* Set default values in opts structure. */
	//设置spdk的默认值
	spdk_app_opts_init(&opts);

	//设置名称
	opts.name = "hello_blob";
	//配置文件信息
	opts.json_config_file = argv[1];
	//给hello_context分配空间
	hello_context = calloc(1, sizeof(struct hello_context_t));

	//启动到hello_start函数中，并将hello_context作为参数传入
	rc = spdk_app_start(&opts, hello_start, hello_context);

}