1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2008 4 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com) 5 */ 6 7 #define KMSG_COMPONENT "cpu" 8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 9 10 #include <linux/stop_machine.h> 11 #include <linux/cpufeature.h> 12 #include <linux/bitops.h> 13 #include <linux/kernel.h> 14 #include <linux/sched/mm.h> 15 #include <linux/init.h> 16 #include <linux/seq_file.h> 17 #include <linux/mm_types.h> 18 #include <linux/delay.h> 19 #include <linux/cpu.h> 20 21 #include <asm/diag.h> 22 #include <asm/facility.h> 23 #include <asm/elf.h> 24 #include <asm/lowcore.h> 25 #include <asm/param.h> 26 #include <asm/smp.h> 27 28 struct cpu_info { 29 unsigned int cpu_mhz_dynamic; 30 unsigned int cpu_mhz_static; 31 struct cpuid cpu_id; 32 }; 33 34 static DEFINE_PER_CPU(struct cpu_info, cpu_info); 35 static DEFINE_PER_CPU(int, cpu_relax_retry); 36 37 static bool machine_has_cpu_mhz; 38 39 void __init cpu_detect_mhz_feature(void) 40 { 41 if (test_facility(34) && __ecag(ECAG_CPU_ATTRIBUTE, 0) != -1UL) 42 machine_has_cpu_mhz = true; 43 } 44 45 static void update_cpu_mhz(void *arg) 46 { 47 unsigned long mhz; 48 struct cpu_info *c; 49 50 mhz = __ecag(ECAG_CPU_ATTRIBUTE, 0); 51 c = this_cpu_ptr(&cpu_info); 52 c->cpu_mhz_dynamic = mhz >> 32; 53 c->cpu_mhz_static = mhz & 0xffffffff; 54 } 55 56 void s390_update_cpu_mhz(void) 57 { 58 s390_adjust_jiffies(); 59 if (machine_has_cpu_mhz) 60 on_each_cpu(update_cpu_mhz, NULL, 0); 61 } 62 63 void notrace stop_machine_yield(const struct cpumask *cpumask) 64 { 65 int cpu, this_cpu; 66 67 this_cpu = smp_processor_id(); 68 if (__this_cpu_inc_return(cpu_relax_retry) >= spin_retry) { 69 __this_cpu_write(cpu_relax_retry, 0); 70 cpu = cpumask_next_wrap(this_cpu, cpumask, this_cpu, false); 71 if (cpu >= nr_cpu_ids) 72 return; 73 if (arch_vcpu_is_preempted(cpu)) 74 smp_yield_cpu(cpu); 75 } 76 } 77 78 /* 79 * cpu_init - initializes state that is per-CPU. 80 */ 81 void cpu_init(void) 82 { 83 struct cpuid *id = this_cpu_ptr(&cpu_info.cpu_id); 84 85 get_cpu_id(id); 86 if (machine_has_cpu_mhz) 87 update_cpu_mhz(NULL); 88 mmgrab(&init_mm); 89 current->active_mm = &init_mm; 90 BUG_ON(current->mm); 91 enter_lazy_tlb(&init_mm, current); 92 } 93 94 /* 95 * cpu_have_feature - Test CPU features on module initialization 96 */ 97 int cpu_have_feature(unsigned int num) 98 { 99 return elf_hwcap & (1UL << num); 100 } 101 EXPORT_SYMBOL(cpu_have_feature); 102 103 static void show_facilities(struct seq_file *m) 104 { 105 unsigned int bit; 106 long *facilities; 107 108 facilities = (long *)&S390_lowcore.stfle_fac_list; 109 seq_puts(m, "facilities :"); 110 for_each_set_bit_inv(bit, facilities, MAX_FACILITY_BIT) 111 seq_printf(m, " %d", bit); 112 seq_putc(m, '\n'); 113 } 114 115 static void show_cpu_summary(struct seq_file *m, void *v) 116 { 117 static const char *hwcap_str[] = { 118 "esan3", "zarch", "stfle", "msa", "ldisp", "eimm", "dfp", 119 "edat", "etf3eh", "highgprs", "te", "vx", "vxd", "vxe", "gs", 120 "vxe2", "vxp", "sort", "dflt" 121 }; 122 static const char * const int_hwcap_str[] = { 123 "sie" 124 }; 125 int i, cpu; 126 127 seq_printf(m, "vendor_id : IBM/S390\n" 128 "# processors : %i\n" 129 "bogomips per cpu: %lu.%02lu\n", 130 num_online_cpus(), loops_per_jiffy/(500000/HZ), 131 (loops_per_jiffy/(5000/HZ))%100); 132 seq_printf(m, "max thread id : %d\n", smp_cpu_mtid); 133 seq_puts(m, "features\t: "); 134 for (i = 0; i < ARRAY_SIZE(hwcap_str); i++) 135 if (hwcap_str[i] && (elf_hwcap & (1UL << i))) 136 seq_printf(m, "%s ", hwcap_str[i]); 137 for (i = 0; i < ARRAY_SIZE(int_hwcap_str); i++) 138 if (int_hwcap_str[i] && (int_hwcap & (1UL << i))) 139 seq_printf(m, "%s ", int_hwcap_str[i]); 140 seq_puts(m, "\n"); 141 show_facilities(m); 142 show_cacheinfo(m); 143 for_each_online_cpu(cpu) { 144 struct cpuid *id = &per_cpu(cpu_info.cpu_id, cpu); 145 146 seq_printf(m, "processor %d: " 147 "version = %02X, " 148 "identification = %06X, " 149 "machine = %04X\n", 150 cpu, id->version, id->ident, id->machine); 151 } 152 } 153 154 static void show_cpu_topology(struct seq_file *m, unsigned long n) 155 { 156 #ifdef CONFIG_SCHED_TOPOLOGY 157 seq_printf(m, "physical id : %d\n", topology_physical_package_id(n)); 158 seq_printf(m, "core id : %d\n", topology_core_id(n)); 159 seq_printf(m, "book id : %d\n", topology_book_id(n)); 160 seq_printf(m, "drawer id : %d\n", topology_drawer_id(n)); 161 seq_printf(m, "dedicated : %d\n", topology_cpu_dedicated(n)); 162 seq_printf(m, "address : %d\n", smp_cpu_get_cpu_address(n)); 163 seq_printf(m, "siblings : %d\n", cpumask_weight(topology_core_cpumask(n))); 164 seq_printf(m, "cpu cores : %d\n", topology_booted_cores(n)); 165 #endif /* CONFIG_SCHED_TOPOLOGY */ 166 } 167 168 static void show_cpu_ids(struct seq_file *m, unsigned long n) 169 { 170 struct cpuid *id = &per_cpu(cpu_info.cpu_id, n); 171 172 seq_printf(m, "version : %02X\n", id->version); 173 seq_printf(m, "identification : %06X\n", id->ident); 174 seq_printf(m, "machine : %04X\n", id->machine); 175 } 176 177 static void show_cpu_mhz(struct seq_file *m, unsigned long n) 178 { 179 struct cpu_info *c = per_cpu_ptr(&cpu_info, n); 180 181 if (!machine_has_cpu_mhz) 182 return; 183 seq_printf(m, "cpu MHz dynamic : %d\n", c->cpu_mhz_dynamic); 184 seq_printf(m, "cpu MHz static : %d\n", c->cpu_mhz_static); 185 } 186 187 /* 188 * show_cpuinfo - Get information on one CPU for use by procfs. 189 */ 190 static int show_cpuinfo(struct seq_file *m, void *v) 191 { 192 unsigned long n = (unsigned long) v - 1; 193 unsigned long first = cpumask_first(cpu_online_mask); 194 195 if (n == first) 196 show_cpu_summary(m, v); 197 seq_printf(m, "\ncpu number : %ld\n", n); 198 show_cpu_topology(m, n); 199 show_cpu_ids(m, n); 200 show_cpu_mhz(m, n); 201 return 0; 202 } 203 204 static inline void *c_update(loff_t *pos) 205 { 206 if (*pos) 207 *pos = cpumask_next(*pos - 1, cpu_online_mask); 208 else 209 *pos = cpumask_first(cpu_online_mask); 210 return *pos < nr_cpu_ids ? (void *)*pos + 1 : NULL; 211 } 212 213 static void *c_start(struct seq_file *m, loff_t *pos) 214 { 215 get_online_cpus(); 216 return c_update(pos); 217 } 218 219 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 220 { 221 ++*pos; 222 return c_update(pos); 223 } 224 225 static void c_stop(struct seq_file *m, void *v) 226 { 227 put_online_cpus(); 228 } 229 230 const struct seq_operations cpuinfo_op = { 231 .start = c_start, 232 .next = c_next, 233 .stop = c_stop, 234 .show = show_cpuinfo, 235 }; 236 237 int s390_isolate_bp(void) 238 { 239 if (!test_facility(82)) 240 return -EOPNOTSUPP; 241 set_thread_flag(TIF_ISOLATE_BP); 242 return 0; 243 } 244 EXPORT_SYMBOL(s390_isolate_bp); 245 246 int s390_isolate_bp_guest(void) 247 { 248 if (!test_facility(82)) 249 return -EOPNOTSUPP; 250 set_thread_flag(TIF_ISOLATE_BP_GUEST); 251 return 0; 252 } 253 EXPORT_SYMBOL(s390_isolate_bp_guest); 254