Branch data Line data Source code
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 : :
47 : : static int shost_eh_deadline = -1;
48 : :
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)");
52 : :
53 : : static DEFINE_IDA(host_index_ida);
54 : :
55 : :
56 : 0 : static void scsi_host_cls_release(struct device *dev)
57 : : {
58 : 0 : put_device(&class_to_shost(dev)->shost_gendev);
59 : 0 : }
60 : :
61 : : static struct class shost_class = {
62 : : .name = "scsi_host",
63 : : .dev_release = scsi_host_cls_release,
64 : : };
65 : :
66 : : /**
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.
70 : : *
71 : : * Returns zero if unsuccessful or an error if the requested
72 : : * transition is illegal.
73 : : **/
74 : 338 : int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
75 : : {
76 : 338 : enum scsi_host_state oldstate = shost->shost_state;
77 : :
78 [ + - ]: 312 : if (state == oldstate)
79 : : return 0;
80 : :
81 [ - + + - : 312 : switch (state) {
- - - - ]
82 : 0 : case SHOST_CREATED:
83 : : /* There are no legal states that come back to
84 : : * created. This is the manually initialised start
85 : : * state */
86 : 0 : goto illegal;
87 : :
88 : 182 : case SHOST_RUNNING:
89 [ - + - + ]: 182 : switch (oldstate) {
90 : : case SHOST_CREATED:
91 : : case SHOST_RECOVERY:
92 : : break;
93 : 0 : default:
94 : 0 : goto illegal;
95 : : }
96 : : break;
97 : :
98 : 156 : case SHOST_RECOVERY:
99 [ - + ]: 156 : switch (oldstate) {
100 : : case SHOST_RUNNING:
101 : : break;
102 : 0 : default:
103 : 0 : goto illegal;
104 : : }
105 : : break;
106 : :
107 : 0 : case SHOST_CANCEL:
108 [ # # # # ]: 0 : switch (oldstate) {
109 : : case SHOST_CREATED:
110 : : case SHOST_RUNNING:
111 : : case SHOST_CANCEL_RECOVERY:
112 : : break;
113 : 0 : default:
114 : 0 : goto illegal;
115 : : }
116 : : break;
117 : :
118 : 0 : case SHOST_DEL:
119 [ # # # # ]: 0 : switch (oldstate) {
120 : : case SHOST_CANCEL:
121 : : case SHOST_DEL_RECOVERY:
122 : : break;
123 : 0 : default:
124 : 0 : goto illegal;
125 : : }
126 : : break;
127 : :
128 : 0 : case SHOST_CANCEL_RECOVERY:
129 [ # # # # ]: 0 : switch (oldstate) {
130 : : case SHOST_CANCEL:
131 : : case SHOST_RECOVERY:
132 : : break;
133 : 0 : default:
134 : 0 : goto illegal;
135 : : }
136 : : break;
137 : :
138 : 0 : case SHOST_DEL_RECOVERY:
139 [ # # # # ]: 0 : switch (oldstate) {
140 : : case SHOST_CANCEL_RECOVERY:
141 : : break;
142 : 0 : default:
143 : 0 : goto illegal;
144 : : }
145 : : break;
146 : : }
147 : 338 : shost->shost_state = state;
148 : 338 : return 0;
149 : :
150 : 338 : illegal:
151 : : SCSI_LOG_ERROR_RECOVERY(1,
152 : : shost_printk(KERN_ERR, shost,
153 : : "Illegal host state transition"
154 : : "%s->%s\n",
155 : : scsi_host_state_name(oldstate),
156 : : scsi_host_state_name(state)));
157 : : return -EINVAL;
158 : : }
159 : :
160 : : /**
161 : : * scsi_remove_host - remove a scsi host
162 : : * @shost: a pointer to a scsi host to remove
163 : : **/
164 : 0 : void scsi_remove_host(struct Scsi_Host *shost)
165 : : {
166 : 0 : unsigned long flags;
167 : :
168 : 0 : mutex_lock(&shost->scan_mutex);
169 : 0 : spin_lock_irqsave(shost->host_lock, flags);
170 [ # # ]: 0 : if (scsi_host_set_state(shost, SHOST_CANCEL))
171 [ # # ]: 0 : if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
172 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
173 : 0 : mutex_unlock(&shost->scan_mutex);
174 : 0 : return;
175 : : }
176 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
177 : :
178 : 0 : scsi_autopm_get_host(shost);
179 : 0 : flush_workqueue(shost->tmf_work_q);
180 : 0 : scsi_forget_host(shost);
181 : 0 : mutex_unlock(&shost->scan_mutex);
182 : 0 : scsi_proc_host_rm(shost);
183 : :
184 : 0 : spin_lock_irqsave(shost->host_lock, flags);
185 [ # # ]: 0 : if (scsi_host_set_state(shost, SHOST_DEL))
186 [ # # # # ]: 0 : BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY));
187 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
188 : :
189 : 0 : transport_unregister_device(&shost->shost_gendev);
190 : 0 : device_unregister(&shost->shost_dev);
191 : 0 : device_del(&shost->shost_gendev);
192 : : }
193 : : EXPORT_SYMBOL(scsi_remove_host);
194 : :
195 : : /**
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
200 : : *
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()
203 : : * function instead.
204 : : *
205 : : * Return value:
206 : : * 0 on success / != 0 for error
207 : : **/
208 : 26 : int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
209 : : struct device *dma_dev)
210 : : {
211 : 26 : struct scsi_host_template *sht = shost->hostt;
212 : 26 : int error = -EINVAL;
213 : :
214 [ - + ]: 26 : shost_printk(KERN_INFO, shost, "%s\n",
215 : : sht->info ? sht->info(shost) : sht->name);
216 : :
217 [ - + ]: 26 : if (!shost->can_queue) {
218 : 0 : shost_printk(KERN_ERR, shost,
219 : : "can_queue = 0 no longer supported\n");
220 : 0 : goto fail;
221 : : }
222 : :
223 : 26 : error = scsi_init_sense_cache(shost);
224 [ - + ]: 26 : if (error)
225 : 0 : goto fail;
226 : :
227 : 26 : error = scsi_mq_setup_tags(shost);
228 [ - + ]: 26 : if (error)
229 : 0 : goto fail;
230 : :
231 [ + - ]: 26 : if (!shost->shost_gendev.parent)
232 [ - + ]: 26 : shost->shost_gendev.parent = dev ? dev : &platform_bus;
233 [ - + ]: 26 : if (!dma_dev)
234 : 0 : dma_dev = shost->shost_gendev.parent;
235 : :
236 : 26 : shost->dma_dev = dma_dev;
237 : :
238 : : /*
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.
242 : : */
243 : 26 : pm_runtime_get_noresume(&shost->shost_gendev);
244 : 26 : pm_runtime_set_active(&shost->shost_gendev);
245 : 26 : pm_runtime_enable(&shost->shost_gendev);
246 [ + - ]: 26 : device_enable_async_suspend(&shost->shost_gendev);
247 : :
248 : 26 : error = device_add(&shost->shost_gendev);
249 [ - + ]: 26 : if (error)
250 : 0 : goto out_disable_runtime_pm;
251 : :
252 [ + - ]: 26 : scsi_host_set_state(shost, SHOST_RUNNING);
253 : 26 : get_device(shost->shost_gendev.parent);
254 : :
255 [ + - ]: 26 : device_enable_async_suspend(&shost->shost_dev);
256 : :
257 : 26 : error = device_add(&shost->shost_dev);
258 [ - + ]: 26 : if (error)
259 : 0 : goto out_del_gendev;
260 : :
261 : 26 : get_device(&shost->shost_gendev);
262 : :
263 [ - + ]: 26 : if (shost->transportt->host_size) {
264 : 0 : shost->shost_data = kzalloc(shost->transportt->host_size,
265 : : GFP_KERNEL);
266 [ # # ]: 0 : if (shost->shost_data == NULL) {
267 : 0 : error = -ENOMEM;
268 : 0 : goto out_del_dev;
269 : : }
270 : : }
271 : :
272 [ - + ]: 26 : if (shost->transportt->create_work_queue) {
273 : 0 : snprintf(shost->work_q_name, sizeof(shost->work_q_name),
274 : : "scsi_wq_%d", shost->host_no);
275 : 0 : shost->work_q = create_singlethread_workqueue(
276 : : shost->work_q_name);
277 [ # # ]: 0 : if (!shost->work_q) {
278 : 0 : error = -EINVAL;
279 : 0 : goto out_free_shost_data;
280 : : }
281 : : }
282 : :
283 : 26 : error = scsi_sysfs_add_host(shost);
284 [ - + ]: 26 : if (error)
285 : 0 : goto out_destroy_host;
286 : :
287 : 26 : scsi_proc_host_add(shost);
288 : 26 : scsi_autopm_put_host(shost);
289 : 26 : return error;
290 : :
291 : : out_destroy_host:
292 [ # # ]: 0 : if (shost->work_q)
293 : 0 : destroy_workqueue(shost->work_q);
294 : 0 : out_free_shost_data:
295 : 0 : kfree(shost->shost_data);
296 : 0 : out_del_dev:
297 : 0 : device_del(&shost->shost_dev);
298 : 0 : out_del_gendev:
299 : 0 : device_del(&shost->shost_gendev);
300 : 0 : out_disable_runtime_pm:
301 [ # # ]: 0 : device_disable_async_suspend(&shost->shost_gendev);
302 : 0 : pm_runtime_disable(&shost->shost_gendev);
303 : 0 : pm_runtime_set_suspended(&shost->shost_gendev);
304 : 0 : pm_runtime_put_noidle(&shost->shost_gendev);
305 : 0 : scsi_mq_destroy_tags(shost);
306 : : fail:
307 : : return error;
308 : : }
309 : : EXPORT_SYMBOL(scsi_add_host_with_dma);
310 : :
311 : 0 : static void scsi_host_dev_release(struct device *dev)
312 : : {
313 : 0 : struct Scsi_Host *shost = dev_to_shost(dev);
314 : 0 : struct device *parent = dev->parent;
315 : :
316 : 0 : scsi_proc_hostdir_rm(shost->hostt);
317 : :
318 : : /* Wait for functions invoked through call_rcu(&shost->rcu, ...) */
319 : 0 : rcu_barrier();
320 : :
321 [ # # ]: 0 : if (shost->tmf_work_q)
322 : 0 : destroy_workqueue(shost->tmf_work_q);
323 [ # # ]: 0 : if (shost->ehandler)
324 : 0 : kthread_stop(shost->ehandler);
325 [ # # ]: 0 : if (shost->work_q)
326 : 0 : destroy_workqueue(shost->work_q);
327 : :
328 [ # # ]: 0 : if (shost->shost_state == SHOST_CREATED) {
329 : : /*
330 : : * Free the shost_dev device name here if scsi_host_alloc()
331 : : * and scsi_host_put() have been called but neither
332 : : * scsi_host_add() nor scsi_host_remove() has been called.
333 : : * This avoids that the memory allocated for the shost_dev
334 : : * name is leaked.
335 : : */
336 [ # # ]: 0 : kfree(dev_name(&shost->shost_dev));
337 : : }
338 : :
339 [ # # ]: 0 : if (shost->tag_set.tags)
340 : 0 : scsi_mq_destroy_tags(shost);
341 : :
342 : 0 : kfree(shost->shost_data);
343 : :
344 : 0 : ida_simple_remove(&host_index_ida, shost->host_no);
345 : :
346 [ # # ]: 0 : if (parent)
347 : 0 : put_device(parent);
348 : 0 : kfree(shost);
349 : 0 : }
350 : :
351 : : static struct device_type scsi_host_type = {
352 : : .name = "scsi_host",
353 : : .release = scsi_host_dev_release,
354 : : };
355 : :
356 : : /**
357 : : * scsi_host_alloc - register a scsi host adapter instance.
358 : : * @sht: pointer to scsi host template
359 : : * @privsize: extra bytes to allocate for driver
360 : : *
361 : : * Note:
362 : : * Allocate a new Scsi_Host and perform basic initialization.
363 : : * The host is not published to the scsi midlayer until scsi_add_host
364 : : * is called.
365 : : *
366 : : * Return value:
367 : : * Pointer to a new Scsi_Host
368 : : **/
369 : 26 : struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
370 : : {
371 : 26 : struct Scsi_Host *shost;
372 : 26 : gfp_t gfp_mask = GFP_KERNEL;
373 : 26 : int index;
374 : :
375 [ - + - - ]: 26 : if (sht->unchecked_isa_dma && privsize)
376 : 0 : gfp_mask |= __GFP_DMA;
377 : :
378 : 26 : shost = kzalloc(sizeof(struct Scsi_Host) + privsize, gfp_mask);
379 [ + - ]: 26 : if (!shost)
380 : : return NULL;
381 : :
382 : 26 : shost->host_lock = &shost->default_lock;
383 : 26 : spin_lock_init(shost->host_lock);
384 : 26 : shost->shost_state = SHOST_CREATED;
385 : 26 : INIT_LIST_HEAD(&shost->__devices);
386 : 26 : INIT_LIST_HEAD(&shost->__targets);
387 : 26 : INIT_LIST_HEAD(&shost->eh_cmd_q);
388 : 26 : INIT_LIST_HEAD(&shost->starved_list);
389 : 26 : init_waitqueue_head(&shost->host_wait);
390 : 26 : mutex_init(&shost->scan_mutex);
391 : :
392 : 26 : index = ida_simple_get(&host_index_ida, 0, 0, GFP_KERNEL);
393 [ - + ]: 26 : if (index < 0)
394 : 0 : goto fail_kfree;
395 : 26 : shost->host_no = index;
396 : :
397 : 26 : shost->dma_channel = 0xff;
398 : :
399 : : /* These three are default values which can be overridden */
400 : 26 : shost->max_channel = 0;
401 : 26 : shost->max_id = 8;
402 : 26 : shost->max_lun = 8;
403 : :
404 : : /* Give each shost a default transportt */
405 : 26 : shost->transportt = &blank_transport_template;
406 : :
407 : : /*
408 : : * All drivers right now should be able to handle 12 byte
409 : : * commands. Every so often there are requests for 16 byte
410 : : * commands, but individual low-level drivers need to certify that
411 : : * they actually do something sensible with such commands.
412 : : */
413 : 26 : shost->max_cmd_len = 12;
414 : 26 : shost->hostt = sht;
415 : 26 : shost->this_id = sht->this_id;
416 : 26 : shost->can_queue = sht->can_queue;
417 : 26 : shost->sg_tablesize = sht->sg_tablesize;
418 : 26 : shost->sg_prot_tablesize = sht->sg_prot_tablesize;
419 : 26 : shost->cmd_per_lun = sht->cmd_per_lun;
420 : 26 : shost->unchecked_isa_dma = sht->unchecked_isa_dma;
421 : 26 : shost->no_write_same = sht->no_write_same;
422 : :
423 [ - + - - ]: 26 : if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler)
424 : 26 : shost->eh_deadline = -1;
425 [ # # ]: 0 : else if ((ulong) shost_eh_deadline * HZ > INT_MAX) {
426 : 0 : shost_printk(KERN_WARNING, shost,
427 : : "eh_deadline %u too large, setting to %u\n",
428 : : shost_eh_deadline, INT_MAX / HZ);
429 : 0 : shost->eh_deadline = INT_MAX;
430 : : } else
431 : 0 : shost->eh_deadline = shost_eh_deadline * HZ;
432 : :
433 [ + - ]: 26 : if (sht->supported_mode == MODE_UNKNOWN)
434 : : /* means we didn't set it ... default to INITIATOR */
435 : 26 : shost->active_mode = MODE_INITIATOR;
436 : : else
437 : 0 : shost->active_mode = sht->supported_mode;
438 : :
439 [ - + ]: 26 : if (sht->max_host_blocked)
440 : 0 : shost->max_host_blocked = sht->max_host_blocked;
441 : : else
442 : 26 : shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED;
443 : :
444 : : /*
445 : : * If the driver imposes no hard sector transfer limit, start at
446 : : * machine infinity initially.
447 : : */
448 [ - + ]: 26 : if (sht->max_sectors)
449 : 0 : shost->max_sectors = sht->max_sectors;
450 : : else
451 : 26 : shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS;
452 : :
453 [ - + ]: 26 : if (sht->max_segment_size)
454 : 0 : shost->max_segment_size = sht->max_segment_size;
455 : : else
456 : 26 : shost->max_segment_size = BLK_MAX_SEGMENT_SIZE;
457 : :
458 : : /*
459 : : * assume a 4GB boundary, if not set
460 : : */
461 [ + - ]: 26 : if (sht->dma_boundary)
462 : 26 : shost->dma_boundary = sht->dma_boundary;
463 : : else
464 : 0 : shost->dma_boundary = 0xffffffff;
465 : :
466 [ - + ]: 26 : if (sht->virt_boundary_mask)
467 : 0 : shost->virt_boundary_mask = sht->virt_boundary_mask;
468 : :
469 : 26 : device_initialize(&shost->shost_gendev);
470 : 26 : dev_set_name(&shost->shost_gendev, "host%d", shost->host_no);
471 : 26 : shost->shost_gendev.bus = &scsi_bus_type;
472 : 26 : shost->shost_gendev.type = &scsi_host_type;
473 : :
474 : 26 : device_initialize(&shost->shost_dev);
475 : 26 : shost->shost_dev.parent = &shost->shost_gendev;
476 : 26 : shost->shost_dev.class = &shost_class;
477 : 26 : dev_set_name(&shost->shost_dev, "host%d", shost->host_no);
478 : 26 : shost->shost_dev.groups = scsi_sysfs_shost_attr_groups;
479 : :
480 [ + - ]: 26 : shost->ehandler = kthread_run(scsi_error_handler, shost,
481 : : "scsi_eh_%d", shost->host_no);
482 [ - + ]: 26 : if (IS_ERR(shost->ehandler)) {
483 : 0 : shost_printk(KERN_WARNING, shost,
484 : : "error handler thread failed to spawn, error = %ld\n",
485 : : PTR_ERR(shost->ehandler));
486 : 0 : goto fail_index_remove;
487 : : }
488 : :
489 : 26 : shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
490 : : WQ_UNBOUND | WQ_MEM_RECLAIM,
491 : : 1, shost->host_no);
492 [ - + ]: 26 : if (!shost->tmf_work_q) {
493 : 0 : shost_printk(KERN_WARNING, shost,
494 : : "failed to create tmf workq\n");
495 : 0 : goto fail_kthread;
496 : : }
497 : 26 : scsi_proc_hostdir_add(shost->hostt);
498 : 26 : return shost;
499 : :
500 : : fail_kthread:
501 : 0 : kthread_stop(shost->ehandler);
502 : 0 : fail_index_remove:
503 : 0 : ida_simple_remove(&host_index_ida, shost->host_no);
504 : 0 : fail_kfree:
505 : 0 : kfree(shost);
506 : 0 : return NULL;
507 : : }
508 : : EXPORT_SYMBOL(scsi_host_alloc);
509 : :
510 : 0 : static int __scsi_host_match(struct device *dev, const void *data)
511 : : {
512 : 0 : struct Scsi_Host *p;
513 : 0 : const unsigned short *hostnum = data;
514 : :
515 : 0 : p = class_to_shost(dev);
516 : 0 : return p->host_no == *hostnum;
517 : : }
518 : :
519 : : /**
520 : : * scsi_host_lookup - get a reference to a Scsi_Host by host no
521 : : * @hostnum: host number to locate
522 : : *
523 : : * Return value:
524 : : * A pointer to located Scsi_Host or NULL.
525 : : *
526 : : * The caller must do a scsi_host_put() to drop the reference
527 : : * that scsi_host_get() took. The put_device() below dropped
528 : : * the reference from class_find_device().
529 : : **/
530 : 0 : struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
531 : : {
532 : 0 : struct device *cdev;
533 : 0 : struct Scsi_Host *shost = NULL;
534 : :
535 : 0 : cdev = class_find_device(&shost_class, NULL, &hostnum,
536 : : __scsi_host_match);
537 [ # # ]: 0 : if (cdev) {
538 : 0 : shost = scsi_host_get(class_to_shost(cdev));
539 : 0 : put_device(cdev);
540 : : }
541 : 0 : return shost;
542 : : }
543 : : EXPORT_SYMBOL(scsi_host_lookup);
544 : :
545 : : /**
546 : : * scsi_host_get - inc a Scsi_Host ref count
547 : : * @shost: Pointer to Scsi_Host to inc.
548 : : **/
549 : 0 : struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost)
550 : : {
551 [ # # # # : 0 : if ((shost->shost_state == SHOST_DEL) ||
# # # # ]
552 : 0 : !get_device(&shost->shost_gendev))
553 : 0 : return NULL;
554 : : return shost;
555 : : }
556 : : EXPORT_SYMBOL(scsi_host_get);
557 : :
558 : 390 : static bool scsi_host_check_in_flight(struct request *rq, void *data,
559 : : bool reserved)
560 : : {
561 : 390 : int *count = data;
562 : 390 : struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
563 : :
564 [ + + ]: 390 : if (test_bit(SCMD_STATE_INFLIGHT, &cmd->state))
565 : 260 : (*count)++;
566 : :
567 : 390 : return true;
568 : : }
569 : :
570 : : /**
571 : : * scsi_host_busy - Return the host busy counter
572 : : * @shost: Pointer to Scsi_Host to inc.
573 : : **/
574 : 442 : int scsi_host_busy(struct Scsi_Host *shost)
575 : : {
576 : 442 : int cnt = 0;
577 : :
578 : 442 : blk_mq_tagset_busy_iter(&shost->tag_set,
579 : : scsi_host_check_in_flight, &cnt);
580 : 442 : return cnt;
581 : : }
582 : : EXPORT_SYMBOL(scsi_host_busy);
583 : :
584 : : /**
585 : : * scsi_host_put - dec a Scsi_Host ref count
586 : : * @shost: Pointer to Scsi_Host to dec.
587 : : **/
588 : 0 : void scsi_host_put(struct Scsi_Host *shost)
589 : : {
590 : 0 : put_device(&shost->shost_gendev);
591 : 0 : }
592 : : EXPORT_SYMBOL(scsi_host_put);
593 : :
594 : 13 : int scsi_init_hosts(void)
595 : : {
596 : 13 : return class_register(&shost_class);
597 : : }
598 : :
599 : 0 : void scsi_exit_hosts(void)
600 : : {
601 : 0 : class_unregister(&shost_class);
602 : 0 : ida_destroy(&host_index_ida);
603 : 0 : }
604 : :
605 : 195 : int scsi_is_host_device(const struct device *dev)
606 : : {
607 [ # # ]: 0 : return dev->type == &scsi_host_type;
608 : : }
609 : : EXPORT_SYMBOL(scsi_is_host_device);
610 : :
611 : : /**
612 : : * scsi_queue_work - Queue work to the Scsi_Host workqueue.
613 : : * @shost: Pointer to Scsi_Host.
614 : : * @work: Work to queue for execution.
615 : : *
616 : : * Return value:
617 : : * 1 - work queued for execution
618 : : * 0 - work is already queued
619 : : * -EINVAL - work queue doesn't exist
620 : : **/
621 : 0 : int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work)
622 : : {
623 [ # # ]: 0 : if (unlikely(!shost->work_q)) {
624 : 0 : shost_printk(KERN_ERR, shost,
625 : : "ERROR: Scsi host '%s' attempted to queue scsi-work, "
626 : : "when no workqueue created.\n", shost->hostt->name);
627 : 0 : dump_stack();
628 : :
629 : 0 : return -EINVAL;
630 : : }
631 : :
632 : 0 : return queue_work(shost->work_q, work);
633 : : }
634 : : EXPORT_SYMBOL_GPL(scsi_queue_work);
635 : :
636 : : /**
637 : : * scsi_flush_work - Flush a Scsi_Host's workqueue.
638 : : * @shost: Pointer to Scsi_Host.
639 : : **/
640 : 0 : void scsi_flush_work(struct Scsi_Host *shost)
641 : : {
642 [ # # ]: 0 : if (!shost->work_q) {
643 : 0 : shost_printk(KERN_ERR, shost,
644 : : "ERROR: Scsi host '%s' attempted to flush scsi-work, "
645 : : "when no workqueue created.\n", shost->hostt->name);
646 : 0 : dump_stack();
647 : 0 : return;
648 : : }
649 : :
650 : 0 : flush_workqueue(shost->work_q);
651 : : }
652 : : EXPORT_SYMBOL_GPL(scsi_flush_work);
|
