projects/linux·blob master · refs

489 lines · 13.3 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/* Microchip VCAP API debug file system support
3 *
4 * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
5 *
6 */
7
8#include "vcap_api_private.h"
9#include "vcap_api_debugfs.h"
10
11struct vcap_admin_debugfs_info {
12 struct vcap_control *vctrl;
13 struct vcap_admin *admin;
14};
15
16struct vcap_port_debugfs_info {
17 struct vcap_control *vctrl;
18 struct net_device *ndev;
19};
20
21/* Dump the keyfields value and mask values */
22static void vcap_debugfs_show_rule_keyfield(struct vcap_control *vctrl,
23 struct vcap_output_print *out,
24 enum vcap_key_field key,
25 const struct vcap_field *keyfield,
26 struct vcap_client_keyfield_data *data)
27{
28 bool hex = false;
29 u8 *value, *mask;
30 int idx, bytes;
31
32 out->prf(out->dst, " %s: W%d: ", vcap_keyfield_name(vctrl, key),
33 keyfield[key].width);
34
35 switch (keyfield[key].type) {
36 case VCAP_FIELD_BIT:
37 out->prf(out->dst, "%d/%d", data->u1.value, data->u1.mask);
38 break;
39 case VCAP_FIELD_U32:
40 value = (u8 *)(&data->u32.value);
41 mask = (u8 *)(&data->u32.mask);
42
43 if (key == VCAP_KF_L3_IP4_SIP || key == VCAP_KF_L3_IP4_DIP) {
44 out->prf(out->dst, "%pI4h/%pI4h", &data->u32.value,
45 &data->u32.mask);
46 } else if (key == VCAP_KF_ETYPE ||
47 key == VCAP_KF_IF_IGR_PORT_MASK ||
48 key == VCAP_KF_IF_EGR_PORT_MASK) {
49 hex = true;
50 } else {
51 u32 fmsk = (1 << keyfield[key].width) - 1;
52
53 if (keyfield[key].width == 32)
54 fmsk = ~0;
55 out->prf(out->dst, "%u/%u", data->u32.value & fmsk,
56 data->u32.mask & fmsk);
57 }
58 break;
59 case VCAP_FIELD_U48:
60 value = data->u48.value;
61 mask = data->u48.mask;
62 if (key == VCAP_KF_L2_SMAC || key == VCAP_KF_L2_DMAC)
63 out->prf(out->dst, "%pMR/%pMR", data->u48.value,
64 data->u48.mask);
65 else
66 hex = true;
67 break;
68 case VCAP_FIELD_U56:
69 value = data->u56.value;
70 mask = data->u56.mask;
71 hex = true;
72 break;
73 case VCAP_FIELD_U64:
74 value = data->u64.value;
75 mask = data->u64.mask;
76 hex = true;
77 break;
78 case VCAP_FIELD_U72:
79 value = data->u72.value;
80 mask = data->u72.mask;
81 hex = true;
82 break;
83 case VCAP_FIELD_U112:
84 value = data->u112.value;
85 mask = data->u112.mask;
86 hex = true;
87 break;
88 case VCAP_FIELD_U128:
89 value = data->u128.value;
90 mask = data->u128.mask;
91 if (key == VCAP_KF_L3_IP6_SIP || key == VCAP_KF_L3_IP6_DIP) {
92 u8 nvalue[16], nmask[16];
93
94 vcap_netbytes_copy(nvalue, data->u128.value,
95 sizeof(nvalue));
96 vcap_netbytes_copy(nmask, data->u128.mask,
97 sizeof(nmask));
98 out->prf(out->dst, "%pI6/%pI6", nvalue, nmask);
99 } else {
100 hex = true;
101 }
102 break;
103 }
104 if (hex) {
105 bytes = DIV_ROUND_UP(keyfield[key].width, BITS_PER_BYTE);
106 out->prf(out->dst, "0x");
107 for (idx = 0; idx < bytes; ++idx)
108 out->prf(out->dst, "%02x", value[bytes - idx - 1]);
109 out->prf(out->dst, "/0x");
110 for (idx = 0; idx < bytes; ++idx)
111 out->prf(out->dst, "%02x", mask[bytes - idx - 1]);
112 }
113 out->prf(out->dst, "\n");
114}
115
116static void
117vcap_debugfs_show_rule_actionfield(struct vcap_control *vctrl,
118 struct vcap_output_print *out,
119 enum vcap_action_field action,
120 const struct vcap_field *actionfield,
121 u8 *value)
122{
123 bool hex = false;
124 int idx, bytes;
125 u32 fmsk, val;
126
127 out->prf(out->dst, " %s: W%d: ",
128 vcap_actionfield_name(vctrl, action),
129 actionfield[action].width);
130
131 switch (actionfield[action].type) {
132 case VCAP_FIELD_BIT:
133 out->prf(out->dst, "%d", value[0]);
134 break;
135 case VCAP_FIELD_U32:
136 fmsk = (1 << actionfield[action].width) - 1;
137 val = *(u32 *)value;
138 out->prf(out->dst, "%u", val & fmsk);
139 break;
140 case VCAP_FIELD_U48:
141 case VCAP_FIELD_U56:
142 case VCAP_FIELD_U64:
143 case VCAP_FIELD_U72:
144 case VCAP_FIELD_U112:
145 case VCAP_FIELD_U128:
146 hex = true;
147 break;
148 }
149 if (hex) {
150 bytes = DIV_ROUND_UP(actionfield[action].width, BITS_PER_BYTE);
151 out->prf(out->dst, "0x");
152 for (idx = 0; idx < bytes; ++idx)
153 out->prf(out->dst, "%02x", value[bytes - idx - 1]);
154 }
155 out->prf(out->dst, "\n");
156}
157
158static int vcap_debugfs_show_keysets(struct vcap_rule_internal *ri,
159 struct vcap_output_print *out)
160{
161 struct vcap_admin *admin = ri->admin;
162 enum vcap_keyfield_set keysets[10];
163 struct vcap_keyset_list matches;
164 int err;
165
166 matches.keysets = keysets;
167 matches.cnt = 0;
168 matches.max = ARRAY_SIZE(keysets);
169
170 if (ri->state == VCAP_RS_DISABLED)
171 err = vcap_rule_get_keysets(ri, &matches);
172 else
173 err = vcap_find_keystream_keysets(ri->vctrl, admin->vtype,
174 admin->cache.keystream,
175 admin->cache.maskstream,
176 false, 0, &matches);
177 if (err) {
178 pr_err("%s:%d: could not find valid keysets: %d\n",
179 __func__, __LINE__, err);
180 return err;
181 }
182
183 out->prf(out->dst, " keysets:");
184 for (int idx = 0; idx < matches.cnt; ++idx)
185 out->prf(out->dst, " %s",
186 vcap_keyset_name(ri->vctrl, matches.keysets[idx]));
187 out->prf(out->dst, "\n");
188 return 0;
189}
190
191static int vcap_debugfs_show_rule_keyset(struct vcap_rule_internal *ri,
192 struct vcap_output_print *out)
193{
194 struct vcap_control *vctrl = ri->vctrl;
195 struct vcap_admin *admin = ri->admin;
196 const struct vcap_field *keyfield;
197 struct vcap_client_keyfield *ckf;
198
199 vcap_debugfs_show_keysets(ri, out);
200 out->prf(out->dst, " keyset_sw: %d\n", ri->keyset_sw);
201 out->prf(out->dst, " keyset_sw_regs: %d\n", ri->keyset_sw_regs);
202
203 list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
204 keyfield = vcap_keyfields(vctrl, admin->vtype, ri->data.keyset);
205 vcap_debugfs_show_rule_keyfield(vctrl, out, ckf->ctrl.key,
206 keyfield, &ckf->data);
207 }
208
209 return 0;
210}
211
212static int vcap_debugfs_show_rule_actionset(struct vcap_rule_internal *ri,
213 struct vcap_output_print *out)
214{
215 struct vcap_control *vctrl = ri->vctrl;
216 struct vcap_admin *admin = ri->admin;
217 const struct vcap_field *actionfield;
218 struct vcap_client_actionfield *caf;
219
220 out->prf(out->dst, " actionset: %s\n",
221 vcap_actionset_name(vctrl, ri->data.actionset));
222 out->prf(out->dst, " actionset_sw: %d\n", ri->actionset_sw);
223 out->prf(out->dst, " actionset_sw_regs: %d\n", ri->actionset_sw_regs);
224
225 list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
226 actionfield = vcap_actionfields(vctrl, admin->vtype,
227 ri->data.actionset);
228 vcap_debugfs_show_rule_actionfield(vctrl, out, caf->ctrl.action,
229 actionfield,
230 &caf->data.u1.value);
231 }
232
233 return 0;
234}
235
236static void vcap_show_admin_rule(struct vcap_control *vctrl,
237 struct vcap_admin *admin,
238 struct vcap_output_print *out,
239 struct vcap_rule_internal *ri)
240{
241 ri->counter.value = admin->cache.counter;
242 ri->counter.sticky = admin->cache.sticky;
243 out->prf(out->dst,
244 "rule: %u, addr: [%d,%d], X%d, ctr[%d]: %d, hit: %d\n",
245 ri->data.id, ri->addr, ri->addr + ri->size - 1, ri->size,
246 ri->counter_id, ri->counter.value, ri->counter.sticky);
247 out->prf(out->dst, " chain_id: %d\n", ri->data.vcap_chain_id);
248 out->prf(out->dst, " user: %d\n", ri->data.user);
249 out->prf(out->dst, " priority: %d\n", ri->data.priority);
250 out->prf(out->dst, " state: ");
251 switch (ri->state) {
252 case VCAP_RS_PERMANENT:
253 out->prf(out->dst, "permanent\n");
254 break;
255 case VCAP_RS_DISABLED:
256 out->prf(out->dst, "disabled\n");
257 break;
258 case VCAP_RS_ENABLED:
259 out->prf(out->dst, "enabled\n");
260 break;
261 }
262 vcap_debugfs_show_rule_keyset(ri, out);
263 vcap_debugfs_show_rule_actionset(ri, out);
264}
265
266static void vcap_show_admin_info(struct vcap_control *vctrl,
267 struct vcap_admin *admin,
268 struct vcap_output_print *out)
269{
270 const struct vcap_info *vcap = &vctrl->vcaps[admin->vtype];
271
272 out->prf(out->dst, "name: %s\n", vcap->name);
273 out->prf(out->dst, "rows: %d\n", vcap->rows);
274 out->prf(out->dst, "sw_count: %d\n", vcap->sw_count);
275 out->prf(out->dst, "sw_width: %d\n", vcap->sw_width);
276 out->prf(out->dst, "sticky_width: %d\n", vcap->sticky_width);
277 out->prf(out->dst, "act_width: %d\n", vcap->act_width);
278 out->prf(out->dst, "default_cnt: %d\n", vcap->default_cnt);
279 out->prf(out->dst, "require_cnt_dis: %d\n", vcap->require_cnt_dis);
280 out->prf(out->dst, "version: %d\n", vcap->version);
281 out->prf(out->dst, "vtype: %d\n", admin->vtype);
282 out->prf(out->dst, "vinst: %d\n", admin->vinst);
283 out->prf(out->dst, "ingress: %d\n", admin->ingress);
284 out->prf(out->dst, "first_cid: %d\n", admin->first_cid);
285 out->prf(out->dst, "last_cid: %d\n", admin->last_cid);
286 out->prf(out->dst, "lookups: %d\n", admin->lookups);
287 out->prf(out->dst, "first_valid_addr: %d\n", admin->first_valid_addr);
288 out->prf(out->dst, "last_valid_addr: %d\n", admin->last_valid_addr);
289 out->prf(out->dst, "last_used_addr: %d\n", admin->last_used_addr);
290}
291
292static int vcap_show_admin(struct vcap_control *vctrl,
293 struct vcap_admin *admin,
294 struct vcap_output_print *out)
295{
296 struct vcap_rule_internal *elem;
297 struct vcap_rule *vrule;
298 int ret = 0;
299
300 vcap_show_admin_info(vctrl, admin, out);
301 list_for_each_entry(elem, &admin->rules, list) {
302 vrule = vcap_decode_rule(elem);
303 if (IS_ERR(vrule)) {
304 ret = PTR_ERR(vrule);
305 break;
306 }
307
308 out->prf(out->dst, "\n");
309 vcap_show_admin_rule(vctrl, admin, out, to_intrule(vrule));
310 vcap_free_rule(vrule);
311 }
312 return ret;
313}
314
315static int vcap_show_admin_raw(struct vcap_control *vctrl,
316 struct vcap_admin *admin,
317 struct vcap_output_print *out)
318{
319 enum vcap_keyfield_set keysets[10];
320 enum vcap_type vt = admin->vtype;
321 struct vcap_keyset_list kslist;
322 struct vcap_rule_internal *ri;
323 const struct vcap_set *info;
324 int addr, idx;
325 int ret;
326
327 if (list_empty(&admin->rules))
328 return 0;
329
330 ret = vcap_api_check(vctrl);
331 if (ret)
332 return ret;
333
334 ri = list_first_entry(&admin->rules, struct vcap_rule_internal, list);
335
336 /* Go from higher to lower addresses searching for a keyset */
337 kslist.keysets = keysets;
338 kslist.max = ARRAY_SIZE(keysets);
339 for (addr = admin->last_valid_addr; addr >= admin->first_valid_addr;
340 --addr) {
341 kslist.cnt = 0;
342 ret = vcap_addr_keysets(vctrl, ri->ndev, admin, addr, &kslist);
343 if (ret < 0)
344 continue;
345 info = vcap_keyfieldset(vctrl, vt, kslist.keysets[0]);
346 if (!info)
347 continue;
348 if (addr % info->sw_per_item) {
349 pr_info("addr: %d X%d error rule, keyset: %s\n",
350 addr,
351 info->sw_per_item,
352 vcap_keyset_name(vctrl, kslist.keysets[0]));
353 } else {
354 out->prf(out->dst, " addr: %d, X%d rule, keysets:",
355 addr,
356 info->sw_per_item);
357 for (idx = 0; idx < kslist.cnt; ++idx)
358 out->prf(out->dst, " %s",
359 vcap_keyset_name(vctrl,
360 kslist.keysets[idx]));
361 out->prf(out->dst, "\n");
362 }
363 }
364 return 0;
365}
366
367/* Show the port configuration and status */
368static int vcap_port_debugfs_show(struct seq_file *m, void *unused)
369{
370 struct vcap_port_debugfs_info *info = m->private;
371 struct vcap_admin *admin;
372 struct vcap_output_print out = {
373 .prf = (void *)seq_printf,
374 .dst = m,
375 };
376
377 list_for_each_entry(admin, &info->vctrl->list, list) {
378 if (admin->vinst)
379 continue;
380 info->vctrl->ops->port_info(info->ndev, admin, &out);
381 }
382 return 0;
383}
384DEFINE_SHOW_ATTRIBUTE(vcap_port_debugfs);
385
386void vcap_port_debugfs(struct device *dev, struct dentry *parent,
387 struct vcap_control *vctrl,
388 struct net_device *ndev)
389{
390 struct vcap_port_debugfs_info *info;
391
392 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
393 if (!info)
394 return;
395
396 info->vctrl = vctrl;
397 info->ndev = ndev;
398 debugfs_create_file(netdev_name(ndev), 0444, parent, info,
399 &vcap_port_debugfs_fops);
400}
401EXPORT_SYMBOL_GPL(vcap_port_debugfs);
402
403void vcap_port_debugfs_portno(struct device *dev,
404 struct dentry *parent,
405 struct vcap_control *vctrl,
406 struct net_device *ndev,
407 unsigned int portno)
408{
409 struct vcap_port_debugfs_info *info;
410 char name[16];
411
412 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
413 if (!info)
414 return;
415
416 info->vctrl = vctrl;
417 info->ndev = ndev;
418
419 snprintf(name, sizeof(name), "p%u", portno);
420 debugfs_create_file(name, 0444, parent, info, &vcap_port_debugfs_fops);
421}
422EXPORT_SYMBOL_GPL(vcap_port_debugfs_portno);
423
424/* Show the full VCAP instance data (rules with all fields) */
425static int vcap_debugfs_show(struct seq_file *m, void *unused)
426{
427 struct vcap_admin_debugfs_info *info = m->private;
428 struct vcap_output_print out = {
429 .prf = (void *)seq_printf,
430 .dst = m,
431 };
432 int ret;
433
434 vcap_lock(info->admin);
435 ret = vcap_show_admin(info->vctrl, info->admin, &out);
436 vcap_unlock(info->admin);
437 return ret;
438}
439DEFINE_SHOW_ATTRIBUTE(vcap_debugfs);
440
441/* Show the raw VCAP instance data (rules with address info) */
442static int vcap_raw_debugfs_show(struct seq_file *m, void *unused)
443{
444 struct vcap_admin_debugfs_info *info = m->private;
445 struct vcap_output_print out = {
446 .prf = (void *)seq_printf,
447 .dst = m,
448 };
449 int ret;
450
451 vcap_lock(info->admin);
452 ret = vcap_show_admin_raw(info->vctrl, info->admin, &out);
453 vcap_unlock(info->admin);
454 return ret;
455}
456DEFINE_SHOW_ATTRIBUTE(vcap_raw_debugfs);
457
458struct dentry *vcap_debugfs(struct device *dev, struct dentry *parent,
459 struct vcap_control *vctrl)
460{
461 struct vcap_admin_debugfs_info *info;
462 struct vcap_admin *admin;
463 struct dentry *dir;
464 char name[50];
465
466 dir = debugfs_create_dir("vcaps", parent);
467 if (PTR_ERR_OR_ZERO(dir))
468 return NULL;
469 list_for_each_entry(admin, &vctrl->list, list) {
470 sprintf(name, "raw_%s_%d", vctrl->vcaps[admin->vtype].name,
471 admin->vinst);
472 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
473 if (!info)
474 return NULL;
475 info->vctrl = vctrl;
476 info->admin = admin;
477 debugfs_create_file(name, 0444, dir, info,
478 &vcap_raw_debugfs_fops);
479 sprintf(name, "%s_%d", vctrl->vcaps[admin->vtype].name,
480 admin->vinst);
481 debugfs_create_file(name, 0444, dir, info, &vcap_debugfs_fops);
482 }
483 return dir;
484}
485EXPORT_SYMBOL_GPL(vcap_debugfs);
486
487#ifdef CONFIG_VCAP_KUNIT_TEST
488#include "vcap_api_debugfs_kunit.c"
489#endif