Commit | Line | Data |
---|---|---|
138fe4e0 | 1 | /* |
4e639fdf | 2 | * Copyright 2007-2010 Red Hat, Inc. |
138fe4e0 KR |
3 | * by Peter Jones <pjones@redhat.com> |
4 | * Copyright 2008 IBM, Inc. | |
5 | * by Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
6 | * Copyright 2008 | |
7 | * by Konrad Rzeszutek <ketuzsezr@darnok.org> | |
8 | * | |
9 | * This code exposes the iSCSI Boot Format Table to userland via sysfs. | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License v2.0 as published by | |
13 | * the Free Software Foundation | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * Changelog: | |
21 | * | |
4e639fdf PJ |
22 | * 06 Jan 2010 - Peter Jones <pjones@redhat.com> |
23 | * New changelog entries are in the git log from now on. Not here. | |
24 | * | |
138fe4e0 KR |
25 | * 14 Mar 2008 - Konrad Rzeszutek <ketuzsezr@darnok.org> |
26 | * Updated comments and copyrights. (v0.4.9) | |
27 | * | |
28 | * 11 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
29 | * Converted to using ibft_addr. (v0.4.8) | |
30 | * | |
31 | * 8 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
32 | * Combined two functions in one: reserve_ibft_region. (v0.4.7) | |
33 | * | |
34 | * 30 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
35 | * Added logic to handle IPv6 addresses. (v0.4.6) | |
36 | * | |
37 | * 25 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
38 | * Added logic to handle badly not-to-spec iBFT. (v0.4.5) | |
39 | * | |
40 | * 4 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
41 | * Added __init to function declarations. (v0.4.4) | |
42 | * | |
43 | * 21 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
44 | * Updated kobject registration, combined unregister functions in one | |
45 | * and code and style cleanup. (v0.4.3) | |
46 | * | |
47 | * 5 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
48 | * Added end-markers to enums and re-organized kobject registration. (v0.4.2) | |
49 | * | |
50 | * 4 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
51 | * Created 'device' sysfs link to the NIC and style cleanup. (v0.4.1) | |
52 | * | |
53 | * 28 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
54 | * Added sysfs-ibft documentation, moved 'find_ibft' function to | |
55 | * in its own file and added text attributes for every struct field. (v0.4) | |
56 | * | |
57 | * 21 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
58 | * Added text attributes emulating OpenFirmware /proc/device-tree naming. | |
59 | * Removed binary /sysfs interface (v0.3) | |
60 | * | |
61 | * 29 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
62 | * Added functionality in setup.c to reserve iBFT region. (v0.2) | |
63 | * | |
64 | * 27 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> | |
65 | * First version exposing iBFT data via a binary /sysfs. (v0.1) | |
66 | * | |
67 | */ | |
68 | ||
69 | ||
70 | #include <linux/blkdev.h> | |
71 | #include <linux/capability.h> | |
72 | #include <linux/ctype.h> | |
73 | #include <linux/device.h> | |
74 | #include <linux/err.h> | |
75 | #include <linux/init.h> | |
76 | #include <linux/iscsi_ibft.h> | |
77 | #include <linux/limits.h> | |
78 | #include <linux/module.h> | |
79 | #include <linux/pci.h> | |
80 | #include <linux/slab.h> | |
81 | #include <linux/stat.h> | |
82 | #include <linux/string.h> | |
83 | #include <linux/types.h> | |
4e639fdf | 84 | #include <linux/acpi.h> |
b33a84a3 | 85 | #include <linux/iscsi_boot_sysfs.h> |
138fe4e0 | 86 | |
4e639fdf PJ |
87 | #define IBFT_ISCSI_VERSION "0.5.0" |
88 | #define IBFT_ISCSI_DATE "2010-Feb-25" | |
138fe4e0 | 89 | |
85ee7a1d JP |
90 | MODULE_AUTHOR("Peter Jones <pjones@redhat.com> and " |
91 | "Konrad Rzeszutek <ketuzsezr@darnok.org>"); | |
138fe4e0 KR |
92 | MODULE_DESCRIPTION("sysfs interface to BIOS iBFT information"); |
93 | MODULE_LICENSE("GPL"); | |
94 | MODULE_VERSION(IBFT_ISCSI_VERSION); | |
95 | ||
96 | struct ibft_hdr { | |
97 | u8 id; | |
98 | u8 version; | |
99 | u16 length; | |
100 | u8 index; | |
101 | u8 flags; | |
102 | } __attribute__((__packed__)); | |
103 | ||
104 | struct ibft_control { | |
105 | struct ibft_hdr hdr; | |
106 | u16 extensions; | |
107 | u16 initiator_off; | |
108 | u16 nic0_off; | |
109 | u16 tgt0_off; | |
110 | u16 nic1_off; | |
111 | u16 tgt1_off; | |
112 | } __attribute__((__packed__)); | |
113 | ||
114 | struct ibft_initiator { | |
115 | struct ibft_hdr hdr; | |
116 | char isns_server[16]; | |
117 | char slp_server[16]; | |
118 | char pri_radius_server[16]; | |
119 | char sec_radius_server[16]; | |
120 | u16 initiator_name_len; | |
121 | u16 initiator_name_off; | |
122 | } __attribute__((__packed__)); | |
123 | ||
124 | struct ibft_nic { | |
125 | struct ibft_hdr hdr; | |
126 | char ip_addr[16]; | |
127 | u8 subnet_mask_prefix; | |
128 | u8 origin; | |
129 | char gateway[16]; | |
130 | char primary_dns[16]; | |
131 | char secondary_dns[16]; | |
132 | char dhcp[16]; | |
133 | u16 vlan; | |
134 | char mac[6]; | |
135 | u16 pci_bdf; | |
136 | u16 hostname_len; | |
137 | u16 hostname_off; | |
138 | } __attribute__((__packed__)); | |
139 | ||
140 | struct ibft_tgt { | |
141 | struct ibft_hdr hdr; | |
142 | char ip_addr[16]; | |
143 | u16 port; | |
144 | char lun[8]; | |
145 | u8 chap_type; | |
146 | u8 nic_assoc; | |
147 | u16 tgt_name_len; | |
148 | u16 tgt_name_off; | |
149 | u16 chap_name_len; | |
150 | u16 chap_name_off; | |
151 | u16 chap_secret_len; | |
152 | u16 chap_secret_off; | |
153 | u16 rev_chap_name_len; | |
154 | u16 rev_chap_name_off; | |
155 | u16 rev_chap_secret_len; | |
156 | u16 rev_chap_secret_off; | |
157 | } __attribute__((__packed__)); | |
158 | ||
159 | /* | |
160 | * The kobject different types and its names. | |
161 | * | |
162 | */ | |
163 | enum ibft_id { | |
164 | id_reserved = 0, /* We don't support. */ | |
165 | id_control = 1, /* Should show up only once and is not exported. */ | |
166 | id_initiator = 2, | |
167 | id_nic = 3, | |
168 | id_target = 4, | |
169 | id_extensions = 5, /* We don't support. */ | |
170 | id_end_marker, | |
171 | }; | |
172 | ||
138fe4e0 KR |
173 | /* |
174 | * The kobject and attribute structures. | |
175 | */ | |
176 | ||
177 | struct ibft_kobject { | |
4e639fdf | 178 | struct acpi_table_ibft *header; |
138fe4e0 KR |
179 | union { |
180 | struct ibft_initiator *initiator; | |
181 | struct ibft_nic *nic; | |
182 | struct ibft_tgt *tgt; | |
183 | struct ibft_hdr *hdr; | |
184 | }; | |
138fe4e0 KR |
185 | }; |
186 | ||
b33a84a3 | 187 | static struct iscsi_boot_kset *boot_kset; |
138fe4e0 KR |
188 | |
189 | static const char nulls[16]; | |
190 | ||
191 | /* | |
192 | * Helper functions to parse data properly. | |
193 | */ | |
194 | static ssize_t sprintf_ipaddr(char *buf, u8 *ip) | |
195 | { | |
196 | char *str = buf; | |
197 | ||
198 | if (ip[0] == 0 && ip[1] == 0 && ip[2] == 0 && ip[3] == 0 && | |
199 | ip[4] == 0 && ip[5] == 0 && ip[6] == 0 && ip[7] == 0 && | |
200 | ip[8] == 0 && ip[9] == 0 && ip[10] == 0xff && ip[11] == 0xff) { | |
201 | /* | |
202 | * IPV4 | |
203 | */ | |
63779436 | 204 | str += sprintf(buf, "%pI4", ip + 12); |
138fe4e0 KR |
205 | } else { |
206 | /* | |
207 | * IPv6 | |
208 | */ | |
5b095d98 | 209 | str += sprintf(str, "%pI6", ip); |
138fe4e0 KR |
210 | } |
211 | str += sprintf(str, "\n"); | |
212 | return str - buf; | |
213 | } | |
214 | ||
215 | static ssize_t sprintf_string(char *str, int len, char *buf) | |
216 | { | |
217 | return sprintf(str, "%.*s\n", len, buf); | |
218 | } | |
219 | ||
220 | /* | |
221 | * Helper function to verify the IBFT header. | |
222 | */ | |
223 | static int ibft_verify_hdr(char *t, struct ibft_hdr *hdr, int id, int length) | |
224 | { | |
225 | if (hdr->id != id) { | |
b33a84a3 | 226 | printk(KERN_ERR "iBFT error: We expected the %s " \ |
138fe4e0 | 227 | "field header.id to have %d but " \ |
b33a84a3 | 228 | "found %d instead!\n", t, id, hdr->id); |
138fe4e0 KR |
229 | return -ENODEV; |
230 | } | |
231 | if (hdr->length != length) { | |
b33a84a3 | 232 | printk(KERN_ERR "iBFT error: We expected the %s " \ |
138fe4e0 | 233 | "field header.length to have %d but " \ |
b33a84a3 | 234 | "found %d instead!\n", t, length, hdr->length); |
138fe4e0 KR |
235 | return -ENODEV; |
236 | } | |
237 | ||
238 | return 0; | |
239 | } | |
240 | ||
138fe4e0 KR |
241 | /* |
242 | * Routines for parsing the iBFT data to be human readable. | |
243 | */ | |
b33a84a3 | 244 | static ssize_t ibft_attr_show_initiator(void *data, int type, char *buf) |
138fe4e0 | 245 | { |
b33a84a3 | 246 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
247 | struct ibft_initiator *initiator = entry->initiator; |
248 | void *ibft_loc = entry->header; | |
249 | char *str = buf; | |
250 | ||
251 | if (!initiator) | |
252 | return 0; | |
253 | ||
b33a84a3 MC |
254 | switch (type) { |
255 | case ISCSI_BOOT_INI_INDEX: | |
138fe4e0 KR |
256 | str += sprintf(str, "%d\n", initiator->hdr.index); |
257 | break; | |
b33a84a3 | 258 | case ISCSI_BOOT_INI_FLAGS: |
138fe4e0 KR |
259 | str += sprintf(str, "%d\n", initiator->hdr.flags); |
260 | break; | |
b33a84a3 | 261 | case ISCSI_BOOT_INI_ISNS_SERVER: |
138fe4e0 KR |
262 | str += sprintf_ipaddr(str, initiator->isns_server); |
263 | break; | |
b33a84a3 | 264 | case ISCSI_BOOT_INI_SLP_SERVER: |
138fe4e0 KR |
265 | str += sprintf_ipaddr(str, initiator->slp_server); |
266 | break; | |
b33a84a3 | 267 | case ISCSI_BOOT_INI_PRI_RADIUS_SERVER: |
138fe4e0 KR |
268 | str += sprintf_ipaddr(str, initiator->pri_radius_server); |
269 | break; | |
b33a84a3 | 270 | case ISCSI_BOOT_INI_SEC_RADIUS_SERVER: |
138fe4e0 KR |
271 | str += sprintf_ipaddr(str, initiator->sec_radius_server); |
272 | break; | |
b33a84a3 | 273 | case ISCSI_BOOT_INI_INITIATOR_NAME: |
138fe4e0 KR |
274 | str += sprintf_string(str, initiator->initiator_name_len, |
275 | (char *)ibft_loc + | |
276 | initiator->initiator_name_off); | |
277 | break; | |
278 | default: | |
279 | break; | |
280 | } | |
281 | ||
282 | return str - buf; | |
283 | } | |
284 | ||
b33a84a3 | 285 | static ssize_t ibft_attr_show_nic(void *data, int type, char *buf) |
138fe4e0 | 286 | { |
b33a84a3 | 287 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
288 | struct ibft_nic *nic = entry->nic; |
289 | void *ibft_loc = entry->header; | |
290 | char *str = buf; | |
00e7825b | 291 | __be32 val; |
138fe4e0 KR |
292 | |
293 | if (!nic) | |
294 | return 0; | |
295 | ||
b33a84a3 MC |
296 | switch (type) { |
297 | case ISCSI_BOOT_ETH_INDEX: | |
138fe4e0 KR |
298 | str += sprintf(str, "%d\n", nic->hdr.index); |
299 | break; | |
b33a84a3 | 300 | case ISCSI_BOOT_ETH_FLAGS: |
138fe4e0 KR |
301 | str += sprintf(str, "%d\n", nic->hdr.flags); |
302 | break; | |
b33a84a3 | 303 | case ISCSI_BOOT_ETH_IP_ADDR: |
138fe4e0 KR |
304 | str += sprintf_ipaddr(str, nic->ip_addr); |
305 | break; | |
b33a84a3 | 306 | case ISCSI_BOOT_ETH_SUBNET_MASK: |
00e7825b JP |
307 | val = cpu_to_be32(~((1 << (32-nic->subnet_mask_prefix))-1)); |
308 | str += sprintf(str, "%pI4", &val); | |
138fe4e0 | 309 | break; |
b33a84a3 | 310 | case ISCSI_BOOT_ETH_ORIGIN: |
138fe4e0 KR |
311 | str += sprintf(str, "%d\n", nic->origin); |
312 | break; | |
b33a84a3 | 313 | case ISCSI_BOOT_ETH_GATEWAY: |
138fe4e0 KR |
314 | str += sprintf_ipaddr(str, nic->gateway); |
315 | break; | |
b33a84a3 | 316 | case ISCSI_BOOT_ETH_PRIMARY_DNS: |
138fe4e0 KR |
317 | str += sprintf_ipaddr(str, nic->primary_dns); |
318 | break; | |
b33a84a3 | 319 | case ISCSI_BOOT_ETH_SECONDARY_DNS: |
138fe4e0 KR |
320 | str += sprintf_ipaddr(str, nic->secondary_dns); |
321 | break; | |
b33a84a3 | 322 | case ISCSI_BOOT_ETH_DHCP: |
138fe4e0 KR |
323 | str += sprintf_ipaddr(str, nic->dhcp); |
324 | break; | |
b33a84a3 | 325 | case ISCSI_BOOT_ETH_VLAN: |
138fe4e0 KR |
326 | str += sprintf(str, "%d\n", nic->vlan); |
327 | break; | |
b33a84a3 | 328 | case ISCSI_BOOT_ETH_MAC: |
2c352948 | 329 | str += sprintf(str, "%pM\n", nic->mac); |
138fe4e0 | 330 | break; |
b33a84a3 | 331 | case ISCSI_BOOT_ETH_HOSTNAME: |
138fe4e0 KR |
332 | str += sprintf_string(str, nic->hostname_len, |
333 | (char *)ibft_loc + nic->hostname_off); | |
334 | break; | |
335 | default: | |
336 | break; | |
337 | } | |
338 | ||
339 | return str - buf; | |
340 | }; | |
341 | ||
b33a84a3 | 342 | static ssize_t ibft_attr_show_target(void *data, int type, char *buf) |
138fe4e0 | 343 | { |
b33a84a3 | 344 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
345 | struct ibft_tgt *tgt = entry->tgt; |
346 | void *ibft_loc = entry->header; | |
347 | char *str = buf; | |
348 | int i; | |
349 | ||
350 | if (!tgt) | |
351 | return 0; | |
352 | ||
b33a84a3 MC |
353 | switch (type) { |
354 | case ISCSI_BOOT_TGT_INDEX: | |
138fe4e0 KR |
355 | str += sprintf(str, "%d\n", tgt->hdr.index); |
356 | break; | |
b33a84a3 | 357 | case ISCSI_BOOT_TGT_FLAGS: |
138fe4e0 KR |
358 | str += sprintf(str, "%d\n", tgt->hdr.flags); |
359 | break; | |
b33a84a3 | 360 | case ISCSI_BOOT_TGT_IP_ADDR: |
138fe4e0 KR |
361 | str += sprintf_ipaddr(str, tgt->ip_addr); |
362 | break; | |
b33a84a3 | 363 | case ISCSI_BOOT_TGT_PORT: |
138fe4e0 KR |
364 | str += sprintf(str, "%d\n", tgt->port); |
365 | break; | |
b33a84a3 | 366 | case ISCSI_BOOT_TGT_LUN: |
138fe4e0 KR |
367 | for (i = 0; i < 8; i++) |
368 | str += sprintf(str, "%x", (u8)tgt->lun[i]); | |
369 | str += sprintf(str, "\n"); | |
370 | break; | |
b33a84a3 | 371 | case ISCSI_BOOT_TGT_NIC_ASSOC: |
138fe4e0 KR |
372 | str += sprintf(str, "%d\n", tgt->nic_assoc); |
373 | break; | |
b33a84a3 | 374 | case ISCSI_BOOT_TGT_CHAP_TYPE: |
138fe4e0 KR |
375 | str += sprintf(str, "%d\n", tgt->chap_type); |
376 | break; | |
b33a84a3 | 377 | case ISCSI_BOOT_TGT_NAME: |
138fe4e0 KR |
378 | str += sprintf_string(str, tgt->tgt_name_len, |
379 | (char *)ibft_loc + tgt->tgt_name_off); | |
380 | break; | |
b33a84a3 | 381 | case ISCSI_BOOT_TGT_CHAP_NAME: |
138fe4e0 KR |
382 | str += sprintf_string(str, tgt->chap_name_len, |
383 | (char *)ibft_loc + tgt->chap_name_off); | |
384 | break; | |
b33a84a3 | 385 | case ISCSI_BOOT_TGT_CHAP_SECRET: |
138fe4e0 KR |
386 | str += sprintf_string(str, tgt->chap_secret_len, |
387 | (char *)ibft_loc + tgt->chap_secret_off); | |
388 | break; | |
b33a84a3 | 389 | case ISCSI_BOOT_TGT_REV_CHAP_NAME: |
138fe4e0 KR |
390 | str += sprintf_string(str, tgt->rev_chap_name_len, |
391 | (char *)ibft_loc + | |
392 | tgt->rev_chap_name_off); | |
393 | break; | |
b33a84a3 | 394 | case ISCSI_BOOT_TGT_REV_CHAP_SECRET: |
138fe4e0 KR |
395 | str += sprintf_string(str, tgt->rev_chap_secret_len, |
396 | (char *)ibft_loc + | |
397 | tgt->rev_chap_secret_off); | |
398 | break; | |
399 | default: | |
400 | break; | |
401 | } | |
402 | ||
403 | return str - buf; | |
404 | } | |
405 | ||
138fe4e0 KR |
406 | static int __init ibft_check_device(void) |
407 | { | |
408 | int len; | |
409 | u8 *pos; | |
410 | u8 csum = 0; | |
411 | ||
4e639fdf | 412 | len = ibft_addr->header.length; |
138fe4e0 KR |
413 | |
414 | /* Sanity checking of iBFT. */ | |
4e639fdf | 415 | if (ibft_addr->header.revision != 1) { |
138fe4e0 | 416 | printk(KERN_ERR "iBFT module supports only revision 1, " \ |
4e639fdf PJ |
417 | "while this is %d.\n", |
418 | ibft_addr->header.revision); | |
138fe4e0 KR |
419 | return -ENOENT; |
420 | } | |
421 | for (pos = (u8 *)ibft_addr; pos < (u8 *)ibft_addr + len; pos++) | |
422 | csum += *pos; | |
423 | ||
424 | if (csum) { | |
425 | printk(KERN_ERR "iBFT has incorrect checksum (0x%x)!\n", csum); | |
426 | return -ENOENT; | |
427 | } | |
428 | ||
429 | return 0; | |
430 | } | |
431 | ||
b33a84a3 MC |
432 | /* |
433 | * Helper routiners to check to determine if the entry is valid | |
434 | * in the proper iBFT structure. | |
435 | */ | |
587a1f16 | 436 | static umode_t ibft_check_nic_for(void *data, int type) |
b33a84a3 MC |
437 | { |
438 | struct ibft_kobject *entry = data; | |
439 | struct ibft_nic *nic = entry->nic; | |
587a1f16 | 440 | umode_t rc = 0; |
b33a84a3 MC |
441 | |
442 | switch (type) { | |
443 | case ISCSI_BOOT_ETH_INDEX: | |
444 | case ISCSI_BOOT_ETH_FLAGS: | |
445 | rc = S_IRUGO; | |
446 | break; | |
447 | case ISCSI_BOOT_ETH_IP_ADDR: | |
448 | if (memcmp(nic->ip_addr, nulls, sizeof(nic->ip_addr))) | |
449 | rc = S_IRUGO; | |
450 | break; | |
451 | case ISCSI_BOOT_ETH_SUBNET_MASK: | |
452 | if (nic->subnet_mask_prefix) | |
453 | rc = S_IRUGO; | |
454 | break; | |
455 | case ISCSI_BOOT_ETH_ORIGIN: | |
456 | rc = S_IRUGO; | |
457 | break; | |
458 | case ISCSI_BOOT_ETH_GATEWAY: | |
459 | if (memcmp(nic->gateway, nulls, sizeof(nic->gateway))) | |
460 | rc = S_IRUGO; | |
461 | break; | |
462 | case ISCSI_BOOT_ETH_PRIMARY_DNS: | |
463 | if (memcmp(nic->primary_dns, nulls, | |
464 | sizeof(nic->primary_dns))) | |
465 | rc = S_IRUGO; | |
466 | break; | |
467 | case ISCSI_BOOT_ETH_SECONDARY_DNS: | |
468 | if (memcmp(nic->secondary_dns, nulls, | |
469 | sizeof(nic->secondary_dns))) | |
470 | rc = S_IRUGO; | |
471 | break; | |
472 | case ISCSI_BOOT_ETH_DHCP: | |
473 | if (memcmp(nic->dhcp, nulls, sizeof(nic->dhcp))) | |
474 | rc = S_IRUGO; | |
475 | break; | |
476 | case ISCSI_BOOT_ETH_VLAN: | |
477 | case ISCSI_BOOT_ETH_MAC: | |
478 | rc = S_IRUGO; | |
479 | break; | |
480 | case ISCSI_BOOT_ETH_HOSTNAME: | |
481 | if (nic->hostname_off) | |
482 | rc = S_IRUGO; | |
483 | break; | |
484 | default: | |
485 | break; | |
486 | } | |
487 | ||
488 | return rc; | |
489 | } | |
490 | ||
587a1f16 | 491 | static umode_t __init ibft_check_tgt_for(void *data, int type) |
b33a84a3 MC |
492 | { |
493 | struct ibft_kobject *entry = data; | |
494 | struct ibft_tgt *tgt = entry->tgt; | |
587a1f16 | 495 | umode_t rc = 0; |
b33a84a3 MC |
496 | |
497 | switch (type) { | |
498 | case ISCSI_BOOT_TGT_INDEX: | |
499 | case ISCSI_BOOT_TGT_FLAGS: | |
500 | case ISCSI_BOOT_TGT_IP_ADDR: | |
501 | case ISCSI_BOOT_TGT_PORT: | |
502 | case ISCSI_BOOT_TGT_LUN: | |
503 | case ISCSI_BOOT_TGT_NIC_ASSOC: | |
504 | case ISCSI_BOOT_TGT_CHAP_TYPE: | |
505 | rc = S_IRUGO; | |
506 | case ISCSI_BOOT_TGT_NAME: | |
507 | if (tgt->tgt_name_len) | |
508 | rc = S_IRUGO; | |
509 | break; | |
510 | case ISCSI_BOOT_TGT_CHAP_NAME: | |
511 | case ISCSI_BOOT_TGT_CHAP_SECRET: | |
512 | if (tgt->chap_name_len) | |
513 | rc = S_IRUGO; | |
514 | break; | |
515 | case ISCSI_BOOT_TGT_REV_CHAP_NAME: | |
516 | case ISCSI_BOOT_TGT_REV_CHAP_SECRET: | |
517 | if (tgt->rev_chap_name_len) | |
518 | rc = S_IRUGO; | |
519 | break; | |
520 | default: | |
521 | break; | |
522 | } | |
523 | ||
524 | return rc; | |
525 | } | |
526 | ||
587a1f16 | 527 | static umode_t __init ibft_check_initiator_for(void *data, int type) |
b33a84a3 MC |
528 | { |
529 | struct ibft_kobject *entry = data; | |
530 | struct ibft_initiator *init = entry->initiator; | |
587a1f16 | 531 | umode_t rc = 0; |
b33a84a3 MC |
532 | |
533 | switch (type) { | |
534 | case ISCSI_BOOT_INI_INDEX: | |
535 | case ISCSI_BOOT_INI_FLAGS: | |
536 | rc = S_IRUGO; | |
537 | break; | |
538 | case ISCSI_BOOT_INI_ISNS_SERVER: | |
539 | if (memcmp(init->isns_server, nulls, | |
540 | sizeof(init->isns_server))) | |
541 | rc = S_IRUGO; | |
542 | break; | |
543 | case ISCSI_BOOT_INI_SLP_SERVER: | |
544 | if (memcmp(init->slp_server, nulls, | |
545 | sizeof(init->slp_server))) | |
546 | rc = S_IRUGO; | |
547 | break; | |
548 | case ISCSI_BOOT_INI_PRI_RADIUS_SERVER: | |
549 | if (memcmp(init->pri_radius_server, nulls, | |
550 | sizeof(init->pri_radius_server))) | |
551 | rc = S_IRUGO; | |
552 | break; | |
553 | case ISCSI_BOOT_INI_SEC_RADIUS_SERVER: | |
554 | if (memcmp(init->sec_radius_server, nulls, | |
555 | sizeof(init->sec_radius_server))) | |
556 | rc = S_IRUGO; | |
557 | break; | |
558 | case ISCSI_BOOT_INI_INITIATOR_NAME: | |
559 | if (init->initiator_name_len) | |
560 | rc = S_IRUGO; | |
561 | break; | |
562 | default: | |
563 | break; | |
564 | } | |
565 | ||
566 | return rc; | |
567 | } | |
568 | ||
f457a46f MC |
569 | static void ibft_kobj_release(void *data) |
570 | { | |
571 | kfree(data); | |
572 | } | |
573 | ||
138fe4e0 KR |
574 | /* |
575 | * Helper function for ibft_register_kobjects. | |
576 | */ | |
4e639fdf | 577 | static int __init ibft_create_kobject(struct acpi_table_ibft *header, |
b33a84a3 | 578 | struct ibft_hdr *hdr) |
138fe4e0 | 579 | { |
b33a84a3 | 580 | struct iscsi_boot_kobj *boot_kobj = NULL; |
138fe4e0 KR |
581 | struct ibft_kobject *ibft_kobj = NULL; |
582 | struct ibft_nic *nic = (struct ibft_nic *)hdr; | |
583 | struct pci_dev *pci_dev; | |
584 | int rc = 0; | |
585 | ||
586 | ibft_kobj = kzalloc(sizeof(*ibft_kobj), GFP_KERNEL); | |
587 | if (!ibft_kobj) | |
588 | return -ENOMEM; | |
589 | ||
590 | ibft_kobj->header = header; | |
591 | ibft_kobj->hdr = hdr; | |
592 | ||
593 | switch (hdr->id) { | |
594 | case id_initiator: | |
595 | rc = ibft_verify_hdr("initiator", hdr, id_initiator, | |
596 | sizeof(*ibft_kobj->initiator)); | |
b33a84a3 MC |
597 | if (rc) |
598 | break; | |
599 | ||
600 | boot_kobj = iscsi_boot_create_initiator(boot_kset, hdr->index, | |
601 | ibft_kobj, | |
602 | ibft_attr_show_initiator, | |
f457a46f MC |
603 | ibft_check_initiator_for, |
604 | ibft_kobj_release); | |
b33a84a3 MC |
605 | if (!boot_kobj) { |
606 | rc = -ENOMEM; | |
607 | goto free_ibft_obj; | |
608 | } | |
138fe4e0 KR |
609 | break; |
610 | case id_nic: | |
611 | rc = ibft_verify_hdr("ethernet", hdr, id_nic, | |
612 | sizeof(*ibft_kobj->nic)); | |
b33a84a3 MC |
613 | if (rc) |
614 | break; | |
615 | ||
616 | boot_kobj = iscsi_boot_create_ethernet(boot_kset, hdr->index, | |
617 | ibft_kobj, | |
618 | ibft_attr_show_nic, | |
f457a46f MC |
619 | ibft_check_nic_for, |
620 | ibft_kobj_release); | |
b33a84a3 MC |
621 | if (!boot_kobj) { |
622 | rc = -ENOMEM; | |
623 | goto free_ibft_obj; | |
624 | } | |
138fe4e0 KR |
625 | break; |
626 | case id_target: | |
627 | rc = ibft_verify_hdr("target", hdr, id_target, | |
628 | sizeof(*ibft_kobj->tgt)); | |
b33a84a3 MC |
629 | if (rc) |
630 | break; | |
631 | ||
632 | boot_kobj = iscsi_boot_create_target(boot_kset, hdr->index, | |
633 | ibft_kobj, | |
634 | ibft_attr_show_target, | |
f457a46f MC |
635 | ibft_check_tgt_for, |
636 | ibft_kobj_release); | |
b33a84a3 MC |
637 | if (!boot_kobj) { |
638 | rc = -ENOMEM; | |
639 | goto free_ibft_obj; | |
640 | } | |
138fe4e0 KR |
641 | break; |
642 | case id_reserved: | |
643 | case id_control: | |
644 | case id_extensions: | |
645 | /* Fields which we don't support. Ignore them */ | |
646 | rc = 1; | |
647 | break; | |
648 | default: | |
649 | printk(KERN_ERR "iBFT has unknown structure type (%d). " \ | |
650 | "Report this bug to %.6s!\n", hdr->id, | |
4e639fdf | 651 | header->header.oem_id); |
138fe4e0 KR |
652 | rc = 1; |
653 | break; | |
654 | } | |
655 | ||
656 | if (rc) { | |
657 | /* Skip adding this kobject, but exit with non-fatal error. */ | |
b33a84a3 MC |
658 | rc = 0; |
659 | goto free_ibft_obj; | |
138fe4e0 KR |
660 | } |
661 | ||
138fe4e0 KR |
662 | if (hdr->id == id_nic) { |
663 | /* | |
664 | * We don't search for the device in other domains than | |
665 | * zero. This is because on x86 platforms the BIOS | |
666 | * executes only devices which are in domain 0. Furthermore, the | |
667 | * iBFT spec doesn't have a domain id field :-( | |
668 | */ | |
669 | pci_dev = pci_get_bus_and_slot((nic->pci_bdf & 0xff00) >> 8, | |
670 | (nic->pci_bdf & 0xff)); | |
671 | if (pci_dev) { | |
b33a84a3 | 672 | rc = sysfs_create_link(&boot_kobj->kobj, |
138fe4e0 KR |
673 | &pci_dev->dev.kobj, "device"); |
674 | pci_dev_put(pci_dev); | |
675 | } | |
676 | } | |
b33a84a3 | 677 | return 0; |
138fe4e0 | 678 | |
b33a84a3 MC |
679 | free_ibft_obj: |
680 | kfree(ibft_kobj); | |
138fe4e0 | 681 | return rc; |
138fe4e0 KR |
682 | } |
683 | ||
684 | /* | |
685 | * Scan the IBFT table structure for the NIC and Target fields. When | |
686 | * found add them on the passed-in list. We do not support the other | |
687 | * fields at this point, so they are skipped. | |
688 | */ | |
b33a84a3 | 689 | static int __init ibft_register_kobjects(struct acpi_table_ibft *header) |
138fe4e0 KR |
690 | { |
691 | struct ibft_control *control = NULL; | |
692 | void *ptr, *end; | |
693 | int rc = 0; | |
694 | u16 offset; | |
695 | u16 eot_offset; | |
696 | ||
697 | control = (void *)header + sizeof(*header); | |
698 | end = (void *)control + control->hdr.length; | |
4e639fdf | 699 | eot_offset = (void *)header + header->header.length - (void *)control; |
138fe4e0 KR |
700 | rc = ibft_verify_hdr("control", (struct ibft_hdr *)control, id_control, |
701 | sizeof(*control)); | |
702 | ||
703 | /* iBFT table safety checking */ | |
704 | rc |= ((control->hdr.index) ? -ENODEV : 0); | |
705 | if (rc) { | |
706 | printk(KERN_ERR "iBFT error: Control header is invalid!\n"); | |
707 | return rc; | |
708 | } | |
709 | for (ptr = &control->initiator_off; ptr < end; ptr += sizeof(u16)) { | |
710 | offset = *(u16 *)ptr; | |
4e639fdf PJ |
711 | if (offset && offset < header->header.length && |
712 | offset < eot_offset) { | |
138fe4e0 | 713 | rc = ibft_create_kobject(header, |
b33a84a3 | 714 | (void *)header + offset); |
138fe4e0 KR |
715 | if (rc) |
716 | break; | |
717 | } | |
718 | } | |
719 | ||
720 | return rc; | |
721 | } | |
722 | ||
b33a84a3 | 723 | static void ibft_unregister(void) |
138fe4e0 | 724 | { |
b33a84a3 MC |
725 | struct iscsi_boot_kobj *boot_kobj, *tmp_kobj; |
726 | struct ibft_kobject *ibft_kobj; | |
727 | ||
728 | list_for_each_entry_safe(boot_kobj, tmp_kobj, | |
729 | &boot_kset->kobj_list, list) { | |
730 | ibft_kobj = boot_kobj->data; | |
731 | if (ibft_kobj->hdr->id == id_nic) | |
732 | sysfs_remove_link(&boot_kobj->kobj, "device"); | |
138fe4e0 | 733 | }; |
138fe4e0 KR |
734 | } |
735 | ||
b33a84a3 | 736 | static void ibft_cleanup(void) |
138fe4e0 | 737 | { |
a12415ff KRW |
738 | if (boot_kset) { |
739 | ibft_unregister(); | |
740 | iscsi_boot_destroy_kset(boot_kset); | |
741 | } | |
138fe4e0 KR |
742 | } |
743 | ||
b33a84a3 | 744 | static void __exit ibft_exit(void) |
138fe4e0 | 745 | { |
b33a84a3 | 746 | ibft_cleanup(); |
138fe4e0 KR |
747 | } |
748 | ||
935a9fee YL |
749 | #ifdef CONFIG_ACPI |
750 | static const struct { | |
751 | char *sign; | |
752 | } ibft_signs[] = { | |
753 | /* | |
754 | * One spec says "IBFT", the other says "iBFT". We have to check | |
755 | * for both. | |
756 | */ | |
757 | { ACPI_SIG_IBFT }, | |
758 | { "iBFT" }, | |
629c27aa | 759 | { "BIFT" }, /* Broadcom iSCSI Offload */ |
935a9fee YL |
760 | }; |
761 | ||
762 | static void __init acpi_find_ibft_region(void) | |
763 | { | |
764 | int i; | |
765 | struct acpi_table_header *table = NULL; | |
766 | ||
767 | if (acpi_disabled) | |
768 | return; | |
769 | ||
770 | for (i = 0; i < ARRAY_SIZE(ibft_signs) && !ibft_addr; i++) { | |
771 | acpi_get_table(ibft_signs[i].sign, 0, &table); | |
772 | ibft_addr = (struct acpi_table_ibft *)table; | |
773 | } | |
774 | } | |
775 | #else | |
776 | static void __init acpi_find_ibft_region(void) | |
777 | { | |
778 | } | |
779 | #endif | |
780 | ||
138fe4e0 KR |
781 | /* |
782 | * ibft_init() - creates sysfs tree entries for the iBFT data. | |
783 | */ | |
784 | static int __init ibft_init(void) | |
785 | { | |
786 | int rc = 0; | |
787 | ||
935a9fee YL |
788 | /* |
789 | As on UEFI systems the setup_arch()/find_ibft_region() | |
790 | is called before ACPI tables are parsed and it only does | |
791 | legacy finding. | |
792 | */ | |
793 | if (!ibft_addr) | |
794 | acpi_find_ibft_region(); | |
795 | ||
138fe4e0 | 796 | if (ibft_addr) { |
935a9fee | 797 | pr_info("iBFT detected.\n"); |
138fe4e0 KR |
798 | |
799 | rc = ibft_check_device(); | |
800 | if (rc) | |
b33a84a3 | 801 | return rc; |
138fe4e0 | 802 | |
b33a84a3 MC |
803 | boot_kset = iscsi_boot_create_kset("ibft"); |
804 | if (!boot_kset) | |
805 | return -ENOMEM; | |
138fe4e0 | 806 | |
b33a84a3 MC |
807 | /* Scan the IBFT for data and register the kobjects. */ |
808 | rc = ibft_register_kobjects(ibft_addr); | |
138fe4e0 KR |
809 | if (rc) |
810 | goto out_free; | |
811 | } else | |
812 | printk(KERN_INFO "No iBFT detected.\n"); | |
813 | ||
814 | return 0; | |
815 | ||
816 | out_free: | |
b33a84a3 | 817 | ibft_cleanup(); |
138fe4e0 KR |
818 | return rc; |
819 | } | |
820 | ||
138fe4e0 KR |
821 | module_init(ibft_init); |
822 | module_exit(ibft_exit); |