Commit 858d9f30 authored by Ramon Nou's avatar Ramon Nou
Browse files

2 RPC to 1 RPC metadata write

parent 164757f5

include/client/open_file_map.hpp

+9 −0
Original line number Diff line number Diff line
@@ -61,6 +61,8 @@ enum class OpenFile_flags { 
    wronly,

    rdwr,

    cloexec,

    created,          // indicates if the file was created during open

    creation_pending, // indicates if the file creation is delayed

    flag_count // this is purely used as a size variable of this enum class

};
@@ -75,6 +77,7 @@ protected: 
    unsigned long pos_;

    std::mutex pos_mutex_;

    std::mutex flag_mutex_;

    mode_t mode_;



public:

    // multiple threads may want to update the file position if fd has been
@@ -106,6 +109,12 @@ public: 


    FileType

    type() const;



    mode_t

    mode() const;



    void

    mode(mode_t mode_);

};

include/client/rpc/forward_metadata.hpp

+6 −0
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ 
#include <string>

#include <memory>

#include <vector>

#include <cstdint>

/* Forward declaration */

namespace gkfs {

namespace filemap {
@@ -62,6 +63,11 @@ namespace rpc { 
int

forward_create(const std::string& path, mode_t mode, const int copy);



int

forward_create_write_inline(const std::string& path, mode_t mode,

                            const std::string& data, uint64_t count,

                            const int copy);



int

forward_stat(const std::string& path, std::string& attr, const int copy);

include/client/rpc/rpc_types.hpp

+137 −0
Original line number Diff line number Diff line
@@ -369,6 +369,143 @@ struct create { 
    };

};



//==============================================================================

// definitions for create_write_inline

struct create_write_inline {



    // forward declarations of public input/output types for this RPC

    class input;



    class output;



    // traits used so that the engine knows what to do with the RPC

    using self_type = create_write_inline;

    using handle_type = hermes::rpc_handle<self_type>;

    using input_type = input;

    using output_type = output;

    using mercury_input_type = rpc_create_write_inline_in_t;

    using mercury_output_type = rpc_create_write_inline_out_t;



    // RPC public identifier

    constexpr static const uint64_t public_id = 7; // Custom ID



    // RPC internal Mercury identifier

    constexpr static const hg_id_t mercury_id = 0;



    // RPC name

    constexpr static const auto name = gkfs::rpc::tag::create_write_inline;



    // requires response?

    constexpr static const auto requires_response = true;



    // Mercury callback to serialize input arguments

    constexpr static const auto mercury_in_proc_cb =

            HG_GEN_PROC_NAME(rpc_create_write_inline_in_t);



    // Mercury callback to serialize output arguments

    constexpr static const auto mercury_out_proc_cb =

            HG_GEN_PROC_NAME(rpc_create_write_inline_out_t);



    class input {



        template <typename ExecutionContext>

        friend hg_return_t

        hermes::detail::post_to_mercury(ExecutionContext*);



    public:

        input(const std::string& path, uint32_t mode, const std::string& data,

              uint64_t count)

            : m_path(path), m_mode(mode), m_data(data), m_count(count) {}



        input(input&& rhs) = default;



        input(const input& other) = default;



        input&

        operator=(input&& rhs) = default;



        input&

        operator=(const input& other) = default;



        std::string

        path() const {

            return m_path;

        }



        uint32_t

        mode() const {

            return m_mode;

        }



        std::string

        data() const {

            return m_data;

        }



        uint64_t

        count() const {

            return m_count;

        }



        explicit input(const rpc_create_write_inline_in_t& other)

            : m_path(other.path), m_mode(other.mode), m_data(other.data),

              m_count(other.count) {}



        explicit

        operator rpc_create_write_inline_in_t() {

            return {m_path.c_str(), m_mode, m_data.c_str(), m_count};

        }



    private:

        std::string m_path;

        uint32_t m_mode;

        std::string m_data;

        uint64_t m_count;

    };



    class output {



        template <typename ExecutionContext>

        friend hg_return_t

        hermes::detail::post_to_mercury(ExecutionContext*);



    public:

        output() : m_err(), m_io_size() {}



        output(int32_t err, uint64_t io_size)

            : m_err(err), m_io_size(io_size) {}



        output(output&& rhs) = default;



        output(const output& other) = default;



        output&

        operator=(output&& rhs) = default;



        output&

        operator=(const output& other) = default;



        explicit output(const rpc_create_write_inline_out_t& out) {

            m_err = out.err;

            m_io_size = out.io_size;

        }



        int32_t

        err() const {

            return m_err;

        }



        uint64_t

        io_size() const {

            return m_io_size;

        }



    private:

        int32_t m_err;

        uint64_t m_io_size;

    };

};



//==============================================================================

// definitions for stat

struct stat {

include/common/common_defs.hpp

+1 −0
Original line number Diff line number Diff line
@@ -59,6 +59,7 @@ namespace tag { 


constexpr auto fs_config = "rpc_srv_fs_config";

constexpr auto create = "rpc_srv_mk_node";

constexpr auto create_write_inline = "rpc_srv_create_write_inline";

constexpr auto stat = "rpc_srv_stat";

constexpr auto remove_metadata = "rpc_srv_rm_metadata";

constexpr auto remove_data = "rpc_srv_rm_data";

include/common/rpc/rpc_types.hpp

+7 −0
Original line number Diff line number Diff line
@@ -202,6 +202,13 @@ MERCURY_GEN_PROC( 
        rpc_write_inline_out_t,

        ((hg_int32_t) (err))((hg_int64_t) (ret_offset))((hg_size_t) (io_size)))



MERCURY_GEN_PROC(rpc_create_write_inline_in_t,

                 ((hg_const_string_t) (path))((uint32_t) (mode))(

                         (hg_const_string_t) (data))((hg_uint64_t) (count)))



MERCURY_GEN_PROC(rpc_create_write_inline_out_t,

                 ((hg_int32_t) (err))((hg_uint64_t) (io_size)))



// Input: path, offset, read length

MERCURY_GEN_PROC(rpc_read_inline_in_t,

                 ((hg_const_string_t) (path))((hg_uint64_t) (offset))(