2016-04-14 19:12:43 -05:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
|
|
/*
|
|
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
*/
|
|
|
|
|
2020-04-18 03:39:50 -05:00
|
|
|
#pragma once
|
2016-04-14 19:12:43 -05:00
|
|
|
|
2018-06-04 15:47:39 -05:00
|
|
|
#include <sys/syscall.h>
|
2017-01-19 18:26:57 -06:00
|
|
|
#include <unistd.h>
|
|
|
|
|
wsd: faster jail setup via bind-mount
loolmount now works and supports mounting and
unmounting, plus numerous improvements,
refactoring, logging, etc.. When enabled,
binding improves the jail setup time by anywhere
from 2x to orders of magnitude (in docker, f.e.).
A new config entry mount_jail_tree controls
whether mounting is used or the old method of
linking/copying of jail contents. It is set to
true by default and falls back to linking/copying.
A test mount is done when the setting is enabled,
and if mounting fails, it's disabled to avoid noise.
Temporarily disabled for unit-tests until we can
cleanup lingering mounts after Jenkins aborts our
build job. In a future patch we will have mount/jail
cleanup as part of make.
The network/system files in /etc that need frequent
refreshing are now updated in systemplate to make
their most recent version available in the jails.
These files can change during the course of loolwsd
lifetime, and are unlikely to be updated in
systemplate after installation at all. We link to
them in the systemplate/etc directory, and if that
fails, we copy them before forking each kit
instance to have the latest.
This reworks the approach used to bind-mount the
jails and the templates such that the total is
now down to only three mounts: systemplate, lo, tmp.
As now systemplate and lotemplate are shared, they
must be mounted as readonly, this means that user/
must now be moved into tmp/user/ which is writable.
The mount-points must be recursive, because we mount
lo/ within the mount-point of systemplate (which is
the root of the jail). But because we (re)bind
recursively, and because both systemplate and
lotemplate are mounted for each jails, we need to
make them unbindable, so they wouldn't multiply the
mount-points for each jails (an explosive growth!)
Contrarywise, we don't want the mount-points to
be shared, because we don't expect to add/remove
mounts after a jail is created.
The random temp directory is now created and set
correctly, plus many logging and other improvements.
Change-Id: Iae3fda5e876cf47d2cae6669a87b5b826a8748df
Reviewed-on: https://gerrit.libreoffice.org/c/online/+/92829
Tested-by: Jenkins
Tested-by: Jenkins CollaboraOffice <jenkinscollaboraoffice@gmail.com>
Reviewed-by: Ashod Nakashian <ashnakash@gmail.com>
2020-04-09 08:02:58 -05:00
|
|
|
#include <cerrno>
|
2018-02-25 13:18:04 -06:00
|
|
|
#include <cstddef>
|
2016-04-14 19:12:43 -05:00
|
|
|
#include <functional>
|
2019-05-22 01:31:59 -05:00
|
|
|
#include <iostream>
|
2018-01-22 08:11:43 -06:00
|
|
|
#include <thread>
|
2016-10-29 20:15:00 -05:00
|
|
|
#include <sstream>
|
|
|
|
#include <string>
|
2016-04-14 19:12:43 -05:00
|
|
|
|
2021-11-16 07:49:41 -06:00
|
|
|
#include <Poco/LocalDateTime.h>
|
2017-06-10 09:45:00 -05:00
|
|
|
#include <Poco/DateTimeFormat.h>
|
|
|
|
#include <Poco/DateTimeFormatter.h>
|
2016-04-14 19:12:43 -05:00
|
|
|
#include <Poco/Logger.h>
|
|
|
|
|
2019-02-13 09:08:01 -06:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
#include <android/log.h>
|
|
|
|
#endif
|
|
|
|
|
2018-07-11 04:58:10 -05:00
|
|
|
#include "Util.hpp"
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
namespace Log
|
|
|
|
{
|
2018-07-16 20:42:17 -05:00
|
|
|
/// Initialize the logging system.
|
2016-08-07 22:32:39 -05:00
|
|
|
void initialize(const std::string& name,
|
2017-01-16 06:04:15 -06:00
|
|
|
const std::string& logLevel,
|
|
|
|
const bool withColor,
|
|
|
|
const bool logToFile,
|
2018-08-13 02:26:09 -05:00
|
|
|
const std::map<std::string, std::string>& config);
|
2018-07-16 20:42:17 -05:00
|
|
|
|
2021-05-28 10:14:18 -05:00
|
|
|
/// Returns the underlying logging system. Return value is effectively thread-local.
|
2016-04-14 19:12:43 -05:00
|
|
|
Poco::Logger& logger();
|
2017-01-19 18:26:57 -06:00
|
|
|
|
2018-07-16 20:42:17 -05:00
|
|
|
/// Shutdown and release the logging system.
|
|
|
|
void shutdown();
|
2020-03-12 10:06:40 -05:00
|
|
|
|
2021-05-28 10:14:18 -05:00
|
|
|
void setThreadLocalLogLevel(const std::string& logLevel);
|
|
|
|
|
2020-03-12 10:06:40 -05:00
|
|
|
#if !MOBILEAPP
|
|
|
|
extern bool IsShutdown;
|
|
|
|
|
2019-09-16 03:55:26 -05:00
|
|
|
/// Was static shutdown() called? If so, producing more logs should be avoided.
|
2020-03-12 10:06:40 -05:00
|
|
|
inline bool isShutdownCalled() { return IsShutdown; }
|
2019-09-16 04:29:22 -05:00
|
|
|
#else
|
|
|
|
constexpr bool isShutdownCalled() { return false; }
|
2019-05-13 08:45:24 -05:00
|
|
|
#endif
|
2018-07-16 20:42:17 -05:00
|
|
|
|
2020-04-25 12:03:32 -05:00
|
|
|
/// Generates log entry prefix. Example follows (without the pipes).
|
|
|
|
/// |wsd-07272-07298 2020-04-25 17:29:28.928697 [ websrv_poll ] TRC |
|
|
|
|
/// This is fully signal-safe. Buffer must be at least 128 bytes.
|
2021-11-16 07:49:41 -06:00
|
|
|
char* prefix(const Poco::LocalDateTime& time, char* buffer, const char* level);
|
2020-04-25 12:03:32 -05:00
|
|
|
template <int Size> inline char* prefix(char buffer[Size], const char* level)
|
|
|
|
{
|
|
|
|
static_assert(Size >= 128, "Buffer size must be at least 128 bytes.");
|
2021-11-16 07:49:41 -06:00
|
|
|
return prefix(Poco::LocalDateTime(), buffer, level);
|
2020-04-25 12:03:32 -05:00
|
|
|
}
|
2016-04-14 19:12:43 -05:00
|
|
|
|
2017-01-19 18:26:57 -06:00
|
|
|
inline bool traceEnabled() { return logger().trace(); }
|
|
|
|
inline bool debugEnabled() { return logger().debug(); }
|
|
|
|
inline bool infoEnabled() { return logger().information(); }
|
|
|
|
inline bool warnEnabled() { return logger().warning(); }
|
|
|
|
inline bool errorEnabled() { return logger().error(); }
|
|
|
|
inline bool fatalEnabled() { return logger().fatal(); }
|
2016-10-30 18:07:41 -05:00
|
|
|
|
2021-05-28 10:14:18 -05:00
|
|
|
const std::string& getLevel();
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
/// The following is to write streaming logs.
|
|
|
|
/// Log::info() << "Value: 0x" << std::hex << value
|
|
|
|
/// << ", pointer: " << this << Log::end;
|
|
|
|
static const struct _end_marker
|
|
|
|
{
|
|
|
|
_end_marker()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
} end;
|
|
|
|
|
2016-08-13 23:01:13 -05:00
|
|
|
/// Helper class to support implementing streaming
|
|
|
|
/// operator for logging.
|
2016-04-14 19:12:43 -05:00
|
|
|
class StreamLogger
|
|
|
|
{
|
2016-10-29 20:15:00 -05:00
|
|
|
public:
|
2016-10-30 18:07:41 -05:00
|
|
|
/// No-op instance.
|
|
|
|
StreamLogger()
|
|
|
|
: _enabled(false)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-01-19 18:26:57 -06:00
|
|
|
StreamLogger(std::function<void(const std::string&)> func, const char*level)
|
2016-10-30 18:07:41 -05:00
|
|
|
: _func(std::move(func)),
|
|
|
|
_enabled(true)
|
2016-10-29 20:15:00 -05:00
|
|
|
{
|
2017-01-19 18:26:57 -06:00
|
|
|
char buffer[1024];
|
2020-04-25 12:03:32 -05:00
|
|
|
_stream << prefix<sizeof(buffer) - 1>(buffer, level);
|
2016-10-29 20:15:00 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
StreamLogger(StreamLogger&& sl) noexcept
|
2016-10-30 18:07:41 -05:00
|
|
|
: _stream(sl._stream.str()),
|
|
|
|
_func(std::move(sl._func)),
|
|
|
|
_enabled(sl._enabled)
|
2016-10-29 20:15:00 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-10-30 18:07:41 -05:00
|
|
|
bool enabled() const { return _enabled; }
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
void flush() const
|
|
|
|
{
|
2016-10-30 18:07:41 -05:00
|
|
|
if (_enabled)
|
|
|
|
{
|
|
|
|
_func(_stream.str());
|
|
|
|
}
|
2016-10-29 20:15:00 -05:00
|
|
|
}
|
|
|
|
|
2018-11-19 02:05:57 -06:00
|
|
|
std::ostringstream& getStream() { return _stream; }
|
2016-10-29 20:15:00 -05:00
|
|
|
|
|
|
|
private:
|
2018-11-19 02:05:57 -06:00
|
|
|
std::ostringstream _stream;
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
std::function<void(const std::string&)> _func;
|
2016-10-30 18:07:41 -05:00
|
|
|
const bool _enabled;
|
2016-04-14 19:12:43 -05:00
|
|
|
};
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger trace()
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:07:41 -05:00
|
|
|
return traceEnabled()
|
2016-10-30 18:16:57 -05:00
|
|
|
? StreamLogger([](const std::string& msg) { logger().trace(msg); }, "TRC")
|
2016-10-30 18:07:41 -05:00
|
|
|
: StreamLogger();
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger debug()
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:16:57 -05:00
|
|
|
return debugEnabled()
|
|
|
|
? StreamLogger([](const std::string& msg) { logger().debug(msg); }, "DBG")
|
|
|
|
: StreamLogger();
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger info()
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:16:57 -05:00
|
|
|
return infoEnabled()
|
|
|
|
? StreamLogger([](const std::string& msg) { logger().information(msg); }, "INF")
|
|
|
|
: StreamLogger();
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger warn()
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:16:57 -05:00
|
|
|
return warnEnabled()
|
|
|
|
? StreamLogger([](const std::string& msg) { logger().warning(msg); }, "WRN")
|
|
|
|
: StreamLogger();
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger error()
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:16:57 -05:00
|
|
|
return errorEnabled()
|
|
|
|
? StreamLogger([](const std::string& msg) { logger().error(msg); }, "ERR")
|
|
|
|
: StreamLogger();
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline StreamLogger fatal()
|
2016-10-14 04:47:48 -05:00
|
|
|
{
|
2016-10-30 18:16:57 -05:00
|
|
|
return fatalEnabled()
|
|
|
|
? StreamLogger([](const std::string& msg) { logger().fatal(msg); }, "FTL")
|
|
|
|
: StreamLogger();
|
2016-10-14 04:47:48 -05:00
|
|
|
}
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
template <typename U>
|
2016-10-29 20:15:00 -05:00
|
|
|
StreamLogger& operator<<(StreamLogger& lhs, const U& rhs)
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:07:41 -05:00
|
|
|
if (lhs.enabled())
|
|
|
|
{
|
2018-11-19 02:05:57 -06:00
|
|
|
lhs.getStream() << rhs;
|
2016-10-30 18:07:41 -05:00
|
|
|
}
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U>
|
2016-10-29 20:15:00 -05:00
|
|
|
StreamLogger& operator<<(StreamLogger&& lhs, U&& rhs)
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
2016-10-30 18:07:41 -05:00
|
|
|
if (lhs.enabled())
|
|
|
|
{
|
2018-11-19 02:05:57 -06:00
|
|
|
lhs.getStream() << rhs;
|
2016-10-30 18:07:41 -05:00
|
|
|
}
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
|
2019-08-30 12:37:55 -05:00
|
|
|
inline StreamLogger& operator<<(StreamLogger& lhs, const std::chrono::system_clock::time_point& rhs)
|
|
|
|
{
|
|
|
|
if (lhs.enabled())
|
|
|
|
{
|
|
|
|
lhs.getStream() << Util::getIso8601FracformatTime(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
|
2016-10-29 20:15:00 -05:00
|
|
|
inline void operator<<(StreamLogger& lhs, const _end_marker&)
|
2016-04-14 19:12:43 -05:00
|
|
|
{
|
|
|
|
(void)end;
|
|
|
|
lhs.flush();
|
|
|
|
}
|
2018-01-22 08:11:43 -06:00
|
|
|
|
|
|
|
/// Dump the invalid id as 0, otherwise dump in hex.
|
2021-03-11 17:26:23 -06:00
|
|
|
/// Note: std::thread::id defines operator<< which
|
|
|
|
/// serializes in decimal. We need this for hex.
|
2018-01-22 08:11:43 -06:00
|
|
|
inline std::string to_string(const std::thread::id& id)
|
|
|
|
{
|
|
|
|
if (id != std::thread::id())
|
|
|
|
{
|
|
|
|
std::ostringstream os;
|
2019-09-29 22:32:45 -05:00
|
|
|
os << std::hex << "0x" << id;
|
2018-01-22 08:11:43 -06:00
|
|
|
return os.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
return "0";
|
|
|
|
}
|
2016-04-14 19:12:43 -05:00
|
|
|
}
|
|
|
|
|
2022-04-16 13:21:25 -05:00
|
|
|
/// A default implementation that is a NOP.
|
|
|
|
/// Any context can implement this to prefix its log entries.
|
2022-04-21 17:59:33 -05:00
|
|
|
inline void logPrefix(std::ostream&) {}
|
2022-04-16 13:21:25 -05:00
|
|
|
|
2022-04-17 10:43:56 -05:00
|
|
|
#ifdef IOS
|
2018-10-17 04:54:36 -05:00
|
|
|
// We know that when building with Xcode, __FILE__ will always be a full path, with several slashes,
|
|
|
|
// so this will always work. We want just the file name, they are unique anyway.
|
2022-04-17 10:43:56 -05:00
|
|
|
/// Strip the path and leave only the filename.
|
|
|
|
template <std::size_t N>
|
|
|
|
static constexpr std::size_t skipPathToFilename(const char (&s)[N], std::size_t n = N - 1)
|
|
|
|
{
|
|
|
|
return n == 0 ? 0 : s[n] == '/' ? n + 1 : skipPathToFilename(s, n - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LOG_FILE_NAME(f) (&f[skipPathToFilename(f)])
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
/// Strip the path prefix ("./") that is noisy.
|
|
|
|
template <std::size_t N>
|
|
|
|
static constexpr std::size_t skipPathPrefix(const char (&s)[N], std::size_t n = 0)
|
|
|
|
{
|
|
|
|
return s[n] == '.' || s[n] == '/' ? skipPathPrefix(s, n + 1) : n;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LOG_FILE_NAME(f) (&f[skipPathPrefix(f)])
|
2018-10-17 04:54:36 -05:00
|
|
|
#endif
|
|
|
|
|
2022-04-03 12:25:19 -05:00
|
|
|
#define STRINGIFY(X) #X
|
|
|
|
#define STRING(X) STRINGIFY(X)
|
|
|
|
|
2019-02-13 09:08:01 -06:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
|
2022-04-17 08:31:09 -05:00
|
|
|
#define LOG_LOG(LOG, PRIO, LVL, STR) \
|
|
|
|
((void)__android_log_print(ANDROID_LOG_DEBUG, "coolwsd", "%s %s", LVL, STR.c_str()))
|
2019-02-13 09:08:01 -06:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
2022-04-17 08:31:09 -05:00
|
|
|
#define LOG_LOG(LOG, PRIO, LVL, STR) \
|
|
|
|
LOG.log(Poco::Message(LOG.name(), STR, Poco::Message::PRIO_##PRIO))
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define LOG_END_NOFILE(LOG) (void)0
|
|
|
|
|
2022-04-17 10:43:56 -05:00
|
|
|
#define LOG_END(LOG) LOG << "| " << LOG_FILE_NAME(__FILE__) << ":" STRING(__LINE__)
|
2022-04-17 08:31:09 -05:00
|
|
|
|
|
|
|
#define LOG_BODY_(LOG, PRIO, LVL, X, END) \
|
2020-02-19 21:00:08 -06:00
|
|
|
char b_[1024]; \
|
2020-04-25 12:03:32 -05:00
|
|
|
std::ostringstream oss_(Log::prefix<sizeof(b_) - 1>(b_, LVL), std::ostringstream::ate); \
|
2022-04-16 13:21:25 -05:00
|
|
|
logPrefix(oss_); \
|
2020-02-19 21:00:08 -06:00
|
|
|
oss_ << std::boolalpha << X; \
|
2022-04-17 08:31:09 -05:00
|
|
|
END(oss_); \
|
|
|
|
LOG_LOG(LOG, PRIO, LVL, oss_.str())
|
2019-02-13 09:08:01 -06:00
|
|
|
|
2022-06-14 15:18:03 -05:00
|
|
|
#define LOG_ANY(X) \
|
|
|
|
char b_[1024]; \
|
|
|
|
std::ostringstream oss_(Log::prefix<sizeof(b_) - 1>(b_, "INF"), std::ostringstream::ate); \
|
|
|
|
logPrefix(oss_); \
|
|
|
|
oss_ << std::boolalpha << X; \
|
|
|
|
LOG_END(oss_); \
|
|
|
|
Poco::AutoPtr<Poco::Channel> channel = Log::logger().getChannel(); \
|
|
|
|
channel->log(Poco::Message("", oss_.str(), Poco::Message::Priority::PRIO_INFORMATION))
|
|
|
|
|
2022-05-27 16:01:40 -05:00
|
|
|
#if defined __GNUC__ || defined __clang__
|
|
|
|
# define LOG_CONDITIONAL(log,type) \
|
|
|
|
__builtin_expect((!Log::isShutdownCalled() && log.type()), 0)
|
|
|
|
#else
|
|
|
|
# define LOG_CONDITIONAL(log,type) \
|
|
|
|
(!Log::isShutdownCalled() && log.type())
|
|
|
|
#endif
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_TRC(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, trace)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, TRACE, "TRC", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_TRC_NOFILE(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, trace)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, TRACE, "TRC", X, LOG_END_NOFILE); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_DBG(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, debug)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, DEBUG, "DBG", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_INF(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, information)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, INFORMATION, "INF", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-07-14 08:43:07 -05:00
|
|
|
#define LOG_INF_NOFILE(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, information)) \
|
2020-07-14 08:43:07 -05:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, INFORMATION, "INF", X, LOG_END_NOFILE); \
|
2020-07-14 08:43:07 -05:00
|
|
|
} \
|
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_WRN(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, warning)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, WARNING, "WRN", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_ERR(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, error)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, ERROR, "ERR", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-12-24 07:58:47 -06:00
|
|
|
/// Log an ERR entry with the given errno appended.
|
|
|
|
#define LOG_SYS_ERRNO(ERRNO, X) \
|
2020-02-19 21:00:08 -06:00
|
|
|
do \
|
|
|
|
{ \
|
2020-12-24 07:58:47 -06:00
|
|
|
const auto onrre = ERRNO; /* Save errno immediately while avoiding name clashes*/ \
|
|
|
|
LOG_ERR(X << " (" << Util::symbolicErrno(onrre) << ": " << std::strerror(onrre) << ')'); \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-12-24 07:58:47 -06:00
|
|
|
/// Log an ERR entry with errno appended.
|
|
|
|
/// NOTE: Must be called immediately after an API that sets errno.
|
|
|
|
/// Use LOG_SYS_ERRNO to pass errno explicitly.
|
|
|
|
#define LOG_SYS(X) LOG_SYS_ERRNO(errno, X)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_FTL(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
std::cerr << X << std::endl; \
|
|
|
|
auto& log_ = Log::logger(); \
|
2022-05-27 16:01:40 -05:00
|
|
|
if (LOG_CONDITIONAL(log_, fatal)) \
|
2020-02-19 21:00:08 -06:00
|
|
|
{ \
|
2022-04-17 08:31:09 -05:00
|
|
|
LOG_BODY_(log_, FATAL, "FTL", X, LOG_END); \
|
2020-02-19 21:00:08 -06:00
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-12-24 07:58:47 -06:00
|
|
|
/// Log an FTL (fatal) entry with errno appended.
|
|
|
|
/// NOTE: Must be called immediately after an API that sets errno.
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_SFL(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
2020-12-24 07:58:47 -06:00
|
|
|
const auto onrre = errno; /* Save errno immediately while avoiding name clashes*/ \
|
|
|
|
LOG_FTL(X << " (" << Util::symbolicErrno(onrre) << ": " << std::strerror(onrre) << ')'); \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_CHECK(X) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (!(X)) \
|
|
|
|
{ \
|
|
|
|
LOG_ERR("Check failed. Expected (" #X ")."); \
|
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
|
|
|
|
2020-02-19 21:00:08 -06:00
|
|
|
#define LOG_CHECK_RET(X, RET) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (!(X)) \
|
|
|
|
{ \
|
|
|
|
LOG_ERR("Check failed. Expected (" #X ")."); \
|
|
|
|
return RET; \
|
|
|
|
} \
|
2018-06-04 09:23:58 -05:00
|
|
|
} while (false)
|
2016-12-12 22:31:00 -06:00
|
|
|
|
2022-04-03 15:43:34 -05:00
|
|
|
/// Assert the truth of a condition, with a custom message.
|
|
|
|
#define LOG_ASSERT_INTERNAL(condition, message, LOG) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
auto&& cond##__LINE__ = !!(condition); \
|
|
|
|
if (!cond##__LINE__) \
|
|
|
|
{ \
|
|
|
|
std::ostringstream oss##__LINE__; \
|
|
|
|
oss##__LINE__ << message; \
|
|
|
|
const auto msg##__LINE__ = oss##__LINE__.str(); \
|
|
|
|
LOG("ERROR: Assertion failure: " \
|
|
|
|
<< (msg##__LINE__.empty() ? "" : msg##__LINE__ + ". ") \
|
|
|
|
<< "Condition: " << (#condition)); \
|
2022-04-19 13:21:26 -05:00
|
|
|
assert(!#condition); \
|
2022-04-03 15:43:34 -05:00
|
|
|
} \
|
|
|
|
} while (false)
|
|
|
|
|
|
|
|
/// Assert the truth of a condition.
|
|
|
|
#if defined(NDEBUG)
|
|
|
|
// In release mode assertions are logged as debug-level, since they are for developers.
|
|
|
|
#define LOG_ASSERT_MSG(condition, message) \
|
|
|
|
LOG_ASSERT_INTERNAL(condition, "Precondition failed", LOG_DBG)
|
|
|
|
#define LOG_ASSERT(condition) LOG_ASSERT_MSG(condition, "Precondition failed")
|
|
|
|
#else
|
|
|
|
// In debug mode assertions are errors.
|
|
|
|
#define LOG_ASSERT_MSG(condition, message) LOG_ASSERT_INTERNAL(condition, message, LOG_ERR)
|
|
|
|
#define LOG_ASSERT(condition) LOG_ASSERT_MSG(condition, "Precondition failed")
|
|
|
|
#endif
|
|
|
|
|
2016-04-14 19:12:43 -05:00
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|