/* * proc_devtree.c - handles /proc/device-tree * * Copyright 1997 Paul Mackerras */ #include <linux/errno.h> #include <linux/init.h> #include <linux/time.h> #include <linux/proc_fs.h> #include <linux/stat.h> #include <linux/string.h> #include <asm/prom.h> #include <asm/uaccess.h> #ifndef HAVE_ARCH_DEVTREE_FIXUPS static inline void set_node_proc_entry(struct device_node *np, struct proc_dir_entry *de) { } #endif static struct proc_dir_entry *proc_device_tree; /* * Supply data on a read from /proc/device-tree/node/property. */ static int property_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { struct property *pp = data; int n; if (off >= pp->length) { *eof = 1; return 0; } n = pp->length - off; if (n > count) n = count; else *eof = 1; memcpy(page, (char *)pp->value + off, n); *start = page; return n; } /* * For a node with a name like "gc@10", we make symlinks called "gc" * and "@10" to it. */ /* * Add a property to a node */ static struct proc_dir_entry * __proc_device_tree_add_prop(struct proc_dir_entry *de, struct property *pp, const char *name) { struct proc_dir_entry *ent; /* * Unfortunately proc_register puts each new entry * at the beginning of the list. So we rearrange them. */ ent = create_proc_read_entry(name, strncmp(name, "security-", 9) ? S_IRUGO : S_IRUSR, de, property_read_proc, pp); if (ent == NULL) return NULL; if (!strncmp(name, "security-", 9)) ent->size = 0; /* don't leak number of password chars */ else ent->size = pp->length; return ent; } void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop) { __proc_device_tree_add_prop(pde, prop, prop->name); } void proc_device_tree_remove_prop(struct proc_dir_entry *pde, struct property *prop) { remove_proc_entry(prop->name, pde); } void proc_device_tree_update_prop(struct proc_dir_entry *pde, struct property *newprop, struct property *oldprop) { struct proc_dir_entry *ent; for (ent = pde->subdir; ent != NULL; ent = ent->next) if (ent->data == oldprop) break; if (ent == NULL) { printk(KERN_WARNING "device-tree: property \"%s\" " " does not exist\n", oldprop->name); } else { ent->data = newprop; ent->size = newprop->length; } } /* * Various dodgy firmware might give us nodes and/or properties with * conflicting names. That's generally ok, except for exporting via /proc, * so munge names here to ensure they're unique. */ static int duplicate_name(struct proc_dir_entry *de, const char *name) { struct proc_dir_entry *ent; int found = 0; spin_lock(&proc_subdir_lock); for (ent = de->subdir; ent != NULL; ent = ent->next) { if (strcmp(ent->name, name) == 0) { found = 1; break; } } spin_unlock(&proc_subdir_lock); return found; } static const char *fixup_name(struct device_node *np, struct proc_dir_entry *de, const char *name) { char *fixed_name; int fixup_len = strlen(name) + 2 + 1; /* name + #x + \0 */ int i = 1, size; realloc: fixed_name = kmalloc(fixup_len, GFP_KERNEL); if (fixed_name == NULL) { printk(KERN_ERR "device-tree: Out of memory trying to fixup " "name \"%s\"\n", name); return name; } retry: size = snprintf(fixed_name, fixup_len, "%s#%d", name, i); size++; /* account for NULL */ if (size > fixup_len) { /* We ran out of space, free and reallocate. */ kfree(fixed_name); fixup_len = size; goto realloc; } if (duplicate_name(de, fixed_name)) { /* Multiple duplicates. Retry with a different offset. */ i++; goto retry; } printk(KERN_WARNING "device-tree: Duplicate name in %s, " "renamed to \"%s\"\n", np->full_name, fixed_name); return fixed_name; } /* * Process a node, adding entries for its children and its properties. */ void proc_device_tree_add_node(struct device_node *np, struct proc_dir_entry *de) { struct property *pp; struct proc_dir_entry *ent; struct device_node *child; const char *p; set_node_proc_entry(np, de); for (child = NULL; (child = of_get_next_child(np, child));) { /* Use everything after the last slash, or the full name */ p = strrchr(child->full_name, '/'); if (!p) p = child->full_name; else ++p; if (duplicate_name(de, p)) p = fixup_name(np, de, p); ent = proc_mkdir(p, de); if (ent == 0) break; proc_device_tree_add_node(child, ent); } of_node_put(child); for (pp = np->properties; pp != 0; pp = pp->next) { p = pp->name; if (duplicate_name(de, p)) p = fixup_name(np, de, p); ent = __proc_device_tree_add_prop(de, pp, p); if (ent == 0) break; } } /* * Called on initialization to set up the /proc/device-tree subtree */ void __init proc_device_tree_init(void) { struct device_node *root; if ( !have_of ) return; proc_device_tree = proc_mkdir("device-tree", NULL); if (proc_device_tree == 0) return; root = of_find_node_by_path("/"); if (root == 0) { printk(KERN_ERR "/proc/device-tree: can't find root\n"); return; } proc_device_tree_add_node(root, proc_device_tree); of_node_put(root); }