arch/s390/hypfs/hypfs_dbfs.c

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