xref: /openbmc/linux/net/smc/smc_stats.h (revision f7dc578a)
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 };
83 
84 struct smc_stats {
85 	struct smc_stats_tech	smc[2];
86 	u64			clnt_hshake_err_cnt;
87 	u64			srv_hshake_err_cnt;
88 };
89 
90 #define SMC_STAT_PAYLOAD_SUB(_smc_stats, _tech, key, _len, _rc) \
91 do { \
92 	typeof(_smc_stats) stats = (_smc_stats); \
93 	typeof(_tech) t = (_tech); \
94 	typeof(_len) l = (_len); \
95 	int _pos; \
96 	typeof(_rc) r = (_rc); \
97 	int m = SMC_BUF_MAX - 1; \
98 	this_cpu_inc((*stats).smc[t].key ## _cnt); \
99 	if (r <= 0 || l <= 0) \
100 		break; \
101 	_pos = fls64((l - 1) >> 13); \
102 	_pos = (_pos <= m) ? _pos : m; \
103 	this_cpu_inc((*stats).smc[t].key ## _pd.buf[_pos]); \
104 	this_cpu_add((*stats).smc[t].key ## _bytes, r); \
105 } \
106 while (0)
107 
108 #define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \
109 do { \
110 	typeof(_smc) __smc = _smc; \
111 	struct net *_net = sock_net(&__smc->sk); \
112 	struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
113 	typeof(length) _len = (length); \
114 	typeof(rcode) _rc = (rcode); \
115 	bool is_smcd = !__smc->conn.lnk; \
116 	if (is_smcd) \
117 		SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, tx, _len, _rc); \
118 	else \
119 		SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, tx, _len, _rc); \
120 } \
121 while (0)
122 
123 #define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \
124 do { \
125 	typeof(_smc) __smc = _smc; \
126 	struct net *_net = sock_net(&__smc->sk); \
127 	struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
128 	typeof(length) _len = (length); \
129 	typeof(rcode) _rc = (rcode); \
130 	bool is_smcd = !__smc->conn.lnk; \
131 	if (is_smcd) \
132 		SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_D, rx, _len, _rc); \
133 	else \
134 		SMC_STAT_PAYLOAD_SUB(_smc_stats, SMC_TYPE_R, rx, _len, _rc); \
135 } \
136 while (0)
137 
138 #define SMC_STAT_RMB_SIZE_SUB(_smc_stats, _tech, k, _len) \
139 do { \
140 	typeof(_len) _l = (_len); \
141 	typeof(_tech) t = (_tech); \
142 	int _pos; \
143 	int m = SMC_BUF_MAX - 1; \
144 	if (_l <= 0) \
145 		break; \
146 	_pos = fls((_l - 1) >> 13); \
147 	_pos = (_pos <= m) ? _pos : m; \
148 	this_cpu_inc((*(_smc_stats)).smc[t].k ## _rmbsize.buf[_pos]); \
149 } \
150 while (0)
151 
152 #define SMC_STAT_RMB_SUB(_smc_stats, type, t, key) \
153 	this_cpu_inc((*(_smc_stats)).smc[t].rmb ## _ ## key.type ## _cnt)
154 
155 #define SMC_STAT_RMB_SIZE(_smc, _is_smcd, _is_rx, _len) \
156 do { \
157 	struct net *_net = sock_net(&(_smc)->sk); \
158 	struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
159 	typeof(_is_smcd) is_d = (_is_smcd); \
160 	typeof(_is_rx) is_r = (_is_rx); \
161 	typeof(_len) l = (_len); \
162 	if ((is_d) && (is_r)) \
163 		SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, rx, l); \
164 	if ((is_d) && !(is_r)) \
165 		SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, tx, l); \
166 	if (!(is_d) && (is_r)) \
167 		SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, rx, l); \
168 	if (!(is_d) && !(is_r)) \
169 		SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, tx, l); \
170 } \
171 while (0)
172 
173 #define SMC_STAT_RMB(_smc, type, _is_smcd, _is_rx) \
174 do { \
175 	struct net *net = sock_net(&(_smc)->sk); \
176 	struct smc_stats __percpu *_smc_stats = net->smc.smc_stats; \
177 	typeof(_is_smcd) is_d = (_is_smcd); \
178 	typeof(_is_rx) is_r = (_is_rx); \
179 	if ((is_d) && (is_r)) \
180 		SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, rx); \
181 	if ((is_d) && !(is_r)) \
182 		SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, tx); \
183 	if (!(is_d) && (is_r)) \
184 		SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, rx); \
185 	if (!(is_d) && !(is_r)) \
186 		SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, tx); \
187 } \
188 while (0)
189 
190 #define SMC_STAT_BUF_REUSE(smc, is_smcd, is_rx) \
191 	SMC_STAT_RMB(smc, reuse, is_smcd, is_rx)
192 
193 #define SMC_STAT_RMB_ALLOC(smc, is_smcd, is_rx) \
194 	SMC_STAT_RMB(smc, alloc, is_smcd, is_rx)
195 
196 #define SMC_STAT_RMB_DOWNGRADED(smc, is_smcd, is_rx) \
197 	SMC_STAT_RMB(smc, dgrade, is_smcd, is_rx)
198 
199 #define SMC_STAT_RMB_TX_PEER_FULL(smc, is_smcd) \
200 	SMC_STAT_RMB(smc, buf_full_peer, is_smcd, false)
201 
202 #define SMC_STAT_RMB_TX_FULL(smc, is_smcd) \
203 	SMC_STAT_RMB(smc, buf_full, is_smcd, false)
204 
205 #define SMC_STAT_RMB_TX_PEER_SIZE_SMALL(smc, is_smcd) \
206 	SMC_STAT_RMB(smc, buf_size_small_peer, is_smcd, false)
207 
208 #define SMC_STAT_RMB_TX_SIZE_SMALL(smc, is_smcd) \
209 	SMC_STAT_RMB(smc, buf_size_small, is_smcd, false)
210 
211 #define SMC_STAT_RMB_RX_SIZE_SMALL(smc, is_smcd) \
212 	SMC_STAT_RMB(smc, buf_size_small, is_smcd, true)
213 
214 #define SMC_STAT_RMB_RX_FULL(smc, is_smcd) \
215 	SMC_STAT_RMB(smc, buf_full, is_smcd, true)
216 
217 #define SMC_STAT_INC(_smc, type) \
218 do { \
219 	typeof(_smc) __smc = _smc; \
220 	bool is_smcd = !(__smc)->conn.lnk; \
221 	struct net *net = sock_net(&(__smc)->sk); \
222 	struct smc_stats __percpu *smc_stats = net->smc.smc_stats; \
223 	if ((is_smcd)) \
224 		this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \
225 	else \
226 		this_cpu_inc(smc_stats->smc[SMC_TYPE_R].type); \
227 } \
228 while (0)
229 
230 #define SMC_STAT_CLNT_SUCC_INC(net, _aclc) \
231 do { \
232 	typeof(_aclc) acl = (_aclc); \
233 	bool is_v2 = (acl->hdr.version == SMC_V2); \
234 	bool is_smcd = (acl->hdr.typev1 == SMC_TYPE_D); \
235 	struct smc_stats __percpu *smc_stats = (net)->smc.smc_stats; \
236 	if (is_v2 && is_smcd) \
237 		this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v2_succ_cnt); \
238 	else if (is_v2 && !is_smcd) \
239 		this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v2_succ_cnt); \
240 	else if (!is_v2 && is_smcd) \
241 		this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v1_succ_cnt); \
242 	else if (!is_v2 && !is_smcd) \
243 		this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v1_succ_cnt); \
244 } \
245 while (0)
246 
247 #define SMC_STAT_SERV_SUCC_INC(net, _ini) \
248 do { \
249 	typeof(_ini) i = (_ini); \
250 	bool is_smcd = (i->is_smcd); \
251 	u8 version = is_smcd ? i->smcd_version : i->smcr_version; \
252 	bool is_v2 = (version & SMC_V2); \
253 	typeof(net->smc.smc_stats) smc_stats = (net)->smc.smc_stats; \
254 	if (is_v2 && is_smcd) \
255 		this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v2_succ_cnt); \
256 	else if (is_v2 && !is_smcd) \
257 		this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v2_succ_cnt); \
258 	else if (!is_v2 && is_smcd) \
259 		this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v1_succ_cnt); \
260 	else if (!is_v2 && !is_smcd) \
261 		this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v1_succ_cnt); \
262 } \
263 while (0)
264 
265 int smc_nl_get_stats(struct sk_buff *skb, struct netlink_callback *cb);
266 int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb);
267 int smc_stats_init(struct net *net);
268 void smc_stats_exit(struct net *net);
269 
270 #endif /* NET_SMC_SMC_STATS_H_ */
271