LXR linux/arch/s390/hypfs/hypfs

   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
  12static struct dentry *dbfs_dir;
  13
  14static 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
  25static 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
  31static 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
  61static 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
  75static const struct file_operations dbfs_ops = {
  76        .read           = dbfs_read,
  77        .llseek         = no_llseek,
  78        .unlocked_ioctl = dbfs_ioctl,
  79};
  80
  81void 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        mutex_init(&df->lock);
  86}
  87
  88void hypfs_dbfs_remove_file(struct hypfs_dbfs_file *df)
  89{
  90        debugfs_remove(df->dentry);
  91}
  92
  93void hypfs_dbfs_init(void)
  94{
  95        dbfs_dir = debugfs_create_dir("s390_hypfs", NULL);
  96}
  97
  98void hypfs_dbfs_exit(void)
  99{
 100        debugfs_remove(dbfs_dir);
 101}
 102