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