Proxmox-Port/linux-loongson
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson synced 2025-09-01 15:14:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

scsi: aacraid: Move the SCSI pointer to private command data

Browse Source 
Set .cmd_size in the SCSI host template instead of using the SCSI pointer
from struct scsi_cmnd. This patch prepares for removal of the SCSI pointer
from struct scsi_cmnd.

Link: https://lore.kernel.org/r/20220218195117.25689-13-bvanassche@acm.org
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Himanshu Madhani <himanshu.madhani@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Bart Van Assche 2022-02-18 11:50:40 -08:00 committed by Martin K. Petersen
parent d80624a2ae
commit 76a3451b64
4 changed files with 54 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
drivers/scsi/aacraid/aachba.c
View File

@ -338,7 +338,7 @@ static inline int aac_valid_context(struct scsi_cmnd *scsicmd,
aac_fib_complete(fibptr); aac_fib_complete(fibptr);
return 0; return 0;
} }
scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; aac_priv(scsicmd)->owner = AAC_OWNER_MIDLEVEL;
device = scsicmd->device; device = scsicmd->device;
if (unlikely(!device)) { if (unlikely(!device)) {
dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n")); dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n"));
@ -592,7 +592,7 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd)
aac_fib_init(cmd_fibcontext); aac_fib_init(cmd_fibcontext);
dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
dinfo->command = cpu_to_le32(VM_ContainerConfig); dinfo->command = cpu_to_le32(VM_ContainerConfig);
dinfo->type = cpu_to_le32(CT_READ_NAME); dinfo->type = cpu_to_le32(CT_READ_NAME);
@ -634,14 +634,15 @@ static void _aac_probe_container2(void * context, struct fib * fibptr)
{ {
struct fsa_dev_info *fsa_dev_ptr; struct fsa_dev_info *fsa_dev_ptr;
int (*callback)(struct scsi_cmnd *); int (*callback)(struct scsi_cmnd *);
struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; struct scsi_cmnd *scsicmd = context;
struct aac_cmd_priv *cmd_priv = aac_priv(scsicmd);
int i; int i;
if (!aac_valid_context(scsicmd, fibptr)) if (!aac_valid_context(scsicmd, fibptr))
return; return;
scsicmd->SCp.Status = 0; cmd_priv->status = 0;
fsa_dev_ptr = fibptr->dev->fsa_dev; fsa_dev_ptr = fibptr->dev->fsa_dev;
if (fsa_dev_ptr) { if (fsa_dev_ptr) {
struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr);
@ -679,12 +680,12 @@ static void _aac_probe_container2(void * context, struct fib * fibptr)
} }
if ((fsa_dev_ptr->valid & 1) == 0) if ((fsa_dev_ptr->valid & 1) == 0)
fsa_dev_ptr->valid = 0; fsa_dev_ptr->valid = 0;
scsicmd->SCp.Status = le32_to_cpu(dresp->count); cmd_priv->status = le32_to_cpu(dresp->count);
} }
aac_fib_complete(fibptr); aac_fib_complete(fibptr);
aac_fib_free(fibptr); aac_fib_free(fibptr);
callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); callback = cmd_priv->callback;
scsicmd->SCp.ptr = NULL; cmd_priv->callback = NULL;
(*callback)(scsicmd); (*callback)(scsicmd);
return; return;
} }
@ -722,7 +723,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
dinfo->count = cpu_to_le32(scmd_id(scsicmd)); dinfo->count = cpu_to_le32(scmd_id(scsicmd));
dinfo->type = cpu_to_le32(FT_FILESYS); dinfo->type = cpu_to_le32(FT_FILESYS);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_fib_send(ContainerCommand, status = aac_fib_send(ContainerCommand,
fibptr, fibptr,
@ -743,6 +744,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *))
{ {
struct aac_cmd_priv *cmd_priv = aac_priv(scsicmd);
struct fib * fibptr; struct fib * fibptr;
int status = -ENOMEM; int status = -ENOMEM;
@ -761,8 +763,8 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
dinfo->count = cpu_to_le32(scmd_id(scsicmd)); dinfo->count = cpu_to_le32(scmd_id(scsicmd));
dinfo->type = cpu_to_le32(FT_FILESYS); dinfo->type = cpu_to_le32(FT_FILESYS);
scsicmd->SCp.ptr = (char *)callback; cmd_priv->callback = callback;
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; cmd_priv->owner = AAC_OWNER_FIRMWARE;
status = aac_fib_send(ContainerCommand, status = aac_fib_send(ContainerCommand,
fibptr, fibptr,
@ -778,7 +780,7 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
return 0; return 0;
if (status < 0) { if (status < 0) {
scsicmd->SCp.ptr = NULL; cmd_priv->callback = NULL;
aac_fib_complete(fibptr); aac_fib_complete(fibptr);
aac_fib_free(fibptr); aac_fib_free(fibptr);
} }
@ -817,6 +819,7 @@ static void aac_probe_container_scsi_done(struct scsi_cmnd *scsi_cmnd)
int aac_probe_container(struct aac_dev *dev, int cid) int aac_probe_container(struct aac_dev *dev, int cid)
{ {
struct scsi_cmnd *scsicmd = kzalloc(sizeof(*scsicmd), GFP_KERNEL); struct scsi_cmnd *scsicmd = kzalloc(sizeof(*scsicmd), GFP_KERNEL);
struct aac_cmd_priv *cmd_priv = aac_priv(scsicmd);
struct scsi_device *scsidev = kzalloc(sizeof(*scsidev), GFP_KERNEL); struct scsi_device *scsidev = kzalloc(sizeof(*scsidev), GFP_KERNEL);
int status; int status;
@ -835,7 +838,7 @@ int aac_probe_container(struct aac_dev *dev, int cid)
while (scsicmd->device == scsidev) while (scsicmd->device == scsidev)
schedule(); schedule();
kfree(scsidev); kfree(scsidev);
status = scsicmd->SCp.Status; status = cmd_priv->status;
kfree(scsicmd); kfree(scsicmd);
return status; return status;
} }
@ -1128,7 +1131,7 @@ static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
dinfo->command = cpu_to_le32(VM_ContainerConfig); dinfo->command = cpu_to_le32(VM_ContainerConfig);
dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID); dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID);
dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_fib_send(ContainerCommand, status = aac_fib_send(ContainerCommand,
cmd_fibcontext, cmd_fibcontext,
@ -2486,7 +2489,7 @@ static int aac_read(struct scsi_cmnd * scsicmd)
* Alocate and initialize a Fib * Alocate and initialize a Fib
*/ */
cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count);
/* /*
@ -2577,7 +2580,7 @@ static int aac_write(struct scsi_cmnd * scsicmd)
* Allocate and initialize a Fib then setup a BlockWrite command * Allocate and initialize a Fib then setup a BlockWrite command
*/ */
cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua); status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
/* /*
@ -2660,7 +2663,7 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd)
synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd)); synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd));
synchronizecmd->count = synchronizecmd->count =
cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
/* /*
* Now send the Fib to the adapter * Now send the Fib to the adapter
@ -2736,7 +2739,7 @@ static int aac_start_stop(struct scsi_cmnd *scsicmd)
pmcmd->cid = cpu_to_le32(sdev_id(sdev)); pmcmd->cid = cpu_to_le32(sdev_id(sdev));
pmcmd->parm = (scsicmd->cmnd[1] & 1) ? pmcmd->parm = (scsicmd->cmnd[1] & 1) ?
cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0; cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0;
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
/* /*
* Now send the Fib to the adapter * Now send the Fib to the adapter
@ -3695,7 +3698,7 @@ void aac_hba_callback(void *context, struct fib *fibptr)
aac_fib_complete(fibptr); aac_fib_complete(fibptr);
if (fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF) if (fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF)
scsicmd->SCp.sent_command = 1; aac_priv(scsicmd)->sent_command = 1;
else else
aac_scsi_done(scsicmd); aac_scsi_done(scsicmd);
} }
@ -3725,7 +3728,7 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
* Allocate and initialize a Fib then setup a BlockWrite command * Allocate and initialize a Fib then setup a BlockWrite command
*/ */
cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_adapter_scsi(cmd_fibcontext, scsicmd); status = aac_adapter_scsi(cmd_fibcontext, scsicmd);
/* /*
@ -3769,7 +3772,7 @@ static int aac_send_hba_fib(struct scsi_cmnd *scsicmd)
if (!cmd_fibcontext) if (!cmd_fibcontext)
return -1; return -1;
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; aac_priv(scsicmd)->owner = AAC_OWNER_FIRMWARE;
status = aac_adapter_hba(cmd_fibcontext, scsicmd); status = aac_adapter_hba(cmd_fibcontext, scsicmd);
/* /*

24
drivers/scsi/aacraid/aacraid.h
View File

@ -29,6 +29,7 @@
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <scsi/scsi_host.h> #include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
/*------------------------------------------------------------------------------ /*------------------------------------------------------------------------------
* D E F I N E S * D E F I N E S
@ -2673,11 +2674,24 @@ static inline void aac_cancel_rescan_worker(struct aac_dev *dev)
cancel_delayed_work_sync(&dev->src_reinit_aif_worker); cancel_delayed_work_sync(&dev->src_reinit_aif_worker);
} }
/* SCp.phase values */ enum aac_cmd_owner {
#define AAC_OWNER_MIDLEVEL 0x101 AAC_OWNER_MIDLEVEL = 0x101,
#define AAC_OWNER_LOWLEVEL 0x102 AAC_OWNER_LOWLEVEL = 0x102,
#define AAC_OWNER_ERROR_HANDLER 0x103 AAC_OWNER_ERROR_HANDLER = 0x103,
#define AAC_OWNER_FIRMWARE 0x106 AAC_OWNER_FIRMWARE = 0x106,
};
struct aac_cmd_priv {
int (*callback)(struct scsi_cmnd *);
int status;
enum aac_cmd_owner owner;
bool sent_command;
};
static inline struct aac_cmd_priv *aac_priv(struct scsi_cmnd *cmd)
{
return scsi_cmd_priv(cmd);
}
void aac_safw_rescan_worker(struct work_struct *work); void aac_safw_rescan_worker(struct work_struct *work);
void aac_src_reinit_aif_worker(struct work_struct *work); void aac_src_reinit_aif_worker(struct work_struct *work);

2
drivers/scsi/aacraid/comminit.c
View File

@ -276,7 +276,7 @@ static bool wait_for_io_iter(struct scsi_cmnd *cmd, void *data, bool rsvd)
{ {
int *active = data; int *active = data;
if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) if (aac_priv(cmd)->owner == AAC_OWNER_FIRMWARE)
*active = *active + 1; *active = *active + 1;
return true; return true;
} }

21
drivers/scsi/aacraid/linit.c
View File

@ -241,10 +241,9 @@ static struct aac_driver_ident aac_drivers[] = {
static int aac_queuecommand(struct Scsi_Host *shost, static int aac_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmd) struct scsi_cmnd *cmd)
{ {
int r = 0; aac_priv(cmd)->owner = AAC_OWNER_LOWLEVEL;
cmd->SCp.phase = AAC_OWNER_LOWLEVEL;
r = (aac_scsi_cmd(cmd) ? FAILED : 0); return aac_scsi_cmd(cmd) ? FAILED : 0;
return r;
} }
/** /**
@ -638,7 +637,7 @@ static bool fib_count_iter(struct scsi_cmnd *scmnd, void *data, bool reserved)
{ {
struct fib_count_data *fib_count = data; struct fib_count_data *fib_count = data;
switch (scmnd->SCp.phase) { switch (aac_priv(scmnd)->owner) {
case AAC_OWNER_FIRMWARE: case AAC_OWNER_FIRMWARE:
fib_count->fwcnt++; fib_count->fwcnt++;
break; break;
@ -680,6 +679,7 @@ static int get_num_of_incomplete_fibs(struct aac_dev *aac)
static int aac_eh_abort(struct scsi_cmnd* cmd) static int aac_eh_abort(struct scsi_cmnd* cmd)
{ {
struct aac_cmd_priv *cmd_priv = aac_priv(cmd);
struct scsi_device * dev = cmd->device; struct scsi_device * dev = cmd->device;
struct Scsi_Host * host = dev->host; struct Scsi_Host * host = dev->host;
struct aac_dev * aac = (struct aac_dev *)host->hostdata; struct aac_dev * aac = (struct aac_dev *)host->hostdata;
@ -732,7 +732,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
tmf->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE); tmf->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
fib->hbacmd_size = sizeof(*tmf); fib->hbacmd_size = sizeof(*tmf);
cmd->SCp.sent_command = 0; cmd_priv->sent_command = 0;
status = aac_hba_send(HBA_IU_TYPE_SCSI_TM_REQ, fib, status = aac_hba_send(HBA_IU_TYPE_SCSI_TM_REQ, fib,
(fib_callback) aac_hba_callback, (fib_callback) aac_hba_callback,
@ -744,7 +744,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
} }
/* Wait up to 15 secs for completion */ /* Wait up to 15 secs for completion */
for (count = 0; count < 15; ++count) { for (count = 0; count < 15; ++count) {
if (cmd->SCp.sent_command) { if (cmd_priv->sent_command) {
ret = SUCCESS; ret = SUCCESS;
break; break;
} }
@ -784,7 +784,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
(fib->callback_data == cmd)) { (fib->callback_data == cmd)) {
fib->flags |= fib->flags |=
FIB_CONTEXT_FLAG_TIMED_OUT; FIB_CONTEXT_FLAG_TIMED_OUT;
cmd->SCp.phase = cmd_priv->owner =
AAC_OWNER_ERROR_HANDLER; AAC_OWNER_ERROR_HANDLER;
ret = SUCCESS; ret = SUCCESS;
} }
@ -811,7 +811,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
(command->device == cmd->device)) { (command->device == cmd->device)) {
fib->flags |= fib->flags |=
FIB_CONTEXT_FLAG_TIMED_OUT; FIB_CONTEXT_FLAG_TIMED_OUT;
command->SCp.phase = aac_priv(command)->owner =
AAC_OWNER_ERROR_HANDLER; AAC_OWNER_ERROR_HANDLER;
if (command == cmd) if (command == cmd)
ret = SUCCESS; ret = SUCCESS;
@ -1058,7 +1058,7 @@ static int aac_eh_bus_reset(struct scsi_cmnd* cmd)
if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS || if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS ||
info->devtype != AAC_DEVTYPE_NATIVE_RAW) { info->devtype != AAC_DEVTYPE_NATIVE_RAW) {
fib->flags |= FIB_CONTEXT_FLAG_EH_RESET; fib->flags |= FIB_CONTEXT_FLAG_EH_RESET;
cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; aac_priv(cmd)->owner = AAC_OWNER_ERROR_HANDLER;
} }
} }
} }
@ -1507,6 +1507,7 @@ static struct scsi_host_template aac_driver_template = {
#endif #endif
.emulated = 1, .emulated = 1,
.no_write_same = 1, .no_write_same = 1,
.cmd_size = sizeof(struct aac_cmd_priv),
}; };
static void __aac_shutdown(struct aac_dev * aac) static void __aac_shutdown(struct aac_dev * aac)