VMCI: event handling implementation.
authorGeorge Zhang <georgezhang@vmware.com>
Tue, 8 Jan 2013 23:54:23 +0000 (15:54 -0800)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Wed, 9 Jan 2013 00:15:55 +0000 (16:15 -0800)
VMCI event code that manages event handlers and handles callbacks when specific
events fire.

Signed-off-by: George Zhang <georgezhang@vmware.com>
Acked-by: Andy king <acking@vmware.com>
Acked-by: Dmitry Torokhov <dtor@vmware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/misc/vmw_vmci/vmci_event.c [new file with mode: 0644]
drivers/misc/vmw_vmci/vmci_event.h [new file with mode: 0644]

diff --git a/drivers/misc/vmw_vmci/vmci_event.c b/drivers/misc/vmw_vmci/vmci_event.c
new file mode 100644 (file)
index 0000000..8449516
--- /dev/null
@@ -0,0 +1,224 @@
+/*
+ * VMware VMCI Driver
+ *
+ * Copyright (C) 2012 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include <linux/vmw_vmci_defs.h>
+#include <linux/vmw_vmci_api.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+
+#include "vmci_driver.h"
+#include "vmci_event.h"
+
+#define EVENT_MAGIC 0xEABE0000
+#define VMCI_EVENT_MAX_ATTEMPTS 10
+
+struct vmci_subscription {
+       u32 id;
+       u32 event;
+       vmci_event_cb callback;
+       void *callback_data;
+       struct list_head node;  /* on one of subscriber lists */
+};
+
+static struct list_head subscriber_array[VMCI_EVENT_MAX];
+static DEFINE_MUTEX(subscriber_mutex);
+
+int __init vmci_event_init(void)
+{
+       int i;
+
+       for (i = 0; i < VMCI_EVENT_MAX; i++)
+               INIT_LIST_HEAD(&subscriber_array[i]);
+
+       return VMCI_SUCCESS;
+}
+
+void vmci_event_exit(void)
+{
+       int e;
+
+       /* We free all memory at exit. */
+       for (e = 0; e < VMCI_EVENT_MAX; e++) {
+               struct vmci_subscription *cur, *p2;
+               list_for_each_entry_safe(cur, p2, &subscriber_array[e], node) {
+
+                       /*
+                        * We should never get here because all events
+                        * should have been unregistered before we try
+                        * to unload the driver module.
+                        */
+                       pr_warn("Unexpected free events occurring\n");
+                       list_del(&cur->node);
+                       kfree(cur);
+               }
+       }
+}
+
+/*
+ * Find entry. Assumes subscriber_mutex is held.
+ */
+static struct vmci_subscription *event_find(u32 sub_id)
+{
+       int e;
+
+       for (e = 0; e < VMCI_EVENT_MAX; e++) {
+               struct vmci_subscription *cur;
+               list_for_each_entry(cur, &subscriber_array[e], node) {
+                       if (cur->id == sub_id)
+                               return cur;
+               }
+       }
+       return NULL;
+}
+
+/*
+ * Actually delivers the events to the subscribers.
+ * The callback function for each subscriber is invoked.
+ */
+static void event_deliver(struct vmci_event_msg *event_msg)
+{
+       struct vmci_subscription *cur;
+       struct list_head *subscriber_list;
+
+       rcu_read_lock();
+       subscriber_list = &subscriber_array[event_msg->event_data.event];
+       list_for_each_entry_rcu(cur, subscriber_list, node) {
+               cur->callback(cur->id, &event_msg->event_data,
+                             cur->callback_data);
+       }
+       rcu_read_unlock();
+}
+
+/*
+ * Dispatcher for the VMCI_EVENT_RECEIVE datagrams. Calls all
+ * subscribers for given event.
+ */
+int vmci_event_dispatch(struct vmci_datagram *msg)
+{
+       struct vmci_event_msg *event_msg = (struct vmci_event_msg *)msg;
+
+       if (msg->payload_size < sizeof(u32) ||
+           msg->payload_size > sizeof(struct vmci_event_data_max))
+               return VMCI_ERROR_INVALID_ARGS;
+
+       if (!VMCI_EVENT_VALID(event_msg->event_data.event))
+               return VMCI_ERROR_EVENT_UNKNOWN;
+
+       event_deliver(event_msg);
+       return VMCI_SUCCESS;
+}
+
+/*
+ * vmci_event_subscribe() - Subscribe to a given event.
+ * @event:      The event to subscribe to.
+ * @callback:   The callback to invoke upon the event.
+ * @callback_data:      Data to pass to the callback.
+ * @subscription_id:    ID used to track subscription.  Used with
+ *              vmci_event_unsubscribe()
+ *
+ * Subscribes to the provided event. The callback specified will be
+ * fired from RCU critical section and therefore must not sleep.
+ */
+int vmci_event_subscribe(u32 event,
+                        vmci_event_cb callback,
+                        void *callback_data,
+                        u32 *new_subscription_id)
+{
+       struct vmci_subscription *sub;
+       int attempts;
+       int retval;
+       bool have_new_id = false;
+
+       if (!new_subscription_id) {
+               pr_devel("%s: Invalid subscription (NULL)\n", __func__);
+               return VMCI_ERROR_INVALID_ARGS;
+       }
+
+       if (!VMCI_EVENT_VALID(event) || !callback) {
+               pr_devel("%s: Failed to subscribe to event (type=%d) (callback=%p) (data=%p)\n",
+                        __func__, event, callback, callback_data);
+               return VMCI_ERROR_INVALID_ARGS;
+       }
+
+       sub = kzalloc(sizeof(*sub), GFP_KERNEL);
+       if (!sub)
+               return VMCI_ERROR_NO_MEM;
+
+       sub->id = VMCI_EVENT_MAX;
+       sub->event = event;
+       sub->callback = callback;
+       sub->callback_data = callback_data;
+       INIT_LIST_HEAD(&sub->node);
+
+       mutex_lock(&subscriber_mutex);
+
+       /* Creation of a new event is always allowed. */
+       for (attempts = 0; attempts < VMCI_EVENT_MAX_ATTEMPTS; attempts++) {
+               static u32 subscription_id;
+               /*
+                * We try to get an id a couple of time before
+                * claiming we are out of resources.
+                */
+
+               /* Test for duplicate id. */
+               if (!event_find(++subscription_id)) {
+                       sub->id = subscription_id;
+                       have_new_id = true;
+                       break;
+               }
+       }
+
+       if (have_new_id) {
+               list_add_rcu(&sub->node, &subscriber_array[event]);
+               retval = VMCI_SUCCESS;
+       } else {
+               retval = VMCI_ERROR_NO_RESOURCES;
+       }
+
+       mutex_unlock(&subscriber_mutex);
+
+       *new_subscription_id = sub->id;
+       return retval;
+}
+EXPORT_SYMBOL_GPL(vmci_event_subscribe);
+
+/*
+ * vmci_event_unsubscribe() - unsubscribe from an event.
+ * @sub_id:     A subscription ID as provided by vmci_event_subscribe()
+ *
+ * Unsubscribe from given event. Removes it from list and frees it.
+ * Will return callback_data if requested by caller.
+ */
+int vmci_event_unsubscribe(u32 sub_id)
+{
+       struct vmci_subscription *s;
+
+       mutex_lock(&subscriber_mutex);
+       s = event_find(sub_id);
+       if (s)
+               list_del_rcu(&s->node);
+       mutex_unlock(&subscriber_mutex);
+
+       if (!s)
+               return VMCI_ERROR_NOT_FOUND;
+
+       synchronize_rcu();
+       kfree(s);
+
+       return VMCI_SUCCESS;
+}
+EXPORT_SYMBOL_GPL(vmci_event_unsubscribe);
diff --git a/drivers/misc/vmw_vmci/vmci_event.h b/drivers/misc/vmw_vmci/vmci_event.h
new file mode 100644 (file)
index 0000000..7df9b1c
--- /dev/null
@@ -0,0 +1,25 @@
+/*
+ * VMware VMCI Driver
+ *
+ * Copyright (C) 2012 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#ifndef __VMCI_EVENT_H__
+#define __VMCI_EVENT_H__
+
+#include <linux/vmw_vmci_api.h>
+
+int vmci_event_init(void);
+void vmci_event_exit(void);
+int vmci_event_dispatch(struct vmci_datagram *msg);
+
+#endif /*__VMCI_EVENT_H__ */