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