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 } 199