linux/drivers/oprofile/oprofilefs.c
<<
>>
Prefs
   1/**
   2 * @file oprofilefs.c
   3 *
   4 * @remark Copyright 2002 OProfile authors
   5 * @remark Read the file COPYING
   6 *
   7 * @author John Levon
   8 *
   9 * A simple filesystem for configuration and
  10 * access of oprofile.
  11 */
  12
  13#include <linux/init.h>
  14#include <linux/module.h>
  15#include <linux/oprofile.h>
  16#include <linux/fs.h>
  17#include <linux/pagemap.h>
  18#include <asm/uaccess.h>
  19
  20#include "oprof.h"
  21
  22#define OPROFILEFS_MAGIC 0x6f70726f
  23
  24DEFINE_RAW_SPINLOCK(oprofilefs_lock);
  25
  26static struct inode *oprofilefs_get_inode(struct super_block *sb, int mode)
  27{
  28        struct inode *inode = new_inode(sb);
  29
  30        if (inode) {
  31                inode->i_ino = get_next_ino();
  32                inode->i_mode = mode;
  33                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  34        }
  35        return inode;
  36}
  37
  38
  39static const struct super_operations s_ops = {
  40        .statfs         = simple_statfs,
  41        .drop_inode     = generic_delete_inode,
  42};
  43
  44
  45ssize_t oprofilefs_str_to_user(char const *str, char __user *buf, size_t count, loff_t *offset)
  46{
  47        return simple_read_from_buffer(buf, count, offset, str, strlen(str));
  48}
  49
  50
  51#define TMPBUFSIZE 50
  52
  53ssize_t oprofilefs_ulong_to_user(unsigned long val, char __user *buf, size_t count, loff_t *offset)
  54{
  55        char tmpbuf[TMPBUFSIZE];
  56        size_t maxlen = snprintf(tmpbuf, TMPBUFSIZE, "%lu\n", val);
  57        if (maxlen > TMPBUFSIZE)
  58                maxlen = TMPBUFSIZE;
  59        return simple_read_from_buffer(buf, count, offset, tmpbuf, maxlen);
  60}
  61
  62
  63/*
  64 * Note: If oprofilefs_ulong_from_user() returns 0, then *val remains
  65 * unchanged and might be uninitialized. This follows write syscall
  66 * implementation when count is zero: "If count is zero ... [and if]
  67 * no errors are detected, 0 will be returned without causing any
  68 * other effect." (man 2 write)
  69 */
  70int oprofilefs_ulong_from_user(unsigned long *val, char const __user *buf, size_t count)
  71{
  72        char tmpbuf[TMPBUFSIZE];
  73        unsigned long flags;
  74
  75        if (!count)
  76                return 0;
  77
  78        if (count > TMPBUFSIZE - 1)
  79                return -EINVAL;
  80
  81        memset(tmpbuf, 0x0, TMPBUFSIZE);
  82
  83        if (copy_from_user(tmpbuf, buf, count))
  84                return -EFAULT;
  85
  86        raw_spin_lock_irqsave(&oprofilefs_lock, flags);
  87        *val = simple_strtoul(tmpbuf, NULL, 0);
  88        raw_spin_unlock_irqrestore(&oprofilefs_lock, flags);
  89        return count;
  90}
  91
  92
  93static ssize_t ulong_read_file(struct file *file, char __user *buf, size_t count, loff_t *offset)
  94{
  95        unsigned long *val = file->private_data;
  96        return oprofilefs_ulong_to_user(*val, buf, count, offset);
  97}
  98
  99
 100static ssize_t ulong_write_file(struct file *file, char const __user *buf, size_t count, loff_t *offset)
 101{
 102        unsigned long value;
 103        int retval;
 104
 105        if (*offset)
 106                return -EINVAL;
 107
 108        retval = oprofilefs_ulong_from_user(&value, buf, count);
 109        if (retval <= 0)
 110                return retval;
 111
 112        retval = oprofile_set_ulong(file->private_data, value);
 113        if (retval)
 114                return retval;
 115
 116        return count;
 117}
 118
 119
 120static const struct file_operations ulong_fops = {
 121        .read           = ulong_read_file,
 122        .write          = ulong_write_file,
 123        .open           = simple_open,
 124        .llseek         = default_llseek,
 125};
 126
 127
 128static const struct file_operations ulong_ro_fops = {
 129        .read           = ulong_read_file,
 130        .open           = simple_open,
 131        .llseek         = default_llseek,
 132};
 133
 134
 135static int __oprofilefs_create_file(struct super_block *sb,
 136        struct dentry *root, char const *name, const struct file_operations *fops,
 137        int perm, void *priv)
 138{
 139        struct dentry *dentry;
 140        struct inode *inode;
 141
 142        dentry = d_alloc_name(root, name);
 143        if (!dentry)
 144                return -ENOMEM;
 145        inode = oprofilefs_get_inode(sb, S_IFREG | perm);
 146        if (!inode) {
 147                dput(dentry);
 148                return -ENOMEM;
 149        }
 150        inode->i_fop = fops;
 151        d_add(dentry, inode);
 152        dentry->d_inode->i_private = priv;
 153        return 0;
 154}
 155
 156
 157int oprofilefs_create_ulong(struct super_block *sb, struct dentry *root,
 158        char const *name, unsigned long *val)
 159{
 160        return __oprofilefs_create_file(sb, root, name,
 161                                        &ulong_fops, 0644, val);
 162}
 163
 164
 165int oprofilefs_create_ro_ulong(struct super_block *sb, struct dentry *root,
 166        char const *name, unsigned long *val)
 167{
 168        return __oprofilefs_create_file(sb, root, name,
 169                                        &ulong_ro_fops, 0444, val);
 170}
 171
 172
 173static ssize_t atomic_read_file(struct file *file, char __user *buf, size_t count, loff_t *offset)
 174{
 175        atomic_t *val = file->private_data;
 176        return oprofilefs_ulong_to_user(atomic_read(val), buf, count, offset);
 177}
 178
 179
 180static const struct file_operations atomic_ro_fops = {
 181        .read           = atomic_read_file,
 182        .open           = simple_open,
 183        .llseek         = default_llseek,
 184};
 185
 186
 187int oprofilefs_create_ro_atomic(struct super_block *sb, struct dentry *root,
 188        char const *name, atomic_t *val)
 189{
 190        return __oprofilefs_create_file(sb, root, name,
 191                                        &atomic_ro_fops, 0444, val);
 192}
 193
 194
 195int oprofilefs_create_file(struct super_block *sb, struct dentry *root,
 196        char const *name, const struct file_operations *fops)
 197{
 198        return __oprofilefs_create_file(sb, root, name, fops, 0644, NULL);
 199}
 200
 201
 202int oprofilefs_create_file_perm(struct super_block *sb, struct dentry *root,
 203        char const *name, const struct file_operations *fops, int perm)
 204{
 205        return __oprofilefs_create_file(sb, root, name, fops, perm, NULL);
 206}
 207
 208
 209struct dentry *oprofilefs_mkdir(struct super_block *sb,
 210        struct dentry *root, char const *name)
 211{
 212        struct dentry *dentry;
 213        struct inode *inode;
 214
 215        dentry = d_alloc_name(root, name);
 216        if (!dentry)
 217                return NULL;
 218        inode = oprofilefs_get_inode(sb, S_IFDIR | 0755);
 219        if (!inode) {
 220                dput(dentry);
 221                return NULL;
 222        }
 223        inode->i_op = &simple_dir_inode_operations;
 224        inode->i_fop = &simple_dir_operations;
 225        d_add(dentry, inode);
 226        return dentry;
 227}
 228
 229
 230static int oprofilefs_fill_super(struct super_block *sb, void *data, int silent)
 231{
 232        struct inode *root_inode;
 233
 234        sb->s_blocksize = PAGE_CACHE_SIZE;
 235        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 236        sb->s_magic = OPROFILEFS_MAGIC;
 237        sb->s_op = &s_ops;
 238        sb->s_time_gran = 1;
 239
 240        root_inode = oprofilefs_get_inode(sb, S_IFDIR | 0755);
 241        if (!root_inode)
 242                return -ENOMEM;
 243        root_inode->i_op = &simple_dir_inode_operations;
 244        root_inode->i_fop = &simple_dir_operations;
 245        sb->s_root = d_make_root(root_inode);
 246        if (!sb->s_root)
 247                return -ENOMEM;
 248
 249        oprofile_create_files(sb, sb->s_root);
 250
 251        // FIXME: verify kill_litter_super removes our dentries
 252        return 0;
 253}
 254
 255
 256static struct dentry *oprofilefs_mount(struct file_system_type *fs_type,
 257        int flags, const char *dev_name, void *data)
 258{
 259        return mount_single(fs_type, flags, data, oprofilefs_fill_super);
 260}
 261
 262
 263static struct file_system_type oprofilefs_type = {
 264        .owner          = THIS_MODULE,
 265        .name           = "oprofilefs",
 266        .mount          = oprofilefs_mount,
 267        .kill_sb        = kill_litter_super,
 268};
 269
 270
 271int __init oprofilefs_register(void)
 272{
 273        return register_filesystem(&oprofilefs_type);
 274}
 275
 276
 277void __exit oprofilefs_unregister(void)
 278{
 279        unregister_filesystem(&oprofilefs_type);
 280}
 281
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.