1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
3 /*
4 * Ceph - scalable distributed file system
5 *
6 * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
7 *
8 * This is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License version 2.1, as published by the Free Software
11 * Foundation. See file COPYING.
12 *
13 */
14
15 #ifndef CEPH_MMDSBEACON_H
16 #define CEPH_MMDSBEACON_H
17
18 #include <string_view>
19
20 #include "msg/Message.h"
21 #include "messages/PaxosServiceMessage.h"
22
23 #include "include/types.h"
24
25 #include "mds/MDSMap.h"
26
27
28
29 /**
30 * Unique ID for each type of metric we can send to the mon, so that if the mon
31 * knows about the IDs then it can implement special behaviour for certain
32 * messages.
33 */
34 enum mds_metric_t {
35 MDS_HEALTH_NULL = 0,
36 MDS_HEALTH_TRIM,
37 MDS_HEALTH_CLIENT_RECALL,
38 MDS_HEALTH_CLIENT_LATE_RELEASE,
39 MDS_HEALTH_CLIENT_RECALL_MANY,
40 MDS_HEALTH_CLIENT_LATE_RELEASE_MANY,
41 MDS_HEALTH_CLIENT_OLDEST_TID,
42 MDS_HEALTH_CLIENT_OLDEST_TID_MANY,
43 MDS_HEALTH_DAMAGE,
44 MDS_HEALTH_READ_ONLY,
45 MDS_HEALTH_SLOW_REQUEST,
46 MDS_HEALTH_CACHE_OVERSIZED,
47 MDS_HEALTH_SLOW_METADATA_IO,
48 };
49
50 inline const char *mds_metric_name(mds_metric_t m)
51 {
52 switch (m) {
53 case MDS_HEALTH_TRIM: return "MDS_TRIM";
54 case MDS_HEALTH_CLIENT_RECALL: return "MDS_CLIENT_RECALL";
55 case MDS_HEALTH_CLIENT_LATE_RELEASE: return "MDS_CLIENT_LATE_RELEASE";
56 case MDS_HEALTH_CLIENT_RECALL_MANY: return "MDS_CLIENT_RECALL_MANY";
57 case MDS_HEALTH_CLIENT_LATE_RELEASE_MANY: return "MDS_CLIENT_LATE_RELEASE_MANY";
58 case MDS_HEALTH_CLIENT_OLDEST_TID: return "MDS_CLIENT_OLDEST_TID";
59 case MDS_HEALTH_CLIENT_OLDEST_TID_MANY: return "MDS_CLIENT_OLDEST_TID_MANY";
60 case MDS_HEALTH_DAMAGE: return "MDS_DAMAGE";
61 case MDS_HEALTH_READ_ONLY: return "MDS_READ_ONLY";
62 case MDS_HEALTH_SLOW_REQUEST: return "MDS_SLOW_REQUEST";
63 case MDS_HEALTH_CACHE_OVERSIZED: return "MDS_CACHE_OVERSIZED";
64 case MDS_HEALTH_SLOW_METADATA_IO: return "MDS_SLOW_METADATA_IO";
65 default:
66 return "???";
67 }
68 }
69
70 inline const char *mds_metric_summary(mds_metric_t m)
71 {
72 switch (m) {
73 case MDS_HEALTH_TRIM:
74 return "%num% MDSs behind on trimming";
75 case MDS_HEALTH_CLIENT_RECALL:
76 return "%num% clients failing to respond to cache pressure";
77 case MDS_HEALTH_CLIENT_LATE_RELEASE:
78 return "%num% clients failing to respond to capability release";
79 case MDS_HEALTH_CLIENT_RECALL_MANY:
80 return "%num% MDSs have many clients failing to respond to cache pressure";
81 case MDS_HEALTH_CLIENT_LATE_RELEASE_MANY:
82 return "%num% MDSs have many clients failing to respond to capability "
83 "release";
84 case MDS_HEALTH_CLIENT_OLDEST_TID:
85 return "%num% clients failing to advance oldest client/flush tid";
86 case MDS_HEALTH_CLIENT_OLDEST_TID_MANY:
87 return "%num% MDSs have clients failing to advance oldest client/flush tid";
88 case MDS_HEALTH_DAMAGE:
89 return "%num% MDSs report damaged metadata";
90 case MDS_HEALTH_READ_ONLY:
91 return "%num% MDSs are read only";
92 case MDS_HEALTH_SLOW_REQUEST:
93 return "%num% MDSs report slow requests";
94 case MDS_HEALTH_CACHE_OVERSIZED:
95 return "%num% MDSs report oversized cache";
96 case MDS_HEALTH_SLOW_METADATA_IO:
97 return "%num% MDSs report slow metadata IOs";
98 default:
99 return "???";
100 }
101 }
102
103 /**
104 * This structure is designed to allow some flexibility in how we emit health
105 * complaints, such that:
106 * - The mon doesn't have to have foreknowledge of all possible metrics: we can
107 * implement new messages in the MDS and have the mon pass them through to the user
108 * (enables us to do complex checks inside the MDS, and allows mon to be older version
109 * than MDS)
110 * - The mon has enough information to perform reductions on some types of metric, for
111 * example complaints about the same client from multiple MDSs where we might want
112 * to reduce three "client X is stale on MDS y" metrics into one "client X is stale
113 * on 3 MDSs" message.
114 */
115 struct MDSHealthMetric
116 {
117 mds_metric_t type;
118 health_status_t sev;
119 std::string message;
120 std::map<std::string, std::string> metadata;
121
122 void encode(bufferlist& bl) const {
123 ENCODE_START(1, 1, bl);
|
(1) Event cond_true: |
Condition "this->type != MDS_HEALTH_NULL", taking true branch. |
124 ceph_assert(type != MDS_HEALTH_NULL);
125 encode((uint16_t)type, bl);
|
(2) Event overrun-buffer-val: |
Overrunning buffer pointed to by "__u8 const((uint8_t)this->sev)" of 1 bytes by passing it to a function which accesses it at byte offset 7. [details] |
126 encode((uint8_t)sev, bl);
127 encode(message, bl);
128 encode(metadata, bl);
129 ENCODE_FINISH(bl);
130 }
131
132 void decode(bufferlist::const_iterator& bl) {
133 DECODE_START(1, bl);
134 decode((uint16_t&)type, bl);
135 ceph_assert(type != MDS_HEALTH_NULL);
136 decode((uint8_t&)sev, bl);
137 decode(message, bl);
138 decode(metadata, bl);
139 DECODE_FINISH(bl);
140 }
141
142 bool operator==(MDSHealthMetric const &other) const
143 {
144 return (type == other.type && sev == other.sev && message == other.message);
145 }
146
147 MDSHealthMetric() : type(MDS_HEALTH_NULL), sev(HEALTH_OK) {}
148 MDSHealthMetric(mds_metric_t type_, health_status_t sev_, std::string_view message_)
149 : type(type_), sev(sev_), message(message_) {}
150 };
151 WRITE_CLASS_ENCODER(MDSHealthMetric)
152
153
154 /**
155 * Health metrics send by the MDS to the mon, so that the mon can generate
156 * user friendly warnings about undesirable states.
157 */
158 struct MDSHealth
159 {
160 std::vector<MDSHealthMetric> metrics;
161
162 void encode(bufferlist& bl) const {
163 ENCODE_START(1, 1, bl);
164 encode(metrics, bl);
165 ENCODE_FINISH(bl);
166 }
167
168 void decode(bufferlist::const_iterator& bl) {
169 DECODE_START(1, bl);
170 decode(metrics, bl);
171 DECODE_FINISH(bl);
172 }
173
174 bool operator==(MDSHealth const &other) const
175 {
176 return metrics == other.metrics;
177 }
178 };
179 WRITE_CLASS_ENCODER(MDSHealth)
180
181
182 class MMDSBeacon : public PaxosServiceMessage {
183 private:
184
185 static constexpr int HEAD_VERSION = 7;
186 static constexpr int COMPAT_VERSION = 6;
187
188 uuid_d fsid;
189 mds_gid_t global_id = MDS_GID_NONE;
190 string name;
191
192 MDSMap::DaemonState state = MDSMap::STATE_NULL;
193 version_t seq = 0;
194
195 CompatSet compat;
196
197 MDSHealth health;
198
199 map<string, string> sys_info;
200
201 uint64_t mds_features = 0;
202
203 protected:
204 MMDSBeacon() : PaxosServiceMessage(MSG_MDS_BEACON, 0, HEAD_VERSION, COMPAT_VERSION)
205 {
206 set_priority(CEPH_MSG_PRIO_HIGH);
207 }
208 MMDSBeacon(const uuid_d &f, mds_gid_t g, const string& n, epoch_t les, MDSMap::DaemonState st, version_t se, uint64_t feat) :
209 PaxosServiceMessage(MSG_MDS_BEACON, les, HEAD_VERSION, COMPAT_VERSION),
210 fsid(f), global_id(g), name(n), state(st), seq(se),
211 mds_features(feat) {
212 set_priority(CEPH_MSG_PRIO_HIGH);
213 }
214 ~MMDSBeacon() override {}
215
216 public:
217 const uuid_d& get_fsid() const { return fsid; }
218 mds_gid_t get_global_id() const { return global_id; }
219 const string& get_name() const { return name; }
220 epoch_t get_last_epoch_seen() const { return version; }
221 MDSMap::DaemonState get_state() const { return state; }
222 version_t get_seq() const { return seq; }
223 std::string_view get_type_name() const override { return "mdsbeacon"; }
224 uint64_t get_mds_features() const { return mds_features; }
225
226 CompatSet const& get_compat() const { return compat; }
227 void set_compat(const CompatSet& c) { compat = c; }
228
229 MDSHealth const& get_health() const { return health; }
230 void set_health(const MDSHealth &h) { health = h; }
231
232 const map<string, string>& get_sys_info() const { return sys_info; }
233 void set_sys_info(const map<string, string>& i) { sys_info = i; }
234
235 void print(ostream& out) const override {
236 out << "mdsbeacon(" << global_id << "/" << name << " " << ceph_mds_state_name(state)
237 << " seq " << seq << " v" << version << ")";
238 }
239
240 void encode_payload(uint64_t features) override {
241 using ceph::encode;
242 paxos_encode();
243 encode(fsid, payload);
244 encode(global_id, payload);
245 encode((__u32)state, payload);
246 encode(seq, payload);
247 encode(name, payload);
248 encode(MDS_RANK_NONE, payload);
249 encode(std::string(), payload);
250 encode(compat, payload);
251 encode(health, payload);
252 if (state == MDSMap::STATE_BOOT) {
253 encode(sys_info, payload);
254 }
255 encode(mds_features, payload);
256 encode(FS_CLUSTER_ID_NONE, payload);
257 encode(false, payload);
258 }
259 void decode_payload() override {
260 using ceph::decode;
261 auto p = payload.cbegin();
262 paxos_decode(p);
263 decode(fsid, p);
264 decode(global_id, p);
265 decode((__u32&)state, p);
266 decode(seq, p);
267 decode(name, p);
268 {
269 mds_rank_t standby_for_rank;
270 decode(standby_for_rank, p);
271 }
272 {
273 std::string standby_for_name;
274 decode(standby_for_name, p);
275 }
276 decode(compat, p);
277 decode(health, p);
278 if (state == MDSMap::STATE_BOOT) {
279 decode(sys_info, p);
280 }
281 decode(mds_features, p);
282 {
283 fs_cluster_id_t standby_for_fscid;
284 decode(standby_for_fscid, p);
285 }
286 if (header.version >= 7) {
287 bool standby_replay;
288 decode(standby_replay, p);
289 }
290
291 if (header.version < 7 && state == MDSMap::STATE_STANDBY_REPLAY) {
292 // Old MDS daemons request the state, instead of explicitly
293 // advertising that they are configured as a replay daemon.
294 state = MDSMap::STATE_STANDBY;
295 }
296 }
297 private:
298 template<class T, typename... Args>
299 friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
300 };
301
302 #endif
303