From cf422ca611fd9bc7eb6bf3bbd21b4913038b9682 Mon Sep 17 00:00:00 2001 From: king Date: Sat, 10 Aug 2024 14:23:21 +0000 Subject: [PATCH] finished api(mount,umount,open,write,read,close) --- zv2404fs.c | 645 +++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 447 insertions(+), 198 deletions(-) diff --git a/zv2404fs.c b/zv2404fs.c index 96c4755..892eac3 100755 --- a/zv2404fs.c +++ b/zv2404fs.c @@ -26,6 +26,8 @@ struct spdk_io_channel *channel; #else +#define FILENAME_LENGTH 128 + // typedef struct zv2404fs_context_s { @@ -41,206 +43,53 @@ typedef struct zv2404fs_context_s { } zv2404fs_context_t; +typedef struct zv2404fs_s { + + struct spdk_blob_store *blobstore; + uint64_t unit_size; + uint64_t free_cluster_count; + uint64_t num_cluster; + + struct spdk_io_channel *channel; + bool finished; + +} zv2404fs_t; + +typedef struct zv2404fs_operation_s { + int (*mount)(struct zv2404fs_s *fs); + int (*umount)(struct zv2404fs_s *fs); +} zv2404fs_operation_t; + + +typedef struct zv2404fs_file_s { + + uint8_t filename[FILENAME_LENGTH]; + + spdk_blob_id blob_id; + struct spdk_blob *blob; + zv2404fs_t *fs; + + uint8_t *write_buffer; + uint8_t *read_buffer; + + bool finished; + +} zv2404fs_file_t; + +typedef struct zv2404fs_file_operation_s { + + int (*open)(struct zv2404fs_file_s *file); + int (*read)(struct zv2404fs_file_s *file); + int (*write)(struct zv2404fs_file_s *file); + int (*close)(struct zv2404fs_file_s *file); + +} zv2404fs_file_operation_t; + + #endif struct spdk_thread *global_thread = NULL; - - -static void zv2404fs_spdk_bs_unload_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - spdk_app_stop(0); - - spdk_free(ctx->write_buffer); - spdk_free(ctx->read_buffer); - free(ctx); -} - - -static void zv2404fs_spdk_blob_delete_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - if (ctx->blobstore) { - if (ctx->channel) { - spdk_bs_free_io_channel(ctx->channel); - } - spdk_bs_unload(ctx->blobstore, zv2404fs_spdk_bs_unload_cb, ctx); - } - -} - -static void zv2404fs_spdk_blob_close_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - spdk_bs_delete_blob(ctx->blobstore, ctx->blob_id, zv2404fs_spdk_blob_delete_cb, ctx); - -} - - - -static void zv2404fs_spdk_blob_read_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - SPDK_NOTICELOG("READ BUFFER : %s\n", ctx->read_buffer); - - spdk_blob_close(ctx->blob, zv2404fs_spdk_blob_close_cb, ctx); - -} - - -static void zv2404fs_spdk_blob_write_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - SPDK_NOTICELOG("WRITE COMPLETE\n"); - - uint8_t *rbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); - if (rbuffer == NULL) { - spdk_app_stop(0); - return ; - } - memset(rbuffer, 0x0, BUFFER_SIZE); - - ctx->read_buffer = rbuffer; - - spdk_blob_io_read(ctx->blob, ctx->channel, rbuffer, 0, 1, zv2404fs_spdk_blob_read_cb, ctx); -} - - -static void zv2404fs_spdk_blob_sync_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - uint8_t *wbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); - if (wbuffer == NULL) { - spdk_app_stop(0); - return ; - } - memset(wbuffer, 'A', BUFFER_SIZE); - *(wbuffer+BUFFER_SIZE-1) = '\0'; - - ctx->write_buffer = wbuffer; - - struct spdk_io_channel *chan = spdk_bs_alloc_io_channel(ctx->blobstore); - if (chan == NULL) { - spdk_app_stop(0); - return ; - } - ctx->channel = chan; - - spdk_blob_io_write(ctx->blob, ctx->channel, wbuffer, 0, 1, zv2404fs_spdk_blob_write_cb, ctx); - -} - - - -static void zv2404fs_spdk_blob_resize_cb(void *arg, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - uint64_t total = spdk_blob_get_num_clusters(ctx->blob); - ctx->num_cluster = total; - - SPDK_NOTICELOG("resize blob :%"PRIu64"\n", total); - - spdk_blob_sync_md(ctx->blob, zv2404fs_spdk_blob_sync_cb, ctx); - -} - - - -static void zv2404fs_spdk_bs_open_blob_cb(void *arg, struct spdk_blob *blb, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - ctx->blob = blb; - - uint64_t free_cluster = spdk_bs_free_cluster_count(ctx->blobstore); // - SPDK_NOTICELOG("free_cluster : %"PRIu64"\n", free_cluster); - ctx->free_cluster_count = free_cluster; - - spdk_blob_resize(blb, free_cluster, zv2404fs_spdk_blob_resize_cb, ctx); - -} - - - -static void zv2404fs_spdk_bs_create_blob_cb(void *arg, spdk_blob_id blobid, int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - ctx->blob_id = blobid; - SPDK_NOTICELOG("blobid : %"PRIu64"\n", blobid); - - spdk_bs_open_blob(ctx->blobstore, blobid, zv2404fs_spdk_bs_open_blob_cb, ctx); -} - - - -static void zv2404fs_spdk_bs_init_cb(void *arg, struct spdk_blob_store *bs, - int bserrno) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - uint64_t io_unit_size = spdk_bs_get_io_unit_size(bs); - SPDK_NOTICELOG("io_unit_size : %"PRIu64"\n", io_unit_size); - - ctx->unit_size = io_unit_size; - ctx ->blobstore = bs; - - spdk_bs_create_blob(bs, zv2404fs_spdk_bs_create_blob_cb, ctx); -} - - - -static void zv2404_spdk_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, - void *event_ctx) { - - SPDK_NOTICELOG("zv2404_spdk_bdev_event_cb\n"); - -} - - - - -static void zv2404fs_entry(void *arg) { - - zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; - - struct spdk_bs_dev *bs_dev = NULL; - - int rc = spdk_bdev_create_bs_dev_ext("Malloc0", zv2404_spdk_bdev_event_cb, NULL, &bs_dev); - if (rc != 0) { - spdk_app_stop(0); - } - - //int *count = malloc(sizeof(int)); - //*count = 2404; - - spdk_bs_init(bs_dev, NULL, zv2404fs_spdk_bs_init_cb, ctx); - - //sleep(10); - SPDK_NOTICELOG("zv2404fs_entry\n"); - -} - -// open - -// read - -// write - -// close - - -#if 1 - - static const int WAITER_MAX_TIME = 100000; static bool waiter(struct spdk_thread *thread, spdk_msg_fn start_fn, void *ctx, bool *finished) { @@ -261,6 +110,365 @@ static bool waiter(struct spdk_thread *thread, spdk_msg_fn start_fn, void *ctx, return true; } + + +static void zv2404fs_spdk_bs_unload_cb(void *arg, int bserrno) { + + zv2404fs_t *fs = (zv2404fs_t *)arg; + fs->finished = true; + +} + + + +static void zv2404fs_do_umount(void *arg) { + + zv2404fs_t *fs = (zv2404fs_t *)arg; + + if (fs->blobstore) { + if (fs->channel) { + spdk_bs_free_io_channel(fs->channel); + } + spdk_bs_unload(fs->blobstore, zv2404fs_spdk_bs_unload_cb, fs); + } + +} + +static void zv2404fs_spdk_blob_delete_cb(void *arg, int bserrno) { +#if 0 + zv2404fs_t *fs = (zv2404fs_t *)arg; + + if (ctx->blobstore) { + if (ctx->channel) { + spdk_bs_free_io_channel(ctx->channel); + } + spdk_bs_unload(ctx->blobstore, zv2404fs_spdk_bs_unload_cb, ctx); + } +#else + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + spdk_free(file->write_buffer); + spdk_free(file->read_buffer); + + SPDK_NOTICELOG("close complete\n"); + file->finished = true; + +#endif +} + + +static void zv2404fs_spdk_blob_close_cb(void *arg, int bserrno) { +#if 0 + zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; + + +#else + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + spdk_bs_delete_blob(file->fs->blobstore, file->blob_id, zv2404fs_spdk_blob_delete_cb, file); + + +#endif +} + + +static void zv2404fs_do_close(void *arg) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + spdk_blob_close(file->blob, zv2404fs_spdk_blob_close_cb, file); + +} + + +static void zv2404fs_spdk_blob_read_cb(void *arg, int bserrno) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + SPDK_NOTICELOG("READ BUFFER : %s\n", file->read_buffer); + + file->finished = true; + + //spdk_blob_close(ctx->blob, zv2404fs_spdk_blob_close_cb, ctx); + +} + + +static void zv2404fs_do_read(void *arg) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + memset(file->read_buffer, 0x0, BUFFER_SIZE); + + spdk_blob_io_read(file->blob, file->fs->channel, file->read_buffer, + 0, 1, zv2404fs_spdk_blob_read_cb, file); + +} + + +static void zv2404fs_spdk_blob_write_cb(void *arg, int bserrno) { +#if 0 + zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; + + SPDK_NOTICELOG("WRITE COMPLETE\n"); + + uint8_t *rbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); + if (rbuffer == NULL) { + spdk_app_stop(0); + return ; + } + memset(rbuffer, 0x0, BUFFER_SIZE); + + ctx->read_buffer = rbuffer; + + spdk_blob_io_read(ctx->blob, ctx->channel, rbuffer, 0, 1, zv2404fs_spdk_blob_read_cb, ctx); + +#else + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + SPDK_NOTICELOG("write complete\n"); + + file->finished = true; + + +#endif +} + + +static void zv2404fs_do_write(void *arg) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + spdk_blob_io_write(file->blob, file->fs->channel, file->write_buffer, + 0, 1, zv2404fs_spdk_blob_write_cb, file); + +} + +static void zv2404fs_spdk_blob_sync_cb(void *arg, int bserrno) { +#if 0 + zv2404fs_context_t *ctx = (zv2404fs_context_t*)arg; + + uint8_t *wbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); + if (wbuffer == NULL) { + spdk_app_stop(0); + return ; + } + memset(wbuffer, 'A', BUFFER_SIZE); + *(wbuffer+BUFFER_SIZE-1) = '\0'; + + ctx->write_buffer = wbuffer; + + struct spdk_io_channel *chan = spdk_bs_alloc_io_channel(ctx->blobstore); + if (chan == NULL) { + spdk_app_stop(0); + return ; + } + ctx->channel = chan; + + spdk_blob_io_write(ctx->blob, ctx->channel, wbuffer, 0, 1, zv2404fs_spdk_blob_write_cb, ctx); +#else + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + file->write_buffer = spdk_malloc(BUFFER_SIZE, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); + if (file->write_buffer == NULL) { + return ; + } + + file->read_buffer = spdk_malloc(BUFFER_SIZE, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); + if (file->read_buffer == NULL) { + return ; + } + + + SPDK_NOTICELOG("open complete\n"); + + file->finished = true; + +#endif +} + + + +static void zv2404fs_spdk_blob_resize_cb(void *arg, int bserrno) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + uint64_t total = spdk_blob_get_num_clusters(file->blob); + file->fs->num_cluster = total; + + SPDK_NOTICELOG("resize blob :%"PRIu64"\n", total); + + spdk_blob_sync_md(file->blob, zv2404fs_spdk_blob_sync_cb, file); + +} + + + +static void zv2404fs_spdk_bs_open_blob_cb(void *arg, struct spdk_blob *blb, int bserrno) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + file->blob = blb; + + uint64_t free_cluster = spdk_bs_free_cluster_count(file->fs->blobstore); // + SPDK_NOTICELOG("free_cluster : %"PRIu64"\n", free_cluster); + file->fs->free_cluster_count = free_cluster; + + spdk_blob_resize(blb, free_cluster, zv2404fs_spdk_blob_resize_cb, file); + +} + + + +static void zv2404fs_spdk_bs_create_blob_cb(void *arg, spdk_blob_id blobid, int bserrno) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + file->blob_id = blobid; + SPDK_NOTICELOG("blobid : %"PRIu64"\n", blobid); + + spdk_bs_open_blob(file->fs->blobstore, blobid, zv2404fs_spdk_bs_open_blob_cb, file); +} + + +static void zv2404fs_do_open(void *arg) { + + zv2404fs_file_t *file = (zv2404fs_file_t *)arg; + + spdk_bs_create_blob(file->fs->blobstore, zv2404fs_spdk_bs_create_blob_cb, file); + +} + +static void zv2404fs_spdk_bs_init_cb(void *arg, struct spdk_blob_store *bs, + int bserrno) { + + zv2404fs_t *fs = (zv2404fs_t*)arg; + + uint64_t io_unit_size = spdk_bs_get_io_unit_size(bs); + SPDK_NOTICELOG("io_unit_size : %"PRIu64"\n", io_unit_size); + + fs->unit_size = io_unit_size; + fs->blobstore = bs; + + fs->channel = spdk_bs_alloc_io_channel(fs->blobstore); + if (fs->channel == NULL) { + return ; + } + + fs->finished = true; + + SPDK_NOTICELOG("mount finished\n"); + + // +} + + + +static void zv2404_spdk_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, + void *event_ctx) { + + SPDK_NOTICELOG("zv2404_spdk_bdev_event_cb\n"); + +} + + + + +static void zv2404fs_do_mount(void *arg) { + + zv2404fs_t *fs = (zv2404fs_t*)arg; + + struct spdk_bs_dev *bs_dev = NULL; + + int rc = spdk_bdev_create_bs_dev_ext("Malloc0", zv2404_spdk_bdev_event_cb, NULL, &bs_dev); + if (rc != 0) { + spdk_app_stop(0); + } + + //int *count = malloc(sizeof(int)); + //*count = 2404; + + spdk_bs_init(bs_dev, NULL, zv2404fs_spdk_bs_init_cb, fs); + + //sleep(10); + SPDK_NOTICELOG("zv2404fs_entry\n"); + +} + + +// filesystem +// load +static int zv2404fs_mount(struct zv2404fs_s *fs) { + + fs->finished = false; + + return waiter(global_thread, zv2404fs_do_mount, fs, &fs->finished); +} + + +// unload +static int zv2404fs_umount(struct zv2404fs_s *fs) { + + fs->finished = false; + + return waiter(global_thread, zv2404fs_do_umount, fs, &fs->finished); +} + + +// file +// open +static int zv2404fs_open(struct zv2404fs_file_s *file) { + + file->finished = false; + + return waiter(global_thread, zv2404fs_do_open, file, &file->finished); + +} + + +// read + +static int zv2404fs_read(struct zv2404fs_file_s *file, uint8_t *buffer, size_t count) { + + file->finished = false; + waiter(global_thread, zv2404fs_do_read, file, &file->finished); + + int len = strlen(file->read_buffer); + memcpy(buffer, file->read_buffer, len); // + + return len; +} + + +// write + +static int zv2404fs_write(struct zv2404fs_file_s *file, const uint8_t *buffer, size_t count) { + + file->finished = false; + + memcpy(file->write_buffer, buffer, count); // count / 512 + + return waiter(global_thread, zv2404fs_do_write, file, &file->finished); +} + +// close +static int zv2404fs_close(struct zv2404fs_file_s *file) { + + file->finished = false; + + return waiter(global_thread, zv2404fs_do_close, file, &file->finished); +} + + +// fd --> file + + +#if 1 + + + // zvfs.json static const char *json_file = "/home/king/share/spdk/examples/5.3.1-zv2404fs/zvfs.json"; @@ -282,7 +490,7 @@ static void zv2404fs_json_load_fn(void *arg) { } -int main(int argc, char *argv[]) { +static int zv2404fs_env_setup(void) { struct spdk_env_opts opts; spdk_env_opts_init(&opts); @@ -305,8 +513,49 @@ int main(int argc, char *argv[]) { waiter(global_thread, zv2404fs_json_load_fn, &done, &done); SPDK_NOTICELOG("json_app_load_done complete\n"); - + return 0; + +} + + +int main(int argc, char *argv[]) { + + if (zv2404fs_env_setup()) { + return -1; + } + + SPDK_NOTICELOG("zv2404fs_env_setup success\n"); + + SPDK_NOTICELOG("\n\n zv2404fs mount start \n\n"); + zv2404fs_t *fs = calloc(1, sizeof(zv2404fs_t)); + zv2404fs_mount(fs); + + SPDK_NOTICELOG("\n\n zv2404fs open start \n\n"); + zv2404fs_file_t *file = calloc(1, sizeof(zv2404fs_file_t)); + file->fs = fs; + zv2404fs_open(file); + + + SPDK_NOTICELOG("\n\n zv2404fs write start \n\n"); + char *buffer = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + zv2404fs_write(file, buffer, strlen(buffer)); + + + SPDK_NOTICELOG("\n\n zv2404fs read start \n\n"); + char rbuffer[BUFFER_SIZE] = {0}; + zv2404fs_read(file, rbuffer, BUFFER_SIZE); + SPDK_NOTICELOG("READ BUFFER: %s\n", rbuffer); + + SPDK_NOTICELOG("\n\n zv2404fs close start \n\n"); + zv2404fs_close(file); + + free(file); + + SPDK_NOTICELOG("\n\n zv2404fs umount start \n\n"); + zv2404fs_umount(fs); + free(fs); + }