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 36 23 24 enum { 25 SMC_BUF_8K, 26 SMC_BUF_16K, 27 SMC_BUF_32K, 28 SMC_BUF_64K, 29 SMC_BUF_128K, 30 SMC_BUF_256K, 31 SMC_BUF_512K, 32 SMC_BUF_1024K, 33 SMC_BUF_G_1024K, 34 SMC_BUF_MAX, 35 }; 36 37 struct smc_stats_fback { 38 int fback_code; 39 u16 count; 40 }; 41 42 struct smc_stats_rsn { 43 struct smc_stats_fback srv[SMC_MAX_FBACK_RSN_CNT]; 44 struct smc_stats_fback clnt[SMC_MAX_FBACK_RSN_CNT]; 45 u64 srv_fback_cnt; 46 u64 clnt_fback_cnt; 47 }; 48 49 struct smc_stats_rmbcnt { 50 u64 buf_size_small_peer_cnt; 51 u64 buf_size_small_cnt; 52 u64 buf_full_peer_cnt; 53 u64 buf_full_cnt; 54 u64 reuse_cnt; 55 u64 alloc_cnt; 56 u64 dgrade_cnt; 57 }; 58 59 struct smc_stats_memsize { 60 u64 buf[SMC_BUF_MAX]; 61 }; 62 63 struct smc_stats_tech { 64 struct smc_stats_memsize tx_rmbsize; 65 struct smc_stats_memsize rx_rmbsize; 66 struct smc_stats_memsize tx_pd; 67 struct smc_stats_memsize rx_pd; 68 struct smc_stats_rmbcnt rmb_tx; 69 struct smc_stats_rmbcnt rmb_rx; 70 u64 clnt_v1_succ_cnt; 71 u64 clnt_v2_succ_cnt; 72 u64 srv_v1_succ_cnt; 73 u64 srv_v2_succ_cnt; 74 u64 urg_data_cnt; 75 u64 splice_cnt; 76 u64 cork_cnt; 77 u64 ndly_cnt; 78 u64 rx_bytes; 79 u64 tx_bytes; 80 u64 rx_cnt; 81 u64 tx_cnt; 82 u64 rx_rmbuse; 83 u64 tx_rmbuse; 84 }; 85 86 struct smc_stats { 87 struct smc_stats_tech smc[2]; 88 u64 clnt_hshake_err_cnt; 89 u64 srv_hshake_err_cnt; 90 }; 91 92 #define SMC_STAT_PAYLOAD_SUB(_smc_stats, _tech, key, _len, _rc) \ 93 do { \ 94 typeof(_smc_stats) stats = (_smc_stats); \ 95 typeof(_tech) t = (_tech); \ 96 typeof(_len) l = (_len); \ 97 int _pos; \ 98 typeof(_rc) r = (_rc); \ 99 int m = SMC_BUF_MAX - 1; \ 100 this_cpu_inc((*stats).smc[t].key ## _cnt); \ 101 if (r <= 0 || l <= 0) \ 102 break; \ 103 _pos = fls64((l - 1) >> 13); \ 104 _pos = (_pos <= m) ? _pos : m; \ 105 this_cpu_inc((*stats).smc[t].key ## _pd.buf[_pos]); \ 106 this_cpu_add((*stats).smc[t].key ## _bytes, r); \ 107 } \ 108 while (0) 109 110 #define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \ 111 do { \ 112 typeof(_smc) __smc = _smc; \ 113 struct net *_net = sock_net(&__smc->sk); \ 114 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ 115 typeof(length) _len = (length); \ 116 typeof(rcode) _rc = (rcode); \ 117 bool is_smcd = !__smc->conn.lnk; \ 118 if (is_smcd) \ 119 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, tx, _len, _rc); \ 120 else \ 121 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, tx, _len, _rc); \ 122 } \ 123 while (0) 124 125 #define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \ 126 do { \ 127 typeof(_smc) __smc = _smc; \ 128 struct net *_net = sock_net(&__smc->sk); \ 129 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ 130 typeof(length) _len = (length); \ 131 typeof(rcode) _rc = (rcode); \ 132 bool is_smcd = !__smc->conn.lnk; \ 133 if (is_smcd) \ 134 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, rx, _len, _rc); \ 135 else \ 136 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, rx, _len, _rc); \ 137 } \ 138 while (0) 139 140 #define SMC_STAT_RMB_SIZE_SUB(_smc_stats, _tech, k, _is_add, _len) \ 141 do { \ 142 typeof(_smc_stats) stats = (_smc_stats); \ 143 typeof(_is_add) is_a = (_is_add); \ 144 typeof(_len) _l = (_len); \ 145 typeof(_tech) t = (_tech); \ 146 int _pos; \ 147 int m = SMC_BUF_MAX - 1; \ 148 if (_l <= 0) \ 149 break; \ 150 if (is_a) { \ 151 _pos = fls((_l - 1) >> 13); \ 152 _pos = (_pos <= m) ? _pos : m; \ 153 this_cpu_inc((*stats).smc[t].k ## _rmbsize.buf[_pos]); \ 154 this_cpu_add((*stats).smc[t].k ## _rmbuse, _l); \ 155 } else { \ 156 this_cpu_sub((*stats).smc[t].k ## _rmbuse, _l); \ 157 } \ 158 } \ 159 while (0) 160 161 #define SMC_STAT_RMB_SUB(_smc_stats, type, t, key) \ 162 this_cpu_inc((*(_smc_stats)).smc[t].rmb ## _ ## key.type ## _cnt) 163 164 #define SMC_STAT_RMB_SIZE(_smc, _is_smcd, _is_rx, _is_add, _len) \ 165 do { \ 166 struct net *_net = sock_net(&(_smc)->sk); \ 167 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ 168 typeof(_is_add) is_add = (_is_add); \ 169 typeof(_is_smcd) is_d = (_is_smcd); \ 170 typeof(_is_rx) is_r = (_is_rx); \ 171 typeof(_len) l = (_len); \ 172 if ((is_d) && (is_r)) \ 173 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, rx, is_add, l); \ 174 if ((is_d) && !(is_r)) \ 175 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, tx, is_add, l); \ 176 if (!(is_d) && (is_r)) \ 177 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, rx, is_add, l); \ 178 if (!(is_d) && !(is_r)) \ 179 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, tx, is_add, l); \ 180 } \ 181 while (0) 182 183 #define SMC_STAT_RMB(_smc, type, _is_smcd, _is_rx) \ 184 do { \ 185 struct net *net = sock_net(&(_smc)->sk); \ 186 struct smc_stats __percpu *_smc_stats = net->smc.smc_stats; \ 187 typeof(_is_smcd) is_d = (_is_smcd); \ 188 typeof(_is_rx) is_r = (_is_rx); \ 189 if ((is_d) && (is_r)) \ 190 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, rx); \ 191 if ((is_d) && !(is_r)) \ 192 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, tx); \ 193 if (!(is_d) && (is_r)) \ 194 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, rx); \ 195 if (!(is_d) && !(is_r)) \ 196 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, tx); \ 197 } \ 198 while (0) 199 200 #define SMC_STAT_BUF_REUSE(smc, is_smcd, is_rx) \ 201 SMC_STAT_RMB(smc, reuse, is_smcd, is_rx) 202 203 #define SMC_STAT_RMB_ALLOC(smc, is_smcd, is_rx) \ 204 SMC_STAT_RMB(smc, alloc, is_smcd, is_rx) 205 206 #define SMC_STAT_RMB_DOWNGRADED(smc, is_smcd, is_rx) \ 207 SMC_STAT_RMB(smc, dgrade, is_smcd, is_rx) 208 209 #define SMC_STAT_RMB_TX_PEER_FULL(smc, is_smcd) \ 210 SMC_STAT_RMB(smc, buf_full_peer, is_smcd, false) 211 212 #define SMC_STAT_RMB_TX_FULL(smc, is_smcd) \ 213 SMC_STAT_RMB(smc, buf_full, is_smcd, false) 214 215 #define SMC_STAT_RMB_TX_PEER_SIZE_SMALL(smc, is_smcd) \ 216 SMC_STAT_RMB(smc, buf_size_small_peer, is_smcd, false) 217 218 #define SMC_STAT_RMB_TX_SIZE_SMALL(smc, is_smcd) \ 219 SMC_STAT_RMB(smc, buf_size_small, is_smcd, false) 220 221 #define SMC_STAT_RMB_RX_SIZE_SMALL(smc, is_smcd) \ 222 SMC_STAT_RMB(smc, buf_size_small, is_smcd, true) 223 224 #define SMC_STAT_RMB_RX_FULL(smc, is_smcd) \ 225 SMC_STAT_RMB(smc, buf_full, is_smcd, true) 226 227 #define SMC_STAT_INC(_smc, type) \ 228 do { \ 229 typeof(_smc) __smc = _smc; \ 230 bool is_smcd = !(__smc)->conn.lnk; \ 231 struct net *net = sock_net(&(__smc)->sk); \ 232 struct smc_stats __percpu *smc_stats = net->smc.smc_stats; \ 233 if ((is_smcd)) \ 234 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \ 235 else \ 236 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].type); \ 237 } \ 238 while (0) 239 240 #define SMC_STAT_CLNT_SUCC_INC(net, _aclc) \ 241 do { \ 242 typeof(_aclc) acl = (_aclc); \ 243 bool is_v2 = (acl->hdr.version == SMC_V2); \ 244 bool is_smcd = (acl->hdr.typev1 == SMC_TYPE_D); \ 245 struct smc_stats __percpu *smc_stats = (net)->smc.smc_stats; \ 246 if (is_v2 && is_smcd) \ 247 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v2_succ_cnt); \ 248 else if (is_v2 && !is_smcd) \ 249 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v2_succ_cnt); \ 250 else if (!is_v2 && is_smcd) \ 251 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v1_succ_cnt); \ 252 else if (!is_v2 && !is_smcd) \ 253 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v1_succ_cnt); \ 254 } \ 255 while (0) 256 257 #define SMC_STAT_SERV_SUCC_INC(net, _ini) \ 258 do { \ 259 typeof(_ini) i = (_ini); \ 260 bool is_smcd = (i->is_smcd); \ 261 u8 version = is_smcd ? i->smcd_version : i->smcr_version; \ 262 bool is_v2 = (version & SMC_V2); \ 263 typeof(net->smc.smc_stats) smc_stats = (net)->smc.smc_stats; \ 264 if (is_v2 && is_smcd) \ 265 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v2_succ_cnt); \ 266 else if (is_v2 && !is_smcd) \ 267 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v2_succ_cnt); \ 268 else if (!is_v2 && is_smcd) \ 269 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v1_succ_cnt); \ 270 else if (!is_v2 && !is_smcd) \ 271 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v1_succ_cnt); \ 272 } \ 273 while (0) 274 275 int smc_nl_get_stats(struct sk_buff *skb, struct netlink_callback *cb); 276 int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb); 277 int smc_stats_init(struct net *net); 278 void smc_stats_exit(struct net *net); 279 280 #endif /* NET_SMC_SMC_STATS_H_ */ 281