/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * ISCSID --

 *

 * Discovery of targets and access to the persistent storage starts here.

 */

#include <sys/thread.h>

#include <sys/types.h>

#include <sys/proc.h>		/* declares:    p0 */

#include <sys/cmn_err.h>

#include <sys/scsi/adapters/iscsi_if.h>

#include <netinet/in.h>

#include "iscsi_targetparam.h"

#include "isns_client.h"

#include "isns_protocol.h"

#include "persistent.h"

#include "iscsi.h"

#include <sys/ethernet.h>

#include <sys/bootprops.h>

/*

 * local function prototypes

 */

static boolean_t iscsid_init_config(iscsi_hba_t *ihp);

static boolean_t iscsid_init_targets(iscsi_hba_t *ihp);

static void iscsid_thread_static(iscsi_thread_t *thread, void *p);

static void iscsid_thread_sendtgts(iscsi_thread_t *thread, void *p);

static void iscsid_thread_isns(iscsi_thread_t *thread, void *p);

static void iscsid_thread_slp(iscsi_thread_t *thread, void *p);

static void iscsid_thread_boot_wd(iscsi_thread_t *thread, void *p);

static void iscsid_threads_create(iscsi_hba_t *ihp);

static void iscsid_threads_destroy(void);

static int iscsid_copyto_param_set(uint32_t param_id,

    iscsi_login_params_t *params, iscsi_param_set_t *ipsp);

static void iscsid_add_pg_list_to_cache(iscsi_hba_t *ihp,

    isns_portal_group_list_t *pg_list);

static void iscsid_set_default_initiator_node_settings(iscsi_hba_t *ihp);

static void iscsid_remove_target_param(char *name);

static boolean_t iscsid_add(iscsi_hba_t *ihp, iSCSIDiscoveryMethod_t method,

    struct sockaddr *addr_dsc, char *target_name, int tpgt,

    struct sockaddr *addr_tgt);

static void iscsi_discovery_event(iscsi_hba_t *ihp,

    iSCSIDiscoveryMethod_t m, boolean_t start);

static void iscsi_send_sysevent(iscsi_hba_t *ihp,

    char *subclass, nvlist_t *np);

static boolean_t iscsid_boot_init_config(iscsi_hba_t *ihp);

static iscsi_sess_t *iscsi_add_boot_sess(iscsi_hba_t *ihp, int isid);

static boolean_t iscsid_make_entry(ib_boot_prop_t *boot_prop_entry,

    entry_t *entry);

extern int modrootloaded;

int iscsi_configroot_retry = 20;

static boolean_t iscsi_configroot_printed = FALSE;

extern ib_boot_prop_t   *iscsiboot_prop;

/*

 * iSCSI target discovery thread table

 */

typedef struct iscsid_thr_table {

	void			(*func_start)(iscsi_thread_t *, void *);

	iscsi_thread_t		*thr_id;

	iSCSIDiscoveryMethod_t	method;

	char			*name;

} iscsid_thr_table;

static iscsid_thr_table iscsid_thr[] = {

	{ iscsid_thread_static, NULL,

	    iSCSIDiscoveryMethodStatic,

	    "Static" },

	{ iscsid_thread_sendtgts, NULL,

	    iSCSIDiscoveryMethodSendTargets,

	    "SendTarget" },

	{ iscsid_thread_slp, NULL,

	    iSCSIDiscoveryMethodSLP,

	    "SLP" },

	{ iscsid_thread_isns, NULL,

	    iSCSIDiscoveryMethodISNS,

	    "iSNS" },

	{ NULL, NULL,

	    iSCSIDiscoveryMethodUnknown,

	    NULL }

};

/*

 * discovery method event table

 */

iSCSIDiscoveryMethod_t	for_failure[] = {

	iSCSIDiscoveryMethodStatic,

	iSCSIDiscoveryMethodSLP,

	iSCSIDiscoveryMethodISNS,

	iSCSIDiscoveryMethodSendTargets,

	iSCSIDiscoveryMethodUnknown /* terminating value */

};

/*

 * The following private tunable, set in /etc/system, e.g.,

 *      set iscsi:iscsi_boot_max_delay = 360

 * , provides with customer a max wait time in

 * seconds to wait for boot lun online during iscsi boot.

 * Defaults to 180s.

 */

int iscsi_boot_max_delay = ISCSI_BOOT_DEFAULT_MAX_DELAY;

/*

 * discovery configuration semaphore

 */

ksema_t iscsid_config_semaphore;

static iscsi_thread_t	*iscsi_boot_wd_handle = NULL;

#define	CHECK_METHOD(v) ((dm & v) ? B_TRUE : B_FALSE)

/*

 * Check if IP is valid

 */

static boolean_t

iscsid_ip_check(char *ip)

{

	int	i	= 0;

	if (!ip)

		return (B_FALSE);

	for (; (ip[i] == 0) && (i < IB_IP_BUFLEN); i++) {}

	if (i == IB_IP_BUFLEN) {

		/* invalid IP address */

		return (B_FALSE);

	}

	return (B_TRUE);

}

/*

 * Make an entry for the boot target.

 * return B_TRUE upon success

 *        B_FALSE if fail

 */

static boolean_t

iscsid_make_entry(ib_boot_prop_t *boot_prop_entry, entry_t *entry)

{

	if (entry == NULL || boot_prop_entry == NULL) {

		return (B_FALSE);

	}

	if (!iscsid_ip_check(

	    (char *)&boot_prop_entry->boot_tgt.tgt_ip_u))

		return (B_FALSE);

	if (boot_prop_entry->boot_tgt.sin_family != AF_INET &&

	    boot_prop_entry->boot_tgt.sin_family != AF_INET6)

		return (B_FALSE);

	entry->e_vers = ISCSI_INTERFACE_VERSION;

	mutex_enter(&iscsi_oid_mutex);

	entry->e_oid = iscsi_oid++;

	mutex_exit(&iscsi_oid_mutex);

	entry->e_tpgt = ISCSI_DEFAULT_TPGT;

	if (boot_prop_entry->boot_tgt.sin_family == AF_INET) {

		entry->e_u.u_in4.s_addr =

		    boot_prop_entry->boot_tgt.tgt_ip_u.u_in4.s_addr;

		entry->e_insize = sizeof (struct in_addr);

	} else {

		(void) bcopy(

		    &boot_prop_entry->boot_tgt.tgt_ip_u.u_in6.s6_addr,

		    entry->e_u.u_in6.s6_addr, 16);

		entry->e_insize = sizeof (struct in6_addr);

	}

	entry->e_port = boot_prop_entry->boot_tgt.tgt_port;

	entry->e_boot = B_TRUE;

	return (B_TRUE);

}

/*

 * Create the boot session

 */

static void

iscsi_boot_session_create(iscsi_hba_t *ihp,

    ib_boot_prop_t	*boot_prop_table)

{

	iSCSIDiscoveryMethod_t  dm;

	entry_t			e;

	iscsi_sockaddr_t	addr_dsc;

	if (ihp == NULL || boot_prop_table == NULL) {

		return;

	}

	if (!iscsid_ip_check(

	    (char *)&boot_prop_table->boot_tgt.tgt_ip_u)) {

		return;

	}

	if (boot_prop_table->boot_tgt.tgt_name != NULL) {

		dm = iSCSIDiscoveryMethodStatic |

		    iSCSIDiscoveryMethodBoot;

		if (!iscsid_make_entry(boot_prop_table, &e))

			return;

		iscsid_addr_to_sockaddr(e.e_insize, &e.e_u,

		    e.e_port, &addr_dsc.sin);

		(void) iscsid_add(ihp, dm, &addr_dsc.sin,

		    (char *)boot_prop_table->boot_tgt.tgt_name,

		    e.e_tpgt, &addr_dsc.sin);

	} else {

		dm = iSCSIDiscoveryMethodSendTargets |

		    iSCSIDiscoveryMethodBoot;

		if (!iscsid_make_entry(boot_prop_table, &e))

			return;

		iscsid_addr_to_sockaddr(e.e_insize, &e.e_u,

		    e.e_port, &addr_dsc.sin);

		iscsid_do_sendtgts(&e);

		(void) iscsid_login_tgt(ihp, NULL, dm,

		    &addr_dsc.sin);

	}

}

/*

 * iscsid_init -- load data from persistent storage and start discovery threads

 *

 * If restart is B_TRUE than someone has issued an ISCSI_DB_RELOAD ioctl.

 * The most likely reason is that a new database has been copied into

 * /etc/iscsi and the driver needs to read the contents.

 */

boolean_t

iscsid_init(iscsi_hba_t *ihp, boolean_t restart)

{

	boolean_t		rval = B_FALSE;

	iSCSIDiscoveryMethod_t  dm;

	iSCSIDiscoveryMethod_t	*fdm;

	sema_init(&iscsid_config_semaphore, 1, NULL,

	    SEMA_DRIVER, NULL);

	if (iscsiboot_prop) {

		if (ihp->persistent_loaded) {

			rval = persistent_init(B_TRUE);

		} else {

			rval = persistent_init(B_FALSE);

			if (rval)

				ihp->persistent_loaded = B_TRUE;

		}

	} else {

		rval = persistent_init(restart);

		if (restart == B_FALSE) {

			ihp->persistent_loaded = B_TRUE;

		}

	}

	if ((modrootloaded == 0) && (iscsiboot_prop != NULL) && rval) {

		if (!iscsid_boot_init_config(ihp)) {

			rval = B_FALSE;

		} else {

			iscsi_boot_session_create(ihp, iscsiboot_prop);

			iscsi_boot_wd_handle =

			    iscsi_thread_create(ihp->hba_dip,

			    "BootWD", iscsid_thread_boot_wd, ihp);

			if (iscsi_boot_wd_handle) {

				rval = iscsi_thread_start(

				    iscsi_boot_wd_handle);

			} else {

				rval = B_FALSE;

			}

		}

		if (!rval) {

			cmn_err(CE_NOTE, "Initializaton of iscsi initiator"

			    " partially failed");

		}

	} else {

		if (rval == B_TRUE) {

			rval = iscsid_init_config(ihp);

			if (rval == B_TRUE) {

				rval = iscsid_init_targets(ihp);

			}

		}

		if (rval == B_TRUE) {

			if (restart == B_FALSE) {

				iscsid_threads_create(ihp);

			}

			dm = persistent_disc_meth_get();

			rval = iscsid_enable_discovery(ihp, dm, B_FALSE);

			if (rval == B_TRUE) {

				rval = iscsid_disable_discovery(ihp, ~dm);

			}

		}

		if (rval == B_FALSE) {

			/*

			 * In case of failure the events still need to be sent

			 * because the door daemon will pause until all these

			 * events have occurred.

			 */

			for (fdm = &for_failure[0]; *fdm !=

			    iSCSIDiscoveryMethodUnknown; fdm++) {

				/* ---- Send both start and end events ---- */

				iscsi_discovery_event(ihp, *fdm, B_TRUE);

				iscsi_discovery_event(ihp, *fdm, B_FALSE);

			}

		}

	}

	return (rval);

}

/*

 * iscsid_fini -- do whatever is required to clean up

 */

/* ARGSUSED */

void

iscsid_fini()

{

	iscsid_threads_destroy();

	if (iscsi_boot_wd_handle != NULL) {

		iscsi_thread_destroy(iscsi_boot_wd_handle);

		iscsi_boot_wd_handle = NULL;

	}

	persistent_fini();

	sema_destroy(&iscsid_config_semaphore);

}

/*

 * iscsid_props -- returns discovery thread information, used by ioctl code

 */

void

iscsid_props(iSCSIDiscoveryProperties_t *props)

{

	iSCSIDiscoveryMethod_t  dm;

	dm = persistent_disc_meth_get();

	props->vers = ISCSI_INTERFACE_VERSION;

	/* ---- change once thread is implemented ---- */

	props->iSNSDiscoverySettable		= B_FALSE;

	props->SLPDiscoverySettable		= B_FALSE;

	props->StaticDiscoverySettable		= B_TRUE;

	props->SendTargetsDiscoverySettable	= B_TRUE;

	props->iSNSDiscoveryMethod		= iSNSDiscoveryMethodStatic;

	props->iSNSDiscoveryEnabled = CHECK_METHOD(iSCSIDiscoveryMethodISNS);

	props->StaticDiscoveryEnabled =

	    CHECK_METHOD(iSCSIDiscoveryMethodStatic);

	props->SendTargetsDiscoveryEnabled =

	    CHECK_METHOD(iSCSIDiscoveryMethodSendTargets);

	props->SLPDiscoveryEnabled = CHECK_METHOD(iSCSIDiscoveryMethodSLP);

}

/*

 * iscsid_enable_discovery - start specified discovery methods

 */

/* ARGSUSED */

boolean_t

iscsid_enable_discovery(iscsi_hba_t *ihp, iSCSIDiscoveryMethod_t idm,

    boolean_t poke)

{

	boolean_t		rval = B_TRUE;

	iscsid_thr_table	*dt;

	/*

	 * start the specified discovery method(s)

	 */

	for (dt = &iscsid_thr[0]; dt->method != iSCSIDiscoveryMethodUnknown;

	    dt++) {

		if (idm & dt->method) {

			if (dt->thr_id != NULL) {

				rval = iscsi_thread_start(dt->thr_id);

				if (rval == B_FALSE) {

					break;

				}

				if (poke == B_TRUE) {

					iscsi_thread_send_wakeup(dt->thr_id);

				}

			} else {

				/*

				 * unexpected condition.  The threads for each

				 * discovery method should have started at

				 * initialization

				 */

				ASSERT(B_FALSE);

			}

		}

	} /* END for() */

	return (rval);

}

/*

 * iscsid_disable_discovery - stop specified discovery methods

 */

boolean_t

iscsid_disable_discovery(iscsi_hba_t *ihp, iSCSIDiscoveryMethod_t idm)

{

	boolean_t		rval = B_TRUE;

	iscsid_thr_table	*dt;

	/*

	 * stop the specified discovery method(s)

	 */

	for (dt = &iscsid_thr[0]; dt->method != iSCSIDiscoveryMethodUnknown;

	    dt++) {

		if (idm & dt->method) {

			/* signal discovery event change - begin */

			iscsi_discovery_event(ihp, dt->method, B_TRUE);

			/* Attempt to logout of all associated targets */

			rval = iscsid_del(ihp, NULL, dt->method, NULL);

			if (rval == B_TRUE) {

				/* Successfully logged out of targets */

				if (dt->thr_id != NULL) {

					rval = iscsi_thread_stop(dt->thr_id);

					if (rval == B_FALSE) {

						/*

						 * signal discovery

						 * event change - end

						 */

						iscsi_discovery_event(ihp,

						    dt->method, B_FALSE);

						break;

					}

				} else {

					/*

					 * unexpected condition.  The threads

					 * for each discovery method should

					 * have started at initialization

					 */

					ASSERT(B_FALSE);

				}

			}

			/* signal discovery event change - end */

			iscsi_discovery_event(ihp, dt->method, B_FALSE);

		}

	} /* END for() */

	return (rval);

}

/*

 * iscsid_poke_discovery - wakeup discovery methods to find any new targets

 * and wait for all discovery processes to complete.

 */

void

iscsid_poke_discovery(iscsi_hba_t *ihp, iSCSIDiscoveryMethod_t method)

{

#define	ISCSI_DISCOVERY_DELAY	1

	iSCSIDiscoveryMethod_t	dm;

	iscsid_thr_table	*dt;

	ASSERT(ihp != NULL);

	/* reset discovery flags */

	mutex_enter(&ihp->hba_discovery_events_mutex);

	ihp->hba_discovery_in_progress = B_TRUE;

	ihp->hba_discovery_events = iSCSIDiscoveryMethodUnknown;

	mutex_exit(&ihp->hba_discovery_events_mutex);

	/* start all enabled discovery methods */

	dm = persistent_disc_meth_get();

	for (dt = &iscsid_thr[0]; dt->method != iSCSIDiscoveryMethodUnknown;

	    dt++) {

		if ((method == iSCSIDiscoveryMethodUnknown) ||

		    (method == dt->method)) {

			if ((dm & dt->method) && (dt->thr_id != NULL)) {

				iscsi_thread_send_wakeup(dt->thr_id);

			} else {

				iscsi_discovery_event(ihp, dt->method, B_TRUE);

				iscsi_discovery_event(ihp, dt->method, B_FALSE);

			}

		} else {

			iscsi_discovery_event(ihp, dt->method, B_TRUE);

			iscsi_discovery_event(ihp, dt->method, B_FALSE);

		}

	}

	mutex_enter(&ihp->hba_discovery_events_mutex);

	while (ihp->hba_discovery_events != ISCSI_ALL_DISCOVERY_METHODS) {

		mutex_exit(&ihp->hba_discovery_events_mutex);

		delay(SEC_TO_TICK(ISCSI_DISCOVERY_DELAY));

		mutex_enter(&ihp->hba_discovery_events_mutex);

	}

	ihp->hba_discovery_in_progress = B_FALSE;