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(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(net->smc.fback_rsn);
34 err_fback:
35 return -ENOMEM;
36 }
37
38 void smc_stats_exit(struct net *net)
39 {
40 kfree(net->smc.fback_rsn);
41 if (net->smc.smc_stats)
42 free_percpu(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, type);
58 if (!attrs)
59 goto errout;
60 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_REUSE_CNT,
61 stats_rmb_cnt->reuse_cnt,
62 SMC_NLA_STATS_RMB_PAD))
63 goto errattr;
64 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_SIZE_SM_PEER_CNT,
65 stats_rmb_cnt->buf_size_small_peer_cnt,
66 SMC_NLA_STATS_RMB_PAD))
67 goto errattr;
68 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_SIZE_SM_CNT,
69 stats_rmb_cnt->buf_size_small_cnt,
70 SMC_NLA_STATS_RMB_PAD))
71 goto errattr;
72 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_FULL_PEER_CNT,
73 stats_rmb_cnt->buf_full_peer_cnt,
74 SMC_NLA_STATS_RMB_PAD))
75 goto errattr;
76 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_FULL_CNT,
77 stats_rmb_cnt->buf_full_cnt,
78 SMC_NLA_STATS_RMB_PAD))
79 goto errattr;
80 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_ALLOC_CNT,
81 stats_rmb_cnt->alloc_cnt,
82 SMC_NLA_STATS_RMB_PAD))
83 goto errattr;
84 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_DGRADE_CNT,
85 stats_rmb_cnt->dgrade_cnt,
86 SMC_NLA_STATS_RMB_PAD))
87 goto errattr;
88
89 nla_nest_end(skb, attrs);
90 return 0;
91
92 errattr:
93 nla_nest_cancel(skb, 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, type);
117 if (!attrs)
118 goto errout;
119 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_8K,
120 stats_pload->buf[SMC_BUF_8K],
121 SMC_NLA_STATS_PLOAD_PAD))
122 goto errattr;
123 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_16K,
124 stats_pload->buf[SMC_BUF_16K],
125 SMC_NLA_STATS_PLOAD_PAD))
126 goto errattr;
127 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_32K,
128 stats_pload->buf[SMC_BUF_32K],
129 SMC_NLA_STATS_PLOAD_PAD))
130 goto errattr;
131 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_64K,
132 stats_pload->buf[SMC_BUF_64K],
133 SMC_NLA_STATS_PLOAD_PAD))
134 goto errattr;
135 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_128K,
136 stats_pload->buf[SMC_BUF_128K],
137 SMC_NLA_STATS_PLOAD_PAD))
138 goto errattr;
139 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_256K,
140 stats_pload->buf[SMC_BUF_256K],
141 SMC_NLA_STATS_PLOAD_PAD))
142 goto errattr;
143 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_512K,
144 stats_pload->buf[SMC_BUF_512K],
145 SMC_NLA_STATS_PLOAD_PAD))
146 goto errattr;
147 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_1024K,
148 stats_pload->buf[SMC_BUF_1024K],
149 SMC_NLA_STATS_PLOAD_PAD))
150 goto errattr;
151 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_G_1024K,
152 stats_pload->buf[SMC_BUF_G_1024K],
153 SMC_NLA_STATS_PLOAD_PAD))
154 goto errattr;
155
156 nla_nest_end(skb, attrs);
157 return 0;
158
159 errattr:
160 nla_nest_cancel(skb, 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, SMC_NLA_STATS_SMCD_TECH);
174 else
175 attrs = nla_nest_start(skb, SMC_NLA_STATS_SMCR_TECH);
176
177 if (!attrs)
178 goto errout;
179 if (smc_nl_fill_stats_rmb_data(skb, stats, tech,
180 SMC_NLA_STATS_T_TX_RMB_STATS))
181 goto errattr;
182 if (smc_nl_fill_stats_rmb_data(skb, stats, tech,
183 SMC_NLA_STATS_T_RX_RMB_STATS))
184 goto errattr;
185 if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
186 SMC_NLA_STATS_T_TXPLOAD_SIZE))
187 goto errattr;
188 if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
189 SMC_NLA_STATS_T_RXPLOAD_SIZE))
190 goto errattr;
191 if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
192 SMC_NLA_STATS_T_TX_RMB_SIZE))
193 goto errattr;
194 if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
195 SMC_NLA_STATS_T_RX_RMB_SIZE))
196 goto errattr;
197 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CLNT_V1_SUCC,
198 smc_tech->clnt_v1_succ_cnt,
199 SMC_NLA_STATS_PAD))
200 goto errattr;
201 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CLNT_V2_SUCC,
202 smc_tech->clnt_v2_succ_cnt,
203 SMC_NLA_STATS_PAD))
204 goto errattr;
205 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SRV_V1_SUCC,
206 smc_tech->srv_v1_succ_cnt,
207 SMC_NLA_STATS_PAD))
208 goto errattr;
209 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SRV_V2_SUCC,
210 smc_tech->srv_v2_succ_cnt,
211 SMC_NLA_STATS_PAD))
212 goto errattr;
213 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_RX_BYTES,
214 smc_tech->rx_bytes,
215 SMC_NLA_STATS_PAD))
216 goto errattr;
217 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_TX_BYTES,
218 smc_tech->tx_bytes,
219 SMC_NLA_STATS_PAD))
220 goto errattr;
221 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_RX_CNT,
222 smc_tech->rx_cnt,
223 SMC_NLA_STATS_PAD))
224 goto errattr;
225 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_TX_CNT,
226 smc_tech->tx_cnt,
227 SMC_NLA_STATS_PAD))
228 goto errattr;
229 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SENDPAGE_CNT,
230 0,
231 SMC_NLA_STATS_PAD))
232 goto errattr;
233 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CORK_CNT,
234 smc_tech->cork_cnt,
235 SMC_NLA_STATS_PAD))
236 goto errattr;
237 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_NDLY_CNT,
238 smc_tech->ndly_cnt,
239 SMC_NLA_STATS_PAD))
240 goto errattr;
241 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SPLICE_CNT,
242 smc_tech->splice_cnt,
243 SMC_NLA_STATS_PAD))
244 goto errattr;
245 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_URG_DATA_CNT,
246 smc_tech->urg_data_cnt,
247 SMC_NLA_STATS_PAD))
248 goto errattr;
249
250 nla_nest_end(skb, attrs);
251 return 0;
252
253 errattr:
254 nla_nest_cancel(skb, 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(cb);
263 struct net *net = sock_net(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, cb->nlh->nlmsg_seq,
274 &smc_gen_nl_family, NLM_F_MULTI,
275 SMC_NETLINK_GET_STATS);
276 if (!nlh)
277 goto errmsg;
278
279 attrs = nla_nest_start(skb, SMC_GEN_STATS);
280 if (!attrs)
281 goto errnest;
282 stats = kzalloc(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, SMC_NLA_STATS_CLNT_HS_ERR_CNT,
297 stats->clnt_hshake_err_cnt,
298 SMC_NLA_STATS_PAD))
299 goto errattr;
300 if (nla_put_u64_64bit(skb, SMC_NLA_STATS_SRV_HS_ERR_CNT,
301 stats->srv_hshake_err_cnt,
302 SMC_NLA_STATS_PAD))
303 goto errattr;
304
305 nla_nest_end(skb, attrs);
306 genlmsg_end(skb, nlh);
307 cb_ctx->pos[0] = 1;
308 kfree(stats);
309 return skb->len;
310
311 errattr:
312 kfree(stats);
313 erralloc:
314 nla_nest_cancel(skb, attrs);
315 errnest:
316 genlmsg_cancel(skb, 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(cb);
326 struct net *net = sock_net(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, cb->nlh->nlmsg_seq,
340 &smc_gen_nl_family, NLM_F_MULTI,
341 SMC_NETLINK_GET_FBACK_STATS);
342 if (!nlh)
343 goto errmsg;
344 attrs = nla_nest_start(skb, SMC_GEN_FBACK_STATS);
345 if (!attrs)
346 goto errout;
347 if (nla_put_u8(skb, SMC_NLA_FBACK_STATS_TYPE, is_srv))
348 goto errattr;
349 if (!cnt_reported) {
350 if (nla_put_u64_64bit(skb, SMC_NLA_FBACK_STATS_SRV_CNT,
351 net->smc.fback_rsn->srv_fback_cnt,
352 SMC_NLA_FBACK_STATS_PAD))
353 goto errattr;
354 if (nla_put_u64_64bit(skb, SMC_NLA_FBACK_STATS_CLNT_CNT,
355 net->smc.fback_rsn->clnt_fback_cnt,
356 SMC_NLA_FBACK_STATS_PAD))
357 goto errattr;
358 cnt_reported = 1;
359 }
360
361 if (nla_put_u32(skb, SMC_NLA_FBACK_STATS_RSN_CODE,
362 trgt_arr[pos].fback_code))
363 goto errattr;
364 if (nla_put_u16(skb, SMC_NLA_FBACK_STATS_RSN_CNT,
365 trgt_arr[pos].count))
366 goto errattr;
367
368 cb_ctx->pos[2] = cnt_reported;
369 nla_nest_end(skb, attrs);
370 genlmsg_end(skb, nlh);
371 return rc;
372
373 errattr:
374 nla_nest_cancel(skb, attrs);
375 errout:
376 genlmsg_cancel(skb, 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(cb);
384 struct net *net = sock_net(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, 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, k, !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(&net->smc.mutex_fback_rsn);
410 cb_ctx->pos[1] = skip_serv;
411 cb_ctx->pos[0] = k;
412 return skb->len;
413 }
414
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.