cregit-Linux how code gets into the kernel

Release 4.18 fs/openpromfs/inode.c

Directory: fs/openpromfs
/* inode.c: /proc/openprom handling routines
 *
 * Copyright (C) 1996-1999 Jakub Jelinek  (jakub@redhat.com)
 * Copyright (C) 1998      Eddie C. Dost  (ecd@skynet.be)
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/magic.h>

#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <linux/uaccess.h>

static DEFINE_MUTEX(op_mutex);


#define OPENPROM_ROOT_INO	0


enum op_inode_type {
	
op_inode_node,
	
op_inode_prop,
};


union op_inode_data {
	
struct device_node	*node;
	
struct property		*prop;
};


struct op_inode_info {
	
struct inode		vfs_inode;
	
enum op_inode_type	type;
	
union op_inode_data	u;
};

static struct inode *openprom_iget(struct super_block *sb, ino_t ino);


static inline struct op_inode_info *OP_I(struct inode *inode) { return container_of(inode, struct op_inode_info, vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller2184.00%150.00%
Linus Torvalds (pre-git)416.00%150.00%
Total25100.00%2100.00%


static int is_string(unsigned char *p, int len) { int i; for (i = 0; i < len; i++) { unsigned char val = p[i]; if ((i && !val) || (val >= ' ' && val <= '~')) continue; return 0; } return 1; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller6089.55%150.00%
Linus Torvalds (pre-git)710.45%150.00%
Total67100.00%2100.00%


static int property_show(struct seq_file *f, void *v) { struct property *prop = f->private; void *pval; int len; len = prop->length; pval = prop->value; if (is_string(pval, len)) { while (len > 0) { int n = strlen(pval); seq_printf(f, "%s", (char *) pval); /* Skip over the NULL byte too. */ pval += n + 1; len -= n + 1; if (len > 0) seq_printf(f, " + "); } } else { if (len & 3) { while (len) { len--; if (len) seq_printf(f, "%02x.", *(unsigned char *) pval); else seq_printf(f, "%02x", *(unsigned char *) pval); pval++; } } else { while (len >= 4) { len -= 4; if (len) seq_printf(f, "%08x.", *(unsigned int *) pval); else seq_printf(f, "%08x", *(unsigned int *) pval); pval += 4; } } } seq_printf(f, "\n"); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller18981.82%350.00%
Linus Torvalds (pre-git)4017.32%233.33%
Jan Engelhardt20.87%116.67%
Total231100.00%6100.00%


static void *property_start(struct seq_file *f, loff_t *pos) { if (*pos == 0) return pos; return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller1758.62%133.33%
Linus Torvalds (pre-git)1241.38%266.67%
Total29100.00%3100.00%


static void *property_next(struct seq_file *f, void *v, loff_t *pos) { (*pos)++; return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller1655.17%133.33%
Linus Torvalds (pre-git)1137.93%133.33%
Trond Myklebust26.90%133.33%
Total29100.00%3100.00%


static void property_stop(struct seq_file *f, void *v) { /* Nothing to do */ }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller1487.50%150.00%
Al Viro212.50%150.00%
Total16100.00%2100.00%

static const struct seq_operations property_op = { .start = property_start, .next = property_next, .stop = property_stop, .show = property_show };
static int property_open(struct inode *inode, struct file *file) { struct op_inode_info *oi = OP_I(inode); int ret; BUG_ON(oi->type != op_inode_prop); ret = seq_open(file, &property_op); if (!ret) { struct seq_file *m = file->private_data; m->private = oi->u.prop; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller6483.12%125.00%
Linus Torvalds (pre-git)1316.88%375.00%
Total77100.00%4100.00%

static const struct file_operations openpromfs_prop_ops = { .open = property_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release, }; static int openpromfs_readdir(struct file *, struct dir_context *); static const struct file_operations openprom_operations = { .read = generic_read_dir, .iterate_shared = openpromfs_readdir, .llseek = generic_file_llseek, }; static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, unsigned int); static const struct inode_operations openprom_inode_operations = { .lookup = openpromfs_lookup, };
static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) { struct op_inode_info *ent_oi, *oi = OP_I(dir); struct device_node *dp, *child; struct property *prop; enum op_inode_type ent_type; union op_inode_data ent_data; const char *name; struct inode *inode; unsigned int ino; int len; BUG_ON(oi->type != op_inode_node); dp = oi->u.node; name = dentry->d_name.name; len = dentry->d_name.len; mutex_lock(&op_mutex); child = dp->child; while (child) { int n = strlen(child->path_component_name); if (len == n && !strncmp(child->path_component_name, name, len)) { ent_type = op_inode_node; ent_data.node = child; ino = child->unique_id; goto found; } child = child->sibling; } prop = dp->properties; while (prop) { int n = strlen(prop->name); if (len == n && !strncmp(prop->name, name, len)) { ent_type = op_inode_prop; ent_data.prop = prop; ino = prop->unique_id; goto found; } prop = prop->next; } mutex_unlock(&op_mutex); return ERR_PTR(-ENOENT); found: inode = openprom_iget(dir->i_sb, ino); mutex_unlock(&op_mutex); if (IS_ERR(inode)) return ERR_CAST(inode); ent_oi = OP_I(inode); ent_oi->type = ent_type; ent_oi->u = ent_data; switch (ent_type) { case op_inode_node: inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; inode->i_op = &openprom_inode_operations; inode->i_fop = &openprom_operations; set_nlink(inode, 2); break; case op_inode_prop: if (!strcmp(dp->name, "options") && (len == 17) && !strncmp (name, "security-password", 17)) inode->i_mode = S_IFREG | S_IRUSR | S_IWUSR; else inode->i_mode = S_IFREG | S_IRUGO; inode->i_fop = &openpromfs_prop_ops; set_nlink(inode, 1); inode->i_size = ent_oi->u.prop->length; break; } return d_splice_alias(inode, dentry); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller31672.48%111.11%
Linus Torvalds (pre-git)9822.48%333.33%
Al Viro81.83%333.33%
Miklos Szeredi81.83%111.11%
David Howells61.38%111.11%
Total436100.00%9100.00%


static int openpromfs_readdir(struct file *file, struct dir_context *ctx) { struct inode *inode = file_inode(file); struct op_inode_info *oi = OP_I(inode); struct device_node *dp = oi->u.node; struct device_node *child; struct property *prop; int i; mutex_lock(&op_mutex); if (ctx->pos == 0) { if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR)) goto out; ctx->pos = 1; } if (ctx->pos == 1) { if (!dir_emit(ctx, "..", 2, (dp->parent == NULL ? OPENPROM_ROOT_INO : dp->parent->unique_id), DT_DIR)) goto out; ctx->pos = 2; } i = ctx->pos - 2; /* First, the children nodes as directories. */ child = dp->child; while (i && child) { child = child->sibling; i--; } while (child) { if (!dir_emit(ctx, child->path_component_name, strlen(child->path_component_name), child->unique_id, DT_DIR)) goto out; ctx->pos++; child = child->sibling; } /* Next, the properties as files. */ prop = dp->properties; while (i && prop) { prop = prop->next; i--; } while (prop) { if (!dir_emit(ctx, prop->name, strlen(prop->name), prop->unique_id, DT_REG)) goto out; ctx->pos++; prop = prop->next; } out: mutex_unlock(&op_mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller20867.31%120.00%
Al Viro5618.12%240.00%
Linus Torvalds (pre-git)4514.56%240.00%
Total309100.00%5100.00%

static struct kmem_cache *op_inode_cachep;
static struct inode *openprom_alloc_inode(struct super_block *sb) { struct op_inode_info *oi; oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL); if (!oi) return NULL; return &oi->vfs_inode; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller2663.41%133.33%
Linus Torvalds (pre-git)1434.15%133.33%
Christoph Lameter12.44%133.33%
Total41100.00%3100.00%


static void openprom_i_callback(struct rcu_head *head) { struct inode *inode = container_of(head, struct inode, i_rcu); kmem_cache_free(op_inode_cachep, OP_I(inode)); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller1850.00%150.00%
Nicholas Piggin1850.00%150.00%
Total36100.00%2100.00%


static void openprom_destroy_inode(struct inode *inode) { call_rcu(&inode->i_rcu, openprom_i_callback); }

Contributors

PersonTokensPropCommitsCommitProp
Nicholas Piggin21100.00%1100.00%
Total21100.00%1100.00%


static struct inode *openprom_iget(struct super_block *sb, ino_t ino) { struct inode *inode; inode = iget_locked(sb, ino); if (!inode) return ERR_PTR(-ENOMEM); if (inode->i_state & I_NEW) { inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); if (inode->i_ino == OPENPROM_ROOT_INO) { inode->i_op = &openprom_inode_operations; inode->i_fop = &openprom_operations; inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; } unlock_new_inode(inode); } return inode; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)5549.55%466.67%
David Howells5246.85%116.67%
Deepa Dinamani43.60%116.67%
Total111100.00%6100.00%


static int openprom_remount(struct super_block *sb, int *flags, char *data) { sync_filesystem(sb); *flags |= SB_NOATIME; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2681.25%133.33%
Theodore Y. Ts'o515.62%133.33%
Linus Torvalds13.12%133.33%
Total32100.00%3100.00%

static const struct super_operations openprom_sops = { .alloc_inode = openprom_alloc_inode, .destroy_inode = openprom_destroy_inode, .statfs = simple_statfs, .remount_fs = openprom_remount, };
static int openprom_fill_super(struct super_block *s, void *data, int silent) { struct inode *root_inode; struct op_inode_info *oi; int ret; s->s_flags |= SB_NOATIME; s->s_blocksize = 1024; s->s_blocksize_bits = 10; s->s_magic = OPENPROM_SUPER_MAGIC; s->s_op = &openprom_sops; s->s_time_gran = 1; root_inode = openprom_iget(s, OPENPROM_ROOT_INO); if (IS_ERR(root_inode)) { ret = PTR_ERR(root_inode); goto out_no_root; } oi = OP_I(root_inode); oi->type = op_inode_node; oi->u.node = of_find_node_by_path("/"); s->s_root = d_make_root(root_inode); if (!s->s_root) goto out_no_root_dentry; return 0; out_no_root_dentry: ret = -ENOMEM; out_no_root: printk("openprom_fill_super: get root inode failed\n"); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)8150.94%330.00%
David Howells3018.87%110.00%
David S. Miller2918.24%110.00%
Al Viro127.55%330.00%
Andi Kleen63.77%110.00%
Linus Torvalds10.63%110.00%
Total159100.00%10100.00%


static struct dentry *openprom_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data) { return mount_single(fs_type, flags, data, openprom_fill_super); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2567.57%233.33%
Linus Torvalds (pre-git)616.22%233.33%
Meelis Roos513.51%116.67%
Andries E. Brouwer12.70%116.67%
Total37100.00%6100.00%

static struct file_system_type openprom_fs_type = { .owner = THIS_MODULE, .name = "openpromfs", .mount = openprom_mount, .kill_sb = kill_anon_super, }; MODULE_ALIAS_FS("openpromfs");
static void op_inode_init_once(void *data) { struct op_inode_info *oi = (struct op_inode_info *) data; inode_init_once(&oi->vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller1653.33%120.00%
Linus Torvalds (pre-git)1136.67%360.00%
Christoph Lameter310.00%120.00%
Total30100.00%5100.00%


static int __init init_openprom_fs(void) { int err; op_inode_cachep = kmem_cache_create("op_inode_cache", sizeof(struct op_inode_info), 0, (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), op_inode_init_once); if (!op_inode_cachep) return -ENOMEM; err = register_filesystem(&openprom_fs_type); if (err) kmem_cache_destroy(op_inode_cachep); return err; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller4872.73%125.00%
Linus Torvalds (pre-git)1624.24%250.00%
Vladimir Davydov23.03%125.00%
Total66100.00%4100.00%


static void __exit exit_openprom_fs(void) { unregister_filesystem(&openprom_fs_type); /* * Make sure all delayed rcu free inodes are flushed before we * destroy cache. */ rcu_barrier(); kmem_cache_destroy(op_inode_cachep); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)1875.00%360.00%
Kirill A. Shutemov416.67%120.00%
David S. Miller28.33%120.00%
Total24100.00%5100.00%

module_init(init_openprom_fs) module_exit(exit_openprom_fs) MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
David S. Miller120457.88%35.56%
Linus Torvalds (pre-git)49523.80%1120.37%
Al Viro1587.60%1425.93%
David Howells1034.95%11.85%
Nicholas Piggin391.88%11.85%
Art Haas100.48%11.85%
Linus Torvalds80.38%35.56%
Miklos Szeredi80.38%11.85%
Andi Kleen60.29%11.85%
Christoph Lameter60.29%35.56%
Theodore Y. Ts'o50.24%11.85%
Eric W. Biedermann50.24%11.85%
Meelis Roos50.24%11.85%
Christoph Hellwig50.24%11.85%
Kirill A. Shutemov40.19%11.85%
Deepa Dinamani40.19%11.85%
Jeff Garzik40.19%11.85%
Jan Engelhardt30.14%23.70%
Trond Myklebust20.10%11.85%
Vladimir Davydov20.10%11.85%
Josef 'Jeff' Sipek10.05%11.85%
Arjan van de Ven10.05%11.85%
Marcel Holtmann10.05%11.85%
Andries E. Brouwer10.05%11.85%
Total2080100.00%54100.00%
Directory: fs/openpromfs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.