Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 264 insertions, 0 deletions

diff --git a/drivers/net/enic/enic_pp.c b/drivers/net/enic/enic_pp.c
new file mode 100644
index 000000000000..ffaa75dd1ded
--- /dev/null
+++ b/drivers/net/enic/enic_pp.c
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2011 Cisco Systems, Inc.  All rights reserved.
+ *
+ * This program is free software; you may redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/rtnetlink.h>
+#include <net/ip.h>
+
+#include "vnic_vic.h"
+#include "enic_res.h"
+#include "enic.h"
+#include "enic_dev.h"
+
+static int enic_set_port_profile(struct enic *enic)
+{
+        struct net_device *netdev = enic->netdev;
+        struct vic_provinfo *vp;
+        const u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
+        const u16 os_type = htons(VIC_GENERIC_PROV_OS_TYPE_LINUX);
+        char uuid_str[38];
+        char client_mac_str[18];
+        u8 *client_mac;
+        int err;
+
+        if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
+                return -EINVAL;
+
+        vp = vic_provinfo_alloc(GFP_KERNEL, oui,
+                VIC_PROVINFO_GENERIC_TYPE);
+        if (!vp)
+                return -ENOMEM;
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR,
+                strlen(enic->pp.name) + 1, enic->pp.name);
+
+        if (!is_zero_ether_addr(enic->pp.mac_addr))
+                client_mac = enic->pp.mac_addr;
+        else
+                client_mac = netdev->dev_addr;
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR,
+                ETH_ALEN, client_mac);
+
+        snprintf(client_mac_str, sizeof(client_mac_str), "%pM", client_mac);
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR,
+                sizeof(client_mac_str), client_mac_str);
+
+        if (enic->pp.set & ENIC_SET_INSTANCE) {
+                sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
+                VIC_PROVINFO_ADD_TLV(vp,
+                        VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
+                        sizeof(uuid_str), uuid_str);
+        }
+
+        if (enic->pp.set & ENIC_SET_HOST) {
+                sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
+                VIC_PROVINFO_ADD_TLV(vp,
+                        VIC_GENERIC_PROV_TLV_HOST_UUID_STR,
+                        sizeof(uuid_str), uuid_str);
+        }
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_OS_TYPE,
+                sizeof(os_type), &os_type);
+
+        err = enic_dev_status_to_errno(enic_dev_init_prov2(enic, vp));
+
+add_tlv_failure:
+        vic_provinfo_free(vp);
+
+        return err;
+}
+
+static int enic_unset_port_profile(struct enic *enic)
+{
+        int err;
+
+        err = enic_vnic_dev_deinit(enic);
+        if (err)
+                return enic_dev_status_to_errno(err);
+
+        enic_reset_addr_lists(enic);
+
+        return 0;
+}
+
+static int enic_are_pp_different(struct enic_port_profile *pp1,
+                struct enic_port_profile *pp2)
+{
+        return strcmp(pp1->name, pp2->name) | !!memcmp(pp1->instance_uuid,
+                pp2->instance_uuid, PORT_UUID_MAX) |
+                !!memcmp(pp1->host_uuid, pp2->host_uuid, PORT_UUID_MAX) |
+                !!memcmp(pp1->mac_addr, pp2->mac_addr, ETH_ALEN);
+}
+
+static int enic_pp_preassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_disassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_preassociate_rr(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_associate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+
+static int (*enic_pp_handlers[])(struct enic *enic,
+                struct enic_port_profile *prev_state, int *restore_pp) = {
+        [PORT_REQUEST_PREASSOCIATE]     = enic_pp_preassociate,
+        [PORT_REQUEST_PREASSOCIATE_RR]  = enic_pp_preassociate_rr,
+        [PORT_REQUEST_ASSOCIATE]        = enic_pp_associate,
+        [PORT_REQUEST_DISASSOCIATE]     = enic_pp_disassociate,
+};
+
+static const int enic_pp_handlers_count =
+                        sizeof(enic_pp_handlers)/sizeof(*enic_pp_handlers);
+
+static int enic_pp_preassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        return -EOPNOTSUPP;
+}
+
+static int enic_pp_disassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        return enic_unset_port_profile(enic);
+}
+
+static int enic_pp_preassociate_rr(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        int err;
+        int active = 0;
+
+        if (enic->pp.request != PORT_REQUEST_ASSOCIATE) {
+                /* If pre-associate is not part of an associate.
+                We always disassociate first */
+                err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](enic,
+                        prev_pp, restore_pp);
+                if (err)
+                        return err;
+
+                *restore_pp = 0;
+        }
+
+        *restore_pp = 0;
+
+        err = enic_set_port_profile(enic);
+        if (err)
+                return err;
+
+        /* If pre-associate is not part of an associate. */
+        if (enic->pp.request != PORT_REQUEST_ASSOCIATE)
+                err = enic_dev_status_to_errno(enic_dev_enable2(enic, active));
+
+        return err;
+}
+
+static int enic_pp_associate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        int err;
+        int active = 1;
+
+        /* Check if a pre-associate was called before */
+        if (prev_pp->request != PORT_REQUEST_PREASSOCIATE_RR ||
+                (prev_pp->request == PORT_REQUEST_PREASSOCIATE_RR &&
+                        enic_are_pp_different(prev_pp, &enic->pp))) {
+                err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](
+                        enic, prev_pp, restore_pp);
+                if (err)
+                        return err;
+
+                *restore_pp = 0;
+        }
+
+        err = enic_pp_handlers[PORT_REQUEST_PREASSOCIATE_RR](
+                        enic, prev_pp, restore_pp);
+        if (err)
+                return err;
+
+        *restore_pp = 0;
+
+        return enic_dev_status_to_errno(enic_dev_enable2(enic, active));
+}
+
+int enic_process_set_pp_request(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        if (enic->pp.request < enic_pp_handlers_count
+                && enic_pp_handlers[enic->pp.request])
+                return enic_pp_handlers[enic->pp.request](enic,
+                        prev_pp, restore_pp);
+        else
+                return -EOPNOTSUPP;
+}
+
+int enic_process_get_pp_request(struct enic *enic, int request,
+        u16 *response)
+{
+        int err, status = ERR_SUCCESS;
+
+        switch (request) {
+
+        case PORT_REQUEST_PREASSOCIATE_RR:
+        case PORT_REQUEST_ASSOCIATE:
+                err = enic_dev_enable2_done(enic, &status);
+                break;
+
+        case PORT_REQUEST_DISASSOCIATE:
+                err = enic_dev_deinit_done(enic, &status);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (err)
+                status = err;
+
+        switch (status) {
+        case ERR_SUCCESS:
+                *response = PORT_PROFILE_RESPONSE_SUCCESS;
+                break;
+        case ERR_EINVAL:
+                *response = PORT_PROFILE_RESPONSE_INVALID;
+                break;
+        case ERR_EBADSTATE:
+                *response = PORT_PROFILE_RESPONSE_BADSTATE;
+                break;
+        case ERR_ENOMEM:
+                *response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
+                break;
+        case ERR_EINPROGRESS:
+                *response = PORT_PROFILE_RESPONSE_INPROGRESS;
+                break;
+        default:
+                *response = PORT_PROFILE_RESPONSE_ERROR;
+                break;
+        }
+
+        return 0;
+}