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