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