vmcp.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright IBM Corp. 2004, 2010
  4 * Interface implementation for communication with the z/VM control program
  5 *
  6 * Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
  7 *
  8 * z/VMs CP offers the possibility to issue commands via the diagnose code 8
  9 * this driver implements a character device that issues these commands and
 10 * returns the answer of CP.
 11 *
 12 * The idea of this driver is based on cpint from Neale Ferguson and #CP in CMS
 13 */
 14
 15#include <linux/fs.h>
 16#include <linux/init.h>
 17#include <linux/kernel.h>
 18#include <linux/miscdevice.h>
 19#include <linux/slab.h>
 20#include <linux/uaccess.h>
 21#include <linux/mutex.h>
 22#include <linux/cma.h>
 23#include <linux/mm.h>
 24#include <asm/machine.h>
 25#include <asm/cpcmd.h>
 26#include <asm/debug.h>
 27#include <asm/vmcp.h>
 28
 29struct vmcp_session {
 30	char *response;
 31	unsigned int bufsize;
 32	unsigned int cma_alloc : 1;
 33	int resp_size;
 34	int resp_code;
 35	struct mutex mutex;
 36};
 37
 38static debug_info_t *vmcp_debug;
 39
 40static unsigned long vmcp_cma_size __initdata = CONFIG_VMCP_CMA_SIZE * 1024 * 1024;
 41static struct cma *vmcp_cma;
 42
 43static int __init early_parse_vmcp_cma(char *p)
 44{
 45	if (!p)
 46		return 1;
 47	vmcp_cma_size = ALIGN(memparse(p, NULL), PAGE_SIZE);
 48	return 0;
 49}
 50early_param("vmcp_cma", early_parse_vmcp_cma);
 51
 52void __init vmcp_cma_reserve(void)
 53{
 54	if (!machine_is_vm())
 55		return;
 56	cma_declare_contiguous(0, vmcp_cma_size, 0, 0, 0, false, "vmcp", &vmcp_cma);
 57}
 58
 59static void vmcp_response_alloc(struct vmcp_session *session)
 60{
 61	struct page *page = NULL;
 62	int nr_pages, order;
 63
 64	order = get_order(session->bufsize);
 65	nr_pages = ALIGN(session->bufsize, PAGE_SIZE) >> PAGE_SHIFT;
 66	/*
 67	 * For anything below order 3 allocations rely on the buddy
 68	 * allocator. If such low-order allocations can't be handled
 69	 * anymore the system won't work anyway.
 70	 */
 71	if (order > 2)
 72		page = cma_alloc(vmcp_cma, nr_pages, 0, false);
 73	if (page) {
 74		session->response = (char *)page_to_virt(page);
 75		session->cma_alloc = 1;
 76		return;
 77	}
 78	session->response = (char *)__get_free_pages(GFP_KERNEL | __GFP_RETRY_MAYFAIL, order);
 79}
 80
 81static void vmcp_response_free(struct vmcp_session *session)
 82{
 83	int nr_pages, order;
 84	struct page *page;
 85
 86	if (!session->response)
 87		return;
 88	order = get_order(session->bufsize);
 89	nr_pages = ALIGN(session->bufsize, PAGE_SIZE) >> PAGE_SHIFT;
 90	if (session->cma_alloc) {
 91		page = virt_to_page(session->response);
 92		cma_release(vmcp_cma, page, nr_pages);
 93		session->cma_alloc = 0;
 94	} else {
 95		free_pages((unsigned long)session->response, order);
 96	}
 97	session->response = NULL;
 98}
 99
100static int vmcp_open(struct inode *inode, struct file *file)
101{
102	struct vmcp_session *session;
103
104	if (!capable(CAP_SYS_ADMIN))
105		return -EPERM;
106
107	session = kmalloc(sizeof(*session), GFP_KERNEL);
108	if (!session)
109		return -ENOMEM;
110
111	session->bufsize = PAGE_SIZE;
112	session->response = NULL;
113	session->resp_size = 0;
114	mutex_init(&session->mutex);
115	file->private_data = session;
116	return nonseekable_open(inode, file);
117}
118
119static int vmcp_release(struct inode *inode, struct file *file)
120{
121	struct vmcp_session *session;
122
123	session = file->private_data;
124	file->private_data = NULL;
125	vmcp_response_free(session);
126	kfree(session);
127	return 0;
128}
129
130static ssize_t
131vmcp_read(struct file *file, char __user *buff, size_t count, loff_t *ppos)
132{
133	ssize_t ret;
134	size_t size;
135	struct vmcp_session *session;
136
137	session = file->private_data;
138	if (mutex_lock_interruptible(&session->mutex))
139		return -ERESTARTSYS;
140	if (!session->response) {
141		mutex_unlock(&session->mutex);
142		return 0;
143	}
144	size = min_t(size_t, session->resp_size, session->bufsize);
145	ret = simple_read_from_buffer(buff, count, ppos,
146					session->response, size);
147
148	mutex_unlock(&session->mutex);
149
150	return ret;
151}
152
153static ssize_t
154vmcp_write(struct file *file, const char __user *buff, size_t count,
155	   loff_t *ppos)
156{
157	char *cmd;
158	struct vmcp_session *session;
159
160	if (count > 240)
161		return -EINVAL;
162	cmd = memdup_user_nul(buff, count);
163	if (IS_ERR(cmd))
164		return PTR_ERR(cmd);
165	session = file->private_data;
166	if (mutex_lock_interruptible(&session->mutex)) {
167		kfree(cmd);
168		return -ERESTARTSYS;
169	}
170	if (!session->response)
171		vmcp_response_alloc(session);
172	if (!session->response) {
173		mutex_unlock(&session->mutex);
174		kfree(cmd);
175		return -ENOMEM;
176	}
177	debug_text_event(vmcp_debug, 1, cmd);
178	session->resp_size = cpcmd(cmd, session->response, session->bufsize,
179				   &session->resp_code);
180	mutex_unlock(&session->mutex);
181	kfree(cmd);
182	*ppos = 0;		/* reset the file pointer after a command */
183	return count;
184}
185
186
187/*
188 * These ioctls are available, as the semantics of the diagnose 8 call
189 * does not fit very well into a Linux call. Diagnose X'08' is described in
190 * CP Programming Services SC24-6084-00
191 *
192 * VMCP_GETCODE: gives the CP return code back to user space
193 * VMCP_SETBUF: sets the response buffer for the next write call. diagnose 8
194 * expects adjacent pages in real storage and to make matters worse, we
195 * dont know the size of the response. Therefore we default to PAGESIZE and
196 * let userspace to change the response size, if userspace expects a bigger
197 * response
198 */
199static long vmcp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
200{
201	struct vmcp_session *session;
202	int ret = -ENOTTY;
203	int __user *argp;
204
205	session = file->private_data;
206	argp = (int __user *)arg;
207	if (mutex_lock_interruptible(&session->mutex))
208		return -ERESTARTSYS;
209	switch (cmd) {
210	case VMCP_GETCODE:
211		ret = put_user(session->resp_code, argp);
212		break;
213	case VMCP_SETBUF:
214		vmcp_response_free(session);
215		ret = get_user(session->bufsize, argp);
216		if (ret)
217			session->bufsize = PAGE_SIZE;
218		if (!session->bufsize || get_order(session->bufsize) > 8) {
219			session->bufsize = PAGE_SIZE;
220			ret = -EINVAL;
221		}
222		break;
223	case VMCP_GETSIZE:
224		ret = put_user(session->resp_size, argp);
225		break;
226	default:
227		break;
228	}
229	mutex_unlock(&session->mutex);
230	return ret;
231}
232
233static const struct file_operations vmcp_fops = {
234	.owner		= THIS_MODULE,
235	.open		= vmcp_open,
236	.release	= vmcp_release,
237	.read		= vmcp_read,
238	.write		= vmcp_write,
239	.unlocked_ioctl	= vmcp_ioctl,
240};
241
242static struct miscdevice vmcp_dev = {
243	.name	= "vmcp",
244	.minor	= MISC_DYNAMIC_MINOR,
245	.fops	= &vmcp_fops,
246};
247
248static int __init vmcp_init(void)
249{
250	int ret;
251
252	if (!machine_is_vm())
253		return 0;
254
255	vmcp_debug = debug_register("vmcp", 1, 1, 240);
256	if (!vmcp_debug)
257		return -ENOMEM;
258
259	ret = debug_register_view(vmcp_debug, &debug_hex_ascii_view);
260	if (ret) {
261		debug_unregister(vmcp_debug);
262		return ret;
263	}
264
265	ret = misc_register(&vmcp_dev);
266	if (ret)
267		debug_unregister(vmcp_debug);
268	return ret;
269}
270device_initcall(vmcp_init);