/*
 * Intel(R) Enclosure LED Utilities
 * Copyright (C) 2009-2019 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#if _HAVE_DMALLOC_H
#include <dmalloc.h>
#endif

#include <scsi/sg_lib.h>
#include <scsi/sg_cmds_extra.h>

#include "cntrl.h"
#include "config.h"
#include "enclosure.h"
#include "list.h"
#include "scsi.h"
#include "ses.h"
#include "status.h"
#include "sysfs.h"
#include "utils.h"

static int debug = 0;

static int get_ses_page(int fd, struct ses_page *p, int pg_code)
{
	int ret;
	int retry_count = 3;

	do {
		ret = sg_ll_receive_diag(fd, 1, pg_code, p->buf, sizeof(p->buf),
					 0, debug);
	} while (ret && retry_count--);

	if (!ret)
		p->len = (p->buf[2] << 8) + p->buf[3] + 4;
	return ret;
}

static int process_page1(struct ses_pages *sp)
{
	int num_encl;		/* number of subenclosures */
	unsigned char *ed;	/* Enclosure Descriptor */
	int len = 0;
	int sum_headers = 0;	/* Number of Type descriptor headers */
	int i = 0;

	/* How many enclosures is in the main enclosure? */
	num_encl = sp->page1->buf[1] + 1;
	/* Go to Enclosure Descriptor */
	ed = sp->page1->buf + 8;
	for (i = 0; i < num_encl; i++, ed += len) {
		if (ed + 3 > sp->page1->buf + sp->page1->len) {
			log_debug
			    ("SES: Error, response pare 1 truncated at %d\n",
			     i);
			return 1;
		}
		sum_headers += ed[2];
		len = ed[3] + 4;
		if (len < 40) {
			log_debug("SES: Response too short for page 1\n");
			continue;
		}
	}

	sp->page1_types = (struct type_descriptor_header *)ed;
	sp->page1_types_len = sum_headers;

	/* ed is on type descr header */
	for (i = 0; i < sum_headers; i++, ed += 4) {
		if (ed > sp->page1->buf + sp->page1->len) {
			log_debug("SES: Response page 1 truncated at %d\n", i);
			return 1;
		}
	}
	return 0;
}

static struct ses_pages *ses_init(void)
{
	struct ses_pages *sp;
	sp = calloc(1, sizeof(*sp));
	if (!sp)
		return NULL;
	sp->page1 = calloc(1, sizeof(struct ses_page));
	if (!sp->page1)
		goto sp1;
	sp->page2 = calloc(1, sizeof(struct ses_page));
	if (!sp->page2)
		goto sp2;
	return sp;
 sp2:
	free(sp->page1);
 sp1:
	free(sp);
	return NULL;
}

static void ses_free(struct ses_pages *sp)
{
	if (!sp)
		return;
	free(sp->page1);
	free(sp->page2);
	free(sp->page10);
	free(sp);
}

static void dump_p10(unsigned char *p)
{
	int i;
	printf("----------------------------------------------\n");
	for (i = 0; i < 8; i++, p += 16) {
		printf("%p: %02x %02x %02x %02x %02x %02x %02x " \
		       "%02x %02x %02x %02x %02x %02x %02x %02x %02x\n", (void *)p,
		       p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
		       p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
	}
}

static int enclosure_open(const struct enclosure_device *enclosure)
{
	int fd = -1;

	if (enclosure->dev_path)
		fd = open(enclosure->dev_path, O_RDWR);

	return fd;
}

static int enclosure_load_pages(struct enclosure_device *enclosure)
{
	int ret;
	int fd;
	struct ses_pages *sp;

	if (enclosure->ses_pages)
		return 0;

	fd = enclosure_open(enclosure);
	if (fd == -1)
		return 1;

	sp = ses_init();
	if (!sp) {
		ret = 1;
		goto end;
	}

	/* Read configuration. */
	ret = get_ses_page(fd, sp->page1, ENCL_CFG_DIAG_STATUS);
	if (ret)
		goto end;

	ret = process_page1(sp);
	if (ret)
		goto end;

	/* Get Enclosure Status */
	ret = get_ses_page(fd, sp->page2, ENCL_CTRL_DIAG_STATUS);
end:
	close(fd);
	if (ret)
		ses_free(sp);
	else
		enclosure->ses_pages = sp;
	return ret;
}

static int enclosure_load_page10(struct enclosure_device *enclosure)
{
	int ret;
	int fd;
	struct ses_page *p;

	if (enclosure->ses_pages && enclosure->ses_pages->page10)
		return 0;

	ret = enclosure_load_pages(enclosure);
	if (ret)
		return ret;

	fd = enclosure_open(enclosure);
	if (fd == -1)
		return 1;

	p = calloc(1, sizeof(struct ses_page));
	if (!p) {
		ret = 1;
		goto end;
	}

	/* Additional Element Status */
	ret = get_ses_page(fd, p, ENCL_ADDITIONAL_EL_STATUS);
end:
	close(fd);
	if (ret)
		free(p);
	else
		enclosure->ses_pages->page10 = p;

	return ret;
}

static void enclosure_free_pages(struct enclosure_device *enclosure)
{
	ses_free(enclosure->ses_pages);
	enclosure->ses_pages = NULL;
}

static void print_page10(struct ses_pages *sp)
{
	unsigned char *ai = sp->page10->buf + 8;
	int i = 0, len = 0, eip = 0;
	unsigned char *sas = NULL;

	while (ai < sp->page10->buf + sp->page10->len) {
		printf("%s()[%d]: Inv: %d, EIP: %d, Proto: 0x%04x\n", __func__,
		       i++, ((ai[0] & 0x80) >> 7), ((ai[0] & 0x10) >> 4),
		       (unsigned int) (ai[0] & 0xf));
		printf("\tDescriptor len (x-1): %d\n", ai[1] + 1);
		eip = ai[0] & 0x10;
		if (eip)
			printf("\tElement Index: %d\n", ai[3]);
		len = ai[1] + 2;
		if ((ai[0] & 0xf) == SCSI_PROTOCOL_SAS) {
			if (eip)
				sas = ai + 4;
			else
				sas = ai + 2;
			printf("\tProtocol SAS:\n");
			printf("\tNumber of phy descriptors: %d\n", sas[0]);
			printf("\tNot all phys: %d, descriptor type: 0x%1x\n",
			       (sas[1] & 1), ((sas[1] & 0xc0) >> 6));
			if (eip) {
				printf("\tDevice slot number: %d\n", sas[3]);
				sas += 2;
			}
			sas += 2;
			printf("\tDevice type: 0x%01x\n",
				(unsigned int)((sas[0] & 0x70) >> 4));
			printf("\tSMP Initiator Port: 0x%01x\n",
				(unsigned int)((sas[2] & 2) >> 1));
			printf("\tSTP Initiator Port: 0x%01x\n",
				(unsigned int)((sas[2] & 4) >> 2));
			printf("\tSSP Initiator Port: 0x%01x\n",
				(unsigned int)((sas[2] & 8) >> 3));
			printf("\tSATA DEVICE: 0x%01x\n",
				(unsigned int)(sas[3] & 1));
			printf("\tSMP Target Port: 0x%01x\n",
				(unsigned int)((sas[3] & 2) >> 1));
			printf("\tSTP Target Port: 0x%01x\n",
				(unsigned int)((sas[3] & 4) >> 2));
			printf("\tSSP Target Port: 0x%01x\n",
				(unsigned int)((sas[3] & 8) >> 3));
			printf("\tSATA Port Selector: 0x%01x\n",
				(unsigned int)((sas[3] & 0X80) >> 7));
			printf
			    ("\tAttached SAS Address: 0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
			     sas[4], sas[5], sas[6], sas[7], sas[8], sas[9],
			     sas[10], sas[11]);
			printf
			    ("\tSAS Address: 0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
			     sas[12], sas[13], sas[14], sas[15], sas[16],
			     sas[17], sas[18], sas[19]);
			printf("\tPHY Identified: 0x%01x\n", sas[20]);
		} else
			printf("\tProtocol not SAS: 0x%02x, skipping\n",
				(unsigned int)(ai[0] & 0xf));
		/* */
		ai += len;
	}
	return;
}

static enum ibpi_pattern ibpi_to_ses(enum ibpi_pattern ibpi)
{
	switch (ibpi) {
	case IBPI_PATTERN_UNKNOWN:
	case IBPI_PATTERN_ONESHOT_NORMAL:
	case IBPI_PATTERN_NORMAL:
		return SES_REQ_OK;
	case IBPI_PATTERN_FAILED_ARRAY:
		return SES_REQ_IFA;
	case IBPI_PATTERN_DEGRADED:
		return SES_REQ_ICA;
	case IBPI_PATTERN_REBUILD:
		return SES_REQ_REBUILD;
	case IBPI_PATTERN_FAILED_DRIVE:
		return SES_REQ_FAULT;
	case IBPI_PATTERN_LOCATE:
		return SES_REQ_IDENT;
	case IBPI_PATTERN_HOTSPARE:
		return SES_REQ_HOSTSPARE;
	case IBPI_PATTERN_PFA:
		return SES_REQ_PRDFAIL;
	default:
		return ibpi;
	}
}

static int ses_set_message(enum ibpi_pattern ibpi, struct ses_slot_ctrl_elem *el)
{
	struct ses_slot_ctrl_elem msg;

	memset(&msg, 0, sizeof(msg));
	if (ibpi == IBPI_PATTERN_LOCATE_OFF) {
		/*
		 * For locate_off we don't set a new state, just clear the
		 * IDENT bit and the bits that are reserved or have different
		 * meanings in Status and Control pages (RQST ACTIVE and
		 * RQST MISSING).
		 */
		_clr_ident(el->b);
		el->b2 &= 0x4e;
		el->b3 &= 0x3c;
		return 0;
	}

	switch (ibpi_to_ses(ibpi)) {
	case SES_REQ_ABORT:
		_set_abrt(msg.b);
		break;
	case SES_REQ_REBUILD:
		_set_rebuild(msg.b);
		break;
	case SES_REQ_IFA:
		_set_ifa(msg.b);
		break;
	case SES_REQ_ICA:
		_set_ica(msg.b);
		break;
	case SES_REQ_CONS_CHECK:
		_set_cons_check(msg.b);
		break;
	case SES_REQ_HOSTSPARE:
		_set_hspare(msg.b);
		break;
	case SES_REQ_RSVD_DEV:
		_set_rsvd_dev(msg.b);
		break;
	case SES_REQ_OK:
		_set_ok(msg.b);
		break;
	case SES_REQ_IDENT:
		_set_ident(msg.b);
		break;
	case SES_REQ_RM:
		_set_rm(msg.b);
		break;
	case SES_REQ_INS:
		_set_ins(msg.b);
		break;
	case SES_REQ_MISSING:
		_set_miss(msg.b);
		break;
	case SES_REQ_DNR:
		_set_dnr(msg.b);
		break;
	case SES_REQ_ACTIVE:
		_set_actv(msg.b);
		break;
	case SES_REQ_EN_BB:
		_set_enbb(msg.b);
		break;
	case SES_REQ_EN_BA:
		_set_enba(msg.b);
		break;
	case SES_REQ_DEV_OFF:
		_set_off(msg.b);
		break;
	case SES_REQ_FAULT:
		_set_fault(msg.b);
		break;
	case SES_REQ_PRDFAIL:
		_set_prdfail(msg.b);
		break;
	default:
		return 1;
	}

	*el = msg;

	return 0;
}

static int ses_write_msg(enum ibpi_pattern ibpi, struct block_device *device)
{
	struct ses_pages *sp = device->enclosure->ses_pages;
	int idx = device->encl_index;
	/* Move do descriptors */
	struct ses_slot_ctrl_elem *descriptors = (void *)(sp->page2->buf + 8);
	int i;
	struct ses_slot_ctrl_elem *desc_element = NULL;
	element_type local_element_type = SES_UNSPECIFIED;

	for (i = 0; i < sp->page1_types_len; i++) {
		struct type_descriptor_header *t = &sp->page1_types[i];

		descriptors++; /* At first, skip overall header. */

		if (t->element_type == SES_DEVICE_SLOT ||
		    t->element_type == SES_ARRAY_DEVICE_SLOT) {
			if (local_element_type < t->element_type &&
			    t->num_of_elements > idx) {
				local_element_type = t->element_type;
				desc_element = &descriptors[idx];
			}
		} else {
			/*
			 * Device Slot and Array Device Slot elements are
			 * always first on the type descriptor header list
			 */
			break;
		}

		descriptors += t->num_of_elements;
	}

	if (desc_element) {
		int ret = ses_set_message(ibpi, desc_element);
		if (ret)
			return ret;
		/* keep PRDFAIL, clear rest */
		desc_element->common_control &= 0x40;
		/* set select */
		desc_element->common_control |= 0x80;

		/* second byte is valid only for Array Device Slot */
		if (local_element_type != SES_ARRAY_DEVICE_SLOT)
			desc_element->array_slot_control = 0;

		return 0;
	}

	return 1;
}

static int ses_send_diag(struct enclosure_device *enclosure)
{
	int ret;
	int fd;

	fd = enclosure_open(enclosure);
	if (fd == -1)
		return 1;

	ret = sg_ll_send_diag(fd, 0, 1, 0, 0, 0, 0,
			      enclosure->ses_pages->page2->buf,
			      enclosure->ses_pages->page2->len,
			      0, debug);
	close(fd);
	return ret;
}

static char *get_drive_end_dev(const char *path)
{
	char *s, *c, *p;

	c = strstr(path, "end_device");
	if (!c)
		return NULL;
	s = strchr(c, '/');
	if (!s)
		return NULL;
	p = calloc(s - c + 1, sizeof(*p));
	if (!p)
		return NULL;

	strncpy(p, c, s - c);
	return p;
}

static uint64_t get_drive_sas_addr(const char *path)
{
	uint64_t ret = 0;
	size_t size = strlen(path) * 2;
	char *buff, *end_dev;

	/* Make big buffer. */
	buff = malloc(size + 1);
	if (!buff)
		return ret;

	end_dev = get_drive_end_dev(path);
	if (!end_dev) {
		free(buff);
		return ret;
	}

	snprintf(buff, size, "/sys/class/sas_end_device/%s/device/sas_device/%s",
		 end_dev, end_dev);

	ret = get_uint64(buff, ret, "sas_address");

	free(end_dev);
	free(buff);

	return ret;
}

static int get_encl_slot(struct block_device *device)
{
	struct ses_pages *sp;
	unsigned char *add_desc = NULL;
	unsigned char *ap = NULL, *addr_p = NULL;
	int i, j, len = 0;
	uint64_t addr, addr_cmp;
	int idx;

	/* try to get slot from sysfs */
	idx = get_int(device->cntrl_path, -1, "slot");
	if (idx != -1)
		return idx;

	/*
	 * Older kernels may not have the "slot" sysfs attribute,
	 * fallback to Page10 method.
	 */
	if (enclosure_load_page10(device->enclosure))
		return -1;
	sp = device->enclosure->ses_pages;

	addr = get_drive_sas_addr(device->sysfs_path);
	if (!addr)
		return -1;

	if (debug)
		print_page10(sp);

	/* Check Page10 for address. Extract index. */
	ap = add_desc = sp->page10->buf + 8;
	for (i = 0; i < sp->page1_types_len; i++) {
		struct type_descriptor_header *t = &sp->page1_types[i];

		if (t->element_type == SES_DEVICE_SLOT ||
		    t->element_type == SES_ARRAY_DEVICE_SLOT) {
			for (j = 0; j < t->num_of_elements; j++, ap += len) {
				if (debug)
					dump_p10(ap);
				/* Get Additional Element Status Descriptor */
				/* length (x-1) */
				len = ap[1] + 2;
				if ((ap[0] & 0xf) != SCSI_PROTOCOL_SAS)
					continue;	/* need SAS PROTO */
				/* It is a SAS protocol, go on */
				if ((ap[0] & 0x10))	/* Check EIP */
					addr_p = ap + 8;
				else
					addr_p = ap + 4;
				/* Process only PHY 0 descriptor. */

				/* Convert be64 to le64 */
				addr_cmp = ((uint64_t)addr_p[12] << 8*7) |
					   ((uint64_t)addr_p[13] << 8*6) |
					   ((uint64_t)addr_p[14] << 8*5) |
					   ((uint64_t)addr_p[15] << 8*4) |
					   ((uint64_t)addr_p[16] << 8*3) |
					   ((uint64_t)addr_p[17] << 8*2) |
					   ((uint64_t)addr_p[18] << 8*1) |
					   ((uint64_t)addr_p[19]);

				if (addr == addr_cmp) {
					idx = ap[0] & 0x10 ? ap[3] : j;
					return idx;
				}
			}
		} else {
			/*
			 * Device Slot and Array Device Slot elements are
			 * always first on the type descriptor header list
			 */
			break;
		}
	}
	return -1;
}

/**
 */
static int _slot_match(const char *slot_path, const char *device_path)
{
	char temp[PATH_MAX], link[PATH_MAX];

	snprintf(temp, sizeof(temp), "%s/device", slot_path);

	if (realpath(temp, link) == NULL)
		return 0;

	return strncmp(link, device_path, strlen(link)) == 0;
}

/**
 */
static char *_slot_find(const char *enclo_path, const char *device_path)
{
	struct list dir;
	char *temp, *result = NULL;

	if (scan_dir(enclo_path, &dir) == 0) {
		list_for_each(&dir, temp) {
			if (_slot_match(temp, device_path)) {
				result = str_dup(temp);
				break;
			}
		}
		list_erase(&dir);
	}
	return result;
}

int scsi_get_enclosure(struct block_device *device)
{
	struct enclosure_device *encl;

	if (!device || !device->sysfs_path)
		return 0;

	list_for_each(sysfs_get_enclosure_devices(), encl) {
		if (_slot_match(encl->sysfs_path, device->cntrl_path)) {
			device->enclosure = encl;
			device->encl_index = get_encl_slot(device);
			break;
		}
	}

	return (device->enclosure != NULL && device->encl_index != -1);
}

/**
 */
int scsi_ses_write(struct block_device *device, enum ibpi_pattern ibpi)
{
	int ret;

	if (!device || !device->sysfs_path || !device->enclosure ||
	    device->encl_index == -1)
		__set_errno_and_return(EINVAL);

	/* write only if state has changed */
	if (ibpi == device->ibpi_prev)
		return 1;

	if ((ibpi < IBPI_PATTERN_NORMAL) || (ibpi > SES_REQ_FAULT))
		__set_errno_and_return(ERANGE);

	ret = enclosure_load_pages(device->enclosure);
	if (ret) {
		log_warning
		    ("Unable to send %s message to %s. Device is missing?",
		     ibpi2str(ibpi), strstr(device->sysfs_path, "host"));
		return ret;
	}

	return ses_write_msg(ibpi, device);
}

int scsi_ses_flush(struct block_device *device)
{
	int ret;

	if (!device || !device->enclosure)
		return 1;

	if (!device->enclosure->ses_pages)
		return 0;

	ret = ses_send_diag(device->enclosure);

	enclosure_free_pages(device->enclosure);
	return ret;
}

/**
 * @brief Gets a path to slot of sas controller.
 *
 * This function returns a sysfs path to component of enclosure the device
 * belongs to.
 *
 * @param[in]      path           Canonical sysfs path to block device.
 *
 * @return A sysfs path to controller device associated with the given
 *         block device if successful, otherwise NULL pointer.
 */
static char *sas_get_slot_path(const char *path, const char *ctrl_path)
{
	char *host;
	char host_path[PATH_MAX] = { 0 };
	size_t ctrl_path_len = strlen(ctrl_path);

	if (strncmp(path, ctrl_path, ctrl_path_len) != 0)
		return NULL;
	host = get_path_hostN(path);
	if (host) {
		snprintf(host_path, sizeof(host_path), "%s/%s/bsg/sas_%s",
			 ctrl_path, host, host);
		free(host);
	}
	return str_dup(host_path);
}

/**
 */
static char *_get_enc_slot_path(const char *path)
{
	struct enclosure_device *device;
	char *result = NULL;

	list_for_each(sysfs_get_enclosure_devices(), device) {
		result = _slot_find(device->sysfs_path, path);
		if (result != NULL)
			break;
	}
	return result;
}

/**
 */
char *scsi_get_slot_path(const char *path, const char *ctrl_path)
{
	char *result = NULL;

	result = _get_enc_slot_path(path);
	if (!result)
		result = sas_get_slot_path(path, ctrl_path);
	return result;
}