sysinfo.c 13.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3 4
 *  Copyright IBM Corp. 2001, 2009
 *  Author(s): Ulrich Weigand <Ulrich.Weigand@de.ibm.com>,
 *	       Martin Schwidefsky <schwidefsky@de.ibm.com>,
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9
 */

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
10
#include <linux/seq_file.h>
Linus Torvalds's avatar
Linus Torvalds committed
11
#include <linux/init.h>
12
#include <linux/delay.h>
13
#include <linux/module.h>
14
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
15
#include <asm/ebcdic.h>
16
#include <asm/sysinfo.h>
17
#include <asm/cpcmd.h>
18
#include <asm/topology.h>
19
#include <asm/fpu/api.h>
20

21 22
int topology_max_mnest;

23
static inline int __stsi(void *sysinfo, int fc, int sel1, int sel2, int *lvl)
Linus Torvalds's avatar
Linus Torvalds committed
24
{
25 26 27 28 29 30 31 32 33 34 35 36 37
	register int r0 asm("0") = (fc << 28) | sel1;
	register int r1 asm("1") = sel2;
	int rc = 0;

	asm volatile(
		"	stsi	0(%3)\n"
		"0:	jz	2f\n"
		"1:	lhi	%1,%4\n"
		"2:\n"
		EX_TABLE(0b, 1b)
		: "+d" (r0), "+d" (rc)
		: "d" (r1), "a" (sysinfo), "K" (-EOPNOTSUPP)
		: "cc", "memory");
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
	*lvl = ((unsigned int) r0) >> 28;
	return rc;
}

/*
 * stsi - store system information
 *
 * Returns the current configuration level if function code 0 was specified.
 * Otherwise returns 0 on success or a negative value on error.
 */
int stsi(void *sysinfo, int fc, int sel1, int sel2)
{
	int lvl, rc;

	rc = __stsi(sysinfo, fc, sel1, sel2, &lvl);
53 54
	if (rc)
		return rc;
55
	return fc ? 0 : lvl;
Linus Torvalds's avatar
Linus Torvalds committed
56
}
57
EXPORT_SYMBOL(stsi);
Linus Torvalds's avatar
Linus Torvalds committed
58

59
static void stsi_1_1_1(struct seq_file *m, struct sysinfo_1_1_1 *info)
Linus Torvalds's avatar
Linus Torvalds committed
60
{
61 62
	int i;

63
	if (stsi(info, 1, 1, 1))
64
		return;
65 66 67 68 69 70
	EBCASC(info->manufacturer, sizeof(info->manufacturer));
	EBCASC(info->type, sizeof(info->type));
	EBCASC(info->model, sizeof(info->model));
	EBCASC(info->sequence, sizeof(info->sequence));
	EBCASC(info->plant, sizeof(info->plant));
	EBCASC(info->model_capacity, sizeof(info->model_capacity));
71 72
	EBCASC(info->model_perm_cap, sizeof(info->model_perm_cap));
	EBCASC(info->model_temp_cap, sizeof(info->model_temp_cap));
73 74 75 76 77 78 79 80 81 82
	seq_printf(m, "Manufacturer:         %-16.16s\n", info->manufacturer);
	seq_printf(m, "Type:                 %-4.4s\n", info->type);
	/*
	 * Sigh: the model field has been renamed with System z9
	 * to model_capacity and a new model field has been added
	 * after the plant field. To avoid confusing older programs
	 * the "Model:" prints "model_capacity model" or just
	 * "model_capacity" if the model string is empty .
	 */
	seq_printf(m, "Model:                %-16.16s", info->model_capacity);
83
	if (info->model[0] != '\0')
84 85 86 87 88
		seq_printf(m, " %-16.16s", info->model);
	seq_putc(m, '\n');
	seq_printf(m, "Sequence Code:        %-16.16s\n", info->sequence);
	seq_printf(m, "Plant:                %-4.4s\n", info->plant);
	seq_printf(m, "Model Capacity:       %-16.16s %08u\n",
89 90
		   info->model_capacity, info->model_cap_rating);
	if (info->model_perm_cap_rating)
91 92
		seq_printf(m, "Model Perm. Capacity: %-16.16s %08u\n",
			   info->model_perm_cap,
93 94
			   info->model_perm_cap_rating);
	if (info->model_temp_cap_rating)
95 96
		seq_printf(m, "Model Temp. Capacity: %-16.16s %08u\n",
			   info->model_temp_cap,
97 98 99 100 101 102 103
			   info->model_temp_cap_rating);
	if (info->ncr)
		seq_printf(m, "Nominal Cap. Rating:  %08u\n", info->ncr);
	if (info->npr)
		seq_printf(m, "Nominal Perm. Rating: %08u\n", info->npr);
	if (info->ntr)
		seq_printf(m, "Nominal Temp. Rating: %08u\n", info->ntr);
104
	if (info->cai) {
105 106
		seq_printf(m, "Capacity Adj. Ind.:   %d\n", info->cai);
		seq_printf(m, "Capacity Ch. Reason:  %d\n", info->ccr);
107 108 109 110 111 112 113
		seq_printf(m, "Capacity Transient:   %d\n", info->t);
	}
	if (info->p) {
		for (i = 1; i <= ARRAY_SIZE(info->typepct); i++) {
			seq_printf(m, "Type %d Percentage:    %d\n",
				   i, info->typepct[i - 1]);
		}
114
	}
Linus Torvalds's avatar
Linus Torvalds committed
115 116
}

117
static void stsi_15_1_x(struct seq_file *m, struct sysinfo_15_1_x *info)
118
{
119
	int i;
120

121
	seq_putc(m, '\n');
122
	if (!MACHINE_HAS_TOPOLOGY)
123
		return;
124 125
	if (stsi(info, 15, 1, topology_max_mnest))
		return;
126
	seq_printf(m, "CPU Topology HW:     ");
127
	for (i = 0; i < TOPOLOGY_NR_MAG; i++)
128 129
		seq_printf(m, " %d", info->mag[i]);
	seq_putc(m, '\n');
130
#ifdef CONFIG_SCHED_TOPOLOGY
131
	store_topology(info);
132
	seq_printf(m, "CPU Topology SW:     ");
133
	for (i = 0; i < TOPOLOGY_NR_MAG; i++)
134 135
		seq_printf(m, " %d", info->mag[i]);
	seq_putc(m, '\n');
136
#endif
137 138
}

139
static void stsi_1_2_2(struct seq_file *m, struct sysinfo_1_2_2 *info)
Linus Torvalds's avatar
Linus Torvalds committed
140
{
141 142 143
	struct sysinfo_1_2_2_extension *ext;
	int i;

144
	if (stsi(info, 1, 2, 2))
145
		return;
146 147
	ext = (struct sysinfo_1_2_2_extension *)
		((unsigned long) info + info->acc_offset);
148 149 150 151
	seq_printf(m, "CPUs Total:           %d\n", info->cpus_total);
	seq_printf(m, "CPUs Configured:      %d\n", info->cpus_configured);
	seq_printf(m, "CPUs Standby:         %d\n", info->cpus_standby);
	seq_printf(m, "CPUs Reserved:        %d\n", info->cpus_reserved);
152 153 154 155
	if (info->mt_installed) {
		seq_printf(m, "CPUs G-MTID:          %d\n", info->mt_gtid);
		seq_printf(m, "CPUs S-MTID:          %d\n", info->mt_stid);
	}
156 157 158 159 160 161 162 163 164 165 166 167 168
	/*
	 * Sigh 2. According to the specification the alternate
	 * capability field is a 32 bit floating point number
	 * if the higher order 8 bits are not zero. Printing
	 * a floating point number in the kernel is a no-no,
	 * always print the number as 32 bit unsigned integer.
	 * The user-space needs to know about the strange
	 * encoding of the alternate cpu capability.
	 */
	seq_printf(m, "Capability:           %u", info->capability);
	if (info->format == 1)
		seq_printf(m, " %u", ext->alt_capability);
	seq_putc(m, '\n');
169 170 171 172
	if (info->nominal_cap)
		seq_printf(m, "Nominal Capability:   %d\n", info->nominal_cap);
	if (info->secondary_cap)
		seq_printf(m, "Secondary Capability: %d\n", info->secondary_cap);
173 174 175 176 177 178
	for (i = 2; i <= info->cpus_total; i++) {
		seq_printf(m, "Adjustment %02d-way:    %u",
			   i, info->adjustment[i-2]);
		if (info->format == 1)
			seq_printf(m, " %u", ext->alt_adjustment[i-2]);
		seq_putc(m, '\n');
179
	}
Linus Torvalds's avatar
Linus Torvalds committed
180 181
}

182
static void stsi_2_2_2(struct seq_file *m, struct sysinfo_2_2_2 *info)
Linus Torvalds's avatar
Linus Torvalds committed
183
{
184
	if (stsi(info, 2, 2, 2))
185
		return;
186
	EBCASC(info->name, sizeof(info->name));
187 188 189
	seq_putc(m, '\n');
	seq_printf(m, "LPAR Number:          %d\n", info->lpar_number);
	seq_printf(m, "LPAR Characteristics: ");
190
	if (info->characteristics & LPAR_CHAR_DEDICATED)
191
		seq_printf(m, "Dedicated ");
192
	if (info->characteristics & LPAR_CHAR_SHARED)
193
		seq_printf(m, "Shared ");
194
	if (info->characteristics & LPAR_CHAR_LIMITED)
195 196 197 198 199 200 201 202 203 204
		seq_printf(m, "Limited ");
	seq_putc(m, '\n');
	seq_printf(m, "LPAR Name:            %-8.8s\n", info->name);
	seq_printf(m, "LPAR Adjustment:      %d\n", info->caf);
	seq_printf(m, "LPAR CPUs Total:      %d\n", info->cpus_total);
	seq_printf(m, "LPAR CPUs Configured: %d\n", info->cpus_configured);
	seq_printf(m, "LPAR CPUs Standby:    %d\n", info->cpus_standby);
	seq_printf(m, "LPAR CPUs Reserved:   %d\n", info->cpus_reserved);
	seq_printf(m, "LPAR CPUs Dedicated:  %d\n", info->cpus_dedicated);
	seq_printf(m, "LPAR CPUs Shared:     %d\n", info->cpus_shared);
205 206 207 208
	if (info->mt_installed) {
		seq_printf(m, "LPAR CPUs G-MTID:     %d\n", info->mt_gtid);
		seq_printf(m, "LPAR CPUs S-MTID:     %d\n", info->mt_stid);
		seq_printf(m, "LPAR CPUs PS-MTID:    %d\n", info->mt_psmtid);
209
	}
Linus Torvalds's avatar
Linus Torvalds committed
210 211
}

212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
static void print_ext_name(struct seq_file *m, int lvl,
			   struct sysinfo_3_2_2 *info)
{
	if (info->vm[lvl].ext_name_encoding == 0)
		return;
	if (info->ext_names[lvl][0] == 0)
		return;
	switch (info->vm[lvl].ext_name_encoding) {
	case 1: /* EBCDIC */
		EBCASC(info->ext_names[lvl], sizeof(info->ext_names[lvl]));
		break;
	case 2:	/* UTF-8 */
		break;
	default:
		return;
	}
	seq_printf(m, "VM%02d Extended Name:   %-.256s\n", lvl,
		   info->ext_names[lvl]);
}

static void print_uuid(struct seq_file *m, int i, struct sysinfo_3_2_2 *info)
{
	if (!memcmp(&info->vm[i].uuid, &NULL_UUID_BE, sizeof(uuid_be)))
		return;
	seq_printf(m, "VM%02d UUID:            %pUb\n", i, &info->vm[i].uuid);
}

239
static void stsi_3_2_2(struct seq_file *m, struct sysinfo_3_2_2 *info)
Linus Torvalds's avatar
Linus Torvalds committed
240
{
241 242
	int i;

243
	if (stsi(info, 3, 2, 2))
244
		return;
245
	for (i = 0; i < info->count; i++) {
246 247
		EBCASC(info->vm[i].name, sizeof(info->vm[i].name));
		EBCASC(info->vm[i].cpi, sizeof(info->vm[i].cpi));
248 249 250 251 252 253 254 255
		seq_putc(m, '\n');
		seq_printf(m, "VM%02d Name:            %-8.8s\n", i, info->vm[i].name);
		seq_printf(m, "VM%02d Control Program: %-16.16s\n", i, info->vm[i].cpi);
		seq_printf(m, "VM%02d Adjustment:      %d\n", i, info->vm[i].caf);
		seq_printf(m, "VM%02d CPUs Total:      %d\n", i, info->vm[i].cpus_total);
		seq_printf(m, "VM%02d CPUs Configured: %d\n", i, info->vm[i].cpus_configured);
		seq_printf(m, "VM%02d CPUs Standby:    %d\n", i, info->vm[i].cpus_standby);
		seq_printf(m, "VM%02d CPUs Reserved:   %d\n", i, info->vm[i].cpus_reserved);
256 257
		print_ext_name(m, i, info);
		print_uuid(m, i, info);
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260
	}
}

261
static int sysinfo_show(struct seq_file *m, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
262
{
263 264
	void *info = (void *)get_zeroed_page(GFP_KERNEL);
	int level;
265

Linus Torvalds's avatar
Linus Torvalds committed
266 267
	if (!info)
		return 0;
268
	level = stsi(NULL, 0, 0, 0);
269
	if (level >= 1)
270
		stsi_1_1_1(m, info);
271
	if (level >= 1)
272
		stsi_15_1_x(m, info);
273
	if (level >= 1)
274
		stsi_1_2_2(m, info);
275
	if (level >= 2)
276
		stsi_2_2_2(m, info);
277
	if (level >= 3)
278 279 280 281
		stsi_3_2_2(m, info);
	free_page((unsigned long)info);
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
282

283 284 285
static int sysinfo_open(struct inode *inode, struct file *file)
{
	return single_open(file, sysinfo_show, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
286 287
}

288 289 290 291 292 293 294 295
static const struct file_operations sysinfo_fops = {
	.open		= sysinfo_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int __init sysinfo_create_proc(void)
Linus Torvalds's avatar
Linus Torvalds committed
296
{
297
	proc_create("sysinfo", 0444, NULL, &sysinfo_fops);
Linus Torvalds's avatar
Linus Torvalds committed
298 299
	return 0;
}
300
device_initcall(sysinfo_create_proc);
Linus Torvalds's avatar
Linus Torvalds committed
301

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/*
 * Service levels interface.
 */

static DECLARE_RWSEM(service_level_sem);
static LIST_HEAD(service_level_list);

int register_service_level(struct service_level *slr)
{
	struct service_level *ptr;

	down_write(&service_level_sem);
	list_for_each_entry(ptr, &service_level_list, list)
		if (ptr == slr) {
			up_write(&service_level_sem);
			return -EEXIST;
		}
	list_add_tail(&slr->list, &service_level_list);
	up_write(&service_level_sem);
	return 0;
}
EXPORT_SYMBOL(register_service_level);

int unregister_service_level(struct service_level *slr)
{
	struct service_level *ptr, *next;
	int rc = -ENOENT;

	down_write(&service_level_sem);
	list_for_each_entry_safe(ptr, next, &service_level_list, list) {
		if (ptr != slr)
			continue;
		list_del(&ptr->list);
		rc = 0;
		break;
	}
	up_write(&service_level_sem);
	return rc;
}
EXPORT_SYMBOL(unregister_service_level);

static void *service_level_start(struct seq_file *m, loff_t *pos)
{
	down_read(&service_level_sem);
	return seq_list_start(&service_level_list, *pos);
}

static void *service_level_next(struct seq_file *m, void *p, loff_t *pos)
{
	return seq_list_next(p, &service_level_list, pos);
}

static void service_level_stop(struct seq_file *m, void *p)
{
	up_read(&service_level_sem);
}

static int service_level_show(struct seq_file *m, void *p)
{
	struct service_level *slr;

	slr = list_entry(p, struct service_level, list);
	slr->seq_print(m, slr);
	return 0;
}

static const struct seq_operations service_level_seq_ops = {
	.start		= service_level_start,
	.next		= service_level_next,
	.stop		= service_level_stop,
	.show		= service_level_show
};

static int service_level_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &service_level_seq_ops);
}

static const struct file_operations service_level_ops = {
	.open		= service_level_open,
	.read		= seq_read,
	.llseek 	= seq_lseek,
	.release	= seq_release
};

static void service_level_vm_print(struct seq_file *m,
				   struct service_level *slr)
{
	char *query_buffer, *str;

	query_buffer = kmalloc(1024, GFP_KERNEL | GFP_DMA);
	if (!query_buffer)
		return;
	cpcmd("QUERY CPLEVEL", query_buffer, 1024, NULL);
	str = strchr(query_buffer, '\n');
	if (str)
		*str = 0;
	seq_printf(m, "VM: %s\n", query_buffer);
	kfree(query_buffer);
}

static struct service_level service_level_vm = {
	.seq_print = service_level_vm_print
};

static __init int create_proc_service_level(void)
{
	proc_create("service_levels", 0, NULL, &service_level_ops);
	if (MACHINE_IS_VM)
		register_service_level(&service_level_vm);
	return 0;
}
subsys_initcall(create_proc_service_level);

416 417 418 419 420 421
/*
 * CPU capability might have changed. Therefore recalculate loops_per_jiffy.
 */
void s390_adjust_jiffies(void)
{
	struct sysinfo_1_2_2 *info;
422 423
	unsigned long capability;
	struct kernel_fpu fpu;
424 425 426 427 428

	info = (void *) get_zeroed_page(GFP_KERNEL);
	if (!info)
		return;

429
	if (stsi(info, 1, 2, 2) == 0) {
430 431 432 433 434 435 436 437 438
		/*
		 * Major sigh. The cpu capability encoding is "special".
		 * If the first 9 bits of info->capability are 0 then it
		 * is a 32 bit unsigned integer in the range 0 .. 2^23.
		 * If the first 9 bits are != 0 then it is a 32 bit float.
		 * In addition a lower value indicates a proportionally
		 * higher cpu capacity. Bogomips are the other way round.
		 * To get to a halfway suitable number we divide 1e7
		 * by the cpu capability number. Yes, that means a floating
439
		 * point division ..
440
		 */
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
		kernel_fpu_begin(&fpu, KERNEL_FPR);
		asm volatile(
			"	sfpc	%3\n"
			"	l	%0,%1\n"
			"	tmlh	%0,0xff80\n"
			"	jnz	0f\n"
			"	cefbr	%%f2,%0\n"
			"	j	1f\n"
			"0:	le	%%f2,%1\n"
			"1:	cefbr	%%f0,%2\n"
			"	debr	%%f0,%%f2\n"
			"	cgebr	%0,5,%%f0\n"
			: "=&d" (capability)
			: "Q" (info->capability), "d" (10000000), "d" (0)
			: "cc"
			);
457
		kernel_fpu_end(&fpu, KERNEL_FPR);
458 459 460 461 462 463 464 465 466 467 468 469 470
	} else
		/*
		 * Really old machine without stsi block for basic
		 * cpu information. Report 42.0 bogomips.
		 */
		capability = 42;
	loops_per_jiffy = capability * (500000/HZ);
	free_page((unsigned long) info);
}

/*
 * calibrate the delay loop
 */
471
void calibrate_delay(void)
472 473 474 475 476 477 478
{
	s390_adjust_jiffies();
	/* Print the good old Bogomips line .. */
	printk(KERN_DEBUG "Calibrating delay loop (skipped)... "
	       "%lu.%02lu BogoMIPS preset\n", loops_per_jiffy/(500000/HZ),
	       (loops_per_jiffy/(5000/HZ)) % 100);
}