1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
5 * Macros for SMC statistics
7 * Copyright IBM Corp. 2021
9 * Author(s): Guvenc Gulce
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>
22 #define SMC_MAX_FBACK_RSN_CNT 30
37 struct smc_stats_fback {
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];
49 struct smc_stats_rmbcnt {
50 u64 buf_size_small_peer_cnt;
51 u64 buf_size_small_cnt;
52 u64 buf_full_peer_cnt;
59 struct smc_stats_memsize {
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;
86 struct smc_stats_tech smc[2];
87 u64 clnt_hshake_err_cnt;
88 u64 srv_hshake_err_cnt;
91 #define SMC_STAT_PAYLOAD_SUB(_smc_stats, _tech, key, _len, _rc) \
93 typeof(_smc_stats) stats = (_smc_stats); \
94 typeof(_tech) t = (_tech); \
95 typeof(_len) l = (_len); \
97 typeof(_rc) r = (_rc); \
98 int m = SMC_BUF_MAX - 1; \
99 this_cpu_inc((*stats).smc[t].key ## _cnt); \
100 if (r <= 0 || l <= 0) \
102 _pos = fls64((l - 1) >> 13); \
103 _pos = (_pos <= m) ? _pos : m; \
104 this_cpu_inc((*stats).smc[t].key ## _pd.buf[_pos]); \
105 this_cpu_add((*stats).smc[t].key ## _bytes, r); \
109 #define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \
111 typeof(_smc) __smc = _smc; \
112 struct net *_net = sock_net(&__smc->sk); \
113 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
114 typeof(length) _len = (length); \
115 typeof(rcode) _rc = (rcode); \
116 bool is_smcd = !__smc->conn.lnk; \
118 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, tx, _len, _rc); \
120 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, tx, _len, _rc); \
124 #define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \
126 typeof(_smc) __smc = _smc; \
127 struct net *_net = sock_net(&__smc->sk); \
128 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
129 typeof(length) _len = (length); \
130 typeof(rcode) _rc = (rcode); \
131 bool is_smcd = !__smc->conn.lnk; \
133 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, rx, _len, _rc); \
135 SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, rx, _len, _rc); \
139 #define SMC_STAT_RMB_SIZE_SUB(_smc_stats, _tech, k, _len) \
141 typeof(_len) _l = (_len); \
142 typeof(_tech) t = (_tech); \
144 int m = SMC_BUF_MAX - 1; \
147 _pos = fls((_l - 1) >> 13); \
148 _pos = (_pos <= m) ? _pos : m; \
149 this_cpu_inc((*(_smc_stats)).smc[t].k ## _rmbsize.buf[_pos]); \
153 #define SMC_STAT_RMB_SUB(_smc_stats, type, t, key) \
154 this_cpu_inc((*(_smc_stats)).smc[t].rmb ## _ ## key.type ## _cnt)
156 #define SMC_STAT_RMB_SIZE(_smc, _is_smcd, _is_rx, _len) \
158 struct net *_net = sock_net(&(_smc)->sk); \
159 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
160 typeof(_is_smcd) is_d = (_is_smcd); \
161 typeof(_is_rx) is_r = (_is_rx); \
162 typeof(_len) l = (_len); \
163 if ((is_d) && (is_r)) \
164 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, rx, l); \
165 if ((is_d) && !(is_r)) \
166 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, tx, l); \
167 if (!(is_d) && (is_r)) \
168 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, rx, l); \
169 if (!(is_d) && !(is_r)) \
170 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, tx, l); \
174 #define SMC_STAT_RMB(_smc, type, _is_smcd, _is_rx) \
176 struct net *net = sock_net(&(_smc)->sk); \
177 struct smc_stats __percpu *_smc_stats = net->smc.smc_stats; \
178 typeof(_is_smcd) is_d = (_is_smcd); \
179 typeof(_is_rx) is_r = (_is_rx); \
180 if ((is_d) && (is_r)) \
181 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, rx); \
182 if ((is_d) && !(is_r)) \
183 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, tx); \
184 if (!(is_d) && (is_r)) \
185 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, rx); \
186 if (!(is_d) && !(is_r)) \
187 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, tx); \
191 #define SMC_STAT_BUF_REUSE(smc, is_smcd, is_rx) \
192 SMC_STAT_RMB(smc, reuse, is_smcd, is_rx)
194 #define SMC_STAT_RMB_ALLOC(smc, is_smcd, is_rx) \
195 SMC_STAT_RMB(smc, alloc, is_smcd, is_rx)
197 #define SMC_STAT_RMB_DOWNGRADED(smc, is_smcd, is_rx) \
198 SMC_STAT_RMB(smc, dgrade, is_smcd, is_rx)
200 #define SMC_STAT_RMB_TX_PEER_FULL(smc, is_smcd) \
201 SMC_STAT_RMB(smc, buf_full_peer, is_smcd, false)
203 #define SMC_STAT_RMB_TX_FULL(smc, is_smcd) \
204 SMC_STAT_RMB(smc, buf_full, is_smcd, false)
206 #define SMC_STAT_RMB_TX_PEER_SIZE_SMALL(smc, is_smcd) \
207 SMC_STAT_RMB(smc, buf_size_small_peer, is_smcd, false)
209 #define SMC_STAT_RMB_TX_SIZE_SMALL(smc, is_smcd) \
210 SMC_STAT_RMB(smc, buf_size_small, is_smcd, false)
212 #define SMC_STAT_RMB_RX_SIZE_SMALL(smc, is_smcd) \
213 SMC_STAT_RMB(smc, buf_size_small, is_smcd, true)
215 #define SMC_STAT_RMB_RX_FULL(smc, is_smcd) \
216 SMC_STAT_RMB(smc, buf_full, is_smcd, true)
218 #define SMC_STAT_INC(_smc, type) \
220 typeof(_smc) __smc = _smc; \
221 bool is_smcd = !(__smc)->conn.lnk; \
222 struct net *net = sock_net(&(__smc)->sk); \
223 struct smc_stats __percpu *smc_stats = net->smc.smc_stats; \
225 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \
227 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].type); \
231 #define SMC_STAT_CLNT_SUCC_INC(net, _aclc) \
233 typeof(_aclc) acl = (_aclc); \
234 bool is_v2 = (acl->hdr.version == SMC_V2); \
235 bool is_smcd = (acl->hdr.typev1 == SMC_TYPE_D); \
236 struct smc_stats __percpu *smc_stats = (net)->smc.smc_stats; \
237 if (is_v2 && is_smcd) \
238 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v2_succ_cnt); \
239 else if (is_v2 && !is_smcd) \
240 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v2_succ_cnt); \
241 else if (!is_v2 && is_smcd) \
242 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v1_succ_cnt); \
243 else if (!is_v2 && !is_smcd) \
244 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v1_succ_cnt); \
248 #define SMC_STAT_SERV_SUCC_INC(net, _ini) \
250 typeof(_ini) i = (_ini); \
251 bool is_smcd = (i->is_smcd); \
252 u8 version = is_smcd ? i->smcd_version : i->smcr_version; \
253 bool is_v2 = (version & SMC_V2); \
254 typeof(net->smc.smc_stats) smc_stats = (net)->smc.smc_stats; \
255 if (is_v2 && is_smcd) \
256 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v2_succ_cnt); \
257 else if (is_v2 && !is_smcd) \
258 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v2_succ_cnt); \
259 else if (!is_v2 && is_smcd) \
260 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v1_succ_cnt); \
261 else if (!is_v2 && !is_smcd) \
262 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v1_succ_cnt); \
266 int smc_nl_get_stats(struct sk_buff *skb, struct netlink_callback *cb);
267 int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb);
268 int smc_stats_init(struct net *net);
269 void smc_stats_exit(struct net *net);
271 #endif /* NET_SMC_SMC_STATS_H_ */