1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Shared Memory Communications over RDMA (SMC-R) and RoCE |
4 | * |
5 | * SMC statistics netlink routines |
6 | * |
7 | * Copyright IBM Corp. 2021 |
8 | * |
9 | * Author(s): Guvenc Gulce |
10 | */ |
11 | #include <linux/init.h> |
12 | #include <linux/mutex.h> |
13 | #include <linux/percpu.h> |
14 | #include <linux/ctype.h> |
15 | #include <linux/smc.h> |
16 | #include <net/genetlink.h> |
17 | #include <net/sock.h> |
18 | #include "smc_netlink.h" |
19 | #include "smc_stats.h" |
20 | |
21 | int smc_stats_init(struct net *net) |
22 | { |
23 | net->smc.fback_rsn = kzalloc(size: sizeof(*net->smc.fback_rsn), GFP_KERNEL); |
24 | if (!net->smc.fback_rsn) |
25 | goto err_fback; |
26 | net->smc.smc_stats = alloc_percpu(struct smc_stats); |
27 | if (!net->smc.smc_stats) |
28 | goto err_stats; |
29 | mutex_init(&net->smc.mutex_fback_rsn); |
30 | return 0; |
31 | |
32 | err_stats: |
33 | kfree(objp: net->smc.fback_rsn); |
34 | err_fback: |
35 | return -ENOMEM; |
36 | } |
37 | |
38 | void smc_stats_exit(struct net *net) |
39 | { |
40 | kfree(objp: net->smc.fback_rsn); |
41 | if (net->smc.smc_stats) |
42 | free_percpu(pdata: net->smc.smc_stats); |
43 | } |
44 | |
45 | static int smc_nl_fill_stats_rmb_data(struct sk_buff *skb, |
46 | struct smc_stats *stats, int tech, |
47 | int type) |
48 | { |
49 | struct smc_stats_rmbcnt *stats_rmb_cnt; |
50 | struct nlattr *attrs; |
51 | |
52 | if (type == SMC_NLA_STATS_T_TX_RMB_STATS) |
53 | stats_rmb_cnt = &stats->smc[tech].rmb_tx; |
54 | else |
55 | stats_rmb_cnt = &stats->smc[tech].rmb_rx; |
56 | |
57 | attrs = nla_nest_start(skb, attrtype: type); |
58 | if (!attrs) |
59 | goto errout; |
60 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_REUSE_CNT, |
61 | value: stats_rmb_cnt->reuse_cnt, |
62 | padattr: SMC_NLA_STATS_RMB_PAD)) |
63 | goto errattr; |
64 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_SIZE_SM_PEER_CNT, |
65 | value: stats_rmb_cnt->buf_size_small_peer_cnt, |
66 | padattr: SMC_NLA_STATS_RMB_PAD)) |
67 | goto errattr; |
68 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_SIZE_SM_CNT, |
69 | value: stats_rmb_cnt->buf_size_small_cnt, |
70 | padattr: SMC_NLA_STATS_RMB_PAD)) |
71 | goto errattr; |
72 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_FULL_PEER_CNT, |
73 | value: stats_rmb_cnt->buf_full_peer_cnt, |
74 | padattr: SMC_NLA_STATS_RMB_PAD)) |
75 | goto errattr; |
76 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_FULL_CNT, |
77 | value: stats_rmb_cnt->buf_full_cnt, |
78 | padattr: SMC_NLA_STATS_RMB_PAD)) |
79 | goto errattr; |
80 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_ALLOC_CNT, |
81 | value: stats_rmb_cnt->alloc_cnt, |
82 | padattr: SMC_NLA_STATS_RMB_PAD)) |
83 | goto errattr; |
84 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_RMB_DGRADE_CNT, |
85 | value: stats_rmb_cnt->dgrade_cnt, |
86 | padattr: SMC_NLA_STATS_RMB_PAD)) |
87 | goto errattr; |
88 | |
89 | nla_nest_end(skb, start: attrs); |
90 | return 0; |
91 | |
92 | errattr: |
93 | nla_nest_cancel(skb, start: attrs); |
94 | errout: |
95 | return -EMSGSIZE; |
96 | } |
97 | |
98 | static int smc_nl_fill_stats_bufsize_data(struct sk_buff *skb, |
99 | struct smc_stats *stats, int tech, |
100 | int type) |
101 | { |
102 | struct smc_stats_memsize *stats_pload; |
103 | struct nlattr *attrs; |
104 | |
105 | if (type == SMC_NLA_STATS_T_TXPLOAD_SIZE) |
106 | stats_pload = &stats->smc[tech].tx_pd; |
107 | else if (type == SMC_NLA_STATS_T_RXPLOAD_SIZE) |
108 | stats_pload = &stats->smc[tech].rx_pd; |
109 | else if (type == SMC_NLA_STATS_T_TX_RMB_SIZE) |
110 | stats_pload = &stats->smc[tech].tx_rmbsize; |
111 | else if (type == SMC_NLA_STATS_T_RX_RMB_SIZE) |
112 | stats_pload = &stats->smc[tech].rx_rmbsize; |
113 | else |
114 | goto errout; |
115 | |
116 | attrs = nla_nest_start(skb, attrtype: type); |
117 | if (!attrs) |
118 | goto errout; |
119 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_8K, |
120 | value: stats_pload->buf[SMC_BUF_8K], |
121 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
122 | goto errattr; |
123 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_16K, |
124 | value: stats_pload->buf[SMC_BUF_16K], |
125 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
126 | goto errattr; |
127 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_32K, |
128 | value: stats_pload->buf[SMC_BUF_32K], |
129 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
130 | goto errattr; |
131 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_64K, |
132 | value: stats_pload->buf[SMC_BUF_64K], |
133 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
134 | goto errattr; |
135 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_128K, |
136 | value: stats_pload->buf[SMC_BUF_128K], |
137 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
138 | goto errattr; |
139 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_256K, |
140 | value: stats_pload->buf[SMC_BUF_256K], |
141 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
142 | goto errattr; |
143 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_512K, |
144 | value: stats_pload->buf[SMC_BUF_512K], |
145 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
146 | goto errattr; |
147 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_1024K, |
148 | value: stats_pload->buf[SMC_BUF_1024K], |
149 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
150 | goto errattr; |
151 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_PLOAD_G_1024K, |
152 | value: stats_pload->buf[SMC_BUF_G_1024K], |
153 | padattr: SMC_NLA_STATS_PLOAD_PAD)) |
154 | goto errattr; |
155 | |
156 | nla_nest_end(skb, start: attrs); |
157 | return 0; |
158 | |
159 | errattr: |
160 | nla_nest_cancel(skb, start: attrs); |
161 | errout: |
162 | return -EMSGSIZE; |
163 | } |
164 | |
165 | static int smc_nl_fill_stats_tech_data(struct sk_buff *skb, |
166 | struct smc_stats *stats, int tech) |
167 | { |
168 | struct smc_stats_tech *smc_tech; |
169 | struct nlattr *attrs; |
170 | |
171 | smc_tech = &stats->smc[tech]; |
172 | if (tech == SMC_TYPE_D) |
173 | attrs = nla_nest_start(skb, attrtype: SMC_NLA_STATS_SMCD_TECH); |
174 | else |
175 | attrs = nla_nest_start(skb, attrtype: SMC_NLA_STATS_SMCR_TECH); |
176 | |
177 | if (!attrs) |
178 | goto errout; |
179 | if (smc_nl_fill_stats_rmb_data(skb, stats, tech, |
180 | type: SMC_NLA_STATS_T_TX_RMB_STATS)) |
181 | goto errattr; |
182 | if (smc_nl_fill_stats_rmb_data(skb, stats, tech, |
183 | type: SMC_NLA_STATS_T_RX_RMB_STATS)) |
184 | goto errattr; |
185 | if (smc_nl_fill_stats_bufsize_data(skb, stats, tech, |
186 | type: SMC_NLA_STATS_T_TXPLOAD_SIZE)) |
187 | goto errattr; |
188 | if (smc_nl_fill_stats_bufsize_data(skb, stats, tech, |
189 | type: SMC_NLA_STATS_T_RXPLOAD_SIZE)) |
190 | goto errattr; |
191 | if (smc_nl_fill_stats_bufsize_data(skb, stats, tech, |
192 | type: SMC_NLA_STATS_T_TX_RMB_SIZE)) |
193 | goto errattr; |
194 | if (smc_nl_fill_stats_bufsize_data(skb, stats, tech, |
195 | type: SMC_NLA_STATS_T_RX_RMB_SIZE)) |
196 | goto errattr; |
197 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_CLNT_V1_SUCC, |
198 | value: smc_tech->clnt_v1_succ_cnt, |
199 | padattr: SMC_NLA_STATS_PAD)) |
200 | goto errattr; |
201 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_CLNT_V2_SUCC, |
202 | value: smc_tech->clnt_v2_succ_cnt, |
203 | padattr: SMC_NLA_STATS_PAD)) |
204 | goto errattr; |
205 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_SRV_V1_SUCC, |
206 | value: smc_tech->srv_v1_succ_cnt, |
207 | padattr: SMC_NLA_STATS_PAD)) |
208 | goto errattr; |
209 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_SRV_V2_SUCC, |
210 | value: smc_tech->srv_v2_succ_cnt, |
211 | padattr: SMC_NLA_STATS_PAD)) |
212 | goto errattr; |
213 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_RX_BYTES, |
214 | value: smc_tech->rx_bytes, |
215 | padattr: SMC_NLA_STATS_PAD)) |
216 | goto errattr; |
217 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_TX_BYTES, |
218 | value: smc_tech->tx_bytes, |
219 | padattr: SMC_NLA_STATS_PAD)) |
220 | goto errattr; |
221 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_RX_CNT, |
222 | value: smc_tech->rx_cnt, |
223 | padattr: SMC_NLA_STATS_PAD)) |
224 | goto errattr; |
225 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_TX_CNT, |
226 | value: smc_tech->tx_cnt, |
227 | padattr: SMC_NLA_STATS_PAD)) |
228 | goto errattr; |
229 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_SENDPAGE_CNT, |
230 | value: 0, |
231 | padattr: SMC_NLA_STATS_PAD)) |
232 | goto errattr; |
233 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_CORK_CNT, |
234 | value: smc_tech->cork_cnt, |
235 | padattr: SMC_NLA_STATS_PAD)) |
236 | goto errattr; |
237 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_NDLY_CNT, |
238 | value: smc_tech->ndly_cnt, |
239 | padattr: SMC_NLA_STATS_PAD)) |
240 | goto errattr; |
241 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_SPLICE_CNT, |
242 | value: smc_tech->splice_cnt, |
243 | padattr: SMC_NLA_STATS_PAD)) |
244 | goto errattr; |
245 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_T_URG_DATA_CNT, |
246 | value: smc_tech->urg_data_cnt, |
247 | padattr: SMC_NLA_STATS_PAD)) |
248 | goto errattr; |
249 | |
250 | nla_nest_end(skb, start: attrs); |
251 | return 0; |
252 | |
253 | errattr: |
254 | nla_nest_cancel(skb, start: attrs); |
255 | errout: |
256 | return -EMSGSIZE; |
257 | } |
258 | |
259 | int smc_nl_get_stats(struct sk_buff *skb, |
260 | struct netlink_callback *cb) |
261 | { |
262 | struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(c: cb); |
263 | struct net *net = sock_net(sk: skb->sk); |
264 | struct smc_stats *stats; |
265 | struct nlattr *attrs; |
266 | int cpu, i, size; |
267 | void *nlh; |
268 | u64 *src; |
269 | u64 *sum; |
270 | |
271 | if (cb_ctx->pos[0]) |
272 | goto errmsg; |
273 | nlh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, seq: cb->nlh->nlmsg_seq, |
274 | family: &smc_gen_nl_family, NLM_F_MULTI, |
275 | cmd: SMC_NETLINK_GET_STATS); |
276 | if (!nlh) |
277 | goto errmsg; |
278 | |
279 | attrs = nla_nest_start(skb, attrtype: SMC_GEN_STATS); |
280 | if (!attrs) |
281 | goto errnest; |
282 | stats = kzalloc(size: sizeof(*stats), GFP_KERNEL); |
283 | if (!stats) |
284 | goto erralloc; |
285 | size = sizeof(*stats) / sizeof(u64); |
286 | for_each_possible_cpu(cpu) { |
287 | src = (u64 *)per_cpu_ptr(net->smc.smc_stats, cpu); |
288 | sum = (u64 *)stats; |
289 | for (i = 0; i < size; i++) |
290 | *(sum++) += *(src++); |
291 | } |
292 | if (smc_nl_fill_stats_tech_data(skb, stats, SMC_TYPE_D)) |
293 | goto errattr; |
294 | if (smc_nl_fill_stats_tech_data(skb, stats, SMC_TYPE_R)) |
295 | goto errattr; |
296 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_CLNT_HS_ERR_CNT, |
297 | value: stats->clnt_hshake_err_cnt, |
298 | padattr: SMC_NLA_STATS_PAD)) |
299 | goto errattr; |
300 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_STATS_SRV_HS_ERR_CNT, |
301 | value: stats->srv_hshake_err_cnt, |
302 | padattr: SMC_NLA_STATS_PAD)) |
303 | goto errattr; |
304 | |
305 | nla_nest_end(skb, start: attrs); |
306 | genlmsg_end(skb, hdr: nlh); |
307 | cb_ctx->pos[0] = 1; |
308 | kfree(objp: stats); |
309 | return skb->len; |
310 | |
311 | errattr: |
312 | kfree(objp: stats); |
313 | erralloc: |
314 | nla_nest_cancel(skb, start: attrs); |
315 | errnest: |
316 | genlmsg_cancel(skb, hdr: nlh); |
317 | errmsg: |
318 | return skb->len; |
319 | } |
320 | |
321 | static int smc_nl_get_fback_details(struct sk_buff *skb, |
322 | struct netlink_callback *cb, int pos, |
323 | bool is_srv) |
324 | { |
325 | struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(c: cb); |
326 | struct net *net = sock_net(sk: skb->sk); |
327 | int cnt_reported = cb_ctx->pos[2]; |
328 | struct smc_stats_fback *trgt_arr; |
329 | struct nlattr *attrs; |
330 | int rc = 0; |
331 | void *nlh; |
332 | |
333 | if (is_srv) |
334 | trgt_arr = &net->smc.fback_rsn->srv[0]; |
335 | else |
336 | trgt_arr = &net->smc.fback_rsn->clnt[0]; |
337 | if (!trgt_arr[pos].fback_code) |
338 | return -ENODATA; |
339 | nlh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, seq: cb->nlh->nlmsg_seq, |
340 | family: &smc_gen_nl_family, NLM_F_MULTI, |
341 | cmd: SMC_NETLINK_GET_FBACK_STATS); |
342 | if (!nlh) |
343 | goto errmsg; |
344 | attrs = nla_nest_start(skb, attrtype: SMC_GEN_FBACK_STATS); |
345 | if (!attrs) |
346 | goto errout; |
347 | if (nla_put_u8(skb, attrtype: SMC_NLA_FBACK_STATS_TYPE, value: is_srv)) |
348 | goto errattr; |
349 | if (!cnt_reported) { |
350 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_FBACK_STATS_SRV_CNT, |
351 | value: net->smc.fback_rsn->srv_fback_cnt, |
352 | padattr: SMC_NLA_FBACK_STATS_PAD)) |
353 | goto errattr; |
354 | if (nla_put_u64_64bit(skb, attrtype: SMC_NLA_FBACK_STATS_CLNT_CNT, |
355 | value: net->smc.fback_rsn->clnt_fback_cnt, |
356 | padattr: SMC_NLA_FBACK_STATS_PAD)) |
357 | goto errattr; |
358 | cnt_reported = 1; |
359 | } |
360 | |
361 | if (nla_put_u32(skb, attrtype: SMC_NLA_FBACK_STATS_RSN_CODE, |
362 | value: trgt_arr[pos].fback_code)) |
363 | goto errattr; |
364 | if (nla_put_u16(skb, attrtype: SMC_NLA_FBACK_STATS_RSN_CNT, |
365 | value: trgt_arr[pos].count)) |
366 | goto errattr; |
367 | |
368 | cb_ctx->pos[2] = cnt_reported; |
369 | nla_nest_end(skb, start: attrs); |
370 | genlmsg_end(skb, hdr: nlh); |
371 | return rc; |
372 | |
373 | errattr: |
374 | nla_nest_cancel(skb, start: attrs); |
375 | errout: |
376 | genlmsg_cancel(skb, hdr: nlh); |
377 | errmsg: |
378 | return -EMSGSIZE; |
379 | } |
380 | |
381 | int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb) |
382 | { |
383 | struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(c: cb); |
384 | struct net *net = sock_net(sk: skb->sk); |
385 | int rc_srv = 0, rc_clnt = 0, k; |
386 | int skip_serv = cb_ctx->pos[1]; |
387 | int snum = cb_ctx->pos[0]; |
388 | bool is_srv = true; |
389 | |
390 | mutex_lock(&net->smc.mutex_fback_rsn); |
391 | for (k = 0; k < SMC_MAX_FBACK_RSN_CNT; k++) { |
392 | if (k < snum) |
393 | continue; |
394 | if (!skip_serv) { |
395 | rc_srv = smc_nl_get_fback_details(skb, cb, pos: k, is_srv); |
396 | if (rc_srv && rc_srv != -ENODATA) |
397 | break; |
398 | } else { |
399 | skip_serv = 0; |
400 | } |
401 | rc_clnt = smc_nl_get_fback_details(skb, cb, pos: k, is_srv: !is_srv); |
402 | if (rc_clnt && rc_clnt != -ENODATA) { |
403 | skip_serv = 1; |
404 | break; |
405 | } |
406 | if (rc_clnt == -ENODATA && rc_srv == -ENODATA) |
407 | break; |
408 | } |
409 | mutex_unlock(lock: &net->smc.mutex_fback_rsn); |
410 | cb_ctx->pos[1] = skip_serv; |
411 | cb_ctx->pos[0] = k; |
412 | return skb->len; |
413 | } |
414 | |