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

/* SPDX-License-Identifier: GPL-2.0 */

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

#include "metric.h"

int ceph_metric_init(struct ceph_client_metric *m)
{
	int ret;

	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;

	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;

	spin_lock_init(&m->read_latency_lock);
	m->read_latency_sq_sum = 0;
	m->read_latency_min = KTIME_MAX;
	m->read_latency_max = 0;
	m->total_reads = 0;
	m->read_latency_sum = 0;

	spin_lock_init(&m->write_latency_lock);
	m->write_latency_sq_sum = 0;
	m->write_latency_min = KTIME_MAX;
	m->write_latency_max = 0;
	m->total_writes = 0;
	m->write_latency_sum = 0;

	spin_lock_init(&m->metadata_latency_lock);
	m->metadata_latency_sq_sum = 0;
	m->metadata_latency_min = KTIME_MAX;
	m->metadata_latency_max = 0;
	m->total_metadatas = 0;
	m->metadata_latency_sum = 0;

	return 0;

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;

	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);
}

static inline void __update_latency(ktime_t *totalp, ktime_t *lsump,
				    ktime_t *min, ktime_t *max,
				    ktime_t *sq_sump, ktime_t lat)
{
	ktime_t total, avg, sq, lsum;

	total = ++(*totalp);
	lsum = (*lsump += lat);

	if (unlikely(lat < *min))
		*min = lat;
	if (unlikely(lat > *max))
		*max = lat;

	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_read_latency(struct ceph_client_metric *m,
			      ktime_t r_start, ktime_t r_end,
			      int rc)
{
	ktime_t lat = ktime_sub(r_end, r_start);

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

	spin_lock(&m->read_latency_lock);
	__update_latency(&m->total_reads, &m->read_latency_sum,
			 &m->read_latency_min, &m->read_latency_max,
			 &m->read_latency_sq_sum, lat);
	spin_unlock(&m->read_latency_lock);
}

void ceph_update_write_latency(struct ceph_client_metric *m,
			       ktime_t r_start, ktime_t r_end,
			       int rc)
{
	ktime_t lat = ktime_sub(r_end, r_start);

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

	spin_lock(&m->write_latency_lock);
	__update_latency(&m->total_writes, &m->write_latency_sum,
			 &m->write_latency_min, &m->write_latency_max,
			 &m->write_latency_sq_sum, lat);
	spin_unlock(&m->write_latency_lock);
}

void ceph_update_metadata_latency(struct ceph_client_metric *m,
				  ktime_t r_start, ktime_t r_end,
				  int rc)
{
	ktime_t lat = ktime_sub(r_end, r_start);

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

	spin_lock(&m->metadata_latency_lock);
	__update_latency(&m->total_metadatas, &m->metadata_latency_sum,
			 &m->metadata_latency_min, &m->metadata_latency_max,
			 &m->metadata_latency_sq_sum, lat);
	spin_unlock(&m->metadata_latency_lock);
}
Commit	Line	Data
f9009efa XL	1	/* SPDX-License-Identifier: GPL-2.0 */
	2
	3	#include <linux/types.h>
	4	#include <linux/percpu_counter.h>
97e27aaa	5	#include <linux/math64.h>
f9009efa XL	6
	7	#include "metric.h"
	8
	9	int ceph_metric_init(struct ceph_client_metric *m)
	10	{
	11	int ret;
	12
	13	if (!m)
	14	return -EINVAL;
	15
	16	atomic64_set(&m->total_dentries, 0);
	17	ret = percpu_counter_init(&m->d_lease_hit, 0, GFP_KERNEL);
	18	if (ret)
	19	return ret;
1af16d54	20
f9009efa	21	ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
1af16d54 XL	22	if (ret)
	23	goto err_d_lease_mis;
	24
	25	ret = percpu_counter_init(&m->i_caps_hit, 0, GFP_KERNEL);
	26	if (ret)
	27	goto err_i_caps_hit;
	28
	29	ret = percpu_counter_init(&m->i_caps_mis, 0, GFP_KERNEL);
	30	if (ret)
	31	goto err_i_caps_mis;
f9009efa	32
97e27aaa XL	33	spin_lock_init(&m->read_latency_lock);
	34	m->read_latency_sq_sum = 0;
	35	m->read_latency_min = KTIME_MAX;
	36	m->read_latency_max = 0;
	37	m->total_reads = 0;
	38	m->read_latency_sum = 0;
	39
	40	spin_lock_init(&m->write_latency_lock);
	41	m->write_latency_sq_sum = 0;
	42	m->write_latency_min = KTIME_MAX;
	43	m->write_latency_max = 0;
	44	m->total_writes = 0;
	45	m->write_latency_sum = 0;
	46
70c94820 XL	47	spin_lock_init(&m->metadata_latency_lock);
	48	m->metadata_latency_sq_sum = 0;
	49	m->metadata_latency_min = KTIME_MAX;
	50	m->metadata_latency_max = 0;
	51	m->total_metadatas = 0;
	52	m->metadata_latency_sum = 0;
	53
f9009efa	54	return 0;
1af16d54 XL	55
	56	err_i_caps_mis:
	57	percpu_counter_destroy(&m->i_caps_hit);
	58	err_i_caps_hit:
	59	percpu_counter_destroy(&m->d_lease_mis);
	60	err_d_lease_mis:
	61	percpu_counter_destroy(&m->d_lease_hit);
	62
	63	return ret;
f9009efa XL	64	}
	65
	66	void ceph_metric_destroy(struct ceph_client_metric *m)
	67	{
	68	if (!m)
	69	return;
	70
1af16d54 XL	71	percpu_counter_destroy(&m->i_caps_mis);
1af16d54 XL	72	percpu_counter_destroy(&m->i_caps_hit);
f9009efa XL	73	percpu_counter_destroy(&m->d_lease_mis);
	74	percpu_counter_destroy(&m->d_lease_hit);
	75	}
97e27aaa XL	76
	77	static inline void __update_latency(ktime_t totalp, ktime_t lsump,
	78	ktime_t min, ktime_t max,
	79	ktime_t *sq_sump, ktime_t lat)
	80	{
	81	ktime_t total, avg, sq, lsum;
	82
	83	total = ++(*totalp);
	84	lsum = (*lsump += lat);
	85
	86	if (unlikely(lat < *min))
	87	*min = lat;
	88	if (unlikely(lat > *max))
	89	*max = lat;
	90
	91	if (unlikely(total == 1))
	92	return;
	93
	94	/* the sq is (lat - old_avg) * (lat - new_avg) */
	95	avg = DIV64_U64_ROUND_CLOSEST((lsum - lat), (total - 1));
	96	sq = lat - avg;
	97	avg = DIV64_U64_ROUND_CLOSEST(lsum, total);
	98	sq = sq * (lat - avg);
	99	*sq_sump += sq;
	100	}
	101
	102	void ceph_update_read_latency(struct ceph_client_metric *m,
	103	ktime_t r_start, ktime_t r_end,
	104	int rc)
	105	{
	106	ktime_t lat = ktime_sub(r_end, r_start);
	107
	108	if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
	109	return;
	110
	111	spin_lock(&m->read_latency_lock);
	112	__update_latency(&m->total_reads, &m->read_latency_sum,
	113	&m->read_latency_min, &m->read_latency_max,
	114	&m->read_latency_sq_sum, lat);
	115	spin_unlock(&m->read_latency_lock);
	116	}
	117
	118	void ceph_update_write_latency(struct ceph_client_metric *m,
	119	ktime_t r_start, ktime_t r_end,
	120	int rc)
	121	{
	122	ktime_t lat = ktime_sub(r_end, r_start);
	123
	124	if (unlikely(rc && rc != -ETIMEDOUT))
	125	return;
	126
	127	spin_lock(&m->write_latency_lock);
	128	__update_latency(&m->total_writes, &m->write_latency_sum,
	129	&m->write_latency_min, &m->write_latency_max,
	130	&m->write_latency_sq_sum, lat);
	131	spin_unlock(&m->write_latency_lock);
	132	}
70c94820 XL	133
	134	void ceph_update_metadata_latency(struct ceph_client_metric *m,
	135	ktime_t r_start, ktime_t r_end,
	136	int rc)
	137	{
	138	ktime_t lat = ktime_sub(r_end, r_start);
	139
	140	if (unlikely(rc && rc != -ENOENT))
	141	return;
	142
	143	spin_lock(&m->metadata_latency_lock);
	144	__update_latency(&m->total_metadatas, &m->metadata_latency_sum,
	145	&m->metadata_latency_min, &m->metadata_latency_max,
	146	&m->metadata_latency_sq_sum, lat);
	147	spin_unlock(&m->metadata_latency_lock);
	148	}