]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.39/patches.arch/s390-01-06-zfcp-cleanup-v2.patch
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported linux-2.6.27.39 suse/xen patches.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.arch / s390-01-06-zfcp-cleanup-v2.patch
1 From: Gerald Schaefer <geraldsc@de.ibm.com>
2 Subject: FCP - code cleanup stage 2
3 References: bnc#417550
4
5 Stage 2 of the code cleanup covers functional aspects of zFCP driver
6 - state machine for adapter, port and unit
7 - layering violation issues regarding request processing
8 - modify exchange-port,
9 - config data to not use recovery semaphore
10 - kernel thread API adaption
11 - remove forced port recovery when port recovery is already running
12 - lock consolidation (config lock vs. other locks)
13
14 Acked-by: John Jolly <jjolly@suse.de>
15 ---
16 drivers/s390/scsi/zfcp_aux.c | 142 +++--------------
17 drivers/s390/scsi/zfcp_ccw.c | 33 +++-
18 drivers/s390/scsi/zfcp_dbf.c | 73 +++++++--
19 drivers/s390/scsi/zfcp_dbf.h | 1
20 drivers/s390/scsi/zfcp_def.h | 178 +++++----------------
21 drivers/s390/scsi/zfcp_erp.c | 178 ++++++---------------
22 drivers/s390/scsi/zfcp_ext.h | 27 +--
23 drivers/s390/scsi/zfcp_fc.c | 227 +++++++++++++++++++---------
24 drivers/s390/scsi/zfcp_fsf.c | 332 ++++++++++++++++++++++++++++-------------
25 drivers/s390/scsi/zfcp_fsf.h | 75 ---------
26 drivers/s390/scsi/zfcp_qdio.c | 40 ++--
27 drivers/s390/scsi/zfcp_scsi.c | 25 ---
28 drivers/s390/scsi/zfcp_sysfs.c | 47 ++---
29 13 files changed, 654 insertions(+), 724 deletions(-)
30
31 --- a/drivers/s390/scsi/zfcp_aux.c
32 +++ b/drivers/s390/scsi/zfcp_aux.c
33 @@ -90,11 +90,13 @@ static int __init zfcp_device_setup(char
34 strncpy(zfcp_data.init_busid, token, BUS_ID_SIZE);
35
36 token = strsep(&str, ",");
37 - if (!token || strict_strtoull(token, 0, &zfcp_data.init_wwpn))
38 + if (!token || strict_strtoull(token, 0,
39 + (unsigned long long *) &zfcp_data.init_wwpn))
40 goto err_out;
41
42 token = strsep(&str, ",");
43 - if (!token || strict_strtoull(token, 0, &zfcp_data.init_fcp_lun))
44 + if (!token || strict_strtoull(token, 0,
45 + (unsigned long long *) &zfcp_data.init_fcp_lun))
46 goto err_out;
47
48 kfree(str);
49 @@ -106,19 +108,6 @@ static int __init zfcp_device_setup(char
50 return 0;
51 }
52
53 -static struct zfcp_adapter *zfcp_get_adapter_by_busid(char *bus_id)
54 -{
55 - struct zfcp_adapter *adapter;
56 -
57 - list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list)
58 - if ((strncmp(bus_id, adapter->ccw_device->dev.bus_id,
59 - BUS_ID_SIZE) == 0) &&
60 - !(atomic_read(&adapter->status) &
61 - ZFCP_STATUS_COMMON_REMOVE))
62 - return adapter;
63 - return NULL;
64 -}
65 -
66 static void __init zfcp_init_device_configure(void)
67 {
68 struct zfcp_adapter *adapter;
69 @@ -142,7 +131,12 @@ static void __init zfcp_init_device_conf
70 goto out_unit;
71 up(&zfcp_data.config_sema);
72 ccw_device_set_online(adapter->ccw_device);
73 +
74 zfcp_erp_wait(adapter);
75 + wait_event(adapter->erp_done_wqh,
76 + !(atomic_read(&unit->status) &
77 + ZFCP_STATUS_UNIT_SCSI_WORK_PENDING));
78 +
79 down(&zfcp_data.config_sema);
80 zfcp_unit_put(unit);
81 out_unit:
82 @@ -181,9 +175,9 @@ static int __init zfcp_module_init(void)
83 if (!zfcp_data.gid_pn_cache)
84 goto out_gid_cache;
85
86 - INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
87 - INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh);
88 + zfcp_data.work_queue = create_singlethread_workqueue("zfcp_wq");
89
90 + INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
91 sema_init(&zfcp_data.config_sema, 1);
92 rwlock_init(&zfcp_data.config_lock);
93
94 @@ -233,8 +227,7 @@ module_init(zfcp_module_init);
95 *
96 * Returns: pointer to zfcp_unit or NULL
97 */
98 -struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port,
99 - fcp_lun_t fcp_lun)
100 +struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
101 {
102 struct zfcp_unit *unit;
103
104 @@ -253,7 +246,7 @@ struct zfcp_unit *zfcp_get_unit_by_lun(s
105 * Returns: pointer to zfcp_port or NULL
106 */
107 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
108 - wwn_t wwpn)
109 + u64 wwpn)
110 {
111 struct zfcp_port *port;
112
113 @@ -278,7 +271,7 @@ static void zfcp_sysfs_unit_release(stru
114 *
115 * Sets up some unit internal structures and creates sysfs entry.
116 */
117 -struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun)
118 +struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
119 {
120 struct zfcp_unit *unit;
121
122 @@ -292,7 +285,8 @@ struct zfcp_unit *zfcp_unit_enqueue(stru
123 unit->port = port;
124 unit->fcp_lun = fcp_lun;
125
126 - snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun);
127 + snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx",
128 + (unsigned long long) fcp_lun);
129 unit->sysfs_device.parent = &port->sysfs_device;
130 unit->sysfs_device.release = zfcp_sysfs_unit_release;
131 dev_set_drvdata(&unit->sysfs_device, unit);
132 @@ -325,7 +319,6 @@ struct zfcp_unit *zfcp_unit_enqueue(stru
133 }
134
135 zfcp_unit_get(unit);
136 - unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun);
137
138 write_lock_irq(&zfcp_data.config_lock);
139 list_add_tail(&unit->list, &port->unit_list_head);
140 @@ -334,7 +327,6 @@ struct zfcp_unit *zfcp_unit_enqueue(stru
141
142 write_unlock_irq(&zfcp_data.config_lock);
143
144 - port->units++;
145 zfcp_port_get(port);
146
147 return unit;
148 @@ -353,11 +345,10 @@ err_out_free:
149 */
150 void zfcp_unit_dequeue(struct zfcp_unit *unit)
151 {
152 - zfcp_unit_wait(unit);
153 + wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
154 write_lock_irq(&zfcp_data.config_lock);
155 list_del(&unit->list);
156 write_unlock_irq(&zfcp_data.config_lock);
157 - unit->port->units--;
158 zfcp_port_put(unit->port);
159 sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs);
160 device_unregister(&unit->sysfs_device);
161 @@ -418,11 +409,6 @@ static void zfcp_free_low_mem_buffers(st
162 mempool_destroy(adapter->pool.data_gid_pn);
163 }
164
165 -static void zfcp_dummy_release(struct device *dev)
166 -{
167 - return;
168 -}
169 -
170 /**
171 * zfcp_status_read_refill - refill the long running status_read_requests
172 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
173 @@ -452,19 +438,6 @@ static void _zfcp_status_read_scheduler(
174 stat_work));
175 }
176
177 -static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter)
178 -{
179 - struct zfcp_port *port;
180 -
181 - port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA,
182 - ZFCP_DID_DIRECTORY_SERVICE);
183 - if (IS_ERR(port))
184 - return PTR_ERR(port);
185 - zfcp_port_put(port);
186 -
187 - return 0;
188 -}
189 -
190 /**
191 * zfcp_adapter_enqueue - enqueue a new adapter to the list
192 * @ccw_device: pointer to the struct cc_device
193 @@ -510,7 +483,6 @@ int zfcp_adapter_enqueue(struct ccw_devi
194 init_waitqueue_head(&adapter->erp_done_wqh);
195
196 INIT_LIST_HEAD(&adapter->port_list_head);
197 - INIT_LIST_HEAD(&adapter->port_remove_lh);
198 INIT_LIST_HEAD(&adapter->erp_ready_head);
199 INIT_LIST_HEAD(&adapter->erp_running_head);
200
201 @@ -520,7 +492,7 @@ int zfcp_adapter_enqueue(struct ccw_devi
202 spin_lock_init(&adapter->san_dbf_lock);
203 spin_lock_init(&adapter->scsi_dbf_lock);
204 spin_lock_init(&adapter->rec_dbf_lock);
205 - spin_lock_init(&adapter->req_q.lock);
206 + spin_lock_init(&adapter->req_q_lock);
207
208 rwlock_init(&adapter->erp_lock);
209 rwlock_init(&adapter->abort_lock);
210 @@ -539,28 +511,15 @@ int zfcp_adapter_enqueue(struct ccw_devi
211 &zfcp_sysfs_adapter_attrs))
212 goto sysfs_failed;
213
214 - adapter->generic_services.parent = &adapter->ccw_device->dev;
215 - adapter->generic_services.release = zfcp_dummy_release;
216 - snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE,
217 - "generic_services");
218 -
219 - if (device_register(&adapter->generic_services))
220 - goto generic_services_failed;
221 -
222 write_lock_irq(&zfcp_data.config_lock);
223 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
224 list_add_tail(&adapter->list, &zfcp_data.adapter_list_head);
225 write_unlock_irq(&zfcp_data.config_lock);
226
227 - zfcp_data.adapters++;
228 -
229 - zfcp_nameserver_enqueue(adapter);
230 + zfcp_fc_nameserver_init(adapter);
231
232 return 0;
233
234 -generic_services_failed:
235 - sysfs_remove_group(&ccw_device->dev.kobj,
236 - &zfcp_sysfs_adapter_attrs);
237 sysfs_failed:
238 zfcp_adapter_debug_unregister(adapter);
239 debug_register_failed:
240 @@ -587,7 +546,6 @@ void zfcp_adapter_dequeue(struct zfcp_ad
241 cancel_work_sync(&adapter->scan_work);
242 cancel_work_sync(&adapter->stat_work);
243 zfcp_adapter_scsi_unregister(adapter);
244 - device_unregister(&adapter->generic_services);
245 sysfs_remove_group(&adapter->ccw_device->dev.kobj,
246 &zfcp_sysfs_adapter_attrs);
247 dev_set_drvdata(&adapter->ccw_device->dev, NULL);
248 @@ -605,9 +563,6 @@ void zfcp_adapter_dequeue(struct zfcp_ad
249 list_del(&adapter->list);
250 write_unlock_irq(&zfcp_data.config_lock);
251
252 - /* decrease number of adapters in list */
253 - zfcp_data.adapters--;
254 -
255 zfcp_qdio_free(adapter);
256
257 zfcp_free_low_mem_buffers(adapter);
258 @@ -635,21 +590,19 @@ static void zfcp_sysfs_port_release(stru
259 * d_id is used to enqueue ports with a well known address like the Directory
260 * Service for nameserver lookup.
261 */
262 -struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn,
263 +struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
264 u32 status, u32 d_id)
265 {
266 struct zfcp_port *port;
267 int retval;
268 - char *bus_id;
269
270 port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
271 if (!port)
272 return ERR_PTR(-ENOMEM);
273
274 init_waitqueue_head(&port->remove_wq);
275 -
276 INIT_LIST_HEAD(&port->unit_list_head);
277 - INIT_LIST_HEAD(&port->unit_remove_lh);
278 + INIT_WORK(&port->gid_pn_work, zfcp_erp_port_strategy_open_lookup);
279
280 port->adapter = adapter;
281 port->d_id = d_id;
282 @@ -659,34 +612,9 @@ struct zfcp_port *zfcp_port_enqueue(stru
283 atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status);
284 atomic_set(&port->refcount, 0);
285
286 - if (status & ZFCP_STATUS_PORT_WKA) {
287 - switch (d_id) {
288 - case ZFCP_DID_DIRECTORY_SERVICE:
289 - bus_id = "directory";
290 - break;
291 - case ZFCP_DID_MANAGEMENT_SERVICE:
292 - bus_id = "management";
293 - break;
294 - case ZFCP_DID_KEY_DISTRIBUTION_SERVICE:
295 - bus_id = "key_distribution";
296 - break;
297 - case ZFCP_DID_ALIAS_SERVICE:
298 - bus_id = "alias";
299 - break;
300 - case ZFCP_DID_TIME_SERVICE:
301 - bus_id = "time";
302 - break;
303 - default:
304 - kfree(port);
305 - return ERR_PTR(-EINVAL);
306 - }
307 - snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id);
308 - port->sysfs_device.parent = &adapter->generic_services;
309 - } else {
310 - snprintf(port->sysfs_device.bus_id,
311 - BUS_ID_SIZE, "0x%016llx", wwpn);
312 - port->sysfs_device.parent = &adapter->ccw_device->dev;
313 - }
314 + snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx",
315 + (unsigned long long) wwpn);
316 + port->sysfs_device.parent = &adapter->ccw_device->dev;
317
318 port->sysfs_device.release = zfcp_sysfs_port_release;
319 dev_set_drvdata(&port->sysfs_device, port);
320 @@ -702,12 +630,8 @@ struct zfcp_port *zfcp_port_enqueue(stru
321 if (device_register(&port->sysfs_device))
322 goto err_out_free;
323
324 - if (status & ZFCP_STATUS_PORT_WKA)
325 - retval = sysfs_create_group(&port->sysfs_device.kobj,
326 - &zfcp_sysfs_ns_port_attrs);
327 - else
328 - retval = sysfs_create_group(&port->sysfs_device.kobj,
329 - &zfcp_sysfs_port_attrs);
330 + retval = sysfs_create_group(&port->sysfs_device.kobj,
331 + &zfcp_sysfs_port_attrs);
332
333 if (retval) {
334 device_unregister(&port->sysfs_device);
335 @@ -720,10 +644,6 @@ struct zfcp_port *zfcp_port_enqueue(stru
336 list_add_tail(&port->list, &adapter->port_list_head);
337 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
338 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
339 - if (d_id == ZFCP_DID_DIRECTORY_SERVICE)
340 - if (!adapter->nameserver_port)
341 - adapter->nameserver_port = port;
342 - adapter->ports++;
343
344 write_unlock_irq(&zfcp_data.config_lock);
345
346 @@ -742,21 +662,15 @@ err_out:
347 */
348 void zfcp_port_dequeue(struct zfcp_port *port)
349 {
350 - zfcp_port_wait(port);
351 + wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
352 write_lock_irq(&zfcp_data.config_lock);
353 list_del(&port->list);
354 - port->adapter->ports--;
355 write_unlock_irq(&zfcp_data.config_lock);
356 if (port->rport)
357 fc_remote_port_delete(port->rport);
358 port->rport = NULL;
359 zfcp_adapter_put(port->adapter);
360 - if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA)
361 - sysfs_remove_group(&port->sysfs_device.kobj,
362 - &zfcp_sysfs_ns_port_attrs);
363 - else
364 - sysfs_remove_group(&port->sysfs_device.kobj,
365 - &zfcp_sysfs_port_attrs);
366 + sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs);
367 device_unregister(&port->sysfs_device);
368 }
369
370 --- a/drivers/s390/scsi/zfcp_ccw.c
371 +++ b/drivers/s390/scsi/zfcp_ccw.c
372 @@ -49,6 +49,8 @@ static void zfcp_ccw_remove(struct ccw_d
373 struct zfcp_adapter *adapter;
374 struct zfcp_port *port, *p;
375 struct zfcp_unit *unit, *u;
376 + LIST_HEAD(unit_remove_lh);
377 + LIST_HEAD(port_remove_lh);
378
379 ccw_device_set_offline(ccw_device);
380 down(&zfcp_data.config_sema);
381 @@ -57,26 +59,26 @@ static void zfcp_ccw_remove(struct ccw_d
382 write_lock_irq(&zfcp_data.config_lock);
383 list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
384 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
385 - list_move(&unit->list, &port->unit_remove_lh);
386 + list_move(&unit->list, &unit_remove_lh);
387 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
388 &unit->status);
389 }
390 - list_move(&port->list, &adapter->port_remove_lh);
391 + list_move(&port->list, &port_remove_lh);
392 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
393 }
394 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
395 write_unlock_irq(&zfcp_data.config_lock);
396
397 - list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
398 - list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
399 - if (atomic_test_mask(ZFCP_STATUS_UNIT_REGISTERED,
400 - &unit->status))
401 + list_for_each_entry_safe(port, p, &port_remove_lh, list) {
402 + list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
403 + if (atomic_read(&unit->status) &
404 + ZFCP_STATUS_UNIT_REGISTERED)
405 scsi_remove_device(unit->device);
406 zfcp_unit_dequeue(unit);
407 }
408 zfcp_port_dequeue(port);
409 }
410 - zfcp_adapter_wait(adapter);
411 + wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
412 zfcp_adapter_dequeue(adapter);
413
414 up(&zfcp_data.config_sema);
415 @@ -226,3 +228,20 @@ int __init zfcp_ccw_register(void)
416 {
417 return ccw_driver_register(&zfcp_ccw_driver);
418 }
419 +
420 +/**
421 + * zfcp_get_adapter_by_busid - find zfcp_adapter struct
422 + * @busid: bus id string of zfcp adapter to find
423 + */
424 +struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
425 +{
426 + struct ccw_device *ccw_device;
427 + struct zfcp_adapter *adapter = NULL;
428 +
429 + ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
430 + if (ccw_device) {
431 + adapter = dev_get_drvdata(&ccw_device->dev);
432 + put_device(&ccw_device->dev);
433 + }
434 + return adapter;
435 +}
436 --- a/drivers/s390/scsi/zfcp_dbf.c
437 +++ b/drivers/s390/scsi/zfcp_dbf.c
438 @@ -320,6 +320,26 @@ void zfcp_hba_dbf_event_qdio(struct zfcp
439 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
440 }
441
442 +/**
443 + * zfcp_hba_dbf_event_berr - trace event for bit error threshold
444 + * @adapter: adapter affected by this QDIO related event
445 + * @req: fsf request
446 + */
447 +void zfcp_hba_dbf_event_berr(struct zfcp_adapter *adapter,
448 + struct zfcp_fsf_req *req)
449 +{
450 + struct zfcp_hba_dbf_record *r = &adapter->hba_dbf_buf;
451 + struct fsf_status_read_buffer *sr_buf = req->data;
452 + struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
453 + unsigned long flags;
454 +
455 + spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
456 + memset(r, 0, sizeof(*r));
457 + strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
458 + memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
459 + debug_event(adapter->hba_dbf, 0, r, sizeof(*r));
460 + spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
461 +}
462 static void zfcp_hba_dbf_view_response(char **p,
463 struct zfcp_hba_dbf_record_response *r)
464 {
465 @@ -401,6 +421,30 @@ static void zfcp_hba_dbf_view_qdio(char
466 zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
467 }
468
469 +static void zfcp_hba_dbf_view_berr(char **p, struct fsf_bit_error_payload *r)
470 +{
471 + zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count);
472 + zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count);
473 + zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count);
474 + zfcp_dbf_out(p, "prim_seq_err", "%d",
475 + r->primitive_sequence_error_count);
476 + zfcp_dbf_out(p, "inval_trans_word_err", "%d",
477 + r->invalid_transmission_word_error_count);
478 + zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
479 + zfcp_dbf_out(p, "prim_seq_event_to", "%d",
480 + r->primitive_sequence_event_timeout_count);
481 + zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
482 + r->elastic_buffer_overrun_error_count);
483 + zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
484 + r->advertised_receive_b2b_credit);
485 + zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
486 + r->current_receive_b2b_credit);
487 + zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
488 + r->advertised_transmit_b2b_credit);
489 + zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
490 + r->current_transmit_b2b_credit);
491 +}
492 +
493 static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view,
494 char *out_buf, const char *in_buf)
495 {
496 @@ -420,6 +464,8 @@ static int zfcp_hba_dbf_view_format(debu
497 zfcp_hba_dbf_view_status(&p, &r->u.status);
498 else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
499 zfcp_hba_dbf_view_qdio(&p, &r->u.qdio);
500 + else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
501 + zfcp_hba_dbf_view_berr(&p, &r->u.berr);
502
503 p += sprintf(p, "\n");
504 return p - out_buf;
505 @@ -521,14 +567,14 @@ static const char *zfcp_rec_dbf_ids[] =
506 [75] = "physical port recovery escalation after failed port "
507 "recovery",
508 [76] = "port recovery escalation after failed unit recovery",
509 - [77] = "recovery opening nameserver port",
510 + [77] = "",
511 [78] = "duplicate request id",
512 [79] = "link down",
513 [80] = "exclusive read-only unit access unsupported",
514 [81] = "shared read-write unit access unsupported",
515 [82] = "incoming rscn",
516 [83] = "incoming wwpn",
517 - [84] = "",
518 + [84] = "wka port handle not valid close port",
519 [85] = "online",
520 [86] = "offline",
521 [87] = "ccw device gone",
522 @@ -831,9 +877,9 @@ void zfcp_rec_dbf_event_action(u8 id2, s
523 void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
524 {
525 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
526 - struct zfcp_port *port = ct->port;
527 - struct zfcp_adapter *adapter = port->adapter;
528 - struct ct_hdr *hdr = zfcp_sg_to_address(ct->req);
529 + struct zfcp_wka_port *wka_port = ct->wka_port;
530 + struct zfcp_adapter *adapter = wka_port->adapter;
531 + struct ct_hdr *hdr = sg_virt(ct->req);
532 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
533 struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req;
534 unsigned long flags;
535 @@ -844,7 +890,7 @@ void zfcp_san_dbf_event_ct_request(struc
536 r->fsf_reqid = (unsigned long)fsf_req;
537 r->fsf_seqno = fsf_req->seq_no;
538 r->s_id = fc_host_port_id(adapter->scsi_host);
539 - r->d_id = port->d_id;
540 + r->d_id = wka_port->d_id;
541 oct->cmd_req_code = hdr->cmd_rsp_code;
542 oct->revision = hdr->revision;
543 oct->gs_type = hdr->gs_type;
544 @@ -865,9 +911,9 @@ void zfcp_san_dbf_event_ct_request(struc
545 void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
546 {
547 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
548 - struct zfcp_port *port = ct->port;
549 - struct zfcp_adapter *adapter = port->adapter;
550 - struct ct_hdr *hdr = zfcp_sg_to_address(ct->resp);
551 + struct zfcp_wka_port *wka_port = ct->wka_port;
552 + struct zfcp_adapter *adapter = wka_port->adapter;
553 + struct ct_hdr *hdr = sg_virt(ct->resp);
554 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
555 struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp;
556 unsigned long flags;
557 @@ -877,7 +923,7 @@ void zfcp_san_dbf_event_ct_response(stru
558 strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
559 r->fsf_reqid = (unsigned long)fsf_req;
560 r->fsf_seqno = fsf_req->seq_no;
561 - r->s_id = port->d_id;
562 + r->s_id = wka_port->d_id;
563 r->d_id = fc_host_port_id(adapter->scsi_host);
564 rct->cmd_rsp_code = hdr->cmd_rsp_code;
565 rct->revision = hdr->revision;
566 @@ -924,8 +970,8 @@ void zfcp_san_dbf_event_els_request(stru
567
568 zfcp_san_dbf_event_els("oels", 2, fsf_req,
569 fc_host_port_id(els->adapter->scsi_host),
570 - els->d_id, *(u8 *) zfcp_sg_to_address(els->req),
571 - zfcp_sg_to_address(els->req), els->req->length);
572 + els->d_id, *(u8 *) sg_virt(els->req),
573 + sg_virt(els->req), els->req->length);
574 }
575
576 /**
577 @@ -938,8 +984,7 @@ void zfcp_san_dbf_event_els_response(str
578
579 zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id,
580 fc_host_port_id(els->adapter->scsi_host),
581 - *(u8 *)zfcp_sg_to_address(els->req),
582 - zfcp_sg_to_address(els->resp),
583 + *(u8 *)sg_virt(els->req), sg_virt(els->resp),
584 els->resp->length);
585 }
586
587 --- a/drivers/s390/scsi/zfcp_dbf.h
588 +++ b/drivers/s390/scsi/zfcp_dbf.h
589 @@ -151,6 +151,7 @@ struct zfcp_hba_dbf_record {
590 struct zfcp_hba_dbf_record_response response;
591 struct zfcp_hba_dbf_record_status status;
592 struct zfcp_hba_dbf_record_qdio qdio;
593 + struct fsf_bit_error_payload berr;
594 } u;
595 } __attribute__ ((packed));
596
597 --- a/drivers/s390/scsi/zfcp_def.h
598 +++ b/drivers/s390/scsi/zfcp_def.h
599 @@ -39,29 +39,6 @@
600
601 /********************* GENERAL DEFINES *********************************/
602
603 -/**
604 - * zfcp_sg_to_address - determine kernel address from struct scatterlist
605 - * @list: struct scatterlist
606 - * Return: kernel address
607 - */
608 -static inline void *
609 -zfcp_sg_to_address(struct scatterlist *list)
610 -{
611 - return sg_virt(list);
612 -}
613 -
614 -/**
615 - * zfcp_address_to_sg - set up struct scatterlist from kernel address
616 - * @address: kernel address
617 - * @list: struct scatterlist
618 - * @size: buffer size
619 - */
620 -static inline void
621 -zfcp_address_to_sg(void *address, struct scatterlist *list, unsigned int size)
622 -{
623 - sg_set_buf(list, address, size);
624 -}
625 -
626 #define REQUEST_LIST_SIZE 128
627
628 /********************* SCSI SPECIFIC DEFINES *********************************/
629 @@ -101,11 +78,6 @@ zfcp_address_to_sg(void *address, struct
630
631 /*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/
632
633 -typedef unsigned long long wwn_t;
634 -typedef unsigned long long fcp_lun_t;
635 -/* data length field may be at variable position in FCP-2 FCP_CMND IU */
636 -typedef unsigned int fcp_dl_t;
637 -
638 /* timeout for name-server lookup (in seconds) */
639 #define ZFCP_NS_GID_PN_TIMEOUT 10
640
641 @@ -129,7 +101,7 @@ typedef unsigned int fcp_dl_t;
642
643 /* FCP(-2) FCP_CMND IU */
644 struct fcp_cmnd_iu {
645 - fcp_lun_t fcp_lun; /* FCP logical unit number */
646 + u64 fcp_lun; /* FCP logical unit number */
647 u8 crn; /* command reference number */
648 u8 reserved0:5; /* reserved */
649 u8 task_attribute:3; /* task attribute */
650 @@ -204,7 +176,7 @@ struct fcp_rscn_element {
651 struct fcp_logo {
652 u32 command;
653 u32 nport_did;
654 - wwn_t nport_wwpn;
655 + u64 nport_wwpn;
656 } __attribute__((packed));
657
658 /*
659 @@ -218,13 +190,6 @@ struct fcp_logo {
660 #define ZFCP_LS_RSCN 0x61
661 #define ZFCP_LS_RNID 0x78
662
663 -struct zfcp_ls_rjt_par {
664 - u8 action;
665 - u8 reason_code;
666 - u8 reason_expl;
667 - u8 vendor_unique;
668 -} __attribute__ ((packed));
669 -
670 struct zfcp_ls_adisc {
671 u8 code;
672 u8 field[3];
673 @@ -234,20 +199,6 @@ struct zfcp_ls_adisc {
674 u32 nport_id;
675 } __attribute__ ((packed));
676
677 -struct zfcp_ls_adisc_acc {
678 - u8 code;
679 - u8 field[3];
680 - u32 hard_nport_id;
681 - u64 wwpn;
682 - u64 wwnn;
683 - u32 nport_id;
684 -} __attribute__ ((packed));
685 -
686 -struct zfcp_rc_entry {
687 - u8 code;
688 - const char *description;
689 -};
690 -
691 /*
692 * FC-GS-2 stuff
693 */
694 @@ -281,9 +232,7 @@ struct zfcp_rc_entry {
695 #define ZFCP_STATUS_COMMON_RUNNING 0x40000000
696 #define ZFCP_STATUS_COMMON_ERP_FAILED 0x20000000
697 #define ZFCP_STATUS_COMMON_UNBLOCKED 0x10000000
698 -#define ZFCP_STATUS_COMMON_OPENING 0x08000000
699 #define ZFCP_STATUS_COMMON_OPEN 0x04000000
700 -#define ZFCP_STATUS_COMMON_CLOSING 0x02000000
701 #define ZFCP_STATUS_COMMON_ERP_INUSE 0x01000000
702 #define ZFCP_STATUS_COMMON_ACCESS_DENIED 0x00800000
703 #define ZFCP_STATUS_COMMON_ACCESS_BOXED 0x00400000
704 @@ -291,16 +240,15 @@ struct zfcp_rc_entry {
705
706 /* adapter status */
707 #define ZFCP_STATUS_ADAPTER_QDIOUP 0x00000002
708 -#define ZFCP_STATUS_ADAPTER_REGISTERED 0x00000004
709 #define ZFCP_STATUS_ADAPTER_XCONFIG_OK 0x00000008
710 #define ZFCP_STATUS_ADAPTER_HOST_CON_INIT 0x00000010
711 #define ZFCP_STATUS_ADAPTER_ERP_THREAD_UP 0x00000020
712 #define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL 0x00000080
713 #define ZFCP_STATUS_ADAPTER_ERP_PENDING 0x00000100
714 #define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED 0x00000200
715 -#define ZFCP_STATUS_ADAPTER_XPORT_OK 0x00000800
716
717 /* FC-PH/FC-GS well-known address identifiers for generic services */
718 +#define ZFCP_DID_WKA 0xFFFFF0
719 #define ZFCP_DID_MANAGEMENT_SERVICE 0xFFFFFA
720 #define ZFCP_DID_TIME_SERVICE 0xFFFFFB
721 #define ZFCP_DID_DIRECTORY_SERVICE 0xFFFFFC
722 @@ -312,29 +260,27 @@ struct zfcp_rc_entry {
723 #define ZFCP_STATUS_PORT_DID_DID 0x00000002
724 #define ZFCP_STATUS_PORT_PHYS_CLOSING 0x00000004
725 #define ZFCP_STATUS_PORT_NO_WWPN 0x00000008
726 -#define ZFCP_STATUS_PORT_NO_SCSI_ID 0x00000010
727 #define ZFCP_STATUS_PORT_INVALID_WWPN 0x00000020
728
729 -/* for ports with well known addresses */
730 -#define ZFCP_STATUS_PORT_WKA \
731 - (ZFCP_STATUS_PORT_NO_WWPN | \
732 - ZFCP_STATUS_PORT_NO_SCSI_ID)
733 +/* well known address (WKA) port status*/
734 +enum zfcp_wka_status {
735 + ZFCP_WKA_PORT_OFFLINE,
736 + ZFCP_WKA_PORT_CLOSING,
737 + ZFCP_WKA_PORT_OPENING,
738 + ZFCP_WKA_PORT_ONLINE,
739 +};
740
741 /* logical unit status */
742 -#define ZFCP_STATUS_UNIT_TEMPORARY 0x00000002
743 #define ZFCP_STATUS_UNIT_SHARED 0x00000004
744 #define ZFCP_STATUS_UNIT_READONLY 0x00000008
745 #define ZFCP_STATUS_UNIT_REGISTERED 0x00000010
746 #define ZFCP_STATUS_UNIT_SCSI_WORK_PENDING 0x00000020
747
748 /* FSF request status (this does not have a common part) */
749 -#define ZFCP_STATUS_FSFREQ_NOT_INIT 0x00000000
750 -#define ZFCP_STATUS_FSFREQ_POOL 0x00000001
751 #define ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT 0x00000002
752 #define ZFCP_STATUS_FSFREQ_COMPLETED 0x00000004
753 #define ZFCP_STATUS_FSFREQ_ERROR 0x00000008
754 #define ZFCP_STATUS_FSFREQ_CLEANUP 0x00000010
755 -#define ZFCP_STATUS_FSFREQ_ABORTING 0x00000020
756 #define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED 0x00000040
757 #define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED 0x00000080
758 #define ZFCP_STATUS_FSFREQ_ABORTED 0x00000100
759 @@ -379,7 +325,7 @@ struct ct_hdr {
760 * a port name is required */
761 struct ct_iu_gid_pn_req {
762 struct ct_hdr header;
763 - wwn_t wwpn;
764 + u64 wwpn;
765 } __attribute__ ((packed));
766
767 /* FS_ACC IU and data unit for GID_PN nameserver request */
768 @@ -388,11 +334,9 @@ struct ct_iu_gid_pn_resp {
769 u32 d_id;
770 } __attribute__ ((packed));
771
772 -typedef void (*zfcp_send_ct_handler_t)(unsigned long);
773 -
774 /**
775 * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct
776 - * @port: port where the request is sent to
777 + * @wka_port: port where the request is sent to
778 * @req: scatter-gather list for request
779 * @resp: scatter-gather list for response
780 * @req_count: number of elements in request scatter-gather list
781 @@ -404,12 +348,12 @@ typedef void (*zfcp_send_ct_handler_t)(u
782 * @status: used to pass error status to calling function
783 */
784 struct zfcp_send_ct {
785 - struct zfcp_port *port;
786 + struct zfcp_wka_port *wka_port;
787 struct scatterlist *req;
788 struct scatterlist *resp;
789 unsigned int req_count;
790 unsigned int resp_count;
791 - zfcp_send_ct_handler_t handler;
792 + void (*handler)(unsigned long);
793 unsigned long handler_data;
794 int timeout;
795 struct completion *completion;
796 @@ -426,8 +370,6 @@ struct zfcp_gid_pn_data {
797 struct zfcp_port *port;
798 };
799
800 -typedef void (*zfcp_send_els_handler_t)(unsigned long);
801 -
802 /**
803 * struct zfcp_send_els - used to pass parameters to function zfcp_fsf_send_els
804 * @adapter: adapter where request is sent from
805 @@ -451,22 +393,28 @@ struct zfcp_send_els {
806 struct scatterlist *resp;
807 unsigned int req_count;
808 unsigned int resp_count;
809 - zfcp_send_els_handler_t handler;
810 + void (*handler)(unsigned long);
811 unsigned long handler_data;
812 struct completion *completion;
813 int ls_code;
814 int status;
815 };
816
817 +struct zfcp_wka_port {
818 + struct zfcp_adapter *adapter;
819 + wait_queue_head_t completion_wq;
820 + enum zfcp_wka_status status;
821 + atomic_t refcount;
822 + u32 d_id;
823 + u32 handle;
824 + struct mutex mutex;
825 + struct delayed_work work;
826 +};
827 +
828 struct zfcp_qdio_queue {
829 - struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q]; /* SBALs */
830 - u8 first; /* index of next free bfr
831 - in queue (free_count>0) */
832 - atomic_t count; /* number of free buffers
833 - in queue */
834 - spinlock_t lock; /* lock for operations on queue */
835 - int pci_batch; /* SBALs since PCI indication
836 - was last set */
837 + struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
838 + u8 first; /* index of next free bfr in queue */
839 + atomic_t count; /* number of free buffers in queue */
840 };
841
842 struct zfcp_erp_action {
843 @@ -475,7 +423,7 @@ struct zfcp_erp_action {
844 struct zfcp_adapter *adapter; /* device which should be recovered */
845 struct zfcp_port *port;
846 struct zfcp_unit *unit;
847 - volatile u32 status; /* recovery status */
848 + u32 status; /* recovery status */
849 u32 step; /* active step of this erp action */
850 struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
851 for this action */
852 @@ -506,8 +454,8 @@ struct zfcp_adapter {
853 atomic_t refcount; /* reference count */
854 wait_queue_head_t remove_wq; /* can be used to wait for
855 refcount drop to zero */
856 - wwn_t peer_wwnn; /* P2P peer WWNN */
857 - wwn_t peer_wwpn; /* P2P peer WWPN */
858 + u64 peer_wwnn; /* P2P peer WWNN */
859 + u64 peer_wwpn; /* P2P peer WWPN */
860 u32 peer_d_id; /* P2P peer D_ID */
861 struct ccw_device *ccw_device; /* S/390 ccw device */
862 u32 hydra_version; /* Hydra version */
863 @@ -518,13 +466,13 @@ struct zfcp_adapter {
864 u16 timer_ticks; /* time int for a tick */
865 struct Scsi_Host *scsi_host; /* Pointer to mid-layer */
866 struct list_head port_list_head; /* remote port list */
867 - struct list_head port_remove_lh; /* head of ports to be
868 - removed */
869 - u32 ports; /* number of remote ports */
870 unsigned long req_no; /* unique FSF req number */
871 struct list_head *req_list; /* list of pending reqs */
872 spinlock_t req_list_lock; /* request list lock */
873 struct zfcp_qdio_queue req_q; /* request queue */
874 + spinlock_t req_q_lock; /* for operations on queue */
875 + int req_q_pci_batch; /* SBALs since PCI indication
876 + was last set */
877 u32 fsf_req_seq_no; /* FSF cmnd seq number */
878 wait_queue_head_t request_wq; /* can be used to wait for
879 more avaliable SBALs */
880 @@ -548,7 +496,7 @@ struct zfcp_adapter {
881 actions */
882 u32 erp_low_mem_count; /* nr of erp actions waiting
883 for memory */
884 - struct zfcp_port *nameserver_port; /* adapter's nameserver */
885 + struct zfcp_wka_port nsp; /* adapter's nameserver */
886 debug_info_t *rec_dbf;
887 debug_info_t *hba_dbf;
888 debug_info_t *san_dbf; /* debug feature areas */
889 @@ -563,7 +511,6 @@ struct zfcp_adapter {
890 struct zfcp_scsi_dbf_record scsi_dbf_buf;
891 struct zfcp_adapter_mempool pool; /* Adapter memory pools */
892 struct qdio_initialize qdio_init_data; /* for qdio_establish */
893 - struct device generic_services; /* directory for WKA ports */
894 struct fc_host_statistics *fc_stats;
895 struct fsf_qtcb_bottom_port *stats_reset_data;
896 unsigned long stats_reset;
897 @@ -580,18 +527,16 @@ struct zfcp_port {
898 refcount drop to zero */
899 struct zfcp_adapter *adapter; /* adapter used to access port */
900 struct list_head unit_list_head; /* head of logical unit list */
901 - struct list_head unit_remove_lh; /* head of luns to be removed
902 - list */
903 - u32 units; /* # of logical units in list */
904 atomic_t status; /* status of this remote port */
905 - wwn_t wwnn; /* WWNN if known */
906 - wwn_t wwpn; /* WWPN */
907 + u64 wwnn; /* WWNN if known */
908 + u64 wwpn; /* WWPN */
909 u32 d_id; /* D_ID */
910 u32 handle; /* handle assigned by FSF */
911 struct zfcp_erp_action erp_action; /* pending error recovery */
912 atomic_t erp_counter;
913 u32 maxframe_size;
914 u32 supported_classes;
915 + struct work_struct gid_pn_work;
916 };
917
918 struct zfcp_unit {
919 @@ -602,8 +547,7 @@ struct zfcp_unit {
920 refcount drop to zero */
921 struct zfcp_port *port; /* remote port of unit */
922 atomic_t status; /* status of this logical unit */
923 - unsigned int scsi_lun; /* own SCSI LUN */
924 - fcp_lun_t fcp_lun; /* own FCP_LUN */
925 + u64 fcp_lun; /* own FCP_LUN */
926 u32 handle; /* handle assigned by FSF */
927 struct scsi_device *device; /* scsi device struct pointer */
928 struct zfcp_erp_action erp_action; /* pending error recovery */
929 @@ -626,7 +570,7 @@ struct zfcp_fsf_req {
930 u8 sbal_response; /* SBAL used in interrupt */
931 wait_queue_head_t completion_wq; /* can be used by a routine
932 to wait for completion */
933 - volatile u32 status; /* status of this request */
934 + u32 status; /* status of this request */
935 u32 fsf_command; /* FSF Command copy */
936 struct fsf_qtcb *qtcb; /* address of associated QTCB */
937 u32 seq_no; /* Sequence number of request */
938 @@ -647,11 +591,7 @@ struct zfcp_fsf_req {
939 struct zfcp_data {
940 struct scsi_host_template scsi_host_template;
941 struct scsi_transport_template *scsi_transport_template;
942 - atomic_t status; /* Module status flags */
943 struct list_head adapter_list_head; /* head of adapter list */
944 - struct list_head adapter_remove_lh; /* head of adapters to be
945 - removed */
946 - u32 adapters; /* # of adapters in list */
947 rwlock_t config_lock; /* serialises changes
948 to adapter/port/unit
949 lists */
950 @@ -659,11 +599,12 @@ struct zfcp_data {
951 changes */
952 atomic_t loglevel; /* current loglevel */
953 char init_busid[BUS_ID_SIZE];
954 - wwn_t init_wwpn;
955 - fcp_lun_t init_fcp_lun;
956 - struct kmem_cache *fsf_req_qtcb_cache;
957 - struct kmem_cache *sr_buffer_cache;
958 - struct kmem_cache *gid_pn_cache;
959 + u64 init_wwpn;
960 + u64 init_fcp_lun;
961 + struct kmem_cache *fsf_req_qtcb_cache;
962 + struct kmem_cache *sr_buffer_cache;
963 + struct kmem_cache *gid_pn_cache;
964 + struct workqueue_struct *work_queue;
965 };
966
967 /* struct used by memory pools for fsf_requests */
968 @@ -680,14 +621,7 @@ struct zfcp_fsf_req_qtcb {
969 #define ZFCP_SET 0x00000100
970 #define ZFCP_CLEAR 0x00000200
971
972 -#ifndef atomic_test_mask
973 -#define atomic_test_mask(mask, target) \
974 - ((atomic_read(target) & mask) == mask)
975 -#endif
976 -
977 #define zfcp_get_busid_by_adapter(adapter) (adapter->ccw_device->dev.bus_id)
978 -#define zfcp_get_busid_by_port(port) (zfcp_get_busid_by_adapter(port->adapter))
979 -#define zfcp_get_busid_by_unit(unit) (zfcp_get_busid_by_port(unit->port))
980
981 /*
982 * Helper functions for request ID management.
983 @@ -748,12 +682,6 @@ zfcp_unit_put(struct zfcp_unit *unit)
984 }
985
986 static inline void
987 -zfcp_unit_wait(struct zfcp_unit *unit)
988 -{
989 - wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
990 -}
991 -
992 -static inline void
993 zfcp_port_get(struct zfcp_port *port)
994 {
995 atomic_inc(&port->refcount);
996 @@ -767,12 +695,6 @@ zfcp_port_put(struct zfcp_port *port)
997 }
998
999 static inline void
1000 -zfcp_port_wait(struct zfcp_port *port)
1001 -{
1002 - wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
1003 -}
1004 -
1005 -static inline void
1006 zfcp_adapter_get(struct zfcp_adapter *adapter)
1007 {
1008 atomic_inc(&adapter->refcount);
1009 @@ -785,10 +707,4 @@ zfcp_adapter_put(struct zfcp_adapter *ad
1010 wake_up(&adapter->remove_wq);
1011 }
1012
1013 -static inline void
1014 -zfcp_adapter_wait(struct zfcp_adapter *adapter)
1015 -{
1016 - wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
1017 -}
1018 -
1019 #endif /* ZFCP_DEF_H */
1020 --- a/drivers/s390/scsi/zfcp_erp.c
1021 +++ b/drivers/s390/scsi/zfcp_erp.c
1022 @@ -25,7 +25,6 @@ enum zfcp_erp_steps {
1023 ZFCP_ERP_STEP_FSF_XCONFIG = 0x0001,
1024 ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
1025 ZFCP_ERP_STEP_PORT_CLOSING = 0x0100,
1026 - ZFCP_ERP_STEP_NAMESERVER_OPEN = 0x0200,
1027 ZFCP_ERP_STEP_NAMESERVER_LOOKUP = 0x0400,
1028 ZFCP_ERP_STEP_PORT_OPENING = 0x0800,
1029 ZFCP_ERP_STEP_UNIT_CLOSING = 0x1000,
1030 @@ -534,8 +533,7 @@ static void _zfcp_erp_port_reopen_all(st
1031 struct zfcp_port *port;
1032
1033 list_for_each_entry(port, &adapter->port_list_head, list)
1034 - if (!(atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA))
1035 - _zfcp_erp_port_reopen(port, clear, id, ref);
1036 + _zfcp_erp_port_reopen(port, clear, id, ref);
1037 }
1038
1039 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id,
1040 @@ -671,8 +669,6 @@ static int zfcp_erp_adapter_strategy_ope
1041 int ret;
1042 struct zfcp_adapter *adapter = act->adapter;
1043
1044 - atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
1045 -
1046 write_lock_irq(&adapter->erp_lock);
1047 zfcp_erp_action_to_running(act);
1048 write_unlock_irq(&adapter->erp_lock);
1049 @@ -743,8 +739,7 @@ static int zfcp_erp_adapter_strategy_gen
1050 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
1051 failed_qdio:
1052 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
1053 - ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
1054 - ZFCP_STATUS_ADAPTER_XPORT_OK,
1055 + ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
1056 &act->adapter->status);
1057 return retval;
1058 }
1059 @@ -753,15 +748,11 @@ static int zfcp_erp_adapter_strategy(str
1060 {
1061 int retval;
1062
1063 - atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &act->adapter->status);
1064 zfcp_erp_adapter_strategy_generic(act, 1); /* close */
1065 - atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &act->adapter->status);
1066 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1067 return ZFCP_ERP_EXIT;
1068
1069 - atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &act->adapter->status);
1070 retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */
1071 - atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &act->adapter->status);
1072
1073 if (retval == ZFCP_ERP_FAILED)
1074 ssleep(8);
1075 @@ -785,10 +776,7 @@ static int zfcp_erp_port_forced_strategy
1076
1077 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
1078 {
1079 - atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
1080 - ZFCP_STATUS_COMMON_CLOSING |
1081 - ZFCP_STATUS_COMMON_ACCESS_DENIED |
1082 - ZFCP_STATUS_PORT_DID_DID |
1083 + atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1084 ZFCP_STATUS_PORT_PHYS_CLOSING |
1085 ZFCP_STATUS_PORT_INVALID_WWPN,
1086 &port->status);
1087 @@ -841,62 +829,6 @@ static int zfcp_erp_port_strategy_open_p
1088 return ZFCP_ERP_CONTINUES;
1089 }
1090
1091 -static void zfcp_erp_port_strategy_open_ns_wake(struct zfcp_erp_action *ns_act)
1092 -{
1093 - unsigned long flags;
1094 - struct zfcp_adapter *adapter = ns_act->adapter;
1095 - struct zfcp_erp_action *act, *tmp;
1096 - int status;
1097 -
1098 - read_lock_irqsave(&adapter->erp_lock, flags);
1099 - list_for_each_entry_safe(act, tmp, &adapter->erp_running_head, list) {
1100 - if (act->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
1101 - status = atomic_read(&adapter->nameserver_port->status);
1102 - if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
1103 - zfcp_erp_port_failed(act->port, 27, NULL);
1104 - zfcp_erp_action_ready(act);
1105 - }
1106 - }
1107 - read_unlock_irqrestore(&adapter->erp_lock, flags);
1108 -}
1109 -
1110 -static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *act)
1111 -{
1112 - int retval;
1113 -
1114 - switch (act->step) {
1115 - case ZFCP_ERP_STEP_UNINITIALIZED:
1116 - case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1117 - case ZFCP_ERP_STEP_PORT_CLOSING:
1118 - return zfcp_erp_port_strategy_open_port(act);
1119 -
1120 - case ZFCP_ERP_STEP_PORT_OPENING:
1121 - if (atomic_read(&act->port->status) & ZFCP_STATUS_COMMON_OPEN)
1122 - retval = ZFCP_ERP_SUCCEEDED;
1123 - else
1124 - retval = ZFCP_ERP_FAILED;
1125 - /* this is needed anyway */
1126 - zfcp_erp_port_strategy_open_ns_wake(act);
1127 - return retval;
1128 -
1129 - default:
1130 - return ZFCP_ERP_FAILED;
1131 - }
1132 -}
1133 -
1134 -static int zfcp_erp_port_strategy_open_lookup(struct zfcp_erp_action *act)
1135 -{
1136 - int retval;
1137 -
1138 - retval = zfcp_fc_ns_gid_pn_request(act);
1139 - if (retval == -ENOMEM)
1140 - return ZFCP_ERP_NOMEM;
1141 - act->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
1142 - if (retval)
1143 - return ZFCP_ERP_FAILED;
1144 - return ZFCP_ERP_CONTINUES;
1145 -}
1146 -
1147 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
1148 {
1149 struct zfcp_adapter *adapter = act->adapter;
1150 @@ -911,11 +843,25 @@ static int zfcp_erp_open_ptp_port(struct
1151 return zfcp_erp_port_strategy_open_port(act);
1152 }
1153
1154 +void zfcp_erp_port_strategy_open_lookup(struct work_struct *work)
1155 +{
1156 + int retval;
1157 + struct zfcp_port *port = container_of(work, struct zfcp_port,
1158 + gid_pn_work);
1159 +
1160 + retval = zfcp_fc_ns_gid_pn(&port->erp_action);
1161 + if (retval == -ENOMEM)
1162 + zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM);
1163 + port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
1164 + if (retval)
1165 + zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED);
1166 +
1167 +}
1168 +
1169 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
1170 {
1171 struct zfcp_adapter *adapter = act->adapter;
1172 struct zfcp_port *port = act->port;
1173 - struct zfcp_port *ns_port = adapter->nameserver_port;
1174 int p_status = atomic_read(&port->status);
1175
1176 switch (act->step) {
1177 @@ -924,28 +870,10 @@ static int zfcp_erp_port_strategy_open_c
1178 case ZFCP_ERP_STEP_PORT_CLOSING:
1179 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
1180 return zfcp_erp_open_ptp_port(act);
1181 - if (!ns_port) {
1182 - dev_err(&adapter->ccw_device->dev,
1183 - "Nameserver port unavailable.\n");
1184 - return ZFCP_ERP_FAILED;
1185 - }
1186 - if (!(atomic_read(&ns_port->status) &
1187 - ZFCP_STATUS_COMMON_UNBLOCKED)) {
1188 - /* nameserver port may live again */
1189 - atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
1190 - &ns_port->status);
1191 - if (zfcp_erp_port_reopen(ns_port, 0, 77, act) >= 0) {
1192 - act->step = ZFCP_ERP_STEP_NAMESERVER_OPEN;
1193 - return ZFCP_ERP_CONTINUES;
1194 - }
1195 - return ZFCP_ERP_FAILED;
1196 + if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
1197 + queue_work(zfcp_data.work_queue, &port->gid_pn_work);
1198 + return ZFCP_ERP_CONTINUES;
1199 }
1200 - /* else nameserver port is already open, fall through */
1201 - case ZFCP_ERP_STEP_NAMESERVER_OPEN:
1202 - if (!(atomic_read(&ns_port->status) & ZFCP_STATUS_COMMON_OPEN))
1203 - return ZFCP_ERP_FAILED;
1204 - return zfcp_erp_port_strategy_open_lookup(act);
1205 -
1206 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
1207 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
1208 if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) {
1209 @@ -958,25 +886,26 @@ static int zfcp_erp_port_strategy_open_c
1210
1211 case ZFCP_ERP_STEP_PORT_OPENING:
1212 /* D_ID might have changed during open */
1213 - if ((p_status & ZFCP_STATUS_COMMON_OPEN) &&
1214 - (p_status & ZFCP_STATUS_PORT_DID_DID))
1215 - return ZFCP_ERP_SUCCEEDED;
1216 + if (p_status & ZFCP_STATUS_COMMON_OPEN) {
1217 + if (p_status & ZFCP_STATUS_PORT_DID_DID)
1218 + return ZFCP_ERP_SUCCEEDED;
1219 + else {
1220 + act->step = ZFCP_ERP_STEP_PORT_CLOSING;
1221 + return ZFCP_ERP_CONTINUES;
1222 + }
1223 /* fall through otherwise */
1224 + }
1225 }
1226 return ZFCP_ERP_FAILED;
1227 }
1228
1229 -static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *act)
1230 -{
1231 - if (atomic_read(&act->port->status) & (ZFCP_STATUS_PORT_WKA))
1232 - return zfcp_erp_port_strategy_open_nameserver(act);
1233 - return zfcp_erp_port_strategy_open_common(act);
1234 -}
1235 -
1236 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
1237 {
1238 struct zfcp_port *port = erp_action->port;
1239
1240 + if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)
1241 + goto close_init_done;
1242 +
1243 switch (erp_action->step) {
1244 case ZFCP_ERP_STEP_UNINITIALIZED:
1245 zfcp_erp_port_strategy_clearstati(port);
1246 @@ -989,19 +918,17 @@ static int zfcp_erp_port_strategy(struct
1247 return ZFCP_ERP_FAILED;
1248 break;
1249 }
1250 +
1251 +close_init_done:
1252 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1253 return ZFCP_ERP_EXIT;
1254 - else
1255 - return zfcp_erp_port_strategy_open(erp_action);
1256
1257 - return ZFCP_ERP_FAILED;
1258 + return zfcp_erp_port_strategy_open_common(erp_action);
1259 }
1260
1261 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
1262 {
1263 - atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
1264 - ZFCP_STATUS_COMMON_CLOSING |
1265 - ZFCP_STATUS_COMMON_ACCESS_DENIED |
1266 + atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1267 ZFCP_STATUS_UNIT_SHARED |
1268 ZFCP_STATUS_UNIT_READONLY,
1269 &unit->status);
1270 @@ -1261,9 +1188,10 @@ static void zfcp_erp_scsi_scan(struct wo
1271 struct zfcp_unit *unit = p->unit;
1272 struct fc_rport *rport = unit->port->rport;
1273 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
1274 - unit->scsi_lun, 0);
1275 + scsilun_to_int((struct scsi_lun *)&unit->fcp_lun), 0);
1276 atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1277 zfcp_unit_put(unit);
1278 + wake_up(&unit->port->adapter->erp_done_wqh);
1279 kfree(p);
1280 }
1281
1282 @@ -1284,7 +1212,7 @@ static void zfcp_erp_schedule_work(struc
1283 atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1284 INIT_WORK(&p->work, zfcp_erp_scsi_scan);
1285 p->unit = unit;
1286 - schedule_work(&p->work);
1287 + queue_work(zfcp_data.work_queue, &p->work);
1288 }
1289
1290 static void zfcp_erp_rport_register(struct zfcp_port *port)
1291 @@ -1310,12 +1238,12 @@ static void zfcp_erp_rport_register(stru
1292 static void zfcp_erp_rports_del(struct zfcp_adapter *adapter)
1293 {
1294 struct zfcp_port *port;
1295 - list_for_each_entry(port, &adapter->port_list_head, list)
1296 - if (port->rport && !(atomic_read(&port->status) &
1297 - ZFCP_STATUS_PORT_WKA)) {
1298 - fc_remote_port_delete(port->rport);
1299 - port->rport = NULL;
1300 - }
1301 + list_for_each_entry(port, &adapter->port_list_head, list) {
1302 + if (!port->rport)
1303 + continue;
1304 + fc_remote_port_delete(port->rport);
1305 + port->rport = NULL;
1306 + }
1307 }
1308
1309 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1310 @@ -1470,9 +1398,9 @@ static int zfcp_erp_thread(void *data)
1311 zfcp_erp_wakeup(adapter);
1312 }
1313
1314 - zfcp_rec_dbf_event_thread(4, adapter);
1315 + zfcp_rec_dbf_event_thread_lock(4, adapter);
1316 down_interruptible(&adapter->erp_ready_sem);
1317 - zfcp_rec_dbf_event_thread(5, adapter);
1318 + zfcp_rec_dbf_event_thread_lock(5, adapter);
1319 }
1320
1321 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1322 @@ -1517,7 +1445,7 @@ void zfcp_erp_thread_kill(struct zfcp_ad
1323 {
1324 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1325 up(&adapter->erp_ready_sem);
1326 - zfcp_rec_dbf_event_thread_lock(2, adapter);
1327 + zfcp_rec_dbf_event_thread_lock(3, adapter);
1328
1329 wait_event(adapter->erp_thread_wqh,
1330 !(atomic_read(&adapter->status) &
1331 @@ -1751,9 +1679,8 @@ static void zfcp_erp_port_access_changed
1332
1333 if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1334 ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
1335 - if (!(status & ZFCP_STATUS_PORT_WKA))
1336 - list_for_each_entry(unit, &port->unit_list_head, list)
1337 - zfcp_erp_unit_access_changed(unit, id, ref);
1338 + list_for_each_entry(unit, &port->unit_list_head, list)
1339 + zfcp_erp_unit_access_changed(unit, id, ref);
1340 return;
1341 }
1342
1343 @@ -1776,10 +1703,7 @@ void zfcp_erp_adapter_access_changed(str
1344 return;
1345
1346 read_lock_irqsave(&zfcp_data.config_lock, flags);
1347 - if (adapter->nameserver_port)
1348 - zfcp_erp_port_access_changed(adapter->nameserver_port, id, ref);
1349 list_for_each_entry(port, &adapter->port_list_head, list)
1350 - if (port != adapter->nameserver_port)
1351 - zfcp_erp_port_access_changed(port, id, ref);
1352 + zfcp_erp_port_access_changed(port, id, ref);
1353 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1354 }
1355 --- a/drivers/s390/scsi/zfcp_ext.h
1356 +++ b/drivers/s390/scsi/zfcp_ext.h
1357 @@ -12,16 +12,14 @@
1358 #include "zfcp_def.h"
1359
1360 /* zfcp_aux.c */
1361 -extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *,
1362 - fcp_lun_t);
1363 -extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *,
1364 - wwn_t);
1365 +extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *, u64);
1366 +extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *, u64);
1367 extern int zfcp_adapter_enqueue(struct ccw_device *);
1368 extern void zfcp_adapter_dequeue(struct zfcp_adapter *);
1369 -extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, wwn_t, u32,
1370 +extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32,
1371 u32);
1372 extern void zfcp_port_dequeue(struct zfcp_port *);
1373 -extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, fcp_lun_t);
1374 +extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64);
1375 extern void zfcp_unit_dequeue(struct zfcp_unit *);
1376 extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
1377 extern void zfcp_sg_free_table(struct scatterlist *, int);
1378 @@ -29,6 +27,7 @@ extern int zfcp_sg_setup_table(struct sc
1379
1380 /* zfcp_ccw.c */
1381 extern int zfcp_ccw_register(void);
1382 +extern struct zfcp_adapter *zfcp_get_adapter_by_busid(char *);
1383
1384 /* zfcp_cfdc.c */
1385 extern struct miscdevice zfcp_cfdc_misc;
1386 @@ -50,6 +49,8 @@ extern void zfcp_hba_dbf_event_fsf_unsol
1387 struct fsf_status_read_buffer *);
1388 extern void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *, unsigned int, int,
1389 int);
1390 +extern void zfcp_hba_dbf_event_berr(struct zfcp_adapter *,
1391 + struct zfcp_fsf_req *);
1392 extern void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *);
1393 extern void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *);
1394 extern void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *);
1395 @@ -91,17 +92,21 @@ extern void zfcp_erp_port_access_denied(
1396 extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, u8, void *);
1397 extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, u8, void *);
1398 extern void zfcp_erp_timeout_handler(unsigned long);
1399 +extern void zfcp_erp_port_strategy_open_lookup(struct work_struct *);
1400
1401 /* zfcp_fc.c */
1402 extern int zfcp_scan_ports(struct zfcp_adapter *);
1403 extern void _zfcp_scan_ports_later(struct work_struct *);
1404 extern void zfcp_fc_incoming_els(struct zfcp_fsf_req *);
1405 -extern int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *);
1406 +extern int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *);
1407 extern void zfcp_fc_plogi_evaluate(struct zfcp_port *, struct fsf_plogi *);
1408 extern void zfcp_test_link(struct zfcp_port *);
1409 +extern void zfcp_fc_nameserver_init(struct zfcp_adapter *);
1410
1411 /* zfcp_fsf.c */
1412 extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
1413 +extern int zfcp_fsf_open_wka_port(struct zfcp_wka_port *);
1414 +extern int zfcp_fsf_close_wka_port(struct zfcp_wka_port *);
1415 extern int zfcp_fsf_close_port(struct zfcp_erp_action *);
1416 extern int zfcp_fsf_close_physical_port(struct zfcp_erp_action *);
1417 extern int zfcp_fsf_open_unit(struct zfcp_erp_action *);
1418 @@ -135,10 +140,8 @@ extern struct zfcp_fsf_req *zfcp_fsf_abo
1419 extern int zfcp_qdio_allocate(struct zfcp_adapter *);
1420 extern void zfcp_qdio_free(struct zfcp_adapter *);
1421 extern int zfcp_qdio_send(struct zfcp_fsf_req *);
1422 -extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_req(
1423 - struct zfcp_fsf_req *);
1424 -extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_curr(
1425 - struct zfcp_fsf_req *);
1426 +extern struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_fsf_req *);
1427 +extern struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_fsf_req *);
1428 extern int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *, unsigned long,
1429 struct scatterlist *, int);
1430 extern int zfcp_qdio_open(struct zfcp_adapter *);
1431 @@ -148,14 +151,12 @@ extern void zfcp_qdio_close(struct zfcp_
1432 extern struct zfcp_data zfcp_data;
1433 extern int zfcp_adapter_scsi_register(struct zfcp_adapter *);
1434 extern void zfcp_adapter_scsi_unregister(struct zfcp_adapter *);
1435 -extern void zfcp_set_fcp_dl(struct fcp_cmnd_iu *, fcp_dl_t);
1436 extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);
1437 extern struct fc_function_template zfcp_transport_functions;
1438
1439 /* zfcp_sysfs.c */
1440 extern struct attribute_group zfcp_sysfs_unit_attrs;
1441 extern struct attribute_group zfcp_sysfs_adapter_attrs;
1442 -extern struct attribute_group zfcp_sysfs_ns_port_attrs;
1443 extern struct attribute_group zfcp_sysfs_port_attrs;
1444 extern struct device_attribute *zfcp_sysfs_sdev_attrs[];
1445 extern struct device_attribute *zfcp_sysfs_shost_attrs[];
1446 --- a/drivers/s390/scsi/zfcp_fc.c
1447 +++ b/drivers/s390/scsi/zfcp_fc.c
1448 @@ -41,6 +41,84 @@ struct zfcp_gpn_ft {
1449 struct scatterlist sg_resp[ZFCP_GPN_FT_BUFFERS];
1450 };
1451
1452 +struct zfcp_fc_ns_handler_data {
1453 + struct completion done;
1454 + void (*handler)(unsigned long);
1455 + unsigned long handler_data;
1456 +};
1457 +
1458 +static int zfcp_wka_port_get(struct zfcp_wka_port *wka_port)
1459 +{
1460 + if (mutex_lock_interruptible(&wka_port->mutex))
1461 + return -ERESTARTSYS;
1462 +
1463 + if (wka_port->status != ZFCP_WKA_PORT_ONLINE) {
1464 + wka_port->status = ZFCP_WKA_PORT_OPENING;
1465 + if (zfcp_fsf_open_wka_port(wka_port))
1466 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1467 + }
1468 +
1469 + mutex_unlock(&wka_port->mutex);
1470 +
1471 + wait_event_timeout(
1472 + wka_port->completion_wq,
1473 + wka_port->status == ZFCP_WKA_PORT_ONLINE ||
1474 + wka_port->status == ZFCP_WKA_PORT_OFFLINE,
1475 + HZ >> 1);
1476 +
1477 + if (wka_port->status == ZFCP_WKA_PORT_ONLINE) {
1478 + atomic_inc(&wka_port->refcount);
1479 + return 0;
1480 + }
1481 + return -EIO;
1482 +}
1483 +
1484 +static void zfcp_wka_port_offline(struct work_struct *work)
1485 +{
1486 + struct delayed_work *dw = container_of(work, struct delayed_work, work);
1487 + struct zfcp_wka_port *wka_port =
1488 + container_of(dw, struct zfcp_wka_port, work);
1489 +
1490 + wait_event(wka_port->completion_wq,
1491 + atomic_read(&wka_port->refcount) == 0);
1492 +
1493 + mutex_lock(&wka_port->mutex);
1494 + if ((atomic_read(&wka_port->refcount) != 0) ||
1495 + (wka_port->status != ZFCP_WKA_PORT_ONLINE))
1496 + goto out;
1497 +
1498 + wka_port->status = ZFCP_WKA_PORT_CLOSING;
1499 + if (zfcp_fsf_close_wka_port(wka_port)) {
1500 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1501 + wake_up(&wka_port->completion_wq);
1502 + }
1503 +out:
1504 + mutex_unlock(&wka_port->mutex);
1505 +}
1506 +
1507 +static void zfcp_wka_port_put(struct zfcp_wka_port *wka_port)
1508 +{
1509 + if (atomic_dec_return(&wka_port->refcount) != 0)
1510 + return;
1511 + /* wait 10 miliseconds, other reqs might pop in */
1512 + schedule_delayed_work(&wka_port->work, HZ / 100);
1513 +}
1514 +
1515 +void zfcp_fc_nameserver_init(struct zfcp_adapter *adapter)
1516 +{
1517 + struct zfcp_wka_port *wka_port = &adapter->nsp;
1518 +
1519 + init_waitqueue_head(&wka_port->completion_wq);
1520 +
1521 + wka_port->adapter = adapter;
1522 + wka_port->d_id = ZFCP_DID_DIRECTORY_SERVICE;
1523 +
1524 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1525 + atomic_set(&wka_port->refcount, 0);
1526 + mutex_init(&wka_port->mutex);
1527 + INIT_DELAYED_WORK(&wka_port->work, zfcp_wka_port_offline);
1528 +}
1529 +
1530 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
1531 struct fcp_rscn_element *elem)
1532 {
1533 @@ -49,10 +127,8 @@ static void _zfcp_fc_incoming_rscn(struc
1534
1535 read_lock_irqsave(&zfcp_data.config_lock, flags);
1536 list_for_each_entry(port, &fsf_req->adapter->port_list_head, list) {
1537 - if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1538 - continue;
1539 /* FIXME: ZFCP_STATUS_PORT_DID_DID check is racy */
1540 - if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status))
1541 + if (!(atomic_read(&port->status) & ZFCP_STATUS_PORT_DID_DID))
1542 /* Try to connect to unused ports anyway. */
1543 zfcp_erp_port_reopen(port,
1544 ZFCP_STATUS_COMMON_ERP_FAILED,
1545 @@ -104,7 +180,7 @@ static void zfcp_fc_incoming_rscn(struct
1546 schedule_work(&fsf_req->adapter->scan_work);
1547 }
1548
1549 -static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, wwn_t wwpn)
1550 +static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
1551 {
1552 struct zfcp_adapter *adapter = req->adapter;
1553 struct zfcp_port *port;
1554 @@ -159,7 +235,18 @@ void zfcp_fc_incoming_els(struct zfcp_fs
1555 zfcp_fc_incoming_rscn(fsf_req);
1556 }
1557
1558 -static void zfcp_ns_gid_pn_handler(unsigned long data)
1559 +static void zfcp_fc_ns_handler(unsigned long data)
1560 +{
1561 + struct zfcp_fc_ns_handler_data *compl_rec =
1562 + (struct zfcp_fc_ns_handler_data *) data;
1563 +
1564 + if (compl_rec->handler)
1565 + compl_rec->handler(compl_rec->handler_data);
1566 +
1567 + complete(&compl_rec->done);
1568 +}
1569 +
1570 +static void zfcp_fc_ns_gid_pn_eval(unsigned long data)
1571 {
1572 struct zfcp_gid_pn_data *gid_pn = (struct zfcp_gid_pn_data *) data;
1573 struct zfcp_send_ct *ct = &gid_pn->ct;
1574 @@ -168,43 +255,31 @@ static void zfcp_ns_gid_pn_handler(unsig
1575 struct zfcp_port *port = gid_pn->port;
1576
1577 if (ct->status)
1578 - goto out;
1579 + return;
1580 if (ct_iu_resp->header.cmd_rsp_code != ZFCP_CT_ACCEPT) {
1581 atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN, &port->status);
1582 - goto out;
1583 + return;
1584 }
1585 /* paranoia */
1586 if (ct_iu_req->wwpn != port->wwpn)
1587 - goto out;
1588 + return;
1589 /* looks like a valid d_id */
1590 port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK;
1591 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
1592 -out:
1593 - mempool_free(gid_pn, port->adapter->pool.data_gid_pn);
1594 }
1595
1596 -/**
1597 - * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
1598 - * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
1599 - * return: -ENOMEM on error, 0 otherwise
1600 - */
1601 -int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *erp_action)
1602 +int static zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *erp_action,
1603 + struct zfcp_gid_pn_data *gid_pn)
1604 {
1605 - int ret;
1606 - struct zfcp_gid_pn_data *gid_pn;
1607 struct zfcp_adapter *adapter = erp_action->adapter;
1608 -
1609 - gid_pn = mempool_alloc(adapter->pool.data_gid_pn, GFP_ATOMIC);
1610 - if (!gid_pn)
1611 - return -ENOMEM;
1612 -
1613 - memset(gid_pn, 0, sizeof(*gid_pn));
1614 + struct zfcp_fc_ns_handler_data compl_rec;
1615 + int ret;
1616
1617 /* setup parameters for send generic command */
1618 gid_pn->port = erp_action->port;
1619 - gid_pn->ct.port = adapter->nameserver_port;
1620 - gid_pn->ct.handler = zfcp_ns_gid_pn_handler;
1621 - gid_pn->ct.handler_data = (unsigned long) gid_pn;
1622 + gid_pn->ct.wka_port = &adapter->nsp;
1623 + gid_pn->ct.handler = zfcp_fc_ns_handler;
1624 + gid_pn->ct.handler_data = (unsigned long) &compl_rec;
1625 gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;
1626 gid_pn->ct.req = &gid_pn->req;
1627 gid_pn->ct.resp = &gid_pn->resp;
1628 @@ -224,10 +299,42 @@ int zfcp_fc_ns_gid_pn_request(struct zfc
1629 gid_pn->ct_iu_req.header.max_res_size = ZFCP_CT_MAX_SIZE;
1630 gid_pn->ct_iu_req.wwpn = erp_action->port->wwpn;
1631
1632 + init_completion(&compl_rec.done);
1633 + compl_rec.handler = zfcp_fc_ns_gid_pn_eval;
1634 + compl_rec.handler_data = (unsigned long) gid_pn;
1635 ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp,
1636 erp_action);
1637 + if (!ret)
1638 + wait_for_completion(&compl_rec.done);
1639 + return ret;
1640 +}
1641 +
1642 +/**
1643 + * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
1644 + * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
1645 + * return: -ENOMEM on error, 0 otherwise
1646 + */
1647 +int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *erp_action)
1648 +{
1649 + int ret;
1650 + struct zfcp_gid_pn_data *gid_pn;
1651 + struct zfcp_adapter *adapter = erp_action->adapter;
1652 +
1653 + gid_pn = mempool_alloc(adapter->pool.data_gid_pn, GFP_ATOMIC);
1654 + if (!gid_pn)
1655 + return -ENOMEM;
1656 +
1657 + memset(gid_pn, 0, sizeof(*gid_pn));
1658 +
1659 + ret = zfcp_wka_port_get(&adapter->nsp);
1660 if (ret)
1661 - mempool_free(gid_pn, adapter->pool.data_gid_pn);
1662 + goto out;
1663 +
1664 + ret = zfcp_fc_ns_gid_pn_request(erp_action, gid_pn);
1665 +
1666 + zfcp_wka_port_put(&adapter->nsp);
1667 +out:
1668 + mempool_free(gid_pn, adapter->pool.data_gid_pn);
1669 return ret;
1670 }
1671
1672 @@ -257,14 +364,14 @@ struct zfcp_els_adisc {
1673 struct scatterlist req;
1674 struct scatterlist resp;
1675 struct zfcp_ls_adisc ls_adisc;
1676 - struct zfcp_ls_adisc_acc ls_adisc_acc;
1677 + struct zfcp_ls_adisc ls_adisc_acc;
1678 };
1679
1680 static void zfcp_fc_adisc_handler(unsigned long data)
1681 {
1682 struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data;
1683 struct zfcp_port *port = adisc->els.port;
1684 - struct zfcp_ls_adisc_acc *ls_adisc = &adisc->ls_adisc_acc;
1685 + struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc;
1686
1687 if (adisc->els.status) {
1688 /* request rejected or timed out */
1689 @@ -297,7 +404,7 @@ static int zfcp_fc_adisc(struct zfcp_por
1690 sg_init_one(adisc->els.req, &adisc->ls_adisc,
1691 sizeof(struct zfcp_ls_adisc));
1692 sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc,
1693 - sizeof(struct zfcp_ls_adisc_acc));
1694 + sizeof(struct zfcp_ls_adisc));
1695
1696 adisc->els.req_count = 1;
1697 adisc->els.resp_count = 1;
1698 @@ -340,30 +447,6 @@ void zfcp_test_link(struct zfcp_port *po
1699 zfcp_erp_port_forced_reopen(port, 0, 65, NULL);
1700 }
1701
1702 -static int zfcp_scan_get_nameserver(struct zfcp_adapter *adapter)
1703 -{
1704 - int ret;
1705 -
1706 - if (!adapter->nameserver_port)
1707 - return -EINTR;
1708 -
1709 - if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
1710 - &adapter->nameserver_port->status)) {
1711 - ret = zfcp_erp_port_reopen(adapter->nameserver_port, 0, 148,
1712 - NULL);
1713 - if (ret)
1714 - return ret;
1715 - zfcp_erp_wait(adapter);
1716 - }
1717 - return !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
1718 - &adapter->nameserver_port->status);
1719 -}
1720 -
1721 -static void zfcp_gpn_ft_handler(unsigned long _done)
1722 -{
1723 - complete((struct completion *)_done);
1724 -}
1725 -
1726 static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft)
1727 {
1728 struct scatterlist *sg = &gpn_ft->sg_req;
1729 @@ -405,7 +488,7 @@ static int zfcp_scan_issue_gpn_ft(struct
1730 {
1731 struct zfcp_send_ct *ct = &gpn_ft->ct;
1732 struct ct_iu_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
1733 - struct completion done;
1734 + struct zfcp_fc_ns_handler_data compl_rec;
1735 int ret;
1736
1737 /* prepare CT IU for GPN_FT */
1738 @@ -422,19 +505,20 @@ static int zfcp_scan_issue_gpn_ft(struct
1739 req->fc4_type = ZFCP_CT_SCSI_FCP;
1740
1741 /* prepare zfcp_send_ct */
1742 - ct->port = adapter->nameserver_port;
1743 - ct->handler = zfcp_gpn_ft_handler;
1744 - ct->handler_data = (unsigned long)&done;
1745 + ct->wka_port = &adapter->nsp;
1746 + ct->handler = zfcp_fc_ns_handler;
1747 + ct->handler_data = (unsigned long)&compl_rec;
1748 ct->timeout = 10;
1749 ct->req = &gpn_ft->sg_req;
1750 ct->resp = gpn_ft->sg_resp;
1751 ct->req_count = 1;
1752 ct->resp_count = ZFCP_GPN_FT_BUFFERS;
1753
1754 - init_completion(&done);
1755 + init_completion(&compl_rec.done);
1756 + compl_rec.handler = NULL;
1757 ret = zfcp_fsf_send_ct(ct, NULL, NULL);
1758 if (!ret)
1759 - wait_for_completion(&done);
1760 + wait_for_completion(&compl_rec.done);
1761 return ret;
1762 }
1763
1764 @@ -444,9 +528,8 @@ static void zfcp_validate_port(struct zf
1765
1766 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status);
1767
1768 - if (port == adapter->nameserver_port)
1769 - return;
1770 - if ((port->supported_classes != 0) || (port->units != 0)) {
1771 + if ((port->supported_classes != 0) ||
1772 + !list_empty(&port->unit_list_head)) {
1773 zfcp_port_put(port);
1774 return;
1775 }
1776 @@ -462,7 +545,7 @@ static int zfcp_scan_eval_gpn_ft(struct
1777 struct scatterlist *sg = gpn_ft->sg_resp;
1778 struct ct_hdr *hdr = sg_virt(sg);
1779 struct gpn_ft_resp_acc *acc = sg_virt(sg);
1780 - struct zfcp_adapter *adapter = ct->port->adapter;
1781 + struct zfcp_adapter *adapter = ct->wka_port->adapter;
1782 struct zfcp_port *port, *tmp;
1783 u32 d_id;
1784 int ret = 0, x, last = 0;
1785 @@ -492,6 +575,9 @@ static int zfcp_scan_eval_gpn_ft(struct
1786 d_id = acc->port_id[0] << 16 | acc->port_id[1] << 8 |
1787 acc->port_id[2];
1788
1789 + /* don't attach ports with a well known address */
1790 + if ((d_id & ZFCP_DID_WKA) == ZFCP_DID_WKA)
1791 + continue;
1792 /* skip the adapter's port and known remote ports */
1793 if (acc->wwpn == fc_host_port_name(adapter->scsi_host))
1794 continue;
1795 @@ -530,13 +616,15 @@ int zfcp_scan_ports(struct zfcp_adapter
1796 if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT)
1797 return 0;
1798
1799 - ret = zfcp_scan_get_nameserver(adapter);
1800 + ret = zfcp_wka_port_get(&adapter->nsp);
1801 if (ret)
1802 return ret;
1803
1804 gpn_ft = zfcp_alloc_sg_env();
1805 - if (!gpn_ft)
1806 - return -ENOMEM;
1807 + if (!gpn_ft) {
1808 + ret = -ENOMEM;
1809 + goto out;
1810 + }
1811
1812 for (i = 0; i < 3; i++) {
1813 ret = zfcp_scan_issue_gpn_ft(gpn_ft, adapter);
1814 @@ -549,7 +637,8 @@ int zfcp_scan_ports(struct zfcp_adapter
1815 }
1816 }
1817 zfcp_free_sg_env(gpn_ft);
1818 -
1819 +out:
1820 + zfcp_wka_port_put(&adapter->nsp);
1821 return ret;
1822 }
1823
1824 --- a/drivers/s390/scsi/zfcp_fsf.c
1825 +++ b/drivers/s390/scsi/zfcp_fsf.c
1826 @@ -71,7 +71,7 @@ static void zfcp_fsf_access_denied_port(
1827 struct fsf_qtcb_header *header = &req->qtcb->header;
1828 dev_warn(&req->adapter->ccw_device->dev,
1829 "Access denied to port 0x%016Lx\n",
1830 - port->wwpn);
1831 + (unsigned long long)port->wwpn);
1832 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
1833 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
1834 zfcp_erp_port_access_denied(port, 55, req);
1835 @@ -84,7 +84,8 @@ static void zfcp_fsf_access_denied_unit(
1836 struct fsf_qtcb_header *header = &req->qtcb->header;
1837 dev_warn(&req->adapter->ccw_device->dev,
1838 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
1839 - unit->fcp_lun, unit->port->wwpn);
1840 + (unsigned long long)unit->fcp_lun,
1841 + (unsigned long long)unit->port->wwpn);
1842 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
1843 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
1844 zfcp_erp_unit_access_denied(unit, 59, req);
1845 @@ -296,6 +297,7 @@ static void zfcp_fsf_status_read_handler
1846 dev_warn(&adapter->ccw_device->dev,
1847 "The error threshold for checksum statistics "
1848 "has been exceeded\n");
1849 + zfcp_hba_dbf_event_berr(adapter, req);
1850 break;
1851 case FSF_STATUS_READ_LINK_DOWN:
1852 zfcp_fsf_status_read_link_down(req);
1853 @@ -330,7 +332,7 @@ static void zfcp_fsf_status_read_handler
1854 zfcp_fsf_req_free(req);
1855
1856 atomic_inc(&adapter->stat_miss);
1857 - schedule_work(&adapter->stat_work);
1858 + queue_work(zfcp_data.work_queue, &adapter->stat_work);
1859 }
1860
1861 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
1862 @@ -624,7 +626,6 @@ static void zfcp_fsf_exchange_port_evalu
1863
1864 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
1865 {
1866 - struct zfcp_adapter *adapter = req->adapter;
1867 struct fsf_qtcb *qtcb = req->qtcb;
1868
1869 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1870 @@ -633,23 +634,23 @@ static void zfcp_fsf_exchange_port_data_
1871 switch (qtcb->header.fsf_status) {
1872 case FSF_GOOD:
1873 zfcp_fsf_exchange_port_evaluate(req);
1874 - atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
1875 break;
1876 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
1877 zfcp_fsf_exchange_port_evaluate(req);
1878 - atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
1879 zfcp_fsf_link_down_info_eval(req, 43,
1880 &qtcb->header.fsf_status_qual.link_down_info);
1881 break;
1882 }
1883 }
1884
1885 -static int zfcp_fsf_sbal_check(struct zfcp_qdio_queue *queue)
1886 +static int zfcp_fsf_sbal_check(struct zfcp_adapter *adapter)
1887 {
1888 - spin_lock_bh(&queue->lock);
1889 - if (atomic_read(&queue->count))
1890 + struct zfcp_qdio_queue *req_q = &adapter->req_q;
1891 +
1892 + spin_lock_bh(&adapter->req_q_lock);
1893 + if (atomic_read(&req_q->count))
1894 return 1;
1895 - spin_unlock_bh(&queue->lock);
1896 + spin_unlock_bh(&adapter->req_q_lock);
1897 return 0;
1898 }
1899
1900 @@ -664,17 +665,16 @@ static int zfcp_fsf_sbal_available(struc
1901 static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
1902 {
1903 long ret;
1904 - struct zfcp_qdio_queue *req_q = &adapter->req_q;
1905
1906 - spin_unlock_bh(&req_q->lock);
1907 + spin_unlock_bh(&adapter->req_q_lock);
1908 ret = wait_event_interruptible_timeout(adapter->request_wq,
1909 - zfcp_fsf_sbal_check(req_q), 5 * HZ);
1910 + zfcp_fsf_sbal_check(adapter), 5 * HZ);
1911 if (ret > 0)
1912 return 0;
1913 if (!ret)
1914 atomic_inc(&adapter->qdio_outb_full);
1915
1916 - spin_lock_bh(&req_q->lock);
1917 + spin_lock_bh(&adapter->req_q_lock);
1918 return -EIO;
1919 }
1920
1921 @@ -711,7 +711,7 @@ static struct zfcp_fsf_req *zfcp_fsf_req
1922 u32 fsf_cmd, int req_flags,
1923 mempool_t *pool)
1924 {
1925 - volatile struct qdio_buffer_element *sbale;
1926 + struct qdio_buffer_element *sbale;
1927
1928 struct zfcp_fsf_req *req;
1929 struct zfcp_qdio_queue *req_q = &adapter->req_q;
1930 @@ -814,10 +814,10 @@ int zfcp_fsf_status_read(struct zfcp_ada
1931 {
1932 struct zfcp_fsf_req *req;
1933 struct fsf_status_read_buffer *sr_buf;
1934 - volatile struct qdio_buffer_element *sbale;
1935 + struct qdio_buffer_element *sbale;
1936 int retval = -EIO;
1937
1938 - spin_lock_bh(&adapter->req_q.lock);
1939 + spin_lock_bh(&adapter->req_q_lock);
1940 if (zfcp_fsf_req_sbal_get(adapter))
1941 goto out;
1942
1943 @@ -857,7 +857,7 @@ failed_buf:
1944 zfcp_fsf_req_free(req);
1945 zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
1946 out:
1947 - spin_unlock_bh(&adapter->req_q.lock);
1948 + spin_unlock_bh(&adapter->req_q_lock);
1949 return retval;
1950 }
1951
1952 @@ -927,10 +927,10 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_
1953 struct zfcp_unit *unit,
1954 int req_flags)
1955 {
1956 - volatile struct qdio_buffer_element *sbale;
1957 + struct qdio_buffer_element *sbale;
1958 struct zfcp_fsf_req *req = NULL;
1959
1960 - spin_lock(&adapter->req_q.lock);
1961 + spin_lock(&adapter->req_q_lock);
1962 if (!zfcp_fsf_sbal_available(adapter))
1963 goto out;
1964 req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
1965 @@ -960,7 +960,7 @@ out_error_free:
1966 zfcp_fsf_req_free(req);
1967 req = NULL;
1968 out:
1969 - spin_unlock(&adapter->req_q.lock);
1970 + spin_unlock(&adapter->req_q_lock);
1971 return req;
1972 }
1973
1974 @@ -968,7 +968,6 @@ static void zfcp_fsf_send_ct_handler(str
1975 {
1976 struct zfcp_adapter *adapter = req->adapter;
1977 struct zfcp_send_ct *send_ct = req->data;
1978 - struct zfcp_port *port = send_ct->port;
1979 struct fsf_qtcb_header *header = &req->qtcb->header;
1980
1981 send_ct->status = -EINVAL;
1982 @@ -987,17 +986,14 @@ static void zfcp_fsf_send_ct_handler(str
1983 case FSF_ADAPTER_STATUS_AVAILABLE:
1984 switch (header->fsf_status_qual.word[0]){
1985 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1986 - zfcp_test_link(port);
1987 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1988 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1989 break;
1990 }
1991 break;
1992 case FSF_ACCESS_DENIED:
1993 - zfcp_fsf_access_denied_port(req, port);
1994 break;
1995 case FSF_PORT_BOXED:
1996 - zfcp_erp_port_boxed(port, 49, req);
1997 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1998 ZFCP_STATUS_FSFREQ_RETRY;
1999 break;
2000 @@ -1048,12 +1044,12 @@ static int zfcp_fsf_setup_sbals(struct z
2001 int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
2002 struct zfcp_erp_action *erp_action)
2003 {
2004 - struct zfcp_port *port = ct->port;
2005 - struct zfcp_adapter *adapter = port->adapter;
2006 + struct zfcp_wka_port *wka_port = ct->wka_port;
2007 + struct zfcp_adapter *adapter = wka_port->adapter;
2008 struct zfcp_fsf_req *req;
2009 int ret = -EIO;
2010
2011 - spin_lock_bh(&adapter->req_q.lock);
2012 + spin_lock_bh(&adapter->req_q_lock);
2013 if (zfcp_fsf_req_sbal_get(adapter))
2014 goto out;
2015
2016 @@ -1070,7 +1066,7 @@ int zfcp_fsf_send_ct(struct zfcp_send_ct
2017 goto failed_send;
2018
2019 req->handler = zfcp_fsf_send_ct_handler;
2020 - req->qtcb->header.port_handle = port->handle;
2021 + req->qtcb->header.port_handle = wka_port->handle;
2022 req->qtcb->bottom.support.service_class = FSF_CLASS_3;
2023 req->qtcb->bottom.support.timeout = ct->timeout;
2024 req->data = ct;
2025 @@ -1095,7 +1091,7 @@ failed_send:
2026 if (erp_action)
2027 erp_action->fsf_req = NULL;
2028 out:
2029 - spin_unlock_bh(&adapter->req_q.lock);
2030 + spin_unlock_bh(&adapter->req_q_lock);
2031 return ret;
2032 }
2033
2034 @@ -1165,7 +1161,7 @@ int zfcp_fsf_send_els(struct zfcp_send_e
2035 ZFCP_STATUS_COMMON_UNBLOCKED)))
2036 return -EBUSY;
2037
2038 - spin_lock(&adapter->req_q.lock);
2039 + spin_lock(&adapter->req_q_lock);
2040 if (!zfcp_fsf_sbal_available(adapter))
2041 goto out;
2042 req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
2043 @@ -1175,8 +1171,8 @@ int zfcp_fsf_send_els(struct zfcp_send_e
2044 goto out;
2045 }
2046
2047 - ret = zfcp_fsf_setup_sbals(req, els->req, els->resp,
2048 - FSF_MAX_SBALS_PER_ELS_REQ);
2049 + ret = zfcp_fsf_setup_sbals(req, els->req, els->resp, 2);
2050 +
2051 if (ret)
2052 goto failed_send;
2053
2054 @@ -1199,18 +1195,18 @@ int zfcp_fsf_send_els(struct zfcp_send_e
2055 failed_send:
2056 zfcp_fsf_req_free(req);
2057 out:
2058 - spin_unlock(&adapter->req_q.lock);
2059 + spin_unlock(&adapter->req_q_lock);
2060 return ret;
2061 }
2062
2063 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
2064 {
2065 - volatile struct qdio_buffer_element *sbale;
2066 + struct qdio_buffer_element *sbale;
2067 struct zfcp_fsf_req *req;
2068 struct zfcp_adapter *adapter = erp_action->adapter;
2069 int retval = -EIO;
2070
2071 - spin_lock_bh(&adapter->req_q.lock);
2072 + spin_lock_bh(&adapter->req_q_lock);
2073 if (!zfcp_fsf_sbal_available(adapter))
2074 goto out;
2075 req = zfcp_fsf_req_create(adapter,
2076 @@ -1242,18 +1238,18 @@ int zfcp_fsf_exchange_config_data(struct
2077 erp_action->fsf_req = NULL;
2078 }
2079 out:
2080 - spin_unlock_bh(&adapter->req_q.lock);
2081 + spin_unlock_bh(&adapter->req_q_lock);
2082 return retval;
2083 }
2084
2085 int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
2086 struct fsf_qtcb_bottom_config *data)
2087 {
2088 - volatile struct qdio_buffer_element *sbale;
2089 + struct qdio_buffer_element *sbale;
2090 struct zfcp_fsf_req *req = NULL;
2091 int retval = -EIO;
2092
2093 - spin_lock_bh(&adapter->req_q.lock);
2094 + spin_lock_bh(&adapter->req_q_lock);
2095 if (zfcp_fsf_req_sbal_get(adapter))
2096 goto out;
2097
2098 @@ -1281,7 +1277,7 @@ int zfcp_fsf_exchange_config_data_sync(s
2099 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2100 retval = zfcp_fsf_req_send(req);
2101 out:
2102 - spin_unlock_bh(&adapter->req_q.lock);
2103 + spin_unlock_bh(&adapter->req_q_lock);
2104 if (!retval)
2105 wait_event(req->completion_wq,
2106 req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
2107 @@ -1298,7 +1294,7 @@ out:
2108 */
2109 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
2110 {
2111 - volatile struct qdio_buffer_element *sbale;
2112 + struct qdio_buffer_element *sbale;
2113 struct zfcp_fsf_req *req;
2114 struct zfcp_adapter *adapter = erp_action->adapter;
2115 int retval = -EIO;
2116 @@ -1306,7 +1302,7 @@ int zfcp_fsf_exchange_port_data(struct z
2117 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
2118 return -EOPNOTSUPP;
2119
2120 - spin_lock_bh(&adapter->req_q.lock);
2121 + spin_lock_bh(&adapter->req_q_lock);
2122 if (!zfcp_fsf_sbal_available(adapter))
2123 goto out;
2124 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
2125 @@ -1332,7 +1328,7 @@ int zfcp_fsf_exchange_port_data(struct z
2126 erp_action->fsf_req = NULL;
2127 }
2128 out:
2129 - spin_unlock_bh(&adapter->req_q.lock);
2130 + spin_unlock_bh(&adapter->req_q_lock);
2131 return retval;
2132 }
2133
2134 @@ -1345,14 +1341,14 @@ out:
2135 int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
2136 struct fsf_qtcb_bottom_port *data)
2137 {
2138 - volatile struct qdio_buffer_element *sbale;
2139 + struct qdio_buffer_element *sbale;
2140 struct zfcp_fsf_req *req = NULL;
2141 int retval = -EIO;
2142
2143 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
2144 return -EOPNOTSUPP;
2145
2146 - spin_lock_bh(&adapter->req_q.lock);
2147 + spin_lock_bh(&adapter->req_q_lock);
2148 if (!zfcp_fsf_sbal_available(adapter))
2149 goto out;
2150
2151 @@ -1374,7 +1370,7 @@ int zfcp_fsf_exchange_port_data_sync(str
2152 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2153 retval = zfcp_fsf_req_send(req);
2154 out:
2155 - spin_unlock_bh(&adapter->req_q.lock);
2156 + spin_unlock_bh(&adapter->req_q_lock);
2157 if (!retval)
2158 wait_event(req->completion_wq,
2159 req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
2160 @@ -1390,7 +1386,7 @@ static void zfcp_fsf_open_port_handler(s
2161 struct fsf_plogi *plogi;
2162
2163 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2164 - goto skip_fsfstatus;
2165 + return;
2166
2167 switch (header->fsf_status) {
2168 case FSF_PORT_ALREADY_OPEN:
2169 @@ -1402,7 +1398,7 @@ static void zfcp_fsf_open_port_handler(s
2170 dev_warn(&req->adapter->ccw_device->dev,
2171 "Not enough FCP adapter resources to open "
2172 "remote port 0x%016Lx\n",
2173 - port->wwpn);
2174 + (unsigned long long)port->wwpn);
2175 zfcp_erp_port_failed(port, 31, req);
2176 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2177 break;
2178 @@ -1415,7 +1411,7 @@ static void zfcp_fsf_open_port_handler(s
2179 case FSF_SQ_NO_RETRY_POSSIBLE:
2180 dev_warn(&req->adapter->ccw_device->dev,
2181 "Remote port 0x%016Lx could not be opened\n",
2182 - port->wwpn);
2183 + (unsigned long long)port->wwpn);
2184 zfcp_erp_port_failed(port, 32, req);
2185 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2186 break;
2187 @@ -1443,9 +1439,6 @@ static void zfcp_fsf_open_port_handler(s
2188 * another GID_PN straight after a port has been opened.
2189 * Alternately, an ADISC/PDISC ELS should suffice, as well.
2190 */
2191 - if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN)
2192 - break;
2193 -
2194 plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
2195 if (req->qtcb->bottom.support.els1_length >= sizeof(*plogi)) {
2196 if (plogi->serv_param.wwpn != port->wwpn)
2197 @@ -1461,9 +1454,6 @@ static void zfcp_fsf_open_port_handler(s
2198 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2199 break;
2200 }
2201 -
2202 -skip_fsfstatus:
2203 - atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status);
2204 }
2205
2206 /**
2207 @@ -1473,12 +1463,12 @@ skip_fsfstatus:
2208 */
2209 int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
2210 {
2211 - volatile struct qdio_buffer_element *sbale;
2212 + struct qdio_buffer_element *sbale;
2213 struct zfcp_adapter *adapter = erp_action->adapter;
2214 struct zfcp_fsf_req *req;
2215 int retval = -EIO;
2216
2217 - spin_lock_bh(&adapter->req_q.lock);
2218 + spin_lock_bh(&adapter->req_q_lock);
2219 if (zfcp_fsf_req_sbal_get(adapter))
2220 goto out;
2221
2222 @@ -1500,7 +1490,6 @@ int zfcp_fsf_open_port(struct zfcp_erp_a
2223 req->data = erp_action->port;
2224 req->erp_action = erp_action;
2225 erp_action->fsf_req = req;
2226 - atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status);
2227
2228 zfcp_fsf_start_erp_timer(req);
2229 retval = zfcp_fsf_req_send(req);
2230 @@ -1509,7 +1498,7 @@ int zfcp_fsf_open_port(struct zfcp_erp_a
2231 erp_action->fsf_req = NULL;
2232 }
2233 out:
2234 - spin_unlock_bh(&adapter->req_q.lock);
2235 + spin_unlock_bh(&adapter->req_q_lock);
2236 return retval;
2237 }
2238
2239 @@ -1518,7 +1507,7 @@ static void zfcp_fsf_close_port_handler(
2240 struct zfcp_port *port = req->data;
2241
2242 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2243 - goto skip_fsfstatus;
2244 + return;
2245
2246 switch (req->qtcb->header.fsf_status) {
2247 case FSF_PORT_HANDLE_NOT_VALID:
2248 @@ -1533,9 +1522,6 @@ static void zfcp_fsf_close_port_handler(
2249 ZFCP_CLEAR);
2250 break;
2251 }
2252 -
2253 -skip_fsfstatus:
2254 - atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status);
2255 }
2256
2257 /**
2258 @@ -1545,12 +1531,12 @@ skip_fsfstatus:
2259 */
2260 int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
2261 {
2262 - volatile struct qdio_buffer_element *sbale;
2263 + struct qdio_buffer_element *sbale;
2264 struct zfcp_adapter *adapter = erp_action->adapter;
2265 struct zfcp_fsf_req *req;
2266 int retval = -EIO;
2267
2268 - spin_lock_bh(&adapter->req_q.lock);
2269 + spin_lock_bh(&adapter->req_q_lock);
2270 if (zfcp_fsf_req_sbal_get(adapter))
2271 goto out;
2272
2273 @@ -1571,7 +1557,6 @@ int zfcp_fsf_close_port(struct zfcp_erp_
2274 req->erp_action = erp_action;
2275 req->qtcb->header.port_handle = erp_action->port->handle;
2276 erp_action->fsf_req = req;
2277 - atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status);
2278
2279 zfcp_fsf_start_erp_timer(req);
2280 retval = zfcp_fsf_req_send(req);
2281 @@ -1580,7 +1565,131 @@ int zfcp_fsf_close_port(struct zfcp_erp_
2282 erp_action->fsf_req = NULL;
2283 }
2284 out:
2285 - spin_unlock_bh(&adapter->req_q.lock);
2286 + spin_unlock_bh(&adapter->req_q_lock);
2287 + return retval;
2288 +}
2289 +
2290 +static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
2291 +{
2292 + struct zfcp_wka_port *wka_port = req->data;
2293 + struct fsf_qtcb_header *header = &req->qtcb->header;
2294 +
2295 + if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
2296 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
2297 + goto out;
2298 + }
2299 +
2300 + switch (header->fsf_status) {
2301 + case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
2302 + dev_warn(&req->adapter->ccw_device->dev,
2303 + "Opening WKA port 0x%x failed\n", wka_port->d_id);
2304 + case FSF_ADAPTER_STATUS_AVAILABLE:
2305 + req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2306 + case FSF_ACCESS_DENIED:
2307 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
2308 + break;
2309 + case FSF_PORT_ALREADY_OPEN:
2310 + case FSF_GOOD:
2311 + wka_port->handle = header->port_handle;
2312 + wka_port->status = ZFCP_WKA_PORT_ONLINE;
2313 + }
2314 +out:
2315 + wake_up(&wka_port->completion_wq);
2316 +}
2317 +
2318 +/**
2319 + * zfcp_fsf_open_wka_port - create and send open wka-port request
2320 + * @wka_port: pointer to struct zfcp_wka_port
2321 + * Returns: 0 on success, error otherwise
2322 + */
2323 +int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
2324 +{
2325 + struct qdio_buffer_element *sbale;
2326 + struct zfcp_adapter *adapter = wka_port->adapter;
2327 + struct zfcp_fsf_req *req;
2328 + int retval = -EIO;
2329 +
2330 + spin_lock_bh(&adapter->req_q_lock);
2331 + if (zfcp_fsf_req_sbal_get(adapter))
2332 + goto out;
2333 +
2334 + req = zfcp_fsf_req_create(adapter,
2335 + FSF_QTCB_OPEN_PORT_WITH_DID,
2336 + ZFCP_REQ_AUTO_CLEANUP,
2337 + adapter->pool.fsf_req_erp);
2338 + if (unlikely(IS_ERR(req))) {
2339 + retval = PTR_ERR(req);
2340 + goto out;
2341 + }
2342 +
2343 + sbale = zfcp_qdio_sbale_req(req);
2344 + sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
2345 + sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2346 +
2347 + req->handler = zfcp_fsf_open_wka_port_handler;
2348 + req->qtcb->bottom.support.d_id = wka_port->d_id;
2349 + req->data = wka_port;
2350 +
2351 + zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2352 + retval = zfcp_fsf_req_send(req);
2353 + if (retval)
2354 + zfcp_fsf_req_free(req);
2355 +out:
2356 + spin_unlock_bh(&adapter->req_q_lock);
2357 + return retval;
2358 +}
2359 +
2360 +static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
2361 +{
2362 + struct zfcp_wka_port *wka_port = req->data;
2363 +
2364 + if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
2365 + req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2366 + zfcp_erp_adapter_reopen(wka_port->adapter, 0, 84, req);
2367 + }
2368 +
2369 + wka_port->status = ZFCP_WKA_PORT_OFFLINE;
2370 + wake_up(&wka_port->completion_wq);
2371 +}
2372 +
2373 +/**
2374 + * zfcp_fsf_close_wka_port - create and send close wka port request
2375 + * @erp_action: pointer to struct zfcp_erp_action
2376 + * Returns: 0 on success, error otherwise
2377 + */
2378 +int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
2379 +{
2380 + struct qdio_buffer_element *sbale;
2381 + struct zfcp_adapter *adapter = wka_port->adapter;
2382 + struct zfcp_fsf_req *req;
2383 + int retval = -EIO;
2384 +
2385 + spin_lock_bh(&adapter->req_q_lock);
2386 + if (zfcp_fsf_req_sbal_get(adapter))
2387 + goto out;
2388 +
2389 + req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
2390 + ZFCP_REQ_AUTO_CLEANUP,
2391 + adapter->pool.fsf_req_erp);
2392 + if (unlikely(IS_ERR(req))) {
2393 + retval = PTR_ERR(req);
2394 + goto out;
2395 + }
2396 +
2397 + sbale = zfcp_qdio_sbale_req(req);
2398 + sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
2399 + sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2400 +
2401 + req->handler = zfcp_fsf_close_wka_port_handler;
2402 + req->data = wka_port;
2403 + req->qtcb->header.port_handle = wka_port->handle;
2404 +
2405 + zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2406 + retval = zfcp_fsf_req_send(req);
2407 + if (retval)
2408 + zfcp_fsf_req_free(req);
2409 +out:
2410 + spin_unlock_bh(&adapter->req_q_lock);
2411 return retval;
2412 }
2413
2414 @@ -1642,12 +1751,12 @@ skip_fsfstatus:
2415 */
2416 int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
2417 {
2418 - volatile struct qdio_buffer_element *sbale;
2419 + struct qdio_buffer_element *sbale;
2420 struct zfcp_adapter *adapter = erp_action->adapter;
2421 struct zfcp_fsf_req *req;
2422 int retval = -EIO;
2423
2424 - spin_lock_bh(&adapter->req_q.lock);
2425 + spin_lock_bh(&adapter->req_q_lock);
2426 if (zfcp_fsf_req_sbal_get(adapter))
2427 goto out;
2428
2429 @@ -1678,7 +1787,7 @@ int zfcp_fsf_close_physical_port(struct
2430 erp_action->fsf_req = NULL;
2431 }
2432 out:
2433 - spin_unlock_bh(&adapter->req_q.lock);
2434 + spin_unlock_bh(&adapter->req_q_lock);
2435 return retval;
2436 }
2437
2438 @@ -1693,7 +1802,7 @@ static void zfcp_fsf_open_unit_handler(s
2439 int exclusive, readwrite;
2440
2441 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2442 - goto skip_fsfstatus;
2443 + return;
2444
2445 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
2446 ZFCP_STATUS_COMMON_ACCESS_BOXED |
2447 @@ -1723,8 +1832,8 @@ static void zfcp_fsf_open_unit_handler(s
2448 dev_warn(&adapter->ccw_device->dev,
2449 "LUN 0x%Lx on port 0x%Lx is already in "
2450 "use by CSS%d, MIF Image ID %x\n",
2451 - unit->fcp_lun,
2452 - unit->port->wwpn,
2453 + (unsigned long long)unit->fcp_lun,
2454 + (unsigned long long)unit->port->wwpn,
2455 queue_designator->cssid,
2456 queue_designator->hla);
2457 else
2458 @@ -1739,7 +1848,8 @@ static void zfcp_fsf_open_unit_handler(s
2459 dev_warn(&adapter->ccw_device->dev,
2460 "No handle is available for LUN "
2461 "0x%016Lx on port 0x%016Lx\n",
2462 - unit->fcp_lun, unit->port->wwpn);
2463 + (unsigned long long)unit->fcp_lun,
2464 + (unsigned long long)unit->port->wwpn);
2465 zfcp_erp_unit_failed(unit, 34, req);
2466 /* fall through */
2467 case FSF_INVALID_COMMAND_OPTION:
2468 @@ -1778,7 +1888,8 @@ static void zfcp_fsf_open_unit_handler(s
2469 dev_info(&adapter->ccw_device->dev,
2470 "SCSI device at LUN 0x%016Lx on port "
2471 "0x%016Lx opened read-only\n",
2472 - unit->fcp_lun, unit->port->wwpn);
2473 + (unsigned long long)unit->fcp_lun,
2474 + (unsigned long long)unit->port->wwpn);
2475 }
2476
2477 if (exclusive && !readwrite) {
2478 @@ -1786,7 +1897,8 @@ static void zfcp_fsf_open_unit_handler(s
2479 "Exclusive read-only access not "
2480 "supported (unit 0x%016Lx, "
2481 "port 0x%016Lx)\n",
2482 - unit->fcp_lun, unit->port->wwpn);
2483 + (unsigned long long)unit->fcp_lun,
2484 + (unsigned long long)unit->port->wwpn);
2485 zfcp_erp_unit_failed(unit, 35, req);
2486 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2487 zfcp_erp_unit_shutdown(unit, 0, 80, req);
2488 @@ -1795,7 +1907,8 @@ static void zfcp_fsf_open_unit_handler(s
2489 "Shared read-write access not "
2490 "supported (unit 0x%016Lx, port "
2491 "0x%016Lx\n)",
2492 - unit->fcp_lun, unit->port->wwpn);
2493 + (unsigned long long)unit->fcp_lun,
2494 + (unsigned long long)unit->port->wwpn);
2495 zfcp_erp_unit_failed(unit, 36, req);
2496 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2497 zfcp_erp_unit_shutdown(unit, 0, 81, req);
2498 @@ -1803,9 +1916,6 @@ static void zfcp_fsf_open_unit_handler(s
2499 }
2500 break;
2501 }
2502 -
2503 -skip_fsfstatus:
2504 - atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status);
2505 }
2506
2507 /**
2508 @@ -1815,12 +1925,12 @@ skip_fsfstatus:
2509 */
2510 int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
2511 {
2512 - volatile struct qdio_buffer_element *sbale;
2513 + struct qdio_buffer_element *sbale;
2514 struct zfcp_adapter *adapter = erp_action->adapter;
2515 struct zfcp_fsf_req *req;
2516 int retval = -EIO;
2517
2518 - spin_lock_bh(&adapter->req_q.lock);
2519 + spin_lock_bh(&adapter->req_q_lock);
2520 if (zfcp_fsf_req_sbal_get(adapter))
2521 goto out;
2522
2523 @@ -1846,8 +1956,6 @@ int zfcp_fsf_open_unit(struct zfcp_erp_a
2524 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
2525 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
2526
2527 - atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status);
2528 -
2529 zfcp_fsf_start_erp_timer(req);
2530 retval = zfcp_fsf_req_send(req);
2531 if (retval) {
2532 @@ -1855,7 +1963,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_a
2533 erp_action->fsf_req = NULL;
2534 }
2535 out:
2536 - spin_unlock_bh(&adapter->req_q.lock);
2537 + spin_unlock_bh(&adapter->req_q_lock);
2538 return retval;
2539 }
2540
2541 @@ -1864,7 +1972,7 @@ static void zfcp_fsf_close_unit_handler(
2542 struct zfcp_unit *unit = req->data;
2543
2544 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2545 - goto skip_fsfstatus;
2546 + return;
2547
2548 switch (req->qtcb->header.fsf_status) {
2549 case FSF_PORT_HANDLE_NOT_VALID:
2550 @@ -1894,8 +2002,6 @@ static void zfcp_fsf_close_unit_handler(
2551 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
2552 break;
2553 }
2554 -skip_fsfstatus:
2555 - atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status);
2556 }
2557
2558 /**
2559 @@ -1905,12 +2011,12 @@ skip_fsfstatus:
2560 */
2561 int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
2562 {
2563 - volatile struct qdio_buffer_element *sbale;
2564 + struct qdio_buffer_element *sbale;
2565 struct zfcp_adapter *adapter = erp_action->adapter;
2566 struct zfcp_fsf_req *req;
2567 int retval = -EIO;
2568
2569 - spin_lock_bh(&adapter->req_q.lock);
2570 + spin_lock_bh(&adapter->req_q_lock);
2571 if (zfcp_fsf_req_sbal_get(adapter))
2572 goto out;
2573 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
2574 @@ -1931,7 +2037,6 @@ int zfcp_fsf_close_unit(struct zfcp_erp_
2575 req->data = erp_action->unit;
2576 req->erp_action = erp_action;
2577 erp_action->fsf_req = req;
2578 - atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status);
2579
2580 zfcp_fsf_start_erp_timer(req);
2581 retval = zfcp_fsf_req_send(req);
2582 @@ -1940,7 +2045,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_
2583 erp_action->fsf_req = NULL;
2584 }
2585 out:
2586 - spin_unlock_bh(&adapter->req_q.lock);
2587 + spin_unlock_bh(&adapter->req_q_lock);
2588 return retval;
2589 }
2590
2591 @@ -2136,7 +2241,8 @@ static void zfcp_fsf_send_fcp_command_ha
2592 "Incorrect direction %d, unit 0x%016Lx on port "
2593 "0x%016Lx closed\n",
2594 req->qtcb->bottom.io.data_direction,
2595 - unit->fcp_lun, unit->port->wwpn);
2596 + (unsigned long long)unit->fcp_lun,
2597 + (unsigned long long)unit->port->wwpn);
2598 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req);
2599 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2600 break;
2601 @@ -2145,7 +2251,8 @@ static void zfcp_fsf_send_fcp_command_ha
2602 "Incorrect CDB length %d, unit 0x%016Lx on "
2603 "port 0x%016Lx closed\n",
2604 req->qtcb->bottom.io.fcp_cmnd_length,
2605 - unit->fcp_lun, unit->port->wwpn);
2606 + (unsigned long long)unit->fcp_lun,
2607 + (unsigned long long)unit->port->wwpn);
2608 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req);
2609 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2610 break;
2611 @@ -2176,6 +2283,20 @@ skip_fsfstatus:
2612 }
2613 }
2614
2615 +static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
2616 +{
2617 + u32 *fcp_dl_ptr;
2618 +
2619 + /*
2620 + * fcp_dl_addr = start address of fcp_cmnd structure +
2621 + * size of fixed part + size of dynamically sized add_dcp_cdb field
2622 + * SEE FCP-2 documentation
2623 + */
2624 + fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
2625 + (fcp_cmd->add_fcp_cdb_length << 2));
2626 + *fcp_dl_ptr = fcp_dl;
2627 +}
2628 +
2629 /**
2630 * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
2631 * @adapter: adapter where scsi command is issued
2632 @@ -2198,7 +2319,7 @@ int zfcp_fsf_send_fcp_command_task(struc
2633 ZFCP_STATUS_COMMON_UNBLOCKED)))
2634 return -EBUSY;
2635
2636 - spin_lock(&adapter->req_q.lock);
2637 + spin_lock(&adapter->req_q_lock);
2638 if (!zfcp_fsf_sbal_available(adapter))
2639 goto out;
2640 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
2641 @@ -2261,7 +2382,7 @@ int zfcp_fsf_send_fcp_command_task(struc
2642 memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
2643
2644 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
2645 - fcp_cmnd_iu->add_fcp_cdb_length + sizeof(fcp_dl_t);
2646 + fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
2647
2648 real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
2649 scsi_sglist(scsi_cmnd),
2650 @@ -2273,7 +2394,8 @@ int zfcp_fsf_send_fcp_command_task(struc
2651 dev_err(&adapter->ccw_device->dev,
2652 "Oversize data package, unit 0x%016Lx "
2653 "on port 0x%016Lx closed\n",
2654 - unit->fcp_lun, unit->port->wwpn);
2655 + (unsigned long long)unit->fcp_lun,
2656 + (unsigned long long)unit->port->wwpn);
2657 zfcp_erp_unit_shutdown(unit, 0, 131, req);
2658 retval = -EINVAL;
2659 }
2660 @@ -2296,7 +2418,7 @@ failed_scsi_cmnd:
2661 zfcp_fsf_req_free(req);
2662 scsi_cmnd->host_scribble = NULL;
2663 out:
2664 - spin_unlock(&adapter->req_q.lock);
2665 + spin_unlock(&adapter->req_q_lock);
2666 return retval;
2667 }
2668
2669 @@ -2312,7 +2434,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
2670 struct zfcp_unit *unit,
2671 u8 tm_flags, int req_flags)
2672 {
2673 - volatile struct qdio_buffer_element *sbale;
2674 + struct qdio_buffer_element *sbale;
2675 struct zfcp_fsf_req *req = NULL;
2676 struct fcp_cmnd_iu *fcp_cmnd_iu;
2677
2678 @@ -2320,7 +2442,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
2679 ZFCP_STATUS_COMMON_UNBLOCKED)))
2680 return NULL;
2681
2682 - spin_lock(&adapter->req_q.lock);
2683 + spin_lock(&adapter->req_q_lock);
2684 if (!zfcp_fsf_sbal_available(adapter))
2685 goto out;
2686 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
2687 @@ -2336,7 +2458,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
2688 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2689 req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2690 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
2691 - sizeof(fcp_dl_t);
2692 + sizeof(u32);
2693
2694 sbale = zfcp_qdio_sbale_req(req);
2695 sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
2696 @@ -2353,7 +2475,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_c
2697 zfcp_fsf_req_free(req);
2698 req = NULL;
2699 out:
2700 - spin_unlock(&adapter->req_q.lock);
2701 + spin_unlock(&adapter->req_q_lock);
2702 return req;
2703 }
2704
2705 @@ -2372,7 +2494,7 @@ static void zfcp_fsf_control_file_handle
2706 struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
2707 struct zfcp_fsf_cfdc *fsf_cfdc)
2708 {
2709 - volatile struct qdio_buffer_element *sbale;
2710 + struct qdio_buffer_element *sbale;
2711 struct zfcp_fsf_req *req = NULL;
2712 struct fsf_qtcb_bottom_support *bottom;
2713 int direction, retval = -EIO, bytes;
2714 @@ -2391,7 +2513,7 @@ struct zfcp_fsf_req *zfcp_fsf_control_fi
2715 return ERR_PTR(-EINVAL);
2716 }
2717
2718 - spin_lock_bh(&adapter->req_q.lock);
2719 + spin_lock_bh(&adapter->req_q_lock);
2720 if (zfcp_fsf_req_sbal_get(adapter))
2721 goto out;
2722
2723 @@ -2421,7 +2543,7 @@ struct zfcp_fsf_req *zfcp_fsf_control_fi
2724 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2725 retval = zfcp_fsf_req_send(req);
2726 out:
2727 - spin_unlock_bh(&adapter->req_q.lock);
2728 + spin_unlock_bh(&adapter->req_q_lock);
2729
2730 if (!retval) {
2731 wait_event(req->completion_wq,
2732 --- a/drivers/s390/scsi/zfcp_fsf.h
2733 +++ b/drivers/s390/scsi/zfcp_fsf.h
2734 @@ -71,13 +71,6 @@
2735 #define FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED 0x00000041
2736 #define FSF_ELS_COMMAND_REJECTED 0x00000050
2737 #define FSF_GENERIC_COMMAND_REJECTED 0x00000051
2738 -#define FSF_OPERATION_PARTIALLY_SUCCESSFUL 0x00000052
2739 -#define FSF_AUTHORIZATION_FAILURE 0x00000053
2740 -#define FSF_CFDC_ERROR_DETECTED 0x00000054
2741 -#define FSF_CONTROL_FILE_UPDATE_ERROR 0x00000055
2742 -#define FSF_CONTROL_FILE_TOO_LARGE 0x00000056
2743 -#define FSF_ACCESS_CONFLICT_DETECTED 0x00000057
2744 -#define FSF_CONFLICTS_OVERRULED 0x00000058
2745 #define FSF_PORT_BOXED 0x00000059
2746 #define FSF_LUN_BOXED 0x0000005A
2747 #define FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE 0x0000005B
2748 @@ -85,9 +78,7 @@
2749 #define FSF_REQUEST_SIZE_TOO_LARGE 0x00000061
2750 #define FSF_RESPONSE_SIZE_TOO_LARGE 0x00000062
2751 #define FSF_SBAL_MISMATCH 0x00000063
2752 -#define FSF_OPEN_PORT_WITHOUT_PRLI 0x00000064
2753 #define FSF_ADAPTER_STATUS_AVAILABLE 0x000000AD
2754 -#define FSF_FCP_RSP_AVAILABLE 0x000000AF
2755 #define FSF_UNKNOWN_COMMAND 0x000000E2
2756 #define FSF_UNKNOWN_OP_SUBTYPE 0x000000E3
2757 #define FSF_INVALID_COMMAND_OPTION 0x000000E5
2758 @@ -102,20 +93,9 @@
2759 #define FSF_SQ_RETRY_IF_POSSIBLE 0x02
2760 #define FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED 0x03
2761 #define FSF_SQ_INVOKE_LINK_TEST_PROCEDURE 0x04
2762 -#define FSF_SQ_ULP_PROGRAMMING_ERROR 0x05
2763 #define FSF_SQ_COMMAND_ABORTED 0x06
2764 #define FSF_SQ_NO_RETRY_POSSIBLE 0x07
2765
2766 -/* FSF status qualifier for CFDC commands */
2767 -#define FSF_SQ_CFDC_HARDENED_ON_SE 0x00000000
2768 -#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE 0x00000001
2769 -#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE2 0x00000002
2770 -/* CFDC subtable codes */
2771 -#define FSF_SQ_CFDC_SUBTABLE_OS 0x0001
2772 -#define FSF_SQ_CFDC_SUBTABLE_PORT_WWPN 0x0002
2773 -#define FSF_SQ_CFDC_SUBTABLE_PORT_DID 0x0003
2774 -#define FSF_SQ_CFDC_SUBTABLE_LUN 0x0004
2775 -
2776 /* FSF status qualifier (most significant 4 bytes), local link down */
2777 #define FSF_PSQ_LINK_NO_LIGHT 0x00000004
2778 #define FSF_PSQ_LINK_WRAP_PLUG 0x00000008
2779 @@ -145,7 +125,6 @@
2780 #define FSF_STATUS_READ_LINK_UP 0x00000006
2781 #define FSF_STATUS_READ_NOTIFICATION_LOST 0x00000009
2782 #define FSF_STATUS_READ_CFDC_UPDATED 0x0000000A
2783 -#define FSF_STATUS_READ_CFDC_HARDENED 0x0000000B
2784 #define FSF_STATUS_READ_FEATURE_UPDATE_ALERT 0x0000000C
2785
2786 /* status subtypes in status read buffer */
2787 @@ -159,20 +138,9 @@
2788
2789 /* status subtypes for unsolicited status notification lost */
2790 #define FSF_STATUS_READ_SUB_INCOMING_ELS 0x00000001
2791 -#define FSF_STATUS_READ_SUB_SENSE_DATA 0x00000002
2792 -#define FSF_STATUS_READ_SUB_LINK_STATUS 0x00000004
2793 -#define FSF_STATUS_READ_SUB_PORT_CLOSED 0x00000008
2794 -#define FSF_STATUS_READ_SUB_BIT_ERROR_THRESHOLD 0x00000010
2795 #define FSF_STATUS_READ_SUB_ACT_UPDATED 0x00000020
2796 -#define FSF_STATUS_READ_SUB_ACT_HARDENED 0x00000040
2797 -#define FSF_STATUS_READ_SUB_FEATURE_UPDATE_ALERT 0x00000080
2798 -
2799 -/* status subtypes for CFDC */
2800 -#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE 0x00000002
2801 -#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F
2802
2803 /* topologie that is detected by the adapter */
2804 -#define FSF_TOPO_ERROR 0x00000000
2805 #define FSF_TOPO_P2P 0x00000001
2806 #define FSF_TOPO_FABRIC 0x00000002
2807 #define FSF_TOPO_AL 0x00000003
2808 @@ -180,17 +148,13 @@
2809 /* data direction for FCP commands */
2810 #define FSF_DATADIR_WRITE 0x00000001
2811 #define FSF_DATADIR_READ 0x00000002
2812 -#define FSF_DATADIR_READ_WRITE 0x00000003
2813 #define FSF_DATADIR_CMND 0x00000004
2814
2815 /* fc service class */
2816 -#define FSF_CLASS_1 0x00000001
2817 -#define FSF_CLASS_2 0x00000002
2818 #define FSF_CLASS_3 0x00000003
2819
2820 /* SBAL chaining */
2821 #define FSF_MAX_SBALS_PER_REQ 36
2822 -#define FSF_MAX_SBALS_PER_ELS_REQ 2
2823
2824 /* logging space behind QTCB */
2825 #define FSF_QTCB_LOG_SIZE 1024
2826 @@ -200,50 +164,16 @@
2827 #define FSF_FEATURE_LUN_SHARING 0x00000004
2828 #define FSF_FEATURE_NOTIFICATION_LOST 0x00000008
2829 #define FSF_FEATURE_HBAAPI_MANAGEMENT 0x00000010
2830 -#define FSF_FEATURE_ELS_CT_CHAINED_SBALS 0x00000020
2831 #define FSF_FEATURE_UPDATE_ALERT 0x00000100
2832 #define FSF_FEATURE_MEASUREMENT_DATA 0x00000200
2833
2834 /* host connection features */
2835 #define FSF_FEATURE_NPIV_MODE 0x00000001
2836 -#define FSF_FEATURE_VM_ASSIGNED_WWPN 0x00000002
2837
2838 /* option */
2839 #define FSF_OPEN_LUN_SUPPRESS_BOXING 0x00000001
2840 -#define FSF_OPEN_LUN_REPLICATE_SENSE 0x00000002
2841 -
2842 -/* adapter types */
2843 -#define FSF_ADAPTER_TYPE_FICON 0x00000001
2844 -#define FSF_ADAPTER_TYPE_FICON_EXPRESS 0x00000002
2845 -
2846 -/* port types */
2847 -#define FSF_HBA_PORTTYPE_UNKNOWN 0x00000001
2848 -#define FSF_HBA_PORTTYPE_NOTPRESENT 0x00000003
2849 -#define FSF_HBA_PORTTYPE_NPORT 0x00000005
2850 -#define FSF_HBA_PORTTYPE_PTP 0x00000021
2851 -/* following are not defined and used by FSF Spec
2852 - but are additionally defined by FC-HBA */
2853 -#define FSF_HBA_PORTTYPE_OTHER 0x00000002
2854 -#define FSF_HBA_PORTTYPE_NOTPRESENT 0x00000003
2855 -#define FSF_HBA_PORTTYPE_NLPORT 0x00000006
2856 -#define FSF_HBA_PORTTYPE_FLPORT 0x00000007
2857 -#define FSF_HBA_PORTTYPE_FPORT 0x00000008
2858 -#define FSF_HBA_PORTTYPE_LPORT 0x00000020
2859 -
2860 -/* port states */
2861 -#define FSF_HBA_PORTSTATE_UNKNOWN 0x00000001
2862 -#define FSF_HBA_PORTSTATE_ONLINE 0x00000002
2863 -#define FSF_HBA_PORTSTATE_OFFLINE 0x00000003
2864 -#define FSF_HBA_PORTSTATE_LINKDOWN 0x00000006
2865 -#define FSF_HBA_PORTSTATE_ERROR 0x00000007
2866 -
2867 -/* IO states of adapter */
2868 -#define FSF_IOSTAT_NPORT_RJT 0x00000004
2869 -#define FSF_IOSTAT_FABRIC_RJT 0x00000005
2870 -#define FSF_IOSTAT_LS_RJT 0x00000009
2871
2872 /* open LUN access flags*/
2873 -#define FSF_UNIT_ACCESS_OPEN_LUN_ALLOWED 0x01000000
2874 #define FSF_UNIT_ACCESS_EXCLUSIVE 0x02000000
2875 #define FSF_UNIT_ACCESS_OUTBOUND_TRANSFER 0x10000000
2876
2877 @@ -265,11 +195,6 @@ struct fsf_queue_designator {
2878 u32 res1;
2879 } __attribute__ ((packed));
2880
2881 -struct fsf_port_closed_payload {
2882 - struct fsf_queue_designator queue_designator;
2883 - u32 port_handle;
2884 -} __attribute__ ((packed));
2885 -
2886 struct fsf_bit_error_payload {
2887 u32 res1;
2888 u32 link_failure_error_count;
2889 --- a/drivers/s390/scsi/zfcp_qdio.c
2890 +++ b/drivers/s390/scsi/zfcp_qdio.c
2891 @@ -30,7 +30,7 @@ static int zfcp_qdio_buffers_enqueue(str
2892 return 0;
2893 }
2894
2895 -static volatile struct qdio_buffer_element *
2896 +static struct qdio_buffer_element *
2897 zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
2898 {
2899 return &q->sbal[sbal_idx]->element[sbale_idx];
2900 @@ -148,7 +148,7 @@ static void zfcp_qdio_int_resp(struct cc
2901 {
2902 struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
2903 struct zfcp_qdio_queue *queue = &adapter->resp_q;
2904 - volatile struct qdio_buffer_element *sbale;
2905 + struct qdio_buffer_element *sbale;
2906 int sbal_idx, sbale_idx, sbal_no;
2907
2908 if (unlikely(qdio_err)) {
2909 @@ -193,8 +193,7 @@ static void zfcp_qdio_int_resp(struct cc
2910 * @fsf_req: pointer to struct fsf_req
2911 * Returns: pointer to qdio_buffer_element (SBALE) structure
2912 */
2913 -volatile struct qdio_buffer_element *
2914 -zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
2915 +struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
2916 {
2917 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 0);
2918 }
2919 @@ -204,8 +203,7 @@ zfcp_qdio_sbale_req(struct zfcp_fsf_req
2920 * @fsf_req: pointer to struct fsf_req
2921 * Returns: pointer to qdio_buffer_element (SBALE) structure
2922 */
2923 -volatile struct qdio_buffer_element *
2924 -zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
2925 +struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
2926 {
2927 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last,
2928 req->sbale_curr);
2929 @@ -219,10 +217,10 @@ static void zfcp_qdio_sbal_limit(struct
2930 % QDIO_MAX_BUFFERS_PER_Q;
2931 }
2932
2933 -static volatile struct qdio_buffer_element *
2934 +static struct qdio_buffer_element *
2935 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
2936 {
2937 - volatile struct qdio_buffer_element *sbale;
2938 + struct qdio_buffer_element *sbale;
2939
2940 /* set last entry flag in current SBALE of current SBAL */
2941 sbale = zfcp_qdio_sbale_curr(fsf_req);
2942 @@ -253,7 +251,7 @@ zfcp_qdio_sbal_chain(struct zfcp_fsf_req
2943 return sbale;
2944 }
2945
2946 -static volatile struct qdio_buffer_element *
2947 +static struct qdio_buffer_element *
2948 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
2949 {
2950 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
2951 @@ -276,7 +274,7 @@ static int zfcp_qdio_fill_sbals(struct z
2952 unsigned int sbtype, void *start_addr,
2953 unsigned int total_length)
2954 {
2955 - volatile struct qdio_buffer_element *sbale;
2956 + struct qdio_buffer_element *sbale;
2957 unsigned long remaining, length;
2958 void *addr;
2959
2960 @@ -311,7 +309,7 @@ static int zfcp_qdio_fill_sbals(struct z
2961 int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
2962 struct scatterlist *sg, int max_sbals)
2963 {
2964 - volatile struct qdio_buffer_element *sbale;
2965 + struct qdio_buffer_element *sbale;
2966 int retval, bytes = 0;
2967
2968 /* figure out last allowed SBAL */
2969 @@ -348,10 +346,10 @@ int zfcp_qdio_send(struct zfcp_fsf_req *
2970 int first = fsf_req->sbal_first;
2971 int count = fsf_req->sbal_number;
2972 int retval, pci, pci_batch;
2973 - volatile struct qdio_buffer_element *sbale;
2974 + struct qdio_buffer_element *sbale;
2975
2976 /* acknowledgements for transferred buffers */
2977 - pci_batch = req_q->pci_batch + count;
2978 + pci_batch = adapter->req_q_pci_batch + count;
2979 if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) {
2980 pci_batch %= ZFCP_QDIO_PCI_INTERVAL;
2981 pci = first + count - (pci_batch + 1);
2982 @@ -371,7 +369,7 @@ int zfcp_qdio_send(struct zfcp_fsf_req *
2983 atomic_sub(count, &req_q->count);
2984 req_q->first += count;
2985 req_q->first %= QDIO_MAX_BUFFERS_PER_Q;
2986 - req_q->pci_batch = pci_batch;
2987 + adapter->req_q_pci_batch = pci_batch;
2988 return 0;
2989 }
2990
2991 @@ -422,14 +420,14 @@ void zfcp_qdio_close(struct zfcp_adapter
2992 struct zfcp_qdio_queue *req_q;
2993 int first, count;
2994
2995 - if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
2996 + if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
2997 return;
2998
2999 /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
3000 req_q = &adapter->req_q;
3001 - spin_lock_bh(&req_q->lock);
3002 + spin_lock_bh(&adapter->req_q_lock);
3003 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
3004 - spin_unlock_bh(&req_q->lock);
3005 + spin_unlock_bh(&adapter->req_q_lock);
3006
3007 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
3008
3009 @@ -442,7 +440,7 @@ void zfcp_qdio_close(struct zfcp_adapter
3010 }
3011 req_q->first = 0;
3012 atomic_set(&req_q->count, 0);
3013 - req_q->pci_batch = 0;
3014 + adapter->req_q_pci_batch = 0;
3015 adapter->resp_q.first = 0;
3016 atomic_set(&adapter->resp_q.count, 0);
3017 }
3018 @@ -454,10 +452,10 @@ void zfcp_qdio_close(struct zfcp_adapter
3019 */
3020 int zfcp_qdio_open(struct zfcp_adapter *adapter)
3021 {
3022 - volatile struct qdio_buffer_element *sbale;
3023 + struct qdio_buffer_element *sbale;
3024 int cc;
3025
3026 - if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
3027 + if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)
3028 return -EIO;
3029
3030 if (qdio_establish(&adapter->qdio_init_data))
3031 @@ -480,7 +478,7 @@ int zfcp_qdio_open(struct zfcp_adapter *
3032 /* set index of first avalable SBALS / number of available SBALS */
3033 adapter->req_q.first = 0;
3034 atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q);
3035 - adapter->req_q.pci_batch = 0;
3036 + adapter->req_q_pci_batch = 0;
3037
3038 return 0;
3039
3040 --- a/drivers/s390/scsi/zfcp_scsi.c
3041 +++ b/drivers/s390/scsi/zfcp_scsi.c
3042 @@ -23,20 +23,6 @@ char *zfcp_get_fcp_sns_info_ptr(struct f
3043 return fcp_sns_info_ptr;
3044 }
3045
3046 -void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl)
3047 -{
3048 - fcp_dl_t *fcp_dl_ptr;
3049 -
3050 - /*
3051 - * fcp_dl_addr = start address of fcp_cmnd structure +
3052 - * size of fixed part + size of dynamically sized add_dcp_cdb field
3053 - * SEE FCP-2 documentation
3054 - */
3055 - fcp_dl_ptr = (fcp_dl_t *) ((unsigned char *) &fcp_cmd[1] +
3056 - (fcp_cmd->add_fcp_cdb_length << 2));
3057 - *fcp_dl_ptr = fcp_dl;
3058 -}
3059 -
3060 static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
3061 {
3062 struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
3063 @@ -121,13 +107,17 @@ static struct zfcp_unit *zfcp_unit_looku
3064 {
3065 struct zfcp_port *port;
3066 struct zfcp_unit *unit;
3067 + int scsi_lun;
3068
3069 list_for_each_entry(port, &adapter->port_list_head, list) {
3070 if (!port->rport || (id != port->rport->scsi_target_id))
3071 continue;
3072 - list_for_each_entry(unit, &port->unit_list_head, list)
3073 - if (lun == unit->scsi_lun)
3074 + list_for_each_entry(unit, &port->unit_list_head, list) {
3075 + scsi_lun = scsilun_to_int(
3076 + (struct scsi_lun *)&unit->fcp_lun);
3077 + if (lun == scsi_lun)
3078 return unit;
3079 + }
3080 }
3081
3082 return NULL;
3083 @@ -185,7 +175,6 @@ static int zfcp_scsi_eh_abort_handler(st
3084 return retval;
3085 }
3086 fsf_req->data = NULL;
3087 - fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING;
3088
3089 /* don't access old fsf_req after releasing the abort_lock */
3090 write_unlock_irqrestore(&adapter->abort_lock, flags);
3091 @@ -315,7 +304,6 @@ int zfcp_adapter_scsi_register(struct zf
3092 scsi_host_put(adapter->scsi_host);
3093 return -EIO;
3094 }
3095 - atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
3096
3097 return 0;
3098 }
3099 @@ -339,7 +327,6 @@ void zfcp_adapter_scsi_unregister(struct
3100 scsi_remove_host(shost);
3101 scsi_host_put(shost);
3102 adapter->scsi_host = NULL;
3103 - atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
3104
3105 return;
3106 }
3107 --- a/drivers/s390/scsi/zfcp_sysfs.c
3108 +++ b/drivers/s390/scsi/zfcp_sysfs.c
3109 @@ -28,9 +28,9 @@ static ZFCP_DEV_ATTR(_feat, _name, S_IRU
3110 ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, status, "0x%08x\n",
3111 atomic_read(&adapter->status));
3112 ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwnn, "0x%016llx\n",
3113 - adapter->peer_wwnn);
3114 + (unsigned long long) adapter->peer_wwnn);
3115 ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwpn, "0x%016llx\n",
3116 - adapter->peer_wwpn);
3117 + (unsigned long long) adapter->peer_wwpn);
3118 ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_d_id, "0x%06x\n",
3119 adapter->peer_d_id);
3120 ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, card_version, "0x%04x\n",
3121 @@ -137,8 +137,9 @@ static ssize_t zfcp_sysfs_port_remove_st
3122 {
3123 struct zfcp_adapter *adapter = dev_get_drvdata(dev);
3124 struct zfcp_port *port;
3125 - wwn_t wwpn;
3126 + u64 wwpn;
3127 int retval = 0;
3128 + LIST_HEAD(port_remove_lh);
3129
3130 down(&zfcp_data.config_sema);
3131 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_REMOVE) {
3132 @@ -146,7 +147,7 @@ static ssize_t zfcp_sysfs_port_remove_st
3133 goto out;
3134 }
3135
3136 - if (strict_strtoull(buf, 0, &wwpn)) {
3137 + if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn)) {
3138 retval = -EINVAL;
3139 goto out;
3140 }
3141 @@ -156,7 +157,7 @@ static ssize_t zfcp_sysfs_port_remove_st
3142 if (port && (atomic_read(&port->refcount) == 0)) {
3143 zfcp_port_get(port);
3144 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
3145 - list_move(&port->list, &adapter->port_remove_lh);
3146 + list_move(&port->list, &port_remove_lh);
3147 } else
3148 port = NULL;
3149 write_unlock_irq(&zfcp_data.config_lock);
3150 @@ -202,7 +203,7 @@ static ssize_t zfcp_sysfs_unit_add_store
3151 {
3152 struct zfcp_port *port = dev_get_drvdata(dev);
3153 struct zfcp_unit *unit;
3154 - fcp_lun_t fcp_lun;
3155 + u64 fcp_lun;
3156 int retval = -EINVAL;
3157
3158 down(&zfcp_data.config_sema);
3159 @@ -211,7 +212,7 @@ static ssize_t zfcp_sysfs_unit_add_store
3160 goto out;
3161 }
3162
3163 - if (strict_strtoull(buf, 0, &fcp_lun))
3164 + if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
3165 goto out;
3166
3167 unit = zfcp_unit_enqueue(port, fcp_lun);
3168 @@ -235,8 +236,9 @@ static ssize_t zfcp_sysfs_unit_remove_st
3169 {
3170 struct zfcp_port *port = dev_get_drvdata(dev);
3171 struct zfcp_unit *unit;
3172 - fcp_lun_t fcp_lun;
3173 + u64 fcp_lun;
3174 int retval = 0;
3175 + LIST_HEAD(unit_remove_lh);
3176
3177 down(&zfcp_data.config_sema);
3178 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE) {
3179 @@ -244,7 +246,7 @@ static ssize_t zfcp_sysfs_unit_remove_st
3180 goto out;
3181 }
3182
3183 - if (strict_strtoull(buf, 0, &fcp_lun)) {
3184 + if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) {
3185 retval = -EINVAL;
3186 goto out;
3187 }
3188 @@ -254,7 +256,7 @@ static ssize_t zfcp_sysfs_unit_remove_st
3189 if (unit && (atomic_read(&unit->refcount) == 0)) {
3190 zfcp_unit_get(unit);
3191 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
3192 - list_move(&unit->list, &port->unit_remove_lh);
3193 + list_move(&unit->list, &unit_remove_lh);
3194 } else
3195 unit = NULL;
3196
3197 @@ -275,22 +277,7 @@ out:
3198 }
3199 static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
3200
3201 -static struct attribute *zfcp_port_ns_attrs[] = {
3202 - &dev_attr_port_failed.attr,
3203 - &dev_attr_port_in_recovery.attr,
3204 - &dev_attr_port_status.attr,
3205 - &dev_attr_port_access_denied.attr,
3206 - NULL
3207 -};
3208 -
3209 -/**
3210 - * zfcp_sysfs_ns_port_attrs - sysfs attributes for nameserver
3211 - */
3212 -struct attribute_group zfcp_sysfs_ns_port_attrs = {
3213 - .attrs = zfcp_port_ns_attrs,
3214 -};
3215 -
3216 -static struct attribute *zfcp_port_no_ns_attrs[] = {
3217 +static struct attribute *zfcp_port_attrs[] = {
3218 &dev_attr_unit_add.attr,
3219 &dev_attr_unit_remove.attr,
3220 &dev_attr_port_failed.attr,
3221 @@ -304,7 +291,7 @@ static struct attribute *zfcp_port_no_ns
3222 * zfcp_sysfs_port_attrs - sysfs attributes for all other ports
3223 */
3224 struct attribute_group zfcp_sysfs_port_attrs = {
3225 - .attrs = zfcp_port_no_ns_attrs,
3226 + .attrs = zfcp_port_attrs,
3227 };
3228
3229 static struct attribute *zfcp_unit_attrs[] = {
3230 @@ -397,8 +384,10 @@ static DEVICE_ATTR(_name, S_IRUGO, zfcp_
3231
3232 ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
3233 unit->port->adapter->ccw_device->dev.bus_id);
3234 -ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n", unit->port->wwpn);
3235 -ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n", unit->fcp_lun);
3236 +ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
3237 + (unsigned long long) unit->port->wwpn);
3238 +ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n",
3239 + (unsigned long long) unit->fcp_lun);
3240
3241 struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
3242 &dev_attr_fcp_lun,
Peter's tree of IPFire 2.x