1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | #include <linux/blkdev.h> |
4 | #include <linux/init.h> |
5 | #include <linux/kernel.h> |
6 | #include <linux/module.h> |
7 | #include <linux/moduleparam.h> |
8 | #include <linux/proc_fs.h> |
9 | #include <linux/seq_file.h> |
10 | #include <linux/slab.h> |
11 | |
12 | #include <scsi/scsi_device.h> |
13 | #include <scsi/scsi_devinfo.h> |
14 | |
15 | #include "scsi_priv.h" |
16 | |
17 | |
18 | /* |
19 | * scsi_dev_info_list: structure to hold black/white listed devices. |
20 | */ |
21 | struct scsi_dev_info_list { |
22 | struct list_head dev_info_list; |
23 | char vendor[8]; |
24 | char model[16]; |
25 | blist_flags_t flags; |
26 | unsigned compatible; /* for use with scsi_static_device_list entries */ |
27 | }; |
28 | |
29 | struct scsi_dev_info_list_table { |
30 | struct list_head node; /* our node for being on the master list */ |
31 | struct list_head scsi_dev_info_list; /* head of dev info list */ |
32 | const char *name; /* name of list for /proc (NULL for global) */ |
33 | int key; /* unique numeric identifier */ |
34 | }; |
35 | |
36 | |
37 | static blist_flags_t scsi_default_dev_flags; |
38 | static LIST_HEAD(scsi_dev_info_list); |
39 | static char scsi_dev_flags[256]; |
40 | |
41 | /* |
42 | * scsi_static_device_list: deprecated list of devices that require |
43 | * settings that differ from the default, includes black-listed (broken) |
44 | * devices. The entries here are added to the tail of scsi_dev_info_list |
45 | * via scsi_dev_info_list_init. |
46 | * |
47 | * Do not add to this list, use the command line or proc interface to add |
48 | * to the scsi_dev_info_list. This table will eventually go away. |
49 | */ |
50 | static struct { |
51 | char *vendor; |
52 | char *model; |
53 | char *revision; /* revision known to be bad, unused */ |
54 | blist_flags_t flags; |
55 | } scsi_static_device_list[] __initdata = { |
56 | /* |
57 | * The following devices are known not to tolerate a lun != 0 scan |
58 | * for one reason or another. Some will respond to all luns, |
59 | * others will lock up. |
60 | */ |
61 | {"Aashima" , "IMAGERY 2400SP" , "1.03" , BLIST_NOLUN}, /* locks up */ |
62 | {"CHINON" , "CD-ROM CDS-431" , "H42" , BLIST_NOLUN}, /* locks up */ |
63 | {"CHINON" , "CD-ROM CDS-535" , "Q14" , BLIST_NOLUN}, /* locks up */ |
64 | {"DENON" , "DRD-25X" , "V" , BLIST_NOLUN}, /* locks up */ |
65 | {"HITACHI" , "DK312C" , "CM81" , BLIST_NOLUN}, /* responds to all lun */ |
66 | {"HITACHI" , "DK314C" , "CR21" , BLIST_NOLUN}, /* responds to all lun */ |
67 | {"IBM" , "2104-DU3" , NULL, BLIST_NOLUN}, /* locks up */ |
68 | {"IBM" , "2104-TU3" , NULL, BLIST_NOLUN}, /* locks up */ |
69 | {"IMS" , "CDD521/10" , "2.06" , BLIST_NOLUN}, /* locks up */ |
70 | {"MAXTOR" , "XT-3280" , "PR02" , BLIST_NOLUN}, /* locks up */ |
71 | {"MAXTOR" , "XT-4380S" , "B3C" , BLIST_NOLUN}, /* locks up */ |
72 | {"MAXTOR" , "MXT-1240S" , "I1.2" , BLIST_NOLUN}, /* locks up */ |
73 | {"MAXTOR" , "XT-4170S" , "B5A" , BLIST_NOLUN}, /* locks up */ |
74 | {"MAXTOR" , "XT-8760S" , "B7B" , BLIST_NOLUN}, /* locks up */ |
75 | {"MEDIAVIS" , "RENO CD-ROMX2A" , "2.03" , BLIST_NOLUN}, /* responds to all lun */ |
76 | {"MICROTEK" , "ScanMakerIII" , "2.30" , BLIST_NOLUN}, /* responds to all lun */ |
77 | {"NEC" , "CD-ROM DRIVE:841" , "1.0" , BLIST_NOLUN},/* locks up */ |
78 | {"PHILIPS" , "PCA80SC" , "V4-2" , BLIST_NOLUN}, /* responds to all lun */ |
79 | {"RODIME" , "RO3000S" , "2.33" , BLIST_NOLUN}, /* locks up */ |
80 | {"SUN" , "SENA" , NULL, BLIST_NOLUN}, /* responds to all luns */ |
81 | /* |
82 | * The following causes a failed REQUEST SENSE on lun 1 for |
83 | * aha152x controller, which causes SCSI code to reset bus. |
84 | */ |
85 | {"SANYO" , "CRD-250S" , "1.20" , BLIST_NOLUN}, |
86 | /* |
87 | * The following causes a failed REQUEST SENSE on lun 1 for |
88 | * aha152x controller, which causes SCSI code to reset bus. |
89 | */ |
90 | {"SEAGATE" , "ST157N" , "\004|j" , BLIST_NOLUN}, |
91 | {"SEAGATE" , "ST296" , "921" , BLIST_NOLUN}, /* responds to all lun */ |
92 | {"SEAGATE" , "ST1581" , "6538" , BLIST_NOLUN}, /* responds to all lun */ |
93 | {"SONY" , "CD-ROM CDU-541" , "4.3d" , BLIST_NOLUN}, |
94 | {"SONY" , "CD-ROM CDU-55S" , "1.0i" , BLIST_NOLUN}, |
95 | {"SONY" , "CD-ROM CDU-561" , "1.7x" , BLIST_NOLUN}, |
96 | {"SONY" , "CD-ROM CDU-8012" , NULL, BLIST_NOLUN}, |
97 | {"SONY" , "SDT-5000" , "3.17" , BLIST_SELECT_NO_ATN}, |
98 | {"TANDBERG" , "TDC 3600" , "U07" , BLIST_NOLUN}, /* locks up */ |
99 | {"TEAC" , "CD-R55S" , "1.0H" , BLIST_NOLUN}, /* locks up */ |
100 | /* |
101 | * The following causes a failed REQUEST SENSE on lun 1 for |
102 | * seagate controller, which causes SCSI code to reset bus. |
103 | */ |
104 | {"TEAC" , "CD-ROM" , "1.06" , BLIST_NOLUN}, |
105 | {"TEAC" , "MT-2ST/45S2-27" , "RV M" , BLIST_NOLUN}, /* responds to all lun */ |
106 | /* |
107 | * The following causes a failed REQUEST SENSE on lun 1 for |
108 | * seagate controller, which causes SCSI code to reset bus. |
109 | */ |
110 | {"HP" , "C1750A" , "3226" , BLIST_NOLUN}, /* scanjet iic */ |
111 | {"HP" , "C1790A" , NULL, BLIST_NOLUN}, /* scanjet iip */ |
112 | {"HP" , "C2500A" , NULL, BLIST_NOLUN}, /* scanjet iicx */ |
113 | {"MEDIAVIS" , "CDR-H93MV" , "1.31" , BLIST_NOLUN}, /* locks up */ |
114 | {"MICROTEK" , "ScanMaker II" , "5.61" , BLIST_NOLUN}, /* responds to all lun */ |
115 | {"MITSUMI" , "CD-R CR-2201CS" , "6119" , BLIST_NOLUN}, /* locks up */ |
116 | {"NEC" , "D3856" , "0009" , BLIST_NOLUN}, |
117 | {"QUANTUM" , "LPS525S" , "3110" , BLIST_NOLUN}, /* locks up */ |
118 | {"QUANTUM" , "PD1225S" , "3110" , BLIST_NOLUN}, /* locks up */ |
119 | {"QUANTUM" , "FIREBALL ST4.3S" , "0F0C" , BLIST_NOLUN}, /* locks up */ |
120 | {"RELISYS" , "Scorpio" , NULL, BLIST_NOLUN}, /* responds to all lun */ |
121 | {"SANKYO" , "CP525" , "6.64" , BLIST_NOLUN}, /* causes failed REQ SENSE, extra reset */ |
122 | {"TEXEL" , "CD-ROM" , "1.06" , BLIST_NOLUN | BLIST_BORKEN}, |
123 | {"transtec" , "T5008" , "0001" , BLIST_NOREPORTLUN }, |
124 | {"YAMAHA" , "CDR100" , "1.00" , BLIST_NOLUN}, /* locks up */ |
125 | {"YAMAHA" , "CDR102" , "1.00" , BLIST_NOLUN}, /* locks up */ |
126 | {"YAMAHA" , "CRW8424S" , "1.0" , BLIST_NOLUN}, /* locks up */ |
127 | {"YAMAHA" , "CRW6416S" , "1.0c" , BLIST_NOLUN}, /* locks up */ |
128 | {"" , "Scanner" , "1.80" , BLIST_NOLUN}, /* responds to all lun */ |
129 | |
130 | /* |
131 | * Other types of devices that have special flags. |
132 | * Note that all USB devices should have the BLIST_INQUIRY_36 flag. |
133 | */ |
134 | {"3PARdata" , "VV" , NULL, BLIST_REPORTLUN2}, |
135 | {"ADAPTEC" , "AACRAID" , NULL, BLIST_FORCELUN}, |
136 | {"ADAPTEC" , "Adaptec 5400S" , NULL, BLIST_FORCELUN}, |
137 | {"AIX" , "VDASD" , NULL, BLIST_TRY_VPD_PAGES | BLIST_NO_VPD_SIZE}, |
138 | {"AFT PRO" , "-IX CF" , "0.0>" , BLIST_FORCELUN}, |
139 | {"BELKIN" , "USB 2 HS-CF" , "1.95" , BLIST_FORCELUN | BLIST_INQUIRY_36}, |
140 | {"BROWNIE" , "1200U3P" , NULL, BLIST_NOREPORTLUN}, |
141 | {"BROWNIE" , "1600U3P" , NULL, BLIST_NOREPORTLUN}, |
142 | {"CANON" , "IPUBJD" , NULL, BLIST_SPARSELUN}, |
143 | {"CBOX3" , "USB Storage-SMC" , "300A" , BLIST_FORCELUN | BLIST_INQUIRY_36}, |
144 | {"CMD" , "CRA-7280" , NULL, BLIST_SPARSELUN}, /* CMD RAID Controller */ |
145 | {"CNSI" , "G7324" , NULL, BLIST_SPARSELUN}, /* Chaparral G7324 RAID */ |
146 | {"CNSi" , "G8324" , NULL, BLIST_SPARSELUN}, /* Chaparral G8324 RAID */ |
147 | {"COMPAQ" , "ARRAY CONTROLLER" , NULL, BLIST_SPARSELUN | BLIST_LARGELUN | |
148 | BLIST_MAX_512 | BLIST_REPORTLUN2}, /* Compaq RA4x00 */ |
149 | {"COMPAQ" , "LOGICAL VOLUME" , NULL, BLIST_FORCELUN | BLIST_MAX_512}, /* Compaq RA4x00 */ |
150 | {"COMPAQ" , "CR3500" , NULL, BLIST_FORCELUN}, |
151 | {"COMPAQ" , "MSA1000" , NULL, BLIST_SPARSELUN | BLIST_NOSTARTONADD}, |
152 | {"COMPAQ" , "MSA1000 VOLUME" , NULL, BLIST_SPARSELUN | BLIST_NOSTARTONADD}, |
153 | {"COMPAQ" , "HSV110" , NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
154 | {"DDN" , "SAN DataDirector" , "*" , BLIST_SPARSELUN}, |
155 | {"DEC" , "HSG80" , NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
156 | {"DELL" , "PV660F" , NULL, BLIST_SPARSELUN}, |
157 | {"DELL" , "PV660F PSEUDO" , NULL, BLIST_SPARSELUN}, |
158 | {"DELL" , "PSEUDO DEVICE ." , NULL, BLIST_SPARSELUN}, /* Dell PV 530F */ |
159 | {"DELL" , "PV530F" , NULL, BLIST_SPARSELUN}, |
160 | {"DELL" , "PERCRAID" , NULL, BLIST_FORCELUN}, |
161 | {"DGC" , "RAID" , NULL, BLIST_SPARSELUN}, /* EMC CLARiiON, storage on LUN 0 */ |
162 | {"DGC" , "DISK" , NULL, BLIST_SPARSELUN}, /* EMC CLARiiON, no storage on LUN 0 */ |
163 | {"EMC" , "Invista" , "*" , BLIST_SPARSELUN | BLIST_LARGELUN}, |
164 | {"EMC" , "SYMMETRIX" , NULL, BLIST_SPARSELUN | BLIST_LARGELUN | |
165 | BLIST_REPORTLUN2 | BLIST_RETRY_ITF}, |
166 | {"EMULEX" , "MD21/S2 ESDI" , NULL, BLIST_SINGLELUN}, |
167 | {"easyRAID" , "16P" , NULL, BLIST_NOREPORTLUN}, |
168 | {"easyRAID" , "X6P" , NULL, BLIST_NOREPORTLUN}, |
169 | {"easyRAID" , "F8" , NULL, BLIST_NOREPORTLUN}, |
170 | {"FSC" , "CentricStor" , "*" , BLIST_SPARSELUN | BLIST_LARGELUN}, |
171 | {"FUJITSU" , "ETERNUS_DXM" , "*" , BLIST_RETRY_ASC_C1}, |
172 | {"Generic" , "USB SD Reader" , "1.00" , BLIST_FORCELUN | BLIST_INQUIRY_36}, |
173 | {"Generic" , "USB Storage-SMC" , NULL, BLIST_FORCELUN | BLIST_INQUIRY_36}, /* FW: 0180 and 0207 */ |
174 | {"Generic" , "Ultra HS-SD/MMC" , "2.09" , BLIST_IGN_MEDIA_CHANGE | BLIST_INQUIRY_36}, |
175 | {"HITACHI" , "DF400" , "*" , BLIST_REPORTLUN2}, |
176 | {"HITACHI" , "DF500" , "*" , BLIST_REPORTLUN2}, |
177 | {"HITACHI" , "DISK-SUBSYSTEM" , "*" , BLIST_REPORTLUN2}, |
178 | {"HITACHI" , "HUS1530" , "*" , BLIST_NO_DIF}, |
179 | {"HITACHI" , "OPEN-" , "*" , BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES}, |
180 | {"HP" , "A6189A" , NULL, BLIST_SPARSELUN | BLIST_LARGELUN}, /* HP VA7400 */ |
181 | {"HP" , "OPEN-" , "*" , BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES}, /* HP XP Arrays */ |
182 | {"HP" , "NetRAID-4M" , NULL, BLIST_FORCELUN}, |
183 | {"HP" , "HSV100" , NULL, BLIST_REPORTLUN2 | BLIST_NOSTARTONADD}, |
184 | {"HP" , "C1557A" , NULL, BLIST_FORCELUN}, |
185 | {"HP" , "C3323-300" , "4269" , BLIST_NOTQ}, |
186 | {"HP" , "C5713A" , NULL, BLIST_NOREPORTLUN}, |
187 | {"HP" , "DISK-SUBSYSTEM" , "*" , BLIST_REPORTLUN2}, |
188 | {"HPE" , "OPEN-" , "*" , BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES}, |
189 | {"IBM" , "AuSaV1S2" , NULL, BLIST_FORCELUN}, |
190 | {"IBM" , "ProFibre 4000R" , "*" , BLIST_SPARSELUN | BLIST_LARGELUN}, |
191 | {"IBM" , "2076" , NULL, BLIST_NO_VPD_SIZE}, |
192 | {"IBM" , "2105" , NULL, BLIST_RETRY_HWERROR}, |
193 | {"iomega" , "jaz 1GB" , "J.86" , BLIST_NOTQ | BLIST_NOLUN}, |
194 | {"IOMEGA" , "ZIP" , NULL, BLIST_NOTQ | BLIST_NOLUN}, |
195 | {"IOMEGA" , "Io20S *F" , NULL, BLIST_KEY}, |
196 | {"INSITE" , "Floptical F*8I" , NULL, BLIST_KEY}, |
197 | {"INSITE" , "I325VM" , NULL, BLIST_KEY}, |
198 | {"Intel" , "Multi-Flex" , NULL, BLIST_NO_RSOC}, |
199 | {"iRiver" , "iFP Mass Driver" , NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
200 | {"LASOUND" , "CDX7405" , "3.10" , BLIST_MAX5LUN | BLIST_SINGLELUN}, |
201 | {"Marvell" , "Console" , NULL, BLIST_SKIP_VPD_PAGES}, |
202 | {"Marvell" , "91xx Config" , "1.01" , BLIST_SKIP_VPD_PAGES}, |
203 | {"MATSHITA" , "PD-1" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
204 | {"MATSHITA" , "DMC-LC5" , NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
205 | {"MATSHITA" , "DMC-LC40" , NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36}, |
206 | {"Medion" , "Flash XL MMC/SD" , "2.6D" , BLIST_FORCELUN}, |
207 | {"MegaRAID" , "LD" , NULL, BLIST_FORCELUN}, |
208 | {"MICROP" , "4110" , NULL, BLIST_NOTQ}, |
209 | {"MSFT" , "Virtual HD" , NULL, BLIST_MAX_1024 | BLIST_NO_RSOC}, |
210 | {"MYLEX" , "DACARMRB" , "*" , BLIST_REPORTLUN2}, |
211 | {"nCipher" , "Fastness Crypto" , NULL, BLIST_FORCELUN}, |
212 | {"NAKAMICH" , "MJ-4.8S" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
213 | {"NAKAMICH" , "MJ-5.16S" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
214 | {"NEC" , "PD-1 ODX654P" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
215 | {"NEC" , "iStorage" , NULL, BLIST_REPORTLUN2}, |
216 | {"NRC" , "MBR-7" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
217 | {"NRC" , "MBR-7.4" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
218 | {"PIONEER" , "CD-ROM DRM-600" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
219 | {"PIONEER" , "CD-ROM DRM-602X" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
220 | {"PIONEER" , "CD-ROM DRM-604X" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
221 | {"PIONEER" , "CD-ROM DRM-624X" , NULL, BLIST_FORCELUN | BLIST_SINGLELUN}, |
222 | {"Promise" , "VTrak E610f" , NULL, BLIST_SPARSELUN | BLIST_NO_RSOC}, |
223 | {"Promise" , "" , NULL, BLIST_SPARSELUN}, |
224 | {"QEMU" , "QEMU CD-ROM" , NULL, BLIST_SKIP_VPD_PAGES}, |
225 | {"QNAP" , "iSCSI Storage" , NULL, BLIST_MAX_1024}, |
226 | {"SYNOLOGY" , "iSCSI Storage" , NULL, BLIST_MAX_1024}, |
227 | {"QUANTUM" , "XP34301" , "1071" , BLIST_NOTQ}, |
228 | {"REGAL" , "CDC-4X" , NULL, BLIST_MAX5LUN | BLIST_SINGLELUN}, |
229 | {"SanDisk" , "ImageMate CF-SD1" , NULL, BLIST_FORCELUN}, |
230 | {"SEAGATE" , "ST34555N" , "0930" , BLIST_NOTQ}, /* Chokes on tagged INQUIRY */ |
231 | {"SEAGATE" , "ST3390N" , "9546" , BLIST_NOTQ}, |
232 | {"SEAGATE" , "ST900MM0006" , NULL, BLIST_SKIP_VPD_PAGES}, |
233 | {"SGI" , "RAID3" , "*" , BLIST_SPARSELUN}, |
234 | {"SGI" , "RAID5" , "*" , BLIST_SPARSELUN}, |
235 | {"SGI" , "TP9100" , "*" , BLIST_REPORTLUN2}, |
236 | {"SGI" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
237 | {"SKhynix" , "H28U74301AMR" , NULL, BLIST_SKIP_VPD_PAGES}, |
238 | {"IBM" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
239 | {"SUN" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
240 | {"DELL" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
241 | {"STK" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
242 | {"NETAPP" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
243 | {"LSI" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
244 | {"ENGENIO" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
245 | {"LENOVO" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
246 | {"FUJITSU" , "Universal Xport" , "*" , BLIST_NO_ULD_ATTACH}, |
247 | {"SanDisk" , "Cruzer Blade" , NULL, BLIST_TRY_VPD_PAGES | |
248 | BLIST_INQUIRY_36}, |
249 | {"SMSC" , "USB 2 HS-CF" , NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36}, |
250 | {"SONY" , "CD-ROM CDU-8001" , NULL, BLIST_BORKEN}, |
251 | {"SONY" , "TSL" , NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */ |
252 | {"ST650211" , "CF" , NULL, BLIST_RETRY_HWERROR}, |
253 | {"SUN" , "T300" , "*" , BLIST_SPARSELUN}, |
254 | {"SUN" , "T4" , "*" , BLIST_SPARSELUN}, |
255 | {"Tornado-" , "F4" , "*" , BLIST_NOREPORTLUN}, |
256 | {"TOSHIBA" , "CDROM" , NULL, BLIST_ISROM}, |
257 | {"TOSHIBA" , "CD-ROM" , NULL, BLIST_ISROM}, |
258 | {"Traxdata" , "CDR4120" , NULL, BLIST_NOLUN}, /* locks up */ |
259 | {"USB2.0" , "SMARTMEDIA/XD" , NULL, BLIST_FORCELUN | BLIST_INQUIRY_36}, |
260 | {"WangDAT" , "Model 2600" , "01.7" , BLIST_SELECT_NO_ATN}, |
261 | {"WangDAT" , "Model 3200" , "02.2" , BLIST_SELECT_NO_ATN}, |
262 | {"WangDAT" , "Model 1300" , "02.4" , BLIST_SELECT_NO_ATN}, |
263 | {"WDC WD25" , "00JB-00FUA0" , NULL, BLIST_NOREPORTLUN}, |
264 | {"XYRATEX" , "RS" , "*" , BLIST_SPARSELUN | BLIST_LARGELUN}, |
265 | {"Zzyzx" , "RocketStor 500S" , NULL, BLIST_SPARSELUN}, |
266 | {"Zzyzx" , "RocketStor 2000" , NULL, BLIST_SPARSELUN}, |
267 | { NULL, NULL, NULL, 0 }, |
268 | }; |
269 | |
270 | static struct scsi_dev_info_list_table *scsi_devinfo_lookup_by_key(int key) |
271 | { |
272 | struct scsi_dev_info_list_table *devinfo_table; |
273 | int found = 0; |
274 | |
275 | list_for_each_entry(devinfo_table, &scsi_dev_info_list, node) |
276 | if (devinfo_table->key == key) { |
277 | found = 1; |
278 | break; |
279 | } |
280 | if (!found) |
281 | return ERR_PTR(error: -EINVAL); |
282 | |
283 | return devinfo_table; |
284 | } |
285 | |
286 | /* |
287 | * scsi_strcpy_devinfo: called from scsi_dev_info_list_add to copy into |
288 | * devinfo vendor and model strings. |
289 | */ |
290 | static void scsi_strcpy_devinfo(char *name, char *to, size_t to_length, |
291 | char *from, int compatible) |
292 | { |
293 | size_t from_length; |
294 | |
295 | from_length = strlen(from); |
296 | /* This zero-pads the destination */ |
297 | strncpy(p: to, q: from, size: to_length); |
298 | if (from_length < to_length && !compatible) { |
299 | /* |
300 | * space pad the string if it is short. |
301 | */ |
302 | memset(&to[from_length], ' ', to_length - from_length); |
303 | } |
304 | if (from_length > to_length) |
305 | printk(KERN_WARNING "%s: %s string '%s' is too long\n" , |
306 | __func__, name, from); |
307 | } |
308 | |
309 | /** |
310 | * scsi_dev_info_list_add - add one dev_info list entry. |
311 | * @compatible: if true, null terminate short strings. Otherwise space pad. |
312 | * @vendor: vendor string |
313 | * @model: model (product) string |
314 | * @strflags: integer string |
315 | * @flags: if strflags NULL, use this flag value |
316 | * |
317 | * Description: |
318 | * Create and add one dev_info entry for @vendor, @model, @strflags or |
319 | * @flag. If @compatible, add to the tail of the list, do not space |
320 | * pad, and set devinfo->compatible. The scsi_static_device_list entries |
321 | * are added with @compatible 1 and @clfags NULL. |
322 | * |
323 | * Returns: 0 OK, -error on failure. |
324 | **/ |
325 | static int scsi_dev_info_list_add(int compatible, char *vendor, char *model, |
326 | char *strflags, blist_flags_t flags) |
327 | { |
328 | return scsi_dev_info_list_add_keyed(compatible, vendor, model, |
329 | strflags, flags, |
330 | key: SCSI_DEVINFO_GLOBAL); |
331 | } |
332 | |
333 | /** |
334 | * scsi_dev_info_list_add_keyed - add one dev_info list entry. |
335 | * @compatible: if true, null terminate short strings. Otherwise space pad. |
336 | * @vendor: vendor string |
337 | * @model: model (product) string |
338 | * @strflags: integer string |
339 | * @flags: if strflags NULL, use this flag value |
340 | * @key: specify list to use |
341 | * |
342 | * Description: |
343 | * Create and add one dev_info entry for @vendor, @model, |
344 | * @strflags or @flag in list specified by @key. If @compatible, |
345 | * add to the tail of the list, do not space pad, and set |
346 | * devinfo->compatible. The scsi_static_device_list entries are |
347 | * added with @compatible 1 and @clfags NULL. |
348 | * |
349 | * Returns: 0 OK, -error on failure. |
350 | **/ |
351 | int scsi_dev_info_list_add_keyed(int compatible, char *vendor, char *model, |
352 | char *strflags, blist_flags_t flags, |
353 | enum scsi_devinfo_key key) |
354 | { |
355 | struct scsi_dev_info_list *devinfo; |
356 | struct scsi_dev_info_list_table *devinfo_table = |
357 | scsi_devinfo_lookup_by_key(key); |
358 | |
359 | if (IS_ERR(ptr: devinfo_table)) |
360 | return PTR_ERR(ptr: devinfo_table); |
361 | |
362 | devinfo = kmalloc(size: sizeof(*devinfo), GFP_KERNEL); |
363 | if (!devinfo) { |
364 | printk(KERN_ERR "%s: no memory\n" , __func__); |
365 | return -ENOMEM; |
366 | } |
367 | |
368 | scsi_strcpy_devinfo(name: "vendor" , to: devinfo->vendor, to_length: sizeof(devinfo->vendor), |
369 | from: vendor, compatible); |
370 | scsi_strcpy_devinfo(name: "model" , to: devinfo->model, to_length: sizeof(devinfo->model), |
371 | from: model, compatible); |
372 | |
373 | if (strflags) { |
374 | unsigned long long val; |
375 | int ret = kstrtoull(s: strflags, base: 0, res: &val); |
376 | |
377 | if (ret != 0) { |
378 | kfree(objp: devinfo); |
379 | return ret; |
380 | } |
381 | flags = (__force blist_flags_t)val; |
382 | } |
383 | if (flags & __BLIST_UNUSED_MASK) { |
384 | pr_err("scsi_devinfo (%s:%s): unsupported flags 0x%llx" , |
385 | vendor, model, flags & __BLIST_UNUSED_MASK); |
386 | kfree(objp: devinfo); |
387 | return -EINVAL; |
388 | } |
389 | devinfo->flags = flags; |
390 | devinfo->compatible = compatible; |
391 | |
392 | if (compatible) |
393 | list_add_tail(new: &devinfo->dev_info_list, |
394 | head: &devinfo_table->scsi_dev_info_list); |
395 | else |
396 | list_add(new: &devinfo->dev_info_list, |
397 | head: &devinfo_table->scsi_dev_info_list); |
398 | |
399 | return 0; |
400 | } |
401 | EXPORT_SYMBOL(scsi_dev_info_list_add_keyed); |
402 | |
403 | /** |
404 | * scsi_dev_info_list_find - find a matching dev_info list entry. |
405 | * @vendor: full vendor string |
406 | * @model: full model (product) string |
407 | * @key: specify list to use |
408 | * |
409 | * Description: |
410 | * Finds the first dev_info entry matching @vendor, @model |
411 | * in list specified by @key. |
412 | * |
413 | * Returns: pointer to matching entry, or ERR_PTR on failure. |
414 | **/ |
415 | static struct scsi_dev_info_list *scsi_dev_info_list_find(const char *vendor, |
416 | const char *model, enum scsi_devinfo_key key) |
417 | { |
418 | struct scsi_dev_info_list *devinfo; |
419 | struct scsi_dev_info_list_table *devinfo_table = |
420 | scsi_devinfo_lookup_by_key(key); |
421 | size_t vmax, mmax, mlen; |
422 | const char *vskip, *mskip; |
423 | |
424 | if (IS_ERR(ptr: devinfo_table)) |
425 | return (struct scsi_dev_info_list *) devinfo_table; |
426 | |
427 | /* Prepare for "compatible" matches */ |
428 | |
429 | /* |
430 | * XXX why skip leading spaces? If an odd INQUIRY |
431 | * value, that should have been part of the |
432 | * scsi_static_device_list[] entry, such as " FOO" |
433 | * rather than "FOO". Since this code is already |
434 | * here, and we don't know what device it is |
435 | * trying to work with, leave it as-is. |
436 | */ |
437 | vmax = sizeof(devinfo->vendor); |
438 | vskip = vendor; |
439 | while (vmax > 0 && *vskip == ' ') { |
440 | vmax--; |
441 | vskip++; |
442 | } |
443 | /* Also skip trailing spaces */ |
444 | while (vmax > 0 && vskip[vmax - 1] == ' ') |
445 | --vmax; |
446 | |
447 | mmax = sizeof(devinfo->model); |
448 | mskip = model; |
449 | while (mmax > 0 && *mskip == ' ') { |
450 | mmax--; |
451 | mskip++; |
452 | } |
453 | while (mmax > 0 && mskip[mmax - 1] == ' ') |
454 | --mmax; |
455 | |
456 | list_for_each_entry(devinfo, &devinfo_table->scsi_dev_info_list, |
457 | dev_info_list) { |
458 | if (devinfo->compatible) { |
459 | /* |
460 | * vendor strings must be an exact match |
461 | */ |
462 | if (vmax != strnlen(p: devinfo->vendor, |
463 | maxlen: sizeof(devinfo->vendor)) || |
464 | memcmp(p: devinfo->vendor, q: vskip, size: vmax)) |
465 | continue; |
466 | |
467 | /* |
468 | * @model specifies the full string, and |
469 | * must be larger or equal to devinfo->model |
470 | */ |
471 | mlen = strnlen(p: devinfo->model, maxlen: sizeof(devinfo->model)); |
472 | if (mmax < mlen || memcmp(p: devinfo->model, q: mskip, size: mlen)) |
473 | continue; |
474 | return devinfo; |
475 | } else { |
476 | if (!memcmp(p: devinfo->vendor, q: vendor, |
477 | size: sizeof(devinfo->vendor)) && |
478 | !memcmp(p: devinfo->model, q: model, |
479 | size: sizeof(devinfo->model))) |
480 | return devinfo; |
481 | } |
482 | } |
483 | |
484 | return ERR_PTR(error: -ENOENT); |
485 | } |
486 | |
487 | /** |
488 | * scsi_dev_info_list_del_keyed - remove one dev_info list entry. |
489 | * @vendor: vendor string |
490 | * @model: model (product) string |
491 | * @key: specify list to use |
492 | * |
493 | * Description: |
494 | * Remove and destroy one dev_info entry for @vendor, @model |
495 | * in list specified by @key. |
496 | * |
497 | * Returns: 0 OK, -error on failure. |
498 | **/ |
499 | int scsi_dev_info_list_del_keyed(char *vendor, char *model, |
500 | enum scsi_devinfo_key key) |
501 | { |
502 | struct scsi_dev_info_list *found; |
503 | |
504 | found = scsi_dev_info_list_find(vendor, model, key); |
505 | if (IS_ERR(ptr: found)) |
506 | return PTR_ERR(ptr: found); |
507 | |
508 | list_del(entry: &found->dev_info_list); |
509 | kfree(objp: found); |
510 | return 0; |
511 | } |
512 | EXPORT_SYMBOL(scsi_dev_info_list_del_keyed); |
513 | |
514 | /** |
515 | * scsi_dev_info_list_add_str - parse dev_list and add to the scsi_dev_info_list. |
516 | * @dev_list: string of device flags to add |
517 | * |
518 | * Description: |
519 | * Parse dev_list, and add entries to the scsi_dev_info_list. |
520 | * dev_list is of the form "vendor:product:flag,vendor:product:flag". |
521 | * dev_list is modified via strsep. Can be called for command line |
522 | * addition, for proc or mabye a sysfs interface. |
523 | * |
524 | * Returns: 0 if OK, -error on failure. |
525 | **/ |
526 | static int scsi_dev_info_list_add_str(char *dev_list) |
527 | { |
528 | char *vendor, *model, *strflags, *next; |
529 | char *next_check; |
530 | int res = 0; |
531 | |
532 | next = dev_list; |
533 | if (next && next[0] == '"') { |
534 | /* |
535 | * Ignore both the leading and trailing quote. |
536 | */ |
537 | next++; |
538 | next_check = ",\"" ; |
539 | } else { |
540 | next_check = "," ; |
541 | } |
542 | |
543 | /* |
544 | * For the leading and trailing '"' case, the for loop comes |
545 | * through the last time with vendor[0] == '\0'. |
546 | */ |
547 | for (vendor = strsep(&next, ":" ); vendor && (vendor[0] != '\0') |
548 | && (res == 0); vendor = strsep(&next, ":" )) { |
549 | strflags = NULL; |
550 | model = strsep(&next, ":" ); |
551 | if (model) |
552 | strflags = strsep(&next, next_check); |
553 | if (!model || !strflags) { |
554 | pr_err("%s: bad dev info string '%s' '%s' '%s'\n" , |
555 | __func__, vendor, model ? model : "" , |
556 | strflags ? strflags : "" ); |
557 | res = -EINVAL; |
558 | } else |
559 | res = scsi_dev_info_list_add(compatible: 0 /* compatible */, vendor, |
560 | model, strflags, flags: 0); |
561 | } |
562 | return res; |
563 | } |
564 | |
565 | /** |
566 | * scsi_get_device_flags - get device specific flags from the dynamic |
567 | * device list. |
568 | * @sdev: &scsi_device to get flags for |
569 | * @vendor: vendor name |
570 | * @model: model name |
571 | * |
572 | * Description: |
573 | * Search the global scsi_dev_info_list (specified by list zero) |
574 | * for an entry matching @vendor and @model, if found, return the |
575 | * matching flags value, else return the host or global default |
576 | * settings. Called during scan time. |
577 | **/ |
578 | blist_flags_t scsi_get_device_flags(struct scsi_device *sdev, |
579 | const unsigned char *vendor, |
580 | const unsigned char *model) |
581 | { |
582 | return scsi_get_device_flags_keyed(sdev, vendor, model, |
583 | key: SCSI_DEVINFO_GLOBAL); |
584 | } |
585 | |
586 | |
587 | /** |
588 | * scsi_get_device_flags_keyed - get device specific flags from the dynamic device list |
589 | * @sdev: &scsi_device to get flags for |
590 | * @vendor: vendor name |
591 | * @model: model name |
592 | * @key: list to look up |
593 | * |
594 | * Description: |
595 | * Search the scsi_dev_info_list specified by @key for an entry |
596 | * matching @vendor and @model, if found, return the matching |
597 | * flags value, else return the host or global default settings. |
598 | * Called during scan time. |
599 | **/ |
600 | blist_flags_t scsi_get_device_flags_keyed(struct scsi_device *sdev, |
601 | const unsigned char *vendor, |
602 | const unsigned char *model, |
603 | enum scsi_devinfo_key key) |
604 | { |
605 | struct scsi_dev_info_list *devinfo; |
606 | |
607 | devinfo = scsi_dev_info_list_find(vendor, model, key); |
608 | if (!IS_ERR(ptr: devinfo)) |
609 | return devinfo->flags; |
610 | |
611 | /* key or device not found: return nothing */ |
612 | if (key != SCSI_DEVINFO_GLOBAL) |
613 | return 0; |
614 | |
615 | /* except for the global list, where we have an exception */ |
616 | if (sdev->sdev_bflags) |
617 | return sdev->sdev_bflags; |
618 | |
619 | return scsi_default_dev_flags; |
620 | } |
621 | EXPORT_SYMBOL(scsi_get_device_flags_keyed); |
622 | |
623 | #ifdef CONFIG_SCSI_PROC_FS |
624 | struct double_list { |
625 | struct list_head *top; |
626 | struct list_head *bottom; |
627 | }; |
628 | |
629 | static int devinfo_seq_show(struct seq_file *m, void *v) |
630 | { |
631 | struct double_list *dl = v; |
632 | struct scsi_dev_info_list_table *devinfo_table = |
633 | list_entry(dl->top, struct scsi_dev_info_list_table, node); |
634 | struct scsi_dev_info_list *devinfo = |
635 | list_entry(dl->bottom, struct scsi_dev_info_list, |
636 | dev_info_list); |
637 | |
638 | if (devinfo_table->scsi_dev_info_list.next == dl->bottom && |
639 | devinfo_table->name) |
640 | seq_printf(m, fmt: "[%s]:\n" , devinfo_table->name); |
641 | |
642 | seq_printf(m, fmt: "'%.8s' '%.16s' 0x%llx\n" , |
643 | devinfo->vendor, devinfo->model, devinfo->flags); |
644 | return 0; |
645 | } |
646 | |
647 | static void *devinfo_seq_start(struct seq_file *m, loff_t *ppos) |
648 | { |
649 | struct double_list *dl = kmalloc(size: sizeof(*dl), GFP_KERNEL); |
650 | loff_t pos = *ppos; |
651 | |
652 | if (!dl) |
653 | return NULL; |
654 | |
655 | list_for_each(dl->top, &scsi_dev_info_list) { |
656 | struct scsi_dev_info_list_table *devinfo_table = |
657 | list_entry(dl->top, struct scsi_dev_info_list_table, |
658 | node); |
659 | list_for_each(dl->bottom, &devinfo_table->scsi_dev_info_list) |
660 | if (pos-- == 0) |
661 | return dl; |
662 | } |
663 | |
664 | kfree(objp: dl); |
665 | return NULL; |
666 | } |
667 | |
668 | static void *devinfo_seq_next(struct seq_file *m, void *v, loff_t *ppos) |
669 | { |
670 | struct double_list *dl = v; |
671 | struct scsi_dev_info_list_table *devinfo_table = |
672 | list_entry(dl->top, struct scsi_dev_info_list_table, node); |
673 | |
674 | ++*ppos; |
675 | dl->bottom = dl->bottom->next; |
676 | while (&devinfo_table->scsi_dev_info_list == dl->bottom) { |
677 | dl->top = dl->top->next; |
678 | if (dl->top == &scsi_dev_info_list) { |
679 | kfree(objp: dl); |
680 | return NULL; |
681 | } |
682 | devinfo_table = list_entry(dl->top, |
683 | struct scsi_dev_info_list_table, |
684 | node); |
685 | dl->bottom = devinfo_table->scsi_dev_info_list.next; |
686 | } |
687 | |
688 | return dl; |
689 | } |
690 | |
691 | static void devinfo_seq_stop(struct seq_file *m, void *v) |
692 | { |
693 | kfree(objp: v); |
694 | } |
695 | |
696 | static const struct seq_operations scsi_devinfo_seq_ops = { |
697 | .start = devinfo_seq_start, |
698 | .next = devinfo_seq_next, |
699 | .stop = devinfo_seq_stop, |
700 | .show = devinfo_seq_show, |
701 | }; |
702 | |
703 | static int proc_scsi_devinfo_open(struct inode *inode, struct file *file) |
704 | { |
705 | return seq_open(file, &scsi_devinfo_seq_ops); |
706 | } |
707 | |
708 | /* |
709 | * proc_scsi_dev_info_write - allow additions to scsi_dev_info_list via /proc. |
710 | * |
711 | * Description: Adds a black/white list entry for vendor and model with an |
712 | * integer value of flag to the scsi device info list. |
713 | * To use, echo "vendor:model:flag" > /proc/scsi/device_info |
714 | */ |
715 | static ssize_t proc_scsi_devinfo_write(struct file *file, |
716 | const char __user *buf, |
717 | size_t length, loff_t *ppos) |
718 | { |
719 | char *buffer; |
720 | ssize_t err = length; |
721 | |
722 | if (!buf || length>PAGE_SIZE) |
723 | return -EINVAL; |
724 | if (!(buffer = (char *) __get_free_page(GFP_KERNEL))) |
725 | return -ENOMEM; |
726 | if (copy_from_user(to: buffer, from: buf, n: length)) { |
727 | err =-EFAULT; |
728 | goto out; |
729 | } |
730 | |
731 | if (length < PAGE_SIZE) |
732 | buffer[length] = '\0'; |
733 | else if (buffer[PAGE_SIZE-1]) { |
734 | err = -EINVAL; |
735 | goto out; |
736 | } |
737 | |
738 | scsi_dev_info_list_add_str(dev_list: buffer); |
739 | |
740 | out: |
741 | free_page((unsigned long)buffer); |
742 | return err; |
743 | } |
744 | |
745 | static const struct proc_ops scsi_devinfo_proc_ops = { |
746 | .proc_open = proc_scsi_devinfo_open, |
747 | .proc_read = seq_read, |
748 | .proc_write = proc_scsi_devinfo_write, |
749 | .proc_lseek = seq_lseek, |
750 | .proc_release = seq_release, |
751 | }; |
752 | #endif /* CONFIG_SCSI_PROC_FS */ |
753 | |
754 | module_param_string(dev_flags, scsi_dev_flags, sizeof(scsi_dev_flags), 0); |
755 | MODULE_PARM_DESC(dev_flags, |
756 | "Given scsi_dev_flags=vendor:model:flags[,v:m:f] add black/white" |
757 | " list entries for vendor and model with an integer value of flags" |
758 | " to the scsi device info list" ); |
759 | |
760 | module_param_named(default_dev_flags, scsi_default_dev_flags, ullong, 0644); |
761 | MODULE_PARM_DESC(default_dev_flags, |
762 | "scsi default device flag uint64_t value" ); |
763 | |
764 | /** |
765 | * scsi_exit_devinfo - remove /proc/scsi/device_info & the scsi_dev_info_list |
766 | **/ |
767 | void scsi_exit_devinfo(void) |
768 | { |
769 | #ifdef CONFIG_SCSI_PROC_FS |
770 | remove_proc_entry("scsi/device_info" , NULL); |
771 | #endif |
772 | |
773 | scsi_dev_info_remove_list(key: SCSI_DEVINFO_GLOBAL); |
774 | } |
775 | |
776 | /** |
777 | * scsi_dev_info_add_list - add a new devinfo list |
778 | * @key: key of the list to add |
779 | * @name: Name of the list to add (for /proc/scsi/device_info) |
780 | * |
781 | * Adds the requested list, returns zero on success, -EEXIST if the |
782 | * key is already registered to a list, or other error on failure. |
783 | */ |
784 | int scsi_dev_info_add_list(enum scsi_devinfo_key key, const char *name) |
785 | { |
786 | struct scsi_dev_info_list_table *devinfo_table = |
787 | scsi_devinfo_lookup_by_key(key); |
788 | |
789 | if (!IS_ERR(ptr: devinfo_table)) |
790 | /* list already exists */ |
791 | return -EEXIST; |
792 | |
793 | devinfo_table = kmalloc(size: sizeof(*devinfo_table), GFP_KERNEL); |
794 | |
795 | if (!devinfo_table) |
796 | return -ENOMEM; |
797 | |
798 | INIT_LIST_HEAD(list: &devinfo_table->node); |
799 | INIT_LIST_HEAD(list: &devinfo_table->scsi_dev_info_list); |
800 | devinfo_table->name = name; |
801 | devinfo_table->key = key; |
802 | list_add_tail(new: &devinfo_table->node, head: &scsi_dev_info_list); |
803 | |
804 | return 0; |
805 | } |
806 | EXPORT_SYMBOL(scsi_dev_info_add_list); |
807 | |
808 | /** |
809 | * scsi_dev_info_remove_list - destroy an added devinfo list |
810 | * @key: key of the list to destroy |
811 | * |
812 | * Iterates over the entire list first, freeing all the values, then |
813 | * frees the list itself. Returns 0 on success or -EINVAL if the key |
814 | * can't be found. |
815 | */ |
816 | int scsi_dev_info_remove_list(enum scsi_devinfo_key key) |
817 | { |
818 | struct list_head *lh, *lh_next; |
819 | struct scsi_dev_info_list_table *devinfo_table = |
820 | scsi_devinfo_lookup_by_key(key); |
821 | |
822 | if (IS_ERR(ptr: devinfo_table)) |
823 | /* no such list */ |
824 | return -EINVAL; |
825 | |
826 | /* remove from the master list */ |
827 | list_del(entry: &devinfo_table->node); |
828 | |
829 | list_for_each_safe(lh, lh_next, &devinfo_table->scsi_dev_info_list) { |
830 | struct scsi_dev_info_list *devinfo; |
831 | |
832 | devinfo = list_entry(lh, struct scsi_dev_info_list, |
833 | dev_info_list); |
834 | kfree(objp: devinfo); |
835 | } |
836 | kfree(objp: devinfo_table); |
837 | |
838 | return 0; |
839 | } |
840 | EXPORT_SYMBOL(scsi_dev_info_remove_list); |
841 | |
842 | /** |
843 | * scsi_init_devinfo - set up the dynamic device list. |
844 | * |
845 | * Description: |
846 | * Add command line entries from scsi_dev_flags, then add |
847 | * scsi_static_device_list entries to the scsi device info list. |
848 | */ |
849 | int __init scsi_init_devinfo(void) |
850 | { |
851 | #ifdef CONFIG_SCSI_PROC_FS |
852 | struct proc_dir_entry *p; |
853 | #endif |
854 | int error, i; |
855 | |
856 | error = scsi_dev_info_add_list(SCSI_DEVINFO_GLOBAL, NULL); |
857 | if (error) |
858 | return error; |
859 | |
860 | error = scsi_dev_info_list_add_str(dev_list: scsi_dev_flags); |
861 | if (error) |
862 | goto out; |
863 | |
864 | for (i = 0; scsi_static_device_list[i].vendor; i++) { |
865 | error = scsi_dev_info_list_add(compatible: 1 /* compatibile */, |
866 | vendor: scsi_static_device_list[i].vendor, |
867 | model: scsi_static_device_list[i].model, |
868 | NULL, |
869 | flags: scsi_static_device_list[i].flags); |
870 | if (error) |
871 | goto out; |
872 | } |
873 | |
874 | #ifdef CONFIG_SCSI_PROC_FS |
875 | p = proc_create(name: "scsi/device_info" , mode: 0, NULL, proc_ops: &scsi_devinfo_proc_ops); |
876 | if (!p) { |
877 | error = -ENOMEM; |
878 | goto out; |
879 | } |
880 | #endif /* CONFIG_SCSI_PROC_FS */ |
881 | |
882 | out: |
883 | if (error) |
884 | scsi_exit_devinfo(); |
885 | return error; |
886 | } |
887 | |