/*

 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <config.h>

#include "dpif-solaris.h"

#include <fcntl.h>

#include <strings.h>

#include <unistd.h>

#include "classifier.h"

#include "dpif-provider.h"

#include "dynamic-string.h"

#include "netdev-solaris.h"

#include "netdev-vport.h"

#include "netlink.h"

#include "odp-execute.h"

#include "poll-loop.h"

#include "shash.h"

#include "socket-util.h"

#include "sset.h"

#include "vlog.h"

#include <netpacket/packet.h>

#include <zone.h>

#include <libdllink.h>

VLOG_DEFINE_THIS_MODULE(dpif_solaris);

static kstat2_handle_t	dpif_khandle;

static boolean_t	kstat2_handle_initialized = B_FALSE;

static struct ovs_mutex	kstat_mutex = OVS_MUTEX_INITIALIZER;

/* Datapath interface for the openvswitch Solaris kernel module. */

struct dpif_solaris {

	struct dpif dpif;

	dladm_handle_t dh;

	int dp_ifindex;	/* datapath id */

	const struct dpif_class *class;

	char *name;

	atomic_flag destroyed;

	struct ovs_refcount ref_cnt;

	/* BRIDGES */

	struct ovs_rwlock bridge_rwlock;

	struct hmap bridges;

	/* PORT */

	struct ovs_rwlock port_rwlock;

	struct hmap ports;

	/* FLOW */

	struct ovs_rwlock flow_rwlock;

	struct hmap flows OVS_GUARDED;

	struct classifier cls;		/* rule, flow & mask */

	/* Upcall messages. */

	struct ovs_rwlock upcall_lock;

	bool recv_set;

	int event_rfd;

	int event_wfd;

};

static struct ovs_mutex dp_solaris_mutex = OVS_MUTEX_INITIALIZER;

/* Contains all 'struct dpif_solaris's. */

static struct shash dp_all_solaris OVS_GUARDED_BY(dp_solaris_mutex) =

    SHASH_INITIALIZER(&dp_all_solaris);

static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(9999, 5);

struct dpif_solaris_bridge {

	char *name;

	struct hmap_node node;	/* Node in dpif_solaris's 'bridges'. */

	struct hmap ports;

	struct list uplink_port_list;	/* List of all uplinks to the bridge */

};

struct dpif_solaris_port {

	struct hmap_node node;		/* Node in dpif_solaris's 'ports'. */

	struct hmap_node brnode;	/* Node in dpif_bridge's 'ports'. */

	odp_port_t port_no;		/* OF port no of this port */

	odp_port_t pf_port_no;		/* OF port no of the PF_PACKET socket */

	char *type;			/* Port type as requested by user. */

	char *name;

	char *linkname;

	char *physname;

	enum ovs_vport_type vtype;

	struct netdev *netdev;

	struct dpif_solaris_bridge *bridge;

	boolean_t is_uplink;

	struct list uplink_node;	/* Node in dpif_solaris_bridge's */

					/* uplink_port_list */

	/* Receive the upcalls */

	int upcall_fd;			/* PF_PACKET fd for MISS event */

	/* Send the packet */

	int xfd;			/* PF_PACKET to execute output action */

};

struct dpif_solaris_flow {

	/* Packet classification. */

	struct cls_rule cr;	/* Node in dpif_solaris's 'cls'. */

	/* Hash table index by unmasked flow. */

	struct hmap_node node;	/* Node in dpif_solaris's 'flows'. */

	struct flow flow;	/* The flow that created this entry. */

	struct flow mask;	/* The flow that created this entry. */

	char *physname;

	char flowname[MAXUSERFLOWNAMELEN];

};

static void dpif_solaris_port_del__(struct dpif_solaris *dpif,

    struct dpif_solaris_port *port)

    OVS_REQ_WRLOCK(dpif->port_rwlock);

static void dpif_solaris_destroy_channels(struct dpif_solaris *dpif)

    OVS_REQ_WRLOCK(dpif->upcall_lock);

static int dpif_solaris_refresh_port_channel(struct dpif_solaris *dpif,

    struct dpif_solaris_port *port, const char *physname, boolean_t notify)

    OVS_REQ_WRLOCK(dpif->port_rwlock);

static int dpif_solaris_get_port_by_number(struct dpif_solaris *dpif,

    odp_port_t port_no, struct dpif_solaris_port **portp)

    OVS_REQ_RDLOCK(dpif->port_rwlock);

static int

dpif_solaris_get_uplink_port_info(struct dpif_solaris *dpif,

    odp_port_t port_no, odp_port_t *uport_nop, int *xfdp,

    enum ovs_vport_type *vtypep);

static void dpif_solaris_flow_remove(struct dpif_solaris *dpif,

    struct dpif_solaris_flow *flow)

    OVS_REQ_WRLOCK(dpif->flow_rwlock);

static int dpif_solaris_flow_flush__(struct dpif_solaris *dpif);

static struct dpif_solaris *

dpif_solaris_cast(const struct dpif *dpif)

{

	dpif_assert_class(dpif, &dpif_solaris_class);

	return (CONTAINER_OF(dpif, struct dpif_solaris, dpif));

}

static int

dpif_solaris_enumerate(struct sset *all_dps)

{

	int error;

	VLOG_DBG("dpif_solaris_enumerate");

	error = solaris_init_rad();

	if (error != 0)

		return (error);

	if (netdev_impl_etherstub_exists()) {

		VLOG_DBG("dpif_solaris_enumerate ovs-system");

		sset_add(all_dps, "ovs-system");

	}

	return (0);

}

static int

dpif_solaris_open(const struct dpif_class *class, const char *name,

    bool create, struct dpif **dpifp)

{

	struct dpif_solaris *dpif;

	int error = 0;

	boolean_t dp_exists;

	dladm_status_t status;

	VLOG_DBG("dpif_solaris_open class type %s name %s do %screate",

	    class->type, name, create ? "" : "not ");

	if (strcmp(name, "ovs-system") != 0)

		return (ENODEV);

	error = solaris_init_rad();

	if (error != 0)

		return (error);

	ovs_mutex_lock(&dp_solaris_mutex);

	dp_exists = netdev_impl_etherstub_exists();

	dpif = shash_find_data(&dp_all_solaris, name);

	/*

	 * The same function is shared by ovs-vswitchd and other utilities as

	 * they call into the same library. Note that for other utilities,

	 * dpif does not exists at first, create it here if dp_exists indicate

	 * the datapath already exists.

	 */

again:

	if ((dp_exists && dpif == NULL) || (!dp_exists && create)) {

		dladm_handle_t dh = NULL;

		status = dladm_open(&dh);

		error = solaris_dladm_status2error(status);

		if (error != 0) {

			ovs_mutex_unlock(&dp_solaris_mutex);

			return (error);

		}

		if (!dp_exists) {

			error = netdev_create_impl_etherstub();

			if (error != 0) {

				ovs_mutex_unlock(&dp_solaris_mutex);

				dladm_close(dh);

				return (error);

			}

		}

		dpif = xzalloc(sizeof (*dpif));

		dpif->dh = dh;

		dpif->dp_ifindex = getzoneid();

		dpif->class = class;

		dpif->name = xstrdup(name);

		atomic_flag_clear(&dpif->destroyed);

		/* UPCALL related */

		ovs_rwlock_init(&dpif->upcall_lock);

		dpif->recv_set = false;

		/* uplink related */

		ovs_rwlock_init(&dpif->bridge_rwlock);

		hmap_init(&dpif->bridges);

		/* port related */

		ovs_rwlock_init(&dpif->port_rwlock);

		hmap_init(&dpif->ports);

		dpif->event_rfd = dpif->event_wfd = -1;

		/* flow related */

		ovs_rwlock_init(&dpif->flow_rwlock);

		classifier_init(&dpif->cls, NULL);

		hmap_init(&dpif->flows);

		ovs_refcount_init(&dpif->ref_cnt);

		shash_add(&dp_all_solaris, name, dpif);

		if (!create) {

			ovs_refcount_ref(&dpif->ref_cnt);

			goto again;

		}

	} else if (!dp_exists) {

		error = ENODEV;

	} else {

		error = (dpif->class != class ? EOPNOTSUPP :

		    create ? EEXIST : 0);

	}

	if (!error) {

		ovs_refcount_ref(&dpif->ref_cnt);

		/* Choose dp_ifindex to be used as netflow engine type and id */

		dpif_init(&dpif->dpif, class, name, dpif->dp_ifindex,

		    dpif->dp_ifindex);

		*dpifp = &dpif->dpif;

	}

	ovs_mutex_unlock(&dp_solaris_mutex);

	return (error);

}

/*

 * Requires dp_netdev_mutex so that we can't get a new reference to 'dp'

 * through the 'dp_netdevs' shash while freeing 'dp'.

 */

static void

dp_solaris_free(struct dpif_solaris *dpif)

    OVS_REQUIRES(dp_solaris_mutex)

{

	struct dpif_solaris_port *port, *next;

	VLOG_DBG("dp_solaris_free %s", dpif->name);

	shash_find_and_delete(&dp_all_solaris, dpif->name);

	ovs_rwlock_wrlock(&dpif->port_rwlock);

	HMAP_FOR_EACH_SAFE(port, next, node, &dpif->ports) {

		dpif_solaris_port_del__(dpif, port);

	}

	ovs_rwlock_unlock(&dpif->port_rwlock);

	dpif_solaris_flow_flush__(dpif);

	classifier_destroy(&dpif->cls);

	hmap_destroy(&dpif->bridges);

	ovs_rwlock_destroy(&dpif->bridge_rwlock);

	hmap_destroy(&dpif->ports);

	ovs_rwlock_destroy(&dpif->port_rwlock);

	hmap_destroy(&dpif->flows);

	ovs_rwlock_destroy(&dpif->flow_rwlock);

	(void) close(dpif->event_rfd);

	(void) close(dpif->event_wfd);

	free(dpif->name);

	dladm_close(dpif->dh);

	netdev_delete_impl_etherstub();

	ovs_rwlock_destroy(&dpif->upcall_lock);

	free(dpif);

}

static void

dp_solaris_unref(struct dpif_solaris *dpif)

{

	if (dpif != NULL) {

		/*

		 * Take dp_solaris_mutex so that, if dpif->ref_cnt falls to

		 * zero, we can't get a hold of 'dpif'.

		 */

		ovs_mutex_lock(&dp_solaris_mutex);

		if (ovs_refcount_unref(&dpif->ref_cnt) == 2) {

			dp_solaris_free(dpif);

		}

		ovs_mutex_unlock(&dp_solaris_mutex);

	}

}

static void

dpif_solaris_close(struct dpif *dpif_)

{

	struct dpif_solaris *dpif = dpif_solaris_cast(dpif_);

	VLOG_DBG("dpif_solaris_close %s", dpif->name);

	ovs_rwlock_wrlock(&dpif->upcall_lock);

	dpif_solaris_destroy_channels(dpif);

	ovs_rwlock_unlock(&dpif->upcall_lock);

	dp_solaris_unref(dpif);

}

static int

dpif_solaris_destroy(struct dpif *dpif_)

{

	struct dpif_solaris *dpif = dpif_solaris_cast(dpif_);

	int cnt;

	VLOG_DBG("dpif_solaris_destroy %s", dpif->name);

	if (!atomic_flag_test_and_set(&dpif->destroyed)) {

		cnt = ovs_refcount_unref(&dpif->ref_cnt);

		if (cnt <= 2) {

			OVS_NOT_REACHED();

		}

	}

	return (0);

}

static int

dpif_solaris_get_stats(const struct dpif *dpif_, struct dpif_dp_stats *stats)

{

	struct dpif_solaris		*dpif = dpif_solaris_cast(dpif_);

	struct dpif_solaris_bridge	*bridge;

	struct dpif_solaris_port	*port;

	kstat2_status_t			stat;

	kstat2_map_t			map;

	char				kuri[1024];

	char				kstat_name[MAXLINKNAMELEN];

	char				*name;

	zoneid_t			zid;

	uint_t				instance;

	bzero(stats, sizeof (struct dpif_dp_stats));

	ovs_mutex_lock(&kstat_mutex);

	if (!kstat2_handle_initialized) {

		VLOG_DBG("dpif_solaris_get_stats initializing handle");

		if (!kstat_handle_init(&dpif_khandle)) {

			ovs_mutex_unlock(&kstat_mutex);

			VLOG_DBG("dpif_solaris_get_stats: error initializing"

			    " kstat handle");

			return (-1);

		}

		kstat2_handle_initialized = B_TRUE;

	} else if (!kstat_handle_update(dpif_khandle)) {

		kstat_handle_close(&dpif_khandle);

		kstat2_handle_initialized = B_FALSE;

		ovs_mutex_unlock(&kstat_mutex);

		VLOG_DBG("dpif_solaris_get_stats: error updating kstats");

		return (-1);

	}

	ovs_rwlock_rdlock(&dpif->bridge_rwlock);

	HMAP_FOR_EACH(bridge, node, &dpif->bridges) {

		LIST_FOR_EACH(port, uplink_node, &bridge->uplink_port_list) {

			name = (char *)port->physname;

			instance = 0;

			if (strchr(port->physname, '/') != NULL) {

				(void) solaris_dlparse_zonelinkname(

				    port->physname, kstat_name, &zid);

				name = kstat_name;

				instance = zid;

			}

			(void) snprintf(kuri, sizeof (kuri),

			    "kstat:/net/%s/link/%d", name, instance);

			stat = kstat2_lookup_map(dpif_khandle, kuri, &map);

			if (stat != KSTAT2_S_OK) {

				ovs_rwlock_unlock(&dpif->bridge_rwlock);

				ovs_mutex_unlock(&kstat_mutex);

				VLOG_WARN("dpif_solaris_get_stats kstat_lookup "

				    "of %s failed: %s", kuri,

				    kstat2_status_string(stat));

				return (-1);

			}

			stats->n_hit += (get_nvvt_int(map, "ipkthit") +

			    get_nvvt_int(map, "opkthit"));

			stats->n_missed += (get_nvvt_int(map, "ipktmiss") +

			    get_nvvt_int(map, "opktmiss"));

		}

	}

	ovs_rwlock_unlock(&dpif->bridge_rwlock);

	ovs_mutex_unlock(&kstat_mutex);

	stats->n_lost   = 0;

	stats->n_flows  = solaris_flow_walk(NULL, NULL, B_TRUE, NULL);

	stats->n_masks  = UINT32_MAX;

	stats->n_mask_hit  = UINT64_MAX;

	return (0);

}

static enum ovs_vport_type

netdev_to_ovs_vport_type(const struct netdev *netdev)

{

	const char *type = netdev_get_type(netdev);

	if (strcmp(type, "system") == 0) {

		return (OVS_VPORT_TYPE_NETDEV);

	} else if (strcmp(type, "internal") == 0) {

		return (OVS_VPORT_TYPE_INTERNAL);

	} else if (strcmp(type, "vxlan") == 0) {

		return (OVS_VPORT_TYPE_VXLAN);

	} else {

		return (OVS_VPORT_TYPE_UNSPEC);

	}

}

static int

dpif_solaris_create_xsocket(struct dpif_solaris *dpif OVS_UNUSED,

    struct dpif_solaris_port *port)

{

	int fd;

	struct sockaddr_ll sll;

	datalink_id_t linkid;

	dladm_status_t status;

	int error;

	if (port->vtype != OVS_VPORT_TYPE_NETDEV &&

	    port->vtype != OVS_VPORT_TYPE_VXLAN &&

	    port->vtype != OVS_VPORT_TYPE_INTERNAL)

		return (0);

	if ((fd = socket(PF_PACKET, SOCK_RAW, ETH_P_ALL)) == -1) {

		return (errno);

	}

	status = dladm_name2info(dpif->dh, port->linkname, &linkid,

	    NULL, NULL, NULL);

	error = solaris_dladm_status2error(status);

	if (error != 0) {

		(void) close(fd);

		return (error);

	}

	(void) memset(&sll, 0, sizeof (sll));

	sll.sll_family = AF_PACKET;

	sll.sll_ifindex = linkid;

	sll.sll_protocol = ETH_P_ALL;

	if (bind(fd, (struct sockaddr *)&sll, sizeof (sll)) == -1) {

		error = errno;

		(void) close(fd);

		return (error);

	}

	port->xfd = fd;

	VLOG_DBG("dpif_solaris_create_xsocket %d on %s port_no: %d", fd,

	    port->name, port->port_no);

	return (0);

}

static boolean_t

port_not_used(struct dpif_solaris *dpif, uint32_t port_no)

    OVS_REQ_WRLOCK(dp->port_rwlock)

{

	struct dpif_solaris_port *port;

	HMAP_FOR_EACH(port, node, &dpif->ports) {

		if (port->port_no == port_no ||

		    port->pf_port_no == port_no) {

			return (true);

		}

	}

	return (false);

}

/*

 * Choose an unused, non-zero port number and return it on success.

 * Return ODPP_NONE on failure.

 * The current approach to choose unused port number is quite inefficient,

 * need improvement. TBD

 */

static odp_port_t

choose_port(struct dpif_solaris *dpif, uint32_t exclude_port_no)

    OVS_REQ_WRLOCK(dp->port_rwlock)

{

	uint32_t port_no;

	for (port_no = PORT_PF_PACKET_UPLINK + 1; port_no < OFPP_MAX;

	    port_no++) {

		if ((exclude_port_no == ODPP_NONE ||

		    port_no != exclude_port_no) &&

		    (!port_not_used(dpif, port_no))) {