Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e7a7c9ab authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi 

Pull SCSI fixes from James Bottomley:
 "This is a set of SAS and SATA fixes; there are one or two longstanding
  bug fixes, but most of this is regression fixes."

* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
  [SCSI] libfc: update mfs boundry checking
  [SCSI] Revert "[SCSI] libsas: fix sas port naming"
  [SCSI] libsas: fix false positive 'device attached' conditions
  [SCSI] libsas, libata: fix start of life for a sas ata_port
  [SCSI] libsas: fix ata_eh clobbering ex_phys via smp_ata_check_ready
  [SCSI] libsas: unify domain_device sas_rphy lifetimes
  [SCSI] libsas: fix sas_get_port_device regression
  [SCSI] libsas: fix sas_find_bcast_phy() in the presence of 'vacant' phys
  [SCSI] libsas: introduce sas_work to fix sas_drain_work vs sas_queue_work
  [SCSI] libata: Pass correct DMA device to scsi host
  [SCSI] scsi_lib: use correct DMA device in __scsi_alloc_queue
parents fec6c20b 93f90e51

drivers/ata/libata-scsi.c

+22 −16
Original line number Diff line number Diff line
@@ -3399,7 +3399,8 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht) 
		 */

		shost->max_host_blocked = 1;



		rc = scsi_add_host(ap->scsi_host, &ap->tdev);

		rc = scsi_add_host_with_dma(ap->scsi_host,

						&ap->tdev, ap->host->dev);

		if (rc)

			goto err_add;

	}
@@ -3838,18 +3839,25 @@ void ata_sas_port_stop(struct ata_port *ap) 
}

EXPORT_SYMBOL_GPL(ata_sas_port_stop);



int ata_sas_async_port_init(struct ata_port *ap)

/**

 * ata_sas_async_probe - simply schedule probing and return

 * @ap: Port to probe

 *

 * For batch scheduling of probe for sas attached ata devices, assumes

 * the port has already been through ata_sas_port_init()

 */

void ata_sas_async_probe(struct ata_port *ap)

{

	int rc = ap->ops->port_start(ap);



	if (!rc) {

		ap->print_id = atomic_inc_return(&ata_print_id);

	__ata_port_probe(ap);

}

EXPORT_SYMBOL_GPL(ata_sas_async_probe);



	return rc;

int ata_sas_sync_probe(struct ata_port *ap)

{

	return ata_port_probe(ap);

}

EXPORT_SYMBOL_GPL(ata_sas_async_port_init);

EXPORT_SYMBOL_GPL(ata_sas_sync_probe);





/**

 *	ata_sas_port_init - Initialize a SATA device
@@ -3866,12 +3874,10 @@ int ata_sas_port_init(struct ata_port *ap) 
{

	int rc = ap->ops->port_start(ap);



	if (!rc) {

		ap->print_id = atomic_inc_return(&ata_print_id);

		rc = ata_port_probe(ap);

	}



	if (rc)

		return rc;

	ap->print_id = atomic_inc_return(&ata_print_id);

	return 0;

}

EXPORT_SYMBOL_GPL(ata_sas_port_init);

drivers/scsi/ipr.c

+5 −1
Original line number Diff line number Diff line
@@ -4549,8 +4549,12 @@ static int ipr_ata_slave_alloc(struct scsi_device *sdev) 
	ENTER;

	if (sdev->sdev_target)

		sata_port = sdev->sdev_target->hostdata;

	if (sata_port)

	if (sata_port) {

		rc = ata_sas_port_init(sata_port->ap);

		if (rc == 0)

			rc = ata_sas_sync_probe(sata_port->ap);

	}



	if (rc)

		ipr_slave_destroy(sdev);

drivers/scsi/libfc/fc_lport.c

+7 −5
Original line number Diff line number Diff line
@@ -1742,17 +1742,19 @@ void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp, 


	mfs = ntohs(flp->fl_csp.sp_bb_data) &

		FC_SP_BB_DATA_MASK;

	if (mfs >= FC_SP_MIN_MAX_PAYLOAD &&

	    mfs <= lport->mfs) {

		lport->mfs = mfs;

		fc_host_maxframe_size(lport->host) = mfs;

	} else {



	if (mfs < FC_SP_MIN_MAX_PAYLOAD || mfs > FC_SP_MAX_MAX_PAYLOAD) {

		FC_LPORT_DBG(lport, "FLOGI bad mfs:%hu response, "

			     "lport->mfs:%hu\n", mfs, lport->mfs);

		fc_lport_error(lport, fp);

		goto err;

	}



	if (mfs <= lport->mfs) {

		lport->mfs = mfs;

		fc_host_maxframe_size(lport->host) = mfs;

	}



	csp_flags = ntohs(flp->fl_csp.sp_features);

	r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);

	e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);

drivers/scsi/libsas/sas_ata.c

+10 −23
Original line number Diff line number Diff line
@@ -546,11 +546,12 @@ static struct ata_port_info sata_port_info = { 
	.port_ops = &sas_sata_ops

};



int sas_ata_init_host_and_port(struct domain_device *found_dev)

int sas_ata_init(struct domain_device *found_dev)

{

	struct sas_ha_struct *ha = found_dev->port->ha;

	struct Scsi_Host *shost = ha->core.shost;

	struct ata_port *ap;

	int rc;



	ata_host_init(&found_dev->sata_dev.ata_host,

		      ha->dev,
@@ -567,8 +568,11 @@ int sas_ata_init_host_and_port(struct domain_device *found_dev) 
	ap->private_data = found_dev;

	ap->cbl = ATA_CBL_SATA;

	ap->scsi_host = shost;

	/* publish initialized ata port */

	smp_wmb();

	rc = ata_sas_port_init(ap);

	if (rc) {

		ata_sas_port_destroy(ap);

		return rc;

	}

	found_dev->sata_dev.ap = ap;



	return 0;
@@ -648,18 +652,13 @@ static void sas_get_ata_command_set(struct domain_device *dev) 
void sas_probe_sata(struct asd_sas_port *port)

{

	struct domain_device *dev, *n;

	int err;



	mutex_lock(&port->ha->disco_mutex);

	list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {

	list_for_each_entry(dev, &port->disco_list, disco_list_node) {

		if (!dev_is_sata(dev))

			continue;



		err = sas_ata_init_host_and_port(dev);

		if (err)

			sas_fail_probe(dev, __func__, err);

		else

			ata_sas_async_port_init(dev->sata_dev.ap);

		ata_sas_async_probe(dev->sata_dev.ap);

	}

	mutex_unlock(&port->ha->disco_mutex);
@@ -718,18 +717,6 @@ static void async_sas_ata_eh(void *data, async_cookie_t cookie) 
	sas_put_device(dev);

}



static bool sas_ata_dev_eh_valid(struct domain_device *dev)

{

	struct ata_port *ap;



	if (!dev_is_sata(dev))

		return false;

	ap = dev->sata_dev.ap;

	/* consume fully initialized ata ports */

	smp_rmb();

	return !!ap;

}



void sas_ata_strategy_handler(struct Scsi_Host *shost)

{

	struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
@@ -753,7 +740,7 @@ void sas_ata_strategy_handler(struct Scsi_Host *shost) 


		spin_lock(&port->dev_list_lock);

		list_for_each_entry(dev, &port->dev_list, dev_list_node) {

			if (!sas_ata_dev_eh_valid(dev))

			if (!dev_is_sata(dev))

				continue;

			async_schedule_domain(async_sas_ata_eh, dev, &async);

		}

drivers/scsi/libsas/sas_discover.c

+35 −26
Original line number Diff line number Diff line
@@ -72,6 +72,7 @@ static int sas_get_port_device(struct asd_sas_port *port) 
	struct asd_sas_phy *phy;

	struct sas_rphy *rphy;

	struct domain_device *dev;

	int rc = -ENODEV;



	dev = sas_alloc_device();

	if (!dev)
@@ -110,9 +111,16 @@ static int sas_get_port_device(struct asd_sas_port *port) 


	sas_init_dev(dev);



	dev->port = port;

	switch (dev->dev_type) {

	case SAS_END_DEV:

	case SATA_DEV:

		rc = sas_ata_init(dev);

		if (rc) {

			rphy = NULL;

			break;

		}

		/* fall through */

	case SAS_END_DEV:

		rphy = sas_end_device_alloc(port->port);

		break;

	case EDGE_DEV:
@@ -131,19 +139,14 @@ static int sas_get_port_device(struct asd_sas_port *port) 


	if (!rphy) {

		sas_put_device(dev);

		return -ENODEV;

		return rc;

	}



	spin_lock_irq(&port->phy_list_lock);

	list_for_each_entry(phy, &port->phy_list, port_phy_el)

		sas_phy_set_target(phy, dev);

	spin_unlock_irq(&port->phy_list_lock);

	rphy->identify.phy_identifier = phy->phy->identify.phy_identifier;

	memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE);

	sas_fill_in_rphy(dev, rphy);

	sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr);

	port->port_dev = dev;

	dev->port = port;

	dev->linkrate = port->linkrate;

	dev->min_linkrate = port->linkrate;

	dev->max_linkrate = port->linkrate;
@@ -155,6 +158,7 @@ static int sas_get_port_device(struct asd_sas_port *port) 
	sas_device_set_phy(dev, port->port);



	dev->rphy = rphy;

	get_device(&dev->rphy->dev);



	if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEV)

		list_add_tail(&dev->disco_list_node, &port->disco_list);
@@ -164,6 +168,11 @@ static int sas_get_port_device(struct asd_sas_port *port) 
		spin_unlock_irq(&port->dev_list_lock);

	}



	spin_lock_irq(&port->phy_list_lock);

	list_for_each_entry(phy, &port->phy_list, port_phy_el)

		sas_phy_set_target(phy, dev);

	spin_unlock_irq(&port->phy_list_lock);



	return 0;

}
@@ -205,8 +214,7 @@ void sas_notify_lldd_dev_gone(struct domain_device *dev) 
static void sas_probe_devices(struct work_struct *work)

{

	struct domain_device *dev, *n;

	struct sas_discovery_event *ev =

		container_of(work, struct sas_discovery_event, work);

	struct sas_discovery_event *ev = to_sas_discovery_event(work);

	struct asd_sas_port *port = ev->port;



	clear_bit(DISCE_PROBE, &port->disc.pending);
@@ -255,6 +263,9 @@ void sas_free_device(struct kref *kref) 
{

	struct domain_device *dev = container_of(kref, typeof(*dev), kref);



	put_device(&dev->rphy->dev);

	dev->rphy = NULL;



	if (dev->parent)

		sas_put_device(dev->parent);
@@ -291,8 +302,7 @@ static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_d 
static void sas_destruct_devices(struct work_struct *work)

{

	struct domain_device *dev, *n;

	struct sas_discovery_event *ev =

		container_of(work, struct sas_discovery_event, work);

	struct sas_discovery_event *ev = to_sas_discovery_event(work);

	struct asd_sas_port *port = ev->port;



	clear_bit(DISCE_DESTRUCT, &port->disc.pending);
@@ -302,7 +312,6 @@ static void sas_destruct_devices(struct work_struct *work) 


		sas_remove_children(&dev->rphy->dev);

		sas_rphy_delete(dev->rphy);

		dev->rphy = NULL;

		sas_unregister_common_dev(port, dev);

	}

}
@@ -314,11 +323,11 @@ void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *dev) 
		/* this rphy never saw sas_rphy_add */

		list_del_init(&dev->disco_list_node);

		sas_rphy_free(dev->rphy);

		dev->rphy = NULL;

		sas_unregister_common_dev(port, dev);

		return;

	}



	if (dev->rphy && !test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) {

	if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) {

		sas_rphy_unlink(dev->rphy);

		list_move_tail(&dev->disco_list_node, &port->destroy_list);

		sas_discover_event(dev->port, DISCE_DESTRUCT);
@@ -377,8 +386,7 @@ static void sas_discover_domain(struct work_struct *work) 
{

	struct domain_device *dev;

	int error = 0;

	struct sas_discovery_event *ev =

		container_of(work, struct sas_discovery_event, work);

	struct sas_discovery_event *ev = to_sas_discovery_event(work);

	struct asd_sas_port *port = ev->port;



	clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending);
@@ -419,8 +427,6 @@ static void sas_discover_domain(struct work_struct *work) 


	if (error) {

		sas_rphy_free(dev->rphy);

		dev->rphy = NULL;



		list_del_init(&dev->disco_list_node);

		spin_lock_irq(&port->dev_list_lock);

		list_del_init(&dev->dev_list_node);
@@ -437,8 +443,7 @@ static void sas_discover_domain(struct work_struct *work) 
static void sas_revalidate_domain(struct work_struct *work)

{

	int res = 0;

	struct sas_discovery_event *ev =

		container_of(work, struct sas_discovery_event, work);

	struct sas_discovery_event *ev = to_sas_discovery_event(work);

	struct asd_sas_port *port = ev->port;

	struct sas_ha_struct *ha = port->ha;
@@ -466,21 +471,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)

static void sas_chain_work(struct sas_ha_struct *ha, struct sas_work *sw)

{

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

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

	/* chained work is not subject to SA_HA_DRAINING or

	 * SAS_HA_REGISTERED, because it is either submitted in the

	 * workqueue, or known to be submitted from a context that is

	 * not racing against draining

	 */

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

}



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

			    struct work_struct *work,

			    struct sas_work *sw,

			    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);

		sas_chain_work(ha, sw);

		spin_unlock_irqrestore(&ha->state_lock, flags);

	}

}
@@ -519,7 +528,7 @@ void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port) 


	disc->pending = 0;

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

		INIT_WORK(&disc->disc_work[i].work, sas_event_fns[i]);

		INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]);

		disc->disc_work[i].port = port;

	}

}