Commit cbb7703a authored by Jean Bez's avatar Jean Bez
Browse files

Sync with master to merge

parents f734de04 12ac0bc9

hermes @ 0af45bfa

Compare a25a82d4 to 0af45bfa
Original line number Original line Diff line number Diff line 
Subproject commit a25a82d401b4a0d986088c6802a08fd79185a278
 
Subproject commit 0af45bfa667f7ff9c78167ef94d975bffbd879f0

include/client/hooks.hpp

+2 −0
Original line number Original line Diff line number Diff line
@@ -105,6 +105,8 @@ int hook_statfs(const char* path, struct statfs* buf); 




int hook_fstatfs(unsigned int fd, struct statfs* buf);

int hook_fstatfs(unsigned int fd, struct statfs* buf);





int hook_fsync(unsigned int fd);



} // namespace hook

} // namespace hook

} // namespace gkfs

} // namespace gkfs

include/client/rpc/rpc_types.hpp

+10 −1
Original line number Original line Diff line number Diff line
@@ -2092,11 +2092,13 @@ struct chunk_stat { 




    public:

    public:

        output() :

        output() :

                m_err(),

                m_chunk_size(),

                m_chunk_size(),

                m_chunk_total(),

                m_chunk_total(),

                m_chunk_free() {}

                m_chunk_free() {}





        output(uint64_t chunk_size, uint64_t chunk_total, uint64_t chunk_free) :

        output(int32_t err, uint64_t chunk_size, uint64_t chunk_total, uint64_t chunk_free) :

                m_err(err),

                m_chunk_size(chunk_size),

                m_chunk_size(chunk_size),

                m_chunk_total(chunk_total),

                m_chunk_total(chunk_total),

                m_chunk_free(chunk_free) {}

                m_chunk_free(chunk_free) {}
@@ -2111,11 +2113,17 @@ struct chunk_stat { 




        explicit

        explicit

        output(const rpc_chunk_stat_out_t& out) {

        output(const rpc_chunk_stat_out_t& out) {

            m_err = out.err;

            m_chunk_size = out.chunk_size;

            m_chunk_size = out.chunk_size;

            m_chunk_total = out.chunk_total;

            m_chunk_total = out.chunk_total;

            m_chunk_free = out.chunk_free;

            m_chunk_free = out.chunk_free;

        }

        }





        int32_t

        err() const {

            return m_err;

        }



        uint64_t

        uint64_t

        chunk_size() const {

        chunk_size() const {

            return m_chunk_size;

            return m_chunk_size;
@@ -2132,6 +2140,7 @@ struct chunk_stat { 
        }

        }





    private:

    private:

        int32_t m_err;

        uint64_t m_chunk_size;

        uint64_t m_chunk_size;

        uint64_t m_chunk_total;

        uint64_t m_chunk_total;

        uint64_t m_chunk_free;

        uint64_t m_chunk_free;

include/daemon/backend/data/chunk_storage.hpp

+22 −22
Original line number Original line Diff line number Diff line
@@ -14,13 +14,12 @@ 
#ifndef GEKKOFS_CHUNK_STORAGE_HPP

#ifndef GEKKOFS_CHUNK_STORAGE_HPP

#define GEKKOFS_CHUNK_STORAGE_HPP

#define GEKKOFS_CHUNK_STORAGE_HPP





extern "C" {

#include <global/global_defs.hpp>

#include <abt.h>

}





#include <limits>

#include <limits>

#include <string>

#include <string>

#include <memory>

#include <memory>

#include <system_error>





/* Forward declarations */

/* Forward declarations */

namespace spdlog {

namespace spdlog {
@@ -36,42 +35,43 @@ struct ChunkStat { 
    unsigned long chunk_free;

    unsigned long chunk_free;

};

};





class ChunkStorageException : public std::system_error {

public:

    ChunkStorageException(const int err_code, const std::string& s) : std::system_error(err_code,

                                                                                        std::generic_category(), s) {};

};



class ChunkStorage {

class ChunkStorage {

private:

private:

    static constexpr const char* LOGGER_NAME = "ChunkStorage";





    std::shared_ptr<spdlog::logger> log;

    std::shared_ptr<spdlog::logger> log_;





    std::string root_path;

    std::string root_path_;

    size_t chunksize;

    size_t chunksize_;





    inline std::string absolute(const std::string& internal_path) const;

    inline std::string absolute(const std::string& internal_path) const;





    static inline std::string get_chunks_dir(const std::string& file_path);

    static inline std::string get_chunks_dir(const std::string& file_path);





    static inline std::string get_chunk_path(const std::string& file_path, unsigned int chunk_id);

    static inline std::string get_chunk_path(const std::string& file_path, gkfs::rpc::chnk_id_t chunk_id);





    void init_chunk_space(const std::string& file_path) const;

    void init_chunk_space(const std::string& file_path) const;





public:

public:

    ChunkStorage(const std::string& path, size_t chunksize);

    ChunkStorage(std::string& path, size_t chunksize);





    void write_chunk(const std::string& file_path, unsigned int chunk_id,

    void destroy_chunk_space(const std::string& file_path) const;

                     const char* buff, size_t size, off64_t offset,

                     ABT_eventual& eventual) const;



    void read_chunk(const std::string& file_path, unsigned int chunk_id,

                    char* buff, size_t size, off64_t offset,

                    ABT_eventual& eventual) const;





    void trim_chunk_space(const std::string& file_path, unsigned int chunk_start,

    ssize_t

                          unsigned int chunk_end = std::numeric_limits<unsigned int>::max());

    write_chunk(const std::string& file_path, gkfs::rpc::chnk_id_t chunk_id, const char* buf, size_t size,

                off64_t offset) const;





    void delete_chunk(const std::string& file_path, unsigned int chunk_id);

    ssize_t read_chunk(const std::string& file_path, gkfs::rpc::chnk_id_t chunk_id, char* buf, size_t size,

                       off64_t offset) const;





    void truncate_chunk(const std::string& file_path, unsigned int chunk_id, off_t length);

    void trim_chunk_space(const std::string& file_path, gkfs::rpc::chnk_id_t chunk_start);





    void destroy_chunk_space(const std::string& file_path) const;

    void truncate_chunk_file(const std::string& file_path, gkfs::rpc::chnk_id_t chunk_id, off_t length);





    ChunkStat chunk_stat() const;

    ChunkStat chunk_stat() const;

};

};

include/daemon/backend/data/data_module.hpp

0 → 100644
+53 −0
Original line number Original line Diff line number Diff line 
/*

  Copyright 2018-2020, Barcelona Supercomputing Center (BSC), Spain

  Copyright 2015-2020, Johannes Gutenberg Universitaet Mainz, Germany



  This software was partially supported by the

  EC H2020 funded project NEXTGenIO (Project ID: 671951, www.nextgenio.eu).



  This software was partially supported by the

  ADA-FS project under the SPPEXA project funded by the DFG.



  SPDX-License-Identifier: MIT

*/



#ifndef GEKKOFS_DAEMON_DATA_LOGGING_HPP

#define GEKKOFS_DAEMON_DATA_LOGGING_HPP



#include <spdlog/spdlog.h>



namespace gkfs {

namespace data {



class DataModule {



private:

    DataModule() {}



    std::shared_ptr<spdlog::logger> log_;



public:



    static constexpr const char* LOGGER_NAME = "DataModule";



    static DataModule* getInstance() {

        static DataModule instance;

        return &instance;

    }



    DataModule(DataModule const&) = delete;



    void operator=(DataModule const&) = delete;



    const std::shared_ptr<spdlog::logger>& log() const;



    void log(const std::shared_ptr<spdlog::logger>& log);



};



#define GKFS_DATA_MOD (static_cast<gkfs::data::DataModule*>(gkfs::data::DataModule::getInstance()))



} // namespace data

} // namespace gkfs



#endif //GEKKOFS_DAEMON_DATA_LOGGING_HPP