ibmvfc: initial MQ development
Subsystems (3)
Tyrel Datwyler
maintainerv4 cover ibmvfc: initial MQ development
Recent updates in pHyp Firmware and VIOS releases provide new infrastructure towards enabling Subordinate Command Response Queues (Sub-CRQs) such that each Sub-CRQ is a channel backed by an actual hardware queue in the FC stack on the partner VIOS. Sub-CRQs are registered with the firmware via hypercalls and then negotiated with the VIOS via new Management Datagrams (MADs) for channel setup.
This initial implementation adds the necessary Sub-CRQ framework and implements the new MADs for negotiating and assigning a set of Sub-CRQs to associated VIOS HW backed channels.
This latest series is completely rebased and reimplemented on top of the recent ("ibmvfc: MQ prepartory locking work") series. [1]
[1] https://lore.kernel.org/linux-scsi/[email protected]/
changes in v4:
* Series rebased and reworked on top of previous ibmvfc locking series
* Dropped all previous Reviewed-by tags
changes in v3:
* Patch 4: changed firmware support logging to dev_warn_once
* Patch 6: adjusted locking
* Patch 15: dropped logging verbosity, moved cancel event tracking into subqueue
* Patch 17: removed write permission for migration module parameters drive hard reset after update to num of scsi channels
changes in v2:
* Patch 4: NULL'd scsi_scrq reference after deallocation
* Patch 6: Added switch case to handle XPORT event
* Patch 9: fixed ibmvfc_event leak and double free
* added support for cancel command with MQ
* added parameter toggles for MQ settings
Tyrel Datwyler (21):
ibmvfc: add vhost fields and defaults for MQ enablement
ibmvfc: move event pool init/free routines
ibmvfc: init/free event pool during queue allocation/free
ibmvfc: add size parameter to ibmvfc_init_event_pool
ibmvfc: define hcall wrapper for registering a Sub-CRQ
ibmvfc: add Subordinate CRQ definitions
ibmvfc: add alloc/dealloc routines for SCSI Sub-CRQ Channels
ibmvfc: add Sub-CRQ IRQ enable/disable routine
ibmvfc: add handlers to drain and complete Sub-CRQ responses
ibmvfc: define Sub-CRQ interrupt handler routine
ibmvfc: map/request irq and register Sub-CRQ interrupt handler
ibmvfc: implement channel enquiry and setup commands
ibmvfc: advertise client support for using hardware channels
ibmvfc: set and track hw queue in ibmvfc_event struct
ibmvfc: send commands down HW Sub-CRQ when channelized
ibmvfc: register Sub-CRQ handles with VIOS during channel setup
ibmvfc: add cancel mad initialization helper
ibmvfc: send Cancel MAD down each hw scsi channel
ibmvfc: purge scsi channels after transport loss/reset
ibmvfc: enable MQ and set reasonable defaults
ibmvfc: provide modules parameters for MQ settings
drivers/scsi/ibmvscsi/ibmvfc.c | 914 ++++++++++++++++++++++++++++----- drivers/scsi/ibmvscsi/ibmvfc.h | 38 ++ 2 files changed, 824 insertions(+), 128 deletions(-)
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 1/21 ibmvfc: add vhost fields and defaults for MQ enablement
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +8 -0
@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1, };/**
@@ -5290,6 +5291,7 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) shost->max_sectors =IBMVFC_MAX_SECTORS ; shost->max_cmd_len =IBMVFC_MAX_CDB_LEN ; shost->unique_id = shost->host_no; + shost->nr_hw_queues =IBMVFC_MQ ?IBMVFC_SCSI_HW_QUEUES :1 ; vhost =shost_priv (shost);INIT_LIST_HEAD (&vhost->targets);
@@ -5300,6 +5302,12 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) vhost->partition_number =-1 ; vhost->log_level = log_level; vhost->task_set =1 ; + + vhost->mq_enabled =IBMVFC_MQ ; + vhost->client_scsi_channels =IBMVFC_SCSI_CHANNELS ; + vhost->using_channels =0 ; + vhost->do_enquiry =1 ; +strcpy (vhost->partition_name,"UNKNOWN" );init_waitqueue_head (&vhost->work_wait_q);init_waitqueue_head (&vhost->init_wait_q);
drivers/scsi/ibmvscsi/ibmvfc.h +9 -0
@@ -41,6 +41,11 @@#define IBMVFC_DEFAULT_LOG_LEVEL 2#define IBMVFC_MAX_CDB_LEN 16#define IBMVFC_CLS3_ERROR 0 +#define IBMVFC_MQ 0 +#define IBMVFC_SCSI_CHANNELS 0 +#define IBMVFC_SCSI_HW_QUEUES 1 +#define IBMVFC_MIG_NO_SUB_TO_CRQ 0 +#define IBMVFC_MIG_NO_N_TO_M 0/* * Ensure we have resources for ERP and initialization:
@@ -840,6 +845,10 @@ struct ibmvfc_host {int delay_init;int scan_complete;int logged_in; +int mq_enabled; +int using_channels; +int do_enquiry; +int client_scsi_channels;int aborting_passthru;int events_to_log;#define IBMVFC_AE_LINKUP 0x0001
Signature · 1 line
2.27.0
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 14 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)drivers/scsi/ibmvscsi/ibmvfc.c +0
-0
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 4 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,
Good to see another user :)
I didn't check the whole series very thoroughly, but I guess that you only need to set this when shost->nr_hw_queues > 1. Having said that, it should be fine when shost->nr_hw_queues = 0 or 1.
Thanks,
John
Quoted 52 lines
drivers/scsi/ibmvscsi/ibmvfc.c +7
-0};/** @@ -5290,6 +5291,7 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) shost->max_sectors =IBMVFC_MAX_SECTORS ; shost->max_cmd_len =IBMVFC_MAX_CDB_LEN ; shost->unique_id = shost->host_no; + shost->nr_hw_queues =IBMVFC_MQ ?IBMVFC_SCSI_HW_QUEUES :1 ; vhost =shost_priv (shost);INIT_LIST_HEAD (&vhost->targets);@@ -5300,6 +5302,12 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) vhost->partition_number =-1 ; vhost->log_level = log_level; vhost->task_set =1 ; + + vhost->mq_enabled =IBMVFC_MQ ; + vhost->client_scsi_channels =IBMVFC_SCSI_CHANNELS ; + vhost->using_channels =0 ; + vhost->do_enquiry =1 ; +strcpy (vhost->partition_name,"UNKNOWN" );init_waitqueue_head (&vhost->work_wait_q);init_waitqueue_head (&vhost->init_wait_q);drivers/scsi/ibmvscsi/ibmvfc.h +9
-0@@ -41,6 +41,11 @@#define IBMVFC_DEFAULT_LOG_LEVEL 2#define IBMVFC_MAX_CDB_LEN 16#define IBMVFC_CLS3_ERROR 0 +#define IBMVFC_MQ 0 +#define IBMVFC_SCSI_CHANNELS 0 +#define IBMVFC_SCSI_HW_QUEUES 1 +#define IBMVFC_MIG_NO_SUB_TO_CRQ 0 +#define IBMVFC_MIG_NO_N_TO_M 0/* * Ensure we have resources for ERP and initialization: @@ -840,6 +845,10 @@ struct ibmvfc_host {int delay_init;int scan_complete;int logged_in; +int mq_enabled; +int using_channels; +int do_enquiry; +int client_scsi_channels;int aborting_passthru;int events_to_log;#define IBMVFC_AE_LINKUP 0x0001
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
In reply to Tyrel DatwylerQuoted 14 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)drivers/scsi/ibmvscsi/ibmvfc.c +0
-0
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 4 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,
This doesn't seem right. You are setting host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host is can_queue. However, it looks like you are allocating max_requests events for each sub crq, which means you are over allocating memory.
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
The ibmvfc driver, which does the same thing the lpfc driver does, modifies can_queue on the scsi_host *after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look at can_queue once the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.
Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change can_queue.
Thanks,
Brian
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center
Tyrel Datwyler
maintainerRe: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 10 lines · Brian King
Quoted 9 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)
Quoted 14 lines
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 9 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,This doesn't seem right. You are setting
host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host iscan_queue. However, it looks like you are allocatingmax_requestsevents for each sub crq, which means you are over allocating memory.
With the shared tagset yes the queue depth for the host is can_queue, but this also implies that the max queue depth for each hw queue is also can_queue. So, in the worst case that all commands are queued down the same hw queue we need an event pool with can_queue commands.
Quoted 4 lines
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
From what I understand the max commands can only become less.
Quoted 11 lines
The ibmvfc driver, which does the same thing the lpfc driver does, modifies
can_queueon thescsi_host*after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look atcan_queueonce the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change
can_queue.
Changing can_queue won't do use any good with the shared tagset becasue each queue still needs to be able to queue can_queue number of commands in the worst case.
The complaint before was not using shared tags increases the tag memory allocation because they are statically allocated for each queue. The question is what claims more memory our event pool allocation or the tagset per queue allocation.
If we chose to not use the shared tagset then the queue depth for each hw queue becomes (can_queue / nr_hw_queues).
-Tyrel
Quoted 6 lines
Thanks,
Brian
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 45 lines · Tyrel Datwyler
Quoted 10 lines · Brian King
Quoted 9 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)Quoted 14 lines
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 9 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,This doesn't seem right. You are setting
host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host iscan_queue. However, it looks like you are allocatingmax_requestsevents for each sub crq, which means you are over allocating memory.With the shared tagset yes the queue depth for the host is
can_queue, but this also implies that the max queue depth for each hw queue is alsocan_queue. So, in the worst case that all commands are queued down the same hw queue we need an event pool withcan_queuecommands.Quoted 4 lines
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
From what I understand the max commands can only become less.
Quoted 7 lines
The ibmvfc driver, which does the same thing the lpfc driver does, modifies
can_queueon thescsi_host*after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look atcan_queueonce the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.
Quoted 8 lines
Quoted 4 lines
Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change
can_queue.Changing
can_queuewon't do use any good with the shared tagset becasue each queue still needs to be able to queuecan_queuenumber of commands in the worst case.
The issue I'm trying to highlight here is the following scenario:
1. We set shost->can_queue, then call scsi_add_host, which allocates the tag set.
2. On our NPIV login response from the VIOS, we might get a lower value than we initially set in shost->can_queue, so we update it, but nobody ever looks at it again, and we don't have any protection against sending too many commands to the host.
Basically, we no longer have any code that ensures we don't send more commands to the VIOS than we are told it supports. According to the architecture, if we actually do this, the VIOS will do an h_free_crq, which would be a bit of a bug on our part.
I don't think it was ever clearly defined in the API that a driver can change shost->can_queue after calling scsi_add_host, but up until commit 6eb045e092efefafc6687409a6fa6d1dabf0fb69, this worked and now it doesn't.
I started looking through drivers that do this, and so far, it looks like the following drivers do: ibmvfc, lpfc, aix94xx, libfc, BusLogic, and likely others...
We probably need an API that lets us change shost->can_queue dynamically.
Thanks,
Brian
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 69 lines · Brian King
Quoted 45 lines · Tyrel Datwyler
Quoted 10 lines · Brian King
Quoted 9 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)Quoted 14 lines
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 9 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,This doesn't seem right. You are setting
host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host iscan_queue. However, it looks like you are allocatingmax_requestsevents for each sub crq, which means you are over allocating memory.With the shared tagset yes the queue depth for the host is
can_queue, but this also implies that the max queue depth for each hw queue is alsocan_queue. So, in the worst case that all commands are queued down the same hw queue we need an event pool withcan_queuecommands.Quoted 4 lines
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
From what I understand the max commands can only become less.
Quoted 7 lines
The ibmvfc driver, which does the same thing the lpfc driver does, modifies
can_queueon thescsi_host*after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look atcan_queueonce the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.Quoted 8 lines
Quoted 4 lines
Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change
can_queue.Changing
can_queuewon't do use any good with the shared tagset becasue each queue still needs to be able to queuecan_queuenumber of commands in the worst case.The issue I'm trying to highlight here is the following scenario:
1. We set
shost->can_queue, then callscsi_add_host, which allocates the tag set.2. On our NPIV login response from the VIOS, we might get a lower value than we initially set in
shost->can_queue, so we update it, but nobody ever looks at it again, and we don't have any protection against sending too many commands to the host.Basically, we no longer have any code that ensures we don't send more commands to the VIOS than we are told it supports. According to the architecture, if we actually do this, the VIOS will do an
h_free_crq, which would be a bit of a bug on our part.
Quoted 4 lines
I don't think it was ever clearly defined in the API that a driver can change
shost->can_queueafter callingscsi_add_host, but up until commit6eb045e092efefafc6687409a6fa6d1dabf0fb69, this worked and now it doesn't.
Actually it isn't related with commit 6eb045e092ef, because blk_mq_alloc_tag_set() uses .can_queue to create driver tag sbitmap and request pool.
So even thought without 6eb045e092ef, the updated .can_queue can't work as expected because the max driver tag depth has been fixed by blk-mq already.
What 6eb045e092ef does is just to remove the double check on max host-wide allowed commands because that has been respected by blk-mq driver tag allocation already.
Quoted 5 lines
I started looking through drivers that do this, and so far, it looks like the following drivers do: ibmvfc, lpfc, aix94xx, libfc, BusLogic, and likely others...
We probably need an API that lets us change
shost->can_queuedynamically.
I'd suggest to confirm changing .can_queue is one real usecase.
Thanks,
Ming
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 75 lines · Ming Lei
Quoted 69 lines · Brian King
Quoted 45 lines · Tyrel Datwyler
Quoted 10 lines · Brian King
Quoted 9 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)Quoted 14 lines
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 9 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,This doesn't seem right. You are setting
host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host iscan_queue. However, it looks like you are allocatingmax_requestsevents for each sub crq, which means you are over allocating memory.With the shared tagset yes the queue depth for the host is
can_queue, but this also implies that the max queue depth for each hw queue is alsocan_queue. So, in the worst case that all commands are queued down the same hw queue we need an event pool withcan_queuecommands.Quoted 4 lines
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
From what I understand the max commands can only become less.
Quoted 7 lines
The ibmvfc driver, which does the same thing the lpfc driver does, modifies
can_queueon thescsi_host*after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look atcan_queueonce the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.Quoted 8 lines
Quoted 4 lines
Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change
can_queue.Changing
can_queuewon't do use any good with the shared tagset becasue each queue still needs to be able to queuecan_queuenumber of commands in the worst case.The issue I'm trying to highlight here is the following scenario:
1. We set
shost->can_queue, then callscsi_add_host, which allocates the tag set.2. On our NPIV login response from the VIOS, we might get a lower value than we initially set in
shost->can_queue, so we update it, but nobody ever looks at it again, and we don't have any protection against sending too many commands to the host.Basically, we no longer have any code that ensures we don't send more commands to the VIOS than we are told it supports. According to the architecture, if we actually do this, the VIOS will do an
h_free_crq, which would be a bit of a bug on our part.Quoted 4 lines
I don't think it was ever clearly defined in the API that a driver can change
shost->can_queueafter callingscsi_add_host, but up until commit6eb045e092efefafc6687409a6fa6d1dabf0fb69, this worked and now it doesn't.
Quoted 5 lines
Actually it isn't related with commit
6eb045e092ef, becauseblk_mq_alloc_tag_set()uses .can_queue to create driver tag sbitmap and request pool.So even thought without
6eb045e092ef, the updated .can_queue can't work as expected because the max driver tag depth has been fixed by blk-mq already.
There are two scenarios here. In the scenario of someone increasing can_queue after the tag set is allocated, I agree, blk-mq will never take advantage of this. However, in the scenario of someone *decreasing* can_queue after the tag set is allocated, prior to 6eb045e092ef, the shost->host_busy code provided this protection.
Quoted 6 lines
What
6eb045e092efdoes is just to remove the double check on max host-wide allowed commands because that has been respected by blk-mq driver tag allocation already.Quoted 1 line
Quoted 6 lines
Quoted 4 lines
I started looking through drivers that do this, and so far, it looks like the following drivers do: ibmvfc, lpfc, aix94xx, libfc, BusLogic, and likely others...
We probably need an API that lets us change
shost->can_queuedynamically.I'd suggest to confirm changing .can_queue is one real usecase.
For ibmvfc, the total number of commands that the scsi host supports is very much a dynamic value. It can increase and it can decrease. Live migrating a logical partition from one system to another is the usual cause of such a capability change. For ibmvfc, at least, this only ever happens when we've self blocked the host and have sent back all outstanding I/O.
However, looking at other drivers that modify can_queue dynamically, this doesn't always hold true. Looking at libfc, it looks to dynamically ramp up and ramp down can_queue based on its ability to handle requests.
There are certainly a number of other drivers that change can_queue after the tag set has been allocated. Some of these drivers could likely be changed to avoid doing this, but changing them all will likely be difficult.
Thanks,
Brian
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center
Re: [PATCH v4 01/21] ibmvfc: add vhost fields and defaults for MQ enablement
Quoted 79 lines · Brian King
Quoted 78 lines · Ming Lei
Quoted 69 lines · Brian King
Quoted 45 lines · Tyrel Datwyler
Quoted 10 lines · Brian King
Quoted 9 lines · Tyrel Datwyler
Introduce several new vhost fields for managing MQ state of the adapter as well as initial defaults for MQ enablement.
Signed-off-by Tyrel Datwyler <[email protected]>--- drivers/scsi/ibmvscsi/ibmvfc.c | 8 ++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 9 +++++++++ 2 files changed, 17 insertions(+)Quoted 14 lines
drivers/scsi/ibmvscsi/ibmvfc.c static struct scsi_host_template driver_template = { · line 3305
Quoted 9 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -3302,6 +3302,7 @@ static struct scsi_host_template driver_template = { .max_sectors = IBMVFC_MAX_SECTORS, .shost_attrs = ibmvfc_attrs, .track_queue_depth = 1, + .host_tagset = 1,This doesn't seem right. You are setting
host_tagset, which means you want a shared, host wide, tag set for commands. It also means that the total queue depth for the host iscan_queue. However, it looks like you are allocatingmax_requestsevents for each sub crq, which means you are over allocating memory.With the shared tagset yes the queue depth for the host is
can_queue, but this also implies that the max queue depth for each hw queue is alsocan_queue. So, in the worst case that all commands are queued down the same hw queue we need an event pool withcan_queuecommands.Quoted 4 lines
Looking at this closer, we might have bigger problems. There is a host wide max number of commands that the VFC host supports, which gets returned on NPIV Login. This value can change across a live migration event.
From what I understand the max commands can only become less.
Quoted 7 lines
The ibmvfc driver, which does the same thing the lpfc driver does, modifies
can_queueon thescsi_host*after* the tag set has been allocated. This looks to be a concern with ibmvfc, not sure about lpfc, as it doesn't look like we look atcan_queueonce the tag set is setup, and I'm not seeing a good way to dynamically change the host queue depth once the tag set is setup.Quoted 8 lines
Quoted 4 lines
Unless I'm missing something, our best options appear to either be to implement our own host wide busy reference counting, which doesn't sound very good, or we need to add some API to block / scsi that allows us to dynamically change
can_queue.Changing
can_queuewon't do use any good with the shared tagset becasue each queue still needs to be able to queuecan_queuenumber of commands in the worst case.The issue I'm trying to highlight here is the following scenario:
1. We set
shost->can_queue, then callscsi_add_host, which allocates the tag set.2. On our NPIV login response from the VIOS, we might get a lower value than we initially set in
shost->can_queue, so we update it, but nobody ever looks at it again, and we don't have any protection against sending too many commands to the host.Basically, we no longer have any code that ensures we don't send more commands to the VIOS than we are told it supports. According to the architecture, if we actually do this, the VIOS will do an
h_free_crq, which would be a bit of a bug on our part.Quoted 4 lines
I don't think it was ever clearly defined in the API that a driver can change
shost->can_queueafter callingscsi_add_host, but up until commit6eb045e092efefafc6687409a6fa6d1dabf0fb69, this worked and now it doesn't.Actually it isn't related with commit
6eb045e092ef, becauseblk_mq_alloc_tag_set()uses .can_queue to create driver tag sbitmap and request pool.
Quoted 8 lines
Quoted 2 lines
So even thought without
6eb045e092ef, the updated .can_queue can't work as expected because the max driver tag depth has been fixed by blk-mq already.There are two scenarios here. In the scenario of someone increasing
can_queueafter the tag set is allocated, I agree, blk-mq will never take advantage of this. However, in the scenario of someone *decreasing*can_queueafter the tag set is allocated, prior to6eb045e092ef, theshost->host_busycode provided this protection.
When .can_queue is decreased, blk-mq still may allocate driver tag which is > .can_queue, this way might break driver/device too, but it depends on how driver uses req->tag.
Quoted 12 lines
Quoted 12 lines
What
6eb045e092efdoes is just to remove the double check on max host-wide allowed commands because that has been respected by blk-mq driver tag allocation already.Quoted 5 lines
I started looking through drivers that do this, and so far, it looks like the following drivers do: ibmvfc, lpfc, aix94xx, libfc, BusLogic, and likely others...
We probably need an API that lets us change
shost->can_queuedynamically.
Quoted 7 lines
Quoted 1 line
I'd suggest to confirm changing .can_queue is one real usecase.
For ibmvfc, the total number of commands that the scsi host supports is very much a dynamic value. It can increase and it can decrease. Live migrating a logical partition from one system to another is the usual cause of such a capability change. For ibmvfc, at least, this only ever happens when we've self blocked the host and have sent back all outstanding I/O.
This one looks a good use case, and the new API may have to freeze request queues of all LUNs, and the operation is very expensive and slow.
Quoted 4 lines
However, looking at other drivers that modify
can_queuedynamically, this doesn't always hold true. Looking at libfc, it looks to dynamically ramp up and ramp downcan_queuebased on its ability to handle requests.
This one looks hard to use the new API which isn't supposed to be called in fast path. And changing host wide resource is really not good in fast path, IMO.
Quoted 5 lines
There are certainly a number of other drivers that change
can_queueafter the tag set has been allocated. Some of these drivers could likely be changed to avoid doing this, but changing them all will likely be difficult.
It is still better to understand why these drivers have to update .can_queue dynamically.
Thanks,
Ming
Tyrel Datwyler
maintainerPATCH v4 2/21 ibmvfc: move event pool init/free routines
In reply to Tyrel DatwylerThe next patch in this series reworks the event pool allocation calls to happen within the individual queue allocation routines instead of as independent calls.
Move the init/free routines earlier in ibmvfc.c to prevent undefined reference errors when calling these functions from the queue allocation code. No functional change.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 151 +++++++++++++++++---------------- 1 file changed, 76 insertions(+), 75 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +76 -75
@@ -716,6 +716,82 @@ static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)return ibmvfc_send_crq (vhost,0xC002000000000000LL ,0 ); } +/** +* ibmvfc_init_event_pool - Allocates and initializes the event pool for a host +* @vhost: ibmvfc host who owns the event pool +* +* Returns zero on success. +**/ +static int ibmvfc_init_event_pool (struct ibmvfc_host *vhost, +struct ibmvfc_queue *queue) +{ +int i; +struct ibmvfc_event_pool *pool = &queue->evt_pool; + +ENTER ; + pool->size = max_requests +IBMVFC_NUM_INTERNAL_REQ ; + pool->events =kcalloc (pool->size,sizeof (*pool->events),GFP_KERNEL ); +if (!pool->events) +return -ENOMEM ; + + pool->iu_storage =dma_alloc_coherent (vhost->dev, + pool->size *sizeof (*pool->iu_storage), + &pool->iu_token,0 ); + +if (!pool->iu_storage) { +kfree (pool->events); +return -ENOMEM ; + } + +INIT_LIST_HEAD (&queue->sent); +INIT_LIST_HEAD (&queue->free); +spin_lock_init (&queue->l_lock); + +for (i =0 ; i < pool->size; ++i) { +struct ibmvfc_event *evt = &pool->events[i]; + +atomic_set (&evt->free,1 ); + evt->crq.valid =0x80 ; + evt->crq.ioba =cpu_to_be64 (pool->iu_token + (sizeof (*evt->xfer_iu) * i)); + evt->xfer_iu = pool->iu_storage + i; + evt->vhost = vhost; + evt->queue = queue; + evt->ext_list =NULL ; +list_add_tail (&evt->queue_list, &queue->free); + } + +LEAVE ; +return 0 ; +} + +/** +* ibmvfc_free_event_pool - Frees memory of the event pool of a host +* @vhost: ibmvfc host who owns the event pool +* +**/ +static void ibmvfc_free_event_pool (struct ibmvfc_host *vhost, +struct ibmvfc_queue *queue) +{ +int i; +struct ibmvfc_event_pool *pool = &queue->evt_pool; + +ENTER ; +for (i =0 ; i < pool->size; ++i) { +list_del (&pool->events[i].queue_list); +BUG_ON (atomic_read (&pool->events[i].free) !=1 ); +if (pool->events[i].ext_list) +dma_pool_free (vhost->sg_pool, + pool->events[i].ext_list, + pool->events[i].ext_list_token); + } + +kfree (pool->events); +dma_free_coherent (vhost->dev, + pool->size *sizeof (*pool->iu_storage), + pool->iu_storage, pool->iu_token); +LEAVE ; +} +/** * ibmvfc_free_queue - Deallocate queue * @vhost: ibmvfc host struct
@@ -1312,81 +1388,6 @@ static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)strncpy (login_info->drc_name, location,IBMVFC_MAX_NAME ); } -/** -* ibmvfc_init_event_pool - Allocates and initializes the event pool for a host -* @vhost: ibmvfc host who owns the event pool -* -* Returns zero on success. -**/ -static int ibmvfc_init_event_pool (struct ibmvfc_host *vhost, -struct ibmvfc_queue *queue) -{ -int i; -struct ibmvfc_event_pool *pool = &queue->evt_pool; - -ENTER ; - pool->size = max_requests +IBMVFC_NUM_INTERNAL_REQ ; - pool->events =kcalloc (pool->size,sizeof (*pool->events),GFP_KERNEL ); -if (!pool->events) -return -ENOMEM ; - - pool->iu_storage =dma_alloc_coherent (vhost->dev, - pool->size *sizeof (*pool->iu_storage), - &pool->iu_token,0 ); - -if (!pool->iu_storage) { -kfree (pool->events); -return -ENOMEM ; - } - -INIT_LIST_HEAD (&queue->sent); -INIT_LIST_HEAD (&queue->free); -spin_lock_init (&queue->l_lock); - -for (i =0 ; i < pool->size; ++i) { -struct ibmvfc_event *evt = &pool->events[i]; -atomic_set (&evt->free,1 ); - evt->crq.valid =0x80 ; - evt->crq.ioba =cpu_to_be64 (pool->iu_token + (sizeof (*evt->xfer_iu) * i)); - evt->xfer_iu = pool->iu_storage + i; - evt->vhost = vhost; - evt->queue = queue; - evt->ext_list =NULL ; -list_add_tail (&evt->queue_list, &queue->free); - } - -LEAVE ; -return 0 ; -} - -/** -* ibmvfc_free_event_pool - Frees memory of the event pool of a host -* @vhost: ibmvfc host who owns the event pool -* -**/ -static void ibmvfc_free_event_pool (struct ibmvfc_host *vhost, -struct ibmvfc_queue *queue) -{ -int i; -struct ibmvfc_event_pool *pool = &queue->evt_pool; - -ENTER ; -for (i =0 ; i < pool->size; ++i) { -list_del (&pool->events[i].queue_list); -BUG_ON (atomic_read (&pool->events[i].free) !=1 ); -if (pool->events[i].ext_list) -dma_pool_free (vhost->sg_pool, - pool->events[i].ext_list, - pool->events[i].ext_list_token); - } - -kfree (pool->events); -dma_free_coherent (vhost->dev, - pool->size *sizeof (*pool->iu_storage), - pool->iu_storage, pool->iu_token); -LEAVE ; -} -/** * ibmvfc_get_event - Gets the next free event in pool * @vhost: ibmvfc host struct
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 3/21 ibmvfc: init/free event pool during queue allocation/free
In reply to Tyrel DatwylerThe event pool and CRQ used to be separate entities of the adapter host structure and as such were allocated and freed independently of each other. Recent work as defined a generic queue structure with an event pool specific to each queue. As such the event pool for each queue shouldn't be allocated/freed independently, but instead performed as part of the queue allocation/free routines.
Move the calls to ibmvfc_event_pool_{init|free} into ibmvfc_{alloc|free}_queue respectively. The only functional change here is that the CRQ cannot be released in ibmvfc_remove until after the event pool has been successfully purged since releasing the queue will also free the event pool.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +8 -10
@@ -807,6 +807,8 @@ static void ibmvfc_free_queue(struct ibmvfc_host *vhost,dma_unmap_single (dev, queue->msg_token,PAGE_SIZE ,DMA_BIDIRECTIONAL );free_page ((unsigned long )queue->msgs.handle); queue->msgs.handle =NULL ; + +ibmvfc_free_event_pool (vhost, queue); }/**
@@ -5019,6 +5021,10 @@ static int ibmvfc_alloc_queue(struct ibmvfc_host *vhost,switch (fmt) {case IBMVFC_CRQ_FMT : fmt_size =sizeof (*queue->msgs.crq); +if (ibmvfc_init_event_pool (vhost, queue)) { +dev_err (dev,"Couldn't initialize event pool.\n" ); +return -ENOMEM ; + }break ;case IBMVFC_ASYNC_FMT : fmt_size =sizeof (*queue->msgs.async);
@@ -5333,13 +5339,8 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) goto kill_kthread; } -if ((rc =ibmvfc_init_event_pool (vhost, &vhost->crq))) { -dev_err (dev,"Couldn't initialize event pool. rc=%d\n" , rc); - goto release_crq; - } -if ((rc =scsi_add_host (shost, dev))) - goto release_event_pool; + goto release_crq;fc_host_dev_loss_tmo (shost) =IBMVFC_DEV_LOSS_TMO ;
@@ -5362,8 +5363,6 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) remove_shost:scsi_remove_host (shost); -release_event_pool: -ibmvfc_free_event_pool (vhost, &vhost->crq); release_crq:ibmvfc_release_crq_queue (vhost); kill_kthread:
@@ -5398,7 +5397,6 @@ static int ibmvfc_remove(struct vio_dev *vdev)spin_unlock_irqrestore (vhost->host->host_lock, flags);ibmvfc_wait_while_resetting (vhost); -ibmvfc_release_crq_queue (vhost);kthread_stop (vhost->work_thread);fc_remove_host (vhost->host);scsi_remove_host (vhost->host);
@@ -5408,7 +5406,7 @@ static int ibmvfc_remove(struct vio_dev *vdev)list_splice_init (&vhost->purge, &purge);spin_unlock_irqrestore (vhost->host->host_lock, flags);ibmvfc_complete_purge (&purge); -ibmvfc_free_event_pool (vhost, &vhost->crq); +ibmvfc_release_crq_queue (vhost);ibmvfc_free_mem (vhost);spin_lock (&ibmvfc_driver_lock);
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 4/21 ibmvfc: add size parameter to ibmvfc_init_event_pool
In reply to Tyrel DatwylerWith the upcoming addition of Sub-CRQs the event pool size may vary per-queue.
Add a size parameter to ibmvfc_init_event_pool such that different size event pools can be requested by ibmvfc_alloc_queue.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +16 -9
@@ -723,19 +723,23 @@ static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)* Returns zero on success. **/ static int ibmvfc_init_event_pool (struct ibmvfc_host *vhost, -struct ibmvfc_queue *queue) +struct ibmvfc_queue *queue, +unsigned int size) {int i;struct ibmvfc_event_pool *pool = &queue->evt_pool;ENTER ; - pool->size = max_requests +IBMVFC_NUM_INTERNAL_REQ ; - pool->events =kcalloc (pool->size,sizeof (*pool->events),GFP_KERNEL ); +if (!size) +return 0 ; + + pool->size = size; + pool->events =kcalloc (size,sizeof (*pool->events),GFP_KERNEL );if (!pool->events)return -ENOMEM ; pool->iu_storage =dma_alloc_coherent (vhost->dev, - pool->size *sizeof (*pool->iu_storage), + size *sizeof (*pool->iu_storage), &pool->iu_token,0 );if (!pool->iu_storage) {
@@ -747,7 +751,7 @@ static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost,INIT_LIST_HEAD (&queue->free);spin_lock_init (&queue->l_lock); -for (i =0 ; i < pool->size; ++i) { +for (i =0 ; i < size; ++i) {struct ibmvfc_event *evt = &pool->events[i];atomic_set (&evt->free,1 );
@@ -5013,6 +5017,7 @@ static int ibmvfc_alloc_queue(struct ibmvfc_host *vhost, {struct device *dev = vhost->dev;size_t fmt_size; +unsigned int pool_size =0 ;ENTER ;spin_lock_init (&queue->_lock);
@@ -5021,10 +5026,7 @@ static int ibmvfc_alloc_queue(struct ibmvfc_host *vhost,switch (fmt) {case IBMVFC_CRQ_FMT : fmt_size =sizeof (*queue->msgs.crq); -if (ibmvfc_init_event_pool (vhost, queue)) { -dev_err (dev,"Couldn't initialize event pool.\n" ); -return -ENOMEM ; - } + pool_size = max_requests +IBMVFC_NUM_INTERNAL_REQ ;break ;case IBMVFC_ASYNC_FMT : fmt_size =sizeof (*queue->msgs.async);
@@ -5034,6 +5036,11 @@ static int ibmvfc_alloc_queue(struct ibmvfc_host *vhost,return -EINVAL ; } +if (ibmvfc_init_event_pool (vhost, queue, pool_size)) { +dev_err (dev,"Couldn't initialize event pool.\n" ); +return -ENOMEM ; + } + queue->msgs.handle = (void *)get_zeroed_page (GFP_KERNEL );if (!queue->msgs.handle)return -ENOMEM ;
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 5/21 ibmvfc: define hcall wrapper for registering a Sub-CRQ
In reply to Tyrel DatwylerSub-CRQs are registred with firmware via a hypercall. Abstract that interface into a simpler helper function.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +14 -0
@@ -138,6 +138,20 @@ static void ibmvfc_tgt_move_login(struct ibmvfc_target *);static const char *unknown_error ="unknown error" ; +static long h_reg_sub_crq (unsigned long unit_address,unsigned long ioba, +unsigned long length,unsigned long *cookie, +unsigned long *irq) +{ +unsigned long retbuf[PLPAR_HCALL_BUFSIZE ]; +long rc; + + rc =plpar_hcall (H_REG_SUB_CRQ , retbuf, unit_address, ioba, length); + *cookie = retbuf[0 ]; + *irq = retbuf[1 ]; + +return rc; +} +static int ibmvfc_check_caps (struct ibmvfc_host *vhost,unsigned long cap_flags) {u64 host_caps =be64_to_cpu (vhost->login_buf->resp.capabilities);
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 6/21 ibmvfc: add Subordinate CRQ definitions
In reply to Tyrel DatwylerSubordinate Command Response Queues (Sub CRQ) are used in conjunction with the primary CRQ when more than one queue is needed by the virtual IO adapter. Recent phyp firmware versions support Sub CRQ's with ibmvfc adapters. This feature is a prerequisite for supporting multiple hardware backed submission queues in the vfc adapter.
The Sub CRQ command element differs from the standard CRQ in that it is 32bytes long as opposed to 16bytes for the latter. Despite this extra 16bytes the ibmvfc protocol will use the original CRQ command element mapped to the first 16bytes of the Sub CRQ element initially.
Add definitions for the Sub CRQ command element and queue.
--- drivers/scsi/ibmvscsi/ibmvfc.h | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.h +21 -0
@@ -650,6 +650,11 @@ struct ibmvfc_crq {volatile __be64 ioba; } __packed__aligned(8) ; +struct ibmvfc_sub_crq { +struct ibmvfc_crq crq; +__be64 reserved[2 ]; +} __packed__aligned(8) ; +enum ibmvfc_ae_link_state {IBMVFC_AE_LS_LINK_UP =0x01 ,IBMVFC_AE_LS_LINK_BOUNCED =0x02 ,
@@ -761,12 +766,14 @@ struct ibmvfc_event_pool {enum ibmvfc_msg_fmt {IBMVFC_CRQ_FMT =0 ,IBMVFC_ASYNC_FMT , +IBMVFC_SUB_CRQ_FMT , };union ibmvfc_msgs {void *handle;struct ibmvfc_crq *crq;struct ibmvfc_async_crq *async; +struct ibmvfc_sub_crq *scrq; };struct ibmvfc_queue {
@@ -781,6 +788,20 @@ struct ibmvfc_queue {struct list_head sent;struct list_head free;spinlock_t l_lock; + +/* Sub-CRQ fields */ +struct ibmvfc_host *vhost; +unsigned long cookie; +unsigned long vios_cookie; +unsigned long hw_irq; +unsigned long irq; +unsigned long hwq_id; +char name[32 ]; +}; + +struct ibmvfc_scsi_channels { +struct ibmvfc_queue *scrqs; +unsigned int active_queues; };enum ibmvfc_host_action {
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 7/21 ibmvfc: add alloc/dealloc routines for SCSI Sub-CRQ Channels
In reply to Tyrel DatwylerAllocate a set of Sub-CRQs in advance. During channel setup the client and VIOS negotiate the number of queues the VIOS supports and the number that the client desires to request. Its possible that the final channel resources allocated is less than requested, but the client is still responsible for sending handles for every queue it is hoping for.
Also, provide deallocation cleanup routines.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 125 +++++++++++++++++++++++++++++++++ drivers/scsi/ibmvscsi/ibmvfc.h | 1 + 2 files changed, 126 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +125 -0
@@ -895,6 +895,8 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)unsigned long flags;struct vio_dev *vdev =to_vio_dev (vhost->dev);struct ibmvfc_queue *crq = &vhost->crq; +struct ibmvfc_queue *scrq; +int i;/* Close the CRQ */ do {
@@ -912,6 +914,16 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)memset (crq->msgs.crq,0 ,PAGE_SIZE ); crq->cur =0 ; +if (vhost->scsi_scrqs.scrqs) { +for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) { + scrq = &vhost->scsi_scrqs.scrqs[i]; +spin_lock (scrq->q_lock); +memset (scrq->msgs.scrq,0 ,PAGE_SIZE ); + scrq->cur =0 ; +spin_unlock (scrq->q_lock); + } + } +/* And re-open it again */ rc =plpar_hcall_norets (H_REG_CRQ , vdev->unit_address, crq->msg_token,PAGE_SIZE );
@@ -5045,6 +5057,11 @@ static int ibmvfc_alloc_queue(struct ibmvfc_host *vhost,case IBMVFC_ASYNC_FMT : fmt_size =sizeof (*queue->msgs.async);break ; +case IBMVFC_SUB_CRQ_FMT : + fmt_size =sizeof (*queue->msgs.scrq); +/* We need one extra event for Cancel Commands */ + pool_size = max_requests +1 ; +break ;default :dev_warn (dev,"Unknown command/response queue message format: %d\n" , fmt);return -EINVAL ;
@@ -5136,6 +5153,107 @@ static int ibmvfc_init_crq(struct ibmvfc_host *vhost)return retrc; } +static int ibmvfc_register_scsi_channel (struct ibmvfc_host *vhost, +int index) +{ +struct device *dev = vhost->dev; +struct vio_dev *vdev =to_vio_dev (dev); +struct ibmvfc_queue *scrq = &vhost->scsi_scrqs.scrqs[index]; +int rc = -ENOMEM ; + +ENTER ; + +if (ibmvfc_alloc_queue (vhost, scrq,IBMVFC_SUB_CRQ_FMT )) +return -ENOMEM ; + + rc =h_reg_sub_crq (vdev->unit_address, scrq->msg_token,PAGE_SIZE , + &scrq->cookie, &scrq->hw_irq); + +if (rc) { +dev_warn (dev,"Error registering sub-crq: %d\n" , rc); +if (rc ==H_PARAMETER ) +dev_warn_once (dev,"Firmware may not support MQ\n" ); + goto reg_failed; + } + + scrq->hwq_id = index; + scrq->vhost = vhost; + +LEAVE ; +return 0 ; + +reg_failed: +ibmvfc_free_queue (vhost, scrq); +LEAVE ; +return rc; +} + +static void ibmvfc_deregister_scsi_channel (struct ibmvfc_host *vhost,int index) +{ +struct device *dev = vhost->dev; +struct vio_dev *vdev =to_vio_dev (dev); +struct ibmvfc_queue *scrq = &vhost->scsi_scrqs.scrqs[index]; +long rc; + +ENTER ; + +do { + rc =plpar_hcall_norets (H_FREE_SUB_CRQ , vdev->unit_address, + scrq->cookie); + }while (rc ==H_BUSY ||H_IS_LONG_BUSY (rc)); + +if (rc) +dev_err (dev,"Failed to free sub-crq[%d]: rc=%ld\n" , index, rc); + +ibmvfc_free_queue (vhost, scrq); +LEAVE ; +} + +static int ibmvfc_init_sub_crqs (struct ibmvfc_host *vhost) +{ +int i, j; + +ENTER ; + + vhost->scsi_scrqs.scrqs =kcalloc (IBMVFC_SCSI_HW_QUEUES , +sizeof (*vhost->scsi_scrqs.scrqs), +GFP_KERNEL ); +if (!vhost->scsi_scrqs.scrqs) +return -1 ; + +for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) { +if (ibmvfc_register_scsi_channel (vhost, i)) { +for (j = i; j >0 ; j--) +ibmvfc_deregister_scsi_channel (vhost, j -1 ); +kfree (vhost->scsi_scrqs.scrqs); + vhost->scsi_scrqs.scrqs =NULL ; + vhost->scsi_scrqs.active_queues =0 ; +LEAVE ; +return -1 ; + } + } + +LEAVE ; +return 0 ; +} + +static void ibmvfc_release_sub_crqs (struct ibmvfc_host *vhost) +{ +int i; + +ENTER ; +if (!vhost->scsi_scrqs.scrqs) +return ; + +for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) +ibmvfc_deregister_scsi_channel (vhost, i); + +kfree (vhost->scsi_scrqs.scrqs); + vhost->scsi_scrqs.scrqs =NULL ; + vhost->scsi_scrqs.active_queues =0 ; +LEAVE ; +} +/** * ibmvfc_free_mem - Free memory for vhost * @vhost: ibmvfc host struct
@@ -5371,6 +5489,12 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) goto remove_shost; } +if (vhost->mq_enabled) { + rc =ibmvfc_init_sub_crqs (vhost); +if (rc) +dev_warn (dev,"Failed to allocate Sub-CRQs. rc=%d\n" , rc); + } +if (shost_to_fc_host (shost)->rqst_q)blk_queue_max_segments (shost_to_fc_host (shost)->rqst_q,1 );dev_set_drvdata (dev, vhost);
@@ -5427,6 +5551,7 @@ static int ibmvfc_remove(struct vio_dev *vdev)list_splice_init (&vhost->purge, &purge);spin_unlock_irqrestore (vhost->host->host_lock, flags);ibmvfc_complete_purge (&purge); +ibmvfc_release_sub_crqs (vhost);ibmvfc_release_crq_queue (vhost);ibmvfc_free_mem (vhost);
drivers/scsi/ibmvscsi/ibmvfc.h +1 -0
@@ -850,6 +850,7 @@ struct ibmvfc_host {mempool_t *tgt_pool;struct ibmvfc_queue crq;struct ibmvfc_queue async_crq; +struct ibmvfc_scsi_channels scsi_scrqs;struct ibmvfc_npiv_login login_info;union ibmvfc_npiv_login_data *login_buf;dma_addr_t login_buf_dma;
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 8/21 ibmvfc: add Sub-CRQ IRQ enable/disable routine
In reply to Tyrel DatwylerEach Sub-CRQ has its own interrupt. A hypercall is required to toggle the IRQ state. Provide the necessary mechanism via a helper function.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +20 -0
@@ -3465,6 +3465,26 @@ static void ibmvfc_tasklet(void *data) } } +static int ibmvfc_toggle_scrq_irq (struct ibmvfc_queue *scrq,int enable) +{ +struct device *dev = scrq->vhost->dev; +struct vio_dev *vdev =to_vio_dev (dev); +unsigned long rc; +int irq_action =H_ENABLE_VIO_INTERRUPT ; + +if (!enable) + irq_action =H_DISABLE_VIO_INTERRUPT ; + + rc =plpar_hcall_norets (H_VIOCTL , vdev->unit_address, irq_action, + scrq->hw_irq,0 ,0 ); + +if (rc) +dev_err (dev,"Couldn't %s sub-crq[%lu] irq. rc=%ld\n" , + enable ?"enable" :"disable" , scrq->hwq_id, rc); + +return rc; +} +/** * ibmvfc_init_tgt - Set the next init job step for the target * @tgt: ibmvfc target struct
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 9/21 ibmvfc: add handlers to drain and complete Sub-CRQ responses
In reply to Tyrel DatwylerThe logic for iterating over the Sub-CRQ responses is similiar to that of the primary CRQ. Add the necessary handlers for processing those responses.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 86 ++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +86 -0
@@ -3485,6 +3485,92 @@ static int ibmvfc_toggle_scrq_irq(struct ibmvfc_queue *scrq, int enable)return rc; } +static void ibmvfc_handle_scrq (struct ibmvfc_crq *crq,struct ibmvfc_host *vhost, +struct list_head *evt_doneq) +{ +struct ibmvfc_event *evt = (struct ibmvfc_event *)be64_to_cpu (crq->ioba); + +switch (crq->valid) { +case IBMVFC_CRQ_CMD_RSP : +break ; +case IBMVFC_CRQ_XPORT_EVENT : +return ; +default : +dev_err (vhost->dev,"Got and invalid message type 0x%02x\n" , crq->valid); +return ; + } + +/* The only kind of payload CRQs we should get are responses to +* things we send. Make sure this response is to something we +* actually sent +*/ +if (unlikely (!ibmvfc_valid_event (&evt->queue->evt_pool, evt))) { +dev_err (vhost->dev,"Returned correlation_token 0x%08llx is invalid!\n" , + crq->ioba); +return ; + } + +if (unlikely (atomic_read (&evt->free))) { +dev_err (vhost->dev,"Received duplicate correlation_token 0x%08llx!\n" , + crq->ioba); +return ; + } + +spin_lock (&evt->queue->l_lock); +list_move_tail (&evt->queue_list, evt_doneq); +spin_unlock (&evt->queue->l_lock); +} + +static struct ibmvfc_crq *ibmvfc_next_scrq (struct ibmvfc_queue *scrq) +{ +struct ibmvfc_crq *crq; + + crq = &scrq->msgs.scrq[scrq->cur].crq; +if (crq->valid &0x80 ) { +if (++scrq->cur == scrq->size) + scrq->cur =0 ; +rmb (); + }else + crq =NULL ; + +return crq; +} + +static void ibmvfc_drain_sub_crq (struct ibmvfc_queue *scrq) +{ +struct ibmvfc_crq *crq; +struct ibmvfc_event *evt, *temp; +unsigned long flags; +int done =0 ; +LIST_HEAD (evt_doneq); + +spin_lock_irqsave (scrq->q_lock, flags); +while (!done) { +while ((crq =ibmvfc_next_scrq (scrq)) !=NULL ) { +ibmvfc_handle_scrq (crq, scrq->vhost, &evt_doneq); + crq->valid =0 ; +wmb (); + } + +ibmvfc_toggle_scrq_irq (scrq,1 ); +if ((crq =ibmvfc_next_scrq (scrq)) !=NULL ) { +ibmvfc_toggle_scrq_irq (scrq,0 ); +ibmvfc_handle_scrq (crq, scrq->vhost, &evt_doneq); + crq->valid =0 ; +wmb (); + }else + done =1 ; + } +spin_unlock_irqrestore (scrq->q_lock, flags); + +list_for_each_entry_safe (evt, temp, &evt_doneq, queue_list) { +del_timer (&evt->timer); +list_del (&evt->queue_list); +ibmvfc_trc_end (evt); + evt->done (evt); + } +} +/** * ibmvfc_init_tgt - Set the next init job step for the target * @tgt: ibmvfc target struct
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 10/21 ibmvfc: define Sub-CRQ interrupt handler routine
In reply to Tyrel DatwylerSimple handler that calls Sub-CRQ drain routine directly.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +10 -0
@@ -3571,6 +3571,16 @@ static void ibmvfc_drain_sub_crq(struct ibmvfc_queue *scrq) } } +static irqreturn_t ibmvfc_interrupt_scsi (int irq,void *scrq_instance) +{ +struct ibmvfc_queue *scrq = (struct ibmvfc_queue *)scrq_instance; + +ibmvfc_toggle_scrq_irq (scrq,0 ); +ibmvfc_drain_sub_crq (scrq); + +return IRQ_HANDLED ; +} +/** * ibmvfc_init_tgt - Set the next init job step for the target * @tgt: ibmvfc target struct
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 11/21 ibmvfc: map/request irq and register Sub-CRQ interrupt handler
In reply to Tyrel DatwylerCreate an irq mapping for the hw_irq number provided from phyp firmware. Request an irq assigned our Sub-CRQ interrupt handler. Unmap these irqs at Sub-CRQ teardown.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +25 -0
@@ -5292,12 +5292,34 @@ static int ibmvfc_register_scsi_channel(struct ibmvfc_host *vhost, goto reg_failed; } + scrq->irq =irq_create_mapping (NULL , scrq->hw_irq); + +if (!scrq->irq) { + rc = -EINVAL ; +dev_err (dev,"Error mapping sub-crq[%d] irq\n" , index); + goto irq_failed; + } + +snprintf (scrq->name,sizeof (scrq->name),"ibmvfc-%x-scsi%d" , + vdev->unit_address, index); + rc =request_irq (scrq->irq, ibmvfc_interrupt_scsi,0 , scrq->name, scrq); + +if (rc) { +dev_err (dev,"Couldn't register sub-crq[%d] irq\n" , index); +irq_dispose_mapping (scrq->irq); + goto irq_failed; + } + scrq->hwq_id = index; scrq->vhost = vhost;LEAVE ;return 0 ; +irq_failed: +do { +plpar_hcall_norets (H_FREE_SUB_CRQ , vdev->unit_address, scrq->cookie); + }while (rc ==H_BUSY ||H_IS_LONG_BUSY (rc)); reg_failed:ibmvfc_free_queue (vhost, scrq);LEAVE ;
@@ -5313,6 +5335,9 @@ static void ibmvfc_deregister_scsi_channel(struct ibmvfc_host *vhost, int index)ENTER ; +free_irq (scrq->irq, scrq); +irq_dispose_mapping (scrq->irq); + do { rc = plpar_hcall_norets(H_FREE_SUB_CRQ, vdev->unit_address, scrq->cookie);
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 12/21 ibmvfc: implement channel enquiry and setup commands
In reply to Tyrel DatwylerNew NPIV_ENQUIRY_CHANNEL and NPIV_SETUP_CHANNEL management datagrams (MADs) were defined in a previous patchset. If the client advertises a desire to use channels and the partner VIOS is channel capable then the client must proceed with channel enquiry to determine the maximum number of channels the VIOS is capable of providing, and registering SubCRQs via channel setup with the VIOS immediately following NPIV Login. This handshaking should not be performed for subsequent NPIV Logins unless the CRQ connection has been reset.
Implement these two new MADs and issue them following a successful NPIV login where the VIOS has set the SUPPORT_CHANNELS capability bit in the NPIV Login response.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 135 ++++++++++++++++++++++++++++++++- drivers/scsi/ibmvscsi/ibmvfc.h | 3 + 2 files changed, 136 insertions(+), 2 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +133 -2
@@ -909,6 +909,8 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)spin_lock (vhost->crq.q_lock); vhost->state =IBMVFC_NO_CRQ ; vhost->logged_in =0 ; + vhost->do_enquiry =1 ; + vhost->using_channels =0 ;/* Clean out the queue */ memset (crq->msgs.crq,0 ,PAGE_SIZE );
@@ -4586,6 +4588,118 @@ static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)ibmvfc_link_down (vhost,IBMVFC_LINK_DEAD ); } +static void ibmvfc_channel_setup_done (struct ibmvfc_event *evt) +{ +struct ibmvfc_host *vhost = evt->vhost; +u32 mad_status =be16_to_cpu (evt->xfer_iu->channel_setup.common.status); +int level =IBMVFC_DEFAULT_LOG_LEVEL ; + +ibmvfc_free_event (evt); + +switch (mad_status) { +case IBMVFC_MAD_SUCCESS : +ibmvfc_dbg (vhost,"Channel Setup succeded\n" ); + vhost->do_enquiry =0 ; +break ; +case IBMVFC_MAD_FAILED : + level +=ibmvfc_retry_host_init (vhost); +ibmvfc_log (vhost, level,"Channel Setup failed\n" ); + fallthrough; +case IBMVFC_MAD_DRIVER_FAILED : +return ; +default : +dev_err (vhost->dev,"Invalid Channel Setup response: 0x%x\n" , + mad_status); +ibmvfc_link_down (vhost,IBMVFC_LINK_DEAD ); +return ; + } + +ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_QUERY ); +wake_up (&vhost->work_wait_q); +} + +static void ibmvfc_channel_setup (struct ibmvfc_host *vhost) +{ +struct ibmvfc_channel_setup_mad *mad; +struct ibmvfc_channel_setup *setup_buf = vhost->channel_setup_buf; +struct ibmvfc_event *evt =ibmvfc_get_event (&vhost->crq); + +memset (setup_buf,0 ,sizeof (*setup_buf)); + setup_buf->flags =cpu_to_be32 (IBMVFC_CANCEL_CHANNELS ); + +ibmvfc_init_event (evt, ibmvfc_channel_setup_done,IBMVFC_MAD_FORMAT ); + mad = &evt->iu.channel_setup; +memset (mad,0 ,sizeof (*mad)); + mad->common.version =cpu_to_be32 (1 ); + mad->common.opcode =cpu_to_be32 (IBMVFC_CHANNEL_SETUP ); + mad->common.length =cpu_to_be16 (sizeof (*mad)); + mad->buffer.va =cpu_to_be64 (vhost->channel_setup_dma); + mad->buffer.len =cpu_to_be32 (sizeof (*vhost->channel_setup_buf)); + +ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_INIT_WAIT ); + +if (!ibmvfc_send_event (evt, vhost, default_timeout)) +ibmvfc_dbg (vhost,"Sent channel setup\n" ); +else +ibmvfc_link_down (vhost,IBMVFC_LINK_DOWN ); +} + +static void ibmvfc_channel_enquiry_done (struct ibmvfc_event *evt) +{ +struct ibmvfc_host *vhost = evt->vhost; +struct ibmvfc_channel_enquiry *rsp = &evt->xfer_iu->channel_enquiry; +u32 mad_status =be16_to_cpu (rsp->common.status); +int level =IBMVFC_DEFAULT_LOG_LEVEL ; + +switch (mad_status) { +case IBMVFC_MAD_SUCCESS : +ibmvfc_dbg (vhost,"Channel Enquiry succeeded\n" ); + vhost->max_vios_scsi_channels =be32_to_cpu (rsp->num_scsi_subq_channels); +ibmvfc_free_event (evt); +break ; +case IBMVFC_MAD_FAILED : + level +=ibmvfc_retry_host_init (vhost); +ibmvfc_log (vhost, level,"Channel Enquiry failed\n" ); + fallthrough; +case IBMVFC_MAD_DRIVER_FAILED : +ibmvfc_free_event (evt); +return ; +default : +dev_err (vhost->dev,"Invalid Channel Enquiry response: 0x%x\n" , + mad_status); +ibmvfc_link_down (vhost,IBMVFC_LINK_DEAD ); +ibmvfc_free_event (evt); +return ; + } + +ibmvfc_channel_setup (vhost); +} + +static void ibmvfc_channel_enquiry (struct ibmvfc_host *vhost) +{ +struct ibmvfc_channel_enquiry *mad; +struct ibmvfc_event *evt =ibmvfc_get_event (&vhost->crq); + +ibmvfc_init_event (evt, ibmvfc_channel_enquiry_done,IBMVFC_MAD_FORMAT ); + mad = &evt->iu.channel_enquiry; +memset (mad,0 ,sizeof (*mad)); + mad->common.version =cpu_to_be32 (1 ); + mad->common.opcode =cpu_to_be32 (IBMVFC_CHANNEL_ENQUIRY ); + mad->common.length =cpu_to_be16 (sizeof (*mad)); + +if (IBMVFC_MIG_NO_SUB_TO_CRQ ) + mad->flags |=cpu_to_be32 (IBMVFC_NO_CHANNELS_TO_CRQ_SUPPORT ); +if (IBMVFC_MIG_NO_N_TO_M ) + mad->flags |=cpu_to_be32 (IBMVFC_NO_N_TO_M_CHANNELS_SUPPORT ); + +ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_INIT_WAIT ); + +if (!ibmvfc_send_event (evt, vhost, default_timeout)) +ibmvfc_dbg (vhost,"Send channel enquiry\n" ); +else +ibmvfc_link_down (vhost,IBMVFC_LINK_DEAD ); +} +/** * ibmvfc_npiv_login_done - Completion handler for NPIV Login * @evt: ibmvfc event struct
@@ -4667,8 +4781,14 @@ static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt) vhost->host->can_queue =be32_to_cpu (rsp->max_cmds) -IBMVFC_NUM_INTERNAL_REQ ; vhost->host->max_sectors = npiv_max_sectors; -ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_QUERY ); -wake_up (&vhost->work_wait_q); + +if (ibmvfc_check_caps (vhost,IBMVFC_CAN_SUPPORT_CHANNELS ) && vhost->do_enquiry) { +ibmvfc_channel_enquiry (vhost); + }else { + vhost->do_enquiry =0 ; +ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_QUERY ); +wake_up (&vhost->work_wait_q); + } }/**
@@ -5477,9 +5597,20 @@ static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost) goto free_trace; } + vhost->channel_setup_buf =dma_alloc_coherent (dev,sizeof (*vhost->channel_setup_buf), + &vhost->channel_setup_dma, +GFP_KERNEL ); + +if (!vhost->channel_setup_buf) { +dev_err (dev,"Couldn't allocate Channel Setup buffer\n" ); + goto free_tgt_pool; + } +LEAVE ;return 0 ; +free_tgt_pool: +mempool_destroy (vhost->tgt_pool); free_trace:kfree (vhost->trace); free_disc_buffer:
drivers/scsi/ibmvscsi/ibmvfc.h +3 -0
@@ -854,10 +854,13 @@ struct ibmvfc_host {struct ibmvfc_npiv_login login_info;union ibmvfc_npiv_login_data *login_buf;dma_addr_t login_buf_dma; +struct ibmvfc_channel_setup *channel_setup_buf; +dma_addr_t channel_setup_dma;int disc_buf_sz;int log_level;struct ibmvfc_discover_targets_entry *disc_buf;struct mutex passthru_mutex; +int max_vios_scsi_channels;int task_set;int init_retries;int discovery_threads;
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 13/21 ibmvfc: advertise client support for using hardware channels
In reply to Tyrel DatwylerPrevious patches have plumbed the necessary Sub-CRQ interface and channel negotiation MADs to fully channelize via hardware backed queues.
Advertise client support via NPIV Login capability IBMVFC_CAN_USE_CHANNELS when the client bits have MQ enabled via vhost->mq_enabled, or when channels were already in use during a subsequent NPIV Login. The later is required because channel support is only renegotiated after a CRQ pair is broken. Simple NPIV Logout/Logins require the client to continue to advertise the channel capability until the CRQ pair between the client is broken.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +4 -0
@@ -1410,6 +1410,10 @@ static void ibmvfc_set_login_info(struct ibmvfc_host *vhost) login_info->max_cmds =cpu_to_be32 (max_requests +IBMVFC_NUM_INTERNAL_REQ ); login_info->capabilities =cpu_to_be64 (IBMVFC_CAN_MIGRATE |IBMVFC_CAN_SEND_VF_WWPN ); + +if (vhost->mq_enabled || vhost->using_channels) + login_info->capabilities |=cpu_to_be64 (IBMVFC_CAN_USE_CHANNELS ); + login_info->async.va =cpu_to_be64 (vhost->async_crq.msg_token); login_info->async.len =cpu_to_be32 (async_crq->size *sizeof (*async_crq->msgs.async));
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 14/21 ibmvfc: set and track hw queue in ibmvfc_event struct
In reply to Tyrel DatwylerExtract the hwq id from a SCSI command and store it in the ibmvfc_event structure to identify which Sub-CRQ to send the command down when channels are being utilized.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 5 +++++ drivers/scsi/ibmvscsi/ibmvfc.h | 1 + 2 files changed, 6 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +5 -0
@@ -1483,6 +1483,7 @@ static void ibmvfc_init_event(struct ibmvfc_event *evt, evt->_done = done; evt->done = ibmvfc_locked_done; } + evt->hwq =0 ; }/**
@@ -1839,6 +1840,8 @@ static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)struct ibmvfc_cmd *vfc_cmd;struct ibmvfc_fcp_cmd_iu *iu;struct ibmvfc_event *evt; +u32 tag_and_hwq =blk_mq_unique_tag (cmnd->request); +u16 hwq =blk_mq_unique_tag_to_hwq (tag_and_hwq);int rc; if (unlikely((rc = fc_remote_port_chkready(rport))) ||
@@ -1865,6 +1868,8 @@ static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd) } vfc_cmd->correlation =cpu_to_be64 ((u64 )evt); +if (vhost->using_channels) + evt->hwq = hwq % vhost->scsi_scrqs.active_queues;if (likely (!(rc =ibmvfc_map_sg_data (cmnd, evt, vfc_cmd, vhost->dev))))return ibmvfc_send_event (evt, vhost,0 );
drivers/scsi/ibmvscsi/ibmvfc.h +1 -0
@@ -753,6 +753,7 @@ struct ibmvfc_event {struct completion comp;struct completion *eh_comp;struct timer_list timer; +u16 hwq; };/* a pool of event structs for use */
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 15/21 ibmvfc: send commands down HW Sub-CRQ when channelized
In reply to Tyrel DatwylerWhen the client has negotiated the use of channels all vfcFrames are required to go down a Sub-CRQ channel or it is a protocoal violation. If the adapter state is channelized submit vfcFrames to the appropriate Sub-CRQ via the h_send_sub_crq() helper.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 39 ++++++++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 6 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +33 -6
@@ -704,6 +704,15 @@ static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)return plpar_hcall_norets (H_SEND_CRQ , vdev->unit_address, word1, word2); } +static int ibmvfc_send_sub_crq (struct ibmvfc_host *vhost,u64 cookie,u64 word1, +u64 word2,u64 word3,u64 word4) +{ +struct vio_dev *vdev =to_vio_dev (vhost->dev); + +return plpar_hcall_norets (H_SEND_SUB_CRQ , vdev->unit_address, cookie, + word1, word2, word3, word4); +} +/** * ibmvfc_send_crq_init - Send a CRQ init message * @vhost: ibmvfc host struct
@@ -1623,8 +1632,17 @@ static int ibmvfc_send_event(struct ibmvfc_event *evt,mb (); -if ((rc =ibmvfc_send_crq (vhost,be64_to_cpu (crq_as_u64[0 ]), -be64_to_cpu (crq_as_u64[1 ])))) { +if (evt->queue->fmt ==IBMVFC_SUB_CRQ_FMT ) + rc =ibmvfc_send_sub_crq (vhost, + evt->queue->vios_cookie, +be64_to_cpu (crq_as_u64[0 ]), +be64_to_cpu (crq_as_u64[1 ]), +0 ,0 ); +else + rc =ibmvfc_send_crq (vhost,be64_to_cpu (crq_as_u64[0 ]), +be64_to_cpu (crq_as_u64[1 ])); + +if (rc) {list_del (&evt->queue_list);spin_unlock_irqrestore (&evt->queue->l_lock, flags);del_timer (&evt->timer);
@@ -1842,6 +1860,7 @@ static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)struct ibmvfc_event *evt;u32 tag_and_hwq =blk_mq_unique_tag (cmnd->request);u16 hwq =blk_mq_unique_tag_to_hwq (tag_and_hwq); +u16 scsi_channel;int rc; if (unlikely((rc = fc_remote_port_chkready(rport))) ||
@@ -1852,7 +1871,13 @@ static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd) } cmnd->result = (DID_OK <<16 ); - evt =ibmvfc_get_event (&vhost->crq); +if (vhost->using_channels) { + scsi_channel = hwq % vhost->scsi_scrqs.active_queues; + evt =ibmvfc_get_event (&vhost->scsi_scrqs.scrqs[scsi_channel]); + evt->hwq = hwq % vhost->scsi_scrqs.active_queues; + }else + evt =ibmvfc_get_event (&vhost->crq); +ibmvfc_init_event (evt, ibmvfc_scsi_done,IBMVFC_CMD_FORMAT ); evt->cmnd = cmnd;
@@ -1868,8 +1893,6 @@ static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd) } vfc_cmd->correlation =cpu_to_be64 ((u64 )evt); -if (vhost->using_channels) - evt->hwq = hwq % vhost->scsi_scrqs.active_queues;if (likely (!(rc =ibmvfc_map_sg_data (cmnd, evt, vfc_cmd, vhost->dev))))return ibmvfc_send_event (evt, vhost,0 );
@@ -2200,7 +2223,11 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)spin_lock_irqsave (vhost->host->host_lock, flags);if (vhost->state ==IBMVFC_ACTIVE ) { - evt =ibmvfc_get_event (&vhost->crq); +if (vhost->using_channels) + evt =ibmvfc_get_event (&vhost->scsi_scrqs.scrqs[0 ]); +else + evt =ibmvfc_get_event (&vhost->crq); +ibmvfc_init_event (evt, ibmvfc_sync_completion,IBMVFC_CMD_FORMAT ); tmf =ibmvfc_init_vfc_cmd (evt, sdev); iu =ibmvfc_get_fcp_iu (vhost, tmf);
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 16/21 ibmvfc: register Sub-CRQ handles with VIOS during channel setup
In reply to Tyrel DatwylerIf the ibmvfc client adapter requests channels it must submit a number of Sub-CRQ handles matching the number of channels being requested. The VIOS in its response will overwrite the actual number of channel resources allocated which may be less than what was requested. The client then must store the VIOS Sub-CRQ handle for each queue. This VIOS handle is needed as a parameter with h_send_sub_crq().
--- drivers/scsi/ibmvscsi/ibmvfc.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-)
drivers/scsi/ibmvscsi/ibmvfc.c +31 -1
@@ -4627,15 +4627,35 @@ static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)static void ibmvfc_channel_setup_done (struct ibmvfc_event *evt) {struct ibmvfc_host *vhost = evt->vhost; +struct ibmvfc_channel_setup *setup = vhost->channel_setup_buf; +struct ibmvfc_scsi_channels *scrqs = &vhost->scsi_scrqs;u32 mad_status =be16_to_cpu (evt->xfer_iu->channel_setup.common.status);int level =IBMVFC_DEFAULT_LOG_LEVEL ; +int flags, active_queues, i;ibmvfc_free_event (evt);switch (mad_status) {case IBMVFC_MAD_SUCCESS :ibmvfc_dbg (vhost,"Channel Setup succeded\n" ); + flags =be32_to_cpu (setup->flags); vhost->do_enquiry =0 ; + active_queues =be32_to_cpu (setup->num_scsi_subq_channels); + scrqs->active_queues = active_queues; + +if (flags &IBMVFC_CHANNELS_CANCELED ) { +ibmvfc_dbg (vhost,"Channels Canceled\n" ); + vhost->using_channels =0 ; + }else { +if (active_queues) + vhost->using_channels =1 ; +for (i =0 ; i < active_queues; i++) + scrqs->scrqs[i].vios_cookie = +be64_to_cpu (setup->channel_handles[i]); + +ibmvfc_dbg (vhost,"Using %u channels\n" , + vhost->scsi_scrqs.active_queues); + }break ;case IBMVFC_MAD_FAILED : level +=ibmvfc_retry_host_init (vhost);
@@ -4659,9 +4679,19 @@ static void ibmvfc_channel_setup(struct ibmvfc_host *vhost)struct ibmvfc_channel_setup_mad *mad;struct ibmvfc_channel_setup *setup_buf = vhost->channel_setup_buf;struct ibmvfc_event *evt =ibmvfc_get_event (&vhost->crq); +struct ibmvfc_scsi_channels *scrqs = &vhost->scsi_scrqs; +unsigned int num_channels = +min (vhost->client_scsi_channels, vhost->max_vios_scsi_channels); +int i;memset (setup_buf,0 ,sizeof (*setup_buf)); - setup_buf->flags =cpu_to_be32 (IBMVFC_CANCEL_CHANNELS ); +if (num_channels ==0 ) + setup_buf->flags =cpu_to_be32 (IBMVFC_CANCEL_CHANNELS ); +else { + setup_buf->num_scsi_subq_channels =cpu_to_be32 (num_channels); +for (i =0 ; i < num_channels; i++) + setup_buf->channel_handles[i] =cpu_to_be64 (scrqs->scrqs[i].cookie); + }ibmvfc_init_event (evt, ibmvfc_channel_setup_done,IBMVFC_MAD_FORMAT ); mad = &evt->iu.channel_setup;
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 17/21 ibmvfc: add cancel mad initialization helper
In reply to Tyrel DatwylerAdd a helper routine for initializing a Cancel MAD. This will be useful for a channelized client that needs to send Cancel commands down every channel commands were sent for a particular LUN.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 68 ++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 28 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +40 -28
@@ -2379,6 +2379,45 @@ static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,return SUCCESS ; } +static struct ibmvfc_event *ibmvfc_init_tmf (struct ibmvfc_queue *queue, +struct scsi_device *sdev, +int type) +{ +struct ibmvfc_host *vhost =shost_priv (sdev->host); +struct scsi_target *starget =scsi_target (sdev); +struct fc_rport *rport =starget_to_rport (starget); +struct ibmvfc_event *evt; +struct ibmvfc_tmf *tmf; + + evt =ibmvfc_get_event (queue); +ibmvfc_init_event (evt, ibmvfc_sync_completion,IBMVFC_MAD_FORMAT ); + + tmf = &evt->iu.tmf; +memset (tmf,0 ,sizeof (*tmf)); +if (ibmvfc_check_caps (vhost,IBMVFC_HANDLE_VF_WWPN )) { + tmf->common.version =cpu_to_be32 (2 ); + tmf->target_wwpn =cpu_to_be64 (rport->port_name); + }else { + tmf->common.version =cpu_to_be32 (1 ); + } + tmf->common.opcode =cpu_to_be32 (IBMVFC_TMF_MAD ); + tmf->common.length =cpu_to_be16 (sizeof (*tmf)); + tmf->scsi_id =cpu_to_be64 (rport->port_id); +int_to_scsilun (sdev->lun, &tmf->lun); +if (!ibmvfc_check_caps (vhost,IBMVFC_CAN_SUPPRESS_ABTS )) + type &= ~IBMVFC_TMF_SUPPRESS_ABTS ; +if (vhost->state ==IBMVFC_ACTIVE ) + tmf->flags =cpu_to_be32 ((type |IBMVFC_TMF_LUA_VALID )); +else + tmf->flags =cpu_to_be32 (((type &IBMVFC_TMF_SUPPRESS_ABTS ) |IBMVFC_TMF_LUA_VALID )); + tmf->cancel_key =cpu_to_be32 ((unsigned long )sdev->hostdata); + tmf->my_cancel_key =cpu_to_be32 ((unsigned long )starget->hostdata); + +init_completion (&evt->comp); + +return evt; +} +/** * ibmvfc_cancel_all - Cancel all outstanding commands to the device * @sdev: scsi device to cancel commands
@@ -2393,9 +2432,6 @@ static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,static int ibmvfc_cancel_all (struct scsi_device *sdev,int type) {struct ibmvfc_host *vhost =shost_priv (sdev->host); -struct scsi_target *starget =scsi_target (sdev); -struct fc_rport *rport =starget_to_rport (starget); -struct ibmvfc_tmf *tmf;struct ibmvfc_event *evt, *found_evt;union ibmvfc_iu rsp;int rsp_rc = -EBUSY ;
@@ -2422,32 +2458,8 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type) }if (vhost->logged_in) { - evt =ibmvfc_get_event (&vhost->crq); -ibmvfc_init_event (evt, ibmvfc_sync_completion,IBMVFC_MAD_FORMAT ); - - tmf = &evt->iu.tmf; -memset (tmf,0 ,sizeof (*tmf)); -if (ibmvfc_check_caps (vhost,IBMVFC_HANDLE_VF_WWPN )) { - tmf->common.version =cpu_to_be32 (2 ); - tmf->target_wwpn =cpu_to_be64 (rport->port_name); - }else { - tmf->common.version =cpu_to_be32 (1 ); - } - tmf->common.opcode =cpu_to_be32 (IBMVFC_TMF_MAD ); - tmf->common.length =cpu_to_be16 (sizeof (*tmf)); - tmf->scsi_id =cpu_to_be64 (rport->port_id); -int_to_scsilun (sdev->lun, &tmf->lun); -if (!ibmvfc_check_caps (vhost,IBMVFC_CAN_SUPPRESS_ABTS )) - type &= ~IBMVFC_TMF_SUPPRESS_ABTS ; -if (vhost->state ==IBMVFC_ACTIVE ) - tmf->flags =cpu_to_be32 ((type |IBMVFC_TMF_LUA_VALID )); -else - tmf->flags =cpu_to_be32 (((type &IBMVFC_TMF_SUPPRESS_ABTS ) |IBMVFC_TMF_LUA_VALID )); - tmf->cancel_key =cpu_to_be32 ((unsigned long )sdev->hostdata); - tmf->my_cancel_key =cpu_to_be32 ((unsigned long )starget->hostdata); - + evt =ibmvfc_init_tmf (&vhost->crq, sdev, type); evt->sync_iu = &rsp; -init_completion (&evt->comp); rsp_rc =ibmvfc_send_event (evt, vhost, default_timeout); }
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 18/21 ibmvfc: send Cancel MAD down each hw scsi channel
In reply to Tyrel DatwylerIn general the client needs to send Cancel MADs and task management commands down the same channel as the command(s) intended to cancel or abort. The client assigns cancel keys per LUN and thus must send a Cancel down each channel commands were submitted for that LUN. Further, the client then must wait for those cancel completions prior to submitting a LUN RESET or ABORT TASK SET.
Add a cancel rsp iu syncronization field to the ibmvfc_queue struct such that the cancel routine can sync the cancel response to each queue that requires a cancel command. Build a list of each cancel event sent and wait for the completion of each submitted cancel.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 106 +++++++++++++++++++++++++++++---- drivers/scsi/ibmvscsi/ibmvfc.h | 3 + 2 files changed, 97 insertions(+), 12 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +94 -12
@@ -2418,18 +2418,79 @@ static struct ibmvfc_event *ibmvfc_init_tmf(struct ibmvfc_queue *queue,return evt; } -/** -* ibmvfc_cancel_all - Cancel all outstanding commands to the device -* @sdev: scsi device to cancel commands -* @type: type of error recovery being performed -* -* This sends a cancel to the VIOS for the specified device. This does -* NOT send any abort to the actual device. That must be done separately. -* -* Returns: -* 0 on success / other on failure -**/ -static int ibmvfc_cancel_all (struct scsi_device *sdev,int type) +static int ibmvfc_cancel_all_mq (struct scsi_device *sdev,int type) +{ +struct ibmvfc_host *vhost =shost_priv (sdev->host); +struct ibmvfc_event *evt, *found_evt, *temp; +struct ibmvfc_queue *queues = vhost->scsi_scrqs.scrqs; +unsigned long flags; +int num_hwq, i; +LIST_HEAD (cancelq); +u16 status; + +ENTER ; +spin_lock_irqsave (vhost->host->host_lock, flags); + num_hwq = vhost->scsi_scrqs.active_queues; +for (i =0 ; i < num_hwq; i++) { +spin_lock (queues[i].q_lock); +spin_lock (&queues[i].l_lock); + found_evt =NULL ; +list_for_each_entry (evt, &queues[i].sent, queue_list) { +if (evt->cmnd && evt->cmnd->device == sdev) { + found_evt = evt; +break ; + } + } +spin_unlock (&queues[i].l_lock); + +if (!found_evt) +continue ; + +if (vhost->logged_in) { + evt =ibmvfc_init_tmf (&queues[i], sdev, type); + evt->sync_iu = &queues[i].cancel_rsp; +ibmvfc_send_event (evt, vhost, default_timeout); +list_add_tail (&evt->cancel, &cancelq); + } + } + +for (i =0 ; i < num_hwq; i++) +spin_unlock (queues[i].q_lock); +spin_unlock_irqrestore (vhost->host->host_lock, flags); + +if (list_empty (&cancelq)) { +if (vhost->log_level >IBMVFC_DEFAULT_LOG_LEVEL ) +sdev_printk (KERN_INFO , sdev,"No events found to cancel\n" ); +return 0 ; + } + +sdev_printk (KERN_INFO , sdev,"Cancelling outstanding commands.\n" ); + +list_for_each_entry_safe (evt, temp, &cancelq, cancel) { +wait_for_completion (&evt->comp); + status =be16_to_cpu (evt->queue->cancel_rsp.mad_common.status); +ibmvfc_free_event (evt); + +if (status !=IBMVFC_MAD_SUCCESS ) { +sdev_printk (KERN_WARNING , sdev,"Cancel failed with rc=%x\n" , status); +switch (status) { +case IBMVFC_MAD_DRIVER_FAILED : +case IBMVFC_MAD_CRQ_ERROR : +/* Host adapter most likely going through reset, return success to +* the caller will wait for the command being cancelled to get returned +*/ +break ; +default : +break ; + } + } + } + +sdev_printk (KERN_INFO , sdev,"Successfully cancelled outstanding commands\n" ); +return 0 ; +} + +static int ibmvfc_cancel_all_sq (struct scsi_device *sdev,int type) {struct ibmvfc_host *vhost =shost_priv (sdev->host);struct ibmvfc_event *evt, *found_evt;
@@ -2498,6 +2559,27 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)return 0 ; } +/** +* ibmvfc_cancel_all - Cancel all outstanding commands to the device +* @sdev: scsi device to cancel commands +* @type: type of error recovery being performed +* +* This sends a cancel to the VIOS for the specified device. This does +* NOT send any abort to the actual device. That must be done separately. +* +* Returns: +* 0 on success / other on failure +**/ +static int ibmvfc_cancel_all (struct scsi_device *sdev,int type) +{ +struct ibmvfc_host *vhost =shost_priv (sdev->host); + +if (vhost->mq_enabled && vhost->using_channels) +return ibmvfc_cancel_all_mq (sdev, type); +else +return ibmvfc_cancel_all_sq (sdev, type); +} +/** * ibmvfc_match_key - Match function for specified cancel key * @evt: ibmvfc event struct
drivers/scsi/ibmvscsi/ibmvfc.h +3 -0
@@ -737,6 +737,7 @@ struct ibmvfc_target {/* a unit of work for the hosting partition */ struct ibmvfc_event {struct list_head queue_list; +struct list_head cancel;struct ibmvfc_host *vhost;struct ibmvfc_queue *queue;struct ibmvfc_target *tgt;
@@ -790,6 +791,8 @@ struct ibmvfc_queue {struct list_head free;spinlock_t l_lock; +union ibmvfc_iu cancel_rsp; +/* Sub-CRQ fields */ struct ibmvfc_host *vhost;unsigned long cookie;
Signature · 1 line
2.27.0
Re: [PATCH v4 18/21] ibmvfc: send Cancel MAD down each hw scsi channel
Quoted 35 lines · Tyrel Datwyler
drivers/scsi/ibmvscsi/ibmvfc.c +15
-12@@ -2418,18 +2418,79 @@ static struct ibmvfc_event *ibmvfc_init_tmf(struct ibmvfc_queue *queue,return evt; } -/** -* ibmvfc_cancel_all - Cancel all outstanding commands to the device -* @sdev: scsi device to cancel commands -* @type: type of error recovery being performed -* -* This sends a cancel to the VIOS for the specified device. This does -* NOT send any abort to the actual device. That must be done separately. -* -* Returns: -* 0 on success / other on failure -**/ -static int ibmvfc_cancel_all (struct scsi_device *sdev,int type) +static int ibmvfc_cancel_all_mq (struct scsi_device *sdev,int type) +{ +struct ibmvfc_host *vhost =shost_priv (sdev->host); +struct ibmvfc_event *evt, *found_evt, *temp; +struct ibmvfc_queue *queues = vhost->scsi_scrqs.scrqs; +unsigned long flags; +int num_hwq, i; +LIST_HEAD (cancelq); +u16 status; + +ENTER ; +spin_lock_irqsave (vhost->host->host_lock, flags); + num_hwq = vhost->scsi_scrqs.active_queues; +for (i =0 ; i < num_hwq; i++) { +spin_lock (queues[i].q_lock);
drivers/scsi/ibmvscsi/ibmvfc.c static struct ibmvfc_event *ibmvfc_init_tmf(struct ibmvfc_queue *queue, · line 2445
Quoted 10 lines
drivers/scsi/ibmvscsi/ibmvfc.c +10
-0+spin_lock (&queues[i].l_lock); + found_evt =NULL ; +list_for_each_entry (evt, &queues[i].sent, queue_list) { +if (evt->cmnd && evt->cmnd->device == sdev) { + found_evt = evt; +break ; + } + } +spin_unlock (&queues[i].l_lock); +
I really don't like the way the first for loop grabs all the q_locks, and then there is a second for loop that drops all these locks... I think this code would be cleaner if it looked like:
if (found_evt && vhost->logged_in) {
evt = ibmvfc_init_tmf(&queues[i], sdev, type);
evt->sync_iu = &queues[i].cancel_rsp;
ibmvfc_send_event(evt, vhost, default_timeout);
list_add_tail(&evt->cancel, &cancelq);
}
spin_unlock(queues[i].q_lock);
}Quoted 16 lines
drivers/scsi/ibmvscsi/ibmvfc.c +16
-0+if (!found_evt) +continue ; + +if (vhost->logged_in) { + evt =ibmvfc_init_tmf (&queues[i], sdev, type); + evt->sync_iu = &queues[i].cancel_rsp; +ibmvfc_send_event (evt, vhost, default_timeout); +list_add_tail (&evt->cancel, &cancelq); + } + } + +for (i =0 ; i < num_hwq; i++) +spin_unlock (queues[i].q_lock); +spin_unlock_irqrestore (vhost->host->host_lock, flags); + +if (list_empty (&cancelq)) {
drivers/scsi/ibmvscsi/ibmvfc.c static struct ibmvfc_event *ibmvfc_init_tmf(struct ibmvfc_queue *queue, · line 2471
Quoted 10 lines
drivers/scsi/ibmvscsi/ibmvfc.c +10
-0+if (vhost->log_level >IBMVFC_DEFAULT_LOG_LEVEL ) +sdev_printk (KERN_INFO , sdev,"No events found to cancel\n" ); +return 0 ; + } + +sdev_printk (KERN_INFO , sdev,"Cancelling outstanding commands.\n" ); + +list_for_each_entry_safe (evt, temp, &cancelq, cancel) { +wait_for_completion (&evt->comp); + status =be16_to_cpu (evt->queue->cancel_rsp.mad_common.status);
You probably want a list_del(&evt->cancel) here.
drivers/scsi/ibmvscsi/ibmvfc.c static struct ibmvfc_event *ibmvfc_init_tmf(struct ibmvfc_queue *queue, · line 2484
Quoted 13 lines
drivers/scsi/ibmvscsi/ibmvfc.c +13
-0+ibmvfc_free_event (evt); + +if (status !=IBMVFC_MAD_SUCCESS ) { +sdev_printk (KERN_WARNING , sdev,"Cancel failed with rc=%x\n" , status); +switch (status) { +case IBMVFC_MAD_DRIVER_FAILED : +case IBMVFC_MAD_CRQ_ERROR : +/* Host adapter most likely going through reset, return success to +* the caller will wait for the command being cancelled to get returned +*/ +break ; +default : +break ;
I think this default break needs to be a return -EIO.
Quoted 16 lines
drivers/scsi/ibmvscsi/ibmvfc.c +9
-0+ } + } + } + +sdev_printk (KERN_INFO , sdev,"Successfully cancelled outstanding commands\n" ); +return 0 ; +} + +static int ibmvfc_cancel_all_sq (struct scsi_device *sdev,int type) {struct ibmvfc_host *vhost =shost_priv (sdev->host);struct ibmvfc_event *evt, *found_evt;@@ -2498,6 +2559,27 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)return 0 ; }
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center
Tyrel Datwyler
maintainerPATCH v4 19/21 ibmvfc: purge scsi channels after transport loss/reset
In reply to Tyrel DatwylerGrab the queue and list lock for each Sub-CRQ and add any uncompleted events to the host purge list.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
drivers/scsi/ibmvscsi/ibmvfc.c +16 -0
@@ -1056,7 +1056,13 @@ static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)static void ibmvfc_purge_requests (struct ibmvfc_host *vhost,int error_code) {struct ibmvfc_event *evt, *pos; +struct ibmvfc_queue *queues = vhost->scsi_scrqs.scrqs;unsigned long flags; +int hwqs =0 ; +int i; + +if (vhost->using_channels) + hwqs = vhost->scsi_scrqs.active_queues;ibmvfc_dbg (vhost,"Purging all requests\n" );spin_lock_irqsave (&vhost->crq.l_lock, flags);
@@ -1064,6 +1070,16 @@ static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)ibmvfc_fail_request (evt, error_code);list_splice_init (&vhost->crq.sent, &vhost->purge);spin_unlock_irqrestore (&vhost->crq.l_lock, flags); + +for (i =0 ; i < hwqs; i++) { +spin_lock_irqsave (queues[i].q_lock, flags); +spin_lock (&queues[i].l_lock); +list_for_each_entry_safe (evt, pos, &queues[i].sent, queue_list) +ibmvfc_fail_request (evt, error_code); +list_splice_init (&queues[i].sent, &vhost->purge); +spin_unlock (&queues[i].l_lock); +spin_unlock_irqrestore (queues[i].q_lock, flags); + } }/**
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 20/21 ibmvfc: enable MQ and set reasonable defaults
In reply to Tyrel DatwylerTurn on MQ by default and set sane values for the upper limit on hw queues for the scsi host, and number of hw scsi channels to request from the partner VIOS.
--- drivers/scsi/ibmvscsi/ibmvfc.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.h +3 -3
@@ -41,9 +41,9 @@#define IBMVFC_DEFAULT_LOG_LEVEL 2#define IBMVFC_MAX_CDB_LEN 16#define IBMVFC_CLS3_ERROR 0 -#define IBMVFC_MQ 0 -#define IBMVFC_SCSI_CHANNELS 0 -#define IBMVFC_SCSI_HW_QUEUES 1 +#define IBMVFC_MQ 1 +#define IBMVFC_SCSI_CHANNELS 8 +#define IBMVFC_SCSI_HW_QUEUES 8#define IBMVFC_MIG_NO_SUB_TO_CRQ 0#define IBMVFC_MIG_NO_N_TO_M 0
Signature · 1 line
2.27.0
Tyrel Datwyler
maintainerPATCH v4 21/21 ibmvfc: provide modules parameters for MQ settings
In reply to Tyrel DatwylerAdd the various module parameter toggles for adjusting the MQ characteristics at boot/load time as well as a device attribute for changing the client scsi channel request amount.
--- drivers/scsi/ibmvscsi/ibmvfc.c | 75 ++++++++++++++++++++++++++++++---- 1 file changed, 66 insertions(+), 9 deletions(-)
drivers/scsi/ibmvscsi/ibmvfc.c +66 -9
@@ -40,6 +40,12 @@ static unsigned int disc_threads = IBMVFC_MAX_DISC_THREADS;static unsigned int ibmvfc_debug =IBMVFC_DEBUG ;static unsigned int log_level =IBMVFC_DEFAULT_LOG_LEVEL ;static unsigned int cls3_error =IBMVFC_CLS3_ERROR ; +static unsigned int mq_enabled =IBMVFC_MQ ; +static unsigned int nr_scsi_hw_queues =IBMVFC_SCSI_HW_QUEUES ; +static unsigned int nr_scsi_channels =IBMVFC_SCSI_CHANNELS ; +static unsigned int mig_channels_only =IBMVFC_MIG_NO_SUB_TO_CRQ ; +static unsigned int mig_no_less_channels =IBMVFC_MIG_NO_N_TO_M ; +static LIST_HEAD (ibmvfc_head);static DEFINE_SPINLOCK (ibmvfc_driver_lock);static struct scsi_transport_template *ibmvfc_transport_template;
@@ -49,6 +55,22 @@ MODULE_AUTHOR("Brian King <[email protected]>");MODULE_LICENSE ("GPL" );MODULE_VERSION (IBMVFC_DRIVER_VERSION ); +module_param_named (mq, mq_enabled, uint,S_IRUGO ); +MODULE_PARM_DESC(mq, "Enable multiqueue support. " + "[Default=" __stringify(IBMVFC_MQ) "]"); +module_param_named (scsi_host_queues, nr_scsi_hw_queues, uint,S_IRUGO ); +MODULE_PARM_DESC(scsi_host_queues, "Number of SCSI Host submission queues. " + "[Default=" __stringify(IBMVFC_SCSI_HW_QUEUES) "]"); +module_param_named (scsi_hw_channels, nr_scsi_channels, uint,S_IRUGO ); +MODULE_PARM_DESC(scsi_hw_channels, "Number of hw scsi channels to request. " + "[Default=" __stringify(IBMVFC_SCSI_CHANNELS) "]"); +module_param_named (mig_channels_only, mig_channels_only, uint,S_IRUGO ); +MODULE_PARM_DESC(mig_channels_only, "Prevent migration to non-channelized system. " + "[Default=" __stringify(IBMVFC_MIG_NO_SUB_TO_CRQ) "]"); +module_param_named (mig_no_less_channels, mig_no_less_channels, uint,S_IRUGO ); +MODULE_PARM_DESC(mig_no_less_channels, "Prevent migration to system with less channels. " + "[Default=" __stringify(IBMVFC_MIG_NO_N_TO_M) "]"); +module_param_named (init_timeout, init_timeout, uint,S_IRUGO |S_IWUSR ); MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds. " "[Default=" __stringify(IBMVFC_INIT_TIMEOUT) "]");
@@ -926,7 +948,7 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost) crq->cur =0 ;if (vhost->scsi_scrqs.scrqs) { -for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) { +for (i =0 ; i < nr_scsi_hw_queues; i++) { scrq = &vhost->scsi_scrqs.scrqs[i];spin_lock (scrq->q_lock);memset (scrq->msgs.scrq,0 ,PAGE_SIZE );
@@ -3394,6 +3416,37 @@ static ssize_t ibmvfc_store_log_level(struct device *dev,return strlen (buf); } +static ssize_t ibmvfc_show_scsi_channels (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct Scsi_Host *shost =class_to_shost (dev); +struct ibmvfc_host *vhost =shost_priv (shost); +unsigned long flags =0 ; +int len; + +spin_lock_irqsave (shost->host_lock, flags); + len =snprintf (buf,PAGE_SIZE ,"%d\n" , vhost->client_scsi_channels); +spin_unlock_irqrestore (shost->host_lock, flags); +return len; +} + +static ssize_t ibmvfc_store_scsi_channels (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +struct Scsi_Host *shost =class_to_shost (dev); +struct ibmvfc_host *vhost =shost_priv (shost); +unsigned long flags =0 ; +unsigned int channels; + +spin_lock_irqsave (shost->host_lock, flags); + channels =simple_strtoul (buf,NULL ,10 ); + vhost->client_scsi_channels =min (channels, nr_scsi_hw_queues); +ibmvfc_hard_reset_host (vhost); +spin_unlock_irqrestore (shost->host_lock, flags); +return strlen (buf); +} + static DEVICE_ATTR(partition_name, S_IRUGO, ibmvfc_show_host_partition_name, NULL); static DEVICE_ATTR(device_name, S_IRUGO, ibmvfc_show_host_device_name, NULL); static DEVICE_ATTR(port_loc_code, S_IRUGO, ibmvfc_show_host_loc_code, NULL);
@@ -3402,6 +3455,8 @@ static DEVICE_ATTR(npiv_version, S_IRUGO, ibmvfc_show_host_npiv_version, NULL); static DEVICE_ATTR(capabilities, S_IRUGO, ibmvfc_show_host_capabilities, NULL); static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR, ibmvfc_show_log_level, ibmvfc_store_log_level); +static DEVICE_ATTR(nr_scsi_channels, S_IRUGO | S_IWUSR, + ibmvfc_show_scsi_channels, ibmvfc_store_scsi_channels);#ifdef CONFIG_SCSI_IBMVFC_TRACE /**
@@ -3458,6 +3513,7 @@ static struct device_attribute *ibmvfc_attrs[] = { &dev_attr_npiv_version, &dev_attr_capabilities, &dev_attr_log_level, + &dev_attr_nr_scsi_channels, NULL };
@@ -4863,9 +4919,9 @@ static void ibmvfc_channel_enquiry(struct ibmvfc_host *vhost) mad->common.opcode =cpu_to_be32 (IBMVFC_CHANNEL_ENQUIRY ); mad->common.length =cpu_to_be16 (sizeof (*mad)); -if (IBMVFC_MIG_NO_SUB_TO_CRQ ) +if (mig_channels_only) mad->flags |=cpu_to_be32 (IBMVFC_NO_CHANNELS_TO_CRQ_SUPPORT ); -if (IBMVFC_MIG_NO_N_TO_M ) +if (mig_no_less_channels) mad->flags |=cpu_to_be32 (IBMVFC_NO_N_TO_M_CHANNELS_SUPPORT );ibmvfc_set_host_action (vhost,IBMVFC_HOST_ACTION_INIT_WAIT );
@@ -5652,13 +5708,13 @@ static int ibmvfc_init_sub_crqs(struct ibmvfc_host *vhost)ENTER ; - vhost->scsi_scrqs.scrqs =kcalloc (IBMVFC_SCSI_HW_QUEUES , + vhost->scsi_scrqs.scrqs =kcalloc (nr_scsi_hw_queues,sizeof (*vhost->scsi_scrqs.scrqs),GFP_KERNEL );if (!vhost->scsi_scrqs.scrqs)return -1 ; -for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) { +for (i =0 ; i < nr_scsi_hw_queues; i++) {if (ibmvfc_register_scsi_channel (vhost, i)) {for (j = i; j >0 ; j--)ibmvfc_deregister_scsi_channel (vhost, j -1 );
@@ -5682,7 +5738,7 @@ static void ibmvfc_release_sub_crqs(struct ibmvfc_host *vhost)if (!vhost->scsi_scrqs.scrqs)return ; -for (i =0 ; i <IBMVFC_SCSI_HW_QUEUES ; i++) +for (i =0 ; i < nr_scsi_hw_queues; i++)ibmvfc_deregister_scsi_channel (vhost, i);kfree (vhost->scsi_scrqs.scrqs);
@@ -5880,12 +5936,13 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) shost->transportt = ibmvfc_transport_template; shost->can_queue = max_requests; + shost->can_queue = (max_requests / nr_scsi_hw_queues); shost->max_lun = max_lun; shost->max_id = max_targets; shost->max_sectors =IBMVFC_MAX_SECTORS ; shost->max_cmd_len =IBMVFC_MAX_CDB_LEN ; shost->unique_id = shost->host_no; - shost->nr_hw_queues =IBMVFC_MQ ?IBMVFC_SCSI_HW_QUEUES :1 ; + shost->nr_hw_queues = mq_enabled ? nr_scsi_hw_queues :1 ; vhost =shost_priv (shost);INIT_LIST_HEAD (&vhost->targets);
@@ -5897,8 +5954,8 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) vhost->log_level = log_level; vhost->task_set =1 ; - vhost->mq_enabled =IBMVFC_MQ ; - vhost->client_scsi_channels =IBMVFC_SCSI_CHANNELS ; + vhost->mq_enabled = mq_enabled; + vhost->client_scsi_channels =min (nr_scsi_hw_queues, nr_scsi_channels); vhost->using_channels =0 ; vhost->do_enquiry =1 ;
Signature · 1 line
2.27.0
Re: [PATCH v4 21/21] ibmvfc: provide modules parameters for MQ settings
drivers/scsi/ibmvscsi/ibmvfc.c static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) · line 5939
Quoted 5 lines · Tyrel Datwyler
drivers/scsi/ibmvscsi/ibmvfc.c +1
-0@@ -5880,12 +5936,13 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) shost->transportt = ibmvfc_transport_template; shost->can_queue = max_requests; + shost->can_queue = (max_requests / nr_scsi_hw_queues);
This looks to be in conflict with the fact that the first patch requested a shared tag set, right?
drivers/scsi/ibmvscsi/ibmvfc.c static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) · line 5945
Quoted 7 lines
drivers/scsi/ibmvscsi/ibmvfc.c +1
-1shost->max_lun = max_lun; shost->max_id = max_targets; shost->max_sectors =IBMVFC_MAX_SECTORS ; shost->max_cmd_len =IBMVFC_MAX_CDB_LEN ; shost->unique_id = shost->host_no; - shost->nr_hw_queues =IBMVFC_MQ ?IBMVFC_SCSI_HW_QUEUES :1 ; + shost->nr_hw_queues = mq_enabled ? nr_scsi_hw_queues :1 ;
You might want to range check this, to make sure its sane.
Quoted 15 lines
drivers/scsi/ibmvscsi/ibmvfc.c +2
-2vhost =shost_priv (shost);INIT_LIST_HEAD (&vhost->targets);@@ -5897,8 +5954,8 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) vhost->log_level = log_level; vhost->task_set =1 ; - vhost->mq_enabled =IBMVFC_MQ ; - vhost->client_scsi_channels =IBMVFC_SCSI_CHANNELS ; + vhost->mq_enabled = mq_enabled; + vhost->client_scsi_channels =min (nr_scsi_hw_queues, nr_scsi_channels); vhost->using_channels =0 ; vhost->do_enquiry =1 ;
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center
With the exception of the few comments I've shared, the rest of this looks good to me and you can add my:
Thanks,
Brian
Signature · 3 lines
Brian King Power Linux I/O IBM Linux Technology Center