Verified Commit 1fe75834 authored by Ramon Nou's avatar Ramon Nou Committed by Marc Vef
Browse files

fmt10 support

parent 9f2734bd

.gitmodules

+1 −0
Original line number Diff line number Diff line 
[submodule "external/hermes"]

	path = external/hermes

	url = https://github.com/bsc-ssrg/hermes.git

	commit = 9f17ff97fd0b6aa44227cc164e099f25f3e5c333

[submodule "tests/scripts/bats"]

	path = tests/scripts/bats

	url = https://github.com/bats-core/bats-core.git

CMakeLists.txt

+1 −1
Original line number Diff line number Diff line
@@ -225,7 +225,7 @@ include_from_source(fmt 
  MESSAGE "[${PROJECT_NAME}] Searching for {fmt}"

  SOURCE_DIR ${GKFS_DEPENDENCIES_PATH}/fmt

  GIT_REPOSITORY https://github.com/fmtlib/fmt

  GIT_TAG f94b7364b9409f05207c3af3fa4666730e11a854 # v6.1.2

  GIT_TAG e57ca2e3685b160617d3d95fcd9e789c4e06ca88 # v10.1.0

)



# ensure that fmt is linked as PIC

include/client/logging.hpp

+20 −38
Original line number Diff line number Diff line
@@ -213,12 +213,15 @@ format_timestamp_to(Buffer&& buffer, 
            std::chrono::microseconds{tv.tv_usec}};



    if(!timezone) {

        fmt::format_to(buffer, "[{}] ", now.time_since_epoch().count());

        fmt::format_to(std::back_inserter(buffer), "[{}] ",

                       now.time_since_epoch().count());

        return;

    }



    fmt::format_to(buffer, "[{}] ",

                   date::zoned_time<std::chrono::microseconds>{timezone, now});

    std::stringstream tmp;

    tmp << date::zoned_time<std::chrono::microseconds>{timezone, now};



    fmt::format_to(std::back_inserter(buffer), "[{}] ", tmp.str());

}



template <typename Buffer>
@@ -226,7 +229,7 @@ static inline void 
format_syscall_info_to(Buffer&& buffer, gkfs::syscall::info info) {



    const auto ttid = syscall_no_intercept(SYS_gettid);

    fmt::format_to(buffer, "[{}] [syscall] ", ttid);

    fmt::format_to(std::back_inserter(buffer), "[{}] [syscall] ", ttid);



    char o;

    char t;
@@ -256,20 +259,15 @@ format_syscall_info_to(Buffer&& buffer, gkfs::syscall::info info) { 
    }



    const std::array<char, 5> tmp = {'[', o, t, ']', ' '};

    fmt::format_to(buffer, fmt::string_view(tmp.data(), tmp.size()));

    fmt::format_to(std::back_inserter(buffer),

                   fmt::string_view(tmp.data(), tmp.size()));

}



} // namespace detail



enum { max_buffer_size = LIBGKFS_LOG_MESSAGE_SIZE };



struct static_buffer : public fmt::basic_memory_buffer<char, max_buffer_size> {



protected:

    void

    grow(std::size_t size) override final;

};



using static_buffer = fmt::basic_memory_buffer<char, max_buffer_size>;



struct logger {
@@ -294,15 +292,16 @@ struct logger { 


        static_buffer buffer;

        detail::format_timestamp_to(buffer, timezone_);

        fmt::format_to(buffer, "[{}] [{}] ", log_process_id_,

                       lookup_level_name(level));

        fmt::format_to(std::back_inserter(buffer), "[{}] [{}] ", ,

                       log_process_id_, lookup_level_name(level));



        if(!!(level & log::debug)) {

            fmt::format_to(buffer, "<{}():{}> ", func, lineno);

            fmt::format_to(std::back_inserter(buffer), "<{}():{}> ", func,

                           lineno);

        }



        fmt::format_to(buffer, std::forward<Args>(args)...);

        fmt::format_to(buffer, "\n");

        fmt::format_to(std::back_inserter(buffer), std::forward<Args>(args)...);

        fmt::format_to(std::back_inserter(buffer), "\n");

        detail::log_buffer(log_fd_, buffer);

    }
@@ -337,8 +336,8 @@ struct logger { 


        static_buffer prefix;

        detail::format_timestamp_to(prefix);

        fmt::format_to(prefix, "[{}] [{}] ", log_process_id_,

                       lookup_level_name(level));

        fmt::format_to(std::back_inserter(prefix), "[{}] [{}] ",

                       log_process_id_, lookup_level_name(level));



        char buffer[max_buffer_size];

        const int n = vsnprintf(buffer, sizeof(buffer), fmt, ap);
@@ -387,8 +386,8 @@ struct logger { 
        }



        static_buffer buffer;

        fmt::format_to(buffer, std::forward<Args>(args)...);

        fmt::format_to(buffer, "\n");

        fmt::format_to(std::back_inserter(buffer), std::forward<Args>(args)...);

        fmt::format_to(std::back_inserter(buffer), "\n");

        detail::log_buffer(fd, buffer);

    }
@@ -440,23 +439,6 @@ destroy_global_logger() { 
    logger::global_logger().reset();

}



inline void

static_buffer::grow(std::size_t size) {



    const auto logger = get_global_logger();



    if(logger) {

        logger->log_mask_ &= ~(syscall | syscall_at_entry);

    }



    std::fprintf(

            stderr,

            "FATAL: message too long for gkfs::log::static_buffer, increase the size of\n"

            "LIBGKFS_LOG_MESSAGE_SIZE in CMake or reduce the length of the offending "

            "message.\n");

    abort();

}



} // namespace gkfs::log



#define LOG(XXX, ...) LOG_##XXX(__VA_ARGS__)

include/client/syscalls/args.hpp

+29 −29
Original line number Diff line number Diff line
@@ -228,7 +228,7 @@ format_flag(FmtBuffer& buffer, long flag, FlagDescriptorArray&& desc) { 
    // we assume that if a flag value is zero, its printable

    // name will always be at position 0 in the array

    if(flag == 0 && desc[0].flag_ == 0) {

        fmt::format_to(buffer, "{}", desc[0].name_);

        fmt::format_to(std::back_inserter(buffer), "{}", desc[0].name_);

        return;

    }
@@ -239,12 +239,12 @@ format_flag(FmtBuffer& buffer, long flag, FlagDescriptorArray&& desc) { 
        }



        if((flag == desc[i].flag_)) {

            fmt::format_to(buffer, "{}", desc[i].name_);

            fmt::format_to(std::back_inserter(buffer), "{}", desc[i].name_);

            return;

        }

    }



    fmt::format_to(buffer, "{:#x}", flag);

    fmt::format_to(std::back_inserter(buffer), "{:#x}", flag);

}



template <typename FmtBuffer, typename FlagDescriptorArray>
@@ -254,7 +254,7 @@ format_flag_set(FmtBuffer& buffer, long flags, FlagDescriptorArray&& desc) { 
    // we assume that if a flag value is zero, its printable

    // name will always be at position 0 in the array

    if(flags == 0 && desc[0].flag_ == 0) {

        fmt::format_to(buffer, "{}", desc[0].name_);

        fmt::format_to(std::back_inserter(buffer), "{}", desc[0].name_);

        return;

    }
@@ -269,7 +269,7 @@ format_flag_set(FmtBuffer& buffer, long flags, FlagDescriptorArray&& desc) { 
        }



        if((flags & desc[i].flag_) != 0) {

            fmt::format_to(buffer, "{}{}",

            fmt::format_to(std::back_inserter(buffer), "{}{}",

                           buffer.size() != buffer_start ? "|" : "",

                           desc[i].name_);

            flags &= ~desc[i].flag_;
@@ -280,15 +280,15 @@ format_flag_set(FmtBuffer& buffer, long flags, FlagDescriptorArray&& desc) { 


    if(flags != 0) {

        if(buffer.size() != buffer_start) {

            fmt::format_to(buffer, "|");

            fmt::format_to(std::back_inserter(buffer), "|");

        }



        fmt::format_to(buffer, "{:#x}", flags);

        fmt::format_to(std::back_inserter(buffer), "{:#x}", flags);

        return;

    }



    if(buffer_start == buffer.size()) {

        fmt::format_to(buffer, "0x0");

        fmt::format_to(std::back_inserter(buffer), "0x0");

    }

}
@@ -311,7 +311,7 @@ format_whence_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
            FLAG_ENTRY(SEEK_END)

        );



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    format_flag_set(buffer, parg.value, flag_names);

}
@@ -334,7 +334,7 @@ format_mmap_prot_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
            FLAG_ENTRY(PROT_WRITE),

            FLAG_ENTRY(PROT_EXEC));



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    format_flag_set(buffer, parg.value, flag_names);



    return;
@@ -376,7 +376,7 @@ format_mmap_flags_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
#endif

            );



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    format_flag_set(buffer, parg.value, flag_names);

    return;

}
@@ -420,14 +420,14 @@ format_clone_flags_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
            FLAG_ENTRY(CLONE_NEWNET),

            FLAG_ENTRY(CLONE_IO));



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);



    // the low byte in clone flags contains the number of the termination

    // signal sent to the parent when the child dies

    format_flag_set(buffer, parg.value & ~0x11l, flag_names);



    if((parg.value & 0x11l) != 0) {

        fmt::format_to(buffer, "|", parg.name);

        fmt::format_to(std::back_inserter(buffer), "|", parg.name);

        format_signum_arg_to(buffer, {"", parg.value & 0x11l});

    }

    return;
@@ -479,7 +479,7 @@ format_signum_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
            FLAG_ENTRY(SIGSYS));



    if(std::strcmp(parg.name, "")) {

        fmt::format_to(buffer, "{}=", parg.name);

        fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    }



    format_flag(buffer, parg.value, flag_names);
@@ -504,7 +504,7 @@ format_sigproc_how_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
            FLAG_ENTRY(SIG_UNBLOCK),

            FLAG_ENTRY(SIG_SETMASK));



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    format_flag(buffer, parg.value, flag_names);

    return;

}
@@ -518,7 +518,7 @@ format_sigproc_how_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
template <typename FmtBuffer>

inline void

format_none_arg_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "void");

    fmt::format_to(std::back_inserter(buffer), "void");

}
@@ -531,7 +531,7 @@ format_none_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
template <typename FmtBuffer>

inline void

format_fd_arg_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "{}={}", parg.name, static_cast<int>(parg.value));

    fmt::format_to(std::back_inserter(buffer), "{}={}", parg.name, static_cast<int>(parg.value));

}
@@ -546,11 +546,11 @@ inline void 
format_atfd_arg_to(FmtBuffer& buffer, const printable_arg& parg) {



    if(static_cast<int>(parg.value) == AT_FDCWD) {

        fmt::format_to(buffer, "{}=AT_FDCWD", parg.name);

        fmt::format_to(std::back_inserter(buffer), "{}=AT_FDCWD", parg.name);

        return;

    }



    fmt::format_to(buffer, "{}={}", parg.name, static_cast<int>(parg.value));

    fmt::format_to(std::back_inserter(buffer), "{}={}", parg.name, static_cast<int>(parg.value));

}
@@ -565,12 +565,12 @@ inline void 
format_cstr_arg_to(FmtBuffer& buffer, const printable_arg& parg) {



    if(LIKELY(reinterpret_cast<const char*>(parg.value) != nullptr)) {

        fmt::format_to(buffer, "{}=\"{}\"", parg.name,

        fmt::format_to(std::back_inserter(buffer), "{}=\"{}\"", parg.name,

                       reinterpret_cast<const char*>(parg.value));

        return;

    }



    fmt::format_to(buffer, "{}=NULL", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=NULL", parg.name);

}



/**
@@ -618,7 +618,7 @@ format_open_flags_to(FmtBuffer& buffer, 


    long flags = parg.value;



    fmt::format_to(buffer, "{}=", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=", parg.name);

    format_flag(buffer, flags & O_ACCMODE, flag_names);



    flags &= ~O_ACCMODE;
@@ -636,7 +636,7 @@ format_open_flags_to(FmtBuffer& buffer, 
#endif // !O_TMPFILE



    if(flags != 0) {

        fmt::format_to(buffer, "|", parg.name);

        fmt::format_to(std::back_inserter(buffer), "|", parg.name);

        format_flag_set(buffer, flags, extra_flag_names);

    }

}
@@ -650,7 +650,7 @@ format_open_flags_to(FmtBuffer& buffer, 
template <typename FmtBuffer>

inline void

format_octal_mode_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "{}={:#04o}", parg.name, parg.value);

    fmt::format_to(std::back_inserter(buffer), "{}={:#04o}", parg.name, parg.value);

}



/**
@@ -664,12 +664,12 @@ inline void 
format_ptr_arg_to(FmtBuffer& buffer, const printable_arg& parg) {



    if(LIKELY(reinterpret_cast<const void*>(parg.value) != nullptr)) {

        fmt::format_to(buffer, "{}={}", parg.name,

        fmt::format_to(std::back_inserter(buffer), "{}={}", parg.name,

                       reinterpret_cast<const void*>(parg.value));

        return;

    }



    fmt::format_to(buffer, "{}=NULL", parg.name);

    fmt::format_to(std::back_inserter(buffer), "{}=NULL", parg.name);

}
@@ -682,7 +682,7 @@ format_ptr_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
template <typename FmtBuffer>

inline void

format_dec_arg_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "{}={}", parg.name, parg.value);

    fmt::format_to(std::back_inserter(buffer), "{}={}", parg.name, parg.value);

}
@@ -695,7 +695,7 @@ format_dec_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
template <typename FmtBuffer>

inline void

format_dec32_arg_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "{}={}", parg.name, static_cast<int>(parg.value));

    fmt::format_to(std::back_inserter(buffer), "{}={}", parg.name, static_cast<int>(parg.value));

}
@@ -708,7 +708,7 @@ format_dec32_arg_to(FmtBuffer& buffer, const printable_arg& parg) { 
template <typename FmtBuffer>

inline void

format_arg_to(FmtBuffer& buffer, const printable_arg& parg) {

    fmt::format_to(buffer, "{}={:#x}", parg.name, parg.value);

    fmt::format_to(std::back_inserter(buffer), "{}={:#x}", parg.name, parg.value);

}



#undef FLAG_ENTRY

include/client/syscalls/decoder.hpp

+12 −11
Original line number Diff line number Diff line
@@ -60,19 +60,19 @@ decode(FmtBuffer& buffer, const long syscall_number, 


    const auto sc = lookup_by_number(syscall_number, argv);



    fmt::format_to(buffer, "{}(", sc.name());

    fmt::format_to(std::back_inserter(buffer), "{}(", sc.name());



    for(int i = 0; i < sc.num_args(); ++i) {

        const auto& arg = sc.args().at(i);

        const auto arg = sc.args().at(i);



        arg.formatter<FmtBuffer>()(buffer, {arg.name(), argv[i]});



        if(i < sc.num_args() - 1) {

            fmt::format_to(buffer, ", ");

            fmt::format_to(std::back_inserter(buffer), ", ");

        }

    }



    fmt::format_to(buffer, ") = ?");

    fmt::format_to(std::back_inserter(buffer), ") = ?");

}



template <typename FmtBuffer>
@@ -84,30 +84,31 @@ decode(FmtBuffer& buffer, const long syscall_number, const long argv[MAX_ARGS], 


    const auto sc = lookup_by_number(syscall_number, argv);



    fmt::format_to(buffer, "{}(", sc.name());

    fmt::format_to(std::back_inserter(buffer), "{}(", sc.name());



    for(int i = 0; i < sc.num_args(); ++i) {

        const auto& arg = sc.args().at(i);

        const auto arg = sc.args().at(i);



        arg.formatter<FmtBuffer>()(buffer, {arg.name(), argv[i]});



        if(i < sc.num_args() - 1) {

            fmt::format_to(buffer, ", ");

            fmt::format_to(std::back_inserter(buffer), ", ");

        }

    }



    if(never_returns(syscall_number)) {

        fmt::format_to(buffer, ") = ?");

        fmt::format_to(std::back_inserter(buffer), ") = ?");

        return;

    }



    if(error_code(result) != 0) {

        fmt::format_to(buffer, ") = {} {} ({})", static_cast<int>(-1),

                       errno_name(-result), errno_message(-result));

        fmt::format_to(std::back_inserter(buffer), ") = {} {} ({})",

                       static_cast<int>(-1), errno_name(-result),

                       errno_message(-result));

        return;

    }



    fmt::format_to(buffer, ") = ");

    fmt::format_to(std::back_inserter(buffer), ") = ");

    const auto& ret = sc.return_type();

    ret.formatter<FmtBuffer>()(buffer, result);

}