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 unsigned long retbuf
[PLPAR_HCALL_BUFSIZE
];
187 rc
= plpar_hcall(H_GET_PPP
, retbuf
);
189 *entitled
= retbuf
[0];
190 *unallocated
= retbuf
[1];
191 *aggregation
= retbuf
[2];
192 *resource
= retbuf
[3];
194 log_plpar_hcall_return(rc
, "H_GET_PPP");
199 static void h_pic(unsigned long *pool_idle_time
, unsigned long *num_procs
)
202 unsigned long retbuf
[PLPAR_HCALL_BUFSIZE
];
204 rc
= plpar_hcall(H_PIC
, retbuf
);
206 *pool_idle_time
= retbuf
[0];
207 *num_procs
= retbuf
[1];
209 if (rc
!= H_AUTHORITY
)
210 log_plpar_hcall_return(rc
, "H_PIC");
213 #define SPLPAR_CHARACTERISTICS_TOKEN 20
214 #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
217 * parse_system_parameter_string()
218 * Retrieve the potential_processors, max_entitled_capacity and friends
219 * through the get-system-parameter rtas call. Replace keyword strings as
222 static void parse_system_parameter_string(struct seq_file
*m
)
226 unsigned char *local_buffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
228 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
229 __FILE__
, __FUNCTION__
, __LINE__
);
233 spin_lock(&rtas_data_buf_lock
);
234 memset(rtas_data_buf
, 0, SPLPAR_MAXLENGTH
);
235 call_status
= rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
237 SPLPAR_CHARACTERISTICS_TOKEN
,
240 memcpy(local_buffer
, rtas_data_buf
, SPLPAR_MAXLENGTH
);
241 spin_unlock(&rtas_data_buf_lock
);
243 if (call_status
!= 0) {
245 "%s %s Error calling get-system-parameter (0x%x)\n",
246 __FILE__
, __FUNCTION__
, call_status
);
250 char *workbuffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
252 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
253 __FILE__
, __FUNCTION__
, __LINE__
);
258 printk(KERN_INFO
"success calling get-system-parameter \n");
260 splpar_strlen
= local_buffer
[0] * 256 + local_buffer
[1];
261 local_buffer
+= 2; /* step over strlen value */
263 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
266 while ((*local_buffer
) && (idx
< splpar_strlen
)) {
267 workbuffer
[w_idx
++] = local_buffer
[idx
++];
268 if ((local_buffer
[idx
] == ',')
269 || (local_buffer
[idx
] == '\0')) {
270 workbuffer
[w_idx
] = '\0';
272 /* avoid the empty string */
273 seq_printf(m
, "%s\n", workbuffer
);
275 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
276 idx
++; /* skip the comma */
278 } else if (local_buffer
[idx
] == '=') {
279 /* code here to replace workbuffer contents
280 with different keyword strings */
281 if (0 == strcmp(workbuffer
, "MaxEntCap")) {
283 "partition_max_entitled_capacity");
284 w_idx
= strlen(workbuffer
);
286 if (0 == strcmp(workbuffer
, "MaxPlatProcs")) {
288 "system_potential_processors");
289 w_idx
= strlen(workbuffer
);
294 local_buffer
-= 2; /* back up over strlen value */
299 /* Return the number of processors in the system.
300 * This function reads through the device tree and counts
301 * the virtual processors, this does not include threads.
303 static int lparcfg_count_active_processors(void)
305 struct device_node
*cpus_dn
= NULL
;
308 while ((cpus_dn
= of_find_node_by_type(cpus_dn
, "cpu"))) {
310 printk(KERN_ERR
"cpus_dn %p \n", cpus_dn
);
317 static int pseries_lparcfg_data(struct seq_file
*m
, void *v
)
319 int partition_potential_processors
;
320 int partition_active_processors
;
321 struct device_node
*rtas_node
;
322 const int *lrdrp
= NULL
;
324 rtas_node
= find_path_device("/rtas");
326 lrdrp
= of_get_property(rtas_node
, "ibm,lrdr-capacity", NULL
);
329 partition_potential_processors
= vdso_data
->processorCount
;
331 partition_potential_processors
= *(lrdrp
+ 4);
334 partition_active_processors
= lparcfg_count_active_processors();
336 if (firmware_has_feature(FW_FEATURE_SPLPAR
)) {
337 unsigned long h_entitled
, h_unallocated
;
338 unsigned long h_aggregation
, h_resource
;
339 unsigned long pool_idle_time
, pool_procs
;
342 h_get_ppp(&h_entitled
, &h_unallocated
, &h_aggregation
,
345 seq_printf(m
, "R4=0x%lx\n", h_entitled
);
346 seq_printf(m
, "R5=0x%lx\n", h_unallocated
);
347 seq_printf(m
, "R6=0x%lx\n", h_aggregation
);
348 seq_printf(m
, "R7=0x%lx\n", h_resource
);
352 /* this call handles the ibm,get-system-parameter contents */
353 parse_system_parameter_string(m
);
355 seq_printf(m
, "partition_entitled_capacity=%ld\n", h_entitled
);
357 seq_printf(m
, "group=%ld\n", (h_aggregation
>> 2 * 8) & 0xffff);
359 seq_printf(m
, "system_active_processors=%ld\n",
360 (h_resource
>> 0 * 8) & 0xffff);
362 /* pool related entries are apropriate for shared configs */
363 if (lppaca
[0].shared_proc
) {
365 h_pic(&pool_idle_time
, &pool_procs
);
367 seq_printf(m
, "pool=%ld\n",
368 (h_aggregation
>> 0 * 8) & 0xffff);
370 /* report pool_capacity in percentage */
371 seq_printf(m
, "pool_capacity=%ld\n",
372 ((h_resource
>> 2 * 8) & 0xffff) * 100);
374 seq_printf(m
, "pool_idle_time=%ld\n", pool_idle_time
);
376 seq_printf(m
, "pool_num_procs=%ld\n", pool_procs
);
379 seq_printf(m
, "unallocated_capacity_weight=%ld\n",
380 (h_resource
>> 4 * 8) & 0xFF);
382 seq_printf(m
, "capacity_weight=%ld\n",
383 (h_resource
>> 5 * 8) & 0xFF);
385 seq_printf(m
, "capped=%ld\n", (h_resource
>> 6 * 8) & 0x01);
387 seq_printf(m
, "unallocated_capacity=%ld\n", h_unallocated
);
389 seq_printf(m
, "purr=%ld\n", purr
);
391 } else { /* non SPLPAR case */
393 seq_printf(m
, "system_active_processors=%d\n",
394 partition_potential_processors
);
396 seq_printf(m
, "system_potential_processors=%d\n",
397 partition_potential_processors
);
399 seq_printf(m
, "partition_max_entitled_capacity=%d\n",
400 partition_potential_processors
* 100);
402 seq_printf(m
, "partition_entitled_capacity=%d\n",
403 partition_active_processors
* 100);
406 seq_printf(m
, "partition_active_processors=%d\n",
407 partition_active_processors
);
409 seq_printf(m
, "partition_potential_processors=%d\n",
410 partition_potential_processors
);
412 seq_printf(m
, "shared_processor_mode=%d\n", lppaca
[0].shared_proc
);
418 * Interface for changing system parameters (variable capacity weight
419 * and entitled capacity). Format of input is "param_name=value";
420 * anything after value is ignored. Valid parameters at this time are
421 * "partition_entitled_capacity" and "capacity_weight". We use
422 * H_SET_PPP to alter parameters.
424 * This function should be invoked only on systems with
427 static ssize_t
lparcfg_write(struct file
*file
, const char __user
* buf
,
428 size_t count
, loff_t
* off
)
432 u64 new_entitled
, *new_entitled_ptr
= &new_entitled
;
433 u8 new_weight
, *new_weight_ptr
= &new_weight
;
435 unsigned long current_entitled
; /* parameters for h_get_ppp */
437 unsigned long resource
;
440 ssize_t retval
= -ENOMEM
;
442 if (!firmware_has_feature(FW_FEATURE_SPLPAR
) ||
443 firmware_has_feature(FW_FEATURE_ISERIES
))
446 kbuf
= kmalloc(count
, GFP_KERNEL
);
451 if (copy_from_user(kbuf
, buf
, count
))
455 kbuf
[count
- 1] = '\0';
456 tmp
= strchr(kbuf
, '=');
462 if (!strcmp(kbuf
, "partition_entitled_capacity")) {
464 *new_entitled_ptr
= (u64
) simple_strtoul(tmp
, &endp
, 10);
467 new_weight_ptr
= ¤t_weight
;
468 } else if (!strcmp(kbuf
, "capacity_weight")) {
470 *new_weight_ptr
= (u8
) simple_strtoul(tmp
, &endp
, 10);
473 new_entitled_ptr
= ¤t_entitled
;
477 /* Get our current parameters */
478 retval
= h_get_ppp(¤t_entitled
, &dummy
, &dummy
, &resource
);
484 current_weight
= (resource
>> 5 * 8) & 0xFF;
486 pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
487 __FUNCTION__
, current_entitled
, current_weight
);
489 pr_debug("%s: new_entitled = %lu, new_weight = %u\n",
490 __FUNCTION__
, *new_entitled_ptr
, *new_weight_ptr
);
492 retval
= plpar_hcall_norets(H_SET_PPP
, *new_entitled_ptr
,
495 if (retval
== H_SUCCESS
|| retval
== H_CONSTRAINED
) {
497 } else if (retval
== H_BUSY
) {
499 } else if (retval
== H_HARDWARE
) {
501 } else if (retval
== H_PARAMETER
) {
504 printk(KERN_WARNING
"%s: received unknown hv return code %ld",
505 __FUNCTION__
, retval
);
514 #else /* CONFIG_PPC_PSERIES */
516 static int pseries_lparcfg_data(struct seq_file
*m
, void *v
)
521 static ssize_t
lparcfg_write(struct file
*file
, const char __user
* buf
,
522 size_t count
, loff_t
* off
)
527 #endif /* CONFIG_PPC_PSERIES */
529 static int lparcfg_data(struct seq_file
*m
, void *v
)
531 struct device_node
*rootdn
;
532 const char *model
= "";
533 const char *system_id
= "";
535 const unsigned int *lp_index_ptr
;
536 unsigned int lp_index
= 0;
538 seq_printf(m
, "%s %s \n", MODULE_NAME
, MODULE_VERS
);
540 rootdn
= find_path_device("/");
542 tmp
= of_get_property(rootdn
, "model", NULL
);
545 /* Skip "IBM," - see platforms/iseries/dt.c */
546 if (firmware_has_feature(FW_FEATURE_ISERIES
))
549 tmp
= of_get_property(rootdn
, "system-id", NULL
);
552 /* Skip "IBM," - see platforms/iseries/dt.c */
553 if (firmware_has_feature(FW_FEATURE_ISERIES
))
556 lp_index_ptr
= of_get_property(rootdn
, "ibm,partition-no",
559 lp_index
= *lp_index_ptr
;
561 seq_printf(m
, "serial_number=%s\n", system_id
);
562 seq_printf(m
, "system_type=%s\n", model
);
563 seq_printf(m
, "partition_id=%d\n", (int)lp_index
);
565 if (firmware_has_feature(FW_FEATURE_ISERIES
))
566 return iseries_lparcfg_data(m
, v
);
567 return pseries_lparcfg_data(m
, v
);
570 static int lparcfg_open(struct inode
*inode
, struct file
*file
)
572 return single_open(file
, lparcfg_data
, NULL
);
575 const struct file_operations lparcfg_fops
= {
576 .owner
= THIS_MODULE
,
578 .write
= lparcfg_write
,
579 .open
= lparcfg_open
,
580 .release
= single_release
,
583 int __init
lparcfg_init(void)
585 struct proc_dir_entry
*ent
;
586 mode_t mode
= S_IRUSR
| S_IRGRP
| S_IROTH
;
588 /* Allow writing if we have FW_FEATURE_SPLPAR */
589 if (firmware_has_feature(FW_FEATURE_SPLPAR
) &&
590 !firmware_has_feature(FW_FEATURE_ISERIES
))
593 ent
= create_proc_entry("ppc64/lparcfg", mode
, NULL
);
595 ent
->proc_fops
= &lparcfg_fops
;
596 ent
->data
= kmalloc(LPARCFG_BUFF_SIZE
, GFP_KERNEL
);
599 "Failed to allocate buffer for lparcfg\n");
600 remove_proc_entry("lparcfg", ent
->parent
);
604 printk(KERN_ERR
"Failed to create ppc64/lparcfg\n");
608 proc_ppc64_lparcfg
= ent
;
612 void __exit
lparcfg_cleanup(void)
614 if (proc_ppc64_lparcfg
) {
615 kfree(proc_ppc64_lparcfg
->data
);
616 remove_proc_entry("lparcfg", proc_ppc64_lparcfg
->parent
);
620 module_init(lparcfg_init
);
621 module_exit(lparcfg_cleanup
);
622 MODULE_DESCRIPTION("Interface for LPAR configuration data");
623 MODULE_AUTHOR("Dave Engebretsen");
624 MODULE_LICENSE("GPL");