ppc64_cpu: Fix handling of non-contiguous CPU IDs

In ppc64le environments, adding or removing CPUs dynamically through
DLPAR can create gaps in CPU IDs, such as `0-103,120-151`, in this
case CPUs 104-119 are missing.

ppc64_cpu doesn't handles this scenario and always considers CPU IDs
to be contiguous causing issues in core numbering, cpu info and SMT
mode reporting.

To illustrate the issues this patch fixes, consider the following
system configuration:

$ lscpu
Architecture:             ppc64le
Byte Order:               Little Endian
CPU(s):                   136
On-line CPU(s) list:      0-103,120-151

**Note: CPU IDs are non-contiguous**

-----------------------------------------------------------------
Before Patch:
-----------------------------------------------------------------

$ ppc64_cpu --info
Core   0:    0*    1*    2*    3*    4*    5*    6*    7*
Core   1:    8*    9*   10*   11*   12*   13*   14*   15*
Core   2:   16*   17*   18*   19*   20*   21*   22*   23*
Core   3:   24*   25*   26*   27*   28*   29*   30*   31*
Core   4:   32*   33*   34*   35*   36*   37*   38*   39*
Core   5:   40*   41*   42*   43*   44*   45*   46*   47*
Core   6:   48*   49*   50*   51*   52*   53*   54*   55*
Core   7:   56*   57*   58*   59*   60*   61*   62*   63*
Core   8:   64*   65*   66*   67*   68*   69*   70*   71*
Core   9:   72*   73*   74*   75*   76*   77*   78*   79*
Core  10:   80*   81*   82*   83*   84*   85*   86*   87*
Core  11:   88*   89*   90*   91*   92*   93*   94*   95*
Core  12:   96*   97*   98*   99*  100*  101*  102*  103*
........................................................... *gap*
Core  13:  120*  121*  122*  123*  124*  125*  126*  127*
Core  14:  128*  129*  130*  131*  132*  133*  134*  135*
Core  15:  136*  137*  138*  139*  140*  141*  142*  143*
Core  16:  144*  145*  146*  147*  148*  149*  150*  151*

**Although the CPU IDs are non contiguous, associated core IDs are
represented in contiguous order, which makes it harder to interpret
this clearly.**

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --cores-on
Number of cores online = 15

**Expected: Number of online cores = 17**
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --offline-cores
Cores offline = 13, 14

**Even though no cores are actually offline, two cores (13, 14)
are displayed as offline.**
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --online-cores
Cores online = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16

**The list of online cores is missing two cores (13, 14).**
-----------------------------------------------------------------

To resolve this, use the present CPU list from sysfs to assign
numbers to CPUs and cores, which will make this accurate.

$ cat /sys/devices/system/cpu/present
0-103,120-151

With this patch, the command output correctly reflects the
current CPU configuration, providing a more precise representation
of the system state.

-----------------------------------------------------------------
After Patch:
-----------------------------------------------------------------

$ ppc64_cpu --info
Core   0:    0*    1*    2*    3*    4*    5*    6*    7*
Core   1:    8*    9*   10*   11*   12*   13*   14*   15*
Core   2:   16*   17*   18*   19*   20*   21*   22*   23*
Core   3:   24*   25*   26*   27*   28*   29*   30*   31*
Core   4:   32*   33*   34*   35*   36*   37*   38*   39*
Core   5:   40*   41*   42*   43*   44*   45*   46*   47*
Core   6:   48*   49*   50*   51*   52*   53*   54*   55*
Core   7:   56*   57*   58*   59*   60*   61*   62*   63*
Core   8:   64*   65*   66*   67*   68*   69*   70*   71*
Core   9:   72*   73*   74*   75*   76*   77*   78*   79*
Core  10:   80*   81*   82*   83*   84*   85*   86*   87*
Core  11:   88*   89*   90*   91*   92*   93*   94*   95*
Core  12:   96*   97*   98*   99*  100*  101*  102*  103*
........................................................... *gap*
Core  15:  120*  121*  122*  123*  124*  125*  126*  127*
Core  16:  128*  129*  130*  131*  132*  133*  134*  135*
Core  17:  136*  137*  138*  139*  140*  141*  142*  143*
Core  18:  144*  145*  146*  147*  148*  149*  150*  151*

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --cores-on
Number of cores online = 17

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --offline-cores
Cores offline =

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

$ ppc64_cpu --online-cores
Cores online = 0,1,2,3,4,5,6,7,8,9,10,11,12,15,16,17,18

-----------------------------------------------------------------

Signed-off-by: Aboorva Devarajan <[email protected]>
Signed-off-by: Tyrel Datwyler <[email protected]>

Author: AboorvaDevarajan

src/common/cpu_info_helpers.c

@@ -311,67 +311,94 @@ int get_present_core_list(int **present_cores, int *num_present_cores, int threa
 }
 
 static void print_cpu_list(const cpu_set_t *cpuset, int cpuset_size,
-		           int cpus_in_system)
+		                   int threads_per_cpu)
 {
-	int core;
+	int *present_cores = NULL;
+	int num_present_cores;
+	int start, end, i = 0;
 	const char *comma = "";
 
-	for (core = 0; core < cpus_in_system; core++) {
-		int begin = core;
-		if (CPU_ISSET_S(core, cpuset_size, cpuset)) {
-			while (CPU_ISSET_S(core+1, cpuset_size, cpuset))
-				core++;
+	if (get_present_core_list(&present_cores, &num_present_cores, threads_per_cpu) != 0) {
+		fprintf(stderr, "Failed to get present_cores list\n");
+		return;
+	}
 
-			if (core > begin)
-				printf("%s%d-%d", comma, begin, core);
-			else
-				printf("%s%d", comma, core);
+	while (i < num_present_cores) {
+		start = present_cores[i];
+		if (CPU_ISSET_S(start, cpuset_size, cpuset)) {
+			end = start;
+			while (i + 1 < num_present_cores &&
+				   CPU_ISSET_S(present_cores[i + 1], cpuset_size, cpuset) &&
+				   present_cores[i + 1] == end + 1) {
+				end = present_cores[++i];
+			}
+			if (start == end) {
+				printf("%s%d", comma, start);
+			} else {
+				printf("%s%d-%d", comma, start, end);
+			}
 			comma = ",";
 		}
+		i++;
 	}
+	free(present_cores);
 }
 
-int __do_smt(bool numeric, int cpus_in_system, int threads_per_cpu,
-	     bool print_smt_state)
+int __do_smt(bool numeric, int cpus_in_system, int threads_per_cpu, bool print_smt_state)
 {
-	int thread, c, smt_state = 0;
 	cpu_set_t **cpu_states = NULL;
-	int cpu_state_size = CPU_ALLOC_SIZE(cpus_in_system);
-	int start_cpu = 0, stop_cpu = cpus_in_system;
+	int thread, smt_state = -1;
+	int cpu_state_size;
 	int rc = 0;
+	int i, core_id, threads_online;
+	int *present_cores = NULL;
+	int num_present_cores;
 
-	cpu_states = (cpu_set_t **)calloc(threads_per_cpu, sizeof(cpu_set_t));
-	if (!cpu_states)
+	if (get_present_core_list(&present_cores, &num_present_cores, threads_per_cpu) != 0) {
+		fprintf(stderr, "Failed to get present core list\n");
 		return -ENOMEM;
+	}
+	cpu_state_size = CPU_ALLOC_SIZE(num_present_cores);
+	cpu_states = (cpu_set_t **)calloc(threads_per_cpu, sizeof(cpu_set_t *));
+	if (!cpu_states) {
+		rc = -ENOMEM;
+		goto cleanup_present_cores;
+	}
 
 	for (thread = 0; thread < threads_per_cpu; thread++) {
-		cpu_states[thread] = CPU_ALLOC(cpus_in_system);
+		cpu_states[thread] = CPU_ALLOC(num_present_cores);
+		if (!cpu_states[thread]) {
+			rc = -ENOMEM;
+			goto cleanup_cpu_states;
+		}
 		CPU_ZERO_S(cpu_state_size, cpu_states[thread]);
 	}
 
-	for (c = start_cpu; c < stop_cpu; c++) {
-		int threads_online = __get_one_smt_state(c, threads_per_cpu);
-
+	for (i = 0; i < num_present_cores; i++) {
+		core_id = present_cores[i];
+		threads_online = __get_one_smt_state(core_id, threads_per_cpu);
 		if (threads_online < 0) {
 			rc = threads_online;
-			goto cleanup_get_smt;
+			goto cleanup_cpu_states;
+		}
+		if (threads_online) {
+			CPU_SET_S(core_id, cpu_state_size, cpu_states[threads_online - 1]);
 		}
-		if (threads_online)
-			CPU_SET_S(c, cpu_state_size,
-					cpu_states[threads_online - 1]);
 	}
 
 	for (thread = 0; thread < threads_per_cpu; thread++) {
 		if (CPU_COUNT_S(cpu_state_size, cpu_states[thread])) {
-			if (smt_state == 0)
+			if (smt_state == -1)
 				smt_state = thread + 1;
 			else if (smt_state > 0)
 				smt_state = 0; /* mix of SMT modes */
 		}
 	}
 
-	if (!print_smt_state)
-		return smt_state;
+	if (!print_smt_state) {
+		rc = smt_state;
+		goto cleanup_cpu_states;
+	}
 
 	if (smt_state == 1) {
 		if (numeric)
@@ -380,21 +407,22 @@ int __do_smt(bool numeric, int cpus_in_system, int threads_per_cpu,
 			printf("SMT is off\n");
 	} else if (smt_state == 0) {
 		for (thread = 0; thread < threads_per_cpu; thread++) {
-			if (CPU_COUNT_S(cpu_state_size,
-						cpu_states[thread])) {
+			if (CPU_COUNT_S(cpu_state_size, cpu_states[thread])) {
 				printf("SMT=%d: ", thread + 1);
-				print_cpu_list(cpu_states[thread],
-						cpu_state_size, cpus_in_system);
+				print_cpu_list(cpu_states[thread], cpu_state_size, threads_per_cpu);
 				printf("\n");
 			}
 		}
 	} else {
 		printf("SMT=%d\n", smt_state);
 	}
 
-cleanup_get_smt:
+cleanup_cpu_states:
 	for (thread = 0; thread < threads_per_cpu; thread++)
 		CPU_FREE(cpu_states[thread]);
+    free(cpu_states);
+cleanup_present_cores:
+	free(present_cores);
 
 	return rc;
 }