1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * pSeries_reconfig.c - support for dynamic reconfiguration (including PCI 4 * Hotplug and Dynamic Logical Partitioning on RPA platforms). 5 * 6 * Copyright (C) 2005 Nathan Lynch 7 * Copyright (C) 2005 IBM Corporation 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/notifier.h> 12 #include <linux/proc_fs.h> 13 #include <linux/security.h> 14 #include <linux/slab.h> 15 #include <linux/of.h> 16 17 #include <asm/machdep.h> 18 #include <linux/uaccess.h> 19 #include <asm/mmu.h> 20 21 #include "of_helpers.h" 22 23 static int pSeries_reconfig_add_node(const char *path, struct property *proplist) 24 { 25 struct device_node *np; 26 int err = -ENOMEM; 27 28 np = kzalloc(sizeof(*np), GFP_KERNEL); 29 if (!np) 30 goto out_err; 31 32 np->full_name = kstrdup(kbasename(path), GFP_KERNEL); 33 if (!np->full_name) 34 goto out_err; 35 36 np->properties = proplist; 37 of_node_set_flag(np, OF_DYNAMIC); 38 of_node_init(np); 39 40 np->parent = pseries_of_derive_parent(path); 41 if (IS_ERR(np->parent)) { 42 err = PTR_ERR(np->parent); 43 goto out_err; 44 } 45 46 err = of_attach_node(np); 47 if (err) { 48 printk(KERN_ERR "Failed to add device node %s\n", path); 49 goto out_err; 50 } 51 52 of_node_put(np->parent); 53 54 return 0; 55 56 out_err: 57 if (np) { 58 of_node_put(np->parent); 59 kfree(np->full_name); 60 kfree(np); 61 } 62 return err; 63 } 64 65 static int pSeries_reconfig_remove_node(struct device_node *np) 66 { 67 struct device_node *parent, *child; 68 69 parent = of_get_parent(np); 70 if (!parent) 71 return -EINVAL; 72 73 if ((child = of_get_next_child(np, NULL))) { 74 of_node_put(child); 75 of_node_put(parent); 76 return -EBUSY; 77 } 78 79 of_detach_node(np); 80 of_node_put(parent); 81 return 0; 82 } 83 84 /* 85 * /proc/powerpc/ofdt - yucky binary interface for adding and removing 86 * OF device nodes. Should be deprecated as soon as we get an 87 * in-kernel wrapper for the RTAS ibm,configure-connector call. 88 */ 89 90 static void release_prop_list(const struct property *prop) 91 { 92 struct property *next; 93 for (; prop; prop = next) { 94 next = prop->next; 95 kfree(prop->name); 96 kfree(prop->value); 97 kfree(prop); 98 } 99 100 } 101 102 /** 103 * parse_next_property - process the next property from raw input buffer 104 * @buf: input buffer, must be nul-terminated 105 * @end: end of the input buffer + 1, for validation 106 * @name: return value; set to property name in buf 107 * @length: return value; set to length of value 108 * @value: return value; set to the property value in buf 109 * 110 * Note that the caller must make copies of the name and value returned, 111 * this function does no allocation or copying of the data. Return value 112 * is set to the next name in buf, or NULL on error. 113 */ 114 static char * parse_next_property(char *buf, char *end, char **name, int *length, 115 unsigned char **value) 116 { 117 char *tmp; 118 119 *name = buf; 120 121 tmp = strchr(buf, ' '); 122 if (!tmp) { 123 printk(KERN_ERR "property parse failed in %s at line %d\n", 124 __func__, __LINE__); 125 return NULL; 126 } 127 *tmp = '\0'; 128 129 if (++tmp >= end) { 130 printk(KERN_ERR "property parse failed in %s at line %d\n", 131 __func__, __LINE__); 132 return NULL; 133 } 134 135 /* now we're on the length */ 136 *length = -1; 137 *length = simple_strtoul(tmp, &tmp, 10); 138 if (*length == -1) { 139 printk(KERN_ERR "property parse failed in %s at line %d\n", 140 __func__, __LINE__); 141 return NULL; 142 } 143 if (*tmp != ' ' || ++tmp >= end) { 144 printk(KERN_ERR "property parse failed in %s at line %d\n", 145 __func__, __LINE__); 146 return NULL; 147 } 148 149 /* now we're on the value */ 150 *value = tmp; 151 tmp += *length; 152 if (tmp > end) { 153 printk(KERN_ERR "property parse failed in %s at line %d\n", 154 __func__, __LINE__); 155 return NULL; 156 } 157 else if (tmp < end && *tmp != ' ' && *tmp != '\0') { 158 printk(KERN_ERR "property parse failed in %s at line %d\n", 159 __func__, __LINE__); 160 return NULL; 161 } 162 tmp++; 163 164 /* and now we should be on the next name, or the end */ 165 return tmp; 166 } 167 168 static struct property *new_property(const char *name, const int length, 169 const unsigned char *value, struct property *last) 170 { 171 struct property *new = kzalloc(sizeof(*new), GFP_KERNEL); 172 173 if (!new) 174 return NULL; 175 176 if (!(new->name = kstrdup(name, GFP_KERNEL))) 177 goto cleanup; 178 if (!(new->value = kmalloc(length + 1, GFP_KERNEL))) 179 goto cleanup; 180 181 memcpy(new->value, value, length); 182 *(((char *)new->value) + length) = 0; 183 new->length = length; 184 new->next = last; 185 return new; 186 187 cleanup: 188 kfree(new->name); 189 kfree(new->value); 190 kfree(new); 191 return NULL; 192 } 193 194 static int do_add_node(char *buf, size_t bufsize) 195 { 196 char *path, *end, *name; 197 struct device_node *np; 198 struct property *prop = NULL; 199 unsigned char* value; 200 int length, rv = 0; 201 202 end = buf + bufsize; 203 path = buf; 204 buf = strchr(buf, ' '); 205 if (!buf) 206 return -EINVAL; 207 *buf = '\0'; 208 buf++; 209 210 if ((np = of_find_node_by_path(path))) { 211 of_node_put(np); 212 return -EINVAL; 213 } 214 215 /* rv = build_prop_list(tmp, bufsize - (tmp - buf), &proplist); */ 216 while (buf < end && 217 (buf = parse_next_property(buf, end, &name, &length, &value))) { 218 struct property *last = prop; 219 220 prop = new_property(name, length, value, last); 221 if (!prop) { 222 rv = -ENOMEM; 223 prop = last; 224 goto out; 225 } 226 } 227 if (!buf) { 228 rv = -EINVAL; 229 goto out; 230 } 231 232 rv = pSeries_reconfig_add_node(path, prop); 233 234 out: 235 if (rv) 236 release_prop_list(prop); 237 return rv; 238 } 239 240 static int do_remove_node(char *buf) 241 { 242 struct device_node *node; 243 int rv = -ENODEV; 244 245 if ((node = of_find_node_by_path(buf))) 246 rv = pSeries_reconfig_remove_node(node); 247 248 of_node_put(node); 249 return rv; 250 } 251 252 static char *parse_node(char *buf, size_t bufsize, struct device_node **npp) 253 { 254 char *handle_str; 255 phandle handle; 256 *npp = NULL; 257 258 handle_str = buf; 259 260 buf = strchr(buf, ' '); 261 if (!buf) 262 return NULL; 263 *buf = '\0'; 264 buf++; 265 266 handle = simple_strtoul(handle_str, NULL, 0); 267 268 *npp = of_find_node_by_phandle(handle); 269 return buf; 270 } 271 272 static int do_add_property(char *buf, size_t bufsize) 273 { 274 struct property *prop = NULL; 275 struct device_node *np; 276 unsigned char *value; 277 char *name, *end; 278 int length; 279 end = buf + bufsize; 280 buf = parse_node(buf, bufsize, &np); 281 282 if (!np) 283 return -ENODEV; 284 285 if (parse_next_property(buf, end, &name, &length, &value) == NULL) 286 return -EINVAL; 287 288 prop = new_property(name, length, value, NULL); 289 if (!prop) 290 return -ENOMEM; 291 292 of_add_property(np, prop); 293 294 return 0; 295 } 296 297 static int do_remove_property(char *buf, size_t bufsize) 298 { 299 struct device_node *np; 300 char *tmp; 301 buf = parse_node(buf, bufsize, &np); 302 303 if (!np) 304 return -ENODEV; 305 306 tmp = strchr(buf,' '); 307 if (tmp) 308 *tmp = '\0'; 309 310 if (strlen(buf) == 0) 311 return -EINVAL; 312 313 return of_remove_property(np, of_find_property(np, buf, NULL)); 314 } 315 316 static int do_update_property(char *buf, size_t bufsize) 317 { 318 struct device_node *np; 319 unsigned char *value; 320 char *name, *end, *next_prop; 321 int length; 322 struct property *newprop; 323 buf = parse_node(buf, bufsize, &np); 324 end = buf + bufsize; 325 326 if (!np) 327 return -ENODEV; 328 329 next_prop = parse_next_property(buf, end, &name, &length, &value); 330 if (!next_prop) 331 return -EINVAL; 332 333 if (!strlen(name)) 334 return -ENODEV; 335 336 newprop = new_property(name, length, value, NULL); 337 if (!newprop) 338 return -ENOMEM; 339 340 if (!strcmp(name, "slb-size") || !strcmp(name, "ibm,slb-size")) 341 slb_set_size(*(int *)value); 342 343 return of_update_property(np, newprop); 344 } 345 346 /** 347 * ofdt_write - perform operations on the Open Firmware device tree 348 * 349 * @file: not used 350 * @buf: command and arguments 351 * @count: size of the command buffer 352 * @off: not used 353 * 354 * Operations supported at this time are addition and removal of 355 * whole nodes along with their properties. Operations on individual 356 * properties are not implemented (yet). 357 */ 358 static ssize_t ofdt_write(struct file *file, const char __user *buf, size_t count, 359 loff_t *off) 360 { 361 int rv; 362 char *kbuf; 363 char *tmp; 364 365 rv = security_locked_down(LOCKDOWN_DEVICE_TREE); 366 if (rv) 367 return rv; 368 369 kbuf = memdup_user_nul(buf, count); 370 if (IS_ERR(kbuf)) 371 return PTR_ERR(kbuf); 372 373 tmp = strchr(kbuf, ' '); 374 if (!tmp) { 375 rv = -EINVAL; 376 goto out; 377 } 378 *tmp = '\0'; 379 tmp++; 380 381 if (!strcmp(kbuf, "add_node")) 382 rv = do_add_node(tmp, count - (tmp - kbuf)); 383 else if (!strcmp(kbuf, "remove_node")) 384 rv = do_remove_node(tmp); 385 else if (!strcmp(kbuf, "add_property")) 386 rv = do_add_property(tmp, count - (tmp - kbuf)); 387 else if (!strcmp(kbuf, "remove_property")) 388 rv = do_remove_property(tmp, count - (tmp - kbuf)); 389 else if (!strcmp(kbuf, "update_property")) 390 rv = do_update_property(tmp, count - (tmp - kbuf)); 391 else 392 rv = -EINVAL; 393 out: 394 kfree(kbuf); 395 return rv ? rv : count; 396 } 397 398 static const struct proc_ops ofdt_proc_ops = { 399 .proc_write = ofdt_write, 400 .proc_lseek = noop_llseek, 401 }; 402 403 /* create /proc/powerpc/ofdt write-only by root */ 404 static int proc_ppc64_create_ofdt(void) 405 { 406 struct proc_dir_entry *ent; 407 408 ent = proc_create("powerpc/ofdt", 0200, NULL, &ofdt_proc_ops); 409 if (ent) 410 proc_set_size(ent, 0); 411 412 return 0; 413 } 414 machine_device_initcall(pseries, proc_ppc64_create_ofdt); 415