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 | |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 165 | static int openpromfs_readdir(struct file *, struct dir_context *); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 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, |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 169 | .iterate = 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 | |
Al Viro | 00cd8dd | 2012-06-10 17:13:09 -0400 | [diff] [blame] | 173 | static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, unsigned int); |
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 | |
Al Viro | 00cd8dd | 2012-06-10 17:13:09 -0400 | [diff] [blame] | 179 | static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) |
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 | |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 263 | static int openpromfs_readdir(struct file *file, struct dir_context *ctx) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | { |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 265 | struct inode *inode = file_inode(file); |
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; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 270 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 272 | mutex_lock(&op_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 274 | if (ctx->pos == 0) { |
| 275 | if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR)) |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 276 | goto out; |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 277 | ctx->pos = 1; |
| 278 | } |
| 279 | if (ctx->pos == 1) { |
| 280 | if (!dir_emit(ctx, "..", 2, |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 281 | (dp->parent == NULL ? |
| 282 | OPENPROM_ROOT_INO : |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 283 | dp->parent->unique_id), DT_DIR)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | goto out; |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 285 | ctx->pos = 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | } |
Al Viro | 68c6147 | 2013-05-16 01:52:12 -0400 | [diff] [blame] | 287 | i = ctx->pos - 2; |
| 288 | |
| 289 | /* First, the children nodes as directories. */ |
| 290 | child = dp->child; |
| 291 | while (i && child) { |
| 292 | child = child->sibling; |
| 293 | i--; |
| 294 | } |
| 295 | while (child) { |
| 296 | if (!dir_emit(ctx, |
| 297 | child->path_component_name, |
| 298 | strlen(child->path_component_name), |
| 299 | child->unique_id, DT_DIR)) |
| 300 | goto out; |
| 301 | |
| 302 | ctx->pos++; |
| 303 | child = child->sibling; |
| 304 | } |
| 305 | |
| 306 | /* Next, the properties as files. */ |
| 307 | prop = dp->properties; |
| 308 | while (i && prop) { |
| 309 | prop = prop->next; |
| 310 | i--; |
| 311 | } |
| 312 | while (prop) { |
| 313 | if (!dir_emit(ctx, prop->name, strlen(prop->name), |
| 314 | prop->unique_id, DT_REG)) |
| 315 | goto out; |
| 316 | |
| 317 | ctx->pos++; |
| 318 | prop = prop->next; |
| 319 | } |
| 320 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | out: |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 322 | mutex_unlock(&op_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | return 0; |
| 324 | } |
| 325 | |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 326 | static struct kmem_cache *op_inode_cachep; |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 327 | |
| 328 | static struct inode *openprom_alloc_inode(struct super_block *sb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 330 | struct op_inode_info *oi; |
| 331 | |
Christoph Lameter | e94b176 | 2006-12-06 20:33:17 -0800 | [diff] [blame] | 332 | oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 333 | if (!oi) |
| 334 | return NULL; |
| 335 | |
| 336 | return &oi->vfs_inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | } |
| 338 | |
Nick Piggin | fa0d7e3d | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 339 | static void openprom_i_callback(struct rcu_head *head) |
| 340 | { |
| 341 | struct inode *inode = container_of(head, struct inode, i_rcu); |
Nick Piggin | fa0d7e3d | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 342 | kmem_cache_free(op_inode_cachep, OP_I(inode)); |
| 343 | } |
| 344 | |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 345 | static void openprom_destroy_inode(struct inode *inode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | { |
Nick Piggin | fa0d7e3d | 2011-01-07 17:49:49 +1100 | [diff] [blame] | 347 | call_rcu(&inode->i_rcu, openprom_i_callback); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | } |
| 349 | |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 350 | static struct inode *openprom_iget(struct super_block *sb, ino_t ino) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | { |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 352 | struct inode *inode; |
| 353 | |
| 354 | inode = iget_locked(sb, ino); |
| 355 | if (!inode) |
| 356 | return ERR_PTR(-ENOMEM); |
| 357 | if (inode->i_state & I_NEW) { |
| 358 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
| 359 | if (inode->i_ino == OPENPROM_ROOT_INO) { |
| 360 | inode->i_op = &openprom_inode_operations; |
| 361 | inode->i_fop = &openprom_operations; |
| 362 | inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; |
| 363 | } |
| 364 | unlock_new_inode(inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | } |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 366 | return inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | static int openprom_remount(struct super_block *sb, int *flags, char *data) |
| 370 | { |
Theodore Ts'o | 02b9984 | 2014-03-13 10:14:33 -0400 | [diff] [blame^] | 371 | sync_filesystem(sb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | *flags |= MS_NOATIME; |
| 373 | return 0; |
| 374 | } |
| 375 | |
Josef 'Jeff' Sipek | ee9b6d6 | 2007-02-12 00:55:41 -0800 | [diff] [blame] | 376 | static const struct super_operations openprom_sops = { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 377 | .alloc_inode = openprom_alloc_inode, |
| 378 | .destroy_inode = openprom_destroy_inode, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | .statfs = simple_statfs, |
| 380 | .remount_fs = openprom_remount, |
| 381 | }; |
| 382 | |
| 383 | static int openprom_fill_super(struct super_block *s, void *data, int silent) |
| 384 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 385 | struct inode *root_inode; |
| 386 | struct op_inode_info *oi; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 387 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | |
| 389 | s->s_flags |= MS_NOATIME; |
| 390 | s->s_blocksize = 1024; |
| 391 | s->s_blocksize_bits = 10; |
| 392 | s->s_magic = OPENPROM_SUPER_MAGIC; |
| 393 | s->s_op = &openprom_sops; |
| 394 | s->s_time_gran = 1; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 395 | root_inode = openprom_iget(s, OPENPROM_ROOT_INO); |
| 396 | if (IS_ERR(root_inode)) { |
| 397 | ret = PTR_ERR(root_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | goto out_no_root; |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 399 | } |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 400 | |
| 401 | oi = OP_I(root_inode); |
| 402 | oi->type = op_inode_node; |
| 403 | oi->u.node = of_find_node_by_path("/"); |
| 404 | |
Al Viro | 48fde70 | 2012-01-08 22:15:13 -0500 | [diff] [blame] | 405 | s->s_root = d_make_root(root_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | if (!s->s_root) |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 407 | goto out_no_root_dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 408 | return 0; |
| 409 | |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 410 | out_no_root_dentry: |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 411 | ret = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | out_no_root: |
| 413 | printk("openprom_fill_super: get root inode failed\n"); |
David Howells | b88a27e | 2008-02-07 00:15:49 -0800 | [diff] [blame] | 414 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | } |
| 416 | |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 417 | static struct dentry *openprom_mount(struct file_system_type *fs_type, |
| 418 | int flags, const char *dev_name, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | { |
Meelis Roos | 0e15482 | 2010-11-08 13:38:14 -0800 | [diff] [blame] | 420 | return mount_single(fs_type, flags, data, openprom_fill_super); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | } |
| 422 | |
| 423 | static struct file_system_type openprom_fs_type = { |
| 424 | .owner = THIS_MODULE, |
| 425 | .name = "openpromfs", |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 426 | .mount = openprom_mount, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 427 | .kill_sb = kill_anon_super, |
| 428 | }; |
Eric W. Biederman | 7f78e03 | 2013-03-02 19:39:14 -0800 | [diff] [blame] | 429 | MODULE_ALIAS_FS("openpromfs"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 430 | |
Alexey Dobriyan | 51cc506 | 2008-07-25 19:45:34 -0700 | [diff] [blame] | 431 | static void op_inode_init_once(void *data) |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 432 | { |
| 433 | struct op_inode_info *oi = (struct op_inode_info *) data; |
| 434 | |
Christoph Lameter | a35afb8 | 2007-05-16 22:10:57 -0700 | [diff] [blame] | 435 | inode_init_once(&oi->vfs_inode); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 436 | } |
| 437 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | static int __init init_openprom_fs(void) |
| 439 | { |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 440 | int err; |
| 441 | |
| 442 | op_inode_cachep = kmem_cache_create("op_inode_cache", |
| 443 | sizeof(struct op_inode_info), |
| 444 | 0, |
| 445 | (SLAB_RECLAIM_ACCOUNT | |
| 446 | SLAB_MEM_SPREAD), |
Paul Mundt | 20c2df8 | 2007-07-20 10:11:58 +0900 | [diff] [blame] | 447 | op_inode_init_once); |
David S. Miller | 3d824a4 | 2006-06-25 23:19:14 -0700 | [diff] [blame] | 448 | if (!op_inode_cachep) |
| 449 | return -ENOMEM; |
| 450 | |
| 451 | err = register_filesystem(&openprom_fs_type); |
| 452 | if (err) |
| 453 | kmem_cache_destroy(op_inode_cachep); |
| 454 | |
| 455 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | static void __exit exit_openprom_fs(void) |
| 459 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | unregister_filesystem(&openprom_fs_type); |
Kirill A. Shutemov | 8c0a853 | 2012-09-26 11:33:07 +1000 | [diff] [blame] | 461 | /* |
| 462 | * Make sure all delayed rcu free inodes are flushed before we |
| 463 | * destroy cache. |
| 464 | */ |
| 465 | rcu_barrier(); |
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"); |