David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 1 | /* inode.c: /proc/openprom handling routines |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * Copyright (C) 1996-1999 Jakub Jelinek (jakub@redhat.com) |
| 4 | * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be) |
| 5 | */ |
| 6 | |
| 7 | #include <linux/module.h> |
| 8 | #include <linux/types.h> |
| 9 | #include <linux/string.h> |
| 10 | #include <linux/fs.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/init.h> |
| 12 | #include <linux/slab.h> |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 13 | #include <linux/seq_file.h> |
Jeff Garzik | e18fa70 | 2006-09-24 11:13:19 -0400 | [diff] [blame] | 14 | #include <linux/magic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | #include <asm/openprom.h> |
| 17 | #include <asm/oplib.h> |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 18 | #include <asm/prom.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <asm/uaccess.h> |
| 20 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 21 | static DEFINE_MUTEX(op_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 23 | #define OPENPROM_ROOT_INO 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 25 | enum op_inode_type { |
| 26 | op_inode_node, |
| 27 | op_inode_prop, |
| 28 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 30 | union op_inode_data { |
| 31 | struct device_node *node; |
| 32 | struct property *prop; |
| 33 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 35 | struct op_inode_info { |
| 36 | struct inode vfs_inode; |
| 37 | enum op_inode_type type; |
| 38 | union op_inode_data u; |
| 39 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 41 | static struct inode *openprom_iget(struct super_block *sb, ino_t ino); |
| 42 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 43 | static inline struct op_inode_info *OP_I(struct inode *inode) |
Jan Engelhardt | a04ee14 | 2006-06-25 05:47:36 -0700 | [diff] [blame] | 44 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 45 | return container_of(inode, struct op_inode_info, vfs_inode); |
Jan Engelhardt | a04ee14 | 2006-06-25 05:47:36 -0700 | [diff] [blame] | 46 | } |
| 47 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 48 | static int is_string(unsigned char *p, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 50 | int i; |
| 51 | |
| 52 | for (i = 0; i < len; i++) { |
| 53 | unsigned char val = p[i]; |
| 54 | |
| 55 | if ((i && !val) || |
| 56 | (val >= ' ' && val <= '~')) |
| 57 | continue; |
| 58 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | return 0; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | } |
| 64 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 65 | static int property_show(struct seq_file *f, void *v) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 67 | struct property *prop = f->private; |
| 68 | void *pval; |
| 69 | int len; |
| 70 | |
| 71 | len = prop->length; |
| 72 | pval = prop->value; |
| 73 | |
| 74 | if (is_string(pval, len)) { |
| 75 | while (len > 0) { |
| 76 | int n = strlen(pval); |
| 77 | |
| 78 | seq_printf(f, "%s", (char *) pval); |
| 79 | |
| 80 | /* Skip over the NULL byte too. */ |
| 81 | pval += n + 1; |
| 82 | len -= n + 1; |
| 83 | |
| 84 | if (len > 0) |
| 85 | seq_printf(f, " + "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | } else { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 88 | if (len & 3) { |
| 89 | while (len) { |
| 90 | len--; |
| 91 | if (len) |
| 92 | seq_printf(f, "%02x.", |
| 93 | *(unsigned char *) pval); |
| 94 | else |
| 95 | seq_printf(f, "%02x", |
| 96 | *(unsigned char *) pval); |
| 97 | pval++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | } |
| 99 | } else { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 100 | while (len >= 4) { |
| 101 | len -= 4; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 103 | if (len) |
| 104 | seq_printf(f, "%08x.", |
| 105 | *(unsigned int *) pval); |
| 106 | else |
| 107 | seq_printf(f, "%08x", |
| 108 | *(unsigned int *) pval); |
| 109 | pval += 4; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | } |
| 111 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 113 | seq_printf(f, "\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | return 0; |
| 116 | } |
| 117 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 118 | static void *property_start(struct seq_file *f, loff_t *pos) |
| 119 | { |
| 120 | if (*pos == 0) |
| 121 | return pos; |
| 122 | return NULL; |
| 123 | } |
| 124 | |
| 125 | static void *property_next(struct seq_file *f, void *v, loff_t *pos) |
| 126 | { |
| 127 | (*pos)++; |
| 128 | return NULL; |
| 129 | } |
| 130 | |
| 131 | static void property_stop(struct seq_file *f, void *v) |
| 132 | { |
| 133 | /* Nothing to do */ |
| 134 | } |
| 135 | |
Jan Engelhardt | 872e2be | 2008-01-22 18:29:20 -0800 | [diff] [blame] | 136 | static const struct seq_operations property_op = { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 137 | .start = property_start, |
| 138 | .next = property_next, |
| 139 | .stop = property_stop, |
| 140 | .show = property_show |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | }; |
| 142 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 143 | static int property_open(struct inode *inode, struct file *file) |
| 144 | { |
| 145 | struct op_inode_info *oi = OP_I(inode); |
| 146 | int ret; |
| 147 | |
| 148 | BUG_ON(oi->type != op_inode_prop); |
| 149 | |
| 150 | ret = seq_open(file, &property_op); |
| 151 | if (!ret) { |
| 152 | struct seq_file *m = file->private_data; |
| 153 | m->private = oi->u.prop; |
| 154 | } |
| 155 | return ret; |
| 156 | } |
| 157 | |
| 158 | static const struct file_operations openpromfs_prop_ops = { |
| 159 | .open = property_open, |
| 160 | .read = seq_read, |
| 161 | .llseek = seq_lseek, |
| 162 | .release = seq_release, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | }; |
| 164 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 165 | static int openpromfs_readdir(struct file *, void *, filldir_t); |
| 166 | |
Arjan van de Ven | 4b6f5d2 | 2006-03-28 01:56:42 -0800 | [diff] [blame] | 167 | static const struct file_operations openprom_operations = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | .read = generic_read_dir, |
| 169 | .readdir = openpromfs_readdir, |
Christoph Hellwig | 3222a3e | 2008-09-03 21:53:01 +0200 | [diff] [blame] | 170 | .llseek = generic_file_llseek, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | }; |
| 172 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 173 | static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, struct nameidata *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | |
Arjan van de Ven | 92e1d5b | 2007-02-12 00:55:39 -0800 | [diff] [blame] | 175 | static const struct inode_operations openprom_inode_operations = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | .lookup = openpromfs_lookup, |
| 177 | }; |
| 178 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 179 | static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 181 | struct op_inode_info *ent_oi, *oi = OP_I(dir); |
| 182 | struct device_node *dp, *child; |
| 183 | struct property *prop; |
| 184 | enum op_inode_type ent_type; |
| 185 | union op_inode_data ent_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | const char *name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | struct inode *inode; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 188 | unsigned int ino; |
| 189 | int len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 191 | BUG_ON(oi->type != op_inode_node); |
| 192 | |
| 193 | dp = oi->u.node; |
| 194 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | name = dentry->d_name.name; |
| 196 | len = dentry->d_name.len; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 197 | |
| 198 | mutex_lock(&op_mutex); |
| 199 | |
| 200 | child = dp->child; |
| 201 | while (child) { |
| 202 | int n = strlen(child->path_component_name); |
| 203 | |
| 204 | if (len == n && |
| 205 | !strncmp(child->path_component_name, name, len)) { |
| 206 | ent_type = op_inode_node; |
| 207 | ent_data.node = child; |
| 208 | ino = child->unique_id; |
| 209 | goto found; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 211 | child = child->sibling; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 213 | |
| 214 | prop = dp->properties; |
| 215 | while (prop) { |
| 216 | int n = strlen(prop->name); |
| 217 | |
| 218 | if (len == n && !strncmp(prop->name, name, len)) { |
| 219 | ent_type = op_inode_prop; |
| 220 | ent_data.prop = prop; |
| 221 | ino = prop->unique_id; |
| 222 | goto found; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 224 | |
| 225 | prop = prop->next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 227 | |
| 228 | mutex_unlock(&op_mutex); |
| 229 | return ERR_PTR(-ENOENT); |
| 230 | |
| 231 | found: |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 232 | inode = openprom_iget(dir->i_sb, ino); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 233 | mutex_unlock(&op_mutex); |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 234 | if (IS_ERR(inode)) |
| 235 | return ERR_CAST(inode); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 236 | ent_oi = OP_I(inode); |
| 237 | ent_oi->type = ent_type; |
| 238 | ent_oi->u = ent_data; |
| 239 | |
| 240 | switch (ent_type) { |
| 241 | case op_inode_node: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 243 | inode->i_op = &openprom_inode_operations; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | inode->i_fop = &openprom_operations; |
Miklos Szeredi | bfe8684 | 2011-10-28 14:13:29 +0200 | [diff] [blame] | 245 | set_nlink(inode, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | break; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 247 | case op_inode_prop: |
| 248 | if (!strcmp(dp->name, "options") && (len == 17) && |
| 249 | !strncmp (name, "security-password", 17)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | inode->i_mode = S_IFREG | S_IRUSR | S_IWUSR; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 251 | else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | inode->i_mode = S_IFREG | S_IRUGO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | inode->i_fop = &openpromfs_prop_ops; |
Miklos Szeredi | bfe8684 | 2011-10-28 14:13:29 +0200 | [diff] [blame] | 254 | set_nlink(inode, 1); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 255 | inode->i_size = ent_oi->u.prop->length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | break; |
| 257 | } |
| 258 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | d_add(dentry, inode); |
| 260 | return NULL; |
| 261 | } |
| 262 | |
| 263 | static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir) |
| 264 | { |
Josef Sipek | 80a0678 | 2006-12-08 02:37:26 -0800 | [diff] [blame] | 265 | struct inode *inode = filp->f_path.dentry->d_inode; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 266 | struct op_inode_info *oi = OP_I(inode); |
| 267 | struct device_node *dp = oi->u.node; |
| 268 | struct device_node *child; |
| 269 | struct property *prop; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | unsigned int ino; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 271 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 273 | mutex_lock(&op_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | |
| 275 | ino = inode->i_ino; |
| 276 | i = filp->f_pos; |
| 277 | switch (i) { |
| 278 | case 0: |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 279 | if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) |
| 280 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | i++; |
| 282 | filp->f_pos++; |
| 283 | /* fall thru */ |
| 284 | case 1: |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 285 | if (filldir(dirent, "..", 2, i, |
| 286 | (dp->parent == NULL ? |
| 287 | OPENPROM_ROOT_INO : |
| 288 | dp->parent->unique_id), DT_DIR) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | goto out; |
| 290 | i++; |
| 291 | filp->f_pos++; |
| 292 | /* fall thru */ |
| 293 | default: |
| 294 | i -= 2; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 295 | |
| 296 | /* First, the children nodes as directories. */ |
| 297 | child = dp->child; |
| 298 | while (i && child) { |
| 299 | child = child->sibling; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | i--; |
| 301 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 302 | while (child) { |
| 303 | if (filldir(dirent, |
| 304 | child->path_component_name, |
| 305 | strlen(child->path_component_name), |
| 306 | filp->f_pos, child->unique_id, DT_DIR) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | goto out; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 308 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | filp->f_pos++; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 310 | child = child->sibling; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 312 | |
| 313 | /* Next, the properties as files. */ |
| 314 | prop = dp->properties; |
| 315 | while (i && prop) { |
| 316 | prop = prop->next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | i--; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 318 | } |
| 319 | while (prop) { |
| 320 | if (filldir(dirent, prop->name, strlen(prop->name), |
| 321 | filp->f_pos, prop->unique_id, DT_REG) < 0) |
| 322 | goto out; |
| 323 | |
| 324 | filp->f_pos++; |
| 325 | prop = prop->next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | } |
| 327 | } |
| 328 | out: |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 329 | mutex_unlock(&op_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | return 0; |
| 331 | } |
| 332 | |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 333 | static struct kmem_cache *op_inode_cachep; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 334 | |
| 335 | static struct inode *openprom_alloc_inode(struct super_block *sb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 337 | struct op_inode_info *oi; |
| 338 | |
Christoph Lameter | e94b176 | 2006-12-06 20:33:17 -0800 | [diff] [blame] | 339 | oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 340 | if (!oi) |
| 341 | return NULL; |
| 342 | |
| 343 | return &oi->vfs_inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | } |
| 345 | |
Nick Piggin | fa0d7e3 | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 346 | static void openprom_i_callback(struct rcu_head *head) |
| 347 | { |
| 348 | struct inode *inode = container_of(head, struct inode, i_rcu); |
Nick Piggin | fa0d7e3 | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 349 | kmem_cache_free(op_inode_cachep, OP_I(inode)); |
| 350 | } |
| 351 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 352 | static void openprom_destroy_inode(struct inode *inode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | { |
Nick Piggin | fa0d7e3 | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 354 | call_rcu(&inode->i_rcu, openprom_i_callback); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | } |
| 356 | |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 357 | static struct inode *openprom_iget(struct super_block *sb, ino_t ino) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | { |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 359 | struct inode *inode; |
| 360 | |
| 361 | inode = iget_locked(sb, ino); |
| 362 | if (!inode) |
| 363 | return ERR_PTR(-ENOMEM); |
| 364 | if (inode->i_state & I_NEW) { |
| 365 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
| 366 | if (inode->i_ino == OPENPROM_ROOT_INO) { |
| 367 | inode->i_op = &openprom_inode_operations; |
| 368 | inode->i_fop = &openprom_operations; |
| 369 | inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; |
| 370 | } |
| 371 | unlock_new_inode(inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | } |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 373 | return inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | } |
| 375 | |
| 376 | static int openprom_remount(struct super_block *sb, int *flags, char *data) |
| 377 | { |
| 378 | *flags |= MS_NOATIME; |
| 379 | return 0; |
| 380 | } |
| 381 | |
Josef 'Jeff' Sipek | ee9b6d6 | 2007-02-12 00:55:41 -0800 | [diff] [blame] | 382 | static const struct super_operations openprom_sops = { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 383 | .alloc_inode = openprom_alloc_inode, |
| 384 | .destroy_inode = openprom_destroy_inode, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | .statfs = simple_statfs, |
| 386 | .remount_fs = openprom_remount, |
| 387 | }; |
| 388 | |
| 389 | static int openprom_fill_super(struct super_block *s, void *data, int silent) |
| 390 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 391 | struct inode *root_inode; |
| 392 | struct op_inode_info *oi; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 393 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | |
| 395 | s->s_flags |= MS_NOATIME; |
| 396 | s->s_blocksize = 1024; |
| 397 | s->s_blocksize_bits = 10; |
| 398 | s->s_magic = OPENPROM_SUPER_MAGIC; |
| 399 | s->s_op = &openprom_sops; |
| 400 | s->s_time_gran = 1; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 401 | root_inode = openprom_iget(s, OPENPROM_ROOT_INO); |
| 402 | if (IS_ERR(root_inode)) { |
| 403 | ret = PTR_ERR(root_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | goto out_no_root; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 405 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 406 | |
| 407 | oi = OP_I(root_inode); |
| 408 | oi->type = op_inode_node; |
| 409 | oi->u.node = of_find_node_by_path("/"); |
| 410 | |
Al Viro | 48fde70 | 2012-01-08 22:15:13 -0500 | [diff] [blame] | 411 | s->s_root = d_make_root(root_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | if (!s->s_root) |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 413 | goto out_no_root_dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | return 0; |
| 415 | |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 416 | out_no_root_dentry: |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 417 | ret = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | out_no_root: |
| 419 | printk("openprom_fill_super: get root inode failed\n"); |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 420 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | } |
| 422 | |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 423 | static struct dentry *openprom_mount(struct file_system_type *fs_type, |
| 424 | int flags, const char *dev_name, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 425 | { |
Meelis Roos | 0e15482 | 2010-11-08 13:38:14 -0800 | [diff] [blame] | 426 | return mount_single(fs_type, flags, data, openprom_fill_super); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | static struct file_system_type openprom_fs_type = { |
| 430 | .owner = THIS_MODULE, |
| 431 | .name = "openpromfs", |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 432 | .mount = openprom_mount, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | .kill_sb = kill_anon_super, |
| 434 | }; |
| 435 | |
Alexey Dobriyan | 51cc506 | 2008-07-25 19:45:34 -0700 | [diff] [blame] | 436 | static void op_inode_init_once(void *data) |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 437 | { |
| 438 | struct op_inode_info *oi = (struct op_inode_info *) data; |
| 439 | |
Christoph Lameter | a35afb8 | 2007-05-16 22:10:57 -0700 | [diff] [blame] | 440 | inode_init_once(&oi->vfs_inode); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 441 | } |
| 442 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | static int __init init_openprom_fs(void) |
| 444 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 445 | int err; |
| 446 | |
| 447 | op_inode_cachep = kmem_cache_create("op_inode_cache", |
| 448 | sizeof(struct op_inode_info), |
| 449 | 0, |
| 450 | (SLAB_RECLAIM_ACCOUNT | |
| 451 | SLAB_MEM_SPREAD), |
Paul Mundt | 20c2df8 | 2007-07-20 10:11:58 +0900 | [diff] [blame] | 452 | op_inode_init_once); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 453 | if (!op_inode_cachep) |
| 454 | return -ENOMEM; |
| 455 | |
| 456 | err = register_filesystem(&openprom_fs_type); |
| 457 | if (err) |
| 458 | kmem_cache_destroy(op_inode_cachep); |
| 459 | |
| 460 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | } |
| 462 | |
| 463 | static void __exit exit_openprom_fs(void) |
| 464 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | unregister_filesystem(&openprom_fs_type); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 466 | kmem_cache_destroy(op_inode_cachep); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | } |
| 468 | |
| 469 | module_init(init_openprom_fs) |
| 470 | module_exit(exit_openprom_fs) |
| 471 | MODULE_LICENSE("GPL"); |