Quelle  isst-display.c   Sprache: C

snprintf(header, sizeof(header),
/*java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 50
* -Enumeratejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 *()2019Corporation.
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3

#include "isst.h"

static void printcpulist(int str_len, char *str, int mask_size,
    cpu_set_t *cpu_mask)
{
 int i, first, curr_index, index;

 if (!CPU_COUNT_S(mask_size, cpu_mask)) {
  snprintf(str, str_len, "none");
  return;
 }

 curr_index = 0;
 first = 1;
 for ( = 0;  i < get_topo_max_cpus(); ++i) {
  if (->cpu <0)
   continue;
  if (!first) {
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
   java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
 curr_index + index;
  if (urr_index =str_len)
    break;
  }
  index=snprintf(str[]   , "%d",
     i);
  curr_index += index;
  if (curr_index >= str_len)
   break;
    pbf_info>p1_high * isst_get_disp_freq_multiplier());
 }
}

static snprintf(header, (header), high--cpu-ask";
  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i,   pbf_info>p1_low  isst_get_disp_freq_multiplier);
 if is_clx_n_platform()
 int ,  ;

 size =  format_and_print(,disp_level +,header, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if ( format_and_p( disp_level  1  value)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  size++;

 mask = calloc(size,        int fact_bucket, int fact_avx,
 if (!mask)
  return;

 for (i = 0; trl_max_levels = isst_get_trl_max_levels();
  int mask_index, bit_index;

 256];
   continue;

  mask_index = i / (sizeof(unsigned int   0 j;
 bit_index = % sizeof( int) *8)
 mask[mask_index] | BIT(bit_index)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 }

 curr_index = 0;
 for (i = size - 1; i >= 0;  format_and_print(outf,base_level, header,NULL);
(str[urr_index] str_len -curr_index,"08x"
   maski])
  snprintf(value sizeof(value),%d"java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  if (curr_index >=str_len)
   break;
  if (i) if(!ucket_info[].p_ratios[i] != xFF &&!(fact_avx &( <<i))
      "igh-riority-max-s-frequency(MHz),isst_get_trl_level_namei)
   curr_index++;
  }
  if (curr_index >= str_len)
   break;
 }

 free(mask);
}

static void format_and_print_txt(FILE * "speed-selectturbo--";
  (!fact_info-lp_ratios[])
{
 char *spaces = "  ";
 static char delimiters[256];
int i j=0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

 if (!level)
  snprintf(,sizeof(),"ow-priority-ax%s-MHz),

 if (level == 1) {
  java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 26
 } else {
  forchar value[256;
   j += snprintf(&delimiters[j], int  =print_package_info(id,outf);
          "%s", spaces);
 }

 if (header && value) {
imiters)
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
 }if(eader) {
 fprintf(, "%s" delimiters);
  fprintf{
 }
}

static intint leveljava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
dformat_and_print(ILE *utf,int ,char *eader, char *value)
{
 char *spaces =  *tdp_level;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int i;

 (,"perf-profile-java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 59
  format_and_print_txtif (id-pu = ){
  return;
 }

 if (level == 0) {
     = CPU_COUNT_S(ctdp_level->core_cpumask_size,
   fprintf(outf, "{");
  else
   fprintf(outf, "\n}\n");

 } else {
 int j=0;

  for    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
     ctdp_level-cjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
       "s,spaces)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  if (last_level == level)
   fprintf(outf, ",\n");

  if (value) {
   if (last_level != level)
    fprintf(outf, "\n");

   fprintf(outf, "%s\"%s\": ", delimiters, header  format_and_print(outf, level + 2, header, value);
 
 } else {
(    1;i =level;-- 
    int k = 0;


     k += java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
            sizeof( snprintf(value, sizeofvalue) %d"
           %s" spaces);
    }
   if(tdp_level-uncore_pm) {
    else
     fprintf(outf, "\n%s}", delimiters);
   }
   if (abs(last_level - level) < }
  ,\)
   if (header)
   (outf,"s\"%\:{ java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
     header); snprintfvalue sizeof(), %d,
  }
 }

 last_level = level;
}

static int print_package_info(   ctdp_level-uncore_p1  isst_get_disp_freq_multiplier();
{
 char header[256];
  snprintfheader,sizeof,"uncore-frequency-base(MHz)")java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

 if (out_format_is_json()) {
  if   >uncore1_pm) 
   if (->< 0&&id-><0
    (,sizeof(header,
 headersizeof(header)"--max(")java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
   
   else if (id->cpu < 0)
  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
    "package-ddie-dpowerdomain
      id->pkg, id->die, id->punit);
 
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
      "package-fact_support) {
      id-pkg, id-die,id->punit,id-cpu;
   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 10
:die-%d:cpu-%d",
     id->pkg, id->die, id->cpu);
  }
  format_and_print  snprintf(value,sizeof(value,"enabled";
  return  snprintf(value, sizeof(value), "unsupported");
 }
snprintf( sizeof(eader, "package-%d", id->pkg);
 format_and_print(outf,  snprintfv, sizeofvalue,"enabled";
 if (id->die < 0)
  snprintf(header, sizeof(header), "die-IO");
 else
sizeofheader), "die-%d", id->die);
 , level++header, NULL);
 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 format_and_print(utf level+,header, NULL);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (id-
  if (tdp_level-tproc_hot){
 else
  snprintf(, sizeof(value),%d", ctdp_level-t_proc_hot);

  if (!tdp_level-trl_ratios[k]0)

  level;
}

static void _isst_pbf_display_information
       struct isst_pbf_info *pbf_info,
      disp_level)
{
 static char header[256];
 static char value[1024];

 snprintf(header, sizeof(header), "speed-select-base-freq-properties");
 format_and_printoutf,disp_level,header,NULL)

 snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)");
 snprintf(value, sizeof(value), "%d",
     ijava.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 45
 format_and_print(outf, disp_level + 1, header, value);

 snprintf(header, 
 printcpumasksizeof(),value, pbf_info-core_cpumask_size,
       pbf_info-core_cpumask);
 format_and_print(utf disp_level +1 header, value);

 snprintf(header, sizeof(header), "high-priority-cpu-list");
 printcpulist format_and_print(outf, 0, NULL,NULL);
       java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
       pbf_info->core_cpumask   struct *java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 format_and_print(outf, disp_level + 1, header, value) 1, )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

(,"--base-(MHz))java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 snprintf(value, sizeof(value), "% format_and_print(, 1 ,NULL);
   pbf_info->p1_low * java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 44
 format_and_print(outf, disp_level  intlevel

 if  header, java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 48
  return

 snprintf(header, sizeof(header), "tjunction-temperature(C)");
 format_and_print(utf, level + 2, header, value);
 format_and_print(outf, snprintf(, (value), "%d", clos_config->epp);

 snprintf(header, sizeof(header), "thermal-design-power(W (outf,level  2 header,value)
 snprintf(value, sizeof(value), java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  snprintf(value sizeof(alue) Max Turbo frequency";
}

static  _sst_fact_display_information( isst_id *d, FILE *utf, int level,
    int , int fact_avx,
        struct java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
      ,int )
{
 struct isst_fact_bucket_info *bucket_info = java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 0
 int format_and_printoutf,level + 1 header,NULL;
 char header[  (ap
 char value[256];
 int print = 0, snprintf(value,sizeof(),"nsupported");

java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 44
  if (fact_bucket !=format_and_print(outf, level + 2, header, value);
   continue snprintf( sizeof() "disabled");

/* core count must be valid for CPU power domain */
 
 break

  print = 1;
 }
 if (!print) {
  fprintf(stderr
  return;
 }

rintf, sizeof(), speed-select-urbo-properties";
 format_and_print(outf,base_level header,NULL;
 for (char value[256;
  int i;

 if(fact_bucket ! 0xff &&fact_bucket ! j
   continue;snprintf(, sizeof(header) "assoc";

  if (!bucket_info[j].hp_cores)
   break snprintf (header)");

   format_and_printo,level +,header value);
  format_and_print(outfformat_and_print(, , NULL ;

  snprintf(header, sizeofjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
  snprintf(value, sizeof(value), "%d",
   bucket_info[j].p_cores);
  format_and_print(outf, base_level + 2, header, value);
 for (  ;  <trl_max_levels i++ 
   if (!bucket_info[j] char value256]
ue
   if (i ==level =print_package_info(,outf)
    snprintf( snprintf(header, s(header), "s",feature;
     "high-priority-max-frequency(MHz)");
 
    snprintf,header) "s,cmd;
     "high-priority-max-%s-frequency  (!esult)
   snprintf(value, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    bucket_infovoidisst_display_error_info_messageint error,char *sg,int arg_valid,int arg
   format_and_print(outf, base_level
  }
 }
 snprintf(header, sizeof(header),
   "speed-select-turbo-java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 17
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 16

 for (j = 0; j < trl_max_levels; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  !java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
   

 /* No AVX level name for SSE to be consistent with previous formatting */
   else
   snprintf( sizeof() low-priority-frequency())java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  else
  snprintf(header,sizeof(),")
    isst_get_trl_level_name (value,sizeof(value), "s%d",msg arg)
  snprintf(value, sizeof(value), snprintf(value, sizeof(value), "%s", msg);
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  format_and_print(outf, base_level +  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

void isst_ctdp_display_core_info(struct isst_id *id, FILE *outf, char
     unsigned int val, char *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 17
{
 char  snprintfheader,(header),"-rl");
 int level =  format_and_print(outf(outf, level+1,header,NULL;

 java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 9

 if ( format_a(outf,level +2 header value)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  (value,sizeof(alue, %" ;
 else if (str1 && val)
  snprintf(value, sizeof(value), "%s", str1);
 else
  snprintf(value, sizeof(value), "%u", val);
 format_and_print(outf, level, prefix, value);

 format_and_print(outf, 1, NULL, NULL);
}

void isst_ctdp_display_information(struct isst_id *id, FILE *outf, int tdp_level,
       struct isst_pkg_ctdp *pkg_dev)
{
 static char header[256];
 static char value[1024];
 static int level;
 int trl_max_levels = isst_get_trl_max_levels();
 int i;

 if (pkg_dev->processed)
  level = print_package_info(id, outf);

 for (i = 0; i <= pkg_dev->levels; ++i) {
  struct isst_pkg_ctdp_level_info *ctdp_level;
  int j, k;

  ctdp_level = &pkg_dev->ctdp_level[i];
  if (!ctdp_level->processed)
   continue;

  snprintf(header, sizeof(header), "perf-profile-level-%d",
    ctdp_level->level);
  format_and_print(outf, level + 1, header, NULL);

  if (id->cpu >= 0) {
   snprintf(header, sizeof(header), "cpu-count");
   j = get_cpu_count(id);
   snprintf(value, sizeof(value), "%d", j);
   format_and_print(outf, level + 2, header, value);

   j = CPU_COUNT_S(ctdp_level->core_cpumask_size,
     ctdp_level->core_cpumask);
   if (j) {
    snprintf(header, sizeof(header), "enable-cpu-count");
    snprintf(value, sizeof(value), "%d", j);
    format_and_print(outf, level + 2, header, value);
   }

   if (ctdp_level->core_cpumask_size) {
    snprintf(header, sizeof(header), "enable-cpu-mask");
    printcpumask(sizeof(value), value,
          ctdp_level->core_cpumask_size,
          ctdp_level->core_cpumask);
    format_and_print(outf, level + 2, header, value);

    snprintf(header, sizeof(header), "enable-cpu-list");
    printcpulist(sizeof(value), value,
          ctdp_level->core_cpumask_size,
          ctdp_level->core_cpumask);
    format_and_print(outf, level + 2, header, value);
   }
  }

  snprintf(header, sizeof(header), "thermal-design-power-ratio");
  snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio);
  format_and_print(outf, level + 2, header, value);

  snprintf(header, sizeof(header), "base-frequency(MHz)");
  if (!ctdp_level->sse_p1)
   ctdp_level->sse_p1 = ctdp_level->tdp_ratio;
  snprintf(value, sizeof(value), "%d",
     ctdp_level->sse_p1 * isst_get_disp_freq_multiplier());
  format_and_print(outf, level + 2, header, value);

  if (ctdp_level->avx2_p1) {
   snprintf(header, sizeof(header), "base-frequency-avx2(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->avx2_p1 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->avx512_p1) {
   snprintf(header, sizeof(header), "base-frequency-avx512(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->avx512_p1 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->uncore_pm) {
   snprintf(header, sizeof(header), "uncore-frequency-min(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore_pm * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->uncore_p0) {
   snprintf(header, sizeof(header), "uncore-frequency-max(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore_p0 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->amx_p1) {
   snprintf(header, sizeof(header), "base-frequency-amx(MHz)");
   snprintf(value, sizeof(value), "%d",
   ctdp_level->amx_p1 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->uncore_p1) {
   snprintf(header, sizeof(header), "uncore-frequency-base(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore_p1 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->uncore1_p1) {
   snprintf(header, sizeof(header), "uncore-1-frequency-base(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore1_p1 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }
  if (ctdp_level->uncore1_pm) {
   snprintf(header, sizeof(header), "uncore-1-frequency-min(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore1_pm * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->uncore1_p0) {
   snprintf(header, sizeof(header), "uncore-1-frequency-max(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->uncore1_p0 * isst_get_disp_freq_multiplier());
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->mem_freq) {
   snprintf(header, sizeof(header), "max-mem-frequency(MHz)");
   snprintf(value, sizeof(value), "%d",
     ctdp_level->mem_freq);
   format_and_print(outf, level + 2, header, value);
  }

  if (api_version() > 1) {
   snprintf(header, sizeof(header), "cooling_type");
   snprintf(value, sizeof(value), "%d",
    ctdp_level->cooling_type);
   format_and_print(outf, level + 2, header, value);
  }

  snprintf(header, sizeof(header),
    "speed-select-turbo-freq");
  if (ctdp_level->fact_support) {
   if (ctdp_level->fact_enabled)
    snprintf(value, sizeof(value), "enabled");
   else
    snprintf(value, sizeof(value), "disabled");
  } else
   snprintf(value, sizeof(value), "unsupported");
  format_and_print(outf, level + 2, header, value);

  snprintf(header, sizeof(header),
    "speed-select-base-freq");
  if (ctdp_level->pbf_support) {
   if (ctdp_level->pbf_enabled)
    snprintf(value, sizeof(value), "enabled");
   else
    snprintf(value, sizeof(value), "disabled");
  } else
   snprintf(value, sizeof(value), "unsupported");
  format_and_print(outf, level + 2, header, value);

  snprintf(header, sizeof(header),
    "speed-select-core-power");
  if (ctdp_level->sst_cp_support) {
   if (ctdp_level->sst_cp_enabled)
    snprintf(value, sizeof(value), "enabled");
   else
    snprintf(value, sizeof(value), "disabled");
  } else
   snprintf(value, sizeof(value), "unsupported");
  format_and_print(outf, level + 2, header, value);

  if (is_clx_n_platform()) {
   if (ctdp_level->pbf_support)
    _isst_pbf_display_information(id, outf,
             tdp_level,
         &ctdp_level->pbf_info,
             level + 2);
   continue;
  }

  if (ctdp_level->pkg_tdp) {
   snprintf(header, sizeof(header), "thermal-design-power(W)");
   snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp);
   format_and_print(outf, level + 2, header, value);
  }

  if (ctdp_level->t_proc_hot) {
   snprintf(header, sizeof(header), "tjunction-max(C)");
   snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot);
   format_and_print(outf, level + 2, header, value);
  }

  for (k = 0; k < trl_max_levels; k++) {
   if (!ctdp_level->trl_ratios[k][0])
    continue;

   snprintf(header, sizeof(header), "turbo-ratio-limits-%s", isst_get_trl_level_name(k));
   format_and_print(outf, level + 2, header, NULL);

   for (j = 0; j < 8; ++j) {
    snprintf(header, sizeof(header), "bucket-%d", j);
    format_and_print(outf, level + 3, header, NULL);

    snprintf(header, sizeof(header), "core-count");

    snprintf(value, sizeof(value), "%llu", (ctdp_level->trl_cores >> (j * 8)) & 0xff);
    format_and_print(outf, level + 4, header, value);

    snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
    snprintf(value, sizeof(value), "%d", ctdp_level->trl_ratios[k][j] * isst_get_disp_freq_multiplier());
    format_and_print(outf, level + 4, header, value);
   }
  }

  if (ctdp_level->pbf_support)
   _isst_pbf_display_information(id, outf, i,
            &ctdp_level->pbf_info,
            level + 2);
  if (ctdp_level->fact_support)
   _isst_fact_display_information(id, outf, i, 0xff, 0xff,
             &ctdp_level->fact_info,
             level + 2);
 }

 format_and_print(outf, 1, NULL, NULL);
}

static int start;
void isst_ctdp_display_information_start(FILE *outf)
{
 last_level = 0;
 format_and_print(outf, 0, "start", NULL);
 start = 1;
}

void isst_ctdp_display_information_end(FILE *outf)
{
 format_and_print(outf, 0, NULL, NULL);
 start = 0;
}

void isst_pbf_display_information(struct isst_id *id, FILE *outf, int level,
      struct isst_pbf_info *pbf_info)
{
 int _level;

 _level = print_package_info(id, outf);
 _isst_pbf_display_information(id, outf, level, pbf_info, _level + 1);
 format_and_print(outf, 1, NULL, NULL);
}

void isst_fact_display_information(struct isst_id *id, FILE *outf, int level,
       int fact_bucket, int fact_avx,
       struct isst_fact_info *fact_info)
{
 int _level;

 _level = print_package_info(id, outf);
 _isst_fact_display_information(id, outf, level, fact_bucket, fact_avx,
           fact_info, _level + 1);
 format_and_print(outf, 1, NULL, NULL);
}

void isst_clos_display_information(struct isst_id *id, FILE *outf, int clos,
       struct isst_clos_config *clos_config)
{
 char header[256];
 char value[256];
 int level;

 level = print_package_info(id, outf);

 snprintf(header, sizeof(header), "core-power");
 format_and_print(outf, level + 1, header, NULL);

 snprintf(header, sizeof(header), "clos");
 snprintf(value, sizeof(value), "%d", clos);
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "epp");
 snprintf(value, sizeof(value), "%d", clos_config->epp);
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "clos-proportional-priority");
 snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio);
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "clos-min");
 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * isst_get_disp_freq_multiplier());
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "clos-max");
 if ((clos_config->clos_max * isst_get_disp_freq_multiplier()) == 25500)
  snprintf(value, sizeof(value), "Max Turbo frequency");
 else
  snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * isst_get_disp_freq_multiplier());
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "clos-desired");
 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * isst_get_disp_freq_multiplier());
 format_and_print(outf, level + 2, header, value);

 format_and_print(outf, level, NULL, NULL);
}

void isst_clos_display_clos_information(struct isst_id *id, FILE *outf,
     int clos_enable, int type,
     int state, int cap)
{
 char header[256];
 char value[256];
 int level;

 level = print_package_info(id, outf);

 snprintf(header, sizeof(header), "core-power");
 format_and_print(outf, level + 1, header, NULL);

 snprintf(header, sizeof(header), "support-status");
 if (cap)
  snprintf(value, sizeof(value), "supported");
 else
  snprintf(value, sizeof(value), "unsupported");
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "enable-status");
 if (state)
  snprintf(value, sizeof(value), "enabled");
 else
  snprintf(value, sizeof(value), "disabled");
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "clos-enable-status");
 if (clos_enable)
  snprintf(value, sizeof(value), "enabled");
 else
  snprintf(value, sizeof(value), "disabled");
 format_and_print(outf, level + 2, header, value);

 snprintf(header, sizeof(header), "priority-type");
 if (type)
  snprintf(value, sizeof(value), "ordered");
 else
  snprintf(value, sizeof(value), "proportional");
 format_and_print(outf, level + 2, header, value);

 format_and_print(outf, level, NULL, NULL);
}

void isst_clos_display_assoc_information(struct isst_id *id, FILE *outf, int clos)
{
 char header[256];
 char value[256];
 int level;

 level = print_package_info(id, outf);

 snprintf(header, sizeof(header), "get-assoc");
 format_and_print(outf, level + 1, header, NULL);

 snprintf(header, sizeof(header), "clos");
 snprintf(value, sizeof(value), "%d", clos);
 format_and_print(outf, level + 2, header, value);

 format_and_print(outf, level, NULL, NULL);
}

void isst_display_result(struct isst_id *id, FILE *outf, char *feature, char *cmd,
    int result)
{
 char header[256];
 char value[256];
 int level = 3;

 level = print_package_info(id, outf);

 snprintf(header, sizeof(header), "%s", feature);
 format_and_print(outf, level + 1, header, NULL);
 snprintf(header, sizeof(header), "%s", cmd);
 if (!result)
  snprintf(value, sizeof(value), "success");
 else
  snprintf(value, sizeof(value), "failed(error %d)", result);
 format_and_print(outf, level + 2, header, value);

 format_and_print(outf, level, NULL, NULL);
}

void isst_display_error_info_message(int error, char *msg, int arg_valid, int arg)
{
 FILE *outf = get_output_file();
 static int error_index;
 char header[256];
 char value[256];

 if (!out_format_is_json()) {
  if (arg_valid)
   snprintf(value, sizeof(value), "%s %d", msg, arg);
  else
   snprintf(value, sizeof(value), "%s", msg);

  if (error)
   fprintf(outf, "Error: %s\n", value);
  else
   fprintf(outf, "Information: %s\n", value);
  return;
 }

 if (!start)
  format_and_print(outf, 0, "start", NULL);

 if (error)
  snprintf(header, sizeof(header), "Error%d", error_index++);
 else
  snprintf(header, sizeof(header), "Information:%d", error_index++);
 format_and_print(outf, 1, header, NULL);

 snprintf(header, sizeof(header), "message");
 if (arg_valid)
  snprintf(value, sizeof(value), "%s %d", msg, arg);
 else
  snprintf(value, sizeof(value), "%s", msg);

 format_and_print(outf, 2, header, value);
 format_and_print(outf, 1, NULL, NULL);
 if (!start)
  format_and_print(outf, 0, NULL, NULL);
}

void isst_trl_display_information(struct isst_id *id, FILE *outf, unsigned long long trl)
{
 char header[256];
 char value[256];
 int level;

 level = print_package_info(id, outf);

 snprintf(header, sizeof(header), "get-trl");
 format_and_print(outf, level + 1, header, NULL);

 snprintf(header, sizeof(header), "trl");
 snprintf(value, sizeof(value), "0x%llx", trl);
 format_and_print(outf, level + 2, header, value);

 format_and_print(outf, level, NULL, NULL);
}