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 static void log_plpar_hcall_return(unsigned long rc
, char *tag
)
139 printk(KERN_INFO
"plpar-hcall (%s) "
140 "Hardware fault\n", tag
);
143 printk(KERN_INFO
"plpar-hcall (%s) "
144 "Function not allowed\n", tag
);
147 printk(KERN_INFO
"plpar-hcall (%s) "
148 "Not authorized to this function\n", tag
);
151 printk(KERN_INFO
"plpar-hcall (%s) "
152 "Bad parameter(s)\n",tag
);
155 printk(KERN_INFO
"plpar-hcall (%s) "
156 "Unexpected rc(0x%lx)\n", tag
, rc
);
161 * H_GET_PPP hcall returns info in 4 parms.
162 * entitled_capacity,unallocated_capacity,
163 * aggregation, resource_capability).
165 * R4 = Entitled Processor Capacity Percentage.
166 * R5 = Unallocated Processor Capacity Percentage.
167 * R6 (AABBCCDDEEFFGGHH).
168 * XXXX - reserved (0)
169 * XXXX - reserved (0)
170 * XXXX - Group Number
171 * XXXX - Pool Number.
172 * R7 (IIJJKKLLMMNNOOPP).
174 * XX - bit 0-6 reserved (0). bit 7 is Capped indicator.
175 * XX - variable processor Capacity Weight
176 * XX - Unallocated Variable Processor Capacity Weight.
177 * XXXX - Active processors in Physical Processor Pool.
178 * XXXX - Processors active on platform.
180 static unsigned int h_get_ppp(unsigned long *entitled
,
181 unsigned long *unallocated
,
182 unsigned long *aggregation
,
183 unsigned long *resource
)
186 unsigned long retbuf
[PLPAR_HCALL_BUFSIZE
];
188 rc
= plpar_hcall(H_GET_PPP
, retbuf
);
190 *entitled
= retbuf
[0];
191 *unallocated
= retbuf
[1];
192 *aggregation
= retbuf
[2];
193 *resource
= retbuf
[3];
195 log_plpar_hcall_return(rc
, "H_GET_PPP");
200 static void h_pic(unsigned long *pool_idle_time
, unsigned long *num_procs
)
203 unsigned long retbuf
[PLPAR_HCALL_BUFSIZE
];
205 rc
= plpar_hcall(H_PIC
, retbuf
);
207 *pool_idle_time
= retbuf
[0];
208 *num_procs
= retbuf
[1];
210 if (rc
!= H_AUTHORITY
)
211 log_plpar_hcall_return(rc
, "H_PIC");
214 #define SPLPAR_CHARACTERISTICS_TOKEN 20
215 #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
218 * parse_system_parameter_string()
219 * Retrieve the potential_processors, max_entitled_capacity and friends
220 * through the get-system-parameter rtas call. Replace keyword strings as
223 static void parse_system_parameter_string(struct seq_file
*m
)
227 unsigned char *local_buffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
229 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
230 __FILE__
, __FUNCTION__
, __LINE__
);
234 spin_lock(&rtas_data_buf_lock
);
235 memset(rtas_data_buf
, 0, SPLPAR_MAXLENGTH
);
236 call_status
= rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
238 SPLPAR_CHARACTERISTICS_TOKEN
,
241 memcpy(local_buffer
, rtas_data_buf
, SPLPAR_MAXLENGTH
);
242 spin_unlock(&rtas_data_buf_lock
);
244 if (call_status
!= 0) {
246 "%s %s Error calling get-system-parameter (0x%x)\n",
247 __FILE__
, __FUNCTION__
, call_status
);
251 char *workbuffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
253 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
254 __FILE__
, __FUNCTION__
, __LINE__
);
259 printk(KERN_INFO
"success calling get-system-parameter \n");
261 splpar_strlen
= local_buffer
[0] * 256 + local_buffer
[1];
262 local_buffer
+= 2; /* step over strlen value */
264 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
267 while ((*local_buffer
) && (idx
< splpar_strlen
)) {
268 workbuffer
[w_idx
++] = local_buffer
[idx
++];
269 if ((local_buffer
[idx
] == ',')
270 || (local_buffer
[idx
] == '\0')) {
271 workbuffer
[w_idx
] = '\0';
273 /* avoid the empty string */
274 seq_printf(m
, "%s\n", workbuffer
);
276 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
277 idx
++; /* skip the comma */
279 } else if (local_buffer
[idx
] == '=') {
280 /* code here to replace workbuffer contents
281 with different keyword strings */
282 if (0 == strcmp(workbuffer
, "MaxEntCap")) {
284 "partition_max_entitled_capacity");
285 w_idx
= strlen(workbuffer
);
287 if (0 == strcmp(workbuffer
, "MaxPlatProcs")) {
289 "system_potential_processors");
290 w_idx
= strlen(workbuffer
);
295 local_buffer
-= 2; /* back up over strlen value */
300 /* Return the number of processors in the system.
301 * This function reads through the device tree and counts
302 * the virtual processors, this does not include threads.
304 static int lparcfg_count_active_processors(void)
306 struct device_node
*cpus_dn
= NULL
;
309 while ((cpus_dn
= of_find_node_by_type(cpus_dn
, "cpu"))) {
311 printk(KERN_ERR
"cpus_dn %p \n", cpus_dn
);
318 static int pseries_lparcfg_data(struct seq_file
*m
, void *v
)
320 int partition_potential_processors
;
321 int partition_active_processors
;
322 struct device_node
*rtas_node
;
323 const int *lrdrp
= NULL
;
325 rtas_node
= of_find_node_by_path("/rtas");
327 lrdrp
= of_get_property(rtas_node
, "ibm,lrdr-capacity", NULL
);
330 partition_potential_processors
= vdso_data
->processorCount
;
332 partition_potential_processors
= *(lrdrp
+ 4);
334 of_node_put(rtas_node
);
336 partition_active_processors
= lparcfg_count_active_processors();
338 if (firmware_has_feature(FW_FEATURE_SPLPAR
)) {
339 unsigned long h_entitled
, h_unallocated
;
340 unsigned long h_aggregation
, h_resource
;
341 unsigned long pool_idle_time
, pool_procs
;
344 h_get_ppp(&h_entitled
, &h_unallocated
, &h_aggregation
,
347 seq_printf(m
, "R4=0x%lx\n", h_entitled
);
348 seq_printf(m
, "R5=0x%lx\n", h_unallocated
);
349 seq_printf(m
, "R6=0x%lx\n", h_aggregation
);
350 seq_printf(m
, "R7=0x%lx\n", h_resource
);
354 /* this call handles the ibm,get-system-parameter contents */
355 parse_system_parameter_string(m
);
357 seq_printf(m
, "partition_entitled_capacity=%ld\n", h_entitled
);
359 seq_printf(m
, "group=%ld\n", (h_aggregation
>> 2 * 8) & 0xffff);
361 seq_printf(m
, "system_active_processors=%ld\n",
362 (h_resource
>> 0 * 8) & 0xffff);
364 /* pool related entries are apropriate for shared configs */
365 if (lppaca
[0].shared_proc
) {
367 h_pic(&pool_idle_time
, &pool_procs
);
369 seq_printf(m
, "pool=%ld\n",
370 (h_aggregation
>> 0 * 8) & 0xffff);
372 /* report pool_capacity in percentage */
373 seq_printf(m
, "pool_capacity=%ld\n",
374 ((h_resource
>> 2 * 8) & 0xffff) * 100);
376 seq_printf(m
, "pool_idle_time=%ld\n", pool_idle_time
);
378 seq_printf(m
, "pool_num_procs=%ld\n", pool_procs
);
381 seq_printf(m
, "unallocated_capacity_weight=%ld\n",
382 (h_resource
>> 4 * 8) & 0xFF);
384 seq_printf(m
, "capacity_weight=%ld\n",
385 (h_resource
>> 5 * 8) & 0xFF);
387 seq_printf(m
, "capped=%ld\n", (h_resource
>> 6 * 8) & 0x01);
389 seq_printf(m
, "unallocated_capacity=%ld\n", h_unallocated
);
391 seq_printf(m
, "purr=%ld\n", purr
);
393 } else { /* non SPLPAR case */
395 seq_printf(m
, "system_active_processors=%d\n",
396 partition_potential_processors
);
398 seq_printf(m
, "system_potential_processors=%d\n",
399 partition_potential_processors
);
401 seq_printf(m
, "partition_max_entitled_capacity=%d\n",
402 partition_potential_processors
* 100);
404 seq_printf(m
, "partition_entitled_capacity=%d\n",
405 partition_active_processors
* 100);
408 seq_printf(m
, "partition_active_processors=%d\n",
409 partition_active_processors
);
411 seq_printf(m
, "partition_potential_processors=%d\n",
412 partition_potential_processors
);
414 seq_printf(m
, "shared_processor_mode=%d\n", lppaca
[0].shared_proc
);
420 * Interface for changing system parameters (variable capacity weight
421 * and entitled capacity). Format of input is "param_name=value";
422 * anything after value is ignored. Valid parameters at this time are
423 * "partition_entitled_capacity" and "capacity_weight". We use
424 * H_SET_PPP to alter parameters.
426 * This function should be invoked only on systems with
429 static ssize_t
lparcfg_write(struct file
*file
, const char __user
* buf
,
430 size_t count
, loff_t
* off
)
434 u64 new_entitled
, *new_entitled_ptr
= &new_entitled
;
435 u8 new_weight
, *new_weight_ptr
= &new_weight
;
437 unsigned long current_entitled
; /* parameters for h_get_ppp */
439 unsigned long resource
;
442 ssize_t retval
= -ENOMEM
;
444 if (!firmware_has_feature(FW_FEATURE_SPLPAR
) ||
445 firmware_has_feature(FW_FEATURE_ISERIES
))
448 kbuf
= kmalloc(count
, GFP_KERNEL
);
453 if (copy_from_user(kbuf
, buf
, count
))
457 kbuf
[count
- 1] = '\0';
458 tmp
= strchr(kbuf
, '=');
464 if (!strcmp(kbuf
, "partition_entitled_capacity")) {
466 *new_entitled_ptr
= (u64
) simple_strtoul(tmp
, &endp
, 10);
469 new_weight_ptr
= ¤t_weight
;
470 } else if (!strcmp(kbuf
, "capacity_weight")) {
472 *new_weight_ptr
= (u8
) simple_strtoul(tmp
, &endp
, 10);
475 new_entitled_ptr
= ¤t_entitled
;
479 /* Get our current parameters */
480 retval
= h_get_ppp(¤t_entitled
, &dummy
, &dummy
, &resource
);
486 current_weight
= (resource
>> 5 * 8) & 0xFF;
488 pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
489 __FUNCTION__
, current_entitled
, current_weight
);
491 pr_debug("%s: new_entitled = %lu, new_weight = %u\n",
492 __FUNCTION__
, *new_entitled_ptr
, *new_weight_ptr
);
494 retval
= plpar_hcall_norets(H_SET_PPP
, *new_entitled_ptr
,
497 if (retval
== H_SUCCESS
|| retval
== H_CONSTRAINED
) {
499 } else if (retval
== H_BUSY
) {
501 } else if (retval
== H_HARDWARE
) {
503 } else if (retval
== H_PARAMETER
) {
506 printk(KERN_WARNING
"%s: received unknown hv return code %ld",
507 __FUNCTION__
, retval
);
516 #else /* CONFIG_PPC_PSERIES */
518 static int pseries_lparcfg_data(struct seq_file
*m
, void *v
)
523 static ssize_t
lparcfg_write(struct file
*file
, const char __user
* buf
,
524 size_t count
, loff_t
* off
)
529 #endif /* CONFIG_PPC_PSERIES */
531 static int lparcfg_data(struct seq_file
*m
, void *v
)
533 struct device_node
*rootdn
;
534 const char *model
= "";
535 const char *system_id
= "";
537 const unsigned int *lp_index_ptr
;
538 unsigned int lp_index
= 0;
540 seq_printf(m
, "%s %s \n", MODULE_NAME
, MODULE_VERS
);
542 rootdn
= of_find_node_by_path("/");
544 tmp
= of_get_property(rootdn
, "model", NULL
);
547 /* Skip "IBM," - see platforms/iseries/dt.c */
548 if (firmware_has_feature(FW_FEATURE_ISERIES
))
551 tmp
= of_get_property(rootdn
, "system-id", NULL
);
554 /* Skip "IBM," - see platforms/iseries/dt.c */
555 if (firmware_has_feature(FW_FEATURE_ISERIES
))
558 lp_index_ptr
= of_get_property(rootdn
, "ibm,partition-no",
561 lp_index
= *lp_index_ptr
;
564 seq_printf(m
, "serial_number=%s\n", system_id
);
565 seq_printf(m
, "system_type=%s\n", model
);
566 seq_printf(m
, "partition_id=%d\n", (int)lp_index
);
568 if (firmware_has_feature(FW_FEATURE_ISERIES
))
569 return iseries_lparcfg_data(m
, v
);
570 return pseries_lparcfg_data(m
, v
);
573 static int lparcfg_open(struct inode
*inode
, struct file
*file
)
575 return single_open(file
, lparcfg_data
, NULL
);
578 const struct file_operations lparcfg_fops
= {
579 .owner
= THIS_MODULE
,
581 .write
= lparcfg_write
,
582 .open
= lparcfg_open
,
583 .release
= single_release
,
586 int __init
lparcfg_init(void)
588 struct proc_dir_entry
*ent
;
589 mode_t mode
= S_IRUSR
| S_IRGRP
| S_IROTH
;
591 /* Allow writing if we have FW_FEATURE_SPLPAR */
592 if (firmware_has_feature(FW_FEATURE_SPLPAR
) &&
593 !firmware_has_feature(FW_FEATURE_ISERIES
))
596 ent
= create_proc_entry("ppc64/lparcfg", mode
, NULL
);
598 ent
->proc_fops
= &lparcfg_fops
;
599 ent
->data
= kmalloc(LPARCFG_BUFF_SIZE
, GFP_KERNEL
);
602 "Failed to allocate buffer for lparcfg\n");
603 remove_proc_entry("lparcfg", ent
->parent
);
607 printk(KERN_ERR
"Failed to create ppc64/lparcfg\n");
611 proc_ppc64_lparcfg
= ent
;
615 void __exit
lparcfg_cleanup(void)
617 if (proc_ppc64_lparcfg
) {
618 kfree(proc_ppc64_lparcfg
->data
);
619 remove_proc_entry("lparcfg", proc_ppc64_lparcfg
->parent
);
623 module_init(lparcfg_init
);
624 module_exit(lparcfg_cleanup
);
625 MODULE_DESCRIPTION("Interface for LPAR configuration data");
626 MODULE_AUTHOR("Dave Engebretsen");
627 MODULE_LICENSE("GPL");