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