X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=arch%2Fppc64%2Fkernel%2Flparcfg.c;h=d729105e5e143c2526ee5cf5399b03c7eafc058a;hb=9bf4aaab3e101692164d49b7ca357651eb691cb6;hp=860f07e8c4e68b1c44f933fb3b484bd1f4b07e1b;hpb=db216c3d5e4c040e557a50f8f5d35d5c415e8c1c;p=linux-2.6.git diff --git a/arch/ppc64/kernel/lparcfg.c b/arch/ppc64/kernel/lparcfg.c index 860f07e8c..d729105e5 100644 --- a/arch/ppc64/kernel/lparcfg.c +++ b/arch/ppc64/kernel/lparcfg.c @@ -5,6 +5,7 @@ * Copyright (c) 2003 Dave Engebretsen * Will Schmidt willschm@us.ibm.com * SPLPAR updates, Copyright (c) 2003 Will Schmidt IBM Corporation. + * seq_file updates, Copyright (c) 2004 Will Schmidt IBM Corporation. * Nathan Lynch nathanl@austin.ibm.com * Added lparcfg_write, Copyright (C) 2004 Nathan Lynch IBM Corporation. * @@ -23,15 +24,41 @@ #include #include #include +#include #include #include #include +#include #include #include +#include +#include -#define MODULE_VERS "1.0" +#define MODULE_VERS "1.3" #define MODULE_NAME "lparcfg" +/* #define LPARCFG_DEBUG */ + +/* find a better place for this function... */ +void log_plpar_hcall_return(unsigned long rc,char * tag) +{ + if (rc ==0 ) /* success, return */ + return; +/* check for null tag ? */ + if (rc == H_Hardware) + printk(KERN_INFO "plpar-hcall (%s) failed with hardware fault\n",tag); + else if (rc == H_Function) + printk(KERN_INFO "plpar-hcall (%s) failed; function not allowed\n",tag); + else if (rc == H_Authority) + printk(KERN_INFO "plpar-hcall (%s) failed; not authorized to this function\n",tag); + else if (rc == H_Parameter) + printk(KERN_INFO "plpar-hcall (%s) failed; Bad parameter(s)\n",tag); + else + printk(KERN_INFO "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",tag,rc); + +} + + static struct proc_dir_entry *proc_ppc64_lparcfg; #define LPARCFG_BUFF_SIZE 4096 @@ -39,103 +66,18 @@ static struct proc_dir_entry *proc_ppc64_lparcfg; #define lparcfg_write NULL -static unsigned char e2a(unsigned char x) -{ - switch (x) { - case 0xF0: - return '0'; - case 0xF1: - return '1'; - case 0xF2: - return '2'; - case 0xF3: - return '3'; - case 0xF4: - return '4'; - case 0xF5: - return '5'; - case 0xF6: - return '6'; - case 0xF7: - return '7'; - case 0xF8: - return '8'; - case 0xF9: - return '9'; - case 0xC1: - return 'A'; - case 0xC2: - return 'B'; - case 0xC3: - return 'C'; - case 0xC4: - return 'D'; - case 0xC5: - return 'E'; - case 0xC6: - return 'F'; - case 0xC7: - return 'G'; - case 0xC8: - return 'H'; - case 0xC9: - return 'I'; - case 0xD1: - return 'J'; - case 0xD2: - return 'K'; - case 0xD3: - return 'L'; - case 0xD4: - return 'M'; - case 0xD5: - return 'N'; - case 0xD6: - return 'O'; - case 0xD7: - return 'P'; - case 0xD8: - return 'Q'; - case 0xD9: - return 'R'; - case 0xE2: - return 'S'; - case 0xE3: - return 'T'; - case 0xE4: - return 'U'; - case 0xE5: - return 'V'; - case 0xE6: - return 'W'; - case 0xE7: - return 'X'; - case 0xE8: - return 'Y'; - case 0xE9: - return 'Z'; - } - return ' '; -} - /* * Methods used to fetch LPAR data when running on an iSeries platform. */ -static int lparcfg_data(unsigned char *buf, unsigned long size) +static int lparcfg_data(struct seq_file *m, void *v) { - unsigned long n = 0, pool_id, lp_index; + unsigned long pool_id, lp_index; int shared, entitled_capacity, max_entitled_capacity; int processors, max_processors; struct paca_struct *lpaca = get_paca(); - if((buf == NULL) || (size > LPARCFG_BUFF_SIZE)) { - return -EFAULT; - } - memset(buf, 0, size); - - shared = (int)(lpaca->xLpPacaPtr->xSharedProc); - n += scnprintf(buf, LPARCFG_BUFF_SIZE - n, - "serial_number=%c%c%c%c%c%c%c\n", + shared = (int)(lpaca->lppaca_ptr->xSharedProc); + seq_printf(m, "serial_number=%c%c%c%c%c%c%c\n", e2a(xItExtVpdPanel.mfgID[2]), e2a(xItExtVpdPanel.mfgID[3]), e2a(xItExtVpdPanel.systemSerial[1]), @@ -144,32 +86,26 @@ static int lparcfg_data(unsigned char *buf, unsigned long size) e2a(xItExtVpdPanel.systemSerial[4]), e2a(xItExtVpdPanel.systemSerial[5])); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_type=%c%c%c%c\n", + seq_printf(m, "system_type=%c%c%c%c\n", e2a(xItExtVpdPanel.machineType[0]), e2a(xItExtVpdPanel.machineType[1]), e2a(xItExtVpdPanel.machineType[2]), e2a(xItExtVpdPanel.machineType[3])); lp_index = HvLpConfig_getLpIndex(); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_id=%d\n", (int)lp_index); + seq_printf(m, "partition_id=%d\n", (int)lp_index); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_active_processors=%d\n", + seq_printf(m, "system_active_processors=%d\n", (int)HvLpConfig_getSystemPhysicalProcessors()); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_potential_processors=%d\n", + seq_printf(m, "system_potential_processors=%d\n", (int)HvLpConfig_getSystemPhysicalProcessors()); processors = (int)HvLpConfig_getPhysicalProcessors(); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_active_processors=%d\n", processors); + seq_printf(m, "partition_active_processors=%d\n", processors); max_processors = (int)HvLpConfig_getMaxPhysicalProcessors(); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_potential_processors=%d\n", max_processors); + seq_printf(m, "partition_potential_processors=%d\n", max_processors); if(shared) { entitled_capacity = HvLpConfig_getSharedProcUnits(); @@ -178,23 +114,19 @@ static int lparcfg_data(unsigned char *buf, unsigned long size) entitled_capacity = processors * 100; max_entitled_capacity = max_processors * 100; } - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_entitled_capacity=%d\n", entitled_capacity); + seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_max_entitled_capacity=%d\n", + seq_printf(m, "partition_max_entitled_capacity=%d\n", max_entitled_capacity); if(shared) { pool_id = HvLpConfig_getSharedPoolIndex(); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, "pool=%d\n", - (int)pool_id); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "pool_capacity=%d\n", (int)(HvLpConfig_getNumProcsInSharedPool(pool_id)*100)); + seq_printf(m, "pool=%d\n", (int)pool_id); + seq_printf(m, "pool_capacity=%d\n", + (int)(HvLpConfig_getNumProcsInSharedPool(pool_id)*100)); } - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "shared_processor_mode=%d\n", shared); + seq_printf(m, "shared_processor_mode=%d\n", shared); return 0; } @@ -217,7 +149,7 @@ static int lparcfg_data(unsigned char *buf, unsigned long size) * XXXX - reserved (0) * XXXX - Group Number * XXXX - Pool Number. - * R7 (PPOONNMMLLKKJJII) + * R7 (IIJJKKLLMMNNOOPP). * XX - reserved. (0) * XX - bit 0-6 reserved (0). bit 7 is Capped indicator. * XX - variable processor Capacity Weight @@ -225,168 +157,257 @@ static int lparcfg_data(unsigned char *buf, unsigned long size) * XXXX - Active processors in Physical Processor Pool. * XXXX - Processors active on platform. */ -unsigned int h_get_ppp(unsigned long *entitled,unsigned long *unallocated,unsigned long *aggregation,unsigned long *resource) +static unsigned int h_get_ppp(unsigned long *entitled, + unsigned long *unallocated, unsigned long *aggregation, + unsigned long *resource) { unsigned long rc; rc = plpar_hcall_4out(H_GET_PPP,0,0,0,0,entitled,unallocated,aggregation,resource); - return 0; + + log_plpar_hcall_return(rc, "H_GET_PPP"); + + return rc; } -/* - * get_splpar_potential_characteristics(). - * Retrieve the potential_processors and max_entitled_capacity values - * through the get-system-parameter rtas call. +static void h_pic(unsigned long *pool_idle_time, unsigned long *num_procs) +{ + unsigned long rc; + unsigned long dummy; + rc = plpar_hcall(H_PIC, 0, 0, 0, 0, pool_idle_time, num_procs, &dummy); + + log_plpar_hcall_return(rc, "H_PIC"); +} + +static unsigned long get_purr(void); +/* ToDo: get sum of purr across all processors. The purr collection code + * is coming, but at this time is still problematic, so for now this + * function will return 0. */ +static unsigned long get_purr() +{ + unsigned long sum_purr=0; + return sum_purr; +} + #define SPLPAR_CHARACTERISTICS_TOKEN 20 #define SPLPAR_MAXLENGTH 1026*(sizeof(char)) -unsigned int get_splpar_potential_characteristics(void) -{ - /* return 0 for now. Underlying rtas functionality is not yet complete. 12/01/2003*/ - return 0; -#if 0 - long call_status; - unsigned long ret[2]; - char * buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL); +/* + * parse_system_parameter_string() + * Retrieve the potential_processors, max_entitled_capacity and friends + * through the get-system-parameter rtas call. Replace keyword strings as + * necessary. + */ +static void parse_system_parameter_string(struct seq_file *m) +{ + int call_status; - printk("token for ibm,get-system-parameter (0x%x)\n",rtas_token("ibm,get-system-parameter")); + char * local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL); + if (!local_buffer) { + printk(KERN_ERR "%s %s kmalloc failure at line %d \n", + __FILE__, __FUNCTION__, __LINE__); + return; + } + spin_lock(&rtas_data_buf_lock); + memset(rtas_data_buf, 0, SPLPAR_MAXLENGTH); call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1, NULL, SPLPAR_CHARACTERISTICS_TOKEN, - &buffer, - SPLPAR_MAXLENGTH, - (void *)&ret); - - if (call_status!=0) { - printk("Error calling get-system-parameter (0x%lx)\n",call_status); - kfree(buffer); - return -1; + __pa(rtas_data_buf)); + memcpy(local_buffer, rtas_data_buf, SPLPAR_MAXLENGTH); + spin_unlock(&rtas_data_buf_lock); + + if (call_status != 0) { + printk(KERN_INFO "%s %s Error calling get-system-parameter (0x%x)\n", + __FILE__, __FUNCTION__, call_status); } else { - printk("get-system-parameter (%s)\n",buffer); - kfree(buffer); - /* TODO: Add code here to parse out value for system_potential_processors and partition_max_entitled_capacity */ - return 1; + int splpar_strlen; + int idx, w_idx; + char * workbuffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL); + if (!workbuffer) { + printk(KERN_ERR "%s %s kmalloc failure at line %d \n",__FILE__,__FUNCTION__,__LINE__); + return; + } + +#ifdef LPARCFG_DEBUG + printk(KERN_INFO "success calling get-system-parameter \n"); +#endif + splpar_strlen = local_buffer[0] * 16 + local_buffer[1]; + local_buffer += 2; /* step over strlen value */ + + memset(workbuffer, 0, SPLPAR_MAXLENGTH); + w_idx = 0; + idx = 0; + while ((*local_buffer) && (idx < splpar_strlen)) { + workbuffer[w_idx++] = local_buffer[idx++]; + if ((local_buffer[idx] == ',') + || (local_buffer[idx] == '\0')) { + workbuffer[w_idx] = '\0'; + if (w_idx) { + /* avoid the empty string */ + seq_printf(m, "%s\n", workbuffer); + } + memset(workbuffer, 0, SPLPAR_MAXLENGTH); + idx++; /* skip the comma */ + w_idx = 0; + } else if (local_buffer[idx] == '=') { + /* code here to replace workbuffer contents + with different keyword strings */ + if (0 == strcmp(workbuffer,"MaxEntCap")) { + strcpy(workbuffer, "partition_max_entitled_capacity"); + w_idx = strlen(workbuffer); + } + if (0 == strcmp(workbuffer,"MaxPlatProcs")) { + strcpy(workbuffer, "system_potential_processors"); + w_idx = strlen(workbuffer); + } + } + } + kfree(workbuffer); + local_buffer -= 2; /* back up over strlen value */ } + kfree(local_buffer); +} + +static int lparcfg_count_active_processors(void); + +/* Return the number of processors in the system. + * This function reads through the device tree and counts + * the virtual processors, this does not include threads. + */ +static int lparcfg_count_active_processors(void) +{ + struct device_node *cpus_dn = NULL; + int count = 0; + + while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) { +#ifdef LPARCFG_DEBUG + printk(KERN_ERR "cpus_dn %p \n",cpus_dn); #endif + count++; + } + return count; } -static int lparcfg_data(unsigned char *buf, unsigned long size) +static int lparcfg_data(struct seq_file *m, void *v) { - unsigned long n = 0; - int shared, max_entitled_capacity; - int processors, system_active_processors, system_potential_processors; - struct device_node *root; + int system_active_processors; + struct device_node *rootdn; const char *model = ""; const char *system_id = ""; unsigned int *lp_index_ptr, lp_index = 0; struct device_node *rtas_node; - int *ip; - unsigned long h_entitled,h_unallocated,h_aggregation,h_resource; - - if((buf == NULL) || (size > LPARCFG_BUFF_SIZE)) { - return -EFAULT; - } - memset(buf, 0, size); - - root = find_path_device("/"); - if (root) { - model = get_property(root, "model", NULL); - system_id = get_property(root, "system-id", NULL); - lp_index_ptr = (unsigned int *)get_property(root, "ibm,partition-no", NULL); - if(lp_index_ptr) lp_index = *lp_index_ptr; + int *lrdrp; + + rootdn = find_path_device("/"); + if (rootdn) { + model = get_property(rootdn, "model", NULL); + system_id = get_property(rootdn, "system-id", NULL); + lp_index_ptr = (unsigned int *) + get_property(rootdn, "ibm,partition-no", NULL); + if (lp_index_ptr) + lp_index = *lp_index_ptr; } - n = scnprintf(buf, LPARCFG_BUFF_SIZE - n, - "serial_number=%s\n", system_id); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_type=%s\n", model); + seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS); + + seq_printf(m, "serial_number=%s\n", system_id); + + seq_printf(m, "system_type=%s\n", model); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_id=%d\n", (int)lp_index); + seq_printf(m, "partition_id=%d\n", (int)lp_index); rtas_node = find_path_device("/rtas"); - ip = (int *)get_property(rtas_node, "ibm,lrdr-capacity", NULL); - if (ip == NULL) { - system_active_processors = systemcfg->processorCount; + lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity", NULL); + + if (lrdrp == NULL) { + system_active_processors = systemcfg->processorCount; } else { - system_active_processors = *(ip + 4); + system_active_processors = *(lrdrp + 4); } if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) { - h_get_ppp(&h_entitled,&h_unallocated,&h_aggregation,&h_resource); -#ifdef DEBUG - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "R4=0x%lx\n", h_entitled); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "R5=0x%lx\n", h_unallocated); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "R6=0x%lx\n", h_aggregation); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "R7=0x%lx\n", h_resource); -#endif /* DEBUG */ - } + unsigned long h_entitled, h_unallocated; + unsigned long h_aggregation, h_resource; + unsigned long pool_idle_time, pool_procs; + unsigned long purr; - if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) { - system_potential_processors = get_splpar_potential_characteristics(); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_active_processors=%ld\n", + h_get_ppp(&h_entitled, &h_unallocated, &h_aggregation, + &h_resource); + + seq_printf(m, "R4=0x%lx\n", h_entitled); + seq_printf(m, "R5=0x%lx\n", h_unallocated); + seq_printf(m, "R6=0x%lx\n", h_aggregation); + seq_printf(m, "R7=0x%lx\n", h_resource); + + h_pic(&pool_idle_time, &pool_procs); + + purr = get_purr(); + + /* this call handles the ibm,get-system-parameter contents */ + parse_system_parameter_string(m); + + seq_printf(m, "partition_entitled_capacity=%ld\n", + h_entitled); + + seq_printf(m, "pool=%ld\n", + (h_aggregation >> 0*8) & 0xffff); + + seq_printf(m, "group=%ld\n", + (h_aggregation >> 2*8) & 0xffff); + + seq_printf(m, "system_active_processors=%ld\n", + (h_resource >> 0*8) & 0xffff); + + seq_printf(m, "pool_capacity=%ld\n", (h_resource >> 2*8) & 0xffff); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_potential_processors=%d\n", - system_potential_processors); - } else { - system_potential_processors = system_active_processors; - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_active_processors=%d\n", - system_active_processors); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "system_potential_processors=%d\n", - system_potential_processors); - } - processors = systemcfg->processorCount; - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_active_processors=%d\n", processors); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_potential_processors=%d\n", - system_active_processors); + seq_printf(m, "unallocated_capacity_weight=%ld\n", + (h_resource >> 4*8) & 0xFF); - /* max_entitled_capacity will come out of get_splpar_potential_characteristics() when that function is complete */ - max_entitled_capacity = system_active_processors * 100; - if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) { - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_entitled_capacity=%ld\n", h_entitled); - } else { - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_entitled_capacity=%d\n", system_active_processors*100); - } + seq_printf(m, "capacity_weight=%ld\n", + (h_resource >> 5*8) & 0xFF); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "partition_max_entitled_capacity=%d\n", - max_entitled_capacity); + seq_printf(m, "capped=%ld\n", + (h_resource >> 6*8) & 0x01); - shared = 0; - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "shared_processor_mode=%d\n", shared); + seq_printf(m, "unallocated_capacity=%ld\n", + h_unallocated); - if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) { - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "pool=%ld\n", (h_aggregation >> 0*8)&0xffff); + seq_printf(m, "pool_idle_time=%ld\n", + pool_idle_time); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "pool_capacity=%ld\n", (h_resource >> 3*8) &0xffff); + seq_printf(m, "pool_num_procs=%ld\n", + pool_procs); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "group=%ld\n", (h_aggregation >> 2*8)&0xffff); + seq_printf(m, "purr=%ld\n", + purr); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "capped=%ld\n", (h_resource >> 6*8)&0x40); + } else /* non SPLPAR case */ { + seq_printf(m, "system_active_processors=%d\n", + system_active_processors); + + seq_printf(m, "system_potential_processors=%d\n", + system_active_processors); - n += scnprintf(buf+n, LPARCFG_BUFF_SIZE - n, - "capacity_weight=%d\n", (int)(h_resource>>5*8)&0xFF); + seq_printf(m, "partition_max_entitled_capacity=%d\n", + 100*system_active_processors); + + seq_printf(m, "partition_entitled_capacity=%d\n", + system_active_processors*100); } + + seq_printf(m, "partition_active_processors=%d\n", + (int) lparcfg_count_active_processors()); + + seq_printf(m, "partition_potential_processors=%d\n", + system_active_processors); + + seq_printf(m, "shared_processor_mode=%d\n", + paca[0].lppaca.xSharedProc); + return 0; } @@ -484,58 +505,16 @@ out: #endif /* CONFIG_PPC_PSERIES */ - -static ssize_t lparcfg_read(struct file *file, char *buf, - size_t count, loff_t *ppos) -{ - struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode); - unsigned long *data = (unsigned long *)dp->data; - unsigned long p; - ssize_t read; - char * pnt; - - if (!data) { - printk(KERN_ERR "lparcfg: read failed no data\n"); - return -EIO; - } - - if(ppos) { - p = *ppos; - } else { - return -EFAULT; - } - - if (p >= LPARCFG_BUFF_SIZE) return 0; - - lparcfg_data((unsigned char *)data, LPARCFG_BUFF_SIZE); - if (count > (strlen((char *)data) - p)) - count = (strlen((char *)data)) - p; - read = 0; - - pnt = (char *)(data) + p; - copy_to_user(buf, (void *)pnt, count); - read += count; - *ppos += read; - return read; -} - static int lparcfg_open(struct inode * inode, struct file * file) { - struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode); - unsigned int *data = (unsigned int *)dp->data; - - if (!data) { - printk(KERN_ERR "lparcfg: open failed no data\n"); - return -EIO; - } - - return 0; + return single_open(file,lparcfg_data,NULL); } struct file_operations lparcfg_fops = { owner: THIS_MODULE, - read: lparcfg_read, + read: seq_read, open: lparcfg_open, + release: single_release, }; int __init lparcfg_init(void)