// 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 <sys/stat.h>

#include <unistd.h>

#include <dirent.h>

#include <stdio.h>

#include "common_int.h"

#include "opae/error.h"

#include "error_int.h"

#define INJECT_ERROR "inject_error"

fpga_result __XFPGA_API__ xfpga_fpgaReadError(fpga_token token, uint32_t error_num, uint64_t *value)

{

	struct _fpga_token *_token = (struct _fpga_token *)token;

	struct stat st;

	uint32_t i = 0;

	fpga_result res = FPGA_OK;

	ASSERT_NOT_NULL(token);

	if (_token->magic != FPGA_TOKEN_MAGIC) {

		OPAE_MSG("Invalid token");

		return FPGA_INVALID_PARAM;

	}

	struct error_list *p = _token->errors;

	while (p) {

		if (i == error_num) {

			// test if file exists

			if (stat(p->error_file, &st) == -1) {

				OPAE_MSG("can't stat %s", p->error_file);

				return FPGA_EXCEPTION;

			}

			res = sysfs_read_u64(p->error_file, value);

			if (res != FPGA_OK) {

				OPAE_MSG("can't read error file '%s'", p->error_file);

				return res;

			}

			return FPGA_OK;

		}

		i++;

		p = p->next;

	}

	OPAE_MSG("error %d not found", error_num);

	return FPGA_NOT_FOUND;

}

fpga_result __XFPGA_API__

xfpga_fpgaClearError(fpga_token token, uint32_t error_num)

{

	struct _fpga_token *_token = (struct _fpga_token *)token;

	struct stat st;

	uint32_t i = 0;

	uint64_t value = 0;

	fpga_result res = FPGA_OK;

	ASSERT_NOT_NULL(token);

	if (_token->magic != FPGA_TOKEN_MAGIC) {

		OPAE_MSG("Invalid token");

		return FPGA_INVALID_PARAM;

	}

	struct error_list *p = _token->errors;

	while (p) {

		if (i == error_num) {

			if (!p->info.can_clear) {

				OPAE_MSG("can't clear error '%s'", p->info.name);

				return FPGA_NOT_SUPPORTED;

			}

			if (strcmp(p->info.name, INJECT_ERROR) == 0) {

				value = 0;

			} else {

				// read current error value

				res = xfpga_fpgaReadError(token, error_num, &value);

				if (res != FPGA_OK)

					return res;

			}

			// write to 'clear' file

			if (stat(p->clear_file, &st) == -1) {

				OPAE_MSG("can't stat %s", p->clear_file);

				return FPGA_EXCEPTION;

			}

			res = sysfs_write_u64(p->clear_file, value);

			if (res != FPGA_OK) {

				OPAE_MSG("can't write clear file '%s'", p->clear_file);

				return res;

			}

			return FPGA_OK;

		}

		i++;

		p = p->next;

	}

	OPAE_MSG("error info %d not found", error_num);

	return FPGA_NOT_FOUND;

}

fpga_result __XFPGA_API__ xfpga_fpgaClearAllErrors(fpga_token token)

{

	struct _fpga_token *_token = (struct _fpga_token *)token;

	uint32_t i = 0;

	fpga_result res = FPGA_OK;

	ASSERT_NOT_NULL(token);

	if (_token->magic != FPGA_TOKEN_MAGIC) {

		OPAE_MSG("Invalid token");

		return FPGA_INVALID_PARAM;

	}

	struct error_list *p = _token->errors;

	while (p) {

		// if error can be cleared

		if (p->info.can_clear) {

			// clear error

			res = xfpga_fpgaClearError(token, i);

			if (res != FPGA_OK)

				return res;

		}

		i++;

		p = p->next;

	}

	return FPGA_OK;

}

fpga_result __XFPGA_API__ xfpga_fpgaGetErrorInfo(fpga_token token,

			     uint32_t error_num,

			     struct fpga_error_info *error_info)

{

	struct _fpga_token *_token = (struct _fpga_token *)token;

	uint32_t i = 0;

	if (!error_info) {

		OPAE_MSG("error_info is NULL");

		return FPGA_INVALID_PARAM;

	}

	ASSERT_NOT_NULL(token);

	if (_token->magic != FPGA_TOKEN_MAGIC) {

		OPAE_MSG("Invalid token");

		return FPGA_INVALID_PARAM;

	}

	struct error_list *p = _token->errors;

	while (p) {

		if (i == error_num) {

			memcpy(error_info, &p->info, sizeof(struct fpga_error_info));

			return FPGA_OK;

		}

		i++;

		p = p->next;

	}

	OPAE_MSG("error info %d not found", error_num);

	return FPGA_NOT_FOUND;

}

/* files and directories to ignore when looking for errors */

#define NUM_ERRORS_EXCLUDE 4

const char *errors_exclude[NUM_ERRORS_EXCLUDE] = {

	"revision",

	"uevent",

	"power",

	"clear"

};

/* files that can be cleared by writing their value to them */

#define NUM_ERRORS_CLEARABLE 6

const char *errors_clearable[] = {

	"pcie0_errors",

	"pcie1_errors",

	"warning_errors",

	"inject_error",

	"fme_errors",

	"errors"

};

/* Walks the given directory and adds error entries to `list`.

 * This function is called during enumeration when adding tokens to

 * the global tokens list. When tokens are cloned, their error

 * lists are only shallowly copied (which works because errors of

 * a token never change).

 * Note that build_error_list() does not check for dupliates; if

 * called again on the same list, it will add all found errors again.

 * Returns the number of error entries added to `list` */

uint32_t

build_error_list(const char *path, struct error_list **list)

{

	struct dirent *de;

	DIR *dir;

	struct stat st;

	char basedir[FILENAME_MAX] = { 0, };

	int len;

	int subpath_len = 0;

	uint32_t n = 0;

	unsigned int i;

	struct error_list **el = list;

	len = strnlen(path, FILENAME_MAX - 1);

	// add 3 to the len

	// 1 for the '/' char

	// 1 for the minimum length of a file appended

	// 1 for null string to terminate

	// if we go over now, then leave without doing anything else

	if (len+3 > FILENAME_MAX) {

		OPAE_MSG("path too long");

		return 0;

	}

	len = snprintf(basedir, sizeof(basedir),

		       "%s/", path);

	// now we've added one to length

	dir = opendir(path);

	if (!dir) {

		OPAE_MSG("unable to open %s", path);

		return 0;

	}

	while ((de = readdir(dir))) {

		size_t blen;

		size_t dlen;

		// skip hidden ('.*') files (includes "." and "..")

		if (de->d_name[0] == '.')

			continue;

		// skip names on blacklist

		for (i = 0; i < NUM_ERRORS_EXCLUDE; i++) {

			if (strcmp(de->d_name, errors_exclude[i]) == 0) {

				break;

			}

		}

		if (i < NUM_ERRORS_EXCLUDE)

			continue;

		subpath_len = strnlen(de->d_name, sizeof(de->d_name) - 1);

		// check if the result abs path is longer than  our max

		if (len + subpath_len > FILENAME_MAX) {

			OPAE_MSG("Error path length is too long");

			continue;

		}

		// build absolute path

		// dmax (arg2) is restricted max length of resulting dest,

		// including null - it must also be at least smax+1 (arg4)

		strncpy(basedir + len, de->d_name, subpath_len + 1);

		// try accessing file/dir

		if (lstat(basedir, &st) == -1) {

			OPAE_MSG("can't stat %s", basedir);

			continue;

		}

		// skip symlinks

		if (S_ISLNK(st.st_mode))

			continue;

		// recursively dive into subdirectories

		if (S_ISDIR(st.st_mode)) {

			n += build_error_list(basedir, el);

			continue;

		}

		// not blacklisted, not hidden, accessible, no symlink, no dir -> count and append it!

		n++;

		if (!el)	// no list

			continue;

		// append error info to list

		struct error_list *new_entry = malloc(sizeof(struct error_list));

		if (!new_entry) {

			OPAE_MSG("can't allocate memory");

			n--;

			break;

		}

		dlen = strnlen(de->d_name, sizeof(new_entry->info.name) - 1);

		memcpy(new_entry->info.name, de->d_name, dlen);

		new_entry->info.name[dlen] = '\0';

		blen = strnlen(basedir, sizeof(new_entry->error_file) - 1);

		memcpy(new_entry->error_file, basedir, blen);

		new_entry->error_file[blen] = '\0';

		new_entry->next = NULL;

		// Errors can be cleared:

		//   * if the name is "errors" and there is a file called "clear" (generic case), OR

		//   * if the name is in the "errors_clearable" table

		new_entry->info.can_clear = false;

		if (strcmp(de->d_name, "errors") == 0 &&

			!stat(FPGA_SYSFS_CLASS_PATH_INTEL, &st)) {

			strncpy(basedir + len, "clear", 6);

			// try accessing clear file

			if (lstat(basedir, &st) != -1) {

				new_entry->info.can_clear = true;

				memcpy(new_entry->clear_file, basedir, blen);

				new_entry->clear_file[blen] = '\0';

			}

		} else {

			for (i = 0; i < NUM_ERRORS_CLEARABLE; i++) {

				if (strcmp(de->d_name, errors_clearable[i]) == 0) {

					memcpy(basedir + len, de->d_name, dlen);

					*(basedir + len + dlen) = '\0';

					// try accessing clear file

					if (lstat(basedir, &st) != -1) {

						new_entry->info.can_clear = true;

						memcpy(new_entry->clear_file, basedir, blen);

						new_entry->clear_file[blen] = '\0';

					}

				}

			}

		}

		if (new_entry && !new_entry->info.can_clear) {

			memset(new_entry->clear_file, 0, sizeof(new_entry->clear_file));

		}

		// find end of list

		while (*el)

			el = &(*el)->next;

		// append

		if (new_entry)

			*el = new_entry;

		el = &new_entry->next;

	}

	closedir(dir);

	return n;

}

uint32_t count_error_files(const char *path)

{

	return build_error_list(path, NULL);

}