blobfs/fuse: put FUSE code in module blobfs_bdev (4c10e0bb) · Commits · Public Repositories / spdk

CHANGELOG.md

+4 −0

Original line number	Diff line number	Diff line
		@@ -81,6 +81,10 @@ Function spdk_blobfs_bdev_detect is added to detect whether blobfs exists on the

		Function spdk_blobfs_bdev_create is added to create a blobfs on the given block device.

		Function spdk_blobfs_bdev_mount is added to mount a blobfs on the given block device to
		a host path by FUSE. Then, a new thread is created dedicatedly for one mountpoint to handle
		FUSE request by blobfs API.

		### build

		Option to build FUSE components into blobfs_bdev module for mounting a blobfs filesystem.

include/spdk/blobfs_bdev.h

+17 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@

		#include "spdk/stdinc.h"
		#include "spdk/bdev.h"
		#include "spdk/config.h"

		#ifdef __cplusplus
		extern "C" {
		@@ -74,6 +75,22 @@ void spdk_blobfs_bdev_detect(const char *bdev_name,
		void spdk_blobfs_bdev_create(const char *bdev_name, uint32_t cluster_sz,
		spdk_blobfs_bdev_op_complete cb_fn, void *cb_arg);

		#ifdef SPDK_CONFIG_FUSE
		/**
		* Mount a blobfs on given device to a host path by FUSE
		*
		* A new thread is created dedicatedly for one mountpoint to handle FUSE request
		* by blobfs API.
		*
		* \param bdev_name Name of block device.
		* \param mountpoint Host path to mount blobfs.
		* \param cb_fn Called when mount operation is complete. fserrno is -EILSEQ if no blobfs exists.
		* \param cb_arg Argument passed to function cb_fn.
		*/
		void spdk_blobfs_bdev_mount(const char bdev_name, const char mountpoint,
		spdk_blobfs_bdev_op_complete cb_fn, void *cb_arg);
		#endif

		#ifdef __cplusplus
		}
		#endif

module/blobfs/bdev/Makefile

+6 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,12 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
		include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

		C_SRCS = blobfs_bdev.c blobfs_bdev_rpc.c

		# libfuse3 is required by blobfs_fuse.c
		ifeq ($(CONFIG_FUSE),y)
		C_SRCS += blobfs_fuse.c
		endif

		LIBNAME = blobfs_bdev

		include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk

module/blobfs/bdev/blobfs_bdev.c

+148 −1

Original line number	Diff line number	Diff line
		@@ -45,6 +45,8 @@

		#include "spdk_internal/log.h"

		#include "blobfs_fuse.h"

		/* Dummy bdev module used to to claim bdevs. */
		static struct spdk_bdev_module blobfs_bdev_module = {
		.name = "blobfs",
		@@ -61,8 +63,21 @@ struct blobfs_bdev_operation_ctx {
		const char *bdev_name;
		struct spdk_filesystem *fs;

		/* If cb_fn is already called in other function, not _blobfs_bdev_unload_cb.
		* cb_fn should be set NULL after its being called, in order to avoid repeated
		* calling in _blobfs_bdev_unload_cb.
		*/
		spdk_blobfs_bdev_op_complete cb_fn;
		void *cb_arg;

		/* Variables for mount operation */
		const char *mountpoint;
		struct spdk_thread *fs_loading_thread;

		/* Used in bdev_event_cb to do some proper operations on blobfs_fuse for
		* asynchronous event of the backend bdev.
		*/
		struct spdk_blobfs_fuse *bfuse;
		};

		static void
		@@ -74,7 +89,10 @@ _blobfs_bdev_unload_cb(void *_ctx, int fserrno)
		SPDK_ERRLOG("Failed to unload blobfs on bdev %s: errno %d\n", ctx->bdev_name, fserrno);
		}

		if (ctx->cb_fn) {
		ctx->cb_fn(ctx->cb_arg, fserrno);
		}

		free(ctx);
		}

		@@ -209,3 +227,132 @@ invalid:

		cb_fn(cb_arg, rc);
		}

		#ifdef SPDK_CONFIG_FUSE

		static void
		blobfs_bdev_unmount(void *arg)
		{
		struct blobfs_bdev_operation_ctx *ctx = arg;

		/* Keep blobfs unloaded in a same spdk thread with spdk_fs_load */
		spdk_thread_send_msg(ctx->fs_loading_thread, blobfs_bdev_unload, ctx);
		}

		static void
		_blobfs_bdev_mount_fuse_start(void *_ctx)
		{
		struct blobfs_bdev_operation_ctx *ctx = _ctx;
		spdk_blobfs_bdev_op_complete cb_fn = ctx->cb_fn;
		int rc;

		/* Since function of ctx->cb_fn will be called in this function, set
		* ctx->cb_fn to be NULL, in order to avoid repeated calling in unload_cb.
		*/
		ctx->cb_fn = NULL;

		rc = spdk_blobfs_fuse_start(ctx->bdev_name, ctx->mountpoint, ctx->fs,
		blobfs_bdev_unmount, ctx, &ctx->bfuse);
		if (rc != 0) {
		SPDK_ERRLOG("Failed to mount blobfs on bdev %s to %s\n", ctx->bdev_name, ctx->mountpoint);

		/* Return failure state back */
		cb_fn(ctx->cb_arg, rc);

		blobfs_bdev_unmount(ctx);

		return;
		}

		cb_fn(ctx->cb_arg, 0);
		}

		static void
		_blobfs_bdev_mount_load_cb(void _ctx, struct spdk_filesystem fs, int fserrno)
		{
		struct blobfs_bdev_operation_ctx *ctx = _ctx;

		if (fserrno) {
		SPDK_ERRLOG("Failed to load blobfs on bdev %s: errno %d\n", ctx->bdev_name, fserrno);

		ctx->cb_fn(ctx->cb_arg, fserrno);
		free(ctx);
		return;
		}

		ctx->fs = fs;
		ctx->fs_loading_thread = spdk_get_thread();

		spdk_thread_send_msg(spdk_get_thread(), _blobfs_bdev_mount_fuse_start, ctx);
		}

		static void
		blobfs_bdev_fuse_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
		void *event_ctx)
		{
		struct blobfs_bdev_operation_ctx *ctx = event_ctx;

		SPDK_WARNLOG("Async event(%d) is triggered in bdev %s\n", type, spdk_bdev_get_name(bdev));

		if (type == SPDK_BDEV_EVENT_REMOVE) {
		spdk_blobfs_fuse_stop(ctx->bfuse);
		}
		}

		void
		spdk_blobfs_bdev_mount(const char bdev_name, const char mountpoint,
		spdk_blobfs_bdev_op_complete cb_fn, void *cb_arg)
		{
		struct blobfs_bdev_operation_ctx *ctx;
		struct spdk_bs_dev *bs_dev;
		struct spdk_bdev_desc *desc;
		int rc;

		ctx = calloc(1, sizeof(*ctx));
		if (ctx == NULL) {
		SPDK_ERRLOG("Failed to allocate ctx.\n");
		cb_fn(cb_arg, -ENOMEM);

		return;
		}

		ctx->bdev_name = bdev_name;
		ctx->mountpoint = mountpoint;
		ctx->cb_fn = cb_fn;
		ctx->cb_arg = cb_arg;

		rc = spdk_bdev_open_ext(bdev_name, true, blobfs_bdev_fuse_event_cb, ctx, &desc);
		if (rc != 0) {
		SPDK_INFOLOG(SPDK_LOG_BLOBFS, "Failed to open bdev(%s): %s\n", ctx->bdev_name, spdk_strerror(rc));

		goto invalid;
		}

		bs_dev = spdk_bdev_create_bs_dev_from_desc(desc);
		if (bs_dev == NULL) {
		SPDK_INFOLOG(SPDK_LOG_BLOBFS, "Failed to create a blobstore block device from bdev desc");
		rc = -ENOMEM;
		spdk_bdev_close(desc);

		goto invalid;
		}

		rc = spdk_bs_bdev_claim(bs_dev, &blobfs_bdev_module);
		if (rc != 0) {
		SPDK_INFOLOG(SPDK_LOG_BLOBFS, "Blobfs base bdev already claimed by another bdev\n");
		bs_dev->destroy(bs_dev);

		goto invalid;
		}

		spdk_fs_load(bs_dev, spdk_blobfs_fuse_send_request, _blobfs_bdev_mount_load_cb, ctx);

		return;

		invalid:
		free(ctx);

		cb_fn(cb_arg, rc);
		}

		#endif

module/blobfs/bdev/blobfs_fuse.c

0 → 100644

+358 −0

Original line number	Diff line number	Diff line
		/*-
		* BSD LICENSE
		*
		* Copyright (c) Intel Corporation.
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		* * Neither the name of Intel Corporation nor the names of its
		* contributors may be used to endorse or promote products derived
		* from this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/

		#include "spdk/stdinc.h"

		#include "spdk/log.h"
		#include "spdk/env.h"
		#include "spdk/event.h"
		#include "spdk/thread.h"
		#include "spdk/string.h"
		#include "spdk/blobfs.h"

		#include "blobfs_fuse.h"

		#define FUSE_USE_VERSION 30
		#include "fuse3/fuse.h"
		#include "fuse3/fuse_lowlevel.h"

		struct spdk_blobfs_fuse {
		char *bdev_name;
		char *mountpoint;
		struct spdk_fs_thread_ctx *channel;
		struct spdk_filesystem *fs;

		struct fuse *fuse_handle;
		pthread_t fuse_tid;

		blobfs_fuse_unmount_cb cb_fn;
		void *cb_arg;
		};

		/* Each thread serves one blobfs */
		static __thread struct spdk_blobfs_fuse *thd_bfuse;

		static void
		blobfs_fuse_free(struct spdk_blobfs_fuse *bfuse)
		{
		if (bfuse == NULL) {
		return;
		}

		free(bfuse->bdev_name);
		free(bfuse->mountpoint);
		free(bfuse);
		}

		static void
		__call_fn(void arg1, void arg2)
		{
		fs_request_fn fn;

		fn = (fs_request_fn)arg1;
		fn(arg2);
		}

		void
		spdk_blobfs_fuse_send_request(fs_request_fn fn, void *arg)
		{
		struct spdk_event *event;

		event = spdk_event_allocate(0, __call_fn, (void *)fn, arg);
		spdk_event_call(event);
		}

		static int
		spdk_fuse_getattr(const char path, struct stat stbuf, struct fuse_file_info *fi)
		{
		struct spdk_file_stat stat;
		int rc;

		if (!strcmp(path, "/")) {
		stbuf->st_mode = S_IFDIR \| 0755;
		stbuf->st_nlink = 2;
		return 0;
		}

		rc = spdk_fs_file_stat(thd_bfuse->fs, thd_bfuse->channel, path, &stat);
		if (rc == 0) {
		stbuf->st_mode = S_IFREG \| 0644;
		stbuf->st_nlink = 1;
		stbuf->st_size = stat.size;
		}

		return rc;
		}

		static int
		spdk_fuse_readdir(const char path, void buf, fuse_fill_dir_t filler,
		off_t offset, struct fuse_file_info *fi,
		enum fuse_readdir_flags flags)
		{
		struct spdk_file *file;
		const char *filename;
		spdk_fs_iter iter;

		filler(buf, ".", NULL, 0, 0);
		filler(buf, "..", NULL, 0, 0);

		iter = spdk_fs_iter_first(thd_bfuse->fs);
		while (iter != NULL) {
		file = spdk_fs_iter_get_file(iter);
		iter = spdk_fs_iter_next(iter);
		filename = spdk_file_get_name(file);
		filler(buf, &filename[1], NULL, 0, 0);
		}

		return 0;
		}

		static int
		spdk_fuse_mknod(const char *path, mode_t mode, dev_t rdev)
		{
		return spdk_fs_create_file(thd_bfuse->fs, thd_bfuse->channel, path);
		}

		static int
		spdk_fuse_unlink(const char *path)
		{
		return spdk_fs_delete_file(thd_bfuse->fs, thd_bfuse->channel, path);
		}

		static int
		spdk_fuse_truncate(const char path, off_t size, struct fuse_file_info fi)
		{
		struct spdk_file *file;
		int rc;

		rc = spdk_fs_open_file(thd_bfuse->fs, thd_bfuse->channel, path, 0, &file);
		if (rc != 0) {
		return -rc;
		}

		rc = spdk_file_truncate(file, thd_bfuse->channel, size);
		if (rc != 0) {
		return -rc;
		}

		spdk_file_close(file, thd_bfuse->channel);

		return 0;
		}

		static int
		spdk_fuse_utimens(const char path, const struct timespec tv[2], struct fuse_file_info fi)
		{
		return 0;
		}

		static int
		spdk_fuse_open(const char path, struct fuse_file_info info)
		{
		struct spdk_file *file;
		int rc;

		rc = spdk_fs_open_file(thd_bfuse->fs, thd_bfuse->channel, path, 0, &file);
		if (rc != 0) {
		return -rc;
		}

		info->fh = (uintptr_t)file;
		return 0;
		}

		static int
		spdk_fuse_release(const char path, struct fuse_file_info info)
		{
		struct spdk_file file = (struct spdk_file )info->fh;

		return spdk_file_close(file, thd_bfuse->channel);
		}

		static int
		spdk_fuse_read(const char path, char buf, size_t len, off_t offset, struct fuse_file_info *info)
		{
		struct spdk_file file = (struct spdk_file )info->fh;

		return spdk_file_read(file, thd_bfuse->channel, buf, offset, len);
		}

		static int
		spdk_fuse_write(const char path, const char buf, size_t len, off_t offset,
		struct fuse_file_info *info)
		{
		struct spdk_file file = (struct spdk_file )info->fh;
		int rc;

		rc = spdk_file_write(file, thd_bfuse->channel, (void *)buf, offset, len);
		if (rc == 0) {
		return len;
		} else {
		return rc;
		}
		}

		static int
		spdk_fuse_flush(const char path, struct fuse_file_info info)
		{
		return 0;
		}

		static int
		spdk_fuse_fsync(const char path, int datasync, struct fuse_file_info info)
		{
		return 0;
		}

		static int
		spdk_fuse_rename(const char old_path, const char new_path, unsigned int flags)
		{
		return spdk_fs_rename_file(thd_bfuse->fs, thd_bfuse->channel, old_path, new_path);
		}

		static struct fuse_operations spdk_fuse_oper = {
		.getattr = spdk_fuse_getattr,
		.readdir = spdk_fuse_readdir,
		.mknod = spdk_fuse_mknod,
		.unlink = spdk_fuse_unlink,
		.truncate = spdk_fuse_truncate,
		.utimens = spdk_fuse_utimens,
		.open = spdk_fuse_open,
		.release = spdk_fuse_release,
		.read = spdk_fuse_read,
		.write = spdk_fuse_write,
		.flush = spdk_fuse_flush,
		.fsync = spdk_fuse_fsync,
		.rename = spdk_fuse_rename,
		};

		static void *
		fuse_loop_new_thread(void *arg)
		{
		struct spdk_blobfs_fuse *bfuse = arg;

		spdk_unaffinitize_thread();

		thd_bfuse = bfuse;
		SPDK_NOTICELOG("Start to loop blobfs on bdev %s mounted at %s\n", bfuse->bdev_name,
		bfuse->mountpoint);

		bfuse->channel = spdk_fs_alloc_thread_ctx(bfuse->fs);

		fuse_loop(bfuse->fuse_handle);
		fuse_unmount(bfuse->fuse_handle);
		fuse_destroy(bfuse->fuse_handle);
		SPDK_NOTICELOG("Blobfs on bdev %s unmounted from %s\n", bfuse->bdev_name, bfuse->mountpoint);

		spdk_fs_free_thread_ctx(bfuse->channel);

		bfuse->cb_fn(bfuse->cb_arg);

		blobfs_fuse_free(bfuse);

		pthread_exit(NULL);
		}

		int
		spdk_blobfs_fuse_start(const char bdev_name, const char mountpoint, struct spdk_filesystem *fs,
		blobfs_fuse_unmount_cb cb_fn, void cb_arg, struct spdk_blobfs_fuse *_bfuse)
		{
		/* Set argv[1] as bdev_name in order to show bdev_name as the mounting source */
		char argv[1] = {(char )bdev_name};
		struct fuse_args args = FUSE_ARGS_INIT(1, argv);
		struct fuse_cmdline_opts opts = {};
		struct fuse *fuse_handle;
		struct spdk_blobfs_fuse *bfuse;
		pthread_t tid;
		int rc;

		bfuse = (struct spdk_blobfs_fuse )calloc(1, sizeof(bfuse));
		if (bfuse == NULL) {
		return -ENOMEM;
		}

		rc = fuse_parse_cmdline(&args, &opts);
		assert(rc == 0);

		bfuse->bdev_name = strdup(bdev_name);
		bfuse->mountpoint = strdup(mountpoint);
		bfuse->fs = fs;
		bfuse->cb_fn = cb_fn;
		bfuse->cb_arg = cb_arg;

		fuse_handle = fuse_new(&args, &spdk_fuse_oper, sizeof(spdk_fuse_oper), NULL);
		fuse_opt_free_args(&args);
		if (fuse_handle == NULL) {
		SPDK_ERRLOG("could not create fuse handle!\n");
		rc = -1;
		goto err;
		}
		bfuse->fuse_handle = fuse_handle;

		rc = fuse_mount(bfuse->fuse_handle, bfuse->mountpoint);
		if (rc != 0) {
		SPDK_ERRLOG("could not mount fuse handle\n");
		rc = -1;
		goto err;
		}

		rc = pthread_create(&tid, NULL, fuse_loop_new_thread, bfuse);
		if (rc != 0) {
		SPDK_ERRLOG("could not create thread: %s\n", spdk_strerror(rc));
		rc = -rc;
		goto err;
		}
		bfuse->fuse_tid = tid;

		rc = pthread_detach(tid);
		if (rc != 0) {
		SPDK_ERRLOG("could not detach thread for fuse loop thread: %s\n", spdk_strerror(rc));
		rc = -rc;
		goto err;
		}

		*_bfuse = bfuse;
		return 0;

		err:
		blobfs_fuse_free(bfuse);

		return rc;
		}

		void
		spdk_blobfs_fuse_stop(struct spdk_blobfs_fuse *bfuse)
		{
		fuse_session_exit(fuse_get_session(bfuse->fuse_handle));
		pthread_kill(bfuse->fuse_tid, SIGINT);
		}