diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2010-02-26 19:55:27 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2010-02-26 19:55:27 -0500 |
commit | 654451748b779b28077d9058442d0f354251870d (patch) | |
tree | ff889a2f6226e16b1121789f809927666a9ccf13 /drivers/s390/scsi | |
parent | 64d497f55379b1e320a08ec2426468d96f5642ec (diff) | |
parent | 77c9cfc51b0d732b2524799810fb30018074fd60 (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (158 commits)
[SCSI] Fix printing of failed 32-byte commands
[SCSI] Fix printing of variable length commands
[SCSI] libsrp: fix bug in ADDITIONAL CDB LENGTH interpretation
[SCSI] scsi_dh_alua: Add IBM Power Virtual SCSI ALUA device to dev list
[SCSI] scsi_dh_alua: add netapp to dev list
[SCSI] qla2xxx: Update version number to 8.03.02-k1.
[SCSI] qla2xxx: EEH: Restore PCI saved state during pci slot reset.
[SCSI] qla2xxx: Add firmware ETS burst support.
[SCSI] qla2xxx: Correct loop-resync issues during SNS scans.
[SCSI] qla2xxx: Correct use-after-free issue in terminate_rport_io callback.
[SCSI] qla2xxx: Correct EH bus-reset handling.
[SCSI] qla2xxx: Proper clean-up of BSG requests when request times out.
[SCSI] qla2xxx: Initialize payload receive length in failure path of vendor commands
[SCSI] fix duplicate removal on error path in scsi_sysfs_add_sdev
[SCSI] fix refcounting bug in scsi_get_host_dev
[SCSI] fix memory leak in scsi_report_lun_scan
[SCSI] lpfc: correct PPC build failure
[SCSI] raid_class: add raid1e
[SCSI] mpt2sas: Do not call sas_is_tlr_enabled for RAID volumes.
[SCSI] zfcp: Introduce header file for qdio structs and inline functions
...
Diffstat (limited to 'drivers/s390/scsi')
-rw-r--r-- | drivers/s390/scsi/zfcp_aux.c | 90 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_ccw.c | 11 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_dbf.c | 20 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_dbf.h | 34 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_def.h | 114 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_erp.c | 36 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_ext.h | 9 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_fc.c | 23 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_fsf.c | 163 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_qdio.c | 50 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_qdio.h | 109 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_reqlist.h | 183 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_scsi.c | 38 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_sysfs.c | 37 |
14 files changed, 513 insertions, 404 deletions
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c index 9d0c941b7d33..66d6c01fcf3e 100644 --- a/drivers/s390/scsi/zfcp_aux.c +++ b/drivers/s390/scsi/zfcp_aux.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Module interface and handling of zfcp data structures. | 4 | * Module interface and handling of zfcp data structures. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | /* | 9 | /* |
@@ -32,6 +32,7 @@ | |||
32 | #include <linux/seq_file.h> | 32 | #include <linux/seq_file.h> |
33 | #include "zfcp_ext.h" | 33 | #include "zfcp_ext.h" |
34 | #include "zfcp_fc.h" | 34 | #include "zfcp_fc.h" |
35 | #include "zfcp_reqlist.h" | ||
35 | 36 | ||
36 | #define ZFCP_BUS_ID_SIZE 20 | 37 | #define ZFCP_BUS_ID_SIZE 20 |
37 | 38 | ||
@@ -49,36 +50,6 @@ static struct kmem_cache *zfcp_cache_hw_align(const char *name, | |||
49 | return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL); | 50 | return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL); |
50 | } | 51 | } |
51 | 52 | ||
52 | static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) | ||
53 | { | ||
54 | int idx; | ||
55 | |||
56 | adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), | ||
57 | GFP_KERNEL); | ||
58 | if (!adapter->req_list) | ||
59 | return -ENOMEM; | ||
60 | |||
61 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) | ||
62 | INIT_LIST_HEAD(&adapter->req_list[idx]); | ||
63 | return 0; | ||
64 | } | ||
65 | |||
66 | /** | ||
67 | * zfcp_reqlist_isempty - is the request list empty | ||
68 | * @adapter: pointer to struct zfcp_adapter | ||
69 | * | ||
70 | * Returns: true if list is empty, false otherwise | ||
71 | */ | ||
72 | int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) | ||
73 | { | ||
74 | unsigned int idx; | ||
75 | |||
76 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) | ||
77 | if (!list_empty(&adapter->req_list[idx])) | ||
78 | return 0; | ||
79 | return 1; | ||
80 | } | ||
81 | |||
82 | static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun) | 53 | static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun) |
83 | { | 54 | { |
84 | struct ccw_device *cdev; | 55 | struct ccw_device *cdev; |
@@ -110,7 +81,7 @@ static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun) | |||
110 | flush_work(&unit->scsi_work); | 81 | flush_work(&unit->scsi_work); |
111 | 82 | ||
112 | out_unit: | 83 | out_unit: |
113 | put_device(&port->sysfs_device); | 84 | put_device(&port->dev); |
114 | out_port: | 85 | out_port: |
115 | zfcp_ccw_adapter_put(adapter); | 86 | zfcp_ccw_adapter_put(adapter); |
116 | out_ccw_device: | 87 | out_ccw_device: |
@@ -255,7 +226,7 @@ struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun) | |||
255 | read_lock_irqsave(&port->unit_list_lock, flags); | 226 | read_lock_irqsave(&port->unit_list_lock, flags); |
256 | list_for_each_entry(unit, &port->unit_list, list) | 227 | list_for_each_entry(unit, &port->unit_list, list) |
257 | if (unit->fcp_lun == fcp_lun) { | 228 | if (unit->fcp_lun == fcp_lun) { |
258 | if (!get_device(&unit->sysfs_device)) | 229 | if (!get_device(&unit->dev)) |
259 | unit = NULL; | 230 | unit = NULL; |
260 | read_unlock_irqrestore(&port->unit_list_lock, flags); | 231 | read_unlock_irqrestore(&port->unit_list_lock, flags); |
261 | return unit; | 232 | return unit; |
@@ -280,7 +251,7 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, | |||
280 | read_lock_irqsave(&adapter->port_list_lock, flags); | 251 | read_lock_irqsave(&adapter->port_list_lock, flags); |
281 | list_for_each_entry(port, &adapter->port_list, list) | 252 | list_for_each_entry(port, &adapter->port_list, list) |
282 | if (port->wwpn == wwpn) { | 253 | if (port->wwpn == wwpn) { |
283 | if (!get_device(&port->sysfs_device)) | 254 | if (!get_device(&port->dev)) |
284 | port = NULL; | 255 | port = NULL; |
285 | read_unlock_irqrestore(&adapter->port_list_lock, flags); | 256 | read_unlock_irqrestore(&adapter->port_list_lock, flags); |
286 | return port; | 257 | return port; |
@@ -298,10 +269,9 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, | |||
298 | */ | 269 | */ |
299 | static void zfcp_unit_release(struct device *dev) | 270 | static void zfcp_unit_release(struct device *dev) |
300 | { | 271 | { |
301 | struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, | 272 | struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev); |
302 | sysfs_device); | ||
303 | 273 | ||
304 | put_device(&unit->port->sysfs_device); | 274 | put_device(&unit->port->dev); |
305 | kfree(unit); | 275 | kfree(unit); |
306 | } | 276 | } |
307 | 277 | ||
@@ -318,11 +288,11 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) | |||
318 | struct zfcp_unit *unit; | 288 | struct zfcp_unit *unit; |
319 | int retval = -ENOMEM; | 289 | int retval = -ENOMEM; |
320 | 290 | ||
321 | get_device(&port->sysfs_device); | 291 | get_device(&port->dev); |
322 | 292 | ||
323 | unit = zfcp_get_unit_by_lun(port, fcp_lun); | 293 | unit = zfcp_get_unit_by_lun(port, fcp_lun); |
324 | if (unit) { | 294 | if (unit) { |
325 | put_device(&unit->sysfs_device); | 295 | put_device(&unit->dev); |
326 | retval = -EEXIST; | 296 | retval = -EEXIST; |
327 | goto err_out; | 297 | goto err_out; |
328 | } | 298 | } |
@@ -333,10 +303,10 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) | |||
333 | 303 | ||
334 | unit->port = port; | 304 | unit->port = port; |
335 | unit->fcp_lun = fcp_lun; | 305 | unit->fcp_lun = fcp_lun; |
336 | unit->sysfs_device.parent = &port->sysfs_device; | 306 | unit->dev.parent = &port->dev; |
337 | unit->sysfs_device.release = zfcp_unit_release; | 307 | unit->dev.release = zfcp_unit_release; |
338 | 308 | ||
339 | if (dev_set_name(&unit->sysfs_device, "0x%016llx", | 309 | if (dev_set_name(&unit->dev, "0x%016llx", |
340 | (unsigned long long) fcp_lun)) { | 310 | (unsigned long long) fcp_lun)) { |
341 | kfree(unit); | 311 | kfree(unit); |
342 | goto err_out; | 312 | goto err_out; |
@@ -353,13 +323,12 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) | |||
353 | unit->latencies.cmd.channel.min = 0xFFFFFFFF; | 323 | unit->latencies.cmd.channel.min = 0xFFFFFFFF; |
354 | unit->latencies.cmd.fabric.min = 0xFFFFFFFF; | 324 | unit->latencies.cmd.fabric.min = 0xFFFFFFFF; |
355 | 325 | ||
356 | if (device_register(&unit->sysfs_device)) { | 326 | if (device_register(&unit->dev)) { |
357 | put_device(&unit->sysfs_device); | 327 | put_device(&unit->dev); |
358 | goto err_out; | 328 | goto err_out; |
359 | } | 329 | } |
360 | 330 | ||
361 | if (sysfs_create_group(&unit->sysfs_device.kobj, | 331 | if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs)) |
362 | &zfcp_sysfs_unit_attrs)) | ||
363 | goto err_out_put; | 332 | goto err_out_put; |
364 | 333 | ||
365 | write_lock_irq(&port->unit_list_lock); | 334 | write_lock_irq(&port->unit_list_lock); |
@@ -371,9 +340,9 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) | |||
371 | return unit; | 340 | return unit; |
372 | 341 | ||
373 | err_out_put: | 342 | err_out_put: |
374 | device_unregister(&unit->sysfs_device); | 343 | device_unregister(&unit->dev); |
375 | err_out: | 344 | err_out: |
376 | put_device(&port->sysfs_device); | 345 | put_device(&port->dev); |
377 | return ERR_PTR(retval); | 346 | return ERR_PTR(retval); |
378 | } | 347 | } |
379 | 348 | ||
@@ -539,7 +508,8 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device) | |||
539 | if (zfcp_allocate_low_mem_buffers(adapter)) | 508 | if (zfcp_allocate_low_mem_buffers(adapter)) |
540 | goto failed; | 509 | goto failed; |
541 | 510 | ||
542 | if (zfcp_reqlist_alloc(adapter)) | 511 | adapter->req_list = zfcp_reqlist_alloc(); |
512 | if (!adapter->req_list) | ||
543 | goto failed; | 513 | goto failed; |
544 | 514 | ||
545 | if (zfcp_dbf_adapter_register(adapter)) | 515 | if (zfcp_dbf_adapter_register(adapter)) |
@@ -560,8 +530,6 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device) | |||
560 | INIT_LIST_HEAD(&adapter->erp_ready_head); | 530 | INIT_LIST_HEAD(&adapter->erp_ready_head); |
561 | INIT_LIST_HEAD(&adapter->erp_running_head); | 531 | INIT_LIST_HEAD(&adapter->erp_running_head); |
562 | 532 | ||
563 | spin_lock_init(&adapter->req_list_lock); | ||
564 | |||
565 | rwlock_init(&adapter->erp_lock); | 533 | rwlock_init(&adapter->erp_lock); |
566 | rwlock_init(&adapter->abort_lock); | 534 | rwlock_init(&adapter->abort_lock); |
567 | 535 | ||
@@ -640,8 +608,7 @@ void zfcp_device_unregister(struct device *dev, | |||
640 | 608 | ||
641 | static void zfcp_port_release(struct device *dev) | 609 | static void zfcp_port_release(struct device *dev) |
642 | { | 610 | { |
643 | struct zfcp_port *port = container_of(dev, struct zfcp_port, | 611 | struct zfcp_port *port = container_of(dev, struct zfcp_port, dev); |
644 | sysfs_device); | ||
645 | 612 | ||
646 | zfcp_ccw_adapter_put(port->adapter); | 613 | zfcp_ccw_adapter_put(port->adapter); |
647 | kfree(port); | 614 | kfree(port); |
@@ -669,7 +636,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn, | |||
669 | 636 | ||
670 | port = zfcp_get_port_by_wwpn(adapter, wwpn); | 637 | port = zfcp_get_port_by_wwpn(adapter, wwpn); |
671 | if (port) { | 638 | if (port) { |
672 | put_device(&port->sysfs_device); | 639 | put_device(&port->dev); |
673 | retval = -EEXIST; | 640 | retval = -EEXIST; |
674 | goto err_out; | 641 | goto err_out; |
675 | } | 642 | } |
@@ -689,22 +656,21 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn, | |||
689 | port->d_id = d_id; | 656 | port->d_id = d_id; |
690 | port->wwpn = wwpn; | 657 | port->wwpn = wwpn; |
691 | port->rport_task = RPORT_NONE; | 658 | port->rport_task = RPORT_NONE; |
692 | port->sysfs_device.parent = &adapter->ccw_device->dev; | 659 | port->dev.parent = &adapter->ccw_device->dev; |
693 | port->sysfs_device.release = zfcp_port_release; | 660 | port->dev.release = zfcp_port_release; |
694 | 661 | ||
695 | if (dev_set_name(&port->sysfs_device, "0x%016llx", | 662 | if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) { |
696 | (unsigned long long)wwpn)) { | ||
697 | kfree(port); | 663 | kfree(port); |
698 | goto err_out; | 664 | goto err_out; |
699 | } | 665 | } |
700 | retval = -EINVAL; | 666 | retval = -EINVAL; |
701 | 667 | ||
702 | if (device_register(&port->sysfs_device)) { | 668 | if (device_register(&port->dev)) { |
703 | put_device(&port->sysfs_device); | 669 | put_device(&port->dev); |
704 | goto err_out; | 670 | goto err_out; |
705 | } | 671 | } |
706 | 672 | ||
707 | if (sysfs_create_group(&port->sysfs_device.kobj, | 673 | if (sysfs_create_group(&port->dev.kobj, |
708 | &zfcp_sysfs_port_attrs)) | 674 | &zfcp_sysfs_port_attrs)) |
709 | goto err_out_put; | 675 | goto err_out_put; |
710 | 676 | ||
@@ -717,7 +683,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn, | |||
717 | return port; | 683 | return port; |
718 | 684 | ||
719 | err_out_put: | 685 | err_out_put: |
720 | device_unregister(&port->sysfs_device); | 686 | device_unregister(&port->dev); |
721 | err_out: | 687 | err_out: |
722 | zfcp_ccw_adapter_put(adapter); | 688 | zfcp_ccw_adapter_put(adapter); |
723 | return ERR_PTR(retval); | 689 | return ERR_PTR(retval); |
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c index c22cb72a5ae8..ce1cc7a11fb4 100644 --- a/drivers/s390/scsi/zfcp_ccw.c +++ b/drivers/s390/scsi/zfcp_ccw.c | |||
@@ -3,13 +3,14 @@ | |||
3 | * | 3 | * |
4 | * Registration and callback for the s390 common I/O layer. | 4 | * Registration and callback for the s390 common I/O layer. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | 10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
11 | 11 | ||
12 | #include "zfcp_ext.h" | 12 | #include "zfcp_ext.h" |
13 | #include "zfcp_reqlist.h" | ||
13 | 14 | ||
14 | #define ZFCP_MODEL_PRIV 0x4 | 15 | #define ZFCP_MODEL_PRIV 0x4 |
15 | 16 | ||
@@ -122,12 +123,10 @@ static void zfcp_ccw_remove(struct ccw_device *cdev) | |||
122 | zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ | 123 | zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */ |
123 | 124 | ||
124 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) | 125 | list_for_each_entry_safe(unit, u, &unit_remove_lh, list) |
125 | zfcp_device_unregister(&unit->sysfs_device, | 126 | zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs); |
126 | &zfcp_sysfs_unit_attrs); | ||
127 | 127 | ||
128 | list_for_each_entry_safe(port, p, &port_remove_lh, list) | 128 | list_for_each_entry_safe(port, p, &port_remove_lh, list) |
129 | zfcp_device_unregister(&port->sysfs_device, | 129 | zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); |
130 | &zfcp_sysfs_port_attrs); | ||
131 | 130 | ||
132 | zfcp_adapter_unregister(adapter); | 131 | zfcp_adapter_unregister(adapter); |
133 | } | 132 | } |
@@ -162,7 +161,7 @@ static int zfcp_ccw_set_online(struct ccw_device *cdev) | |||
162 | } | 161 | } |
163 | 162 | ||
164 | /* initialize request counter */ | 163 | /* initialize request counter */ |
165 | BUG_ON(!zfcp_reqlist_isempty(adapter)); | 164 | BUG_ON(!zfcp_reqlist_isempty(adapter->req_list)); |
166 | adapter->req_no = 0; | 165 | adapter->req_no = 0; |
167 | 166 | ||
168 | zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL, | 167 | zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL, |
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c index 7369c8911bcf..7a149fd85f6d 100644 --- a/drivers/s390/scsi/zfcp_dbf.c +++ b/drivers/s390/scsi/zfcp_dbf.c | |||
@@ -140,9 +140,9 @@ void _zfcp_dbf_hba_fsf_response(const char *tag2, int level, | |||
140 | memcpy(response->fsf_status_qual, | 140 | memcpy(response->fsf_status_qual, |
141 | fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); | 141 | fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); |
142 | response->fsf_req_status = fsf_req->status; | 142 | response->fsf_req_status = fsf_req->status; |
143 | response->sbal_first = fsf_req->queue_req.sbal_first; | 143 | response->sbal_first = fsf_req->qdio_req.sbal_first; |
144 | response->sbal_last = fsf_req->queue_req.sbal_last; | 144 | response->sbal_last = fsf_req->qdio_req.sbal_last; |
145 | response->sbal_response = fsf_req->queue_req.sbal_response; | 145 | response->sbal_response = fsf_req->qdio_req.sbal_response; |
146 | response->pool = fsf_req->pool != NULL; | 146 | response->pool = fsf_req->pool != NULL; |
147 | response->erp_action = (unsigned long)fsf_req->erp_action; | 147 | response->erp_action = (unsigned long)fsf_req->erp_action; |
148 | 148 | ||
@@ -576,7 +576,8 @@ void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf) | |||
576 | struct zfcp_adapter *adapter = dbf->adapter; | 576 | struct zfcp_adapter *adapter = dbf->adapter; |
577 | 577 | ||
578 | zfcp_dbf_rec_target(id, ref, dbf, &adapter->status, | 578 | zfcp_dbf_rec_target(id, ref, dbf, &adapter->status, |
579 | &adapter->erp_counter, 0, 0, 0); | 579 | &adapter->erp_counter, 0, 0, |
580 | ZFCP_DBF_INVALID_LUN); | ||
580 | } | 581 | } |
581 | 582 | ||
582 | /** | 583 | /** |
@@ -590,8 +591,8 @@ void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port) | |||
590 | struct zfcp_dbf *dbf = port->adapter->dbf; | 591 | struct zfcp_dbf *dbf = port->adapter->dbf; |
591 | 592 | ||
592 | zfcp_dbf_rec_target(id, ref, dbf, &port->status, | 593 | zfcp_dbf_rec_target(id, ref, dbf, &port->status, |
593 | &port->erp_counter, port->wwpn, port->d_id, | 594 | &port->erp_counter, port->wwpn, port->d_id, |
594 | 0); | 595 | ZFCP_DBF_INVALID_LUN); |
595 | } | 596 | } |
596 | 597 | ||
597 | /** | 598 | /** |
@@ -642,10 +643,9 @@ void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action, | |||
642 | r->u.trigger.ps = atomic_read(&port->status); | 643 | r->u.trigger.ps = atomic_read(&port->status); |
643 | r->u.trigger.wwpn = port->wwpn; | 644 | r->u.trigger.wwpn = port->wwpn; |
644 | } | 645 | } |
645 | if (unit) { | 646 | if (unit) |
646 | r->u.trigger.us = atomic_read(&unit->status); | 647 | r->u.trigger.us = atomic_read(&unit->status); |
647 | r->u.trigger.fcp_lun = unit->fcp_lun; | 648 | r->u.trigger.fcp_lun = unit ? unit->fcp_lun : ZFCP_DBF_INVALID_LUN; |
648 | } | ||
649 | debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r)); | 649 | debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r)); |
650 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | 650 | spin_unlock_irqrestore(&dbf->rec_lock, flags); |
651 | } | 651 | } |
@@ -668,7 +668,7 @@ void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action) | |||
668 | r->u.action.action = (unsigned long)erp_action; | 668 | r->u.action.action = (unsigned long)erp_action; |
669 | r->u.action.status = erp_action->status; | 669 | r->u.action.status = erp_action->status; |
670 | r->u.action.step = erp_action->step; | 670 | r->u.action.step = erp_action->step; |
671 | r->u.action.fsf_req = (unsigned long)erp_action->fsf_req; | 671 | r->u.action.fsf_req = erp_action->fsf_req_id; |
672 | debug_event(dbf->rec, 5, r, sizeof(*r)); | 672 | debug_event(dbf->rec, 5, r, sizeof(*r)); |
673 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | 673 | spin_unlock_irqrestore(&dbf->rec_lock, flags); |
674 | } | 674 | } |
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h index 8b7fd9a1033e..457e046f2d28 100644 --- a/drivers/s390/scsi/zfcp_dbf.h +++ b/drivers/s390/scsi/zfcp_dbf.h | |||
@@ -30,6 +30,8 @@ | |||
30 | #define ZFCP_DBF_TAG_SIZE 4 | 30 | #define ZFCP_DBF_TAG_SIZE 4 |
31 | #define ZFCP_DBF_ID_SIZE 7 | 31 | #define ZFCP_DBF_ID_SIZE 7 |
32 | 32 | ||
33 | #define ZFCP_DBF_INVALID_LUN 0xFFFFFFFFFFFFFFFFull | ||
34 | |||
33 | struct zfcp_dbf_dump { | 35 | struct zfcp_dbf_dump { |
34 | u8 tag[ZFCP_DBF_TAG_SIZE]; | 36 | u8 tag[ZFCP_DBF_TAG_SIZE]; |
35 | u32 total_size; /* size of total dump data */ | 37 | u32 total_size; /* size of total dump data */ |
@@ -192,10 +194,10 @@ struct zfcp_dbf_san_record { | |||
192 | struct zfcp_dbf_san_record_ct_response ct_resp; | 194 | struct zfcp_dbf_san_record_ct_response ct_resp; |
193 | struct zfcp_dbf_san_record_els els; | 195 | struct zfcp_dbf_san_record_els els; |
194 | } u; | 196 | } u; |
195 | #define ZFCP_DBF_SAN_MAX_PAYLOAD 1024 | ||
196 | u8 payload[32]; | ||
197 | } __attribute__ ((packed)); | 197 | } __attribute__ ((packed)); |
198 | 198 | ||
199 | #define ZFCP_DBF_SAN_MAX_PAYLOAD 1024 | ||
200 | |||
199 | struct zfcp_dbf_scsi_record { | 201 | struct zfcp_dbf_scsi_record { |
200 | u8 tag[ZFCP_DBF_TAG_SIZE]; | 202 | u8 tag[ZFCP_DBF_TAG_SIZE]; |
201 | u8 tag2[ZFCP_DBF_TAG_SIZE]; | 203 | u8 tag2[ZFCP_DBF_TAG_SIZE]; |
@@ -301,17 +303,31 @@ void zfcp_dbf_scsi(const char *tag, const char *tag2, int level, | |||
301 | 303 | ||
302 | /** | 304 | /** |
303 | * zfcp_dbf_scsi_result - trace event for SCSI command completion | 305 | * zfcp_dbf_scsi_result - trace event for SCSI command completion |
304 | * @tag: tag indicating success or failure of SCSI command | 306 | * @dbf: adapter dbf trace |
305 | * @level: trace level applicable for this event | 307 | * @scmd: SCSI command pointer |
306 | * @adapter: adapter that has been used to issue the SCSI command | 308 | * @req: FSF request used to issue SCSI command |
309 | */ | ||
310 | static inline | ||
311 | void zfcp_dbf_scsi_result(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd, | ||
312 | struct zfcp_fsf_req *req) | ||
313 | { | ||
314 | if (scmd->result != 0) | ||
315 | zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0); | ||
316 | else if (scmd->retries > 0) | ||
317 | zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0); | ||
318 | else | ||
319 | zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0); | ||
320 | } | ||
321 | |||
322 | /** | ||
323 | * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command | ||
324 | * @dbf: adapter dbf trace | ||
307 | * @scmd: SCSI command pointer | 325 | * @scmd: SCSI command pointer |
308 | * @fsf_req: request used to issue SCSI command (might be NULL) | ||
309 | */ | 326 | */ |
310 | static inline | 327 | static inline |
311 | void zfcp_dbf_scsi_result(const char *tag, int level, struct zfcp_dbf *dbf, | 328 | void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd) |
312 | struct scsi_cmnd *scmd, struct zfcp_fsf_req *fsf_req) | ||
313 | { | 329 | { |
314 | zfcp_dbf_scsi("rslt", tag, level, dbf, scmd, fsf_req, 0); | 330 | zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0); |
315 | } | 331 | } |
316 | 332 | ||
317 | /** | 333 | /** |
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h index e1b5b88e2ddb..7131c7db1f04 100644 --- a/drivers/s390/scsi/zfcp_def.h +++ b/drivers/s390/scsi/zfcp_def.h | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Global definitions for the zfcp device driver. | 4 | * Global definitions for the zfcp device driver. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #ifndef ZFCP_DEF_H | 9 | #ifndef ZFCP_DEF_H |
@@ -33,15 +33,13 @@ | |||
33 | #include <scsi/scsi_transport_fc.h> | 33 | #include <scsi/scsi_transport_fc.h> |
34 | #include <scsi/scsi_bsg_fc.h> | 34 | #include <scsi/scsi_bsg_fc.h> |
35 | #include <asm/ccwdev.h> | 35 | #include <asm/ccwdev.h> |
36 | #include <asm/qdio.h> | ||
37 | #include <asm/debug.h> | 36 | #include <asm/debug.h> |
38 | #include <asm/ebcdic.h> | 37 | #include <asm/ebcdic.h> |
39 | #include <asm/sysinfo.h> | 38 | #include <asm/sysinfo.h> |
40 | #include "zfcp_fsf.h" | 39 | #include "zfcp_fsf.h" |
40 | #include "zfcp_qdio.h" | ||
41 | 41 | ||
42 | /********************* GENERAL DEFINES *********************************/ | 42 | struct zfcp_reqlist; |
43 | |||
44 | #define REQUEST_LIST_SIZE 128 | ||
45 | 43 | ||
46 | /********************* SCSI SPECIFIC DEFINES *********************************/ | 44 | /********************* SCSI SPECIFIC DEFINES *********************************/ |
47 | #define ZFCP_SCSI_ER_TIMEOUT (10*HZ) | 45 | #define ZFCP_SCSI_ER_TIMEOUT (10*HZ) |
@@ -129,12 +127,6 @@ struct zfcp_adapter_mempool { | |||
129 | mempool_t *qtcb_pool; | 127 | mempool_t *qtcb_pool; |
130 | }; | 128 | }; |
131 | 129 | ||
132 | struct zfcp_qdio_queue { | ||
133 | struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q]; | ||
134 | u8 first; /* index of next free bfr in queue */ | ||
135 | atomic_t count; /* number of free buffers in queue */ | ||
136 | }; | ||
137 | |||
138 | struct zfcp_erp_action { | 130 | struct zfcp_erp_action { |
139 | struct list_head list; | 131 | struct list_head list; |
140 | int action; /* requested action code */ | 132 | int action; /* requested action code */ |
@@ -143,8 +135,7 @@ struct zfcp_erp_action { | |||
143 | struct zfcp_unit *unit; | 135 | struct zfcp_unit *unit; |
144 | u32 status; /* recovery status */ | 136 | u32 status; /* recovery status */ |
145 | u32 step; /* active step of this erp action */ | 137 | u32 step; /* active step of this erp action */ |
146 | struct zfcp_fsf_req *fsf_req; /* fsf request currently pending | 138 | unsigned long fsf_req_id; |
147 | for this action */ | ||
148 | struct timer_list timer; | 139 | struct timer_list timer; |
149 | }; | 140 | }; |
150 | 141 | ||
@@ -167,29 +158,6 @@ struct zfcp_latencies { | |||
167 | spinlock_t lock; | 158 | spinlock_t lock; |
168 | }; | 159 | }; |
169 | 160 | ||
170 | /** struct zfcp_qdio - basic QDIO data structure | ||
171 | * @resp_q: response queue | ||
172 | * @req_q: request queue | ||
173 | * @stat_lock: lock to protect req_q_util and req_q_time | ||
174 | * @req_q_lock; lock to serialize access to request queue | ||
175 | * @req_q_time: time of last fill level change | ||
176 | * @req_q_util: used for accounting | ||
177 | * @req_q_full: queue full incidents | ||
178 | * @req_q_wq: used to wait for SBAL availability | ||
179 | * @adapter: adapter used in conjunction with this QDIO structure | ||
180 | */ | ||
181 | struct zfcp_qdio { | ||
182 | struct zfcp_qdio_queue resp_q; | ||
183 | struct zfcp_qdio_queue req_q; | ||
184 | spinlock_t stat_lock; | ||
185 | spinlock_t req_q_lock; | ||
186 | unsigned long long req_q_time; | ||
187 | u64 req_q_util; | ||
188 | atomic_t req_q_full; | ||
189 | wait_queue_head_t req_q_wq; | ||
190 | struct zfcp_adapter *adapter; | ||
191 | }; | ||
192 | |||
193 | struct zfcp_adapter { | 161 | struct zfcp_adapter { |
194 | struct kref ref; | 162 | struct kref ref; |
195 | u64 peer_wwnn; /* P2P peer WWNN */ | 163 | u64 peer_wwnn; /* P2P peer WWNN */ |
@@ -207,8 +175,7 @@ struct zfcp_adapter { | |||
207 | struct list_head port_list; /* remote port list */ | 175 | struct list_head port_list; /* remote port list */ |
208 | rwlock_t port_list_lock; /* port list lock */ | 176 | rwlock_t port_list_lock; /* port list lock */ |
209 | unsigned long req_no; /* unique FSF req number */ | 177 | unsigned long req_no; /* unique FSF req number */ |
210 | struct list_head *req_list; /* list of pending reqs */ | 178 | struct zfcp_reqlist *req_list; |
211 | spinlock_t req_list_lock; /* request list lock */ | ||
212 | u32 fsf_req_seq_no; /* FSF cmnd seq number */ | 179 | u32 fsf_req_seq_no; /* FSF cmnd seq number */ |
213 | rwlock_t abort_lock; /* Protects against SCSI | 180 | rwlock_t abort_lock; /* Protects against SCSI |
214 | stack abort/command | 181 | stack abort/command |
@@ -241,7 +208,7 @@ struct zfcp_adapter { | |||
241 | }; | 208 | }; |
242 | 209 | ||
243 | struct zfcp_port { | 210 | struct zfcp_port { |
244 | struct device sysfs_device; /* sysfs device */ | 211 | struct device dev; |
245 | struct fc_rport *rport; /* rport of fc transport class */ | 212 | struct fc_rport *rport; /* rport of fc transport class */ |
246 | struct list_head list; /* list of remote ports */ | 213 | struct list_head list; /* list of remote ports */ |
247 | struct zfcp_adapter *adapter; /* adapter used to access port */ | 214 | struct zfcp_adapter *adapter; /* adapter used to access port */ |
@@ -263,7 +230,7 @@ struct zfcp_port { | |||
263 | }; | 230 | }; |
264 | 231 | ||
265 | struct zfcp_unit { | 232 | struct zfcp_unit { |
266 | struct device sysfs_device; /* sysfs device */ | 233 | struct device dev; |
267 | struct list_head list; /* list of logical units */ | 234 | struct list_head list; /* list of logical units */ |
268 | struct zfcp_port *port; /* remote port of unit */ | 235 | struct zfcp_port *port; /* remote port of unit */ |
269 | atomic_t status; /* status of this logical unit */ | 236 | atomic_t status; /* status of this logical unit */ |
@@ -277,33 +244,11 @@ struct zfcp_unit { | |||
277 | }; | 244 | }; |
278 | 245 | ||
279 | /** | 246 | /** |
280 | * struct zfcp_queue_req - queue related values for a request | ||
281 | * @sbal_number: number of free SBALs | ||
282 | * @sbal_first: first SBAL for this request | ||
283 | * @sbal_last: last SBAL for this request | ||
284 | * @sbal_limit: last possible SBAL for this request | ||
285 | * @sbale_curr: current SBALE at creation of this request | ||
286 | * @sbal_response: SBAL used in interrupt | ||
287 | * @qdio_outb_usage: usage of outbound queue | ||
288 | * @qdio_inb_usage: usage of inbound queue | ||
289 | */ | ||
290 | struct zfcp_queue_req { | ||
291 | u8 sbal_number; | ||
292 | u8 sbal_first; | ||
293 | u8 sbal_last; | ||
294 | u8 sbal_limit; | ||
295 | u8 sbale_curr; | ||
296 | u8 sbal_response; | ||
297 | u16 qdio_outb_usage; | ||
298 | u16 qdio_inb_usage; | ||
299 | }; | ||
300 | |||
301 | /** | ||
302 | * struct zfcp_fsf_req - basic FSF request structure | 247 | * struct zfcp_fsf_req - basic FSF request structure |
303 | * @list: list of FSF requests | 248 | * @list: list of FSF requests |
304 | * @req_id: unique request ID | 249 | * @req_id: unique request ID |
305 | * @adapter: adapter this request belongs to | 250 | * @adapter: adapter this request belongs to |
306 | * @queue_req: queue related values | 251 | * @qdio_req: qdio queue related values |
307 | * @completion: used to signal the completion of the request | 252 | * @completion: used to signal the completion of the request |
308 | * @status: status of the request | 253 | * @status: status of the request |
309 | * @fsf_command: FSF command issued | 254 | * @fsf_command: FSF command issued |
@@ -321,7 +266,7 @@ struct zfcp_fsf_req { | |||
321 | struct list_head list; | 266 | struct list_head list; |
322 | unsigned long req_id; | 267 | unsigned long req_id; |
323 | struct zfcp_adapter *adapter; | 268 | struct zfcp_adapter *adapter; |
324 | struct zfcp_queue_req queue_req; | 269 | struct zfcp_qdio_req qdio_req; |
325 | struct completion completion; | 270 | struct completion completion; |
326 | u32 status; | 271 | u32 status; |
327 | u32 fsf_command; | 272 | u32 fsf_command; |
@@ -352,45 +297,4 @@ struct zfcp_data { | |||
352 | #define ZFCP_SET 0x00000100 | 297 | #define ZFCP_SET 0x00000100 |
353 | #define ZFCP_CLEAR 0x00000200 | 298 | #define ZFCP_CLEAR 0x00000200 |
354 | 299 | ||
355 | /* | ||
356 | * Helper functions for request ID management. | ||
357 | */ | ||
358 | static inline int zfcp_reqlist_hash(unsigned long req_id) | ||
359 | { | ||
360 | return req_id % REQUEST_LIST_SIZE; | ||
361 | } | ||
362 | |||
363 | static inline void zfcp_reqlist_remove(struct zfcp_adapter *adapter, | ||
364 | struct zfcp_fsf_req *fsf_req) | ||
365 | { | ||
366 | list_del(&fsf_req->list); | ||
367 | } | ||
368 | |||
369 | static inline struct zfcp_fsf_req * | ||
370 | zfcp_reqlist_find(struct zfcp_adapter *adapter, unsigned long req_id) | ||
371 | { | ||
372 | struct zfcp_fsf_req *request; | ||
373 | unsigned int idx; | ||
374 | |||
375 | idx = zfcp_reqlist_hash(req_id); | ||
376 | list_for_each_entry(request, &adapter->req_list[idx], list) | ||
377 | if (request->req_id == req_id) | ||
378 | return request; | ||
379 | return NULL; | ||
380 | } | ||
381 | |||
382 | static inline struct zfcp_fsf_req * | ||
383 | zfcp_reqlist_find_safe(struct zfcp_adapter *adapter, struct zfcp_fsf_req *req) | ||
384 | { | ||
385 | struct zfcp_fsf_req *request; | ||
386 | unsigned int idx; | ||
387 | |||
388 | for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) { | ||
389 | list_for_each_entry(request, &adapter->req_list[idx], list) | ||
390 | if (request == req) | ||
391 | return request; | ||
392 | } | ||
393 | return NULL; | ||
394 | } | ||
395 | |||
396 | #endif /* ZFCP_DEF_H */ | 300 | #endif /* ZFCP_DEF_H */ |
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c index b51a11a82e63..0be5e7ea2828 100644 --- a/drivers/s390/scsi/zfcp_erp.c +++ b/drivers/s390/scsi/zfcp_erp.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Error Recovery Procedures (ERP). | 4 | * Error Recovery Procedures (ERP). |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
@@ -11,6 +11,7 @@ | |||
11 | 11 | ||
12 | #include <linux/kthread.h> | 12 | #include <linux/kthread.h> |
13 | #include "zfcp_ext.h" | 13 | #include "zfcp_ext.h" |
14 | #include "zfcp_reqlist.h" | ||
14 | 15 | ||
15 | #define ZFCP_MAX_ERPS 3 | 16 | #define ZFCP_MAX_ERPS 3 |
16 | 17 | ||
@@ -174,7 +175,7 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need, | |||
174 | 175 | ||
175 | switch (need) { | 176 | switch (need) { |
176 | case ZFCP_ERP_ACTION_REOPEN_UNIT: | 177 | case ZFCP_ERP_ACTION_REOPEN_UNIT: |
177 | if (!get_device(&unit->sysfs_device)) | 178 | if (!get_device(&unit->dev)) |
178 | return NULL; | 179 | return NULL; |
179 | atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); | 180 | atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); |
180 | erp_action = &unit->erp_action; | 181 | erp_action = &unit->erp_action; |
@@ -184,7 +185,7 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need, | |||
184 | 185 | ||
185 | case ZFCP_ERP_ACTION_REOPEN_PORT: | 186 | case ZFCP_ERP_ACTION_REOPEN_PORT: |
186 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: | 187 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: |
187 | if (!get_device(&port->sysfs_device)) | 188 | if (!get_device(&port->dev)) |
188 | return NULL; | 189 | return NULL; |
189 | zfcp_erp_action_dismiss_port(port); | 190 | zfcp_erp_action_dismiss_port(port); |
190 | atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); | 191 | atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); |
@@ -478,26 +479,27 @@ static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) | |||
478 | static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act) | 479 | static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act) |
479 | { | 480 | { |
480 | struct zfcp_adapter *adapter = act->adapter; | 481 | struct zfcp_adapter *adapter = act->adapter; |
482 | struct zfcp_fsf_req *req; | ||
481 | 483 | ||
482 | if (!act->fsf_req) | 484 | if (!act->fsf_req_id) |
483 | return; | 485 | return; |
484 | 486 | ||
485 | spin_lock(&adapter->req_list_lock); | 487 | spin_lock(&adapter->req_list->lock); |
486 | if (zfcp_reqlist_find_safe(adapter, act->fsf_req) && | 488 | req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id); |
487 | act->fsf_req->erp_action == act) { | 489 | if (req && req->erp_action == act) { |
488 | if (act->status & (ZFCP_STATUS_ERP_DISMISSED | | 490 | if (act->status & (ZFCP_STATUS_ERP_DISMISSED | |
489 | ZFCP_STATUS_ERP_TIMEDOUT)) { | 491 | ZFCP_STATUS_ERP_TIMEDOUT)) { |
490 | act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; | 492 | req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; |
491 | zfcp_dbf_rec_action("erscf_1", act); | 493 | zfcp_dbf_rec_action("erscf_1", act); |
492 | act->fsf_req->erp_action = NULL; | 494 | req->erp_action = NULL; |
493 | } | 495 | } |
494 | if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) | 496 | if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) |
495 | zfcp_dbf_rec_action("erscf_2", act); | 497 | zfcp_dbf_rec_action("erscf_2", act); |
496 | if (act->fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) | 498 | if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) |
497 | act->fsf_req = NULL; | 499 | act->fsf_req_id = 0; |
498 | } else | 500 | } else |
499 | act->fsf_req = NULL; | 501 | act->fsf_req_id = 0; |
500 | spin_unlock(&adapter->req_list_lock); | 502 | spin_unlock(&adapter->req_list->lock); |
501 | } | 503 | } |
502 | 504 | ||
503 | /** | 505 | /** |
@@ -1179,19 +1181,19 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result) | |||
1179 | switch (act->action) { | 1181 | switch (act->action) { |
1180 | case ZFCP_ERP_ACTION_REOPEN_UNIT: | 1182 | case ZFCP_ERP_ACTION_REOPEN_UNIT: |
1181 | if ((result == ZFCP_ERP_SUCCEEDED) && !unit->device) { | 1183 | if ((result == ZFCP_ERP_SUCCEEDED) && !unit->device) { |
1182 | get_device(&unit->sysfs_device); | 1184 | get_device(&unit->dev); |
1183 | if (scsi_queue_work(unit->port->adapter->scsi_host, | 1185 | if (scsi_queue_work(unit->port->adapter->scsi_host, |
1184 | &unit->scsi_work) <= 0) | 1186 | &unit->scsi_work) <= 0) |
1185 | put_device(&unit->sysfs_device); | 1187 | put_device(&unit->dev); |
1186 | } | 1188 | } |
1187 | put_device(&unit->sysfs_device); | 1189 | put_device(&unit->dev); |
1188 | break; | 1190 | break; |
1189 | 1191 | ||
1190 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: | 1192 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: |
1191 | case ZFCP_ERP_ACTION_REOPEN_PORT: | 1193 | case ZFCP_ERP_ACTION_REOPEN_PORT: |
1192 | if (result == ZFCP_ERP_SUCCEEDED) | 1194 | if (result == ZFCP_ERP_SUCCEEDED) |
1193 | zfcp_scsi_schedule_rport_register(port); | 1195 | zfcp_scsi_schedule_rport_register(port); |
1194 | put_device(&port->sysfs_device); | 1196 | put_device(&port->dev); |
1195 | break; | 1197 | break; |
1196 | 1198 | ||
1197 | case ZFCP_ERP_ACTION_REOPEN_ADAPTER: | 1199 | case ZFCP_ERP_ACTION_REOPEN_ADAPTER: |
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h index 66bdb34143cb..8786a79c7f8f 100644 --- a/drivers/s390/scsi/zfcp_ext.h +++ b/drivers/s390/scsi/zfcp_ext.h | |||
@@ -21,7 +21,6 @@ extern struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *); | |||
21 | extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32, | 21 | extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32, |
22 | u32); | 22 | u32); |
23 | extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64); | 23 | extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64); |
24 | extern int zfcp_reqlist_isempty(struct zfcp_adapter *); | ||
25 | extern void zfcp_sg_free_table(struct scatterlist *, int); | 24 | extern void zfcp_sg_free_table(struct scatterlist *, int); |
26 | extern int zfcp_sg_setup_table(struct scatterlist *, int); | 25 | extern int zfcp_sg_setup_table(struct scatterlist *, int); |
27 | extern void zfcp_device_unregister(struct device *, | 26 | extern void zfcp_device_unregister(struct device *, |
@@ -144,13 +143,9 @@ extern void zfcp_fsf_reqid_check(struct zfcp_qdio *, int); | |||
144 | /* zfcp_qdio.c */ | 143 | /* zfcp_qdio.c */ |
145 | extern int zfcp_qdio_setup(struct zfcp_adapter *); | 144 | extern int zfcp_qdio_setup(struct zfcp_adapter *); |
146 | extern void zfcp_qdio_destroy(struct zfcp_qdio *); | 145 | extern void zfcp_qdio_destroy(struct zfcp_qdio *); |
147 | extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_queue_req *); | 146 | extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_qdio_req *); |
148 | extern struct qdio_buffer_element | ||
149 | *zfcp_qdio_sbale_req(struct zfcp_qdio *, struct zfcp_queue_req *); | ||
150 | extern struct qdio_buffer_element | ||
151 | *zfcp_qdio_sbale_curr(struct zfcp_qdio *, struct zfcp_queue_req *); | ||
152 | extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *, | 147 | extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *, |
153 | struct zfcp_queue_req *, unsigned long, | 148 | struct zfcp_qdio_req *, unsigned long, |
154 | struct scatterlist *, int); | 149 | struct scatterlist *, int); |
155 | extern int zfcp_qdio_open(struct zfcp_qdio *); | 150 | extern int zfcp_qdio_open(struct zfcp_qdio *); |
156 | extern void zfcp_qdio_close(struct zfcp_qdio *); | 151 | extern void zfcp_qdio_close(struct zfcp_qdio *); |
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c index 271399f62f1b..5219670f0c99 100644 --- a/drivers/s390/scsi/zfcp_fc.c +++ b/drivers/s390/scsi/zfcp_fc.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Fibre Channel related functions for the zfcp device driver. | 4 | * Fibre Channel related functions for the zfcp device driver. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2008, 2009 | 6 | * Copyright IBM Corporation 2008, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
@@ -316,7 +316,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work) | |||
316 | 316 | ||
317 | zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL); | 317 | zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL); |
318 | out: | 318 | out: |
319 | put_device(&port->sysfs_device); | 319 | put_device(&port->dev); |
320 | } | 320 | } |
321 | 321 | ||
322 | /** | 322 | /** |
@@ -325,9 +325,9 @@ out: | |||
325 | */ | 325 | */ |
326 | void zfcp_fc_trigger_did_lookup(struct zfcp_port *port) | 326 | void zfcp_fc_trigger_did_lookup(struct zfcp_port *port) |
327 | { | 327 | { |
328 | get_device(&port->sysfs_device); | 328 | get_device(&port->dev); |
329 | if (!queue_work(port->adapter->work_queue, &port->gid_pn_work)) | 329 | if (!queue_work(port->adapter->work_queue, &port->gid_pn_work)) |
330 | put_device(&port->sysfs_device); | 330 | put_device(&port->dev); |
331 | } | 331 | } |
332 | 332 | ||
333 | /** | 333 | /** |
@@ -389,7 +389,7 @@ static void zfcp_fc_adisc_handler(void *data) | |||
389 | zfcp_scsi_schedule_rport_register(port); | 389 | zfcp_scsi_schedule_rport_register(port); |
390 | out: | 390 | out: |
391 | atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); | 391 | atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); |
392 | put_device(&port->sysfs_device); | 392 | put_device(&port->dev); |
393 | kmem_cache_free(zfcp_data.adisc_cache, adisc); | 393 | kmem_cache_free(zfcp_data.adisc_cache, adisc); |
394 | } | 394 | } |
395 | 395 | ||
@@ -436,7 +436,7 @@ void zfcp_fc_link_test_work(struct work_struct *work) | |||
436 | container_of(work, struct zfcp_port, test_link_work); | 436 | container_of(work, struct zfcp_port, test_link_work); |
437 | int retval; | 437 | int retval; |
438 | 438 | ||
439 | get_device(&port->sysfs_device); | 439 | get_device(&port->dev); |
440 | port->rport_task = RPORT_DEL; | 440 | port->rport_task = RPORT_DEL; |
441 | zfcp_scsi_rport_work(&port->rport_work); | 441 | zfcp_scsi_rport_work(&port->rport_work); |
442 | 442 | ||
@@ -455,7 +455,7 @@ void zfcp_fc_link_test_work(struct work_struct *work) | |||
455 | zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL); | 455 | zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL); |
456 | 456 | ||
457 | out: | 457 | out: |
458 | put_device(&port->sysfs_device); | 458 | put_device(&port->dev); |
459 | } | 459 | } |
460 | 460 | ||
461 | /** | 461 | /** |
@@ -468,9 +468,9 @@ out: | |||
468 | */ | 468 | */ |
469 | void zfcp_fc_test_link(struct zfcp_port *port) | 469 | void zfcp_fc_test_link(struct zfcp_port *port) |
470 | { | 470 | { |
471 | get_device(&port->sysfs_device); | 471 | get_device(&port->dev); |
472 | if (!queue_work(port->adapter->work_queue, &port->test_link_work)) | 472 | if (!queue_work(port->adapter->work_queue, &port->test_link_work)) |
473 | put_device(&port->sysfs_device); | 473 | put_device(&port->dev); |
474 | } | 474 | } |
475 | 475 | ||
476 | static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num) | 476 | static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num) |
@@ -617,8 +617,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft, | |||
617 | 617 | ||
618 | list_for_each_entry_safe(port, tmp, &remove_lh, list) { | 618 | list_for_each_entry_safe(port, tmp, &remove_lh, list) { |
619 | zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL); | 619 | zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL); |
620 | zfcp_device_unregister(&port->sysfs_device, | 620 | zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); |
621 | &zfcp_sysfs_port_attrs); | ||
622 | } | 621 | } |
623 | 622 | ||
624 | return ret; | 623 | return ret; |
@@ -731,7 +730,7 @@ static int zfcp_fc_exec_els_job(struct fc_bsg_job *job, | |||
731 | return -EINVAL; | 730 | return -EINVAL; |
732 | 731 | ||
733 | d_id = port->d_id; | 732 | d_id = port->d_id; |
734 | put_device(&port->sysfs_device); | 733 | put_device(&port->dev); |
735 | } else | 734 | } else |
736 | d_id = ntoh24(job->request->rqst_data.h_els.port_id); | 735 | d_id = ntoh24(job->request->rqst_data.h_els.port_id); |
737 | 736 | ||
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c index e8fb4d9baa8b..6538742b421a 100644 --- a/drivers/s390/scsi/zfcp_fsf.c +++ b/drivers/s390/scsi/zfcp_fsf.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Implementation of FSF commands. | 4 | * Implementation of FSF commands. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
@@ -14,6 +14,8 @@ | |||
14 | #include "zfcp_ext.h" | 14 | #include "zfcp_ext.h" |
15 | #include "zfcp_fc.h" | 15 | #include "zfcp_fc.h" |
16 | #include "zfcp_dbf.h" | 16 | #include "zfcp_dbf.h" |
17 | #include "zfcp_qdio.h" | ||
18 | #include "zfcp_reqlist.h" | ||
17 | 19 | ||
18 | static void zfcp_fsf_request_timeout_handler(unsigned long data) | 20 | static void zfcp_fsf_request_timeout_handler(unsigned long data) |
19 | { | 21 | { |
@@ -393,7 +395,7 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req) | |||
393 | case FSF_PROT_LINK_DOWN: | 395 | case FSF_PROT_LINK_DOWN: |
394 | zfcp_fsf_link_down_info_eval(req, "fspse_5", | 396 | zfcp_fsf_link_down_info_eval(req, "fspse_5", |
395 | &psq->link_down_info); | 397 | &psq->link_down_info); |
396 | /* FIXME: reopening adapter now? better wait for link up */ | 398 | /* go through reopen to flush pending requests */ |
397 | zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req); | 399 | zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req); |
398 | break; | 400 | break; |
399 | case FSF_PROT_REEST_QUEUE: | 401 | case FSF_PROT_REEST_QUEUE: |
@@ -457,15 +459,10 @@ static void zfcp_fsf_req_complete(struct zfcp_fsf_req *req) | |||
457 | void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter) | 459 | void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter) |
458 | { | 460 | { |
459 | struct zfcp_fsf_req *req, *tmp; | 461 | struct zfcp_fsf_req *req, *tmp; |
460 | unsigned long flags; | ||
461 | LIST_HEAD(remove_queue); | 462 | LIST_HEAD(remove_queue); |
462 | unsigned int i; | ||
463 | 463 | ||
464 | BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP); | 464 | BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP); |
465 | spin_lock_irqsave(&adapter->req_list_lock, flags); | 465 | zfcp_reqlist_move(adapter->req_list, &remove_queue); |
466 | for (i = 0; i < REQUEST_LIST_SIZE; i++) | ||
467 | list_splice_init(&adapter->req_list[i], &remove_queue); | ||
468 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | ||
469 | 466 | ||
470 | list_for_each_entry_safe(req, tmp, &remove_queue, list) { | 467 | list_for_each_entry_safe(req, tmp, &remove_queue, list) { |
471 | list_del(&req->list); | 468 | list_del(&req->list); |
@@ -495,8 +492,6 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req) | |||
495 | fc_host_port_id(shost) = ntoh24(bottom->s_id); | 492 | fc_host_port_id(shost) = ntoh24(bottom->s_id); |
496 | fc_host_speed(shost) = bottom->fc_link_speed; | 493 | fc_host_speed(shost) = bottom->fc_link_speed; |
497 | fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3; | 494 | fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3; |
498 | fc_host_supported_fc4s(shost)[2] = 1; /* FCP */ | ||
499 | fc_host_active_fc4s(shost)[2] = 1; /* FCP */ | ||
500 | 495 | ||
501 | adapter->hydra_version = bottom->adapter_type; | 496 | adapter->hydra_version = bottom->adapter_type; |
502 | adapter->timer_ticks = bottom->timer_interval; | 497 | adapter->timer_ticks = bottom->timer_interval; |
@@ -619,6 +614,10 @@ static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req) | |||
619 | fc_host_permanent_port_name(shost) = fc_host_port_name(shost); | 614 | fc_host_permanent_port_name(shost) = fc_host_port_name(shost); |
620 | fc_host_maxframe_size(shost) = bottom->maximum_frame_size; | 615 | fc_host_maxframe_size(shost) = bottom->maximum_frame_size; |
621 | fc_host_supported_speeds(shost) = bottom->supported_speed; | 616 | fc_host_supported_speeds(shost) = bottom->supported_speed; |
617 | memcpy(fc_host_supported_fc4s(shost), bottom->supported_fc4_types, | ||
618 | FC_FC4_LIST_SIZE); | ||
619 | memcpy(fc_host_active_fc4s(shost), bottom->active_fc4_types, | ||
620 | FC_FC4_LIST_SIZE); | ||
622 | } | 621 | } |
623 | 622 | ||
624 | static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req) | 623 | static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req) |
@@ -725,12 +724,12 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio, | |||
725 | req->adapter = adapter; | 724 | req->adapter = adapter; |
726 | req->fsf_command = fsf_cmd; | 725 | req->fsf_command = fsf_cmd; |
727 | req->req_id = adapter->req_no; | 726 | req->req_id = adapter->req_no; |
728 | req->queue_req.sbal_number = 1; | 727 | req->qdio_req.sbal_number = 1; |
729 | req->queue_req.sbal_first = req_q->first; | 728 | req->qdio_req.sbal_first = req_q->first; |
730 | req->queue_req.sbal_last = req_q->first; | 729 | req->qdio_req.sbal_last = req_q->first; |
731 | req->queue_req.sbale_curr = 1; | 730 | req->qdio_req.sbale_curr = 1; |
732 | 731 | ||
733 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 732 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
734 | sbale[0].addr = (void *) req->req_id; | 733 | sbale[0].addr = (void *) req->req_id; |
735 | sbale[0].flags |= SBAL_FLAGS0_COMMAND; | 734 | sbale[0].flags |= SBAL_FLAGS0_COMMAND; |
736 | 735 | ||
@@ -745,6 +744,7 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio, | |||
745 | return ERR_PTR(-ENOMEM); | 744 | return ERR_PTR(-ENOMEM); |
746 | } | 745 | } |
747 | 746 | ||
747 | req->seq_no = adapter->fsf_req_seq_no; | ||
748 | req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; | 748 | req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; |
749 | req->qtcb->prefix.req_id = req->req_id; | 749 | req->qtcb->prefix.req_id = req->req_id; |
750 | req->qtcb->prefix.ulp_info = 26; | 750 | req->qtcb->prefix.ulp_info = 26; |
@@ -752,8 +752,6 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio, | |||
752 | req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION; | 752 | req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION; |
753 | req->qtcb->header.req_handle = req->req_id; | 753 | req->qtcb->header.req_handle = req->req_id; |
754 | req->qtcb->header.fsf_command = req->fsf_command; | 754 | req->qtcb->header.fsf_command = req->fsf_command; |
755 | req->seq_no = adapter->fsf_req_seq_no; | ||
756 | req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; | ||
757 | sbale[1].addr = (void *) req->qtcb; | 755 | sbale[1].addr = (void *) req->qtcb; |
758 | sbale[1].length = sizeof(struct fsf_qtcb); | 756 | sbale[1].length = sizeof(struct fsf_qtcb); |
759 | } | 757 | } |
@@ -770,25 +768,17 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req) | |||
770 | { | 768 | { |
771 | struct zfcp_adapter *adapter = req->adapter; | 769 | struct zfcp_adapter *adapter = req->adapter; |
772 | struct zfcp_qdio *qdio = adapter->qdio; | 770 | struct zfcp_qdio *qdio = adapter->qdio; |
773 | unsigned long flags; | 771 | int with_qtcb = (req->qtcb != NULL); |
774 | int idx; | 772 | int req_id = req->req_id; |
775 | int with_qtcb = (req->qtcb != NULL); | ||
776 | 773 | ||
777 | /* put allocated FSF request into hash table */ | 774 | zfcp_reqlist_add(adapter->req_list, req); |
778 | spin_lock_irqsave(&adapter->req_list_lock, flags); | ||
779 | idx = zfcp_reqlist_hash(req->req_id); | ||
780 | list_add_tail(&req->list, &adapter->req_list[idx]); | ||
781 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | ||
782 | 775 | ||
783 | req->queue_req.qdio_outb_usage = atomic_read(&qdio->req_q.count); | 776 | req->qdio_req.qdio_outb_usage = atomic_read(&qdio->req_q.count); |
784 | req->issued = get_clock(); | 777 | req->issued = get_clock(); |
785 | if (zfcp_qdio_send(qdio, &req->queue_req)) { | 778 | if (zfcp_qdio_send(qdio, &req->qdio_req)) { |
786 | del_timer(&req->timer); | 779 | del_timer(&req->timer); |
787 | spin_lock_irqsave(&adapter->req_list_lock, flags); | ||
788 | /* lookup request again, list might have changed */ | 780 | /* lookup request again, list might have changed */ |
789 | if (zfcp_reqlist_find_safe(adapter, req)) | 781 | zfcp_reqlist_find_rm(adapter->req_list, req_id); |
790 | zfcp_reqlist_remove(adapter, req); | ||
791 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | ||
792 | zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req); | 782 | zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req); |
793 | return -EIO; | 783 | return -EIO; |
794 | } | 784 | } |
@@ -826,9 +816,9 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio) | |||
826 | goto out; | 816 | goto out; |
827 | } | 817 | } |
828 | 818 | ||
829 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 819 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
830 | sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY; | 820 | sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY; |
831 | req->queue_req.sbale_curr = 2; | 821 | req->qdio_req.sbale_curr = 2; |
832 | 822 | ||
833 | sr_buf = mempool_alloc(adapter->pool.status_read_data, GFP_ATOMIC); | 823 | sr_buf = mempool_alloc(adapter->pool.status_read_data, GFP_ATOMIC); |
834 | if (!sr_buf) { | 824 | if (!sr_buf) { |
@@ -837,7 +827,7 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio) | |||
837 | } | 827 | } |
838 | memset(sr_buf, 0, sizeof(*sr_buf)); | 828 | memset(sr_buf, 0, sizeof(*sr_buf)); |
839 | req->data = sr_buf; | 829 | req->data = sr_buf; |
840 | sbale = zfcp_qdio_sbale_curr(qdio, &req->queue_req); | 830 | sbale = zfcp_qdio_sbale_curr(qdio, &req->qdio_req); |
841 | sbale->addr = (void *) sr_buf; | 831 | sbale->addr = (void *) sr_buf; |
842 | sbale->length = sizeof(*sr_buf); | 832 | sbale->length = sizeof(*sr_buf); |
843 | 833 | ||
@@ -934,7 +924,7 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id, | |||
934 | ZFCP_STATUS_COMMON_UNBLOCKED))) | 924 | ZFCP_STATUS_COMMON_UNBLOCKED))) |
935 | goto out_error_free; | 925 | goto out_error_free; |
936 | 926 | ||
937 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 927 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
938 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 928 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
939 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 929 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
940 | 930 | ||
@@ -1029,7 +1019,7 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req, | |||
1029 | { | 1019 | { |
1030 | struct zfcp_adapter *adapter = req->adapter; | 1020 | struct zfcp_adapter *adapter = req->adapter; |
1031 | struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(adapter->qdio, | 1021 | struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(adapter->qdio, |
1032 | &req->queue_req); | 1022 | &req->qdio_req); |
1033 | u32 feat = adapter->adapter_features; | 1023 | u32 feat = adapter->adapter_features; |
1034 | int bytes; | 1024 | int bytes; |
1035 | 1025 | ||
@@ -1047,15 +1037,15 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req, | |||
1047 | return 0; | 1037 | return 0; |
1048 | } | 1038 | } |
1049 | 1039 | ||
1050 | bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req, | 1040 | bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req, |
1051 | SBAL_FLAGS0_TYPE_WRITE_READ, | 1041 | SBAL_FLAGS0_TYPE_WRITE_READ, |
1052 | sg_req, max_sbals); | 1042 | sg_req, max_sbals); |
1053 | if (bytes <= 0) | 1043 | if (bytes <= 0) |
1054 | return -EIO; | 1044 | return -EIO; |
1055 | req->qtcb->bottom.support.req_buf_length = bytes; | 1045 | req->qtcb->bottom.support.req_buf_length = bytes; |
1056 | req->queue_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL; | 1046 | req->qdio_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL; |
1057 | 1047 | ||
1058 | bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req, | 1048 | bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req, |
1059 | SBAL_FLAGS0_TYPE_WRITE_READ, | 1049 | SBAL_FLAGS0_TYPE_WRITE_READ, |
1060 | sg_resp, max_sbals); | 1050 | sg_resp, max_sbals); |
1061 | req->qtcb->bottom.support.resp_buf_length = bytes; | 1051 | req->qtcb->bottom.support.resp_buf_length = bytes; |
@@ -1251,7 +1241,7 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action) | |||
1251 | } | 1241 | } |
1252 | 1242 | ||
1253 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1243 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1254 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1244 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1255 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1245 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1256 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1246 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1257 | 1247 | ||
@@ -1262,13 +1252,13 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action) | |||
1262 | FSF_FEATURE_UPDATE_ALERT; | 1252 | FSF_FEATURE_UPDATE_ALERT; |
1263 | req->erp_action = erp_action; | 1253 | req->erp_action = erp_action; |
1264 | req->handler = zfcp_fsf_exchange_config_data_handler; | 1254 | req->handler = zfcp_fsf_exchange_config_data_handler; |
1265 | erp_action->fsf_req = req; | 1255 | erp_action->fsf_req_id = req->req_id; |
1266 | 1256 | ||
1267 | zfcp_fsf_start_erp_timer(req); | 1257 | zfcp_fsf_start_erp_timer(req); |
1268 | retval = zfcp_fsf_req_send(req); | 1258 | retval = zfcp_fsf_req_send(req); |
1269 | if (retval) { | 1259 | if (retval) { |
1270 | zfcp_fsf_req_free(req); | 1260 | zfcp_fsf_req_free(req); |
1271 | erp_action->fsf_req = NULL; | 1261 | erp_action->fsf_req_id = 0; |
1272 | } | 1262 | } |
1273 | out: | 1263 | out: |
1274 | spin_unlock_bh(&qdio->req_q_lock); | 1264 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -1293,7 +1283,7 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio, | |||
1293 | goto out_unlock; | 1283 | goto out_unlock; |
1294 | } | 1284 | } |
1295 | 1285 | ||
1296 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1286 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1297 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1287 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1298 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1288 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1299 | req->handler = zfcp_fsf_exchange_config_data_handler; | 1289 | req->handler = zfcp_fsf_exchange_config_data_handler; |
@@ -1349,19 +1339,19 @@ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action) | |||
1349 | } | 1339 | } |
1350 | 1340 | ||
1351 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1341 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1352 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1342 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1353 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1343 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1354 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1344 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1355 | 1345 | ||
1356 | req->handler = zfcp_fsf_exchange_port_data_handler; | 1346 | req->handler = zfcp_fsf_exchange_port_data_handler; |
1357 | req->erp_action = erp_action; | 1347 | req->erp_action = erp_action; |
1358 | erp_action->fsf_req = req; | 1348 | erp_action->fsf_req_id = req->req_id; |
1359 | 1349 | ||
1360 | zfcp_fsf_start_erp_timer(req); | 1350 | zfcp_fsf_start_erp_timer(req); |
1361 | retval = zfcp_fsf_req_send(req); | 1351 | retval = zfcp_fsf_req_send(req); |
1362 | if (retval) { | 1352 | if (retval) { |
1363 | zfcp_fsf_req_free(req); | 1353 | zfcp_fsf_req_free(req); |
1364 | erp_action->fsf_req = NULL; | 1354 | erp_action->fsf_req_id = 0; |
1365 | } | 1355 | } |
1366 | out: | 1356 | out: |
1367 | spin_unlock_bh(&qdio->req_q_lock); | 1357 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -1398,7 +1388,7 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio, | |||
1398 | if (data) | 1388 | if (data) |
1399 | req->data = data; | 1389 | req->data = data; |
1400 | 1390 | ||
1401 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1391 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1402 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1392 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1403 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1393 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1404 | 1394 | ||
@@ -1484,7 +1474,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req) | |||
1484 | } | 1474 | } |
1485 | 1475 | ||
1486 | out: | 1476 | out: |
1487 | put_device(&port->sysfs_device); | 1477 | put_device(&port->dev); |
1488 | } | 1478 | } |
1489 | 1479 | ||
1490 | /** | 1480 | /** |
@@ -1513,7 +1503,7 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action) | |||
1513 | } | 1503 | } |
1514 | 1504 | ||
1515 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1505 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1516 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1506 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1517 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1507 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1518 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1508 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1519 | 1509 | ||
@@ -1521,15 +1511,15 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action) | |||
1521 | hton24(req->qtcb->bottom.support.d_id, port->d_id); | 1511 | hton24(req->qtcb->bottom.support.d_id, port->d_id); |
1522 | req->data = port; | 1512 | req->data = port; |
1523 | req->erp_action = erp_action; | 1513 | req->erp_action = erp_action; |
1524 | erp_action->fsf_req = req; | 1514 | erp_action->fsf_req_id = req->req_id; |
1525 | get_device(&port->sysfs_device); | 1515 | get_device(&port->dev); |
1526 | 1516 | ||
1527 | zfcp_fsf_start_erp_timer(req); | 1517 | zfcp_fsf_start_erp_timer(req); |
1528 | retval = zfcp_fsf_req_send(req); | 1518 | retval = zfcp_fsf_req_send(req); |
1529 | if (retval) { | 1519 | if (retval) { |
1530 | zfcp_fsf_req_free(req); | 1520 | zfcp_fsf_req_free(req); |
1531 | erp_action->fsf_req = NULL; | 1521 | erp_action->fsf_req_id = 0; |
1532 | put_device(&port->sysfs_device); | 1522 | put_device(&port->dev); |
1533 | } | 1523 | } |
1534 | out: | 1524 | out: |
1535 | spin_unlock_bh(&qdio->req_q_lock); | 1525 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -1583,7 +1573,7 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action) | |||
1583 | } | 1573 | } |
1584 | 1574 | ||
1585 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1575 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1586 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1576 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1587 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1577 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1588 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1578 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1589 | 1579 | ||
@@ -1591,13 +1581,13 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action) | |||
1591 | req->data = erp_action->port; | 1581 | req->data = erp_action->port; |
1592 | req->erp_action = erp_action; | 1582 | req->erp_action = erp_action; |
1593 | req->qtcb->header.port_handle = erp_action->port->handle; | 1583 | req->qtcb->header.port_handle = erp_action->port->handle; |
1594 | erp_action->fsf_req = req; | 1584 | erp_action->fsf_req_id = req->req_id; |
1595 | 1585 | ||
1596 | zfcp_fsf_start_erp_timer(req); | 1586 | zfcp_fsf_start_erp_timer(req); |
1597 | retval = zfcp_fsf_req_send(req); | 1587 | retval = zfcp_fsf_req_send(req); |
1598 | if (retval) { | 1588 | if (retval) { |
1599 | zfcp_fsf_req_free(req); | 1589 | zfcp_fsf_req_free(req); |
1600 | erp_action->fsf_req = NULL; | 1590 | erp_action->fsf_req_id = 0; |
1601 | } | 1591 | } |
1602 | out: | 1592 | out: |
1603 | spin_unlock_bh(&qdio->req_q_lock); | 1593 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -1660,7 +1650,7 @@ int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port) | |||
1660 | } | 1650 | } |
1661 | 1651 | ||
1662 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1652 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1663 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1653 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1664 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1654 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1665 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1655 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1666 | 1656 | ||
@@ -1715,7 +1705,7 @@ int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port) | |||
1715 | } | 1705 | } |
1716 | 1706 | ||
1717 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1707 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1718 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1708 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1719 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1709 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1720 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1710 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1721 | 1711 | ||
@@ -1809,7 +1799,7 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action) | |||
1809 | } | 1799 | } |
1810 | 1800 | ||
1811 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1801 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1812 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1802 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1813 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1803 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1814 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1804 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1815 | 1805 | ||
@@ -1817,13 +1807,13 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action) | |||
1817 | req->qtcb->header.port_handle = erp_action->port->handle; | 1807 | req->qtcb->header.port_handle = erp_action->port->handle; |
1818 | req->erp_action = erp_action; | 1808 | req->erp_action = erp_action; |
1819 | req->handler = zfcp_fsf_close_physical_port_handler; | 1809 | req->handler = zfcp_fsf_close_physical_port_handler; |
1820 | erp_action->fsf_req = req; | 1810 | erp_action->fsf_req_id = req->req_id; |
1821 | 1811 | ||
1822 | zfcp_fsf_start_erp_timer(req); | 1812 | zfcp_fsf_start_erp_timer(req); |
1823 | retval = zfcp_fsf_req_send(req); | 1813 | retval = zfcp_fsf_req_send(req); |
1824 | if (retval) { | 1814 | if (retval) { |
1825 | zfcp_fsf_req_free(req); | 1815 | zfcp_fsf_req_free(req); |
1826 | erp_action->fsf_req = NULL; | 1816 | erp_action->fsf_req_id = 0; |
1827 | } | 1817 | } |
1828 | out: | 1818 | out: |
1829 | spin_unlock_bh(&qdio->req_q_lock); | 1819 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -1982,7 +1972,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action) | |||
1982 | } | 1972 | } |
1983 | 1973 | ||
1984 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 1974 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
1985 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 1975 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
1986 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1976 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1987 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1977 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1988 | 1978 | ||
@@ -1991,7 +1981,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action) | |||
1991 | req->handler = zfcp_fsf_open_unit_handler; | 1981 | req->handler = zfcp_fsf_open_unit_handler; |
1992 | req->data = erp_action->unit; | 1982 | req->data = erp_action->unit; |
1993 | req->erp_action = erp_action; | 1983 | req->erp_action = erp_action; |
1994 | erp_action->fsf_req = req; | 1984 | erp_action->fsf_req_id = req->req_id; |
1995 | 1985 | ||
1996 | if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) | 1986 | if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) |
1997 | req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING; | 1987 | req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING; |
@@ -2000,7 +1990,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action) | |||
2000 | retval = zfcp_fsf_req_send(req); | 1990 | retval = zfcp_fsf_req_send(req); |
2001 | if (retval) { | 1991 | if (retval) { |
2002 | zfcp_fsf_req_free(req); | 1992 | zfcp_fsf_req_free(req); |
2003 | erp_action->fsf_req = NULL; | 1993 | erp_action->fsf_req_id = 0; |
2004 | } | 1994 | } |
2005 | out: | 1995 | out: |
2006 | spin_unlock_bh(&qdio->req_q_lock); | 1996 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -2068,7 +2058,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action) | |||
2068 | } | 2058 | } |
2069 | 2059 | ||
2070 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 2060 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
2071 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 2061 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
2072 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 2062 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
2073 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 2063 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
2074 | 2064 | ||
@@ -2077,13 +2067,13 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action) | |||
2077 | req->handler = zfcp_fsf_close_unit_handler; | 2067 | req->handler = zfcp_fsf_close_unit_handler; |
2078 | req->data = erp_action->unit; | 2068 | req->data = erp_action->unit; |
2079 | req->erp_action = erp_action; | 2069 | req->erp_action = erp_action; |
2080 | erp_action->fsf_req = req; | 2070 | erp_action->fsf_req_id = req->req_id; |
2081 | 2071 | ||
2082 | zfcp_fsf_start_erp_timer(req); | 2072 | zfcp_fsf_start_erp_timer(req); |
2083 | retval = zfcp_fsf_req_send(req); | 2073 | retval = zfcp_fsf_req_send(req); |
2084 | if (retval) { | 2074 | if (retval) { |
2085 | zfcp_fsf_req_free(req); | 2075 | zfcp_fsf_req_free(req); |
2086 | erp_action->fsf_req = NULL; | 2076 | erp_action->fsf_req_id = 0; |
2087 | } | 2077 | } |
2088 | out: | 2078 | out: |
2089 | spin_unlock_bh(&qdio->req_q_lock); | 2079 | spin_unlock_bh(&qdio->req_q_lock); |
@@ -2111,8 +2101,8 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi) | |||
2111 | blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC; | 2101 | blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC; |
2112 | if (req->status & ZFCP_STATUS_FSFREQ_ERROR) | 2102 | if (req->status & ZFCP_STATUS_FSFREQ_ERROR) |
2113 | blktrc.flags |= ZFCP_BLK_REQ_ERROR; | 2103 | blktrc.flags |= ZFCP_BLK_REQ_ERROR; |
2114 | blktrc.inb_usage = req->queue_req.qdio_inb_usage; | 2104 | blktrc.inb_usage = req->qdio_req.qdio_inb_usage; |
2115 | blktrc.outb_usage = req->queue_req.qdio_outb_usage; | 2105 | blktrc.outb_usage = req->qdio_req.qdio_outb_usage; |
2116 | 2106 | ||
2117 | if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) { | 2107 | if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) { |
2118 | blktrc.flags |= ZFCP_BLK_LAT_VALID; | 2108 | blktrc.flags |= ZFCP_BLK_LAT_VALID; |
@@ -2169,12 +2159,7 @@ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req) | |||
2169 | zfcp_fsf_req_trace(req, scpnt); | 2159 | zfcp_fsf_req_trace(req, scpnt); |
2170 | 2160 | ||
2171 | skip_fsfstatus: | 2161 | skip_fsfstatus: |
2172 | if (scpnt->result != 0) | 2162 | zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req); |
2173 | zfcp_dbf_scsi_result("erro", 3, req->adapter->dbf, scpnt, req); | ||
2174 | else if (scpnt->retries > 0) | ||
2175 | zfcp_dbf_scsi_result("retr", 4, req->adapter->dbf, scpnt, req); | ||
2176 | else | ||
2177 | zfcp_dbf_scsi_result("norm", 6, req->adapter->dbf, scpnt, req); | ||
2178 | 2163 | ||
2179 | scpnt->host_scribble = NULL; | 2164 | scpnt->host_scribble = NULL; |
2180 | (scpnt->scsi_done) (scpnt); | 2165 | (scpnt->scsi_done) (scpnt); |
@@ -2274,7 +2259,7 @@ skip_fsfstatus: | |||
2274 | else { | 2259 | else { |
2275 | zfcp_fsf_send_fcp_command_task_handler(req); | 2260 | zfcp_fsf_send_fcp_command_task_handler(req); |
2276 | req->unit = NULL; | 2261 | req->unit = NULL; |
2277 | put_device(&unit->sysfs_device); | 2262 | put_device(&unit->dev); |
2278 | } | 2263 | } |
2279 | } | 2264 | } |
2280 | 2265 | ||
@@ -2312,7 +2297,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit, | |||
2312 | } | 2297 | } |
2313 | 2298 | ||
2314 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; | 2299 | req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; |
2315 | get_device(&unit->sysfs_device); | 2300 | get_device(&unit->dev); |
2316 | req->unit = unit; | 2301 | req->unit = unit; |
2317 | req->data = scsi_cmnd; | 2302 | req->data = scsi_cmnd; |
2318 | req->handler = zfcp_fsf_send_fcp_command_handler; | 2303 | req->handler = zfcp_fsf_send_fcp_command_handler; |
@@ -2346,11 +2331,11 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit, | |||
2346 | fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd; | 2331 | fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd; |
2347 | zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd); | 2332 | zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd); |
2348 | 2333 | ||
2349 | real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req, sbtype, | 2334 | real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sbtype, |
2350 | scsi_sglist(scsi_cmnd), | 2335 | scsi_sglist(scsi_cmnd), |
2351 | FSF_MAX_SBALS_PER_REQ); | 2336 | FSF_MAX_SBALS_PER_REQ); |
2352 | if (unlikely(real_bytes < 0)) { | 2337 | if (unlikely(real_bytes < 0)) { |
2353 | if (req->queue_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) { | 2338 | if (req->qdio_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) { |
2354 | dev_err(&adapter->ccw_device->dev, | 2339 | dev_err(&adapter->ccw_device->dev, |
2355 | "Oversize data package, unit 0x%016Lx " | 2340 | "Oversize data package, unit 0x%016Lx " |
2356 | "on port 0x%016Lx closed\n", | 2341 | "on port 0x%016Lx closed\n", |
@@ -2369,7 +2354,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit, | |||
2369 | goto out; | 2354 | goto out; |
2370 | 2355 | ||
2371 | failed_scsi_cmnd: | 2356 | failed_scsi_cmnd: |
2372 | put_device(&unit->sysfs_device); | 2357 | put_device(&unit->dev); |
2373 | zfcp_fsf_req_free(req); | 2358 | zfcp_fsf_req_free(req); |
2374 | scsi_cmnd->host_scribble = NULL; | 2359 | scsi_cmnd->host_scribble = NULL; |
2375 | out: | 2360 | out: |
@@ -2415,7 +2400,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags) | |||
2415 | req->qtcb->bottom.io.service_class = FSF_CLASS_3; | 2400 | req->qtcb->bottom.io.service_class = FSF_CLASS_3; |
2416 | req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN; | 2401 | req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN; |
2417 | 2402 | ||
2418 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 2403 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
2419 | sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE; | 2404 | sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE; |
2420 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 2405 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
2421 | 2406 | ||
@@ -2478,14 +2463,14 @@ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter, | |||
2478 | 2463 | ||
2479 | req->handler = zfcp_fsf_control_file_handler; | 2464 | req->handler = zfcp_fsf_control_file_handler; |
2480 | 2465 | ||
2481 | sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req); | 2466 | sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req); |
2482 | sbale[0].flags |= direction; | 2467 | sbale[0].flags |= direction; |
2483 | 2468 | ||
2484 | bottom = &req->qtcb->bottom.support; | 2469 | bottom = &req->qtcb->bottom.support; |
2485 | bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE; | 2470 | bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE; |
2486 | bottom->option = fsf_cfdc->option; | 2471 | bottom->option = fsf_cfdc->option; |
2487 | 2472 | ||
2488 | bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req, | 2473 | bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, |
2489 | direction, fsf_cfdc->sg, | 2474 | direction, fsf_cfdc->sg, |
2490 | FSF_MAX_SBALS_PER_REQ); | 2475 | FSF_MAX_SBALS_PER_REQ); |
2491 | if (bytes != ZFCP_CFDC_MAX_SIZE) { | 2476 | if (bytes != ZFCP_CFDC_MAX_SIZE) { |
@@ -2516,15 +2501,14 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx) | |||
2516 | struct qdio_buffer *sbal = qdio->resp_q.sbal[sbal_idx]; | 2501 | struct qdio_buffer *sbal = qdio->resp_q.sbal[sbal_idx]; |
2517 | struct qdio_buffer_element *sbale; | 2502 | struct qdio_buffer_element *sbale; |
2518 | struct zfcp_fsf_req *fsf_req; | 2503 | struct zfcp_fsf_req *fsf_req; |
2519 | unsigned long flags, req_id; | 2504 | unsigned long req_id; |
2520 | int idx; | 2505 | int idx; |
2521 | 2506 | ||
2522 | for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) { | 2507 | for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) { |
2523 | 2508 | ||
2524 | sbale = &sbal->element[idx]; | 2509 | sbale = &sbal->element[idx]; |
2525 | req_id = (unsigned long) sbale->addr; | 2510 | req_id = (unsigned long) sbale->addr; |
2526 | spin_lock_irqsave(&adapter->req_list_lock, flags); | 2511 | fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id); |
2527 | fsf_req = zfcp_reqlist_find(adapter, req_id); | ||
2528 | 2512 | ||
2529 | if (!fsf_req) | 2513 | if (!fsf_req) |
2530 | /* | 2514 | /* |
@@ -2534,11 +2518,8 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx) | |||
2534 | panic("error: unknown req_id (%lx) on adapter %s.\n", | 2518 | panic("error: unknown req_id (%lx) on adapter %s.\n", |
2535 | req_id, dev_name(&adapter->ccw_device->dev)); | 2519 | req_id, dev_name(&adapter->ccw_device->dev)); |
2536 | 2520 | ||
2537 | list_del(&fsf_req->list); | 2521 | fsf_req->qdio_req.sbal_response = sbal_idx; |
2538 | spin_unlock_irqrestore(&adapter->req_list_lock, flags); | 2522 | fsf_req->qdio_req.qdio_inb_usage = |
2539 | |||
2540 | fsf_req->queue_req.sbal_response = sbal_idx; | ||
2541 | fsf_req->queue_req.qdio_inb_usage = | ||
2542 | atomic_read(&qdio->resp_q.count); | 2523 | atomic_read(&qdio->resp_q.count); |
2543 | zfcp_fsf_req_complete(fsf_req); | 2524 | zfcp_fsf_req_complete(fsf_req); |
2544 | 2525 | ||
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c index 6c5228b627fc..71b97ff77cf0 100644 --- a/drivers/s390/scsi/zfcp_qdio.c +++ b/drivers/s390/scsi/zfcp_qdio.c | |||
@@ -10,6 +10,7 @@ | |||
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | 10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
11 | 11 | ||
12 | #include "zfcp_ext.h" | 12 | #include "zfcp_ext.h" |
13 | #include "zfcp_qdio.h" | ||
13 | 14 | ||
14 | #define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer)) | 15 | #define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer)) |
15 | 16 | ||
@@ -28,12 +29,6 @@ static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal) | |||
28 | return 0; | 29 | return 0; |
29 | } | 30 | } |
30 | 31 | ||
31 | static struct qdio_buffer_element * | ||
32 | zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx) | ||
33 | { | ||
34 | return &q->sbal[sbal_idx]->element[sbale_idx]; | ||
35 | } | ||
36 | |||
37 | static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id) | 32 | static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id) |
38 | { | 33 | { |
39 | struct zfcp_adapter *adapter = qdio->adapter; | 34 | struct zfcp_adapter *adapter = qdio->adapter; |
@@ -106,7 +101,7 @@ static void zfcp_qdio_resp_put_back(struct zfcp_qdio *qdio, int processed) | |||
106 | 101 | ||
107 | if (unlikely(retval)) { | 102 | if (unlikely(retval)) { |
108 | atomic_set(&queue->count, count); | 103 | atomic_set(&queue->count, count); |
109 | /* FIXME: Recover this with an adapter reopen? */ | 104 | zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdrpb_1", NULL); |
110 | } else { | 105 | } else { |
111 | queue->first += count; | 106 | queue->first += count; |
112 | queue->first %= QDIO_MAX_BUFFERS_PER_Q; | 107 | queue->first %= QDIO_MAX_BUFFERS_PER_Q; |
@@ -145,32 +140,8 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err, | |||
145 | zfcp_qdio_resp_put_back(qdio, count); | 140 | zfcp_qdio_resp_put_back(qdio, count); |
146 | } | 141 | } |
147 | 142 | ||
148 | /** | ||
149 | * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req | ||
150 | * @qdio: pointer to struct zfcp_qdio | ||
151 | * @q_rec: pointer to struct zfcp_queue_rec | ||
152 | * Returns: pointer to qdio_buffer_element (SBALE) structure | ||
153 | */ | ||
154 | struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_qdio *qdio, | ||
155 | struct zfcp_queue_req *q_req) | ||
156 | { | ||
157 | return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0); | ||
158 | } | ||
159 | |||
160 | /** | ||
161 | * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req | ||
162 | * @fsf_req: pointer to struct fsf_req | ||
163 | * Returns: pointer to qdio_buffer_element (SBALE) structure | ||
164 | */ | ||
165 | struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio, | ||
166 | struct zfcp_queue_req *q_req) | ||
167 | { | ||
168 | return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, | ||
169 | q_req->sbale_curr); | ||
170 | } | ||
171 | |||
172 | static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio, | 143 | static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio, |
173 | struct zfcp_queue_req *q_req, int max_sbals) | 144 | struct zfcp_qdio_req *q_req, int max_sbals) |
174 | { | 145 | { |
175 | int count = atomic_read(&qdio->req_q.count); | 146 | int count = atomic_read(&qdio->req_q.count); |
176 | count = min(count, max_sbals); | 147 | count = min(count, max_sbals); |
@@ -179,7 +150,7 @@ static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio, | |||
179 | } | 150 | } |
180 | 151 | ||
181 | static struct qdio_buffer_element * | 152 | static struct qdio_buffer_element * |
182 | zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req, | 153 | zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req, |
183 | unsigned long sbtype) | 154 | unsigned long sbtype) |
184 | { | 155 | { |
185 | struct qdio_buffer_element *sbale; | 156 | struct qdio_buffer_element *sbale; |
@@ -214,7 +185,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req, | |||
214 | } | 185 | } |
215 | 186 | ||
216 | static struct qdio_buffer_element * | 187 | static struct qdio_buffer_element * |
217 | zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req, | 188 | zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req, |
218 | unsigned int sbtype) | 189 | unsigned int sbtype) |
219 | { | 190 | { |
220 | if (q_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL) | 191 | if (q_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL) |
@@ -224,7 +195,7 @@ zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req, | |||
224 | } | 195 | } |
225 | 196 | ||
226 | static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio, | 197 | static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio, |
227 | struct zfcp_queue_req *q_req) | 198 | struct zfcp_qdio_req *q_req) |
228 | { | 199 | { |
229 | struct qdio_buffer **sbal = qdio->req_q.sbal; | 200 | struct qdio_buffer **sbal = qdio->req_q.sbal; |
230 | int first = q_req->sbal_first; | 201 | int first = q_req->sbal_first; |
@@ -235,7 +206,7 @@ static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio, | |||
235 | } | 206 | } |
236 | 207 | ||
237 | static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio, | 208 | static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio, |
238 | struct zfcp_queue_req *q_req, | 209 | struct zfcp_qdio_req *q_req, |
239 | unsigned int sbtype, void *start_addr, | 210 | unsigned int sbtype, void *start_addr, |
240 | unsigned int total_length) | 211 | unsigned int total_length) |
241 | { | 212 | { |
@@ -271,8 +242,7 @@ static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio, | |||
271 | * @max_sbals: upper bound for number of SBALs to be used | 242 | * @max_sbals: upper bound for number of SBALs to be used |
272 | * Returns: number of bytes, or error (negativ) | 243 | * Returns: number of bytes, or error (negativ) |
273 | */ | 244 | */ |
274 | int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, | 245 | int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req, |
275 | struct zfcp_queue_req *q_req, | ||
276 | unsigned long sbtype, struct scatterlist *sg, | 246 | unsigned long sbtype, struct scatterlist *sg, |
277 | int max_sbals) | 247 | int max_sbals) |
278 | { | 248 | { |
@@ -304,10 +274,10 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, | |||
304 | /** | 274 | /** |
305 | * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO | 275 | * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO |
306 | * @qdio: pointer to struct zfcp_qdio | 276 | * @qdio: pointer to struct zfcp_qdio |
307 | * @q_req: pointer to struct zfcp_queue_req | 277 | * @q_req: pointer to struct zfcp_qdio_req |
308 | * Returns: 0 on success, error otherwise | 278 | * Returns: 0 on success, error otherwise |
309 | */ | 279 | */ |
310 | int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req) | 280 | int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req) |
311 | { | 281 | { |
312 | struct zfcp_qdio_queue *req_q = &qdio->req_q; | 282 | struct zfcp_qdio_queue *req_q = &qdio->req_q; |
313 | int first = q_req->sbal_first; | 283 | int first = q_req->sbal_first; |
diff --git a/drivers/s390/scsi/zfcp_qdio.h b/drivers/s390/scsi/zfcp_qdio.h new file mode 100644 index 000000000000..8cca54631e1e --- /dev/null +++ b/drivers/s390/scsi/zfcp_qdio.h | |||
@@ -0,0 +1,109 @@ | |||
1 | /* | ||
2 | * zfcp device driver | ||
3 | * | ||
4 | * Header file for zfcp qdio interface | ||
5 | * | ||
6 | * Copyright IBM Corporation 2010 | ||
7 | */ | ||
8 | |||
9 | #ifndef ZFCP_QDIO_H | ||
10 | #define ZFCP_QDIO_H | ||
11 | |||
12 | #include <asm/qdio.h> | ||
13 | |||
14 | /** | ||
15 | * struct zfcp_qdio_queue - qdio queue buffer, zfcp index and free count | ||
16 | * @sbal: qdio buffers | ||
17 | * @first: index of next free buffer in queue | ||
18 | * @count: number of free buffers in queue | ||
19 | */ | ||
20 | struct zfcp_qdio_queue { | ||
21 | struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q]; | ||
22 | u8 first; | ||
23 | atomic_t count; | ||
24 | }; | ||
25 | |||
26 | /** | ||
27 | * struct zfcp_qdio - basic qdio data structure | ||
28 | * @resp_q: response queue | ||
29 | * @req_q: request queue | ||
30 | * @stat_lock: lock to protect req_q_util and req_q_time | ||
31 | * @req_q_lock: lock to serialize access to request queue | ||
32 | * @req_q_time: time of last fill level change | ||
33 | * @req_q_util: used for accounting | ||
34 | * @req_q_full: queue full incidents | ||
35 | * @req_q_wq: used to wait for SBAL availability | ||
36 | * @adapter: adapter used in conjunction with this qdio structure | ||
37 | */ | ||
38 | struct zfcp_qdio { | ||
39 | struct zfcp_qdio_queue resp_q; | ||
40 | struct zfcp_qdio_queue req_q; | ||
41 | spinlock_t stat_lock; | ||
42 | spinlock_t req_q_lock; | ||
43 | unsigned long long req_q_time; | ||
44 | u64 req_q_util; | ||
45 | atomic_t req_q_full; | ||
46 | wait_queue_head_t req_q_wq; | ||
47 | struct zfcp_adapter *adapter; | ||
48 | }; | ||
49 | |||
50 | /** | ||
51 | * struct zfcp_qdio_req - qdio queue related values for a request | ||
52 | * @sbal_number: number of free sbals | ||
53 | * @sbal_first: first sbal for this request | ||
54 | * @sbal_last: last sbal for this request | ||
55 | * @sbal_limit: last possible sbal for this request | ||
56 | * @sbale_curr: current sbale at creation of this request | ||
57 | * @sbal_response: sbal used in interrupt | ||
58 | * @qdio_outb_usage: usage of outbound queue | ||
59 | * @qdio_inb_usage: usage of inbound queue | ||
60 | */ | ||
61 | struct zfcp_qdio_req { | ||
62 | u8 sbal_number; | ||
63 | u8 sbal_first; | ||
64 | u8 sbal_last; | ||
65 | u8 sbal_limit; | ||
66 | u8 sbale_curr; | ||
67 | u8 sbal_response; | ||
68 | u16 qdio_outb_usage; | ||
69 | u16 qdio_inb_usage; | ||
70 | }; | ||
71 | |||
72 | /** | ||
73 | * zfcp_qdio_sbale - return pointer to sbale in qdio queue | ||
74 | * @q: queue where to find sbal | ||
75 | * @sbal_idx: sbal index in queue | ||
76 | * @sbale_idx: sbale index in sbal | ||
77 | */ | ||
78 | static inline struct qdio_buffer_element * | ||
79 | zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx) | ||
80 | { | ||
81 | return &q->sbal[sbal_idx]->element[sbale_idx]; | ||
82 | } | ||
83 | |||
84 | /** | ||
85 | * zfcp_qdio_sbale_req - return pointer to sbale on req_q for a request | ||
86 | * @qdio: pointer to struct zfcp_qdio | ||
87 | * @q_rec: pointer to struct zfcp_qdio_req | ||
88 | * Returns: pointer to qdio_buffer_element (sbale) structure | ||
89 | */ | ||
90 | static inline struct qdio_buffer_element * | ||
91 | zfcp_qdio_sbale_req(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req) | ||
92 | { | ||
93 | return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0); | ||
94 | } | ||
95 | |||
96 | /** | ||
97 | * zfcp_qdio_sbale_curr - return current sbale on req_q for a request | ||
98 | * @qdio: pointer to struct zfcp_qdio | ||
99 | * @fsf_req: pointer to struct zfcp_fsf_req | ||
100 | * Returns: pointer to qdio_buffer_element (sbale) structure | ||
101 | */ | ||
102 | static inline struct qdio_buffer_element * | ||
103 | zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req) | ||
104 | { | ||
105 | return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, | ||
106 | q_req->sbale_curr); | ||
107 | } | ||
108 | |||
109 | #endif /* ZFCP_QDIO_H */ | ||
diff --git a/drivers/s390/scsi/zfcp_reqlist.h b/drivers/s390/scsi/zfcp_reqlist.h new file mode 100644 index 000000000000..a72d1b730aba --- /dev/null +++ b/drivers/s390/scsi/zfcp_reqlist.h | |||
@@ -0,0 +1,183 @@ | |||
1 | /* | ||
2 | * zfcp device driver | ||
3 | * | ||
4 | * Data structure and helper functions for tracking pending FSF | ||
5 | * requests. | ||
6 | * | ||
7 | * Copyright IBM Corporation 2009 | ||
8 | */ | ||
9 | |||
10 | #ifndef ZFCP_REQLIST_H | ||
11 | #define ZFCP_REQLIST_H | ||
12 | |||
13 | /* number of hash buckets */ | ||
14 | #define ZFCP_REQ_LIST_BUCKETS 128 | ||
15 | |||
16 | /** | ||
17 | * struct zfcp_reqlist - Container for request list (reqlist) | ||
18 | * @lock: Spinlock for protecting the hash list | ||
19 | * @list: Array of hashbuckets, each is a list of requests in this bucket | ||
20 | */ | ||
21 | struct zfcp_reqlist { | ||
22 | spinlock_t lock; | ||
23 | struct list_head buckets[ZFCP_REQ_LIST_BUCKETS]; | ||
24 | }; | ||
25 | |||
26 | static inline int zfcp_reqlist_hash(unsigned long req_id) | ||
27 | { | ||
28 | return req_id % ZFCP_REQ_LIST_BUCKETS; | ||
29 | } | ||
30 | |||
31 | /** | ||
32 | * zfcp_reqlist_alloc - Allocate and initialize reqlist | ||
33 | * | ||
34 | * Returns pointer to allocated reqlist on success, or NULL on | ||
35 | * allocation failure. | ||
36 | */ | ||
37 | static inline struct zfcp_reqlist *zfcp_reqlist_alloc(void) | ||
38 | { | ||
39 | unsigned int i; | ||
40 | struct zfcp_reqlist *rl; | ||
41 | |||
42 | rl = kzalloc(sizeof(struct zfcp_reqlist), GFP_KERNEL); | ||
43 | if (!rl) | ||
44 | return NULL; | ||
45 | |||
46 | spin_lock_init(&rl->lock); | ||
47 | |||
48 | for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++) | ||
49 | INIT_LIST_HEAD(&rl->buckets[i]); | ||
50 | |||
51 | return rl; | ||
52 | } | ||
53 | |||
54 | /** | ||
55 | * zfcp_reqlist_isempty - Check whether the request list empty | ||
56 | * @rl: pointer to reqlist | ||
57 | * | ||
58 | * Returns: 1 if list is empty, 0 if not | ||
59 | */ | ||
60 | static inline int zfcp_reqlist_isempty(struct zfcp_reqlist *rl) | ||
61 | { | ||
62 | unsigned int i; | ||
63 | |||
64 | for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++) | ||
65 | if (!list_empty(&rl->buckets[i])) | ||
66 | return 0; | ||
67 | return 1; | ||
68 | } | ||
69 | |||
70 | /** | ||
71 | * zfcp_reqlist_free - Free allocated memory for reqlist | ||
72 | * @rl: The reqlist where to free memory | ||
73 | */ | ||
74 | static inline void zfcp_reqlist_free(struct zfcp_reqlist *rl) | ||
75 | { | ||
76 | /* sanity check */ | ||
77 | BUG_ON(!zfcp_reqlist_isempty(rl)); | ||
78 | |||
79 | kfree(rl); | ||
80 | } | ||
81 | |||
82 | static inline struct zfcp_fsf_req * | ||
83 | _zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id) | ||
84 | { | ||
85 | struct zfcp_fsf_req *req; | ||
86 | unsigned int i; | ||
87 | |||
88 | i = zfcp_reqlist_hash(req_id); | ||
89 | list_for_each_entry(req, &rl->buckets[i], list) | ||
90 | if (req->req_id == req_id) | ||
91 | return req; | ||
92 | return NULL; | ||
93 | } | ||
94 | |||
95 | /** | ||
96 | * zfcp_reqlist_find - Lookup FSF request by its request id | ||
97 | * @rl: The reqlist where to lookup the FSF request | ||
98 | * @req_id: The request id to look for | ||
99 | * | ||
100 | * Returns a pointer to the FSF request with the specified request id | ||
101 | * or NULL if there is no known FSF request with this id. | ||
102 | */ | ||
103 | static inline struct zfcp_fsf_req * | ||
104 | zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id) | ||
105 | { | ||
106 | unsigned long flags; | ||
107 | struct zfcp_fsf_req *req; | ||
108 | |||
109 | spin_lock_irqsave(&rl->lock, flags); | ||
110 | req = _zfcp_reqlist_find(rl, req_id); | ||
111 | spin_unlock_irqrestore(&rl->lock, flags); | ||
112 | |||
113 | return req; | ||
114 | } | ||
115 | |||
116 | /** | ||
117 | * zfcp_reqlist_find_rm - Lookup request by id and remove it from reqlist | ||
118 | * @rl: reqlist where to search and remove entry | ||
119 | * @req_id: The request id of the request to look for | ||
120 | * | ||
121 | * This functions tries to find the FSF request with the specified | ||
122 | * id and then removes it from the reqlist. The reqlist lock is held | ||
123 | * during both steps of the operation. | ||
124 | * | ||
125 | * Returns: Pointer to the FSF request if the request has been found, | ||
126 | * NULL if it has not been found. | ||
127 | */ | ||
128 | static inline struct zfcp_fsf_req * | ||
129 | zfcp_reqlist_find_rm(struct zfcp_reqlist *rl, unsigned long req_id) | ||
130 | { | ||
131 | unsigned long flags; | ||
132 | struct zfcp_fsf_req *req; | ||
133 | |||
134 | spin_lock_irqsave(&rl->lock, flags); | ||
135 | req = _zfcp_reqlist_find(rl, req_id); | ||
136 | if (req) | ||
137 | list_del(&req->list); | ||
138 | spin_unlock_irqrestore(&rl->lock, flags); | ||
139 | |||
140 | return req; | ||
141 | } | ||
142 | |||
143 | /** | ||
144 | * zfcp_reqlist_add - Add entry to reqlist | ||
145 | * @rl: reqlist where to add the entry | ||
146 | * @req: The entry to add | ||
147 | * | ||
148 | * The request id always increases. As an optimization new requests | ||
149 | * are added here with list_add_tail at the end of the bucket lists | ||
150 | * while old requests are looked up starting at the beginning of the | ||
151 | * lists. | ||
152 | */ | ||
153 | static inline void zfcp_reqlist_add(struct zfcp_reqlist *rl, | ||
154 | struct zfcp_fsf_req *req) | ||
155 | { | ||
156 | unsigned int i; | ||
157 | unsigned long flags; | ||
158 | |||
159 | i = zfcp_reqlist_hash(req->req_id); | ||
160 | |||
161 | spin_lock_irqsave(&rl->lock, flags); | ||
162 | list_add_tail(&req->list, &rl->buckets[i]); | ||
163 | spin_unlock_irqrestore(&rl->lock, flags); | ||
164 | } | ||
165 | |||
166 | /** | ||
167 | * zfcp_reqlist_move - Move all entries from reqlist to simple list | ||
168 | * @rl: The zfcp_reqlist where to remove all entries | ||
169 | * @list: The list where to move all entries | ||
170 | */ | ||
171 | static inline void zfcp_reqlist_move(struct zfcp_reqlist *rl, | ||
172 | struct list_head *list) | ||
173 | { | ||
174 | unsigned int i; | ||
175 | unsigned long flags; | ||
176 | |||
177 | spin_lock_irqsave(&rl->lock, flags); | ||
178 | for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++) | ||
179 | list_splice_init(&rl->buckets[i], list); | ||
180 | spin_unlock_irqrestore(&rl->lock, flags); | ||
181 | } | ||
182 | |||
183 | #endif /* ZFCP_REQLIST_H */ | ||
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c index 8e6fc68d6bd4..c3c4178888af 100644 --- a/drivers/s390/scsi/zfcp_scsi.c +++ b/drivers/s390/scsi/zfcp_scsi.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * Interface to Linux SCSI midlayer. | 4 | * Interface to Linux SCSI midlayer. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2002, 2009 | 6 | * Copyright IBM Corporation 2002, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
@@ -15,6 +15,7 @@ | |||
15 | #include "zfcp_ext.h" | 15 | #include "zfcp_ext.h" |
16 | #include "zfcp_dbf.h" | 16 | #include "zfcp_dbf.h" |
17 | #include "zfcp_fc.h" | 17 | #include "zfcp_fc.h" |
18 | #include "zfcp_reqlist.h" | ||
18 | 19 | ||
19 | static unsigned int default_depth = 32; | 20 | static unsigned int default_depth = 32; |
20 | module_param_named(queue_depth, default_depth, uint, 0600); | 21 | module_param_named(queue_depth, default_depth, uint, 0600); |
@@ -43,7 +44,7 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt) | |||
43 | { | 44 | { |
44 | struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata; | 45 | struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata; |
45 | unit->device = NULL; | 46 | unit->device = NULL; |
46 | put_device(&unit->sysfs_device); | 47 | put_device(&unit->dev); |
47 | } | 48 | } |
48 | 49 | ||
49 | static int zfcp_scsi_slave_configure(struct scsi_device *sdp) | 50 | static int zfcp_scsi_slave_configure(struct scsi_device *sdp) |
@@ -59,10 +60,9 @@ static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) | |||
59 | { | 60 | { |
60 | struct zfcp_adapter *adapter = | 61 | struct zfcp_adapter *adapter = |
61 | (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; | 62 | (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; |
63 | |||
62 | set_host_byte(scpnt, result); | 64 | set_host_byte(scpnt, result); |
63 | if ((scpnt->device != NULL) && (scpnt->device->host != NULL)) | 65 | zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt); |
64 | zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL); | ||
65 | /* return directly */ | ||
66 | scpnt->scsi_done(scpnt); | 66 | scpnt->scsi_done(scpnt); |
67 | } | 67 | } |
68 | 68 | ||
@@ -86,18 +86,10 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt, | |||
86 | adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; | 86 | adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; |
87 | unit = scpnt->device->hostdata; | 87 | unit = scpnt->device->hostdata; |
88 | 88 | ||
89 | BUG_ON(!adapter || (adapter != unit->port->adapter)); | ||
90 | BUG_ON(!scpnt->scsi_done); | ||
91 | |||
92 | if (unlikely(!unit)) { | ||
93 | zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); | ||
94 | return 0; | ||
95 | } | ||
96 | |||
97 | scsi_result = fc_remote_port_chkready(rport); | 89 | scsi_result = fc_remote_port_chkready(rport); |
98 | if (unlikely(scsi_result)) { | 90 | if (unlikely(scsi_result)) { |
99 | scpnt->result = scsi_result; | 91 | scpnt->result = scsi_result; |
100 | zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL); | 92 | zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt); |
101 | scpnt->scsi_done(scpnt); | 93 | scpnt->scsi_done(scpnt); |
102 | return 0; | 94 | return 0; |
103 | } | 95 | } |
@@ -189,9 +181,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) | |||
189 | /* avoid race condition between late normal completion and abort */ | 181 | /* avoid race condition between late normal completion and abort */ |
190 | write_lock_irqsave(&adapter->abort_lock, flags); | 182 | write_lock_irqsave(&adapter->abort_lock, flags); |
191 | 183 | ||
192 | spin_lock(&adapter->req_list_lock); | 184 | old_req = zfcp_reqlist_find(adapter->req_list, old_reqid); |
193 | old_req = zfcp_reqlist_find(adapter, old_reqid); | ||
194 | spin_unlock(&adapter->req_list_lock); | ||
195 | if (!old_req) { | 185 | if (!old_req) { |
196 | write_unlock_irqrestore(&adapter->abort_lock, flags); | 186 | write_unlock_irqrestore(&adapter->abort_lock, flags); |
197 | zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL, | 187 | zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL, |
@@ -521,7 +511,7 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport) | |||
521 | 511 | ||
522 | if (port) { | 512 | if (port) { |
523 | zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL); | 513 | zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL); |
524 | put_device(&port->sysfs_device); | 514 | put_device(&port->dev); |
525 | } | 515 | } |
526 | } | 516 | } |
527 | 517 | ||
@@ -563,23 +553,23 @@ static void zfcp_scsi_rport_block(struct zfcp_port *port) | |||
563 | 553 | ||
564 | void zfcp_scsi_schedule_rport_register(struct zfcp_port *port) | 554 | void zfcp_scsi_schedule_rport_register(struct zfcp_port *port) |
565 | { | 555 | { |
566 | get_device(&port->sysfs_device); | 556 | get_device(&port->dev); |
567 | port->rport_task = RPORT_ADD; | 557 | port->rport_task = RPORT_ADD; |
568 | 558 | ||
569 | if (!queue_work(port->adapter->work_queue, &port->rport_work)) | 559 | if (!queue_work(port->adapter->work_queue, &port->rport_work)) |
570 | put_device(&port->sysfs_device); | 560 | put_device(&port->dev); |
571 | } | 561 | } |
572 | 562 | ||
573 | void zfcp_scsi_schedule_rport_block(struct zfcp_port *port) | 563 | void zfcp_scsi_schedule_rport_block(struct zfcp_port *port) |
574 | { | 564 | { |
575 | get_device(&port->sysfs_device); | 565 | get_device(&port->dev); |
576 | port->rport_task = RPORT_DEL; | 566 | port->rport_task = RPORT_DEL; |
577 | 567 | ||
578 | if (port->rport && queue_work(port->adapter->work_queue, | 568 | if (port->rport && queue_work(port->adapter->work_queue, |
579 | &port->rport_work)) | 569 | &port->rport_work)) |
580 | return; | 570 | return; |
581 | 571 | ||
582 | put_device(&port->sysfs_device); | 572 | put_device(&port->dev); |
583 | } | 573 | } |
584 | 574 | ||
585 | void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter) | 575 | void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter) |
@@ -608,7 +598,7 @@ void zfcp_scsi_rport_work(struct work_struct *work) | |||
608 | } | 598 | } |
609 | } | 599 | } |
610 | 600 | ||
611 | put_device(&port->sysfs_device); | 601 | put_device(&port->dev); |
612 | } | 602 | } |
613 | 603 | ||
614 | 604 | ||
@@ -626,7 +616,7 @@ void zfcp_scsi_scan(struct work_struct *work) | |||
626 | scsilun_to_int((struct scsi_lun *) | 616 | scsilun_to_int((struct scsi_lun *) |
627 | &unit->fcp_lun), 0); | 617 | &unit->fcp_lun), 0); |
628 | 618 | ||
629 | put_device(&unit->sysfs_device); | 619 | put_device(&unit->dev); |
630 | } | 620 | } |
631 | 621 | ||
632 | struct fc_function_template zfcp_transport_functions = { | 622 | struct fc_function_template zfcp_transport_functions = { |
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c index f539e006683c..a43035d4bd70 100644 --- a/drivers/s390/scsi/zfcp_sysfs.c +++ b/drivers/s390/scsi/zfcp_sysfs.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * sysfs attributes. | 4 | * sysfs attributes. |
5 | * | 5 | * |
6 | * Copyright IBM Corporation 2008, 2009 | 6 | * Copyright IBM Corporation 2008, 2010 |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #define KMSG_COMPONENT "zfcp" | 9 | #define KMSG_COMPONENT "zfcp" |
@@ -19,8 +19,7 @@ static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev, \ | |||
19 | struct device_attribute *at,\ | 19 | struct device_attribute *at,\ |
20 | char *buf) \ | 20 | char *buf) \ |
21 | { \ | 21 | { \ |
22 | struct _feat_def *_feat = container_of(dev, struct _feat_def, \ | 22 | struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \ |
23 | sysfs_device); \ | ||
24 | \ | 23 | \ |
25 | return sprintf(buf, _format, _value); \ | 24 | return sprintf(buf, _format, _value); \ |
26 | } \ | 25 | } \ |
@@ -87,8 +86,7 @@ static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev, \ | |||
87 | struct device_attribute *attr, \ | 86 | struct device_attribute *attr, \ |
88 | char *buf) \ | 87 | char *buf) \ |
89 | { \ | 88 | { \ |
90 | struct _feat_def *_feat = container_of(dev, struct _feat_def, \ | 89 | struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \ |
91 | sysfs_device); \ | ||
92 | \ | 90 | \ |
93 | if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED) \ | 91 | if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED) \ |
94 | return sprintf(buf, "1\n"); \ | 92 | return sprintf(buf, "1\n"); \ |
@@ -99,12 +97,11 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev, \ | |||
99 | struct device_attribute *attr,\ | 97 | struct device_attribute *attr,\ |
100 | const char *buf, size_t count)\ | 98 | const char *buf, size_t count)\ |
101 | { \ | 99 | { \ |
102 | struct _feat_def *_feat = container_of(dev, struct _feat_def, \ | 100 | struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \ |
103 | sysfs_device); \ | ||
104 | unsigned long val; \ | 101 | unsigned long val; \ |
105 | int retval = 0; \ | 102 | int retval = 0; \ |
106 | \ | 103 | \ |
107 | if (!(_feat && get_device(&_feat->sysfs_device))) \ | 104 | if (!(_feat && get_device(&_feat->dev))) \ |
108 | return -EBUSY; \ | 105 | return -EBUSY; \ |
109 | \ | 106 | \ |
110 | if (strict_strtoul(buf, 0, &val) || val != 0) { \ | 107 | if (strict_strtoul(buf, 0, &val) || val != 0) { \ |
@@ -118,7 +115,7 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev, \ | |||
118 | _reopen_id, NULL); \ | 115 | _reopen_id, NULL); \ |
119 | zfcp_erp_wait(_adapter); \ | 116 | zfcp_erp_wait(_adapter); \ |
120 | out: \ | 117 | out: \ |
121 | put_device(&_feat->sysfs_device); \ | 118 | put_device(&_feat->dev); \ |
122 | return retval ? retval : (ssize_t) count; \ | 119 | return retval ? retval : (ssize_t) count; \ |
123 | } \ | 120 | } \ |
124 | static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO, \ | 121 | static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO, \ |
@@ -224,10 +221,10 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev, | |||
224 | list_del(&port->list); | 221 | list_del(&port->list); |
225 | write_unlock_irq(&adapter->port_list_lock); | 222 | write_unlock_irq(&adapter->port_list_lock); |
226 | 223 | ||
227 | put_device(&port->sysfs_device); | 224 | put_device(&port->dev); |
228 | 225 | ||
229 | zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL); | 226 | zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL); |
230 | zfcp_device_unregister(&port->sysfs_device, &zfcp_sysfs_port_attrs); | 227 | zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); |
231 | out: | 228 | out: |
232 | zfcp_ccw_adapter_put(adapter); | 229 | zfcp_ccw_adapter_put(adapter); |
233 | return retval ? retval : (ssize_t) count; | 230 | return retval ? retval : (ssize_t) count; |
@@ -258,13 +255,12 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev, | |||
258 | struct device_attribute *attr, | 255 | struct device_attribute *attr, |
259 | const char *buf, size_t count) | 256 | const char *buf, size_t count) |
260 | { | 257 | { |
261 | struct zfcp_port *port = container_of(dev, struct zfcp_port, | 258 | struct zfcp_port *port = container_of(dev, struct zfcp_port, dev); |
262 | sysfs_device); | ||
263 | struct zfcp_unit *unit; | 259 | struct zfcp_unit *unit; |
264 | u64 fcp_lun; | 260 | u64 fcp_lun; |
265 | int retval = -EINVAL; | 261 | int retval = -EINVAL; |
266 | 262 | ||
267 | if (!(port && get_device(&port->sysfs_device))) | 263 | if (!(port && get_device(&port->dev))) |
268 | return -EBUSY; | 264 | return -EBUSY; |
269 | 265 | ||
270 | if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) | 266 | if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) |
@@ -280,7 +276,7 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev, | |||
280 | zfcp_erp_wait(unit->port->adapter); | 276 | zfcp_erp_wait(unit->port->adapter); |
281 | flush_work(&unit->scsi_work); | 277 | flush_work(&unit->scsi_work); |
282 | out: | 278 | out: |
283 | put_device(&port->sysfs_device); | 279 | put_device(&port->dev); |
284 | return retval ? retval : (ssize_t) count; | 280 | return retval ? retval : (ssize_t) count; |
285 | } | 281 | } |
286 | static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store); | 282 | static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store); |
@@ -289,13 +285,12 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev, | |||
289 | struct device_attribute *attr, | 285 | struct device_attribute *attr, |
290 | const char *buf, size_t count) | 286 | const char *buf, size_t count) |
291 | { | 287 | { |
292 | struct zfcp_port *port = container_of(dev, struct zfcp_port, | 288 | struct zfcp_port *port = container_of(dev, struct zfcp_port, dev); |
293 | sysfs_device); | ||
294 | struct zfcp_unit *unit; | 289 | struct zfcp_unit *unit; |
295 | u64 fcp_lun; | 290 | u64 fcp_lun; |
296 | int retval = -EINVAL; | 291 | int retval = -EINVAL; |
297 | 292 | ||
298 | if (!(port && get_device(&port->sysfs_device))) | 293 | if (!(port && get_device(&port->dev))) |
299 | return -EBUSY; | 294 | return -EBUSY; |
300 | 295 | ||
301 | if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) | 296 | if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) |
@@ -314,12 +309,12 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev, | |||
314 | list_del(&unit->list); | 309 | list_del(&unit->list); |
315 | write_unlock_irq(&port->unit_list_lock); | 310 | write_unlock_irq(&port->unit_list_lock); |
316 | 311 | ||
317 | put_device(&unit->sysfs_device); | 312 | put_device(&unit->dev); |
318 | 313 | ||
319 | zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL); | 314 | zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL); |
320 | zfcp_device_unregister(&unit->sysfs_device, &zfcp_sysfs_unit_attrs); | 315 | zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs); |
321 | out: | 316 | out: |
322 | put_device(&port->sysfs_device); | 317 | put_device(&port->dev); |
323 | return retval ? retval : (ssize_t) count; | 318 | return retval ? retval : (ssize_t) count; |
324 | } | 319 | } |
325 | static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store); | 320 | static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store); |