// Copyright(c) 2018-2020, Intel Corporation
//
// 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.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H

#include <stdio.h>
#include <linux/limits.h>
#include <dlfcn.h>
#include <glob.h>

#include <uuid/uuid.h>

#include "monitored_device.h"
#include "monitor_thread.h"
#include "api/sysfs.h"

#ifdef LOG
#undef LOG
#endif
#define LOG(format, ...) \
log_printf("monitored_device: " format, ##__VA_ARGS__)

fpgad_supported_device default_supported_devices_table[] = {
	{ 0x8086, 0xbcc0, "libfpgad-xfpga.so", 0, NULL, "" },
	{ 0x8086, 0xbcc1, "libfpgad-xfpga.so", 0, NULL, "" },
	{ 0x8086, 0x0b30,    "libfpgad-vc.so", 0, NULL, "" },
	{ 0x8086, 0x0b31,    "libfpgad-vc.so", 0, NULL, "" },
	{      0,      0,                NULL, 0, NULL, "" },
};

STATIC fpgad_supported_device *mon_is_loaded(struct fpgad_config *c,
					     const char *library_path)
{
	unsigned i;
	int res = 0;

	for (i = 0 ; c->supported_devices[i].library_path ; ++i) {
		fpgad_supported_device *d = &c->supported_devices[i];

		res = strcmp(library_path, d->library_path);

		if (!res && (d->flags & FPGAD_DEV_LOADED))
			return d;
	}
	return NULL;
}

STATIC fpgad_monitored_device *
allocate_monitored_device(struct fpgad_config *config,
			  fpgad_supported_device *supported,
			  fpga_token token,
			  uint64_t object_id,
			  fpga_objtype object_type,
			  opae_bitstream_info *bitstr)
{
	fpgad_monitored_device *d;

	d = (fpgad_monitored_device *) calloc(
			1, sizeof(fpgad_monitored_device));

	if (!d) {
		LOG("out of memory");
		return NULL;
	}

	d->config = config;
	d->supported = supported;
	d->token = token;
	d->object_id = object_id;
	d->object_type = object_type;
	d->bitstr = bitstr;

	return d;
}

STATIC void *mon_find_plugin(const char *libpath)
{
	char plugin_path[PATH_MAX];
	const char *search_paths[] = { OPAE_MODULE_SEARCH_PATHS };
	unsigned i;
	void *dl_handle;

	for (i = 0 ;
		i < sizeof(search_paths) / sizeof(search_paths[0]) ;
		++i) {
		snprintf(plugin_path, sizeof(plugin_path),
				"%s%s", search_paths[i], libpath);

		dl_handle = dlopen(plugin_path, RTLD_LAZY|RTLD_LOCAL);
		if (dl_handle)
			return dl_handle;
	}

	return NULL;
}

STATIC bool mon_consider_device(struct fpgad_config *c, fpga_token token)
{
	unsigned i;
	fpga_properties props = NULL;
	fpga_token parent = NULL;
	fpga_properties parent_props = NULL;
	fpga_result res;
	uint16_t vendor_id;
	uint16_t device_id;
	uint64_t object_id;
	fpga_objtype object_type;
	opae_bitstream_info *bitstr = NULL;
	fpga_guid pr_ifc_id;
	bool added = false;

	res = fpgaGetProperties(token, &props);
	if (res != FPGA_OK) {
		LOG("failed to get properties\n");
		return false;
	}

	vendor_id = 0;
	res = fpgaPropertiesGetVendorID(props, &vendor_id);
	if (res != FPGA_OK) {
		LOG("failed to get vendor ID\n");
		goto err_out_destroy;
	}

	device_id = 0;
	res = fpgaPropertiesGetDeviceID(props, &device_id);
	if (res != FPGA_OK) {
		LOG("failed to get device ID\n");
		goto err_out_destroy;
	}

	object_id = 0;
	res = fpgaPropertiesGetObjectID(props, &object_id);
	if (res != FPGA_OK) {
		LOG("failed to get object ID\n");
		goto err_out_destroy;
	}

	object_type = FPGA_ACCELERATOR;
	res = fpgaPropertiesGetObjectType(props, &object_type);
	if (res != FPGA_OK) {
		LOG("failed to get object type\n");
		goto err_out_destroy;
	}

	// Do we have a NULL GBS from the command line
	// that matches this device?

	if (object_type == FPGA_DEVICE) {
		// The token's guid is the PR interface ID.

		res = fpgaPropertiesGetGUID(props, &pr_ifc_id);
		if (res != FPGA_OK) {
			LOG("failed to get PR interface ID\n");\
			goto err_out_destroy;
		}

		for (i = 0 ; i < c->num_null_gbs ; ++i) {
			if (!uuid_compare(c->null_gbs[i].pr_interface_id,
					  pr_ifc_id)) {
				bitstr = &c->null_gbs[i];
				break;
			}
		}
	} else {
		// The parent token's guid is the PR interface ID.

		res = fpgaPropertiesGetParent(props, &parent);
		if (res != FPGA_OK) {
			LOG("failed to get parent token\n");
			goto err_out_destroy;
		}

		res = fpgaGetProperties(parent, &parent_props);
		if (res != FPGA_OK) {
			LOG("failed to get parent properties\n");
			goto err_out_destroy;
		}

		res = fpgaPropertiesGetGUID(parent_props, &pr_ifc_id);
		if (res != FPGA_OK) {
			LOG("failed to get PR interface ID\n");
			goto err_out_destroy;
		}

		fpgaDestroyProperties(&parent_props);
		fpgaDestroyToken(&parent);

		for (i = 0 ; i < c->num_null_gbs ; ++i) {
			if (!uuid_compare(c->null_gbs[i].pr_interface_id,
					  pr_ifc_id)) {
				bitstr = &c->null_gbs[i];
				break;
			}
		}
	}

	fpgaDestroyProperties(&props);

	for (i = 0 ; c->supported_devices[i].library_path ; ++i) {
		fpgad_supported_device *d = &c->supported_devices[i];

		// Do we support this device?
		if (d->vendor_id == vendor_id &&
		    d->device_id == device_id) {
			fpgad_supported_device *loaded_by;
			fpgad_monitored_device *monitored;
			fpgad_plugin_configure_t cfg;
			int res;

			d->flags |= FPGAD_DEV_DETECTED;

			// Is the fpgad plugin already loaded?
			loaded_by = mon_is_loaded(c, d->library_path);

			if (loaded_by) {
				// The two table entries will share the
				// same plugin handle (but only loaded_by
				// will have FPGAD_DEV_LOADED).
				d->dl_handle = loaded_by->dl_handle;
			} else {
				// Plugin hasn't been loaded.
				// Load it now.
				d->dl_handle =
					mon_find_plugin(d->library_path);
				if (!d->dl_handle) {
					char *err = dlerror();
					LOG("failed to load \"%s\" %s\n",
							d->library_path,
							err ? err : "");
					continue;
				}

				d->flags |= FPGAD_DEV_LOADED;
			}

			if (!bitstr) {
				LOG("Warning: no NULL GBS for vid=0x%04x "
					"did=0x%04x objid=0x%x (%s)\n",
				vendor_id,
				device_id,
				object_id,
				object_type == FPGA_ACCELERATOR ?
				"accelerator" : "device");
			}

			// Add the device to the monitored list.
			monitored = allocate_monitored_device(c,
							      d,
							      token,
							      object_id,
							      object_type,
							      bitstr);
			if (!monitored) {
				LOG("failed to add device 0x%04x:0x%04x\n",
					vendor_id, device_id);
				continue;
			}

			// Success
			cfg = (fpgad_plugin_configure_t)
				dlsym(d->dl_handle,
				      FPGAD_PLUGIN_CONFIGURE);
			if (!cfg) {
				LOG("failed to find %s in \"%s\"\n",
					FPGAD_PLUGIN_CONFIGURE,
					d->library_path);
				free(monitored);
				continue;
			}

			res = cfg(monitored, d->config);
			if (res) {
				LOG("%s for \"%s\" returned %d.\n",
				    FPGAD_PLUGIN_CONFIGURE,
				    d->library_path,
				    res);
				free(monitored);
				continue;
			}

			if (monitored->type == FPGAD_PLUGIN_TYPE_THREAD) {

				if (monitored->thread_fn) {

					if (pthread_create(&monitored->thread,
							   NULL,
							   monitored->thread_fn,
							   monitored)) {
						LOG("failed to create thread"
						    " for \"%s\"\n",
						    d->library_path);
						free(monitored);
						continue;
					}

				} else {
					LOG("Thread plugin \"%s\" has no "
					    "thread_fn\n", d->library_path);
					free(monitored);
					continue;
				}

			}

			mon_monitor_device(monitored);
			added = true;
			break;
		}
	}

	return added;

err_out_destroy:
	if (props)
		fpgaDestroyProperties(&props);
	if (parent)
		fpgaDestroyToken(&parent);
	if (parent_props)
		fpgaDestroyProperties(&parent_props);
	return false;
}

int mon_enumerate(struct fpgad_config *c)
{
	fpga_token *tokens = NULL;
	fpga_result res;
	uint32_t num_matches = 0;
	uint32_t i;
	unsigned monitored_devices = 0;

	res = fpgaEnumerate(NULL, 0, NULL, 0, &num_matches);
	if (res != FPGA_OK) {
		LOG("enumeration failed\n");
		return res;
	}

	if (!num_matches) {
		res = 1;
		return res;
	}

	tokens = calloc(num_matches, sizeof(fpga_token));
	if (!tokens) {
		res = 1;
		LOG("out of memory\n");
		return res;
	}

	res = fpgaEnumerate(NULL, 0, tokens, num_matches, &num_matches);
	if (res != FPGA_OK) {
		LOG("enumeration failed (2)\n");
		goto out_exit;
	}

	for (i = 0 ; i < num_matches ; ++i) {
		if (!mon_consider_device(c, tokens[i])) {
			// Not monitoring it. Destroy the token.
			fpgaDestroyToken(&tokens[i]);
		} else {
			++monitored_devices;
		}
	}

out_exit:
	if (tokens)
		free(tokens);
	return res + (monitored_devices ? 0 : 1);
}