Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
4a9d2d8b AH |
2 | * This file is part of the zfcp device driver for |
3 | * FCP adapters for IBM System z9 and zSeries. | |
1da177e4 | 4 | * |
4a9d2d8b | 5 | * (C) Copyright IBM Corp. 2002, 2006 |
1da177e4 LT |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2, or (at your option) | |
10 | * any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
20 | */ | |
21 | ||
4a9d2d8b AH |
22 | /* |
23 | * Driver authors: | |
24 | * Martin Peschke (originator of the driver) | |
25 | * Raimund Schroeder | |
26 | * Aron Zeh | |
27 | * Wolfgang Taphorn | |
28 | * Stefan Bader | |
29 | * Heiko Carstens (kernel 2.6 port of the driver) | |
30 | * Andreas Herrmann | |
31 | * Maxim Shchetynin | |
32 | * Volker Sameske | |
33 | * Ralph Wuerthner | |
34 | */ | |
35 | ||
45633fdc | 36 | #include <linux/miscdevice.h> |
1da177e4 LT |
37 | #include "zfcp_ext.h" |
38 | ||
39 | /* accumulated log level (module parameter) */ | |
40 | static u32 loglevel = ZFCP_LOG_LEVEL_DEFAULTS; | |
41 | static char *device; | |
42 | /*********************** FUNCTION PROTOTYPES *********************************/ | |
43 | ||
44 | /* written against the module interface */ | |
45 | static int __init zfcp_module_init(void); | |
46 | ||
1da177e4 LT |
47 | /*********************** KERNEL/MODULE PARAMETERS ***************************/ |
48 | ||
49 | /* declare driver module init/cleanup functions */ | |
50 | module_init(zfcp_module_init); | |
51 | ||
4a9d2d8b | 52 | MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); |
1da177e4 | 53 | MODULE_DESCRIPTION |
4a9d2d8b | 54 | ("FCP (SCSI over Fibre Channel) HBA driver for IBM System z9 and zSeries"); |
1da177e4 LT |
55 | MODULE_LICENSE("GPL"); |
56 | ||
6f71d9bc | 57 | module_param(device, charp, 0400); |
1da177e4 LT |
58 | MODULE_PARM_DESC(device, "specify initial device"); |
59 | ||
6f71d9bc | 60 | module_param(loglevel, uint, 0400); |
1da177e4 LT |
61 | MODULE_PARM_DESC(loglevel, |
62 | "log levels, 8 nibbles: " | |
63 | "FC ERP QDIO CIO Config FSF SCSI Other, " | |
64 | "levels: 0=none 1=normal 2=devel 3=trace"); | |
65 | ||
1da177e4 LT |
66 | /****************************************************************/ |
67 | /************** Functions without logging ***********************/ | |
68 | /****************************************************************/ | |
69 | ||
70 | void | |
71 | _zfcp_hex_dump(char *addr, int count) | |
72 | { | |
73 | int i; | |
74 | for (i = 0; i < count; i++) { | |
75 | printk("%02x", addr[i]); | |
76 | if ((i % 4) == 3) | |
77 | printk(" "); | |
78 | if ((i % 32) == 31) | |
79 | printk("\n"); | |
80 | } | |
81 | if (((i-1) % 32) != 31) | |
82 | printk("\n"); | |
83 | } | |
84 | ||
fea9d6c7 VS |
85 | |
86 | /****************************************************************/ | |
87 | /****** Functions to handle the request ID hash table ********/ | |
88 | /****************************************************************/ | |
89 | ||
90 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_FSF | |
91 | ||
ca2d02c2 | 92 | static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) |
fea9d6c7 | 93 | { |
ca2d02c2 | 94 | int idx; |
fea9d6c7 VS |
95 | |
96 | adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), | |
97 | GFP_KERNEL); | |
fea9d6c7 VS |
98 | if (!adapter->req_list) |
99 | return -ENOMEM; | |
100 | ||
ca2d02c2 HC |
101 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) |
102 | INIT_LIST_HEAD(&adapter->req_list[idx]); | |
fea9d6c7 VS |
103 | return 0; |
104 | } | |
105 | ||
106 | static void zfcp_reqlist_free(struct zfcp_adapter *adapter) | |
107 | { | |
fea9d6c7 VS |
108 | kfree(adapter->req_list); |
109 | } | |
110 | ||
fea9d6c7 VS |
111 | int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) |
112 | { | |
ca2d02c2 | 113 | unsigned int idx; |
fea9d6c7 | 114 | |
ca2d02c2 HC |
115 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) |
116 | if (!list_empty(&adapter->req_list[idx])) | |
fea9d6c7 | 117 | return 0; |
fea9d6c7 VS |
118 | return 1; |
119 | } | |
120 | ||
121 | #undef ZFCP_LOG_AREA | |
122 | ||
1da177e4 LT |
123 | /****************************************************************/ |
124 | /************** Uncategorised Functions *************************/ | |
125 | /****************************************************************/ | |
126 | ||
127 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER | |
128 | ||
1da177e4 LT |
129 | /** |
130 | * zfcp_device_setup - setup function | |
131 | * @str: pointer to parameter string | |
132 | * | |
133 | * Parse "device=..." parameter string. | |
134 | */ | |
135 | static int __init | |
cd8a383e | 136 | zfcp_device_setup(char *devstr) |
1da177e4 | 137 | { |
cd8a383e AH |
138 | char *tmp, *str; |
139 | size_t len; | |
1da177e4 | 140 | |
cd8a383e | 141 | if (!devstr) |
1da177e4 LT |
142 | return 0; |
143 | ||
cd8a383e | 144 | len = strlen(devstr) + 1; |
5cbded58 | 145 | str = kmalloc(len, GFP_KERNEL); |
cd8a383e AH |
146 | if (!str) |
147 | goto err_out; | |
148 | memcpy(str, devstr, len); | |
149 | ||
1da177e4 LT |
150 | tmp = strchr(str, ','); |
151 | if (!tmp) | |
152 | goto err_out; | |
153 | *tmp++ = '\0'; | |
154 | strncpy(zfcp_data.init_busid, str, BUS_ID_SIZE); | |
155 | zfcp_data.init_busid[BUS_ID_SIZE-1] = '\0'; | |
156 | ||
157 | zfcp_data.init_wwpn = simple_strtoull(tmp, &tmp, 0); | |
158 | if (*tmp++ != ',') | |
159 | goto err_out; | |
160 | if (*tmp == '\0') | |
161 | goto err_out; | |
162 | ||
163 | zfcp_data.init_fcp_lun = simple_strtoull(tmp, &tmp, 0); | |
164 | if (*tmp != '\0') | |
165 | goto err_out; | |
cd8a383e | 166 | kfree(str); |
1da177e4 LT |
167 | return 1; |
168 | ||
169 | err_out: | |
170 | ZFCP_LOG_NORMAL("Parse error for device parameter string %s\n", str); | |
cd8a383e | 171 | kfree(str); |
1da177e4 LT |
172 | return 0; |
173 | } | |
174 | ||
175 | static void __init | |
176 | zfcp_init_device_configure(void) | |
177 | { | |
178 | struct zfcp_adapter *adapter; | |
179 | struct zfcp_port *port; | |
180 | struct zfcp_unit *unit; | |
181 | ||
182 | down(&zfcp_data.config_sema); | |
183 | read_lock_irq(&zfcp_data.config_lock); | |
184 | adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid); | |
185 | if (adapter) | |
186 | zfcp_adapter_get(adapter); | |
187 | read_unlock_irq(&zfcp_data.config_lock); | |
188 | ||
189 | if (adapter == NULL) | |
190 | goto out_adapter; | |
191 | port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0); | |
192 | if (!port) | |
193 | goto out_port; | |
194 | unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun); | |
195 | if (!unit) | |
196 | goto out_unit; | |
197 | up(&zfcp_data.config_sema); | |
198 | ccw_device_set_online(adapter->ccw_device); | |
199 | zfcp_erp_wait(adapter); | |
200 | down(&zfcp_data.config_sema); | |
201 | zfcp_unit_put(unit); | |
202 | out_unit: | |
203 | zfcp_port_put(port); | |
204 | out_port: | |
205 | zfcp_adapter_put(adapter); | |
206 | out_adapter: | |
207 | up(&zfcp_data.config_sema); | |
208 | return; | |
209 | } | |
210 | ||
dd52e0ea HC |
211 | static int calc_alignment(int size) |
212 | { | |
213 | int align = 1; | |
214 | ||
215 | if (!size) | |
216 | return 0; | |
217 | ||
218 | while ((size - align) > 0) | |
219 | align <<= 1; | |
220 | ||
221 | return align; | |
222 | } | |
223 | ||
1da177e4 LT |
224 | static int __init |
225 | zfcp_module_init(void) | |
226 | { | |
dd52e0ea HC |
227 | int retval = -ENOMEM; |
228 | int size, align; | |
229 | ||
230 | size = sizeof(struct zfcp_fsf_req_qtcb); | |
231 | align = calc_alignment(size); | |
232 | zfcp_data.fsf_req_qtcb_cache = | |
20c2df83 | 233 | kmem_cache_create("zfcp_fsf", size, align, 0, NULL); |
dd52e0ea HC |
234 | if (!zfcp_data.fsf_req_qtcb_cache) |
235 | goto out; | |
1da177e4 | 236 | |
dd52e0ea HC |
237 | size = sizeof(struct fsf_status_read_buffer); |
238 | align = calc_alignment(size); | |
239 | zfcp_data.sr_buffer_cache = | |
20c2df83 | 240 | kmem_cache_create("zfcp_sr", size, align, 0, NULL); |
dd52e0ea HC |
241 | if (!zfcp_data.sr_buffer_cache) |
242 | goto out_sr_cache; | |
243 | ||
244 | size = sizeof(struct zfcp_gid_pn_data); | |
245 | align = calc_alignment(size); | |
246 | zfcp_data.gid_pn_cache = | |
20c2df83 | 247 | kmem_cache_create("zfcp_gid", size, align, 0, NULL); |
dd52e0ea HC |
248 | if (!zfcp_data.gid_pn_cache) |
249 | goto out_gid_cache; | |
1da177e4 LT |
250 | |
251 | atomic_set(&zfcp_data.loglevel, loglevel); | |
252 | ||
253 | /* initialize adapter list */ | |
254 | INIT_LIST_HEAD(&zfcp_data.adapter_list_head); | |
255 | ||
256 | /* initialize adapters to be removed list head */ | |
257 | INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh); | |
258 | ||
dd52e0ea HC |
259 | zfcp_data.scsi_transport_template = |
260 | fc_attach_transport(&zfcp_transport_functions); | |
261 | if (!zfcp_data.scsi_transport_template) | |
262 | goto out_transport; | |
1da177e4 | 263 | |
1da177e4 LT |
264 | retval = misc_register(&zfcp_cfdc_misc); |
265 | if (retval != 0) { | |
266 | ZFCP_LOG_INFO("registration of misc device " | |
267 | "zfcp_cfdc failed\n"); | |
dd52e0ea | 268 | goto out_misc; |
1da177e4 LT |
269 | } |
270 | ||
271 | /* Initialise proc semaphores */ | |
272 | sema_init(&zfcp_data.config_sema, 1); | |
273 | ||
274 | /* initialise configuration rw lock */ | |
275 | rwlock_init(&zfcp_data.config_lock); | |
276 | ||
1da177e4 LT |
277 | /* setup dynamic I/O */ |
278 | retval = zfcp_ccw_register(); | |
279 | if (retval) { | |
280 | ZFCP_LOG_NORMAL("registration with common I/O layer failed\n"); | |
281 | goto out_ccw_register; | |
282 | } | |
283 | ||
284 | if (zfcp_device_setup(device)) | |
285 | zfcp_init_device_configure(); | |
286 | ||
287 | goto out; | |
288 | ||
289 | out_ccw_register: | |
290 | misc_deregister(&zfcp_cfdc_misc); | |
dd52e0ea HC |
291 | out_misc: |
292 | fc_release_transport(zfcp_data.scsi_transport_template); | |
293 | out_transport: | |
294 | kmem_cache_destroy(zfcp_data.gid_pn_cache); | |
295 | out_gid_cache: | |
296 | kmem_cache_destroy(zfcp_data.sr_buffer_cache); | |
297 | out_sr_cache: | |
298 | kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); | |
1da177e4 LT |
299 | out: |
300 | return retval; | |
301 | } | |
302 | ||
1da177e4 LT |
303 | #undef ZFCP_LOG_AREA |
304 | ||
305 | /****************************************************************/ | |
306 | /****** Functions for configuration/set-up of structures ********/ | |
307 | /****************************************************************/ | |
308 | ||
309 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG | |
310 | ||
311 | /** | |
312 | * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN | |
313 | * @port: pointer to port to search for unit | |
314 | * @fcp_lun: FCP LUN to search for | |
315 | * Traverse list of all units of a port and return pointer to a unit | |
316 | * with the given FCP LUN. | |
317 | */ | |
318 | struct zfcp_unit * | |
319 | zfcp_get_unit_by_lun(struct zfcp_port *port, fcp_lun_t fcp_lun) | |
320 | { | |
321 | struct zfcp_unit *unit; | |
322 | int found = 0; | |
323 | ||
324 | list_for_each_entry(unit, &port->unit_list_head, list) { | |
325 | if ((unit->fcp_lun == fcp_lun) && | |
326 | !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status)) | |
327 | { | |
328 | found = 1; | |
329 | break; | |
330 | } | |
331 | } | |
332 | return found ? unit : NULL; | |
333 | } | |
334 | ||
335 | /** | |
336 | * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn | |
337 | * @adapter: pointer to adapter to search for port | |
338 | * @wwpn: wwpn to search for | |
339 | * Traverse list of all ports of an adapter and return pointer to a port | |
340 | * with the given wwpn. | |
341 | */ | |
342 | struct zfcp_port * | |
343 | zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, wwn_t wwpn) | |
344 | { | |
345 | struct zfcp_port *port; | |
346 | int found = 0; | |
347 | ||
348 | list_for_each_entry(port, &adapter->port_list_head, list) { | |
349 | if ((port->wwpn == wwpn) && | |
350 | !(atomic_read(&port->status) & | |
351 | (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) { | |
352 | found = 1; | |
353 | break; | |
354 | } | |
355 | } | |
356 | return found ? port : NULL; | |
357 | } | |
358 | ||
359 | /** | |
360 | * zfcp_get_port_by_did - find port in port list of adapter by d_id | |
361 | * @adapter: pointer to adapter to search for port | |
362 | * @d_id: d_id to search for | |
363 | * Traverse list of all ports of an adapter and return pointer to a port | |
364 | * with the given d_id. | |
365 | */ | |
366 | struct zfcp_port * | |
367 | zfcp_get_port_by_did(struct zfcp_adapter *adapter, u32 d_id) | |
368 | { | |
369 | struct zfcp_port *port; | |
370 | int found = 0; | |
371 | ||
372 | list_for_each_entry(port, &adapter->port_list_head, list) { | |
373 | if ((port->d_id == d_id) && | |
374 | !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status)) | |
375 | { | |
376 | found = 1; | |
377 | break; | |
378 | } | |
379 | } | |
380 | return found ? port : NULL; | |
381 | } | |
382 | ||
383 | /** | |
384 | * zfcp_get_adapter_by_busid - find adpater in adapter list by bus_id | |
385 | * @bus_id: bus_id to search for | |
386 | * Traverse list of all adapters and return pointer to an adapter | |
387 | * with the given bus_id. | |
388 | */ | |
389 | struct zfcp_adapter * | |
390 | zfcp_get_adapter_by_busid(char *bus_id) | |
391 | { | |
392 | struct zfcp_adapter *adapter; | |
393 | int found = 0; | |
394 | ||
395 | list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) { | |
396 | if ((strncmp(bus_id, zfcp_get_busid_by_adapter(adapter), | |
397 | BUS_ID_SIZE) == 0) && | |
398 | !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, | |
399 | &adapter->status)){ | |
400 | found = 1; | |
401 | break; | |
402 | } | |
403 | } | |
404 | return found ? adapter : NULL; | |
405 | } | |
406 | ||
407 | /** | |
408 | * zfcp_unit_enqueue - enqueue unit to unit list of a port. | |
409 | * @port: pointer to port where unit is added | |
410 | * @fcp_lun: FCP LUN of unit to be enqueued | |
411 | * Return: pointer to enqueued unit on success, NULL on error | |
412 | * Locks: config_sema must be held to serialize changes to the unit list | |
413 | * | |
414 | * Sets up some unit internal structures and creates sysfs entry. | |
415 | */ | |
416 | struct zfcp_unit * | |
417 | zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) | |
418 | { | |
462b7859 | 419 | struct zfcp_unit *unit; |
1da177e4 LT |
420 | |
421 | /* | |
422 | * check that there is no unit with this FCP_LUN already in list | |
423 | * and enqueue it. | |
424 | * Note: Unlike for the adapter and the port, this is an error | |
425 | */ | |
426 | read_lock_irq(&zfcp_data.config_lock); | |
427 | unit = zfcp_get_unit_by_lun(port, fcp_lun); | |
428 | read_unlock_irq(&zfcp_data.config_lock); | |
429 | if (unit) | |
430 | return NULL; | |
431 | ||
ec4081c6 | 432 | unit = kzalloc(sizeof (struct zfcp_unit), GFP_KERNEL); |
1da177e4 LT |
433 | if (!unit) |
434 | return NULL; | |
1da177e4 LT |
435 | |
436 | /* initialise reference count stuff */ | |
437 | atomic_set(&unit->refcount, 0); | |
438 | init_waitqueue_head(&unit->remove_wq); | |
439 | ||
440 | unit->port = port; | |
441 | unit->fcp_lun = fcp_lun; | |
442 | ||
443 | /* setup for sysfs registration */ | |
444 | snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun); | |
445 | unit->sysfs_device.parent = &port->sysfs_device; | |
446 | unit->sysfs_device.release = zfcp_sysfs_unit_release; | |
447 | dev_set_drvdata(&unit->sysfs_device, unit); | |
448 | ||
449 | /* mark unit unusable as long as sysfs registration is not complete */ | |
450 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); | |
451 | ||
c9615858 CS |
452 | spin_lock_init(&unit->latencies.lock); |
453 | unit->latencies.write.channel.min = 0xFFFFFFFF; | |
454 | unit->latencies.write.fabric.min = 0xFFFFFFFF; | |
455 | unit->latencies.read.channel.min = 0xFFFFFFFF; | |
456 | unit->latencies.read.fabric.min = 0xFFFFFFFF; | |
457 | unit->latencies.cmd.channel.min = 0xFFFFFFFF; | |
458 | unit->latencies.cmd.fabric.min = 0xFFFFFFFF; | |
459 | ||
1da177e4 LT |
460 | if (device_register(&unit->sysfs_device)) { |
461 | kfree(unit); | |
462 | return NULL; | |
463 | } | |
464 | ||
465 | if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) { | |
466 | device_unregister(&unit->sysfs_device); | |
467 | return NULL; | |
468 | } | |
469 | ||
470 | zfcp_unit_get(unit); | |
462b7859 | 471 | unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun); |
1da177e4 | 472 | |
1da177e4 | 473 | write_lock_irq(&zfcp_data.config_lock); |
462b7859 | 474 | list_add_tail(&unit->list, &port->unit_list_head); |
1da177e4 LT |
475 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); |
476 | atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); | |
477 | write_unlock_irq(&zfcp_data.config_lock); | |
478 | ||
479 | port->units++; | |
480 | zfcp_port_get(port); | |
481 | ||
482 | return unit; | |
483 | } | |
484 | ||
485 | void | |
486 | zfcp_unit_dequeue(struct zfcp_unit *unit) | |
487 | { | |
488 | zfcp_unit_wait(unit); | |
489 | write_lock_irq(&zfcp_data.config_lock); | |
490 | list_del(&unit->list); | |
491 | write_unlock_irq(&zfcp_data.config_lock); | |
492 | unit->port->units--; | |
493 | zfcp_port_put(unit->port); | |
494 | zfcp_sysfs_unit_remove_files(&unit->sysfs_device); | |
495 | device_unregister(&unit->sysfs_device); | |
496 | } | |
497 | ||
1da177e4 LT |
498 | /* |
499 | * Allocates a combined QTCB/fsf_req buffer for erp actions and fcp/SCSI | |
500 | * commands. | |
41fa2ada | 501 | * It also genrates fcp-nameserver request/response buffer and unsolicited |
1da177e4 LT |
502 | * status read fsf_req buffers. |
503 | * | |
504 | * locks: must only be called with zfcp_data.config_sema taken | |
505 | */ | |
506 | static int | |
507 | zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) | |
508 | { | |
509 | adapter->pool.fsf_req_erp = | |
dd52e0ea HC |
510 | mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ERP_NR, |
511 | zfcp_data.fsf_req_qtcb_cache); | |
0eaae62a | 512 | if (!adapter->pool.fsf_req_erp) |
1da177e4 LT |
513 | return -ENOMEM; |
514 | ||
515 | adapter->pool.fsf_req_scsi = | |
dd52e0ea HC |
516 | mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_SCSI_NR, |
517 | zfcp_data.fsf_req_qtcb_cache); | |
0eaae62a | 518 | if (!adapter->pool.fsf_req_scsi) |
1da177e4 LT |
519 | return -ENOMEM; |
520 | ||
521 | adapter->pool.fsf_req_abort = | |
dd52e0ea HC |
522 | mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ABORT_NR, |
523 | zfcp_data.fsf_req_qtcb_cache); | |
0eaae62a | 524 | if (!adapter->pool.fsf_req_abort) |
1da177e4 LT |
525 | return -ENOMEM; |
526 | ||
527 | adapter->pool.fsf_req_status_read = | |
0eaae62a MD |
528 | mempool_create_kmalloc_pool(ZFCP_POOL_STATUS_READ_NR, |
529 | sizeof(struct zfcp_fsf_req)); | |
530 | if (!adapter->pool.fsf_req_status_read) | |
1da177e4 LT |
531 | return -ENOMEM; |
532 | ||
533 | adapter->pool.data_status_read = | |
dd52e0ea HC |
534 | mempool_create_slab_pool(ZFCP_POOL_STATUS_READ_NR, |
535 | zfcp_data.sr_buffer_cache); | |
0eaae62a | 536 | if (!adapter->pool.data_status_read) |
1da177e4 LT |
537 | return -ENOMEM; |
538 | ||
539 | adapter->pool.data_gid_pn = | |
dd52e0ea HC |
540 | mempool_create_slab_pool(ZFCP_POOL_DATA_GID_PN_NR, |
541 | zfcp_data.gid_pn_cache); | |
0eaae62a | 542 | if (!adapter->pool.data_gid_pn) |
1da177e4 LT |
543 | return -ENOMEM; |
544 | ||
545 | return 0; | |
546 | } | |
547 | ||
548 | /** | |
549 | * zfcp_free_low_mem_buffers - free memory pools of an adapter | |
550 | * @adapter: pointer to zfcp_adapter for which memory pools should be freed | |
551 | * locking: zfcp_data.config_sema must be held | |
552 | */ | |
553 | static void | |
554 | zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) | |
555 | { | |
556 | if (adapter->pool.fsf_req_erp) | |
557 | mempool_destroy(adapter->pool.fsf_req_erp); | |
558 | if (adapter->pool.fsf_req_scsi) | |
559 | mempool_destroy(adapter->pool.fsf_req_scsi); | |
560 | if (adapter->pool.fsf_req_abort) | |
561 | mempool_destroy(adapter->pool.fsf_req_abort); | |
562 | if (adapter->pool.fsf_req_status_read) | |
563 | mempool_destroy(adapter->pool.fsf_req_status_read); | |
564 | if (adapter->pool.data_status_read) | |
565 | mempool_destroy(adapter->pool.data_status_read); | |
566 | if (adapter->pool.data_gid_pn) | |
567 | mempool_destroy(adapter->pool.data_gid_pn); | |
568 | } | |
569 | ||
763968e2 | 570 | static void zfcp_dummy_release(struct device *dev) |
1da177e4 LT |
571 | { |
572 | return; | |
573 | } | |
574 | ||
d26ab06e SS |
575 | int zfcp_status_read_refill(struct zfcp_adapter *adapter) |
576 | { | |
577 | while (atomic_read(&adapter->stat_miss) > 0) | |
578 | if (zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL)) | |
579 | break; | |
580 | else | |
581 | atomic_dec(&adapter->stat_miss); | |
582 | ||
583 | if (ZFCP_STATUS_READS_RECOM <= atomic_read(&adapter->stat_miss)) { | |
584 | zfcp_erp_adapter_reopen(adapter, 0, 103, NULL); | |
585 | return 1; | |
586 | } | |
587 | return 0; | |
588 | } | |
589 | ||
590 | static void _zfcp_status_read_scheduler(struct work_struct *work) | |
591 | { | |
592 | zfcp_status_read_refill(container_of(work, struct zfcp_adapter, | |
593 | stat_work)); | |
594 | } | |
595 | ||
1da177e4 LT |
596 | /* |
597 | * Enqueues an adapter at the end of the adapter list in the driver data. | |
598 | * All adapter internal structures are set up. | |
599 | * Proc-fs entries are also created. | |
600 | * | |
601 | * returns: 0 if a new adapter was successfully enqueued | |
602 | * ZFCP_KNOWN if an adapter with this devno was already present | |
603 | * -ENOMEM if alloc failed | |
604 | * locks: config_sema must be held to serialise changes to the adapter list | |
605 | */ | |
606 | struct zfcp_adapter * | |
607 | zfcp_adapter_enqueue(struct ccw_device *ccw_device) | |
608 | { | |
1da177e4 LT |
609 | struct zfcp_adapter *adapter; |
610 | ||
611 | /* | |
41fa2ada | 612 | * Note: It is safe to release the list_lock, as any list changes |
1da177e4 LT |
613 | * are protected by the config_sema, which must be held to get here |
614 | */ | |
615 | ||
616 | /* try to allocate new adapter data structure (zeroed) */ | |
ec4081c6 | 617 | adapter = kzalloc(sizeof (struct zfcp_adapter), GFP_KERNEL); |
1da177e4 LT |
618 | if (!adapter) { |
619 | ZFCP_LOG_INFO("error: allocation of base adapter " | |
620 | "structure failed\n"); | |
621 | goto out; | |
622 | } | |
1da177e4 LT |
623 | |
624 | ccw_device->handler = NULL; | |
625 | ||
626 | /* save ccw_device pointer */ | |
627 | adapter->ccw_device = ccw_device; | |
628 | ||
00bab910 | 629 | if (zfcp_qdio_allocate(adapter)) |
1da177e4 LT |
630 | goto qdio_allocate_failed; |
631 | ||
00bab910 | 632 | if (zfcp_allocate_low_mem_buffers(adapter)) |
1da177e4 | 633 | goto failed_low_mem_buffers; |
1da177e4 LT |
634 | |
635 | /* initialise reference count stuff */ | |
636 | atomic_set(&adapter->refcount, 0); | |
637 | init_waitqueue_head(&adapter->remove_wq); | |
638 | ||
639 | /* initialise list of ports */ | |
640 | INIT_LIST_HEAD(&adapter->port_list_head); | |
641 | ||
642 | /* initialise list of ports to be removed */ | |
643 | INIT_LIST_HEAD(&adapter->port_remove_lh); | |
644 | ||
645 | /* initialize list of fsf requests */ | |
fea9d6c7 | 646 | spin_lock_init(&adapter->req_list_lock); |
00bab910 | 647 | if (zfcp_reqlist_alloc(adapter)) |
fea9d6c7 | 648 | goto failed_low_mem_buffers; |
1da177e4 | 649 | |
c48a29d0 HC |
650 | /* initialize debug locks */ |
651 | ||
c48a29d0 HC |
652 | spin_lock_init(&adapter->hba_dbf_lock); |
653 | spin_lock_init(&adapter->san_dbf_lock); | |
654 | spin_lock_init(&adapter->scsi_dbf_lock); | |
d79a83db | 655 | spin_lock_init(&adapter->rec_dbf_lock); |
c48a29d0 | 656 | |
00bab910 | 657 | if (zfcp_adapter_debug_register(adapter)) |
ff17a29d CS |
658 | goto debug_register_failed; |
659 | ||
c48a29d0 HC |
660 | /* initialize error recovery stuff */ |
661 | ||
662 | rwlock_init(&adapter->erp_lock); | |
663 | sema_init(&adapter->erp_ready_sem, 0); | |
664 | INIT_LIST_HEAD(&adapter->erp_ready_head); | |
665 | INIT_LIST_HEAD(&adapter->erp_running_head); | |
666 | ||
1da177e4 LT |
667 | /* initialize abort lock */ |
668 | rwlock_init(&adapter->abort_lock); | |
669 | ||
670 | /* initialise some erp stuff */ | |
671 | init_waitqueue_head(&adapter->erp_thread_wqh); | |
672 | init_waitqueue_head(&adapter->erp_done_wqh); | |
673 | ||
674 | /* initialize lock of associated request queue */ | |
00bab910 | 675 | rwlock_init(&adapter->req_q.lock); |
d26ab06e | 676 | INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); |
1da177e4 | 677 | |
1da177e4 LT |
678 | /* mark adapter unusable as long as sysfs registration is not complete */ |
679 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); | |
680 | ||
1da177e4 LT |
681 | dev_set_drvdata(&ccw_device->dev, adapter); |
682 | ||
683 | if (zfcp_sysfs_adapter_create_files(&ccw_device->dev)) | |
684 | goto sysfs_failed; | |
685 | ||
686 | adapter->generic_services.parent = &adapter->ccw_device->dev; | |
687 | adapter->generic_services.release = zfcp_dummy_release; | |
688 | snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE, | |
689 | "generic_services"); | |
690 | ||
691 | if (device_register(&adapter->generic_services)) | |
692 | goto generic_services_failed; | |
693 | ||
694 | /* put allocated adapter at list tail */ | |
695 | write_lock_irq(&zfcp_data.config_lock); | |
696 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); | |
697 | list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); | |
698 | write_unlock_irq(&zfcp_data.config_lock); | |
699 | ||
700 | zfcp_data.adapters++; | |
701 | ||
702 | goto out; | |
703 | ||
704 | generic_services_failed: | |
705 | zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); | |
706 | sysfs_failed: | |
ff17a29d CS |
707 | zfcp_adapter_debug_unregister(adapter); |
708 | debug_register_failed: | |
1da177e4 | 709 | dev_set_drvdata(&ccw_device->dev, NULL); |
ca2d02c2 | 710 | zfcp_reqlist_free(adapter); |
1da177e4 LT |
711 | failed_low_mem_buffers: |
712 | zfcp_free_low_mem_buffers(adapter); | |
1da177e4 | 713 | qdio_allocate_failed: |
00bab910 | 714 | zfcp_qdio_free(adapter); |
1da177e4 LT |
715 | kfree(adapter); |
716 | adapter = NULL; | |
717 | out: | |
718 | return adapter; | |
719 | } | |
720 | ||
721 | /* | |
722 | * returns: 0 - struct zfcp_adapter data structure successfully removed | |
723 | * !0 - struct zfcp_adapter data structure could not be removed | |
724 | * (e.g. still used) | |
725 | * locks: adapter list write lock is assumed to be held by caller | |
1da177e4 LT |
726 | */ |
727 | void | |
728 | zfcp_adapter_dequeue(struct zfcp_adapter *adapter) | |
729 | { | |
730 | int retval = 0; | |
731 | unsigned long flags; | |
732 | ||
d26ab06e | 733 | cancel_work_sync(&adapter->stat_work); |
9f28745a | 734 | zfcp_adapter_scsi_unregister(adapter); |
1da177e4 LT |
735 | device_unregister(&adapter->generic_services); |
736 | zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); | |
737 | dev_set_drvdata(&adapter->ccw_device->dev, NULL); | |
738 | /* sanity check: no pending FSF requests */ | |
fea9d6c7 VS |
739 | spin_lock_irqsave(&adapter->req_list_lock, flags); |
740 | retval = zfcp_reqlist_isempty(adapter); | |
741 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | |
742 | if (!retval) { | |
1da177e4 LT |
743 | retval = -EBUSY; |
744 | goto out; | |
745 | } | |
746 | ||
ff17a29d CS |
747 | zfcp_adapter_debug_unregister(adapter); |
748 | ||
1da177e4 LT |
749 | /* remove specified adapter data structure from list */ |
750 | write_lock_irq(&zfcp_data.config_lock); | |
751 | list_del(&adapter->list); | |
752 | write_unlock_irq(&zfcp_data.config_lock); | |
753 | ||
754 | /* decrease number of adapters in list */ | |
755 | zfcp_data.adapters--; | |
756 | ||
00bab910 | 757 | zfcp_qdio_free(adapter); |
1da177e4 LT |
758 | |
759 | zfcp_free_low_mem_buffers(adapter); | |
fea9d6c7 | 760 | zfcp_reqlist_free(adapter); |
f6cd94b1 AH |
761 | kfree(adapter->fc_stats); |
762 | kfree(adapter->stats_reset_data); | |
1da177e4 LT |
763 | ZFCP_LOG_TRACE("freeing adapter structure\n"); |
764 | kfree(adapter); | |
765 | out: | |
766 | return; | |
767 | } | |
768 | ||
769 | /** | |
770 | * zfcp_port_enqueue - enqueue port to port list of adapter | |
771 | * @adapter: adapter where remote port is added | |
772 | * @wwpn: WWPN of the remote port to be enqueued | |
773 | * @status: initial status for the port | |
774 | * @d_id: destination id of the remote port to be enqueued | |
775 | * Return: pointer to enqueued port on success, NULL on error | |
776 | * Locks: config_sema must be held to serialize changes to the port list | |
777 | * | |
778 | * All port internal structures are set up and the sysfs entry is generated. | |
779 | * d_id is used to enqueue ports with a well known address like the Directory | |
780 | * Service for nameserver lookup. | |
781 | */ | |
782 | struct zfcp_port * | |
783 | zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, u32 status, | |
784 | u32 d_id) | |
785 | { | |
3859f6a2 | 786 | struct zfcp_port *port; |
1da177e4 | 787 | int check_wwpn; |
1da177e4 LT |
788 | |
789 | check_wwpn = !(status & ZFCP_STATUS_PORT_NO_WWPN); | |
1da177e4 LT |
790 | /* |
791 | * check that there is no port with this WWPN already in list | |
792 | */ | |
793 | if (check_wwpn) { | |
794 | read_lock_irq(&zfcp_data.config_lock); | |
795 | port = zfcp_get_port_by_wwpn(adapter, wwpn); | |
796 | read_unlock_irq(&zfcp_data.config_lock); | |
797 | if (port) | |
798 | return NULL; | |
799 | } | |
800 | ||
ec4081c6 | 801 | port = kzalloc(sizeof (struct zfcp_port), GFP_KERNEL); |
1da177e4 LT |
802 | if (!port) |
803 | return NULL; | |
1da177e4 LT |
804 | |
805 | /* initialise reference count stuff */ | |
806 | atomic_set(&port->refcount, 0); | |
807 | init_waitqueue_head(&port->remove_wq); | |
808 | ||
809 | INIT_LIST_HEAD(&port->unit_list_head); | |
810 | INIT_LIST_HEAD(&port->unit_remove_lh); | |
811 | ||
812 | port->adapter = adapter; | |
813 | ||
814 | if (check_wwpn) | |
815 | port->wwpn = wwpn; | |
816 | ||
817 | atomic_set_mask(status, &port->status); | |
818 | ||
819 | /* setup for sysfs registration */ | |
820 | if (status & ZFCP_STATUS_PORT_WKA) { | |
821 | switch (d_id) { | |
822 | case ZFCP_DID_DIRECTORY_SERVICE: | |
823 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, | |
824 | "directory"); | |
825 | break; | |
826 | case ZFCP_DID_MANAGEMENT_SERVICE: | |
827 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, | |
828 | "management"); | |
829 | break; | |
830 | case ZFCP_DID_KEY_DISTRIBUTION_SERVICE: | |
831 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, | |
832 | "key_distribution"); | |
833 | break; | |
834 | case ZFCP_DID_ALIAS_SERVICE: | |
835 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, | |
836 | "alias"); | |
837 | break; | |
838 | case ZFCP_DID_TIME_SERVICE: | |
839 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, | |
840 | "time"); | |
841 | break; | |
842 | default: | |
843 | kfree(port); | |
844 | return NULL; | |
845 | } | |
846 | port->d_id = d_id; | |
847 | port->sysfs_device.parent = &adapter->generic_services; | |
848 | } else { | |
849 | snprintf(port->sysfs_device.bus_id, | |
850 | BUS_ID_SIZE, "0x%016llx", wwpn); | |
3859f6a2 | 851 | port->sysfs_device.parent = &adapter->ccw_device->dev; |
1da177e4 LT |
852 | } |
853 | port->sysfs_device.release = zfcp_sysfs_port_release; | |
854 | dev_set_drvdata(&port->sysfs_device, port); | |
855 | ||
856 | /* mark port unusable as long as sysfs registration is not complete */ | |
857 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); | |
858 | ||
859 | if (device_register(&port->sysfs_device)) { | |
860 | kfree(port); | |
861 | return NULL; | |
862 | } | |
863 | ||
864 | if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) { | |
865 | device_unregister(&port->sysfs_device); | |
866 | return NULL; | |
867 | } | |
868 | ||
869 | zfcp_port_get(port); | |
870 | ||
1da177e4 | 871 | write_lock_irq(&zfcp_data.config_lock); |
3859f6a2 | 872 | list_add_tail(&port->list, &adapter->port_list_head); |
1da177e4 LT |
873 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); |
874 | atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); | |
875 | if (d_id == ZFCP_DID_DIRECTORY_SERVICE) | |
876 | if (!adapter->nameserver_port) | |
877 | adapter->nameserver_port = port; | |
878 | adapter->ports++; | |
879 | write_unlock_irq(&zfcp_data.config_lock); | |
880 | ||
881 | zfcp_adapter_get(adapter); | |
882 | ||
883 | return port; | |
884 | } | |
885 | ||
886 | void | |
887 | zfcp_port_dequeue(struct zfcp_port *port) | |
888 | { | |
889 | zfcp_port_wait(port); | |
890 | write_lock_irq(&zfcp_data.config_lock); | |
891 | list_del(&port->list); | |
892 | port->adapter->ports--; | |
893 | write_unlock_irq(&zfcp_data.config_lock); | |
3859f6a2 | 894 | if (port->rport) |
20b1730a HC |
895 | fc_remote_port_delete(port->rport); |
896 | port->rport = NULL; | |
1da177e4 LT |
897 | zfcp_adapter_put(port->adapter); |
898 | zfcp_sysfs_port_remove_files(&port->sysfs_device, | |
899 | atomic_read(&port->status)); | |
900 | device_unregister(&port->sysfs_device); | |
901 | } | |
902 | ||
903 | /* Enqueues a nameserver port */ | |
904 | int | |
905 | zfcp_nameserver_enqueue(struct zfcp_adapter *adapter) | |
906 | { | |
907 | struct zfcp_port *port; | |
908 | ||
909 | port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA, | |
910 | ZFCP_DID_DIRECTORY_SERVICE); | |
911 | if (!port) { | |
912 | ZFCP_LOG_INFO("error: enqueue of nameserver port for " | |
913 | "adapter %s failed\n", | |
914 | zfcp_get_busid_by_adapter(adapter)); | |
915 | return -ENXIO; | |
916 | } | |
917 | zfcp_port_put(port); | |
918 | ||
919 | return 0; | |
920 | } | |
921 | ||
45633fdc CS |
922 | void zfcp_sg_free_table(struct scatterlist *sg, int count) |
923 | { | |
924 | int i; | |
925 | ||
926 | for (i = 0; i < count; i++, sg++) | |
927 | if (sg) | |
928 | free_page((unsigned long) sg_virt(sg)); | |
929 | else | |
930 | break; | |
931 | } | |
932 | ||
933 | int zfcp_sg_setup_table(struct scatterlist *sg, int count) | |
934 | { | |
935 | void *addr; | |
936 | int i; | |
937 | ||
938 | sg_init_table(sg, count); | |
939 | for (i = 0; i < count; i++, sg++) { | |
940 | addr = (void *) get_zeroed_page(GFP_KERNEL); | |
941 | if (!addr) { | |
942 | zfcp_sg_free_table(sg, i); | |
943 | return -ENOMEM; | |
944 | } | |
945 | sg_set_buf(sg, addr, PAGE_SIZE); | |
946 | } | |
947 | return 0; | |
948 | } | |
949 | ||
1da177e4 | 950 | #undef ZFCP_LOG_AREA |