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 | 188 | |
e6050b61 | 189 | /* fully null address */ |
138fe4e0 KR |
190 | static const char nulls[16]; |
191 | ||
e6050b61 CL |
192 | /* IPv4-mapped IPv6 ::ffff:0.0.0.0 */ |
193 | static const char mapped_nulls[16] = { 0x00, 0x00, 0x00, 0x00, | |
194 | 0x00, 0x00, 0x00, 0x00, | |
195 | 0x00, 0x00, 0xff, 0xff, | |
196 | 0x00, 0x00, 0x00, 0x00 }; | |
197 | ||
198 | static int address_not_null(u8 *ip) | |
199 | { | |
200 | return (memcmp(ip, nulls, 16) && memcmp(ip, mapped_nulls, 16)); | |
201 | } | |
202 | ||
138fe4e0 KR |
203 | /* |
204 | * Helper functions to parse data properly. | |
205 | */ | |
206 | static ssize_t sprintf_ipaddr(char *buf, u8 *ip) | |
207 | { | |
208 | char *str = buf; | |
209 | ||
210 | if (ip[0] == 0 && ip[1] == 0 && ip[2] == 0 && ip[3] == 0 && | |
211 | ip[4] == 0 && ip[5] == 0 && ip[6] == 0 && ip[7] == 0 && | |
212 | ip[8] == 0 && ip[9] == 0 && ip[10] == 0xff && ip[11] == 0xff) { | |
213 | /* | |
214 | * IPV4 | |
215 | */ | |
63779436 | 216 | str += sprintf(buf, "%pI4", ip + 12); |
138fe4e0 KR |
217 | } else { |
218 | /* | |
219 | * IPv6 | |
220 | */ | |
5b095d98 | 221 | str += sprintf(str, "%pI6", ip); |
138fe4e0 KR |
222 | } |
223 | str += sprintf(str, "\n"); | |
224 | return str - buf; | |
225 | } | |
226 | ||
227 | static ssize_t sprintf_string(char *str, int len, char *buf) | |
228 | { | |
229 | return sprintf(str, "%.*s\n", len, buf); | |
230 | } | |
231 | ||
232 | /* | |
233 | * Helper function to verify the IBFT header. | |
234 | */ | |
235 | static int ibft_verify_hdr(char *t, struct ibft_hdr *hdr, int id, int length) | |
236 | { | |
237 | if (hdr->id != id) { | |
b33a84a3 | 238 | printk(KERN_ERR "iBFT error: We expected the %s " \ |
138fe4e0 | 239 | "field header.id to have %d but " \ |
b33a84a3 | 240 | "found %d instead!\n", t, id, hdr->id); |
138fe4e0 KR |
241 | return -ENODEV; |
242 | } | |
243 | if (hdr->length != length) { | |
b33a84a3 | 244 | printk(KERN_ERR "iBFT error: We expected the %s " \ |
138fe4e0 | 245 | "field header.length to have %d but " \ |
b33a84a3 | 246 | "found %d instead!\n", t, length, hdr->length); |
138fe4e0 KR |
247 | return -ENODEV; |
248 | } | |
249 | ||
250 | return 0; | |
251 | } | |
252 | ||
138fe4e0 KR |
253 | /* |
254 | * Routines for parsing the iBFT data to be human readable. | |
255 | */ | |
b33a84a3 | 256 | static ssize_t ibft_attr_show_initiator(void *data, int type, char *buf) |
138fe4e0 | 257 | { |
b33a84a3 | 258 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
259 | struct ibft_initiator *initiator = entry->initiator; |
260 | void *ibft_loc = entry->header; | |
261 | char *str = buf; | |
262 | ||
263 | if (!initiator) | |
264 | return 0; | |
265 | ||
b33a84a3 MC |
266 | switch (type) { |
267 | case ISCSI_BOOT_INI_INDEX: | |
138fe4e0 KR |
268 | str += sprintf(str, "%d\n", initiator->hdr.index); |
269 | break; | |
b33a84a3 | 270 | case ISCSI_BOOT_INI_FLAGS: |
138fe4e0 KR |
271 | str += sprintf(str, "%d\n", initiator->hdr.flags); |
272 | break; | |
b33a84a3 | 273 | case ISCSI_BOOT_INI_ISNS_SERVER: |
138fe4e0 KR |
274 | str += sprintf_ipaddr(str, initiator->isns_server); |
275 | break; | |
b33a84a3 | 276 | case ISCSI_BOOT_INI_SLP_SERVER: |
138fe4e0 KR |
277 | str += sprintf_ipaddr(str, initiator->slp_server); |
278 | break; | |
b33a84a3 | 279 | case ISCSI_BOOT_INI_PRI_RADIUS_SERVER: |
138fe4e0 KR |
280 | str += sprintf_ipaddr(str, initiator->pri_radius_server); |
281 | break; | |
b33a84a3 | 282 | case ISCSI_BOOT_INI_SEC_RADIUS_SERVER: |
138fe4e0 KR |
283 | str += sprintf_ipaddr(str, initiator->sec_radius_server); |
284 | break; | |
b33a84a3 | 285 | case ISCSI_BOOT_INI_INITIATOR_NAME: |
138fe4e0 KR |
286 | str += sprintf_string(str, initiator->initiator_name_len, |
287 | (char *)ibft_loc + | |
288 | initiator->initiator_name_off); | |
289 | break; | |
290 | default: | |
291 | break; | |
292 | } | |
293 | ||
294 | return str - buf; | |
295 | } | |
296 | ||
b33a84a3 | 297 | static ssize_t ibft_attr_show_nic(void *data, int type, char *buf) |
138fe4e0 | 298 | { |
b33a84a3 | 299 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
300 | struct ibft_nic *nic = entry->nic; |
301 | void *ibft_loc = entry->header; | |
302 | char *str = buf; | |
00e7825b | 303 | __be32 val; |
138fe4e0 KR |
304 | |
305 | if (!nic) | |
306 | return 0; | |
307 | ||
b33a84a3 MC |
308 | switch (type) { |
309 | case ISCSI_BOOT_ETH_INDEX: | |
138fe4e0 KR |
310 | str += sprintf(str, "%d\n", nic->hdr.index); |
311 | break; | |
b33a84a3 | 312 | case ISCSI_BOOT_ETH_FLAGS: |
138fe4e0 KR |
313 | str += sprintf(str, "%d\n", nic->hdr.flags); |
314 | break; | |
b33a84a3 | 315 | case ISCSI_BOOT_ETH_IP_ADDR: |
138fe4e0 KR |
316 | str += sprintf_ipaddr(str, nic->ip_addr); |
317 | break; | |
b33a84a3 | 318 | case ISCSI_BOOT_ETH_SUBNET_MASK: |
00e7825b JP |
319 | val = cpu_to_be32(~((1 << (32-nic->subnet_mask_prefix))-1)); |
320 | str += sprintf(str, "%pI4", &val); | |
138fe4e0 | 321 | break; |
c988cabe HR |
322 | case ISCSI_BOOT_ETH_PREFIX_LEN: |
323 | str += sprintf(str, "%d\n", nic->subnet_mask_prefix); | |
324 | break; | |
b33a84a3 | 325 | case ISCSI_BOOT_ETH_ORIGIN: |
138fe4e0 KR |
326 | str += sprintf(str, "%d\n", nic->origin); |
327 | break; | |
b33a84a3 | 328 | case ISCSI_BOOT_ETH_GATEWAY: |
138fe4e0 KR |
329 | str += sprintf_ipaddr(str, nic->gateway); |
330 | break; | |
b33a84a3 | 331 | case ISCSI_BOOT_ETH_PRIMARY_DNS: |
138fe4e0 KR |
332 | str += sprintf_ipaddr(str, nic->primary_dns); |
333 | break; | |
b33a84a3 | 334 | case ISCSI_BOOT_ETH_SECONDARY_DNS: |
138fe4e0 KR |
335 | str += sprintf_ipaddr(str, nic->secondary_dns); |
336 | break; | |
b33a84a3 | 337 | case ISCSI_BOOT_ETH_DHCP: |
138fe4e0 KR |
338 | str += sprintf_ipaddr(str, nic->dhcp); |
339 | break; | |
b33a84a3 | 340 | case ISCSI_BOOT_ETH_VLAN: |
138fe4e0 KR |
341 | str += sprintf(str, "%d\n", nic->vlan); |
342 | break; | |
b33a84a3 | 343 | case ISCSI_BOOT_ETH_MAC: |
2c352948 | 344 | str += sprintf(str, "%pM\n", nic->mac); |
138fe4e0 | 345 | break; |
b33a84a3 | 346 | case ISCSI_BOOT_ETH_HOSTNAME: |
138fe4e0 KR |
347 | str += sprintf_string(str, nic->hostname_len, |
348 | (char *)ibft_loc + nic->hostname_off); | |
349 | break; | |
350 | default: | |
351 | break; | |
352 | } | |
353 | ||
354 | return str - buf; | |
355 | }; | |
356 | ||
b33a84a3 | 357 | static ssize_t ibft_attr_show_target(void *data, int type, char *buf) |
138fe4e0 | 358 | { |
b33a84a3 | 359 | struct ibft_kobject *entry = data; |
138fe4e0 KR |
360 | struct ibft_tgt *tgt = entry->tgt; |
361 | void *ibft_loc = entry->header; | |
362 | char *str = buf; | |
363 | int i; | |
364 | ||
365 | if (!tgt) | |
366 | return 0; | |
367 | ||
b33a84a3 MC |
368 | switch (type) { |
369 | case ISCSI_BOOT_TGT_INDEX: | |
138fe4e0 KR |
370 | str += sprintf(str, "%d\n", tgt->hdr.index); |
371 | break; | |
b33a84a3 | 372 | case ISCSI_BOOT_TGT_FLAGS: |
138fe4e0 KR |
373 | str += sprintf(str, "%d\n", tgt->hdr.flags); |
374 | break; | |
b33a84a3 | 375 | case ISCSI_BOOT_TGT_IP_ADDR: |
138fe4e0 KR |
376 | str += sprintf_ipaddr(str, tgt->ip_addr); |
377 | break; | |
b33a84a3 | 378 | case ISCSI_BOOT_TGT_PORT: |
138fe4e0 KR |
379 | str += sprintf(str, "%d\n", tgt->port); |
380 | break; | |
b33a84a3 | 381 | case ISCSI_BOOT_TGT_LUN: |
138fe4e0 KR |
382 | for (i = 0; i < 8; i++) |
383 | str += sprintf(str, "%x", (u8)tgt->lun[i]); | |
384 | str += sprintf(str, "\n"); | |
385 | break; | |
b33a84a3 | 386 | case ISCSI_BOOT_TGT_NIC_ASSOC: |
138fe4e0 KR |
387 | str += sprintf(str, "%d\n", tgt->nic_assoc); |
388 | break; | |
b33a84a3 | 389 | case ISCSI_BOOT_TGT_CHAP_TYPE: |
138fe4e0 KR |
390 | str += sprintf(str, "%d\n", tgt->chap_type); |
391 | break; | |
b33a84a3 | 392 | case ISCSI_BOOT_TGT_NAME: |
138fe4e0 KR |
393 | str += sprintf_string(str, tgt->tgt_name_len, |
394 | (char *)ibft_loc + tgt->tgt_name_off); | |
395 | break; | |
b33a84a3 | 396 | case ISCSI_BOOT_TGT_CHAP_NAME: |
138fe4e0 KR |
397 | str += sprintf_string(str, tgt->chap_name_len, |
398 | (char *)ibft_loc + tgt->chap_name_off); | |
399 | break; | |
b33a84a3 | 400 | case ISCSI_BOOT_TGT_CHAP_SECRET: |
138fe4e0 KR |
401 | str += sprintf_string(str, tgt->chap_secret_len, |
402 | (char *)ibft_loc + tgt->chap_secret_off); | |
403 | break; | |
b33a84a3 | 404 | case ISCSI_BOOT_TGT_REV_CHAP_NAME: |
138fe4e0 KR |
405 | str += sprintf_string(str, tgt->rev_chap_name_len, |
406 | (char *)ibft_loc + | |
407 | tgt->rev_chap_name_off); | |
408 | break; | |
b33a84a3 | 409 | case ISCSI_BOOT_TGT_REV_CHAP_SECRET: |
138fe4e0 KR |
410 | str += sprintf_string(str, tgt->rev_chap_secret_len, |
411 | (char *)ibft_loc + | |
412 | tgt->rev_chap_secret_off); | |
413 | break; | |
414 | default: | |
415 | break; | |
416 | } | |
417 | ||
418 | return str - buf; | |
419 | } | |
420 | ||
138fe4e0 KR |
421 | static int __init ibft_check_device(void) |
422 | { | |
423 | int len; | |
424 | u8 *pos; | |
425 | u8 csum = 0; | |
426 | ||
4e639fdf | 427 | len = ibft_addr->header.length; |
138fe4e0 KR |
428 | |
429 | /* Sanity checking of iBFT. */ | |
4e639fdf | 430 | if (ibft_addr->header.revision != 1) { |
138fe4e0 | 431 | printk(KERN_ERR "iBFT module supports only revision 1, " \ |
4e639fdf PJ |
432 | "while this is %d.\n", |
433 | ibft_addr->header.revision); | |
138fe4e0 KR |
434 | return -ENOENT; |
435 | } | |
436 | for (pos = (u8 *)ibft_addr; pos < (u8 *)ibft_addr + len; pos++) | |
437 | csum += *pos; | |
438 | ||
439 | if (csum) { | |
440 | printk(KERN_ERR "iBFT has incorrect checksum (0x%x)!\n", csum); | |
441 | return -ENOENT; | |
442 | } | |
443 | ||
444 | return 0; | |
445 | } | |
446 | ||
b33a84a3 MC |
447 | /* |
448 | * Helper routiners to check to determine if the entry is valid | |
449 | * in the proper iBFT structure. | |
450 | */ | |
587a1f16 | 451 | static umode_t ibft_check_nic_for(void *data, int type) |
b33a84a3 MC |
452 | { |
453 | struct ibft_kobject *entry = data; | |
454 | struct ibft_nic *nic = entry->nic; | |
587a1f16 | 455 | umode_t rc = 0; |
b33a84a3 MC |
456 | |
457 | switch (type) { | |
458 | case ISCSI_BOOT_ETH_INDEX: | |
459 | case ISCSI_BOOT_ETH_FLAGS: | |
460 | rc = S_IRUGO; | |
461 | break; | |
462 | case ISCSI_BOOT_ETH_IP_ADDR: | |
e6050b61 | 463 | if (address_not_null(nic->ip_addr)) |
b33a84a3 MC |
464 | rc = S_IRUGO; |
465 | break; | |
c988cabe | 466 | case ISCSI_BOOT_ETH_PREFIX_LEN: |
b33a84a3 MC |
467 | case ISCSI_BOOT_ETH_SUBNET_MASK: |
468 | if (nic->subnet_mask_prefix) | |
469 | rc = S_IRUGO; | |
470 | break; | |
471 | case ISCSI_BOOT_ETH_ORIGIN: | |
472 | rc = S_IRUGO; | |
473 | break; | |
474 | case ISCSI_BOOT_ETH_GATEWAY: | |
e6050b61 | 475 | if (address_not_null(nic->gateway)) |
b33a84a3 MC |
476 | rc = S_IRUGO; |
477 | break; | |
478 | case ISCSI_BOOT_ETH_PRIMARY_DNS: | |
e6050b61 | 479 | if (address_not_null(nic->primary_dns)) |
b33a84a3 MC |
480 | rc = S_IRUGO; |
481 | break; | |
482 | case ISCSI_BOOT_ETH_SECONDARY_DNS: | |
e6050b61 | 483 | if (address_not_null(nic->secondary_dns)) |
b33a84a3 MC |
484 | rc = S_IRUGO; |
485 | break; | |
486 | case ISCSI_BOOT_ETH_DHCP: | |
e6050b61 | 487 | if (address_not_null(nic->dhcp)) |
b33a84a3 MC |
488 | rc = S_IRUGO; |
489 | break; | |
490 | case ISCSI_BOOT_ETH_VLAN: | |
491 | case ISCSI_BOOT_ETH_MAC: | |
492 | rc = S_IRUGO; | |
493 | break; | |
494 | case ISCSI_BOOT_ETH_HOSTNAME: | |
495 | if (nic->hostname_off) | |
496 | rc = S_IRUGO; | |
497 | break; | |
498 | default: | |
499 | break; | |
500 | } | |
501 | ||
502 | return rc; | |
503 | } | |
504 | ||
587a1f16 | 505 | static umode_t __init ibft_check_tgt_for(void *data, int type) |
b33a84a3 MC |
506 | { |
507 | struct ibft_kobject *entry = data; | |
508 | struct ibft_tgt *tgt = entry->tgt; | |
587a1f16 | 509 | umode_t rc = 0; |
b33a84a3 MC |
510 | |
511 | switch (type) { | |
512 | case ISCSI_BOOT_TGT_INDEX: | |
513 | case ISCSI_BOOT_TGT_FLAGS: | |
514 | case ISCSI_BOOT_TGT_IP_ADDR: | |
515 | case ISCSI_BOOT_TGT_PORT: | |
516 | case ISCSI_BOOT_TGT_LUN: | |
517 | case ISCSI_BOOT_TGT_NIC_ASSOC: | |
518 | case ISCSI_BOOT_TGT_CHAP_TYPE: | |
519 | rc = S_IRUGO; | |
520 | case ISCSI_BOOT_TGT_NAME: | |
521 | if (tgt->tgt_name_len) | |
522 | rc = S_IRUGO; | |
523 | break; | |
524 | case ISCSI_BOOT_TGT_CHAP_NAME: | |
525 | case ISCSI_BOOT_TGT_CHAP_SECRET: | |
526 | if (tgt->chap_name_len) | |
527 | rc = S_IRUGO; | |
528 | break; | |
529 | case ISCSI_BOOT_TGT_REV_CHAP_NAME: | |
530 | case ISCSI_BOOT_TGT_REV_CHAP_SECRET: | |
531 | if (tgt->rev_chap_name_len) | |
532 | rc = S_IRUGO; | |
533 | break; | |
534 | default: | |
535 | break; | |
536 | } | |
537 | ||
538 | return rc; | |
539 | } | |
540 | ||
587a1f16 | 541 | static umode_t __init ibft_check_initiator_for(void *data, int type) |
b33a84a3 MC |
542 | { |
543 | struct ibft_kobject *entry = data; | |
544 | struct ibft_initiator *init = entry->initiator; | |
587a1f16 | 545 | umode_t rc = 0; |
b33a84a3 MC |
546 | |
547 | switch (type) { | |
548 | case ISCSI_BOOT_INI_INDEX: | |
549 | case ISCSI_BOOT_INI_FLAGS: | |
550 | rc = S_IRUGO; | |
551 | break; | |
552 | case ISCSI_BOOT_INI_ISNS_SERVER: | |
e6050b61 | 553 | if (address_not_null(init->isns_server)) |
b33a84a3 MC |
554 | rc = S_IRUGO; |
555 | break; | |
556 | case ISCSI_BOOT_INI_SLP_SERVER: | |
e6050b61 | 557 | if (address_not_null(init->slp_server)) |
b33a84a3 MC |
558 | rc = S_IRUGO; |
559 | break; | |
560 | case ISCSI_BOOT_INI_PRI_RADIUS_SERVER: | |
e6050b61 | 561 | if (address_not_null(init->pri_radius_server)) |
b33a84a3 MC |
562 | rc = S_IRUGO; |
563 | break; | |
564 | case ISCSI_BOOT_INI_SEC_RADIUS_SERVER: | |
e6050b61 | 565 | if (address_not_null(init->sec_radius_server)) |
b33a84a3 MC |
566 | rc = S_IRUGO; |
567 | break; | |
568 | case ISCSI_BOOT_INI_INITIATOR_NAME: | |
569 | if (init->initiator_name_len) | |
570 | rc = S_IRUGO; | |
571 | break; | |
572 | default: | |
573 | break; | |
574 | } | |
575 | ||
576 | return rc; | |
577 | } | |
578 | ||
f457a46f MC |
579 | static void ibft_kobj_release(void *data) |
580 | { | |
581 | kfree(data); | |
582 | } | |
583 | ||
138fe4e0 KR |
584 | /* |
585 | * Helper function for ibft_register_kobjects. | |
586 | */ | |
4e639fdf | 587 | static int __init ibft_create_kobject(struct acpi_table_ibft *header, |
b33a84a3 | 588 | struct ibft_hdr *hdr) |
138fe4e0 | 589 | { |
b33a84a3 | 590 | struct iscsi_boot_kobj *boot_kobj = NULL; |
138fe4e0 KR |
591 | struct ibft_kobject *ibft_kobj = NULL; |
592 | struct ibft_nic *nic = (struct ibft_nic *)hdr; | |
593 | struct pci_dev *pci_dev; | |
594 | int rc = 0; | |
595 | ||
596 | ibft_kobj = kzalloc(sizeof(*ibft_kobj), GFP_KERNEL); | |
597 | if (!ibft_kobj) | |
598 | return -ENOMEM; | |
599 | ||
600 | ibft_kobj->header = header; | |
601 | ibft_kobj->hdr = hdr; | |
602 | ||
603 | switch (hdr->id) { | |
604 | case id_initiator: | |
605 | rc = ibft_verify_hdr("initiator", hdr, id_initiator, | |
606 | sizeof(*ibft_kobj->initiator)); | |
b33a84a3 MC |
607 | if (rc) |
608 | break; | |
609 | ||
610 | boot_kobj = iscsi_boot_create_initiator(boot_kset, hdr->index, | |
611 | ibft_kobj, | |
612 | ibft_attr_show_initiator, | |
f457a46f MC |
613 | ibft_check_initiator_for, |
614 | ibft_kobj_release); | |
b33a84a3 MC |
615 | if (!boot_kobj) { |
616 | rc = -ENOMEM; | |
617 | goto free_ibft_obj; | |
618 | } | |
138fe4e0 KR |
619 | break; |
620 | case id_nic: | |
621 | rc = ibft_verify_hdr("ethernet", hdr, id_nic, | |
622 | sizeof(*ibft_kobj->nic)); | |
b33a84a3 MC |
623 | if (rc) |
624 | break; | |
625 | ||
626 | boot_kobj = iscsi_boot_create_ethernet(boot_kset, hdr->index, | |
627 | ibft_kobj, | |
628 | ibft_attr_show_nic, | |
f457a46f MC |
629 | ibft_check_nic_for, |
630 | ibft_kobj_release); | |
b33a84a3 MC |
631 | if (!boot_kobj) { |
632 | rc = -ENOMEM; | |
633 | goto free_ibft_obj; | |
634 | } | |
138fe4e0 KR |
635 | break; |
636 | case id_target: | |
637 | rc = ibft_verify_hdr("target", hdr, id_target, | |
638 | sizeof(*ibft_kobj->tgt)); | |
b33a84a3 MC |
639 | if (rc) |
640 | break; | |
641 | ||
642 | boot_kobj = iscsi_boot_create_target(boot_kset, hdr->index, | |
643 | ibft_kobj, | |
644 | ibft_attr_show_target, | |
f457a46f MC |
645 | ibft_check_tgt_for, |
646 | ibft_kobj_release); | |
b33a84a3 MC |
647 | if (!boot_kobj) { |
648 | rc = -ENOMEM; | |
649 | goto free_ibft_obj; | |
650 | } | |
138fe4e0 KR |
651 | break; |
652 | case id_reserved: | |
653 | case id_control: | |
654 | case id_extensions: | |
655 | /* Fields which we don't support. Ignore them */ | |
656 | rc = 1; | |
657 | break; | |
658 | default: | |
659 | printk(KERN_ERR "iBFT has unknown structure type (%d). " \ | |
660 | "Report this bug to %.6s!\n", hdr->id, | |
4e639fdf | 661 | header->header.oem_id); |
138fe4e0 KR |
662 | rc = 1; |
663 | break; | |
664 | } | |
665 | ||
666 | if (rc) { | |
667 | /* Skip adding this kobject, but exit with non-fatal error. */ | |
b33a84a3 MC |
668 | rc = 0; |
669 | goto free_ibft_obj; | |
138fe4e0 KR |
670 | } |
671 | ||
138fe4e0 KR |
672 | if (hdr->id == id_nic) { |
673 | /* | |
674 | * We don't search for the device in other domains than | |
675 | * zero. This is because on x86 platforms the BIOS | |
676 | * executes only devices which are in domain 0. Furthermore, the | |
677 | * iBFT spec doesn't have a domain id field :-( | |
678 | */ | |
679 | pci_dev = pci_get_bus_and_slot((nic->pci_bdf & 0xff00) >> 8, | |
680 | (nic->pci_bdf & 0xff)); | |
681 | if (pci_dev) { | |
b33a84a3 | 682 | rc = sysfs_create_link(&boot_kobj->kobj, |
138fe4e0 KR |
683 | &pci_dev->dev.kobj, "device"); |
684 | pci_dev_put(pci_dev); | |
685 | } | |
686 | } | |
b33a84a3 | 687 | return 0; |
138fe4e0 | 688 | |
b33a84a3 MC |
689 | free_ibft_obj: |
690 | kfree(ibft_kobj); | |
138fe4e0 | 691 | return rc; |
138fe4e0 KR |
692 | } |
693 | ||
694 | /* | |
695 | * Scan the IBFT table structure for the NIC and Target fields. When | |
696 | * found add them on the passed-in list. We do not support the other | |
697 | * fields at this point, so they are skipped. | |
698 | */ | |
b33a84a3 | 699 | static int __init ibft_register_kobjects(struct acpi_table_ibft *header) |
138fe4e0 KR |
700 | { |
701 | struct ibft_control *control = NULL; | |
702 | void *ptr, *end; | |
703 | int rc = 0; | |
704 | u16 offset; | |
705 | u16 eot_offset; | |
706 | ||
707 | control = (void *)header + sizeof(*header); | |
708 | end = (void *)control + control->hdr.length; | |
4e639fdf | 709 | eot_offset = (void *)header + header->header.length - (void *)control; |
138fe4e0 KR |
710 | rc = ibft_verify_hdr("control", (struct ibft_hdr *)control, id_control, |
711 | sizeof(*control)); | |
712 | ||
713 | /* iBFT table safety checking */ | |
714 | rc |= ((control->hdr.index) ? -ENODEV : 0); | |
715 | if (rc) { | |
716 | printk(KERN_ERR "iBFT error: Control header is invalid!\n"); | |
717 | return rc; | |
718 | } | |
719 | for (ptr = &control->initiator_off; ptr < end; ptr += sizeof(u16)) { | |
720 | offset = *(u16 *)ptr; | |
4e639fdf PJ |
721 | if (offset && offset < header->header.length && |
722 | offset < eot_offset) { | |
138fe4e0 | 723 | rc = ibft_create_kobject(header, |
b33a84a3 | 724 | (void *)header + offset); |
138fe4e0 KR |
725 | if (rc) |
726 | break; | |
727 | } | |
728 | } | |
729 | ||
730 | return rc; | |
731 | } | |
732 | ||
b33a84a3 | 733 | static void ibft_unregister(void) |
138fe4e0 | 734 | { |
b33a84a3 MC |
735 | struct iscsi_boot_kobj *boot_kobj, *tmp_kobj; |
736 | struct ibft_kobject *ibft_kobj; | |
737 | ||
738 | list_for_each_entry_safe(boot_kobj, tmp_kobj, | |
739 | &boot_kset->kobj_list, list) { | |
740 | ibft_kobj = boot_kobj->data; | |
741 | if (ibft_kobj->hdr->id == id_nic) | |
742 | sysfs_remove_link(&boot_kobj->kobj, "device"); | |
138fe4e0 | 743 | }; |
138fe4e0 KR |
744 | } |
745 | ||
b33a84a3 | 746 | static void ibft_cleanup(void) |
138fe4e0 | 747 | { |
a12415ff KRW |
748 | if (boot_kset) { |
749 | ibft_unregister(); | |
750 | iscsi_boot_destroy_kset(boot_kset); | |
751 | } | |
138fe4e0 KR |
752 | } |
753 | ||
b33a84a3 | 754 | static void __exit ibft_exit(void) |
138fe4e0 | 755 | { |
b33a84a3 | 756 | ibft_cleanup(); |
138fe4e0 KR |
757 | } |
758 | ||
935a9fee YL |
759 | #ifdef CONFIG_ACPI |
760 | static const struct { | |
761 | char *sign; | |
762 | } ibft_signs[] = { | |
763 | /* | |
764 | * One spec says "IBFT", the other says "iBFT". We have to check | |
765 | * for both. | |
766 | */ | |
767 | { ACPI_SIG_IBFT }, | |
768 | { "iBFT" }, | |
629c27aa | 769 | { "BIFT" }, /* Broadcom iSCSI Offload */ |
935a9fee YL |
770 | }; |
771 | ||
772 | static void __init acpi_find_ibft_region(void) | |
773 | { | |
774 | int i; | |
775 | struct acpi_table_header *table = NULL; | |
776 | ||
777 | if (acpi_disabled) | |
778 | return; | |
779 | ||
780 | for (i = 0; i < ARRAY_SIZE(ibft_signs) && !ibft_addr; i++) { | |
781 | acpi_get_table(ibft_signs[i].sign, 0, &table); | |
782 | ibft_addr = (struct acpi_table_ibft *)table; | |
783 | } | |
784 | } | |
785 | #else | |
786 | static void __init acpi_find_ibft_region(void) | |
787 | { | |
788 | } | |
789 | #endif | |
790 | ||
138fe4e0 KR |
791 | /* |
792 | * ibft_init() - creates sysfs tree entries for the iBFT data. | |
793 | */ | |
794 | static int __init ibft_init(void) | |
795 | { | |
796 | int rc = 0; | |
797 | ||
935a9fee YL |
798 | /* |
799 | As on UEFI systems the setup_arch()/find_ibft_region() | |
800 | is called before ACPI tables are parsed and it only does | |
801 | legacy finding. | |
802 | */ | |
803 | if (!ibft_addr) | |
804 | acpi_find_ibft_region(); | |
805 | ||
138fe4e0 | 806 | if (ibft_addr) { |
935a9fee | 807 | pr_info("iBFT detected.\n"); |
138fe4e0 KR |
808 | |
809 | rc = ibft_check_device(); | |
810 | if (rc) | |
b33a84a3 | 811 | return rc; |
138fe4e0 | 812 | |
b33a84a3 MC |
813 | boot_kset = iscsi_boot_create_kset("ibft"); |
814 | if (!boot_kset) | |
815 | return -ENOMEM; | |
138fe4e0 | 816 | |
b33a84a3 MC |
817 | /* Scan the IBFT for data and register the kobjects. */ |
818 | rc = ibft_register_kobjects(ibft_addr); | |
138fe4e0 KR |
819 | if (rc) |
820 | goto out_free; | |
821 | } else | |
822 | printk(KERN_INFO "No iBFT detected.\n"); | |
823 | ||
824 | return 0; | |
825 | ||
826 | out_free: | |
b33a84a3 | 827 | ibft_cleanup(); |
138fe4e0 KR |
828 | return rc; |
829 | } | |
830 | ||
138fe4e0 KR |
831 | module_init(ibft_init); |
832 | module_exit(ibft_exit); |