1 // SPDX-License-Identifier: GPL-2.0-only
3 * hosts.c Copyright (C) 1992 Drew Eckhardt
4 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
5 * Copyright (C) 2002-2003 Christoph Hellwig
7 * mid to lowlevel SCSI driver interface
8 * Initial versions: Drew Eckhardt
9 * Subsequent revisions: Eric Youngdale
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
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>
21 * Restructured scsi_host lists and associated functions.
22 * September 04, 2002 Mike Anderson (andmike@us.ibm.com)
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>
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>
43 #include "scsi_priv.h"
44 #include "scsi_logging.h"
47 static int shost_eh_deadline
= -1;
49 module_param_named(eh_deadline
, shost_eh_deadline
, int, S_IRUGO
|S_IWUSR
);
50 MODULE_PARM_DESC(eh_deadline
,
51 "SCSI EH timeout in seconds (should be between 0 and 2^31-1)");
53 static DEFINE_IDA(host_index_ida
);
56 static void scsi_host_cls_release(struct device
*dev
)
58 put_device(&class_to_shost(dev
)->shost_gendev
);
61 static struct class shost_class
= {
63 .dev_release
= scsi_host_cls_release
,
67 * scsi_host_set_state - Take the given host through the host state model.
68 * @shost: scsi host to change the state of.
69 * @state: state to change to.
71 * Returns zero if unsuccessful or an error if the requested
72 * transition is illegal.
74 int scsi_host_set_state(struct Scsi_Host
*shost
, enum scsi_host_state state
)
76 enum scsi_host_state oldstate
= shost
->shost_state
;
78 if (state
== oldstate
)
83 /* There are no legal states that come back to
84 * created. This is the manually initialised start
111 case SHOST_CANCEL_RECOVERY
:
121 case SHOST_DEL_RECOVERY
:
128 case SHOST_CANCEL_RECOVERY
:
138 case SHOST_DEL_RECOVERY
:
140 case SHOST_CANCEL_RECOVERY
:
147 shost
->shost_state
= state
;
151 SCSI_LOG_ERROR_RECOVERY(1,
152 shost_printk(KERN_ERR
, shost
,
153 "Illegal host state transition"
155 scsi_host_state_name(oldstate
),
156 scsi_host_state_name(state
)));
161 * scsi_remove_host - remove a scsi host
162 * @shost: a pointer to a scsi host to remove
164 void scsi_remove_host(struct Scsi_Host
*shost
)
168 mutex_lock(&shost
->scan_mutex
);
169 spin_lock_irqsave(shost
->host_lock
, flags
);
170 if (scsi_host_set_state(shost
, SHOST_CANCEL
))
171 if (scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
)) {
172 spin_unlock_irqrestore(shost
->host_lock
, flags
);
173 mutex_unlock(&shost
->scan_mutex
);
176 spin_unlock_irqrestore(shost
->host_lock
, flags
);
178 scsi_autopm_get_host(shost
);
179 flush_workqueue(shost
->tmf_work_q
);
180 scsi_forget_host(shost
);
181 mutex_unlock(&shost
->scan_mutex
);
182 scsi_proc_host_rm(shost
);
184 spin_lock_irqsave(shost
->host_lock
, flags
);
185 if (scsi_host_set_state(shost
, SHOST_DEL
))
186 BUG_ON(scsi_host_set_state(shost
, SHOST_DEL_RECOVERY
));
187 spin_unlock_irqrestore(shost
->host_lock
, flags
);
189 transport_unregister_device(&shost
->shost_gendev
);
190 device_unregister(&shost
->shost_dev
);
191 device_del(&shost
->shost_gendev
);
193 EXPORT_SYMBOL(scsi_remove_host
);
196 * scsi_add_host_with_dma - add a scsi host with dma device
197 * @shost: scsi host pointer to add
198 * @dev: a struct device of type scsi class
199 * @dma_dev: dma device for the host
201 * Note: You rarely need to worry about this unless you're in a
202 * virtualised host environments, so use the simpler scsi_add_host()
206 * 0 on success / != 0 for error
208 int scsi_add_host_with_dma(struct Scsi_Host
*shost
, struct device
*dev
,
209 struct device
*dma_dev
)
211 struct scsi_host_template
*sht
= shost
->hostt
;
214 shost_printk(KERN_INFO
, shost
, "%s\n",
215 sht
->info
? sht
->info(shost
) : sht
->name
);
217 if (!shost
->can_queue
) {
218 shost_printk(KERN_ERR
, shost
,
219 "can_queue = 0 no longer supported\n");
223 error
= scsi_init_sense_cache(shost
);
227 error
= scsi_mq_setup_tags(shost
);
231 if (!shost
->shost_gendev
.parent
)
232 shost
->shost_gendev
.parent
= dev
? dev
: &platform_bus
;
234 dma_dev
= shost
->shost_gendev
.parent
;
236 shost
->dma_dev
= dma_dev
;
239 * Increase usage count temporarily here so that calling
240 * scsi_autopm_put_host() will trigger runtime idle if there is
241 * nothing else preventing suspending the device.
243 pm_runtime_get_noresume(&shost
->shost_gendev
);
244 pm_runtime_set_active(&shost
->shost_gendev
);
245 pm_runtime_enable(&shost
->shost_gendev
);
246 device_enable_async_suspend(&shost
->shost_gendev
);
248 error
= device_add(&shost
->shost_gendev
);
250 goto out_disable_runtime_pm
;
252 scsi_host_set_state(shost
, SHOST_RUNNING
);
253 get_device(shost
->shost_gendev
.parent
);
255 device_enable_async_suspend(&shost
->shost_dev
);
257 error
= device_add(&shost
->shost_dev
);
261 get_device(&shost
->shost_gendev
);
263 if (shost
->transportt
->host_size
) {
264 shost
->shost_data
= kzalloc(shost
->transportt
->host_size
,
266 if (shost
->shost_data
== NULL
) {
272 if (shost
->transportt
->create_work_queue
) {
273 snprintf(shost
->work_q_name
, sizeof(shost
->work_q_name
),
274 "scsi_wq_%d", shost
->host_no
);
275 shost
->work_q
= alloc_workqueue("%s",
276 WQ_SYSFS
| __WQ_LEGACY
| WQ_MEM_RECLAIM
| WQ_UNBOUND
,
277 1, shost
->work_q_name
);
279 if (!shost
->work_q
) {
281 goto out_free_shost_data
;
285 error
= scsi_sysfs_add_host(shost
);
287 goto out_destroy_host
;
289 scsi_proc_host_add(shost
);
290 scsi_autopm_put_host(shost
);
295 destroy_workqueue(shost
->work_q
);
297 kfree(shost
->shost_data
);
299 device_del(&shost
->shost_dev
);
301 device_del(&shost
->shost_gendev
);
302 out_disable_runtime_pm
:
303 device_disable_async_suspend(&shost
->shost_gendev
);
304 pm_runtime_disable(&shost
->shost_gendev
);
305 pm_runtime_set_suspended(&shost
->shost_gendev
);
306 pm_runtime_put_noidle(&shost
->shost_gendev
);
307 scsi_mq_destroy_tags(shost
);
311 EXPORT_SYMBOL(scsi_add_host_with_dma
);
313 static void scsi_host_dev_release(struct device
*dev
)
315 struct Scsi_Host
*shost
= dev_to_shost(dev
);
316 struct device
*parent
= dev
->parent
;
318 scsi_proc_hostdir_rm(shost
->hostt
);
320 /* Wait for functions invoked through call_rcu(&shost->rcu, ...) */
323 if (shost
->tmf_work_q
)
324 destroy_workqueue(shost
->tmf_work_q
);
326 kthread_stop(shost
->ehandler
);
328 destroy_workqueue(shost
->work_q
);
330 if (shost
->shost_state
== SHOST_CREATED
) {
332 * Free the shost_dev device name here if scsi_host_alloc()
333 * and scsi_host_put() have been called but neither
334 * scsi_host_add() nor scsi_host_remove() has been called.
335 * This avoids that the memory allocated for the shost_dev
338 kfree(dev_name(&shost
->shost_dev
));
341 if (shost
->tag_set
.tags
)
342 scsi_mq_destroy_tags(shost
);
344 kfree(shost
->shost_data
);
346 ida_simple_remove(&host_index_ida
, shost
->host_no
);
353 static struct device_type scsi_host_type
= {
355 .release
= scsi_host_dev_release
,
359 * scsi_host_alloc - register a scsi host adapter instance.
360 * @sht: pointer to scsi host template
361 * @privsize: extra bytes to allocate for driver
364 * Allocate a new Scsi_Host and perform basic initialization.
365 * The host is not published to the scsi midlayer until scsi_add_host
369 * Pointer to a new Scsi_Host
371 struct Scsi_Host
*scsi_host_alloc(struct scsi_host_template
*sht
, int privsize
)
373 struct Scsi_Host
*shost
;
374 gfp_t gfp_mask
= GFP_KERNEL
;
377 if (sht
->unchecked_isa_dma
&& privsize
)
378 gfp_mask
|= __GFP_DMA
;
380 shost
= kzalloc(sizeof(struct Scsi_Host
) + privsize
, gfp_mask
);
384 shost
->host_lock
= &shost
->default_lock
;
385 spin_lock_init(shost
->host_lock
);
386 shost
->shost_state
= SHOST_CREATED
;
387 INIT_LIST_HEAD(&shost
->__devices
);
388 INIT_LIST_HEAD(&shost
->__targets
);
389 INIT_LIST_HEAD(&shost
->eh_cmd_q
);
390 INIT_LIST_HEAD(&shost
->starved_list
);
391 init_waitqueue_head(&shost
->host_wait
);
392 mutex_init(&shost
->scan_mutex
);
394 index
= ida_simple_get(&host_index_ida
, 0, 0, GFP_KERNEL
);
399 shost
->host_no
= index
;
401 shost
->dma_channel
= 0xff;
403 /* These three are default values which can be overridden */
404 shost
->max_channel
= 0;
408 /* Give each shost a default transportt */
409 shost
->transportt
= &blank_transport_template
;
412 * All drivers right now should be able to handle 12 byte
413 * commands. Every so often there are requests for 16 byte
414 * commands, but individual low-level drivers need to certify that
415 * they actually do something sensible with such commands.
417 shost
->max_cmd_len
= 12;
419 shost
->this_id
= sht
->this_id
;
420 shost
->can_queue
= sht
->can_queue
;
421 shost
->sg_tablesize
= sht
->sg_tablesize
;
422 shost
->sg_prot_tablesize
= sht
->sg_prot_tablesize
;
423 shost
->cmd_per_lun
= sht
->cmd_per_lun
;
424 shost
->unchecked_isa_dma
= sht
->unchecked_isa_dma
;
425 shost
->no_write_same
= sht
->no_write_same
;
426 shost
->host_tagset
= sht
->host_tagset
;
428 if (shost_eh_deadline
== -1 || !sht
->eh_host_reset_handler
)
429 shost
->eh_deadline
= -1;
430 else if ((ulong
) shost_eh_deadline
* HZ
> INT_MAX
) {
431 shost_printk(KERN_WARNING
, shost
,
432 "eh_deadline %u too large, setting to %u\n",
433 shost_eh_deadline
, INT_MAX
/ HZ
);
434 shost
->eh_deadline
= INT_MAX
;
436 shost
->eh_deadline
= shost_eh_deadline
* HZ
;
438 if (sht
->supported_mode
== MODE_UNKNOWN
)
439 /* means we didn't set it ... default to INITIATOR */
440 shost
->active_mode
= MODE_INITIATOR
;
442 shost
->active_mode
= sht
->supported_mode
;
444 if (sht
->max_host_blocked
)
445 shost
->max_host_blocked
= sht
->max_host_blocked
;
447 shost
->max_host_blocked
= SCSI_DEFAULT_HOST_BLOCKED
;
450 * If the driver imposes no hard sector transfer limit, start at
451 * machine infinity initially.
453 if (sht
->max_sectors
)
454 shost
->max_sectors
= sht
->max_sectors
;
456 shost
->max_sectors
= SCSI_DEFAULT_MAX_SECTORS
;
458 if (sht
->max_segment_size
)
459 shost
->max_segment_size
= sht
->max_segment_size
;
461 shost
->max_segment_size
= BLK_MAX_SEGMENT_SIZE
;
464 * assume a 4GB boundary, if not set
466 if (sht
->dma_boundary
)
467 shost
->dma_boundary
= sht
->dma_boundary
;
469 shost
->dma_boundary
= 0xffffffff;
471 if (sht
->virt_boundary_mask
)
472 shost
->virt_boundary_mask
= sht
->virt_boundary_mask
;
474 device_initialize(&shost
->shost_gendev
);
475 dev_set_name(&shost
->shost_gendev
, "host%d", shost
->host_no
);
476 shost
->shost_gendev
.bus
= &scsi_bus_type
;
477 shost
->shost_gendev
.type
= &scsi_host_type
;
479 device_initialize(&shost
->shost_dev
);
480 shost
->shost_dev
.parent
= &shost
->shost_gendev
;
481 shost
->shost_dev
.class = &shost_class
;
482 dev_set_name(&shost
->shost_dev
, "host%d", shost
->host_no
);
483 shost
->shost_dev
.groups
= scsi_sysfs_shost_attr_groups
;
485 shost
->ehandler
= kthread_run(scsi_error_handler
, shost
,
486 "scsi_eh_%d", shost
->host_no
);
487 if (IS_ERR(shost
->ehandler
)) {
488 shost_printk(KERN_WARNING
, shost
,
489 "error handler thread failed to spawn, error = %ld\n",
490 PTR_ERR(shost
->ehandler
));
494 shost
->tmf_work_q
= alloc_workqueue("scsi_tmf_%d",
495 WQ_UNBOUND
| WQ_MEM_RECLAIM
| WQ_SYSFS
,
497 if (!shost
->tmf_work_q
) {
498 shost_printk(KERN_WARNING
, shost
,
499 "failed to create tmf workq\n");
502 scsi_proc_hostdir_add(shost
->hostt
);
506 * Host state is still SHOST_CREATED and that is enough to release
507 * ->shost_gendev. scsi_host_dev_release() will free
508 * dev_name(&shost->shost_dev).
510 put_device(&shost
->shost_gendev
);
514 EXPORT_SYMBOL(scsi_host_alloc
);
516 static int __scsi_host_match(struct device
*dev
, const void *data
)
519 const unsigned short *hostnum
= data
;
521 p
= class_to_shost(dev
);
522 return p
->host_no
== *hostnum
;
526 * scsi_host_lookup - get a reference to a Scsi_Host by host no
527 * @hostnum: host number to locate
530 * A pointer to located Scsi_Host or NULL.
532 * The caller must do a scsi_host_put() to drop the reference
533 * that scsi_host_get() took. The put_device() below dropped
534 * the reference from class_find_device().
536 struct Scsi_Host
*scsi_host_lookup(unsigned short hostnum
)
539 struct Scsi_Host
*shost
= NULL
;
541 cdev
= class_find_device(&shost_class
, NULL
, &hostnum
,
544 shost
= scsi_host_get(class_to_shost(cdev
));
549 EXPORT_SYMBOL(scsi_host_lookup
);
552 * scsi_host_get - inc a Scsi_Host ref count
553 * @shost: Pointer to Scsi_Host to inc.
555 struct Scsi_Host
*scsi_host_get(struct Scsi_Host
*shost
)
557 if ((shost
->shost_state
== SHOST_DEL
) ||
558 !get_device(&shost
->shost_gendev
))
562 EXPORT_SYMBOL(scsi_host_get
);
564 static bool scsi_host_check_in_flight(struct request
*rq
, void *data
,
568 struct scsi_cmnd
*cmd
= blk_mq_rq_to_pdu(rq
);
570 if (test_bit(SCMD_STATE_INFLIGHT
, &cmd
->state
))
577 * scsi_host_busy - Return the host busy counter
578 * @shost: Pointer to Scsi_Host to inc.
580 int scsi_host_busy(struct Scsi_Host
*shost
)
584 blk_mq_tagset_busy_iter(&shost
->tag_set
,
585 scsi_host_check_in_flight
, &cnt
);
588 EXPORT_SYMBOL(scsi_host_busy
);
591 * scsi_host_put - dec a Scsi_Host ref count
592 * @shost: Pointer to Scsi_Host to dec.
594 void scsi_host_put(struct Scsi_Host
*shost
)
596 put_device(&shost
->shost_gendev
);
598 EXPORT_SYMBOL(scsi_host_put
);
600 int scsi_init_hosts(void)
602 return class_register(&shost_class
);
605 void scsi_exit_hosts(void)
607 class_unregister(&shost_class
);
608 ida_destroy(&host_index_ida
);
611 int scsi_is_host_device(const struct device
*dev
)
613 return dev
->type
== &scsi_host_type
;
615 EXPORT_SYMBOL(scsi_is_host_device
);
618 * scsi_queue_work - Queue work to the Scsi_Host workqueue.
619 * @shost: Pointer to Scsi_Host.
620 * @work: Work to queue for execution.
623 * 1 - work queued for execution
624 * 0 - work is already queued
625 * -EINVAL - work queue doesn't exist
627 int scsi_queue_work(struct Scsi_Host
*shost
, struct work_struct
*work
)
629 if (unlikely(!shost
->work_q
)) {
630 shost_printk(KERN_ERR
, shost
,
631 "ERROR: Scsi host '%s' attempted to queue scsi-work, "
632 "when no workqueue created.\n", shost
->hostt
->name
);
638 return queue_work(shost
->work_q
, work
);
640 EXPORT_SYMBOL_GPL(scsi_queue_work
);
643 * scsi_flush_work - Flush a Scsi_Host's workqueue.
644 * @shost: Pointer to Scsi_Host.
646 void scsi_flush_work(struct Scsi_Host
*shost
)
648 if (!shost
->work_q
) {
649 shost_printk(KERN_ERR
, shost
,
650 "ERROR: Scsi host '%s' attempted to flush scsi-work, "
651 "when no workqueue created.\n", shost
->hostt
->name
);
656 flush_workqueue(shost
->work_q
);
658 EXPORT_SYMBOL_GPL(scsi_flush_work
);
660 static bool complete_all_cmds_iter(struct request
*rq
, void *data
, bool rsvd
)
662 struct scsi_cmnd
*scmd
= blk_mq_rq_to_pdu(rq
);
663 int status
= *(int *)data
;
665 scsi_dma_unmap(scmd
);
666 scmd
->result
= status
<< 16;
667 scmd
->scsi_done(scmd
);
672 * scsi_host_complete_all_commands - Terminate all running commands
673 * @shost: Scsi Host on which commands should be terminated
674 * @status: Status to be set for the terminated commands
676 * There is no protection against modification of the number
677 * of outstanding commands. It is the responsibility of the
678 * caller to ensure that concurrent I/O submission and/or
679 * completion is stopped when calling this function.
681 void scsi_host_complete_all_commands(struct Scsi_Host
*shost
, int status
)
683 blk_mq_tagset_busy_iter(&shost
->tag_set
, complete_all_cmds_iter
,
686 EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands
);
688 struct scsi_host_busy_iter_data
{
689 bool (*fn
)(struct scsi_cmnd
*, void *, bool);
693 static bool __scsi_host_busy_iter_fn(struct request
*req
, void *priv
,
696 struct scsi_host_busy_iter_data
*iter_data
= priv
;
697 struct scsi_cmnd
*sc
= blk_mq_rq_to_pdu(req
);
699 return iter_data
->fn(sc
, iter_data
->priv
, reserved
);
703 * scsi_host_busy_iter - Iterate over all busy commands
704 * @shost: Pointer to Scsi_Host.
705 * @fn: Function to call on each busy command
706 * @priv: Data pointer passed to @fn
708 * If locking against concurrent command completions is required
709 * ithas to be provided by the caller
711 void scsi_host_busy_iter(struct Scsi_Host
*shost
,
712 bool (*fn
)(struct scsi_cmnd
*, void *, bool),
715 struct scsi_host_busy_iter_data iter_data
= {
720 blk_mq_tagset_busy_iter(&shost
->tag_set
, __scsi_host_busy_iter_fn
,
723 EXPORT_SYMBOL_GPL(scsi_host_busy_iter
);