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