examples/l2fwd-cat/cat.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016 Intel Corporation
   3  */
   4
   5 #include <getopt.h>
   6 #include <inttypes.h>
   7 #include <limits.h>
   8 #include <sched.h>
   9 #include <signal.h>
  10 #include <stdio.h>
  11
  12 #include <rte_common.h>
  13 #include <rte_memcpy.h>
  14
  15 #include <pqos.h>
  16
  17 #include "cat.h"
  18
  19 #define BITS_PER_HEX            4
  20 #define PQOS_MAX_SOCKETS        8
  21 #define PQOS_MAX_SOCKET_CORES   64
  22 #define PQOS_MAX_CORES          (PQOS_MAX_SOCKET_CORES * PQOS_MAX_SOCKETS)
  23
  24 static const struct pqos_cap *m_cap;
  25 static const struct pqos_cpuinfo *m_cpu;
  26 static const struct pqos_capability *m_cap_l3ca;
  27 #if PQOS_VERSION <= 103
  28 static unsigned m_sockets[PQOS_MAX_SOCKETS];
  29 #else
  30 static unsigned int *m_sockets;
  31 #endif
  32 static unsigned m_sock_count;
  33 static struct cat_config m_config[PQOS_MAX_CORES];
  34 static unsigned m_config_count;
  35
  36 static unsigned
  37 bits_count(uint64_t bitmask)
  38 {
  39         unsigned count = 0;
  40
  41         for (; bitmask != 0; count++)
  42                 bitmask &= bitmask - 1;
  43
  44         return count;
  45 }
  46
  47 /*
  48  * Parse elem, the elem could be single number/range or '(' ')' group
  49  * 1) A single number elem, it's just a simple digit. e.g. 9
  50  * 2) A single range elem, two digits with a '-' between. e.g. 2-6
  51  * 3) A group elem, combines multiple 1) or 2) with '( )'. e.g (0,2-4,6)
  52  *    Within group elem, '-' used for a range separator;
  53  *                       ',' used for a single number.
  54  */
  55 static int
  56 parse_set(const char *input, rte_cpuset_t *cpusetp)
  57 {
  58         unsigned idx;
  59         const char *str = input;
  60         char *end = NULL;
  61         unsigned min, max;
  62         const unsigned num = PQOS_MAX_CORES;
  63
  64         CPU_ZERO(cpusetp);
  65
  66         while (isblank(*str))
  67                 str++;
  68
  69         /* only digit or left bracket is qualify for start point */
  70         if ((!isdigit(*str) && *str != '(') || *str == '\0')
  71                 return -1;
  72
  73         /* process single number or single range of number */
  74         if (*str != '(') {
  75                 errno = 0;
  76                 idx = strtoul(str, &end, 10);
  77
  78                 if (errno || end == NULL || idx >= num)
  79                         return -1;
  80
  81                 while (isblank(*end))
  82                         end++;
  83
  84                 min = idx;
  85                 max = idx;
  86                 if (*end == '-') {
  87                         /* process single <number>-<number> */
  88                         end++;
  89                         while (isblank(*end))
  90                                 end++;
  91                         if (!isdigit(*end))
  92                                 return -1;
  93
  94                         errno = 0;
  95                         idx = strtoul(end, &end, 10);
  96                         if (errno || end == NULL || idx >= num)
  97                                 return -1;
  98                         max = idx;
  99                         while (isblank(*end))
 100                                 end++;
 101                         if (*end != ',' && *end != '\0')
 102                                 return -1;
 103                 }
 104
 105                 if (*end != ',' && *end != '\0' && *end != '@')
 106                         return -1;
 107
 108                 for (idx = RTE_MIN(min, max); idx <= RTE_MAX(min, max);
 109                                 idx++)
 110                         CPU_SET(idx, cpusetp);
 111
 112                 return end - input;
 113         }
 114
 115         /* process set within bracket */
 116         str++;
 117         while (isblank(*str))
 118                 str++;
 119         if (*str == '\0')
 120                 return -1;
 121
 122         min = PQOS_MAX_CORES;
 123         do {
 124
 125                 /* go ahead to the first digit */
 126                 while (isblank(*str))
 127                         str++;
 128                 if (!isdigit(*str))
 129                         return -1;
 130
 131                 /* get the digit value */
 132                 errno = 0;
 133                 idx = strtoul(str, &end, 10);
 134                 if (errno || end == NULL || idx >= num)
 135                         return -1;
 136
 137                 /* go ahead to separator '-',',' and ')' */
 138                 while (isblank(*end))
 139                         end++;
 140                 if (*end == '-') {
 141                         if (min == PQOS_MAX_CORES)
 142                                 min = idx;
 143                         else /* avoid continuous '-' */
 144                                 return -1;
 145                 } else if ((*end == ',') || (*end == ')')) {
 146                         max = idx;
 147                         if (min == PQOS_MAX_CORES)
 148                                 min = idx;
 149                         for (idx = RTE_MIN(min, max); idx <= RTE_MAX(min, max);
 150                                         idx++)
 151                                 CPU_SET(idx, cpusetp);
 152
 153                         min = PQOS_MAX_CORES;
 154                 } else
 155                         return -1;
 156
 157                 str = end + 1;
 158         } while (*end != '\0' && *end != ')');
 159
 160         return str - input;
 161 }
 162
 163 /* Test if bitmask is contiguous */
 164 static int
 165 is_contiguous(uint64_t bitmask)
 166 {
 167         /* check if bitmask is contiguous */
 168         unsigned i = 0;
 169         unsigned j = 0;
 170         const unsigned max_idx = (sizeof(bitmask) * CHAR_BIT);
 171
 172         if (bitmask == 0)
 173                 return 0;
 174
 175         for (i = 0; i < max_idx; i++) {
 176                 if (((1ULL << i) & bitmask) != 0)
 177                         j++;
 178                 else if (j > 0)
 179                         break;
 180         }
 181
 182         if (bits_count(bitmask) != j) {
 183                 printf("PQOS: mask 0x%llx is not contiguous.\n",
 184                         (unsigned long long)bitmask);
 185                 return 0;
 186         }
 187
 188         return 1;
 189 }
 190
 191 /*
 192  * The format pattern: --l3ca='<cbm@cpus>[,<(ccbm,dcbm)@cpus>...]'
 193  * cbm could be a single mask or for a CDP enabled system, a group of two masks
 194  * ("code cbm" and "data cbm")
 195  * '(' and ')' are necessary if it's a group.
 196  * cpus could be a single digit/range or a group.
 197  * '(' and ')' are necessary if it's a group.
 198  *
 199  * e.g. '0x00F00@(1,3), 0x0FF00@(4-6), 0xF0000@7'
 200  * - CPUs 1 and 3 share its 4 ways with CPUs 4, 5 and 6;
 201  * - CPUs 4,5 and 6 share half (4 out of 8 ways) of its L3 with 1 and 3;
 202  * - CPUs 4,5 and 6 have exclusive access to 4 out of  8 ways;
 203  * - CPU 7 has exclusive access to all of its 4 ways;
 204  *
 205  * e.g. '(0x00C00,0x00300)@(1,3)' for a CDP enabled system
 206  * - cpus 1 and 3 have access to 2 ways for code and 2 ways for data,
 207  *   code and data ways are not overlapping.;
 208  */
 209 static int
 210 parse_l3ca(const char *l3ca)
 211 {
 212         unsigned idx = 0;
 213         const char *cbm_start = NULL;
 214         char *cbm_end = NULL;
 215         const char *end = NULL;
 216         int offset;
 217         rte_cpuset_t cpuset;
 218         uint64_t mask = 0;
 219         uint64_t cmask = 0;
 220
 221         if (l3ca == NULL)
 222                 goto err;
 223
 224         /* Get cbm */
 225         do {
 226                 CPU_ZERO(&cpuset);
 227                 mask = 0;
 228                 cmask = 0;
 229
 230                 while (isblank(*l3ca))
 231                         l3ca++;
 232
 233                 if (*l3ca == '\0')
 234                         goto err;
 235
 236                 /* record mask_set start point */
 237                 cbm_start = l3ca;
 238
 239                 /* go across a complete bracket */
 240                 if (*cbm_start == '(') {
 241                         l3ca += strcspn(l3ca, ")");
 242                         if (*l3ca++ == '\0')
 243                                 goto err;
 244                 }
 245
 246                 /* scan the separator '@', ','(next) or '\0'(finish) */
 247                 l3ca += strcspn(l3ca, "@,");
 248
 249                 if (*l3ca != '@')
 250                         goto err;
 251
 252                 /* explicit assign cpu_set */
 253                 offset = parse_set(l3ca + 1, &cpuset);
 254                 if (offset < 0 || CPU_COUNT(&cpuset) == 0)
 255                         goto err;
 256
 257                 end = l3ca + 1 + offset;
 258
 259                 if (*end != ',' && *end != '\0')
 260                         goto err;
 261
 262                 /* parse mask_set from start point */
 263                 if (*cbm_start == '(') {
 264                         cbm_start++;
 265
 266                         while (isblank(*cbm_start))
 267                                 cbm_start++;
 268
 269                         if (!isxdigit(*cbm_start))
 270                                 goto err;
 271
 272                         errno = 0;
 273                         cmask = strtoul(cbm_start, &cbm_end, 16);
 274                         if (errno != 0 || cbm_end == NULL || cmask == 0)
 275                                 goto err;
 276
 277                         while (isblank(*cbm_end))
 278                                 cbm_end++;
 279
 280                         if (*cbm_end != ',')
 281                                 goto err;
 282
 283                         cbm_end++;
 284
 285                         while (isblank(*cbm_end))
 286                                 cbm_end++;
 287
 288                         if (!isxdigit(*cbm_end))
 289                                 goto err;
 290
 291                         errno = 0;
 292                         mask = strtoul(cbm_end, &cbm_end, 16);
 293                         if (errno != 0 || cbm_end == NULL || mask == 0)
 294                                 goto err;
 295                 } else {
 296                         while (isblank(*cbm_start))
 297                                 cbm_start++;
 298
 299                         if (!isxdigit(*cbm_start))
 300                                 goto err;
 301
 302                         errno = 0;
 303                         mask = strtoul(cbm_start, &cbm_end, 16);
 304                         if (errno != 0 || cbm_end == NULL || mask == 0)
 305                                 goto err;
 306
 307                 }
 308
 309                 if (mask == 0 || is_contiguous(mask) == 0)
 310                         goto err;
 311
 312                 if (cmask != 0 && is_contiguous(cmask) == 0)
 313                         goto err;
 314
 315                 rte_memcpy(&m_config[idx].cpumask,
 316                         &cpuset, sizeof(rte_cpuset_t));
 317
 318                 if (cmask != 0) {
 319                         m_config[idx].cdp = 1;
 320                         m_config[idx].code_mask = cmask;
 321                         m_config[idx].data_mask = mask;
 322                 } else
 323                         m_config[idx].mask = mask;
 324
 325                 m_config_count++;
 326
 327                 l3ca = end + 1;
 328                 idx++;
 329         } while (*end != '\0' && idx < PQOS_MAX_CORES);
 330
 331         return 0;
 332
 333 err:
 334         return -EINVAL;
 335 }
 336
 337 static int
 338 check_cpus_overlapping(void)
 339 {
 340         unsigned i = 0;
 341         unsigned j = 0;
 342         rte_cpuset_t mask;
 343
 344         CPU_ZERO(&mask);
 345
 346         for (i = 0; i < m_config_count; i++) {
 347                 for (j = i + 1; j < m_config_count; j++) {
 348                         CPU_AND(&mask,
 349                                 &m_config[i].cpumask,
 350                                 &m_config[j].cpumask);
 351
 352                         if (CPU_COUNT(&mask) != 0) {
 353                                 printf("PQOS: Requested CPUs sets are "
 354                                         "overlapping.\n");
 355                                 return -EINVAL;
 356                         }
 357                 }
 358         }
 359
 360         return 0;
 361 }
 362
 363 static int
 364 check_cpus(void)
 365 {
 366         unsigned i = 0;
 367         unsigned cpu_id = 0;
 368         unsigned cos_id = 0;
 369         int ret = 0;
 370
 371         for (i = 0; i < m_config_count; i++) {
 372                 for (cpu_id = 0; cpu_id < PQOS_MAX_CORES; cpu_id++) {
 373                         if (CPU_ISSET(cpu_id, &m_config[i].cpumask) != 0) {
 374
 375                                 ret = pqos_cpu_check_core(m_cpu, cpu_id);
 376                                 if (ret != PQOS_RETVAL_OK) {
 377                                         printf("PQOS: %u is not a valid "
 378                                                 "logical core id.\n", cpu_id);
 379                                         ret = -ENODEV;
 380                                         goto exit;
 381                                 }
 382
 383 #if PQOS_VERSION <= 103
 384                                 ret = pqos_l3ca_assoc_get(cpu_id, &cos_id);
 385 #else
 386                                 ret = pqos_alloc_assoc_get(cpu_id, &cos_id);
 387 #endif
 388                                 if (ret != PQOS_RETVAL_OK) {
 389                                         printf("PQOS: Failed to read COS "
 390                                                 "associated to cpu %u.\n",
 391                                                 cpu_id);
 392                                         ret = -EFAULT;
 393                                         goto exit;
 394                                 }
 395
 396                                 /*
 397                                  * Check if COS assigned to lcore is different
 398                                  * then default one (#0)
 399                                  */
 400                                 if (cos_id != 0) {
 401                                         printf("PQOS: cpu %u has already "
 402                                                 "associated COS#%u. "
 403                                                 "Please reset L3CA.\n",
 404                                                 cpu_id, cos_id);
 405                                         ret = -EBUSY;
 406                                         goto exit;
 407                                 }
 408                         }
 409                 }
 410         }
 411
 412 exit:
 413         return ret;
 414 }
 415
 416 static int
 417 check_cdp(void)
 418 {
 419         unsigned i = 0;
 420
 421         for (i = 0; i < m_config_count; i++) {
 422                 if (m_config[i].cdp == 1 && m_cap_l3ca->u.l3ca->cdp_on == 0) {
 423                         if (m_cap_l3ca->u.l3ca->cdp == 0) {
 424                                 printf("PQOS: CDP requested but not "
 425                                         "supported.\n");
 426                         } else {
 427                                 printf("PQOS: CDP requested but not enabled. "
 428                                         "Please enable CDP.\n");
 429                         }
 430                         return -ENOTSUP;
 431                 }
 432         }
 433
 434         return 0;
 435 }
 436
 437 static int
 438 check_cbm_len_and_contention(void)
 439 {
 440         unsigned i = 0;
 441         uint64_t mask = 0;
 442         const uint64_t not_cbm = (UINT64_MAX << (m_cap_l3ca->u.l3ca->num_ways));
 443         const uint64_t cbm_contention_mask = m_cap_l3ca->u.l3ca->way_contention;
 444         int ret = 0;
 445
 446         for (i = 0; i < m_config_count; i++) {
 447                 if (m_config[i].cdp == 1)
 448                         mask = m_config[i].code_mask | m_config[i].data_mask;
 449                 else
 450                         mask = m_config[i].mask;
 451
 452                 if ((mask & not_cbm) != 0) {
 453                         printf("PQOS: One or more of requested CBM masks not "
 454                                 "supported by system (too long).\n");
 455                         ret = -ENOTSUP;
 456                         break;
 457                 }
 458
 459                 /* Just a warning */
 460                 if ((mask & cbm_contention_mask) != 0) {
 461                         printf("PQOS: One or more of requested CBM  masks "
 462                                 "overlap CBM contention mask.\n");
 463                         break;
 464                 }
 465
 466         }
 467
 468         return ret;
 469 }
 470
 471 static int
 472 check_and_select_classes(unsigned cos_id_map[][PQOS_MAX_SOCKETS])
 473 {
 474         unsigned i = 0;
 475         unsigned j = 0;
 476         unsigned phy_pkg_id = 0;
 477         unsigned cos_id = 0;
 478         unsigned cpu_id = 0;
 479         unsigned phy_pkg_lcores[PQOS_MAX_SOCKETS][m_config_count];
 480         const unsigned cos_num = m_cap_l3ca->u.l3ca->num_classes;
 481         unsigned used_cos_table[PQOS_MAX_SOCKETS][cos_num];
 482         int ret = 0;
 483
 484         memset(phy_pkg_lcores, 0, sizeof(phy_pkg_lcores));
 485         memset(used_cos_table, 0, sizeof(used_cos_table));
 486
 487         /* detect currently used COS */
 488         for (j = 0; j < m_cpu->num_cores; j++) {
 489                 cpu_id = m_cpu->cores[j].lcore;
 490
 491 #if PQOS_VERSION <= 103
 492                 ret = pqos_l3ca_assoc_get(cpu_id, &cos_id);
 493 #else
 494                 ret = pqos_alloc_assoc_get(cpu_id, &cos_id);
 495 #endif
 496                 if (ret != PQOS_RETVAL_OK) {
 497                         printf("PQOS: Failed to read COS associated to "
 498                                 "cpu %u on phy_pkg %u.\n", cpu_id, phy_pkg_id);
 499                         ret = -EFAULT;
 500                         goto exit;
 501                 }
 502
 503                 ret = pqos_cpu_get_socketid(m_cpu, cpu_id, &phy_pkg_id);
 504                 if (ret != PQOS_RETVAL_OK) {
 505                         printf("PQOS: Failed to get socket for cpu %u\n",
 506                                 cpu_id);
 507                         ret = -EFAULT;
 508                         goto exit;
 509                 }
 510
 511                 /* Mark COS as used */
 512                 if (used_cos_table[phy_pkg_id][cos_id] == 0)
 513                         used_cos_table[phy_pkg_id][cos_id]++;
 514         }
 515
 516         /* look for avail. COS to fulfill requested config */
 517         for (i = 0; i < m_config_count; i++) {
 518                 for (j = 0; j < m_cpu->num_cores; j++) {
 519                         cpu_id = m_cpu->cores[j].lcore;
 520                         if (CPU_ISSET(cpu_id, &m_config[i].cpumask) == 0)
 521                                 continue;
 522
 523                         ret = pqos_cpu_get_socketid(m_cpu, cpu_id, &phy_pkg_id);
 524                         if (ret != PQOS_RETVAL_OK) {
 525                                 printf("PQOS: Failed to get socket for "
 526                                         "cpu %u\n", cpu_id);
 527                                 ret = -EFAULT;
 528                                 goto exit;
 529                         }
 530
 531                         /*
 532                          * Check if we already have COS selected
 533                          * to be used for that group on that socket
 534                          */
 535                         if (phy_pkg_lcores[phy_pkg_id][i] != 0)
 536                                 continue;
 537
 538                         phy_pkg_lcores[phy_pkg_id][i]++;
 539
 540                         /* Search for avail. COS to be used on that socket */
 541                         for (cos_id = 0; cos_id < cos_num; cos_id++) {
 542                                 if (used_cos_table[phy_pkg_id][cos_id] == 0) {
 543                                         used_cos_table[phy_pkg_id][cos_id]++;
 544                                         cos_id_map[i][phy_pkg_id] = cos_id;
 545                                         break;
 546                                 }
 547                         }
 548
 549                         /* If there is no COS available ...*/
 550                         if (cos_id == cos_num) {
 551                                 ret = -E2BIG;
 552                                 goto exit;
 553                         }
 554                 }
 555         }
 556
 557 exit:
 558         if (ret != 0)
 559                 printf("PQOS: Not enough available COS to configure "
 560                         "requested configuration.\n");
 561
 562         return ret;
 563 }
 564
 565 static int
 566 configure_cat(unsigned cos_id_map[][PQOS_MAX_SOCKETS])
 567 {
 568         unsigned phy_pkg_id = 0;
 569         unsigned cpu_id = 0;
 570         unsigned cos_id = 0;
 571         unsigned i = 0;
 572         unsigned j = 0;
 573         struct pqos_l3ca l3ca = {0};
 574         int ret = 0;
 575
 576         for (i = 0; i < m_config_count; i++) {
 577                 memset(&l3ca, 0, sizeof(l3ca));
 578
 579                 l3ca.cdp = m_config[i].cdp;
 580                 if (m_config[i].cdp == 1) {
 581 #if PQOS_VERSION <= 103
 582                         l3ca.code_mask = m_config[i].code_mask;
 583                         l3ca.data_mask = m_config[i].data_mask;
 584 #else
 585                         l3ca.u.s.code_mask = m_config[i].code_mask;
 586                         l3ca.u.s.data_mask = m_config[i].data_mask;
 587 #endif
 588                 } else
 589 #if PQOS_VERSION <= 103
 590                         l3ca.ways_mask = m_config[i].mask;
 591 #else
 592                         l3ca.u.ways_mask = m_config[i].mask;
 593 #endif
 594
 595                 for (j = 0; j < m_sock_count; j++) {
 596                         phy_pkg_id = m_sockets[j];
 597                         if (cos_id_map[i][phy_pkg_id] == 0)
 598                                 continue;
 599
 600                         l3ca.class_id = cos_id_map[i][phy_pkg_id];
 601
 602                         ret = pqos_l3ca_set(phy_pkg_id, 1, &l3ca);
 603                         if (ret != PQOS_RETVAL_OK) {
 604                                 printf("PQOS: Failed to set COS %u on "
 605                                         "phy_pkg %u.\n", l3ca.class_id,
 606                                         phy_pkg_id);
 607                                 ret = -EFAULT;
 608                                 goto exit;
 609                         }
 610                 }
 611         }
 612
 613         for (i = 0; i < m_config_count; i++) {
 614                 for (j = 0; j < m_cpu->num_cores; j++) {
 615                         cpu_id = m_cpu->cores[j].lcore;
 616                         if (CPU_ISSET(cpu_id, &m_config[i].cpumask) == 0)
 617                                 continue;
 618
 619                         ret = pqos_cpu_get_socketid(m_cpu, cpu_id, &phy_pkg_id);
 620                         if (ret != PQOS_RETVAL_OK) {
 621                                 printf("PQOS: Failed to get socket for "
 622                                         "cpu %u\n", cpu_id);
 623                                 ret = -EFAULT;
 624                                 goto exit;
 625                         }
 626
 627                         cos_id = cos_id_map[i][phy_pkg_id];
 628
 629 #if PQOS_VERSION <= 103
 630                         ret = pqos_l3ca_assoc_set(cpu_id, cos_id);
 631 #else
 632                         ret = pqos_alloc_assoc_set(cpu_id, cos_id);
 633 #endif
 634                         if (ret != PQOS_RETVAL_OK) {
 635                                 printf("PQOS: Failed to associate COS %u to "
 636                                         "cpu %u\n", cos_id, cpu_id);
 637                                 ret = -EFAULT;
 638                                 goto exit;
 639                         }
 640                 }
 641         }
 642
 643 exit:
 644         return ret;
 645 }
 646
 647
 648 /* Parse the argument given in the command line of the application */
 649 static int
 650 parse_args(int argc, char **argv)
 651 {
 652         int opt = 0;
 653         int retval = 0;
 654         int oldopterr = 0;
 655         char **argvopt = argv;
 656         char *prgname = argv[0];
 657
 658         static struct option lgopts[] = {
 659                 { "l3ca", required_argument, 0, 0 },
 660                 { NULL, 0, 0, 0 }
 661         };
 662
 663         /* Disable printing messages within getopt() */
 664         oldopterr = opterr;
 665         opterr = 0;
 666
 667         opt = getopt_long(argc, argvopt, "", lgopts, NULL);
 668         if (opt == 0) {
 669                 retval = parse_l3ca(optarg);
 670                 if (retval != 0) {
 671                         printf("PQOS: Invalid L3CA parameters!\n");
 672                         goto exit;
 673                 }
 674
 675                 argv[optind - 1] = prgname;
 676                 retval = optind - 1;
 677         } else
 678                 retval = 0;
 679
 680 exit:
 681         /* reset getopt lib */
 682         optind = 1;
 683
 684         /* Restore opterr value */
 685         opterr = oldopterr;
 686
 687         return retval;
 688 }
 689
 690 static void
 691 print_cmd_line_config(void)
 692 {
 693         char cpustr[PQOS_MAX_CORES * 3] = {0};
 694         unsigned i = 0;
 695         unsigned j = 0;
 696
 697         for (i = 0; i < m_config_count; i++) {
 698                 unsigned len = 0;
 699                 memset(cpustr, 0, sizeof(cpustr));
 700
 701                 /* Generate CPU list */
 702                 for (j = 0; j < PQOS_MAX_CORES; j++) {
 703                         if (CPU_ISSET(j, &m_config[i].cpumask) != 1)
 704                                 continue;
 705
 706                         len += snprintf(cpustr + len, sizeof(cpustr) - len - 1,
 707                                 "%u,", j);
 708
 709                         if (len >= sizeof(cpustr) - 1)
 710                                 break;
 711                 }
 712
 713                 if (m_config[i].cdp == 1) {
 714                         printf("PQOS: CPUs: %s cMASK: 0x%llx, dMASK: "
 715                                 "0x%llx\n", cpustr,
 716                                 (unsigned long long)m_config[i].code_mask,
 717                                 (unsigned long long)m_config[i].data_mask);
 718                 } else {
 719                         printf("PQOS: CPUs: %s MASK: 0x%llx\n", cpustr,
 720                                         (unsigned long long)m_config[i].mask);
 721                 }
 722         }
 723 }
 724
 725 /**
 726  * @brief Prints CAT configuration
 727  */
 728 static void
 729 print_cat_config(void)
 730 {
 731         int ret = PQOS_RETVAL_OK;
 732         unsigned i = 0;
 733
 734         for (i = 0; i < m_sock_count; i++) {
 735                 struct pqos_l3ca tab[PQOS_MAX_L3CA_COS] = {{0} };
 736                 unsigned num = 0;
 737                 unsigned n = 0;
 738
 739                 ret = pqos_l3ca_get(m_sockets[i], PQOS_MAX_L3CA_COS, &num, tab);
 740                 if (ret != PQOS_RETVAL_OK) {
 741                         printf("PQOS: Error retrieving COS!\n");
 742                         return;
 743                 }
 744
 745                 printf("PQOS: COS definitions for Socket %u:\n", m_sockets[i]);
 746                 for (n = 0; n < num; n++) {
 747                         if (tab[n].cdp == 1) {
 748                                 printf("PQOS: COS: %u, cMASK: 0x%llx, "
 749                                         "dMASK: 0x%llx\n", tab[n].class_id,
 750 #if PQOS_VERSION <= 103
 751                                         (unsigned long long)tab[n].code_mask,
 752                                         (unsigned long long)tab[n].data_mask);
 753 #else
 754                                         (unsigned long long)tab[n].u.s.code_mask,
 755                                         (unsigned long long)tab[n].u.s.data_mask);
 756 #endif
 757                         } else {
 758                                 printf("PQOS: COS: %u, MASK: 0x%llx\n",
 759                                         tab[n].class_id,
 760 #if PQOS_VERSION <= 103
 761                                         (unsigned long long)tab[n].ways_mask);
 762 #else
 763                                         (unsigned long long)tab[n].u.ways_mask);
 764 #endif
 765                         }
 766                 }
 767         }
 768
 769         for (i = 0; i < m_sock_count; i++) {
 770 #if PQOS_VERSION <= 103
 771                 unsigned lcores[PQOS_MAX_SOCKET_CORES] = {0};
 772 #else
 773                 unsigned int *lcores = NULL;
 774 #endif
 775                 unsigned lcount = 0;
 776                 unsigned n = 0;
 777
 778 #if PQOS_VERSION <= 103
 779                 ret = pqos_cpu_get_cores(m_cpu, m_sockets[i],
 780                                 PQOS_MAX_SOCKET_CORES, &lcount, &lcores[0]);
 781                 if (ret != PQOS_RETVAL_OK) {
 782 #else
 783                 lcores = pqos_cpu_get_cores(m_cpu, m_sockets[i],
 784                                 &lcount);
 785                 if (lcores == NULL || lcount == 0) {
 786 #endif
 787                         printf("PQOS: Error retrieving core information!\n");
 788                         return;
 789                 }
 790
 791                 printf("PQOS: CPU information for socket %u:\n", m_sockets[i]);
 792                 for (n = 0; n < lcount; n++) {
 793                         unsigned class_id = 0;
 794
 795 #if PQOS_VERSION <= 103
 796                         ret = pqos_l3ca_assoc_get(lcores[n], &class_id);
 797 #else
 798                         ret = pqos_alloc_assoc_get(lcores[n], &class_id);
 799 #endif
 800                         if (ret == PQOS_RETVAL_OK)
 801                                 printf("PQOS: CPU: %u, COS: %u\n", lcores[n],
 802                                         class_id);
 803                         else
 804                                 printf("PQOS: CPU: %u, ERROR\n", lcores[n]);
 805                 }
 806
 807 #if PQOS_VERSION > 103
 808                 free(lcores);
 809 #endif
 810         }
 811
 812 }
 813
 814 static int
 815 cat_validate(void)
 816 {
 817         int ret = 0;
 818
 819         ret = check_cpus();
 820         if (ret != 0)
 821                 return ret;
 822
 823         ret = check_cdp();
 824         if (ret != 0)
 825                 return ret;
 826
 827         ret = check_cbm_len_and_contention();
 828         if (ret != 0)
 829                 return ret;
 830
 831         ret = check_cpus_overlapping();
 832         if (ret != 0)
 833                 return ret;
 834
 835         return 0;
 836 }
 837
 838 static int
 839 cat_set(void)
 840 {
 841         int ret = 0;
 842         unsigned cos_id_map[m_config_count][PQOS_MAX_SOCKETS];
 843
 844         memset(cos_id_map, 0, sizeof(cos_id_map));
 845
 846         ret = check_and_select_classes(cos_id_map);
 847         if (ret != 0)
 848                 return ret;
 849
 850         ret = configure_cat(cos_id_map);
 851         if (ret != 0)
 852                 return ret;
 853
 854         return 0;
 855 }
 856
 857 static void
 858 cat_fini(void)
 859 {
 860         int ret = 0;
 861
 862         printf("PQOS: Shutting down PQoS library...\n");
 863
 864         /* deallocate all the resources */
 865         ret = pqos_fini();
 866         if (ret != PQOS_RETVAL_OK && ret != PQOS_RETVAL_INIT)
 867                 printf("PQOS: Error shutting down PQoS library!\n");
 868
 869         m_cap = NULL;
 870         m_cpu = NULL;
 871         m_cap_l3ca = NULL;
 872 #if PQOS_VERSION <= 103
 873         memset(m_sockets, 0, sizeof(m_sockets));
 874 #else
 875         if (m_sockets != NULL)
 876                 free(m_sockets);
 877 #endif
 878         m_sock_count = 0;
 879         memset(m_config, 0, sizeof(m_config));
 880         m_config_count = 0;
 881 }
 882
 883 void
 884 cat_exit(void)
 885 {
 886         unsigned i = 0;
 887         unsigned j = 0;
 888         unsigned cpu_id = 0;
 889         int ret = 0;
 890
 891         /* if lib is not initialized, do nothing */
 892         if (m_cap == NULL && m_cpu == NULL)
 893                 return;
 894
 895         printf("PQOS: Reverting CAT configuration...\n");
 896
 897         for (i = 0; i < m_config_count; i++) {
 898                 for (j = 0; j < m_cpu->num_cores; j++) {
 899                         cpu_id = m_cpu->cores[j].lcore;
 900                         if (CPU_ISSET(cpu_id, &m_config[i].cpumask) == 0)
 901                                 continue;
 902
 903 #if PQOS_VERSION <= 103
 904                         ret = pqos_l3ca_assoc_set(cpu_id, 0);
 905 #else
 906                         ret = pqos_alloc_assoc_set(cpu_id, 0);
 907 #endif
 908                         if (ret != PQOS_RETVAL_OK) {
 909                                 printf("PQOS: Failed to associate COS 0 to "
 910                                         "cpu %u\n", cpu_id);
 911                         }
 912                 }
 913         }
 914
 915         cat_fini();
 916 }
 917
 918 static void
 919 signal_handler(int signum)
 920 {
 921         if (signum == SIGINT || signum == SIGTERM) {
 922                 printf("\nPQOS: Signal %d received, preparing to exit...\n",
 923                                 signum);
 924
 925                 cat_exit();
 926
 927                 /* exit with the expected status */
 928                 signal(signum, SIG_DFL);
 929                 kill(getpid(), signum);
 930         }
 931 }
 932
 933 int
 934 cat_init(int argc, char **argv)
 935 {
 936         int ret = 0;
 937         int args_num = 0;
 938         struct pqos_config cfg = {0};
 939
 940         if (m_cap != NULL || m_cpu != NULL) {
 941                 printf("PQOS: CAT module already initialized!\n");
 942                 return -EEXIST;
 943         }
 944
 945         /* Parse cmd line args */
 946         ret = parse_args(argc, argv);
 947
 948         if (ret <= 0)
 949                 goto err;
 950
 951         args_num = ret;
 952
 953         /* Print cmd line configuration */
 954         print_cmd_line_config();
 955
 956         /* PQoS Initialization - Check and initialize CAT capability */
 957         cfg.fd_log = STDOUT_FILENO;
 958         cfg.verbose = 0;
 959 #if PQOS_VERSION <= 103
 960         cfg.cdp_cfg = PQOS_REQUIRE_CDP_ANY;
 961 #endif
 962         ret = pqos_init(&cfg);
 963         if (ret != PQOS_RETVAL_OK) {
 964                 printf("PQOS: Error initializing PQoS library!\n");
 965                 ret = -EFAULT;
 966                 goto err;
 967         }
 968
 969         /* Get capability and CPU info pointer */
 970         ret = pqos_cap_get(&m_cap, &m_cpu);
 971         if (ret != PQOS_RETVAL_OK || m_cap == NULL || m_cpu == NULL) {
 972                 printf("PQOS: Error retrieving PQoS capabilities!\n");
 973                 ret = -EFAULT;
 974                 goto err;
 975         }
 976
 977         /* Get L3CA capabilities */
 978         ret = pqos_cap_get_type(m_cap, PQOS_CAP_TYPE_L3CA, &m_cap_l3ca);
 979         if (ret != PQOS_RETVAL_OK || m_cap_l3ca == NULL) {
 980                 printf("PQOS: Error retrieving PQOS_CAP_TYPE_L3CA "
 981                         "capabilities!\n");
 982                 ret = -EFAULT;
 983                 goto err;
 984         }
 985
 986         /* Get CPU socket information */
 987 #if PQOS_VERSION <= 103
 988         ret = pqos_cpu_get_sockets(m_cpu, PQOS_MAX_SOCKETS, &m_sock_count,
 989                 m_sockets);
 990         if (ret != PQOS_RETVAL_OK) {
 991 #else
 992         m_sockets = pqos_cpu_get_sockets(m_cpu, &m_sock_count);
 993         if (m_sockets == NULL) {
 994 #endif
 995                 printf("PQOS: Error retrieving CPU socket information!\n");
 996                 ret = -EFAULT;
 997                 goto err;
 998         }
 999
1000         /* Validate cmd line configuration */
1001         ret = cat_validate();
1002         if (ret != 0) {
1003                 printf("PQOS: Requested CAT configuration is not valid!\n");
1004                 goto err;
1005         }
1006
1007         /* configure system */
1008         ret = cat_set();
1009         if (ret != 0) {
1010                 printf("PQOS: Failed to configure CAT!\n");
1011                 goto err;
1012         }
1013
1014         signal(SIGINT, signal_handler);
1015         signal(SIGTERM, signal_handler);
1016
1017         ret = atexit(cat_exit);
1018         if (ret != 0) {
1019                 printf("PQOS: Cannot set exit function\n");
1020                 goto err;
1021         }
1022
1023         /* Print CAT configuration */
1024         print_cat_config();
1025
1026         return args_num;
1027
1028 err:
1029         /* deallocate all the resources */
1030         cat_fini();
1031         return ret;
1032 }