1 /* 2 * Copyright IBM Corp. 2007, 2011 3 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com> 4 */ 5 6 #define KMSG_COMPONENT "cpu" 7 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 8 9 #include <linux/workqueue.h> 10 #include <linux/bootmem.h> 11 #include <linux/cpuset.h> 12 #include <linux/device.h> 13 #include <linux/kernel.h> 14 #include <linux/sched.h> 15 #include <linux/init.h> 16 #include <linux/delay.h> 17 #include <linux/cpu.h> 18 #include <linux/smp.h> 19 #include <linux/mm.h> 20 #include <asm/sysinfo.h> 21 22 #define PTF_HORIZONTAL (0UL) 23 #define PTF_VERTICAL (1UL) 24 #define PTF_CHECK (2UL) 25 26 struct mask_info { 27 struct mask_info *next; 28 unsigned char id; 29 cpumask_t mask; 30 }; 31 32 static void set_topology_timer(void); 33 static void topology_work_fn(struct work_struct *work); 34 static struct sysinfo_15_1_x *tl_info; 35 36 static int topology_enabled = 1; 37 static DECLARE_WORK(topology_work, topology_work_fn); 38 39 /* topology_lock protects the socket and book linked lists */ 40 static DEFINE_SPINLOCK(topology_lock); 41 static struct mask_info socket_info; 42 static struct mask_info book_info; 43 44 struct cpu_topology_s390 cpu_topology[NR_CPUS]; 45 46 static cpumask_t cpu_group_map(struct mask_info *info, unsigned int cpu) 47 { 48 cpumask_t mask; 49 50 cpumask_copy(&mask, cpumask_of(cpu)); 51 if (!topology_enabled || !MACHINE_HAS_TOPOLOGY) 52 return mask; 53 for (; info; info = info->next) { 54 if (cpumask_test_cpu(cpu, &info->mask)) 55 return info->mask; 56 } 57 return mask; 58 } 59 60 static struct mask_info *add_cpus_to_mask(struct topology_cpu *tl_cpu, 61 struct mask_info *book, 62 struct mask_info *socket, 63 int one_socket_per_cpu) 64 { 65 unsigned int cpu; 66 67 for_each_set_bit(cpu, &tl_cpu->mask[0], TOPOLOGY_CPU_BITS) { 68 unsigned int rcpu; 69 int lcpu; 70 71 rcpu = TOPOLOGY_CPU_BITS - 1 - cpu + tl_cpu->origin; 72 lcpu = smp_find_processor_id(rcpu); 73 if (lcpu < 0) 74 continue; 75 cpumask_set_cpu(lcpu, &book->mask); 76 cpu_topology[lcpu].book_id = book->id; 77 cpumask_set_cpu(lcpu, &socket->mask); 78 cpu_topology[lcpu].core_id = rcpu; 79 if (one_socket_per_cpu) { 80 cpu_topology[lcpu].socket_id = rcpu; 81 socket = socket->next; 82 } else { 83 cpu_topology[lcpu].socket_id = socket->id; 84 } 85 smp_cpu_set_polarization(lcpu, tl_cpu->pp); 86 } 87 return socket; 88 } 89 90 static void clear_masks(void) 91 { 92 struct mask_info *info; 93 94 info = &socket_info; 95 while (info) { 96 cpumask_clear(&info->mask); 97 info = info->next; 98 } 99 info = &book_info; 100 while (info) { 101 cpumask_clear(&info->mask); 102 info = info->next; 103 } 104 } 105 106 static union topology_entry *next_tle(union topology_entry *tle) 107 { 108 if (!tle->nl) 109 return (union topology_entry *)((struct topology_cpu *)tle + 1); 110 return (union topology_entry *)((struct topology_container *)tle + 1); 111 } 112 113 static void __tl_to_masks_generic(struct sysinfo_15_1_x *info) 114 { 115 struct mask_info *socket = &socket_info; 116 struct mask_info *book = &book_info; 117 union topology_entry *tle, *end; 118 119 tle = info->tle; 120 end = (union topology_entry *)((unsigned long)info + info->length); 121 while (tle < end) { 122 switch (tle->nl) { 123 case 2: 124 book = book->next; 125 book->id = tle->container.id; 126 break; 127 case 1: 128 socket = socket->next; 129 socket->id = tle->container.id; 130 break; 131 case 0: 132 add_cpus_to_mask(&tle->cpu, book, socket, 0); 133 break; 134 default: 135 clear_masks(); 136 return; 137 } 138 tle = next_tle(tle); 139 } 140 } 141 142 static void __tl_to_masks_z10(struct sysinfo_15_1_x *info) 143 { 144 struct mask_info *socket = &socket_info; 145 struct mask_info *book = &book_info; 146 union topology_entry *tle, *end; 147 148 tle = info->tle; 149 end = (union topology_entry *)((unsigned long)info + info->length); 150 while (tle < end) { 151 switch (tle->nl) { 152 case 1: 153 book = book->next; 154 book->id = tle->container.id; 155 break; 156 case 0: 157 socket = add_cpus_to_mask(&tle->cpu, book, socket, 1); 158 break; 159 default: 160 clear_masks(); 161 return; 162 } 163 tle = next_tle(tle); 164 } 165 } 166 167 static void tl_to_masks(struct sysinfo_15_1_x *info) 168 { 169 struct cpuid cpu_id; 170 171 spin_lock_irq(&topology_lock); 172 get_cpu_id(&cpu_id); 173 clear_masks(); 174 switch (cpu_id.machine) { 175 case 0x2097: 176 case 0x2098: 177 __tl_to_masks_z10(info); 178 break; 179 default: 180 __tl_to_masks_generic(info); 181 } 182 spin_unlock_irq(&topology_lock); 183 } 184 185 static void topology_update_polarization_simple(void) 186 { 187 int cpu; 188 189 mutex_lock(&smp_cpu_state_mutex); 190 for_each_possible_cpu(cpu) 191 smp_cpu_set_polarization(cpu, POLARIZATION_HRZ); 192 mutex_unlock(&smp_cpu_state_mutex); 193 } 194 195 static int ptf(unsigned long fc) 196 { 197 int rc; 198 199 asm volatile( 200 " .insn rre,0xb9a20000,%1,%1\n" 201 " ipm %0\n" 202 " srl %0,28\n" 203 : "=d" (rc) 204 : "d" (fc) : "cc"); 205 return rc; 206 } 207 208 int topology_set_cpu_management(int fc) 209 { 210 int cpu, rc; 211 212 if (!MACHINE_HAS_TOPOLOGY) 213 return -EOPNOTSUPP; 214 if (fc) 215 rc = ptf(PTF_VERTICAL); 216 else 217 rc = ptf(PTF_HORIZONTAL); 218 if (rc) 219 return -EBUSY; 220 for_each_possible_cpu(cpu) 221 smp_cpu_set_polarization(cpu, POLARIZATION_UNKNOWN); 222 return rc; 223 } 224 225 static void update_cpu_masks(void) 226 { 227 unsigned long flags; 228 int cpu; 229 230 spin_lock_irqsave(&topology_lock, flags); 231 for_each_possible_cpu(cpu) { 232 cpu_topology[cpu].core_mask = cpu_group_map(&socket_info, cpu); 233 cpu_topology[cpu].book_mask = cpu_group_map(&book_info, cpu); 234 if (!MACHINE_HAS_TOPOLOGY) { 235 cpu_topology[cpu].core_id = cpu; 236 cpu_topology[cpu].socket_id = cpu; 237 cpu_topology[cpu].book_id = cpu; 238 } 239 } 240 spin_unlock_irqrestore(&topology_lock, flags); 241 } 242 243 void store_topology(struct sysinfo_15_1_x *info) 244 { 245 if (topology_max_mnest >= 3) 246 stsi(info, 15, 1, 3); 247 else 248 stsi(info, 15, 1, 2); 249 } 250 251 int arch_update_cpu_topology(void) 252 { 253 struct sysinfo_15_1_x *info = tl_info; 254 struct device *dev; 255 int cpu; 256 257 if (!MACHINE_HAS_TOPOLOGY) { 258 update_cpu_masks(); 259 topology_update_polarization_simple(); 260 return 0; 261 } 262 store_topology(info); 263 tl_to_masks(info); 264 update_cpu_masks(); 265 for_each_online_cpu(cpu) { 266 dev = get_cpu_device(cpu); 267 kobject_uevent(&dev->kobj, KOBJ_CHANGE); 268 } 269 return 1; 270 } 271 272 static void topology_work_fn(struct work_struct *work) 273 { 274 rebuild_sched_domains(); 275 } 276 277 void topology_schedule_update(void) 278 { 279 schedule_work(&topology_work); 280 } 281 282 static void topology_timer_fn(unsigned long ignored) 283 { 284 if (ptf(PTF_CHECK)) 285 topology_schedule_update(); 286 set_topology_timer(); 287 } 288 289 static struct timer_list topology_timer = 290 TIMER_DEFERRED_INITIALIZER(topology_timer_fn, 0, 0); 291 292 static atomic_t topology_poll = ATOMIC_INIT(0); 293 294 static void set_topology_timer(void) 295 { 296 if (atomic_add_unless(&topology_poll, -1, 0)) 297 mod_timer(&topology_timer, jiffies + HZ / 10); 298 else 299 mod_timer(&topology_timer, jiffies + HZ * 60); 300 } 301 302 void topology_expect_change(void) 303 { 304 if (!MACHINE_HAS_TOPOLOGY) 305 return; 306 /* This is racy, but it doesn't matter since it is just a heuristic. 307 * Worst case is that we poll in a higher frequency for a bit longer. 308 */ 309 if (atomic_read(&topology_poll) > 60) 310 return; 311 atomic_add(60, &topology_poll); 312 set_topology_timer(); 313 } 314 315 static int __init early_parse_topology(char *p) 316 { 317 if (strncmp(p, "off", 3)) 318 return 0; 319 topology_enabled = 0; 320 return 0; 321 } 322 early_param("topology", early_parse_topology); 323 324 static void __init alloc_masks(struct sysinfo_15_1_x *info, 325 struct mask_info *mask, int offset) 326 { 327 int i, nr_masks; 328 329 nr_masks = info->mag[TOPOLOGY_NR_MAG - offset]; 330 for (i = 0; i < info->mnest - offset; i++) 331 nr_masks *= info->mag[TOPOLOGY_NR_MAG - offset - 1 - i]; 332 nr_masks = max(nr_masks, 1); 333 for (i = 0; i < nr_masks; i++) { 334 mask->next = alloc_bootmem(sizeof(struct mask_info)); 335 mask = mask->next; 336 } 337 } 338 339 void __init s390_init_cpu_topology(void) 340 { 341 struct sysinfo_15_1_x *info; 342 int i; 343 344 if (!MACHINE_HAS_TOPOLOGY) 345 return; 346 tl_info = alloc_bootmem_pages(PAGE_SIZE); 347 info = tl_info; 348 store_topology(info); 349 pr_info("The CPU configuration topology of the machine is:"); 350 for (i = 0; i < TOPOLOGY_NR_MAG; i++) 351 printk(KERN_CONT " %d", info->mag[i]); 352 printk(KERN_CONT " / %d\n", info->mnest); 353 alloc_masks(info, &socket_info, 1); 354 alloc_masks(info, &book_info, 2); 355 } 356 357 static int cpu_management; 358 359 static ssize_t dispatching_show(struct device *dev, 360 struct device_attribute *attr, 361 char *buf) 362 { 363 ssize_t count; 364 365 mutex_lock(&smp_cpu_state_mutex); 366 count = sprintf(buf, "%d\n", cpu_management); 367 mutex_unlock(&smp_cpu_state_mutex); 368 return count; 369 } 370 371 static ssize_t dispatching_store(struct device *dev, 372 struct device_attribute *attr, 373 const char *buf, 374 size_t count) 375 { 376 int val, rc; 377 char delim; 378 379 if (sscanf(buf, "%d %c", &val, &delim) != 1) 380 return -EINVAL; 381 if (val != 0 && val != 1) 382 return -EINVAL; 383 rc = 0; 384 get_online_cpus(); 385 mutex_lock(&smp_cpu_state_mutex); 386 if (cpu_management == val) 387 goto out; 388 rc = topology_set_cpu_management(val); 389 if (rc) 390 goto out; 391 cpu_management = val; 392 topology_expect_change(); 393 out: 394 mutex_unlock(&smp_cpu_state_mutex); 395 put_online_cpus(); 396 return rc ? rc : count; 397 } 398 static DEVICE_ATTR(dispatching, 0644, dispatching_show, 399 dispatching_store); 400 401 static ssize_t cpu_polarization_show(struct device *dev, 402 struct device_attribute *attr, char *buf) 403 { 404 int cpu = dev->id; 405 ssize_t count; 406 407 mutex_lock(&smp_cpu_state_mutex); 408 switch (smp_cpu_get_polarization(cpu)) { 409 case POLARIZATION_HRZ: 410 count = sprintf(buf, "horizontal\n"); 411 break; 412 case POLARIZATION_VL: 413 count = sprintf(buf, "vertical:low\n"); 414 break; 415 case POLARIZATION_VM: 416 count = sprintf(buf, "vertical:medium\n"); 417 break; 418 case POLARIZATION_VH: 419 count = sprintf(buf, "vertical:high\n"); 420 break; 421 default: 422 count = sprintf(buf, "unknown\n"); 423 break; 424 } 425 mutex_unlock(&smp_cpu_state_mutex); 426 return count; 427 } 428 static DEVICE_ATTR(polarization, 0444, cpu_polarization_show, NULL); 429 430 static struct attribute *topology_cpu_attrs[] = { 431 &dev_attr_polarization.attr, 432 NULL, 433 }; 434 435 static struct attribute_group topology_cpu_attr_group = { 436 .attrs = topology_cpu_attrs, 437 }; 438 439 int topology_cpu_init(struct cpu *cpu) 440 { 441 return sysfs_create_group(&cpu->dev.kobj, &topology_cpu_attr_group); 442 } 443 444 static int __init topology_init(void) 445 { 446 if (!MACHINE_HAS_TOPOLOGY) { 447 topology_update_polarization_simple(); 448 goto out; 449 } 450 set_topology_timer(); 451 out: 452 update_cpu_masks(); 453 return device_create_file(cpu_subsys.dev_root, &dev_attr_dispatching); 454 } 455 device_initcall(topology_init); 456