1 /* 2 * Kernel/userspace transport abstraction for Hyper-V util driver. 3 * 4 * Copyright (C) 2015, Vitaly Kuznetsov <vkuznets@redhat.com> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published 8 * by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 13 * NON INFRINGEMENT. See the GNU General Public License for more 14 * details. 15 * 16 */ 17 18 #include <linux/slab.h> 19 #include <linux/fs.h> 20 #include <linux/poll.h> 21 22 #include "hyperv_vmbus.h" 23 #include "hv_utils_transport.h" 24 25 static DEFINE_SPINLOCK(hvt_list_lock); 26 static struct list_head hvt_list = LIST_HEAD_INIT(hvt_list); 27 28 static void hvt_reset(struct hvutil_transport *hvt) 29 { 30 kfree(hvt->outmsg); 31 hvt->outmsg = NULL; 32 hvt->outmsg_len = 0; 33 if (hvt->on_reset) 34 hvt->on_reset(); 35 } 36 37 static ssize_t hvt_op_read(struct file *file, char __user *buf, 38 size_t count, loff_t *ppos) 39 { 40 struct hvutil_transport *hvt; 41 int ret; 42 43 hvt = container_of(file->f_op, struct hvutil_transport, fops); 44 45 if (wait_event_interruptible(hvt->outmsg_q, hvt->outmsg_len > 0 || 46 hvt->mode != HVUTIL_TRANSPORT_CHARDEV)) 47 return -EINTR; 48 49 mutex_lock(&hvt->lock); 50 51 if (hvt->mode == HVUTIL_TRANSPORT_DESTROY) { 52 ret = -EBADF; 53 goto out_unlock; 54 } 55 56 if (!hvt->outmsg) { 57 ret = -EAGAIN; 58 goto out_unlock; 59 } 60 61 if (count < hvt->outmsg_len) { 62 ret = -EINVAL; 63 goto out_unlock; 64 } 65 66 if (!copy_to_user(buf, hvt->outmsg, hvt->outmsg_len)) 67 ret = hvt->outmsg_len; 68 else 69 ret = -EFAULT; 70 71 kfree(hvt->outmsg); 72 hvt->outmsg = NULL; 73 hvt->outmsg_len = 0; 74 75 if (hvt->on_read) 76 hvt->on_read(); 77 hvt->on_read = NULL; 78 79 out_unlock: 80 mutex_unlock(&hvt->lock); 81 return ret; 82 } 83 84 static ssize_t hvt_op_write(struct file *file, const char __user *buf, 85 size_t count, loff_t *ppos) 86 { 87 struct hvutil_transport *hvt; 88 u8 *inmsg; 89 int ret; 90 91 hvt = container_of(file->f_op, struct hvutil_transport, fops); 92 93 inmsg = memdup_user(buf, count); 94 if (IS_ERR(inmsg)) 95 return PTR_ERR(inmsg); 96 97 if (hvt->mode == HVUTIL_TRANSPORT_DESTROY) 98 ret = -EBADF; 99 else 100 ret = hvt->on_msg(inmsg, count); 101 102 kfree(inmsg); 103 104 return ret ? ret : count; 105 } 106 107 static __poll_t hvt_op_poll(struct file *file, poll_table *wait) 108 { 109 struct hvutil_transport *hvt; 110 111 hvt = container_of(file->f_op, struct hvutil_transport, fops); 112 113 poll_wait(file, &hvt->outmsg_q, wait); 114 115 if (hvt->mode == HVUTIL_TRANSPORT_DESTROY) 116 return EPOLLERR | EPOLLHUP; 117 118 if (hvt->outmsg_len > 0) 119 return EPOLLIN | EPOLLRDNORM; 120 121 return 0; 122 } 123 124 static int hvt_op_open(struct inode *inode, struct file *file) 125 { 126 struct hvutil_transport *hvt; 127 int ret = 0; 128 bool issue_reset = false; 129 130 hvt = container_of(file->f_op, struct hvutil_transport, fops); 131 132 mutex_lock(&hvt->lock); 133 134 if (hvt->mode == HVUTIL_TRANSPORT_DESTROY) { 135 ret = -EBADF; 136 } else if (hvt->mode == HVUTIL_TRANSPORT_INIT) { 137 /* 138 * Switching to CHARDEV mode. We switch bach to INIT when 139 * device gets released. 140 */ 141 hvt->mode = HVUTIL_TRANSPORT_CHARDEV; 142 } 143 else if (hvt->mode == HVUTIL_TRANSPORT_NETLINK) { 144 /* 145 * We're switching from netlink communication to using char 146 * device. Issue the reset first. 147 */ 148 issue_reset = true; 149 hvt->mode = HVUTIL_TRANSPORT_CHARDEV; 150 } else { 151 ret = -EBUSY; 152 } 153 154 if (issue_reset) 155 hvt_reset(hvt); 156 157 mutex_unlock(&hvt->lock); 158 159 return ret; 160 } 161 162 static void hvt_transport_free(struct hvutil_transport *hvt) 163 { 164 misc_deregister(&hvt->mdev); 165 kfree(hvt->outmsg); 166 kfree(hvt); 167 } 168 169 static int hvt_op_release(struct inode *inode, struct file *file) 170 { 171 struct hvutil_transport *hvt; 172 int mode_old; 173 174 hvt = container_of(file->f_op, struct hvutil_transport, fops); 175 176 mutex_lock(&hvt->lock); 177 mode_old = hvt->mode; 178 if (hvt->mode != HVUTIL_TRANSPORT_DESTROY) 179 hvt->mode = HVUTIL_TRANSPORT_INIT; 180 /* 181 * Cleanup message buffers to avoid spurious messages when the daemon 182 * connects back. 183 */ 184 hvt_reset(hvt); 185 186 if (mode_old == HVUTIL_TRANSPORT_DESTROY) 187 complete(&hvt->release); 188 189 mutex_unlock(&hvt->lock); 190 191 return 0; 192 } 193 194 static void hvt_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) 195 { 196 struct hvutil_transport *hvt, *hvt_found = NULL; 197 198 spin_lock(&hvt_list_lock); 199 list_for_each_entry(hvt, &hvt_list, list) { 200 if (hvt->cn_id.idx == msg->id.idx && 201 hvt->cn_id.val == msg->id.val) { 202 hvt_found = hvt; 203 break; 204 } 205 } 206 spin_unlock(&hvt_list_lock); 207 if (!hvt_found) { 208 pr_warn("hvt_cn_callback: spurious message received!\n"); 209 return; 210 } 211 212 /* 213 * Switching to NETLINK mode. Switching to CHARDEV happens when someone 214 * opens the device. 215 */ 216 mutex_lock(&hvt->lock); 217 if (hvt->mode == HVUTIL_TRANSPORT_INIT) 218 hvt->mode = HVUTIL_TRANSPORT_NETLINK; 219 220 if (hvt->mode == HVUTIL_TRANSPORT_NETLINK) 221 hvt_found->on_msg(msg->data, msg->len); 222 else 223 pr_warn("hvt_cn_callback: unexpected netlink message!\n"); 224 mutex_unlock(&hvt->lock); 225 } 226 227 int hvutil_transport_send(struct hvutil_transport *hvt, void *msg, int len, 228 void (*on_read_cb)(void)) 229 { 230 struct cn_msg *cn_msg; 231 int ret = 0; 232 233 if (hvt->mode == HVUTIL_TRANSPORT_INIT || 234 hvt->mode == HVUTIL_TRANSPORT_DESTROY) { 235 return -EINVAL; 236 } else if (hvt->mode == HVUTIL_TRANSPORT_NETLINK) { 237 cn_msg = kzalloc(sizeof(*cn_msg) + len, GFP_ATOMIC); 238 if (!cn_msg) 239 return -ENOMEM; 240 cn_msg->id.idx = hvt->cn_id.idx; 241 cn_msg->id.val = hvt->cn_id.val; 242 cn_msg->len = len; 243 memcpy(cn_msg->data, msg, len); 244 ret = cn_netlink_send(cn_msg, 0, 0, GFP_ATOMIC); 245 kfree(cn_msg); 246 /* 247 * We don't know when netlink messages are delivered but unlike 248 * in CHARDEV mode we're not blocked and we can send next 249 * messages right away. 250 */ 251 if (on_read_cb) 252 on_read_cb(); 253 return ret; 254 } 255 /* HVUTIL_TRANSPORT_CHARDEV */ 256 mutex_lock(&hvt->lock); 257 if (hvt->mode != HVUTIL_TRANSPORT_CHARDEV) { 258 ret = -EINVAL; 259 goto out_unlock; 260 } 261 262 if (hvt->outmsg) { 263 /* Previous message wasn't received */ 264 ret = -EFAULT; 265 goto out_unlock; 266 } 267 hvt->outmsg = kzalloc(len, GFP_KERNEL); 268 if (hvt->outmsg) { 269 memcpy(hvt->outmsg, msg, len); 270 hvt->outmsg_len = len; 271 hvt->on_read = on_read_cb; 272 wake_up_interruptible(&hvt->outmsg_q); 273 } else 274 ret = -ENOMEM; 275 out_unlock: 276 mutex_unlock(&hvt->lock); 277 return ret; 278 } 279 280 struct hvutil_transport *hvutil_transport_init(const char *name, 281 u32 cn_idx, u32 cn_val, 282 int (*on_msg)(void *, int), 283 void (*on_reset)(void)) 284 { 285 struct hvutil_transport *hvt; 286 287 hvt = kzalloc(sizeof(*hvt), GFP_KERNEL); 288 if (!hvt) 289 return NULL; 290 291 hvt->cn_id.idx = cn_idx; 292 hvt->cn_id.val = cn_val; 293 294 hvt->mdev.minor = MISC_DYNAMIC_MINOR; 295 hvt->mdev.name = name; 296 297 hvt->fops.owner = THIS_MODULE; 298 hvt->fops.read = hvt_op_read; 299 hvt->fops.write = hvt_op_write; 300 hvt->fops.poll = hvt_op_poll; 301 hvt->fops.open = hvt_op_open; 302 hvt->fops.release = hvt_op_release; 303 304 hvt->mdev.fops = &hvt->fops; 305 306 init_waitqueue_head(&hvt->outmsg_q); 307 mutex_init(&hvt->lock); 308 init_completion(&hvt->release); 309 310 spin_lock(&hvt_list_lock); 311 list_add(&hvt->list, &hvt_list); 312 spin_unlock(&hvt_list_lock); 313 314 hvt->on_msg = on_msg; 315 hvt->on_reset = on_reset; 316 317 if (misc_register(&hvt->mdev)) 318 goto err_free_hvt; 319 320 /* Use cn_id.idx/cn_id.val to determine if we need to setup netlink */ 321 if (hvt->cn_id.idx > 0 && hvt->cn_id.val > 0 && 322 cn_add_callback(&hvt->cn_id, name, hvt_cn_callback)) 323 goto err_free_hvt; 324 325 return hvt; 326 327 err_free_hvt: 328 spin_lock(&hvt_list_lock); 329 list_del(&hvt->list); 330 spin_unlock(&hvt_list_lock); 331 kfree(hvt); 332 return NULL; 333 } 334 335 void hvutil_transport_destroy(struct hvutil_transport *hvt) 336 { 337 int mode_old; 338 339 mutex_lock(&hvt->lock); 340 mode_old = hvt->mode; 341 hvt->mode = HVUTIL_TRANSPORT_DESTROY; 342 wake_up_interruptible(&hvt->outmsg_q); 343 mutex_unlock(&hvt->lock); 344 345 /* 346 * In case we were in 'chardev' mode we still have an open fd so we 347 * have to defer freeing the device. Netlink interface can be freed 348 * now. 349 */ 350 spin_lock(&hvt_list_lock); 351 list_del(&hvt->list); 352 spin_unlock(&hvt_list_lock); 353 if (hvt->cn_id.idx > 0 && hvt->cn_id.val > 0) 354 cn_del_callback(&hvt->cn_id); 355 356 if (mode_old == HVUTIL_TRANSPORT_CHARDEV) 357 wait_for_completion(&hvt->release); 358 359 hvt_transport_free(hvt); 360 } 361