net/smc/smc_stats.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Shared Memory Communications over RDMA (SMC-R) and RoCE
   4  *
   5  * Macros for SMC statistics
   6  *
   7  * Copyright IBM Corp. 2021
   8  *
   9  * Author(s):  Guvenc Gulce
  10  */
  11
  12 #ifndef NET_SMC_SMC_STATS_H_
  13 #define NET_SMC_SMC_STATS_H_
  14 #include <linux/init.h>
  15 #include <linux/mutex.h>
  16 #include <linux/percpu.h>
  17 #include <linux/ctype.h>
  18 #include <linux/smc.h>
  19
  20 #include "smc_clc.h"
  21
  22 #define SMC_MAX_FBACK_RSN_CNT 30
  23
  24 extern struct smc_stats __percpu *smc_stats;    /* per cpu counters for SMC */
  25 extern struct smc_stats_reason fback_rsn;
  26 extern struct mutex smc_stat_fback_rsn;
  27
  28 enum {
  29         SMC_BUF_8K,
  30         SMC_BUF_16K,
  31         SMC_BUF_32K,
  32         SMC_BUF_64K,
  33         SMC_BUF_128K,
  34         SMC_BUF_256K,
  35         SMC_BUF_512K,
  36         SMC_BUF_1024K,
  37         SMC_BUF_G_1024K,
  38         SMC_BUF_MAX,
  39 };
  40
  41 struct smc_stats_fback {
  42         int     fback_code;
  43         u16     count;
  44 };
  45
  46 struct smc_stats_reason {
  47         struct  smc_stats_fback srv[SMC_MAX_FBACK_RSN_CNT];
  48         struct  smc_stats_fback clnt[SMC_MAX_FBACK_RSN_CNT];
  49         u64                     srv_fback_cnt;
  50         u64                     clnt_fback_cnt;
  51 };
  52
  53 struct smc_stats_rmbcnt {
  54         u64     buf_size_small_peer_cnt;
  55         u64     buf_size_small_cnt;
  56         u64     buf_full_peer_cnt;
  57         u64     buf_full_cnt;
  58         u64     reuse_cnt;
  59         u64     alloc_cnt;
  60         u64     dgrade_cnt;
  61 };
  62
  63 struct smc_stats_memsize {
  64         u64     buf[SMC_BUF_MAX];
  65 };
  66
  67 struct smc_stats_tech {
  68         struct smc_stats_memsize tx_rmbsize;
  69         struct smc_stats_memsize rx_rmbsize;
  70         struct smc_stats_memsize tx_pd;
  71         struct smc_stats_memsize rx_pd;
  72         struct smc_stats_rmbcnt rmb_tx;
  73         struct smc_stats_rmbcnt rmb_rx;
  74         u64                     clnt_v1_succ_cnt;
  75         u64                     clnt_v2_succ_cnt;
  76         u64                     srv_v1_succ_cnt;
  77         u64                     srv_v2_succ_cnt;
  78         u64                     sendpage_cnt;
  79         u64                     urg_data_cnt;
  80         u64                     splice_cnt;
  81         u64                     cork_cnt;
  82         u64                     ndly_cnt;
  83         u64                     rx_bytes;
  84         u64                     tx_bytes;
  85         u64                     rx_cnt;
  86         u64                     tx_cnt;
  87 };
  88
  89 struct smc_stats {
  90         struct smc_stats_tech   smc[2];
  91         u64                     clnt_hshake_err_cnt;
  92         u64                     srv_hshake_err_cnt;
  93 };
  94
  95 #define SMC_STAT_PAYLOAD_SUB(_tech, key, _len, _rc) \
  96 do { \
  97         typeof(_tech) t = (_tech); \
  98         typeof(_len) l = (_len); \
  99         int _pos = fls64((l) >> 13); \
 100         typeof(_rc) r = (_rc); \
 101         int m = SMC_BUF_MAX - 1; \
 102         this_cpu_inc((*smc_stats).smc[t].key ## _cnt); \
 103         if (r <= 0) \
 104                 break; \
 105         _pos = (_pos < m) ? ((l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
 106         this_cpu_inc((*smc_stats).smc[t].key ## _pd.buf[_pos]); \
 107         this_cpu_add((*smc_stats).smc[t].key ## _bytes, r); \
 108 } \
 109 while (0)
 110
 111 #define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \
 112 do { \
 113         typeof(_smc) __smc = _smc; \
 114         typeof(length) _len = (length); \
 115         typeof(rcode) _rc = (rcode); \
 116         bool is_smcd = !__smc->conn.lnk; \
 117         if (is_smcd) \
 118                 SMC_STAT_PAYLOAD_SUB(SMC_TYPE_D, tx, _len, _rc); \
 119         else \
 120                 SMC_STAT_PAYLOAD_SUB(SMC_TYPE_R, tx, _len, _rc); \
 121 } \
 122 while (0)
 123
 124 #define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \
 125 do { \
 126         typeof(_smc) __smc = _smc; \
 127         typeof(length) _len = (length); \
 128         typeof(rcode) _rc = (rcode); \
 129         bool is_smcd = !__smc->conn.lnk; \
 130         if (is_smcd) \
 131                 SMC_STAT_PAYLOAD_SUB(SMC_TYPE_D, rx, _len, _rc); \
 132         else \
 133                 SMC_STAT_PAYLOAD_SUB(SMC_TYPE_R, rx, _len, _rc); \
 134 } \
 135 while (0)
 136
 137 #define SMC_STAT_RMB_SIZE_SUB(_tech, k, _len) \
 138 do { \
 139         typeof(_len) _l = (_len); \
 140         typeof(_tech) t = (_tech); \
 141         int _pos = fls((_l) >> 13); \
 142         int m = SMC_BUF_MAX - 1; \
 143         _pos = (_pos < m) ? ((_l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
 144         this_cpu_inc((*smc_stats).smc[t].k ## _rmbsize.buf[_pos]); \
 145 } \
 146 while (0)
 147
 148 #define SMC_STAT_RMB_SUB(type, t, key) \
 149         this_cpu_inc((*smc_stats).smc[t].rmb ## _ ## key.type ## _cnt)
 150
 151 #define SMC_STAT_RMB_SIZE(_is_smcd, _is_rx, _len) \
 152 do { \
 153         typeof(_is_smcd) is_d = (_is_smcd); \
 154         typeof(_is_rx) is_r = (_is_rx); \
 155         typeof(_len) l = (_len); \
 156         if ((is_d) && (is_r)) \
 157                 SMC_STAT_RMB_SIZE_SUB(SMC_TYPE_D, rx, l); \
 158         if ((is_d) && !(is_r)) \
 159                 SMC_STAT_RMB_SIZE_SUB(SMC_TYPE_D, tx, l); \
 160         if (!(is_d) && (is_r)) \
 161                 SMC_STAT_RMB_SIZE_SUB(SMC_TYPE_R, rx, l); \
 162         if (!(is_d) && !(is_r)) \
 163                 SMC_STAT_RMB_SIZE_SUB(SMC_TYPE_R, tx, l); \
 164 } \
 165 while (0)
 166
 167 #define SMC_STAT_RMB(type, _is_smcd, _is_rx) \
 168 do { \
 169         typeof(_is_smcd) is_d = (_is_smcd); \
 170         typeof(_is_rx) is_r = (_is_rx); \
 171         if ((is_d) && (is_r)) \
 172                 SMC_STAT_RMB_SUB(type, SMC_TYPE_D, rx); \
 173         if ((is_d) && !(is_r)) \
 174                 SMC_STAT_RMB_SUB(type, SMC_TYPE_D, tx); \
 175         if (!(is_d) && (is_r)) \
 176                 SMC_STAT_RMB_SUB(type, SMC_TYPE_R, rx); \
 177         if (!(is_d) && !(is_r)) \
 178                 SMC_STAT_RMB_SUB(type, SMC_TYPE_R, tx); \
 179 } \
 180 while (0)
 181
 182 #define SMC_STAT_BUF_REUSE(is_smcd, is_rx) \
 183         SMC_STAT_RMB(reuse, is_smcd, is_rx)
 184
 185 #define SMC_STAT_RMB_ALLOC(is_smcd, is_rx) \
 186         SMC_STAT_RMB(alloc, is_smcd, is_rx)
 187
 188 #define SMC_STAT_RMB_DOWNGRADED(is_smcd, is_rx) \
 189         SMC_STAT_RMB(dgrade, is_smcd, is_rx)
 190
 191 #define SMC_STAT_RMB_TX_PEER_FULL(is_smcd) \
 192         SMC_STAT_RMB(buf_full_peer, is_smcd, false)
 193
 194 #define SMC_STAT_RMB_TX_FULL(is_smcd) \
 195         SMC_STAT_RMB(buf_full, is_smcd, false)
 196
 197 #define SMC_STAT_RMB_TX_PEER_SIZE_SMALL(is_smcd) \
 198         SMC_STAT_RMB(buf_size_small_peer, is_smcd, false)
 199
 200 #define SMC_STAT_RMB_TX_SIZE_SMALL(is_smcd) \
 201         SMC_STAT_RMB(buf_size_small, is_smcd, false)
 202
 203 #define SMC_STAT_RMB_RX_SIZE_SMALL(is_smcd) \
 204         SMC_STAT_RMB(buf_size_small, is_smcd, true)
 205
 206 #define SMC_STAT_RMB_RX_FULL(is_smcd) \
 207         SMC_STAT_RMB(buf_full, is_smcd, true)
 208
 209 #define SMC_STAT_INC(is_smcd, type) \
 210 do { \
 211         if ((is_smcd)) \
 212                 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \
 213         else \
 214                 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].type); \
 215 } \
 216 while (0)
 217
 218 #define SMC_STAT_CLNT_SUCC_INC(_aclc) \
 219 do { \
 220         typeof(_aclc) acl = (_aclc); \
 221         bool is_v2 = (acl->hdr.version == SMC_V2); \
 222         bool is_smcd = (acl->hdr.typev1 == SMC_TYPE_D); \
 223         if (is_v2 && is_smcd) \
 224                 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v2_succ_cnt); \
 225         else if (is_v2 && !is_smcd) \
 226                 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v2_succ_cnt); \
 227         else if (!is_v2 && is_smcd) \
 228                 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v1_succ_cnt); \
 229         else if (!is_v2 && !is_smcd) \
 230                 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v1_succ_cnt); \
 231 } \
 232 while (0)
 233
 234 #define SMC_STAT_SERV_SUCC_INC(_ini) \
 235 do { \
 236         typeof(_ini) i = (_ini); \
 237         bool is_v2 = (i->smcd_version & SMC_V2); \
 238         bool is_smcd = (i->is_smcd); \
 239         if (is_v2 && is_smcd) \
 240                 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v2_succ_cnt); \
 241         else if (is_v2 && !is_smcd) \
 242                 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v2_succ_cnt); \
 243         else if (!is_v2 && is_smcd) \
 244                 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v1_succ_cnt); \
 245         else if (!is_v2 && !is_smcd) \
 246                 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v1_succ_cnt); \
 247 } \
 248 while (0)
 249
 250 int smc_nl_get_stats(struct sk_buff *skb, struct netlink_callback *cb);
 251 int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb);
 252 int smc_stats_init(void) __init;
 253 void smc_stats_exit(void);
 254
 255 #endif /* NET_SMC_SMC_STATS_H_ */