common/Log.hpp | 6 +- common/Util.hpp | 142 +++++++++++++++++++++++++++++++++++++++++++++++++ net/DelaySocket.cpp | 6 +- test/httpcrashtest.cpp | 2 wsd/Storage.cpp | 2 5 files changed, 151 insertions(+), 7 deletions(-)
New commits: commit 3b4269a301e373262a091a5e06a33354996dd52b Author: Tor Lillqvist <t...@collabora.com> Date: Wed Jul 11 12:58:10 2018 +0300 Use Util::symbolicErrno() I think the general policy should be to always log errno using both Util::symbolicErrno() and std::strerror(), never log a naked errno. But only in cases where we know that it is highly likely that it is the most recent system call that has failed, so errno makes sense. Change-Id: I4a1fb31e375ea949e7da17687464361efe7c1761 diff --git a/common/Log.hpp b/common/Log.hpp index bb5a61554..a26c68148 100644 --- a/common/Log.hpp +++ b/common/Log.hpp @@ -23,6 +23,8 @@ #include <Poco/DateTimeFormatter.h> #include <Poco/Logger.h> +#include "Util.hpp" + inline std::ostream& operator<< (std::ostream& os, const Poco::Timestamp& ts) { os << Poco::DateTimeFormatter::format(Poco::DateTime(ts), @@ -220,9 +222,9 @@ namespace Log #define LOG_INF(X) do { auto& l_ = Log::logger(); if (l_.information()) { LOG_BODY_(INFORMATION, "INF", X); } } while (false) #define LOG_WRN(X) do { auto& l_ = Log::logger(); if (l_.warning()) { LOG_BODY_(WARNING, "WRN", X); } } while (false) #define LOG_ERR(X) do { auto& l_ = Log::logger(); if (l_.error()) { LOG_BODY_(ERROR, "ERR", X); } } while (false) -#define LOG_SYS(X) do { auto& l_ = Log::logger(); if (l_.error()) { LOG_BODY_(ERROR, "ERR", X << " (errno: " << std::strerror(errno) << ")"); } } while (false) +#define LOG_SYS(X) do { auto& l_ = Log::logger(); if (l_.error()) { LOG_BODY_(ERROR, "ERR", X << " (" << Util::symbolicErrno(errno) << ": " << std::strerror(errno) << ")"); } } while (false) #define LOG_FTL(X) do { auto& l_ = Log::logger(); if (l_.fatal()) { LOG_BODY_(FATAL, "FTL", X); } } while (false) -#define LOG_SFL(X) do { auto& l_ = Log::logger(); if (l_.error()) { LOG_BODY_(FATAL, "FTL", X << " (errno: " << std::strerror(errno) << ")"); } } while (false) +#define LOG_SFL(X) do { auto& l_ = Log::logger(); if (l_.error()) { LOG_BODY_(FATAL, "FTL", X << " (" << Util::symbolicErrno(errno) << ": " << std::strerror(errno) << ")"); } } while (false) #define LOG_END(l) do { l << __FILE__ << ':' << __LINE__; l.flush(); } while (false) diff --git a/net/DelaySocket.cpp b/net/DelaySocket.cpp index 2c999edb5..41eb4faf5 100644 --- a/net/DelaySocket.cpp +++ b/net/DelaySocket.cpp @@ -150,7 +150,7 @@ public: } else if (errno != EAGAIN && errno != EWOULDBLOCK) { - DELAY_LOG("#" << getFD() << " error : " << errno << " " << strerror(errno) << "\n"); + DELAY_LOG("#" << getFD() << " error : " << Util::symbolicErrno(errno) << ": " << strerror(errno) << "\n"); changeState(Closed); // FIXME - propagate the error ? } } @@ -189,8 +189,8 @@ public: DELAY_LOG("#" << getFD() << " failed onwards write " << len << "bytes of " << chunk->_data.size() - << " queue: " << _chunks.size() << " error " - << strerror(errno) << "\n"); + << " queue: " << _chunks.size() << " error: " + << Util::symbolicErrno(errno) << ": " << strerror(errno) << "\n"); changeState(Closed); } } diff --git a/test/httpcrashtest.cpp b/test/httpcrashtest.cpp index d4a0e06ab..a2b1a9d2a 100644 --- a/test/httpcrashtest.cpp +++ b/test/httpcrashtest.cpp @@ -240,7 +240,7 @@ static void killPids(const std::vector<int> &pids, const std::string& testname) { TST_LOG_BEGIN("Killing " << pid); if (kill(pid, SIGKILL) == -1) - TST_LOG_APPEND("kill(" << pid << ", SIGKILL) failed: " << std::strerror(errno)); + TST_LOG_APPEND("kill(" << pid << ", SIGKILL) failed: " << Util::symbolicErrno(errno) << ": " << std::strerror(errno)); TST_LOG_END; } } diff --git a/wsd/Storage.cpp b/wsd/Storage.cpp index 0b3ed3545..f6f8066eb 100644 --- a/wsd/Storage.cpp +++ b/wsd/Storage.cpp @@ -269,7 +269,7 @@ std::string LocalStorage::loadStorageFileToLocal(const Authorization& /*auth*/) { // Failed LOG_WRN("link(\"" << publicFilePath << "\", \"" << _jailedFilePath << "\") failed. Will copy. " - "Linking error: " << errno << " " << strerror(errno)); + "Linking error: " << Util::symbolicErrno(errno) << " " << strerror(errno)); } try commit 40f4cf17c9be3795ebb0b5be5e2bc147176f48ab Author: Tor Lillqvist <t...@collabora.com> Date: Wed Jul 11 12:54:23 2018 +0300 Add a symbolicErrno() function to Util For a developer, it is much nicer to see "EXDEV" in a log than "18", for instance. (Sure, we often also log strerror(), but might that perhaps be localised? And the symbolic names are what one uses when coding anyway.) Change-Id: I456a8c2589147dcad87f1b4c3a20b3bd5a35d097 diff --git a/common/Util.hpp b/common/Util.hpp index cd59f7d95..afc42dcd0 100644 --- a/common/Util.hpp +++ b/common/Util.hpp @@ -11,6 +11,7 @@ #define INCLUDED_UTIL_HPP #include <cassert> +#include <cerrno> #include <cstddef> #include <atomic> #include <functional> @@ -305,6 +306,147 @@ namespace Util return s.length() >= t.length() && memcmp(s.c_str(), t.c_str(), t.length()) == 0; } + /// Return the symbolic name for an errno value, or in decimal if not handled here. + inline std::string symbolicErrno(int e) + { + // Errnos from <asm-generic/errno-base.h> and <asm-generic/errno.h> on Linux. + switch (e) + { + case EPERM: return "EPERM"; + case ENOENT: return "ENOENT"; + case ESRCH: return "ESRCH"; + case EINTR: return "EINTR"; + case EIO: return "EIO"; + case ENXIO: return "ENXIO"; + case E2BIG: return "E2BIG"; + case ENOEXEC: return "ENOEXEC"; + case EBADF: return "EBADF"; + case ECHILD: return "ECHILD"; + case EAGAIN: return "EAGAIN"; + case ENOMEM: return "ENOMEM"; + case EACCES: return "EACCES"; + case EFAULT: return "EFAULT"; + case ENOTBLK: return "ENOTBLK"; + case EBUSY: return "EBUSY"; + case EEXIST: return "EEXIST"; + case EXDEV: return "EXDEV"; + case ENODEV: return "ENODEV"; + case ENOTDIR: return "ENOTDIR"; + case EISDIR: return "EISDIR"; + case EINVAL: return "EINVAL"; + case ENFILE: return "ENFILE"; + case EMFILE: return "EMFILE"; + case ENOTTY: return "ENOTTY"; + case ETXTBSY: return "ETXTBSY"; + case EFBIG: return "EFBIG"; + case ENOSPC: return "ENOSPC"; + case ESPIPE: return "ESPIPE"; + case EROFS: return "EROFS"; + case EMLINK: return "EMLINK"; + case EPIPE: return "EPIPE"; + case EDOM: return "EDOM"; + case ERANGE: return "ERANGE"; + case EDEADLK: return "EDEADLK"; + case ENAMETOOLONG: return "ENAMETOOLONG"; + case ENOLCK: return "ENOLCK"; + case ENOSYS: return "ENOSYS"; + case ENOTEMPTY: return "ENOTEMPTY"; + case ELOOP: return "ELOOP"; + case ENOMSG: return "ENOMSG"; + case EIDRM: return "EIDRM"; + case ECHRNG: return "ECHRNG"; + case EL2NSYNC: return "EL2NSYNC"; + case EL3HLT: return "EL3HLT"; + case EL3RST: return "EL3RST"; + case ELNRNG: return "ELNRNG"; + case EUNATCH: return "EUNATCH"; + case ENOCSI: return "ENOCSI"; + case EL2HLT: return "EL2HLT"; + case EBADE: return "EBADE"; + case EBADR: return "EBADR"; + case EXFULL: return "EXFULL"; + case ENOANO: return "ENOANO"; + case EBADRQC: return "EBADRQC"; + case EBADSLT: return "EBADSLT"; + case EBFONT: return "EBFONT"; + case ENOSTR: return "ENOSTR"; + case ENODATA: return "ENODATA"; + case ETIME: return "ETIME"; + case ENOSR: return "ENOSR"; + case ENONET: return "ENONET"; + case ENOPKG: return "ENOPKG"; + case EREMOTE: return "EREMOTE"; + case ENOLINK: return "ENOLINK"; + case EADV: return "EADV"; + case ESRMNT: return "ESRMNT"; + case ECOMM: return "ECOMM"; + case EPROTO: return "EPROTO"; + case EMULTIHOP: return "EMULTIHOP"; + case EDOTDOT: return "EDOTDOT"; + case EBADMSG: return "EBADMSG"; + case EOVERFLOW: return "EOVERFLOW"; + case ENOTUNIQ: return "ENOTUNIQ"; + case EBADFD: return "EBADFD"; + case EREMCHG: return "EREMCHG"; + case ELIBACC: return "ELIBACC"; + case ELIBBAD: return "ELIBBAD"; + case ELIBSCN: return "ELIBSCN"; + case ELIBMAX: return "ELIBMAX"; + case ELIBEXEC: return "ELIBEXEC"; + case EILSEQ: return "EILSEQ"; + case ERESTART: return "ERESTART"; + case ESTRPIPE: return "ESTRPIPE"; + case EUSERS: return "EUSERS"; + case ENOTSOCK: return "ENOTSOCK"; + case EDESTADDRREQ: return "EDESTADDRREQ"; + case EMSGSIZE: return "EMSGSIZE"; + case EPROTOTYPE: return "EPROTOTYPE"; + case ENOPROTOOPT: return "ENOPROTOOPT"; + case EPROTONOSUPPORT: return "EPROTONOSUPPORT"; + case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT"; + case EOPNOTSUPP: return "EOPNOTSUPP"; + case EPFNOSUPPORT: return "EPFNOSUPPORT"; + case EAFNOSUPPORT: return "EAFNOSUPPORT"; + case EADDRINUSE: return "EADDRINUSE"; + case EADDRNOTAVAIL: return "EADDRNOTAVAIL"; + case ENETDOWN: return "ENETDOWN"; + case ENETUNREACH: return "ENETUNREACH"; + case ENETRESET: return "ENETRESET"; + case ECONNABORTED: return "ECONNABORTED"; + case ECONNRESET: return "ECONNRESET"; + case ENOBUFS: return "ENOBUFS"; + case EISCONN: return "EISCONN"; + case ENOTCONN: return "ENOTCONN"; + case ESHUTDOWN: return "ESHUTDOWN"; + case ETOOMANYREFS: return "ETOOMANYREFS"; + case ETIMEDOUT: return "ETIMEDOUT"; + case ECONNREFUSED: return "ECONNREFUSED"; + case EHOSTDOWN: return "EHOSTDOWN"; + case EHOSTUNREACH: return "EHOSTUNREACH"; + case EALREADY: return "EALREADY"; + case EINPROGRESS: return "EINPROGRESS"; + case ESTALE: return "ESTALE"; + case EUCLEAN: return "EUCLEAN"; + case ENOTNAM: return "ENOTNAM"; + case ENAVAIL: return "ENAVAIL"; + case EISNAM: return "EISNAM"; + case EREMOTEIO: return "EREMOTEIO"; + case EDQUOT: return "EDQUOT"; + case ENOMEDIUM: return "ENOMEDIUM"; + case EMEDIUMTYPE: return "EMEDIUMTYPE"; + case ECANCELED: return "ECANCELED"; + case ENOKEY: return "ENOKEY"; + case EKEYEXPIRED: return "EKEYEXPIRED"; + case EKEYREVOKED: return "EKEYREVOKED"; + case EKEYREJECTED: return "EKEYREJECTED"; + case EOWNERDEAD: return "EOWNERDEAD"; + case ENOTRECOVERABLE: return "ENOTRECOVERABLE"; + case ERFKILL: return "ERFKILL"; + case EHWPOISON: return "EHWPOISON"; + default: return std::to_string(e); + } + } + /// Check for the URI scheme validity. /// For now just a basic sanity check, can be extended if necessary. bool isValidURIScheme(const std::string& scheme); _______________________________________________ Libreoffice-commits mailing list libreoffice-comm...@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits