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 here if scsi_host_alloc() |
357 | * and scsi_host_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 is leaked. |
361 | */ |
362 | kfree(objp: dev_name(dev: &shost->shost_dev)); |
363 | } |
364 | |
365 | kfree(objp: shost->shost_data); |
366 | |
367 | ida_free(&host_index_ida, id: shost->host_no); |
368 | |
369 | if (shost->shost_state != SHOST_CREATED) |
370 | put_device(dev: parent); |
371 | kfree(objp: shost); |
372 | } |
373 | |
374 | static struct device_type scsi_host_type = { |
375 | .name = "scsi_host" , |
376 | .release = scsi_host_dev_release, |
377 | }; |
378 | |
379 | /** |
380 | * scsi_host_alloc - register a scsi host adapter instance. |
381 | * @sht: pointer to scsi host template |
382 | * @privsize: extra bytes to allocate for driver |
383 | * |
384 | * Note: |
385 | * Allocate a new Scsi_Host and perform basic initialization. |
386 | * The host is not published to the scsi midlayer until scsi_add_host |
387 | * is called. |
388 | * |
389 | * Return value: |
390 | * Pointer to a new Scsi_Host |
391 | **/ |
392 | struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *sht, int privsize) |
393 | { |
394 | struct Scsi_Host *shost; |
395 | int index; |
396 | |
397 | shost = kzalloc(size: sizeof(struct Scsi_Host) + privsize, GFP_KERNEL); |
398 | if (!shost) |
399 | return NULL; |
400 | |
401 | shost->host_lock = &shost->default_lock; |
402 | spin_lock_init(shost->host_lock); |
403 | shost->shost_state = SHOST_CREATED; |
404 | INIT_LIST_HEAD(list: &shost->__devices); |
405 | INIT_LIST_HEAD(list: &shost->__targets); |
406 | INIT_LIST_HEAD(list: &shost->eh_abort_list); |
407 | INIT_LIST_HEAD(list: &shost->eh_cmd_q); |
408 | INIT_LIST_HEAD(list: &shost->starved_list); |
409 | init_waitqueue_head(&shost->host_wait); |
410 | mutex_init(&shost->scan_mutex); |
411 | |
412 | index = ida_alloc(ida: &host_index_ida, GFP_KERNEL); |
413 | if (index < 0) { |
414 | kfree(objp: shost); |
415 | return NULL; |
416 | } |
417 | shost->host_no = index; |
418 | |
419 | shost->dma_channel = 0xff; |
420 | |
421 | /* These three are default values which can be overridden */ |
422 | shost->max_channel = 0; |
423 | shost->max_id = 8; |
424 | shost->max_lun = 8; |
425 | |
426 | /* Give each shost a default transportt */ |
427 | shost->transportt = &blank_transport_template; |
428 | |
429 | /* |
430 | * All drivers right now should be able to handle 12 byte |
431 | * commands. Every so often there are requests for 16 byte |
432 | * commands, but individual low-level drivers need to certify that |
433 | * they actually do something sensible with such commands. |
434 | */ |
435 | shost->max_cmd_len = 12; |
436 | shost->hostt = sht; |
437 | shost->this_id = sht->this_id; |
438 | shost->can_queue = sht->can_queue; |
439 | shost->sg_tablesize = sht->sg_tablesize; |
440 | shost->sg_prot_tablesize = sht->sg_prot_tablesize; |
441 | shost->cmd_per_lun = sht->cmd_per_lun; |
442 | shost->no_write_same = sht->no_write_same; |
443 | shost->host_tagset = sht->host_tagset; |
444 | shost->queuecommand_may_block = sht->queuecommand_may_block; |
445 | |
446 | if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler) |
447 | shost->eh_deadline = -1; |
448 | else if ((ulong) shost_eh_deadline * HZ > INT_MAX) { |
449 | shost_printk(KERN_WARNING, shost, |
450 | "eh_deadline %u too large, setting to %u\n" , |
451 | shost_eh_deadline, INT_MAX / HZ); |
452 | shost->eh_deadline = INT_MAX; |
453 | } else |
454 | shost->eh_deadline = shost_eh_deadline * HZ; |
455 | |
456 | if (sht->supported_mode == MODE_UNKNOWN) |
457 | /* means we didn't set it ... default to INITIATOR */ |
458 | shost->active_mode = MODE_INITIATOR; |
459 | else |
460 | shost->active_mode = sht->supported_mode; |
461 | |
462 | if (sht->max_host_blocked) |
463 | shost->max_host_blocked = sht->max_host_blocked; |
464 | else |
465 | shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED; |
466 | |
467 | /* |
468 | * If the driver imposes no hard sector transfer limit, start at |
469 | * machine infinity initially. |
470 | */ |
471 | if (sht->max_sectors) |
472 | shost->max_sectors = sht->max_sectors; |
473 | else |
474 | shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS; |
475 | |
476 | if (sht->max_segment_size) |
477 | shost->max_segment_size = sht->max_segment_size; |
478 | else |
479 | shost->max_segment_size = BLK_MAX_SEGMENT_SIZE; |
480 | |
481 | /* |
482 | * assume a 4GB boundary, if not set |
483 | */ |
484 | if (sht->dma_boundary) |
485 | shost->dma_boundary = sht->dma_boundary; |
486 | else |
487 | shost->dma_boundary = 0xffffffff; |
488 | |
489 | if (sht->virt_boundary_mask) |
490 | shost->virt_boundary_mask = sht->virt_boundary_mask; |
491 | |
492 | device_initialize(dev: &shost->shost_gendev); |
493 | dev_set_name(dev: &shost->shost_gendev, name: "host%d" , shost->host_no); |
494 | shost->shost_gendev.bus = &scsi_bus_type; |
495 | shost->shost_gendev.type = &scsi_host_type; |
496 | scsi_enable_async_suspend(dev: &shost->shost_gendev); |
497 | |
498 | device_initialize(dev: &shost->shost_dev); |
499 | shost->shost_dev.parent = &shost->shost_gendev; |
500 | shost->shost_dev.class = &shost_class; |
501 | dev_set_name(dev: &shost->shost_dev, name: "host%d" , shost->host_no); |
502 | shost->shost_dev.groups = sht->shost_groups; |
503 | |
504 | shost->ehandler = kthread_run(scsi_error_handler, shost, |
505 | "scsi_eh_%d" , shost->host_no); |
506 | if (IS_ERR(ptr: shost->ehandler)) { |
507 | shost_printk(KERN_WARNING, shost, |
508 | "error handler thread failed to spawn, error = %ld\n" , |
509 | PTR_ERR(shost->ehandler)); |
510 | shost->ehandler = NULL; |
511 | goto fail; |
512 | } |
513 | |
514 | shost->tmf_work_q = alloc_workqueue(fmt: "scsi_tmf_%d" , |
515 | flags: WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_SYSFS, |
516 | max_active: 1, shost->host_no); |
517 | if (!shost->tmf_work_q) { |
518 | shost_printk(KERN_WARNING, shost, |
519 | "failed to create tmf workq\n" ); |
520 | goto fail; |
521 | } |
522 | if (scsi_proc_hostdir_add(shost->hostt) < 0) |
523 | goto fail; |
524 | return shost; |
525 | fail: |
526 | /* |
527 | * Host state is still SHOST_CREATED and that is enough to release |
528 | * ->shost_gendev. scsi_host_dev_release() will free |
529 | * dev_name(&shost->shost_dev). |
530 | */ |
531 | put_device(dev: &shost->shost_gendev); |
532 | |
533 | return NULL; |
534 | } |
535 | EXPORT_SYMBOL(scsi_host_alloc); |
536 | |
537 | static int __scsi_host_match(struct device *dev, const void *data) |
538 | { |
539 | struct Scsi_Host *p; |
540 | const unsigned int *hostnum = data; |
541 | |
542 | p = class_to_shost(dev); |
543 | return p->host_no == *hostnum; |
544 | } |
545 | |
546 | /** |
547 | * scsi_host_lookup - get a reference to a Scsi_Host by host no |
548 | * @hostnum: host number to locate |
549 | * |
550 | * Return value: |
551 | * A pointer to located Scsi_Host or NULL. |
552 | * |
553 | * The caller must do a scsi_host_put() to drop the reference |
554 | * that scsi_host_get() took. The put_device() below dropped |
555 | * the reference from class_find_device(). |
556 | **/ |
557 | struct Scsi_Host *scsi_host_lookup(unsigned int hostnum) |
558 | { |
559 | struct device *cdev; |
560 | struct Scsi_Host *shost = NULL; |
561 | |
562 | cdev = class_find_device(class: &shost_class, NULL, data: &hostnum, |
563 | match: __scsi_host_match); |
564 | if (cdev) { |
565 | shost = scsi_host_get(class_to_shost(cdev)); |
566 | put_device(dev: cdev); |
567 | } |
568 | return shost; |
569 | } |
570 | EXPORT_SYMBOL(scsi_host_lookup); |
571 | |
572 | /** |
573 | * scsi_host_get - inc a Scsi_Host ref count |
574 | * @shost: Pointer to Scsi_Host to inc. |
575 | **/ |
576 | struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost) |
577 | { |
578 | if ((shost->shost_state == SHOST_DEL) || |
579 | !get_device(dev: &shost->shost_gendev)) |
580 | return NULL; |
581 | return shost; |
582 | } |
583 | EXPORT_SYMBOL(scsi_host_get); |
584 | |
585 | static bool scsi_host_check_in_flight(struct request *rq, void *data) |
586 | { |
587 | int *count = data; |
588 | struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); |
589 | |
590 | if (test_bit(SCMD_STATE_INFLIGHT, &cmd->state)) |
591 | (*count)++; |
592 | |
593 | return true; |
594 | } |
595 | |
596 | /** |
597 | * scsi_host_busy - Return the host busy counter |
598 | * @shost: Pointer to Scsi_Host to inc. |
599 | **/ |
600 | int scsi_host_busy(struct Scsi_Host *shost) |
601 | { |
602 | int cnt = 0; |
603 | |
604 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, |
605 | fn: scsi_host_check_in_flight, priv: &cnt); |
606 | return cnt; |
607 | } |
608 | EXPORT_SYMBOL(scsi_host_busy); |
609 | |
610 | /** |
611 | * scsi_host_put - dec a Scsi_Host ref count |
612 | * @shost: Pointer to Scsi_Host to dec. |
613 | **/ |
614 | void scsi_host_put(struct Scsi_Host *shost) |
615 | { |
616 | put_device(dev: &shost->shost_gendev); |
617 | } |
618 | EXPORT_SYMBOL(scsi_host_put); |
619 | |
620 | int scsi_init_hosts(void) |
621 | { |
622 | return class_register(class: &shost_class); |
623 | } |
624 | |
625 | void scsi_exit_hosts(void) |
626 | { |
627 | class_unregister(class: &shost_class); |
628 | ida_destroy(ida: &host_index_ida); |
629 | } |
630 | |
631 | int scsi_is_host_device(const struct device *dev) |
632 | { |
633 | return dev->type == &scsi_host_type; |
634 | } |
635 | EXPORT_SYMBOL(scsi_is_host_device); |
636 | |
637 | /** |
638 | * scsi_queue_work - Queue work to the Scsi_Host workqueue. |
639 | * @shost: Pointer to Scsi_Host. |
640 | * @work: Work to queue for execution. |
641 | * |
642 | * Return value: |
643 | * 1 - work queued for execution |
644 | * 0 - work is already queued |
645 | * -EINVAL - work queue doesn't exist |
646 | **/ |
647 | int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work) |
648 | { |
649 | if (unlikely(!shost->work_q)) { |
650 | shost_printk(KERN_ERR, shost, |
651 | "ERROR: Scsi host '%s' attempted to queue scsi-work, " |
652 | "when no workqueue created.\n" , shost->hostt->name); |
653 | dump_stack(); |
654 | |
655 | return -EINVAL; |
656 | } |
657 | |
658 | return queue_work(wq: shost->work_q, work); |
659 | } |
660 | EXPORT_SYMBOL_GPL(scsi_queue_work); |
661 | |
662 | /** |
663 | * scsi_flush_work - Flush a Scsi_Host's workqueue. |
664 | * @shost: Pointer to Scsi_Host. |
665 | **/ |
666 | void scsi_flush_work(struct Scsi_Host *shost) |
667 | { |
668 | if (!shost->work_q) { |
669 | shost_printk(KERN_ERR, shost, |
670 | "ERROR: Scsi host '%s' attempted to flush scsi-work, " |
671 | "when no workqueue created.\n" , shost->hostt->name); |
672 | dump_stack(); |
673 | return; |
674 | } |
675 | |
676 | flush_workqueue(shost->work_q); |
677 | } |
678 | EXPORT_SYMBOL_GPL(scsi_flush_work); |
679 | |
680 | static bool complete_all_cmds_iter(struct request *rq, void *data) |
681 | { |
682 | struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); |
683 | enum scsi_host_status status = *(enum scsi_host_status *)data; |
684 | |
685 | scsi_dma_unmap(cmd: scmd); |
686 | scmd->result = 0; |
687 | set_host_byte(cmd: scmd, status); |
688 | scsi_done(cmd: scmd); |
689 | return true; |
690 | } |
691 | |
692 | /** |
693 | * scsi_host_complete_all_commands - Terminate all running commands |
694 | * @shost: Scsi Host on which commands should be terminated |
695 | * @status: Status to be set for the terminated commands |
696 | * |
697 | * There is no protection against modification of the number |
698 | * of outstanding commands. It is the responsibility of the |
699 | * caller to ensure that concurrent I/O submission and/or |
700 | * completion is stopped when calling this function. |
701 | */ |
702 | void scsi_host_complete_all_commands(struct Scsi_Host *shost, |
703 | enum scsi_host_status status) |
704 | { |
705 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, fn: complete_all_cmds_iter, |
706 | priv: &status); |
707 | } |
708 | EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands); |
709 | |
710 | struct scsi_host_busy_iter_data { |
711 | bool (*fn)(struct scsi_cmnd *, void *); |
712 | void *priv; |
713 | }; |
714 | |
715 | static bool __scsi_host_busy_iter_fn(struct request *req, void *priv) |
716 | { |
717 | struct scsi_host_busy_iter_data *iter_data = priv; |
718 | struct scsi_cmnd *sc = blk_mq_rq_to_pdu(rq: req); |
719 | |
720 | return iter_data->fn(sc, iter_data->priv); |
721 | } |
722 | |
723 | /** |
724 | * scsi_host_busy_iter - Iterate over all busy commands |
725 | * @shost: Pointer to Scsi_Host. |
726 | * @fn: Function to call on each busy command |
727 | * @priv: Data pointer passed to @fn |
728 | * |
729 | * If locking against concurrent command completions is required |
730 | * ithas to be provided by the caller |
731 | **/ |
732 | void scsi_host_busy_iter(struct Scsi_Host *shost, |
733 | bool (*fn)(struct scsi_cmnd *, void *), |
734 | void *priv) |
735 | { |
736 | struct scsi_host_busy_iter_data iter_data = { |
737 | .fn = fn, |
738 | .priv = priv, |
739 | }; |
740 | |
741 | blk_mq_tagset_busy_iter(tagset: &shost->tag_set, fn: __scsi_host_busy_iter_fn, |
742 | priv: &iter_data); |
743 | } |
744 | EXPORT_SYMBOL_GPL(scsi_host_busy_iter); |
745 | |