finished api(mount,umount,open,write,read,close)

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);
@@ -306,6 +514,47 @@ int main(int argc, char *argv[]) {
 	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);
 	
 }