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 | static void scsi_host_cls_release(struct device *dev) |
57 | { |
58 | put_device(dev: &class_to_shost(dev)->shost_gendev); |
59 | } |
60 | |
61 | static 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 | **/ |
75 | int 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 | **/ |
165 | void 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, state: SHOST_CANCEL)) |
172 | if (scsi_host_set_state(shost, state: SHOST_CANCEL_RECOVERY)) { |
173 | spin_unlock_irqrestore(lock: shost->host_lock, flags); |
174 | mutex_unlock(lock: &shost->scan_mutex); |
175 | return; |
176 | } |
177 | spin_unlock_irqrestore(lock: 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(lock: &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(kref: &shost->tagset_refcnt, release: 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, state: SHOST_DEL)) |
197 | BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY)); |
198 | spin_unlock_irqrestore(lock: shost->host_lock, flags); |
199 | |
200 | transport_unregister_device(dev: &shost->shost_gendev); |
201 | device_unregister(dev: &shost->shost_dev); |
202 | device_del(dev: &shost->shost_gendev); |
203 | } |
204 | EXPORT_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 | **/ |
219 | int 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 | /* Use min_t(int, ...) in case shost->can_queue exceeds SHRT_MAX */ |
235 | shost->cmd_per_lun = min_t(int, shost->cmd_per_lun, |
236 | shost->can_queue); |
237 | |
238 | error = scsi_init_sense_cache(shost); |
239 | if (error) |
240 | goto fail; |
241 | |
242 | if (!shost->shost_gendev.parent) |
243 | shost->shost_gendev.parent = dev ? dev : &platform_bus; |
244 | if (!dma_dev) |
245 | dma_dev = shost->shost_gendev.parent; |
246 | |
247 | shost->dma_dev = dma_dev; |
248 | |
249 | if (dma_dev->dma_mask) { |
250 | shost->max_sectors = min_t(unsigned int, shost->max_sectors, |
251 | dma_max_mapping_size(dma_dev) >> SECTOR_SHIFT); |
252 | } |
253 | |
254 | error = scsi_mq_setup_tags(shost); |
255 | if (error) |
256 | goto fail; |
257 | |
258 | kref_init(kref: &shost->tagset_refcnt); |
259 | init_completion(x: &shost->tagset_freed); |
260 | |
261 | /* |
262 | * Increase usage count temporarily here so that calling |
263 | * scsi_autopm_put_host() will trigger runtime idle if there is |
264 | * nothing else preventing suspending the device. |
265 | */ |
266 | pm_runtime_get_noresume(dev: &shost->shost_gendev); |
267 | pm_runtime_set_active(dev: &shost->shost_gendev); |
268 | pm_runtime_enable(dev: &shost->shost_gendev); |
269 | device_enable_async_suspend(dev: &shost->shost_gendev); |
270 | |
271 | error = device_add(dev: &shost->shost_gendev); |
272 | if (error) |
273 | goto out_disable_runtime_pm; |
274 | |
275 | scsi_host_set_state(shost, state: SHOST_RUNNING); |
276 | get_device(dev: shost->shost_gendev.parent); |
277 | |
278 | device_enable_async_suspend(dev: &shost->shost_dev); |
279 | |
280 | get_device(dev: &shost->shost_gendev); |
281 | error = device_add(dev: &shost->shost_dev); |
282 | if (error) |
283 | goto out_del_gendev; |
284 | |
285 | if (shost->transportt->host_size) { |
286 | shost->shost_data = kzalloc(size: shost->transportt->host_size, |
287 | GFP_KERNEL); |
288 | if (shost->shost_data == NULL) { |
289 | error = -ENOMEM; |
290 | goto out_del_dev; |
291 | } |
292 | } |
293 | |
294 | if (shost->transportt->create_work_queue) { |
295 | snprintf(buf: shost->work_q_name, size: sizeof(shost->work_q_name), |
296 | fmt: "scsi_wq_%d" , shost->host_no); |
297 | shost->work_q = alloc_workqueue(fmt: "%s" , |
298 | flags: WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, |
299 | max_active: 1, shost->work_q_name); |
300 | |
301 | if (!shost->work_q) { |
302 | error = -EINVAL; |
303 | goto out_del_dev; |
304 | } |
305 | } |
306 | |
307 | error = scsi_sysfs_add_host(shost); |
308 | if (error) |
309 | goto out_del_dev; |
310 | |
311 | scsi_proc_host_add(shost); |
312 | scsi_autopm_put_host(shost); |
313 | return error; |
314 | |
315 | /* |
316 | * Any host allocation in this function will be freed in |
317 | * scsi_host_dev_release(). |
318 | */ |
319 | out_del_dev: |
320 | device_del(dev: &shost->shost_dev); |
321 | out_del_gendev: |
322 | /* |
323 | * Host state is SHOST_RUNNING so we have to explicitly release |
324 | * ->shost_dev. |
325 | */ |
326 | put_device(dev: &shost->shost_dev); |
327 | device_del(dev: &shost->shost_gendev); |
328 | out_disable_runtime_pm: |
329 | device_disable_async_suspend(dev: &shost->shost_gendev); |
330 | pm_runtime_disable(dev: &shost->shost_gendev); |
331 | pm_runtime_set_suspended(dev: &shost->shost_gendev); |
332 | pm_runtime_put_noidle(dev: &shost->shost_gendev); |
333 | kref_put(kref: &shost->tagset_refcnt, release: scsi_mq_free_tags); |
334 | fail: |
335 | return error; |
336 | } |
337 | EXPORT_SYMBOL(scsi_add_host_with_dma); |
338 | |
339 | static void scsi_host_dev_release(struct device *dev) |
340 | { |
341 | struct Scsi_Host *shost = dev_to_shost(dev); |
342 | struct device *parent = dev->parent; |
343 | |
344 | /* Wait for functions invoked through call_rcu(&scmd->rcu, ...) */ |
345 | rcu_barrier(); |
346 | |
347 | if (shost->tmf_work_q) |
348 | destroy_workqueue(wq: shost->tmf_work_q); |
349 | if (shost->ehandler) |
350 | kthread_stop(k: shost->ehandler); |
351 | if (shost->work_q) |
352 | destroy_workqueue(wq: shost->work_q); |
353 | |
354 | if (shost->shost_state == SHOST_CREATED) { |
355 | /* |
356 | * Free the shost_dev device name and remove the proc host dir |
357 | * here if scsi_host_{alloc,put}() have been called but neither |
358 | * scsi_host_add() nor scsi_remove_host() has been called. |
359 | * This avoids that the memory allocated for the shost_dev |
360 | * name as well as the proc dir structure are leaked. |
361 | */ |
362 | scsi_proc_hostdir_rm(shost->hostt); |
363 | kfree(objp: dev_name(dev: &shost->shost_dev)); |
364 | } |
365 | |
366 | kfree(objp: shost->shost_data); |
367 | |
368 | ida_free(&host_index_ida, id: shost->host_no); |
369 | |
370 | if (shost->shost_state != SHOST_CREATED) |
371 | put_device(dev: parent); |
372 | kfree(objp: shost); |
373 | } |
374 | |
375 | static const struct device_type scsi_host_type = { |
376 | .name = "scsi_host" , |
377 | .release = scsi_host_dev_release, |
378 | }; |
379 | |
380 | /** |
381 | * scsi_host_alloc - register a scsi host adapter instance. |
382 | * @sht: pointer to scsi host template |
383 | * @privsize: extra bytes to allocate for driver |
384 | * |
385 | * Note: |
386 | * Allocate a new Scsi_Host and perform basic initialization. |
387 | * The host is not published to the scsi midlayer until scsi_add_host |
388 | * is called. |
389 | * |
390 | * Return value: |
391 | * Pointer to a new Scsi_Host |
392 | **/ |
393 | struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *sht, int privsize) |
394 | { |
395 | struct Scsi_Host *shost; |
396 | int index; |
397 | |
398 | shost = kzalloc(size: sizeof(struct Scsi_Host) + privsize, GFP_KERNEL); |
399 | if (!shost) |
400 | return NULL; |
401 | |
402 | shost->host_lock = &shost->default_lock; |
403 | spin_lock_init(shost->host_lock); |
404 | shost->shost_state = SHOST_CREATED; |
405 | INIT_LIST_HEAD(list: &shost->__devices); |
406 | INIT_LIST_HEAD(list: &shost->__targets); |
407 | INIT_LIST_HEAD(list: &shost->eh_abort_list); |
408 | INIT_LIST_HEAD(list: &shost->eh_cmd_q); |
409 | INIT_LIST_HEAD(list: &shost->starved_list); |
410 | init_waitqueue_head(&shost->host_wait); |
411 | mutex_init(&shost->scan_mutex); |
412 | |
413 | index = ida_alloc(ida: &host_index_ida, GFP_KERNEL); |
414 | if (index < 0) { |
415 | kfree(objp: shost); |
416 | return NULL; |
417 | } |
418 | shost->host_no = index; |
419 | |
420 | shost->dma_channel = 0xff; |
421 | |
422 | /* These three are default values which can be overridden */ |
423 | shost->max_channel = 0; |
424 | shost->max_id = 8; |
425 | shost->max_lun = 8; |
426 | |
427 | /* Give each shost a default transportt */ |
428 | shost->transportt = &blank_transport_template; |
429 | |
430 | /* |
431 | * All drivers right now should be able to handle 12 byte |
432 | * commands. Every so often there are requests for 16 byte |
433 | * commands, but individual low-level drivers need to certify that |
434 | * they actually do something sensible with such commands. |
435 | */ |
436 | shost->max_cmd_len = 12; |
437 | shost->hostt = sht; |
438 | shost->this_id = sht->this_id; |
439 | shost->can_queue = sht->can_queue; |
440 | shost->sg_tablesize = sht->sg_tablesize; |
441 | shost->sg_prot_tablesize = sht->sg_prot_tablesize; |
442 | shost->cmd_per_lun = sht->cmd_per_lun; |
443 | shost->no_write_same = sht->no_write_same; |
444 | shost->host_tagset = sht->host_tagset; |
445 | shost->queuecommand_may_block = sht->queuecommand_may_block; |
446 | |
447 | if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler) |
448 | shost->eh_deadline = -1; |
449 | else if ((ulong) shost_eh_deadline * HZ > INT_MAX) { |
450 | shost_printk(KERN_WARNING, shost, |
451 | "eh_deadline %u too large, setting to %u\n" , |
452 | shost_eh_deadline, INT_MAX / HZ); |
453 | shost->eh_deadline = INT_MAX; |
454 | } else |
455 | shost->eh_deadline = shost_eh_deadline * HZ; |
456 | |
457 | if (sht->supported_mode == MODE_UNKNOWN) |
458 | /* means we didn't set it ... default to INITIATOR */ |
459 | shost->active_mode = MODE_INITIATOR; |
460 | else |
461 | shost->active_mode = sht->supported_mode; |
462 | |
463 | if (sht->max_host_blocked) |
464 | shost->max_host_blocked = sht->max_host_blocked; |
465 | else |
466 | shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED; |
467 | |
468 | /* |
469 | * If the driver imposes no hard sector transfer limit, start at |
470 | * machine infinity initially. |
471 | */ |
472 | if (sht->max_sectors) |
473 | shost->max_sectors = sht->max_sectors; |
474 | else |
475 | shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS; |
476 | |
477 | if (sht->max_segment_size) |
478 | shost->max_segment_size = sht->max_segment_size; |
479 | else |
480 | shost->max_segment_size = BLK_MAX_SEGMENT_SIZE; |
481 | |
482 | /* |
483 | * assume a 4GB boundary, if not set |
484 | */ |
485 | if (sht->dma_boundary) |
486 | shost->dma_boundary = sht->dma_boundary; |
487 | else |
488 | shost->dma_boundary = 0xffffffff; |
489 | |
490 | if (sht->virt_boundary_mask) |
491 | shost->virt_boundary_mask = sht->virt_boundary_mask; |
492 | |
493 | device_initialize(dev: &shost->shost_gendev); |
494 | dev_set_name(dev: &shost->shost_gendev, name: "host%d" , shost->host_no); |
495 | shost->shost_gendev.bus = &scsi_bus_type; |
496 | shost->shost_gendev.type = &scsi_host_type; |
497 | scsi_enable_async_suspend(dev: &shost->shost_gendev); |
498 | |
499 | device_initialize(dev: &shost->shost_dev); |
500 | shost->shost_dev.parent = &shost->shost_gendev; |
501 | shost->shost_dev.class = &shost_class; |
502 | dev_set_name(dev: &shost->shost_dev, name: "host%d" , shost->host_no); |
503 | shost->shost_dev.groups = sht->shost_groups; |
504 | |
505 | shost->ehandler = kthread_run(scsi_error_handler, shost, |
506 | "scsi_eh_%d" , shost->host_no); |
507 | if (IS_ERR(ptr: shost->ehandler)) { |
508 | shost_printk(KERN_WARNING, shost, |
509 | "error handler thread failed to spawn, error = %ld\n" , |
510 | PTR_ERR(shost->ehandler)); |
511 | shost->ehandler = NULL; |
512 | goto fail; |
513 | } |
514 | |
515 | shost->tmf_work_q = alloc_workqueue(fmt: "scsi_tmf_%d" , |
516 | flags: WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_SYSFS, |
517 | max_active: 1, shost->host_no); |
518 | if (!shost->tmf_work_q) { |
519 | shost_printk(KERN_WARNING, shost, |
520 | "failed to create tmf workq\n" ); |
521 | goto fail; |
522 | } |
523 | if (scsi_proc_hostdir_add(shost->hostt) < 0) |
524 | goto fail; |
525 | return shost; |
526 | fail: |
527 | /* |
528 | * Host state is still SHOST_CREATED and that is enough to release |
529 | * ->shost_gendev. scsi_host_dev_release() will free |
530 | * dev_name(&shost->shost_dev). |
531 | */ |
532 | put_device(dev: &shost->shost_gendev); |
533 | |
534 | return NULL; |
535 | } |
536 | EXPORT_SYMBOL(scsi_host_alloc); |
537 | |
538 | static int __scsi_host_match(struct device *dev, const void *data) |
539 | { |
540 | struct Scsi_Host *p; |
541 | const unsigned int *hostnum = data; |
542 | |
543 | p = class_to_shost(dev); |
544 | return p->host_no == *hostnum; |
545 | } |
546 | |
547 | /** |
548 | * scsi_host_lookup - get a reference to a Scsi_Host by host no |
549 | * @hostnum: host number to locate |
550 | * |
551 | * Return value: |
552 | * A pointer to located Scsi_Host or NULL. |
553 | * |
554 | * The caller must do a scsi_host_put() to drop the reference |
555 | * that scsi_host_get() took. The put_device() below dropped |
556 | * the reference from class_find_device(). |
557 | **/ |
558 | struct Scsi_Host *scsi_host_lookup(unsigned int hostnum) |
559 | { |
560 | struct device *cdev; |
561 | struct Scsi_Host *shost = NULL; |
562 | |
563 | cdev = class_find_device(class: &shost_class, NULL, data: &hostnum, |
564 | match: __scsi_host_match); |
565 | if (cdev) { |
566 | shost = scsi_host_get(class_to_shost(cdev)); |
567 | put_device(dev: cdev); |
568 | } |
569 | return shost; |
570 | } |
571 | EXPORT_SYMBOL(scsi_host_lookup); |
572 | |
573 | /** |
574 | * scsi_host_get - inc a Scsi_Host ref count |
575 | * @shost: Pointer to Scsi_Host to inc. |
576 | **/ |
577 | struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost) |
578 | { |
579 | if ((shost->shost_state == SHOST_DEL) || |
580 | !get_device(dev: &shost->shost_gendev)) |
581 | return NULL; |
582 | return shost; |
583 | } |
584 | EXPORT_SYMBOL(scsi_host_get); |
585 | |
586 | static bool scsi_host_check_in_flight(struct request *rq, void *data) |
587 | { |
588 | int *count = data; |
589 | struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); |
590 | |
591 | if (test_bit(SCMD_STATE_INFLIGHT, &cmd->state)) |
592 | (*count)++; |
593 | |
594 | return true; |
595 | } |
596 | |
597 | /** |
598 | * scsi_host_busy - Return the host busy counter |
599 | * @shost: Pointer to Scsi_Host to inc. |
600 | **/ |
601 | int scsi_host_busy(struct Scsi_Host *shost) |
602 | { |
603 | int cnt = 0; |
604 | |
605 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, |
606 | fn: scsi_host_check_in_flight, priv: &cnt); |
607 | return cnt; |
608 | } |
609 | EXPORT_SYMBOL(scsi_host_busy); |
610 | |
611 | /** |
612 | * scsi_host_put - dec a Scsi_Host ref count |
613 | * @shost: Pointer to Scsi_Host to dec. |
614 | **/ |
615 | void scsi_host_put(struct Scsi_Host *shost) |
616 | { |
617 | put_device(dev: &shost->shost_gendev); |
618 | } |
619 | EXPORT_SYMBOL(scsi_host_put); |
620 | |
621 | int scsi_init_hosts(void) |
622 | { |
623 | return class_register(class: &shost_class); |
624 | } |
625 | |
626 | void scsi_exit_hosts(void) |
627 | { |
628 | class_unregister(class: &shost_class); |
629 | ida_destroy(ida: &host_index_ida); |
630 | } |
631 | |
632 | int scsi_is_host_device(const struct device *dev) |
633 | { |
634 | return dev->type == &scsi_host_type; |
635 | } |
636 | EXPORT_SYMBOL(scsi_is_host_device); |
637 | |
638 | /** |
639 | * scsi_queue_work - Queue work to the Scsi_Host workqueue. |
640 | * @shost: Pointer to Scsi_Host. |
641 | * @work: Work to queue for execution. |
642 | * |
643 | * Return value: |
644 | * 1 - work queued for execution |
645 | * 0 - work is already queued |
646 | * -EINVAL - work queue doesn't exist |
647 | **/ |
648 | int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work) |
649 | { |
650 | if (unlikely(!shost->work_q)) { |
651 | shost_printk(KERN_ERR, shost, |
652 | "ERROR: Scsi host '%s' attempted to queue scsi-work, " |
653 | "when no workqueue created.\n" , shost->hostt->name); |
654 | dump_stack(); |
655 | |
656 | return -EINVAL; |
657 | } |
658 | |
659 | return queue_work(wq: shost->work_q, work); |
660 | } |
661 | EXPORT_SYMBOL_GPL(scsi_queue_work); |
662 | |
663 | /** |
664 | * scsi_flush_work - Flush a Scsi_Host's workqueue. |
665 | * @shost: Pointer to Scsi_Host. |
666 | **/ |
667 | void scsi_flush_work(struct Scsi_Host *shost) |
668 | { |
669 | if (!shost->work_q) { |
670 | shost_printk(KERN_ERR, shost, |
671 | "ERROR: Scsi host '%s' attempted to flush scsi-work, " |
672 | "when no workqueue created.\n" , shost->hostt->name); |
673 | dump_stack(); |
674 | return; |
675 | } |
676 | |
677 | flush_workqueue(shost->work_q); |
678 | } |
679 | EXPORT_SYMBOL_GPL(scsi_flush_work); |
680 | |
681 | static bool complete_all_cmds_iter(struct request *rq, void *data) |
682 | { |
683 | struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); |
684 | enum scsi_host_status status = *(enum scsi_host_status *)data; |
685 | |
686 | scsi_dma_unmap(cmd: scmd); |
687 | scmd->result = 0; |
688 | set_host_byte(cmd: scmd, status); |
689 | scsi_done(cmd: scmd); |
690 | return true; |
691 | } |
692 | |
693 | /** |
694 | * scsi_host_complete_all_commands - Terminate all running commands |
695 | * @shost: Scsi Host on which commands should be terminated |
696 | * @status: Status to be set for the terminated commands |
697 | * |
698 | * There is no protection against modification of the number |
699 | * of outstanding commands. It is the responsibility of the |
700 | * caller to ensure that concurrent I/O submission and/or |
701 | * completion is stopped when calling this function. |
702 | */ |
703 | void scsi_host_complete_all_commands(struct Scsi_Host *shost, |
704 | enum scsi_host_status status) |
705 | { |
706 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, fn: complete_all_cmds_iter, |
707 | priv: &status); |
708 | } |
709 | EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands); |
710 | |
711 | struct scsi_host_busy_iter_data { |
712 | bool (*fn)(struct scsi_cmnd *, void *); |
713 | void *priv; |
714 | }; |
715 | |
716 | static bool __scsi_host_busy_iter_fn(struct request *req, void *priv) |
717 | { |
718 | struct scsi_host_busy_iter_data *iter_data = priv; |
719 | struct scsi_cmnd *sc = blk_mq_rq_to_pdu(rq: req); |
720 | |
721 | return iter_data->fn(sc, iter_data->priv); |
722 | } |
723 | |
724 | /** |
725 | * scsi_host_busy_iter - Iterate over all busy commands |
726 | * @shost: Pointer to Scsi_Host. |
727 | * @fn: Function to call on each busy command |
728 | * @priv: Data pointer passed to @fn |
729 | * |
730 | * If locking against concurrent command completions is required |
731 | * ithas to be provided by the caller |
732 | **/ |
733 | void scsi_host_busy_iter(struct Scsi_Host *shost, |
734 | bool (*fn)(struct scsi_cmnd *, void *), |
735 | void *priv) |
736 | { |
737 | struct scsi_host_busy_iter_data iter_data = { |
738 | .fn = fn, |
739 | .priv = priv, |
740 | }; |
741 | |
742 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, fn: __scsi_host_busy_iter_fn, |
743 | priv: &iter_data); |
744 | } |
745 | EXPORT_SYMBOL_GPL(scsi_host_busy_iter); |
746 | |