Quelle  diag310.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Request memory topology information via diag0x310.
 *
 * Copyright IBM Corp. 2025
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>
#include <asm/diag.h>
#include <asm/sclp.h>
#include <uapi/asm/diag.h>
#include "diag_ioctl.h"

#define DIAG310_LEVELMIN 1
#define DIAG310_LEVELMAX 6

enum diag310_sc {
 DIAG310_SUBC_0 = 0,
 DIAG310_SUBC_1 = 1,
 DIAG310_SUBC_4 = 4,
 DIAG310_SUBC_5 = 5
};

enum diag310_retcode {
 DIAG310_RET_SUCCESS = 0x0001,
 DIAG310_RET_BUSY = 0x0101,
 DIAG310_RET_OPNOTSUPP = 0x0102,
 DIAG310_RET_SC4_INVAL = 0x0401,
 DIAG310_RET_SC4_NODATA = 0x0402,
 DIAG310_RET_SC5_INVAL = 0x0501,
 DIAG310_RET_SC5_NODATA = 0x0502,
 DIAG310_RET_SC5_ESIZE = 0x0503
};

union diag310_response {
 u64 response;
 struct {
  u64 result : 32;
  u64  : 16;
  u64 rc  : 16;
 };
};

union diag310_req_subcode {
 u64 subcode;
 struct {
  u64  : 48;
  u64 st  : 8;
  u64 sc  : 8;
 };
};

union diag310_req_size {
 u64 size;
 struct {
  u64 page_count : 32;
  u64  : 32;
 };
};

static inline unsigned long diag310(unsigned long subcode, unsigned long size, void *addr)
{
 union register_pair rp = { .even = (unsigned long)addr, .odd = size };

 diag_stat_inc(DIAG_STAT_X310);
 asm volatile("diag %[rp],%[subcode],0x310\n"
       : [rp] "+d" (rp.pair)
       : [subcode] "d" (subcode)
       : "memory");
 return rp.odd;
}

static int diag310_result_to_errno(unsigned int result)
{
 switch (result) {
 case DIAG310_RET_BUSY:
  return -EBUSY;
 case DIAG310_RET_OPNOTSUPP:
  return -EOPNOTSUPP;
 default:
  return -EINVAL;
 }
}

static int diag310_get_subcode_mask(unsigned long *mask)
{
 union diag310_response res;

 res.response = diag310(DIAG310_SUBC_0, 0, NULL);
 if (res.rc != DIAG310_RET_SUCCESS)
  return diag310_result_to_errno(res.rc);
 *mask = res.response;
 return 0;
}

static int diag310_get_memtop_stride(unsigned long *stride)
{
 union diag310_response res;

 res.response = diag310(DIAG310_SUBC_1, 0, NULL);
 if (res.rc != DIAG310_RET_SUCCESS)
  return diag310_result_to_errno(res.rc);
 *stride = res.result;
 return 0;
}

static int diag310_get_memtop_size(unsigned long *pages, unsigned long level)
{
 union diag310_req_subcode req = { .sc = DIAG310_SUBC_4, .st = level };
 union diag310_response res;

 res.response = diag310(req.subcode, 0, NULL);
 switch (res.rc) {
 case DIAG310_RET_SUCCESS:
  *pages = res.result;
  return 0;
 case DIAG310_RET_SC4_NODATA:
  return -ENODATA;
 case DIAG310_RET_SC4_INVAL:
  return -EINVAL;
 default:
  return diag310_result_to_errno(res.rc);
 }
}

static int diag310_store_topology_map(void *buf, unsigned long pages, unsigned long level)
{
 union diag310_req_subcode req_sc = { .sc = DIAG310_SUBC_5, .st = level };
 union diag310_req_size req_size = { .page_count = pages };
 union diag310_response res;

 res.response = diag310(req_sc.subcode, req_size.size, buf);
 switch (res.rc) {
 case DIAG310_RET_SUCCESS:
  return 0;
 case DIAG310_RET_SC5_NODATA:
  return -ENODATA;
 case DIAG310_RET_SC5_ESIZE:
  return -EOVERFLOW;
 case DIAG310_RET_SC5_INVAL:
  return -EINVAL;
 default:
  return diag310_result_to_errno(res.rc);
 }
}

static int diag310_check_features(void)
{
 static int features_available;
 unsigned long mask;
 int rc;

 if (READ_ONCE(features_available))
  return 0;
 if (!sclp.has_diag310)
  return -EOPNOTSUPP;
 rc = diag310_get_subcode_mask(&mask);
 if (rc)
  return rc;
 if (!test_bit_inv(DIAG310_SUBC_1, &mask))
  return -EOPNOTSUPP;
 if (!test_bit_inv(DIAG310_SUBC_4, &mask))
  return -EOPNOTSUPP;
 if (!test_bit_inv(DIAG310_SUBC_5, &mask))
  return -EOPNOTSUPP;
 WRITE_ONCE(features_available, 1);
 return 0;
}

static int memtop_get_stride_len(unsigned long *res)
{
 static unsigned long memtop_stride;
 unsigned long stride;
 int rc;

 stride = READ_ONCE(memtop_stride);
 if (!stride) {
  rc = diag310_get_memtop_stride(&stride);
  if (rc)
   return rc;
  WRITE_ONCE(memtop_stride, stride);
 }
 *res = stride;
 return 0;
}

static int memtop_get_page_count(unsigned long *res, unsigned long level)
{
 static unsigned long memtop_pages[DIAG310_LEVELMAX];
 unsigned long pages;
 int rc;

 if (level > DIAG310_LEVELMAX || level < DIAG310_LEVELMIN)
  return -EINVAL;
 pages = READ_ONCE(memtop_pages[level - 1]);
 if (!pages) {
  rc = diag310_get_memtop_size(&pages, level);
  if (rc)
   return rc;
  WRITE_ONCE(memtop_pages[level - 1], pages);
 }
 *res = pages;
 return 0;
}

long diag310_memtop_stride(unsigned long arg)
{
 size_t __user *argp = (void __user *)arg;
 unsigned long stride;
 int rc;

 rc = diag310_check_features();
 if (rc)
  return rc;
 rc = memtop_get_stride_len(&stride);
 if (rc)
  return rc;
 if (put_user(stride, argp))
  return -EFAULT;
 return 0;
}

long diag310_memtop_len(unsigned long arg)
{
 size_t __user *argp = (void __user *)arg;
 unsigned long pages, level;
 int rc;

 rc = diag310_check_features();
 if (rc)
  return rc;
 if (get_user(level, argp))
  return -EFAULT;
 rc = memtop_get_page_count(&pages, level);
 if (rc)
  return rc;
 if (put_user(pages * PAGE_SIZE, argp))
  return -EFAULT;
 return 0;
}

long diag310_memtop_buf(unsigned long arg)
{
 struct diag310_memtop __user *udata = (struct diag310_memtop __user *)arg;
 unsigned long level, pages, data_size;
 u64 address;
 void *buf;
 int rc;

 rc = diag310_check_features();
 if (rc)
  return rc;
 if (get_user(level, &udata->nesting_lvl))
  return -EFAULT;
 if (get_user(address, &udata->address))
  return -EFAULT;
 rc = memtop_get_page_count(&pages, level);
 if (rc)
  return rc;
 data_size = pages * PAGE_SIZE;
 buf = __vmalloc_node(data_size, PAGE_SIZE, GFP_KERNEL | __GFP_ZERO | __GFP_ACCOUNT,
        NUMA_NO_NODE, __builtin_return_address(0));
 if (!buf)
  return -ENOMEM;
 rc = diag310_store_topology_map(buf, pages, level);
 if (rc)
  goto out;
 if (copy_to_user((void __user *)address, buf, data_size))
  rc = -EFAULT;
out:
 vfree(buf);
 return rc;
}