Client: Removing shared metadata pointers from gkfs functions (b45e4f15) · Commits · David Auer / gekkofs

include/client/preload_util.hpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -55,7 +55,7 @@ to_underlying(E e) {
	return static_cast<typename std::underlying_type<E>::type>(e);		return static_cast<typename std::underlying_type<E>::type>(e);
	}		}

	std::shared_ptr<gkfs::metadata::Metadata>		std::optional<gkfs::metadata::Metadata>
	get_metadata(const std::string& path, bool follow_links = false);		get_metadata(const std::string& path, bool follow_links = false);

	int		int

src/client/gkfs_functions.cpp

+40 −31

Original line number	Original line	Diff line number	Diff line
	@@ -128,8 +128,8 @@ gkfs_open(const std::string& path, mode_t mode, int flags) {
	errno = ENOTSUP;		errno = ENOTSUP;
	return -1;		return -1;
	}		}
	// metadata pointer assigned during create or stat		// metadata object filled during create or stat
	std::shared_ptr<gkfs::metadata::Metadata> md = nullptr;		gkfs::metadata::Metadata md{};
	if(flags & O_CREAT) {		if(flags & O_CREAT) {
	if(flags & O_DIRECTORY) {		if(flags & O_DIRECTORY) {
	LOG(ERROR, "O_DIRECTORY use with O_CREAT. NOT SUPPORTED");		LOG(ERROR, "O_DIRECTORY use with O_CREAT. NOT SUPPORTED");
	@@ -149,7 +149,14 @@ gkfs_open(const std::string& path, mode_t mode, int flags) {
	}		}
	// file exists, O_CREAT was set O_EXCL wasnt, so function does		// file exists, O_CREAT was set O_EXCL wasnt, so function does
	// not fail this case is actually undefined as per `man 2 open`		// not fail this case is actually undefined as per `man 2 open`
	md = gkfs::util::get_metadata(path);		auto md_ = gkfs::util::get_metadata(path);
			if(!md_) {
			LOG(ERROR,
			"Could not get metadata after creating file '{}': '{}'",
			path, strerror(errno));
			return -1;
			}
			md = md_.value();
	} else {		} else {
	LOG(ERROR, "Error creating file: '{}'", strerror(errno));		LOG(ERROR, "Error creating file: '{}'", strerror(errno));
	return -1;		return -1;
	@@ -160,40 +167,40 @@ gkfs_open(const std::string& path, mode_t mode, int flags) {
	std::make_shared<gkfs::filemap::OpenFile>(path, flags));		std::make_shared<gkfs::filemap::OpenFile>(path, flags));
	}		}
	} else {		} else {
	md = gkfs::util::get_metadata(path);		auto md_ = gkfs::util::get_metadata(path);
	if(!md) {		if(!md_) {
	if(errno == ENOENT) {		if(errno == ENOENT) {
	// file doesn't exists and O_CREAT was not set		// file doesn't exists and O_CREAT was not set
	return -1;		return -1;
	} else {		} else {
	LOG(ERROR, "Error stating existing file");		LOG(ERROR, "Error stating existing file '{}'", path);
	return -1;		return -1;
	}		}
	}		}
			md = md_.value();
	}		}
	assert(md);

	#ifdef HAS_SYMLINKS		#ifdef HAS_SYMLINKS
	if(md->is_link()) {		if(md.is_link()) {
	if(flags & O_NOFOLLOW) {		if(flags & O_NOFOLLOW) {
	LOG(WARNING, "Symlink found and O_NOFOLLOW flag was specified");		LOG(WARNING, "Symlink found and O_NOFOLLOW flag was specified");
	errno = ELOOP;		errno = ELOOP;
	return -1;		return -1;
	}		}
	return gkfs_open(md->target_path(), mode, flags);		return gkfs_open(md.target_path(), mode, flags);
	}		}
	#endif		#endif

	if(S_ISDIR(md->mode())) {		if(S_ISDIR(md.mode())) {
	return gkfs_opendir(path);		return gkfs_opendir(path);
	}		}


	/* Regular file exists */		/* Regular file exists */
	assert(S_ISREG(md->mode()));		assert(S_ISREG(md.mode()));

	if((flags & O_TRUNC) && ((flags & O_RDWR) \|\| (flags & O_WRONLY))) {		if((flags & O_TRUNC) && ((flags & O_RDWR) \|\| (flags & O_WRONLY))) {
	if(gkfs_truncate(path, md->size(), 0)) {		if(gkfs_truncate(path, md.size(), 0)) {
	LOG(ERROR, "Error truncating file");		LOG(ERROR, "Error truncating file");
	return -1;		return -1;
	}		}
	@@ -257,8 +264,10 @@ gkfs_remove(const std::string& path) {
	if(!md) {		if(!md) {
	return -1;		return -1;
	}		}
	bool has_data = S_ISREG(md->mode()) && (md->size() != 0);		gkfs::metadata::Metadata md{attr.value()};
	auto err = gkfs::rpc::forward_remove(path, !has_data, md->size());
			bool has_data = S_ISREG(md.mode()) && (md.size() != 0);
			auto err = gkfs::rpc::forward_remove(path, !has_data, md.size());
	if(err) {		if(err) {
	errno = err;		errno = err;
	return -1;		return -1;
	@@ -278,7 +287,6 @@ int
	gkfs_access(const std::string& path, const int mask, bool follow_links) {		gkfs_access(const std::string& path, const int mask, bool follow_links) {
	auto md = gkfs::util::get_metadata(path, follow_links);		auto md = gkfs::util::get_metadata(path, follow_links);
	if(!md) {		if(!md) {
	errno = ENOENT;
	return -1;		return -1;
	}		}
	return 0;		return 0;
	@@ -298,7 +306,7 @@ gkfs_stat(const string& path, struct stat* buf, bool follow_links) {
	if(!md) {		if(!md) {
	return -1;		return -1;
	}		}
	gkfs::util::metadata_to_stat(path, md, buf);		gkfs::util::metadata_to_stat(path, md.value(), *buf);
	return 0;		return 0;
	}		}

	@@ -325,7 +333,7 @@ gkfs_statx(int dirfs, const std::string& path, int flags, unsigned int mask,

	struct stat tmp {};		struct stat tmp {};

	gkfs::util::metadata_to_stat(path, *md, tmp);		gkfs::util::metadata_to_stat(path, md.value(), tmp);

	buf->stx_mask = 0;		buf->stx_mask = 0;
	buf->stx_blksize = tmp.st_blksize;		buf->stx_blksize = tmp.st_blksize;
	@@ -549,7 +557,8 @@ gkfs_truncate(const std::string& path, off_t length) {
	if(!md) {		if(!md) {
	return -1;		return -1;
	}		}
	auto size = md->size();
			auto size = md.value().size();
	if(static_cast<unsigned long>(length) > size) {		if(static_cast<unsigned long>(length) > size) {
	LOG(DEBUG, "Length is greater then file size: {} > {}", length, size);		LOG(DEBUG, "Length is greater then file size: {} > {}", length, size);
	errno = EINVAL;		errno = EINVAL;
	@@ -862,12 +871,12 @@ gkfs_pread_ws(int fd, void* buf, size_t count, off64_t offset) {
	*/		*/
	int		int
	gkfs_opendir(const std::string& path) {		gkfs_opendir(const std::string& path) {

	auto md = gkfs::util::get_metadata(path);		auto md = gkfs::util::get_metadata(path);
	if(!md) {		if(!md) {
	return -1;		return -1;
	}		}
	if(!S_ISDIR(md->mode())) {
			if(!S_ISDIR(md.value().mode())) {
	LOG(DEBUG, "Path is not a directory");		LOG(DEBUG, "Path is not a directory");
	errno = ENOTDIR;		errno = ENOTDIR;
	return -1;		return -1;
	@@ -893,11 +902,10 @@ int
	gkfs_rmdir(const std::string& path) {		gkfs_rmdir(const std::string& path) {
	auto md = gkfs::util::get_metadata(path);		auto md = gkfs::util::get_metadata(path);
	if(!md) {		if(!md) {
	LOG(DEBUG, "Path '{}' does not exist: ", path);		LOG(DEBUG, "Error: Path '{}' err code '{}' ", path, strerror(errno));
	errno = ENOENT;
	return -1;		return -1;
	}		}
	if(!S_ISDIR(md->mode())) {		if(!S_ISDIR(md.value().mode())) {
	LOG(DEBUG, "Path '{}' is not a directory", path);		LOG(DEBUG, "Path '{}' is not a directory", path);
	errno = ENOTDIR;		errno = ENOTDIR;
	return -1;		return -1;
	@@ -1089,8 +1097,8 @@ gkfs_mk_symlink(const std::string& path, const std::string& target_path) {
	* So that application know we don't support link to directory.		* So that application know we don't support link to directory.
	*/		*/
	auto target_md = gkfs::util::get_metadata(target_path, false);		auto target_md = gkfs::util::get_metadata(target_path, false);
	if(target_md != nullptr) {		if(target_md) {
	auto trg_mode = target_md->mode();		auto trg_mode = target_md.value().mode();
	if(!(S_ISREG(trg_mode) \|\| S_ISLNK(trg_mode))) {		if(!(S_ISREG(trg_mode) \|\| S_ISLNK(trg_mode))) {
	assert(S_ISDIR(trg_mode));		assert(S_ISDIR(trg_mode));
	LOG(DEBUG, "Target path is a directory. Not supported");		LOG(DEBUG, "Target path is a directory. Not supported");
	@@ -1104,11 +1112,12 @@ gkfs_mk_symlink(const std::string& path, const std::string& target_path) {
	}		}

	auto link_md = gkfs::util::get_metadata(path, false);		auto link_md = gkfs::util::get_metadata(path, false);
	if(link_md != nullptr) {		if(link_md) {
	LOG(DEBUG, "Link exists: '{}'", path);		LOG(DEBUG, "Link exists: '{}'", path);
	errno = EEXIST;		errno = EEXIST;
	return -1;		return -1;
	}		}

	auto err = gkfs::rpc::forward_mk_symlink(path, target_path);		auto err = gkfs::rpc::forward_mk_symlink(path, target_path);
	if(err) {		if(err) {
	errno = err;		errno = err;
	@@ -1131,25 +1140,25 @@ gkfs_mk_symlink(const std::string& path, const std::string& target_path) {
	int		int
	gkfs_readlink(const std::string& path, char* buf, int bufsize) {		gkfs_readlink(const std::string& path, char* buf, int bufsize) {
	auto md = gkfs::util::get_metadata(path, false);		auto md = gkfs::util::get_metadata(path, false);
	if(md == nullptr) {		if(!md) {
	LOG(DEBUG, "Named link doesn't exist");		LOG(DEBUG, "Named link doesn't exist");
	return -1;		return -1;
	}		}
	if(!(md->is_link())) {		if(!(md.value().is_link())) {
	LOG(DEBUG, "The named file is not a symbolic link");		LOG(DEBUG, "The named file is not a symbolic link");
	errno = EINVAL;		errno = EINVAL;
	return -1;		return -1;
	}		}
	int path_size = md->target_path().size() + CTX->mountdir().size();		int path_size = md.value().target_path().size() + CTX->mountdir().size();
	if(path_size >= bufsize) {		if(path_size >= bufsize) {
	LOG(WARNING, "Destination buffer size is too short: {} < {}, {} ",		LOG(WARNING, "Destination buffer size is too short: {} < {}, {} ",
	bufsize, path_size, md->target_path());		bufsize, path_size, md.value().target_path());
	errno = ENAMETOOLONG;		errno = ENAMETOOLONG;
	return -1;		return -1;
	}		}

	CTX->mountdir().copy(buf, CTX->mountdir().size());		CTX->mountdir().copy(buf, CTX->mountdir().size());
	std::strcpy(buf + CTX->mountdir().size(), md->target_path().c_str());		std::strcpy(buf + CTX->mountdir().size(), md.value().target_path().c_str());
	return path_size;		return path_size;
	}		}

src/client/hooks.cpp

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -615,11 +615,12 @@ hook_chdir(const char* path) {
	if(internal) {		if(internal) {
	// path falls in our namespace		// path falls in our namespace
	auto md = gkfs::util::get_metadata(rel_path);		auto md = gkfs::util::get_metadata(rel_path);
	if(md == nullptr) {		if(!md) {
	LOG(ERROR, "{}() path does not exists", __func__);		LOG(ERROR, "{}() path {} errno {}", __func__, path, errno);
	return -ENOENT;		return -errno;
	}		}
	if(!S_ISDIR(md->mode())) {
			if(!S_ISDIR(md.value().mode())) {
	LOG(ERROR, "{}() path is not a directory", __func__);		LOG(ERROR, "{}() path is not a directory", __func__);
	return -ENOTDIR;		return -ENOTDIR;
	}		}

src/client/preload_util.cpp

+8 −6

Original line number	Original line	Diff line number	Diff line
	@@ -165,20 +165,21 @@ load_hostfile(const std::string& path) {

	namespace gkfs::util {		namespace gkfs::util {


	/**		/**
	* Retrieve metadata from daemon		* Retrieve metadata from daemon and return Metadata object
	* errno may be set		* errno may be set
	* @param path		* @param path
	* @param follow_links		* @param follow_links
	* @return shared_ptr for metadata, nullptr else		* @return Metadata
	*/		*/
	std::shared_ptr<gkfs::metadata::Metadata>		optional<gkfs::metadata::Metadata>
	get_metadata(const string& path, bool follow_links) {		get_metadata(const string& path, bool follow_links) {
	std::string attr;		std::string attr;
	auto err = gkfs::rpc::forward_stat(path, attr);		auto err = gkfs::rpc::forward_stat(path, attr);
	if(err) {		if(err) {
	errno = err;		errno = err;
	return nullptr;		return {};
	}		}
	#ifdef HAS_SYMLINKS		#ifdef HAS_SYMLINKS
	if(follow_links) {		if(follow_links) {
	@@ -187,15 +188,16 @@ get_metadata(const string& path, bool follow_links) {
	err = gkfs::rpc::forward_stat(md.target_path(), attr);		err = gkfs::rpc::forward_stat(md.target_path(), attr);
	if(err) {		if(err) {
	errno = err;		errno = err;
	return nullptr;		return {};
	}		}
	md = gkfs::metadata::Metadata{attr};		md = gkfs::metadata::Metadata{attr};
	}		}
	}		}
	#endif		#endif
	return make_shared<gkfs::metadata::Metadata>(attr);		return gkfs::metadata::Metadata{attr};
	}		}


	/**		/**
	* Converts the Metadata object into a stat struct, which is needed by Linux		* Converts the Metadata object into a stat struct, which is needed by Linux
	* @param path		* @param path