fs/openpromfs/inode.c

   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");