Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
553448f6 | 2 | * zfcp device driver |
1da177e4 | 3 | * |
553448f6 | 4 | * Module interface and handling of zfcp data structures. |
1da177e4 | 5 | * |
553448f6 | 6 | * Copyright IBM Corporation 2002, 2008 |
1da177e4 LT |
7 | */ |
8 | ||
4a9d2d8b AH |
9 | /* |
10 | * Driver authors: | |
11 | * Martin Peschke (originator of the driver) | |
12 | * Raimund Schroeder | |
13 | * Aron Zeh | |
14 | * Wolfgang Taphorn | |
15 | * Stefan Bader | |
16 | * Heiko Carstens (kernel 2.6 port of the driver) | |
17 | * Andreas Herrmann | |
18 | * Maxim Shchetynin | |
19 | * Volker Sameske | |
20 | * Ralph Wuerthner | |
553448f6 CS |
21 | * Michael Loehr |
22 | * Swen Schillig | |
23 | * Christof Schmitt | |
24 | * Martin Petermann | |
25 | * Sven Schuetz | |
4a9d2d8b AH |
26 | */ |
27 | ||
45633fdc | 28 | #include <linux/miscdevice.h> |
1da177e4 LT |
29 | #include "zfcp_ext.h" |
30 | ||
1da177e4 | 31 | static char *device; |
1da177e4 | 32 | |
4a9d2d8b | 33 | MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); |
317e6b65 | 34 | MODULE_DESCRIPTION("FCP HBA driver"); |
1da177e4 LT |
35 | MODULE_LICENSE("GPL"); |
36 | ||
6f71d9bc | 37 | module_param(device, charp, 0400); |
1da177e4 LT |
38 | MODULE_PARM_DESC(device, "specify initial device"); |
39 | ||
ca2d02c2 | 40 | static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) |
fea9d6c7 | 41 | { |
ca2d02c2 | 42 | int idx; |
fea9d6c7 VS |
43 | |
44 | adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), | |
45 | GFP_KERNEL); | |
fea9d6c7 VS |
46 | if (!adapter->req_list) |
47 | return -ENOMEM; | |
48 | ||
ca2d02c2 HC |
49 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) |
50 | INIT_LIST_HEAD(&adapter->req_list[idx]); | |
fea9d6c7 VS |
51 | return 0; |
52 | } | |
53 | ||
317e6b65 SS |
54 | /** |
55 | * zfcp_reqlist_isempty - is the request list empty | |
56 | * @adapter: pointer to struct zfcp_adapter | |
57 | * | |
58 | * Returns: true if list is empty, false otherwise | |
59 | */ | |
fea9d6c7 VS |
60 | int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) |
61 | { | |
ca2d02c2 | 62 | unsigned int idx; |
fea9d6c7 | 63 | |
ca2d02c2 HC |
64 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) |
65 | if (!list_empty(&adapter->req_list[idx])) | |
fea9d6c7 | 66 | return 0; |
fea9d6c7 VS |
67 | return 1; |
68 | } | |
69 | ||
317e6b65 | 70 | static int __init zfcp_device_setup(char *devstr) |
1da177e4 | 71 | { |
317e6b65 SS |
72 | char *token; |
73 | char *str; | |
1da177e4 | 74 | |
cd8a383e | 75 | if (!devstr) |
1da177e4 LT |
76 | return 0; |
77 | ||
317e6b65 SS |
78 | /* duplicate devstr and keep the original for sysfs presentation*/ |
79 | str = kmalloc(strlen(devstr) + 1, GFP_KERNEL); | |
80 | if (!str) | |
553448f6 | 81 | return 0; |
cd8a383e | 82 | |
317e6b65 | 83 | strcpy(str, devstr); |
1da177e4 | 84 | |
317e6b65 SS |
85 | token = strsep(&str, ","); |
86 | if (!token || strlen(token) >= BUS_ID_SIZE) | |
1da177e4 | 87 | goto err_out; |
317e6b65 SS |
88 | strncpy(zfcp_data.init_busid, token, BUS_ID_SIZE); |
89 | ||
90 | token = strsep(&str, ","); | |
91 | if (!token || strict_strtoull(token, 0, &zfcp_data.init_wwpn)) | |
1da177e4 LT |
92 | goto err_out; |
93 | ||
317e6b65 SS |
94 | token = strsep(&str, ","); |
95 | if (!token || strict_strtoull(token, 0, &zfcp_data.init_fcp_lun)) | |
1da177e4 | 96 | goto err_out; |
317e6b65 | 97 | |
cd8a383e | 98 | kfree(str); |
1da177e4 LT |
99 | return 1; |
100 | ||
101 | err_out: | |
cd8a383e | 102 | kfree(str); |
317e6b65 SS |
103 | pr_err("zfcp: Parse error for device parameter string %s, " |
104 | "device not attached.\n", devstr); | |
1da177e4 LT |
105 | return 0; |
106 | } | |
107 | ||
317e6b65 SS |
108 | static struct zfcp_adapter *zfcp_get_adapter_by_busid(char *bus_id) |
109 | { | |
110 | struct zfcp_adapter *adapter; | |
111 | ||
112 | list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) | |
113 | if ((strncmp(bus_id, adapter->ccw_device->dev.bus_id, | |
114 | BUS_ID_SIZE) == 0) && | |
115 | !(atomic_read(&adapter->status) & | |
116 | ZFCP_STATUS_COMMON_REMOVE)) | |
117 | return adapter; | |
118 | return NULL; | |
119 | } | |
120 | ||
121 | static void __init zfcp_init_device_configure(void) | |
1da177e4 LT |
122 | { |
123 | struct zfcp_adapter *adapter; | |
124 | struct zfcp_port *port; | |
125 | struct zfcp_unit *unit; | |
126 | ||
127 | down(&zfcp_data.config_sema); | |
128 | read_lock_irq(&zfcp_data.config_lock); | |
129 | adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid); | |
130 | if (adapter) | |
131 | zfcp_adapter_get(adapter); | |
132 | read_unlock_irq(&zfcp_data.config_lock); | |
133 | ||
317e6b65 | 134 | if (!adapter) |
1da177e4 LT |
135 | goto out_adapter; |
136 | port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0); | |
317e6b65 | 137 | if (IS_ERR(port)) |
1da177e4 LT |
138 | goto out_port; |
139 | unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun); | |
317e6b65 | 140 | if (IS_ERR(unit)) |
1da177e4 LT |
141 | goto out_unit; |
142 | up(&zfcp_data.config_sema); | |
143 | ccw_device_set_online(adapter->ccw_device); | |
144 | zfcp_erp_wait(adapter); | |
145 | down(&zfcp_data.config_sema); | |
146 | zfcp_unit_put(unit); | |
317e6b65 | 147 | out_unit: |
1da177e4 | 148 | zfcp_port_put(port); |
317e6b65 | 149 | out_port: |
1da177e4 | 150 | zfcp_adapter_put(adapter); |
317e6b65 | 151 | out_adapter: |
1da177e4 LT |
152 | up(&zfcp_data.config_sema); |
153 | return; | |
154 | } | |
155 | ||
317e6b65 | 156 | static struct kmem_cache *zfcp_cache_create(int size, char *name) |
dd52e0ea HC |
157 | { |
158 | int align = 1; | |
dd52e0ea HC |
159 | while ((size - align) > 0) |
160 | align <<= 1; | |
317e6b65 | 161 | return kmem_cache_create(name , size, align, 0, NULL); |
dd52e0ea HC |
162 | } |
163 | ||
317e6b65 | 164 | static int __init zfcp_module_init(void) |
1da177e4 | 165 | { |
dd52e0ea | 166 | int retval = -ENOMEM; |
dd52e0ea | 167 | |
317e6b65 SS |
168 | zfcp_data.fsf_req_qtcb_cache = zfcp_cache_create( |
169 | sizeof(struct zfcp_fsf_req_qtcb), "zfcp_fsf"); | |
dd52e0ea HC |
170 | if (!zfcp_data.fsf_req_qtcb_cache) |
171 | goto out; | |
1da177e4 | 172 | |
317e6b65 SS |
173 | zfcp_data.sr_buffer_cache = zfcp_cache_create( |
174 | sizeof(struct fsf_status_read_buffer), "zfcp_sr"); | |
dd52e0ea HC |
175 | if (!zfcp_data.sr_buffer_cache) |
176 | goto out_sr_cache; | |
177 | ||
317e6b65 SS |
178 | zfcp_data.gid_pn_cache = zfcp_cache_create( |
179 | sizeof(struct zfcp_gid_pn_data), "zfcp_gid"); | |
dd52e0ea HC |
180 | if (!zfcp_data.gid_pn_cache) |
181 | goto out_gid_cache; | |
1da177e4 | 182 | |
1da177e4 | 183 | INIT_LIST_HEAD(&zfcp_data.adapter_list_head); |
1da177e4 LT |
184 | INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh); |
185 | ||
317e6b65 SS |
186 | sema_init(&zfcp_data.config_sema, 1); |
187 | rwlock_init(&zfcp_data.config_lock); | |
188 | ||
dd52e0ea HC |
189 | zfcp_data.scsi_transport_template = |
190 | fc_attach_transport(&zfcp_transport_functions); | |
191 | if (!zfcp_data.scsi_transport_template) | |
192 | goto out_transport; | |
1da177e4 | 193 | |
1da177e4 | 194 | retval = misc_register(&zfcp_cfdc_misc); |
317e6b65 | 195 | if (retval) { |
553448f6 | 196 | pr_err("zfcp: registration of misc device zfcp_cfdc failed\n"); |
dd52e0ea | 197 | goto out_misc; |
1da177e4 LT |
198 | } |
199 | ||
1da177e4 LT |
200 | retval = zfcp_ccw_register(); |
201 | if (retval) { | |
553448f6 | 202 | pr_err("zfcp: Registration with common I/O layer failed.\n"); |
1da177e4 LT |
203 | goto out_ccw_register; |
204 | } | |
205 | ||
206 | if (zfcp_device_setup(device)) | |
207 | zfcp_init_device_configure(); | |
208 | ||
209 | goto out; | |
210 | ||
317e6b65 | 211 | out_ccw_register: |
1da177e4 | 212 | misc_deregister(&zfcp_cfdc_misc); |
317e6b65 | 213 | out_misc: |
dd52e0ea | 214 | fc_release_transport(zfcp_data.scsi_transport_template); |
317e6b65 | 215 | out_transport: |
dd52e0ea | 216 | kmem_cache_destroy(zfcp_data.gid_pn_cache); |
317e6b65 | 217 | out_gid_cache: |
dd52e0ea | 218 | kmem_cache_destroy(zfcp_data.sr_buffer_cache); |
317e6b65 | 219 | out_sr_cache: |
dd52e0ea | 220 | kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); |
317e6b65 | 221 | out: |
1da177e4 LT |
222 | return retval; |
223 | } | |
224 | ||
317e6b65 | 225 | module_init(zfcp_module_init); |
1da177e4 | 226 | |
1da177e4 LT |
227 | /** |
228 | * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN | |
229 | * @port: pointer to port to search for unit | |
230 | * @fcp_lun: FCP LUN to search for | |
317e6b65 SS |
231 | * |
232 | * Returns: pointer to zfcp_unit or NULL | |
1da177e4 | 233 | */ |
317e6b65 SS |
234 | struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, |
235 | fcp_lun_t fcp_lun) | |
1da177e4 LT |
236 | { |
237 | struct zfcp_unit *unit; | |
1da177e4 | 238 | |
317e6b65 | 239 | list_for_each_entry(unit, &port->unit_list_head, list) |
1da177e4 | 240 | if ((unit->fcp_lun == fcp_lun) && |
317e6b65 SS |
241 | !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE)) |
242 | return unit; | |
243 | return NULL; | |
1da177e4 LT |
244 | } |
245 | ||
246 | /** | |
247 | * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn | |
248 | * @adapter: pointer to adapter to search for port | |
249 | * @wwpn: wwpn to search for | |
317e6b65 SS |
250 | * |
251 | * Returns: pointer to zfcp_port or NULL | |
1da177e4 | 252 | */ |
317e6b65 SS |
253 | struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, |
254 | wwn_t wwpn) | |
1da177e4 LT |
255 | { |
256 | struct zfcp_port *port; | |
1da177e4 | 257 | |
317e6b65 SS |
258 | list_for_each_entry(port, &adapter->port_list_head, list) |
259 | if ((port->wwpn == wwpn) && !(atomic_read(&port->status) & | |
260 | (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) | |
261 | return port; | |
262 | return NULL; | |
1da177e4 LT |
263 | } |
264 | ||
265 | /** | |
266 | * zfcp_unit_enqueue - enqueue unit to unit list of a port. | |
267 | * @port: pointer to port where unit is added | |
268 | * @fcp_lun: FCP LUN of unit to be enqueued | |
317e6b65 | 269 | * Returns: pointer to enqueued unit on success, ERR_PTR on error |
1da177e4 LT |
270 | * Locks: config_sema must be held to serialize changes to the unit list |
271 | * | |
272 | * Sets up some unit internal structures and creates sysfs entry. | |
273 | */ | |
317e6b65 | 274 | struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) |
1da177e4 | 275 | { |
462b7859 | 276 | struct zfcp_unit *unit; |
1da177e4 | 277 | |
317e6b65 | 278 | unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); |
1da177e4 | 279 | if (!unit) |
317e6b65 | 280 | return ERR_PTR(-ENOMEM); |
1da177e4 | 281 | |
1da177e4 LT |
282 | atomic_set(&unit->refcount, 0); |
283 | init_waitqueue_head(&unit->remove_wq); | |
284 | ||
285 | unit->port = port; | |
286 | unit->fcp_lun = fcp_lun; | |
287 | ||
1da177e4 LT |
288 | snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun); |
289 | unit->sysfs_device.parent = &port->sysfs_device; | |
290 | unit->sysfs_device.release = zfcp_sysfs_unit_release; | |
291 | dev_set_drvdata(&unit->sysfs_device, unit); | |
292 | ||
293 | /* mark unit unusable as long as sysfs registration is not complete */ | |
294 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); | |
295 | ||
c9615858 CS |
296 | spin_lock_init(&unit->latencies.lock); |
297 | unit->latencies.write.channel.min = 0xFFFFFFFF; | |
298 | unit->latencies.write.fabric.min = 0xFFFFFFFF; | |
299 | unit->latencies.read.channel.min = 0xFFFFFFFF; | |
300 | unit->latencies.read.fabric.min = 0xFFFFFFFF; | |
301 | unit->latencies.cmd.channel.min = 0xFFFFFFFF; | |
302 | unit->latencies.cmd.fabric.min = 0xFFFFFFFF; | |
303 | ||
317e6b65 SS |
304 | read_lock_irq(&zfcp_data.config_lock); |
305 | if (zfcp_get_unit_by_lun(port, fcp_lun)) { | |
306 | read_unlock_irq(&zfcp_data.config_lock); | |
307 | goto err_out_free; | |
1da177e4 | 308 | } |
317e6b65 SS |
309 | read_unlock_irq(&zfcp_data.config_lock); |
310 | ||
311 | if (device_register(&unit->sysfs_device)) | |
312 | goto err_out_free; | |
1da177e4 LT |
313 | |
314 | if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) { | |
315 | device_unregister(&unit->sysfs_device); | |
317e6b65 | 316 | return ERR_PTR(-EIO); |
1da177e4 LT |
317 | } |
318 | ||
319 | zfcp_unit_get(unit); | |
462b7859 | 320 | unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun); |
1da177e4 | 321 | |
1da177e4 | 322 | write_lock_irq(&zfcp_data.config_lock); |
462b7859 | 323 | list_add_tail(&unit->list, &port->unit_list_head); |
1da177e4 LT |
324 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); |
325 | atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); | |
317e6b65 | 326 | |
1da177e4 LT |
327 | write_unlock_irq(&zfcp_data.config_lock); |
328 | ||
329 | port->units++; | |
330 | zfcp_port_get(port); | |
331 | ||
332 | return unit; | |
317e6b65 SS |
333 | |
334 | err_out_free: | |
335 | kfree(unit); | |
336 | return ERR_PTR(-EINVAL); | |
1da177e4 LT |
337 | } |
338 | ||
317e6b65 SS |
339 | /** |
340 | * zfcp_unit_dequeue - dequeue unit | |
341 | * @unit: pointer to zfcp_unit | |
342 | * | |
343 | * waits until all work is done on unit and removes it then from the unit->list | |
344 | * of the associated port. | |
345 | */ | |
346 | void zfcp_unit_dequeue(struct zfcp_unit *unit) | |
1da177e4 LT |
347 | { |
348 | zfcp_unit_wait(unit); | |
349 | write_lock_irq(&zfcp_data.config_lock); | |
350 | list_del(&unit->list); | |
351 | write_unlock_irq(&zfcp_data.config_lock); | |
352 | unit->port->units--; | |
353 | zfcp_port_put(unit->port); | |
354 | zfcp_sysfs_unit_remove_files(&unit->sysfs_device); | |
355 | device_unregister(&unit->sysfs_device); | |
356 | } | |
357 | ||
317e6b65 | 358 | static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) |
1da177e4 | 359 | { |
317e6b65 | 360 | /* must only be called with zfcp_data.config_sema taken */ |
1da177e4 | 361 | adapter->pool.fsf_req_erp = |
317e6b65 | 362 | mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); |
0eaae62a | 363 | if (!adapter->pool.fsf_req_erp) |
1da177e4 LT |
364 | return -ENOMEM; |
365 | ||
366 | adapter->pool.fsf_req_scsi = | |
317e6b65 | 367 | mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); |
0eaae62a | 368 | if (!adapter->pool.fsf_req_scsi) |
1da177e4 LT |
369 | return -ENOMEM; |
370 | ||
371 | adapter->pool.fsf_req_abort = | |
317e6b65 | 372 | mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); |
0eaae62a | 373 | if (!adapter->pool.fsf_req_abort) |
1da177e4 LT |
374 | return -ENOMEM; |
375 | ||
376 | adapter->pool.fsf_req_status_read = | |
317e6b65 | 377 | mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, |
0eaae62a MD |
378 | sizeof(struct zfcp_fsf_req)); |
379 | if (!adapter->pool.fsf_req_status_read) | |
1da177e4 LT |
380 | return -ENOMEM; |
381 | ||
382 | adapter->pool.data_status_read = | |
317e6b65 | 383 | mempool_create_slab_pool(FSF_STATUS_READS_RECOM, |
dd52e0ea | 384 | zfcp_data.sr_buffer_cache); |
0eaae62a | 385 | if (!adapter->pool.data_status_read) |
1da177e4 LT |
386 | return -ENOMEM; |
387 | ||
388 | adapter->pool.data_gid_pn = | |
317e6b65 | 389 | mempool_create_slab_pool(1, zfcp_data.gid_pn_cache); |
0eaae62a | 390 | if (!adapter->pool.data_gid_pn) |
1da177e4 LT |
391 | return -ENOMEM; |
392 | ||
393 | return 0; | |
394 | } | |
395 | ||
317e6b65 | 396 | static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) |
1da177e4 | 397 | { |
317e6b65 | 398 | /* zfcp_data.config_sema must be held */ |
1da177e4 LT |
399 | if (adapter->pool.fsf_req_erp) |
400 | mempool_destroy(adapter->pool.fsf_req_erp); | |
401 | if (adapter->pool.fsf_req_scsi) | |
402 | mempool_destroy(adapter->pool.fsf_req_scsi); | |
403 | if (adapter->pool.fsf_req_abort) | |
404 | mempool_destroy(adapter->pool.fsf_req_abort); | |
405 | if (adapter->pool.fsf_req_status_read) | |
406 | mempool_destroy(adapter->pool.fsf_req_status_read); | |
407 | if (adapter->pool.data_status_read) | |
408 | mempool_destroy(adapter->pool.data_status_read); | |
409 | if (adapter->pool.data_gid_pn) | |
410 | mempool_destroy(adapter->pool.data_gid_pn); | |
411 | } | |
412 | ||
763968e2 | 413 | static void zfcp_dummy_release(struct device *dev) |
1da177e4 LT |
414 | { |
415 | return; | |
416 | } | |
417 | ||
317e6b65 SS |
418 | /** |
419 | * zfcp_status_read_refill - refill the long running status_read_requests | |
420 | * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled | |
421 | * | |
422 | * Returns: 0 on success, 1 otherwise | |
423 | * | |
424 | * if there are 16 or more status_read requests missing an adapter_reopen | |
425 | * is triggered | |
426 | */ | |
d26ab06e SS |
427 | int zfcp_status_read_refill(struct zfcp_adapter *adapter) |
428 | { | |
429 | while (atomic_read(&adapter->stat_miss) > 0) | |
7afe29f7 SS |
430 | if (zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL)) { |
431 | if (atomic_read(&adapter->stat_miss) >= 16) { | |
432 | zfcp_erp_adapter_reopen(adapter, 0, 103, NULL); | |
433 | return 1; | |
434 | } | |
d26ab06e | 435 | break; |
7afe29f7 SS |
436 | } else |
437 | atomic_dec(&adapter->stat_miss); | |
d26ab06e SS |
438 | return 0; |
439 | } | |
440 | ||
441 | static void _zfcp_status_read_scheduler(struct work_struct *work) | |
442 | { | |
443 | zfcp_status_read_refill(container_of(work, struct zfcp_adapter, | |
444 | stat_work)); | |
445 | } | |
446 | ||
cc8c2829 SS |
447 | static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter) |
448 | { | |
449 | struct zfcp_port *port; | |
450 | ||
451 | port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA, | |
452 | ZFCP_DID_DIRECTORY_SERVICE); | |
317e6b65 SS |
453 | if (IS_ERR(port)) |
454 | return PTR_ERR(port); | |
cc8c2829 SS |
455 | zfcp_port_put(port); |
456 | ||
457 | return 0; | |
458 | } | |
459 | ||
317e6b65 SS |
460 | /** |
461 | * zfcp_adapter_enqueue - enqueue a new adapter to the list | |
462 | * @ccw_device: pointer to the struct cc_device | |
463 | * | |
464 | * Returns: 0 if a new adapter was successfully enqueued | |
465 | * -ENOMEM if alloc failed | |
1da177e4 LT |
466 | * Enqueues an adapter at the end of the adapter list in the driver data. |
467 | * All adapter internal structures are set up. | |
468 | * Proc-fs entries are also created. | |
1da177e4 LT |
469 | * locks: config_sema must be held to serialise changes to the adapter list |
470 | */ | |
317e6b65 | 471 | int zfcp_adapter_enqueue(struct ccw_device *ccw_device) |
1da177e4 | 472 | { |
1da177e4 LT |
473 | struct zfcp_adapter *adapter; |
474 | ||
475 | /* | |
41fa2ada | 476 | * Note: It is safe to release the list_lock, as any list changes |
1da177e4 LT |
477 | * are protected by the config_sema, which must be held to get here |
478 | */ | |
479 | ||
317e6b65 | 480 | adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); |
553448f6 | 481 | if (!adapter) |
317e6b65 | 482 | return -ENOMEM; |
1da177e4 LT |
483 | |
484 | ccw_device->handler = NULL; | |
1da177e4 | 485 | adapter->ccw_device = ccw_device; |
317e6b65 | 486 | atomic_set(&adapter->refcount, 0); |
1da177e4 | 487 | |
00bab910 | 488 | if (zfcp_qdio_allocate(adapter)) |
1da177e4 LT |
489 | goto qdio_allocate_failed; |
490 | ||
00bab910 | 491 | if (zfcp_allocate_low_mem_buffers(adapter)) |
1da177e4 | 492 | goto failed_low_mem_buffers; |
1da177e4 | 493 | |
317e6b65 SS |
494 | if (zfcp_reqlist_alloc(adapter)) |
495 | goto failed_low_mem_buffers; | |
496 | ||
497 | if (zfcp_adapter_debug_register(adapter)) | |
498 | goto debug_register_failed; | |
499 | ||
1da177e4 | 500 | init_waitqueue_head(&adapter->remove_wq); |
317e6b65 SS |
501 | init_waitqueue_head(&adapter->erp_thread_wqh); |
502 | init_waitqueue_head(&adapter->erp_done_wqh); | |
1da177e4 | 503 | |
1da177e4 | 504 | INIT_LIST_HEAD(&adapter->port_list_head); |
1da177e4 | 505 | INIT_LIST_HEAD(&adapter->port_remove_lh); |
317e6b65 SS |
506 | INIT_LIST_HEAD(&adapter->erp_ready_head); |
507 | INIT_LIST_HEAD(&adapter->erp_running_head); | |
1da177e4 | 508 | |
fea9d6c7 | 509 | spin_lock_init(&adapter->req_list_lock); |
c48a29d0 | 510 | |
c48a29d0 HC |
511 | spin_lock_init(&adapter->hba_dbf_lock); |
512 | spin_lock_init(&adapter->san_dbf_lock); | |
513 | spin_lock_init(&adapter->scsi_dbf_lock); | |
d79a83db | 514 | spin_lock_init(&adapter->rec_dbf_lock); |
c48a29d0 | 515 | |
c48a29d0 | 516 | rwlock_init(&adapter->erp_lock); |
1da177e4 | 517 | rwlock_init(&adapter->abort_lock); |
317e6b65 | 518 | rwlock_init(&adapter->req_q.lock); |
1da177e4 | 519 | |
317e6b65 | 520 | sema_init(&adapter->erp_ready_sem, 0); |
1da177e4 | 521 | |
d26ab06e | 522 | INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); |
cc8c2829 | 523 | INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); |
1da177e4 | 524 | |
1da177e4 LT |
525 | /* mark adapter unusable as long as sysfs registration is not complete */ |
526 | atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); | |
527 | ||
1da177e4 LT |
528 | dev_set_drvdata(&ccw_device->dev, adapter); |
529 | ||
530 | if (zfcp_sysfs_adapter_create_files(&ccw_device->dev)) | |
531 | goto sysfs_failed; | |
532 | ||
533 | adapter->generic_services.parent = &adapter->ccw_device->dev; | |
534 | adapter->generic_services.release = zfcp_dummy_release; | |
535 | snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE, | |
536 | "generic_services"); | |
537 | ||
538 | if (device_register(&adapter->generic_services)) | |
539 | goto generic_services_failed; | |
540 | ||
1da177e4 LT |
541 | write_lock_irq(&zfcp_data.config_lock); |
542 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); | |
543 | list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); | |
544 | write_unlock_irq(&zfcp_data.config_lock); | |
545 | ||
546 | zfcp_data.adapters++; | |
547 | ||
cc8c2829 SS |
548 | zfcp_nameserver_enqueue(adapter); |
549 | ||
317e6b65 | 550 | return 0; |
1da177e4 | 551 | |
317e6b65 | 552 | generic_services_failed: |
1da177e4 | 553 | zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); |
317e6b65 | 554 | sysfs_failed: |
ff17a29d | 555 | zfcp_adapter_debug_unregister(adapter); |
317e6b65 | 556 | debug_register_failed: |
1da177e4 | 557 | dev_set_drvdata(&ccw_device->dev, NULL); |
317e6b65 SS |
558 | kfree(adapter->req_list); |
559 | failed_low_mem_buffers: | |
1da177e4 | 560 | zfcp_free_low_mem_buffers(adapter); |
317e6b65 | 561 | qdio_allocate_failed: |
00bab910 | 562 | zfcp_qdio_free(adapter); |
1da177e4 | 563 | kfree(adapter); |
317e6b65 | 564 | return -ENOMEM; |
1da177e4 LT |
565 | } |
566 | ||
317e6b65 SS |
567 | /** |
568 | * zfcp_adapter_dequeue - remove the adapter from the resource list | |
569 | * @adapter: pointer to struct zfcp_adapter which should be removed | |
1da177e4 | 570 | * locks: adapter list write lock is assumed to be held by caller |
1da177e4 | 571 | */ |
317e6b65 | 572 | void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) |
1da177e4 LT |
573 | { |
574 | int retval = 0; | |
575 | unsigned long flags; | |
576 | ||
cc8c2829 | 577 | cancel_work_sync(&adapter->scan_work); |
d26ab06e | 578 | cancel_work_sync(&adapter->stat_work); |
9f28745a | 579 | zfcp_adapter_scsi_unregister(adapter); |
1da177e4 LT |
580 | device_unregister(&adapter->generic_services); |
581 | zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); | |
582 | dev_set_drvdata(&adapter->ccw_device->dev, NULL); | |
583 | /* sanity check: no pending FSF requests */ | |
fea9d6c7 VS |
584 | spin_lock_irqsave(&adapter->req_list_lock, flags); |
585 | retval = zfcp_reqlist_isempty(adapter); | |
586 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | |
317e6b65 SS |
587 | if (!retval) |
588 | return; | |
1da177e4 | 589 | |
ff17a29d CS |
590 | zfcp_adapter_debug_unregister(adapter); |
591 | ||
1da177e4 LT |
592 | /* remove specified adapter data structure from list */ |
593 | write_lock_irq(&zfcp_data.config_lock); | |
594 | list_del(&adapter->list); | |
595 | write_unlock_irq(&zfcp_data.config_lock); | |
596 | ||
597 | /* decrease number of adapters in list */ | |
598 | zfcp_data.adapters--; | |
599 | ||
00bab910 | 600 | zfcp_qdio_free(adapter); |
1da177e4 LT |
601 | |
602 | zfcp_free_low_mem_buffers(adapter); | |
317e6b65 | 603 | kfree(adapter->req_list); |
f6cd94b1 AH |
604 | kfree(adapter->fc_stats); |
605 | kfree(adapter->stats_reset_data); | |
1da177e4 | 606 | kfree(adapter); |
1da177e4 LT |
607 | } |
608 | ||
609 | /** | |
610 | * zfcp_port_enqueue - enqueue port to port list of adapter | |
611 | * @adapter: adapter where remote port is added | |
612 | * @wwpn: WWPN of the remote port to be enqueued | |
613 | * @status: initial status for the port | |
614 | * @d_id: destination id of the remote port to be enqueued | |
317e6b65 | 615 | * Returns: pointer to enqueued port on success, ERR_PTR on error |
1da177e4 LT |
616 | * Locks: config_sema must be held to serialize changes to the port list |
617 | * | |
618 | * All port internal structures are set up and the sysfs entry is generated. | |
619 | * d_id is used to enqueue ports with a well known address like the Directory | |
620 | * Service for nameserver lookup. | |
621 | */ | |
317e6b65 SS |
622 | struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, |
623 | u32 status, u32 d_id) | |
1da177e4 | 624 | { |
3859f6a2 | 625 | struct zfcp_port *port; |
317e6b65 | 626 | char *bus_id; |
1da177e4 | 627 | |
317e6b65 | 628 | port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL); |
1da177e4 | 629 | if (!port) |
317e6b65 | 630 | return ERR_PTR(-ENOMEM); |
1da177e4 | 631 | |
1da177e4 LT |
632 | init_waitqueue_head(&port->remove_wq); |
633 | ||
634 | INIT_LIST_HEAD(&port->unit_list_head); | |
635 | INIT_LIST_HEAD(&port->unit_remove_lh); | |
636 | ||
637 | port->adapter = adapter; | |
317e6b65 SS |
638 | port->d_id = d_id; |
639 | port->wwpn = wwpn; | |
1da177e4 | 640 | |
317e6b65 SS |
641 | /* mark port unusable as long as sysfs registration is not complete */ |
642 | atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status); | |
643 | atomic_set(&port->refcount, 0); | |
1da177e4 | 644 | |
1da177e4 LT |
645 | if (status & ZFCP_STATUS_PORT_WKA) { |
646 | switch (d_id) { | |
647 | case ZFCP_DID_DIRECTORY_SERVICE: | |
317e6b65 | 648 | bus_id = "directory"; |
1da177e4 LT |
649 | break; |
650 | case ZFCP_DID_MANAGEMENT_SERVICE: | |
317e6b65 | 651 | bus_id = "management"; |
1da177e4 LT |
652 | break; |
653 | case ZFCP_DID_KEY_DISTRIBUTION_SERVICE: | |
317e6b65 | 654 | bus_id = "key_distribution"; |
1da177e4 LT |
655 | break; |
656 | case ZFCP_DID_ALIAS_SERVICE: | |
317e6b65 | 657 | bus_id = "alias"; |
1da177e4 LT |
658 | break; |
659 | case ZFCP_DID_TIME_SERVICE: | |
317e6b65 | 660 | bus_id = "time"; |
1da177e4 LT |
661 | break; |
662 | default: | |
663 | kfree(port); | |
317e6b65 | 664 | return ERR_PTR(-EINVAL); |
1da177e4 | 665 | } |
317e6b65 | 666 | snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id); |
1da177e4 LT |
667 | port->sysfs_device.parent = &adapter->generic_services; |
668 | } else { | |
669 | snprintf(port->sysfs_device.bus_id, | |
670 | BUS_ID_SIZE, "0x%016llx", wwpn); | |
3859f6a2 | 671 | port->sysfs_device.parent = &adapter->ccw_device->dev; |
1da177e4 | 672 | } |
cc8c2829 | 673 | |
1da177e4 LT |
674 | port->sysfs_device.release = zfcp_sysfs_port_release; |
675 | dev_set_drvdata(&port->sysfs_device, port); | |
676 | ||
317e6b65 SS |
677 | read_lock_irq(&zfcp_data.config_lock); |
678 | if (!(status & ZFCP_STATUS_PORT_NO_WWPN)) | |
679 | if (zfcp_get_port_by_wwpn(adapter, wwpn)) { | |
680 | read_unlock_irq(&zfcp_data.config_lock); | |
681 | goto err_out_free; | |
682 | } | |
683 | read_unlock_irq(&zfcp_data.config_lock); | |
1da177e4 | 684 | |
317e6b65 SS |
685 | if (device_register(&port->sysfs_device)) |
686 | goto err_out_free; | |
1da177e4 LT |
687 | |
688 | if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) { | |
689 | device_unregister(&port->sysfs_device); | |
317e6b65 | 690 | goto err_out; |
1da177e4 LT |
691 | } |
692 | ||
693 | zfcp_port_get(port); | |
694 | ||
1da177e4 | 695 | write_lock_irq(&zfcp_data.config_lock); |
3859f6a2 | 696 | list_add_tail(&port->list, &adapter->port_list_head); |
1da177e4 LT |
697 | atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); |
698 | atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); | |
699 | if (d_id == ZFCP_DID_DIRECTORY_SERVICE) | |
700 | if (!adapter->nameserver_port) | |
701 | adapter->nameserver_port = port; | |
702 | adapter->ports++; | |
317e6b65 | 703 | |
1da177e4 LT |
704 | write_unlock_irq(&zfcp_data.config_lock); |
705 | ||
706 | zfcp_adapter_get(adapter); | |
1da177e4 | 707 | return port; |
317e6b65 SS |
708 | |
709 | err_out_free: | |
710 | kfree(port); | |
711 | err_out: | |
712 | return ERR_PTR(-EINVAL); | |
1da177e4 LT |
713 | } |
714 | ||
317e6b65 SS |
715 | /** |
716 | * zfcp_port_dequeue - dequeues a port from the port list of the adapter | |
717 | * @port: pointer to struct zfcp_port which should be removed | |
718 | */ | |
719 | void zfcp_port_dequeue(struct zfcp_port *port) | |
1da177e4 LT |
720 | { |
721 | zfcp_port_wait(port); | |
722 | write_lock_irq(&zfcp_data.config_lock); | |
723 | list_del(&port->list); | |
724 | port->adapter->ports--; | |
725 | write_unlock_irq(&zfcp_data.config_lock); | |
3859f6a2 | 726 | if (port->rport) |
20b1730a HC |
727 | fc_remote_port_delete(port->rport); |
728 | port->rport = NULL; | |
1da177e4 LT |
729 | zfcp_adapter_put(port->adapter); |
730 | zfcp_sysfs_port_remove_files(&port->sysfs_device, | |
731 | atomic_read(&port->status)); | |
732 | device_unregister(&port->sysfs_device); | |
733 | } | |
734 | ||
317e6b65 SS |
735 | /** |
736 | * zfcp_sg_free_table - free memory used by scatterlists | |
737 | * @sg: pointer to scatterlist | |
738 | * @count: number of scatterlist which are to be free'ed | |
739 | * the scatterlist are expected to reference pages always | |
740 | */ | |
45633fdc CS |
741 | void zfcp_sg_free_table(struct scatterlist *sg, int count) |
742 | { | |
743 | int i; | |
744 | ||
745 | for (i = 0; i < count; i++, sg++) | |
746 | if (sg) | |
747 | free_page((unsigned long) sg_virt(sg)); | |
748 | else | |
749 | break; | |
750 | } | |
751 | ||
317e6b65 SS |
752 | /** |
753 | * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers | |
754 | * @sg: pointer to struct scatterlist | |
755 | * @count: number of scatterlists which should be assigned with buffers | |
756 | * of size page | |
757 | * | |
758 | * Returns: 0 on success, -ENOMEM otherwise | |
759 | */ | |
45633fdc CS |
760 | int zfcp_sg_setup_table(struct scatterlist *sg, int count) |
761 | { | |
762 | void *addr; | |
763 | int i; | |
764 | ||
765 | sg_init_table(sg, count); | |
766 | for (i = 0; i < count; i++, sg++) { | |
767 | addr = (void *) get_zeroed_page(GFP_KERNEL); | |
768 | if (!addr) { | |
769 | zfcp_sg_free_table(sg, i); | |
770 | return -ENOMEM; | |
771 | } | |
772 | sg_set_buf(sg, addr, PAGE_SIZE); | |
773 | } | |
774 | return 0; | |
775 | } |