/*

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

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * 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.

 */

#if HAVE_CONFIG_H

#include <config.h>

#endif /* HAVE_CONFIG_H */

/*

 * OFED Solaris wrapper

 */

#if defined(__SVR4) && defined(__sun)

#include <stdarg.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/processor.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <sys/param.h>

#include <sys/ib/clients/of/sol_uverbs/sol_uverbs_ioctl.h>

#include <sys/ib/clients/of/sol_umad/sol_umad_ioctl.h>

#include <alloca.h>

#include "../include/infiniband/arch.h"

#include "../include/infiniband/verbs.h"

#include "../include/infiniband/kern-abi.h"

#include "../include/infiniband/driver.h"

#include <errno.h>

#include <pthread.h>

#include <kstat.h>

#define	min(a, b)	((a) < (b) ? (a) : (b))

/*

 * duplicate ABI definitions for HCAs as the HCA abi headers are not

 * installed in proto.

 */

#define	RDMA_USER_CM_MIN_ABI_VERSION	3 /* rdma_cma_abi.h */

#define	RDMA_USER_CM_MAX_ABI_VERSION	4 /* rdma_cma_abi.h */

/*

 * Some useful definitions.

 */

#define	HW_DRIVER_MAX_NAME_LEN			20

#define	UVERBS_KERNEL_SYSFS_NAME_BASE		"uverbs"

#define	UMAD_KERNEL_SYSFS_NAME_BASE		"umad"

#define	IB_HCA_DEVPATH_PREFIX			"/dev/infiniband/hca"

#define	IB_OFS_DEVPATH_PREFIX			"/dev/infiniband/ofs"

#define	IB_HCA_DEVPATH_SZ			64

#define	MAX_OFS_DEVPATH_LEN			64

#define	MAX_HCAS				(64*16)

#define	MAX_PORTS				(MAX_HCAS*2)

/*

 * sol_uverbs_drv_status is the status of what libibverbs knows

 * about the status of sol_uverbs driver.

 */

#define	SOL_UVERBS_DRV_STATUS_UNKNOWN	0x0

#define	SOL_UVERBS_DRV_STATUS_LOADED	0x1

#define	SOL_UVERBS_DRV_STATUS_UNLOADED	0x02

static kstat_ctl_t	*kc = NULL;	/* libkstat cookie */

static int sol_uverbs_drv_status = SOL_UVERBS_DRV_STATUS_UNKNOWN;

static int sol_uverbs_minor_dev = -1;

/*

 * Override verbs abi version.

 * If the build system doesn't have the intended

 * header file then override with the intended abi version.

 * These changes can be deleted once the build system has

 * the correct header file.

 */

#if	(IB_USER_VERBS_SOLARIS_ABI_VERSION == 2)

#undef	IB_USER_VERBS_SOLARIS_ABI_VERSION

#define	IB_USER_VERBS_SOLARIS_ABI_VERSION	4

#define	UVERBS_PSID_STR_SZ		32

#define	UVERBS_IBDEV_NAME_SZ		64

#define	UVERBS_HCA_DRIVER_NAME_SZ	40

#define	UVERBS_DEVID_STR_SZ		16

typedef struct sol_uverbs_hca_info_v4_s {

	char		uverbs_hca_psid_string[UVERBS_PSID_STR_SZ];

	uint8_t		uverbs_hca_pad1[8];

	char		uverbs_hca_ibdev_name[UVERBS_IBDEV_NAME_SZ];

	char		uverbs_hca_driver_name[UVERBS_HCA_DRIVER_NAME_SZ];

	uint32_t	uverbs_hca_driver_instance;

	uint32_t	uverbs_hca_vendorid;

	uint16_t	uverbs_hca_deviceid;

	uint16_t	uverbs_hca_devidx;

	int32_t		uverbs_hca_abi_version;

	uint64_t	uverbs_hca_fw_ver;

	uint64_t	uverbs_hca_node_guid;

	uint64_t	uverbs_hca_node_external_guid;

	uint64_t	uverbs_hca_sys_image_guid;

	uint32_t	uverbs_hca_hw_version;

	uint8_t		uverbs_hca_pad2[4];

	char		uverbs_hca_devid_string[UVERBS_DEVID_STR_SZ];

	uint8_t		uverbs_hca_pad3[24];

} sol_uverbs_hca_info_v4_t;

#define	IB_USER_VERBS_V4_IN_V3

#endif

/*

 * Some useful definitions.

 */

#define	SIZEOF_UVERBS_INFO	(sizeof (sol_uverbs_info_t))

#ifdef	IB_USER_VERBS_V4_IN_V3

#define	SIZEOF_HCA_INFO		(sizeof (sol_uverbs_hca_info_v4_t))

#else

#define	SIZEOF_HCA_INFO		(sizeof (sol_uverbs_hca_info_t))

#endif

#define	UVERBS_INFO(x)		((sol_uverbs_info_t *)x)

/*

 * check_path() prefixs

 */

typedef enum cp_prefix_e {

	CP_SOL_UVERBS		= 1,

	CP_DEVICE		= 2,

	CP_D			= 3,

	CP_GIDS			= 4,

	CP_PKEYS		= 5,

	CP_PORTS		= 6,

	CP_UMAD			= 7,

	CP_SLASH		= 8,

	CP_SYS			= 9,

	CP_CLASS		= 10,

	CP_INFINIBAND_VERBS	= 11,

	CP_INFINIBAND		= 12,

	CP_INFINIBAND_MAD	= 13,

	CP_MISC			= 14,

	CP_RDMA_CM		= 15

} cp_prefix_t;

/*

 * Some temporary cache code, until things are cleaned up as part of DR

 * work. This will speed up the sysfs emulation.

 */

typedef struct ibdev_cache_info_s {

	boolean_t			ibd_valid;

	uint_t				ibd_hw_rev;

	uint_t				ibd_abi_version;

	uint_t				ibd_vendor_id;

	uint_t				ibd_device_id;

	char				ibd_hca_path[IB_HCA_DEVPATH_SZ];

	char				ibd_node_guid_str[20];

	char				ibd_node_guid_external_str[20];

	char				ibd_sys_image_guid[20];

	char				ibd_fw_ver[16];

	char				ibd_name[UVERBS_IBDEV_NAME_SZ];

	char				ibd_boardid_string[UVERBS_PSID_STR_SZ];

	char				ibd_devid_string[UVERBS_DEVID_STR_SZ];

} ibdev_cache_info_t;

/* IB device info cache */

static ibdev_cache_info_t	ibdev_cache[MAX_HCAS];

static int			uverbs_abi_version = -1;

typedef struct umad_cache_info_s {

	uint_t		umc_valid;

	int		umc_port;

	char		umc_ib_dev[16];

} umad_cache_info_t;

static umad_cache_info_t	umad_dev_cache[MAX_PORTS];

static int			umad_abi_version = -1;

pthread_once_t		oneTimeInit = PTHREAD_ONCE_INIT;

static int 		umad_cache_cnt = 0;

static boolean_t	initialized = B_FALSE;

static boolean_t	umad_cache_initialized = B_FALSE;

static boolean_t	ibdev_cache_initialized = B_FALSE;

static pthread_mutex_t	umad_cache_mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_mutex_t	ibdev_cache_mutex = PTHREAD_MUTEX_INITIALIZER;

int sol_ibv_query_gid(struct ibv_context *, uint8_t, int, union ibv_gid *);

int sol_ibv_query_pkey(struct ibv_context *, uint8_t, int, uint16_t *);

void __attribute__((constructor))solaris_init(void);

void __attribute__((destructor))solaris_fini(void);

int sol_ibv_query_device(struct ibv_device *device,

    struct ibv_device_attr *device_attr);

int sol_ibv_query_port(struct ibv_context *, uint8_t, struct ibv_port_attr *);

void

solaris_init(void)

{

	while ((kc = kstat_open()) == NULL) {

		if (errno == EAGAIN)

			(void) poll(NULL, 0, 200);

		else

			fprintf(stderr, "cannot open /dev/kstat: %s\n",

			    strerror(errno));

	}

}

void

solaris_fini(void)

{

	(void) kstat_close(kc);

}

#define	isdigit(c)	((c) >= '0' && (c) <= '9')

/*

 * Given a device name of the form <driver-prefix><instance>,

 * get the device number. Device name is of the form

 * for example:- mlx4_0, mlx4_2 etc. Function will return the device instance

 * extracted from the name.

 * for example:- mlx4_0 will return 0 and mlx4_2 will return 2.

 */

static int

get_device_num(const char *device_name)

{

	const char *temp;

	const char *end;

	const char *start = device_name;

	int len;

	int devnum;

	if (!start)

		return (-1);

	len = strlen(device_name);

	end = &device_name[len - 1];

	for (temp = end; temp >= start && isdigit(*temp); temp--)

		/* Null body */;

	/*

	 * Check if the device number is invalid.

	 */

	if (temp == end || temp < start)

		return (-1);

	devnum = atoi(temp + 1);

	if (devnum < 0 || devnum >= MAX_HCAS)

		return (-1);

	return (devnum);

}

/*

 * For usages where ibdev cache needs to be read based on the IB device

 * name instead of uverbs device name a simple compare against the cache

 * entries is used to retrieve the corresponding ibdev cache entry.

 */

static ibdev_cache_info_t *

ibdev_cache_read_by_devname(const char *devname)

{

	int idx;

	ibdev_cache_info_t *cache = NULL;

	if (!devname)

		return (NULL);

	for (idx = 0; idx < MAX_HCAS; idx++) {

		cache = &ibdev_cache[idx];

		if (strcmp(cache->ibd_name, devname) == 0)

			break;

	}

	/*

	 * If we failed to find an entry return NULL.

	 */

	if (idx == MAX_HCAS)

		cache = NULL;

	return (cache);

}

/*

 * Helper function to update the ibdev cache entries with the values obtained

 * from the uverbs HCA info ioctl.

 */

static int

ibdev_cache_init()

{

	ibdev_cache_info_t		*info;

	int				fd, i, hca_cnt;

	char				uverbs_devpath[MAX_OFS_DEVPATH_LEN];

	sol_uverbs_info_t		*uverbs_infop;

#ifdef	IB_USER_VERBS_V4_IN_V3

	sol_uverbs_hca_info_v4_t	*hca_infop;

#else

	sol_uverbs_hca_info_t		*hca_infop;

#endif

	char 				*buf;

	size_t				bufsize;

	uint16_t			major, minor, sub_minor;

	uint64_t			raw_fw_ver;

	uint64_t			guid;

	snprintf(uverbs_devpath, MAX_OFS_DEVPATH_LEN, "%s/%s%d",

	    IB_OFS_DEVPATH_PREFIX, UVERBS_KERNEL_SYSFS_NAME_BASE,

	    sol_uverbs_minor_dev);

	/*

	 * using the first sol_uverbs minor node that can be opened to get

	 * all the HCA information

	 */

	if ((fd = open(uverbs_devpath, O_RDWR)) < 0) {

		fprintf(stderr, "sol_uverbs failed to open: %s\n",

		    strerror(errno));

		return (-1);

	}

	bufsize = SIZEOF_UVERBS_INFO + (MAX_HCAS * SIZEOF_HCA_INFO);

	buf = malloc(bufsize);

	if (!buf) {

		fprintf(stderr, "ibdev_cache_update() failed to alloc\n");

		close(fd);

		return (-1);

	}

	memset(buf, 0, bufsize);

	uverbs_infop = UVERBS_INFO(buf);

	uverbs_infop->uverbs_hca_cnt = MAX_HCAS;

	if (ioctl(fd, UVERBS_IOCTL_GET_HCA_INFO, uverbs_infop) != 0) {

		fprintf(stderr, "sol_uverbs ioctl failed: %s\n",

		    strerror(errno));

		goto error_exit1;

	}

	if (uverbs_infop->uverbs_solaris_abi_version !=

	    IB_USER_VERBS_SOLARIS_ABI_VERSION) {

		fprintf(stderr, "sol_uverbs solaris_abi_version !="

		    "IB_USER_VERBS_SOLARIS_ABI_VERSION : %d\n",

		    uverbs_infop->uverbs_solaris_abi_version);

		goto error_exit1;

	}

	hca_cnt = uverbs_infop->uverbs_hca_cnt;	/* hca count returned */

	hca_infop = uverbs_infop->uverbs_hca_info;

	if (hca_cnt > MAX_HCAS) {

		fprintf(stderr, "Number of HCAs returned exceeds max\n");

		goto error_exit1;

	}

	if (uverbs_abi_version == -1)

		uverbs_abi_version = uverbs_infop->uverbs_abi_version;

	for (i = 0; i < hca_cnt; i++, hca_infop++) {

		/*

		 * Update the cache.

		 */

		info = &ibdev_cache[hca_infop->uverbs_hca_devidx];

		(void) strncpy(info->ibd_name,

		    hca_infop->uverbs_hca_ibdev_name, UVERBS_IBDEV_NAME_SZ);

		guid = hca_infop->uverbs_hca_node_guid;

		sprintf(info->ibd_node_guid_str, "%04x:%04x:%04x:%04x",

		    (unsigned)(guid >> 48) & 0xffff,

		    (unsigned)(guid >> 32) & 0xffff,

		    (unsigned)(guid >> 16) & 0xffff,

		    (unsigned)(guid >>  0) & 0xffff);

		guid = hca_infop->uverbs_hca_node_external_guid;

		sprintf(info->ibd_node_guid_external_str, "%04x:%04x:%04x:%04x",

		    (unsigned)(guid >> 48) & 0xffff,

		    (unsigned)(guid >> 32) & 0xffff,

		    (unsigned)(guid >> 16) & 0xffff,

		    (unsigned)(guid >>  0) & 0xffff);

		guid = hca_infop->uverbs_hca_sys_image_guid;

		sprintf(info->ibd_sys_image_guid, "%04x:%04x:%04x:%04x",

		    (unsigned)(guid >> 48) & 0xffff,

		    (unsigned)(guid >> 32) & 0xffff,

		    (unsigned)(guid >> 16) & 0xffff,

		    (unsigned)(guid >>  0) & 0xffff);

		raw_fw_ver = hca_infop->uverbs_hca_fw_ver;

		major	   = (raw_fw_ver >> 32) & 0xffff;

		minor	   = (raw_fw_ver >> 16) & 0xffff;

		sub_minor  = raw_fw_ver & 0xffff;

		snprintf(info->ibd_fw_ver, sizeof (info->ibd_fw_ver),

		    "%d.%d.%03d", major, minor, sub_minor);

		info->ibd_hw_rev	= hca_infop->uverbs_hca_hw_version;

		info->ibd_vendor_id	= hca_infop->uverbs_hca_vendorid;

		info->ibd_device_id	= hca_infop->uverbs_hca_deviceid;

		info->ibd_abi_version	= hca_infop->uverbs_hca_abi_version;

		snprintf(info->ibd_hca_path, sizeof (info->ibd_hca_path),

		    "%s/%s%d", IB_HCA_DEVPATH_PREFIX,

		    hca_infop->uverbs_hca_driver_name,

		    hca_infop->uverbs_hca_driver_instance);

		strncpy(info->ibd_boardid_string,

		    hca_infop->uverbs_hca_psid_string, UVERBS_PSID_STR_SZ);

		strncpy(info->ibd_devid_string,

		    hca_infop->uverbs_hca_devid_string, UVERBS_DEVID_STR_SZ);

		info->ibd_valid = B_TRUE;

	}

	free(buf);

	close(fd);

	return (0);

error_exit1:

	free(buf);

	close(fd);

	return (-1);

}

static int

umad_cache_add(uint_t dev_num, int port, char *ibdev)

{

	if ((dev_num >= MAX_PORTS) || (umad_cache_cnt >= MAX_PORTS)) {

		fprintf(stderr, "dev %d: exceeds umad cache size\n", dev_num);

		return (1);

	}

	umad_dev_cache[dev_num].umc_port = port;

	strcpy(umad_dev_cache[dev_num].umc_ib_dev, ibdev);

	umad_dev_cache[dev_num].umc_valid = 1;

	umad_cache_cnt++;

	return (0);

}

static int

umad_cache_init()

{

	int				i, fd, minor;

	int				save_errno = 0;

	int				port_cnt, bufsize;

	char				umad_devpath[MAX_OFS_DEVPATH_LEN], *buf;

	sol_umad_ioctl_info_t		*umad_infop;

	sol_umad_ioctl_port_info_t	*port_infop;

	for (minor = 0; minor < MAX_PORTS; minor++) {

		snprintf(umad_devpath, MAX_OFS_DEVPATH_LEN, "%s/%s%d",

		    IB_OFS_DEVPATH_PREFIX, UMAD_KERNEL_SYSFS_NAME_BASE,

		    minor);

		if ((fd = open(umad_devpath, O_RDWR)) > 0)

			break;

		if ((! save_errno) && (errno != ENOENT))

			save_errno = errno;

	}

	if ((minor == MAX_PORTS) && (fd < 0)) {

		if (! save_errno)

			save_errno = errno;

		fprintf(stderr, "failed to open sol_umad: %s\n",

		    strerror(save_errno));

		return (-1);

	}

	bufsize = sizeof (sol_umad_ioctl_info_t) +

	    (sizeof (sol_umad_ioctl_port_info_t) * MAX_PORTS);

	buf = malloc(bufsize);

	memset(buf, 0, bufsize);

	umad_infop = (sol_umad_ioctl_info_t *)buf;

	umad_infop->umad_port_cnt = MAX_PORTS;

	if (ioctl(fd, IB_USER_MAD_GET_PORT_INFO, umad_infop) != 0) {

		fprintf(stderr, "sol_umad ioctl failed: %s\n",

		    strerror(errno));

		goto error_exit;