1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Intel dynamic_speed_select -- Enumerate and control features 4 * Copyright (c) 2019 Intel Corporation. 5 */ 6 7 #include "isst.h" 8 9 static void printcpulist(int str_len, char *str, int mask_size, 10 cpu_set_t *cpu_mask) 11 { 12 int i, first, curr_index, index; 13 14 if (!CPU_COUNT_S(mask_size, cpu_mask)) { 15 snprintf(str, str_len, "none"); 16 return; 17 } 18 19 curr_index = 0; 20 first = 1; 21 for (i = 0; i < get_topo_max_cpus(); ++i) { 22 if (!CPU_ISSET_S(i, mask_size, cpu_mask)) 23 continue; 24 if (!first) { 25 index = snprintf(&str[curr_index], 26 str_len - curr_index, ","); 27 curr_index += index; 28 } 29 index = snprintf(&str[curr_index], str_len - curr_index, "%d", 30 i); 31 curr_index += index; 32 first = 0; 33 } 34 } 35 36 static void printcpumask(int str_len, char *str, int mask_size, 37 cpu_set_t *cpu_mask) 38 { 39 int i, max_cpus = get_topo_max_cpus(); 40 unsigned int *mask; 41 int size, index, curr_index; 42 43 size = max_cpus / (sizeof(unsigned int) * 8); 44 if (max_cpus % (sizeof(unsigned int) * 8)) 45 size++; 46 47 mask = calloc(size, sizeof(unsigned int)); 48 if (!mask) 49 return; 50 51 for (i = 0; i < max_cpus; ++i) { 52 int mask_index, bit_index; 53 54 if (!CPU_ISSET_S(i, mask_size, cpu_mask)) 55 continue; 56 57 mask_index = i / (sizeof(unsigned int) * 8); 58 bit_index = i % (sizeof(unsigned int) * 8); 59 mask[mask_index] |= BIT(bit_index); 60 } 61 62 curr_index = 0; 63 for (i = size - 1; i >= 0; --i) { 64 index = snprintf(&str[curr_index], str_len - curr_index, "%08x", 65 mask[i]); 66 curr_index += index; 67 if (i) { 68 strncat(&str[curr_index], ",", str_len - curr_index); 69 curr_index++; 70 } 71 } 72 73 free(mask); 74 } 75 76 static void format_and_print_txt(FILE *outf, int level, char *header, 77 char *value) 78 { 79 char *spaces = " "; 80 static char delimiters[256]; 81 int i, j = 0; 82 83 if (!level) 84 return; 85 86 if (level == 1) { 87 strcpy(delimiters, " "); 88 } else { 89 for (i = 0; i < level - 1; ++i) 90 j += snprintf(&delimiters[j], sizeof(delimiters) - j, 91 "%s", spaces); 92 } 93 94 if (header && value) { 95 fprintf(outf, "%s", delimiters); 96 fprintf(outf, "%s:%s\n", header, value); 97 } else if (header) { 98 fprintf(outf, "%s", delimiters); 99 fprintf(outf, "%s\n", header); 100 } 101 } 102 103 static int last_level; 104 static void format_and_print(FILE *outf, int level, char *header, char *value) 105 { 106 char *spaces = " "; 107 static char delimiters[256]; 108 int i; 109 110 if (!out_format_is_json()) { 111 format_and_print_txt(outf, level, header, value); 112 return; 113 } 114 115 if (level == 0) { 116 if (header) 117 fprintf(outf, "{"); 118 else 119 fprintf(outf, "\n}\n"); 120 121 } else { 122 int j = 0; 123 124 for (i = 0; i < level; ++i) 125 j += snprintf(&delimiters[j], sizeof(delimiters) - j, 126 "%s", spaces); 127 128 if (last_level == level) 129 fprintf(outf, ",\n"); 130 131 if (value) { 132 if (last_level != level) 133 fprintf(outf, "\n"); 134 135 fprintf(outf, "%s\"%s\": ", delimiters, header); 136 fprintf(outf, "\"%s\"", value); 137 } else { 138 for (i = last_level - 1; i >= level; --i) { 139 int k = 0; 140 141 for (j = i; j > 0; --j) 142 k += snprintf(&delimiters[k], 143 sizeof(delimiters) - k, 144 "%s", spaces); 145 if (i == level && header) 146 fprintf(outf, "\n%s},", delimiters); 147 else 148 fprintf(outf, "\n%s}", delimiters); 149 } 150 if (abs(last_level - level) < 3) 151 fprintf(outf, "\n"); 152 if (header) 153 fprintf(outf, "%s\"%s\": {", delimiters, 154 header); 155 } 156 } 157 158 last_level = level; 159 } 160 161 static int print_package_info(int cpu, FILE *outf) 162 { 163 char header[256]; 164 165 if (out_format_is_json()) { 166 snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d", 167 get_physical_package_id(cpu), get_physical_die_id(cpu), 168 cpu); 169 format_and_print(outf, 1, header, NULL); 170 return 1; 171 } 172 snprintf(header, sizeof(header), "package-%d", 173 get_physical_package_id(cpu)); 174 format_and_print(outf, 1, header, NULL); 175 snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu)); 176 format_and_print(outf, 2, header, NULL); 177 snprintf(header, sizeof(header), "cpu-%d", cpu); 178 format_and_print(outf, 3, header, NULL); 179 180 return 3; 181 } 182 183 static void _isst_pbf_display_information(int cpu, FILE *outf, int level, 184 struct isst_pbf_info *pbf_info, 185 int disp_level) 186 { 187 char header[256]; 188 char value[256]; 189 190 snprintf(header, sizeof(header), "speed-select-base-freq-properties"); 191 format_and_print(outf, disp_level, header, NULL); 192 193 snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)"); 194 snprintf(value, sizeof(value), "%d", 195 pbf_info->p1_high * DISP_FREQ_MULTIPLIER); 196 format_and_print(outf, disp_level + 1, header, value); 197 198 snprintf(header, sizeof(header), "high-priority-cpu-mask"); 199 printcpumask(sizeof(value), value, pbf_info->core_cpumask_size, 200 pbf_info->core_cpumask); 201 format_and_print(outf, disp_level + 1, header, value); 202 203 snprintf(header, sizeof(header), "high-priority-cpu-list"); 204 printcpulist(sizeof(value), value, 205 pbf_info->core_cpumask_size, 206 pbf_info->core_cpumask); 207 format_and_print(outf, disp_level + 1, header, value); 208 209 snprintf(header, sizeof(header), "low-priority-base-frequency(MHz)"); 210 snprintf(value, sizeof(value), "%d", 211 pbf_info->p1_low * DISP_FREQ_MULTIPLIER); 212 format_and_print(outf, disp_level + 1, header, value); 213 214 if (is_clx_n_platform()) 215 return; 216 217 snprintf(header, sizeof(header), "tjunction-temperature(C)"); 218 snprintf(value, sizeof(value), "%d", pbf_info->t_prochot); 219 format_and_print(outf, disp_level + 1, header, value); 220 221 snprintf(header, sizeof(header), "thermal-design-power(W)"); 222 snprintf(value, sizeof(value), "%d", pbf_info->tdp); 223 format_and_print(outf, disp_level + 1, header, value); 224 } 225 226 static void _isst_fact_display_information(int cpu, FILE *outf, int level, 227 int fact_bucket, int fact_avx, 228 struct isst_fact_info *fact_info, 229 int base_level) 230 { 231 struct isst_fact_bucket_info *bucket_info = fact_info->bucket_info; 232 char header[256]; 233 char value[256]; 234 int print = 0, j; 235 236 for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) { 237 if (fact_bucket != 0xff && fact_bucket != j) 238 continue; 239 240 if (!bucket_info[j].high_priority_cores_count) 241 break; 242 243 print = 1; 244 } 245 if (!print) { 246 fprintf(stderr, "Invalid bucket\n"); 247 return; 248 } 249 250 snprintf(header, sizeof(header), "speed-select-turbo-freq-properties"); 251 format_and_print(outf, base_level, header, NULL); 252 for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) { 253 if (fact_bucket != 0xff && fact_bucket != j) 254 continue; 255 256 if (!bucket_info[j].high_priority_cores_count) 257 break; 258 259 snprintf(header, sizeof(header), "bucket-%d", j); 260 format_and_print(outf, base_level + 1, header, NULL); 261 262 snprintf(header, sizeof(header), "high-priority-cores-count"); 263 snprintf(value, sizeof(value), "%d", 264 bucket_info[j].high_priority_cores_count); 265 format_and_print(outf, base_level + 2, header, value); 266 267 if (fact_avx & 0x01) { 268 snprintf(header, sizeof(header), 269 "high-priority-max-frequency(MHz)"); 270 snprintf(value, sizeof(value), "%d", 271 bucket_info[j].sse_trl * DISP_FREQ_MULTIPLIER); 272 format_and_print(outf, base_level + 2, header, value); 273 } 274 275 if (fact_avx & 0x02) { 276 snprintf(header, sizeof(header), 277 "high-priority-max-avx2-frequency(MHz)"); 278 snprintf(value, sizeof(value), "%d", 279 bucket_info[j].avx_trl * DISP_FREQ_MULTIPLIER); 280 format_and_print(outf, base_level + 2, header, value); 281 } 282 283 if (fact_avx & 0x04) { 284 snprintf(header, sizeof(header), 285 "high-priority-max-avx512-frequency(MHz)"); 286 snprintf(value, sizeof(value), "%d", 287 bucket_info[j].avx512_trl * 288 DISP_FREQ_MULTIPLIER); 289 format_and_print(outf, base_level + 2, header, value); 290 } 291 } 292 snprintf(header, sizeof(header), 293 "speed-select-turbo-freq-clip-frequencies"); 294 format_and_print(outf, base_level + 1, header, NULL); 295 snprintf(header, sizeof(header), "low-priority-max-frequency(MHz)"); 296 snprintf(value, sizeof(value), "%d", 297 fact_info->lp_clipping_ratio_license_sse * 298 DISP_FREQ_MULTIPLIER); 299 format_and_print(outf, base_level + 2, header, value); 300 snprintf(header, sizeof(header), 301 "low-priority-max-avx2-frequency(MHz)"); 302 snprintf(value, sizeof(value), "%d", 303 fact_info->lp_clipping_ratio_license_avx2 * 304 DISP_FREQ_MULTIPLIER); 305 format_and_print(outf, base_level + 2, header, value); 306 snprintf(header, sizeof(header), 307 "low-priority-max-avx512-frequency(MHz)"); 308 snprintf(value, sizeof(value), "%d", 309 fact_info->lp_clipping_ratio_license_avx512 * 310 DISP_FREQ_MULTIPLIER); 311 format_and_print(outf, base_level + 2, header, value); 312 } 313 314 void isst_ctdp_display_core_info(int cpu, FILE *outf, char *prefix, 315 unsigned int val, char *str0, char *str1) 316 { 317 char header[256]; 318 char value[256]; 319 int level = 1; 320 321 if (out_format_is_json()) { 322 snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d", 323 get_physical_package_id(cpu), get_physical_die_id(cpu), 324 cpu); 325 format_and_print(outf, level++, header, NULL); 326 } else { 327 snprintf(header, sizeof(header), "package-%d", 328 get_physical_package_id(cpu)); 329 format_and_print(outf, level++, header, NULL); 330 snprintf(header, sizeof(header), "die-%d", 331 get_physical_die_id(cpu)); 332 format_and_print(outf, level++, header, NULL); 333 snprintf(header, sizeof(header), "cpu-%d", cpu); 334 format_and_print(outf, level++, header, NULL); 335 } 336 337 if (str0 && !val) 338 snprintf(value, sizeof(value), "%s", str0); 339 else if (str1 && val) 340 snprintf(value, sizeof(value), "%s", str1); 341 else 342 snprintf(value, sizeof(value), "%u", val); 343 format_and_print(outf, level, prefix, value); 344 345 format_and_print(outf, 1, NULL, NULL); 346 } 347 348 void isst_ctdp_display_information(int cpu, FILE *outf, int tdp_level, 349 struct isst_pkg_ctdp *pkg_dev) 350 { 351 char header[256]; 352 char value[256]; 353 static int level; 354 int i; 355 356 if (pkg_dev->processed) 357 level = print_package_info(cpu, outf); 358 359 for (i = 0; i <= pkg_dev->levels; ++i) { 360 struct isst_pkg_ctdp_level_info *ctdp_level; 361 int j; 362 363 ctdp_level = &pkg_dev->ctdp_level[i]; 364 if (!ctdp_level->processed) 365 continue; 366 367 snprintf(header, sizeof(header), "perf-profile-level-%d", 368 ctdp_level->level); 369 format_and_print(outf, level + 1, header, NULL); 370 371 snprintf(header, sizeof(header), "cpu-count"); 372 j = get_cpu_count(get_physical_die_id(cpu), 373 get_physical_die_id(cpu)); 374 snprintf(value, sizeof(value), "%d", j); 375 format_and_print(outf, level + 2, header, value); 376 377 j = CPU_COUNT_S(ctdp_level->core_cpumask_size, 378 ctdp_level->core_cpumask); 379 if (j) { 380 snprintf(header, sizeof(header), "enable-cpu-count"); 381 snprintf(value, sizeof(value), "%d", j); 382 format_and_print(outf, level + 2, header, value); 383 } 384 385 if (ctdp_level->core_cpumask_size) { 386 snprintf(header, sizeof(header), "enable-cpu-mask"); 387 printcpumask(sizeof(value), value, 388 ctdp_level->core_cpumask_size, 389 ctdp_level->core_cpumask); 390 format_and_print(outf, level + 2, header, value); 391 392 snprintf(header, sizeof(header), "enable-cpu-list"); 393 printcpulist(sizeof(value), value, 394 ctdp_level->core_cpumask_size, 395 ctdp_level->core_cpumask); 396 format_and_print(outf, level + 2, header, value); 397 } 398 399 snprintf(header, sizeof(header), "thermal-design-power-ratio"); 400 snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio); 401 format_and_print(outf, level + 2, header, value); 402 403 snprintf(header, sizeof(header), "base-frequency(MHz)"); 404 if (!ctdp_level->sse_p1) 405 ctdp_level->sse_p1 = ctdp_level->tdp_ratio; 406 snprintf(value, sizeof(value), "%d", 407 ctdp_level->sse_p1 * DISP_FREQ_MULTIPLIER); 408 format_and_print(outf, level + 2, header, value); 409 410 if (ctdp_level->avx2_p1) { 411 snprintf(header, sizeof(header), "base-frequency-avx2(MHz)"); 412 snprintf(value, sizeof(value), "%d", 413 ctdp_level->avx2_p1 * DISP_FREQ_MULTIPLIER); 414 format_and_print(outf, level + 2, header, value); 415 } 416 417 if (ctdp_level->avx512_p1) { 418 snprintf(header, sizeof(header), "base-frequency-avx512(MHz)"); 419 snprintf(value, sizeof(value), "%d", 420 ctdp_level->avx512_p1 * DISP_FREQ_MULTIPLIER); 421 format_and_print(outf, level + 2, header, value); 422 } 423 424 if (ctdp_level->uncore_p1) { 425 snprintf(header, sizeof(header), "uncore-frequency-min(MHz)"); 426 snprintf(value, sizeof(value), "%d", 427 ctdp_level->uncore_p1 * DISP_FREQ_MULTIPLIER); 428 format_and_print(outf, level + 2, header, value); 429 } 430 431 if (ctdp_level->uncore_p0) { 432 snprintf(header, sizeof(header), "uncore-frequency-max(MHz)"); 433 snprintf(value, sizeof(value), "%d", 434 ctdp_level->uncore_p0 * DISP_FREQ_MULTIPLIER); 435 format_and_print(outf, level + 2, header, value); 436 } 437 438 if (ctdp_level->mem_freq) { 439 snprintf(header, sizeof(header), "mem-frequency(MHz)"); 440 snprintf(value, sizeof(value), "%d", 441 ctdp_level->mem_freq * DISP_FREQ_MULTIPLIER); 442 format_and_print(outf, level + 2, header, value); 443 } 444 445 snprintf(header, sizeof(header), 446 "speed-select-turbo-freq"); 447 if (ctdp_level->fact_support) { 448 if (ctdp_level->fact_enabled) 449 snprintf(value, sizeof(value), "enabled"); 450 else 451 snprintf(value, sizeof(value), "disabled"); 452 } else 453 snprintf(value, sizeof(value), "unsupported"); 454 format_and_print(outf, level + 2, header, value); 455 456 snprintf(header, sizeof(header), 457 "speed-select-base-freq"); 458 if (ctdp_level->pbf_support) { 459 if (ctdp_level->pbf_enabled) 460 snprintf(value, sizeof(value), "enabled"); 461 else 462 snprintf(value, sizeof(value), "disabled"); 463 } else 464 snprintf(value, sizeof(value), "unsupported"); 465 format_and_print(outf, level + 2, header, value); 466 467 snprintf(header, sizeof(header), 468 "speed-select-core-power"); 469 if (ctdp_level->sst_cp_support) { 470 if (ctdp_level->sst_cp_enabled) 471 snprintf(value, sizeof(value), "enabled"); 472 else 473 snprintf(value, sizeof(value), "disabled"); 474 } else 475 snprintf(value, sizeof(value), "unsupported"); 476 format_and_print(outf, level + 2, header, value); 477 478 if (is_clx_n_platform()) { 479 if (ctdp_level->pbf_support) 480 _isst_pbf_display_information(cpu, outf, 481 tdp_level, 482 &ctdp_level->pbf_info, 483 level + 2); 484 continue; 485 } 486 487 if (ctdp_level->pkg_tdp) { 488 snprintf(header, sizeof(header), "thermal-design-power(W)"); 489 snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp); 490 format_and_print(outf, level + 2, header, value); 491 } 492 493 if (ctdp_level->t_proc_hot) { 494 snprintf(header, sizeof(header), "tjunction-max(C)"); 495 snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot); 496 format_and_print(outf, level + 2, header, value); 497 } 498 499 snprintf(header, sizeof(header), "turbo-ratio-limits-sse"); 500 format_and_print(outf, level + 2, header, NULL); 501 for (j = 0; j < 8; ++j) { 502 snprintf(header, sizeof(header), "bucket-%d", j); 503 format_and_print(outf, level + 3, header, NULL); 504 505 snprintf(header, sizeof(header), "core-count"); 506 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff); 507 format_and_print(outf, level + 4, header, value); 508 509 snprintf(header, sizeof(header), 510 "max-turbo-frequency(MHz)"); 511 snprintf(value, sizeof(value), "%d", 512 ctdp_level->trl_sse_active_cores[j] * 513 DISP_FREQ_MULTIPLIER); 514 format_and_print(outf, level + 4, header, value); 515 } 516 517 if (ctdp_level->trl_avx_active_cores[0]) { 518 snprintf(header, sizeof(header), "turbo-ratio-limits-avx2"); 519 format_and_print(outf, level + 2, header, NULL); 520 for (j = 0; j < 8; ++j) { 521 snprintf(header, sizeof(header), "bucket-%d", j); 522 format_and_print(outf, level + 3, header, NULL); 523 524 snprintf(header, sizeof(header), "core-count"); 525 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff); 526 format_and_print(outf, level + 4, header, value); 527 528 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)"); 529 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_active_cores[j] * DISP_FREQ_MULTIPLIER); 530 format_and_print(outf, level + 4, header, value); 531 } 532 } 533 534 if (ctdp_level->trl_avx_512_active_cores[0]) { 535 snprintf(header, sizeof(header), "turbo-ratio-limits-avx512"); 536 format_and_print(outf, level + 2, header, NULL); 537 for (j = 0; j < 8; ++j) { 538 snprintf(header, sizeof(header), "bucket-%d", j); 539 format_and_print(outf, level + 3, header, NULL); 540 541 snprintf(header, sizeof(header), "core-count"); 542 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff); 543 format_and_print(outf, level + 4, header, value); 544 545 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)"); 546 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_512_active_cores[j] * DISP_FREQ_MULTIPLIER); 547 format_and_print(outf, level + 4, header, value); 548 } 549 } 550 551 if (ctdp_level->pbf_support) 552 _isst_pbf_display_information(cpu, outf, i, 553 &ctdp_level->pbf_info, 554 level + 2); 555 if (ctdp_level->fact_support) 556 _isst_fact_display_information(cpu, outf, i, 0xff, 0xff, 557 &ctdp_level->fact_info, 558 level + 2); 559 } 560 561 format_and_print(outf, 1, NULL, NULL); 562 } 563 564 static int start; 565 void isst_ctdp_display_information_start(FILE *outf) 566 { 567 last_level = 0; 568 format_and_print(outf, 0, "start", NULL); 569 start = 1; 570 } 571 572 void isst_ctdp_display_information_end(FILE *outf) 573 { 574 format_and_print(outf, 0, NULL, NULL); 575 start = 0; 576 } 577 578 void isst_pbf_display_information(int cpu, FILE *outf, int level, 579 struct isst_pbf_info *pbf_info) 580 { 581 int _level; 582 583 _level = print_package_info(cpu, outf); 584 _isst_pbf_display_information(cpu, outf, level, pbf_info, _level + 1); 585 format_and_print(outf, 1, NULL, NULL); 586 } 587 588 void isst_fact_display_information(int cpu, FILE *outf, int level, 589 int fact_bucket, int fact_avx, 590 struct isst_fact_info *fact_info) 591 { 592 int _level; 593 594 _level = print_package_info(cpu, outf); 595 _isst_fact_display_information(cpu, outf, level, fact_bucket, fact_avx, 596 fact_info, _level + 1); 597 format_and_print(outf, 1, NULL, NULL); 598 } 599 600 void isst_clos_display_information(int cpu, FILE *outf, int clos, 601 struct isst_clos_config *clos_config) 602 { 603 char header[256]; 604 char value[256]; 605 int level; 606 607 level = print_package_info(cpu, outf); 608 609 snprintf(header, sizeof(header), "core-power"); 610 format_and_print(outf, level + 1, header, NULL); 611 612 snprintf(header, sizeof(header), "clos"); 613 snprintf(value, sizeof(value), "%d", clos); 614 format_and_print(outf, level + 2, header, value); 615 616 snprintf(header, sizeof(header), "epp"); 617 snprintf(value, sizeof(value), "%d", clos_config->epp); 618 format_and_print(outf, level + 2, header, value); 619 620 snprintf(header, sizeof(header), "clos-proportional-priority"); 621 snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio); 622 format_and_print(outf, level + 2, header, value); 623 624 snprintf(header, sizeof(header), "clos-min"); 625 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * DISP_FREQ_MULTIPLIER); 626 format_and_print(outf, level + 2, header, value); 627 628 snprintf(header, sizeof(header), "clos-max"); 629 if (clos_config->clos_max == 0xff) 630 snprintf(value, sizeof(value), "Max Turbo frequency"); 631 else 632 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * DISP_FREQ_MULTIPLIER); 633 format_and_print(outf, level + 2, header, value); 634 635 snprintf(header, sizeof(header), "clos-desired"); 636 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * DISP_FREQ_MULTIPLIER); 637 format_and_print(outf, level + 2, header, value); 638 639 format_and_print(outf, level, NULL, NULL); 640 } 641 642 void isst_clos_display_clos_information(int cpu, FILE *outf, 643 int clos_enable, int type, 644 int state, int cap) 645 { 646 char header[256]; 647 char value[256]; 648 int level; 649 650 level = print_package_info(cpu, outf); 651 652 snprintf(header, sizeof(header), "core-power"); 653 format_and_print(outf, level + 1, header, NULL); 654 655 snprintf(header, sizeof(header), "support-status"); 656 if (cap) 657 snprintf(value, sizeof(value), "supported"); 658 else 659 snprintf(value, sizeof(value), "unsupported"); 660 format_and_print(outf, level + 2, header, value); 661 662 snprintf(header, sizeof(header), "enable-status"); 663 if (state) 664 snprintf(value, sizeof(value), "enabled"); 665 else 666 snprintf(value, sizeof(value), "disabled"); 667 format_and_print(outf, level + 2, header, value); 668 669 snprintf(header, sizeof(header), "clos-enable-status"); 670 if (clos_enable) 671 snprintf(value, sizeof(value), "enabled"); 672 else 673 snprintf(value, sizeof(value), "disabled"); 674 format_and_print(outf, level + 2, header, value); 675 676 snprintf(header, sizeof(header), "priority-type"); 677 if (type) 678 snprintf(value, sizeof(value), "ordered"); 679 else 680 snprintf(value, sizeof(value), "proportional"); 681 format_and_print(outf, level + 2, header, value); 682 683 format_and_print(outf, level, NULL, NULL); 684 } 685 686 void isst_clos_display_assoc_information(int cpu, FILE *outf, int clos) 687 { 688 char header[256]; 689 char value[256]; 690 int level; 691 692 level = print_package_info(cpu, outf); 693 694 snprintf(header, sizeof(header), "get-assoc"); 695 format_and_print(outf, level + 1, header, NULL); 696 697 snprintf(header, sizeof(header), "clos"); 698 snprintf(value, sizeof(value), "%d", clos); 699 format_and_print(outf, level + 2, header, value); 700 701 format_and_print(outf, level, NULL, NULL); 702 } 703 704 void isst_display_result(int cpu, FILE *outf, char *feature, char *cmd, 705 int result) 706 { 707 char header[256]; 708 char value[256]; 709 int level = 3; 710 711 if (cpu >= 0) 712 level = print_package_info(cpu, outf); 713 714 snprintf(header, sizeof(header), "%s", feature); 715 format_and_print(outf, level + 1, header, NULL); 716 snprintf(header, sizeof(header), "%s", cmd); 717 if (!result) 718 snprintf(value, sizeof(value), "success"); 719 else 720 snprintf(value, sizeof(value), "failed(error %d)", result); 721 format_and_print(outf, level + 2, header, value); 722 723 format_and_print(outf, level, NULL, NULL); 724 } 725 726 void isst_display_error_info_message(int error, char *msg, int arg_valid, int arg) 727 { 728 FILE *outf = get_output_file(); 729 static int error_index; 730 char header[256]; 731 char value[256]; 732 733 if (!out_format_is_json()) { 734 if (arg_valid) 735 snprintf(value, sizeof(value), "%s %d", msg, arg); 736 else 737 snprintf(value, sizeof(value), "%s", msg); 738 739 if (error) 740 fprintf(outf, "Error: %s\n", value); 741 else 742 fprintf(outf, "Information: %s\n", value); 743 return; 744 } 745 746 if (!start) 747 format_and_print(outf, 0, "start", NULL); 748 749 if (error) 750 snprintf(header, sizeof(header), "Error%d", error_index++); 751 else 752 snprintf(header, sizeof(header), "Information:%d", error_index++); 753 format_and_print(outf, 1, header, NULL); 754 755 snprintf(header, sizeof(header), "message"); 756 if (arg_valid) 757 snprintf(value, sizeof(value), "%s %d", msg, arg); 758 else 759 snprintf(value, sizeof(value), "%s", msg); 760 761 format_and_print(outf, 2, header, value); 762 format_and_print(outf, 1, NULL, NULL); 763 if (!start) 764 format_and_print(outf, 0, NULL, NULL); 765 } 766