1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include <linux/module.h>
42#include <linux/moduleparam.h>
43#include <linux/kernel.h>
44#include <linux/timer.h>
45#include <linux/string.h>
46#include <linux/slab.h>
47#include <linux/blkdev.h>
48#include <linux/delay.h>
49#include <linux/init.h>
50#include <linux/completion.h>
51#include <linux/unistd.h>
52#include <linux/spinlock.h>
53#include <linux/kmod.h>
54#include <linux/interrupt.h>
55#include <linux/notifier.h>
56#include <linux/cpu.h>
57#include <linux/mutex.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
77
78
79
80
81
82
83unsigned int scsi_logging_level;
84#if defined(CONFIG_SCSI_LOGGING)
85EXPORT_SYMBOL(scsi_logging_level);
86#endif
87
88#ifdef CONFIG_SCSI_LOGGING
89void scsi_log_send(struct scsi_cmnd *cmd)
90{
91 unsigned int level;
92
93
94
95
96
97
98
99
100
101
102
103
104 if (unlikely(scsi_logging_level)) {
105 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
106 SCSI_LOG_MLQUEUE_BITS);
107 if (level > 1) {
108 scmd_printk(KERN_INFO, cmd,
109 "Send: scmd 0x%p\n", cmd);
110 scsi_print_command(cmd);
111 }
112 }
113}
114
115void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
116{
117 unsigned int level;
118
119
120
121
122
123
124
125
126
127
128
129
130
131 if (unlikely(scsi_logging_level)) {
132 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
133 SCSI_LOG_MLCOMPLETE_BITS);
134 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
135 (level > 1)) {
136 scsi_print_result(cmd, "Done", disposition);
137 scsi_print_command(cmd);
138 if (scsi_status_is_check_condition(cmd->result))
139 scsi_print_sense(cmd);
140 if (level > 3)
141 scmd_printk(KERN_INFO, cmd,
142 "scsi host busy %d failed %d\n",
143 scsi_host_busy(cmd->device->host),
144 cmd->device->host->host_failed);
145 }
146 }
147}
148#endif
149
150
151
152
153
154
155
156
157
158void scsi_finish_command(struct scsi_cmnd *cmd)
159{
160 struct scsi_device *sdev = cmd->device;
161 struct scsi_target *starget = scsi_target(sdev);
162 struct Scsi_Host *shost = sdev->host;
163 struct scsi_driver *drv;
164 unsigned int good_bytes;
165
166 scsi_device_unbusy(sdev, cmd);
167
168
169
170
171
172 if (atomic_read(&shost->host_blocked))
173 atomic_set(&shost->host_blocked, 0);
174 if (atomic_read(&starget->target_blocked))
175 atomic_set(&starget->target_blocked, 0);
176 if (atomic_read(&sdev->device_blocked))
177 atomic_set(&sdev->device_blocked, 0);
178
179 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
180 "Notifying upper driver of completion "
181 "(result %x)\n", cmd->result));
182
183 good_bytes = scsi_bufflen(cmd);
184 if (!blk_rq_is_passthrough(scsi_cmd_to_rq(cmd))) {
185 int old_good_bytes = good_bytes;
186 drv = scsi_cmd_to_driver(cmd);
187 if (drv->done)
188 good_bytes = drv->done(cmd);
189
190
191
192
193
194
195 if (good_bytes == old_good_bytes)
196 good_bytes -= scsi_get_resid(cmd);
197 }
198 scsi_io_completion(cmd, good_bytes);
199}
200
201
202
203
204
205int scsi_device_max_queue_depth(struct scsi_device *sdev)
206{
207 return min_t(int, sdev->host->can_queue, 1024);
208}
209
210
211
212
213
214
215
216
217int scsi_change_queue_depth(struct scsi_device *sdev, int depth)
218{
219 depth = min_t(int, depth, scsi_device_max_queue_depth(sdev));
220
221 if (depth > 0) {
222 sdev->queue_depth = depth;
223 wmb();
224 }
225
226 if (sdev->request_queue)
227 blk_set_queue_depth(sdev->request_queue, depth);
228
229 sbitmap_resize(&sdev->budget_map, sdev->queue_depth);
230
231 return sdev->queue_depth;
232}
233EXPORT_SYMBOL(scsi_change_queue_depth);
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254int scsi_track_queue_full(struct scsi_device *sdev, int depth)
255{
256
257
258
259
260
261
262 if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
263 return 0;
264
265 sdev->last_queue_full_time = jiffies;
266 if (sdev->last_queue_full_depth != depth) {
267 sdev->last_queue_full_count = 1;
268 sdev->last_queue_full_depth = depth;
269 } else {
270 sdev->last_queue_full_count++;
271 }
272
273 if (sdev->last_queue_full_count <= 10)
274 return 0;
275
276 return scsi_change_queue_depth(sdev, depth);
277}
278EXPORT_SYMBOL(scsi_track_queue_full);
279
280
281
282
283
284
285
286
287
288
289
290
291
292static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
293 u8 page, unsigned len)
294{
295 int result;
296 unsigned char cmd[16];
297
298 if (len < 4)
299 return -EINVAL;
300
301 cmd[0] = INQUIRY;
302 cmd[1] = 1;
303 cmd[2] = page;
304 cmd[3] = len >> 8;
305 cmd[4] = len & 0xff;
306 cmd[5] = 0;
307
308
309
310
311
312 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
313 len, NULL, 30 * HZ, 3, NULL);
314 if (result)
315 return -EIO;
316
317
318 if (buffer[1] != page)
319 return -EIO;
320
321 return get_unaligned_be16(&buffer[2]) + 4;
322}
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
339 int buf_len)
340{
341 int i, result;
342
343 if (sdev->skip_vpd_pages)
344 goto fail;
345
346
347 result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
348 if (result < 4)
349 goto fail;
350
351
352 if (page == 0)
353 return 0;
354
355 for (i = 4; i < min(result, buf_len); i++)
356 if (buf[i] == page)
357 goto found;
358
359 if (i < result && i >= buf_len)
360
361 goto found;
362
363 goto fail;
364
365 found:
366 result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
367 if (result < 0)
368 goto fail;
369
370 return 0;
371
372 fail:
373 return -EINVAL;
374}
375EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
376
377
378
379
380
381
382
383
384static struct scsi_vpd *scsi_get_vpd_buf(struct scsi_device *sdev, u8 page)
385{
386 struct scsi_vpd *vpd_buf;
387 int vpd_len = SCSI_VPD_PG_LEN, result;
388
389retry_pg:
390 vpd_buf = kmalloc(sizeof(*vpd_buf) + vpd_len, GFP_KERNEL);
391 if (!vpd_buf)
392 return NULL;
393
394 result = scsi_vpd_inquiry(sdev, vpd_buf->data, page, vpd_len);
395 if (result < 0) {
396 kfree(vpd_buf);
397 return NULL;
398 }
399 if (result > vpd_len) {
400 vpd_len = result;
401 kfree(vpd_buf);
402 goto retry_pg;
403 }
404
405 vpd_buf->len = result;
406
407 return vpd_buf;
408}
409
410static void scsi_update_vpd_page(struct scsi_device *sdev, u8 page,
411 struct scsi_vpd __rcu **sdev_vpd_buf)
412{
413 struct scsi_vpd *vpd_buf;
414
415 vpd_buf = scsi_get_vpd_buf(sdev, page);
416 if (!vpd_buf)
417 return;
418
419 mutex_lock(&sdev->inquiry_mutex);
420 vpd_buf = rcu_replace_pointer(*sdev_vpd_buf, vpd_buf,
421 lockdep_is_held(&sdev->inquiry_mutex));
422 mutex_unlock(&sdev->inquiry_mutex);
423
424 if (vpd_buf)
425 kfree_rcu(vpd_buf, rcu);
426}
427
428
429
430
431
432
433
434
435
436
437void scsi_attach_vpd(struct scsi_device *sdev)
438{
439 int i;
440 struct scsi_vpd *vpd_buf;
441
442 if (!scsi_device_supports_vpd(sdev))
443 return;
444
445
446 vpd_buf = scsi_get_vpd_buf(sdev, 0);
447 if (!vpd_buf)
448 return;
449
450 for (i = 4; i < vpd_buf->len; i++) {
451 if (vpd_buf->data[i] == 0x0)
452 scsi_update_vpd_page(sdev, 0x0, &sdev->vpd_pg0);
453 if (vpd_buf->data[i] == 0x80)
454 scsi_update_vpd_page(sdev, 0x80, &sdev->vpd_pg80);
455 if (vpd_buf->data[i] == 0x83)
456 scsi_update_vpd_page(sdev, 0x83, &sdev->vpd_pg83);
457 if (vpd_buf->data[i] == 0x89)
458 scsi_update_vpd_page(sdev, 0x89, &sdev->vpd_pg89);
459 }
460 kfree(vpd_buf);
461}
462
463
464
465
466
467
468
469
470
471
472
473
474int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
475 unsigned int len, unsigned char opcode)
476{
477 unsigned char cmd[16];
478 struct scsi_sense_hdr sshdr;
479 int result;
480
481 if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
482 return -EINVAL;
483
484 memset(cmd, 0, 16);
485 cmd[0] = MAINTENANCE_IN;
486 cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
487 cmd[2] = 1;
488 cmd[3] = opcode;
489 put_unaligned_be32(len, &cmd[6]);
490 memset(buffer, 0, len);
491
492 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
493 &sshdr, 30 * HZ, 3, NULL);
494
495 if (result < 0)
496 return result;
497 if (result && scsi_sense_valid(&sshdr) &&
498 sshdr.sense_key == ILLEGAL_REQUEST &&
499 (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
500 return -EINVAL;
501
502 if ((buffer[1] & 3) == 3)
503 return 1;
504
505 return 0;
506}
507EXPORT_SYMBOL(scsi_report_opcode);
508
509
510
511
512
513
514
515
516
517
518
519
520int scsi_device_get(struct scsi_device *sdev)
521{
522 if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL)
523 goto fail;
524 if (!get_device(&sdev->sdev_gendev))
525 goto fail;
526 if (!try_module_get(sdev->host->hostt->module))
527 goto fail_put_device;
528 return 0;
529
530fail_put_device:
531 put_device(&sdev->sdev_gendev);
532fail:
533 return -ENXIO;
534}
535EXPORT_SYMBOL(scsi_device_get);
536
537
538
539
540
541
542
543
544
545void scsi_device_put(struct scsi_device *sdev)
546{
547 struct module *mod = sdev->host->hostt->module;
548
549 put_device(&sdev->sdev_gendev);
550 module_put(mod);
551}
552EXPORT_SYMBOL(scsi_device_put);
553
554
555struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
556 struct scsi_device *prev)
557{
558 struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
559 struct scsi_device *next = NULL;
560 unsigned long flags;
561
562 spin_lock_irqsave(shost->host_lock, flags);
563 while (list->next != &shost->__devices) {
564 next = list_entry(list->next, struct scsi_device, siblings);
565
566 if (!scsi_device_get(next))
567 break;
568 next = NULL;
569 list = list->next;
570 }
571 spin_unlock_irqrestore(shost->host_lock, flags);
572
573 if (prev)
574 scsi_device_put(prev);
575 return next;
576}
577EXPORT_SYMBOL(__scsi_iterate_devices);
578
579
580
581
582
583
584
585
586
587
588
589void starget_for_each_device(struct scsi_target *starget, void *data,
590 void (*fn)(struct scsi_device *, void *))
591{
592 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
593 struct scsi_device *sdev;
594
595 shost_for_each_device(sdev, shost) {
596 if ((sdev->channel == starget->channel) &&
597 (sdev->id == starget->id))
598 fn(sdev, data);
599 }
600}
601EXPORT_SYMBOL(starget_for_each_device);
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617void __starget_for_each_device(struct scsi_target *starget, void *data,
618 void (*fn)(struct scsi_device *, void *))
619{
620 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
621 struct scsi_device *sdev;
622
623 __shost_for_each_device(sdev, shost) {
624 if ((sdev->channel == starget->channel) &&
625 (sdev->id == starget->id))
626 fn(sdev, data);
627 }
628}
629EXPORT_SYMBOL(__starget_for_each_device);
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
647 u64 lun)
648{
649 struct scsi_device *sdev;
650
651 list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
652 if (sdev->sdev_state == SDEV_DEL)
653 continue;
654 if (sdev->lun ==lun)
655 return sdev;
656 }
657
658 return NULL;
659}
660EXPORT_SYMBOL(__scsi_device_lookup_by_target);
661
662
663
664
665
666
667
668
669
670
671struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
672 u64 lun)
673{
674 struct scsi_device *sdev;
675 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
676 unsigned long flags;
677
678 spin_lock_irqsave(shost->host_lock, flags);
679 sdev = __scsi_device_lookup_by_target(starget, lun);
680 if (sdev && scsi_device_get(sdev))
681 sdev = NULL;
682 spin_unlock_irqrestore(shost->host_lock, flags);
683
684 return sdev;
685}
686EXPORT_SYMBOL(scsi_device_lookup_by_target);
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
705 uint channel, uint id, u64 lun)
706{
707 struct scsi_device *sdev;
708
709 list_for_each_entry(sdev, &shost->__devices, siblings) {
710 if (sdev->sdev_state == SDEV_DEL)
711 continue;
712 if (sdev->channel == channel && sdev->id == id &&
713 sdev->lun ==lun)
714 return sdev;
715 }
716
717 return NULL;
718}
719EXPORT_SYMBOL(__scsi_device_lookup);
720
721
722
723
724
725
726
727
728
729
730
731
732struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
733 uint channel, uint id, u64 lun)
734{
735 struct scsi_device *sdev;
736 unsigned long flags;
737
738 spin_lock_irqsave(shost->host_lock, flags);
739 sdev = __scsi_device_lookup(shost, channel, id, lun);
740 if (sdev && scsi_device_get(sdev))
741 sdev = NULL;
742 spin_unlock_irqrestore(shost->host_lock, flags);
743
744 return sdev;
745}
746EXPORT_SYMBOL(scsi_device_lookup);
747
748MODULE_DESCRIPTION("SCSI core");
749MODULE_LICENSE("GPL");
750
751module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
752MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
753
754static int __init init_scsi(void)
755{
756 int error;
757
758 error = scsi_init_procfs();
759 if (error)
760 goto cleanup_queue;
761 error = scsi_init_devinfo();
762 if (error)
763 goto cleanup_procfs;
764 error = scsi_init_hosts();
765 if (error)
766 goto cleanup_devlist;
767 error = scsi_init_sysctl();
768 if (error)
769 goto cleanup_hosts;
770 error = scsi_sysfs_register();
771 if (error)
772 goto cleanup_sysctl;
773
774 scsi_netlink_init();
775
776 printk(KERN_NOTICE "SCSI subsystem initialized\n");
777 return 0;
778
779cleanup_sysctl:
780 scsi_exit_sysctl();
781cleanup_hosts:
782 scsi_exit_hosts();
783cleanup_devlist:
784 scsi_exit_devinfo();
785cleanup_procfs:
786 scsi_exit_procfs();
787cleanup_queue:
788 scsi_exit_queue();
789 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
790 -error);
791 return error;
792}
793
794static void __exit exit_scsi(void)
795{
796 scsi_netlink_exit();
797 scsi_sysfs_unregister();
798 scsi_exit_sysctl();
799 scsi_exit_hosts();
800 scsi_exit_devinfo();
801 scsi_exit_procfs();
802 scsi_exit_queue();
803}
804
805subsys_initcall(init_scsi);
806module_exit(exit_scsi);
807