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 11 struct vcap_admin_debugfs_info { 12 struct vcap_control *vctrl; 13 struct vcap_admin *admin; 14 }; 15 16 struct vcap_port_debugfs_info { 17 struct vcap_control *vctrl; 18 struct net_device *ndev; 19 }; 20 21 /* Dump the keyfields value and mask values */ 22 static 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 116 static void 117 vcap_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 158 static 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 191 static 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 212 static 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 236 static 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 266 static 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 292 static 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_OR_NULL(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 315 static 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 */ 368 static 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 } 384 DEFINE_SHOW_ATTRIBUTE(vcap_port_debugfs); 385 386 void 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 } 401 EXPORT_SYMBOL_GPL(vcap_port_debugfs); 402 403 /* Show the full VCAP instance data (rules with all fields) */ 404 static int vcap_debugfs_show(struct seq_file *m, void *unused) 405 { 406 struct vcap_admin_debugfs_info *info = m->private; 407 struct vcap_output_print out = { 408 .prf = (void *)seq_printf, 409 .dst = m, 410 }; 411 int ret; 412 413 mutex_lock(&info->admin->lock); 414 ret = vcap_show_admin(info->vctrl, info->admin, &out); 415 mutex_unlock(&info->admin->lock); 416 return ret; 417 } 418 DEFINE_SHOW_ATTRIBUTE(vcap_debugfs); 419 420 /* Show the raw VCAP instance data (rules with address info) */ 421 static int vcap_raw_debugfs_show(struct seq_file *m, void *unused) 422 { 423 struct vcap_admin_debugfs_info *info = m->private; 424 struct vcap_output_print out = { 425 .prf = (void *)seq_printf, 426 .dst = m, 427 }; 428 int ret; 429 430 mutex_lock(&info->admin->lock); 431 ret = vcap_show_admin_raw(info->vctrl, info->admin, &out); 432 mutex_unlock(&info->admin->lock); 433 return ret; 434 } 435 DEFINE_SHOW_ATTRIBUTE(vcap_raw_debugfs); 436 437 struct dentry *vcap_debugfs(struct device *dev, struct dentry *parent, 438 struct vcap_control *vctrl) 439 { 440 struct vcap_admin_debugfs_info *info; 441 struct vcap_admin *admin; 442 struct dentry *dir; 443 char name[50]; 444 445 dir = debugfs_create_dir("vcaps", parent); 446 if (PTR_ERR_OR_ZERO(dir)) 447 return NULL; 448 list_for_each_entry(admin, &vctrl->list, list) { 449 sprintf(name, "raw_%s_%d", vctrl->vcaps[admin->vtype].name, 450 admin->vinst); 451 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); 452 if (!info) 453 return NULL; 454 info->vctrl = vctrl; 455 info->admin = admin; 456 debugfs_create_file(name, 0444, dir, info, 457 &vcap_raw_debugfs_fops); 458 sprintf(name, "%s_%d", vctrl->vcaps[admin->vtype].name, 459 admin->vinst); 460 debugfs_create_file(name, 0444, dir, info, &vcap_debugfs_fops); 461 } 462 return dir; 463 } 464 EXPORT_SYMBOL_GPL(vcap_debugfs); 465 466 #ifdef CONFIG_VCAP_KUNIT_TEST 467 #include "vcap_api_debugfs_kunit.c" 468 #endif 469