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

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _FS_CEPH_MDS_METRIC_H
#define _FS_CEPH_MDS_METRIC_H

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

extern bool disable_send_metrics;

enum ceph_metric_type {
	CLIENT_METRIC_TYPE_CAP_INFO,
	CLIENT_METRIC_TYPE_READ_LATENCY,
	CLIENT_METRIC_TYPE_WRITE_LATENCY,
	CLIENT_METRIC_TYPE_METADATA_LATENCY,
	CLIENT_METRIC_TYPE_DENTRY_LEASE,
	CLIENT_METRIC_TYPE_OPENED_FILES,
	CLIENT_METRIC_TYPE_PINNED_ICAPS,
	CLIENT_METRIC_TYPE_OPENED_INODES,
	CLIENT_METRIC_TYPE_READ_IO_SIZES,
	CLIENT_METRIC_TYPE_WRITE_IO_SIZES,

	CLIENT_METRIC_TYPE_MAX = CLIENT_METRIC_TYPE_WRITE_IO_SIZES,
};

/*
 * This will always have the highest metric bit value
 * as the last element of the array.
 */
#define CEPHFS_METRIC_SPEC_CLIENT_SUPPORTED {	\
	CLIENT_METRIC_TYPE_CAP_INFO,		\
	CLIENT_METRIC_TYPE_READ_LATENCY,	\
	CLIENT_METRIC_TYPE_WRITE_LATENCY,	\
	CLIENT_METRIC_TYPE_METADATA_LATENCY,	\
	CLIENT_METRIC_TYPE_DENTRY_LEASE,	\
	CLIENT_METRIC_TYPE_OPENED_FILES,	\
	CLIENT_METRIC_TYPE_PINNED_ICAPS,	\
	CLIENT_METRIC_TYPE_OPENED_INODES,	\
	CLIENT_METRIC_TYPE_READ_IO_SIZES,	\
	CLIENT_METRIC_TYPE_WRITE_IO_SIZES,	\
						\
	CLIENT_METRIC_TYPE_MAX,			\
}

struct ceph_metric_header {
	__le32 type;     /* ceph metric type */
	__u8  ver;
	__u8  compat;
	__le32 data_len; /* length of sizeof(hit + mis + total) */
} __packed;

/* metric caps header */
struct ceph_metric_cap {
	struct ceph_metric_header header;
	__le64 hit;
	__le64 mis;
	__le64 total;
} __packed;

/* metric read latency header */
struct ceph_metric_read_latency {
	struct ceph_metric_header header;
	__le32 sec;
	__le32 nsec;
} __packed;

/* metric write latency header */
struct ceph_metric_write_latency {
	struct ceph_metric_header header;
	__le32 sec;
	__le32 nsec;
} __packed;

/* metric metadata latency header */
struct ceph_metric_metadata_latency {
	struct ceph_metric_header header;
	__le32 sec;
	__le32 nsec;
} __packed;

/* metric dentry lease header */
struct ceph_metric_dlease {
	struct ceph_metric_header header;
	__le64 hit;
	__le64 mis;
	__le64 total;
} __packed;

/* metric opened files header */
struct ceph_opened_files {
	struct ceph_metric_header header;
	__le64 opened_files;
	__le64 total;
} __packed;

/* metric pinned i_caps header */
struct ceph_pinned_icaps {
	struct ceph_metric_header header;
	__le64 pinned_icaps;
	__le64 total;
} __packed;

/* metric opened inodes header */
struct ceph_opened_inodes {
	struct ceph_metric_header header;
	__le64 opened_inodes;
	__le64 total;
} __packed;

/* metric read io size header */
struct ceph_read_io_size {
	struct ceph_metric_header header;
	__le64 total_ops;
	__le64 total_size;
} __packed;

/* metric write io size header */
struct ceph_write_io_size {
	struct ceph_metric_header header;
	__le64 total_ops;
	__le64 total_size;
} __packed;

struct ceph_metric_head {
	__le32 num;	/* the number of metrics that will be sent */
} __packed;

/* This is the global metrics */
struct ceph_client_metric {
	atomic64_t            total_dentries;
	struct percpu_counter d_lease_hit;
	struct percpu_counter d_lease_mis;

	atomic64_t            total_caps;
	struct percpu_counter i_caps_hit;
	struct percpu_counter i_caps_mis;

	spinlock_t read_metric_lock;
	u64 total_reads;
	u64 read_size_sum;
	u64 read_size_min;
	u64 read_size_max;
	ktime_t read_latency_sum;
	ktime_t read_latency_sq_sum;
	ktime_t read_latency_min;
	ktime_t read_latency_max;

	spinlock_t write_metric_lock;
	u64 total_writes;
	u64 write_size_sum;
	u64 write_size_min;
	u64 write_size_max;
	ktime_t write_latency_sum;
	ktime_t write_latency_sq_sum;
	ktime_t write_latency_min;
	ktime_t write_latency_max;

	spinlock_t metadata_metric_lock;
	u64 total_metadatas;
	ktime_t metadata_latency_sum;
	ktime_t metadata_latency_sq_sum;
	ktime_t metadata_latency_min;
	ktime_t metadata_latency_max;

	/* The total number of directories and files that are opened */
	atomic64_t opened_files;

	/* The total number of inodes that have opened files or directories */
	struct percpu_counter opened_inodes;
	struct percpu_counter total_inodes;

	struct ceph_mds_session *session;
	struct delayed_work delayed_work;  /* delayed work */
};

static inline void metric_schedule_delayed(struct ceph_client_metric *m)
{
	if (disable_send_metrics)
		return;

	/* per second */
	schedule_delayed_work(&m->delayed_work, round_jiffies_relative(HZ));
}

extern int ceph_metric_init(struct ceph_client_metric *m);
extern void ceph_metric_destroy(struct ceph_client_metric *m);

static inline void ceph_update_cap_hit(struct ceph_client_metric *m)
{
	percpu_counter_inc(&m->i_caps_hit);
}

static inline void ceph_update_cap_mis(struct ceph_client_metric *m)
{
	percpu_counter_inc(&m->i_caps_mis);
}

extern void ceph_update_read_metrics(struct ceph_client_metric *m,
				     ktime_t r_start, ktime_t r_end,
				     unsigned int size, int rc);
extern void ceph_update_write_metrics(struct ceph_client_metric *m,
				      ktime_t r_start, ktime_t r_end,
				      unsigned int size, int rc);
extern void ceph_update_metadata_metrics(struct ceph_client_metric *m,
				         ktime_t r_start, ktime_t r_end,
					 int rc);
#endif /* _FS_CEPH_MDS_METRIC_H */
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _FS_CEPH_MDS_METRIC_H
	3	#define _FS_CEPH_MDS_METRIC_H
	4
	5	#include <linux/types.h>
	6	#include <linux/percpu_counter.h>
	7	#include <linux/ktime.h>
	8
	9	extern bool disable_send_metrics;
	10
	11	enum ceph_metric_type {
	12	CLIENT_METRIC_TYPE_CAP_INFO,
	13	CLIENT_METRIC_TYPE_READ_LATENCY,
	14	CLIENT_METRIC_TYPE_WRITE_LATENCY,
	15	CLIENT_METRIC_TYPE_METADATA_LATENCY,
	16	CLIENT_METRIC_TYPE_DENTRY_LEASE,
	17	CLIENT_METRIC_TYPE_OPENED_FILES,
	18	CLIENT_METRIC_TYPE_PINNED_ICAPS,
	19	CLIENT_METRIC_TYPE_OPENED_INODES,
	20	CLIENT_METRIC_TYPE_READ_IO_SIZES,
	21	CLIENT_METRIC_TYPE_WRITE_IO_SIZES,
	22
	23	CLIENT_METRIC_TYPE_MAX = CLIENT_METRIC_TYPE_WRITE_IO_SIZES,
	24	};
	25
	26	/*
	27	* This will always have the highest metric bit value
	28	* as the last element of the array.
	29	*/
	30	#define CEPHFS_METRIC_SPEC_CLIENT_SUPPORTED { \
	31	CLIENT_METRIC_TYPE_CAP_INFO, \
	32	CLIENT_METRIC_TYPE_READ_LATENCY, \
	33	CLIENT_METRIC_TYPE_WRITE_LATENCY, \
	34	CLIENT_METRIC_TYPE_METADATA_LATENCY, \
	35	CLIENT_METRIC_TYPE_DENTRY_LEASE, \
	36	CLIENT_METRIC_TYPE_OPENED_FILES, \
	37	CLIENT_METRIC_TYPE_PINNED_ICAPS, \
	38	CLIENT_METRIC_TYPE_OPENED_INODES, \
	39	CLIENT_METRIC_TYPE_READ_IO_SIZES, \
	40	CLIENT_METRIC_TYPE_WRITE_IO_SIZES, \
	41	\
	42	CLIENT_METRIC_TYPE_MAX, \
	43	}
	44
	45	struct ceph_metric_header {
	46	__le32 type; /* ceph metric type */
	47	__u8 ver;
	48	__u8 compat;
	49	__le32 data_len; /* length of sizeof(hit + mis + total) */
	50	} __packed;
	51
	52	/* metric caps header */
	53	struct ceph_metric_cap {
	54	struct ceph_metric_header header;
	55	__le64 hit;
	56	__le64 mis;
	57	__le64 total;
	58	} __packed;
	59
	60	/* metric read latency header */
	61	struct ceph_metric_read_latency {
	62	struct ceph_metric_header header;
	63	__le32 sec;
	64	__le32 nsec;
	65	} __packed;
	66
	67	/* metric write latency header */
	68	struct ceph_metric_write_latency {
	69	struct ceph_metric_header header;
	70	__le32 sec;
	71	__le32 nsec;
	72	} __packed;
	73
	74	/* metric metadata latency header */
	75	struct ceph_metric_metadata_latency {
	76	struct ceph_metric_header header;
	77	__le32 sec;
	78	__le32 nsec;
	79	} __packed;
	80
	81	/* metric dentry lease header */
	82	struct ceph_metric_dlease {
	83	struct ceph_metric_header header;
	84	__le64 hit;
	85	__le64 mis;
	86	__le64 total;
	87	} __packed;
	88
	89	/* metric opened files header */
	90	struct ceph_opened_files {
	91	struct ceph_metric_header header;
	92	__le64 opened_files;
	93	__le64 total;
	94	} __packed;
	95
	96	/* metric pinned i_caps header */
	97	struct ceph_pinned_icaps {
	98	struct ceph_metric_header header;
	99	__le64 pinned_icaps;
	100	__le64 total;
	101	} __packed;
	102
	103	/* metric opened inodes header */
	104	struct ceph_opened_inodes {
	105	struct ceph_metric_header header;
	106	__le64 opened_inodes;
	107	__le64 total;
	108	} __packed;
	109
	110	/* metric read io size header */
	111	struct ceph_read_io_size {
	112	struct ceph_metric_header header;
	113	__le64 total_ops;
	114	__le64 total_size;
	115	} __packed;
	116
	117	/* metric write io size header */
	118	struct ceph_write_io_size {
	119	struct ceph_metric_header header;
	120	__le64 total_ops;
	121	__le64 total_size;
	122	} __packed;
	123
	124	struct ceph_metric_head {
	125	__le32 num; /* the number of metrics that will be sent */
	126	} __packed;
	127
	128	/* This is the global metrics */
	129	struct ceph_client_metric {
	130	atomic64_t total_dentries;
	131	struct percpu_counter d_lease_hit;
	132	struct percpu_counter d_lease_mis;
	133
	134	atomic64_t total_caps;
	135	struct percpu_counter i_caps_hit;
	136	struct percpu_counter i_caps_mis;
	137
	138	spinlock_t read_metric_lock;
	139	u64 total_reads;
	140	u64 read_size_sum;
	141	u64 read_size_min;
	142	u64 read_size_max;
	143	ktime_t read_latency_sum;
	144	ktime_t read_latency_sq_sum;
	145	ktime_t read_latency_min;
	146	ktime_t read_latency_max;
	147
	148	spinlock_t write_metric_lock;
	149	u64 total_writes;
	150	u64 write_size_sum;
	151	u64 write_size_min;
	152	u64 write_size_max;
	153	ktime_t write_latency_sum;
	154	ktime_t write_latency_sq_sum;
	155	ktime_t write_latency_min;
	156	ktime_t write_latency_max;
	157
	158	spinlock_t metadata_metric_lock;
	159	u64 total_metadatas;
	160	ktime_t metadata_latency_sum;
	161	ktime_t metadata_latency_sq_sum;
	162	ktime_t metadata_latency_min;
	163	ktime_t metadata_latency_max;
	164
	165	/* The total number of directories and files that are opened */
	166	atomic64_t opened_files;
	167
	168	/* The total number of inodes that have opened files or directories */
	169	struct percpu_counter opened_inodes;
	170	struct percpu_counter total_inodes;
	171
	172	struct ceph_mds_session *session;
	173	struct delayed_work delayed_work; /* delayed work */
	174	};
	175
	176	static inline void metric_schedule_delayed(struct ceph_client_metric *m)
	177	{
	178	if (disable_send_metrics)
	179	return;
	180
	181	/* per second */
	182	schedule_delayed_work(&m->delayed_work, round_jiffies_relative(HZ));
	183	}
	184
	185	extern int ceph_metric_init(struct ceph_client_metric *m);
	186	extern void ceph_metric_destroy(struct ceph_client_metric *m);
	187
	188	static inline void ceph_update_cap_hit(struct ceph_client_metric *m)
	189	{
	190	percpu_counter_inc(&m->i_caps_hit);
	191	}
	192
	193	static inline void ceph_update_cap_mis(struct ceph_client_metric *m)
	194	{
	195	percpu_counter_inc(&m->i_caps_mis);
	196	}
	197
	198	extern void ceph_update_read_metrics(struct ceph_client_metric *m,
	199	ktime_t r_start, ktime_t r_end,
	200	unsigned int size, int rc);
	201	extern void ceph_update_write_metrics(struct ceph_client_metric *m,
	202	ktime_t r_start, ktime_t r_end,
	203	unsigned int size, int rc);
	204	extern void ceph_update_metadata_metrics(struct ceph_client_metric *m,
	205	ktime_t r_start, ktime_t r_end,
	206	int rc);
	207	#endif /* _FS_CEPH_MDS_METRIC_H */