fs/ceph/metric.h

   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 enum metric_type {
 129         METRIC_READ,
 130         METRIC_WRITE,
 131         METRIC_METADATA,
 132         METRIC_COPYFROM,
 133         METRIC_MAX
 134 };
 135
 136 struct ceph_metric {
 137         spinlock_t lock;
 138         u64 total;
 139         u64 size_sum;
 140         u64 size_min;
 141         u64 size_max;
 142         ktime_t latency_sum;
 143         ktime_t latency_sq_sum;
 144         ktime_t latency_min;
 145         ktime_t latency_max;
 146 };
 147
 148 /* This is the global metrics */
 149 struct ceph_client_metric {
 150         atomic64_t            total_dentries;
 151         struct percpu_counter d_lease_hit;
 152         struct percpu_counter d_lease_mis;
 153
 154         atomic64_t            total_caps;
 155         struct percpu_counter i_caps_hit;
 156         struct percpu_counter i_caps_mis;
 157
 158         struct ceph_metric metric[METRIC_MAX];
 159
 160         /* The total number of directories and files that are opened */
 161         atomic64_t opened_files;
 162
 163         /* The total number of inodes that have opened files or directories */
 164         struct percpu_counter opened_inodes;
 165         struct percpu_counter total_inodes;
 166
 167         struct ceph_mds_session *session;
 168         struct delayed_work delayed_work;  /* delayed work */
 169 };
 170
 171 static inline void metric_schedule_delayed(struct ceph_client_metric *m)
 172 {
 173         if (disable_send_metrics)
 174                 return;
 175
 176         /* per second */
 177         schedule_delayed_work(&m->delayed_work, round_jiffies_relative(HZ));
 178 }
 179
 180 extern int ceph_metric_init(struct ceph_client_metric *m);
 181 extern void ceph_metric_destroy(struct ceph_client_metric *m);
 182
 183 static inline void ceph_update_cap_hit(struct ceph_client_metric *m)
 184 {
 185         percpu_counter_inc(&m->i_caps_hit);
 186 }
 187
 188 static inline void ceph_update_cap_mis(struct ceph_client_metric *m)
 189 {
 190         percpu_counter_inc(&m->i_caps_mis);
 191 }
 192
 193 extern void ceph_update_metrics(struct ceph_metric *m,
 194                                 ktime_t r_start, ktime_t r_end,
 195                                 unsigned int size, int rc);
 196
 197 static inline void ceph_update_read_metrics(struct ceph_client_metric *m,
 198                                             ktime_t r_start, ktime_t r_end,
 199                                             unsigned int size, int rc)
 200 {
 201         ceph_update_metrics(&m->metric[METRIC_READ],
 202                             r_start, r_end, size, rc);
 203 }
 204 static inline void ceph_update_write_metrics(struct ceph_client_metric *m,
 205                                              ktime_t r_start, ktime_t r_end,
 206                                              unsigned int size, int rc)
 207 {
 208         ceph_update_metrics(&m->metric[METRIC_WRITE],
 209                             r_start, r_end, size, rc);
 210 }
 211 static inline void ceph_update_metadata_metrics(struct ceph_client_metric *m,
 212                                                 ktime_t r_start, ktime_t r_end,
 213                                                 int rc)
 214 {
 215         ceph_update_metrics(&m->metric[METRIC_METADATA],
 216                             r_start, r_end, 0, rc);
 217 }
 218 static inline void ceph_update_copyfrom_metrics(struct ceph_client_metric *m,
 219                                                 ktime_t r_start, ktime_t r_end,
 220                                                 unsigned int size, int rc)
 221 {
 222         ceph_update_metrics(&m->metric[METRIC_COPYFROM],
 223                             r_start, r_end, size, rc);
 224 }
 225 #endif /* _FS_CEPH_MDS_METRIC_H */