1 /*
2  * VMware VMCI Driver
3  *
4  * Copyright (C) 2012 VMware, Inc. All rights reserved.
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 as published by the
8  * Free Software Foundation version 2 and no later version.
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 MERCHANTABILITY
12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13  * for more details.
14  */
15 
16 #include <linux/vmw_vmci_defs.h>
17 #include <linux/vmw_vmci_api.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/rculist.h>
23 
24 #include "vmci_driver.h"
25 #include "vmci_event.h"
26 
27 #define EVENT_MAGIC 0xEABE0000
28 #define VMCI_EVENT_MAX_ATTEMPTS 10
29 
30 struct vmci_subscription {
31 	u32 id;
32 	u32 event;
33 	vmci_event_cb callback;
34 	void *callback_data;
35 	struct list_head node;	/* on one of subscriber lists */
36 };
37 
38 static struct list_head subscriber_array[VMCI_EVENT_MAX];
39 static DEFINE_MUTEX(subscriber_mutex);
40 
vmci_event_init(void)41 int __init vmci_event_init(void)
42 {
43 	int i;
44 
45 	for (i = 0; i < VMCI_EVENT_MAX; i++)
46 		INIT_LIST_HEAD(&subscriber_array[i]);
47 
48 	return VMCI_SUCCESS;
49 }
50 
vmci_event_exit(void)51 void vmci_event_exit(void)
52 {
53 	int e;
54 
55 	/* We free all memory at exit. */
56 	for (e = 0; e < VMCI_EVENT_MAX; e++) {
57 		struct vmci_subscription *cur, *p2;
58 		list_for_each_entry_safe(cur, p2, &subscriber_array[e], node) {
59 
60 			/*
61 			 * We should never get here because all events
62 			 * should have been unregistered before we try
63 			 * to unload the driver module.
64 			 */
65 			pr_warn("Unexpected free events occurring\n");
66 			list_del(&cur->node);
67 			kfree(cur);
68 		}
69 	}
70 }
71 
72 /*
73  * Find entry. Assumes subscriber_mutex is held.
74  */
event_find(u32 sub_id)75 static struct vmci_subscription *event_find(u32 sub_id)
76 {
77 	int e;
78 
79 	for (e = 0; e < VMCI_EVENT_MAX; e++) {
80 		struct vmci_subscription *cur;
81 		list_for_each_entry(cur, &subscriber_array[e], node) {
82 			if (cur->id == sub_id)
83 				return cur;
84 		}
85 	}
86 	return NULL;
87 }
88 
89 /*
90  * Actually delivers the events to the subscribers.
91  * The callback function for each subscriber is invoked.
92  */
event_deliver(struct vmci_event_msg * event_msg)93 static void event_deliver(struct vmci_event_msg *event_msg)
94 {
95 	struct vmci_subscription *cur;
96 	struct list_head *subscriber_list;
97 
98 	rcu_read_lock();
99 	subscriber_list = &subscriber_array[event_msg->event_data.event];
100 	list_for_each_entry_rcu(cur, subscriber_list, node) {
101 		cur->callback(cur->id, &event_msg->event_data,
102 			      cur->callback_data);
103 	}
104 	rcu_read_unlock();
105 }
106 
107 /*
108  * Dispatcher for the VMCI_EVENT_RECEIVE datagrams. Calls all
109  * subscribers for given event.
110  */
vmci_event_dispatch(struct vmci_datagram * msg)111 int vmci_event_dispatch(struct vmci_datagram *msg)
112 {
113 	struct vmci_event_msg *event_msg = (struct vmci_event_msg *)msg;
114 
115 	if (msg->payload_size < sizeof(u32) ||
116 	    msg->payload_size > sizeof(struct vmci_event_data_max))
117 		return VMCI_ERROR_INVALID_ARGS;
118 
119 	if (!VMCI_EVENT_VALID(event_msg->event_data.event))
120 		return VMCI_ERROR_EVENT_UNKNOWN;
121 
122 	event_deliver(event_msg);
123 	return VMCI_SUCCESS;
124 }
125 
126 /*
127  * vmci_event_subscribe() - Subscribe to a given event.
128  * @event:      The event to subscribe to.
129  * @callback:   The callback to invoke upon the event.
130  * @callback_data:      Data to pass to the callback.
131  * @subscription_id:    ID used to track subscription.  Used with
132  *              vmci_event_unsubscribe()
133  *
134  * Subscribes to the provided event. The callback specified will be
135  * fired from RCU critical section and therefore must not sleep.
136  */
vmci_event_subscribe(u32 event,vmci_event_cb callback,void * callback_data,u32 * new_subscription_id)137 int vmci_event_subscribe(u32 event,
138 			 vmci_event_cb callback,
139 			 void *callback_data,
140 			 u32 *new_subscription_id)
141 {
142 	struct vmci_subscription *sub;
143 	int attempts;
144 	int retval;
145 	bool have_new_id = false;
146 
147 	if (!new_subscription_id) {
148 		pr_devel("%s: Invalid subscription (NULL)\n", __func__);
149 		return VMCI_ERROR_INVALID_ARGS;
150 	}
151 
152 	if (!VMCI_EVENT_VALID(event) || !callback) {
153 		pr_devel("%s: Failed to subscribe to event (type=%d) (callback=%p) (data=%p)\n",
154 			 __func__, event, callback, callback_data);
155 		return VMCI_ERROR_INVALID_ARGS;
156 	}
157 
158 	sub = kzalloc(sizeof(*sub), GFP_KERNEL);
159 	if (!sub)
160 		return VMCI_ERROR_NO_MEM;
161 
162 	sub->id = VMCI_EVENT_MAX;
163 	sub->event = event;
164 	sub->callback = callback;
165 	sub->callback_data = callback_data;
166 	INIT_LIST_HEAD(&sub->node);
167 
168 	mutex_lock(&subscriber_mutex);
169 
170 	/* Creation of a new event is always allowed. */
171 	for (attempts = 0; attempts < VMCI_EVENT_MAX_ATTEMPTS; attempts++) {
172 		static u32 subscription_id;
173 		/*
174 		 * We try to get an id a couple of time before
175 		 * claiming we are out of resources.
176 		 */
177 
178 		/* Test for duplicate id. */
179 		if (!event_find(++subscription_id)) {
180 			sub->id = subscription_id;
181 			have_new_id = true;
182 			break;
183 		}
184 	}
185 
186 	if (have_new_id) {
187 		list_add_rcu(&sub->node, &subscriber_array[event]);
188 		retval = VMCI_SUCCESS;
189 	} else {
190 		retval = VMCI_ERROR_NO_RESOURCES;
191 	}
192 
193 	mutex_unlock(&subscriber_mutex);
194 
195 	*new_subscription_id = sub->id;
196 	return retval;
197 }
198 EXPORT_SYMBOL_GPL(vmci_event_subscribe);
199 
200 /*
201  * vmci_event_unsubscribe() - unsubscribe from an event.
202  * @sub_id:     A subscription ID as provided by vmci_event_subscribe()
203  *
204  * Unsubscribe from given event. Removes it from list and frees it.
205  * Will return callback_data if requested by caller.
206  */
vmci_event_unsubscribe(u32 sub_id)207 int vmci_event_unsubscribe(u32 sub_id)
208 {
209 	struct vmci_subscription *s;
210 
211 	mutex_lock(&subscriber_mutex);
212 	s = event_find(sub_id);
213 	if (s)
214 		list_del_rcu(&s->node);
215 	mutex_unlock(&subscriber_mutex);
216 
217 	if (!s)
218 		return VMCI_ERROR_NOT_FOUND;
219 
220 	synchronize_rcu();
221 	kfree(s);
222 
223 	return VMCI_SUCCESS;
224 }
225 EXPORT_SYMBOL_GPL(vmci_event_unsubscribe);
226