Commit 9f988238 authored by Chunyang Hui's avatar Chunyang Hui Committed by Changpeng Liu
Browse files

Opal: Refactor and clean functions 



Delete opal_next, introduce opal_add_tokens.
Delete spdk_opal_cmd, seperate cmds to new APIs.

Change-Id: Ide56817eec7fde7b110818966ebf10e65a952fc9
Signed-off-by: default avatarChunyang Hui <chunyang.hui@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/454433


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
parent 4913ed4d

CHANGELOG.md

+2 −0
Original line number Diff line number Diff line
@@ -39,6 +39,8 @@ taken into account if trying to achieve an artificial latency on top of an nvme 
Added spdk_nvme_ctrlr_get_transport_id() to get the transport ID from a

previously attached controller.



Nvme Opal library spdk_opal_cmd deprecated. Adding seperate command APIs.



### env



The parameter `free_space` has been added to spdk_ring_enqueue() to wait when

examples/nvme/nvme_manage/nvme_manage.c

+3 −3
Original line number Diff line number Diff line
@@ -955,7 +955,7 @@ opal_scan(struct dev *iter) 
		if (spdk_opal_supported(iter->opal_dev)) {

			printf("\n\nOpal Supported:\n");

			display_controller(iter, CONTROLLER_DISPLAY_SIMPLISTIC);

			spdk_opal_scan(iter->opal_dev);

			spdk_opal_cmd_scan(iter->opal_dev);

			opal_dump_info(spdk_opal_get_info(iter->opal_dev));

		}

		spdk_opal_close(iter->opal_dev);
@@ -985,7 +985,7 @@ opal_take_ownership(struct dev *iter) 
			while ((ch = getchar()) != '\n' && ch != EOF);

			passwd_p = get_line(new_passwd, MAX_PASSWORD_SIZE, stdin);

			if (passwd_p) {

				ret = spdk_opal_cmd(iter->opal_dev, OPAL_CMD_TAKE_OWNERSHIP, passwd_p);

				ret = spdk_opal_cmd_take_ownership(iter->opal_dev, passwd_p);

				if (ret) {

					printf("Take ownership failure: %d\n", ret);

					return;
@@ -1021,7 +1021,7 @@ opal_revert_tper(struct dev *iter) 
			while ((ch = getchar()) != '\n' && ch != EOF);

			passwd_p = get_line(passwd, MAX_PASSWORD_SIZE, stdin);

			if (passwd_p) {

				ret = spdk_opal_cmd(iter->opal_dev, OPAL_CMD_REVERT_TPER, passwd_p);

				ret = spdk_opal_cmd_revert_tper(iter->opal_dev, passwd_p);

				if (ret) {

					printf("Revert TPer failure: %d\n", ret);

					return;

include/spdk/opal.h

+23 −19
Original line number Diff line number Diff line
@@ -72,23 +72,6 @@ static const char *const spdk_opal_errors[] = { 
	"AUTHORITY LOCKED OUT",

};



enum spdk_opal_cmd {

	OPAL_CMD_SAVE,

	OPAL_CMD_LOCK_UNLOCK,

	OPAL_CMD_TAKE_OWNERSHIP,

	OPAL_CMD_ACTIVATE_LSP,	/* locking sp */

	OPAL_CMD_SET_NEW_PASSWD,

	OPAL_CMD_ACTIVATE_USER,

	OPAL_CMD_REVERT_TPER,

	OPAL_CMD_SETUP_LOCKING_RANGE,

	OPAL_CMD_ADD_USER_TO_LOCKING_RANGE,

	OPAL_CMD_ENABLE_DISABLE_SHADOW_MBR,

	OPAL_CMD_ERASE_LOCKING_RANGE,

	OPAL_CMD_SECURE_ERASE_LOCKING_RANGE,

	OPAL_CMD_INITIAL_SETUP,

	OPAL_CMD_SCAN,

};



struct spdk_opal_info {

	uint8_t tper : 1;

	uint8_t locking : 1;
@@ -135,16 +118,37 @@ struct spdk_opal_info { 
	uint16_t vu_feature_code; /* vendor specific feature */

};



enum spdk_opal_lock_state {

	OPAL_LS_DISALBELOCKING		= 0x00,

	OPAL_LS_READLOCK_ENABLE		= 0x01,

	OPAL_LS_WRITELOCK_ENABLE	= 0x02,

	OPAL_LS_RWLOCK_ENABLE		= 0x04,

};



enum spdk_opal_user {

	OPAL_ADMIN1 = 0x0,

	OPAL_USER1 = 0x01,

	OPAL_USER2 = 0x02,

	OPAL_USER3 = 0x03,

	OPAL_USER4 = 0x04,

	OPAL_USER5 = 0x05,

	OPAL_USER6 = 0x06,

	OPAL_USER7 = 0x07,

	OPAL_USER8 = 0x08,

	OPAL_USER9 = 0x09,

};



struct spdk_opal_dev;



struct spdk_opal_dev *spdk_opal_init_dev(void *dev_handler);



int spdk_opal_scan(struct spdk_opal_dev *dev);

void spdk_opal_close(struct spdk_opal_dev *dev);

struct spdk_opal_info *spdk_opal_get_info(struct spdk_opal_dev *dev);



bool spdk_opal_supported(struct spdk_opal_dev *dev);



int spdk_opal_cmd(struct spdk_opal_dev *dev, unsigned int cmd, void *arg);

int spdk_opal_cmd_scan(struct spdk_opal_dev *dev);

int spdk_opal_cmd_take_ownership(struct spdk_opal_dev *dev, char *new_passwd);

int spdk_opal_cmd_revert_tper(struct spdk_opal_dev *dev, const char *passwd);



#endif

lib/nvme/nvme_opal.c

+129 −157
Original line number Diff line number Diff line
@@ -39,8 +39,6 @@ 


typedef int (spdk_opal_cb)(struct spdk_opal_dev *dev);



static int opal_end_session_error(struct spdk_opal_dev *dev);



static const char *

opal_error_to_human(int error)

{
@@ -195,6 +193,10 @@ opal_add_token_u64(int *err, struct spdk_opal_dev *dev, uint64_t number) 
{

	int startat = 0;



	if (*err) {

		return;

	}



	/* add header first */

	if (number <= SPDK_TINY_ATOM_DATA_MASK) {

		dev->cmd[dev->cmd_pos++] = (uint8_t) number & SPDK_TINY_ATOM_DATA_MASK;
@@ -220,6 +222,24 @@ opal_add_token_u64(int *err, struct spdk_opal_dev *dev, uint64_t number) 
	}

}



static void

opal_add_tokens(int *err, struct spdk_opal_dev *dev, int num, ...)

{

	int i;

	va_list args_ptr;

	enum spdk_opal_token tmp;



	va_start(args_ptr, num);



	for (i = 0; i < num; i++) {

		tmp = va_arg(args_ptr, enum spdk_opal_token);

		opal_add_token_u8(err, dev, tmp);

		if (*err != 0) { break; }

	}



	va_end(args_ptr);

}



static int

opal_cmd_finalize(struct spdk_opal_dev *dev, uint32_t hsn, uint32_t tsn, bool eod)

{
@@ -227,12 +247,10 @@ opal_cmd_finalize(struct spdk_opal_dev *dev, uint32_t hsn, uint32_t tsn, bool eo 
	int err = 0;



	if (eod) {

		opal_add_token_u8(&err, dev, SPDK_OPAL_ENDOFDATA);

		opal_add_token_u8(&err, dev, SPDK_OPAL_STARTLIST);

		opal_add_token_u8(&err, dev, 0);

		opal_add_token_u8(&err, dev, 0);

		opal_add_token_u8(&err, dev, 0);

		opal_add_token_u8(&err, dev, SPDK_OPAL_ENDLIST);

		opal_add_tokens(&err, dev, 6, SPDK_OPAL_ENDOFDATA,

				SPDK_OPAL_STARTLIST,

				0, 0, 0,

				SPDK_OPAL_ENDLIST);

	}



	if (err) {
@@ -594,39 +612,6 @@ opal_set_comid(struct spdk_opal_dev *dev, uint16_t comid) 
	hdr->com_packet.extended_comid[1] = 0;

}



static int

opal_next(struct spdk_opal_dev *dev)

{

	const struct spdk_opal_step *step;

	int state = 0, error = 0;



	do {

		step = &dev->steps[state];

		if (!step->opal_fn) {

			if (state != 0) {

				break;

			} else {

				SPDK_ERRLOG("First step is NULL\n");

				return -1;

			}

		}



		error = step->opal_fn(dev, step->data);

		if (error) {

			SPDK_ERRLOG("Error on step function: %d with error %d: %s\n",

				    state, error,

				    opal_error_to_human(error));

			if (state > 1) {

				opal_end_session_error(dev);

				return error;

			}

		}

		state++;

	} while (!error);



	return error;

}



static void

opal_check_tper(struct spdk_opal_dev *dev, const void *data)

{
@@ -821,7 +806,7 @@ opal_discovery0_end(struct spdk_opal_dev *dev) 
}



static int

opal_discovery0(struct spdk_opal_dev *dev, void *data)

opal_discovery0(struct spdk_opal_dev *dev)

{

	int ret;
@@ -836,10 +821,8 @@ opal_discovery0(struct spdk_opal_dev *dev, void *data) 
}



static inline void

opal_setup_dev(struct spdk_opal_dev *dev,

	       const struct spdk_opal_step *steps)

opal_setup_dev(struct spdk_opal_dev *dev)

{

	dev->steps = steps;

	dev->tsn = 0;

	dev->hsn = 0;

	dev->prev_data = NULL;
@@ -855,7 +838,7 @@ opal_end_session_cb(struct spdk_opal_dev *dev) 
}



static int

opal_end_session(struct spdk_opal_dev *dev, void *data)

opal_end_session(struct spdk_opal_dev *dev)

{

	int err = 0;

	bool eod = 0;
@@ -870,33 +853,15 @@ opal_end_session(struct spdk_opal_dev *dev, void *data) 
	return opal_finalize_and_send(dev, eod, opal_end_session_cb);

}



static int

opal_end_session_error(struct spdk_opal_dev *dev)

{

	const struct spdk_opal_step error_end_session[] = {

		{ opal_end_session, },

		{ NULL, }

	};

	dev->steps = error_end_session;

	return opal_next(dev);

}



static int

opal_check_support(struct spdk_opal_dev *dev)

{

	const struct spdk_opal_step steps[] = {

		{ opal_discovery0, },

		{ NULL, }

	};

	int ret;



	opal_setup_dev(dev, steps);

	ret = opal_next(dev);

	if (ret == 0) {

		dev->supported = true;

	} else {

		dev->supported = false;

	}

	opal_setup_dev(dev);

	ret = opal_discovery0(dev);



	dev->supported = (ret == 0 ? true : false);



	return ret;

}
@@ -971,9 +936,10 @@ opal_start_generic_session(struct spdk_opal_dev *dev, 
		opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

		opal_add_token_u8(&err, dev, 0); /* HostChallenge */

		opal_add_token_bytestring(&err, dev, key, key_len);

		opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);

		opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

		opal_add_token_u8(&err, dev, 3); /* HostSignAuth */

		opal_add_tokens(&err, dev, 3,    /* number of token */

				SPDK_OPAL_ENDNAME,

				SPDK_OPAL_STARTNAME,

				3);/* HostSignAuth */

		opal_add_token_bytestring(&err, dev, spdk_opal_uid[auth],

					  OPAL_UID_LENGTH);

		opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);
@@ -994,7 +960,7 @@ opal_start_generic_session(struct spdk_opal_dev *dev, 




static int

opal_start_anybody_adminsp_session(struct spdk_opal_dev *dev, void *data)

opal_start_anybody_adminsp_session(struct spdk_opal_dev *dev)

{

	return opal_start_generic_session(dev, UID_ANYBODY,

					  UID_ADMINSP, NULL, 0);
@@ -1031,7 +997,7 @@ opal_get_msid_cpin_pin_cb(struct spdk_opal_dev *dev) 
}



static int

opal_get_msid_cpin_pin(struct spdk_opal_dev *dev, void *data)

opal_get_msid_cpin_pin(struct spdk_opal_dev *dev)

{

	int err = 0;
@@ -1043,21 +1009,18 @@ opal_get_msid_cpin_pin(struct spdk_opal_dev *dev, void *data) 
				  OPAL_UID_LENGTH);

	opal_add_token_bytestring(&err, dev, spdk_opal_method[GET_METHOD], OPAL_UID_LENGTH);



	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTLIST);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTLIST);



	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTCOLUMN);

	opal_add_token_u8(&err, dev, SPDK_OPAL_PIN);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);



	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDCOLUMN);

	opal_add_token_u8(&err, dev, SPDK_OPAL_PIN);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);



	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDLIST);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDLIST);

	opal_add_tokens(&err, dev, 12, SPDK_OPAL_STARTLIST,

			SPDK_OPAL_STARTLIST,

			SPDK_OPAL_STARTNAME,

			SPDK_OPAL_STARTCOLUMN,

			SPDK_OPAL_PIN,

			SPDK_OPAL_ENDNAME,

			SPDK_OPAL_STARTNAME,

			SPDK_OPAL_ENDCOLUMN,

			SPDK_OPAL_PIN,

			SPDK_OPAL_ENDNAME,

			SPDK_OPAL_ENDLIST,

			SPDK_OPAL_ENDLIST);



	if (err) {

		SPDK_ERRLOG("Error building Get MSID CPIN PIN command.\n");
@@ -1107,18 +1070,20 @@ opal_generic_pw_cmd(uint8_t *key, size_t key_len, uint8_t *cpin_uid, 
	opal_add_token_bytestring(&err, dev, cpin_uid, OPAL_UID_LENGTH);

	opal_add_token_bytestring(&err, dev, spdk_opal_method[SET_METHOD],

				  OPAL_UID_LENGTH);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTLIST);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_VALUES);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTLIST);

	opal_add_token_u8(&err, dev, SPDK_OPAL_STARTNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_PIN);

	opal_add_token_bytestring(&err, dev, key, key_len);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDLIST);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDNAME);

	opal_add_token_u8(&err, dev, SPDK_OPAL_ENDLIST);



	opal_add_tokens(&err, dev, 6,

			SPDK_OPAL_STARTLIST,

			SPDK_OPAL_STARTNAME,

			SPDK_OPAL_VALUES,

			SPDK_OPAL_STARTLIST,

			SPDK_OPAL_STARTNAME,

			SPDK_OPAL_PIN);

	opal_add_token_bytestring(&err, dev, key, key_len);

	opal_add_tokens(&err, dev, 4,

			SPDK_OPAL_ENDNAME,

			SPDK_OPAL_ENDLIST,

			SPDK_OPAL_ENDNAME,

			SPDK_OPAL_ENDLIST);

	return err;

}
@@ -1148,28 +1113,64 @@ opal_set_sid_cpin_pin(struct spdk_opal_dev *dev, void *data) 
	return opal_finalize_and_send(dev, 1, opal_parse_and_check_status);

}



static int

spdk_opal_take_ownership(struct spdk_opal_dev *dev, char *new_passwd)

int

spdk_opal_cmd_take_ownership(struct spdk_opal_dev *dev, char *new_passwd)

{

	const struct spdk_opal_step owner_steps[] = {

		{ opal_discovery0, },

		{ opal_start_anybody_adminsp_session, },

		{ opal_get_msid_cpin_pin, },

		{ opal_end_session, },

		{ opal_start_adminsp_session, },

		{ opal_set_sid_cpin_pin, new_passwd },

		{ opal_end_session, },

		{ NULL, }

	};

	int ret;



	if (!dev) {

	if (!dev || dev->supported == false) {

		return -ENODEV;

	}



	pthread_mutex_lock(&dev->mutex_lock);

	opal_setup_dev(dev, owner_steps);

	ret = opal_next(dev);

	opal_setup_dev(dev);

	ret = opal_start_anybody_adminsp_session(dev);

	if (ret) {

		SPDK_ERRLOG("start admin SP session error %d: %s\n", ret,

			    opal_error_to_human(ret));

		opal_end_session(dev);

		goto end;

	}



	ret = opal_get_msid_cpin_pin(dev);

	if (ret) {

		SPDK_ERRLOG("get msid error %d: %s\n", ret,

			    opal_error_to_human(ret));

		opal_end_session(dev);

		goto end;

	}



	ret = opal_end_session(dev);

	if (ret) {

		SPDK_ERRLOG("end session error %d: %s\n", ret,

			    opal_error_to_human(ret));

		goto end;

	}



	ret = opal_start_adminsp_session(dev, NULL); /* key stored in dev->prev_data */

	if (ret) {

		SPDK_ERRLOG("start admin SP session error %d: %s\n", ret,

			    opal_error_to_human(ret));

		opal_end_session(dev);

		goto end;

	}



	ret = opal_set_sid_cpin_pin(dev, new_passwd);

	if (ret) {

		SPDK_ERRLOG("set cpin error %d: %s\n", ret,

			    opal_error_to_human(ret));

		opal_end_session(dev);

		goto end;

	}



	ret = opal_end_session(dev);

	if (ret) {

		SPDK_ERRLOG("end session error %d: %s\n", ret,

			    opal_error_to_human(ret));

		goto end;

	}



end:

	pthread_mutex_unlock(&dev->mutex_lock);

	return ret;

}
@@ -1212,7 +1213,7 @@ spdk_opal_init_dev(void *dev_handler) 
}



int

spdk_opal_scan(struct spdk_opal_dev *dev)

spdk_opal_cmd_scan(struct spdk_opal_dev *dev)

{

	int ret;
@@ -1225,7 +1226,7 @@ spdk_opal_scan(struct spdk_opal_dev *dev) 
}



static int

opal_revert_tper(struct spdk_opal_dev *dev, void *data)

opal_revert_tper(struct spdk_opal_dev *dev)

{

	int err = 0;
@@ -1247,12 +1248,16 @@ opal_revert_tper(struct spdk_opal_dev *dev, void *data) 
	return opal_finalize_and_send(dev, 1, opal_parse_and_check_status);

}



static int

spdk_opal_revert_tper(struct spdk_opal_dev *dev, const char *passwd)

int

spdk_opal_cmd_revert_tper(struct spdk_opal_dev *dev, const char *passwd)

{

	int ret;

	struct spdk_opal_key *opal_key;



	if (!dev || dev->supported == false) {

		return -ENODEV;

	}



	opal_key = calloc(1, sizeof(struct spdk_opal_key));

	if (!opal_key) {

		SPDK_ERRLOG("Memory allocation failed for spdk_opal_key\n");
@@ -1263,30 +1268,26 @@ spdk_opal_revert_tper(struct spdk_opal_dev *dev, const char *passwd) 
	dev->dev_key = opal_key;



	pthread_mutex_lock(&dev->mutex_lock);

	opal_setup_dev(dev, NULL);

	ret = opal_discovery0(dev, NULL);

	if (ret) {

		SPDK_ERRLOG("Error on discovery 0 with error %d: %s\n", ret,

			    opal_error_to_human(ret));

		goto end;

	}

	opal_setup_dev(dev);



	ret = opal_start_adminsp_session(dev, opal_key);

	if (ret) {

		opal_end_session_error(dev);

		opal_end_session(dev);

		SPDK_ERRLOG("Error on starting admin SP session with error %d: %s\n", ret,

			    opal_error_to_human(ret));

		goto end;

	}



	ret = opal_revert_tper(dev, NULL);

	ret = opal_revert_tper(dev);

	if (ret) {

		opal_end_session_error(dev);

		opal_end_session(dev);

		SPDK_ERRLOG("Error on reverting TPer with error %d: %s\n", ret,

			    opal_error_to_human(ret));

		goto end;

	}



	/* Controller will terminate session. No "end session" here needed. */



end:

	pthread_mutex_unlock(&dev->mutex_lock);

	free(opal_key);
@@ -1306,34 +1307,5 @@ spdk_opal_supported(struct spdk_opal_dev *dev) 
	return dev->supported;

}



int

spdk_opal_cmd(struct spdk_opal_dev *dev, unsigned int cmd, void *arg)

{

	if (!dev) {

		SPDK_ERRLOG("Device null\n");

		return -ENODEV;

	}

	if (!dev->supported) {

		SPDK_ERRLOG("Device not supported\n");

		return -EINVAL;

	}



	switch (cmd) {

	case OPAL_CMD_SCAN:

		return spdk_opal_scan(dev);

	case OPAL_CMD_TAKE_OWNERSHIP:

		return spdk_opal_take_ownership(dev, arg);

	case OPAL_CMD_REVERT_TPER:

		return spdk_opal_revert_tper(dev, arg);

	case OPAL_CMD_LOCK_UNLOCK:

	case OPAL_CMD_ACTIVATE_LSP:

	case OPAL_CMD_SETUP_LOCKING_RANGE:



	default:

		SPDK_ERRLOG("NOT SUPPORTED\n");

		return -EINVAL;

	}

}



/* Log component for opal submodule */

SPDK_LOG_REGISTER_COMPONENT("opal", SPDK_LOG_OPAL)

lib/nvme/nvme_opal_internal.h

+11 −37
Original line number Diff line number Diff line
@@ -128,23 +128,23 @@ union spdk_discovery0_features { 
	struct spdk_d0_opal_v100 opalv100;

};



struct spdk_opal_session {

struct opal_common_session {

	uint32_t sum; /* single user mode */

	uint32_t who;

	struct spdk_opal_key *opal_key;

};



struct spdk_opal_lock_unlock {

	struct spdk_opal_session session;

struct spdk_opal_locking_session {

	struct opal_common_session session;

	uint32_t l_state;

};



struct spdk_opal_new_pw {

	struct spdk_opal_session session_start;

	struct spdk_opal_session new_user_pw;

struct spdk_opal_new_pw_session {

	struct opal_common_session old_session;

	struct opal_common_session new_pw_session;

};



static const uint8_t spdk_opal_uid[][OPAL_UID_LENGTH] = {

const uint8_t spdk_opal_uid[][OPAL_UID_LENGTH] = {

	/* users */

	[UID_SMUID] = /* Session Manager UID */

	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
@@ -205,7 +205,7 @@ static const uint8_t spdk_opal_uid[][OPAL_UID_LENGTH] = { 
/*

 * TCG Storage SSC Methods.

 */

static const uint8_t spdk_opal_method[][OPAL_UID_LENGTH] = {

const uint8_t spdk_opal_method[][OPAL_UID_LENGTH] = {

	[PROPERTIES_METHOD] =

	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01 },

	[STARTSESSION_METHOD] =
@@ -232,19 +232,6 @@ static const uint8_t spdk_opal_method[][OPAL_UID_LENGTH] = { 
	{ 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x01 },

};



enum spdk_opal_user {

	OPAL_ADMIN1 = 0x0,

	OPAL_USER1 = 0x01,

	OPAL_USER2 = 0x02,

	OPAL_USER3 = 0x03,

	OPAL_USER4 = 0x04,

	OPAL_USER5 = 0x05,

	OPAL_USER6 = 0x06,

	OPAL_USER7 = 0x07,

	OPAL_USER8 = 0x08,

	OPAL_USER9 = 0x09,

};



/*

 * Response token

 */
@@ -265,11 +252,6 @@ struct spdk_opal_resp_parsed { 
	struct spdk_opal_resp_token resp_tokens[MAX_TOKS];

};



struct spdk_opal_step {

	int (*opal_fn)(struct spdk_opal_dev *dev, void *data);

	void *data;

};



struct spdk_opal_key {

	uint8_t locking_range;

	uint8_t key_len;
@@ -277,21 +259,21 @@ struct spdk_opal_key { 
	uint8_t key[OPAL_KEY_MAX];

};



struct spdk_opal_locking_range_activate {

struct opal_locking_range_activate_session {

	struct spdk_opal_key key;

	uint32_t sum;		/* single user mode */

	uint8_t lockingrange_num;

	uint8_t lockingrange[OPAL_MAX_LRS];

};



struct spdk_opal_locking_range_setup {

struct opal_locking_range_setup_session {

	uint8_t id;

	uint8_t _padding[7];

	uint64_t range_start;

	uint64_t range_length;

	bool RLE; /* Read Lock enabled */

	bool WLE; /* Write Lock Enabled */

	struct spdk_opal_session session;

	struct opal_common_session session;

};



/* header of a response */
@@ -305,7 +287,6 @@ struct spdk_opal_dev { 
	bool supported;

	void *dev_handler;



	const struct spdk_opal_step *steps;

	uint16_t comid;

	uint32_t hsn;

	uint32_t tsn;
@@ -329,11 +310,4 @@ struct spdk_opal_dev { 
	pthread_mutex_t mutex_lock; /* some structs are accessed by current thread only */

};



enum opal_lock_state {

	OPAL_LS_DISALBELOCKING		= 0x00,

	OPAL_LS_READLOCK_ENABLE		= 0x01,

	OPAL_LS_WRITELOCK_ENABLE	= 0x02,

	OPAL_LS_RWLOCK_ENABLE		= 0x04,

};



#endif