1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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>
32#include <asm/rtas.h>
33#include <asm/system.h>
34#include <asm/time.h>
35#include <asm/prom.h>
36#include <asm/vdso_datapage.h>
37#include <asm/vio.h>
38#include <asm/mmu.h>
39
40#define MODULE_VERS "1.8"
41#define MODULE_NAME "lparcfg"
42
43
44
45static struct proc_dir_entry *proc_ppc64_lparcfg;
46
47
48
49
50
51static unsigned long get_purr(void)
52{
53 unsigned long sum_purr = 0;
54 int cpu;
55
56 for_each_possible_cpu(cpu) {
57 if (firmware_has_feature(FW_FEATURE_ISERIES))
58 sum_purr += lppaca[cpu].emulated_time_base;
59 else {
60 struct cpu_usage *cu;
61
62 cu = &per_cpu(cpu_usage_array, cpu);
63 sum_purr += cu->current_tb;
64 }
65 }
66 return sum_purr;
67}
68
69#ifdef CONFIG_PPC_ISERIES
70
71
72
73
74static int iseries_lparcfg_data(struct seq_file *m, void *v)
75{
76 unsigned long pool_id;
77 int shared, entitled_capacity, max_entitled_capacity;
78 int processors, max_processors;
79 unsigned long purr = get_purr();
80
81 shared = (int)(local_paca->lppaca_ptr->shared_proc);
82
83 seq_printf(m, "system_active_processors=%d\n",
84 (int)HvLpConfig_getSystemPhysicalProcessors());
85
86 seq_printf(m, "system_potential_processors=%d\n",
87 (int)HvLpConfig_getSystemPhysicalProcessors());
88
89 processors = (int)HvLpConfig_getPhysicalProcessors();
90 seq_printf(m, "partition_active_processors=%d\n", processors);
91
92 max_processors = (int)HvLpConfig_getMaxPhysicalProcessors();
93 seq_printf(m, "partition_potential_processors=%d\n", max_processors);
94
95 if (shared) {
96 entitled_capacity = HvLpConfig_getSharedProcUnits();
97 max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits();
98 } else {
99 entitled_capacity = processors * 100;
100 max_entitled_capacity = max_processors * 100;
101 }
102 seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity);
103
104 seq_printf(m, "partition_max_entitled_capacity=%d\n",
105 max_entitled_capacity);
106
107 if (shared) {
108 pool_id = HvLpConfig_getSharedPoolIndex();
109 seq_printf(m, "pool=%d\n", (int)pool_id);
110 seq_printf(m, "pool_capacity=%d\n",
111 (int)(HvLpConfig_getNumProcsInSharedPool(pool_id) *
112 100));
113 seq_printf(m, "purr=%ld\n", purr);
114 }
115
116 seq_printf(m, "shared_processor_mode=%d\n", shared);
117
118 return 0;
119}
120
121#else
122
123static int iseries_lparcfg_data(struct seq_file *m, void *v)
124{
125 return 0;
126}
127
128#endif
129
130#ifdef CONFIG_PPC_PSERIES
131
132
133
134
135
136
137
138int h_get_mpp(struct hvcall_mpp_data *mpp_data)
139{
140 int rc;
141 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
142
143 rc = plpar_hcall9(H_GET_MPP, retbuf);
144
145 mpp_data->entitled_mem = retbuf[0];
146 mpp_data->mapped_mem = retbuf[1];
147
148 mpp_data->group_num = (retbuf[2] >> 2 * 8) & 0xffff;
149 mpp_data->pool_num = retbuf[2] & 0xffff;
150
151 mpp_data->mem_weight = (retbuf[3] >> 7 * 8) & 0xff;
152 mpp_data->unallocated_mem_weight = (retbuf[3] >> 6 * 8) & 0xff;
153 mpp_data->unallocated_entitlement = retbuf[3] & 0xffffffffffff;
154
155 mpp_data->pool_size = retbuf[4];
156 mpp_data->loan_request = retbuf[5];
157 mpp_data->backing_mem = retbuf[6];
158
159 return rc;
160}
161EXPORT_SYMBOL(h_get_mpp);
162
163struct hvcall_ppp_data {
164 u64 entitlement;
165 u64 unallocated_entitlement;
166 u16 group_num;
167 u16 pool_num;
168 u8 capped;
169 u8 weight;
170 u8 unallocated_weight;
171 u16 active_procs_in_pool;
172 u16 active_system_procs;
173 u16 phys_platform_procs;
174 u32 max_proc_cap_avail;
175 u32 entitled_proc_cap_avail;
176};
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203static unsigned int h_get_ppp(struct hvcall_ppp_data *ppp_data)
204{
205 unsigned long rc;
206 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
207
208 rc = plpar_hcall9(H_GET_PPP, retbuf);
209
210 ppp_data->entitlement = retbuf[0];
211 ppp_data->unallocated_entitlement = retbuf[1];
212
213 ppp_data->group_num = (retbuf[2] >> 2 * 8) & 0xffff;
214 ppp_data->pool_num = retbuf[2] & 0xffff;
215
216 ppp_data->capped = (retbuf[3] >> 6 * 8) & 0x01;
217 ppp_data->weight = (retbuf[3] >> 5 * 8) & 0xff;
218 ppp_data->unallocated_weight = (retbuf[3] >> 4 * 8) & 0xff;
219 ppp_data->active_procs_in_pool = (retbuf[3] >> 2 * 8) & 0xffff;
220 ppp_data->active_system_procs = retbuf[3] & 0xffff;
221
222 ppp_data->phys_platform_procs = retbuf[4] >> 6 * 8;
223 ppp_data->max_proc_cap_avail = (retbuf[4] >> 3 * 8) & 0xffffff;
224 ppp_data->entitled_proc_cap_avail = retbuf[4] & 0xffffff;
225
226 return rc;
227}
228
229static unsigned h_pic(unsigned long *pool_idle_time,
230 unsigned long *num_procs)
231{
232 unsigned long rc;
233 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
234
235 rc = plpar_hcall(H_PIC, retbuf);
236
237 *pool_idle_time = retbuf[0];
238 *num_procs = retbuf[1];
239
240 return rc;
241}
242
243
244
245
246
247static void parse_ppp_data(struct seq_file *m)
248{
249 struct hvcall_ppp_data ppp_data;
250 struct device_node *root;
251 const int *perf_level;
252 int rc;
253
254 rc = h_get_ppp(&ppp_data);
255 if (rc)
256 return;
257
258 seq_printf(m, "partition_entitled_capacity=%lld\n",
259 ppp_data.entitlement);
260 seq_printf(m, "group=%d\n", ppp_data.group_num);
261 seq_printf(m, "system_active_processors=%d\n",
262 ppp_data.active_system_procs);
263
264
265 if (lppaca[0].shared_proc) {
266 unsigned long pool_idle_time, pool_procs;
267
268 seq_printf(m, "pool=%d\n", ppp_data.pool_num);
269
270
271 seq_printf(m, "pool_capacity=%d\n",
272 ppp_data.active_procs_in_pool * 100);
273
274 h_pic(&pool_idle_time, &pool_procs);
275 seq_printf(m, "pool_idle_time=%ld\n", pool_idle_time);
276 seq_printf(m, "pool_num_procs=%ld\n", pool_procs);
277 }
278
279 seq_printf(m, "unallocated_capacity_weight=%d\n",
280 ppp_data.unallocated_weight);
281 seq_printf(m, "capacity_weight=%d\n", ppp_data.weight);
282 seq_printf(m, "capped=%d\n", ppp_data.capped);
283 seq_printf(m, "unallocated_capacity=%lld\n",
284 ppp_data.unallocated_entitlement);
285
286
287
288
289
290 root = of_find_node_by_path("/");
291 if (root) {
292 perf_level = of_get_property(root,
293 "ibm,partition-performance-parameters-level",
294 NULL);
295 if (perf_level && (*perf_level >= 1)) {
296 seq_printf(m,
297 "physical_procs_allocated_to_virtualization=%d\n",
298 ppp_data.phys_platform_procs);
299 seq_printf(m, "max_proc_capacity_available=%d\n",
300 ppp_data.max_proc_cap_avail);
301 seq_printf(m, "entitled_proc_capacity_available=%d\n",
302 ppp_data.entitled_proc_cap_avail);
303 }
304
305 of_node_put(root);
306 }
307}
308
309
310
311
312
313static void parse_mpp_data(struct seq_file *m)
314{
315 struct hvcall_mpp_data mpp_data;
316 int rc;
317
318 rc = h_get_mpp(&mpp_data);
319 if (rc)
320 return;
321
322 seq_printf(m, "entitled_memory=%ld\n", mpp_data.entitled_mem);
323
324 if (mpp_data.mapped_mem != -1)
325 seq_printf(m, "mapped_entitled_memory=%ld\n",
326 mpp_data.mapped_mem);
327
328 seq_printf(m, "entitled_memory_group_number=%d\n", mpp_data.group_num);
329 seq_printf(m, "entitled_memory_pool_number=%d\n", mpp_data.pool_num);
330
331 seq_printf(m, "entitled_memory_weight=%d\n", mpp_data.mem_weight);
332 seq_printf(m, "unallocated_entitled_memory_weight=%d\n",
333 mpp_data.unallocated_mem_weight);
334 seq_printf(m, "unallocated_io_mapping_entitlement=%ld\n",
335 mpp_data.unallocated_entitlement);
336
337 if (mpp_data.pool_size != -1)
338 seq_printf(m, "entitled_memory_pool_size=%ld bytes\n",
339 mpp_data.pool_size);
340
341 seq_printf(m, "entitled_memory_loan_request=%ld\n",
342 mpp_data.loan_request);
343
344 seq_printf(m, "backing_memory=%ld bytes\n", mpp_data.backing_mem);
345}
346
347#define SPLPAR_CHARACTERISTICS_TOKEN 20
348#define SPLPAR_MAXLENGTH 1026*(sizeof(char))
349
350
351
352
353
354
355
356static void parse_system_parameter_string(struct seq_file *m)
357{
358 int call_status;
359
360 unsigned char *local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
361 if (!local_buffer) {
362 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
363 __FILE__, __func__, __LINE__);
364 return;
365 }
366
367 spin_lock(&rtas_data_buf_lock);
368 memset(rtas_data_buf, 0, SPLPAR_MAXLENGTH);
369 call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
370 NULL,
371 SPLPAR_CHARACTERISTICS_TOKEN,
372 __pa(rtas_data_buf),
373 RTAS_DATA_BUF_SIZE);
374 memcpy(local_buffer, rtas_data_buf, SPLPAR_MAXLENGTH);
375 spin_unlock(&rtas_data_buf_lock);
376
377 if (call_status != 0) {
378 printk(KERN_INFO
379 "%s %s Error calling get-system-parameter (0x%x)\n",
380 __FILE__, __func__, call_status);
381 } else {
382 int splpar_strlen;
383 int idx, w_idx;
384 char *workbuffer = kzalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
385 if (!workbuffer) {
386 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
387 __FILE__, __func__, __LINE__);
388 kfree(local_buffer);
389 return;
390 }
391#ifdef LPARCFG_DEBUG
392 printk(KERN_INFO "success calling get-system-parameter \n");
393#endif
394 splpar_strlen = local_buffer[0] * 256 + local_buffer[1];
395 local_buffer += 2;
396
397 w_idx = 0;
398 idx = 0;
399 while ((*local_buffer) && (idx < splpar_strlen)) {
400 workbuffer[w_idx++] = local_buffer[idx++];
401 if ((local_buffer[idx] == ',')
402 || (local_buffer[idx] == '\0')) {
403 workbuffer[w_idx] = '\0';
404 if (w_idx) {
405
406 seq_printf(m, "%s\n", workbuffer);
407 }
408 memset(workbuffer, 0, SPLPAR_MAXLENGTH);
409 idx++;
410 w_idx = 0;
411 } else if (local_buffer[idx] == '=') {
412
413
414 if (0 == strcmp(workbuffer, "MaxEntCap")) {
415 strcpy(workbuffer,
416 "partition_max_entitled_capacity");
417 w_idx = strlen(workbuffer);
418 }
419 if (0 == strcmp(workbuffer, "MaxPlatProcs")) {
420 strcpy(workbuffer,
421 "system_potential_processors");
422 w_idx = strlen(workbuffer);
423 }
424 }
425 }
426 kfree(workbuffer);
427 local_buffer -= 2;
428 }
429 kfree(local_buffer);
430}
431
432
433
434
435
436static int lparcfg_count_active_processors(void)
437{
438 struct device_node *cpus_dn = NULL;
439 int count = 0;
440
441 while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) {
442#ifdef LPARCFG_DEBUG
443 printk(KERN_ERR "cpus_dn %p \n", cpus_dn);
444#endif
445 count++;
446 }
447 return count;
448}
449
450static void pseries_cmo_data(struct seq_file *m)
451{
452 int cpu;
453 unsigned long cmo_faults = 0;
454 unsigned long cmo_fault_time = 0;
455
456 seq_printf(m, "cmo_enabled=%d\n", firmware_has_feature(FW_FEATURE_CMO));
457
458 if (!firmware_has_feature(FW_FEATURE_CMO))
459 return;
460
461 for_each_possible_cpu(cpu) {
462 cmo_faults += lppaca[cpu].cmo_faults;
463 cmo_fault_time += lppaca[cpu].cmo_fault_time;
464 }
465
466 seq_printf(m, "cmo_faults=%lu\n", cmo_faults);
467 seq_printf(m, "cmo_fault_time_usec=%lu\n",
468 cmo_fault_time / tb_ticks_per_usec);
469 seq_printf(m, "cmo_primary_psp=%d\n", cmo_get_primary_psp());
470 seq_printf(m, "cmo_secondary_psp=%d\n", cmo_get_secondary_psp());
471 seq_printf(m, "cmo_page_size=%lu\n", cmo_get_page_size());
472}
473
474static void splpar_dispatch_data(struct seq_file *m)
475{
476 int cpu;
477 unsigned long dispatches = 0;
478 unsigned long dispatch_dispersions = 0;
479
480 for_each_possible_cpu(cpu) {
481 dispatches += lppaca[cpu].yield_count;
482 dispatch_dispersions += lppaca[cpu].dispersion_count;
483 }
484
485 seq_printf(m, "dispatches=%lu\n", dispatches);
486 seq_printf(m, "dispatch_dispersions=%lu\n", dispatch_dispersions);
487}
488
489static int pseries_lparcfg_data(struct seq_file *m, void *v)
490{
491 int partition_potential_processors;
492 int partition_active_processors;
493 struct device_node *rtas_node;
494 const int *lrdrp = NULL;
495
496 rtas_node = of_find_node_by_path("/rtas");
497 if (rtas_node)
498 lrdrp = of_get_property(rtas_node, "ibm,lrdr-capacity", NULL);
499
500 if (lrdrp == NULL) {
501 partition_potential_processors = vdso_data->processorCount;
502 } else {
503 partition_potential_processors = *(lrdrp + 4);
504 }
505 of_node_put(rtas_node);
506
507 partition_active_processors = lparcfg_count_active_processors();
508
509 if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
510
511 parse_system_parameter_string(m);
512 parse_ppp_data(m);
513 parse_mpp_data(m);
514 pseries_cmo_data(m);
515 splpar_dispatch_data(m);
516
517 seq_printf(m, "purr=%ld\n", get_purr());
518 } else {
519
520 seq_printf(m, "system_active_processors=%d\n",
521 partition_potential_processors);
522
523 seq_printf(m, "system_potential_processors=%d\n",
524 partition_potential_processors);
525
526 seq_printf(m, "partition_max_entitled_capacity=%d\n",
527 partition_potential_processors * 100);
528
529 seq_printf(m, "partition_entitled_capacity=%d\n",
530 partition_active_processors * 100);
531 }
532
533 seq_printf(m, "partition_active_processors=%d\n",
534 partition_active_processors);
535
536 seq_printf(m, "partition_potential_processors=%d\n",
537 partition_potential_processors);
538
539 seq_printf(m, "shared_processor_mode=%d\n", lppaca[0].shared_proc);
540
541 seq_printf(m, "slb_size=%d\n", mmu_slb_size);
542
543 return 0;
544}
545
546static ssize_t update_ppp(u64 *entitlement, u8 *weight)
547{
548 struct hvcall_ppp_data ppp_data;
549 u8 new_weight;
550 u64 new_entitled;
551 ssize_t retval;
552
553
554 retval = h_get_ppp(&ppp_data);
555 if (retval)
556 return retval;
557
558 if (entitlement) {
559 new_weight = ppp_data.weight;
560 new_entitled = *entitlement;
561 } else if (weight) {
562 new_weight = *weight;
563 new_entitled = ppp_data.entitlement;
564 } else
565 return -EINVAL;
566
567 pr_debug("%s: current_entitled = %llu, current_weight = %u\n",
568 __func__, ppp_data.entitlement, ppp_data.weight);
569
570 pr_debug("%s: new_entitled = %llu, new_weight = %u\n",
571 __func__, new_entitled, new_weight);
572
573 retval = plpar_hcall_norets(H_SET_PPP, new_entitled, new_weight);
574 return retval;
575}
576
577
578
579
580
581
582
583
584static ssize_t update_mpp(u64 *entitlement, u8 *weight)
585{
586 struct hvcall_mpp_data mpp_data;
587 u64 new_entitled;
588 u8 new_weight;
589 ssize_t rc;
590
591 if (entitlement) {
592
593
594
595 rc = vio_cmo_entitlement_update(*entitlement);
596 if (rc)
597 return rc;
598 }
599
600 rc = h_get_mpp(&mpp_data);
601 if (rc)
602 return rc;
603
604 if (entitlement) {
605 new_weight = mpp_data.mem_weight;
606 new_entitled = *entitlement;
607 } else if (weight) {
608 new_weight = *weight;
609 new_entitled = mpp_data.entitled_mem;
610 } else
611 return -EINVAL;
612
613 pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
614 __func__, mpp_data.entitled_mem, mpp_data.mem_weight);
615
616 pr_debug("%s: new_entitled = %llu, new_weight = %u\n",
617 __func__, new_entitled, new_weight);
618
619 rc = plpar_hcall_norets(H_SET_MPP, new_entitled, new_weight);
620 return rc;
621}
622
623
624
625
626
627
628
629
630
631
632
633static ssize_t lparcfg_write(struct file *file, const char __user * buf,
634 size_t count, loff_t * off)
635{
636 int kbuf_sz = 64;
637 char kbuf[kbuf_sz];
638 char *tmp;
639 u64 new_entitled, *new_entitled_ptr = &new_entitled;
640 u8 new_weight, *new_weight_ptr = &new_weight;
641 ssize_t retval;
642
643 if (!firmware_has_feature(FW_FEATURE_SPLPAR) ||
644 firmware_has_feature(FW_FEATURE_ISERIES))
645 return -EINVAL;
646
647 if (count > kbuf_sz)
648 return -EINVAL;
649
650 if (copy_from_user(kbuf, buf, count))
651 return -EFAULT;
652
653 kbuf[count - 1] = '\0';
654 tmp = strchr(kbuf, '=');
655 if (!tmp)
656 return -EINVAL;
657
658 *tmp++ = '\0';
659
660 if (!strcmp(kbuf, "partition_entitled_capacity")) {
661 char *endp;
662 *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
663 if (endp == tmp)
664 return -EINVAL;
665
666 retval = update_ppp(new_entitled_ptr, NULL);
667 } else if (!strcmp(kbuf, "capacity_weight")) {
668 char *endp;
669 *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
670 if (endp == tmp)
671 return -EINVAL;
672
673 retval = update_ppp(NULL, new_weight_ptr);
674 } else if (!strcmp(kbuf, "entitled_memory")) {
675 char *endp;
676 *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
677 if (endp == tmp)
678 return -EINVAL;
679
680 retval = update_mpp(new_entitled_ptr, NULL);
681 } else if (!strcmp(kbuf, "entitled_memory_weight")) {
682 char *endp;
683 *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
684 if (endp == tmp)
685 return -EINVAL;
686
687 retval = update_mpp(NULL, new_weight_ptr);
688 } else
689 return -EINVAL;
690
691 if (retval == H_SUCCESS || retval == H_CONSTRAINED) {
692 retval = count;
693 } else if (retval == H_BUSY) {
694 retval = -EBUSY;
695 } else if (retval == H_HARDWARE) {
696 retval = -EIO;
697 } else if (retval == H_PARAMETER) {
698 retval = -EINVAL;
699 }
700
701 return retval;
702}
703
704#else
705
706static int pseries_lparcfg_data(struct seq_file *m, void *v)
707{
708 return 0;
709}
710
711static ssize_t lparcfg_write(struct file *file, const char __user * buf,
712 size_t count, loff_t * off)
713{
714 return -EINVAL;
715}
716
717#endif
718
719static int lparcfg_data(struct seq_file *m, void *v)
720{
721 struct device_node *rootdn;
722 const char *model = "";
723 const char *system_id = "";
724 const char *tmp;
725 const unsigned int *lp_index_ptr;
726 unsigned int lp_index = 0;
727
728 seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
729
730 rootdn = of_find_node_by_path("/");
731 if (rootdn) {
732 tmp = of_get_property(rootdn, "model", NULL);
733 if (tmp) {
734 model = tmp;
735
736 if (firmware_has_feature(FW_FEATURE_ISERIES))
737 model += 4;
738 }
739 tmp = of_get_property(rootdn, "system-id", NULL);
740 if (tmp) {
741 system_id = tmp;
742
743 if (firmware_has_feature(FW_FEATURE_ISERIES))
744 system_id += 4;
745 }
746 lp_index_ptr = of_get_property(rootdn, "ibm,partition-no",
747 NULL);
748 if (lp_index_ptr)
749 lp_index = *lp_index_ptr;
750 of_node_put(rootdn);
751 }
752 seq_printf(m, "serial_number=%s\n", system_id);
753 seq_printf(m, "system_type=%s\n", model);
754 seq_printf(m, "partition_id=%d\n", (int)lp_index);
755
756 if (firmware_has_feature(FW_FEATURE_ISERIES))
757 return iseries_lparcfg_data(m, v);
758 return pseries_lparcfg_data(m, v);
759}
760
761static int lparcfg_open(struct inode *inode, struct file *file)
762{
763 return single_open(file, lparcfg_data, NULL);
764}
765
766static const struct file_operations lparcfg_fops = {
767 .owner = THIS_MODULE,
768 .read = seq_read,
769 .write = lparcfg_write,
770 .open = lparcfg_open,
771 .release = single_release,
772};
773
774static int __init lparcfg_init(void)
775{
776 struct proc_dir_entry *ent;
777 mode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
778
779
780 if (firmware_has_feature(FW_FEATURE_SPLPAR) &&
781 !firmware_has_feature(FW_FEATURE_ISERIES))
782 mode |= S_IWUSR;
783
784 ent = proc_create("ppc64/lparcfg", mode, NULL, &lparcfg_fops);
785 if (!ent) {
786 printk(KERN_ERR "Failed to create ppc64/lparcfg\n");
787 return -EIO;
788 }
789
790 proc_ppc64_lparcfg = ent;
791 return 0;
792}
793
794static void __exit lparcfg_cleanup(void)
795{
796 if (proc_ppc64_lparcfg)
797 remove_proc_entry("lparcfg", proc_ppc64_lparcfg->parent);
798}
799
800module_init(lparcfg_init);
801module_exit(lparcfg_cleanup);
802MODULE_DESCRIPTION("Interface for LPAR configuration data");
803MODULE_AUTHOR("Dave Engebretsen");
804MODULE_LICENSE("GPL");
805