/*

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

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#if _HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#include "block.h"

#include "config.h"

#include "ibpi.h"

#include "list.h"

#include "raid.h"

#include "slave.h"

#include "status.h"

#include "sysfs.h"

#include "utils.h"

/**

 */

static enum raid_state _get_array_state(const char *path)

{

	enum raid_state state = RAID_STATE_UNKNOWN;

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

	if (p) {

		if (strcmp(p, "clear") == 0)

			state = RAID_STATE_CLEAR;

		else if (strcmp(p, "inactive") == 0)

			state = RAID_STATE_INACTIVE;

		else if (strcmp(p, "suspended") == 0)

			state = RAID_STATE_SUSPENDED;

		else if (strcmp(p, "readonly") == 0)

			state = RAID_STATE_READONLY;

		else if (strcmp(p, "read-auto") == 0)

			state = RAID_STATE_READ_AUTO;

		else if (strcmp(p, "clean") == 0)

			state = RAID_STATE_CLEAN;

		else if (strcmp(p, "active") == 0)

			state = RAID_STATE_ACTIVE;

		else if (strcmp(p, "write-pending") == 0)

			state = RAID_STATE_WRITE_PENDING;

		else if (strcmp(p, "active-idle") == 0)

			state = RAID_STATE_ACTIVE_IDLE;

		free(p);

	}

	return state;

}

/**

 */

static enum raid_action _get_sync_action(const char *path)

{

	enum raid_action action = RAID_ACTION_UNKNOWN;

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

	if (p) {

		if (strcmp(p, "idle") == 0)

			action = RAID_ACTION_IDLE;

		else if (strcmp(p, "reshape") == 0)

			action = RAID_ACTION_RESHAPE;

		else if (strcmp(p, "frozen") == 0)

			action = RAID_ACTION_FROZEN;

		else if (strcmp(p, "resync") == 0)

			action = RAID_ACTION_RESYNC;

		else if (strcmp(p, "check") == 0)

			action = RAID_ACTION_CHECK;

		else if (strcmp(p, "recover") == 0)

			action = RAID_ACTION_RECOVER;

		else if (strcmp(p, "repair") == 0)

			action = RAID_ACTION_REPAIR;

		free(p);

	}

	return action;

}

/**

 */

static enum raid_level _get_level(const char *path)

{

	enum raid_level result = RAID_LEVEL_UNKNOWN;

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

	if (p) {

		if (strcmp(p, "raid0") == 0)

			result = RAID_LEVEL_0;

		else if (strcmp(p, "raid1") == 0)

			result = RAID_LEVEL_1;

		else if (strcmp(p, "raid10") == 0)

			result = RAID_LEVEL_10;

		else if (strcmp(p, "raid4") == 0)

			result = RAID_LEVEL_4;

		else if (strcmp(p, "raid5") == 0)

			result = RAID_LEVEL_5;

		else if (strcmp(p, "raid6") == 0)

			result = RAID_LEVEL_6;

		else if (strcmp(p, "linear") == 0)

			result = RAID_LEVEL_LINEAR;

		else if (strcmp(p, "faulty") == 0)

			result = RAID_LEVEL_FAULTY;

		free(p);

	}

	return result;

}

/**

 */

struct raid_device *raid_device_init(const char *path, unsigned int device_num,

				     enum device_type type)

{

	struct raid_device *device = NULL;

	enum raid_state state;

	const char *debug_dev;

	state = _get_array_state(path);

	if (state > RAID_STATE_INACTIVE ||

	    (type == DEVICE_TYPE_CONTAINER && state > RAID_STATE_CLEAR)) {

		device = malloc(sizeof(struct raid_device));

		if (device) {

			device->sysfs_path = str_dup(path);

			device->device_num = device_num;

			device->sync_action = _get_sync_action(path);

			device->array_state = state;

			device->level = _get_level(path);

			device->degraded = get_int(path, -1, "md/degraded");

			device->raid_disks = get_int(path, 0, "md/raid_disks");

			device->type = type;

			debug_dev = strrchr(path, '/');

			debug_dev = debug_dev ? debug_dev + 1 : path;

			log_debug("(%s) path: %s, level=%d, state=%d, " \

					"degraded=%d, disks=%d, type=%d",

					__func__, debug_dev, device->level,

						state, device->degraded,

						device->raid_disks, type);

		}

	}

	return device;

}

/**

 */

void raid_device_fini(struct raid_device *device)

{

	if (device) {

		if (device->sysfs_path)

			free(device->sysfs_path);

		free(device);

	}

}

/**

 */

struct raid_device *raid_device_duplicate(struct raid_device *device)

{

	struct raid_device *new_device = NULL;

	if (device) {

		new_device = malloc(sizeof(struct raid_device));

		if (new_device) {

			*new_device = *device;

			new_device->sysfs_path = str_dup(device->sysfs_path);

		}

	}

	return new_device;

}

/**

 */

struct raid_device *find_raid_device(const struct list *raid_list,

				     char *raid_sysfs_path)

{

	struct raid_device *raid = NULL;

	list_for_each(raid_list, raid) {

		if (strcmp(raid->sysfs_path, raid_sysfs_path) == 0)

			return raid;

	}

	return NULL;

}