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