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