hosts.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  hosts.c Copyright (C) 1992 Drew Eckhardt
  4 *          Copyright (C) 1993, 1994, 1995 Eric Youngdale
  5 *          Copyright (C) 2002-2003 Christoph Hellwig
  6 *
  7 *  mid to lowlevel SCSI driver interface
  8 *      Initial versions: Drew Eckhardt
  9 *      Subsequent revisions: Eric Youngdale
 10 *
 11 *  <drew@colorado.edu>
 12 *
 13 *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
 14 *  Added QLOGIC QLA1280 SCSI controller kernel host support. 
 15 *     August 4, 1999 Fred Lewis, Intel DuPont
 16 *
 17 *  Updated to reflect the new initialization scheme for the higher 
 18 *  level of scsi drivers (sd/sr/st)
 19 *  September 17, 2000 Torben Mathiasen <tmm@image.dk>
 20 *
 21 *  Restructured scsi_host lists and associated functions.
 22 *  September 04, 2002 Mike Anderson (andmike@us.ibm.com)
 23 */
 24
 25#include <linux/module.h>
 26#include <linux/blkdev.h>
 27#include <linux/kernel.h>
 28#include <linux/slab.h>
 29#include <linux/kthread.h>
 30#include <linux/string.h>
 31#include <linux/mm.h>
 32#include <linux/init.h>
 33#include <linux/completion.h>
 34#include <linux/transport_class.h>
 35#include <linux/platform_device.h>
 36#include <linux/pm_runtime.h>
 37#include <linux/idr.h>
 38#include <scsi/scsi_device.h>
 39#include <scsi/scsi_host.h>
 40#include <scsi/scsi_transport.h>
 41#include <scsi/scsi_cmnd.h>
 42
 43#include "scsi_priv.h"
 44#include "scsi_logging.h"
 45
 46
 47static int shost_eh_deadline = -1;
 48
 49module_param_named(eh_deadline, shost_eh_deadline, int, S_IRUGO|S_IWUSR);
 50MODULE_PARM_DESC(eh_deadline,
 51		 "SCSI EH timeout in seconds (should be between 0 and 2^31-1)");
 52
 53static DEFINE_IDA(host_index_ida);
 54
 55
 56static void scsi_host_cls_release(struct device *dev)
 57{
 58	put_device(&class_to_shost(dev)->shost_gendev);
 59}
 60
 61static struct class shost_class = {
 62	.name		= "scsi_host",
 63	.dev_release	= scsi_host_cls_release,
 64	.dev_groups	= scsi_shost_groups,
 65};
 66
 67/**
 68 *	scsi_host_set_state - Take the given host through the host state model.
 69 *	@shost:	scsi host to change the state of.
 70 *	@state:	state to change to.
 71 *
 72 *	Returns zero if unsuccessful or an error if the requested
 73 *	transition is illegal.
 74 **/
 75int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
 76{
 77	enum scsi_host_state oldstate = shost->shost_state;
 78
 79	if (state == oldstate)
 80		return 0;
 81
 82	switch (state) {
 83	case SHOST_CREATED:
 84		/* There are no legal states that come back to
 85		 * created.  This is the manually initialised start
 86		 * state */
 87		goto illegal;
 88
 89	case SHOST_RUNNING:
 90		switch (oldstate) {
 91		case SHOST_CREATED:
 92		case SHOST_RECOVERY:
 93			break;
 94		default:
 95			goto illegal;
 96		}
 97		break;
 98
 99	case SHOST_RECOVERY:
100		switch (oldstate) {
101		case SHOST_RUNNING:
102			break;
103		default:
104			goto illegal;
105		}
106		break;
107
108	case SHOST_CANCEL:
109		switch (oldstate) {
110		case SHOST_CREATED:
111		case SHOST_RUNNING:
112		case SHOST_CANCEL_RECOVERY:
113			break;
114		default:
115			goto illegal;
116		}
117		break;
118
119	case SHOST_DEL:
120		switch (oldstate) {
121		case SHOST_CANCEL:
122		case SHOST_DEL_RECOVERY:
123			break;
124		default:
125			goto illegal;
126		}
127		break;
128
129	case SHOST_CANCEL_RECOVERY:
130		switch (oldstate) {
131		case SHOST_CANCEL:
132		case SHOST_RECOVERY:
133			break;
134		default:
135			goto illegal;
136		}
137		break;
138
139	case SHOST_DEL_RECOVERY:
140		switch (oldstate) {
141		case SHOST_CANCEL_RECOVERY:
142			break;
143		default:
144			goto illegal;
145		}
146		break;
147	}
148	shost->shost_state = state;
149	return 0;
150
151 illegal:
152	SCSI_LOG_ERROR_RECOVERY(1,
153				shost_printk(KERN_ERR, shost,
154					     "Illegal host state transition"
155					     "%s->%s\n",
156					     scsi_host_state_name(oldstate),
157					     scsi_host_state_name(state)));
158	return -EINVAL;
159}
160
161/**
162 * scsi_remove_host - remove a scsi host
163 * @shost:	a pointer to a scsi host to remove
164 **/
165void scsi_remove_host(struct Scsi_Host *shost)
166{
167	unsigned long flags;
168
169	mutex_lock(&shost->scan_mutex);
170	spin_lock_irqsave(shost->host_lock, flags);
171	if (scsi_host_set_state(shost, SHOST_CANCEL))
172		if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
173			spin_unlock_irqrestore(shost->host_lock, flags);
174			mutex_unlock(&shost->scan_mutex);
175			return;
176		}
177	spin_unlock_irqrestore(shost->host_lock, flags);
178
179	scsi_autopm_get_host(shost);
180	flush_workqueue(shost->tmf_work_q);
181	scsi_forget_host(shost);
182	mutex_unlock(&shost->scan_mutex);
183	scsi_proc_host_rm(shost);
184	scsi_proc_hostdir_rm(shost->hostt);
185
186	/*
187	 * New SCSI devices cannot be attached anymore because of the SCSI host
188	 * state so drop the tag set refcnt. Wait until the tag set refcnt drops
189	 * to zero because .exit_cmd_priv implementations may need the host
190	 * pointer.
191	 */
192	kref_put(&shost->tagset_refcnt, scsi_mq_free_tags);
193	wait_for_completion(&shost->tagset_freed);
194
195	spin_lock_irqsave(shost->host_lock, flags);
196	if (scsi_host_set_state(shost, SHOST_DEL))
197		BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY));
198	spin_unlock_irqrestore(shost->host_lock, flags);
199
200	transport_unregister_device(&shost->shost_gendev);
201	device_unregister(&shost->shost_dev);
202	device_del(&shost->shost_gendev);
203}
204EXPORT_SYMBOL(scsi_remove_host);
205
206/**
207 * scsi_add_host_with_dma - add a scsi host with dma device
208 * @shost:	scsi host pointer to add
209 * @dev:	a struct device of type scsi class
210 * @dma_dev:	dma device for the host
211 *
212 * Note: You rarely need to worry about this unless you're in a
213 * virtualised host environments, so use the simpler scsi_add_host()
214 * function instead.
215 *
216 * Return value: 
217 * 	0 on success / != 0 for error
218 **/
219int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
220			   struct device *dma_dev)
221{
222	const struct scsi_host_template *sht = shost->hostt;
223	int error = -EINVAL;
224
225	shost_printk(KERN_INFO, shost, "%s\n",
226			sht->info ? sht->info(shost) : sht->name);
227
228	if (!shost->can_queue) {
229		shost_printk(KERN_ERR, shost,
230			     "can_queue = 0 no longer supported\n");
231		goto fail;
232	}
233
234	if (shost->nr_reserved_cmds && !sht->queue_reserved_command) {
235		shost_printk(KERN_ERR, shost,
236			     "nr_reserved_cmds set but no method to queue\n");
237		goto fail;
238	}
239
240	/* Use min_t(int, ...) in case shost->can_queue exceeds SHRT_MAX */
241	shost->cmd_per_lun = min_t(int, shost->cmd_per_lun,
242				   shost->can_queue);
243
244	error = scsi_init_sense_cache(shost);
245	if (error)
246		goto fail;
247
248	if (!shost->shost_gendev.parent)
249		shost->shost_gendev.parent = dev ? dev : &platform_bus;
250	if (!dma_dev)
251		dma_dev = shost->shost_gendev.parent;
252
253	shost->dma_dev = dma_dev;
254
255	if (dma_dev->dma_mask) {
256		shost->max_sectors = min_t(unsigned int, shost->max_sectors,
257				dma_max_mapping_size(dma_dev) >> SECTOR_SHIFT);
258	}
259
260	error = scsi_mq_setup_tags(shost);
261	if (error)
262		goto fail;
263
264	kref_init(&shost->tagset_refcnt);
265	init_completion(&shost->tagset_freed);
266
267	/*
268	 * Increase usage count temporarily here so that calling
269	 * scsi_autopm_put_host() will trigger runtime idle if there is
270	 * nothing else preventing suspending the device.
271	 */
272	pm_runtime_get_noresume(&shost->shost_gendev);
273	pm_runtime_set_active(&shost->shost_gendev);
274	pm_runtime_enable(&shost->shost_gendev);
275	device_enable_async_suspend(&shost->shost_gendev);
276
277	error = device_add(&shost->shost_gendev);
278	if (error)
279		goto out_disable_runtime_pm;
280
281	scsi_host_set_state(shost, SHOST_RUNNING);
282	get_device(shost->shost_gendev.parent);
283
284	device_enable_async_suspend(&shost->shost_dev);
285
286	get_device(&shost->shost_gendev);
287	error = device_add(&shost->shost_dev);
288	if (error)
289		goto out_del_gendev;
290
291	if (shost->transportt->host_size) {
292		shost->shost_data = kzalloc(shost->transportt->host_size,
293					 GFP_KERNEL);
294		if (shost->shost_data == NULL) {
295			error = -ENOMEM;
296			goto out_del_dev;
297		}
298	}
299
300	if (shost->transportt->create_work_queue) {
301		shost->work_q = alloc_workqueue(
302			"scsi_wq_%d",
303			WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, 1,
304			shost->host_no);
305
306		if (!shost->work_q) {
307			error = -EINVAL;
308			goto out_del_dev;
309		}
310	}
311
312	error = scsi_sysfs_add_host(shost);
313	if (error)
314		goto out_del_dev;
315
316	if (shost->nr_reserved_cmds) {
317		shost->pseudo_sdev = scsi_get_pseudo_sdev(shost);
318		if (!shost->pseudo_sdev) {
319			error = -ENOMEM;
320			goto out_del_dev;
321		}
322	}
323
324	scsi_proc_host_add(shost);
325	scsi_autopm_put_host(shost);
326	return error;
327
328	/*
329	 * Any host allocation in this function will be freed in
330	 * scsi_host_dev_release().
331	 */
332 out_del_dev:
333	device_del(&shost->shost_dev);
334 out_del_gendev:
335	/*
336	 * Host state is SHOST_RUNNING so we have to explicitly release
337	 * ->shost_dev.
338	 */
339	put_device(&shost->shost_dev);
340	device_del(&shost->shost_gendev);
341 out_disable_runtime_pm:
342	device_disable_async_suspend(&shost->shost_gendev);
343	pm_runtime_disable(&shost->shost_gendev);
344	pm_runtime_set_suspended(&shost->shost_gendev);
345	pm_runtime_put_noidle(&shost->shost_gendev);
346	kref_put(&shost->tagset_refcnt, scsi_mq_free_tags);
347 fail:
348	return error;
349}
350EXPORT_SYMBOL(scsi_add_host_with_dma);
351
352static void scsi_host_dev_release(struct device *dev)
353{
354	struct Scsi_Host *shost = dev_to_shost(dev);
355	struct device *parent = dev->parent;
356
357	/* Wait for functions invoked through call_rcu(&scmd->rcu, ...) */
358	rcu_barrier();
359
360	if (shost->tmf_work_q)
361		destroy_workqueue(shost->tmf_work_q);
362	if (shost->ehandler)
363		kthread_stop(shost->ehandler);
364	if (shost->work_q)
365		destroy_workqueue(shost->work_q);
366
367	if (shost->shost_state == SHOST_CREATED) {
368		/*
369		 * Free the shost_dev device name and remove the proc host dir
370		 * here if scsi_host_{alloc,put}() have been called but neither
371		 * scsi_host_add() nor scsi_remove_host() has been called.
372		 * This avoids that the memory allocated for the shost_dev
373		 * name as well as the proc dir structure are leaked.
374		 */
375		scsi_proc_hostdir_rm(shost->hostt);
376		kfree(dev_name(&shost->shost_dev));
377	}
378
379	kfree(shost->shost_data);
380
381	ida_free(&host_index_ida, shost->host_no);
382
383	if (shost->shost_state != SHOST_CREATED)
384		put_device(parent);
385	kfree(shost);
386}
387
388static const struct device_type scsi_host_type = {
389	.name =		"scsi_host",
390	.release =	scsi_host_dev_release,
391};
392
393/**
394 * scsi_host_alloc - register a scsi host adapter instance.
395 * @sht:	pointer to scsi host template
396 * @privsize:	extra bytes to allocate for driver
397 *
398 * Note:
399 * 	Allocate a new Scsi_Host and perform basic initialization.
400 * 	The host is not published to the scsi midlayer until scsi_add_host
401 * 	is called.
402 *
403 * Return value:
404 * 	Pointer to a new Scsi_Host
405 **/
406struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *sht, int privsize)
407{
408	struct Scsi_Host *shost;
409	int index;
410
411	shost = kzalloc(sizeof(struct Scsi_Host) + privsize, GFP_KERNEL);
412	if (!shost)
413		return NULL;
414
415	shost->host_lock = &shost->default_lock;
416	spin_lock_init(shost->host_lock);
417	shost->shost_state = SHOST_CREATED;
418	INIT_LIST_HEAD(&shost->__devices);
419	INIT_LIST_HEAD(&shost->__targets);
420	INIT_LIST_HEAD(&shost->eh_abort_list);
421	INIT_LIST_HEAD(&shost->eh_cmd_q);
422	INIT_LIST_HEAD(&shost->starved_list);
423	init_waitqueue_head(&shost->host_wait);
424	mutex_init(&shost->scan_mutex);
425
426	index = ida_alloc(&host_index_ida, GFP_KERNEL);
427	if (index < 0) {
428		kfree(shost);
429		return NULL;
430	}
431	shost->host_no = index;
432
433	shost->dma_channel = 0xff;
434
435	/* These three are default values which can be overridden */
436	shost->max_channel = 0;
437	shost->max_id = 8;
438	shost->max_lun = 8;
439
440	/* Give each shost a default transportt */
441	shost->transportt = &blank_transport_template;
442
443	/*
444	 * All drivers right now should be able to handle 12 byte
445	 * commands.  Every so often there are requests for 16 byte
446	 * commands, but individual low-level drivers need to certify that
447	 * they actually do something sensible with such commands.
448	 */
449	shost->max_cmd_len = 12;
450	shost->hostt = sht;
451	shost->this_id = sht->this_id;
452	shost->can_queue = sht->can_queue;
453	shost->nr_reserved_cmds = sht->nr_reserved_cmds;
454	shost->sg_tablesize = sht->sg_tablesize;
455	shost->sg_prot_tablesize = sht->sg_prot_tablesize;
456	shost->cmd_per_lun = sht->cmd_per_lun;
457	shost->no_write_same = sht->no_write_same;
458	shost->host_tagset = sht->host_tagset;
459	shost->queuecommand_may_block = sht->queuecommand_may_block;
460
461	if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler)
462		shost->eh_deadline = -1;
463	else if ((ulong) shost_eh_deadline * HZ > INT_MAX) {
464		shost_printk(KERN_WARNING, shost,
465			     "eh_deadline %u too large, setting to %u\n",
466			     shost_eh_deadline, INT_MAX / HZ);
467		shost->eh_deadline = INT_MAX;
468	} else
469		shost->eh_deadline = shost_eh_deadline * HZ;
470
471	if (sht->supported_mode == MODE_UNKNOWN)
472		/* means we didn't set it ... default to INITIATOR */
473		shost->active_mode = MODE_INITIATOR;
474	else
475		shost->active_mode = sht->supported_mode;
476
477	if (sht->max_host_blocked)
478		shost->max_host_blocked = sht->max_host_blocked;
479	else
480		shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED;
481
482	/*
483	 * If the driver imposes no hard sector transfer limit, start at
484	 * machine infinity initially.
485	 */
486	if (sht->max_sectors)
487		shost->max_sectors = sht->max_sectors;
488	else
489		shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS;
490
491	shost->virt_boundary_mask = sht->virt_boundary_mask;
492	if (shost->virt_boundary_mask) {
493		WARN_ON_ONCE(sht->max_segment_size &&
494			     sht->max_segment_size != UINT_MAX);
495		shost->max_segment_size = UINT_MAX;
496	} else {
497		if (sht->max_segment_size)
498			shost->max_segment_size = sht->max_segment_size;
499		else
500			shost->max_segment_size = BLK_MAX_SEGMENT_SIZE;
501	}
502
503	/* 32-byte (dword) is a common minimum for HBAs. */
504	if (sht->dma_alignment)
505		shost->dma_alignment = sht->dma_alignment;
506	else
507		shost->dma_alignment = 3;
508
509	/*
510	 * assume a 4GB boundary, if not set
511	 */
512	if (sht->dma_boundary)
513		shost->dma_boundary = sht->dma_boundary;
514	else
515		shost->dma_boundary = 0xffffffff;
516
517	device_initialize(&shost->shost_gendev);
518	dev_set_name(&shost->shost_gendev, "host%d", shost->host_no);
519	shost->shost_gendev.bus = &scsi_bus_type;
520	shost->shost_gendev.type = &scsi_host_type;
521	scsi_enable_async_suspend(&shost->shost_gendev);
522
523	device_initialize(&shost->shost_dev);
524	shost->shost_dev.parent = &shost->shost_gendev;
525	shost->shost_dev.class = &shost_class;
526	dev_set_name(&shost->shost_dev, "host%d", shost->host_no);
527	shost->shost_dev.groups = sht->shost_groups;
528
529	shost->ehandler = kthread_run(scsi_error_handler, shost,
530			"scsi_eh_%d", shost->host_no);
531	if (IS_ERR(shost->ehandler)) {
532		shost_printk(KERN_WARNING, shost,
533			"error handler thread failed to spawn, error = %ld\n",
534			PTR_ERR(shost->ehandler));
535		shost->ehandler = NULL;
536		goto fail;
537	}
538
539	shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
540					WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_SYSFS,
541					   1, shost->host_no);
542	if (!shost->tmf_work_q) {
543		shost_printk(KERN_WARNING, shost,
544			     "failed to create tmf workq\n");
545		goto fail;
546	}
547	if (scsi_proc_hostdir_add(shost->hostt) < 0)
548		goto fail;
549	return shost;
550 fail:
551	/*
552	 * Host state is still SHOST_CREATED and that is enough to release
553	 * ->shost_gendev. scsi_host_dev_release() will free
554	 * dev_name(&shost->shost_dev).
555	 */
556	put_device(&shost->shost_gendev);
557
558	return NULL;
559}
560EXPORT_SYMBOL(scsi_host_alloc);
561
562static int __scsi_host_match(struct device *dev, const void *data)
563{
564	struct Scsi_Host *p;
565	const unsigned int *hostnum = data;
566
567	p = class_to_shost(dev);
568	return p->host_no == *hostnum;
569}
570
571/**
572 * scsi_host_lookup - get a reference to a Scsi_Host by host no
573 * @hostnum:	host number to locate
574 *
575 * Return value:
576 *	A pointer to located Scsi_Host or NULL.
577 *
578 *	The caller must do a scsi_host_put() to drop the reference
579 *	that scsi_host_get() took. The put_device() below dropped
580 *	the reference from class_find_device().
581 **/
582struct Scsi_Host *scsi_host_lookup(unsigned int hostnum)
583{
584	struct device *cdev;
585	struct Scsi_Host *shost = NULL;
586
587	cdev = class_find_device(&shost_class, NULL, &hostnum,
588				 __scsi_host_match);
589	if (cdev) {
590		shost = scsi_host_get(class_to_shost(cdev));
591		put_device(cdev);
592	}
593	return shost;
594}
595EXPORT_SYMBOL(scsi_host_lookup);
596
597/**
598 * scsi_host_get - inc a Scsi_Host ref count
599 * @shost:	Pointer to Scsi_Host to inc.
600 **/
601struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost)
602{
603	if ((shost->shost_state == SHOST_DEL) ||
604		!get_device(&shost->shost_gendev))
605		return NULL;
606	return shost;
607}
608EXPORT_SYMBOL(scsi_host_get);
609
610static bool scsi_host_check_in_flight(struct request *rq, void *data)
611{
612	int *count = data;
613	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
614
615	if (test_bit(SCMD_STATE_INFLIGHT, &cmd->state))
616		(*count)++;
617
618	return true;
619}
620
621/**
622 * scsi_host_busy - Return the count of in-flight commands
623 * @shost:	Pointer to Scsi_Host
624 **/
625int scsi_host_busy(struct Scsi_Host *shost)
626{
627	int cnt = 0;
628
629	if (shost->tag_set.ops)
630		blk_mq_tagset_busy_iter(&shost->tag_set,
631					scsi_host_check_in_flight, &cnt);
632	return cnt;
633}
634EXPORT_SYMBOL(scsi_host_busy);
635
636/**
637 * scsi_host_put - dec a Scsi_Host ref count
638 * @shost:	Pointer to Scsi_Host to dec.
639 **/
640void scsi_host_put(struct Scsi_Host *shost)
641{
642	put_device(&shost->shost_gendev);
643}
644EXPORT_SYMBOL(scsi_host_put);
645
646int scsi_init_hosts(void)
647{
648	return class_register(&shost_class);
649}
650
651void scsi_exit_hosts(void)
652{
653	class_unregister(&shost_class);
654	ida_destroy(&host_index_ida);
655}
656
657int scsi_is_host_device(const struct device *dev)
658{
659	return dev->type == &scsi_host_type;
660}
661EXPORT_SYMBOL(scsi_is_host_device);
662
663/**
664 * scsi_queue_work - Queue work to the Scsi_Host workqueue.
665 * @shost:	Pointer to Scsi_Host.
666 * @work:	Work to queue for execution.
667 *
668 * Return value:
669 * 	1 - work queued for execution
670 *	0 - work is already queued
671 *	-EINVAL - work queue doesn't exist
672 **/
673int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work)
674{
675	if (unlikely(!shost->work_q)) {
676		shost_printk(KERN_ERR, shost,
677			"ERROR: Scsi host '%s' attempted to queue scsi-work, "
678			"when no workqueue created.\n", shost->hostt->name);
679		dump_stack();
680
681		return -EINVAL;
682	}
683
684	return queue_work(shost->work_q, work);
685}
686EXPORT_SYMBOL_GPL(scsi_queue_work);
687
688/**
689 * scsi_flush_work - Flush a Scsi_Host's workqueue.
690 * @shost:	Pointer to Scsi_Host.
691 **/
692void scsi_flush_work(struct Scsi_Host *shost)
693{
694	if (!shost->work_q) {
695		shost_printk(KERN_ERR, shost,
696			"ERROR: Scsi host '%s' attempted to flush scsi-work, "
697			"when no workqueue created.\n", shost->hostt->name);
698		dump_stack();
699		return;
700	}
701
702	flush_workqueue(shost->work_q);
703}
704EXPORT_SYMBOL_GPL(scsi_flush_work);
705
706static bool complete_all_cmds_iter(struct request *rq, void *data)
707{
708	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
709	enum scsi_host_status status = *(enum scsi_host_status *)data;
710
711	scsi_dma_unmap(scmd);
712	scmd->result = 0;
713	set_host_byte(scmd, status);
714	scsi_done(scmd);
715	return true;
716}
717
718/**
719 * scsi_host_complete_all_commands - Terminate all running commands
720 * @shost:	Scsi Host on which commands should be terminated
721 * @status:	Status to be set for the terminated commands
722 *
723 * There is no protection against modification of the number
724 * of outstanding commands. It is the responsibility of the
725 * caller to ensure that concurrent I/O submission and/or
726 * completion is stopped when calling this function.
727 */
728void scsi_host_complete_all_commands(struct Scsi_Host *shost,
729				     enum scsi_host_status status)
730{
731	blk_mq_tagset_busy_iter(&shost->tag_set, complete_all_cmds_iter,
732				&status);
733}
734EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands);
735
736struct scsi_host_busy_iter_data {
737	bool (*fn)(struct scsi_cmnd *, void *);
738	void *priv;
739};
740
741static bool __scsi_host_busy_iter_fn(struct request *req, void *priv)
742{
743	struct scsi_host_busy_iter_data *iter_data = priv;
744	struct scsi_cmnd *sc = blk_mq_rq_to_pdu(req);
745
746	return iter_data->fn(sc, iter_data->priv);
747}
748
749/**
750 * scsi_host_busy_iter - Iterate over all busy commands
751 * @shost:	Pointer to Scsi_Host.
752 * @fn:		Function to call on each busy command
753 * @priv:	Data pointer passed to @fn
754 *
755 * If locking against concurrent command completions is required
756 * ithas to be provided by the caller
757 **/
758void scsi_host_busy_iter(struct Scsi_Host *shost,
759			 bool (*fn)(struct scsi_cmnd *, void *),
760			 void *priv)
761{
762	struct scsi_host_busy_iter_data iter_data = {
763		.fn = fn,
764		.priv = priv,
765	};
766
767	blk_mq_tagset_busy_iter(&shost->tag_set, __scsi_host_busy_iter_fn,
768				&iter_data);
769}
770EXPORT_SYMBOL_GPL(scsi_host_busy_iter);