1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2010 Sage Weil <sage@newdream.net>
* Copyright (C) 2010 Dreamhost
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_DOUT_H
#define CEPH_DOUT_H
#include <type_traits>
#include "include/ceph_assert.h"
#ifdef WITH_SEASTAR
#include <seastar/util/log.hh>
#include "crimson/common/log.h"
#include "crimson/common/config_proxy.h"
#else
#include "global/global_context.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "common/likely.h"
#include "common/Clock.h"
#include "log/Log.h"
#endif
extern void dout_emergency(const char * const str);
extern void dout_emergency(const std::string &str);
// intentionally conflict with endl
class _bad_endl_use_dendl_t { public: _bad_endl_use_dendl_t(int) {} };
static const _bad_endl_use_dendl_t endl = 0;
inline std::ostream& operator<<(std::ostream& out, _bad_endl_use_dendl_t) {
ceph_abort_msg("you are using the wrong endl.. use std::endl or dendl");
return out;
}
class DoutPrefixProvider {
public:
virtual std::ostream& gen_prefix(std::ostream& out) const = 0;
virtual CephContext *get_cct() const = 0;
virtual unsigned get_subsys() const = 0;
virtual ~DoutPrefixProvider() {}
};
// a prefix provider with empty prefix
class NoDoutPrefix : public DoutPrefixProvider {
CephContext *const cct;
const unsigned subsys;
public:
NoDoutPrefix(CephContext *cct, unsigned subsys) : cct(cct), subsys(subsys) {}
std::ostream& gen_prefix(std::ostream& out) const override { return out; }
CephContext *get_cct() const override { return cct; }
unsigned get_subsys() const override { return subsys; }
};
// a prefix provider with static (const char*) prefix
class DoutPrefix : public NoDoutPrefix {
const char *const prefix;
public:
DoutPrefix(CephContext *cct, unsigned subsys, const char *prefix)
: NoDoutPrefix(cct, subsys), prefix(prefix) {}
std::ostream& gen_prefix(std::ostream& out) const override {
return out << prefix;
}
};
// a prefix provider that composes itself on top of another
class DoutPrefixPipe : public DoutPrefixProvider {
const DoutPrefixProvider& dpp;
public:
DoutPrefixPipe(const DoutPrefixProvider& dpp) : dpp(dpp) {}
std::ostream& gen_prefix(std::ostream& out) const override final {
dpp.gen_prefix(out);
add_prefix(out);
return out;
}
CephContext *get_cct() const override { return dpp.get_cct(); }
unsigned get_subsys() const override { return dpp.get_subsys(); }
virtual void add_prefix(std::ostream& out) const = 0;
};
// helpers
namespace ceph::dout {
template<typename T>
struct dynamic_marker_t {
T value;
operator T() const { return value; }
};
template<typename T>
dynamic_marker_t<T> need_dynamic(T&& t) {
return dynamic_marker_t<T>{ std::forward<T>(t) };
}
template<typename T>
struct is_dynamic : public std::false_type {};
template<typename T>
struct is_dynamic<dynamic_marker_t<T>> : public std::true_type {};
} // ceph::dout
// generic macros
#define dout_prefix *_dout
#ifdef WITH_SEASTAR
#define dout_impl(cct, sub, v) \
do { \
if (ceph::common::local_conf()->subsys.should_gather(sub, v)) { \
seastar::logger& _logger = ceph::get_logger(sub); \
const auto _lv = v; \
std::ostringstream _out; \
std::ostream* _dout = &_out;
#define dendl_impl \
""; \
const std::string _s = _out.str(); \
if (_lv < 0) { \
_logger.error(_s.c_str()); \
} else if (_lv < 1) { \
_logger.warn(_s.c_str()); \
} else if (_lv < 5) { \
_logger.info(_s.c_str()); \
} else if (_lv < 10) { \
_logger.debug(_s.c_str()); \
} else { \
_logger.trace(_s.c_str()); \
} \
} \
} while (0)
#else
#define dout_impl(cct, sub, v) \
do { \
const bool should_gather = [&](const auto cctX) { \
if constexpr (ceph::dout::is_dynamic<decltype(sub)>::value || \
ceph::dout::is_dynamic<decltype(v)>::value) { \
return cctX->_conf->subsys.should_gather(sub, v); \
} else { \
/* The parentheses are **essential** because commas in angle \
* brackets are NOT ignored on macro expansion! A language's \
* limitation, sorry. */ \
return (cctX->_conf->subsys.template should_gather<sub, v>()); \
} \
}(cct); \
\
if (should_gather) { \
ceph::logging::MutableEntry _dout_e(v, sub); \
static_assert(std::is_convertible<decltype(&*cct), \
CephContext* >::value, \
"provided cct must be compatible with CephContext*"); \
auto _dout_cct = cct; \
std::ostream* _dout = &_dout_e.get_ostream();
#define dendl_impl std::flush; \
_dout_cct->_log->submit_entry(std::move(_dout_e)); \
} \
} while (0)
#endif // WITH_SEASTAR
#define lsubdout(cct, sub, v) dout_impl(cct, ceph_subsys_##sub, v) dout_prefix
#define ldout(cct, v) dout_impl(cct, dout_subsys, v) dout_prefix
#define lderr(cct) dout_impl(cct, ceph_subsys_, -1) dout_prefix
#define ldpp_dout(dpp, v) \
if (decltype(auto) pdpp = (dpp); pdpp) /* workaround -Wnonnull-compare for 'this' */ \
dout_impl(pdpp->get_cct(), ceph::dout::need_dynamic(pdpp->get_subsys()), v) \
pdpp->gen_prefix(*_dout)
#define lgeneric_subdout(cct, sub, v) dout_impl(cct, ceph_subsys_##sub, v) *_dout
#define lgeneric_dout(cct, v) dout_impl(cct, ceph_subsys_, v) *_dout
#define lgeneric_derr(cct) dout_impl(cct, ceph_subsys_, -1) *_dout
#define ldlog_p1(cct, sub, lvl) \
(cct->_conf->subsys.should_gather((sub), (lvl)))
#define dendl dendl_impl
#endif
|
