xref: /openbmc/linux/drivers/scsi/scsi.c (revision 034f90b3)
1 /*
2  *  scsi.c Copyright (C) 1992 Drew Eckhardt
3  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4  *         Copyright (C) 2002, 2003 Christoph Hellwig
5  *
6  *  generic mid-level SCSI driver
7  *      Initial versions: Drew Eckhardt
8  *      Subsequent revisions: Eric Youngdale
9  *
10  *  <drew@colorado.edu>
11  *
12  *  Bug correction thanks go to :
13  *      Rik Faith <faith@cs.unc.edu>
14  *      Tommy Thorn <tthorn>
15  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
16  *
17  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
18  *  add scatter-gather, multiple outstanding request, and other
19  *  enhancements.
20  *
21  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
22  *  support added by Michael Neuffer <mike@i-connect.net>
23  *
24  *  Added request_module("scsi_hostadapter") for kerneld:
25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
26  *  Bjorn Ekwall  <bj0rn@blox.se>
27  *  (changed to kmod)
28  *
29  *  Major improvements to the timeout, abort, and reset processing,
30  *  as well as performance modifications for large queue depths by
31  *  Leonard N. Zubkoff <lnz@dandelion.com>
32  *
33  *  Converted cli() code to spinlocks, Ingo Molnar
34  *
35  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
36  *
37  *  out_of_space hacks, D. Gilbert (dpg) 990608
38  */
39 
40 #include <linux/module.h>
41 #include <linux/moduleparam.h>
42 #include <linux/kernel.h>
43 #include <linux/timer.h>
44 #include <linux/string.h>
45 #include <linux/slab.h>
46 #include <linux/blkdev.h>
47 #include <linux/delay.h>
48 #include <linux/init.h>
49 #include <linux/completion.h>
50 #include <linux/unistd.h>
51 #include <linux/spinlock.h>
52 #include <linux/kmod.h>
53 #include <linux/interrupt.h>
54 #include <linux/notifier.h>
55 #include <linux/cpu.h>
56 #include <linux/mutex.h>
57 #include <linux/async.h>
58 #include <asm/unaligned.h>
59 
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_dbg.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_driver.h>
65 #include <scsi/scsi_eh.h>
66 #include <scsi/scsi_host.h>
67 #include <scsi/scsi_tcq.h>
68 
69 #include "scsi_priv.h"
70 #include "scsi_logging.h"
71 
72 #define CREATE_TRACE_POINTS
73 #include <trace/events/scsi.h>
74 
75 /*
76  * Definitions and constants.
77  */
78 
79 /*
80  * Note - the initial logging level can be set here to log events at boot time.
81  * After the system is up, you may enable logging via the /proc interface.
82  */
83 unsigned int scsi_logging_level;
84 #if defined(CONFIG_SCSI_LOGGING)
85 EXPORT_SYMBOL(scsi_logging_level);
86 #endif
87 
88 /* sd, scsi core and power management need to coordinate flushing async actions */
89 ASYNC_DOMAIN(scsi_sd_probe_domain);
90 EXPORT_SYMBOL(scsi_sd_probe_domain);
91 
92 /*
93  * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
94  * asynchronous system resume operations.  It is marked 'exclusive' to avoid
95  * being included in the async_synchronize_full() that is invoked by
96  * dpm_resume()
97  */
98 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
99 EXPORT_SYMBOL(scsi_sd_pm_domain);
100 
101 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
102  * You may not alter any existing entry (although adding new ones is
103  * encouraged once assigned by ANSI/INCITS T10
104  */
105 static const char *const scsi_device_types[] = {
106 	"Direct-Access    ",
107 	"Sequential-Access",
108 	"Printer          ",
109 	"Processor        ",
110 	"WORM             ",
111 	"CD-ROM           ",
112 	"Scanner          ",
113 	"Optical Device   ",
114 	"Medium Changer   ",
115 	"Communications   ",
116 	"ASC IT8          ",
117 	"ASC IT8          ",
118 	"RAID             ",
119 	"Enclosure        ",
120 	"Direct-Access-RBC",
121 	"Optical card     ",
122 	"Bridge controller",
123 	"Object storage   ",
124 	"Automation/Drive ",
125 	"Security Manager ",
126 	"Direct-Access-ZBC",
127 };
128 
129 /**
130  * scsi_device_type - Return 17 char string indicating device type.
131  * @type: type number to look up
132  */
133 
134 const char * scsi_device_type(unsigned type)
135 {
136 	if (type == 0x1e)
137 		return "Well-known LUN   ";
138 	if (type == 0x1f)
139 		return "No Device        ";
140 	if (type >= ARRAY_SIZE(scsi_device_types))
141 		return "Unknown          ";
142 	return scsi_device_types[type];
143 }
144 
145 EXPORT_SYMBOL(scsi_device_type);
146 
147 struct scsi_host_cmd_pool {
148 	struct kmem_cache	*cmd_slab;
149 	struct kmem_cache	*sense_slab;
150 	unsigned int		users;
151 	char			*cmd_name;
152 	char			*sense_name;
153 	unsigned int		slab_flags;
154 	gfp_t			gfp_mask;
155 };
156 
157 static struct scsi_host_cmd_pool scsi_cmd_pool = {
158 	.cmd_name	= "scsi_cmd_cache",
159 	.sense_name	= "scsi_sense_cache",
160 	.slab_flags	= SLAB_HWCACHE_ALIGN,
161 };
162 
163 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
164 	.cmd_name	= "scsi_cmd_cache(DMA)",
165 	.sense_name	= "scsi_sense_cache(DMA)",
166 	.slab_flags	= SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
167 	.gfp_mask	= __GFP_DMA,
168 };
169 
170 static DEFINE_MUTEX(host_cmd_pool_mutex);
171 
172 /**
173  * scsi_host_free_command - internal function to release a command
174  * @shost:	host to free the command for
175  * @cmd:	command to release
176  *
177  * the command must previously have been allocated by
178  * scsi_host_alloc_command.
179  */
180 static void
181 scsi_host_free_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
182 {
183 	struct scsi_host_cmd_pool *pool = shost->cmd_pool;
184 
185 	if (cmd->prot_sdb)
186 		kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
187 	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
188 	kmem_cache_free(pool->cmd_slab, cmd);
189 }
190 
191 /**
192  * scsi_host_alloc_command - internal function to allocate command
193  * @shost:	SCSI host whose pool to allocate from
194  * @gfp_mask:	mask for the allocation
195  *
196  * Returns a fully allocated command with sense buffer and protection
197  * data buffer (where applicable) or NULL on failure
198  */
199 static struct scsi_cmnd *
200 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
201 {
202 	struct scsi_host_cmd_pool *pool = shost->cmd_pool;
203 	struct scsi_cmnd *cmd;
204 
205 	cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
206 	if (!cmd)
207 		goto fail;
208 
209 	cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
210 					     gfp_mask | pool->gfp_mask);
211 	if (!cmd->sense_buffer)
212 		goto fail_free_cmd;
213 
214 	if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
215 		cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
216 		if (!cmd->prot_sdb)
217 			goto fail_free_sense;
218 	}
219 
220 	return cmd;
221 
222 fail_free_sense:
223 	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
224 fail_free_cmd:
225 	kmem_cache_free(pool->cmd_slab, cmd);
226 fail:
227 	return NULL;
228 }
229 
230 /**
231  * __scsi_get_command - Allocate a struct scsi_cmnd
232  * @shost: host to transmit command
233  * @gfp_mask: allocation mask
234  *
235  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
236  *              host's free_list if necessary.
237  */
238 static struct scsi_cmnd *
239 __scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
240 {
241 	struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
242 
243 	if (unlikely(!cmd)) {
244 		unsigned long flags;
245 
246 		spin_lock_irqsave(&shost->free_list_lock, flags);
247 		if (likely(!list_empty(&shost->free_list))) {
248 			cmd = list_entry(shost->free_list.next,
249 					 struct scsi_cmnd, list);
250 			list_del_init(&cmd->list);
251 		}
252 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
253 
254 		if (cmd) {
255 			void *buf, *prot;
256 
257 			buf = cmd->sense_buffer;
258 			prot = cmd->prot_sdb;
259 
260 			memset(cmd, 0, sizeof(*cmd));
261 
262 			cmd->sense_buffer = buf;
263 			cmd->prot_sdb = prot;
264 		}
265 	}
266 
267 	return cmd;
268 }
269 
270 /**
271  * scsi_get_command - Allocate and setup a scsi command block
272  * @dev: parent scsi device
273  * @gfp_mask: allocator flags
274  *
275  * Returns:	The allocated scsi command structure.
276  */
277 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
278 {
279 	struct scsi_cmnd *cmd = __scsi_get_command(dev->host, gfp_mask);
280 	unsigned long flags;
281 
282 	if (unlikely(cmd == NULL))
283 		return NULL;
284 
285 	cmd->device = dev;
286 	INIT_LIST_HEAD(&cmd->list);
287 	INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
288 	spin_lock_irqsave(&dev->list_lock, flags);
289 	list_add_tail(&cmd->list, &dev->cmd_list);
290 	spin_unlock_irqrestore(&dev->list_lock, flags);
291 	cmd->jiffies_at_alloc = jiffies;
292 	return cmd;
293 }
294 
295 /**
296  * __scsi_put_command - Free a struct scsi_cmnd
297  * @shost: dev->host
298  * @cmd: Command to free
299  */
300 static void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
301 {
302 	unsigned long flags;
303 
304 	if (unlikely(list_empty(&shost->free_list))) {
305 		spin_lock_irqsave(&shost->free_list_lock, flags);
306 		if (list_empty(&shost->free_list)) {
307 			list_add(&cmd->list, &shost->free_list);
308 			cmd = NULL;
309 		}
310 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
311 	}
312 
313 	if (likely(cmd != NULL))
314 		scsi_host_free_command(shost, cmd);
315 }
316 
317 /**
318  * scsi_put_command - Free a scsi command block
319  * @cmd: command block to free
320  *
321  * Returns:	Nothing.
322  *
323  * Notes:	The command must not belong to any lists.
324  */
325 void scsi_put_command(struct scsi_cmnd *cmd)
326 {
327 	unsigned long flags;
328 
329 	/* serious error if the command hasn't come from a device list */
330 	spin_lock_irqsave(&cmd->device->list_lock, flags);
331 	BUG_ON(list_empty(&cmd->list));
332 	list_del_init(&cmd->list);
333 	spin_unlock_irqrestore(&cmd->device->list_lock, flags);
334 
335 	BUG_ON(delayed_work_pending(&cmd->abort_work));
336 
337 	__scsi_put_command(cmd->device->host, cmd);
338 }
339 
340 static struct scsi_host_cmd_pool *
341 scsi_find_host_cmd_pool(struct Scsi_Host *shost)
342 {
343 	if (shost->hostt->cmd_size)
344 		return shost->hostt->cmd_pool;
345 	if (shost->unchecked_isa_dma)
346 		return &scsi_cmd_dma_pool;
347 	return &scsi_cmd_pool;
348 }
349 
350 static void
351 scsi_free_host_cmd_pool(struct scsi_host_cmd_pool *pool)
352 {
353 	kfree(pool->sense_name);
354 	kfree(pool->cmd_name);
355 	kfree(pool);
356 }
357 
358 static struct scsi_host_cmd_pool *
359 scsi_alloc_host_cmd_pool(struct Scsi_Host *shost)
360 {
361 	struct scsi_host_template *hostt = shost->hostt;
362 	struct scsi_host_cmd_pool *pool;
363 
364 	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
365 	if (!pool)
366 		return NULL;
367 
368 	pool->cmd_name = kasprintf(GFP_KERNEL, "%s_cmd", hostt->proc_name);
369 	pool->sense_name = kasprintf(GFP_KERNEL, "%s_sense", hostt->proc_name);
370 	if (!pool->cmd_name || !pool->sense_name) {
371 		scsi_free_host_cmd_pool(pool);
372 		return NULL;
373 	}
374 
375 	pool->slab_flags = SLAB_HWCACHE_ALIGN;
376 	if (shost->unchecked_isa_dma) {
377 		pool->slab_flags |= SLAB_CACHE_DMA;
378 		pool->gfp_mask = __GFP_DMA;
379 	}
380 
381 	if (hostt->cmd_size)
382 		hostt->cmd_pool = pool;
383 
384 	return pool;
385 }
386 
387 static struct scsi_host_cmd_pool *
388 scsi_get_host_cmd_pool(struct Scsi_Host *shost)
389 {
390 	struct scsi_host_template *hostt = shost->hostt;
391 	struct scsi_host_cmd_pool *retval = NULL, *pool;
392 	size_t cmd_size = sizeof(struct scsi_cmnd) + hostt->cmd_size;
393 
394 	/*
395 	 * Select a command slab for this host and create it if not
396 	 * yet existent.
397 	 */
398 	mutex_lock(&host_cmd_pool_mutex);
399 	pool = scsi_find_host_cmd_pool(shost);
400 	if (!pool) {
401 		pool = scsi_alloc_host_cmd_pool(shost);
402 		if (!pool)
403 			goto out;
404 	}
405 
406 	if (!pool->users) {
407 		pool->cmd_slab = kmem_cache_create(pool->cmd_name, cmd_size, 0,
408 						   pool->slab_flags, NULL);
409 		if (!pool->cmd_slab)
410 			goto out_free_pool;
411 
412 		pool->sense_slab = kmem_cache_create(pool->sense_name,
413 						     SCSI_SENSE_BUFFERSIZE, 0,
414 						     pool->slab_flags, NULL);
415 		if (!pool->sense_slab)
416 			goto out_free_slab;
417 	}
418 
419 	pool->users++;
420 	retval = pool;
421 out:
422 	mutex_unlock(&host_cmd_pool_mutex);
423 	return retval;
424 
425 out_free_slab:
426 	kmem_cache_destroy(pool->cmd_slab);
427 out_free_pool:
428 	if (hostt->cmd_size) {
429 		scsi_free_host_cmd_pool(pool);
430 		hostt->cmd_pool = NULL;
431 	}
432 	goto out;
433 }
434 
435 static void scsi_put_host_cmd_pool(struct Scsi_Host *shost)
436 {
437 	struct scsi_host_template *hostt = shost->hostt;
438 	struct scsi_host_cmd_pool *pool;
439 
440 	mutex_lock(&host_cmd_pool_mutex);
441 	pool = scsi_find_host_cmd_pool(shost);
442 
443 	/*
444 	 * This may happen if a driver has a mismatched get and put
445 	 * of the command pool; the driver should be implicated in
446 	 * the stack trace
447 	 */
448 	BUG_ON(pool->users == 0);
449 
450 	if (!--pool->users) {
451 		kmem_cache_destroy(pool->cmd_slab);
452 		kmem_cache_destroy(pool->sense_slab);
453 		if (hostt->cmd_size) {
454 			scsi_free_host_cmd_pool(pool);
455 			hostt->cmd_pool = NULL;
456 		}
457 	}
458 	mutex_unlock(&host_cmd_pool_mutex);
459 }
460 
461 /**
462  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
463  * @shost: host to allocate the freelist for.
464  *
465  * Description: The command freelist protects against system-wide out of memory
466  * deadlock by preallocating one SCSI command structure for each host, so the
467  * system can always write to a swap file on a device associated with that host.
468  *
469  * Returns:	Nothing.
470  */
471 int scsi_setup_command_freelist(struct Scsi_Host *shost)
472 {
473 	const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
474 	struct scsi_cmnd *cmd;
475 
476 	spin_lock_init(&shost->free_list_lock);
477 	INIT_LIST_HEAD(&shost->free_list);
478 
479 	shost->cmd_pool = scsi_get_host_cmd_pool(shost);
480 	if (!shost->cmd_pool)
481 		return -ENOMEM;
482 
483 	/*
484 	 * Get one backup command for this host.
485 	 */
486 	cmd = scsi_host_alloc_command(shost, gfp_mask);
487 	if (!cmd) {
488 		scsi_put_host_cmd_pool(shost);
489 		shost->cmd_pool = NULL;
490 		return -ENOMEM;
491 	}
492 	list_add(&cmd->list, &shost->free_list);
493 	return 0;
494 }
495 
496 /**
497  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
498  * @shost: host whose freelist is going to be destroyed
499  */
500 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
501 {
502 	/*
503 	 * If cmd_pool is NULL the free list was not initialized, so
504 	 * do not attempt to release resources.
505 	 */
506 	if (!shost->cmd_pool)
507 		return;
508 
509 	while (!list_empty(&shost->free_list)) {
510 		struct scsi_cmnd *cmd;
511 
512 		cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
513 		list_del_init(&cmd->list);
514 		scsi_host_free_command(shost, cmd);
515 	}
516 	shost->cmd_pool = NULL;
517 	scsi_put_host_cmd_pool(shost);
518 }
519 
520 #ifdef CONFIG_SCSI_LOGGING
521 void scsi_log_send(struct scsi_cmnd *cmd)
522 {
523 	unsigned int level;
524 
525 	/*
526 	 * If ML QUEUE log level is greater than or equal to:
527 	 *
528 	 * 1: nothing (match completion)
529 	 *
530 	 * 2: log opcode + command of all commands + cmd address
531 	 *
532 	 * 3: same as 2
533 	 *
534 	 * 4: same as 3
535 	 */
536 	if (unlikely(scsi_logging_level)) {
537 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
538 				       SCSI_LOG_MLQUEUE_BITS);
539 		if (level > 1) {
540 			scmd_printk(KERN_INFO, cmd,
541 				    "Send: scmd 0x%p\n", cmd);
542 			scsi_print_command(cmd);
543 		}
544 	}
545 }
546 
547 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
548 {
549 	unsigned int level;
550 
551 	/*
552 	 * If ML COMPLETE log level is greater than or equal to:
553 	 *
554 	 * 1: log disposition, result, opcode + command, and conditionally
555 	 * sense data for failures or non SUCCESS dispositions.
556 	 *
557 	 * 2: same as 1 but for all command completions.
558 	 *
559 	 * 3: same as 2
560 	 *
561 	 * 4: same as 3 plus dump extra junk
562 	 */
563 	if (unlikely(scsi_logging_level)) {
564 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
565 				       SCSI_LOG_MLCOMPLETE_BITS);
566 		if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
567 		    (level > 1)) {
568 			scsi_print_result(cmd, "Done", disposition);
569 			scsi_print_command(cmd);
570 			if (status_byte(cmd->result) & CHECK_CONDITION)
571 				scsi_print_sense(cmd);
572 			if (level > 3)
573 				scmd_printk(KERN_INFO, cmd,
574 					    "scsi host busy %d failed %d\n",
575 					    atomic_read(&cmd->device->host->host_busy),
576 					    cmd->device->host->host_failed);
577 		}
578 	}
579 }
580 #endif
581 
582 /**
583  * scsi_cmd_get_serial - Assign a serial number to a command
584  * @host: the scsi host
585  * @cmd: command to assign serial number to
586  *
587  * Description: a serial number identifies a request for error recovery
588  * and debugging purposes.  Protected by the Host_Lock of host.
589  */
590 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
591 {
592 	cmd->serial_number = host->cmd_serial_number++;
593 	if (cmd->serial_number == 0)
594 		cmd->serial_number = host->cmd_serial_number++;
595 }
596 EXPORT_SYMBOL(scsi_cmd_get_serial);
597 
598 /**
599  * scsi_finish_command - cleanup and pass command back to upper layer
600  * @cmd: the command
601  *
602  * Description: Pass command off to upper layer for finishing of I/O
603  *              request, waking processes that are waiting on results,
604  *              etc.
605  */
606 void scsi_finish_command(struct scsi_cmnd *cmd)
607 {
608 	struct scsi_device *sdev = cmd->device;
609 	struct scsi_target *starget = scsi_target(sdev);
610 	struct Scsi_Host *shost = sdev->host;
611 	struct scsi_driver *drv;
612 	unsigned int good_bytes;
613 
614 	scsi_device_unbusy(sdev);
615 
616 	/*
617 	 * Clear the flags that say that the device/target/host is no longer
618 	 * capable of accepting new commands.
619 	 */
620 	if (atomic_read(&shost->host_blocked))
621 		atomic_set(&shost->host_blocked, 0);
622 	if (atomic_read(&starget->target_blocked))
623 		atomic_set(&starget->target_blocked, 0);
624 	if (atomic_read(&sdev->device_blocked))
625 		atomic_set(&sdev->device_blocked, 0);
626 
627 	/*
628 	 * If we have valid sense information, then some kind of recovery
629 	 * must have taken place.  Make a note of this.
630 	 */
631 	if (SCSI_SENSE_VALID(cmd))
632 		cmd->result |= (DRIVER_SENSE << 24);
633 
634 	SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
635 				"Notifying upper driver of completion "
636 				"(result %x)\n", cmd->result));
637 
638 	good_bytes = scsi_bufflen(cmd);
639         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
640 		int old_good_bytes = good_bytes;
641 		drv = scsi_cmd_to_driver(cmd);
642 		if (drv->done)
643 			good_bytes = drv->done(cmd);
644 		/*
645 		 * USB may not give sense identifying bad sector and
646 		 * simply return a residue instead, so subtract off the
647 		 * residue if drv->done() error processing indicates no
648 		 * change to the completion length.
649 		 */
650 		if (good_bytes == old_good_bytes)
651 			good_bytes -= scsi_get_resid(cmd);
652 	}
653 	scsi_io_completion(cmd, good_bytes);
654 }
655 
656 /**
657  * scsi_change_queue_depth - change a device's queue depth
658  * @sdev: SCSI Device in question
659  * @depth: number of commands allowed to be queued to the driver
660  *
661  * Sets the device queue depth and returns the new value.
662  */
663 int scsi_change_queue_depth(struct scsi_device *sdev, int depth)
664 {
665 	unsigned long flags;
666 
667 	if (depth <= 0)
668 		goto out;
669 
670 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
671 
672 	/*
673 	 * Check to see if the queue is managed by the block layer.
674 	 * If it is, and we fail to adjust the depth, exit.
675 	 *
676 	 * Do not resize the tag map if it is a host wide share bqt,
677 	 * because the size should be the hosts's can_queue. If there
678 	 * is more IO than the LLD's can_queue (so there are not enuogh
679 	 * tags) request_fn's host queue ready check will handle it.
680 	 */
681 	if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) {
682 		if (blk_queue_tagged(sdev->request_queue) &&
683 		    blk_queue_resize_tags(sdev->request_queue, depth) != 0)
684 			goto out_unlock;
685 	}
686 
687 	sdev->queue_depth = depth;
688 out_unlock:
689 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
690 out:
691 	return sdev->queue_depth;
692 }
693 EXPORT_SYMBOL(scsi_change_queue_depth);
694 
695 /**
696  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
697  * @sdev: SCSI Device in question
698  * @depth: Current number of outstanding SCSI commands on this device,
699  *         not counting the one returned as QUEUE_FULL.
700  *
701  * Description:	This function will track successive QUEUE_FULL events on a
702  * 		specific SCSI device to determine if and when there is a
703  * 		need to adjust the queue depth on the device.
704  *
705  * Returns:	0 - No change needed, >0 - Adjust queue depth to this new depth,
706  * 		-1 - Drop back to untagged operation using host->cmd_per_lun
707  * 			as the untagged command depth
708  *
709  * Lock Status:	None held on entry
710  *
711  * Notes:	Low level drivers may call this at any time and we will do
712  * 		"The Right Thing."  We are interrupt context safe.
713  */
714 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
715 {
716 
717 	/*
718 	 * Don't let QUEUE_FULLs on the same
719 	 * jiffies count, they could all be from
720 	 * same event.
721 	 */
722 	if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
723 		return 0;
724 
725 	sdev->last_queue_full_time = jiffies;
726 	if (sdev->last_queue_full_depth != depth) {
727 		sdev->last_queue_full_count = 1;
728 		sdev->last_queue_full_depth = depth;
729 	} else {
730 		sdev->last_queue_full_count++;
731 	}
732 
733 	if (sdev->last_queue_full_count <= 10)
734 		return 0;
735 
736 	return scsi_change_queue_depth(sdev, depth);
737 }
738 EXPORT_SYMBOL(scsi_track_queue_full);
739 
740 /**
741  * scsi_vpd_inquiry - Request a device provide us with a VPD page
742  * @sdev: The device to ask
743  * @buffer: Where to put the result
744  * @page: Which Vital Product Data to return
745  * @len: The length of the buffer
746  *
747  * This is an internal helper function.  You probably want to use
748  * scsi_get_vpd_page instead.
749  *
750  * Returns size of the vpd page on success or a negative error number.
751  */
752 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
753 							u8 page, unsigned len)
754 {
755 	int result;
756 	unsigned char cmd[16];
757 
758 	if (len < 4)
759 		return -EINVAL;
760 
761 	cmd[0] = INQUIRY;
762 	cmd[1] = 1;		/* EVPD */
763 	cmd[2] = page;
764 	cmd[3] = len >> 8;
765 	cmd[4] = len & 0xff;
766 	cmd[5] = 0;		/* Control byte */
767 
768 	/*
769 	 * I'm not convinced we need to try quite this hard to get VPD, but
770 	 * all the existing users tried this hard.
771 	 */
772 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
773 				  len, NULL, 30 * HZ, 3, NULL);
774 	if (result)
775 		return -EIO;
776 
777 	/* Sanity check that we got the page back that we asked for */
778 	if (buffer[1] != page)
779 		return -EIO;
780 
781 	return get_unaligned_be16(&buffer[2]) + 4;
782 }
783 
784 /**
785  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
786  * @sdev: The device to ask
787  * @page: Which Vital Product Data to return
788  * @buf: where to store the VPD
789  * @buf_len: number of bytes in the VPD buffer area
790  *
791  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
792  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
793  * If the device supports this VPD page, this routine returns a pointer
794  * to a buffer containing the data from that page.  The caller is
795  * responsible for calling kfree() on this pointer when it is no longer
796  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
797  */
798 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
799 		      int buf_len)
800 {
801 	int i, result;
802 
803 	if (sdev->skip_vpd_pages)
804 		goto fail;
805 
806 	/* Ask for all the pages supported by this device */
807 	result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
808 	if (result < 4)
809 		goto fail;
810 
811 	/* If the user actually wanted this page, we can skip the rest */
812 	if (page == 0)
813 		return 0;
814 
815 	for (i = 4; i < min(result, buf_len); i++)
816 		if (buf[i] == page)
817 			goto found;
818 
819 	if (i < result && i >= buf_len)
820 		/* ran off the end of the buffer, give us benefit of doubt */
821 		goto found;
822 	/* The device claims it doesn't support the requested page */
823 	goto fail;
824 
825  found:
826 	result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
827 	if (result < 0)
828 		goto fail;
829 
830 	return 0;
831 
832  fail:
833 	return -EINVAL;
834 }
835 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
836 
837 /**
838  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
839  * @sdev: The device to ask
840  *
841  * Attach the 'Device Identification' VPD page (0x83) and the
842  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
843  * structure. This information can be used to identify the device
844  * uniquely.
845  */
846 void scsi_attach_vpd(struct scsi_device *sdev)
847 {
848 	int result, i;
849 	int vpd_len = SCSI_VPD_PG_LEN;
850 	int pg80_supported = 0;
851 	int pg83_supported = 0;
852 	unsigned char *vpd_buf;
853 
854 	if (sdev->skip_vpd_pages)
855 		return;
856 retry_pg0:
857 	vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
858 	if (!vpd_buf)
859 		return;
860 
861 	/* Ask for all the pages supported by this device */
862 	result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len);
863 	if (result < 0) {
864 		kfree(vpd_buf);
865 		return;
866 	}
867 	if (result > vpd_len) {
868 		vpd_len = result;
869 		kfree(vpd_buf);
870 		goto retry_pg0;
871 	}
872 
873 	for (i = 4; i < result; i++) {
874 		if (vpd_buf[i] == 0x80)
875 			pg80_supported = 1;
876 		if (vpd_buf[i] == 0x83)
877 			pg83_supported = 1;
878 	}
879 	kfree(vpd_buf);
880 	vpd_len = SCSI_VPD_PG_LEN;
881 
882 	if (pg80_supported) {
883 retry_pg80:
884 		vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
885 		if (!vpd_buf)
886 			return;
887 
888 		result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len);
889 		if (result < 0) {
890 			kfree(vpd_buf);
891 			return;
892 		}
893 		if (result > vpd_len) {
894 			vpd_len = result;
895 			kfree(vpd_buf);
896 			goto retry_pg80;
897 		}
898 		sdev->vpd_pg80_len = result;
899 		sdev->vpd_pg80 = vpd_buf;
900 		vpd_len = SCSI_VPD_PG_LEN;
901 	}
902 
903 	if (pg83_supported) {
904 retry_pg83:
905 		vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
906 		if (!vpd_buf)
907 			return;
908 
909 		result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len);
910 		if (result < 0) {
911 			kfree(vpd_buf);
912 			return;
913 		}
914 		if (result > vpd_len) {
915 			vpd_len = result;
916 			kfree(vpd_buf);
917 			goto retry_pg83;
918 		}
919 		sdev->vpd_pg83_len = result;
920 		sdev->vpd_pg83 = vpd_buf;
921 	}
922 }
923 
924 /**
925  * scsi_report_opcode - Find out if a given command opcode is supported
926  * @sdev:	scsi device to query
927  * @buffer:	scratch buffer (must be at least 20 bytes long)
928  * @len:	length of buffer
929  * @opcode:	opcode for command to look up
930  *
931  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
932  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
933  * unsupported and 1 if the device claims to support the command.
934  */
935 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
936 		       unsigned int len, unsigned char opcode)
937 {
938 	unsigned char cmd[16];
939 	struct scsi_sense_hdr sshdr;
940 	int result;
941 
942 	if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
943 		return -EINVAL;
944 
945 	memset(cmd, 0, 16);
946 	cmd[0] = MAINTENANCE_IN;
947 	cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
948 	cmd[2] = 1;		/* One command format */
949 	cmd[3] = opcode;
950 	put_unaligned_be32(len, &cmd[6]);
951 	memset(buffer, 0, len);
952 
953 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
954 				  &sshdr, 30 * HZ, 3, NULL);
955 
956 	if (result && scsi_sense_valid(&sshdr) &&
957 	    sshdr.sense_key == ILLEGAL_REQUEST &&
958 	    (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
959 		return -EINVAL;
960 
961 	if ((buffer[1] & 3) == 3) /* Command supported */
962 		return 1;
963 
964 	return 0;
965 }
966 EXPORT_SYMBOL(scsi_report_opcode);
967 
968 /**
969  * scsi_device_get  -  get an additional reference to a scsi_device
970  * @sdev:	device to get a reference to
971  *
972  * Description: Gets a reference to the scsi_device and increments the use count
973  * of the underlying LLDD module.  You must hold host_lock of the
974  * parent Scsi_Host or already have a reference when calling this.
975  */
976 int scsi_device_get(struct scsi_device *sdev)
977 {
978 	if (sdev->sdev_state == SDEV_DEL)
979 		return -ENXIO;
980 	if (!get_device(&sdev->sdev_gendev))
981 		return -ENXIO;
982 	/* We can fail try_module_get if we're doing SCSI operations
983 	 * from module exit (like cache flush) */
984 	__module_get(sdev->host->hostt->module);
985 
986 	return 0;
987 }
988 EXPORT_SYMBOL(scsi_device_get);
989 
990 /**
991  * scsi_device_put  -  release a reference to a scsi_device
992  * @sdev:	device to release a reference on.
993  *
994  * Description: Release a reference to the scsi_device and decrements the use
995  * count of the underlying LLDD module.  The device is freed once the last
996  * user vanishes.
997  */
998 void scsi_device_put(struct scsi_device *sdev)
999 {
1000 	module_put(sdev->host->hostt->module);
1001 	put_device(&sdev->sdev_gendev);
1002 }
1003 EXPORT_SYMBOL(scsi_device_put);
1004 
1005 /* helper for shost_for_each_device, see that for documentation */
1006 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1007 					   struct scsi_device *prev)
1008 {
1009 	struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1010 	struct scsi_device *next = NULL;
1011 	unsigned long flags;
1012 
1013 	spin_lock_irqsave(shost->host_lock, flags);
1014 	while (list->next != &shost->__devices) {
1015 		next = list_entry(list->next, struct scsi_device, siblings);
1016 		/* skip devices that we can't get a reference to */
1017 		if (!scsi_device_get(next))
1018 			break;
1019 		next = NULL;
1020 		list = list->next;
1021 	}
1022 	spin_unlock_irqrestore(shost->host_lock, flags);
1023 
1024 	if (prev)
1025 		scsi_device_put(prev);
1026 	return next;
1027 }
1028 EXPORT_SYMBOL(__scsi_iterate_devices);
1029 
1030 /**
1031  * starget_for_each_device  -  helper to walk all devices of a target
1032  * @starget:	target whose devices we want to iterate over.
1033  * @data:	Opaque passed to each function call.
1034  * @fn:		Function to call on each device
1035  *
1036  * This traverses over each device of @starget.  The devices have
1037  * a reference that must be released by scsi_host_put when breaking
1038  * out of the loop.
1039  */
1040 void starget_for_each_device(struct scsi_target *starget, void *data,
1041 		     void (*fn)(struct scsi_device *, void *))
1042 {
1043 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1044 	struct scsi_device *sdev;
1045 
1046 	shost_for_each_device(sdev, shost) {
1047 		if ((sdev->channel == starget->channel) &&
1048 		    (sdev->id == starget->id))
1049 			fn(sdev, data);
1050 	}
1051 }
1052 EXPORT_SYMBOL(starget_for_each_device);
1053 
1054 /**
1055  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1056  * @starget:	target whose devices we want to iterate over.
1057  * @data:	parameter for callback @fn()
1058  * @fn:		callback function that is invoked for each device
1059  *
1060  * This traverses over each device of @starget.  It does _not_
1061  * take a reference on the scsi_device, so the whole loop must be
1062  * protected by shost->host_lock.
1063  *
1064  * Note:  The only reason why drivers would want to use this is because
1065  * they need to access the device list in irq context.  Otherwise you
1066  * really want to use starget_for_each_device instead.
1067  **/
1068 void __starget_for_each_device(struct scsi_target *starget, void *data,
1069 			       void (*fn)(struct scsi_device *, void *))
1070 {
1071 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1072 	struct scsi_device *sdev;
1073 
1074 	__shost_for_each_device(sdev, shost) {
1075 		if ((sdev->channel == starget->channel) &&
1076 		    (sdev->id == starget->id))
1077 			fn(sdev, data);
1078 	}
1079 }
1080 EXPORT_SYMBOL(__starget_for_each_device);
1081 
1082 /**
1083  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1084  * @starget:	SCSI target pointer
1085  * @lun:	SCSI Logical Unit Number
1086  *
1087  * Description: Looks up the scsi_device with the specified @lun for a given
1088  * @starget.  The returned scsi_device does not have an additional
1089  * reference.  You must hold the host's host_lock over this call and
1090  * any access to the returned scsi_device. A scsi_device in state
1091  * SDEV_DEL is skipped.
1092  *
1093  * Note:  The only reason why drivers should use this is because
1094  * they need to access the device list in irq context.  Otherwise you
1095  * really want to use scsi_device_lookup_by_target instead.
1096  **/
1097 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1098 						   u64 lun)
1099 {
1100 	struct scsi_device *sdev;
1101 
1102 	list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1103 		if (sdev->sdev_state == SDEV_DEL)
1104 			continue;
1105 		if (sdev->lun ==lun)
1106 			return sdev;
1107 	}
1108 
1109 	return NULL;
1110 }
1111 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1112 
1113 /**
1114  * scsi_device_lookup_by_target - find a device given the target
1115  * @starget:	SCSI target pointer
1116  * @lun:	SCSI Logical Unit Number
1117  *
1118  * Description: Looks up the scsi_device with the specified @lun for a given
1119  * @starget.  The returned scsi_device has an additional reference that
1120  * needs to be released with scsi_device_put once you're done with it.
1121  **/
1122 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1123 						 u64 lun)
1124 {
1125 	struct scsi_device *sdev;
1126 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1127 	unsigned long flags;
1128 
1129 	spin_lock_irqsave(shost->host_lock, flags);
1130 	sdev = __scsi_device_lookup_by_target(starget, lun);
1131 	if (sdev && scsi_device_get(sdev))
1132 		sdev = NULL;
1133 	spin_unlock_irqrestore(shost->host_lock, flags);
1134 
1135 	return sdev;
1136 }
1137 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1138 
1139 /**
1140  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1141  * @shost:	SCSI host pointer
1142  * @channel:	SCSI channel (zero if only one channel)
1143  * @id:		SCSI target number (physical unit number)
1144  * @lun:	SCSI Logical Unit Number
1145  *
1146  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1147  * for a given host. The returned scsi_device does not have an additional
1148  * reference.  You must hold the host's host_lock over this call and any access
1149  * to the returned scsi_device.
1150  *
1151  * Note:  The only reason why drivers would want to use this is because
1152  * they need to access the device list in irq context.  Otherwise you
1153  * really want to use scsi_device_lookup instead.
1154  **/
1155 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1156 		uint channel, uint id, u64 lun)
1157 {
1158 	struct scsi_device *sdev;
1159 
1160 	list_for_each_entry(sdev, &shost->__devices, siblings) {
1161 		if (sdev->channel == channel && sdev->id == id &&
1162 				sdev->lun ==lun)
1163 			return sdev;
1164 	}
1165 
1166 	return NULL;
1167 }
1168 EXPORT_SYMBOL(__scsi_device_lookup);
1169 
1170 /**
1171  * scsi_device_lookup - find a device given the host
1172  * @shost:	SCSI host pointer
1173  * @channel:	SCSI channel (zero if only one channel)
1174  * @id:		SCSI target number (physical unit number)
1175  * @lun:	SCSI Logical Unit Number
1176  *
1177  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1178  * for a given host.  The returned scsi_device has an additional reference that
1179  * needs to be released with scsi_device_put once you're done with it.
1180  **/
1181 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1182 		uint channel, uint id, u64 lun)
1183 {
1184 	struct scsi_device *sdev;
1185 	unsigned long flags;
1186 
1187 	spin_lock_irqsave(shost->host_lock, flags);
1188 	sdev = __scsi_device_lookup(shost, channel, id, lun);
1189 	if (sdev && scsi_device_get(sdev))
1190 		sdev = NULL;
1191 	spin_unlock_irqrestore(shost->host_lock, flags);
1192 
1193 	return sdev;
1194 }
1195 EXPORT_SYMBOL(scsi_device_lookup);
1196 
1197 MODULE_DESCRIPTION("SCSI core");
1198 MODULE_LICENSE("GPL");
1199 
1200 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1201 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1202 
1203 #ifdef CONFIG_SCSI_MQ_DEFAULT
1204 bool scsi_use_blk_mq = true;
1205 #else
1206 bool scsi_use_blk_mq = false;
1207 #endif
1208 module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO);
1209 
1210 static int __init init_scsi(void)
1211 {
1212 	int error;
1213 
1214 	error = scsi_init_queue();
1215 	if (error)
1216 		return error;
1217 	error = scsi_init_procfs();
1218 	if (error)
1219 		goto cleanup_queue;
1220 	error = scsi_init_devinfo();
1221 	if (error)
1222 		goto cleanup_procfs;
1223 	error = scsi_init_hosts();
1224 	if (error)
1225 		goto cleanup_devlist;
1226 	error = scsi_init_sysctl();
1227 	if (error)
1228 		goto cleanup_hosts;
1229 	error = scsi_sysfs_register();
1230 	if (error)
1231 		goto cleanup_sysctl;
1232 
1233 	scsi_netlink_init();
1234 
1235 	printk(KERN_NOTICE "SCSI subsystem initialized\n");
1236 	return 0;
1237 
1238 cleanup_sysctl:
1239 	scsi_exit_sysctl();
1240 cleanup_hosts:
1241 	scsi_exit_hosts();
1242 cleanup_devlist:
1243 	scsi_exit_devinfo();
1244 cleanup_procfs:
1245 	scsi_exit_procfs();
1246 cleanup_queue:
1247 	scsi_exit_queue();
1248 	printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1249 	       -error);
1250 	return error;
1251 }
1252 
1253 static void __exit exit_scsi(void)
1254 {
1255 	scsi_netlink_exit();
1256 	scsi_sysfs_unregister();
1257 	scsi_exit_sysctl();
1258 	scsi_exit_hosts();
1259 	scsi_exit_devinfo();
1260 	scsi_exit_procfs();
1261 	scsi_exit_queue();
1262 	async_unregister_domain(&scsi_sd_probe_domain);
1263 }
1264 
1265 subsys_initcall(init_scsi);
1266 module_exit(exit_scsi);
1267