1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2001, 2009
4 * Author(s): Ulrich Weigand <Ulrich.Weigand@de.ibm.com>,
5 * Martin Schwidefsky <schwidefsky@de.ibm.com>,
8 #include <linux/debugfs.h>
9 #include <linux/kernel.h>
11 #include <linux/proc_fs.h>
12 #include <linux/seq_file.h>
13 #include <linux/init.h>
14 #include <linux/delay.h>
15 #include <linux/export.h>
16 #include <linux/slab.h>
17 #include <asm/ebcdic.h>
18 #include <asm/debug.h>
19 #include <asm/sysinfo.h>
20 #include <asm/cpcmd.h>
21 #include <asm/topology.h>
22 #include <asm/fpu/api.h>
24 int topology_max_mnest
;
26 static inline int __stsi(void *sysinfo
, int fc
, int sel1
, int sel2
, int *lvl
)
28 register int r0
asm("0") = (fc
<< 28) | sel1
;
29 register int r1
asm("1") = sel2
;
38 : "+d" (r0
), "+d" (rc
)
39 : "d" (r1
), "a" (sysinfo
), "K" (-EOPNOTSUPP
)
41 *lvl
= ((unsigned int) r0
) >> 28;
46 * stsi - store system information
48 * Returns the current configuration level if function code 0 was specified.
49 * Otherwise returns 0 on success or a negative value on error.
51 int stsi(void *sysinfo
, int fc
, int sel1
, int sel2
)
55 rc
= __stsi(sysinfo
, fc
, sel1
, sel2
, &lvl
);
62 static bool convert_ext_name(unsigned char encoding
, char *name
, size_t len
)
76 static void stsi_1_1_1(struct seq_file
*m
, struct sysinfo_1_1_1
*info
)
80 if (stsi(info
, 1, 1, 1))
82 EBCASC(info
->manufacturer
, sizeof(info
->manufacturer
));
83 EBCASC(info
->type
, sizeof(info
->type
));
84 EBCASC(info
->model
, sizeof(info
->model
));
85 EBCASC(info
->sequence
, sizeof(info
->sequence
));
86 EBCASC(info
->plant
, sizeof(info
->plant
));
87 EBCASC(info
->model_capacity
, sizeof(info
->model_capacity
));
88 EBCASC(info
->model_perm_cap
, sizeof(info
->model_perm_cap
));
89 EBCASC(info
->model_temp_cap
, sizeof(info
->model_temp_cap
));
90 seq_printf(m
, "Manufacturer: %-16.16s\n", info
->manufacturer
);
91 seq_printf(m
, "Type: %-4.4s\n", info
->type
);
93 * Sigh: the model field has been renamed with System z9
94 * to model_capacity and a new model field has been added
95 * after the plant field. To avoid confusing older programs
96 * the "Model:" prints "model_capacity model" or just
97 * "model_capacity" if the model string is empty .
99 seq_printf(m
, "Model: %-16.16s", info
->model_capacity
);
100 if (info
->model
[0] != '\0')
101 seq_printf(m
, " %-16.16s", info
->model
);
103 seq_printf(m
, "Sequence Code: %-16.16s\n", info
->sequence
);
104 seq_printf(m
, "Plant: %-4.4s\n", info
->plant
);
105 seq_printf(m
, "Model Capacity: %-16.16s %08u\n",
106 info
->model_capacity
, info
->model_cap_rating
);
107 if (info
->model_perm_cap_rating
)
108 seq_printf(m
, "Model Perm. Capacity: %-16.16s %08u\n",
109 info
->model_perm_cap
,
110 info
->model_perm_cap_rating
);
111 if (info
->model_temp_cap_rating
)
112 seq_printf(m
, "Model Temp. Capacity: %-16.16s %08u\n",
113 info
->model_temp_cap
,
114 info
->model_temp_cap_rating
);
116 seq_printf(m
, "Nominal Cap. Rating: %08u\n", info
->ncr
);
118 seq_printf(m
, "Nominal Perm. Rating: %08u\n", info
->npr
);
120 seq_printf(m
, "Nominal Temp. Rating: %08u\n", info
->ntr
);
122 seq_printf(m
, "Capacity Adj. Ind.: %d\n", info
->cai
);
123 seq_printf(m
, "Capacity Ch. Reason: %d\n", info
->ccr
);
124 seq_printf(m
, "Capacity Transient: %d\n", info
->t
);
127 for (i
= 1; i
<= ARRAY_SIZE(info
->typepct
); i
++) {
128 seq_printf(m
, "Type %d Percentage: %d\n",
129 i
, info
->typepct
[i
- 1]);
134 static void stsi_15_1_x(struct seq_file
*m
, struct sysinfo_15_1_x
*info
)
139 if (!MACHINE_HAS_TOPOLOGY
)
141 if (stsi(info
, 15, 1, topology_max_mnest
))
143 seq_printf(m
, "CPU Topology HW: ");
144 for (i
= 0; i
< TOPOLOGY_NR_MAG
; i
++)
145 seq_printf(m
, " %d", info
->mag
[i
]);
147 #ifdef CONFIG_SCHED_TOPOLOGY
148 store_topology(info
);
149 seq_printf(m
, "CPU Topology SW: ");
150 for (i
= 0; i
< TOPOLOGY_NR_MAG
; i
++)
151 seq_printf(m
, " %d", info
->mag
[i
]);
156 static void stsi_1_2_2(struct seq_file
*m
, struct sysinfo_1_2_2
*info
)
158 struct sysinfo_1_2_2_extension
*ext
;
161 if (stsi(info
, 1, 2, 2))
163 ext
= (struct sysinfo_1_2_2_extension
*)
164 ((unsigned long) info
+ info
->acc_offset
);
165 seq_printf(m
, "CPUs Total: %d\n", info
->cpus_total
);
166 seq_printf(m
, "CPUs Configured: %d\n", info
->cpus_configured
);
167 seq_printf(m
, "CPUs Standby: %d\n", info
->cpus_standby
);
168 seq_printf(m
, "CPUs Reserved: %d\n", info
->cpus_reserved
);
169 if (info
->mt_installed
) {
170 seq_printf(m
, "CPUs G-MTID: %d\n", info
->mt_gtid
);
171 seq_printf(m
, "CPUs S-MTID: %d\n", info
->mt_stid
);
174 * Sigh 2. According to the specification the alternate
175 * capability field is a 32 bit floating point number
176 * if the higher order 8 bits are not zero. Printing
177 * a floating point number in the kernel is a no-no,
178 * always print the number as 32 bit unsigned integer.
179 * The user-space needs to know about the strange
180 * encoding of the alternate cpu capability.
182 seq_printf(m
, "Capability: %u", info
->capability
);
183 if (info
->format
== 1)
184 seq_printf(m
, " %u", ext
->alt_capability
);
186 if (info
->nominal_cap
)
187 seq_printf(m
, "Nominal Capability: %d\n", info
->nominal_cap
);
188 if (info
->secondary_cap
)
189 seq_printf(m
, "Secondary Capability: %d\n", info
->secondary_cap
);
190 for (i
= 2; i
<= info
->cpus_total
; i
++) {
191 seq_printf(m
, "Adjustment %02d-way: %u",
192 i
, info
->adjustment
[i
-2]);
193 if (info
->format
== 1)
194 seq_printf(m
, " %u", ext
->alt_adjustment
[i
-2]);
199 static void stsi_2_2_2(struct seq_file
*m
, struct sysinfo_2_2_2
*info
)
201 if (stsi(info
, 2, 2, 2))
203 EBCASC(info
->name
, sizeof(info
->name
));
205 seq_printf(m
, "LPAR Number: %d\n", info
->lpar_number
);
206 seq_printf(m
, "LPAR Characteristics: ");
207 if (info
->characteristics
& LPAR_CHAR_DEDICATED
)
208 seq_printf(m
, "Dedicated ");
209 if (info
->characteristics
& LPAR_CHAR_SHARED
)
210 seq_printf(m
, "Shared ");
211 if (info
->characteristics
& LPAR_CHAR_LIMITED
)
212 seq_printf(m
, "Limited ");
214 seq_printf(m
, "LPAR Name: %-8.8s\n", info
->name
);
215 seq_printf(m
, "LPAR Adjustment: %d\n", info
->caf
);
216 seq_printf(m
, "LPAR CPUs Total: %d\n", info
->cpus_total
);
217 seq_printf(m
, "LPAR CPUs Configured: %d\n", info
->cpus_configured
);
218 seq_printf(m
, "LPAR CPUs Standby: %d\n", info
->cpus_standby
);
219 seq_printf(m
, "LPAR CPUs Reserved: %d\n", info
->cpus_reserved
);
220 seq_printf(m
, "LPAR CPUs Dedicated: %d\n", info
->cpus_dedicated
);
221 seq_printf(m
, "LPAR CPUs Shared: %d\n", info
->cpus_shared
);
222 if (info
->mt_installed
) {
223 seq_printf(m
, "LPAR CPUs G-MTID: %d\n", info
->mt_gtid
);
224 seq_printf(m
, "LPAR CPUs S-MTID: %d\n", info
->mt_stid
);
225 seq_printf(m
, "LPAR CPUs PS-MTID: %d\n", info
->mt_psmtid
);
227 if (convert_ext_name(info
->vsne
, info
->ext_name
, sizeof(info
->ext_name
))) {
228 seq_printf(m
, "LPAR Extended Name: %-.256s\n", info
->ext_name
);
229 seq_printf(m
, "LPAR UUID: %pUb\n", &info
->uuid
);
233 static void print_ext_name(struct seq_file
*m
, int lvl
,
234 struct sysinfo_3_2_2
*info
)
236 size_t len
= sizeof(info
->ext_names
[lvl
]);
238 if (!convert_ext_name(info
->vm
[lvl
].evmne
, info
->ext_names
[lvl
], len
))
240 seq_printf(m
, "VM%02d Extended Name: %-.256s\n", lvl
,
241 info
->ext_names
[lvl
]);
244 static void print_uuid(struct seq_file
*m
, int i
, struct sysinfo_3_2_2
*info
)
246 if (uuid_is_null(&info
->vm
[i
].uuid
))
248 seq_printf(m
, "VM%02d UUID: %pUb\n", i
, &info
->vm
[i
].uuid
);
251 static void stsi_3_2_2(struct seq_file
*m
, struct sysinfo_3_2_2
*info
)
255 if (stsi(info
, 3, 2, 2))
257 for (i
= 0; i
< info
->count
; i
++) {
258 EBCASC(info
->vm
[i
].name
, sizeof(info
->vm
[i
].name
));
259 EBCASC(info
->vm
[i
].cpi
, sizeof(info
->vm
[i
].cpi
));
261 seq_printf(m
, "VM%02d Name: %-8.8s\n", i
, info
->vm
[i
].name
);
262 seq_printf(m
, "VM%02d Control Program: %-16.16s\n", i
, info
->vm
[i
].cpi
);
263 seq_printf(m
, "VM%02d Adjustment: %d\n", i
, info
->vm
[i
].caf
);
264 seq_printf(m
, "VM%02d CPUs Total: %d\n", i
, info
->vm
[i
].cpus_total
);
265 seq_printf(m
, "VM%02d CPUs Configured: %d\n", i
, info
->vm
[i
].cpus_configured
);
266 seq_printf(m
, "VM%02d CPUs Standby: %d\n", i
, info
->vm
[i
].cpus_standby
);
267 seq_printf(m
, "VM%02d CPUs Reserved: %d\n", i
, info
->vm
[i
].cpus_reserved
);
268 print_ext_name(m
, i
, info
);
269 print_uuid(m
, i
, info
);
273 static int sysinfo_show(struct seq_file
*m
, void *v
)
275 void *info
= (void *)get_zeroed_page(GFP_KERNEL
);
280 level
= stsi(NULL
, 0, 0, 0);
284 stsi_15_1_x(m
, info
);
291 free_page((unsigned long)info
);
295 static int sysinfo_open(struct inode
*inode
, struct file
*file
)
297 return single_open(file
, sysinfo_show
, NULL
);
300 static const struct file_operations sysinfo_fops
= {
301 .open
= sysinfo_open
,
304 .release
= single_release
,
307 static int __init
sysinfo_create_proc(void)
309 proc_create("sysinfo", 0444, NULL
, &sysinfo_fops
);
312 device_initcall(sysinfo_create_proc
);
315 * Service levels interface.
318 static DECLARE_RWSEM(service_level_sem
);
319 static LIST_HEAD(service_level_list
);
321 int register_service_level(struct service_level
*slr
)
323 struct service_level
*ptr
;
325 down_write(&service_level_sem
);
326 list_for_each_entry(ptr
, &service_level_list
, list
)
328 up_write(&service_level_sem
);
331 list_add_tail(&slr
->list
, &service_level_list
);
332 up_write(&service_level_sem
);
335 EXPORT_SYMBOL(register_service_level
);
337 int unregister_service_level(struct service_level
*slr
)
339 struct service_level
*ptr
, *next
;
342 down_write(&service_level_sem
);
343 list_for_each_entry_safe(ptr
, next
, &service_level_list
, list
) {
346 list_del(&ptr
->list
);
350 up_write(&service_level_sem
);
353 EXPORT_SYMBOL(unregister_service_level
);
355 static void *service_level_start(struct seq_file
*m
, loff_t
*pos
)
357 down_read(&service_level_sem
);
358 return seq_list_start(&service_level_list
, *pos
);
361 static void *service_level_next(struct seq_file
*m
, void *p
, loff_t
*pos
)
363 return seq_list_next(p
, &service_level_list
, pos
);
366 static void service_level_stop(struct seq_file
*m
, void *p
)
368 up_read(&service_level_sem
);
371 static int service_level_show(struct seq_file
*m
, void *p
)
373 struct service_level
*slr
;
375 slr
= list_entry(p
, struct service_level
, list
);
376 slr
->seq_print(m
, slr
);
380 static const struct seq_operations service_level_seq_ops
= {
381 .start
= service_level_start
,
382 .next
= service_level_next
,
383 .stop
= service_level_stop
,
384 .show
= service_level_show
387 static int service_level_open(struct inode
*inode
, struct file
*file
)
389 return seq_open(file
, &service_level_seq_ops
);
392 static const struct file_operations service_level_ops
= {
393 .open
= service_level_open
,
396 .release
= seq_release
399 static void service_level_vm_print(struct seq_file
*m
,
400 struct service_level
*slr
)
402 char *query_buffer
, *str
;
404 query_buffer
= kmalloc(1024, GFP_KERNEL
| GFP_DMA
);
407 cpcmd("QUERY CPLEVEL", query_buffer
, 1024, NULL
);
408 str
= strchr(query_buffer
, '\n');
411 seq_printf(m
, "VM: %s\n", query_buffer
);
415 static struct service_level service_level_vm
= {
416 .seq_print
= service_level_vm_print
419 static __init
int create_proc_service_level(void)
421 proc_create("service_levels", 0, NULL
, &service_level_ops
);
423 register_service_level(&service_level_vm
);
426 subsys_initcall(create_proc_service_level
);
429 * CPU capability might have changed. Therefore recalculate loops_per_jiffy.
431 void s390_adjust_jiffies(void)
433 struct sysinfo_1_2_2
*info
;
434 unsigned long capability
;
435 struct kernel_fpu fpu
;
437 info
= (void *) get_zeroed_page(GFP_KERNEL
);
441 if (stsi(info
, 1, 2, 2) == 0) {
443 * Major sigh. The cpu capability encoding is "special".
444 * If the first 9 bits of info->capability are 0 then it
445 * is a 32 bit unsigned integer in the range 0 .. 2^23.
446 * If the first 9 bits are != 0 then it is a 32 bit float.
447 * In addition a lower value indicates a proportionally
448 * higher cpu capacity. Bogomips are the other way round.
449 * To get to a halfway suitable number we divide 1e7
450 * by the cpu capability number. Yes, that means a floating
453 kernel_fpu_begin(&fpu
, KERNEL_FPR
);
466 : "Q" (info
->capability
), "d" (10000000), "d" (0)
469 kernel_fpu_end(&fpu
, KERNEL_FPR
);
472 * Really old machine without stsi block for basic
473 * cpu information. Report 42.0 bogomips.
476 loops_per_jiffy
= capability
* (500000/HZ
);
477 free_page((unsigned long) info
);
481 * calibrate the delay loop
483 void calibrate_delay(void)
485 s390_adjust_jiffies();
486 /* Print the good old Bogomips line .. */
487 printk(KERN_DEBUG
"Calibrating delay loop (skipped)... "
488 "%lu.%02lu BogoMIPS preset\n", loops_per_jiffy
/(500000/HZ
),
489 (loops_per_jiffy
/(5000/HZ
)) % 100);
492 #ifdef CONFIG_DEBUG_FS
494 #define STSI_FILE(fc, s1, s2) \
495 static int stsi_open_##fc##_##s1##_##s2(struct inode *inode, struct file *file)\
497 file->private_data = (void *) get_zeroed_page(GFP_KERNEL); \
498 if (!file->private_data) \
500 if (stsi(file->private_data, fc, s1, s2)) { \
501 free_page((unsigned long)file->private_data); \
502 file->private_data = NULL; \
505 return nonseekable_open(inode, file); \
508 static const struct file_operations stsi_##fc##_##s1##_##s2##_fs_ops = { \
509 .open = stsi_open_##fc##_##s1##_##s2, \
510 .release = stsi_release, \
512 .llseek = no_llseek, \
515 static int stsi_release(struct inode
*inode
, struct file
*file
)
517 free_page((unsigned long)file
->private_data
);
521 static ssize_t
stsi_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*ppos
)
523 return simple_read_from_buffer(buf
, size
, ppos
, file
->private_data
, PAGE_SIZE
);
539 const struct file_operations
*fops
;
543 static struct stsi_file stsi_file
[] __initdata
= {
544 {.fops
= &stsi_1_1_1_fs_ops
, .name
= "1_1_1"},
545 {.fops
= &stsi_1_2_1_fs_ops
, .name
= "1_2_1"},
546 {.fops
= &stsi_1_2_2_fs_ops
, .name
= "1_2_2"},
547 {.fops
= &stsi_2_2_1_fs_ops
, .name
= "2_2_1"},
548 {.fops
= &stsi_2_2_2_fs_ops
, .name
= "2_2_2"},
549 {.fops
= &stsi_3_2_2_fs_ops
, .name
= "3_2_2"},
550 {.fops
= &stsi_15_1_2_fs_ops
, .name
= "15_1_2"},
551 {.fops
= &stsi_15_1_3_fs_ops
, .name
= "15_1_3"},
552 {.fops
= &stsi_15_1_4_fs_ops
, .name
= "15_1_4"},
553 {.fops
= &stsi_15_1_5_fs_ops
, .name
= "15_1_5"},
554 {.fops
= &stsi_15_1_6_fs_ops
, .name
= "15_1_6"},
557 static u8 stsi_0_0_0
;
559 static __init
int stsi_init_debugfs(void)
561 struct dentry
*stsi_root
;
562 struct stsi_file
*sf
;
565 stsi_root
= debugfs_create_dir("stsi", arch_debugfs_dir
);
566 if (IS_ERR_OR_NULL(stsi_root
))
568 lvl
= stsi(NULL
, 0, 0, 0);
571 debugfs_create_u8("0_0_0", 0400, stsi_root
, &stsi_0_0_0
);
572 for (i
= 0; i
< ARRAY_SIZE(stsi_file
); i
++) {
574 debugfs_create_file(sf
->name
, 0400, stsi_root
, NULL
, sf
->fops
);
576 if (IS_ENABLED(CONFIG_SCHED_TOPOLOGY
) && MACHINE_HAS_TOPOLOGY
) {
579 sprintf(link_to
, "15_1_%d", topology_mnest_limit());
580 debugfs_create_symlink("topology", stsi_root
, link_to
);
584 device_initcall(stsi_init_debugfs
);
586 #endif /* CONFIG_DEBUG_FS */