~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/pseries/dlpar.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Support for dynamic reconfiguration for PCI, Memory, and CPU
  3  * Hotplug and Dynamic Logical Partitioning on RPA platforms.
  4  *
  5  * Copyright (C) 2009 Nathan Fontenot
  6  * Copyright (C) 2009 IBM Corporation
  7  *
  8  * This program is free software; you can redistribute it and/or
  9  * modify it under the terms of the GNU General Public License version
 10  * 2 as published by the Free Software Foundation.
 11  */
 12 
 13 #include <linux/kernel.h>
 14 #include <linux/kref.h>
 15 #include <linux/notifier.h>
 16 #include <linux/spinlock.h>
 17 #include <linux/cpu.h>
 18 #include <linux/slab.h>
 19 #include <linux/of.h>
 20 #include "offline_states.h"
 21 
 22 #include <asm/prom.h>
 23 #include <asm/machdep.h>
 24 #include <asm/uaccess.h>
 25 #include <asm/rtas.h>
 26 
 27 struct cc_workarea {
 28         u32     drc_index;
 29         u32     zero;
 30         u32     name_offset;
 31         u32     prop_length;
 32         u32     prop_offset;
 33 };
 34 
 35 void dlpar_free_cc_property(struct property *prop)
 36 {
 37         kfree(prop->name);
 38         kfree(prop->value);
 39         kfree(prop);
 40 }
 41 
 42 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
 43 {
 44         struct property *prop;
 45         char *name;
 46         char *value;
 47 
 48         prop = kzalloc(sizeof(*prop), GFP_KERNEL);
 49         if (!prop)
 50                 return NULL;
 51 
 52         name = (char *)ccwa + ccwa->name_offset;
 53         prop->name = kstrdup(name, GFP_KERNEL);
 54 
 55         prop->length = ccwa->prop_length;
 56         value = (char *)ccwa + ccwa->prop_offset;
 57         prop->value = kmemdup(value, prop->length, GFP_KERNEL);
 58         if (!prop->value) {
 59                 dlpar_free_cc_property(prop);
 60                 return NULL;
 61         }
 62 
 63         return prop;
 64 }
 65 
 66 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa)
 67 {
 68         struct device_node *dn;
 69         char *name;
 70 
 71         dn = kzalloc(sizeof(*dn), GFP_KERNEL);
 72         if (!dn)
 73                 return NULL;
 74 
 75         /* The configure connector reported name does not contain a
 76          * preceding '/', so we allocate a buffer large enough to
 77          * prepend this to the full_name.
 78          */
 79         name = (char *)ccwa + ccwa->name_offset;
 80         dn->full_name = kasprintf(GFP_KERNEL, "/%s", name);
 81         if (!dn->full_name) {
 82                 kfree(dn);
 83                 return NULL;
 84         }
 85 
 86         return dn;
 87 }
 88 
 89 static void dlpar_free_one_cc_node(struct device_node *dn)
 90 {
 91         struct property *prop;
 92 
 93         while (dn->properties) {
 94                 prop = dn->properties;
 95                 dn->properties = prop->next;
 96                 dlpar_free_cc_property(prop);
 97         }
 98 
 99         kfree(dn->full_name);
100         kfree(dn);
101 }
102 
103 void dlpar_free_cc_nodes(struct device_node *dn)
104 {
105         if (dn->child)
106                 dlpar_free_cc_nodes(dn->child);
107 
108         if (dn->sibling)
109                 dlpar_free_cc_nodes(dn->sibling);
110 
111         dlpar_free_one_cc_node(dn);
112 }
113 
114 #define COMPLETE        0
115 #define NEXT_SIBLING    1
116 #define NEXT_CHILD      2
117 #define NEXT_PROPERTY   3
118 #define PREV_PARENT     4
119 #define MORE_MEMORY     5
120 #define CALL_AGAIN      -2
121 #define ERR_CFG_USE     -9003
122 
123 struct device_node *dlpar_configure_connector(u32 drc_index)
124 {
125         struct device_node *dn;
126         struct device_node *first_dn = NULL;
127         struct device_node *last_dn = NULL;
128         struct property *property;
129         struct property *last_property = NULL;
130         struct cc_workarea *ccwa;
131         char *data_buf;
132         int cc_token;
133         int rc = -1;
134 
135         cc_token = rtas_token("ibm,configure-connector");
136         if (cc_token == RTAS_UNKNOWN_SERVICE)
137                 return NULL;
138 
139         data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
140         if (!data_buf)
141                 return NULL;
142 
143         ccwa = (struct cc_workarea *)&data_buf[0];
144         ccwa->drc_index = drc_index;
145         ccwa->zero = 0;
146 
147         do {
148                 /* Since we release the rtas_data_buf lock between configure
149                  * connector calls we want to re-populate the rtas_data_buffer
150                  * with the contents of the previous call.
151                  */
152                 spin_lock(&rtas_data_buf_lock);
153 
154                 memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE);
155                 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
156                 memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);
157 
158                 spin_unlock(&rtas_data_buf_lock);
159 
160                 switch (rc) {
161                 case COMPLETE:
162                         break;
163 
164                 case NEXT_SIBLING:
165                         dn = dlpar_parse_cc_node(ccwa);
166                         if (!dn)
167                                 goto cc_error;
168 
169                         dn->parent = last_dn->parent;
170                         last_dn->sibling = dn;
171                         last_dn = dn;
172                         break;
173 
174                 case NEXT_CHILD:
175                         dn = dlpar_parse_cc_node(ccwa);
176                         if (!dn)
177                                 goto cc_error;
178 
179                         if (!first_dn)
180                                 first_dn = dn;
181                         else {
182                                 dn->parent = last_dn;
183                                 if (last_dn)
184                                         last_dn->child = dn;
185                         }
186 
187                         last_dn = dn;
188                         break;
189 
190                 case NEXT_PROPERTY:
191                         property = dlpar_parse_cc_property(ccwa);
192                         if (!property)
193                                 goto cc_error;
194 
195                         if (!last_dn->properties)
196                                 last_dn->properties = property;
197                         else
198                                 last_property->next = property;
199 
200                         last_property = property;
201                         break;
202 
203                 case PREV_PARENT:
204                         last_dn = last_dn->parent;
205                         break;
206 
207                 case CALL_AGAIN:
208                         break;
209 
210                 case MORE_MEMORY:
211                 case ERR_CFG_USE:
212                 default:
213                         printk(KERN_ERR "Unexpected Error (%d) "
214                                "returned from configure-connector\n", rc);
215                         goto cc_error;
216                 }
217         } while (rc);
218 
219 cc_error:
220         kfree(data_buf);
221 
222         if (rc) {
223                 if (first_dn)
224                         dlpar_free_cc_nodes(first_dn);
225 
226                 return NULL;
227         }
228 
229         return first_dn;
230 }
231 
232 static struct device_node *derive_parent(const char *path)
233 {
234         struct device_node *parent;
235         char *last_slash;
236 
237         last_slash = strrchr(path, '/');
238         if (last_slash == path) {
239                 parent = of_find_node_by_path("/");
240         } else {
241                 char *parent_path;
242                 int parent_path_len = last_slash - path + 1;
243                 parent_path = kmalloc(parent_path_len, GFP_KERNEL);
244                 if (!parent_path)
245                         return NULL;
246 
247                 strlcpy(parent_path, path, parent_path_len);
248                 parent = of_find_node_by_path(parent_path);
249                 kfree(parent_path);
250         }
251 
252         return parent;
253 }
254 
255 int dlpar_attach_node(struct device_node *dn)
256 {
257         int rc;
258 
259         of_node_set_flag(dn, OF_DYNAMIC);
260         kref_init(&dn->kref);
261         dn->parent = derive_parent(dn->full_name);
262         if (!dn->parent)
263                 return -ENOMEM;
264 
265         rc = of_attach_node(dn);
266         if (rc) {
267                 printk(KERN_ERR "Failed to add device node %s\n",
268                        dn->full_name);
269                 return rc;
270         }
271 
272         of_node_put(dn->parent);
273         return 0;
274 }
275 
276 int dlpar_detach_node(struct device_node *dn)
277 {
278         int rc;
279 
280         rc = of_detach_node(dn);
281         if (rc)
282                 return rc;
283 
284         of_node_put(dn); /* Must decrement the refcount */
285         return 0;
286 }
287 
288 #define DR_ENTITY_SENSE         9003
289 #define DR_ENTITY_PRESENT       1
290 #define DR_ENTITY_UNUSABLE      2
291 #define ALLOCATION_STATE        9003
292 #define ALLOC_UNUSABLE          0
293 #define ALLOC_USABLE            1
294 #define ISOLATION_STATE         9001
295 #define ISOLATE                 0
296 #define UNISOLATE               1
297 
298 int dlpar_acquire_drc(u32 drc_index)
299 {
300         int dr_status, rc;
301 
302         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
303                        DR_ENTITY_SENSE, drc_index);
304         if (rc || dr_status != DR_ENTITY_UNUSABLE)
305                 return -1;
306 
307         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
308         if (rc)
309                 return rc;
310 
311         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
312         if (rc) {
313                 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
314                 return rc;
315         }
316 
317         return 0;
318 }
319 
320 int dlpar_release_drc(u32 drc_index)
321 {
322         int dr_status, rc;
323 
324         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
325                        DR_ENTITY_SENSE, drc_index);
326         if (rc || dr_status != DR_ENTITY_PRESENT)
327                 return -1;
328 
329         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
330         if (rc)
331                 return rc;
332 
333         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
334         if (rc) {
335                 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
336                 return rc;
337         }
338 
339         return 0;
340 }
341 
342 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
343 
344 static int dlpar_online_cpu(struct device_node *dn)
345 {
346         int rc = 0;
347         unsigned int cpu;
348         int len, nthreads, i;
349         const u32 *intserv;
350 
351         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
352         if (!intserv)
353                 return -EINVAL;
354 
355         nthreads = len / sizeof(u32);
356 
357         cpu_maps_update_begin();
358         for (i = 0; i < nthreads; i++) {
359                 for_each_present_cpu(cpu) {
360                         if (get_hard_smp_processor_id(cpu) != intserv[i])
361                                 continue;
362                         BUG_ON(get_cpu_current_state(cpu)
363                                         != CPU_STATE_OFFLINE);
364                         cpu_maps_update_done();
365                         rc = cpu_up(cpu);
366                         if (rc)
367                                 goto out;
368                         cpu_maps_update_begin();
369 
370                         break;
371                 }
372                 if (cpu == num_possible_cpus())
373                         printk(KERN_WARNING "Could not find cpu to online "
374                                "with physical id 0x%x\n", intserv[i]);
375         }
376         cpu_maps_update_done();
377 
378 out:
379         return rc;
380 
381 }
382 
383 static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
384 {
385         struct device_node *dn;
386         unsigned long drc_index;
387         char *cpu_name;
388         int rc;
389 
390         cpu_hotplug_driver_lock();
391         rc = strict_strtoul(buf, 0, &drc_index);
392         if (rc) {
393                 rc = -EINVAL;
394                 goto out;
395         }
396 
397         dn = dlpar_configure_connector(drc_index);
398         if (!dn) {
399                 rc = -EINVAL;
400                 goto out;
401         }
402 
403         /* configure-connector reports cpus as living in the base
404          * directory of the device tree.  CPUs actually live in the
405          * cpus directory so we need to fixup the full_name.
406          */
407         cpu_name = kasprintf(GFP_KERNEL, "/cpus%s", dn->full_name);
408         if (!cpu_name) {
409                 dlpar_free_cc_nodes(dn);
410                 rc = -ENOMEM;
411                 goto out;
412         }
413 
414         kfree(dn->full_name);
415         dn->full_name = cpu_name;
416 
417         rc = dlpar_acquire_drc(drc_index);
418         if (rc) {
419                 dlpar_free_cc_nodes(dn);
420                 rc = -EINVAL;
421                 goto out;
422         }
423 
424         rc = dlpar_attach_node(dn);
425         if (rc) {
426                 dlpar_release_drc(drc_index);
427                 dlpar_free_cc_nodes(dn);
428                 goto out;
429         }
430 
431         rc = dlpar_online_cpu(dn);
432 out:
433         cpu_hotplug_driver_unlock();
434 
435         return rc ? rc : count;
436 }
437 
438 static int dlpar_offline_cpu(struct device_node *dn)
439 {
440         int rc = 0;
441         unsigned int cpu;
442         int len, nthreads, i;
443         const u32 *intserv;
444 
445         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
446         if (!intserv)
447                 return -EINVAL;
448 
449         nthreads = len / sizeof(u32);
450 
451         cpu_maps_update_begin();
452         for (i = 0; i < nthreads; i++) {
453                 for_each_present_cpu(cpu) {
454                         if (get_hard_smp_processor_id(cpu) != intserv[i])
455                                 continue;
456 
457                         if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
458                                 break;
459 
460                         if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
461                                 set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
462                                 cpu_maps_update_done();
463                                 rc = cpu_down(cpu);
464                                 if (rc)
465                                         goto out;
466                                 cpu_maps_update_begin();
467                                 break;
468 
469                         }
470 
471                         /*
472                          * The cpu is in CPU_STATE_INACTIVE.
473                          * Upgrade it's state to CPU_STATE_OFFLINE.
474                          */
475                         set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
476                         BUG_ON(plpar_hcall_norets(H_PROD, intserv[i])
477                                                                 != H_SUCCESS);
478                         __cpu_die(cpu);
479                         break;
480                 }
481                 if (cpu == num_possible_cpus())
482                         printk(KERN_WARNING "Could not find cpu to offline "
483                                "with physical id 0x%x\n", intserv[i]);
484         }
485         cpu_maps_update_done();
486 
487 out:
488         return rc;
489 
490 }
491 
492 static ssize_t dlpar_cpu_release(const char *buf, size_t count)
493 {
494         struct device_node *dn;
495         const u32 *drc_index;
496         int rc;
497 
498         dn = of_find_node_by_path(buf);
499         if (!dn)
500                 return -EINVAL;
501 
502         drc_index = of_get_property(dn, "ibm,my-drc-index", NULL);
503         if (!drc_index) {
504                 of_node_put(dn);
505                 return -EINVAL;
506         }
507 
508         cpu_hotplug_driver_lock();
509         rc = dlpar_offline_cpu(dn);
510         if (rc) {
511                 of_node_put(dn);
512                 rc = -EINVAL;
513                 goto out;
514         }
515 
516         rc = dlpar_release_drc(*drc_index);
517         if (rc) {
518                 of_node_put(dn);
519                 goto out;
520         }
521 
522         rc = dlpar_detach_node(dn);
523         if (rc) {
524                 dlpar_acquire_drc(*drc_index);
525                 goto out;
526         }
527 
528         of_node_put(dn);
529 out:
530         cpu_hotplug_driver_unlock();
531         return rc ? rc : count;
532 }
533 
534 static int __init pseries_dlpar_init(void)
535 {
536         ppc_md.cpu_probe = dlpar_cpu_probe;
537         ppc_md.cpu_release = dlpar_cpu_release;
538 
539         return 0;
540 }
541 machine_device_initcall(pseries, pseries_dlpar_init);
542 
543 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
544 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp