drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

   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(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