1
2
3
4
5
6
7
8
9
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
24enum {
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
37struct smc_stats_fback {
38 int fback_code;
39 u16 count;
40};
41
42struct 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
49struct 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
59struct smc_stats_memsize {
60 u64 buf[SMC_BUF_MAX];
61};
62
63struct 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 sendpage_cnt;
75 u64 urg_data_cnt;
76 u64 splice_cnt;
77 u64 cork_cnt;
78 u64 ndly_cnt;
79 u64 rx_bytes;
80 u64 tx_bytes;
81 u64 rx_cnt;
82 u64 tx_cnt;
83};
84
85struct smc_stats {
86 struct smc_stats_tech smc[2];
87 u64 clnt_hshake_err_cnt;
88 u64 srv_hshake_err_cnt;
89};
90
91#define SMC_STAT_PAYLOAD_SUB(_smc_stats, _tech, key, _len, _rc) \
92do { \
93 typeof(_smc_stats) stats = (_smc_stats); \
94 typeof(_tech) t = (_tech); \
95 typeof(_len) l = (_len); \
96 int _pos = fls64((l) >> 13); \
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) \
101 break; \
102 _pos = (_pos < m) ? ((l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
103 this_cpu_inc((*stats).smc[t].key ## _pd.buf[_pos]); \
104 this_cpu_add((*stats).smc[t].key ## _bytes, r); \
105} \
106while (0)
107
108#define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \
109do { \
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} \
121while (0)
122
123#define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \
124do { \
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} \
136while (0)
137
138#define SMC_STAT_RMB_SIZE_SUB(_smc_stats, _tech, k, _len) \
139do { \
140 typeof(_len) _l = (_len); \
141 typeof(_tech) t = (_tech); \
142 int _pos = fls((_l) >> 13); \
143 int m = SMC_BUF_MAX - 1; \
144 _pos = (_pos < m) ? ((_l == 1 << (_pos + 12)) ? _pos - 1 : _pos) : m; \
145 this_cpu_inc((*(_smc_stats)).smc[t].k ## _rmbsize.buf[_pos]); \
146} \
147while (0)
148
149#define SMC_STAT_RMB_SUB(_smc_stats, type, t, key) \
150 this_cpu_inc((*(_smc_stats)).smc[t].rmb ## _ ## key.type ## _cnt)
151
152#define SMC_STAT_RMB_SIZE(_smc, _is_smcd, _is_rx, _len) \
153do { \
154 struct net *_net = sock_net(&(_smc)->sk); \
155 struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \
156 typeof(_is_smcd) is_d = (_is_smcd); \
157 typeof(_is_rx) is_r = (_is_rx); \
158 typeof(_len) l = (_len); \
159 if ((is_d) && (is_r)) \
160 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, rx, l); \
161 if ((is_d) && !(is_r)) \
162 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_D, tx, l); \
163 if (!(is_d) && (is_r)) \
164 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, rx, l); \
165 if (!(is_d) && !(is_r)) \
166 SMC_STAT_RMB_SIZE_SUB(_smc_stats, SMC_TYPE_R, tx, l); \
167} \
168while (0)
169
170#define SMC_STAT_RMB(_smc, type, _is_smcd, _is_rx) \
171do { \
172 struct net *net = sock_net(&(_smc)->sk); \
173 struct smc_stats __percpu *_smc_stats = net->smc.smc_stats; \
174 typeof(_is_smcd) is_d = (_is_smcd); \
175 typeof(_is_rx) is_r = (_is_rx); \
176 if ((is_d) && (is_r)) \
177 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, rx); \
178 if ((is_d) && !(is_r)) \
179 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_D, tx); \
180 if (!(is_d) && (is_r)) \
181 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, rx); \
182 if (!(is_d) && !(is_r)) \
183 SMC_STAT_RMB_SUB(_smc_stats, type, SMC_TYPE_R, tx); \
184} \
185while (0)
186
187#define SMC_STAT_BUF_REUSE(smc, is_smcd, is_rx) \
188 SMC_STAT_RMB(smc, reuse, is_smcd, is_rx)
189
190#define SMC_STAT_RMB_ALLOC(smc, is_smcd, is_rx) \
191 SMC_STAT_RMB(smc, alloc, is_smcd, is_rx)
192
193#define SMC_STAT_RMB_DOWNGRADED(smc, is_smcd, is_rx) \
194 SMC_STAT_RMB(smc, dgrade, is_smcd, is_rx)
195
196#define SMC_STAT_RMB_TX_PEER_FULL(smc, is_smcd) \
197 SMC_STAT_RMB(smc, buf_full_peer, is_smcd, false)
198
199#define SMC_STAT_RMB_TX_FULL(smc, is_smcd) \
200 SMC_STAT_RMB(smc, buf_full, is_smcd, false)
201
202#define SMC_STAT_RMB_TX_PEER_SIZE_SMALL(smc, is_smcd) \
203 SMC_STAT_RMB(smc, buf_size_small_peer, is_smcd, false)
204
205#define SMC_STAT_RMB_TX_SIZE_SMALL(smc, is_smcd) \
206 SMC_STAT_RMB(smc, buf_size_small, is_smcd, false)
207
208#define SMC_STAT_RMB_RX_SIZE_SMALL(smc, is_smcd) \
209 SMC_STAT_RMB(smc, buf_size_small, is_smcd, true)
210
211#define SMC_STAT_RMB_RX_FULL(smc, is_smcd) \
212 SMC_STAT_RMB(smc, buf_full, is_smcd, true)
213
214#define SMC_STAT_INC(_smc, type) \
215do { \
216 typeof(_smc) __smc = _smc; \
217 bool is_smcd = !(__smc)->conn.lnk; \
218 struct net *net = sock_net(&(__smc)->sk); \
219 struct smc_stats __percpu *smc_stats = net->smc.smc_stats; \
220 if ((is_smcd)) \
221 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \
222 else \
223 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].type); \
224} \
225while (0)
226
227#define SMC_STAT_CLNT_SUCC_INC(net, _aclc) \
228do { \
229 typeof(_aclc) acl = (_aclc); \
230 bool is_v2 = (acl->hdr.version == SMC_V2); \
231 bool is_smcd = (acl->hdr.typev1 == SMC_TYPE_D); \
232 struct smc_stats __percpu *smc_stats = (net)->smc.smc_stats; \
233 if (is_v2 && is_smcd) \
234 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v2_succ_cnt); \
235 else if (is_v2 && !is_smcd) \
236 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v2_succ_cnt); \
237 else if (!is_v2 && is_smcd) \
238 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].clnt_v1_succ_cnt); \
239 else if (!is_v2 && !is_smcd) \
240 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].clnt_v1_succ_cnt); \
241} \
242while (0)
243
244#define SMC_STAT_SERV_SUCC_INC(net, _ini) \
245do { \
246 typeof(_ini) i = (_ini); \
247 bool is_v2 = (i->smcd_version & SMC_V2); \
248 bool is_smcd = (i->is_smcd); \
249 typeof(net->smc.smc_stats) smc_stats = (net)->smc.smc_stats; \
250 if (is_v2 && is_smcd) \
251 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v2_succ_cnt); \
252 else if (is_v2 && !is_smcd) \
253 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v2_succ_cnt); \
254 else if (!is_v2 && is_smcd) \
255 this_cpu_inc(smc_stats->smc[SMC_TYPE_D].srv_v1_succ_cnt); \
256 else if (!is_v2 && !is_smcd) \
257 this_cpu_inc(smc_stats->smc[SMC_TYPE_R].srv_v1_succ_cnt); \
258} \
259while (0)
260
261int smc_nl_get_stats(struct sk_buff *skb, struct netlink_callback *cb);
262int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb);
263int smc_stats_init(struct net *net);
264void smc_stats_exit(struct net *net);
265
266#endif
267
