/*

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

#include <limits.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <unistd.h>

#if _HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#include "block.h"

#include "cntrl.h"

#include "config.h"

#include "config_file.h"

#include "enclosure.h"

#include "ibpi.h"

#include "list.h"

#include "pci_slot.h"

#include "raid.h"

#include "slave.h"

#include "stdio.h"

#include "sysfs.h"

#include "utils.h"

/**

 */

#define SYSFS_CLASS_BLOCK       "/sys/block"

#define SYSFS_CLASS_ENCLOSURE   "/sys/class/enclosure"

#define SYSFS_PCI_DEVICES       "/sys/bus/pci/devices"

#define SYSFS_PCI_SLOTS         "/sys/bus/pci/slots"

/**

 * This is internal variable global to sysfs module only. It is a list of

 * block devices registered in the system. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list sysfs_block_list;

/**

 * This is internal variable global to sysfs module only. It is a list of

 * RAID volumes registered in the system. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list volum_list;

/**

 * This is internal variable global to sysfs module only. It is a list of

 * storage controller devices registered in the system and

 * supported by Intel(R) Enclosure LEDs Control Utility. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list cntrl_list;

/**

 * This is internal variable global to sysfs module only. It is a list of

 * slave devices registered in the system. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list slave_list;

/**

 * This is internal variable global to sysfs module only. It is a list of

 * RAID containers registered in the system. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list cntnr_list;

/**

 * This is internal variable global to sysfs module only. It is a to list of

 * enclosures registered in the system.

 */

static struct list enclo_list;

/**

 * This is internal variable global to sysfs module only. It is a list of

 * PCI slots registered in the system. Use sysfs_init()

 * function to initialize the variable. Use sysfs_scan() function to populate

 * the list. Use sysfs_reset() function to delete the content of the list.

 */

static struct list slots_list;

/**

 * @brief Determine device type.

 *

 * This is internal function of sysfs module. The function determines a type of

 * RAID device either it is VOLUME or CONTAINER device. The information required

 * if read from 'metadata_version' attribute from sysfs. External and native

 * RAID devices are reported as volumes with no distinction between both types.

 *

 * @param[in]      path           Path to RAID device in sysfs tree.

 *

 * @return Type of RAID device if successful, otherwise DEVICE_TYPE_UNKNOWN.

 */

static enum device_type _get_device_type(const char *path)

{

	enum device_type result = DEVICE_TYPE_UNKNOWN;

	char *p = get_text(path, "md/metadata_version");

	if (p != NULL) {

		if (strlen(p) > 0) {

			if (strncmp(p, "external:", 9) == 0) {

				if (p[9] == '/' || p[9] == '-')

					result = DEVICE_TYPE_VOLUME;

				else

					result = DEVICE_TYPE_CONTAINER;

			} else {

				result = DEVICE_TYPE_VOLUME;

			}

		}

		free(p);

	}

	return result;

}

/**

 * @brief Gets device major and minor.

 *

 * This is internal function of sysfs module. The function retrieves major and

 * minor of device from sysfs attribute. Each block device has 'dev' attribute

 * where major and minor separated by colon are stored.

 *

 * @param[in]      path           Path to block device in sysfs tree.

 * @param[in]      d_id           Placeholder where major and minor of device

 *                                will be stored. If this argument is NULL the

 *                                behavior of function is unspecified.

 *

 * @return The function does not return a value.

 */

static void _get_id(const char *path, struct device_id *d_id)

{

	char temp[PATH_MAX];

	snprintf(temp, sizeof(temp), "%s/dev", path);

	get_id(temp, d_id);

}

/**

 * @brief Adds slave device to RAID volume.

 *

 * This is internal function of sysfs module. The function puts slave device on

 * list of slave devices of RAID volume. The memory is allocated and structure

 * fields populated. RAID device is link to slave device.

 *

 * @param[in]      path           Path to 'md' directory of RAID device in sysfs

 *                                tree.

 * @param[in]      raid           Pointer to RAID device structure corresponding

 *                                to 'path' argument.

 *

 * @return The function does not return a value.

 */

static void _slave_vol_add(const char *path, struct raid_device *raid)

{

	struct slave_device *device;

	char *t = strrchr(path, '/');

	if (strncmp(t + 1, "dev-", 4) == 0) {

		device = slave_device_init(path, &sysfs_block_list);

		if (device) {

			device->raid = raid;

			list_append(&slave_list, device);

		}

	}

}

/**

 * @brief Checks for duplicate entries on list of slave devices.

 *

 * This is internal function of sysfs module. The functions checks if the given

 * slave device is already on list with slave devices. This function is used by

 * _slave_cnt_add() function to avoid duplicate entries.

 *

 * @param[in]      slave          Pointer to slave device structure to check.

 *

 * @return 1 the given device is on the list, otherwise the function returns 0.

 */

static int _is_duplicate(struct slave_device *slave)

{

	struct slave_device *device;

	list_for_each(&slave_list, device) {

		if (device->block == slave->block)

			return 1;

	}

	return 0;

}

/**

 * @brief Checks if given disk can be removed from sysfs_block_list if

 * metatada is not present.

 *

 * This is internal function (action) of sysfs module. The slave_list keeps

 * all devices with metadata (raid devices). If disk is not included in slave

 * list there is not metadata on it.

 *

 * @return 1 if can be removed, otherwise 0.

 */

static int _is_non_raid_device(struct block_device *block_device)

{

	struct slave_device *slave_device;

	list_for_each(&slave_list, slave_device) {

		if (strcmp(slave_device->block->sysfs_path,

			   block_device->sysfs_path) == 0)

			return 0;

	}

	return 1;

}

/**

 */

static void _slave_cnt_add(const char *path, struct raid_device *raid)

{

	struct slave_device *device;

	char *t = strrchr(path, '/');

	if (strncmp(t + 1, "dev-", 4) == 0) {

		device = slave_device_init(path, &sysfs_block_list);

		if (device) {

			if (!_is_duplicate(device)) {

				device->raid = raid;

				list_append(&slave_list, device);

			} else {

				slave_device_fini(device);

			}

		}

	}

}

static void _link_raid_device(struct raid_device *device, enum device_type type)

{

	char temp[PATH_MAX];

	struct list dir;

	snprintf(temp, sizeof(temp), "%s/md", device->sysfs_path);

	if (scan_dir(temp, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path) {

			if (type == DEVICE_TYPE_VOLUME)

				_slave_vol_add(dir_path, device);

			else if (type == DEVICE_TYPE_CONTAINER)

				_slave_cnt_add(dir_path, device);

		}

		list_erase(&dir;;

	}

}

/**

 */

static void _block_add(const char *path)

{

	struct block_device *device = block_device_init(&cntrl_list, path);

	if (device)

		list_append(&sysfs_block_list, device);

}

/**

 */

static void _volum_add(const char *path, unsigned int device_num)

{

	struct raid_device *device =

	    raid_device_init(path, device_num, DEVICE_TYPE_VOLUME);

	if (device)

		list_append(&volum_list, device);

}

/**

 */

static void _cntnr_add(const char *path, unsigned int device_num)

{

	struct raid_device *device =

	    raid_device_init(path, device_num, DEVICE_TYPE_CONTAINER);

	if (device)

		list_append(&cntnr_list, device);

}

/**

 */

static void _raid_add(const char *path)

{

	struct device_id device_id;

	_get_id(path, &device_id);

	if (device_id.major == 9) {

		switch (_get_device_type(path)) {

		case DEVICE_TYPE_VOLUME:

			_volum_add(path, device_id.minor);

			break;

		case DEVICE_TYPE_CONTAINER:

			_cntnr_add(path, device_id.minor);

			break;

		case DEVICE_TYPE_UNKNOWN:

			break;

		}

	}

}

/**

 */

static void _cntrl_add(const char *path)

{

	struct cntrl_device *device = cntrl_device_init(path);

	if (device)

		list_append(&cntrl_list, device);

}

/**

 */

static void _enclo_add(const char *path)

{

	struct enclosure_device *device = enclosure_device_init(path);

	if (device)

		list_append(&enclo_list, device);

}

/**

 */

static void _slots_add(const char *path)

{

	struct pci_slot *device = pci_slot_init(path);

	if (device)

		list_append(&slots_list, device);

}

/**

 */

static void _check_raid(const char *path)

{

	char *t = strrchr(path, '/');

	if (strncmp(t + 1, "md", 2) == 0)

		_raid_add(path);

}

/**

 */

static void _check_cntrl(const char *path)

{

	char link[PATH_MAX];

	if (realpath(path, link) != NULL)

		_cntrl_add(link);

}

/**

 */

static void _check_enclo(const char *path)

{

	char link[PATH_MAX];

	if (realpath(path, link) != NULL)

		_enclo_add(link);

}

static void _scan_block(void)

{

	struct list dir;

	if (scan_dir(SYSFS_CLASS_BLOCK, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_block_add(dir_path);

		list_erase(&dir;;

	}

}

static void _scan_raid(void)

{

	struct list dir;

	if (scan_dir(SYSFS_CLASS_BLOCK, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_check_raid(dir_path);

		list_erase(&dir;;

	}

}

static void _scan_cntrl(void)

{

	struct list dir;

	if (scan_dir(SYSFS_PCI_DEVICES, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_check_cntrl(dir_path);

		list_erase(&dir;;

	}

}

static void _scan_slave(void)

{

	struct raid_device *device;

	list_for_each(&volum_list, device)

		_link_raid_device(device, DEVICE_TYPE_VOLUME);

	list_for_each(&cntnr_list, device)

		_link_raid_device(device, DEVICE_TYPE_CONTAINER);

	if (conf.raid_members_only) {

		struct node *node;

		list_for_each_node(&sysfs_block_list, node) {

			if (_is_non_raid_device(node->item))

				list_delete(node);

		}

	}

}

static void _scan_enclo(void)

{

	struct list dir;

	if (scan_dir(SYSFS_CLASS_ENCLOSURE, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_check_enclo(dir_path);

		list_erase(&dir;;

	}

}

static void _scan_slots(void)

{

	struct list dir;

	if (scan_dir(SYSFS_PCI_SLOTS, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_slots_add(dir_path);

		list_erase(&dir;;

	}

}

/**

 */

static int _is_failed_array(struct raid_device *raid)

{

	if (raid->degraded > 0) {

		switch (raid->level) {

		case RAID_LEVEL_1:

		case RAID_LEVEL_10:

			return (raid->degraded == raid->raid_disks);

		case RAID_LEVEL_4:

		case RAID_LEVEL_5:

			return (raid->degraded > 1);

		case RAID_LEVEL_6:

			return (raid->degraded > 2);

		case RAID_LEVEL_LINEAR:

		case RAID_LEVEL_UNKNOWN:

		case RAID_LEVEL_0:

			break;

		case RAID_LEVEL_FAULTY:

			return 1;

		}

	}

	return -1;

}

/**

 */

static void _set_block_state(struct block_device *block, enum ibpi_pattern ibpi)

{

	char *debug_dev = strrchr(block->sysfs_path, '/');

	debug_dev = debug_dev ? debug_dev + 1 : block->sysfs_path;

	log_debug("(%s): device: %s, state: %s", __func__, debug_dev,

		  ibpi2str(ibpi));

	if (block->ibpi < ibpi)

		block->ibpi = ibpi;

}

/**

 */

static void _set_array_state(struct raid_device *raid,

			     struct block_device *block)

{

	switch (raid->sync_action) {

	case RAID_ACTION_UNKNOWN:

	case RAID_ACTION_IDLE:

	case RAID_ACTION_FROZEN:

		_set_block_state(block, IBPI_PATTERN_NORMAL);

		break;

	case RAID_ACTION_RESHAPE:

		if (conf.blink_on_migration)

			_set_block_state(block, IBPI_PATTERN_REBUILD);

		break;

	case RAID_ACTION_CHECK:

	case RAID_ACTION_RESYNC:

	case RAID_ACTION_REPAIR:

		if (conf.blink_on_init)

			_set_block_state(block, IBPI_PATTERN_REBUILD);

		break;

	case RAID_ACTION_RECOVER:

		if (conf.rebuild_blink_on_all)

			_set_block_state(block, IBPI_PATTERN_REBUILD);

		break;

	}

}

/**

 */

static void _determine(struct slave_device *device)

{

	if (!device->block->raid_dev ||

	     (device->block->raid_dev->type == DEVICE_TYPE_CONTAINER &&

	      device->raid->type == DEVICE_TYPE_VOLUME)) {

		raid_device_fini(device->block->raid_dev);

		device->block->raid_dev = raid_device_duplicate(device->raid);

	}

	if ((device->state & SLAVE_STATE_FAULTY) != 0) {

		_set_block_state(device->block, IBPI_PATTERN_FAILED_DRIVE);

	} else if ((device->

	     state & (SLAVE_STATE_BLOCKED | SLAVE_STATE_WRITE_MOSTLY)) != 0) {

		_set_block_state(device->block, IBPI_PATTERN_NORMAL);

	} else if ((device->state & SLAVE_STATE_SPARE) != 0) {

		if (_is_failed_array(device->raid) == 0) {

			if (device->raid->sync_action != RAID_ACTION_RESHAPE ||

			    conf.blink_on_migration == 1)

				_set_block_state(device->block,

						 IBPI_PATTERN_REBUILD);

		} else {

			_set_block_state(device->block, IBPI_PATTERN_HOTSPARE);

		}

	} else if ((device->state & SLAVE_STATE_IN_SYNC) != 0) {

		switch (_is_failed_array(device->raid)) {

		case 0:

			_set_block_state(device->block, IBPI_PATTERN_DEGRADED);

			break;

		case 1:

			_set_block_state(device->block,

					 IBPI_PATTERN_FAILED_ARRAY);

			break;

		}

		_set_array_state(device->raid, device->block);

	}

}

static void _determine_slaves(struct list *local_slave_list)

{

	struct slave_device *device;

	list_for_each(local_slave_list, device)

		_determine(device);

}

void sysfs_init(void)

{

	list_init(&sysfs_block_list, (item_free_t)block_device_fini);

	list_init(&volum_list, (item_free_t)raid_device_fini);

	list_init(&cntrl_list, (item_free_t)cntrl_device_fini);

	list_init(&slave_list, (item_free_t)slave_device_fini);

	list_init(&cntnr_list, (item_free_t)raid_device_fini);

	list_init(&enclo_list, (item_free_t)enclosure_device_fini);

	list_init(&slots_list, (item_free_t)pci_slot_fini);

}

void sysfs_reset(void)

{

	list_erase(&sysfs_block_list);

	list_erase(&volum_list);

	list_erase(&cntrl_list);

	list_erase(&slave_list);

	list_erase(&cntnr_list);

	list_erase(&enclo_list);

	list_erase(&slots_list);

}

void sysfs_scan(void)

{

	_scan_enclo();

	_scan_cntrl();

	_scan_slots();

	_scan_block();

	_scan_raid();

	_scan_slave();

	_determine_slaves(&slave_list);

}

/*

 * The function reutrns list of enclosure devices attached to SAS/SCSI storage

 * controller(s).

 */

const struct list *sysfs_get_enclosure_devices(void)

{

	return &enclo_list;

}

/*

 * The function returns list of controller devices present in the system.

 */

const struct list *sysfs_get_cntrl_devices(void)

{

	return &cntrl_list;

}

/*

 * The function returns list of RAID volumes present in the system.

 */

const struct list *sysfs_get_volumes(void)

{

	return &volum_list;

}

const struct list *sysfs_get_block_devices(void)

{

	return &sysfs_block_list;

}

const struct list *sysfs_get_pci_slots(void)

{

	return &slots_list;

}

/*

 * The function checks if the given storage controller has enclosure device(s)

 * attached.

 */

int sysfs_enclosure_attached_to_cntrl(const char *path)

{

	struct enclosure_device *device;

	list_for_each(&enclo_list, device) {

		if ((device->sysfs_path != NULL) &&

		    (strncmp(device->sysfs_path, path, strlen(path)) == 0))

			return 1;

	}

	return 0;

}

/*

 * This function checks driver type.

 */

int sysfs_check_driver(const char *path, const char *driver)

{

	char buf[PATH_MAX];

	char driver_path[PATH_MAX];

	char *link;

	int found = 0;

	snprintf(buf, sizeof(buf), "%s/driver", path);

	snprintf(driver_path, sizeof(driver_path), "/%s", driver);

	link = realpath(buf, NULL);

	if (link && strstr(link, driver_path))

		found = 1;

	free(link);

	return found;

}