]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/suse-2.6.27.25/patches.arch/s390-01-06-zfcp-cleanup-v2.patch
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reenabled linux-xen and xen-image build
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.arch / s390-01-06-zfcp-cleanup-v2.patch
CommitLineData
00e5a55c
BS		 1From: Gerald Schaefer <geraldsc@de.ibm.com>
2Subject: FCP - code cleanup stage 2
3References: bnc#417550
4
5Stage 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
14Acked-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