arch/s390/hypfs/hypfs_dbfs.c

   1 /*
   2  * Hypervisor filesystem for Linux on s390 - debugfs interface
   3  *
   4  * Copyright IBM Corp. 2010
   5  * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
   6  */
   7
   8 #include <linux/slab.h>
   9 #include "hypfs.h"
  10
  11 static struct dentry *dbfs_dir;
  12
  13 static struct hypfs_dbfs_data *hypfs_dbfs_data_alloc(struct hypfs_dbfs_file *f)
  14 {
  15         struct hypfs_dbfs_data *data;
  16
  17         data = kmalloc(sizeof(*data), GFP_KERNEL);
  18         if (!data)
  19                 return NULL;
  20         kref_init(&data->kref);
  21         data->dbfs_file = f;
  22         return data;
  23 }
  24
  25 static void hypfs_dbfs_data_free(struct kref *kref)
  26 {
  27         struct hypfs_dbfs_data *data;
  28
  29         data = container_of(kref, struct hypfs_dbfs_data, kref);
  30         data->dbfs_file->data_free(data->buf_free_ptr);
  31         kfree(data);
  32 }
  33
  34 static void data_free_delayed(struct work_struct *work)
  35 {
  36         struct hypfs_dbfs_data *data;
  37         struct hypfs_dbfs_file *df;
  38
  39         df = container_of(work, struct hypfs_dbfs_file, data_free_work.work);
  40         mutex_lock(&df->lock);
  41         data = df->data;
  42         df->data = NULL;
  43         mutex_unlock(&df->lock);
  44         kref_put(&data->kref, hypfs_dbfs_data_free);
  45 }
  46
  47 static ssize_t dbfs_read(struct file *file, char __user *buf,
  48                          size_t size, loff_t *ppos)
  49 {
  50         struct hypfs_dbfs_data *data;
  51         struct hypfs_dbfs_file *df;
  52         ssize_t rc;
  53
  54         if (*ppos != 0)
  55                 return 0;
  56
  57         df = file_inode(file)->i_private;
  58         mutex_lock(&df->lock);
  59         if (!df->data) {
  60                 data = hypfs_dbfs_data_alloc(df);
  61                 if (!data) {
  62                         mutex_unlock(&df->lock);
  63                         return -ENOMEM;
  64                 }
  65                 rc = df->data_create(&data->buf, &data->buf_free_ptr,
  66                                      &data->size);
  67                 if (rc) {
  68                         mutex_unlock(&df->lock);
  69                         kfree(data);
  70                         return rc;
  71                 }
  72                 df->data = data;
  73                 schedule_delayed_work(&df->data_free_work, HZ);
  74         }
  75         data = df->data;
  76         kref_get(&data->kref);
  77         mutex_unlock(&df->lock);
  78
  79         rc = simple_read_from_buffer(buf, size, ppos, data->buf, data->size);
  80         kref_put(&data->kref, hypfs_dbfs_data_free);
  81         return rc;
  82 }
  83
  84 static long dbfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  85 {
  86         struct hypfs_dbfs_file *df;
  87         long rc;
  88
  89         df = file->f_path.dentry->d_inode->i_private;
  90         mutex_lock(&df->lock);
  91         if (df->unlocked_ioctl)
  92                 rc = df->unlocked_ioctl(file, cmd, arg);
  93         else
  94                 rc = -ENOTTY;
  95         mutex_unlock(&df->lock);
  96         return rc;
  97 }
  98
  99 static const struct file_operations dbfs_ops = {
 100         .read           = dbfs_read,
 101         .llseek         = no_llseek,
 102         .unlocked_ioctl = dbfs_ioctl,
 103 };
 104
 105 int hypfs_dbfs_create_file(struct hypfs_dbfs_file *df)
 106 {
 107         df->dentry = debugfs_create_file(df->name, 0400, dbfs_dir, df,
 108                                          &dbfs_ops);
 109         if (IS_ERR(df->dentry))
 110                 return PTR_ERR(df->dentry);
 111         mutex_init(&df->lock);
 112         INIT_DELAYED_WORK(&df->data_free_work, data_free_delayed);
 113         return 0;
 114 }
 115
 116 void hypfs_dbfs_remove_file(struct hypfs_dbfs_file *df)
 117 {
 118         debugfs_remove(df->dentry);
 119 }
 120
 121 int hypfs_dbfs_init(void)
 122 {
 123         dbfs_dir = debugfs_create_dir("s390_hypfs", NULL);
 124         return PTR_ERR_OR_ZERO(dbfs_dir);
 125 }
 126
 127 void hypfs_dbfs_exit(void)
 128 {
 129         debugfs_remove(dbfs_dir);
 130 }