Loading...
Note: File does not exist in v3.15.
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
11static bool ceph_mdsc_send_metrics(struct ceph_mds_client *mdsc,
12 struct ceph_mds_session *s)
13{
14 struct ceph_metric_head *head;
15 struct ceph_metric_cap *cap;
16 struct ceph_metric_read_latency *read;
17 struct ceph_metric_write_latency *write;
18 struct ceph_metric_metadata_latency *meta;
19 struct ceph_metric_dlease *dlease;
20 struct ceph_opened_files *files;
21 struct ceph_pinned_icaps *icaps;
22 struct ceph_opened_inodes *inodes;
23 struct ceph_read_io_size *rsize;
24 struct ceph_write_io_size *wsize;
25 struct ceph_client_metric *m = &mdsc->metric;
26 u64 nr_caps = atomic64_read(&m->total_caps);
27 u32 header_len = sizeof(struct ceph_metric_header);
28 struct ceph_msg *msg;
29 struct timespec64 ts;
30 s64 sum;
31 s32 items = 0;
32 s32 len;
33
34 len = sizeof(*head) + sizeof(*cap) + sizeof(*read) + sizeof(*write)
35 + sizeof(*meta) + sizeof(*dlease) + sizeof(*files)
36 + sizeof(*icaps) + sizeof(*inodes) + sizeof(*rsize)
37 + sizeof(*wsize);
38
39 msg = ceph_msg_new(CEPH_MSG_CLIENT_METRICS, len, GFP_NOFS, true);
40 if (!msg) {
41 pr_err("send metrics to mds%d, failed to allocate message\n",
42 s->s_mds);
43 return false;
44 }
45
46 head = msg->front.iov_base;
47
48 /* encode the cap metric */
49 cap = (struct ceph_metric_cap *)(head + 1);
50 cap->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_CAP_INFO);
51 cap->header.ver = 1;
52 cap->header.compat = 1;
53 cap->header.data_len = cpu_to_le32(sizeof(*cap) - header_len);
54 cap->hit = cpu_to_le64(percpu_counter_sum(&m->i_caps_hit));
55 cap->mis = cpu_to_le64(percpu_counter_sum(&m->i_caps_mis));
56 cap->total = cpu_to_le64(nr_caps);
57 items++;
58
59 /* encode the read latency metric */
60 read = (struct ceph_metric_read_latency *)(cap + 1);
61 read->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_LATENCY);
62 read->header.ver = 1;
63 read->header.compat = 1;
64 read->header.data_len = cpu_to_le32(sizeof(*read) - header_len);
65 sum = m->read_latency_sum;
66 jiffies_to_timespec64(sum, &ts);
67 read->sec = cpu_to_le32(ts.tv_sec);
68 read->nsec = cpu_to_le32(ts.tv_nsec);
69 items++;
70
71 /* encode the write latency metric */
72 write = (struct ceph_metric_write_latency *)(read + 1);
73 write->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_LATENCY);
74 write->header.ver = 1;
75 write->header.compat = 1;
76 write->header.data_len = cpu_to_le32(sizeof(*write) - header_len);
77 sum = m->write_latency_sum;
78 jiffies_to_timespec64(sum, &ts);
79 write->sec = cpu_to_le32(ts.tv_sec);
80 write->nsec = cpu_to_le32(ts.tv_nsec);
81 items++;
82
83 /* encode the metadata latency metric */
84 meta = (struct ceph_metric_metadata_latency *)(write + 1);
85 meta->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_METADATA_LATENCY);
86 meta->header.ver = 1;
87 meta->header.compat = 1;
88 meta->header.data_len = cpu_to_le32(sizeof(*meta) - header_len);
89 sum = m->metadata_latency_sum;
90 jiffies_to_timespec64(sum, &ts);
91 meta->sec = cpu_to_le32(ts.tv_sec);
92 meta->nsec = cpu_to_le32(ts.tv_nsec);
93 items++;
94
95 /* encode the dentry lease metric */
96 dlease = (struct ceph_metric_dlease *)(meta + 1);
97 dlease->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_DENTRY_LEASE);
98 dlease->header.ver = 1;
99 dlease->header.compat = 1;
100 dlease->header.data_len = cpu_to_le32(sizeof(*dlease) - header_len);
101 dlease->hit = cpu_to_le64(percpu_counter_sum(&m->d_lease_hit));
102 dlease->mis = cpu_to_le64(percpu_counter_sum(&m->d_lease_mis));
103 dlease->total = cpu_to_le64(atomic64_read(&m->total_dentries));
104 items++;
105
106 sum = percpu_counter_sum(&m->total_inodes);
107
108 /* encode the opened files metric */
109 files = (struct ceph_opened_files *)(dlease + 1);
110 files->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_FILES);
111 files->header.ver = 1;
112 files->header.compat = 1;
113 files->header.data_len = cpu_to_le32(sizeof(*files) - header_len);
114 files->opened_files = cpu_to_le64(atomic64_read(&m->opened_files));
115 files->total = cpu_to_le64(sum);
116 items++;
117
118 /* encode the pinned icaps metric */
119 icaps = (struct ceph_pinned_icaps *)(files + 1);
120 icaps->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_PINNED_ICAPS);
121 icaps->header.ver = 1;
122 icaps->header.compat = 1;
123 icaps->header.data_len = cpu_to_le32(sizeof(*icaps) - header_len);
124 icaps->pinned_icaps = cpu_to_le64(nr_caps);
125 icaps->total = cpu_to_le64(sum);
126 items++;
127
128 /* encode the opened inodes metric */
129 inodes = (struct ceph_opened_inodes *)(icaps + 1);
130 inodes->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_INODES);
131 inodes->header.ver = 1;
132 inodes->header.compat = 1;
133 inodes->header.data_len = cpu_to_le32(sizeof(*inodes) - header_len);
134 inodes->opened_inodes = cpu_to_le64(percpu_counter_sum(&m->opened_inodes));
135 inodes->total = cpu_to_le64(sum);
136 items++;
137
138 /* encode the read io size metric */
139 rsize = (struct ceph_read_io_size *)(inodes + 1);
140 rsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_IO_SIZES);
141 rsize->header.ver = 1;
142 rsize->header.compat = 1;
143 rsize->header.data_len = cpu_to_le32(sizeof(*rsize) - header_len);
144 rsize->total_ops = cpu_to_le64(m->total_reads);
145 rsize->total_size = cpu_to_le64(m->read_size_sum);
146 items++;
147
148 /* encode the write io size metric */
149 wsize = (struct ceph_write_io_size *)(rsize + 1);
150 wsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_IO_SIZES);
151 wsize->header.ver = 1;
152 wsize->header.compat = 1;
153 wsize->header.data_len = cpu_to_le32(sizeof(*wsize) - header_len);
154 wsize->total_ops = cpu_to_le64(m->total_writes);
155 wsize->total_size = cpu_to_le64(m->write_size_sum);
156 items++;
157
158 put_unaligned_le32(items, &head->num);
159 msg->front.iov_len = len;
160 msg->hdr.version = cpu_to_le16(1);
161 msg->hdr.compat_version = cpu_to_le16(1);
162 msg->hdr.front_len = cpu_to_le32(msg->front.iov_len);
163 dout("client%llu send metrics to mds%d\n",
164 ceph_client_gid(mdsc->fsc->client), s->s_mds);
165 ceph_con_send(&s->s_con, msg);
166
167 return true;
168}
169
170
171static void metric_get_session(struct ceph_mds_client *mdsc)
172{
173 struct ceph_mds_session *s;
174 int i;
175
176 mutex_lock(&mdsc->mutex);
177 for (i = 0; i < mdsc->max_sessions; i++) {
178 s = __ceph_lookup_mds_session(mdsc, i);
179 if (!s)
180 continue;
181
182 /*
183 * Skip it if MDS doesn't support the metric collection,
184 * or the MDS will close the session's socket connection
185 * directly when it get this message.
186 */
187 if (check_session_state(s) &&
188 test_bit(CEPHFS_FEATURE_METRIC_COLLECT, &s->s_features)) {
189 mdsc->metric.session = s;
190 break;
191 }
192
193 ceph_put_mds_session(s);
194 }
195 mutex_unlock(&mdsc->mutex);
196}
197
198static void metric_delayed_work(struct work_struct *work)
199{
200 struct ceph_client_metric *m =
201 container_of(work, struct ceph_client_metric, delayed_work.work);
202 struct ceph_mds_client *mdsc =
203 container_of(m, struct ceph_mds_client, metric);
204
205 if (mdsc->stopping)
206 return;
207
208 if (!m->session || !check_session_state(m->session)) {
209 if (m->session) {
210 ceph_put_mds_session(m->session);
211 m->session = NULL;
212 }
213 metric_get_session(mdsc);
214 }
215 if (m->session) {
216 ceph_mdsc_send_metrics(mdsc, m->session);
217 metric_schedule_delayed(m);
218 }
219}
220
221int ceph_metric_init(struct ceph_client_metric *m)
222{
223 int ret;
224
225 if (!m)
226 return -EINVAL;
227
228 atomic64_set(&m->total_dentries, 0);
229 ret = percpu_counter_init(&m->d_lease_hit, 0, GFP_KERNEL);
230 if (ret)
231 return ret;
232
233 ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
234 if (ret)
235 goto err_d_lease_mis;
236
237 atomic64_set(&m->total_caps, 0);
238 ret = percpu_counter_init(&m->i_caps_hit, 0, GFP_KERNEL);
239 if (ret)
240 goto err_i_caps_hit;
241
242 ret = percpu_counter_init(&m->i_caps_mis, 0, GFP_KERNEL);
243 if (ret)
244 goto err_i_caps_mis;
245
246 spin_lock_init(&m->read_metric_lock);
247 m->read_latency_sq_sum = 0;
248 m->read_latency_min = KTIME_MAX;
249 m->read_latency_max = 0;
250 m->total_reads = 0;
251 m->read_latency_sum = 0;
252 m->read_size_min = U64_MAX;
253 m->read_size_max = 0;
254 m->read_size_sum = 0;
255
256 spin_lock_init(&m->write_metric_lock);
257 m->write_latency_sq_sum = 0;
258 m->write_latency_min = KTIME_MAX;
259 m->write_latency_max = 0;
260 m->total_writes = 0;
261 m->write_latency_sum = 0;
262 m->write_size_min = U64_MAX;
263 m->write_size_max = 0;
264 m->write_size_sum = 0;
265
266 spin_lock_init(&m->metadata_metric_lock);
267 m->metadata_latency_sq_sum = 0;
268 m->metadata_latency_min = KTIME_MAX;
269 m->metadata_latency_max = 0;
270 m->total_metadatas = 0;
271 m->metadata_latency_sum = 0;
272
273 atomic64_set(&m->opened_files, 0);
274 ret = percpu_counter_init(&m->opened_inodes, 0, GFP_KERNEL);
275 if (ret)
276 goto err_opened_inodes;
277 ret = percpu_counter_init(&m->total_inodes, 0, GFP_KERNEL);
278 if (ret)
279 goto err_total_inodes;
280
281 m->session = NULL;
282 INIT_DELAYED_WORK(&m->delayed_work, metric_delayed_work);
283
284 return 0;
285
286err_total_inodes:
287 percpu_counter_destroy(&m->opened_inodes);
288err_opened_inodes:
289 percpu_counter_destroy(&m->i_caps_mis);
290err_i_caps_mis:
291 percpu_counter_destroy(&m->i_caps_hit);
292err_i_caps_hit:
293 percpu_counter_destroy(&m->d_lease_mis);
294err_d_lease_mis:
295 percpu_counter_destroy(&m->d_lease_hit);
296
297 return ret;
298}
299
300void ceph_metric_destroy(struct ceph_client_metric *m)
301{
302 if (!m)
303 return;
304
305 cancel_delayed_work_sync(&m->delayed_work);
306
307 percpu_counter_destroy(&m->total_inodes);
308 percpu_counter_destroy(&m->opened_inodes);
309 percpu_counter_destroy(&m->i_caps_mis);
310 percpu_counter_destroy(&m->i_caps_hit);
311 percpu_counter_destroy(&m->d_lease_mis);
312 percpu_counter_destroy(&m->d_lease_hit);
313
314 ceph_put_mds_session(m->session);
315}
316
317#define METRIC_UPDATE_MIN_MAX(min, max, new) \
318{ \
319 if (unlikely(new < min)) \
320 min = new; \
321 if (unlikely(new > max)) \
322 max = new; \
323}
324
325static inline void __update_stdev(ktime_t total, ktime_t lsum,
326 ktime_t *sq_sump, ktime_t lat)
327{
328 ktime_t avg, sq;
329
330 if (unlikely(total == 1))
331 return;
332
333 /* the sq is (lat - old_avg) * (lat - new_avg) */
334 avg = DIV64_U64_ROUND_CLOSEST((lsum - lat), (total - 1));
335 sq = lat - avg;
336 avg = DIV64_U64_ROUND_CLOSEST(lsum, total);
337 sq = sq * (lat - avg);
338 *sq_sump += sq;
339}
340
341void ceph_update_read_metrics(struct ceph_client_metric *m,
342 ktime_t r_start, ktime_t r_end,
343 unsigned int size, int rc)
344{
345 ktime_t lat = ktime_sub(r_end, r_start);
346 ktime_t total;
347
348 if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
349 return;
350
351 spin_lock(&m->read_metric_lock);
352 total = ++m->total_reads;
353 m->read_size_sum += size;
354 m->read_latency_sum += lat;
355 METRIC_UPDATE_MIN_MAX(m->read_size_min,
356 m->read_size_max,
357 size);
358 METRIC_UPDATE_MIN_MAX(m->read_latency_min,
359 m->read_latency_max,
360 lat);
361 __update_stdev(total, m->read_latency_sum,
362 &m->read_latency_sq_sum, lat);
363 spin_unlock(&m->read_metric_lock);
364}
365
366void ceph_update_write_metrics(struct ceph_client_metric *m,
367 ktime_t r_start, ktime_t r_end,
368 unsigned int size, int rc)
369{
370 ktime_t lat = ktime_sub(r_end, r_start);
371 ktime_t total;
372
373 if (unlikely(rc && rc != -ETIMEDOUT))
374 return;
375
376 spin_lock(&m->write_metric_lock);
377 total = ++m->total_writes;
378 m->write_size_sum += size;
379 m->write_latency_sum += lat;
380 METRIC_UPDATE_MIN_MAX(m->write_size_min,
381 m->write_size_max,
382 size);
383 METRIC_UPDATE_MIN_MAX(m->write_latency_min,
384 m->write_latency_max,
385 lat);
386 __update_stdev(total, m->write_latency_sum,
387 &m->write_latency_sq_sum, lat);
388 spin_unlock(&m->write_metric_lock);
389}
390
391void ceph_update_metadata_metrics(struct ceph_client_metric *m,
392 ktime_t r_start, ktime_t r_end,
393 int rc)
394{
395 ktime_t lat = ktime_sub(r_end, r_start);
396 ktime_t total;
397
398 if (unlikely(rc && rc != -ENOENT))
399 return;
400
401 spin_lock(&m->metadata_metric_lock);
402 total = ++m->total_metadatas;
403 m->metadata_latency_sum += lat;
404 METRIC_UPDATE_MIN_MAX(m->metadata_latency_min,
405 m->metadata_latency_max,
406 lat);
407 __update_stdev(total, m->metadata_latency_sum,
408 &m->metadata_latency_sq_sum, lat);
409 spin_unlock(&m->metadata_metric_lock);
410}