Commit 7497cde8 authored by Sumit.Saxena@avagotech.com's avatar Sumit.Saxena@avagotech.com Committed by Christoph Hellwig
Browse files

megaraid_sas: add support for secure JBOD 



This patch adds support for Secure Encrypting Drives (SED) in JBOD mode:

1) If the firmware supports SED JBOD, all non read/write commands to JBODs
   will be sent via firmware path, and read/write commands to JBODs will
   be sent via fastpath.
2) If the firmware does not support SED JBOD, driver will fall back to the
   old design, i.e. send all JBOD I/O via fastpath.

Signed-off-by: default avatarSumit Saxena <sumit.saxena@avagotech.com>
Signed-off-by: default avatarChaitra Basappa <chaitra.basappa@avagotech.com>
Reviewed-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
parent 200aed58

drivers/scsi/megaraid/megaraid_sas.h

+48 −9
Original line number Diff line number Diff line
@@ -969,7 +969,20 @@ struct megasas_ctrl_info { 


	struct {

#if defined(__BIG_ENDIAN_BITFIELD)

		u32     reserved:25;

		u32     reserved:12;

		u32     discardCacheDuringLDDelete:1;

		u32     supportSecurityonJBOD:1;

		u32     supportCacheBypassModes:1;

		u32     supportDisableSESMonitoring:1;

		u32     supportForceFlash:1;

		u32     supportNVDRAM:1;

		u32     supportDrvActivityLEDSetting:1;

		u32     supportAllowedOpsforDrvRemoval:1;

		u32     supportHOQRebuild:1;

		u32     supportForceTo512e:1;

		u32     supportNVCacheErase:1;

		u32     supportDebugQueue:1;

		u32     supportSwZone:1;

		u32     supportCrashDump:1;

		u32     supportMaxExtLDs:1;

		u32     supportT10RebuildAssist:1;
@@ -983,7 +996,20 @@ struct megasas_ctrl_info { 
		u32     supportT10RebuildAssist:1;

		u32	supportMaxExtLDs:1;

		u32	supportCrashDump:1;

		u32     reserved:25;

		u32     supportSwZone:1;

		u32     supportDebugQueue:1;

		u32     supportNVCacheErase:1;

		u32     supportForceTo512e:1;

		u32     supportHOQRebuild:1;

		u32     supportAllowedOpsforDrvRemoval:1;

		u32     supportDrvActivityLEDSetting:1;

		u32     supportNVDRAM:1;

		u32     supportForceFlash:1;

		u32     supportDisableSESMonitoring:1;

		u32     supportCacheBypassModes:1;

		u32     supportSecurityonJBOD:1;

		u32     discardCacheDuringLDDelete:1;

		u32     reserved:12;

#endif

	} adapterOperations3;
@@ -1022,6 +1048,13 @@ enum MR_MFI_MPT_PTHR_FLAGS { 
	MFI_MPT_ATTACHED = 2,

};



enum MR_SCSI_CMD_TYPE {

	READ_WRITE_LDIO = 0,

	NON_READ_WRITE_LDIO = 1,

	READ_WRITE_SYSPDIO = 2,

	NON_READ_WRITE_SYSPDIO = 3,

};



/* Frame Type */

#define IO_FRAME				0

#define PTHRU_FRAME				1
@@ -1194,19 +1227,23 @@ union megasas_sgl_frame { 
typedef union _MFI_CAPABILITIES {

	struct {

#if   defined(__BIG_ENDIAN_BITFIELD)

		u32     reserved:27;

		u32     reserved:25;

		u32     security_protocol_cmds_fw:1;

		u32     support_core_affinity:1;

		u32     support_ndrive_r1_lb:1;

		u32	support_max_255lds:1;

		u32	reserved1:1;

		u32	support_fastpath_wb:1;

		u32     support_additional_msix:1;

		u32     support_fp_remote_lun:1;

#else

		u32     support_fp_remote_lun:1;

		u32     support_additional_msix:1;

		u32	reserved1:1;

		u32	support_fastpath_wb:1;

		u32	support_max_255lds:1;

		u32     support_ndrive_r1_lb:1;

		u32     reserved:27;

		u32     support_core_affinity:1;

		u32     security_protocol_cmds_fw:1;

		u32     reserved:25;

#endif

	} mfi_capabilities;

	u32     reg;
@@ -1638,6 +1675,7 @@ struct megasas_instance { 
	u32 crash_dump_fw_support;

	u32 crash_dump_drv_support;

	u32 crash_dump_app_support;

	u32 secure_jbod_support;

	spinlock_t crashdump_lock;



	struct megasas_register_set __iomem *reg_set;
@@ -1946,5 +1984,6 @@ void __megasas_return_cmd(struct megasas_instance *instance, 


void megasas_return_mfi_mpt_pthr(struct megasas_instance *instance,

	struct megasas_cmd *cmd_mfi, struct megasas_cmd_fusion *cmd_fusion);

int megasas_cmd_type(struct scsi_cmnd *cmd);



#endif				/*LSI_MEGARAID_SAS_H */

drivers/scsi/megaraid/megaraid_sas_base.c

+18 −10
Original line number Diff line number Diff line
@@ -1417,16 +1417,15 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp, 
}



/**

 * megasas_is_ldio -		Checks if the cmd is for logical drive

 * megasas_cmd_type -		Checks if the cmd is for logical drive/sysPD

 *				and whether it's RW or non RW

 * @scmd:			SCSI command

 *

 * Called by megasas_queue_command to find out if the command to be queued

 * is a logical drive command

 */

inline int megasas_is_ldio(struct scsi_cmnd *cmd)

inline int megasas_cmd_type(struct scsi_cmnd *cmd)

{

	if (!MEGASAS_IS_LOGICAL(cmd))

		return 0;

	int ret;



	switch (cmd->cmnd[0]) {

	case READ_10:

	case WRITE_10:
@@ -1436,10 +1435,14 @@ inline int megasas_is_ldio(struct scsi_cmnd *cmd) 
	case WRITE_6:

	case READ_16:

	case WRITE_16:

		return 1;

		ret = (MEGASAS_IS_LOGICAL(cmd)) ?

			READ_WRITE_LDIO : READ_WRITE_SYSPDIO;

		break;

	default:

		return 0;

		ret = (MEGASAS_IS_LOGICAL(cmd)) ?

			NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;

	}

	return ret;

}



 /**
@@ -1471,7 +1474,7 @@ megasas_dump_pending_frames(struct megasas_instance *instance) 
		if(!cmd->scmd)

			continue;

		printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);

		if (megasas_is_ldio(cmd->scmd)){

		if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {

			ldio = (struct megasas_io_frame *)cmd->frame;

			mfi_sgl = &ldio->sgl;

			sgcount = ldio->sge_count;
@@ -1531,7 +1534,7 @@ megasas_build_and_issue_cmd(struct megasas_instance *instance, 
	/*

	 * Logical drive command

	 */

	if (megasas_is_ldio(scmd))

	if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)

		frame_count = megasas_build_ldio(instance, scmd, cmd);

	else

		frame_count = megasas_build_dcdb(instance, scmd, cmd);
@@ -4629,6 +4632,11 @@ static int megasas_init_fw(struct megasas_instance *instance) 
				instance->crash_dump_h);

		instance->crash_dump_buf = NULL;

	}



	instance->secure_jbod_support =

		ctrl_info->adapterOperations3.supportSecurityonJBOD;

	if (instance->secure_jbod_support)

		dev_info(&instance->pdev->dev, "Firmware supports Secure JBOD\n");

	instance->max_sectors_per_req = instance->max_num_sge *

						PAGE_SIZE / 512;

	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))

drivers/scsi/megaraid/megaraid_sas_fusion.c

+41 −32
Original line number Diff line number Diff line
@@ -63,7 +63,6 @@ extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance 
extern void

megasas_complete_cmd(struct megasas_instance *instance,

		     struct megasas_cmd *cmd, u8 alt_status);

int megasas_is_ldio(struct scsi_cmnd *cmd);

int

wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,

	      int seconds);
@@ -196,6 +195,7 @@ inline void megasas_return_cmd_fusion(struct megasas_instance *instance, 


	cmd->scmd = NULL;

	cmd->sync_cmd_idx = (u32)ULONG_MAX;

	memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));

	list_add(&cmd->list, (&fusion->cmd_pool)->next);



	spin_unlock_irqrestore(&fusion->mpt_pool_lock, flags);
@@ -689,6 +689,8 @@ megasas_ioc_init_fusion(struct megasas_instance *instance) 
		= 1;

	init_frame->driver_operations.mfi_capabilities.support_ndrive_r1_lb

		= 1;

	init_frame->driver_operations.mfi_capabilities.security_protocol_cmds_fw

		= 1;

	/* Convert capability to LE32 */

	cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
@@ -1284,6 +1286,7 @@ megasas_make_sgl_fusion(struct megasas_instance *instance, 


			sgl_ptr =

			  (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;

			memset(sgl_ptr, 0, MEGASAS_MAX_SZ_CHAIN_FRAME);

		}

	}
@@ -1657,6 +1660,8 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance, 
	u32 device_id;

	struct MPI2_RAID_SCSI_IO_REQUEST *io_request;

	u16 pd_index = 0;

	u16 os_timeout_value;

	u16 timeout_limit;

	struct MR_DRV_RAID_MAP_ALL *local_map_ptr;

	struct fusion_context *fusion = instance->ctrl_context;

	u8                          span, physArm;
@@ -1673,44 +1678,48 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance, 


	io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));





	/* Check if this is a system PD I/O */

	if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS &&

	    instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) {

		io_request->Function = 0;

		if (fusion->fast_path_io)

			io_request->DevHandle =

			local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;

		io_request->RaidContext.RAIDFlags =

			MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD

			<< MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;

		cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;

		cmd->request_desc->SCSIIO.MSIxIndex =

			instance->msix_vectors ? smp_processor_id() % instance->msix_vectors : 0;

		os_timeout_value = scmd->request->timeout / HZ;



		if (instance->secure_jbod_support &&

			(megasas_cmd_type(scmd) == NON_READ_WRITE_SYSPDIO)) {

			/* system pd firmware path */

			io_request->Function  =

				MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;

			cmd->request_desc->SCSIIO.RequestFlags =

				(MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<

				MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);

			io_request->RaidContext.timeoutValue =

			local_map_ptr->raidMap.fpPdIoTimeoutSec;

				cpu_to_le16(os_timeout_value);

		} else {

			/* system pd Fast Path */

			io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;

			io_request->RaidContext.regLockFlags = 0;

			io_request->RaidContext.regLockRowLBA = 0;

			io_request->RaidContext.regLockLength = 0;

		io_request->RaidContext.RAIDFlags =

			MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD <<

			MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;

			timeout_limit = (scmd->device->type == TYPE_DISK) ?

					255 : 0xFFFF;

			io_request->RaidContext.timeoutValue =

				cpu_to_le16((os_timeout_value > timeout_limit) ?

				timeout_limit : os_timeout_value);

		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||

			(instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))

			io_request->IoFlags |= cpu_to_le16(

				MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);

			io_request->IoFlags |=

			cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);



			cmd->request_desc->SCSIIO.RequestFlags =

				(MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<

				MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);

		cmd->request_desc->SCSIIO.DevHandle =

			local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;

		cmd->request_desc->SCSIIO.MSIxIndex =

			instance->msix_vectors ? smp_processor_id() % instance->msix_vectors : 0;

		/*

		 * If the command is for the tape device, set the

		 * FP timeout to the os layer timeout value.

		 */

		if (scmd->device->type == TYPE_TAPE) {

			if ((scmd->request->timeout / HZ) > 0xFFFF)

				io_request->RaidContext.timeoutValue =

					0xFFFF;

			else

				io_request->RaidContext.timeoutValue =

					scmd->request->timeout / HZ;

		}

	} else {

		if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS)
@@ -1810,7 +1819,7 @@ megasas_build_io_fusion(struct megasas_instance *instance, 
	 */

	io_request->IoFlags = cpu_to_le16(scp->cmd_len);



	if (megasas_is_ldio(scp))

	if (megasas_cmd_type(scp) == READ_WRITE_LDIO)

		megasas_build_ldio_fusion(instance, scp, cmd);

	else

		megasas_build_dcdb_fusion(instance, scp, cmd);