ulp/rtrs/rtrs-clt-stats.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * RDMA Transport Layer
   4  *
   5  * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
   6  * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
   7  * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
   8  */
   9 #undef pr_fmt
  10 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
  11
  12 #include "rtrs-clt.h"
  13
  14 void rtrs_clt_update_wc_stats(struct rtrs_clt_con *con)
  15 {
  16         struct rtrs_clt_path *clt_path = to_clt_path(con->c.path);
  17         struct rtrs_clt_stats *stats = clt_path->stats;
  18         struct rtrs_clt_stats_pcpu *s;
  19         int cpu;
  20
  21         cpu = raw_smp_processor_id();
  22         s = get_cpu_ptr(stats->pcpu_stats);
  23         if (con->cpu != cpu) {
  24                 s->cpu_migr.to++;
  25
  26                 /* Careful here, override s pointer */
  27                 s = per_cpu_ptr(stats->pcpu_stats, con->cpu);
  28                 atomic_inc(&s->cpu_migr.from);
  29         }
  30         put_cpu_ptr(stats->pcpu_stats);
  31 }
  32
  33 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *stats)
  34 {
  35         this_cpu_inc(stats->pcpu_stats->rdma.failover_cnt);
  36 }
  37
  38 int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf)
  39 {
  40         struct rtrs_clt_stats_pcpu *s;
  41
  42         size_t used;
  43         int cpu;
  44
  45         used = 0;
  46         for_each_possible_cpu(cpu) {
  47                 s = per_cpu_ptr(stats->pcpu_stats, cpu);
  48                 used += sysfs_emit_at(buf, used, "%d ",
  49                                   atomic_read(&s->cpu_migr.from));
  50         }
  51
  52         used += sysfs_emit_at(buf, used, "\n");
  53
  54         return used;
  55 }
  56
  57 int rtrs_clt_stats_migration_to_cnt_to_str(struct rtrs_clt_stats *stats, char *buf)
  58 {
  59         struct rtrs_clt_stats_pcpu *s;
  60
  61         size_t used;
  62         int cpu;
  63
  64         used = 0;
  65         for_each_possible_cpu(cpu) {
  66                 s = per_cpu_ptr(stats->pcpu_stats, cpu);
  67                 used += sysfs_emit_at(buf, used, "%d ", s->cpu_migr.to);
  68         }
  69
  70         used += sysfs_emit_at(buf, used, "\n");
  71
  72         return used;
  73 }
  74
  75 int rtrs_clt_stats_reconnects_to_str(struct rtrs_clt_stats *stats, char *buf)
  76 {
  77         return sysfs_emit(buf, "%d %d\n", stats->reconnects.successful_cnt,
  78                           stats->reconnects.fail_cnt);
  79 }
  80
  81 ssize_t rtrs_clt_stats_rdma_to_str(struct rtrs_clt_stats *stats, char *page)
  82 {
  83         struct rtrs_clt_stats_rdma sum;
  84         struct rtrs_clt_stats_rdma *r;
  85         int cpu;
  86
  87         memset(&sum, 0, sizeof(sum));
  88
  89         for_each_possible_cpu(cpu) {
  90                 r = &per_cpu_ptr(stats->pcpu_stats, cpu)->rdma;
  91
  92                 sum.dir[READ].cnt         += r->dir[READ].cnt;
  93                 sum.dir[READ].size_total  += r->dir[READ].size_total;
  94                 sum.dir[WRITE].cnt        += r->dir[WRITE].cnt;
  95                 sum.dir[WRITE].size_total += r->dir[WRITE].size_total;
  96                 sum.failover_cnt          += r->failover_cnt;
  97         }
  98
  99         return sysfs_emit(page, "%llu %llu %llu %llu %u %llu\n",
 100                          sum.dir[READ].cnt, sum.dir[READ].size_total,
 101                          sum.dir[WRITE].cnt, sum.dir[WRITE].size_total,
 102                          atomic_read(&stats->inflight), sum.failover_cnt);
 103 }
 104
 105 ssize_t rtrs_clt_reset_all_help(struct rtrs_clt_stats *s, char *page)
 106 {
 107         return sysfs_emit(page, "echo 1 to reset all statistics\n");
 108 }
 109
 110 int rtrs_clt_reset_rdma_stats(struct rtrs_clt_stats *stats, bool enable)
 111 {
 112         struct rtrs_clt_stats_pcpu *s;
 113         int cpu;
 114
 115         if (!enable)
 116                 return -EINVAL;
 117
 118         for_each_possible_cpu(cpu) {
 119                 s = per_cpu_ptr(stats->pcpu_stats, cpu);
 120                 memset(&s->rdma, 0, sizeof(s->rdma));
 121         }
 122
 123         return 0;
 124 }
 125
 126 int rtrs_clt_reset_cpu_migr_stats(struct rtrs_clt_stats *stats, bool enable)
 127 {
 128         struct rtrs_clt_stats_pcpu *s;
 129         int cpu;
 130
 131         if (!enable)
 132                 return -EINVAL;
 133
 134         for_each_possible_cpu(cpu) {
 135                 s = per_cpu_ptr(stats->pcpu_stats, cpu);
 136                 memset(&s->cpu_migr, 0, sizeof(s->cpu_migr));
 137         }
 138
 139         return 0;
 140 }
 141
 142 int rtrs_clt_reset_reconnects_stat(struct rtrs_clt_stats *stats, bool enable)
 143 {
 144         if (!enable)
 145                 return -EINVAL;
 146
 147         memset(&stats->reconnects, 0, sizeof(stats->reconnects));
 148
 149         return 0;
 150 }
 151
 152 int rtrs_clt_reset_all_stats(struct rtrs_clt_stats *s, bool enable)
 153 {
 154         if (enable) {
 155                 rtrs_clt_reset_rdma_stats(s, enable);
 156                 rtrs_clt_reset_cpu_migr_stats(s, enable);
 157                 rtrs_clt_reset_reconnects_stat(s, enable);
 158                 atomic_set(&s->inflight, 0);
 159                 return 0;
 160         }
 161
 162         return -EINVAL;
 163 }
 164
 165 static inline void rtrs_clt_update_rdma_stats(struct rtrs_clt_stats *stats,
 166                                                size_t size, int d)
 167 {
 168         this_cpu_inc(stats->pcpu_stats->rdma.dir[d].cnt);
 169         this_cpu_add(stats->pcpu_stats->rdma.dir[d].size_total, size);
 170 }
 171
 172 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir)
 173 {
 174         struct rtrs_clt_con *con = req->con;
 175         struct rtrs_clt_path *clt_path = to_clt_path(con->c.path);
 176         struct rtrs_clt_stats *stats = clt_path->stats;
 177         unsigned int len;
 178
 179         len = req->usr_len + req->data_len;
 180         rtrs_clt_update_rdma_stats(stats, len, dir);
 181         if (req->mp_policy == MP_POLICY_MIN_INFLIGHT)
 182                 atomic_inc(&stats->inflight);
 183 }
 184
 185 int rtrs_clt_init_stats(struct rtrs_clt_stats *stats)
 186 {
 187         stats->pcpu_stats = alloc_percpu(typeof(*stats->pcpu_stats));
 188         if (!stats->pcpu_stats)
 189                 return -ENOMEM;
 190
 191         /*
 192          * successful_cnt will be set to 0 after session
 193          * is established for the first time
 194          */
 195         stats->reconnects.successful_cnt = -1;
 196
 197         return 0;
 198 }