Commit 8b807dc4 authored by Marc Vef's avatar Marc Vef
Browse files

Refact: consistent data types based on fuse and the stat struct

parent 1d779e91

lfs/src/adafs_ops/access.cpp

+1 −1
Original line number Diff line number Diff line
@@ -77,7 +77,7 @@ int chk_uid(const fuse_req_t& req, const Metadata& md) { 
int change_access(Metadata& md, mode_t mode, const bfs::path& path) {



//    auto path_hash = ADAFS_DATA->hashf(path.string());

//    md.mode((uint32_t) mode);

//    md.mode((mode_t) mode);

//

//    write_metadata_field(md.mode(), path_hash, md_field_map.at(Md_fields::mode));

//

lfs/src/adafs_ops/dentry_ops.cpp

+10 −10
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ using namespace std; 
 * @param inode

 * @return

 */

bool init_dentry_dir(const uint64_t inode) {

bool init_dentry_dir(const fuse_ino_t inode) {

    auto d_path = bfs::path(ADAFS_DATA->dentry_path());

    d_path /= to_string(inode);

    bfs::create_directories(d_path);
@@ -28,7 +28,7 @@ bool init_dentry_dir(const uint64_t inode) { 
 * @param inode

 * @return true if successfully deleted

 */

bool destroy_dentry_dir(const uint64_t inode) {

bool destroy_dentry_dir(const fuse_ino_t inode) {

    auto d_path = bfs::path(ADAFS_DATA->dentry_path());

    d_path /= to_string(inode);
@@ -44,7 +44,7 @@ bool destroy_dentry_dir(const uint64_t inode) { 
 * @param fname

 * @return

 */

bool verify_dentry(const uint64_t inode) {

bool verify_dentry(const fuse_ino_t inode) {

    // XXX do I need this?

    return false;

//    auto d_path = bfs::path(ADAFS_DATA->dentry_path());
@@ -68,7 +68,7 @@ bool verify_dentry(const uint64_t inode) { 
 * Reads all directory entries in a directory with a given @hash. Returns 0 if successful.

 * @dir is assumed to be empty

 */

int read_dentries(const uint64_t p_inode, const unsigned long inode) {

int read_dentries(const fuse_ino_t p_inode, const fuse_ino_t inode) {

//    auto path = bfs::path(ADAFS_DATA->dentry_path());

//    path /= to_string(inode);

//    if (!bfs::exists(path)) return 1;
@@ -91,7 +91,7 @@ int read_dentries(const uint64_t p_inode, const unsigned long inode) { 
 * @param dir_inode

 * @return

 */

int get_dentries(vector<Dentry>& dentries, const uint64_t dir_inode) {

int get_dentries(vector<Dentry>& dentries, const fuse_ino_t dir_inode) {

    ADAFS_DATA->spdlogger()->debug("get_dentries: inode {}", dir_inode);

    auto d_path = bfs::path(ADAFS_DATA->dentry_path());

    d_path /= to_string(dir_inode);
@@ -126,9 +126,9 @@ int get_dentries(vector<Dentry>& dentries, const uint64_t dir_inode) { 
 * @param name

 * @return pair<err, inode>

 */

pair<int, uint64_t> do_lookup(fuse_req_t& req, const uint64_t p_inode, const string& name) {

pair<int, fuse_ino_t> do_lookup(fuse_req_t& req, const fuse_ino_t p_inode, const string& name) {



    uint64_t inode;

    fuse_ino_t inode;

    // XXX error handling

    // TODO look into cache first

    auto d_path = bfs::path(ADAFS_DATA->dentry_path());
@@ -154,7 +154,7 @@ pair<int, uint64_t> do_lookup(fuse_req_t& req, const uint64_t p_inode, const str 
 * @param name

 * @return

 */

int create_dentry(const uint64_t p_inode, const uint64_t inode, const string& name, mode_t mode) {

int create_dentry(const fuse_ino_t p_inode, const fuse_ino_t inode, const string& name, mode_t mode) {

//    ADAFS_DATA->logger->debug("create_dentry() enter with fname: {}", inode);

    // XXX Errorhandling

    auto d_path = bfs::path(ADAFS_DATA->dentry_path());
@@ -182,7 +182,7 @@ int create_dentry(const uint64_t p_inode, const uint64_t inode, const string& na 
 * @return

 */

// XXX errorhandling

int remove_dentry(const unsigned long p_inode, const uint64_t inode) {

int remove_dentry(const unsigned long p_inode, const fuse_ino_t inode) {

//    auto f_path = bfs::path(ADAFS_DATA->dentry_path());

//    f_path /= to_string(p_inode);

//    if (!bfs::exists(f_path)) {
@@ -204,7 +204,7 @@ int remove_dentry(const unsigned long p_inode, const uint64_t inode) { 
 * @param inode

 * @return bool

 */

bool is_dir_empty(const uint64_t inode) {

bool is_dir_empty(const fuse_ino_t inode) {

//    auto d_path = bfs::path(ADAFS_DATA->dentry_path());

//    // use hash function to path and append it to d_path

//    d_path /= to_string(ADAFS_DATA->hashf(inode.string()));

lfs/src/adafs_ops/dentry_ops.h

+9 −9
Original line number Diff line number Diff line
@@ -9,22 +9,22 @@ 
#include "../classes/dentry.h"





bool init_dentry_dir(const uint64_t inode);

bool init_dentry_dir(const fuse_ino_t inode);



bool destroy_dentry_dir(const uint64_t inode);

bool destroy_dentry_dir(const fuse_ino_t inode);



bool verify_dentry(const uint64_t inode);

bool verify_dentry(const fuse_ino_t inode);



int read_dentries(const uint64_t p_inode, const unsigned long inode);

int read_dentries(const fuse_ino_t p_inode, const fuse_ino_t inode);



int get_dentries(std::vector<Dentry>& dentries, const uint64_t dir_inode);

int get_dentries(std::vector<Dentry>& dentries, const fuse_ino_t dir_inode);



std::pair<int, uint64_t> do_lookup(fuse_req_t& req, const uint64_t p_inode, const std::string& name);

std::pair<int, fuse_ino_t> do_lookup(fuse_req_t& req, const fuse_ino_t p_inode, const std::string& name);



int create_dentry(const uint64_t p_inode, const uint64_t inode, const std::string& name, mode_t mode);

int create_dentry(const fuse_ino_t p_inode, const fuse_ino_t inode, const std::string& name, mode_t mode);



int remove_dentry(const unsigned long p_inode, const uint64_t inode);

int remove_dentry(const fuse_ino_t p_inode, const fuse_ino_t inode);



bool is_dir_empty(const uint64_t inode);

bool is_dir_empty(const fuse_ino_t inode);



#endif //FS_DENTRY_OPS_H

lfs/src/adafs_ops/metadata_ops.cpp

+12 −12
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ 




// TODO error handling. Each read_metadata_field should check for boolean, i.e., if I/O failed.

bool write_all_metadata(const Metadata& md, const uint64_t inode) {

bool write_all_metadata(const Metadata& md, const fuse_ino_t inode) {

    write_metadata_field(md.atime(), md_field_map.at(Md_fields::atime), inode);

    write_metadata_field(md.mtime(), md_field_map.at(Md_fields::mtime), inode);

    write_metadata_field(md.ctime(), md_field_map.at(Md_fields::ctime), inode);
@@ -24,17 +24,17 @@ bool write_all_metadata(const Metadata& md, const uint64_t inode) { 
}



// TODO error handling. Each read_metadata_field should check for nullptr, i.e., if I/O failed.

bool read_all_metadata(Metadata& md, const uint64_t inode) {

bool read_all_metadata(Metadata& md, const fuse_ino_t inode) {

    md.atime(*read_metadata_field<time_t>(md_field_map.at(Md_fields::atime), inode));

    md.mtime(*read_metadata_field<time_t>(md_field_map.at(Md_fields::mtime), inode));

    md.ctime(*read_metadata_field<time_t>(md_field_map.at(Md_fields::ctime), inode));

    md.uid(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::uid), inode));

    md.gid(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::gid), inode));

    md.mode(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::mode), inode));

    md.inode_no(*read_metadata_field<uint64_t>(md_field_map.at(Md_fields::inode_no), inode));

    md.link_count(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::link_count), inode));

    md.size(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::size), inode));

    md.blocks(*read_metadata_field<uint32_t>(md_field_map.at(Md_fields::blocks), inode));

    md.uid(*read_metadata_field<uid_t>(md_field_map.at(Md_fields::uid), inode));

    md.gid(*read_metadata_field<gid_t>(md_field_map.at(Md_fields::gid), inode));

    md.mode(*read_metadata_field<mode_t>(md_field_map.at(Md_fields::mode), inode));

    md.inode_no(*read_metadata_field<fuse_ino_t>(md_field_map.at(Md_fields::inode_no), inode));

    md.link_count(*read_metadata_field<nlink_t>(md_field_map.at(Md_fields::link_count), inode));

    md.size(*read_metadata_field<off_t>(md_field_map.at(Md_fields::size), inode));

    md.blocks(*read_metadata_field<blkcnt_t>(md_field_map.at(Md_fields::blocks), inode));

    return true;

}
@@ -44,7 +44,7 @@ bool read_all_metadata(Metadata& md, const uint64_t inode) { 
 * @param inode

 * @return err

 */

int get_metadata(Metadata& md, const uint64_t inode) {

int get_metadata(Metadata& md, const fuse_ino_t inode) {

    ADAFS_DATA->spdlogger()->debug("get_metadata() enter for inode {}", inode);

    // Verify that the file's inode exists

    auto path = bfs::path(ADAFS_DATA->inode_path());
@@ -64,7 +64,7 @@ int get_metadata(Metadata& md, const uint64_t inode) { 
 * @param inode

 * @return err

 */

int get_attr(struct stat& attr, const uint64_t inode) {

int get_attr(struct stat& attr, const fuse_ino_t inode) {



    // XXX look in cache first

    auto md = make_shared<Metadata>();
@@ -110,7 +110,7 @@ void metadata_to_stat(const Metadata& md, struct stat& attr) { 
//    return 0;

//}



int create_node(fuse_req_t& req, struct fuse_entry_param& fep, uint64_t parent, const string& name, mode_t mode) {

int create_node(fuse_req_t& req, struct fuse_entry_param& fep, fuse_ino_t parent, const string& name, mode_t mode) {



    // create metadata of new file (this will also create a new inode number)

    // mode is used here to init metadata

lfs/src/adafs_ops/metadata_ops.h

+7 −7
Original line number Diff line number Diff line
@@ -30,11 +30,11 @@ const std::map<Md_fields, std::string> md_field_map = { 
        {Md_fields::blocks,     "/blocks"}

};



bool write_all_metadata(const Metadata& md, const uint64_t inode);

bool write_all_metadata(const Metadata& md, const fuse_ino_t inode);



// TODO error handling.

template<typename T>

bool write_metadata_field(const T& field, const string& field_name, const uint64_t inode) {

bool write_metadata_field(const T& field, const string& field_name, const fuse_ino_t inode) {

    auto i_path = bfs::path(ADAFS_DATA->inode_path());

    i_path /= to_string(inode);

    bfs::create_directories(i_path);
@@ -48,11 +48,11 @@ bool write_metadata_field(const T& field, const string& field_name, const uint64 
    return true;

}



bool read_all_metadata(Metadata& md, const uint64_t inode);

bool read_all_metadata(Metadata& md, const fuse_ino_t inode);



// TODO error handling

template<typename T>

unique_ptr<T> read_metadata_field(const string& field_name, const uint64_t inode) {

unique_ptr<T> read_metadata_field(const string& field_name, const fuse_ino_t inode) {

    auto path = bfs::path(ADAFS_DATA->inode_path());

    path /= to_string(inode);

    path /= field_name;
@@ -67,14 +67,14 @@ unique_ptr<T> read_metadata_field(const string& field_name, const uint64_t inode 
    return field;

}



int get_metadata(Metadata& md, const uint64_t inode);

int get_metadata(Metadata& md, const fuse_ino_t inode);



int get_attr(struct stat& attr, const uint64_t inode);

int get_attr(struct stat& attr, const fuse_ino_t inode);



void metadata_to_stat(const Metadata& md, struct stat& attr);



//int remove_metadata(const unsigned long hash);



int create_node(fuse_req_t& req, struct fuse_entry_param& fep, uint64_t parent, const string& name, mode_t mode);

int create_node(fuse_req_t& req, struct fuse_entry_param& fep, fuse_ino_t parent, const string& name, mode_t mode);



#endif //FS_METADATA_OPS_H