Quelle  htmdump.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) IBM Corporation, 2024
 */

#define pr_fmt(fmt) "htmdump: " fmt

#include <linux/debugfs.h>
#include <linux/module.h>
#include <asm/io.h>
#include <asm/machdep.h>
#include <asm/plpar_wrappers.h>
#include <asm/kvm_guest.h>

static void *htm_buf;
static void *htm_status_buf;
static void *htm_info_buf;
static void *htm_caps_buf;
static u32 nodeindex;
static u32 nodalchipindex;
static u32 coreindexonchip;
static u32 htmtype;
static u32 htmconfigure;
static u32 htmstart;
static u32 htmsetup;
static u64 htmflags;

static struct dentry *htmdump_debugfs_dir;
#define HTM_ENABLE 1
#define HTM_DISABLE 0
#define HTM_NOWRAP 1
#define HTM_WRAP 0

/*
 * Check the return code for H_HTM hcall.
 * Return non-zero value (1) if either H_PARTIAL or H_SUCCESS
 * is returned. For other return codes:
 * Return zero if H_NOT_AVAILABLE.
 * Return -EBUSY if hcall return busy.
 * Return -EINVAL if any parameter or operation is not valid.
 * Return -EPERM if HTM Virtualization Engine Technology code
 * is not applied.
 * Return -EIO if the HTM state is not valid.
 */
static ssize_t htm_return_check(long rc)
{
 switch (rc) {
 case H_SUCCESS:
 /* H_PARTIAL for the case where all available data can't be
 * returned due to buffer size constraint.
 */
 case H_PARTIAL:
  break;
 /* H_NOT_AVAILABLE indicates reading from an offset outside the range,
 * i.e. past end of file.
 */
 case H_NOT_AVAILABLE:
  return 0;
 case H_BUSY:
 case H_LONG_BUSY_ORDER_1_MSEC:
 case H_LONG_BUSY_ORDER_10_MSEC:
 case H_LONG_BUSY_ORDER_100_MSEC:
 case H_LONG_BUSY_ORDER_1_SEC:
 case H_LONG_BUSY_ORDER_10_SEC:
 case H_LONG_BUSY_ORDER_100_SEC:
  return -EBUSY;
 case H_PARAMETER:
 case H_P2:
 case H_P3:
 case H_P4:
 case H_P5:
 case H_P6:
  return -EINVAL;
 case H_STATE:
  return -EIO;
 case H_AUTHORITY:
  return -EPERM;
 }

 /*
 * Return 1 for H_SUCCESS/H_PARTIAL
 */
 return 1;
}

static ssize_t htmdump_read(struct file *filp, char __user *ubuf,
        size_t count, loff_t *ppos)
{
 void *htm_buf = filp->private_data;
 unsigned long page, read_size, available;
 loff_t offset;
 long rc, ret;

 page = ALIGN_DOWN(*ppos, PAGE_SIZE);
 offset = (*ppos) % PAGE_SIZE;

 /*
 * Invoke H_HTM call with:
 * - operation as htm dump (H_HTM_OP_DUMP_DATA)
 * - last three values are address, size and offset
 */
 rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
       htmtype, H_HTM_OP_DUMP_DATA, virt_to_phys(htm_buf),
       PAGE_SIZE, page);

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed for op: H_HTM_OP_DUMP_DATA, returning %ld\n", ret);
  return ret;
 }

 available = PAGE_SIZE;
 read_size = min(count, available);
 *ppos += read_size;
 return simple_read_from_buffer(ubuf, count, &offset, htm_buf, available);
}

static const struct file_operations htmdump_fops = {
 .llseek = NULL,
 .read = htmdump_read,
 .open = simple_open,
};

static int  htmconfigure_set(void *data, u64 val)
{
 long rc, ret;
 unsigned long param1 = -1, param2 = -1;

 /*
 * value as 1 : configure HTM.
 * value as 0 : deconfigure HTM. Return -EINVAL for
 * other values.
 */
 if (val == HTM_ENABLE) {
  /*
 * Invoke H_HTM call with:
 * - operation as htm configure (H_HTM_OP_CONFIGURE)
 * - If htmflags is set, param1 and param2 will be -1
 *   which is an indicator to use default htm mode reg mask
 *   and htm mode reg value.
 * - last three values are unused, hence set to zero
 */
  if (!htmflags) {
   param1 = 0;
   param2 = 0;
  }

  rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
      htmtype, H_HTM_OP_CONFIGURE, param1, param2, 0);
 } else if (val == HTM_DISABLE) {
  /*
 * Invoke H_HTM call with:
 * - operation as htm deconfigure (H_HTM_OP_DECONFIGURE)
 * - last three values are unused, hence set to zero
 */
  rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
    htmtype, H_HTM_OP_DECONFIGURE, 0, 0, 0);
 } else
  return -EINVAL;

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed, returning %ld\n", ret);
  return ret;
 }

 /* Set htmconfigure if operation succeeds */
 htmconfigure = val;

 return 0;
}

static int htmconfigure_get(void *data, u64 *val)
{
 *val = htmconfigure;
 return 0;
}

static int  htmstart_set(void *data, u64 val)
{
 long rc, ret;

 /*
 * value as 1: start HTM
 * value as 0: stop HTM
 * Return -EINVAL for other values.
 */
 if (val == HTM_ENABLE) {
  /*
 * Invoke H_HTM call with:
 * - operation as htm start (H_HTM_OP_START)
 * - last three values are unused, hence set to zero
 */
  rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
      htmtype, H_HTM_OP_START, 0, 0, 0);

 } else if (val == HTM_DISABLE) {
  /*
 * Invoke H_HTM call with:
 * - operation as htm stop (H_HTM_OP_STOP)
 * - last three values are unused, hence set to zero
 */
  rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
    htmtype, H_HTM_OP_STOP, 0, 0, 0);
 } else
  return -EINVAL;

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed, returning %ld\n", ret);
  return ret;
 }

 /* Set htmstart if H_HTM_OP_START/H_HTM_OP_STOP operation succeeds */
 htmstart = val;

 return 0;
}

static int htmstart_get(void *data, u64 *val)
{
 *val = htmstart;
 return 0;
}

static ssize_t htmstatus_read(struct file *filp, char __user *ubuf,
        size_t count, loff_t *ppos)
{
 void *htm_status_buf = filp->private_data;
 long rc, ret;
 u64 *num_entries;
 u64 to_copy;
 int htmstatus_flag;

 /*
 * Invoke H_HTM call with:
 * - operation as htm status (H_HTM_OP_STATUS)
 * - last three values as addr, size and offset
 */
 rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
       htmtype, H_HTM_OP_STATUS, virt_to_phys(htm_status_buf),
       PAGE_SIZE, 0);

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed for op: H_HTM_OP_STATUS, returning %ld\n", ret);
  return ret;
 }

 /*
 * HTM status buffer, start of buffer + 0x10 gives the
 * number of HTM entries in the buffer. Each nest htm status
 * entry is 0x6 bytes where each core htm status entry is
 * 0x8 bytes.
 * So total count to copy is:
 * 32 bytes (for first 7 fields) + (number of HTM entries * entry size)
 */
 num_entries = htm_status_buf + 0x10;
 if (htmtype == 0x2)
  htmstatus_flag = 0x8;
 else
  htmstatus_flag = 0x6;
 to_copy = 32 + (be64_to_cpu(*num_entries) * htmstatus_flag);
 return simple_read_from_buffer(ubuf, count, ppos, htm_status_buf, to_copy);
}

static const struct file_operations htmstatus_fops = {
 .llseek = NULL,
 .read = htmstatus_read,
 .open = simple_open,
};

static ssize_t htminfo_read(struct file *filp, char __user *ubuf,
        size_t count, loff_t *ppos)
{
 void *htm_info_buf = filp->private_data;
 long rc, ret;
 u64 *num_entries;
 u64 to_copy;

 /*
 * Invoke H_HTM call with:
 * - operation as htm status (H_HTM_OP_STATUS)
 * - last three values as addr, size and offset
 */
 rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
       htmtype, H_HTM_OP_DUMP_SYSPROC_CONF, virt_to_phys(htm_info_buf),
       PAGE_SIZE, 0);

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed for op: H_HTM_OP_DUMP_SYSPROC_CONF, returning %ld\n", ret);
  return ret;
 }

 /*
 * HTM status buffer, start of buffer + 0x10 gives the
 * number of HTM entries in the buffer. Each entry of processor
 * is 16 bytes.
 *
 * So total count to copy is:
 * 32 bytes (for first 5 fields) + (number of HTM entries * entry size)
 */
 num_entries = htm_info_buf + 0x10;
 to_copy = 32 + (be64_to_cpu(*num_entries) * 16);
 return simple_read_from_buffer(ubuf, count, ppos, htm_info_buf, to_copy);
}

static ssize_t htmcaps_read(struct file *filp, char __user *ubuf,
        size_t count, loff_t *ppos)
{
 void *htm_caps_buf = filp->private_data;
 long rc, ret;

 /*
 * Invoke H_HTM call with:
 * - operation as htm capabilities (H_HTM_OP_CAPABILITIES)
 * - last three values as addr, size (0x80 for Capabilities Output Buffer
 *   and zero
 */
 rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
       htmtype, H_HTM_OP_CAPABILITIES, virt_to_phys(htm_caps_buf),
       0x80, 0);

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed for op: H_HTM_OP_CAPABILITIES, returning %ld\n", ret);
  return ret;
 }

 return simple_read_from_buffer(ubuf, count, ppos, htm_caps_buf, 0x80);
}

static const struct file_operations htminfo_fops = {
 .llseek = NULL,
 .read   = htminfo_read,
 .open   = simple_open,
};

static const struct file_operations htmcaps_fops = {
 .llseek = NULL,
 .read   = htmcaps_read,
 .open   = simple_open,
};

static int  htmsetup_set(void *data, u64 val)
{
 long rc, ret;

 /*
 * Input value: HTM buffer size in the power of 2
 * example: hex value 0x21 ( decimal: 33 ) is for
 * 8GB
 * Invoke H_HTM call with:
 * - operation as htm start (H_HTM_OP_SETUP)
 * - parameter 1 set to input value.
 * - last two values are unused, hence set to zero
 */
 rc = htm_hcall_wrapper(htmflags, nodeindex, nodalchipindex, coreindexonchip,
   htmtype, H_HTM_OP_SETUP, val, 0, 0);

 ret = htm_return_check(rc);
 if (ret <= 0) {
  pr_debug("H_HTM hcall failed for op: H_HTM_OP_SETUP, returning %ld\n", ret);
  return ret;
 }

 /* Set htmsetup if H_HTM_OP_SETUP operation succeeds */
 htmsetup = val;

 return 0;
}

static int htmsetup_get(void *data, u64 *val)
{
 *val = htmsetup;
 return 0;
}

static int  htmflags_set(void *data, u64 val)
{
 /*
 * Input value:
 * Currently supported flag value is to enable/disable
 * HTM buffer wrap. wrap is used along with "configure"
 * to prevent HTM buffer from wrapping.
 * Writing 1 will set noWrap while configuring HTM
 */
 if (val == HTM_NOWRAP)
  htmflags = H_HTM_FLAGS_NOWRAP;
 else if (val == HTM_WRAP)
  htmflags = 0;
 else
  return -EINVAL;

 return 0;
}

static int htmflags_get(void *data, u64 *val)
{
 *val = htmflags;
 return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(htmconfigure_fops, htmconfigure_get, htmconfigure_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmstart_fops, htmstart_get, htmstart_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmsetup_fops, htmsetup_get, htmsetup_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(htmflags_fops, htmflags_get, htmflags_set, "%llu\n");

static int htmdump_init_debugfs(void)
{
 htm_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 if (!htm_buf) {
  pr_err("Failed to allocate htmdump buf\n");
  return -ENOMEM;
 }

 htmdump_debugfs_dir = debugfs_create_dir("htmdump",
        arch_debugfs_dir);

 debugfs_create_u32("nodeindex", 0600,
   htmdump_debugfs_dir, &nodeindex);
 debugfs_create_u32("nodalchipindex", 0600,
   htmdump_debugfs_dir, &nodalchipindex);
 debugfs_create_u32("coreindexonchip", 0600,
   htmdump_debugfs_dir, &coreindexonchip);
 debugfs_create_u32("htmtype", 0600,
   htmdump_debugfs_dir, &htmtype);
 debugfs_create_file("trace", 0400, htmdump_debugfs_dir, htm_buf, &htmdump_fops);

 /*
 * Debugfs interface files to control HTM operations:
 */
 debugfs_create_file("htmconfigure", 0600, htmdump_debugfs_dir, NULL, &htmconfigure_fops);
 debugfs_create_file("htmstart", 0600, htmdump_debugfs_dir, NULL, &htmstart_fops);
 debugfs_create_file("htmsetup", 0600, htmdump_debugfs_dir, NULL, &htmsetup_fops);
 debugfs_create_file("htmflags", 0600, htmdump_debugfs_dir, NULL, &htmflags_fops);

 /* Debugfs interface file to present status of HTM */
 htm_status_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 if (!htm_status_buf) {
  pr_err("Failed to allocate htmstatus buf\n");
  return -ENOMEM;
 }

 /* Debugfs interface file to present System Processor Configuration */
 htm_info_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 if (!htm_info_buf) {
  pr_err("Failed to allocate htm info buf\n");
  return -ENOMEM;
 }

 /* Debugfs interface file to present HTM capabilities */
 htm_caps_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 if (!htm_caps_buf) {
  pr_err("Failed to allocate htm caps buf\n");
  return -ENOMEM;
 }

 debugfs_create_file("htmstatus", 0400, htmdump_debugfs_dir, htm_status_buf, &htmstatus_fops);
 debugfs_create_file("htminfo", 0400, htmdump_debugfs_dir, htm_info_buf, &htminfo_fops);
 debugfs_create_file("htmcaps", 0400, htmdump_debugfs_dir, htm_caps_buf, &htmcaps_fops);

 return 0;
}

static int __init htmdump_init(void)
{
 /* Disable on kvm guest */
 if (is_kvm_guest()) {
  pr_info("htmdump not supported inside KVM guest\n");
  return -EOPNOTSUPP;
 }

 if (htmdump_init_debugfs())
  return -ENOMEM;

 return 0;
}

static void __exit htmdump_exit(void)
{
 debugfs_remove_recursive(htmdump_debugfs_dir);
 kfree(htm_buf);
}

module_init(htmdump_init);
module_exit(htmdump_exit);
MODULE_DESCRIPTION("PHYP Hardware Trace Macro (HTM) data dumper");
MODULE_LICENSE("GPL");