Commit af92c02f authored by Martin K. Petersen's avatar Martin K. Petersen
Browse files

Merge patch series "scsi: fixes for targets with many LUNs, and scsi_target_block rework" 

Martin Wilck <mwilck@suse.com> says:

This patch series addresses some issues we saw in a test setup with a
large number of SCSI LUNs. The first two patches simply increase the
number of available sg and bsg devices. 3-5 fix a large delay we
encountered between blocking a Fibre Channel remote port and the
dev_loss_tmo. 6 renames scsi_target_block() to scsi_block_targets(),
and makes additional changes to this API, as suggested in the review
of the v2 series. 7 improves a warning message.

Link: https://lore.kernel.org/r/20230614103616.31857-1-mwilck@suse.com


Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parents 20fce500 6d7160c7

block/bsg.c

+1 −1
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ static inline struct bsg_device *to_bsg_device(struct inode *inode) 
}



#define BSG_DEFAULT_CMDS	64

#define BSG_MAX_DEVS		32768

#define BSG_MAX_DEVS		(1 << MINORBITS)



static DEFINE_IDA(bsg_minor_ida);

static struct class *bsg_class;

drivers/scsi/scsi_lib.c

+40 −40
Original line number Diff line number Diff line
@@ -2731,24 +2731,16 @@ void scsi_start_queue(struct scsi_device *sdev) 
		blk_mq_unquiesce_queue(sdev->request_queue);

}



static void scsi_stop_queue(struct scsi_device *sdev, bool nowait)

static void scsi_stop_queue(struct scsi_device *sdev)

{

	/*

	 * The atomic variable of ->queue_stopped covers that

	 * blk_mq_quiesce_queue* is balanced with blk_mq_unquiesce_queue.

	 *

	 * However, we still need to wait until quiesce is done

	 * in case that queue has been stopped.

	 * The caller needs to wait until quiesce is done.

	 */

	if (!cmpxchg(&sdev->queue_stopped, 0, 1)) {

		if (nowait)

	if (!cmpxchg(&sdev->queue_stopped, 0, 1))

		blk_mq_quiesce_queue_nowait(sdev->request_queue);

		else

			blk_mq_quiesce_queue(sdev->request_queue);

	} else {

		if (!nowait)

			blk_mq_wait_quiesce_done(sdev->request_queue->tag_set);

	}

}



/**
@@ -2775,19 +2767,19 @@ int scsi_internal_device_block_nowait(struct scsi_device *sdev) 
	 * request queue.

	 */

	if (!ret)

		scsi_stop_queue(sdev, true);

		scsi_stop_queue(sdev);

	return ret;

}

EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait);



/**

 * scsi_internal_device_block - try to transition to the SDEV_BLOCK state

 * scsi_device_block - try to transition to the SDEV_BLOCK state

 * @sdev: device to block

 * @data: dummy argument, ignored

 *

 * Pause SCSI command processing on the specified device and wait until all

 * ongoing scsi_request_fn() / scsi_queue_rq() calls have finished. May sleep.

 *

 * Returns zero if successful or a negative error code upon failure.

 * Pause SCSI command processing on the specified device. Callers must wait

 * until all ongoing scsi_queue_rq() calls have finished after this function

 * returns.

 *

 * Note:

 * This routine transitions the device to the SDEV_BLOCK state (which must be
@@ -2795,17 +2787,26 @@ EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait); 
 * is paused until the device leaves the SDEV_BLOCK state. See also

 * scsi_internal_device_unblock().

 */

static int scsi_internal_device_block(struct scsi_device *sdev)

static void scsi_device_block(struct scsi_device *sdev, void *data)

{

	int err;

	enum scsi_device_state state;



	mutex_lock(&sdev->state_mutex);

	err = __scsi_internal_device_block_nowait(sdev);

	state = sdev->sdev_state;

	if (err == 0)

		scsi_stop_queue(sdev, false);

		/*

		 * scsi_stop_queue() must be called with the state_mutex

		 * held. Otherwise a simultaneous scsi_start_queue() call

		 * might unquiesce the queue before we quiesce it.

		 */

		scsi_stop_queue(sdev);



	mutex_unlock(&sdev->state_mutex);



	return err;

	WARN_ONCE(err, "%s: failed to block %s in state %d\n",

		  __func__, dev_name(&sdev->sdev_gendev), state);

}



/**
@@ -2888,36 +2889,35 @@ static int scsi_internal_device_unblock(struct scsi_device *sdev, 
	return ret;

}



static void

device_block(struct scsi_device *sdev, void *data)

{

	int ret;



	ret = scsi_internal_device_block(sdev);



	WARN_ONCE(ret, "scsi_internal_device_block(%s) failed: ret = %d\n",

		  dev_name(&sdev->sdev_gendev), ret);

}



static int

target_block(struct device *dev, void *data)

{

	if (scsi_is_target_device(dev))

		starget_for_each_device(to_scsi_target(dev), NULL,

					device_block);

					scsi_device_block);

	return 0;

}



/**

 * scsi_block_targets - transition all SCSI child devices to SDEV_BLOCK state

 * @dev: a parent device of one or more scsi_target devices

 * @shost: the Scsi_Host to which this device belongs

 *

 * Iterate over all children of @dev, which should be scsi_target devices,

 * and switch all subordinate scsi devices to SDEV_BLOCK state. Wait for

 * ongoing scsi_queue_rq() calls to finish. May sleep.

 *

 * Note:

 * @dev must not itself be a scsi_target device.

 */

void

scsi_target_block(struct device *dev)

scsi_block_targets(struct Scsi_Host *shost, struct device *dev)

{

	if (scsi_is_target_device(dev))

		starget_for_each_device(to_scsi_target(dev), NULL,

					device_block);

	else

	WARN_ON_ONCE(scsi_is_target_device(dev));

	device_for_each_child(dev, NULL, target_block);

	blk_mq_wait_quiesce_done(&shost->tag_set);

}

EXPORT_SYMBOL_GPL(scsi_target_block);

EXPORT_SYMBOL_GPL(scsi_block_targets);



static void

device_unblock(struct scsi_device *sdev, void *data)

drivers/scsi/scsi_transport_fc.c

+1 −1
Original line number Diff line number Diff line
@@ -3451,7 +3451,7 @@ fc_remote_port_delete(struct fc_rport *rport) 


	spin_unlock_irqrestore(shost->host_lock, flags);



	scsi_target_block(&rport->dev);

	scsi_block_targets(shost, &rport->dev);



	/* see if we need to kill io faster than waiting for device loss */

	if ((rport->fast_io_fail_tmo != -1) &&

drivers/scsi/scsi_transport_iscsi.c

+2 −1
Original line number Diff line number Diff line
@@ -1943,13 +1943,14 @@ static void __iscsi_block_session(struct work_struct *work) 
	struct iscsi_cls_session *session =

			container_of(work, struct iscsi_cls_session,

				     block_work);

	struct Scsi_Host *shost = iscsi_session_to_shost(session);

	unsigned long flags;



	ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");

	spin_lock_irqsave(&session->lock, flags);

	session->state = ISCSI_SESSION_FAILED;

	spin_unlock_irqrestore(&session->lock, flags);

	scsi_target_block(&session->dev);

	scsi_block_targets(shost, &session->dev);

	ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");

	if (session->recovery_tmo >= 0)

		queue_delayed_work(session->workq,

drivers/scsi/scsi_transport_srp.c

+3 −3
Original line number Diff line number Diff line
@@ -396,7 +396,7 @@ static void srp_reconnect_work(struct work_struct *work) 
}



/*

 * scsi_target_block() must have been called before this function is

 * scsi_block_targets() must have been called before this function is

 * called to guarantee that no .queuecommand() calls are in progress.

 */

static void __rport_fail_io_fast(struct srp_rport *rport)
@@ -480,7 +480,7 @@ static void __srp_start_tl_fail_timers(struct srp_rport *rport) 
	    srp_rport_set_state(rport, SRP_RPORT_BLOCKED) == 0) {

		pr_debug("%s new state: %d\n", dev_name(&shost->shost_gendev),

			 rport->state);

		scsi_target_block(&shost->shost_gendev);

		scsi_block_targets(shost, &shost->shost_gendev);

		if (fast_io_fail_tmo >= 0)

			queue_delayed_work(system_long_wq,

					   &rport->fast_io_fail_work,
@@ -548,7 +548,7 @@ int srp_reconnect_rport(struct srp_rport *rport) 
		 * later is ok though, scsi_internal_device_unblock_nowait()

		 * treats SDEV_TRANSPORT_OFFLINE like SDEV_BLOCK.

		 */

		scsi_target_block(&shost->shost_gendev);

		scsi_block_targets(shost, &shost->shost_gendev);

	res = rport->state != SRP_RPORT_LOST ? i->f->reconnect(rport) : -ENODEV;

	pr_debug("%s (state %d): transport.reconnect() returned %d\n",

		 dev_name(&shost->shost_gendev), rport->state, res);