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