1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include <linux/ceph/ceph_debug.h>
3
4 #include <linux/types.h>
5 #include <linux/percpu_counter.h>
6 #include <linux/math64.h>
7
8 #include "metric.h"
9 #include "mds_client.h"
10
ktime_to_ceph_timespec(struct ceph_timespec * ts,ktime_t val)11 static void ktime_to_ceph_timespec(struct ceph_timespec *ts, ktime_t val)
12 {
13 struct timespec64 t = ktime_to_timespec64(val);
14 ceph_encode_timespec64(ts, &t);
15 }
16
ceph_mdsc_send_metrics(struct ceph_mds_client * mdsc,struct ceph_mds_session * s)17 static bool ceph_mdsc_send_metrics(struct ceph_mds_client *mdsc,
18 struct ceph_mds_session *s)
19 {
20 struct ceph_metric_head *head;
21 struct ceph_metric_cap *cap;
22 struct ceph_metric_read_latency *read;
23 struct ceph_metric_write_latency *write;
24 struct ceph_metric_metadata_latency *meta;
25 struct ceph_metric_dlease *dlease;
26 struct ceph_opened_files *files;
27 struct ceph_pinned_icaps *icaps;
28 struct ceph_opened_inodes *inodes;
29 struct ceph_read_io_size *rsize;
30 struct ceph_write_io_size *wsize;
31 struct ceph_client_metric *m = &mdsc->metric;
32 u64 nr_caps = atomic64_read(&m->total_caps);
33 u32 header_len = sizeof(struct ceph_metric_header);
34 struct ceph_msg *msg;
35 s64 sum;
36 s32 items = 0;
37 s32 len;
38
39 /* Do not send the metrics until the MDS rank is ready */
40 mutex_lock(&mdsc->mutex);
41 if (ceph_mdsmap_get_state(mdsc->mdsmap, s->s_mds) != CEPH_MDS_STATE_ACTIVE) {
42 mutex_unlock(&mdsc->mutex);
43 return false;
44 }
45 mutex_unlock(&mdsc->mutex);
46
47 len = sizeof(*head) + sizeof(*cap) + sizeof(*read) + sizeof(*write)
48 + sizeof(*meta) + sizeof(*dlease) + sizeof(*files)
49 + sizeof(*icaps) + sizeof(*inodes) + sizeof(*rsize)
50 + sizeof(*wsize);
51
52 msg = ceph_msg_new(CEPH_MSG_CLIENT_METRICS, len, GFP_NOFS, true);
53 if (!msg) {
54 pr_err("send metrics to mds%d, failed to allocate message\n",
55 s->s_mds);
56 return false;
57 }
58
59 head = msg->front.iov_base;
60
61 /* encode the cap metric */
62 cap = (struct ceph_metric_cap *)(head + 1);
63 cap->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_CAP_INFO);
64 cap->header.ver = 1;
65 cap->header.compat = 1;
66 cap->header.data_len = cpu_to_le32(sizeof(*cap) - header_len);
67 cap->hit = cpu_to_le64(percpu_counter_sum(&m->i_caps_hit));
68 cap->mis = cpu_to_le64(percpu_counter_sum(&m->i_caps_mis));
69 cap->total = cpu_to_le64(nr_caps);
70 items++;
71
72 /* encode the read latency metric */
73 read = (struct ceph_metric_read_latency *)(cap + 1);
74 read->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_LATENCY);
75 read->header.ver = 2;
76 read->header.compat = 1;
77 read->header.data_len = cpu_to_le32(sizeof(*read) - header_len);
78 sum = m->metric[METRIC_READ].latency_sum;
79 ktime_to_ceph_timespec(&read->lat, sum);
80 ktime_to_ceph_timespec(&read->avg, m->metric[METRIC_READ].latency_avg);
81 read->sq_sum = cpu_to_le64(m->metric[METRIC_READ].latency_sq_sum);
82 read->count = cpu_to_le64(m->metric[METRIC_READ].total);
83 items++;
84
85 /* encode the write latency metric */
86 write = (struct ceph_metric_write_latency *)(read + 1);
87 write->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_LATENCY);
88 write->header.ver = 2;
89 write->header.compat = 1;
90 write->header.data_len = cpu_to_le32(sizeof(*write) - header_len);
91 sum = m->metric[METRIC_WRITE].latency_sum;
92 ktime_to_ceph_timespec(&write->lat, sum);
93 ktime_to_ceph_timespec(&write->avg, m->metric[METRIC_WRITE].latency_avg);
94 write->sq_sum = cpu_to_le64(m->metric[METRIC_WRITE].latency_sq_sum);
95 write->count = cpu_to_le64(m->metric[METRIC_WRITE].total);
96 items++;
97
98 /* encode the metadata latency metric */
99 meta = (struct ceph_metric_metadata_latency *)(write + 1);
100 meta->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_METADATA_LATENCY);
101 meta->header.ver = 2;
102 meta->header.compat = 1;
103 meta->header.data_len = cpu_to_le32(sizeof(*meta) - header_len);
104 sum = m->metric[METRIC_METADATA].latency_sum;
105 ktime_to_ceph_timespec(&meta->lat, sum);
106 ktime_to_ceph_timespec(&meta->avg, m->metric[METRIC_METADATA].latency_avg);
107 meta->sq_sum = cpu_to_le64(m->metric[METRIC_METADATA].latency_sq_sum);
108 meta->count = cpu_to_le64(m->metric[METRIC_METADATA].total);
109 items++;
110
111 /* encode the dentry lease metric */
112 dlease = (struct ceph_metric_dlease *)(meta + 1);
113 dlease->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_DENTRY_LEASE);
114 dlease->header.ver = 1;
115 dlease->header.compat = 1;
116 dlease->header.data_len = cpu_to_le32(sizeof(*dlease) - header_len);
117 dlease->hit = cpu_to_le64(percpu_counter_sum(&m->d_lease_hit));
118 dlease->mis = cpu_to_le64(percpu_counter_sum(&m->d_lease_mis));
119 dlease->total = cpu_to_le64(atomic64_read(&m->total_dentries));
120 items++;
121
122 sum = percpu_counter_sum(&m->total_inodes);
123
124 /* encode the opened files metric */
125 files = (struct ceph_opened_files *)(dlease + 1);
126 files->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_FILES);
127 files->header.ver = 1;
128 files->header.compat = 1;
129 files->header.data_len = cpu_to_le32(sizeof(*files) - header_len);
130 files->opened_files = cpu_to_le64(atomic64_read(&m->opened_files));
131 files->total = cpu_to_le64(sum);
132 items++;
133
134 /* encode the pinned icaps metric */
135 icaps = (struct ceph_pinned_icaps *)(files + 1);
136 icaps->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_PINNED_ICAPS);
137 icaps->header.ver = 1;
138 icaps->header.compat = 1;
139 icaps->header.data_len = cpu_to_le32(sizeof(*icaps) - header_len);
140 icaps->pinned_icaps = cpu_to_le64(nr_caps);
141 icaps->total = cpu_to_le64(sum);
142 items++;
143
144 /* encode the opened inodes metric */
145 inodes = (struct ceph_opened_inodes *)(icaps + 1);
146 inodes->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_INODES);
147 inodes->header.ver = 1;
148 inodes->header.compat = 1;
149 inodes->header.data_len = cpu_to_le32(sizeof(*inodes) - header_len);
150 inodes->opened_inodes = cpu_to_le64(percpu_counter_sum(&m->opened_inodes));
151 inodes->total = cpu_to_le64(sum);
152 items++;
153
154 /* encode the read io size metric */
155 rsize = (struct ceph_read_io_size *)(inodes + 1);
156 rsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_IO_SIZES);
157 rsize->header.ver = 1;
158 rsize->header.compat = 1;
159 rsize->header.data_len = cpu_to_le32(sizeof(*rsize) - header_len);
160 rsize->total_ops = cpu_to_le64(m->metric[METRIC_READ].total);
161 rsize->total_size = cpu_to_le64(m->metric[METRIC_READ].size_sum);
162 items++;
163
164 /* encode the write io size metric */
165 wsize = (struct ceph_write_io_size *)(rsize + 1);
166 wsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_IO_SIZES);
167 wsize->header.ver = 1;
168 wsize->header.compat = 1;
169 wsize->header.data_len = cpu_to_le32(sizeof(*wsize) - header_len);
170 wsize->total_ops = cpu_to_le64(m->metric[METRIC_WRITE].total);
171 wsize->total_size = cpu_to_le64(m->metric[METRIC_WRITE].size_sum);
172 items++;
173
174 put_unaligned_le32(items, &head->num);
175 msg->front.iov_len = len;
176 msg->hdr.version = cpu_to_le16(1);
177 msg->hdr.compat_version = cpu_to_le16(1);
178 msg->hdr.front_len = cpu_to_le32(msg->front.iov_len);
179 ceph_con_send(&s->s_con, msg);
180
181 return true;
182 }
183
184
metric_get_session(struct ceph_mds_client * mdsc)185 static void metric_get_session(struct ceph_mds_client *mdsc)
186 {
187 struct ceph_mds_session *s;
188 int i;
189
190 mutex_lock(&mdsc->mutex);
191 for (i = 0; i < mdsc->max_sessions; i++) {
192 s = __ceph_lookup_mds_session(mdsc, i);
193 if (!s)
194 continue;
195
196 /*
197 * Skip it if MDS doesn't support the metric collection,
198 * or the MDS will close the session's socket connection
199 * directly when it get this message.
200 */
201 if (check_session_state(s) &&
202 test_bit(CEPHFS_FEATURE_METRIC_COLLECT, &s->s_features)) {
203 mdsc->metric.session = s;
204 break;
205 }
206
207 ceph_put_mds_session(s);
208 }
209 mutex_unlock(&mdsc->mutex);
210 }
211
metric_delayed_work(struct work_struct * work)212 static void metric_delayed_work(struct work_struct *work)
213 {
214 struct ceph_client_metric *m =
215 container_of(work, struct ceph_client_metric, delayed_work.work);
216 struct ceph_mds_client *mdsc =
217 container_of(m, struct ceph_mds_client, metric);
218
219 if (mdsc->stopping || disable_send_metrics)
220 return;
221
222 if (!m->session || !check_session_state(m->session)) {
223 if (m->session) {
224 ceph_put_mds_session(m->session);
225 m->session = NULL;
226 }
227 metric_get_session(mdsc);
228 }
229 if (m->session) {
230 ceph_mdsc_send_metrics(mdsc, m->session);
231 metric_schedule_delayed(m);
232 }
233 }
234
ceph_metric_init(struct ceph_client_metric * m)235 int ceph_metric_init(struct ceph_client_metric *m)
236 {
237 struct ceph_metric *metric;
238 int ret, i;
239
240 if (!m)
241 return -EINVAL;
242
243 atomic64_set(&m->total_dentries, 0);
244 ret = percpu_counter_init(&m->d_lease_hit, 0, GFP_KERNEL);
245 if (ret)
246 return ret;
247
248 ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
249 if (ret)
250 goto err_d_lease_mis;
251
252 atomic64_set(&m->total_caps, 0);
253 ret = percpu_counter_init(&m->i_caps_hit, 0, GFP_KERNEL);
254 if (ret)
255 goto err_i_caps_hit;
256
257 ret = percpu_counter_init(&m->i_caps_mis, 0, GFP_KERNEL);
258 if (ret)
259 goto err_i_caps_mis;
260
261 for (i = 0; i < METRIC_MAX; i++) {
262 metric = &m->metric[i];
263 spin_lock_init(&metric->lock);
264 metric->size_sum = 0;
265 metric->size_min = U64_MAX;
266 metric->size_max = 0;
267 metric->total = 0;
268 metric->latency_sum = 0;
269 metric->latency_avg = 0;
270 metric->latency_sq_sum = 0;
271 metric->latency_min = KTIME_MAX;
272 metric->latency_max = 0;
273 }
274
275 atomic64_set(&m->opened_files, 0);
276 ret = percpu_counter_init(&m->opened_inodes, 0, GFP_KERNEL);
277 if (ret)
278 goto err_opened_inodes;
279 ret = percpu_counter_init(&m->total_inodes, 0, GFP_KERNEL);
280 if (ret)
281 goto err_total_inodes;
282
283 m->session = NULL;
284 INIT_DELAYED_WORK(&m->delayed_work, metric_delayed_work);
285
286 return 0;
287
288 err_total_inodes:
289 percpu_counter_destroy(&m->opened_inodes);
290 err_opened_inodes:
291 percpu_counter_destroy(&m->i_caps_mis);
292 err_i_caps_mis:
293 percpu_counter_destroy(&m->i_caps_hit);
294 err_i_caps_hit:
295 percpu_counter_destroy(&m->d_lease_mis);
296 err_d_lease_mis:
297 percpu_counter_destroy(&m->d_lease_hit);
298
299 return ret;
300 }
301
ceph_metric_destroy(struct ceph_client_metric * m)302 void ceph_metric_destroy(struct ceph_client_metric *m)
303 {
304 if (!m)
305 return;
306
307 cancel_delayed_work_sync(&m->delayed_work);
308
309 percpu_counter_destroy(&m->total_inodes);
310 percpu_counter_destroy(&m->opened_inodes);
311 percpu_counter_destroy(&m->i_caps_mis);
312 percpu_counter_destroy(&m->i_caps_hit);
313 percpu_counter_destroy(&m->d_lease_mis);
314 percpu_counter_destroy(&m->d_lease_hit);
315
316 ceph_put_mds_session(m->session);
317 }
318
319 #define METRIC_UPDATE_MIN_MAX(min, max, new) \
320 { \
321 if (unlikely(new < min)) \
322 min = new; \
323 if (unlikely(new > max)) \
324 max = new; \
325 }
326
__update_mean_and_stdev(ktime_t total,ktime_t * lavg,ktime_t * sq_sump,ktime_t lat)327 static inline void __update_mean_and_stdev(ktime_t total, ktime_t *lavg,
328 ktime_t *sq_sump, ktime_t lat)
329 {
330 ktime_t avg;
331
332 if (unlikely(total == 1)) {
333 *lavg = lat;
334 } else {
335 /* the sq is (lat - old_avg) * (lat - new_avg) */
336 avg = *lavg + div64_s64(lat - *lavg, total);
337 *sq_sump += (lat - *lavg)*(lat - avg);
338 *lavg = avg;
339 }
340 }
341
ceph_update_metrics(struct ceph_metric * m,ktime_t r_start,ktime_t r_end,unsigned int size,int rc)342 void ceph_update_metrics(struct ceph_metric *m,
343 ktime_t r_start, ktime_t r_end,
344 unsigned int size, int rc)
345 {
346 ktime_t lat = ktime_sub(r_end, r_start);
347 ktime_t total;
348
349 if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
350 return;
351
352 spin_lock(&m->lock);
353 total = ++m->total;
354 m->size_sum += size;
355 METRIC_UPDATE_MIN_MAX(m->size_min, m->size_max, size);
356 m->latency_sum += lat;
357 METRIC_UPDATE_MIN_MAX(m->latency_min, m->latency_max, lat);
358 __update_mean_and_stdev(total, &m->latency_avg, &m->latency_sq_sum,
359 lat);
360 spin_unlock(&m->lock);
361 }
362