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