1 /* 2 * Copyright IBM Corp. 2004,2010 3 * Interface implementation for communication with the z/VM control program 4 * 5 * Author(s): Christian Borntraeger <borntraeger@de.ibm.com> 6 * 7 * z/VMs CP offers the possibility to issue commands via the diagnose code 8 8 * this driver implements a character device that issues these commands and 9 * returns the answer of CP. 10 * 11 * The idea of this driver is based on cpint from Neale Ferguson and #CP in CMS 12 */ 13 14 #include <linux/fs.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/miscdevice.h> 18 #include <linux/slab.h> 19 #include <asm/compat.h> 20 #include <asm/cpcmd.h> 21 #include <asm/debug.h> 22 #include <asm/uaccess.h> 23 #include "vmcp.h" 24 25 static debug_info_t *vmcp_debug; 26 27 static int vmcp_open(struct inode *inode, struct file *file) 28 { 29 struct vmcp_session *session; 30 31 if (!capable(CAP_SYS_ADMIN)) 32 return -EPERM; 33 34 session = kmalloc(sizeof(*session), GFP_KERNEL); 35 if (!session) 36 return -ENOMEM; 37 38 session->bufsize = PAGE_SIZE; 39 session->response = NULL; 40 session->resp_size = 0; 41 mutex_init(&session->mutex); 42 file->private_data = session; 43 return nonseekable_open(inode, file); 44 } 45 46 static int vmcp_release(struct inode *inode, struct file *file) 47 { 48 struct vmcp_session *session; 49 50 session = file->private_data; 51 file->private_data = NULL; 52 free_pages((unsigned long)session->response, get_order(session->bufsize)); 53 kfree(session); 54 return 0; 55 } 56 57 static ssize_t 58 vmcp_read(struct file *file, char __user *buff, size_t count, loff_t *ppos) 59 { 60 ssize_t ret; 61 size_t size; 62 struct vmcp_session *session; 63 64 session = file->private_data; 65 if (mutex_lock_interruptible(&session->mutex)) 66 return -ERESTARTSYS; 67 if (!session->response) { 68 mutex_unlock(&session->mutex); 69 return 0; 70 } 71 size = min_t(size_t, session->resp_size, session->bufsize); 72 ret = simple_read_from_buffer(buff, count, ppos, 73 session->response, size); 74 75 mutex_unlock(&session->mutex); 76 77 return ret; 78 } 79 80 static ssize_t 81 vmcp_write(struct file *file, const char __user *buff, size_t count, 82 loff_t *ppos) 83 { 84 char *cmd; 85 struct vmcp_session *session; 86 87 if (count > 240) 88 return -EINVAL; 89 cmd = kmalloc(count + 1, GFP_KERNEL); 90 if (!cmd) 91 return -ENOMEM; 92 if (copy_from_user(cmd, buff, count)) { 93 kfree(cmd); 94 return -EFAULT; 95 } 96 cmd[count] = '\0'; 97 session = file->private_data; 98 if (mutex_lock_interruptible(&session->mutex)) { 99 kfree(cmd); 100 return -ERESTARTSYS; 101 } 102 if (!session->response) 103 session->response = (char *)__get_free_pages(GFP_KERNEL 104 | __GFP_REPEAT | GFP_DMA, 105 get_order(session->bufsize)); 106 if (!session->response) { 107 mutex_unlock(&session->mutex); 108 kfree(cmd); 109 return -ENOMEM; 110 } 111 debug_text_event(vmcp_debug, 1, cmd); 112 session->resp_size = cpcmd(cmd, session->response, session->bufsize, 113 &session->resp_code); 114 mutex_unlock(&session->mutex); 115 kfree(cmd); 116 *ppos = 0; /* reset the file pointer after a command */ 117 return count; 118 } 119 120 121 /* 122 * These ioctls are available, as the semantics of the diagnose 8 call 123 * does not fit very well into a Linux call. Diagnose X'08' is described in 124 * CP Programming Services SC24-6084-00 125 * 126 * VMCP_GETCODE: gives the CP return code back to user space 127 * VMCP_SETBUF: sets the response buffer for the next write call. diagnose 8 128 * expects adjacent pages in real storage and to make matters worse, we 129 * dont know the size of the response. Therefore we default to PAGESIZE and 130 * let userspace to change the response size, if userspace expects a bigger 131 * response 132 */ 133 static long vmcp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 134 { 135 struct vmcp_session *session; 136 int __user *argp; 137 int temp; 138 139 session = file->private_data; 140 if (is_compat_task()) 141 argp = compat_ptr(arg); 142 else 143 argp = (int __user *)arg; 144 if (mutex_lock_interruptible(&session->mutex)) 145 return -ERESTARTSYS; 146 switch (cmd) { 147 case VMCP_GETCODE: 148 temp = session->resp_code; 149 mutex_unlock(&session->mutex); 150 return put_user(temp, argp); 151 case VMCP_SETBUF: 152 free_pages((unsigned long)session->response, 153 get_order(session->bufsize)); 154 session->response=NULL; 155 temp = get_user(session->bufsize, argp); 156 if (get_order(session->bufsize) > 8) { 157 session->bufsize = PAGE_SIZE; 158 temp = -EINVAL; 159 } 160 mutex_unlock(&session->mutex); 161 return temp; 162 case VMCP_GETSIZE: 163 temp = session->resp_size; 164 mutex_unlock(&session->mutex); 165 return put_user(temp, argp); 166 default: 167 mutex_unlock(&session->mutex); 168 return -ENOIOCTLCMD; 169 } 170 } 171 172 static const struct file_operations vmcp_fops = { 173 .owner = THIS_MODULE, 174 .open = vmcp_open, 175 .release = vmcp_release, 176 .read = vmcp_read, 177 .write = vmcp_write, 178 .unlocked_ioctl = vmcp_ioctl, 179 .compat_ioctl = vmcp_ioctl, 180 .llseek = no_llseek, 181 }; 182 183 static struct miscdevice vmcp_dev = { 184 .name = "vmcp", 185 .minor = MISC_DYNAMIC_MINOR, 186 .fops = &vmcp_fops, 187 }; 188 189 static int __init vmcp_init(void) 190 { 191 int ret; 192 193 if (!MACHINE_IS_VM) 194 return 0; 195 196 vmcp_debug = debug_register("vmcp", 1, 1, 240); 197 if (!vmcp_debug) 198 return -ENOMEM; 199 200 ret = debug_register_view(vmcp_debug, &debug_hex_ascii_view); 201 if (ret) { 202 debug_unregister(vmcp_debug); 203 return ret; 204 } 205 206 ret = misc_register(&vmcp_dev); 207 if (ret) 208 debug_unregister(vmcp_debug); 209 return ret; 210 } 211 device_initcall(vmcp_init); 212