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        mutex_lock(&root->d_inode->i_mutex);
 143        dentry = d_alloc_name(root, name);
 144        if (!dentry) {
 145                mutex_unlock(&root->d_inode->i_mutex);
 146                return -ENOMEM;
 147        }
 148        inode = oprofilefs_get_inode(sb, S_IFREG | perm);
 149        if (!inode) {
 150                dput(dentry);
 151                mutex_unlock(&root->d_inode->i_mutex);
 152                return -ENOMEM;
 153        }
 154        inode->i_fop = fops;
 155        inode->i_private = priv;
 156        d_add(dentry, inode);
 157        mutex_unlock(&root->d_inode->i_mutex);
 158        return 0;
 159}
 160
 161
 162int oprofilefs_create_ulong(struct super_block *sb, struct dentry *root,
 163        char const *name, unsigned long *val)
 164{
 165        return __oprofilefs_create_file(sb, root, name,
 166                                        &ulong_fops, 0644, val);
 167}
 168
 169
 170int oprofilefs_create_ro_ulong(struct super_block *sb, struct dentry *root,
 171        char const *name, unsigned long *val)
 172{
 173        return __oprofilefs_create_file(sb, root, name,
 174                                        &ulong_ro_fops, 0444, val);
 175}
 176
 177
 178static ssize_t atomic_read_file(struct file *file, char __user *buf, size_t count, loff_t *offset)
 179{
 180        atomic_t *val = file->private_data;
 181        return oprofilefs_ulong_to_user(atomic_read(val), buf, count, offset);
 182}
 183
 184
 185static const struct file_operations atomic_ro_fops = {
 186        .read           = atomic_read_file,
 187        .open           = simple_open,
 188        .llseek         = default_llseek,
 189};
 190
 191
 192int oprofilefs_create_ro_atomic(struct super_block *sb, struct dentry *root,
 193        char const *name, atomic_t *val)
 194{
 195        return __oprofilefs_create_file(sb, root, name,
 196                                        &atomic_ro_fops, 0444, val);
 197}
 198
 199
 200int oprofilefs_create_file(struct super_block *sb, struct dentry *root,
 201        char const *name, const struct file_operations *fops)
 202{
 203        return __oprofilefs_create_file(sb, root, name, fops, 0644, NULL);
 204}
 205
 206
 207int oprofilefs_create_file_perm(struct super_block *sb, struct dentry *root,
 208        char const *name, const struct file_operations *fops, int perm)
 209{
 210        return __oprofilefs_create_file(sb, root, name, fops, perm, NULL);
 211}
 212
 213
 214struct dentry *oprofilefs_mkdir(struct super_block *sb,
 215        struct dentry *root, char const *name)
 216{
 217        struct dentry *dentry;
 218        struct inode *inode;
 219
 220        mutex_lock(&root->d_inode->i_mutex);
 221        dentry = d_alloc_name(root, name);
 222        if (!dentry) {
 223                mutex_unlock(&root->d_inode->i_mutex);
 224                return NULL;
 225        }
 226        inode = oprofilefs_get_inode(sb, S_IFDIR | 0755);
 227        if (!inode) {
 228                dput(dentry);
 229                mutex_unlock(&root->d_inode->i_mutex);
 230                return NULL;
 231        }
 232        inode->i_op = &simple_dir_inode_operations;
 233        inode->i_fop = &simple_dir_operations;
 234        d_add(dentry, inode);
 235        mutex_unlock(&root->d_inode->i_mutex);
 236        return dentry;
 237}
 238
 239
 240static int oprofilefs_fill_super(struct super_block *sb, void *data, int silent)
 241{
 242        struct inode *root_inode;
 243
 244        sb->s_blocksize = PAGE_CACHE_SIZE;
 245        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 246        sb->s_magic = OPROFILEFS_MAGIC;
 247        sb->s_op = &s_ops;
 248        sb->s_time_gran = 1;
 249
 250        root_inode = oprofilefs_get_inode(sb, S_IFDIR | 0755);
 251        if (!root_inode)
 252                return -ENOMEM;
 253        root_inode->i_op = &simple_dir_inode_operations;
 254        root_inode->i_fop = &simple_dir_operations;
 255        sb->s_root = d_make_root(root_inode);
 256        if (!sb->s_root)
 257                return -ENOMEM;
 258
 259        oprofile_create_files(sb, sb->s_root);
 260
 261        // FIXME: verify kill_litter_super removes our dentries
 262        return 0;
 263}
 264
 265
 266static struct dentry *oprofilefs_mount(struct file_system_type *fs_type,
 267        int flags, const char *dev_name, void *data)
 268{
 269        return mount_single(fs_type, flags, data, oprofilefs_fill_super);
 270}
 271
 272
 273static struct file_system_type oprofilefs_type = {
 274        .owner          = THIS_MODULE,
 275        .name           = "oprofilefs",
 276        .mount          = oprofilefs_mount,
 277        .kill_sb        = kill_litter_super,
 278};
 279MODULE_ALIAS_FS("oprofilefs");
 280
 281
 282int __init oprofilefs_register(void)
 283{
 284        return register_filesystem(&oprofilefs_type);
 285}
 286
 287
 288void __exit oprofilefs_unregister(void)
 289{
 290        unregister_filesystem(&oprofilefs_type);
 291}
 292
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.