Commit b1124cd3 authored by Dan Williams's avatar Dan Williams Committed by James Bottomley
Browse files

[SCSI] libsas: introduce sas_drain_work() 



When an lldd invokes ->notify_port_event() it can trigger a chain of libsas
events to:

  1/ form the port and find the direct attached device

  2/ if the attached device is an expander perform domain discovery

A call to flush_workqueue() will only flush the initial port formation work.
Currently libsas users need to call scsi_flush_work() up to the max depth of
chain (which will grow from 2 to 3 when ata discovery is moved to its own
discovery event).  Instead of open coding multiple calls switch to use
drain_workqueue() to flush sas work.

drain_workqueue() does not handle new work submitted during the drain so
libsas needs a bit of infrastructure to hold off unchained work submissions
while a drain is in flight.  A lldd ->notify() event is considered 'unchained'
while a sas_discover_event() is 'chained'.  As Tejun notes:

  "For now, I think it would be best to add private wrapper in libsas to
   support deferring unchained work items while draining."

Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
Signed-off-by: default avatarJames Bottomley <JBottomley@Parallels.com>
parent f8daa6e6

drivers/scsi/aic94xx/aic94xx_init.c

+1 −1
Original line number Diff line number Diff line
@@ -971,7 +971,7 @@ static int asd_scan_finished(struct Scsi_Host *shost, unsigned long time) 
	if (time < HZ)

		return 0;

	/* Wait for discovery to finish */

	scsi_flush_work(shost);

	sas_drain_work(SHOST_TO_SAS_HA(shost));

	return 1;

}

drivers/scsi/isci/host.c

+3 −5
Original line number Diff line number Diff line
@@ -650,15 +650,13 @@ static void isci_host_start_complete(struct isci_host *ihost, enum sci_status co 


int isci_host_scan_finished(struct Scsi_Host *shost, unsigned long time)

{

	struct isci_host *ihost = SHOST_TO_SAS_HA(shost)->lldd_ha;

	struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);

	struct isci_host *ihost = ha->lldd_ha;



	if (test_bit(IHOST_START_PENDING, &ihost->flags))

		return 0;



	/* todo: use sas_flush_discovery once it is upstream */

	scsi_flush_work(shost);



	scsi_flush_work(shost);

	sas_drain_work(ha);



	dev_dbg(&ihost->pdev->dev,

		"%s: ihost->status = %d, time = %ld\n",

drivers/scsi/libsas/sas_discover.c

+20 −1
Original line number Diff line number Diff line
@@ -367,6 +367,25 @@ static void sas_revalidate_domain(struct work_struct *work) 


/* ---------- Events ---------- */



static void sas_chain_work(struct sas_ha_struct *ha, struct work_struct *work)

{

	/* chained work is not subject to SA_HA_DRAINING or SAS_HA_REGISTERED */

	scsi_queue_work(ha->core.shost, work);

}



static void sas_chain_event(int event, unsigned long *pending,

			    struct work_struct *work,

			    struct sas_ha_struct *ha)

{

	if (!test_and_set_bit(event, pending)) {

		unsigned long flags;



		spin_lock_irqsave(&ha->state_lock, flags);

		sas_chain_work(ha, work);

		spin_unlock_irqrestore(&ha->state_lock, flags);

	}

}



int sas_discover_event(struct asd_sas_port *port, enum discover_event ev)

{

	struct sas_discovery *disc;
@@ -377,7 +396,7 @@ int sas_discover_event(struct asd_sas_port *port, enum discover_event ev) 


	BUG_ON(ev >= DISC_NUM_EVENTS);



	sas_queue_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);

	sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);



	return 0;

}

drivers/scsi/libsas/sas_event.c

+55 −0
Original line number Diff line number Diff line
@@ -22,10 +22,65 @@ 
 *

 */



#include <linux/export.h>

#include <scsi/scsi_host.h>

#include "sas_internal.h"

#include "sas_dump.h"



static void sas_queue_work(struct sas_ha_struct *ha, struct work_struct *work)

{

	if (!test_bit(SAS_HA_REGISTERED, &ha->state))

		return;



	if (test_bit(SAS_HA_DRAINING, &ha->state))

		list_add(&work->entry, &ha->defer_q);

	else

		scsi_queue_work(ha->core.shost, work);

}



static void sas_queue_event(int event, unsigned long *pending,

			    struct work_struct *work,

			    struct sas_ha_struct *ha)

{

	if (!test_and_set_bit(event, pending)) {

		unsigned long flags;



		spin_lock_irqsave(&ha->state_lock, flags);

		sas_queue_work(ha, work);

		spin_unlock_irqrestore(&ha->state_lock, flags);

	}

}



int sas_drain_work(struct sas_ha_struct *ha)

{

	struct workqueue_struct *wq = ha->core.shost->work_q;

	struct work_struct *w, *_w;

	int err;



	err = mutex_lock_interruptible(&ha->drain_mutex);

	if (err)

		return err;



	set_bit(SAS_HA_DRAINING, &ha->state);

	/* flush submitters */

	spin_lock_irq(&ha->state_lock);

	spin_unlock_irq(&ha->state_lock);



	drain_workqueue(wq);



	spin_lock_irq(&ha->state_lock);

	clear_bit(SAS_HA_DRAINING, &ha->state);

	list_for_each_entry_safe(w, _w, &ha->defer_q, entry) {

		list_del_init(&w->entry);

		sas_queue_work(ha, w);

	}

	spin_unlock_irq(&ha->state_lock);

	mutex_unlock(&ha->drain_mutex);



	return 0;

}

EXPORT_SYMBOL_GPL(sas_drain_work);



static void notify_ha_event(struct sas_ha_struct *sas_ha, enum ha_event event)

{

	BUG_ON(event >= HA_NUM_EVENTS);

drivers/scsi/libsas/sas_init.c

+6 −3
Original line number Diff line number Diff line
@@ -114,6 +114,8 @@ int sas_register_ha(struct sas_ha_struct *sas_ha) 


	set_bit(SAS_HA_REGISTERED, &sas_ha->state);

	spin_lock_init(&sas_ha->state_lock);

	mutex_init(&sas_ha->drain_mutex);

	INIT_LIST_HEAD(&sas_ha->defer_q);



	error = sas_register_phys(sas_ha);

	if (error) {
@@ -157,12 +159,13 @@ int sas_unregister_ha(struct sas_ha_struct *sas_ha) 
{

	unsigned long flags;



	/* Set the state to unregistered to avoid further

	 * events to be queued */

	/* Set the state to unregistered to avoid further unchained

	 * events to be queued

	 */

	spin_lock_irqsave(&sas_ha->state_lock, flags);

	clear_bit(SAS_HA_REGISTERED, &sas_ha->state);

	spin_unlock_irqrestore(&sas_ha->state_lock, flags);

	scsi_flush_work(sas_ha->core.shost);

	sas_drain_work(sas_ha);



	sas_unregister_ports(sas_ha);

CRA Git | Maintained and supported by SUSTech CRA and CCSE