VMCI: event handling implementation.

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>

2 files changed, 249 insertions, 0 deletions

diff --git a/drivers/misc/vmw_vmci/vmci_event.c b/drivers/misc/vmw_vmci/vmci_event.c
new file mode 100644
index 000000000000..8449516d6ac6
--- /dev/null
+++ b/drivers/misc/vmw_vmci/vmci_event.c
@@ -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
index 000000000000..7df9b1c0a96c
--- /dev/null
+++ b/drivers/misc/vmw_vmci/vmci_event.h
@@ -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__ */