[linux-block.git] / fs / ceph / metric.c

/* SPDX-License-Identifier: GPL-2.0 */
#include <linux/ceph/ceph_debug.h>

#include <linux/types.h>
#include <linux/percpu_counter.h>
#include <linux/math64.h>

#include "metric.h"
#include "mds_client.h"

static bool ceph_mdsc_send_metrics(struct ceph_mds_client *mdsc,
				   struct ceph_mds_session *s)
{
	struct ceph_metric_head *head;
	struct ceph_metric_cap *cap;
	struct ceph_metric_read_latency *read;
	struct ceph_metric_write_latency *write;
	struct ceph_metric_metadata_latency *meta;
	struct ceph_metric_dlease *dlease;
	struct ceph_opened_files *files;
	struct ceph_pinned_icaps *icaps;
	struct ceph_opened_inodes *inodes;
	struct ceph_read_io_size *rsize;
	struct ceph_write_io_size *wsize;
	struct ceph_client_metric *m = &mdsc->metric;
	u64 nr_caps = atomic64_read(&m->total_caps);
	u32 header_len = sizeof(struct ceph_metric_header);
	struct ceph_msg *msg;
	struct timespec64 ts;
	s64 sum;
	s32 items = 0;
	s32 len;

	len = sizeof(*head) + sizeof(*cap) + sizeof(*read) + sizeof(*write)
	      + sizeof(*meta) + sizeof(*dlease) + sizeof(*files)
	      + sizeof(*icaps) + sizeof(*inodes) + sizeof(*rsize)
	      + sizeof(*wsize);

	msg = ceph_msg_new(CEPH_MSG_CLIENT_METRICS, len, GFP_NOFS, true);
	if (!msg) {
		pr_err("send metrics to mds%d, failed to allocate message\n",
		       s->s_mds);
		return false;
	}

	head = msg->front.iov_base;

	/* encode the cap metric */
	cap = (struct ceph_metric_cap *)(head + 1);
	cap->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_CAP_INFO);
	cap->header.ver = 1;
	cap->header.compat = 1;
	cap->header.data_len = cpu_to_le32(sizeof(*cap) - header_len);
	cap->hit = cpu_to_le64(percpu_counter_sum(&m->i_caps_hit));
	cap->mis = cpu_to_le64(percpu_counter_sum(&m->i_caps_mis));
	cap->total = cpu_to_le64(nr_caps);
	items++;

	/* encode the read latency metric */
	read = (struct ceph_metric_read_latency *)(cap + 1);
	read->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_LATENCY);
	read->header.ver = 1;
	read->header.compat = 1;
	read->header.data_len = cpu_to_le32(sizeof(*read) - header_len);
	sum = m->metric[METRIC_READ].latency_sum;
	jiffies_to_timespec64(sum, &ts);
	read->sec = cpu_to_le32(ts.tv_sec);
	read->nsec = cpu_to_le32(ts.tv_nsec);
	items++;

	/* encode the write latency metric */
	write = (struct ceph_metric_write_latency *)(read + 1);
	write->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_LATENCY);
	write->header.ver = 1;
	write->header.compat = 1;
	write->header.data_len = cpu_to_le32(sizeof(*write) - header_len);
	sum = m->metric[METRIC_WRITE].latency_sum;
	jiffies_to_timespec64(sum, &ts);
	write->sec = cpu_to_le32(ts.tv_sec);
	write->nsec = cpu_to_le32(ts.tv_nsec);
	items++;

	/* encode the metadata latency metric */
	meta = (struct ceph_metric_metadata_latency *)(write + 1);
	meta->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_METADATA_LATENCY);
	meta->header.ver = 1;
	meta->header.compat = 1;
	meta->header.data_len = cpu_to_le32(sizeof(*meta) - header_len);
	sum = m->metric[METRIC_METADATA].latency_sum;
	jiffies_to_timespec64(sum, &ts);
	meta->sec = cpu_to_le32(ts.tv_sec);
	meta->nsec = cpu_to_le32(ts.tv_nsec);
	items++;

	/* encode the dentry lease metric */
	dlease = (struct ceph_metric_dlease *)(meta + 1);
	dlease->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_DENTRY_LEASE);
	dlease->header.ver = 1;
	dlease->header.compat = 1;
	dlease->header.data_len = cpu_to_le32(sizeof(*dlease) - header_len);
	dlease->hit = cpu_to_le64(percpu_counter_sum(&m->d_lease_hit));
	dlease->mis = cpu_to_le64(percpu_counter_sum(&m->d_lease_mis));
	dlease->total = cpu_to_le64(atomic64_read(&m->total_dentries));
	items++;

	sum = percpu_counter_sum(&m->total_inodes);

	/* encode the opened files metric */
	files = (struct ceph_opened_files *)(dlease + 1);
	files->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_FILES);
	files->header.ver = 1;
	files->header.compat = 1;
	files->header.data_len = cpu_to_le32(sizeof(*files) - header_len);
	files->opened_files = cpu_to_le64(atomic64_read(&m->opened_files));
	files->total = cpu_to_le64(sum);
	items++;

	/* encode the pinned icaps metric */
	icaps = (struct ceph_pinned_icaps *)(files + 1);
	icaps->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_PINNED_ICAPS);
	icaps->header.ver = 1;
	icaps->header.compat = 1;
	icaps->header.data_len = cpu_to_le32(sizeof(*icaps) - header_len);
	icaps->pinned_icaps = cpu_to_le64(nr_caps);
	icaps->total = cpu_to_le64(sum);
	items++;

	/* encode the opened inodes metric */
	inodes = (struct ceph_opened_inodes *)(icaps + 1);
	inodes->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_OPENED_INODES);
	inodes->header.ver = 1;
	inodes->header.compat = 1;
	inodes->header.data_len = cpu_to_le32(sizeof(*inodes) - header_len);
	inodes->opened_inodes = cpu_to_le64(percpu_counter_sum(&m->opened_inodes));
	inodes->total = cpu_to_le64(sum);
	items++;

	/* encode the read io size metric */
	rsize = (struct ceph_read_io_size *)(inodes + 1);
	rsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_READ_IO_SIZES);
	rsize->header.ver = 1;
	rsize->header.compat = 1;
	rsize->header.data_len = cpu_to_le32(sizeof(*rsize) - header_len);
	rsize->total_ops = cpu_to_le64(m->metric[METRIC_READ].total);
	rsize->total_size = cpu_to_le64(m->metric[METRIC_READ].size_sum);
	items++;

	/* encode the write io size metric */
	wsize = (struct ceph_write_io_size *)(rsize + 1);
	wsize->header.type = cpu_to_le32(CLIENT_METRIC_TYPE_WRITE_IO_SIZES);
	wsize->header.ver = 1;
	wsize->header.compat = 1;
	wsize->header.data_len = cpu_to_le32(sizeof(*wsize) - header_len);
	wsize->total_ops = cpu_to_le64(m->metric[METRIC_WRITE].total);
	wsize->total_size = cpu_to_le64(m->metric[METRIC_WRITE].size_sum);
	items++;

	put_unaligned_le32(items, &head->num);
	msg->front.iov_len = len;
	msg->hdr.version = cpu_to_le16(1);
	msg->hdr.compat_version = cpu_to_le16(1);
	msg->hdr.front_len = cpu_to_le32(msg->front.iov_len);
	ceph_con_send(&s->s_con, msg);

	return true;
}


static void metric_get_session(struct ceph_mds_client *mdsc)
{
	struct ceph_mds_session *s;
	int i;

	mutex_lock(&mdsc->mutex);
	for (i = 0; i < mdsc->max_sessions; i++) {
		s = __ceph_lookup_mds_session(mdsc, i);
		if (!s)
			continue;

		/*
		 * Skip it if MDS doesn't support the metric collection,
		 * or the MDS will close the session's socket connection
		 * directly when it get this message.
		 */
		if (check_session_state(s) &&
		    test_bit(CEPHFS_FEATURE_METRIC_COLLECT, &s->s_features)) {
			mdsc->metric.session = s;
			break;
		}

		ceph_put_mds_session(s);
	}
	mutex_unlock(&mdsc->mutex);
}

static void metric_delayed_work(struct work_struct *work)
{
	struct ceph_client_metric *m =
		container_of(work, struct ceph_client_metric, delayed_work.work);
	struct ceph_mds_client *mdsc =
		container_of(m, struct ceph_mds_client, metric);

	if (mdsc->stopping)
		return;

	if (!m->session || !check_session_state(m->session)) {
		if (m->session) {
			ceph_put_mds_session(m->session);
			m->session = NULL;
		}
		metric_get_session(mdsc);
	}
	if (m->session) {
		ceph_mdsc_send_metrics(mdsc, m->session);
		metric_schedule_delayed(m);
	}
}

int ceph_metric_init(struct ceph_client_metric *m)
{
	struct ceph_metric *metric;
	int ret, i;

	if (!m)
		return -EINVAL;

	atomic64_set(&m->total_dentries, 0);
	ret = percpu_counter_init(&m->d_lease_hit, 0, GFP_KERNEL);
	if (ret)
		return ret;

	ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
	if (ret)
		goto err_d_lease_mis;

	atomic64_set(&m->total_caps, 0);
	ret = percpu_counter_init(&m->i_caps_hit, 0, GFP_KERNEL);
	if (ret)
		goto err_i_caps_hit;

	ret = percpu_counter_init(&m->i_caps_mis, 0, GFP_KERNEL);
	if (ret)
		goto err_i_caps_mis;

	for (i = 0; i < METRIC_MAX; i++) {
		metric = &m->metric[i];
		spin_lock_init(&metric->lock);
		metric->size_sum = 0;
		metric->size_min = U64_MAX;
		metric->size_max = 0;
		metric->total = 0;
		metric->latency_sum = 0;
		metric->latency_sq_sum = 0;
		metric->latency_min = KTIME_MAX;
		metric->latency_max = 0;
	}

	atomic64_set(&m->opened_files, 0);
	ret = percpu_counter_init(&m->opened_inodes, 0, GFP_KERNEL);
	if (ret)
		goto err_opened_inodes;
	ret = percpu_counter_init(&m->total_inodes, 0, GFP_KERNEL);
	if (ret)
		goto err_total_inodes;

	m->session = NULL;
	INIT_DELAYED_WORK(&m->delayed_work, metric_delayed_work);

	return 0;

err_total_inodes:
	percpu_counter_destroy(&m->opened_inodes);
err_opened_inodes:
	percpu_counter_destroy(&m->i_caps_mis);
err_i_caps_mis:
	percpu_counter_destroy(&m->i_caps_hit);
err_i_caps_hit:
	percpu_counter_destroy(&m->d_lease_mis);
err_d_lease_mis:
	percpu_counter_destroy(&m->d_lease_hit);

	return ret;
}

void ceph_metric_destroy(struct ceph_client_metric *m)
{
	if (!m)
		return;

	cancel_delayed_work_sync(&m->delayed_work);

	percpu_counter_destroy(&m->total_inodes);
	percpu_counter_destroy(&m->opened_inodes);
	percpu_counter_destroy(&m->i_caps_mis);
	percpu_counter_destroy(&m->i_caps_hit);
	percpu_counter_destroy(&m->d_lease_mis);
	percpu_counter_destroy(&m->d_lease_hit);

	ceph_put_mds_session(m->session);
}

#define METRIC_UPDATE_MIN_MAX(min, max, new)	\
{						\
	if (unlikely(new < min))		\
		min = new;			\
	if (unlikely(new > max))		\
		max = new;			\
}

static inline void __update_stdev(ktime_t total, ktime_t lsum,
				  ktime_t *sq_sump, ktime_t lat)
{
	ktime_t avg, sq;

	if (unlikely(total == 1))
		return;

	/* the sq is (lat - old_avg) * (lat - new_avg) */
	avg = DIV64_U64_ROUND_CLOSEST((lsum - lat), (total - 1));
	sq = lat - avg;
	avg = DIV64_U64_ROUND_CLOSEST(lsum, total);
	sq = sq * (lat - avg);
	*sq_sump += sq;
}

void ceph_update_metrics(struct ceph_metric *m,
			 ktime_t r_start, ktime_t r_end,
			 unsigned int size, int rc)
{
	ktime_t lat = ktime_sub(r_end, r_start);
	ktime_t total;

	if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
		return;

	spin_lock(&m->lock);
	total = ++m->total;
	m->size_sum += size;
	METRIC_UPDATE_MIN_MAX(m->size_min, m->size_max, size);
	m->latency_sum += lat;
	METRIC_UPDATE_MIN_MAX(m->latency_min, m->latency_max, lat);
	__update_stdev(total, m->latency_sum, &m->latency_sq_sum, lat);
	spin_unlock(&m->lock);
}
Commit	Line	Data
f9009efa	1	/* SPDX-License-Identifier: GPL-2.0 */
18f473b3	2	#include <linux/ceph/ceph_debug.h>
f9009efa XL	3
	4	#include <linux/types.h>
	5	#include <linux/percpu_counter.h>
97e27aaa	6	#include <linux/math64.h>
f9009efa XL	7
f9009efa XL	8	#include "metric.h"
18f473b3 XL	9	#include "mds_client.h"
	10
	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;
8ba3b8c7	19	struct ceph_metric_dlease *dlease;
3d8b6987 XL	20	struct ceph_opened_files *files;
	21	struct ceph_pinned_icaps *icaps;
	22	struct ceph_opened_inodes *inodes;
903f4fec XL	23	struct ceph_read_io_size *rsize;
903f4fec XL	24	struct ceph_write_io_size *wsize;
18f473b3 XL	25	struct ceph_client_metric *m = &mdsc->metric;
18f473b3 XL	26	u64 nr_caps = atomic64_read(&m->total_caps);
8ecd34c7	27	u32 header_len = sizeof(struct ceph_metric_header);
18f473b3 XL	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)
3d8b6987	35	+ sizeof(meta) + sizeof(dlease) + sizeof(*files)
903f4fec XL	36	+ sizeof(icaps) + sizeof(inodes) + sizeof(*rsize)
903f4fec XL	37	+ sizeof(*wsize);
18f473b3 XL	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);
8ecd34c7 XL	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);
8ba3b8c7 XL	54	cap->hit = cpu_to_le64(percpu_counter_sum(&m->i_caps_hit));
8ba3b8c7 XL	55	cap->mis = cpu_to_le64(percpu_counter_sum(&m->i_caps_mis));
18f473b3 XL	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);
8ecd34c7 XL	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);
17e9fc9f	65	sum = m->metric[METRIC_READ].latency_sum;
18f473b3 XL	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);
8ecd34c7 XL	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);
17e9fc9f	77	sum = m->metric[METRIC_WRITE].latency_sum;
18f473b3 XL	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);
8ecd34c7 XL	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);
17e9fc9f	89	sum = m->metric[METRIC_METADATA].latency_sum;
18f473b3 XL	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
8ba3b8c7 XL	95	/* encode the dentry lease metric */
8ba3b8c7 XL	96	dlease = (struct ceph_metric_dlease *)(meta + 1);
8ecd34c7 XL	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);
8ba3b8c7 XL	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
3d8b6987 XL	106	sum = percpu_counter_sum(&m->total_inodes);
	107
	108	/* encode the opened files metric */
	109	files = (struct ceph_opened_files *)(dlease + 1);
8ecd34c7 XL	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);
3d8b6987 XL	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);
8ecd34c7 XL	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);
3d8b6987 XL	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);
8ecd34c7 XL	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);
3d8b6987 XL	134	inodes->opened_inodes = cpu_to_le64(percpu_counter_sum(&m->opened_inodes));
	135	inodes->total = cpu_to_le64(sum);
	136	items++;
	137
903f4fec XL	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);
17e9fc9f LH	144	rsize->total_ops = cpu_to_le64(m->metric[METRIC_READ].total);
17e9fc9f LH	145	rsize->total_size = cpu_to_le64(m->metric[METRIC_READ].size_sum);
903f4fec XL	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);
17e9fc9f LH	154	wsize->total_ops = cpu_to_le64(m->metric[METRIC_WRITE].total);
17e9fc9f LH	155	wsize->total_size = cpu_to_le64(m->metric[METRIC_WRITE].size_sum);
903f4fec XL	156	items++;
903f4fec XL	157
18f473b3 XL	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);
18f473b3 XL	163	ceph_con_send(&s->s_con, msg);
	164
	165	return true;
	166	}
	167
	168
	169	static void metric_get_session(struct ceph_mds_client *mdsc)
	170	{
	171	struct ceph_mds_session *s;
	172	int i;
	173
	174	mutex_lock(&mdsc->mutex);
	175	for (i = 0; i < mdsc->max_sessions; i++) {
	176	s = __ceph_lookup_mds_session(mdsc, i);
	177	if (!s)
	178	continue;
	179
	180	/*
	181	* Skip it if MDS doesn't support the metric collection,
	182	* or the MDS will close the session's socket connection
	183	* directly when it get this message.
	184	*/
	185	if (check_session_state(s) &&
	186	test_bit(CEPHFS_FEATURE_METRIC_COLLECT, &s->s_features)) {
	187	mdsc->metric.session = s;
	188	break;
	189	}
	190
	191	ceph_put_mds_session(s);
	192	}
	193	mutex_unlock(&mdsc->mutex);
	194	}
	195
	196	static void metric_delayed_work(struct work_struct *work)
	197	{
	198	struct ceph_client_metric *m =
	199	container_of(work, struct ceph_client_metric, delayed_work.work);
	200	struct ceph_mds_client *mdsc =
	201	container_of(m, struct ceph_mds_client, metric);
	202
	203	if (mdsc->stopping)
	204	return;
	205
	206	if (!m->session \|\| !check_session_state(m->session)) {
	207	if (m->session) {
	208	ceph_put_mds_session(m->session);
	209	m->session = NULL;
	210	}
	211	metric_get_session(mdsc);
	212	}
	213	if (m->session) {
	214	ceph_mdsc_send_metrics(mdsc, m->session);
	215	metric_schedule_delayed(m);
	216	}
	217	}
f9009efa XL	218
	219	int ceph_metric_init(struct ceph_client_metric *m)
	220	{
17e9fc9f LH	221	struct ceph_metric *metric;
17e9fc9f LH	222	int ret, i;
f9009efa XL	223
	224	if (!m)
	225	return -EINVAL;
	226
	227	atomic64_set(&m->total_dentries, 0);
	228	ret = percpu_counter_init(&m->d_lease_hit, 0, GFP_KERNEL);
	229	if (ret)
	230	return ret;
1af16d54	231
f9009efa	232	ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
1af16d54 XL	233	if (ret)
	234	goto err_d_lease_mis;
	235
4f1d756d	236	atomic64_set(&m->total_caps, 0);
1af16d54 XL	237	ret = percpu_counter_init(&m->i_caps_hit, 0, GFP_KERNEL);
	238	if (ret)
	239	goto err_i_caps_hit;
	240
	241	ret = percpu_counter_init(&m->i_caps_mis, 0, GFP_KERNEL);
	242	if (ret)
	243	goto err_i_caps_mis;
f9009efa	244
17e9fc9f LH	245	for (i = 0; i < METRIC_MAX; i++) {
	246	metric = &m->metric[i];
	247	spin_lock_init(&metric->lock);
	248	metric->size_sum = 0;
	249	metric->size_min = U64_MAX;
	250	metric->size_max = 0;
	251	metric->total = 0;
	252	metric->latency_sum = 0;
	253	metric->latency_sq_sum = 0;
	254	metric->latency_min = KTIME_MAX;
	255	metric->latency_max = 0;
	256	}
70c94820	257
1dd8d470 XL	258	atomic64_set(&m->opened_files, 0);
	259	ret = percpu_counter_init(&m->opened_inodes, 0, GFP_KERNEL);
	260	if (ret)
	261	goto err_opened_inodes;
	262	ret = percpu_counter_init(&m->total_inodes, 0, GFP_KERNEL);
	263	if (ret)
	264	goto err_total_inodes;
	265
18f473b3 XL	266	m->session = NULL;
	267	INIT_DELAYED_WORK(&m->delayed_work, metric_delayed_work);
	268
f9009efa	269	return 0;
1af16d54	270
1dd8d470 XL	271	err_total_inodes:
	272	percpu_counter_destroy(&m->opened_inodes);
	273	err_opened_inodes:
	274	percpu_counter_destroy(&m->i_caps_mis);
1af16d54 XL	275	err_i_caps_mis:
	276	percpu_counter_destroy(&m->i_caps_hit);
	277	err_i_caps_hit:
	278	percpu_counter_destroy(&m->d_lease_mis);
	279	err_d_lease_mis:
	280	percpu_counter_destroy(&m->d_lease_hit);
	281
	282	return ret;
f9009efa XL	283	}
	284
	285	void ceph_metric_destroy(struct ceph_client_metric *m)
	286	{
	287	if (!m)
	288	return;
	289
b4002173 JL	290	cancel_delayed_work_sync(&m->delayed_work);
b4002173 JL	291
1dd8d470 XL	292	percpu_counter_destroy(&m->total_inodes);
1dd8d470 XL	293	percpu_counter_destroy(&m->opened_inodes);
1af16d54 XL	294	percpu_counter_destroy(&m->i_caps_mis);
1af16d54 XL	295	percpu_counter_destroy(&m->i_caps_hit);
f9009efa XL	296	percpu_counter_destroy(&m->d_lease_mis);
f9009efa XL	297	percpu_counter_destroy(&m->d_lease_hit);
18f473b3	298
7e65624d	299	ceph_put_mds_session(m->session);
f9009efa	300	}
97e27aaa	301
fc123d5f XL	302	#define METRIC_UPDATE_MIN_MAX(min, max, new) \
	303	{ \
	304	if (unlikely(new < min)) \
	305	min = new; \
	306	if (unlikely(new > max)) \
	307	max = new; \
	308	}
97e27aaa	309
fc123d5f XL	310	static inline void __update_stdev(ktime_t total, ktime_t lsum,
	311	ktime_t *sq_sump, ktime_t lat)
	312	{
	313	ktime_t avg, sq;
97e27aaa XL	314
	315	if (unlikely(total == 1))
	316	return;
	317
	318	/* the sq is (lat - old_avg) * (lat - new_avg) */
	319	avg = DIV64_U64_ROUND_CLOSEST((lsum - lat), (total - 1));
	320	sq = lat - avg;
	321	avg = DIV64_U64_ROUND_CLOSEST(lsum, total);
	322	sq = sq * (lat - avg);
	323	*sq_sump += sq;
	324	}
	325
17e9fc9f LH	326	void ceph_update_metrics(struct ceph_metric *m,
	327	ktime_t r_start, ktime_t r_end,
	328	unsigned int size, int rc)
97e27aaa XL	329	{
97e27aaa XL	330	ktime_t lat = ktime_sub(r_end, r_start);
fc123d5f	331	ktime_t total;
97e27aaa XL	332
	333	if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
	334	return;
	335
17e9fc9f LH	336	spin_lock(&m->lock);
	337	total = ++m->total;
	338	m->size_sum += size;
	339	METRIC_UPDATE_MIN_MAX(m->size_min, m->size_max, size);
	340	m->latency_sum += lat;
	341	METRIC_UPDATE_MIN_MAX(m->latency_min, m->latency_max, lat);
	342	__update_stdev(total, m->latency_sum, &m->latency_sq_sum, lat);
	343	spin_unlock(&m->lock);
70c94820	344	}