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