create/remove file fix, refactoring (88eb5b31) · Commits · hpc / gekkofs

lfs/src/classes/fs_data.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -181,6 +181,10 @@ fuse_ino_t FsData::raise_inode_count(fuse_ino_t count) {
		return FsData::inode_count_;
		}

		bool FsData::is_local_op(const size_t recipient) {
		return recipient == host_id_;
		}

lfs/src/classes/fs_data.hpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -152,6 +152,8 @@ public:
		// Utility member functions

		fuse_ino_t raise_inode_count(fuse_ino_t count);

		bool is_local_op(size_t recipient);
		};

lfs/src/fuse_ops/directory.cpp

+3 −4

Original line number	Diff line number	Diff line
		@@ -30,15 +30,14 @@ void adafs_ll_lookup(fuse_req_t req, fuse_ino_t parent, const char* name) {
		int err;
		fuse_ino_t inode;

		if (ADAFS_DATA->host_size() > 1) { // might be remote
		if (ADAFS_DATA->host_size() > 1) { // multiple node operation
		auto recipient = RPC_DATA->get_rpc_node(RPC_DATA->get_dentry_hashable(parent, name));
		if (recipient == ADAFS_DATA->host_id()) { // local
		if (ADAFS_DATA->is_local_op(recipient)) { // local
		tie(err, inode) = do_lookup(parent, string(name));

		} else { // remote
		err = rpc_send_lookup(recipient, parent, name, inode);
		}
		} else { // local
		} else { // single node operation
		//get inode no first (either from cache or disk) with parent inode and name;; returns <err, inode_of_dentry> pair
		tie(err, inode) = do_lookup(parent, string(name));
		}

lfs/src/fuse_ops/file.cpp

+49 −41

Original line number	Diff line number	Diff line
		@@ -38,15 +38,14 @@ void adafs_ll_getattr(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info* fi)
		struct stat attr{};
		int err;

		if (ADAFS_DATA->host_size() > 1) { // might be remote
		if (ADAFS_DATA->host_size() > 1) { // multiple node operation
		auto recipient = RPC_DATA->get_rpc_node(fmt::FormatInt(ino).str());
		if (recipient == ADAFS_DATA->host_id() \|\| ino == ADAFS_ROOT_INODE) { // local, root inode is locally available
		if (ADAFS_DATA->is_local_op(recipient) \|\| ino == ADAFS_ROOT_INODE) { // local, root inode is locally available
		err = get_attr(attr, ino);

		} else { // remote
		err = rpc_send_get_attr(recipient, ino, attr);
		}
		} else { // local
		} else { // single node operation
		err = get_attr(attr, ino);

		}
		@@ -208,22 +207,33 @@ void adafs_ll_create(fuse_req_t req, fuse_ino_t parent, const char* name, mode_t

		fuse_entry_param fep{};
		int err;
		fuse_ino_t new_inode;
		auto uid = fuse_req_ctx(req)->uid;
		auto gid = fuse_req_ctx(req)->gid;
		auto f_mode = S_IFREG \| mode;

		if (ADAFS_DATA->host_size() > 1) {
		if (ADAFS_DATA->host_size() > 1) { // multiple node operation
		auto recipient = RPC_DATA->get_rpc_node(RPC_DATA->get_dentry_hashable(parent, name));
		if (recipient == ADAFS_DATA->host_id()) { // local
		// XXX check permissions (omittable), should create node be atomic?
		err = create_node(fep, parent, string(name), uid, gid, f_mode);
		} else { // remote
		fuse_ino_t new_inode;
		if (ADAFS_DATA->is_local_op(recipient)) { // local dentry create
		new_inode = Util::generate_inode_no();
		err = create_dentry(parent, new_inode, name, mode);
		} else { // remote dentry create
		err = rpc_send_create_dentry(recipient, parent, name, f_mode, new_inode);
		if (err == 0) {
		}
		if (err != 0) { // failure in dentry creation
		fuse_reply_err(req, err);
		ADAFS_DATA->spdlogger()->error("Failed to create a dentry");
		return;
		}
		// calculate recipient again for new inode because it could hash somewhere else
		recipient = RPC_DATA->get_rpc_node(fmt::FormatInt(new_inode).str());
		if (ADAFS_DATA->is_local_op(recipient)) { // local metadata init
		err = init_metadata_fep(fep, new_inode, uid, gid, mode);
		} else { // remote metadata init
		err = rpc_send_create_mdata(recipient, uid, gid, f_mode, new_inode);
		if (err == 0) {
		// Because we don't want to return the metadata init values through the RPC
		// we just set dummy values here with the most important bits
		fep.ino = new_inode;
		fep.attr.st_ino = new_inode;
		fep.attr.st_mode = mode;
		@@ -236,14 +246,11 @@ void adafs_ll_create(fuse_req_t req, fuse_ino_t parent, const char* name, mode_t
		fep.attr_timeout = 1.0;
		}
		}

		}
		} else { // local
		} else { //local single node operation
		// XXX check permissions (omittable), should create node be atomic?
		err = create_node(fep, parent, string(name), uid, gid, f_mode);
		}


		// XXX create chunk space
		if (err == 0)
		fuse_reply_create(req, &fep, fi);
		@@ -312,25 +319,26 @@ void adafs_ll_unlink(fuse_req_t req, fuse_ino_t parent, const char* name) {
		fuse_ino_t del_inode;
		int err;

		if (ADAFS_DATA->host_size() > 1) {
		if (ADAFS_DATA->host_size() > 1) { // multiple node operation
		auto recipient = RPC_DATA->get_rpc_node(RPC_DATA->get_dentry_hashable(parent, name));
		if (recipient == ADAFS_DATA->host_id()) { // local
		if (ADAFS_DATA->is_local_op(recipient)) { // local dentry removal
		// Remove denty returns <err, inode_of_dentry> pair
		tie(err, del_inode) = remove_dentry(parent, name);
		} else { // remote dentry removal
		err = rpc_send_remove_dentry(recipient, parent, name, del_inode);
		}
		if (err != 0) {
		fuse_reply_err(req, err);
		return;
		}
		// Remove inode
		err = remove_all_metadata(del_inode);
		} else { // remote
		err = rpc_send_remove_dentry(recipient, parent, name, del_inode);
		if (err == 0) {
		// recalculate recipient for metadata removal
		recipient = RPC_DATA->get_rpc_node(fmt::FormatInt(del_inode).str());
		if (ADAFS_DATA->is_local_op(recipient)) { // local metadata removal
		err = remove_all_metadata(del_inode);
		} else { // remote metadata removal
		err = rpc_send_remove_mdata(recipient, del_inode);
		}
		}
		} else { // local
		} else { // single node local operation
		// Remove denty returns <err, inode_of_dentry> pair
		tie(err, del_inode) = remove_dentry(parent, name);
		if (err != 0) {

lfs/src/rpc/client/c_dentry.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -53,7 +53,7 @@ int rpc_send_lookup(const size_t recipient, const fuse_ino_t parent, const char*
		HG_Destroy(handle);

		if (inode == INVALID_INODE)
		err = 1;
		err = ENOENT;
		return err;
		}