xref: /illumos-gate/usr/src/lib/libstmf/common/libstmf.h (revision 4b31676f)

/*
 * 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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#ifndef	_LIBSTMF_H
#define	_LIBSTMF_H

#include <time.h>
#include <sys/param.h>
#include <libnvpair.h>

#ifdef	__cplusplus
extern "C" {
#endif

/* Constants and Types */

/* LU and Local Port states */
#define	STMF_LOGICAL_UNIT_OFFLINE	0
#define	STMF_LOGICAL_UNIT_OFFLINING	1
#define	STMF_LOGICAL_UNIT_ONLINE	2
#define	STMF_LOGICAL_UNIT_ONLINING	3
#define	STMF_LOGICAL_UNIT_UNREGISTERED	4
#define	STMF_TARGET_PORT_OFFLINE	5
#define	STMF_TARGET_PORT_OFFLINING	6
#define	STMF_TARGET_PORT_ONLINE		7
#define	STMF_TARGET_PORT_ONLINING	8
#define	STMF_SERVICE_STATE_ONLINE	9
#define	STMF_SERVICE_STATE_OFFLINE	10
#define	STMF_SERVICE_STATE_ONLINING	11
#define	STMF_SERVICE_STATE_OFFLINING	12
#define	STMF_SERVICE_STATE_UNKNOWN	13
#define	STMF_CONFIG_STATE_NONE		14
#define	STMF_CONFIG_STATE_INIT		15
#define	STMF_CONFIG_STATE_INIT_DONE	16
#define	STMF_CONFIG_STATE_UNKNOWN	17
#define	STMF_DEFAULT_LU_STATE		18
#define	STMF_DEFAULT_TARGET_PORT_STATE	19

#define	STMF_IDENT_LENGTH   255

/* API status return values */
#define	STMF_STATUS_SUCCESS	    0x0000
#define	STMF_STATUS_ERROR	    0x8000
#define	STMF_ERROR_BUSY			(STMF_STATUS_ERROR | 0x01)
#define	STMF_ERROR_NOT_FOUND		(STMF_STATUS_ERROR | 0x02)
#define	STMF_ERROR_MEMBER_NOT_FOUND	(STMF_STATUS_ERROR | 0x03)
#define	STMF_ERROR_GROUP_NOT_FOUND	(STMF_STATUS_ERROR | 0x04)
#define	STMF_ERROR_PERM			(STMF_STATUS_ERROR | 0x05)
#define	STMF_ERROR_NOMEM		(STMF_STATUS_ERROR | 0x06)
#define	STMF_ERROR_INVALID_ARG		(STMF_STATUS_ERROR | 0x07)
#define	STMF_ERROR_EXISTS		(STMF_STATUS_ERROR | 0x08)
#define	STMF_ERROR_SERVICE_NOT_FOUND	(STMF_STATUS_ERROR | 0x09)
#define	STMF_ERROR_SERVICE_ONLINE	(STMF_STATUS_ERROR | 0x0a)
#define	STMF_ERROR_SERVICE_OFFLINE	(STMF_STATUS_ERROR | 0x0b)
#define	STMF_ERROR_GROUP_IN_USE		(STMF_STATUS_ERROR | 0x0c)
#define	STMF_ERROR_LUN_IN_USE		(STMF_STATUS_ERROR | 0x0d)
#define	STMF_ERROR_VE_CONFLICT		(STMF_STATUS_ERROR | 0x0e)
#define	STMF_ERROR_CONFIG_NONE		(STMF_STATUS_ERROR | 0x0f)
#define	STMF_ERROR_SERVICE_DATA_VERSION (STMF_STATUS_ERROR | 0x10)
#define	STMF_ERROR_INVALID_HG		(STMF_STATUS_ERROR | 0x11)
#define	STMF_ERROR_INVALID_TG		(STMF_STATUS_ERROR | 0x12)
#define	STMF_ERROR_PROV_DATA_STALE	(STMF_STATUS_ERROR | 0x13)
#define	STMF_ERROR_NO_PROP		(STMF_STATUS_ERROR | 0x14)
#define	STMF_ERROR_NO_PROP_VAL		(STMF_STATUS_ERROR | 0x15)
#define	STMF_ERROR_MISSING_PROP_VAL	(STMF_STATUS_ERROR | 0x16)
#define	STMF_ERROR_INVALID_BLOCKSIZE	(STMF_STATUS_ERROR | 0x17)
#define	STMF_ERROR_FILE_ALREADY		(STMF_STATUS_ERROR | 0x18)
#define	STMF_ERROR_INVALID_PROPSIZE	(STMF_STATUS_ERROR | 0x19)
#define	STMF_ERROR_INVALID_PROP		(STMF_STATUS_ERROR | 0x20)
#define	STMF_ERROR_PERSIST_TYPE		(STMF_STATUS_ERROR | 0x21)
#define	STMF_ERROR_TG_ONLINE		(STMF_STATUS_ERROR | 0x22)
#define	STMF_ERROR_ACCESS_STATE_SET	(STMF_STATUS_ERROR | 0x23)
#define	STMF_ERROR_NO_PROP_STANDBY	(STMF_STATUS_ERROR | 0x24)
#define	STMF_ERROR_POST_MSG_FAILED	(STMF_STATUS_ERROR | 0x25)
#define	STMF_ERROR_DOOR_INSTALLED	(STMF_STATUS_ERROR | 0x26)

/* Failures for stmfCreateLu */
#define	STMF_ERROR_FILE_IN_USE		(STMF_STATUS_ERROR | 0x100)
#define	STMF_ERROR_INVALID_BLKSIZE	(STMF_STATUS_ERROR | 0x101)
#define	STMF_ERROR_GUID_IN_USE		(STMF_STATUS_ERROR | 0x102)
#define	STMF_ERROR_META_FILE_NAME	(STMF_STATUS_ERROR | 0x103)
#define	STMF_ERROR_DATA_FILE_NAME	(STMF_STATUS_ERROR | 0x104)
#define	STMF_ERROR_SIZE_OUT_OF_RANGE	(STMF_STATUS_ERROR | 0x105)
#define	STMF_ERROR_LU_BUSY		(STMF_STATUS_ERROR | 0x106)
#define	STMF_ERROR_META_CREATION	(STMF_STATUS_ERROR | 0x107)
#define	STMF_ERROR_FILE_SIZE_INVALID	(STMF_STATUS_ERROR | 0x108)
#define	STMF_ERROR_WRITE_CACHE_SET	(STMF_STATUS_ERROR | 0x109)

/* Initiator Name Types */
#define	STMF_FC_PORT_WWN	    1
#define	STMF_ISCSI_NAME		    2


/* provider types */
#define	STMF_LU_PROVIDER_TYPE	1
#define	STMF_PORT_PROVIDER_TYPE	2

/* LU Resource types */
#define	STMF_DISK   0

/* Persistence methods */
#define	STMF_PERSIST_SMF	1
#define	STMF_PERSIST_NONE	2

/* Logical unit access states */
#define	STMF_ACCESS_ACTIVE		"0"
#define	STMF_ACCESS_ACTIVE_TO_STANDBY   "1"
#define	STMF_ACCESS_STANDBY		"2"
#define	STMF_ACCESS_STANDBY_TO_ACTIVE	"3"

/*
 * LU Disk Properties
 */

enum {
	STMF_LU_PROP_ALIAS = 1,
	STMF_LU_PROP_BLOCK_SIZE,
	STMF_LU_PROP_COMPANY_ID,
	STMF_LU_PROP_FILENAME,
	STMF_LU_PROP_GUID,
	STMF_LU_PROP_META_FILENAME,
	STMF_LU_PROP_MGMT_URL,
	STMF_LU_PROP_NEW,
	STMF_LU_PROP_SIZE,
	STMF_LU_PROP_WRITE_PROTECT,
	STMF_LU_PROP_WRITE_CACHE_DISABLE,
	STMF_LU_PROP_VID,
	STMF_LU_PROP_PID,
	STMF_LU_PROP_SERIAL_NUM,
	STMF_LU_PROP_ACCESS_STATE,
	STMF_LU_PROP_HOST_ID
};


/* devid code set and name types */
#define	EUI_64_TYPE	2
#define	NAA_TYPE	3
#define	SCSI_NAME_TYPE	8

#define	BINARY_CODE_SET	1
#define	ASCII_CODE_SET	2
#define	UTF_8_CODE_SET	3

typedef enum _stmfProtocol
{
	STMF_PROTOCOL_FIBRE_CHANNEL =	0,
	STMF_PROTOCOL_SCSI =		1,
	STMF_PROTOCOL_SSA =		2,
	STMF_PROTOCOL_IEEE_1394 =	3,
	STMF_PROTOCOL_SRP =		4,
	STMF_PROTOCOL_ISCSI =		5,
	STMF_PROTOCOL_SAS =		6
} stmfProtocol;


typedef struct _stmfGuid
{
	uchar_t	guid[16];
} stmfGuid;

typedef struct _stmfGuidList
{
	uint32_t cnt;
	stmfGuid guid[1];
} stmfGuidList;

typedef struct _stmfState
{
	int operationalState;
	int configState;
} stmfState;

typedef struct _stmfDevid
{
	uint8_t identLength;	/* length of ident */
	uint8_t	ident[STMF_IDENT_LENGTH]; /* SCSI name string ident */
} stmfDevid;

typedef struct _stmfDevidList
{
	uint32_t cnt;
	stmfDevid devid[1];
} stmfDevidList;

typedef char stmfGroupName[256];
typedef char stmfProviderName[256];

typedef struct _stmfGroupList
{
	uint32_t cnt;
	stmfGroupName name[1];
} stmfGroupList;

typedef struct _stmfProvider
{
	int providerType;
	stmfProviderName name;
} stmfProvider;

typedef struct _stmfProviderList
{
	uint32_t cnt;
	stmfProvider provider[1];
} stmfProviderList;

typedef struct _stmfSession
{
	stmfDevid initiator;
	char alias[256];
	time_t creationTime;
} stmfSession;

typedef struct _stmfSessionList
{
	uint32_t cnt;
	stmfSession session[1];
} stmfSessionList;


typedef struct _stmfViewEntry
{
	boolean_t	veIndexValid;	/* if B_TRUE, veIndex is valid value */
	uint32_t	veIndex;	/* View Entry index */
	boolean_t	allHosts;	/* all initiator ports */
	stmfGroupName   hostGroup;	/* Host Group Name */
	boolean_t	allTargets;	/* B_TRUE = targetGroup is invalid */
	stmfGroupName	targetGroup;	/* Target Group Name */
	boolean_t	luNbrValid;	/* if B_TRUE, luNbr is a valid value */
	uchar_t		luNbr[8];	/* LU number for this view entry */
} stmfViewEntry;

typedef struct _stmfViewEntryList
{
	uint32_t cnt;
	stmfViewEntry ve[1];
} stmfViewEntryList;

typedef struct _stmfViewEntryProperties
{
	stmfGuid	associatedLogicalUnitGuid;
	stmfViewEntry	viewEntry;
} stmfViewEntryProperties;

typedef struct _stmfGroupProperties
{
	uint32_t	cnt;
	stmfDevid	name[1];
} stmfGroupProperties;

typedef struct _stmfTargetProperties
{
	stmfProviderName providerName;
	char		 alias[256];
	uint16_t	 status;
	stmfProtocol	 protocol;
	stmfDevid	 devid;
} stmfTargetProperties;

typedef struct _stmfLogicalUnitProperties
{
	char	    alias[256];
	uchar_t	    vendor[8];
	uchar_t	    product[16];
	uchar_t	    revision[4];
	uint32_t    status;
	char	    providerName[256];
	stmfGuid    luid;
} stmfLogicalUnitProperties;

typedef void * luResource;

typedef struct _stmfLogicalUnitProviderProperties
{
	char	    providerName[MAXPATHLEN];
	uint32_t    instance;
	uint32_t    status;
	uchar_t	    rsvd[64];
} stmfLogicalUnitProviderProperties;

typedef struct _stmfLocalPortProviderProperties
{
	char	    providerName[MAXPATHLEN];
	uint32_t    instance;
	uint32_t    status;
	uchar_t	    rsvd[64];
} stmfLocalPortProviderProperties;

/* API prototypes */
int stmfAddToHostGroup(stmfGroupName *hostGroupName, stmfDevid *name);
int stmfAddToTargetGroup(stmfGroupName *targetGroupName, stmfDevid *targetName);
int stmfAddViewEntry(stmfGuid *lu, stmfViewEntry *viewEntry);
int stmfClearProviderData(char *providerName, int providerType);
int stmfCreateHostGroup(stmfGroupName *hostGroupName);
int stmfCreateLu(luResource hdl, stmfGuid *luGuid);
int stmfCreateLuResource(uint16_t dType, luResource *hdl);
int stmfCreateTargetGroup(stmfGroupName *targetGroupName);
int stmfDeleteHostGroup(stmfGroupName *hostGroupName);
int stmfDeleteLu(stmfGuid *luGuid);
int stmfDeleteTargetGroup(stmfGroupName *targetGroupName);
void stmfDestroyProxyDoor(int hdl);
int stmfDevidFromIscsiName(char *iscsiName, stmfDevid *devid);
int stmfDevidFromWwn(uchar_t wwn[8], stmfDevid *devid);
int stmfFreeLuResource(luResource hdl);
void stmfFreeMemory(void *);
int stmfGetAluaState(boolean_t *enabled, uint32_t *node);
int stmfGetGlobalLuProp(uint16_t dType, uint32_t prop, char *propVal,
    size_t *propLen);
int stmfGetHostGroupList(stmfGroupList **initiatorGroupList);
int stmfGetHostGroupMembers(stmfGroupName *hostGroupName,
    stmfGroupProperties **groupProperties);
int stmfGetLocalPortProviderList(stmfProviderList **localPortProviderList);
int stmfGetLocalPortProviderProperties(stmfProviderName *providerName,
    stmfLocalPortProviderProperties *providerProperties);
int stmfGetLogicalUnitList(stmfGuidList **logicalUnitList);
int stmfGetLogicalUnitProperties(stmfGuid *logicalUnit,
    stmfLogicalUnitProperties *logicalUnitProps);
int stmfGetLogicalUnitProviderList(stmfProviderList **logicalUnitProviderList);
int stmfGetLogicalUnitProviderProperties(stmfProviderName *providerName,
    stmfLogicalUnitProviderProperties *providerProperties);
int stmfGetLuProp(luResource hdl, uint32_t propType, char *prop,
    size_t *propLen);
int stmfGetLuResource(stmfGuid *luGuid, luResource *hdl);
int stmfGetPersistMethod(uint8_t *persistType, boolean_t serviceState);
int stmfGetProviderData(char *providerName, nvlist_t **nvl, int providerType);
int stmfGetProviderDataProt(char *providerName, nvlist_t **nvl,
    int providerType, uint64_t *setToken);
int stmfGetSessionList(stmfDevid *target, stmfSessionList **sessionList);
int stmfGetState(stmfState *);
int stmfGetTargetGroupList(stmfGroupList **targetGroupList);
int stmfGetTargetGroupMembers(stmfGroupName *targetGroupName,
    stmfGroupProperties **groupProperties);
int stmfGetTargetList(stmfDevidList **targetList);
int stmfGetTargetProperties(stmfDevid *target,
    stmfTargetProperties *targetProps);
int stmfGetViewEntryList(stmfGuid *lu, stmfViewEntryList **viewEntryList);
int stmfImportLu(uint16_t dType, char *fname, stmfGuid *luGuid);
int stmfInitProxyDoor(int *hdl, int fd);
int stmfLoadConfig(void);
int stmfLuStandby(stmfGuid *luGuid);
int stmfModifyLu(stmfGuid *luGuid, uint32_t prop, const char *propVal);
int stmfModifyLuByFname(uint16_t dType, const char *fname, uint32_t prop,
    const char *propVal);
int stmfOffline(void);
int stmfOfflineTarget(stmfDevid *devid);
int stmfOfflineLogicalUnit(stmfGuid *logicalUnit);
int stmfOnline(void);
int stmfOnlineTarget(stmfDevid *devid);
int stmfOnlineLogicalUnit(stmfGuid *logicalUnit);
int stmfPostProxyMsg(int hdl, void *buf, uint32_t buflen);
int stmfRemoveFromHostGroup(stmfGroupName *hostGroupName,
    stmfDevid *initiatorName);
int stmfRemoveFromTargetGroup(stmfGroupName *targetGroupName,
    stmfDevid *targetName);
int stmfRemoveViewEntry(stmfGuid *lu, uint32_t viewEntryIndex);
int stmfSetAluaState(boolean_t enabled, uint32_t node);
int stmfSetGlobalLuProp(uint16_t dType, uint32_t propType, const char *propVal);
int stmfSetLuProp(luResource hdl, uint32_t propType, const char *propVal);
int stmfSetPersistMethod(uint8_t persistType, boolean_t serviceSet);
int stmfSetProviderData(char *providerName, nvlist_t *nvl, int providerType);
int stmfSetProviderDataProt(char *providerName, nvlist_t *nvl,
    int providerType, uint64_t *setToken);
int stmfValidateView(stmfViewEntry *viewEntry);
int stmfSetStmfProp(uint8_t propType, char *propVal);
int stmfGetStmfProp(uint8_t propType, char *propVal, size_t *propLen);
int stmfLoadStmfProps(void);

#ifdef	__cplusplus
}
#endif

#endif	/* _LIBSTMF_H */