LXR linux/fs/ceph/metric.c

   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_metric_dlease *dlease;
  20        struct ceph_opened_files *files;
  21        struct ceph_pinned_icaps *icaps;
  22        struct ceph_opened_inodes *inodes;
  23        struct ceph_read_io_size *rsize;
  24        struct ceph_write_io_size *wsize;
  25        struct ceph_client_metric *m = &mdsc->metric;
  26        u64 nr_caps = atomic64_read(&m->total_caps);
  27        u32 header_len = sizeof(struct ceph_metric_header);
  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)
  35              + sizeof(*meta) + sizeof(*dlease) + sizeof(*files)
  36              + sizeof(*icaps) + sizeof(*inodes) + sizeof(*rsize)
  37              + sizeof(*wsize);
  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);
  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);
  54        cap->hit = cpu_to_le64(percpu_counter_sum(&m->i_caps_hit));
  55        cap->mis = cpu_to_le64(percpu_counter_sum(&m->i_caps_mis));
  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);
  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);
  65        sum = m->metric[METRIC_READ].latency_sum;
  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);
  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);
  77        sum = m->metric[METRIC_WRITE].latency_sum;
  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);
  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);
  89        sum = m->metric[METRIC_METADATA].latency_sum;
  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
  95        /* encode the dentry lease metric */
  96        dlease = (struct ceph_metric_dlease *)(meta + 1);
  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);
 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
 106        sum = percpu_counter_sum(&m->total_inodes);
 107
 108        /* encode the opened files metric */
 109        files = (struct ceph_opened_files *)(dlease + 1);
 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);
 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);
 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);
 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);
 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);
 134        inodes->opened_inodes = cpu_to_le64(percpu_counter_sum(&m->opened_inodes));
 135        inodes->total = cpu_to_le64(sum);
 136        items++;
 137
 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);
 144        rsize->total_ops = cpu_to_le64(m->metric[METRIC_READ].total);
 145        rsize->total_size = cpu_to_le64(m->metric[METRIC_READ].size_sum);
 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);
 154        wsize->total_ops = cpu_to_le64(m->metric[METRIC_WRITE].total);
 155        wsize->total_size = cpu_to_le64(m->metric[METRIC_WRITE].size_sum);
 156        items++;
 157
 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);
 163        ceph_con_send(&s->s_con, msg);
 164
 165        return true;
 166}
 167
 168
 169static 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
 196static 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}
 218
 219int ceph_metric_init(struct ceph_client_metric *m)
 220{
 221        struct ceph_metric *metric;
 222        int ret, i;
 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;
 231
 232        ret = percpu_counter_init(&m->d_lease_mis, 0, GFP_KERNEL);
 233        if (ret)
 234                goto err_d_lease_mis;
 235
 236        atomic64_set(&m->total_caps, 0);
 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;
 244
 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        }
 257
 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
 266        m->session = NULL;
 267        INIT_DELAYED_WORK(&m->delayed_work, metric_delayed_work);
 268
 269        return 0;
 270
 271err_total_inodes:
 272        percpu_counter_destroy(&m->opened_inodes);
 273err_opened_inodes:
 274        percpu_counter_destroy(&m->i_caps_mis);
 275err_i_caps_mis:
 276        percpu_counter_destroy(&m->i_caps_hit);
 277err_i_caps_hit:
 278        percpu_counter_destroy(&m->d_lease_mis);
 279err_d_lease_mis:
 280        percpu_counter_destroy(&m->d_lease_hit);
 281
 282        return ret;
 283}
 284
 285void ceph_metric_destroy(struct ceph_client_metric *m)
 286{
 287        if (!m)
 288                return;
 289
 290        cancel_delayed_work_sync(&m->delayed_work);
 291
 292        percpu_counter_destroy(&m->total_inodes);
 293        percpu_counter_destroy(&m->opened_inodes);
 294        percpu_counter_destroy(&m->i_caps_mis);
 295        percpu_counter_destroy(&m->i_caps_hit);
 296        percpu_counter_destroy(&m->d_lease_mis);
 297        percpu_counter_destroy(&m->d_lease_hit);
 298
 299        ceph_put_mds_session(m->session);
 300}
 301
 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}
 309
 310static inline void __update_stdev(ktime_t total, ktime_t lsum,
 311                                  ktime_t *sq_sump, ktime_t lat)
 312{
 313        ktime_t avg, sq;
 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
 326void ceph_update_metrics(struct ceph_metric *m,
 327                         ktime_t r_start, ktime_t r_end,
 328                         unsigned int size, int rc)
 329{
 330        ktime_t lat = ktime_sub(r_end, r_start);
 331        ktime_t total;
 332
 333        if (unlikely(rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT))
 334                return;
 335
 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);
 344}
 345