x86/speculation/mds: Fix documentation typo
[linux/fpc-iii.git] / arch / s390 / kernel / topology.c
blobed0bdd220e1a643788655fbefaef328dd38c7951
1 /*
2 * Copyright IBM Corp. 2007, 2011
3 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
4 */
6 #define KMSG_COMPONENT "cpu"
7 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
9 #include <linux/workqueue.h>
10 #include <linux/bootmem.h>
11 #include <linux/uaccess.h>
12 #include <linux/sysctl.h>
13 #include <linux/cpuset.h>
14 #include <linux/device.h>
15 #include <linux/export.h>
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/sched/topology.h>
19 #include <linux/delay.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/cpu.h>
23 #include <linux/smp.h>
24 #include <linux/mm.h>
25 #include <linux/nodemask.h>
26 #include <linux/node.h>
27 #include <asm/sysinfo.h>
28 #include <asm/numa.h>
30 #define PTF_HORIZONTAL (0UL)
31 #define PTF_VERTICAL (1UL)
32 #define PTF_CHECK (2UL)
34 enum {
35 TOPOLOGY_MODE_HW,
36 TOPOLOGY_MODE_SINGLE,
37 TOPOLOGY_MODE_PACKAGE,
38 TOPOLOGY_MODE_UNINITIALIZED
41 struct mask_info {
42 struct mask_info *next;
43 unsigned char id;
44 cpumask_t mask;
47 static int topology_mode = TOPOLOGY_MODE_UNINITIALIZED;
48 static void set_topology_timer(void);
49 static void topology_work_fn(struct work_struct *work);
50 static struct sysinfo_15_1_x *tl_info;
52 static DECLARE_WORK(topology_work, topology_work_fn);
55 * Socket/Book linked lists and cpu_topology updates are
56 * protected by "sched_domains_mutex".
58 static struct mask_info socket_info;
59 static struct mask_info book_info;
60 static struct mask_info drawer_info;
62 struct cpu_topology_s390 cpu_topology[NR_CPUS];
63 EXPORT_SYMBOL_GPL(cpu_topology);
65 cpumask_t cpus_with_topology;
67 static cpumask_t cpu_group_map(struct mask_info *info, unsigned int cpu)
69 cpumask_t mask;
71 cpumask_copy(&mask, cpumask_of(cpu));
72 switch (topology_mode) {
73 case TOPOLOGY_MODE_HW:
74 while (info) {
75 if (cpumask_test_cpu(cpu, &info->mask)) {
76 mask = info->mask;
77 break;
79 info = info->next;
81 if (cpumask_empty(&mask))
82 cpumask_copy(&mask, cpumask_of(cpu));
83 break;
84 case TOPOLOGY_MODE_PACKAGE:
85 cpumask_copy(&mask, cpu_present_mask);
86 break;
87 default:
88 /* fallthrough */
89 case TOPOLOGY_MODE_SINGLE:
90 cpumask_copy(&mask, cpumask_of(cpu));
91 break;
93 return mask;
96 static cpumask_t cpu_thread_map(unsigned int cpu)
98 cpumask_t mask;
99 int i;
101 cpumask_copy(&mask, cpumask_of(cpu));
102 if (topology_mode != TOPOLOGY_MODE_HW)
103 return mask;
104 cpu -= cpu % (smp_cpu_mtid + 1);
105 for (i = 0; i <= smp_cpu_mtid; i++)
106 if (cpu_present(cpu + i))
107 cpumask_set_cpu(cpu + i, &mask);
108 return mask;
111 #define TOPOLOGY_CORE_BITS 64
113 static void add_cpus_to_mask(struct topology_core *tl_core,
114 struct mask_info *drawer,
115 struct mask_info *book,
116 struct mask_info *socket)
118 struct cpu_topology_s390 *topo;
119 unsigned int core;
121 for_each_set_bit(core, &tl_core->mask, TOPOLOGY_CORE_BITS) {
122 unsigned int rcore;
123 int lcpu, i;
125 rcore = TOPOLOGY_CORE_BITS - 1 - core + tl_core->origin;
126 lcpu = smp_find_processor_id(rcore << smp_cpu_mt_shift);
127 if (lcpu < 0)
128 continue;
129 for (i = 0; i <= smp_cpu_mtid; i++) {
130 topo = &cpu_topology[lcpu + i];
131 topo->drawer_id = drawer->id;
132 topo->book_id = book->id;
133 topo->socket_id = socket->id;
134 topo->core_id = rcore;
135 topo->thread_id = lcpu + i;
136 cpumask_set_cpu(lcpu + i, &drawer->mask);
137 cpumask_set_cpu(lcpu + i, &book->mask);
138 cpumask_set_cpu(lcpu + i, &socket->mask);
139 cpumask_set_cpu(lcpu + i, &cpus_with_topology);
140 smp_cpu_set_polarization(lcpu + i, tl_core->pp);
145 static void clear_masks(void)
147 struct mask_info *info;
149 info = &socket_info;
150 while (info) {
151 cpumask_clear(&info->mask);
152 info = info->next;
154 info = &book_info;
155 while (info) {
156 cpumask_clear(&info->mask);
157 info = info->next;
159 info = &drawer_info;
160 while (info) {
161 cpumask_clear(&info->mask);
162 info = info->next;
166 static union topology_entry *next_tle(union topology_entry *tle)
168 if (!tle->nl)
169 return (union topology_entry *)((struct topology_core *)tle + 1);
170 return (union topology_entry *)((struct topology_container *)tle + 1);
173 static void tl_to_masks(struct sysinfo_15_1_x *info)
175 struct mask_info *socket = &socket_info;
176 struct mask_info *book = &book_info;
177 struct mask_info *drawer = &drawer_info;
178 union topology_entry *tle, *end;
180 clear_masks();
181 tle = info->tle;
182 end = (union topology_entry *)((unsigned long)info + info->length);
183 while (tle < end) {
184 switch (tle->nl) {
185 case 3:
186 drawer = drawer->next;
187 drawer->id = tle->container.id;
188 break;
189 case 2:
190 book = book->next;
191 book->id = tle->container.id;
192 break;
193 case 1:
194 socket = socket->next;
195 socket->id = tle->container.id;
196 break;
197 case 0:
198 add_cpus_to_mask(&tle->cpu, drawer, book, socket);
199 break;
200 default:
201 clear_masks();
202 return;
204 tle = next_tle(tle);
208 static void topology_update_polarization_simple(void)
210 int cpu;
212 for_each_possible_cpu(cpu)
213 smp_cpu_set_polarization(cpu, POLARIZATION_HRZ);
216 static int ptf(unsigned long fc)
218 int rc;
220 asm volatile(
221 " .insn rre,0xb9a20000,%1,%1\n"
222 " ipm %0\n"
223 " srl %0,28\n"
224 : "=d" (rc)
225 : "d" (fc) : "cc");
226 return rc;
229 int topology_set_cpu_management(int fc)
231 int cpu, rc;
233 if (!MACHINE_HAS_TOPOLOGY)
234 return -EOPNOTSUPP;
235 if (fc)
236 rc = ptf(PTF_VERTICAL);
237 else
238 rc = ptf(PTF_HORIZONTAL);
239 if (rc)
240 return -EBUSY;
241 for_each_possible_cpu(cpu)
242 smp_cpu_set_polarization(cpu, POLARIZATION_UNKNOWN);
243 return rc;
246 static void update_cpu_masks(void)
248 struct cpu_topology_s390 *topo;
249 int cpu, id;
251 for_each_possible_cpu(cpu) {
252 topo = &cpu_topology[cpu];
253 topo->thread_mask = cpu_thread_map(cpu);
254 topo->core_mask = cpu_group_map(&socket_info, cpu);
255 topo->book_mask = cpu_group_map(&book_info, cpu);
256 topo->drawer_mask = cpu_group_map(&drawer_info, cpu);
257 if (topology_mode != TOPOLOGY_MODE_HW) {
258 id = topology_mode == TOPOLOGY_MODE_PACKAGE ? 0 : cpu;
259 topo->thread_id = cpu;
260 topo->core_id = cpu;
261 topo->socket_id = id;
262 topo->book_id = id;
263 topo->drawer_id = id;
264 if (cpu_present(cpu))
265 cpumask_set_cpu(cpu, &cpus_with_topology);
268 numa_update_cpu_topology();
271 void store_topology(struct sysinfo_15_1_x *info)
273 stsi(info, 15, 1, topology_mnest_limit());
276 static int __arch_update_cpu_topology(void)
278 struct sysinfo_15_1_x *info = tl_info;
279 int rc = 0;
281 mutex_lock(&smp_cpu_state_mutex);
282 cpumask_clear(&cpus_with_topology);
283 if (MACHINE_HAS_TOPOLOGY) {
284 rc = 1;
285 store_topology(info);
286 tl_to_masks(info);
288 update_cpu_masks();
289 if (!MACHINE_HAS_TOPOLOGY)
290 topology_update_polarization_simple();
291 mutex_unlock(&smp_cpu_state_mutex);
292 return rc;
295 int arch_update_cpu_topology(void)
297 struct device *dev;
298 int cpu, rc;
300 rc = __arch_update_cpu_topology();
301 for_each_online_cpu(cpu) {
302 dev = get_cpu_device(cpu);
303 kobject_uevent(&dev->kobj, KOBJ_CHANGE);
305 return rc;
308 static void topology_work_fn(struct work_struct *work)
310 rebuild_sched_domains();
313 void topology_schedule_update(void)
315 schedule_work(&topology_work);
318 static void topology_flush_work(void)
320 flush_work(&topology_work);
323 static void topology_timer_fn(unsigned long ignored)
325 if (ptf(PTF_CHECK))
326 topology_schedule_update();
327 set_topology_timer();
330 static struct timer_list topology_timer =
331 TIMER_DEFERRED_INITIALIZER(topology_timer_fn, 0, 0);
333 static atomic_t topology_poll = ATOMIC_INIT(0);
335 static void set_topology_timer(void)
337 if (atomic_add_unless(&topology_poll, -1, 0))
338 mod_timer(&topology_timer, jiffies + HZ / 10);
339 else
340 mod_timer(&topology_timer, jiffies + HZ * 60);
343 void topology_expect_change(void)
345 if (!MACHINE_HAS_TOPOLOGY)
346 return;
347 /* This is racy, but it doesn't matter since it is just a heuristic.
348 * Worst case is that we poll in a higher frequency for a bit longer.
350 if (atomic_read(&topology_poll) > 60)
351 return;
352 atomic_add(60, &topology_poll);
353 set_topology_timer();
356 static int cpu_management;
358 static ssize_t dispatching_show(struct device *dev,
359 struct device_attribute *attr,
360 char *buf)
362 ssize_t count;
364 mutex_lock(&smp_cpu_state_mutex);
365 count = sprintf(buf, "%d\n", cpu_management);
366 mutex_unlock(&smp_cpu_state_mutex);
367 return count;
370 static ssize_t dispatching_store(struct device *dev,
371 struct device_attribute *attr,
372 const char *buf,
373 size_t count)
375 int val, rc;
376 char delim;
378 if (sscanf(buf, "%d %c", &val, &delim) != 1)
379 return -EINVAL;
380 if (val != 0 && val != 1)
381 return -EINVAL;
382 rc = 0;
383 get_online_cpus();
384 mutex_lock(&smp_cpu_state_mutex);
385 if (cpu_management == val)
386 goto out;
387 rc = topology_set_cpu_management(val);
388 if (rc)
389 goto out;
390 cpu_management = val;
391 topology_expect_change();
392 out:
393 mutex_unlock(&smp_cpu_state_mutex);
394 put_online_cpus();
395 return rc ? rc : count;
397 static DEVICE_ATTR(dispatching, 0644, dispatching_show,
398 dispatching_store);
400 static ssize_t cpu_polarization_show(struct device *dev,
401 struct device_attribute *attr, char *buf)
403 int cpu = dev->id;
404 ssize_t count;
406 mutex_lock(&smp_cpu_state_mutex);
407 switch (smp_cpu_get_polarization(cpu)) {
408 case POLARIZATION_HRZ:
409 count = sprintf(buf, "horizontal\n");
410 break;
411 case POLARIZATION_VL:
412 count = sprintf(buf, "vertical:low\n");
413 break;
414 case POLARIZATION_VM:
415 count = sprintf(buf, "vertical:medium\n");
416 break;
417 case POLARIZATION_VH:
418 count = sprintf(buf, "vertical:high\n");
419 break;
420 default:
421 count = sprintf(buf, "unknown\n");
422 break;
424 mutex_unlock(&smp_cpu_state_mutex);
425 return count;
427 static DEVICE_ATTR(polarization, 0444, cpu_polarization_show, NULL);
429 static struct attribute *topology_cpu_attrs[] = {
430 &dev_attr_polarization.attr,
431 NULL,
434 static struct attribute_group topology_cpu_attr_group = {
435 .attrs = topology_cpu_attrs,
438 int topology_cpu_init(struct cpu *cpu)
440 return sysfs_create_group(&cpu->dev.kobj, &topology_cpu_attr_group);
443 static const struct cpumask *cpu_thread_mask(int cpu)
445 return &cpu_topology[cpu].thread_mask;
449 const struct cpumask *cpu_coregroup_mask(int cpu)
451 return &cpu_topology[cpu].core_mask;
454 static const struct cpumask *cpu_book_mask(int cpu)
456 return &cpu_topology[cpu].book_mask;
459 static const struct cpumask *cpu_drawer_mask(int cpu)
461 return &cpu_topology[cpu].drawer_mask;
464 static struct sched_domain_topology_level s390_topology[] = {
465 { cpu_thread_mask, cpu_smt_flags, SD_INIT_NAME(SMT) },
466 { cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
467 { cpu_book_mask, SD_INIT_NAME(BOOK) },
468 { cpu_drawer_mask, SD_INIT_NAME(DRAWER) },
469 { cpu_cpu_mask, SD_INIT_NAME(DIE) },
470 { NULL, },
473 static void __init alloc_masks(struct sysinfo_15_1_x *info,
474 struct mask_info *mask, int offset)
476 int i, nr_masks;
478 nr_masks = info->mag[TOPOLOGY_NR_MAG - offset];
479 for (i = 0; i < info->mnest - offset; i++)
480 nr_masks *= info->mag[TOPOLOGY_NR_MAG - offset - 1 - i];
481 nr_masks = max(nr_masks, 1);
482 for (i = 0; i < nr_masks; i++) {
483 mask->next = memblock_virt_alloc(sizeof(*mask->next), 8);
484 mask = mask->next;
488 void __init topology_init_early(void)
490 struct sysinfo_15_1_x *info;
492 set_sched_topology(s390_topology);
493 if (topology_mode == TOPOLOGY_MODE_UNINITIALIZED) {
494 if (MACHINE_HAS_TOPOLOGY)
495 topology_mode = TOPOLOGY_MODE_HW;
496 else
497 topology_mode = TOPOLOGY_MODE_SINGLE;
499 if (!MACHINE_HAS_TOPOLOGY)
500 goto out;
501 tl_info = memblock_virt_alloc(PAGE_SIZE, PAGE_SIZE);
502 info = tl_info;
503 store_topology(info);
504 pr_info("The CPU configuration topology of the machine is: %d %d %d %d %d %d / %d\n",
505 info->mag[0], info->mag[1], info->mag[2], info->mag[3],
506 info->mag[4], info->mag[5], info->mnest);
507 alloc_masks(info, &socket_info, 1);
508 alloc_masks(info, &book_info, 2);
509 alloc_masks(info, &drawer_info, 3);
510 out:
511 __arch_update_cpu_topology();
514 static inline int topology_get_mode(int enabled)
516 if (!enabled)
517 return TOPOLOGY_MODE_SINGLE;
518 return MACHINE_HAS_TOPOLOGY ? TOPOLOGY_MODE_HW : TOPOLOGY_MODE_PACKAGE;
521 static inline int topology_is_enabled(void)
523 return topology_mode != TOPOLOGY_MODE_SINGLE;
526 static int __init topology_setup(char *str)
528 bool enabled;
529 int rc;
531 rc = kstrtobool(str, &enabled);
532 if (rc)
533 return rc;
534 topology_mode = topology_get_mode(enabled);
535 return 0;
537 early_param("topology", topology_setup);
539 static int topology_ctl_handler(struct ctl_table *ctl, int write,
540 void __user *buffer, size_t *lenp, loff_t *ppos)
542 unsigned int len;
543 int new_mode;
544 char buf[2];
546 if (!*lenp || *ppos) {
547 *lenp = 0;
548 return 0;
550 if (!write) {
551 strncpy(buf, topology_is_enabled() ? "1\n" : "0\n",
552 ARRAY_SIZE(buf));
553 len = strnlen(buf, ARRAY_SIZE(buf));
554 if (len > *lenp)
555 len = *lenp;
556 if (copy_to_user(buffer, buf, len))
557 return -EFAULT;
558 goto out;
560 len = *lenp;
561 if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len))
562 return -EFAULT;
563 if (buf[0] != '0' && buf[0] != '1')
564 return -EINVAL;
565 mutex_lock(&smp_cpu_state_mutex);
566 new_mode = topology_get_mode(buf[0] == '1');
567 if (topology_mode != new_mode) {
568 topology_mode = new_mode;
569 topology_schedule_update();
571 mutex_unlock(&smp_cpu_state_mutex);
572 topology_flush_work();
573 out:
574 *lenp = len;
575 *ppos += len;
576 return 0;
579 static struct ctl_table topology_ctl_table[] = {
581 .procname = "topology",
582 .mode = 0644,
583 .proc_handler = topology_ctl_handler,
585 { },
588 static struct ctl_table topology_dir_table[] = {
590 .procname = "s390",
591 .maxlen = 0,
592 .mode = 0555,
593 .child = topology_ctl_table,
595 { },
598 static int __init topology_init(void)
600 if (MACHINE_HAS_TOPOLOGY)
601 set_topology_timer();
602 else
603 topology_update_polarization_simple();
604 register_sysctl_table(topology_dir_table);
605 return device_create_file(cpu_subsys.dev_root, &dev_attr_dispatching);
607 device_initcall(topology_init);