cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sclp_config.c (4093B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 *    Copyright IBM Corp. 2007
      4 */
      5
      6#define KMSG_COMPONENT "sclp_config"
      7#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
      8
      9#include <linux/init.h>
     10#include <linux/errno.h>
     11#include <linux/cpu.h>
     12#include <linux/device.h>
     13#include <linux/workqueue.h>
     14#include <linux/slab.h>
     15#include <linux/sysfs.h>
     16#include <asm/smp.h>
     17
     18#include "sclp.h"
     19
     20struct conf_mgm_data {
     21	u8 reserved;
     22	u8 ev_qualifier;
     23} __attribute__((packed));
     24
     25#define OFB_DATA_MAX 64
     26
     27struct sclp_ofb_evbuf {
     28	struct evbuf_header header;
     29	struct conf_mgm_data cm_data;
     30	char ev_data[OFB_DATA_MAX];
     31} __packed;
     32
     33struct sclp_ofb_sccb {
     34	struct sccb_header header;
     35	struct sclp_ofb_evbuf ofb_evbuf;
     36} __packed;
     37
     38#define EV_QUAL_CPU_CHANGE	1
     39#define EV_QUAL_CAP_CHANGE	3
     40#define EV_QUAL_OPEN4BUSINESS	5
     41
     42static struct work_struct sclp_cpu_capability_work;
     43static struct work_struct sclp_cpu_change_work;
     44
     45static void sclp_cpu_capability_notify(struct work_struct *work)
     46{
     47	int cpu;
     48	struct device *dev;
     49
     50	s390_update_cpu_mhz();
     51	pr_info("CPU capability may have changed\n");
     52	cpus_read_lock();
     53	for_each_online_cpu(cpu) {
     54		dev = get_cpu_device(cpu);
     55		kobject_uevent(&dev->kobj, KOBJ_CHANGE);
     56	}
     57	cpus_read_unlock();
     58}
     59
     60static void __ref sclp_cpu_change_notify(struct work_struct *work)
     61{
     62	lock_device_hotplug();
     63	smp_rescan_cpus();
     64	unlock_device_hotplug();
     65}
     66
     67static void sclp_conf_receiver_fn(struct evbuf_header *evbuf)
     68{
     69	struct conf_mgm_data *cdata;
     70
     71	cdata = (struct conf_mgm_data *)(evbuf + 1);
     72	switch (cdata->ev_qualifier) {
     73	case EV_QUAL_CPU_CHANGE:
     74		schedule_work(&sclp_cpu_change_work);
     75		break;
     76	case EV_QUAL_CAP_CHANGE:
     77		schedule_work(&sclp_cpu_capability_work);
     78		break;
     79	}
     80}
     81
     82static struct sclp_register sclp_conf_register =
     83{
     84#ifdef CONFIG_SCLP_OFB
     85	.send_mask    = EVTYP_CONFMGMDATA_MASK,
     86#endif
     87	.receive_mask = EVTYP_CONFMGMDATA_MASK,
     88	.receiver_fn  = sclp_conf_receiver_fn,
     89};
     90
     91#ifdef CONFIG_SCLP_OFB
     92static int sclp_ofb_send_req(char *ev_data, size_t len)
     93{
     94	static DEFINE_MUTEX(send_mutex);
     95	struct sclp_ofb_sccb *sccb;
     96	int rc, response;
     97
     98	if (len > OFB_DATA_MAX)
     99		return -EINVAL;
    100	sccb = (struct sclp_ofb_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
    101	if (!sccb)
    102		return -ENOMEM;
    103	/* Setup SCCB for Control-Program Identification */
    104	sccb->header.length = sizeof(struct sclp_ofb_sccb);
    105	sccb->ofb_evbuf.header.length = sizeof(struct sclp_ofb_evbuf);
    106	sccb->ofb_evbuf.header.type = EVTYP_CONFMGMDATA;
    107	sccb->ofb_evbuf.cm_data.ev_qualifier = EV_QUAL_OPEN4BUSINESS;
    108	memcpy(sccb->ofb_evbuf.ev_data, ev_data, len);
    109
    110	if (!(sclp_conf_register.sclp_receive_mask & EVTYP_CONFMGMDATA_MASK))
    111		pr_warn("SCLP receiver did not register to receive "
    112			"Configuration Management Data Events.\n");
    113
    114	mutex_lock(&send_mutex);
    115	rc = sclp_sync_request(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
    116	mutex_unlock(&send_mutex);
    117	if (rc)
    118		goto out;
    119	response = sccb->header.response_code;
    120	if (response != 0x0020) {
    121		pr_err("Open for Business request failed with response code "
    122		       "0x%04x\n", response);
    123		rc = -EIO;
    124	}
    125out:
    126	free_page((unsigned long)sccb);
    127	return rc;
    128}
    129
    130static ssize_t sysfs_ofb_data_write(struct file *filp, struct kobject *kobj,
    131				    struct bin_attribute *bin_attr,
    132				    char *buf, loff_t off, size_t count)
    133{
    134	int rc;
    135
    136	rc = sclp_ofb_send_req(buf, count);
    137	return rc ?: count;
    138}
    139
    140static const struct bin_attribute ofb_bin_attr = {
    141	.attr = {
    142		.name = "event_data",
    143		.mode = S_IWUSR,
    144	},
    145	.write = sysfs_ofb_data_write,
    146};
    147#endif
    148
    149static int __init sclp_ofb_setup(void)
    150{
    151#ifdef CONFIG_SCLP_OFB
    152	struct kset *ofb_kset;
    153	int rc;
    154
    155	ofb_kset = kset_create_and_add("ofb", NULL, firmware_kobj);
    156	if (!ofb_kset)
    157		return -ENOMEM;
    158	rc = sysfs_create_bin_file(&ofb_kset->kobj, &ofb_bin_attr);
    159	if (rc) {
    160		kset_unregister(ofb_kset);
    161		return rc;
    162	}
    163#endif
    164	return 0;
    165}
    166
    167static int __init sclp_conf_init(void)
    168{
    169	int rc;
    170
    171	INIT_WORK(&sclp_cpu_capability_work, sclp_cpu_capability_notify);
    172	INIT_WORK(&sclp_cpu_change_work, sclp_cpu_change_notify);
    173	rc = sclp_register(&sclp_conf_register);
    174	if (rc)
    175		return rc;
    176	return sclp_ofb_setup();
    177}
    178
    179__initcall(sclp_conf_init);