2 * PowerPC64 LPAR Configuration Information Driver
4 * Dave Engebretsen engebret@us.ibm.com
5 * Copyright (c) 2003 Dave Engebretsen
6 * Will Schmidt willschm@us.ibm.com
7 * SPLPAR updates, Copyright (c) 2003 Will Schmidt IBM Corporation.
8 * seq_file updates, Copyright (c) 2004 Will Schmidt IBM Corporation.
9 * Nathan Lynch nathanl@austin.ibm.com
10 * Added lparcfg_write, Copyright (C) 2004 Nathan Lynch IBM Corporation.
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
17 * This driver creates a proc file at /proc/ppc64/lparcfg which contains
18 * keyword - value pairs that specify the configuration of the partition.
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/errno.h>
24 #include <linux/proc_fs.h>
25 #include <linux/init.h>
26 #include <linux/seq_file.h>
27 #include <asm/uaccess.h>
28 #include <asm/iseries/hv_lp_config.h>
29 #include <asm/lppaca.h>
30 #include <asm/hvcall.h>
31 #include <asm/firmware.h>
33 #include <asm/system.h>
36 #include <asm/vdso_datapage.h>
38 #define MODULE_VERS "1.7"
39 #define MODULE_NAME "lparcfg"
41 /* #define LPARCFG_DEBUG */
43 static struct proc_dir_entry *proc_ppc64_lparcfg;
44 #define LPARCFG_BUFF_SIZE 4096
47 * Track sum of all purrs across all processors. This is used to further
48 * calculate usage values by different applications
50 static unsigned long get_purr(void)
52 unsigned long sum_purr = 0;
55 for_each_possible_cpu(cpu) {
56 if (firmware_has_feature(FW_FEATURE_ISERIES))
57 sum_purr += lppaca[cpu].emulated_time_base;
61 cu = &per_cpu(cpu_usage_array, cpu);
62 sum_purr += cu->current_tb;
68 #ifdef CONFIG_PPC_ISERIES
71 * Methods used to fetch LPAR data when running on an iSeries platform.
73 static int iseries_lparcfg_data(struct seq_file *m, void *v)
75 unsigned long pool_id;
76 int shared, entitled_capacity, max_entitled_capacity;
77 int processors, max_processors;
78 unsigned long purr = get_purr();
80 shared = (int)(get_lppaca()->shared_proc);
82 seq_printf(m, "system_active_processors=%d\n",
83 (int)HvLpConfig_getSystemPhysicalProcessors());
85 seq_printf(m, "system_potential_processors=%d\n",
86 (int)HvLpConfig_getSystemPhysicalProcessors());
88 processors = (int)HvLpConfig_getPhysicalProcessors();
89 seq_printf(m, "partition_active_processors=%d\n", processors);
91 max_processors = (int)HvLpConfig_getMaxPhysicalProcessors();
92 seq_printf(m, "partition_potential_processors=%d\n", max_processors);
95 entitled_capacity = HvLpConfig_getSharedProcUnits();
96 max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits();
98 entitled_capacity = processors * 100;
99 max_entitled_capacity = max_processors * 100;
101 seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity);
103 seq_printf(m, "partition_max_entitled_capacity=%d\n",
104 max_entitled_capacity);
107 pool_id = HvLpConfig_getSharedPoolIndex();
108 seq_printf(m, "pool=%d\n", (int)pool_id);
109 seq_printf(m, "pool_capacity=%d\n",
110 (int)(HvLpConfig_getNumProcsInSharedPool(pool_id) *
112 seq_printf(m, "purr=%ld\n", purr);
115 seq_printf(m, "shared_processor_mode=%d\n", shared);
120 #else /* CONFIG_PPC_ISERIES */
122 static int iseries_lparcfg_data(struct seq_file *m, void *v)
127 #endif /* CONFIG_PPC_ISERIES */
129 #ifdef CONFIG_PPC_PSERIES
131 * Methods used to fetch LPAR data when running on a pSeries platform.
133 /* find a better place for this function... */
134 static void log_plpar_hcall_return(unsigned long rc, char *tag)
136 if (rc == 0) /* success, return */
138 /* check for null tag ? */
139 if (rc == H_HARDWARE)
141 "plpar-hcall (%s) failed with hardware fault\n", tag);
142 else if (rc == H_FUNCTION)
144 "plpar-hcall (%s) failed; function not allowed\n", tag);
145 else if (rc == H_AUTHORITY)
147 "plpar-hcall (%s) failed; not authorized to this"
149 else if (rc == H_PARAMETER)
150 printk(KERN_INFO "plpar-hcall (%s) failed; Bad parameter(s)\n",
154 "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",
160 * H_GET_PPP hcall returns info in 4 parms.
161 * entitled_capacity,unallocated_capacity,
162 * aggregation, resource_capability).
164 * R4 = Entitled Processor Capacity Percentage.
165 * R5 = Unallocated Processor Capacity Percentage.
166 * R6 (AABBCCDDEEFFGGHH).
167 * XXXX - reserved (0)
168 * XXXX - reserved (0)
169 * XXXX - Group Number
170 * XXXX - Pool Number.
171 * R7 (IIJJKKLLMMNNOOPP).
173 * XX - bit 0-6 reserved (0). bit 7 is Capped indicator.
174 * XX - variable processor Capacity Weight
175 * XX - Unallocated Variable Processor Capacity Weight.
176 * XXXX - Active processors in Physical Processor Pool.
177 * XXXX - Processors active on platform.
179 static unsigned int h_get_ppp(unsigned long *entitled,
180 unsigned long *unallocated,
181 unsigned long *aggregation,
182 unsigned long *resource)
185 rc = plpar_hcall_4out(H_GET_PPP, 0, 0, 0, 0, entitled, unallocated,
186 aggregation, resource);
188 log_plpar_hcall_return(rc, "H_GET_PPP");
193 static void h_pic(unsigned long *pool_idle_time, unsigned long *num_procs)
197 rc = plpar_hcall(H_PIC, 0, 0, 0, 0, pool_idle_time, num_procs, &dummy);
199 if (rc != H_AUTHORITY)
200 log_plpar_hcall_return(rc, "H_PIC");
203 #define SPLPAR_CHARACTERISTICS_TOKEN 20
204 #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
207 * parse_system_parameter_string()
208 * Retrieve the potential_processors, max_entitled_capacity and friends
209 * through the get-system-parameter rtas call. Replace keyword strings as
212 static void parse_system_parameter_string(struct seq_file *m)
216 unsigned char *local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
218 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
219 __FILE__, __FUNCTION__, __LINE__);
223 spin_lock(&rtas_data_buf_lock);
224 memset(rtas_data_buf, 0, SPLPAR_MAXLENGTH);
225 call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
227 SPLPAR_CHARACTERISTICS_TOKEN,
230 memcpy(local_buffer, rtas_data_buf, SPLPAR_MAXLENGTH);
231 spin_unlock(&rtas_data_buf_lock);
233 if (call_status != 0) {
235 "%s %s Error calling get-system-parameter (0x%x)\n",
236 __FILE__, __FUNCTION__, call_status);
240 char *workbuffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
242 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
243 __FILE__, __FUNCTION__, __LINE__);
248 printk(KERN_INFO "success calling get-system-parameter \n");
250 splpar_strlen = local_buffer[0] * 256 + local_buffer[1];
251 local_buffer += 2; /* step over strlen value */
253 memset(workbuffer, 0, SPLPAR_MAXLENGTH);
256 while ((*local_buffer) && (idx < splpar_strlen)) {
257 workbuffer[w_idx++] = local_buffer[idx++];
258 if ((local_buffer[idx] == ',')
259 || (local_buffer[idx] == '\0')) {
260 workbuffer[w_idx] = '\0';
262 /* avoid the empty string */
263 seq_printf(m, "%s\n", workbuffer);
265 memset(workbuffer, 0, SPLPAR_MAXLENGTH);
266 idx++; /* skip the comma */
268 } else if (local_buffer[idx] == '=') {
269 /* code here to replace workbuffer contents
270 with different keyword strings */
271 if (0 == strcmp(workbuffer, "MaxEntCap")) {
273 "partition_max_entitled_capacity");
274 w_idx = strlen(workbuffer);
276 if (0 == strcmp(workbuffer, "MaxPlatProcs")) {
278 "system_potential_processors");
279 w_idx = strlen(workbuffer);
284 local_buffer -= 2; /* back up over strlen value */
289 /* Return the number of processors in the system.
290 * This function reads through the device tree and counts
291 * the virtual processors, this does not include threads.
293 static int lparcfg_count_active_processors(void)
295 struct device_node *cpus_dn = NULL;
298 while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) {
300 printk(KERN_ERR "cpus_dn %p \n", cpus_dn);
307 static int pseries_lparcfg_data(struct seq_file *m, void *v)
309 int partition_potential_processors;
310 int partition_active_processors;
311 struct device_node *rtas_node;
314 rtas_node = find_path_device("/rtas");
316 lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity",
320 partition_potential_processors = vdso_data->processorCount;
322 partition_potential_processors = *(lrdrp + 4);
325 partition_active_processors = lparcfg_count_active_processors();
327 if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
328 unsigned long h_entitled, h_unallocated;
329 unsigned long h_aggregation, h_resource;
330 unsigned long pool_idle_time, pool_procs;
333 h_get_ppp(&h_entitled, &h_unallocated, &h_aggregation,
336 seq_printf(m, "R4=0x%lx\n", h_entitled);
337 seq_printf(m, "R5=0x%lx\n", h_unallocated);
338 seq_printf(m, "R6=0x%lx\n", h_aggregation);
339 seq_printf(m, "R7=0x%lx\n", h_resource);
343 /* this call handles the ibm,get-system-parameter contents */
344 parse_system_parameter_string(m);
346 seq_printf(m, "partition_entitled_capacity=%ld\n", h_entitled);
348 seq_printf(m, "group=%ld\n", (h_aggregation >> 2 * 8) & 0xffff);
350 seq_printf(m, "system_active_processors=%ld\n",
351 (h_resource >> 0 * 8) & 0xffff);
353 /* pool related entries are apropriate for shared configs */
354 if (lppaca[0].shared_proc) {
356 h_pic(&pool_idle_time, &pool_procs);
358 seq_printf(m, "pool=%ld\n",
359 (h_aggregation >> 0 * 8) & 0xffff);
361 /* report pool_capacity in percentage */
362 seq_printf(m, "pool_capacity=%ld\n",
363 ((h_resource >> 2 * 8) & 0xffff) * 100);
365 seq_printf(m, "pool_idle_time=%ld\n", pool_idle_time);
367 seq_printf(m, "pool_num_procs=%ld\n", pool_procs);
370 seq_printf(m, "unallocated_capacity_weight=%ld\n",
371 (h_resource >> 4 * 8) & 0xFF);
373 seq_printf(m, "capacity_weight=%ld\n",
374 (h_resource >> 5 * 8) & 0xFF);
376 seq_printf(m, "capped=%ld\n", (h_resource >> 6 * 8) & 0x01);
378 seq_printf(m, "unallocated_capacity=%ld\n", h_unallocated);
380 seq_printf(m, "purr=%ld\n", purr);
382 } else { /* non SPLPAR case */
384 seq_printf(m, "system_active_processors=%d\n",
385 partition_potential_processors);
387 seq_printf(m, "system_potential_processors=%d\n",
388 partition_potential_processors);
390 seq_printf(m, "partition_max_entitled_capacity=%d\n",
391 partition_potential_processors * 100);
393 seq_printf(m, "partition_entitled_capacity=%d\n",
394 partition_active_processors * 100);
397 seq_printf(m, "partition_active_processors=%d\n",
398 partition_active_processors);
400 seq_printf(m, "partition_potential_processors=%d\n",
401 partition_potential_processors);
403 seq_printf(m, "shared_processor_mode=%d\n", lppaca[0].shared_proc);
409 * Interface for changing system parameters (variable capacity weight
410 * and entitled capacity). Format of input is "param_name=value";
411 * anything after value is ignored. Valid parameters at this time are
412 * "partition_entitled_capacity" and "capacity_weight". We use
413 * H_SET_PPP to alter parameters.
415 * This function should be invoked only on systems with
418 static ssize_t lparcfg_write(struct file *file, const char __user * buf,
419 size_t count, loff_t * off)
423 u64 new_entitled, *new_entitled_ptr = &new_entitled;
424 u8 new_weight, *new_weight_ptr = &new_weight;
426 unsigned long current_entitled; /* parameters for h_get_ppp */
428 unsigned long resource;
431 ssize_t retval = -ENOMEM;
433 kbuf = kmalloc(count, GFP_KERNEL);
438 if (copy_from_user(kbuf, buf, count))
442 kbuf[count - 1] = '\0';
443 tmp = strchr(kbuf, '=');
449 if (!strcmp(kbuf, "partition_entitled_capacity")) {
451 *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
454 new_weight_ptr = ¤t_weight;
455 } else if (!strcmp(kbuf, "capacity_weight")) {
457 *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
460 new_entitled_ptr = ¤t_entitled;
464 /* Get our current parameters */
465 retval = h_get_ppp(¤t_entitled, &dummy, &dummy, &resource);
471 current_weight = (resource >> 5 * 8) & 0xFF;
473 pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
474 __FUNCTION__, current_entitled, current_weight);
476 pr_debug("%s: new_entitled = %lu, new_weight = %u\n",
477 __FUNCTION__, *new_entitled_ptr, *new_weight_ptr);
479 retval = plpar_hcall_norets(H_SET_PPP, *new_entitled_ptr,
482 if (retval == H_SUCCESS || retval == H_CONSTRAINED) {
484 } else if (retval == H_BUSY) {
486 } else if (retval == H_HARDWARE) {
488 } else if (retval == H_PARAMETER) {
491 printk(KERN_WARNING "%s: received unknown hv return code %ld",
492 __FUNCTION__, retval);
501 #else /* CONFIG_PPC_PSERIES */
503 static int pseries_lparcfg_data(struct seq_file *m, void *v)
508 static ssize_t lparcfg_write(struct file *file, const char __user * buf,
509 size_t count, loff_t * off)
514 #endif /* CONFIG_PPC_PSERIES */
516 static int lparcfg_data(struct seq_file *m, void *v)
518 struct device_node *rootdn;
519 const char *model = "";
520 const char *system_id = "";
522 unsigned int *lp_index_ptr, lp_index = 0;
524 seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
526 rootdn = find_path_device("/");
528 tmp = get_property(rootdn, "model", NULL);
531 /* Skip "IBM," - see platforms/iseries/dt.c */
532 if (firmware_has_feature(FW_FEATURE_ISERIES))
535 tmp = get_property(rootdn, "system-id", NULL);
538 /* Skip "IBM," - see platforms/iseries/dt.c */
539 if (firmware_has_feature(FW_FEATURE_ISERIES))
542 lp_index_ptr = (unsigned int *)
543 get_property(rootdn, "ibm,partition-no", NULL);
545 lp_index = *lp_index_ptr;
547 seq_printf(m, "serial_number=%s\n", system_id);
548 seq_printf(m, "system_type=%s\n", model);
549 seq_printf(m, "partition_id=%d\n", (int)lp_index);
551 if (firmware_has_feature(FW_FEATURE_ISERIES))
552 return iseries_lparcfg_data(m, v);
553 return pseries_lparcfg_data(m, v);
556 static int lparcfg_open(struct inode *inode, struct file *file)
558 return single_open(file, lparcfg_data, NULL);
561 struct file_operations lparcfg_fops = {
562 .owner = THIS_MODULE,
564 .open = lparcfg_open,
565 .release = single_release,
568 int __init lparcfg_init(void)
570 struct proc_dir_entry *ent;
571 mode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
573 /* Allow writing if we have FW_FEATURE_SPLPAR */
574 if (firmware_has_feature(FW_FEATURE_SPLPAR) &&
575 !firmware_has_feature(FW_FEATURE_ISERIES)) {
576 lparcfg_fops.write = lparcfg_write;
580 ent = create_proc_entry("ppc64/lparcfg", mode, NULL);
582 ent->proc_fops = &lparcfg_fops;
583 ent->data = kmalloc(LPARCFG_BUFF_SIZE, GFP_KERNEL);
586 "Failed to allocate buffer for lparcfg\n");
587 remove_proc_entry("lparcfg", ent->parent);
591 printk(KERN_ERR "Failed to create ppc64/lparcfg\n");
595 proc_ppc64_lparcfg = ent;
599 void __exit lparcfg_cleanup(void)
601 if (proc_ppc64_lparcfg) {
602 kfree(proc_ppc64_lparcfg->data);
603 remove_proc_entry("lparcfg", proc_ppc64_lparcfg->parent);
607 module_init(lparcfg_init);
608 module_exit(lparcfg_cleanup);
609 MODULE_DESCRIPTION("Interface for LPAR configuration data");
610 MODULE_AUTHOR("Dave Engebretsen");
611 MODULE_LICENSE("GPL");