diff options
author | Linus Torvalds <torvalds@g5.osdl.org> | 2005-09-20 11:50:49 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@g5.osdl.org> | 2005-09-20 11:50:49 -0400 |
commit | 9600c11ba3602be161cd376f1460f3de561fc299 (patch) | |
tree | d071c2427a8f7ad601aec6d8ae76b0f61410becf /drivers/s390 | |
parent | 676d55ae30ea3b688f0386f70553489f25f24d55 (diff) | |
parent | 13e1e1f08c1c098c7574c1fa72bd8c67792dc89b (diff) |
Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-for-linus-2.6
Diffstat (limited to 'drivers/s390')
-rw-r--r-- | drivers/s390/scsi/Makefile | 2 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_aux.c | 184 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_ccw.c | 10 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_dbf.c | 995 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_def.h | 307 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_erp.c | 135 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_ext.h | 30 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_fsf.c | 769 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_fsf.h | 54 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_qdio.c | 30 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_scsi.c | 297 | ||||
-rw-r--r-- | drivers/s390/scsi/zfcp_sysfs_adapter.c | 14 |
12 files changed, 1822 insertions, 1005 deletions
diff --git a/drivers/s390/scsi/Makefile b/drivers/s390/scsi/Makefile index fc145307a7d4..d6a78f1a2f16 100644 --- a/drivers/s390/scsi/Makefile +++ b/drivers/s390/scsi/Makefile | |||
@@ -3,7 +3,7 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_scsi.o zfcp_erp.o zfcp_qdio.o \ | 5 | zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_scsi.o zfcp_erp.o zfcp_qdio.o \ |
6 | zfcp_fsf.o zfcp_sysfs_adapter.o zfcp_sysfs_port.o \ | 6 | zfcp_fsf.o zfcp_dbf.o zfcp_sysfs_adapter.o zfcp_sysfs_port.o \ |
7 | zfcp_sysfs_unit.o zfcp_sysfs_driver.o | 7 | zfcp_sysfs_unit.o zfcp_sysfs_driver.o |
8 | 8 | ||
9 | obj-$(CONFIG_ZFCP) += zfcp.o | 9 | obj-$(CONFIG_ZFCP) += zfcp.o |
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c index bfe3ba73bc0f..0b5087f7cabc 100644 --- a/drivers/s390/scsi/zfcp_aux.c +++ b/drivers/s390/scsi/zfcp_aux.c | |||
@@ -122,95 +122,6 @@ _zfcp_hex_dump(char *addr, int count) | |||
122 | 122 | ||
123 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER | 123 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER |
124 | 124 | ||
125 | static inline int | ||
126 | zfcp_fsf_req_is_scsi_cmnd(struct zfcp_fsf_req *fsf_req) | ||
127 | { | ||
128 | return ((fsf_req->fsf_command == FSF_QTCB_FCP_CMND) && | ||
129 | !(fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)); | ||
130 | } | ||
131 | |||
132 | void | ||
133 | zfcp_cmd_dbf_event_fsf(const char *text, struct zfcp_fsf_req *fsf_req, | ||
134 | void *add_data, int add_length) | ||
135 | { | ||
136 | struct zfcp_adapter *adapter = fsf_req->adapter; | ||
137 | struct scsi_cmnd *scsi_cmnd; | ||
138 | int level = 3; | ||
139 | int i; | ||
140 | unsigned long flags; | ||
141 | |||
142 | spin_lock_irqsave(&adapter->dbf_lock, flags); | ||
143 | if (zfcp_fsf_req_is_scsi_cmnd(fsf_req)) { | ||
144 | scsi_cmnd = fsf_req->data.send_fcp_command_task.scsi_cmnd; | ||
145 | debug_text_event(adapter->cmd_dbf, level, "fsferror"); | ||
146 | debug_text_event(adapter->cmd_dbf, level, text); | ||
147 | debug_event(adapter->cmd_dbf, level, &fsf_req, | ||
148 | sizeof (unsigned long)); | ||
149 | debug_event(adapter->cmd_dbf, level, &fsf_req->seq_no, | ||
150 | sizeof (u32)); | ||
151 | debug_event(adapter->cmd_dbf, level, &scsi_cmnd, | ||
152 | sizeof (unsigned long)); | ||
153 | debug_event(adapter->cmd_dbf, level, &scsi_cmnd->cmnd, | ||
154 | min(ZFCP_CMD_DBF_LENGTH, (int)scsi_cmnd->cmd_len)); | ||
155 | for (i = 0; i < add_length; i += ZFCP_CMD_DBF_LENGTH) | ||
156 | debug_event(adapter->cmd_dbf, | ||
157 | level, | ||
158 | (char *) add_data + i, | ||
159 | min(ZFCP_CMD_DBF_LENGTH, add_length - i)); | ||
160 | } | ||
161 | spin_unlock_irqrestore(&adapter->dbf_lock, flags); | ||
162 | } | ||
163 | |||
164 | /* XXX additionally log unit if available */ | ||
165 | /* ---> introduce new parameter for unit, see 2.4 code */ | ||
166 | void | ||
167 | zfcp_cmd_dbf_event_scsi(const char *text, struct scsi_cmnd *scsi_cmnd) | ||
168 | { | ||
169 | struct zfcp_adapter *adapter; | ||
170 | union zfcp_req_data *req_data; | ||
171 | struct zfcp_fsf_req *fsf_req; | ||
172 | int level = ((host_byte(scsi_cmnd->result) != 0) ? 1 : 5); | ||
173 | unsigned long flags; | ||
174 | |||
175 | adapter = (struct zfcp_adapter *) scsi_cmnd->device->host->hostdata[0]; | ||
176 | req_data = (union zfcp_req_data *) scsi_cmnd->host_scribble; | ||
177 | fsf_req = (req_data ? req_data->send_fcp_command_task.fsf_req : NULL); | ||
178 | spin_lock_irqsave(&adapter->dbf_lock, flags); | ||
179 | debug_text_event(adapter->cmd_dbf, level, "hostbyte"); | ||
180 | debug_text_event(adapter->cmd_dbf, level, text); | ||
181 | debug_event(adapter->cmd_dbf, level, &scsi_cmnd->result, sizeof (u32)); | ||
182 | debug_event(adapter->cmd_dbf, level, &scsi_cmnd, | ||
183 | sizeof (unsigned long)); | ||
184 | debug_event(adapter->cmd_dbf, level, &scsi_cmnd->cmnd, | ||
185 | min(ZFCP_CMD_DBF_LENGTH, (int)scsi_cmnd->cmd_len)); | ||
186 | if (likely(fsf_req)) { | ||
187 | debug_event(adapter->cmd_dbf, level, &fsf_req, | ||
188 | sizeof (unsigned long)); | ||
189 | debug_event(adapter->cmd_dbf, level, &fsf_req->seq_no, | ||
190 | sizeof (u32)); | ||
191 | } else { | ||
192 | debug_text_event(adapter->cmd_dbf, level, ""); | ||
193 | debug_text_event(adapter->cmd_dbf, level, ""); | ||
194 | } | ||
195 | spin_unlock_irqrestore(&adapter->dbf_lock, flags); | ||
196 | } | ||
197 | |||
198 | void | ||
199 | zfcp_in_els_dbf_event(struct zfcp_adapter *adapter, const char *text, | ||
200 | struct fsf_status_read_buffer *status_buffer, int length) | ||
201 | { | ||
202 | int level = 1; | ||
203 | int i; | ||
204 | |||
205 | debug_text_event(adapter->in_els_dbf, level, text); | ||
206 | debug_event(adapter->in_els_dbf, level, &status_buffer->d_id, 8); | ||
207 | for (i = 0; i < length; i += ZFCP_IN_ELS_DBF_LENGTH) | ||
208 | debug_event(adapter->in_els_dbf, | ||
209 | level, | ||
210 | (char *) status_buffer->payload + i, | ||
211 | min(ZFCP_IN_ELS_DBF_LENGTH, length - i)); | ||
212 | } | ||
213 | |||
214 | /** | 125 | /** |
215 | * zfcp_device_setup - setup function | 126 | * zfcp_device_setup - setup function |
216 | * @str: pointer to parameter string | 127 | * @str: pointer to parameter string |
@@ -1017,81 +928,6 @@ zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) | |||
1017 | mempool_destroy(adapter->pool.data_gid_pn); | 928 | mempool_destroy(adapter->pool.data_gid_pn); |
1018 | } | 929 | } |
1019 | 930 | ||
1020 | /** | ||
1021 | * zfcp_adapter_debug_register - registers debug feature for an adapter | ||
1022 | * @adapter: pointer to adapter for which debug features should be registered | ||
1023 | * return: -ENOMEM on error, 0 otherwise | ||
1024 | */ | ||
1025 | int | ||
1026 | zfcp_adapter_debug_register(struct zfcp_adapter *adapter) | ||
1027 | { | ||
1028 | char dbf_name[20]; | ||
1029 | |||
1030 | /* debug feature area which records SCSI command failures (hostbyte) */ | ||
1031 | spin_lock_init(&adapter->dbf_lock); | ||
1032 | |||
1033 | sprintf(dbf_name, ZFCP_CMD_DBF_NAME "%s", | ||
1034 | zfcp_get_busid_by_adapter(adapter)); | ||
1035 | adapter->cmd_dbf = debug_register(dbf_name, ZFCP_CMD_DBF_INDEX, | ||
1036 | ZFCP_CMD_DBF_AREAS, | ||
1037 | ZFCP_CMD_DBF_LENGTH); | ||
1038 | debug_register_view(adapter->cmd_dbf, &debug_hex_ascii_view); | ||
1039 | debug_set_level(adapter->cmd_dbf, ZFCP_CMD_DBF_LEVEL); | ||
1040 | |||
1041 | /* debug feature area which records SCSI command aborts */ | ||
1042 | sprintf(dbf_name, ZFCP_ABORT_DBF_NAME "%s", | ||
1043 | zfcp_get_busid_by_adapter(adapter)); | ||
1044 | adapter->abort_dbf = debug_register(dbf_name, ZFCP_ABORT_DBF_INDEX, | ||
1045 | ZFCP_ABORT_DBF_AREAS, | ||
1046 | ZFCP_ABORT_DBF_LENGTH); | ||
1047 | debug_register_view(adapter->abort_dbf, &debug_hex_ascii_view); | ||
1048 | debug_set_level(adapter->abort_dbf, ZFCP_ABORT_DBF_LEVEL); | ||
1049 | |||
1050 | /* debug feature area which records incoming ELS commands */ | ||
1051 | sprintf(dbf_name, ZFCP_IN_ELS_DBF_NAME "%s", | ||
1052 | zfcp_get_busid_by_adapter(adapter)); | ||
1053 | adapter->in_els_dbf = debug_register(dbf_name, ZFCP_IN_ELS_DBF_INDEX, | ||
1054 | ZFCP_IN_ELS_DBF_AREAS, | ||
1055 | ZFCP_IN_ELS_DBF_LENGTH); | ||
1056 | debug_register_view(adapter->in_els_dbf, &debug_hex_ascii_view); | ||
1057 | debug_set_level(adapter->in_els_dbf, ZFCP_IN_ELS_DBF_LEVEL); | ||
1058 | |||
1059 | /* debug feature area which records erp events */ | ||
1060 | sprintf(dbf_name, ZFCP_ERP_DBF_NAME "%s", | ||
1061 | zfcp_get_busid_by_adapter(adapter)); | ||
1062 | adapter->erp_dbf = debug_register(dbf_name, ZFCP_ERP_DBF_INDEX, | ||
1063 | ZFCP_ERP_DBF_AREAS, | ||
1064 | ZFCP_ERP_DBF_LENGTH); | ||
1065 | debug_register_view(adapter->erp_dbf, &debug_hex_ascii_view); | ||
1066 | debug_set_level(adapter->erp_dbf, ZFCP_ERP_DBF_LEVEL); | ||
1067 | |||
1068 | if (!(adapter->cmd_dbf && adapter->abort_dbf && | ||
1069 | adapter->in_els_dbf && adapter->erp_dbf)) { | ||
1070 | zfcp_adapter_debug_unregister(adapter); | ||
1071 | return -ENOMEM; | ||
1072 | } | ||
1073 | |||
1074 | return 0; | ||
1075 | |||
1076 | } | ||
1077 | |||
1078 | /** | ||
1079 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | ||
1080 | * @adapter: pointer to adapter for which debug features should be unregistered | ||
1081 | */ | ||
1082 | void | ||
1083 | zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter) | ||
1084 | { | ||
1085 | debug_unregister(adapter->abort_dbf); | ||
1086 | debug_unregister(adapter->cmd_dbf); | ||
1087 | debug_unregister(adapter->erp_dbf); | ||
1088 | debug_unregister(adapter->in_els_dbf); | ||
1089 | adapter->abort_dbf = NULL; | ||
1090 | adapter->cmd_dbf = NULL; | ||
1091 | adapter->erp_dbf = NULL; | ||
1092 | adapter->in_els_dbf = NULL; | ||
1093 | } | ||
1094 | |||
1095 | void | 931 | void |
1096 | zfcp_dummy_release(struct device *dev) | 932 | zfcp_dummy_release(struct device *dev) |
1097 | { | 933 | { |
@@ -1462,10 +1298,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter, | |||
1462 | /* see FC-FS */ | 1298 | /* see FC-FS */ |
1463 | no_entries = (fcp_rscn_head->payload_len / 4); | 1299 | no_entries = (fcp_rscn_head->payload_len / 4); |
1464 | 1300 | ||
1465 | zfcp_in_els_dbf_event(adapter, "##rscn", status_buffer, | ||
1466 | fcp_rscn_head->payload_len); | ||
1467 | |||
1468 | debug_text_event(adapter->erp_dbf, 1, "unsol_els_rscn:"); | ||
1469 | for (i = 1; i < no_entries; i++) { | 1301 | for (i = 1; i < no_entries; i++) { |
1470 | /* skip head and start with 1st element */ | 1302 | /* skip head and start with 1st element */ |
1471 | fcp_rscn_element++; | 1303 | fcp_rscn_element++; |
@@ -1497,8 +1329,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter, | |||
1497 | (ZFCP_STATUS_PORT_DID_DID, &port->status)) { | 1329 | (ZFCP_STATUS_PORT_DID_DID, &port->status)) { |
1498 | ZFCP_LOG_INFO("incoming RSCN, trying to open " | 1330 | ZFCP_LOG_INFO("incoming RSCN, trying to open " |
1499 | "port 0x%016Lx\n", port->wwpn); | 1331 | "port 0x%016Lx\n", port->wwpn); |
1500 | debug_text_event(adapter->erp_dbf, 1, | ||
1501 | "unsol_els_rscnu:"); | ||
1502 | zfcp_erp_port_reopen(port, | 1332 | zfcp_erp_port_reopen(port, |
1503 | ZFCP_STATUS_COMMON_ERP_FAILED); | 1333 | ZFCP_STATUS_COMMON_ERP_FAILED); |
1504 | continue; | 1334 | continue; |
@@ -1524,8 +1354,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter, | |||
1524 | */ | 1354 | */ |
1525 | ZFCP_LOG_INFO("incoming RSCN, trying to open " | 1355 | ZFCP_LOG_INFO("incoming RSCN, trying to open " |
1526 | "port 0x%016Lx\n", port->wwpn); | 1356 | "port 0x%016Lx\n", port->wwpn); |
1527 | debug_text_event(adapter->erp_dbf, 1, | ||
1528 | "unsol_els_rscnk:"); | ||
1529 | zfcp_test_link(port); | 1357 | zfcp_test_link(port); |
1530 | } | 1358 | } |
1531 | } | 1359 | } |
@@ -1541,8 +1369,6 @@ zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter, | |||
1541 | struct zfcp_port *port; | 1369 | struct zfcp_port *port; |
1542 | unsigned long flags; | 1370 | unsigned long flags; |
1543 | 1371 | ||
1544 | zfcp_in_els_dbf_event(adapter, "##plogi", status_buffer, 28); | ||
1545 | |||
1546 | read_lock_irqsave(&zfcp_data.config_lock, flags); | 1372 | read_lock_irqsave(&zfcp_data.config_lock, flags); |
1547 | list_for_each_entry(port, &adapter->port_list_head, list) { | 1373 | list_for_each_entry(port, &adapter->port_list_head, list) { |
1548 | if (port->wwpn == (*(wwn_t *) & els_logi->nport_wwn)) | 1374 | if (port->wwpn == (*(wwn_t *) & els_logi->nport_wwn)) |
@@ -1556,8 +1382,6 @@ zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter, | |||
1556 | status_buffer->d_id, | 1382 | status_buffer->d_id, |
1557 | zfcp_get_busid_by_adapter(adapter)); | 1383 | zfcp_get_busid_by_adapter(adapter)); |
1558 | } else { | 1384 | } else { |
1559 | debug_text_event(adapter->erp_dbf, 1, "unsol_els_plogi:"); | ||
1560 | debug_event(adapter->erp_dbf, 1, &els_logi->nport_wwn, 8); | ||
1561 | zfcp_erp_port_forced_reopen(port, 0); | 1385 | zfcp_erp_port_forced_reopen(port, 0); |
1562 | } | 1386 | } |
1563 | } | 1387 | } |
@@ -1570,8 +1394,6 @@ zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter, | |||
1570 | struct zfcp_port *port; | 1394 | struct zfcp_port *port; |
1571 | unsigned long flags; | 1395 | unsigned long flags; |
1572 | 1396 | ||
1573 | zfcp_in_els_dbf_event(adapter, "##logo", status_buffer, 16); | ||
1574 | |||
1575 | read_lock_irqsave(&zfcp_data.config_lock, flags); | 1397 | read_lock_irqsave(&zfcp_data.config_lock, flags); |
1576 | list_for_each_entry(port, &adapter->port_list_head, list) { | 1398 | list_for_each_entry(port, &adapter->port_list_head, list) { |
1577 | if (port->wwpn == els_logo->nport_wwpn) | 1399 | if (port->wwpn == els_logo->nport_wwpn) |
@@ -1585,8 +1407,6 @@ zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter, | |||
1585 | status_buffer->d_id, | 1407 | status_buffer->d_id, |
1586 | zfcp_get_busid_by_adapter(adapter)); | 1408 | zfcp_get_busid_by_adapter(adapter)); |
1587 | } else { | 1409 | } else { |
1588 | debug_text_event(adapter->erp_dbf, 1, "unsol_els_logo:"); | ||
1589 | debug_event(adapter->erp_dbf, 1, &els_logo->nport_wwpn, 8); | ||
1590 | zfcp_erp_port_forced_reopen(port, 0); | 1410 | zfcp_erp_port_forced_reopen(port, 0); |
1591 | } | 1411 | } |
1592 | } | 1412 | } |
@@ -1595,7 +1415,6 @@ static void | |||
1595 | zfcp_fsf_incoming_els_unknown(struct zfcp_adapter *adapter, | 1415 | zfcp_fsf_incoming_els_unknown(struct zfcp_adapter *adapter, |
1596 | struct fsf_status_read_buffer *status_buffer) | 1416 | struct fsf_status_read_buffer *status_buffer) |
1597 | { | 1417 | { |
1598 | zfcp_in_els_dbf_event(adapter, "##undef", status_buffer, 24); | ||
1599 | ZFCP_LOG_NORMAL("warning: unknown incoming ELS 0x%08x " | 1418 | ZFCP_LOG_NORMAL("warning: unknown incoming ELS 0x%08x " |
1600 | "for adapter %s\n", *(u32 *) (status_buffer->payload), | 1419 | "for adapter %s\n", *(u32 *) (status_buffer->payload), |
1601 | zfcp_get_busid_by_adapter(adapter)); | 1420 | zfcp_get_busid_by_adapter(adapter)); |
@@ -1609,10 +1428,11 @@ zfcp_fsf_incoming_els(struct zfcp_fsf_req *fsf_req) | |||
1609 | u32 els_type; | 1428 | u32 els_type; |
1610 | struct zfcp_adapter *adapter; | 1429 | struct zfcp_adapter *adapter; |
1611 | 1430 | ||
1612 | status_buffer = fsf_req->data.status_read.buffer; | 1431 | status_buffer = (struct fsf_status_read_buffer *) fsf_req->data; |
1613 | els_type = *(u32 *) (status_buffer->payload); | 1432 | els_type = *(u32 *) (status_buffer->payload); |
1614 | adapter = fsf_req->adapter; | 1433 | adapter = fsf_req->adapter; |
1615 | 1434 | ||
1435 | zfcp_san_dbf_event_incoming_els(fsf_req); | ||
1616 | if (els_type == LS_PLOGI) | 1436 | if (els_type == LS_PLOGI) |
1617 | zfcp_fsf_incoming_els_plogi(adapter, status_buffer); | 1437 | zfcp_fsf_incoming_els_plogi(adapter, status_buffer); |
1618 | else if (els_type == LS_LOGO) | 1438 | else if (els_type == LS_LOGO) |
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c index b30abab77da3..0fc46381fc22 100644 --- a/drivers/s390/scsi/zfcp_ccw.c +++ b/drivers/s390/scsi/zfcp_ccw.c | |||
@@ -202,19 +202,9 @@ static int | |||
202 | zfcp_ccw_set_offline(struct ccw_device *ccw_device) | 202 | zfcp_ccw_set_offline(struct ccw_device *ccw_device) |
203 | { | 203 | { |
204 | struct zfcp_adapter *adapter; | 204 | struct zfcp_adapter *adapter; |
205 | struct zfcp_port *port; | ||
206 | struct fc_rport *rport; | ||
207 | 205 | ||
208 | down(&zfcp_data.config_sema); | 206 | down(&zfcp_data.config_sema); |
209 | adapter = dev_get_drvdata(&ccw_device->dev); | 207 | adapter = dev_get_drvdata(&ccw_device->dev); |
210 | /* might be racy, but we cannot take config_lock due to the fact that | ||
211 | fc_remote_port_delete might sleep */ | ||
212 | list_for_each_entry(port, &adapter->port_list_head, list) | ||
213 | if (port->rport) { | ||
214 | rport = port->rport; | ||
215 | port->rport = NULL; | ||
216 | fc_remote_port_delete(rport); | ||
217 | } | ||
218 | zfcp_erp_adapter_shutdown(adapter, 0); | 208 | zfcp_erp_adapter_shutdown(adapter, 0); |
219 | zfcp_erp_wait(adapter); | 209 | zfcp_erp_wait(adapter); |
220 | zfcp_adapter_scsi_unregister(adapter); | 210 | zfcp_adapter_scsi_unregister(adapter); |
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c new file mode 100644 index 000000000000..826fb3b00605 --- /dev/null +++ b/drivers/s390/scsi/zfcp_dbf.c | |||
@@ -0,0 +1,995 @@ | |||
1 | /* | ||
2 | * | ||
3 | * linux/drivers/s390/scsi/zfcp_dbf.c | ||
4 | * | ||
5 | * FCP adapter driver for IBM eServer zSeries | ||
6 | * | ||
7 | * Debugging facilities | ||
8 | * | ||
9 | * (C) Copyright IBM Corp. 2005 | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation; either version 2, or (at your option) | ||
14 | * any later version. | ||
15 | * | ||
16 | * This program is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with this program; if not, write to the Free Software | ||
23 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
24 | */ | ||
25 | |||
26 | #define ZFCP_DBF_REVISION "$Revision$" | ||
27 | |||
28 | #include <asm/debug.h> | ||
29 | #include <linux/ctype.h> | ||
30 | #include "zfcp_ext.h" | ||
31 | |||
32 | static u32 dbfsize = 4; | ||
33 | |||
34 | module_param(dbfsize, uint, 0400); | ||
35 | MODULE_PARM_DESC(dbfsize, | ||
36 | "number of pages for each debug feature area (default 4)"); | ||
37 | |||
38 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER | ||
39 | |||
40 | static inline int | ||
41 | zfcp_dbf_stck(char *out_buf, const char *label, unsigned long long stck) | ||
42 | { | ||
43 | unsigned long long sec; | ||
44 | struct timespec xtime; | ||
45 | int len = 0; | ||
46 | |||
47 | stck -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096); | ||
48 | sec = stck >> 12; | ||
49 | do_div(sec, 1000000); | ||
50 | xtime.tv_sec = sec; | ||
51 | stck -= (sec * 1000000) << 12; | ||
52 | xtime.tv_nsec = ((stck * 1000) >> 12); | ||
53 | len += sprintf(out_buf + len, "%-24s%011lu:%06lu\n", | ||
54 | label, xtime.tv_sec, xtime.tv_nsec); | ||
55 | |||
56 | return len; | ||
57 | } | ||
58 | |||
59 | static int zfcp_dbf_tag(char *out_buf, const char *label, const char *tag) | ||
60 | { | ||
61 | int len = 0, i; | ||
62 | |||
63 | len += sprintf(out_buf + len, "%-24s", label); | ||
64 | for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++) | ||
65 | len += sprintf(out_buf + len, "%c", tag[i]); | ||
66 | len += sprintf(out_buf + len, "\n"); | ||
67 | |||
68 | return len; | ||
69 | } | ||
70 | |||
71 | static int | ||
72 | zfcp_dbf_view(char *out_buf, const char *label, const char *format, ...) | ||
73 | { | ||
74 | va_list arg; | ||
75 | int len = 0; | ||
76 | |||
77 | len += sprintf(out_buf + len, "%-24s", label); | ||
78 | va_start(arg, format); | ||
79 | len += vsprintf(out_buf + len, format, arg); | ||
80 | va_end(arg); | ||
81 | len += sprintf(out_buf + len, "\n"); | ||
82 | |||
83 | return len; | ||
84 | } | ||
85 | |||
86 | static int | ||
87 | zfcp_dbf_view_dump(char *out_buf, const char *label, | ||
88 | char *buffer, int buflen, int offset, int total_size) | ||
89 | { | ||
90 | int len = 0; | ||
91 | |||
92 | if (offset == 0) | ||
93 | len += sprintf(out_buf + len, "%-24s ", label); | ||
94 | |||
95 | while (buflen--) { | ||
96 | if (offset > 0) { | ||
97 | if ((offset % 32) == 0) | ||
98 | len += sprintf(out_buf + len, "\n%-24c ", ' '); | ||
99 | else if ((offset % 4) == 0) | ||
100 | len += sprintf(out_buf + len, " "); | ||
101 | } | ||
102 | len += sprintf(out_buf + len, "%02x", *buffer++); | ||
103 | if (++offset == total_size) { | ||
104 | len += sprintf(out_buf + len, "\n"); | ||
105 | break; | ||
106 | } | ||
107 | } | ||
108 | |||
109 | if (total_size == 0) | ||
110 | len += sprintf(out_buf + len, "\n"); | ||
111 | |||
112 | return len; | ||
113 | } | ||
114 | |||
115 | static inline int | ||
116 | zfcp_dbf_view_header(debug_info_t * id, struct debug_view *view, int area, | ||
117 | debug_entry_t * entry, char *out_buf) | ||
118 | { | ||
119 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry); | ||
120 | int len = 0; | ||
121 | |||
122 | if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) { | ||
123 | len += zfcp_dbf_stck(out_buf + len, "timestamp", | ||
124 | entry->id.stck); | ||
125 | len += zfcp_dbf_view(out_buf + len, "cpu", "%02i", | ||
126 | entry->id.fields.cpuid); | ||
127 | } else { | ||
128 | len += zfcp_dbf_view_dump(out_buf + len, NULL, | ||
129 | dump->data, | ||
130 | dump->size, | ||
131 | dump->offset, dump->total_size); | ||
132 | if ((dump->offset + dump->size) == dump->total_size) | ||
133 | len += sprintf(out_buf + len, "\n"); | ||
134 | } | ||
135 | |||
136 | return len; | ||
137 | } | ||
138 | |||
139 | inline void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req) | ||
140 | { | ||
141 | struct zfcp_adapter *adapter = fsf_req->adapter; | ||
142 | struct fsf_qtcb *qtcb = fsf_req->qtcb; | ||
143 | union fsf_prot_status_qual *prot_status_qual = | ||
144 | &qtcb->prefix.prot_status_qual; | ||
145 | union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; | ||
146 | struct scsi_cmnd *scsi_cmnd; | ||
147 | struct zfcp_port *port; | ||
148 | struct zfcp_unit *unit; | ||
149 | struct zfcp_send_els *send_els; | ||
150 | struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf; | ||
151 | struct zfcp_hba_dbf_record_response *response = &rec->type.response; | ||
152 | int level; | ||
153 | unsigned long flags; | ||
154 | |||
155 | spin_lock_irqsave(&adapter->hba_dbf_lock, flags); | ||
156 | memset(rec, 0, sizeof(struct zfcp_hba_dbf_record)); | ||
157 | strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); | ||
158 | |||
159 | if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) && | ||
160 | (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) { | ||
161 | strncpy(rec->tag2, "perr", ZFCP_DBF_TAG_SIZE); | ||
162 | level = 1; | ||
163 | } else if (qtcb->header.fsf_status != FSF_GOOD) { | ||
164 | strncpy(rec->tag2, "ferr", ZFCP_DBF_TAG_SIZE); | ||
165 | level = 1; | ||
166 | } else if ((fsf_req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) || | ||
167 | (fsf_req->fsf_command == FSF_QTCB_OPEN_LUN)) { | ||
168 | strncpy(rec->tag2, "open", ZFCP_DBF_TAG_SIZE); | ||
169 | level = 4; | ||
170 | } else if ((prot_status_qual->doubleword[0] != 0) || | ||
171 | (prot_status_qual->doubleword[1] != 0) || | ||
172 | (fsf_status_qual->doubleword[0] != 0) || | ||
173 | (fsf_status_qual->doubleword[1] != 0)) { | ||
174 | strncpy(rec->tag2, "qual", ZFCP_DBF_TAG_SIZE); | ||
175 | level = 3; | ||
176 | } else { | ||
177 | strncpy(rec->tag2, "norm", ZFCP_DBF_TAG_SIZE); | ||
178 | level = 6; | ||
179 | } | ||
180 | |||
181 | response->fsf_command = fsf_req->fsf_command; | ||
182 | response->fsf_reqid = (unsigned long)fsf_req; | ||
183 | response->fsf_seqno = fsf_req->seq_no; | ||
184 | response->fsf_issued = fsf_req->issued; | ||
185 | response->fsf_prot_status = qtcb->prefix.prot_status; | ||
186 | response->fsf_status = qtcb->header.fsf_status; | ||
187 | memcpy(response->fsf_prot_status_qual, | ||
188 | prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE); | ||
189 | memcpy(response->fsf_status_qual, | ||
190 | fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); | ||
191 | response->fsf_req_status = fsf_req->status; | ||
192 | response->sbal_first = fsf_req->sbal_first; | ||
193 | response->sbal_curr = fsf_req->sbal_curr; | ||
194 | response->sbal_last = fsf_req->sbal_last; | ||
195 | response->pool = fsf_req->pool != NULL; | ||
196 | response->erp_action = (unsigned long)fsf_req->erp_action; | ||
197 | |||
198 | switch (fsf_req->fsf_command) { | ||
199 | case FSF_QTCB_FCP_CMND: | ||
200 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) | ||
201 | break; | ||
202 | scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; | ||
203 | if (scsi_cmnd != NULL) { | ||
204 | response->data.send_fcp.scsi_cmnd | ||
205 | = (unsigned long)scsi_cmnd; | ||
206 | response->data.send_fcp.scsi_serial | ||
207 | = scsi_cmnd->serial_number; | ||
208 | } | ||
209 | break; | ||
210 | |||
211 | case FSF_QTCB_OPEN_PORT_WITH_DID: | ||
212 | case FSF_QTCB_CLOSE_PORT: | ||
213 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | ||
214 | port = (struct zfcp_port *)fsf_req->data; | ||
215 | response->data.port.wwpn = port->wwpn; | ||
216 | response->data.port.d_id = port->d_id; | ||
217 | response->data.port.port_handle = qtcb->header.port_handle; | ||
218 | break; | ||
219 | |||
220 | case FSF_QTCB_OPEN_LUN: | ||
221 | case FSF_QTCB_CLOSE_LUN: | ||
222 | unit = (struct zfcp_unit *)fsf_req->data; | ||
223 | port = unit->port; | ||
224 | response->data.unit.wwpn = port->wwpn; | ||
225 | response->data.unit.fcp_lun = unit->fcp_lun; | ||
226 | response->data.unit.port_handle = qtcb->header.port_handle; | ||
227 | response->data.unit.lun_handle = qtcb->header.lun_handle; | ||
228 | break; | ||
229 | |||
230 | case FSF_QTCB_SEND_ELS: | ||
231 | send_els = (struct zfcp_send_els *)fsf_req->data; | ||
232 | response->data.send_els.d_id = qtcb->bottom.support.d_id; | ||
233 | response->data.send_els.ls_code = send_els->ls_code >> 24; | ||
234 | break; | ||
235 | |||
236 | case FSF_QTCB_ABORT_FCP_CMND: | ||
237 | case FSF_QTCB_SEND_GENERIC: | ||
238 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | ||
239 | case FSF_QTCB_EXCHANGE_PORT_DATA: | ||
240 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | ||
241 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | ||
242 | break; | ||
243 | } | ||
244 | |||
245 | debug_event(adapter->hba_dbf, level, | ||
246 | rec, sizeof(struct zfcp_hba_dbf_record)); | ||
247 | spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); | ||
248 | } | ||
249 | |||
250 | inline void | ||
251 | zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter, | ||
252 | struct fsf_status_read_buffer *status_buffer) | ||
253 | { | ||
254 | struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf; | ||
255 | unsigned long flags; | ||
256 | |||
257 | spin_lock_irqsave(&adapter->hba_dbf_lock, flags); | ||
258 | memset(rec, 0, sizeof(struct zfcp_hba_dbf_record)); | ||
259 | strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); | ||
260 | strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); | ||
261 | |||
262 | rec->type.status.failed = adapter->status_read_failed; | ||
263 | if (status_buffer != NULL) { | ||
264 | rec->type.status.status_type = status_buffer->status_type; | ||
265 | rec->type.status.status_subtype = status_buffer->status_subtype; | ||
266 | memcpy(&rec->type.status.queue_designator, | ||
267 | &status_buffer->queue_designator, | ||
268 | sizeof(struct fsf_queue_designator)); | ||
269 | |||
270 | switch (status_buffer->status_type) { | ||
271 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: | ||
272 | rec->type.status.payload_size = | ||
273 | ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; | ||
274 | break; | ||
275 | |||
276 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: | ||
277 | rec->type.status.payload_size = | ||
278 | ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; | ||
279 | break; | ||
280 | |||
281 | case FSF_STATUS_READ_LINK_DOWN: | ||
282 | switch (status_buffer->status_subtype) { | ||
283 | case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: | ||
284 | case FSF_STATUS_READ_SUB_FDISC_FAILED: | ||
285 | rec->type.status.payload_size = | ||
286 | sizeof(struct fsf_link_down_info); | ||
287 | } | ||
288 | break; | ||
289 | |||
290 | case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: | ||
291 | rec->type.status.payload_size = | ||
292 | ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; | ||
293 | break; | ||
294 | } | ||
295 | memcpy(&rec->type.status.payload, | ||
296 | &status_buffer->payload, rec->type.status.payload_size); | ||
297 | } | ||
298 | |||
299 | debug_event(adapter->hba_dbf, 2, | ||
300 | rec, sizeof(struct zfcp_hba_dbf_record)); | ||
301 | spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); | ||
302 | } | ||
303 | |||
304 | inline void | ||
305 | zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter, unsigned int status, | ||
306 | unsigned int qdio_error, unsigned int siga_error, | ||
307 | int sbal_index, int sbal_count) | ||
308 | { | ||
309 | struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf; | ||
310 | unsigned long flags; | ||
311 | |||
312 | spin_lock_irqsave(&adapter->hba_dbf_lock, flags); | ||
313 | memset(rec, 0, sizeof(struct zfcp_hba_dbf_record)); | ||
314 | strncpy(rec->tag, "qdio", ZFCP_DBF_TAG_SIZE); | ||
315 | rec->type.qdio.status = status; | ||
316 | rec->type.qdio.qdio_error = qdio_error; | ||
317 | rec->type.qdio.siga_error = siga_error; | ||
318 | rec->type.qdio.sbal_index = sbal_index; | ||
319 | rec->type.qdio.sbal_count = sbal_count; | ||
320 | debug_event(adapter->hba_dbf, 0, | ||
321 | rec, sizeof(struct zfcp_hba_dbf_record)); | ||
322 | spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); | ||
323 | } | ||
324 | |||
325 | static inline int | ||
326 | zfcp_hba_dbf_view_response(char *out_buf, | ||
327 | struct zfcp_hba_dbf_record_response *rec) | ||
328 | { | ||
329 | int len = 0; | ||
330 | |||
331 | len += zfcp_dbf_view(out_buf + len, "fsf_command", "0x%08x", | ||
332 | rec->fsf_command); | ||
333 | len += zfcp_dbf_view(out_buf + len, "fsf_reqid", "0x%0Lx", | ||
334 | rec->fsf_reqid); | ||
335 | len += zfcp_dbf_view(out_buf + len, "fsf_seqno", "0x%08x", | ||
336 | rec->fsf_seqno); | ||
337 | len += zfcp_dbf_stck(out_buf + len, "fsf_issued", rec->fsf_issued); | ||
338 | len += zfcp_dbf_view(out_buf + len, "fsf_prot_status", "0x%08x", | ||
339 | rec->fsf_prot_status); | ||
340 | len += zfcp_dbf_view(out_buf + len, "fsf_status", "0x%08x", | ||
341 | rec->fsf_status); | ||
342 | len += zfcp_dbf_view_dump(out_buf + len, "fsf_prot_status_qual", | ||
343 | rec->fsf_prot_status_qual, | ||
344 | FSF_PROT_STATUS_QUAL_SIZE, | ||
345 | 0, FSF_PROT_STATUS_QUAL_SIZE); | ||
346 | len += zfcp_dbf_view_dump(out_buf + len, "fsf_status_qual", | ||
347 | rec->fsf_status_qual, | ||
348 | FSF_STATUS_QUALIFIER_SIZE, | ||
349 | 0, FSF_STATUS_QUALIFIER_SIZE); | ||
350 | len += zfcp_dbf_view(out_buf + len, "fsf_req_status", "0x%08x", | ||
351 | rec->fsf_req_status); | ||
352 | len += zfcp_dbf_view(out_buf + len, "sbal_first", "0x%02x", | ||
353 | rec->sbal_first); | ||
354 | len += zfcp_dbf_view(out_buf + len, "sbal_curr", "0x%02x", | ||
355 | rec->sbal_curr); | ||
356 | len += zfcp_dbf_view(out_buf + len, "sbal_last", "0x%02x", | ||
357 | rec->sbal_last); | ||
358 | len += zfcp_dbf_view(out_buf + len, "pool", "0x%02x", rec->pool); | ||
359 | |||
360 | switch (rec->fsf_command) { | ||
361 | case FSF_QTCB_FCP_CMND: | ||
362 | if (rec->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) | ||
363 | break; | ||
364 | len += zfcp_dbf_view(out_buf + len, "scsi_cmnd", "0x%0Lx", | ||
365 | rec->data.send_fcp.scsi_cmnd); | ||
366 | len += zfcp_dbf_view(out_buf + len, "scsi_serial", "0x%016Lx", | ||
367 | rec->data.send_fcp.scsi_serial); | ||
368 | break; | ||
369 | |||
370 | case FSF_QTCB_OPEN_PORT_WITH_DID: | ||
371 | case FSF_QTCB_CLOSE_PORT: | ||
372 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | ||
373 | len += zfcp_dbf_view(out_buf + len, "wwpn", "0x%016Lx", | ||
374 | rec->data.port.wwpn); | ||
375 | len += zfcp_dbf_view(out_buf + len, "d_id", "0x%06x", | ||
376 | rec->data.port.d_id); | ||
377 | len += zfcp_dbf_view(out_buf + len, "port_handle", "0x%08x", | ||
378 | rec->data.port.port_handle); | ||
379 | break; | ||
380 | |||
381 | case FSF_QTCB_OPEN_LUN: | ||
382 | case FSF_QTCB_CLOSE_LUN: | ||
383 | len += zfcp_dbf_view(out_buf + len, "wwpn", "0x%016Lx", | ||
384 | rec->data.unit.wwpn); | ||
385 | len += zfcp_dbf_view(out_buf + len, "fcp_lun", "0x%016Lx", | ||
386 | rec->data.unit.fcp_lun); | ||
387 | len += zfcp_dbf_view(out_buf + len, "port_handle", "0x%08x", | ||
388 | rec->data.unit.port_handle); | ||
389 | len += zfcp_dbf_view(out_buf + len, "lun_handle", "0x%08x", | ||
390 | rec->data.unit.lun_handle); | ||
391 | break; | ||
392 | |||
393 | case FSF_QTCB_SEND_ELS: | ||
394 | len += zfcp_dbf_view(out_buf + len, "d_id", "0x%06x", | ||
395 | rec->data.send_els.d_id); | ||
396 | len += zfcp_dbf_view(out_buf + len, "ls_code", "0x%02x", | ||
397 | rec->data.send_els.ls_code); | ||
398 | break; | ||
399 | |||
400 | case FSF_QTCB_ABORT_FCP_CMND: | ||
401 | case FSF_QTCB_SEND_GENERIC: | ||
402 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | ||
403 | case FSF_QTCB_EXCHANGE_PORT_DATA: | ||
404 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | ||
405 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | ||
406 | break; | ||
407 | } | ||
408 | |||
409 | return len; | ||
410 | } | ||
411 | |||
412 | static inline int | ||
413 | zfcp_hba_dbf_view_status(char *out_buf, struct zfcp_hba_dbf_record_status *rec) | ||
414 | { | ||
415 | int len = 0; | ||
416 | |||
417 | len += zfcp_dbf_view(out_buf + len, "failed", "0x%02x", rec->failed); | ||
418 | len += zfcp_dbf_view(out_buf + len, "status_type", "0x%08x", | ||
419 | rec->status_type); | ||
420 | len += zfcp_dbf_view(out_buf + len, "status_subtype", "0x%08x", | ||
421 | rec->status_subtype); | ||
422 | len += zfcp_dbf_view_dump(out_buf + len, "queue_designator", | ||
423 | (char *)&rec->queue_designator, | ||
424 | sizeof(struct fsf_queue_designator), | ||
425 | 0, sizeof(struct fsf_queue_designator)); | ||
426 | len += zfcp_dbf_view_dump(out_buf + len, "payload", | ||
427 | (char *)&rec->payload, | ||
428 | rec->payload_size, 0, rec->payload_size); | ||
429 | |||
430 | return len; | ||
431 | } | ||
432 | |||
433 | static inline int | ||
434 | zfcp_hba_dbf_view_qdio(char *out_buf, struct zfcp_hba_dbf_record_qdio *rec) | ||
435 | { | ||
436 | int len = 0; | ||
437 | |||
438 | len += zfcp_dbf_view(out_buf + len, "status", "0x%08x", rec->status); | ||
439 | len += zfcp_dbf_view(out_buf + len, "qdio_error", "0x%08x", | ||
440 | rec->qdio_error); | ||
441 | len += zfcp_dbf_view(out_buf + len, "siga_error", "0x%08x", | ||
442 | rec->siga_error); | ||
443 | len += zfcp_dbf_view(out_buf + len, "sbal_index", "0x%02x", | ||
444 | rec->sbal_index); | ||
445 | len += zfcp_dbf_view(out_buf + len, "sbal_count", "0x%02x", | ||
446 | rec->sbal_count); | ||
447 | |||
448 | return len; | ||
449 | } | ||
450 | |||
451 | static int | ||
452 | zfcp_hba_dbf_view_format(debug_info_t * id, struct debug_view *view, | ||
453 | char *out_buf, const char *in_buf) | ||
454 | { | ||
455 | struct zfcp_hba_dbf_record *rec = (struct zfcp_hba_dbf_record *)in_buf; | ||
456 | int len = 0; | ||
457 | |||
458 | if (strncmp(rec->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) | ||
459 | return 0; | ||
460 | |||
461 | len += zfcp_dbf_tag(out_buf + len, "tag", rec->tag); | ||
462 | if (isalpha(rec->tag2[0])) | ||
463 | len += zfcp_dbf_tag(out_buf + len, "tag2", rec->tag2); | ||
464 | if (strncmp(rec->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) | ||
465 | len += zfcp_hba_dbf_view_response(out_buf + len, | ||
466 | &rec->type.response); | ||
467 | else if (strncmp(rec->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) | ||
468 | len += zfcp_hba_dbf_view_status(out_buf + len, | ||
469 | &rec->type.status); | ||
470 | else if (strncmp(rec->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) | ||
471 | len += zfcp_hba_dbf_view_qdio(out_buf + len, &rec->type.qdio); | ||
472 | |||
473 | len += sprintf(out_buf + len, "\n"); | ||
474 | |||
475 | return len; | ||
476 | } | ||
477 | |||
478 | struct debug_view zfcp_hba_dbf_view = { | ||
479 | "structured", | ||
480 | NULL, | ||
481 | &zfcp_dbf_view_header, | ||
482 | &zfcp_hba_dbf_view_format, | ||
483 | NULL, | ||
484 | NULL | ||
485 | }; | ||
486 | |||
487 | inline void | ||
488 | _zfcp_san_dbf_event_common_ct(const char *tag, struct zfcp_fsf_req *fsf_req, | ||
489 | u32 s_id, u32 d_id, void *buffer, int buflen) | ||
490 | { | ||
491 | struct zfcp_send_ct *send_ct = (struct zfcp_send_ct *)fsf_req->data; | ||
492 | struct zfcp_port *port = send_ct->port; | ||
493 | struct zfcp_adapter *adapter = port->adapter; | ||
494 | struct ct_hdr *header = (struct ct_hdr *)buffer; | ||
495 | struct zfcp_san_dbf_record *rec = &adapter->san_dbf_buf; | ||
496 | struct zfcp_san_dbf_record_ct *ct = &rec->type.ct; | ||
497 | unsigned long flags; | ||
498 | |||
499 | spin_lock_irqsave(&adapter->san_dbf_lock, flags); | ||
500 | memset(rec, 0, sizeof(struct zfcp_san_dbf_record)); | ||
501 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | ||
502 | rec->fsf_reqid = (unsigned long)fsf_req; | ||
503 | rec->fsf_seqno = fsf_req->seq_no; | ||
504 | rec->s_id = s_id; | ||
505 | rec->d_id = d_id; | ||
506 | if (strncmp(tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { | ||
507 | ct->type.request.cmd_req_code = header->cmd_rsp_code; | ||
508 | ct->type.request.revision = header->revision; | ||
509 | ct->type.request.gs_type = header->gs_type; | ||
510 | ct->type.request.gs_subtype = header->gs_subtype; | ||
511 | ct->type.request.options = header->options; | ||
512 | ct->type.request.max_res_size = header->max_res_size; | ||
513 | } else if (strncmp(tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { | ||
514 | ct->type.response.cmd_rsp_code = header->cmd_rsp_code; | ||
515 | ct->type.response.revision = header->revision; | ||
516 | ct->type.response.reason_code = header->reason_code; | ||
517 | ct->type.response.reason_code_expl = header->reason_code_expl; | ||
518 | ct->type.response.vendor_unique = header->vendor_unique; | ||
519 | } | ||
520 | ct->payload_size = | ||
521 | min(buflen - (int)sizeof(struct ct_hdr), ZFCP_DBF_CT_PAYLOAD); | ||
522 | memcpy(ct->payload, buffer + sizeof(struct ct_hdr), ct->payload_size); | ||
523 | debug_event(adapter->san_dbf, 3, | ||
524 | rec, sizeof(struct zfcp_san_dbf_record)); | ||
525 | spin_unlock_irqrestore(&adapter->san_dbf_lock, flags); | ||
526 | } | ||
527 | |||
528 | inline void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) | ||
529 | { | ||
530 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | ||
531 | struct zfcp_port *port = ct->port; | ||
532 | struct zfcp_adapter *adapter = port->adapter; | ||
533 | |||
534 | _zfcp_san_dbf_event_common_ct("octc", fsf_req, | ||
535 | fc_host_port_id(adapter->scsi_host), | ||
536 | port->d_id, zfcp_sg_to_address(ct->req), | ||
537 | ct->req->length); | ||
538 | } | ||
539 | |||
540 | inline void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req) | ||
541 | { | ||
542 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | ||
543 | struct zfcp_port *port = ct->port; | ||
544 | struct zfcp_adapter *adapter = port->adapter; | ||
545 | |||
546 | _zfcp_san_dbf_event_common_ct("rctc", fsf_req, port->d_id, | ||
547 | fc_host_port_id(adapter->scsi_host), | ||
548 | zfcp_sg_to_address(ct->resp), | ||
549 | ct->resp->length); | ||
550 | } | ||
551 | |||
552 | static inline void | ||
553 | _zfcp_san_dbf_event_common_els(const char *tag, int level, | ||
554 | struct zfcp_fsf_req *fsf_req, u32 s_id, | ||
555 | u32 d_id, u8 ls_code, void *buffer, int buflen) | ||
556 | { | ||
557 | struct zfcp_adapter *adapter = fsf_req->adapter; | ||
558 | struct zfcp_san_dbf_record *rec = &adapter->san_dbf_buf; | ||
559 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; | ||
560 | unsigned long flags; | ||
561 | int offset = 0; | ||
562 | |||
563 | spin_lock_irqsave(&adapter->san_dbf_lock, flags); | ||
564 | do { | ||
565 | memset(rec, 0, sizeof(struct zfcp_san_dbf_record)); | ||
566 | if (offset == 0) { | ||
567 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | ||
568 | rec->fsf_reqid = (unsigned long)fsf_req; | ||
569 | rec->fsf_seqno = fsf_req->seq_no; | ||
570 | rec->s_id = s_id; | ||
571 | rec->d_id = d_id; | ||
572 | rec->type.els.ls_code = ls_code; | ||
573 | buflen = min(buflen, ZFCP_DBF_ELS_MAX_PAYLOAD); | ||
574 | rec->type.els.payload_size = buflen; | ||
575 | memcpy(rec->type.els.payload, | ||
576 | buffer, min(buflen, ZFCP_DBF_ELS_PAYLOAD)); | ||
577 | offset += min(buflen, ZFCP_DBF_ELS_PAYLOAD); | ||
578 | } else { | ||
579 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | ||
580 | dump->total_size = buflen; | ||
581 | dump->offset = offset; | ||
582 | dump->size = min(buflen - offset, | ||
583 | (int)sizeof(struct zfcp_san_dbf_record) | ||
584 | - (int)sizeof(struct zfcp_dbf_dump)); | ||
585 | memcpy(dump->data, buffer + offset, dump->size); | ||
586 | offset += dump->size; | ||
587 | } | ||
588 | debug_event(adapter->san_dbf, level, | ||
589 | rec, sizeof(struct zfcp_san_dbf_record)); | ||
590 | } while (offset < buflen); | ||
591 | spin_unlock_irqrestore(&adapter->san_dbf_lock, flags); | ||
592 | } | ||
593 | |||
594 | inline void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req) | ||
595 | { | ||
596 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | ||
597 | |||
598 | _zfcp_san_dbf_event_common_els("oels", 2, fsf_req, | ||
599 | fc_host_port_id(els->adapter->scsi_host), | ||
600 | els->d_id, | ||
601 | *(u8 *) zfcp_sg_to_address(els->req), | ||
602 | zfcp_sg_to_address(els->req), | ||
603 | els->req->length); | ||
604 | } | ||
605 | |||
606 | inline void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req) | ||
607 | { | ||
608 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | ||
609 | |||
610 | _zfcp_san_dbf_event_common_els("rels", 2, fsf_req, els->d_id, | ||
611 | fc_host_port_id(els->adapter->scsi_host), | ||
612 | *(u8 *) zfcp_sg_to_address(els->req), | ||
613 | zfcp_sg_to_address(els->resp), | ||
614 | els->resp->length); | ||
615 | } | ||
616 | |||
617 | inline void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req) | ||
618 | { | ||
619 | struct zfcp_adapter *adapter = fsf_req->adapter; | ||
620 | struct fsf_status_read_buffer *status_buffer = | ||
621 | (struct fsf_status_read_buffer *)fsf_req->data; | ||
622 | int length = (int)status_buffer->length - | ||
623 | (int)((void *)&status_buffer->payload - (void *)status_buffer); | ||
624 | |||
625 | _zfcp_san_dbf_event_common_els("iels", 1, fsf_req, status_buffer->d_id, | ||
626 | fc_host_port_id(adapter->scsi_host), | ||
627 | *(u8 *) status_buffer->payload, | ||
628 | (void *)status_buffer->payload, length); | ||
629 | } | ||
630 | |||
631 | static int | ||
632 | zfcp_san_dbf_view_format(debug_info_t * id, struct debug_view *view, | ||
633 | char *out_buf, const char *in_buf) | ||
634 | { | ||
635 | struct zfcp_san_dbf_record *rec = (struct zfcp_san_dbf_record *)in_buf; | ||
636 | char *buffer = NULL; | ||
637 | int buflen = 0, total = 0; | ||
638 | int len = 0; | ||
639 | |||
640 | if (strncmp(rec->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) | ||
641 | return 0; | ||
642 | |||
643 | len += zfcp_dbf_tag(out_buf + len, "tag", rec->tag); | ||
644 | len += zfcp_dbf_view(out_buf + len, "fsf_reqid", "0x%0Lx", | ||
645 | rec->fsf_reqid); | ||
646 | len += zfcp_dbf_view(out_buf + len, "fsf_seqno", "0x%08x", | ||
647 | rec->fsf_seqno); | ||
648 | len += zfcp_dbf_view(out_buf + len, "s_id", "0x%06x", rec->s_id); | ||
649 | len += zfcp_dbf_view(out_buf + len, "d_id", "0x%06x", rec->d_id); | ||
650 | |||
651 | if (strncmp(rec->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { | ||
652 | len += zfcp_dbf_view(out_buf + len, "cmd_req_code", "0x%04x", | ||
653 | rec->type.ct.type.request.cmd_req_code); | ||
654 | len += zfcp_dbf_view(out_buf + len, "revision", "0x%02x", | ||
655 | rec->type.ct.type.request.revision); | ||
656 | len += zfcp_dbf_view(out_buf + len, "gs_type", "0x%02x", | ||
657 | rec->type.ct.type.request.gs_type); | ||
658 | len += zfcp_dbf_view(out_buf + len, "gs_subtype", "0x%02x", | ||
659 | rec->type.ct.type.request.gs_subtype); | ||
660 | len += zfcp_dbf_view(out_buf + len, "options", "0x%02x", | ||
661 | rec->type.ct.type.request.options); | ||
662 | len += zfcp_dbf_view(out_buf + len, "max_res_size", "0x%04x", | ||
663 | rec->type.ct.type.request.max_res_size); | ||
664 | total = rec->type.ct.payload_size; | ||
665 | buffer = rec->type.ct.payload; | ||
666 | buflen = min(total, ZFCP_DBF_CT_PAYLOAD); | ||
667 | } else if (strncmp(rec->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { | ||
668 | len += zfcp_dbf_view(out_buf + len, "cmd_rsp_code", "0x%04x", | ||
669 | rec->type.ct.type.response.cmd_rsp_code); | ||
670 | len += zfcp_dbf_view(out_buf + len, "revision", "0x%02x", | ||
671 | rec->type.ct.type.response.revision); | ||
672 | len += zfcp_dbf_view(out_buf + len, "reason_code", "0x%02x", | ||
673 | rec->type.ct.type.response.reason_code); | ||
674 | len += | ||
675 | zfcp_dbf_view(out_buf + len, "reason_code_expl", "0x%02x", | ||
676 | rec->type.ct.type.response.reason_code_expl); | ||
677 | len += | ||
678 | zfcp_dbf_view(out_buf + len, "vendor_unique", "0x%02x", | ||
679 | rec->type.ct.type.response.vendor_unique); | ||
680 | total = rec->type.ct.payload_size; | ||
681 | buffer = rec->type.ct.payload; | ||
682 | buflen = min(total, ZFCP_DBF_CT_PAYLOAD); | ||
683 | } else if (strncmp(rec->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 || | ||
684 | strncmp(rec->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 || | ||
685 | strncmp(rec->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) { | ||
686 | len += zfcp_dbf_view(out_buf + len, "ls_code", "0x%02x", | ||
687 | rec->type.els.ls_code); | ||
688 | total = rec->type.els.payload_size; | ||
689 | buffer = rec->type.els.payload; | ||
690 | buflen = min(total, ZFCP_DBF_ELS_PAYLOAD); | ||
691 | } | ||
692 | |||
693 | len += zfcp_dbf_view_dump(out_buf + len, "payload", | ||
694 | buffer, buflen, 0, total); | ||
695 | |||
696 | if (buflen == total) | ||
697 | len += sprintf(out_buf + len, "\n"); | ||
698 | |||
699 | return len; | ||
700 | } | ||
701 | |||
702 | struct debug_view zfcp_san_dbf_view = { | ||
703 | "structured", | ||
704 | NULL, | ||
705 | &zfcp_dbf_view_header, | ||
706 | &zfcp_san_dbf_view_format, | ||
707 | NULL, | ||
708 | NULL | ||
709 | }; | ||
710 | |||
711 | static inline void | ||
712 | _zfcp_scsi_dbf_event_common(const char *tag, const char *tag2, int level, | ||
713 | struct zfcp_adapter *adapter, | ||
714 | struct scsi_cmnd *scsi_cmnd, | ||
715 | struct zfcp_fsf_req *new_fsf_req) | ||
716 | { | ||
717 | struct zfcp_fsf_req *fsf_req = | ||
718 | (struct zfcp_fsf_req *)scsi_cmnd->host_scribble; | ||
719 | struct zfcp_scsi_dbf_record *rec = &adapter->scsi_dbf_buf; | ||
720 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; | ||
721 | unsigned long flags; | ||
722 | struct fcp_rsp_iu *fcp_rsp; | ||
723 | char *fcp_rsp_info = NULL, *fcp_sns_info = NULL; | ||
724 | int offset = 0, buflen = 0; | ||
725 | |||
726 | spin_lock_irqsave(&adapter->scsi_dbf_lock, flags); | ||
727 | do { | ||
728 | memset(rec, 0, sizeof(struct zfcp_scsi_dbf_record)); | ||
729 | if (offset == 0) { | ||
730 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | ||
731 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); | ||
732 | if (scsi_cmnd->device) { | ||
733 | rec->scsi_id = scsi_cmnd->device->id; | ||
734 | rec->scsi_lun = scsi_cmnd->device->lun; | ||
735 | } | ||
736 | rec->scsi_result = scsi_cmnd->result; | ||
737 | rec->scsi_cmnd = (unsigned long)scsi_cmnd; | ||
738 | rec->scsi_serial = scsi_cmnd->serial_number; | ||
739 | memcpy(rec->scsi_opcode, | ||
740 | &scsi_cmnd->cmnd, | ||
741 | min((int)scsi_cmnd->cmd_len, | ||
742 | ZFCP_DBF_SCSI_OPCODE)); | ||
743 | rec->scsi_retries = scsi_cmnd->retries; | ||
744 | rec->scsi_allowed = scsi_cmnd->allowed; | ||
745 | if (fsf_req != NULL) { | ||
746 | fcp_rsp = (struct fcp_rsp_iu *) | ||
747 | &(fsf_req->qtcb->bottom.io.fcp_rsp); | ||
748 | fcp_rsp_info = | ||
749 | zfcp_get_fcp_rsp_info_ptr(fcp_rsp); | ||
750 | fcp_sns_info = | ||
751 | zfcp_get_fcp_sns_info_ptr(fcp_rsp); | ||
752 | |||
753 | rec->type.fcp.rsp_validity = | ||
754 | fcp_rsp->validity.value; | ||
755 | rec->type.fcp.rsp_scsi_status = | ||
756 | fcp_rsp->scsi_status; | ||
757 | rec->type.fcp.rsp_resid = fcp_rsp->fcp_resid; | ||
758 | if (fcp_rsp->validity.bits.fcp_rsp_len_valid) | ||
759 | rec->type.fcp.rsp_code = | ||
760 | *(fcp_rsp_info + 3); | ||
761 | if (fcp_rsp->validity.bits.fcp_sns_len_valid) { | ||
762 | buflen = min((int)fcp_rsp->fcp_sns_len, | ||
763 | ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO); | ||
764 | rec->type.fcp.sns_info_len = buflen; | ||
765 | memcpy(rec->type.fcp.sns_info, | ||
766 | fcp_sns_info, | ||
767 | min(buflen, | ||
768 | ZFCP_DBF_SCSI_FCP_SNS_INFO)); | ||
769 | offset += min(buflen, | ||
770 | ZFCP_DBF_SCSI_FCP_SNS_INFO); | ||
771 | } | ||
772 | |||
773 | rec->fsf_reqid = (unsigned long)fsf_req; | ||
774 | rec->fsf_seqno = fsf_req->seq_no; | ||
775 | rec->fsf_issued = fsf_req->issued; | ||
776 | } | ||
777 | if (new_fsf_req != NULL) { | ||
778 | rec->type.new_fsf_req.fsf_reqid = | ||
779 | (unsigned long) | ||
780 | new_fsf_req; | ||
781 | rec->type.new_fsf_req.fsf_seqno = | ||
782 | new_fsf_req->seq_no; | ||
783 | rec->type.new_fsf_req.fsf_issued = | ||
784 | new_fsf_req->issued; | ||
785 | } | ||
786 | } else { | ||
787 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | ||
788 | dump->total_size = buflen; | ||
789 | dump->offset = offset; | ||
790 | dump->size = min(buflen - offset, | ||
791 | (int)sizeof(struct | ||
792 | zfcp_scsi_dbf_record) - | ||
793 | (int)sizeof(struct zfcp_dbf_dump)); | ||
794 | memcpy(dump->data, fcp_sns_info + offset, dump->size); | ||
795 | offset += dump->size; | ||
796 | } | ||
797 | debug_event(adapter->scsi_dbf, level, | ||
798 | rec, sizeof(struct zfcp_scsi_dbf_record)); | ||
799 | } while (offset < buflen); | ||
800 | spin_unlock_irqrestore(&adapter->scsi_dbf_lock, flags); | ||
801 | } | ||
802 | |||
803 | inline void | ||
804 | zfcp_scsi_dbf_event_result(const char *tag, int level, | ||
805 | struct zfcp_adapter *adapter, | ||
806 | struct scsi_cmnd *scsi_cmnd) | ||
807 | { | ||
808 | _zfcp_scsi_dbf_event_common("rslt", | ||
809 | tag, level, adapter, scsi_cmnd, NULL); | ||
810 | } | ||
811 | |||
812 | inline void | ||
813 | zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter, | ||
814 | struct scsi_cmnd *scsi_cmnd, | ||
815 | struct zfcp_fsf_req *new_fsf_req) | ||
816 | { | ||
817 | _zfcp_scsi_dbf_event_common("abrt", | ||
818 | tag, 1, adapter, scsi_cmnd, new_fsf_req); | ||
819 | } | ||
820 | |||
821 | inline void | ||
822 | zfcp_scsi_dbf_event_devreset(const char *tag, u8 flag, struct zfcp_unit *unit, | ||
823 | struct scsi_cmnd *scsi_cmnd) | ||
824 | { | ||
825 | struct zfcp_adapter *adapter = unit->port->adapter; | ||
826 | |||
827 | _zfcp_scsi_dbf_event_common(flag == FCP_TARGET_RESET ? "trst" : "lrst", | ||
828 | tag, 1, adapter, scsi_cmnd, NULL); | ||
829 | } | ||
830 | |||
831 | static int | ||
832 | zfcp_scsi_dbf_view_format(debug_info_t * id, struct debug_view *view, | ||
833 | char *out_buf, const char *in_buf) | ||
834 | { | ||
835 | struct zfcp_scsi_dbf_record *rec = | ||
836 | (struct zfcp_scsi_dbf_record *)in_buf; | ||
837 | int len = 0; | ||
838 | |||
839 | if (strncmp(rec->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) | ||
840 | return 0; | ||
841 | |||
842 | len += zfcp_dbf_tag(out_buf + len, "tag", rec->tag); | ||
843 | len += zfcp_dbf_tag(out_buf + len, "tag2", rec->tag2); | ||
844 | len += zfcp_dbf_view(out_buf + len, "scsi_id", "0x%08x", rec->scsi_id); | ||
845 | len += zfcp_dbf_view(out_buf + len, "scsi_lun", "0x%08x", | ||
846 | rec->scsi_lun); | ||
847 | len += zfcp_dbf_view(out_buf + len, "scsi_result", "0x%08x", | ||
848 | rec->scsi_result); | ||
849 | len += zfcp_dbf_view(out_buf + len, "scsi_cmnd", "0x%0Lx", | ||
850 | rec->scsi_cmnd); | ||
851 | len += zfcp_dbf_view(out_buf + len, "scsi_serial", "0x%016Lx", | ||
852 | rec->scsi_serial); | ||
853 | len += zfcp_dbf_view_dump(out_buf + len, "scsi_opcode", | ||
854 | rec->scsi_opcode, | ||
855 | ZFCP_DBF_SCSI_OPCODE, | ||
856 | 0, ZFCP_DBF_SCSI_OPCODE); | ||
857 | len += zfcp_dbf_view(out_buf + len, "scsi_retries", "0x%02x", | ||
858 | rec->scsi_retries); | ||
859 | len += zfcp_dbf_view(out_buf + len, "scsi_allowed", "0x%02x", | ||
860 | rec->scsi_allowed); | ||
861 | len += zfcp_dbf_view(out_buf + len, "fsf_reqid", "0x%0Lx", | ||
862 | rec->fsf_reqid); | ||
863 | len += zfcp_dbf_view(out_buf + len, "fsf_seqno", "0x%08x", | ||
864 | rec->fsf_seqno); | ||
865 | len += zfcp_dbf_stck(out_buf + len, "fsf_issued", rec->fsf_issued); | ||
866 | if (strncmp(rec->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { | ||
867 | len += | ||
868 | zfcp_dbf_view(out_buf + len, "fcp_rsp_validity", "0x%02x", | ||
869 | rec->type.fcp.rsp_validity); | ||
870 | len += | ||
871 | zfcp_dbf_view(out_buf + len, "fcp_rsp_scsi_status", | ||
872 | "0x%02x", rec->type.fcp.rsp_scsi_status); | ||
873 | len += | ||
874 | zfcp_dbf_view(out_buf + len, "fcp_rsp_resid", "0x%08x", | ||
875 | rec->type.fcp.rsp_resid); | ||
876 | len += | ||
877 | zfcp_dbf_view(out_buf + len, "fcp_rsp_code", "0x%08x", | ||
878 | rec->type.fcp.rsp_code); | ||
879 | len += | ||
880 | zfcp_dbf_view(out_buf + len, "fcp_sns_info_len", "0x%08x", | ||
881 | rec->type.fcp.sns_info_len); | ||
882 | len += | ||
883 | zfcp_dbf_view_dump(out_buf + len, "fcp_sns_info", | ||
884 | rec->type.fcp.sns_info, | ||
885 | min((int)rec->type.fcp.sns_info_len, | ||
886 | ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, | ||
887 | rec->type.fcp.sns_info_len); | ||
888 | } else if (strncmp(rec->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) { | ||
889 | len += zfcp_dbf_view(out_buf + len, "fsf_reqid_abort", "0x%0Lx", | ||
890 | rec->type.new_fsf_req.fsf_reqid); | ||
891 | len += zfcp_dbf_view(out_buf + len, "fsf_seqno_abort", "0x%08x", | ||
892 | rec->type.new_fsf_req.fsf_seqno); | ||
893 | len += zfcp_dbf_stck(out_buf + len, "fsf_issued", | ||
894 | rec->type.new_fsf_req.fsf_issued); | ||
895 | } else if ((strncmp(rec->tag, "trst", ZFCP_DBF_TAG_SIZE) == 0) || | ||
896 | (strncmp(rec->tag, "lrst", ZFCP_DBF_TAG_SIZE) == 0)) { | ||
897 | len += zfcp_dbf_view(out_buf + len, "fsf_reqid_reset", "0x%0Lx", | ||
898 | rec->type.new_fsf_req.fsf_reqid); | ||
899 | len += zfcp_dbf_view(out_buf + len, "fsf_seqno_reset", "0x%08x", | ||
900 | rec->type.new_fsf_req.fsf_seqno); | ||
901 | len += zfcp_dbf_stck(out_buf + len, "fsf_issued", | ||
902 | rec->type.new_fsf_req.fsf_issued); | ||
903 | } | ||
904 | |||
905 | len += sprintf(out_buf + len, "\n"); | ||
906 | |||
907 | return len; | ||
908 | } | ||
909 | |||
910 | struct debug_view zfcp_scsi_dbf_view = { | ||
911 | "structured", | ||
912 | NULL, | ||
913 | &zfcp_dbf_view_header, | ||
914 | &zfcp_scsi_dbf_view_format, | ||
915 | NULL, | ||
916 | NULL | ||
917 | }; | ||
918 | |||
919 | /** | ||
920 | * zfcp_adapter_debug_register - registers debug feature for an adapter | ||
921 | * @adapter: pointer to adapter for which debug features should be registered | ||
922 | * return: -ENOMEM on error, 0 otherwise | ||
923 | */ | ||
924 | int zfcp_adapter_debug_register(struct zfcp_adapter *adapter) | ||
925 | { | ||
926 | char dbf_name[DEBUG_MAX_NAME_LEN]; | ||
927 | |||
928 | /* debug feature area which records recovery activity */ | ||
929 | spin_lock_init(&adapter->erp_dbf_lock); | ||
930 | sprintf(dbf_name, "zfcp_%s_erp", zfcp_get_busid_by_adapter(adapter)); | ||
931 | adapter->erp_dbf = debug_register(dbf_name, dbfsize, 2, | ||
932 | sizeof(struct zfcp_erp_dbf_record)); | ||
933 | if (!adapter->erp_dbf) | ||
934 | goto failed; | ||
935 | debug_register_view(adapter->erp_dbf, &debug_hex_ascii_view); | ||
936 | debug_set_level(adapter->erp_dbf, 3); | ||
937 | |||
938 | /* debug feature area which records HBA (FSF and QDIO) conditions */ | ||
939 | spin_lock_init(&adapter->hba_dbf_lock); | ||
940 | sprintf(dbf_name, "zfcp_%s_hba", zfcp_get_busid_by_adapter(adapter)); | ||
941 | adapter->hba_dbf = debug_register(dbf_name, dbfsize, 1, | ||
942 | sizeof(struct zfcp_hba_dbf_record)); | ||
943 | if (!adapter->hba_dbf) | ||
944 | goto failed; | ||
945 | debug_register_view(adapter->hba_dbf, &debug_hex_ascii_view); | ||
946 | debug_register_view(adapter->hba_dbf, &zfcp_hba_dbf_view); | ||
947 | debug_set_level(adapter->hba_dbf, 3); | ||
948 | |||
949 | /* debug feature area which records SAN command failures and recovery */ | ||
950 | spin_lock_init(&adapter->san_dbf_lock); | ||
951 | sprintf(dbf_name, "zfcp_%s_san", zfcp_get_busid_by_adapter(adapter)); | ||
952 | adapter->san_dbf = debug_register(dbf_name, dbfsize, 1, | ||
953 | sizeof(struct zfcp_san_dbf_record)); | ||
954 | if (!adapter->san_dbf) | ||
955 | goto failed; | ||
956 | debug_register_view(adapter->san_dbf, &debug_hex_ascii_view); | ||
957 | debug_register_view(adapter->san_dbf, &zfcp_san_dbf_view); | ||
958 | debug_set_level(adapter->san_dbf, 6); | ||
959 | |||
960 | /* debug feature area which records SCSI command failures and recovery */ | ||
961 | spin_lock_init(&adapter->scsi_dbf_lock); | ||
962 | sprintf(dbf_name, "zfcp_%s_scsi", zfcp_get_busid_by_adapter(adapter)); | ||
963 | adapter->scsi_dbf = debug_register(dbf_name, dbfsize, 1, | ||
964 | sizeof(struct zfcp_scsi_dbf_record)); | ||
965 | if (!adapter->scsi_dbf) | ||
966 | goto failed; | ||
967 | debug_register_view(adapter->scsi_dbf, &debug_hex_ascii_view); | ||
968 | debug_register_view(adapter->scsi_dbf, &zfcp_scsi_dbf_view); | ||
969 | debug_set_level(adapter->scsi_dbf, 3); | ||
970 | |||
971 | return 0; | ||
972 | |||
973 | failed: | ||
974 | zfcp_adapter_debug_unregister(adapter); | ||
975 | |||
976 | return -ENOMEM; | ||
977 | } | ||
978 | |||
979 | /** | ||
980 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | ||
981 | * @adapter: pointer to adapter for which debug features should be unregistered | ||
982 | */ | ||
983 | void zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter) | ||
984 | { | ||
985 | debug_unregister(adapter->scsi_dbf); | ||
986 | debug_unregister(adapter->san_dbf); | ||
987 | debug_unregister(adapter->hba_dbf); | ||
988 | debug_unregister(adapter->erp_dbf); | ||
989 | adapter->scsi_dbf = NULL; | ||
990 | adapter->san_dbf = NULL; | ||
991 | adapter->hba_dbf = NULL; | ||
992 | adapter->erp_dbf = NULL; | ||
993 | } | ||
994 | |||
995 | #undef ZFCP_LOG_AREA | ||
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h index 455e902533a9..d81b737d68cc 100644 --- a/drivers/s390/scsi/zfcp_def.h +++ b/drivers/s390/scsi/zfcp_def.h | |||
@@ -66,7 +66,7 @@ | |||
66 | /********************* GENERAL DEFINES *********************************/ | 66 | /********************* GENERAL DEFINES *********************************/ |
67 | 67 | ||
68 | /* zfcp version number, it consists of major, minor, and patch-level number */ | 68 | /* zfcp version number, it consists of major, minor, and patch-level number */ |
69 | #define ZFCP_VERSION "4.3.0" | 69 | #define ZFCP_VERSION "4.5.0" |
70 | 70 | ||
71 | /** | 71 | /** |
72 | * zfcp_sg_to_address - determine kernel address from struct scatterlist | 72 | * zfcp_sg_to_address - determine kernel address from struct scatterlist |
@@ -154,13 +154,17 @@ typedef u32 scsi_lun_t; | |||
154 | #define ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP 100 | 154 | #define ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP 100 |
155 | #define ZFCP_EXCHANGE_CONFIG_DATA_RETRIES 7 | 155 | #define ZFCP_EXCHANGE_CONFIG_DATA_RETRIES 7 |
156 | 156 | ||
157 | /* Retry 5 times every 2 second, then every minute */ | ||
158 | #define ZFCP_EXCHANGE_PORT_DATA_SHORT_RETRIES 5 | ||
159 | #define ZFCP_EXCHANGE_PORT_DATA_SHORT_SLEEP 200 | ||
160 | #define ZFCP_EXCHANGE_PORT_DATA_LONG_SLEEP 6000 | ||
161 | |||
157 | /* timeout value for "default timer" for fsf requests */ | 162 | /* timeout value for "default timer" for fsf requests */ |
158 | #define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ); | 163 | #define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ); |
159 | 164 | ||
160 | /*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/ | 165 | /*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/ |
161 | 166 | ||
162 | typedef unsigned long long wwn_t; | 167 | typedef unsigned long long wwn_t; |
163 | typedef unsigned int fc_id_t; | ||
164 | typedef unsigned long long fcp_lun_t; | 168 | typedef unsigned long long fcp_lun_t; |
165 | /* data length field may be at variable position in FCP-2 FCP_CMND IU */ | 169 | /* data length field may be at variable position in FCP-2 FCP_CMND IU */ |
166 | typedef unsigned int fcp_dl_t; | 170 | typedef unsigned int fcp_dl_t; |
@@ -281,6 +285,171 @@ struct fcp_logo { | |||
281 | } __attribute__((packed)); | 285 | } __attribute__((packed)); |
282 | 286 | ||
283 | /* | 287 | /* |
288 | * DBF stuff | ||
289 | */ | ||
290 | #define ZFCP_DBF_TAG_SIZE 4 | ||
291 | |||
292 | struct zfcp_dbf_dump { | ||
293 | u8 tag[ZFCP_DBF_TAG_SIZE]; | ||
294 | u32 total_size; /* size of total dump data */ | ||
295 | u32 offset; /* how much data has being already dumped */ | ||
296 | u32 size; /* how much data comes with this record */ | ||
297 | u8 data[]; /* dump data */ | ||
298 | } __attribute__ ((packed)); | ||
299 | |||
300 | /* FIXME: to be inflated when reworking the erp dbf */ | ||
301 | struct zfcp_erp_dbf_record { | ||
302 | u8 dummy[16]; | ||
303 | } __attribute__ ((packed)); | ||
304 | |||
305 | struct zfcp_hba_dbf_record_response { | ||
306 | u32 fsf_command; | ||
307 | u64 fsf_reqid; | ||
308 | u32 fsf_seqno; | ||
309 | u64 fsf_issued; | ||
310 | u32 fsf_prot_status; | ||
311 | u32 fsf_status; | ||
312 | u8 fsf_prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE]; | ||
313 | u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE]; | ||
314 | u32 fsf_req_status; | ||
315 | u8 sbal_first; | ||
316 | u8 sbal_curr; | ||
317 | u8 sbal_last; | ||
318 | u8 pool; | ||
319 | u64 erp_action; | ||
320 | union { | ||
321 | struct { | ||
322 | u64 scsi_cmnd; | ||
323 | u64 scsi_serial; | ||
324 | } send_fcp; | ||
325 | struct { | ||
326 | u64 wwpn; | ||
327 | u32 d_id; | ||
328 | u32 port_handle; | ||
329 | } port; | ||
330 | struct { | ||
331 | u64 wwpn; | ||
332 | u64 fcp_lun; | ||
333 | u32 port_handle; | ||
334 | u32 lun_handle; | ||
335 | } unit; | ||
336 | struct { | ||
337 | u32 d_id; | ||
338 | u8 ls_code; | ||
339 | } send_els; | ||
340 | } data; | ||
341 | } __attribute__ ((packed)); | ||
342 | |||
343 | struct zfcp_hba_dbf_record_status { | ||
344 | u8 failed; | ||
345 | u32 status_type; | ||
346 | u32 status_subtype; | ||
347 | struct fsf_queue_designator | ||
348 | queue_designator; | ||
349 | u32 payload_size; | ||
350 | #define ZFCP_DBF_UNSOL_PAYLOAD 80 | ||
351 | #define ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL 32 | ||
352 | #define ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD 56 | ||
353 | #define ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT 2 * sizeof(u32) | ||
354 | u8 payload[ZFCP_DBF_UNSOL_PAYLOAD]; | ||
355 | } __attribute__ ((packed)); | ||
356 | |||
357 | struct zfcp_hba_dbf_record_qdio { | ||
358 | u32 status; | ||
359 | u32 qdio_error; | ||
360 | u32 siga_error; | ||
361 | u8 sbal_index; | ||
362 | u8 sbal_count; | ||
363 | } __attribute__ ((packed)); | ||
364 | |||
365 | struct zfcp_hba_dbf_record { | ||
366 | u8 tag[ZFCP_DBF_TAG_SIZE]; | ||
367 | u8 tag2[ZFCP_DBF_TAG_SIZE]; | ||
368 | union { | ||
369 | struct zfcp_hba_dbf_record_response response; | ||
370 | struct zfcp_hba_dbf_record_status status; | ||
371 | struct zfcp_hba_dbf_record_qdio qdio; | ||
372 | } type; | ||
373 | } __attribute__ ((packed)); | ||
374 | |||
375 | struct zfcp_san_dbf_record_ct { | ||
376 | union { | ||
377 | struct { | ||
378 | u16 cmd_req_code; | ||
379 | u8 revision; | ||
380 | u8 gs_type; | ||
381 | u8 gs_subtype; | ||
382 | u8 options; | ||
383 | u16 max_res_size; | ||
384 | } request; | ||
385 | struct { | ||
386 | u16 cmd_rsp_code; | ||
387 | u8 revision; | ||
388 | u8 reason_code; | ||
389 | u8 reason_code_expl; | ||
390 | u8 vendor_unique; | ||
391 | } response; | ||
392 | } type; | ||
393 | u32 payload_size; | ||
394 | #define ZFCP_DBF_CT_PAYLOAD 24 | ||
395 | u8 payload[ZFCP_DBF_CT_PAYLOAD]; | ||
396 | } __attribute__ ((packed)); | ||
397 | |||
398 | struct zfcp_san_dbf_record_els { | ||
399 | u8 ls_code; | ||
400 | u32 payload_size; | ||
401 | #define ZFCP_DBF_ELS_PAYLOAD 32 | ||
402 | #define ZFCP_DBF_ELS_MAX_PAYLOAD 1024 | ||
403 | u8 payload[ZFCP_DBF_ELS_PAYLOAD]; | ||
404 | } __attribute__ ((packed)); | ||
405 | |||
406 | struct zfcp_san_dbf_record { | ||
407 | u8 tag[ZFCP_DBF_TAG_SIZE]; | ||
408 | u64 fsf_reqid; | ||
409 | u32 fsf_seqno; | ||
410 | u32 s_id; | ||
411 | u32 d_id; | ||
412 | union { | ||
413 | struct zfcp_san_dbf_record_ct ct; | ||
414 | struct zfcp_san_dbf_record_els els; | ||
415 | } type; | ||
416 | } __attribute__ ((packed)); | ||
417 | |||
418 | struct zfcp_scsi_dbf_record { | ||
419 | u8 tag[ZFCP_DBF_TAG_SIZE]; | ||
420 | u8 tag2[ZFCP_DBF_TAG_SIZE]; | ||
421 | u32 scsi_id; | ||
422 | u32 scsi_lun; | ||
423 | u32 scsi_result; | ||
424 | u64 scsi_cmnd; | ||
425 | u64 scsi_serial; | ||
426 | #define ZFCP_DBF_SCSI_OPCODE 16 | ||
427 | u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE]; | ||
428 | u8 scsi_retries; | ||
429 | u8 scsi_allowed; | ||
430 | u64 fsf_reqid; | ||
431 | u32 fsf_seqno; | ||
432 | u64 fsf_issued; | ||
433 | union { | ||
434 | struct { | ||
435 | u64 fsf_reqid; | ||
436 | u32 fsf_seqno; | ||
437 | u64 fsf_issued; | ||
438 | } new_fsf_req; | ||
439 | struct { | ||
440 | u8 rsp_validity; | ||
441 | u8 rsp_scsi_status; | ||
442 | u32 rsp_resid; | ||
443 | u8 rsp_code; | ||
444 | #define ZFCP_DBF_SCSI_FCP_SNS_INFO 16 | ||
445 | #define ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO 256 | ||
446 | u32 sns_info_len; | ||
447 | u8 sns_info[ZFCP_DBF_SCSI_FCP_SNS_INFO]; | ||
448 | } fcp; | ||
449 | } type; | ||
450 | } __attribute__ ((packed)); | ||
451 | |||
452 | /* | ||
284 | * FC-FS stuff | 453 | * FC-FS stuff |
285 | */ | 454 | */ |
286 | #define R_A_TOV 10 /* seconds */ | 455 | #define R_A_TOV 10 /* seconds */ |
@@ -339,34 +508,6 @@ struct zfcp_rc_entry { | |||
339 | */ | 508 | */ |
340 | #define ZFCP_CT_TIMEOUT (3 * R_A_TOV) | 509 | #define ZFCP_CT_TIMEOUT (3 * R_A_TOV) |
341 | 510 | ||
342 | |||
343 | /***************** S390 DEBUG FEATURE SPECIFIC DEFINES ***********************/ | ||
344 | |||
345 | /* debug feature entries per adapter */ | ||
346 | #define ZFCP_ERP_DBF_INDEX 1 | ||
347 | #define ZFCP_ERP_DBF_AREAS 2 | ||
348 | #define ZFCP_ERP_DBF_LENGTH 16 | ||
349 | #define ZFCP_ERP_DBF_LEVEL 3 | ||
350 | #define ZFCP_ERP_DBF_NAME "zfcperp" | ||
351 | |||
352 | #define ZFCP_CMD_DBF_INDEX 2 | ||
353 | #define ZFCP_CMD_DBF_AREAS 1 | ||
354 | #define ZFCP_CMD_DBF_LENGTH 8 | ||
355 | #define ZFCP_CMD_DBF_LEVEL 3 | ||
356 | #define ZFCP_CMD_DBF_NAME "zfcpcmd" | ||
357 | |||
358 | #define ZFCP_ABORT_DBF_INDEX 2 | ||
359 | #define ZFCP_ABORT_DBF_AREAS 1 | ||
360 | #define ZFCP_ABORT_DBF_LENGTH 8 | ||
361 | #define ZFCP_ABORT_DBF_LEVEL 6 | ||
362 | #define ZFCP_ABORT_DBF_NAME "zfcpabt" | ||
363 | |||
364 | #define ZFCP_IN_ELS_DBF_INDEX 2 | ||
365 | #define ZFCP_IN_ELS_DBF_AREAS 1 | ||
366 | #define ZFCP_IN_ELS_DBF_LENGTH 8 | ||
367 | #define ZFCP_IN_ELS_DBF_LEVEL 6 | ||
368 | #define ZFCP_IN_ELS_DBF_NAME "zfcpels" | ||
369 | |||
370 | /******************** LOGGING MACROS AND DEFINES *****************************/ | 511 | /******************** LOGGING MACROS AND DEFINES *****************************/ |
371 | 512 | ||
372 | /* | 513 | /* |
@@ -501,6 +642,7 @@ do { \ | |||
501 | #define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL 0x00000080 | 642 | #define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL 0x00000080 |
502 | #define ZFCP_STATUS_ADAPTER_ERP_PENDING 0x00000100 | 643 | #define ZFCP_STATUS_ADAPTER_ERP_PENDING 0x00000100 |
503 | #define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED 0x00000200 | 644 | #define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED 0x00000200 |
645 | #define ZFCP_STATUS_ADAPTER_XPORT_OK 0x00000800 | ||
504 | 646 | ||
505 | #define ZFCP_STATUS_ADAPTER_SCSI_UP \ | 647 | #define ZFCP_STATUS_ADAPTER_SCSI_UP \ |
506 | (ZFCP_STATUS_COMMON_UNBLOCKED | \ | 648 | (ZFCP_STATUS_COMMON_UNBLOCKED | \ |
@@ -635,45 +777,6 @@ struct zfcp_adapter_mempool { | |||
635 | mempool_t *data_gid_pn; | 777 | mempool_t *data_gid_pn; |
636 | }; | 778 | }; |
637 | 779 | ||
638 | struct zfcp_exchange_config_data{ | ||
639 | }; | ||
640 | |||
641 | struct zfcp_open_port { | ||
642 | struct zfcp_port *port; | ||
643 | }; | ||
644 | |||
645 | struct zfcp_close_port { | ||
646 | struct zfcp_port *port; | ||
647 | }; | ||
648 | |||
649 | struct zfcp_open_unit { | ||
650 | struct zfcp_unit *unit; | ||
651 | }; | ||
652 | |||
653 | struct zfcp_close_unit { | ||
654 | struct zfcp_unit *unit; | ||
655 | }; | ||
656 | |||
657 | struct zfcp_close_physical_port { | ||
658 | struct zfcp_port *port; | ||
659 | }; | ||
660 | |||
661 | struct zfcp_send_fcp_command_task { | ||
662 | struct zfcp_fsf_req *fsf_req; | ||
663 | struct zfcp_unit *unit; | ||
664 | struct scsi_cmnd *scsi_cmnd; | ||
665 | unsigned long start_jiffies; | ||
666 | }; | ||
667 | |||
668 | struct zfcp_send_fcp_command_task_management { | ||
669 | struct zfcp_unit *unit; | ||
670 | }; | ||
671 | |||
672 | struct zfcp_abort_fcp_command { | ||
673 | struct zfcp_fsf_req *fsf_req; | ||
674 | struct zfcp_unit *unit; | ||
675 | }; | ||
676 | |||
677 | /* | 780 | /* |
678 | * header for CT_IU | 781 | * header for CT_IU |
679 | */ | 782 | */ |
@@ -702,7 +805,7 @@ struct ct_iu_gid_pn_req { | |||
702 | /* FS_ACC IU and data unit for GID_PN nameserver request */ | 805 | /* FS_ACC IU and data unit for GID_PN nameserver request */ |
703 | struct ct_iu_gid_pn_resp { | 806 | struct ct_iu_gid_pn_resp { |
704 | struct ct_hdr header; | 807 | struct ct_hdr header; |
705 | fc_id_t d_id; | 808 | u32 d_id; |
706 | } __attribute__ ((packed)); | 809 | } __attribute__ ((packed)); |
707 | 810 | ||
708 | typedef void (*zfcp_send_ct_handler_t)(unsigned long); | 811 | typedef void (*zfcp_send_ct_handler_t)(unsigned long); |
@@ -768,7 +871,7 @@ typedef void (*zfcp_send_els_handler_t)(unsigned long); | |||
768 | struct zfcp_send_els { | 871 | struct zfcp_send_els { |
769 | struct zfcp_adapter *adapter; | 872 | struct zfcp_adapter *adapter; |
770 | struct zfcp_port *port; | 873 | struct zfcp_port *port; |
771 | fc_id_t d_id; | 874 | u32 d_id; |
772 | struct scatterlist *req; | 875 | struct scatterlist *req; |
773 | struct scatterlist *resp; | 876 | struct scatterlist *resp; |
774 | unsigned int req_count; | 877 | unsigned int req_count; |
@@ -781,33 +884,6 @@ struct zfcp_send_els { | |||
781 | int status; | 884 | int status; |
782 | }; | 885 | }; |
783 | 886 | ||
784 | struct zfcp_status_read { | ||
785 | struct fsf_status_read_buffer *buffer; | ||
786 | }; | ||
787 | |||
788 | struct zfcp_fsf_done { | ||
789 | struct completion *complete; | ||
790 | int status; | ||
791 | }; | ||
792 | |||
793 | /* request specific data */ | ||
794 | union zfcp_req_data { | ||
795 | struct zfcp_exchange_config_data exchange_config_data; | ||
796 | struct zfcp_open_port open_port; | ||
797 | struct zfcp_close_port close_port; | ||
798 | struct zfcp_open_unit open_unit; | ||
799 | struct zfcp_close_unit close_unit; | ||
800 | struct zfcp_close_physical_port close_physical_port; | ||
801 | struct zfcp_send_fcp_command_task send_fcp_command_task; | ||
802 | struct zfcp_send_fcp_command_task_management | ||
803 | send_fcp_command_task_management; | ||
804 | struct zfcp_abort_fcp_command abort_fcp_command; | ||
805 | struct zfcp_send_ct *send_ct; | ||
806 | struct zfcp_send_els *send_els; | ||
807 | struct zfcp_status_read status_read; | ||
808 | struct fsf_qtcb_bottom_port *port_data; | ||
809 | }; | ||
810 | |||
811 | struct zfcp_qdio_queue { | 887 | struct zfcp_qdio_queue { |
812 | struct qdio_buffer *buffer[QDIO_MAX_BUFFERS_PER_Q]; /* SBALs */ | 888 | struct qdio_buffer *buffer[QDIO_MAX_BUFFERS_PER_Q]; /* SBALs */ |
813 | u8 free_index; /* index of next free bfr | 889 | u8 free_index; /* index of next free bfr |
@@ -838,21 +914,19 @@ struct zfcp_adapter { | |||
838 | atomic_t refcount; /* reference count */ | 914 | atomic_t refcount; /* reference count */ |
839 | wait_queue_head_t remove_wq; /* can be used to wait for | 915 | wait_queue_head_t remove_wq; /* can be used to wait for |
840 | refcount drop to zero */ | 916 | refcount drop to zero */ |
841 | wwn_t wwnn; /* WWNN */ | ||
842 | wwn_t wwpn; /* WWPN */ | ||
843 | fc_id_t s_id; /* N_Port ID */ | ||
844 | wwn_t peer_wwnn; /* P2P peer WWNN */ | 917 | wwn_t peer_wwnn; /* P2P peer WWNN */ |
845 | wwn_t peer_wwpn; /* P2P peer WWPN */ | 918 | wwn_t peer_wwpn; /* P2P peer WWPN */ |
846 | fc_id_t peer_d_id; /* P2P peer D_ID */ | 919 | u32 peer_d_id; /* P2P peer D_ID */ |
920 | wwn_t physical_wwpn; /* WWPN of physical port */ | ||
921 | u32 physical_s_id; /* local FC port ID */ | ||
847 | struct ccw_device *ccw_device; /* S/390 ccw device */ | 922 | struct ccw_device *ccw_device; /* S/390 ccw device */ |
848 | u8 fc_service_class; | 923 | u8 fc_service_class; |
849 | u32 fc_topology; /* FC topology */ | 924 | u32 fc_topology; /* FC topology */ |
850 | u32 fc_link_speed; /* FC interface speed */ | ||
851 | u32 hydra_version; /* Hydra version */ | 925 | u32 hydra_version; /* Hydra version */ |
852 | u32 fsf_lic_version; | 926 | u32 fsf_lic_version; |
853 | u32 supported_features;/* of FCP channel */ | 927 | u32 adapter_features; /* FCP channel features */ |
928 | u32 connection_features; /* host connection features */ | ||
854 | u32 hardware_version; /* of FCP channel */ | 929 | u32 hardware_version; /* of FCP channel */ |
855 | u8 serial_number[32]; /* of hardware */ | ||
856 | struct Scsi_Host *scsi_host; /* Pointer to mid-layer */ | 930 | struct Scsi_Host *scsi_host; /* Pointer to mid-layer */ |
857 | unsigned short scsi_host_no; /* Assigned host number */ | 931 | unsigned short scsi_host_no; /* Assigned host number */ |
858 | unsigned char name[9]; | 932 | unsigned char name[9]; |
@@ -889,11 +963,18 @@ struct zfcp_adapter { | |||
889 | u32 erp_low_mem_count; /* nr of erp actions waiting | 963 | u32 erp_low_mem_count; /* nr of erp actions waiting |
890 | for memory */ | 964 | for memory */ |
891 | struct zfcp_port *nameserver_port; /* adapter's nameserver */ | 965 | struct zfcp_port *nameserver_port; /* adapter's nameserver */ |
892 | debug_info_t *erp_dbf; /* S/390 debug features */ | 966 | debug_info_t *erp_dbf; |
893 | debug_info_t *abort_dbf; | 967 | debug_info_t *hba_dbf; |
894 | debug_info_t *in_els_dbf; | 968 | debug_info_t *san_dbf; /* debug feature areas */ |
895 | debug_info_t *cmd_dbf; | 969 | debug_info_t *scsi_dbf; |
896 | spinlock_t dbf_lock; | 970 | spinlock_t erp_dbf_lock; |
971 | spinlock_t hba_dbf_lock; | ||
972 | spinlock_t san_dbf_lock; | ||
973 | spinlock_t scsi_dbf_lock; | ||
974 | struct zfcp_erp_dbf_record erp_dbf_buf; | ||
975 | struct zfcp_hba_dbf_record hba_dbf_buf; | ||
976 | struct zfcp_san_dbf_record san_dbf_buf; | ||
977 | struct zfcp_scsi_dbf_record scsi_dbf_buf; | ||
897 | struct zfcp_adapter_mempool pool; /* Adapter memory pools */ | 978 | struct zfcp_adapter_mempool pool; /* Adapter memory pools */ |
898 | struct qdio_initialize qdio_init_data; /* for qdio_establish */ | 979 | struct qdio_initialize qdio_init_data; /* for qdio_establish */ |
899 | struct device generic_services; /* directory for WKA ports */ | 980 | struct device generic_services; /* directory for WKA ports */ |
@@ -919,7 +1000,7 @@ struct zfcp_port { | |||
919 | atomic_t status; /* status of this remote port */ | 1000 | atomic_t status; /* status of this remote port */ |
920 | wwn_t wwnn; /* WWNN if known */ | 1001 | wwn_t wwnn; /* WWNN if known */ |
921 | wwn_t wwpn; /* WWPN */ | 1002 | wwn_t wwpn; /* WWPN */ |
922 | fc_id_t d_id; /* D_ID */ | 1003 | u32 d_id; /* D_ID */ |
923 | u32 handle; /* handle assigned by FSF */ | 1004 | u32 handle; /* handle assigned by FSF */ |
924 | struct zfcp_erp_action erp_action; /* pending error recovery */ | 1005 | struct zfcp_erp_action erp_action; /* pending error recovery */ |
925 | atomic_t erp_counter; | 1006 | atomic_t erp_counter; |
@@ -963,11 +1044,13 @@ struct zfcp_fsf_req { | |||
963 | u32 fsf_command; /* FSF Command copy */ | 1044 | u32 fsf_command; /* FSF Command copy */ |
964 | struct fsf_qtcb *qtcb; /* address of associated QTCB */ | 1045 | struct fsf_qtcb *qtcb; /* address of associated QTCB */ |
965 | u32 seq_no; /* Sequence number of request */ | 1046 | u32 seq_no; /* Sequence number of request */ |
966 | union zfcp_req_data data; /* Info fields of request */ | 1047 | unsigned long data; /* private data of request */ |
967 | struct zfcp_erp_action *erp_action; /* used if this request is | 1048 | struct zfcp_erp_action *erp_action; /* used if this request is |
968 | issued on behalf of erp */ | 1049 | issued on behalf of erp */ |
969 | mempool_t *pool; /* used if request was alloacted | 1050 | mempool_t *pool; /* used if request was alloacted |
970 | from emergency pool */ | 1051 | from emergency pool */ |
1052 | unsigned long long issued; /* request sent time (STCK) */ | ||
1053 | struct zfcp_unit *unit; | ||
971 | }; | 1054 | }; |
972 | 1055 | ||
973 | typedef void zfcp_fsf_req_handler_t(struct zfcp_fsf_req*); | 1056 | typedef void zfcp_fsf_req_handler_t(struct zfcp_fsf_req*); |
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c index cb4f612550ba..023f4e558ae4 100644 --- a/drivers/s390/scsi/zfcp_erp.c +++ b/drivers/s390/scsi/zfcp_erp.c | |||
@@ -82,6 +82,7 @@ static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *); | |||
82 | static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *); | 82 | static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *); |
83 | static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *); | 83 | static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *); |
84 | static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *); | 84 | static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *); |
85 | static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *); | ||
85 | static int zfcp_erp_adapter_strategy_open_fsf_statusread( | 86 | static int zfcp_erp_adapter_strategy_open_fsf_statusread( |
86 | struct zfcp_erp_action *); | 87 | struct zfcp_erp_action *); |
87 | 88 | ||
@@ -345,13 +346,13 @@ zfcp_erp_adisc(struct zfcp_port *port) | |||
345 | 346 | ||
346 | /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports | 347 | /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports |
347 | without FC-AL-2 capability, so we don't set it */ | 348 | without FC-AL-2 capability, so we don't set it */ |
348 | adisc->wwpn = adapter->wwpn; | 349 | adisc->wwpn = fc_host_port_name(adapter->scsi_host); |
349 | adisc->wwnn = adapter->wwnn; | 350 | adisc->wwnn = fc_host_node_name(adapter->scsi_host); |
350 | adisc->nport_id = adapter->s_id; | 351 | adisc->nport_id = fc_host_port_id(adapter->scsi_host); |
351 | ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x " | 352 | ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x " |
352 | "(wwpn=0x%016Lx, wwnn=0x%016Lx, " | 353 | "(wwpn=0x%016Lx, wwnn=0x%016Lx, " |
353 | "hard_nport_id=0x%08x, nport_id=0x%08x)\n", | 354 | "hard_nport_id=0x%08x, nport_id=0x%08x)\n", |
354 | adapter->s_id, send_els->d_id, (wwn_t) adisc->wwpn, | 355 | adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn, |
355 | (wwn_t) adisc->wwnn, adisc->hard_nport_id, | 356 | (wwn_t) adisc->wwnn, adisc->hard_nport_id, |
356 | adisc->nport_id); | 357 | adisc->nport_id); |
357 | 358 | ||
@@ -404,7 +405,7 @@ zfcp_erp_adisc_handler(unsigned long data) | |||
404 | struct zfcp_send_els *send_els; | 405 | struct zfcp_send_els *send_els; |
405 | struct zfcp_port *port; | 406 | struct zfcp_port *port; |
406 | struct zfcp_adapter *adapter; | 407 | struct zfcp_adapter *adapter; |
407 | fc_id_t d_id; | 408 | u32 d_id; |
408 | struct zfcp_ls_adisc_acc *adisc; | 409 | struct zfcp_ls_adisc_acc *adisc; |
409 | 410 | ||
410 | send_els = (struct zfcp_send_els *) data; | 411 | send_els = (struct zfcp_send_els *) data; |
@@ -435,9 +436,9 @@ zfcp_erp_adisc_handler(unsigned long data) | |||
435 | ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id " | 436 | ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id " |
436 | "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, " | 437 | "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, " |
437 | "hard_nport_id=0x%08x, nport_id=0x%08x)\n", | 438 | "hard_nport_id=0x%08x, nport_id=0x%08x)\n", |
438 | d_id, adapter->s_id, (wwn_t) adisc->wwpn, | 439 | d_id, fc_host_port_id(adapter->scsi_host), |
439 | (wwn_t) adisc->wwnn, adisc->hard_nport_id, | 440 | (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn, |
440 | adisc->nport_id); | 441 | adisc->hard_nport_id, adisc->nport_id); |
441 | 442 | ||
442 | /* set wwnn for port */ | 443 | /* set wwnn for port */ |
443 | if (port->wwnn == 0) | 444 | if (port->wwnn == 0) |
@@ -886,7 +887,7 @@ static int | |||
886 | zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action) | 887 | zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action) |
887 | { | 888 | { |
888 | int retval = 0; | 889 | int retval = 0; |
889 | struct zfcp_fsf_req *fsf_req; | 890 | struct zfcp_fsf_req *fsf_req = NULL; |
890 | struct zfcp_adapter *adapter = erp_action->adapter; | 891 | struct zfcp_adapter *adapter = erp_action->adapter; |
891 | 892 | ||
892 | if (erp_action->fsf_req) { | 893 | if (erp_action->fsf_req) { |
@@ -896,7 +897,7 @@ zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action) | |||
896 | list_for_each_entry(fsf_req, &adapter->fsf_req_list_head, list) | 897 | list_for_each_entry(fsf_req, &adapter->fsf_req_list_head, list) |
897 | if (fsf_req == erp_action->fsf_req) | 898 | if (fsf_req == erp_action->fsf_req) |
898 | break; | 899 | break; |
899 | if (fsf_req == erp_action->fsf_req) { | 900 | if (fsf_req && (fsf_req->erp_action == erp_action)) { |
900 | /* fsf_req still exists */ | 901 | /* fsf_req still exists */ |
901 | debug_text_event(adapter->erp_dbf, 3, "a_ca_req"); | 902 | debug_text_event(adapter->erp_dbf, 3, "a_ca_req"); |
902 | debug_event(adapter->erp_dbf, 3, &fsf_req, | 903 | debug_event(adapter->erp_dbf, 3, &fsf_req, |
@@ -2258,16 +2259,21 @@ zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action) | |||
2258 | static int | 2259 | static int |
2259 | zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action) | 2260 | zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action) |
2260 | { | 2261 | { |
2261 | int retval; | 2262 | int xconfig, xport; |
2263 | |||
2264 | if (atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
2265 | &erp_action->adapter->status)) { | ||
2266 | zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); | ||
2267 | atomic_set(&erp_action->adapter->erp_counter, 0); | ||
2268 | return ZFCP_ERP_FAILED; | ||
2269 | } | ||
2262 | 2270 | ||
2263 | /* do 'exchange configuration data' */ | 2271 | xconfig = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action); |
2264 | retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action); | 2272 | xport = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); |
2265 | if (retval == ZFCP_ERP_FAILED) | 2273 | if ((xconfig == ZFCP_ERP_FAILED) || (xport == ZFCP_ERP_FAILED)) |
2266 | return retval; | 2274 | return ZFCP_ERP_FAILED; |
2267 | 2275 | ||
2268 | /* start the desired number of Status Reads */ | 2276 | return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action); |
2269 | retval = zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action); | ||
2270 | return retval; | ||
2271 | } | 2277 | } |
2272 | 2278 | ||
2273 | /* | 2279 | /* |
@@ -2291,7 +2297,9 @@ zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action) | |||
2291 | atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, | 2297 | atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, |
2292 | &adapter->status); | 2298 | &adapter->status); |
2293 | ZFCP_LOG_DEBUG("Doing exchange config data\n"); | 2299 | ZFCP_LOG_DEBUG("Doing exchange config data\n"); |
2300 | write_lock(&adapter->erp_lock); | ||
2294 | zfcp_erp_action_to_running(erp_action); | 2301 | zfcp_erp_action_to_running(erp_action); |
2302 | write_unlock(&adapter->erp_lock); | ||
2295 | zfcp_erp_timeout_init(erp_action); | 2303 | zfcp_erp_timeout_init(erp_action); |
2296 | if (zfcp_fsf_exchange_config_data(erp_action)) { | 2304 | if (zfcp_fsf_exchange_config_data(erp_action)) { |
2297 | retval = ZFCP_ERP_FAILED; | 2305 | retval = ZFCP_ERP_FAILED; |
@@ -2348,6 +2356,76 @@ zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action) | |||
2348 | return retval; | 2356 | return retval; |
2349 | } | 2357 | } |
2350 | 2358 | ||
2359 | static int | ||
2360 | zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action) | ||
2361 | { | ||
2362 | int retval = ZFCP_ERP_SUCCEEDED; | ||
2363 | int retries; | ||
2364 | int sleep; | ||
2365 | struct zfcp_adapter *adapter = erp_action->adapter; | ||
2366 | |||
2367 | atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); | ||
2368 | |||
2369 | for (retries = 0; ; retries++) { | ||
2370 | ZFCP_LOG_DEBUG("Doing exchange port data\n"); | ||
2371 | zfcp_erp_action_to_running(erp_action); | ||
2372 | zfcp_erp_timeout_init(erp_action); | ||
2373 | if (zfcp_fsf_exchange_port_data(erp_action, adapter, NULL)) { | ||
2374 | retval = ZFCP_ERP_FAILED; | ||
2375 | debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf"); | ||
2376 | ZFCP_LOG_INFO("error: initiation of exchange of " | ||
2377 | "port data failed for adapter %s\n", | ||
2378 | zfcp_get_busid_by_adapter(adapter)); | ||
2379 | break; | ||
2380 | } | ||
2381 | debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok"); | ||
2382 | ZFCP_LOG_DEBUG("Xchange underway\n"); | ||
2383 | |||
2384 | /* | ||
2385 | * Why this works: | ||
2386 | * Both the normal completion handler as well as the timeout | ||
2387 | * handler will do an 'up' when the 'exchange port data' | ||
2388 | * request completes or times out. Thus, the signal to go on | ||
2389 | * won't be lost utilizing this semaphore. | ||
2390 | * Furthermore, this 'adapter_reopen' action is | ||
2391 | * guaranteed to be the only action being there (highest action | ||
2392 | * which prevents other actions from being created). | ||
2393 | * Resulting from that, the wake signal recognized here | ||
2394 | * _must_ be the one belonging to the 'exchange port | ||
2395 | * data' request. | ||
2396 | */ | ||
2397 | down(&adapter->erp_ready_sem); | ||
2398 | if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { | ||
2399 | ZFCP_LOG_INFO("error: exchange of port data " | ||
2400 | "for adapter %s timed out\n", | ||
2401 | zfcp_get_busid_by_adapter(adapter)); | ||
2402 | break; | ||
2403 | } | ||
2404 | |||
2405 | if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
2406 | &adapter->status)) | ||
2407 | break; | ||
2408 | |||
2409 | ZFCP_LOG_DEBUG("host connection still initialising... " | ||
2410 | "waiting and retrying...\n"); | ||
2411 | /* sleep a little bit before retry */ | ||
2412 | sleep = retries < ZFCP_EXCHANGE_PORT_DATA_SHORT_RETRIES ? | ||
2413 | ZFCP_EXCHANGE_PORT_DATA_SHORT_SLEEP : | ||
2414 | ZFCP_EXCHANGE_PORT_DATA_LONG_SLEEP; | ||
2415 | msleep(jiffies_to_msecs(sleep)); | ||
2416 | } | ||
2417 | |||
2418 | if (atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
2419 | &adapter->status)) { | ||
2420 | ZFCP_LOG_INFO("error: exchange of port data for " | ||
2421 | "adapter %s failed\n", | ||
2422 | zfcp_get_busid_by_adapter(adapter)); | ||
2423 | retval = ZFCP_ERP_FAILED; | ||
2424 | } | ||
2425 | |||
2426 | return retval; | ||
2427 | } | ||
2428 | |||
2351 | /* | 2429 | /* |
2352 | * function: | 2430 | * function: |
2353 | * | 2431 | * |
@@ -3194,11 +3272,19 @@ zfcp_erp_action_enqueue(int action, | |||
3194 | /* fall through !!! */ | 3272 | /* fall through !!! */ |
3195 | 3273 | ||
3196 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: | 3274 | case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: |
3197 | if (atomic_test_mask | 3275 | if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, |
3198 | (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status) | 3276 | &port->status)) { |
3199 | && port->erp_action.action == | 3277 | if (port->erp_action.action != |
3200 | ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) { | 3278 | ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) { |
3201 | debug_text_event(adapter->erp_dbf, 4, "pf_actenq_drp"); | 3279 | ZFCP_LOG_INFO("dropped erp action %i (port " |
3280 | "0x%016Lx, action in use: %i)\n", | ||
3281 | action, port->wwpn, | ||
3282 | port->erp_action.action); | ||
3283 | debug_text_event(adapter->erp_dbf, 4, | ||
3284 | "pf_actenq_drp"); | ||
3285 | } else | ||
3286 | debug_text_event(adapter->erp_dbf, 4, | ||
3287 | "pf_actenq_drpcp"); | ||
3202 | debug_event(adapter->erp_dbf, 4, &port->wwpn, | 3288 | debug_event(adapter->erp_dbf, 4, &port->wwpn, |
3203 | sizeof (wwn_t)); | 3289 | sizeof (wwn_t)); |
3204 | goto out; | 3290 | goto out; |
@@ -3589,6 +3675,9 @@ zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter) | |||
3589 | struct zfcp_port *port; | 3675 | struct zfcp_port *port; |
3590 | unsigned long flags; | 3676 | unsigned long flags; |
3591 | 3677 | ||
3678 | if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) | ||
3679 | return; | ||
3680 | |||
3592 | debug_text_event(adapter->erp_dbf, 3, "a_access_recover"); | 3681 | debug_text_event(adapter->erp_dbf, 3, "a_access_recover"); |
3593 | debug_event(adapter->erp_dbf, 3, &adapter->name, 8); | 3682 | debug_event(adapter->erp_dbf, 3, &adapter->name, 8); |
3594 | 3683 | ||
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h index cd98a2de9f8f..c3782261cb5c 100644 --- a/drivers/s390/scsi/zfcp_ext.h +++ b/drivers/s390/scsi/zfcp_ext.h | |||
@@ -96,7 +96,8 @@ extern int zfcp_fsf_open_unit(struct zfcp_erp_action *); | |||
96 | extern int zfcp_fsf_close_unit(struct zfcp_erp_action *); | 96 | extern int zfcp_fsf_close_unit(struct zfcp_erp_action *); |
97 | 97 | ||
98 | extern int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *); | 98 | extern int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *); |
99 | extern int zfcp_fsf_exchange_port_data(struct zfcp_adapter *, | 99 | extern int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *, |
100 | struct zfcp_adapter *, | ||
100 | struct fsf_qtcb_bottom_port *); | 101 | struct fsf_qtcb_bottom_port *); |
101 | extern int zfcp_fsf_control_file(struct zfcp_adapter *, struct zfcp_fsf_req **, | 102 | extern int zfcp_fsf_control_file(struct zfcp_adapter *, struct zfcp_fsf_req **, |
102 | u32, u32, struct zfcp_sg_list *); | 103 | u32, u32, struct zfcp_sg_list *); |
@@ -109,7 +110,6 @@ extern int zfcp_fsf_req_create(struct zfcp_adapter *, u32, int, mempool_t *, | |||
109 | extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *, | 110 | extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *, |
110 | struct zfcp_erp_action *); | 111 | struct zfcp_erp_action *); |
111 | extern int zfcp_fsf_send_els(struct zfcp_send_els *); | 112 | extern int zfcp_fsf_send_els(struct zfcp_send_els *); |
112 | extern int zfcp_fsf_req_wait_and_cleanup(struct zfcp_fsf_req *, int, u32 *); | ||
113 | extern int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *, | 113 | extern int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *, |
114 | struct zfcp_unit *, | 114 | struct zfcp_unit *, |
115 | struct scsi_cmnd *, | 115 | struct scsi_cmnd *, |
@@ -182,9 +182,25 @@ extern void zfcp_erp_port_access_changed(struct zfcp_port *); | |||
182 | extern void zfcp_erp_unit_access_changed(struct zfcp_unit *); | 182 | extern void zfcp_erp_unit_access_changed(struct zfcp_unit *); |
183 | 183 | ||
184 | /******************************** AUX ****************************************/ | 184 | /******************************** AUX ****************************************/ |
185 | extern void zfcp_cmd_dbf_event_fsf(const char *, struct zfcp_fsf_req *, | 185 | extern void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *); |
186 | void *, int); | 186 | extern void zfcp_hba_dbf_event_fsf_unsol(const char *, struct zfcp_adapter *, |
187 | extern void zfcp_cmd_dbf_event_scsi(const char *, struct scsi_cmnd *); | 187 | struct fsf_status_read_buffer *); |
188 | extern void zfcp_in_els_dbf_event(struct zfcp_adapter *, const char *, | 188 | extern void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *, |
189 | struct fsf_status_read_buffer *, int); | 189 | unsigned int, unsigned int, unsigned int, |
190 | int, int); | ||
191 | |||
192 | extern void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *); | ||
193 | extern void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *); | ||
194 | extern void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *); | ||
195 | extern void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *); | ||
196 | extern void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *); | ||
197 | |||
198 | extern void zfcp_scsi_dbf_event_result(const char *, int, struct zfcp_adapter *, | ||
199 | struct scsi_cmnd *); | ||
200 | extern void zfcp_scsi_dbf_event_abort(const char *, struct zfcp_adapter *, | ||
201 | struct scsi_cmnd *, | ||
202 | struct zfcp_fsf_req *); | ||
203 | extern void zfcp_scsi_dbf_event_devreset(const char *, u8, struct zfcp_unit *, | ||
204 | struct scsi_cmnd *); | ||
205 | |||
190 | #endif /* ZFCP_EXT_H */ | 206 | #endif /* ZFCP_EXT_H */ |
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c index c007b6424e74..3b0fc1163f5f 100644 --- a/drivers/s390/scsi/zfcp_fsf.c +++ b/drivers/s390/scsi/zfcp_fsf.c | |||
@@ -59,6 +59,8 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *, struct timer_list *); | |||
59 | static int zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *); | 59 | static int zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *); |
60 | static int zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *); | 60 | static int zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *); |
61 | static int zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *); | 61 | static int zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *); |
62 | static void zfcp_fsf_link_down_info_eval(struct zfcp_adapter *, | ||
63 | struct fsf_link_down_info *); | ||
62 | static int zfcp_fsf_req_dispatch(struct zfcp_fsf_req *); | 64 | static int zfcp_fsf_req_dispatch(struct zfcp_fsf_req *); |
63 | static void zfcp_fsf_req_dismiss(struct zfcp_fsf_req *); | 65 | static void zfcp_fsf_req_dismiss(struct zfcp_fsf_req *); |
64 | 66 | ||
@@ -285,51 +287,51 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
285 | { | 287 | { |
286 | int retval = 0; | 288 | int retval = 0; |
287 | struct zfcp_adapter *adapter = fsf_req->adapter; | 289 | struct zfcp_adapter *adapter = fsf_req->adapter; |
290 | struct fsf_qtcb *qtcb = fsf_req->qtcb; | ||
291 | union fsf_prot_status_qual *prot_status_qual = | ||
292 | &qtcb->prefix.prot_status_qual; | ||
288 | 293 | ||
289 | ZFCP_LOG_DEBUG("QTCB is at %p\n", fsf_req->qtcb); | 294 | zfcp_hba_dbf_event_fsf_response(fsf_req); |
290 | 295 | ||
291 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { | 296 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { |
292 | ZFCP_LOG_DEBUG("fsf_req 0x%lx has been dismissed\n", | 297 | ZFCP_LOG_DEBUG("fsf_req 0x%lx has been dismissed\n", |
293 | (unsigned long) fsf_req); | 298 | (unsigned long) fsf_req); |
294 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR | | 299 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR | |
295 | ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */ | 300 | ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */ |
296 | zfcp_cmd_dbf_event_fsf("dismiss", fsf_req, NULL, 0); | ||
297 | goto skip_protstatus; | 301 | goto skip_protstatus; |
298 | } | 302 | } |
299 | 303 | ||
300 | /* log additional information provided by FSF (if any) */ | 304 | /* log additional information provided by FSF (if any) */ |
301 | if (unlikely(fsf_req->qtcb->header.log_length)) { | 305 | if (unlikely(qtcb->header.log_length)) { |
302 | /* do not trust them ;-) */ | 306 | /* do not trust them ;-) */ |
303 | if (fsf_req->qtcb->header.log_start > sizeof(struct fsf_qtcb)) { | 307 | if (qtcb->header.log_start > sizeof(struct fsf_qtcb)) { |
304 | ZFCP_LOG_NORMAL | 308 | ZFCP_LOG_NORMAL |
305 | ("bug: ULP (FSF logging) log data starts " | 309 | ("bug: ULP (FSF logging) log data starts " |
306 | "beyond end of packet header. Ignored. " | 310 | "beyond end of packet header. Ignored. " |
307 | "(start=%i, size=%li)\n", | 311 | "(start=%i, size=%li)\n", |
308 | fsf_req->qtcb->header.log_start, | 312 | qtcb->header.log_start, |
309 | sizeof(struct fsf_qtcb)); | 313 | sizeof(struct fsf_qtcb)); |
310 | goto forget_log; | 314 | goto forget_log; |
311 | } | 315 | } |
312 | if ((size_t) (fsf_req->qtcb->header.log_start + | 316 | if ((size_t) (qtcb->header.log_start + qtcb->header.log_length) |
313 | fsf_req->qtcb->header.log_length) | ||
314 | > sizeof(struct fsf_qtcb)) { | 317 | > sizeof(struct fsf_qtcb)) { |
315 | ZFCP_LOG_NORMAL("bug: ULP (FSF logging) log data ends " | 318 | ZFCP_LOG_NORMAL("bug: ULP (FSF logging) log data ends " |
316 | "beyond end of packet header. Ignored. " | 319 | "beyond end of packet header. Ignored. " |
317 | "(start=%i, length=%i, size=%li)\n", | 320 | "(start=%i, length=%i, size=%li)\n", |
318 | fsf_req->qtcb->header.log_start, | 321 | qtcb->header.log_start, |
319 | fsf_req->qtcb->header.log_length, | 322 | qtcb->header.log_length, |
320 | sizeof(struct fsf_qtcb)); | 323 | sizeof(struct fsf_qtcb)); |
321 | goto forget_log; | 324 | goto forget_log; |
322 | } | 325 | } |
323 | ZFCP_LOG_TRACE("ULP log data: \n"); | 326 | ZFCP_LOG_TRACE("ULP log data: \n"); |
324 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, | 327 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, |
325 | (char *) fsf_req->qtcb + | 328 | (char *) qtcb + qtcb->header.log_start, |
326 | fsf_req->qtcb->header.log_start, | 329 | qtcb->header.log_length); |
327 | fsf_req->qtcb->header.log_length); | ||
328 | } | 330 | } |
329 | forget_log: | 331 | forget_log: |
330 | 332 | ||
331 | /* evaluate FSF Protocol Status */ | 333 | /* evaluate FSF Protocol Status */ |
332 | switch (fsf_req->qtcb->prefix.prot_status) { | 334 | switch (qtcb->prefix.prot_status) { |
333 | 335 | ||
334 | case FSF_PROT_GOOD: | 336 | case FSF_PROT_GOOD: |
335 | case FSF_PROT_FSF_STATUS_PRESENTED: | 337 | case FSF_PROT_FSF_STATUS_PRESENTED: |
@@ -340,14 +342,9 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
340 | "microcode of version 0x%x, the device driver " | 342 | "microcode of version 0x%x, the device driver " |
341 | "only supports 0x%x. Aborting.\n", | 343 | "only supports 0x%x. Aborting.\n", |
342 | zfcp_get_busid_by_adapter(adapter), | 344 | zfcp_get_busid_by_adapter(adapter), |
343 | fsf_req->qtcb->prefix.prot_status_qual. | 345 | prot_status_qual->version_error.fsf_version, |
344 | version_error.fsf_version, ZFCP_QTCB_VERSION); | 346 | ZFCP_QTCB_VERSION); |
345 | /* stop operation for this adapter */ | ||
346 | debug_text_exception(adapter->erp_dbf, 0, "prot_ver_err"); | ||
347 | zfcp_erp_adapter_shutdown(adapter, 0); | 347 | zfcp_erp_adapter_shutdown(adapter, 0); |
348 | zfcp_cmd_dbf_event_fsf("qverserr", fsf_req, | ||
349 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
350 | sizeof (union fsf_prot_status_qual)); | ||
351 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 348 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
352 | break; | 349 | break; |
353 | 350 | ||
@@ -355,16 +352,10 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
355 | ZFCP_LOG_NORMAL("bug: Sequence number mismatch between " | 352 | ZFCP_LOG_NORMAL("bug: Sequence number mismatch between " |
356 | "driver (0x%x) and adapter %s (0x%x). " | 353 | "driver (0x%x) and adapter %s (0x%x). " |
357 | "Restarting all operations on this adapter.\n", | 354 | "Restarting all operations on this adapter.\n", |
358 | fsf_req->qtcb->prefix.req_seq_no, | 355 | qtcb->prefix.req_seq_no, |
359 | zfcp_get_busid_by_adapter(adapter), | 356 | zfcp_get_busid_by_adapter(adapter), |
360 | fsf_req->qtcb->prefix.prot_status_qual. | 357 | prot_status_qual->sequence_error.exp_req_seq_no); |
361 | sequence_error.exp_req_seq_no); | ||
362 | debug_text_exception(adapter->erp_dbf, 0, "prot_seq_err"); | ||
363 | /* restart operation on this adapter */ | ||
364 | zfcp_erp_adapter_reopen(adapter, 0); | 358 | zfcp_erp_adapter_reopen(adapter, 0); |
365 | zfcp_cmd_dbf_event_fsf("seqnoerr", fsf_req, | ||
366 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
367 | sizeof (union fsf_prot_status_qual)); | ||
368 | fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY; | 359 | fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY; |
369 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 360 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
370 | break; | 361 | break; |
@@ -375,116 +366,35 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
375 | "that used on adapter %s. " | 366 | "that used on adapter %s. " |
376 | "Stopping all operations on this adapter.\n", | 367 | "Stopping all operations on this adapter.\n", |
377 | zfcp_get_busid_by_adapter(adapter)); | 368 | zfcp_get_busid_by_adapter(adapter)); |
378 | debug_text_exception(adapter->erp_dbf, 0, "prot_unsup_qtcb"); | ||
379 | zfcp_erp_adapter_shutdown(adapter, 0); | 369 | zfcp_erp_adapter_shutdown(adapter, 0); |
380 | zfcp_cmd_dbf_event_fsf("unsqtcbt", fsf_req, | ||
381 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
382 | sizeof (union fsf_prot_status_qual)); | ||
383 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 370 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
384 | break; | 371 | break; |
385 | 372 | ||
386 | case FSF_PROT_HOST_CONNECTION_INITIALIZING: | 373 | case FSF_PROT_HOST_CONNECTION_INITIALIZING: |
387 | zfcp_cmd_dbf_event_fsf("hconinit", fsf_req, | ||
388 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
389 | sizeof (union fsf_prot_status_qual)); | ||
390 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 374 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
391 | atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, | 375 | atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, |
392 | &(adapter->status)); | 376 | &(adapter->status)); |
393 | debug_text_event(adapter->erp_dbf, 3, "prot_con_init"); | ||
394 | break; | 377 | break; |
395 | 378 | ||
396 | case FSF_PROT_DUPLICATE_REQUEST_ID: | 379 | case FSF_PROT_DUPLICATE_REQUEST_ID: |
397 | if (fsf_req->qtcb) { | ||
398 | ZFCP_LOG_NORMAL("bug: The request identifier 0x%Lx " | 380 | ZFCP_LOG_NORMAL("bug: The request identifier 0x%Lx " |
399 | "to the adapter %s is ambiguous. " | 381 | "to the adapter %s is ambiguous. " |
400 | "Stopping all operations on this " | 382 | "Stopping all operations on this adapter.\n", |
401 | "adapter.\n", | 383 | *(unsigned long long*) |
402 | *(unsigned long long *) | 384 | (&qtcb->bottom.support.req_handle), |
403 | (&fsf_req->qtcb->bottom.support. | ||
404 | req_handle), | ||
405 | zfcp_get_busid_by_adapter(adapter)); | ||
406 | } else { | ||
407 | ZFCP_LOG_NORMAL("bug: The request identifier %p " | ||
408 | "to the adapter %s is ambiguous. " | ||
409 | "Stopping all operations on this " | ||
410 | "adapter. " | ||
411 | "(bug: got this for an unsolicited " | ||
412 | "status read request)\n", | ||
413 | fsf_req, | ||
414 | zfcp_get_busid_by_adapter(adapter)); | 385 | zfcp_get_busid_by_adapter(adapter)); |
415 | } | ||
416 | debug_text_exception(adapter->erp_dbf, 0, "prot_dup_id"); | ||
417 | zfcp_erp_adapter_shutdown(adapter, 0); | 386 | zfcp_erp_adapter_shutdown(adapter, 0); |
418 | zfcp_cmd_dbf_event_fsf("dupreqid", fsf_req, | ||
419 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
420 | sizeof (union fsf_prot_status_qual)); | ||
421 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 387 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
422 | break; | 388 | break; |
423 | 389 | ||
424 | case FSF_PROT_LINK_DOWN: | 390 | case FSF_PROT_LINK_DOWN: |
425 | /* | 391 | zfcp_fsf_link_down_info_eval(adapter, |
426 | * 'test and set' is not atomic here - | 392 | &prot_status_qual->link_down_info); |
427 | * it's ok as long as calls to our response queue handler | ||
428 | * (and thus execution of this code here) are serialized | ||
429 | * by the qdio module | ||
430 | */ | ||
431 | if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
432 | &adapter->status)) { | ||
433 | switch (fsf_req->qtcb->prefix.prot_status_qual. | ||
434 | locallink_error.code) { | ||
435 | case FSF_PSQ_LINK_NOLIGHT: | ||
436 | ZFCP_LOG_INFO("The local link to adapter %s " | ||
437 | "is down (no light detected).\n", | ||
438 | zfcp_get_busid_by_adapter( | ||
439 | adapter)); | ||
440 | break; | ||
441 | case FSF_PSQ_LINK_WRAPPLUG: | ||
442 | ZFCP_LOG_INFO("The local link to adapter %s " | ||
443 | "is down (wrap plug detected).\n", | ||
444 | zfcp_get_busid_by_adapter( | ||
445 | adapter)); | ||
446 | break; | ||
447 | case FSF_PSQ_LINK_NOFCP: | ||
448 | ZFCP_LOG_INFO("The local link to adapter %s " | ||
449 | "is down (adjacent node on " | ||
450 | "link does not support FCP).\n", | ||
451 | zfcp_get_busid_by_adapter( | ||
452 | adapter)); | ||
453 | break; | ||
454 | default: | ||
455 | ZFCP_LOG_INFO("The local link to adapter %s " | ||
456 | "is down " | ||
457 | "(warning: unknown reason " | ||
458 | "code).\n", | ||
459 | zfcp_get_busid_by_adapter( | ||
460 | adapter)); | ||
461 | break; | ||
462 | |||
463 | } | ||
464 | /* | ||
465 | * Due to the 'erp failed' flag the adapter won't | ||
466 | * be recovered but will be just set to 'blocked' | ||
467 | * state. All subordinary devices will have state | ||
468 | * 'blocked' and 'erp failed', too. | ||
469 | * Thus the adapter is still able to provide | ||
470 | * 'link up' status without being flooded with | ||
471 | * requests. | ||
472 | * (note: even 'close port' is not permitted) | ||
473 | */ | ||
474 | ZFCP_LOG_INFO("Stopping all operations for adapter " | ||
475 | "%s.\n", | ||
476 | zfcp_get_busid_by_adapter(adapter)); | ||
477 | atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | | ||
478 | ZFCP_STATUS_COMMON_ERP_FAILED, | ||
479 | &adapter->status); | ||
480 | zfcp_erp_adapter_reopen(adapter, 0); | ||
481 | } | ||
482 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 393 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
483 | break; | 394 | break; |
484 | 395 | ||
485 | case FSF_PROT_REEST_QUEUE: | 396 | case FSF_PROT_REEST_QUEUE: |
486 | debug_text_event(adapter->erp_dbf, 1, "prot_reest_queue"); | 397 | ZFCP_LOG_NORMAL("The local link to adapter with " |
487 | ZFCP_LOG_INFO("The local link to adapter with " | ||
488 | "%s was re-plugged. " | 398 | "%s was re-plugged. " |
489 | "Re-starting operations on this adapter.\n", | 399 | "Re-starting operations on this adapter.\n", |
490 | zfcp_get_busid_by_adapter(adapter)); | 400 | zfcp_get_busid_by_adapter(adapter)); |
@@ -495,9 +405,6 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
495 | zfcp_erp_adapter_reopen(adapter, | 405 | zfcp_erp_adapter_reopen(adapter, |
496 | ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 406 | ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
497 | | ZFCP_STATUS_COMMON_ERP_FAILED); | 407 | | ZFCP_STATUS_COMMON_ERP_FAILED); |
498 | zfcp_cmd_dbf_event_fsf("reestque", fsf_req, | ||
499 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
500 | sizeof (union fsf_prot_status_qual)); | ||
501 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 408 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
502 | break; | 409 | break; |
503 | 410 | ||
@@ -507,12 +414,7 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
507 | "Restarting all operations on this " | 414 | "Restarting all operations on this " |
508 | "adapter.\n", | 415 | "adapter.\n", |
509 | zfcp_get_busid_by_adapter(adapter)); | 416 | zfcp_get_busid_by_adapter(adapter)); |
510 | debug_text_event(adapter->erp_dbf, 0, "prot_err_sta"); | ||
511 | /* restart operation on this adapter */ | ||
512 | zfcp_erp_adapter_reopen(adapter, 0); | 417 | zfcp_erp_adapter_reopen(adapter, 0); |
513 | zfcp_cmd_dbf_event_fsf("proterrs", fsf_req, | ||
514 | &fsf_req->qtcb->prefix.prot_status_qual, | ||
515 | sizeof (union fsf_prot_status_qual)); | ||
516 | fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY; | 418 | fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY; |
517 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 419 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
518 | break; | 420 | break; |
@@ -524,11 +426,7 @@ zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
524 | "Stopping all operations on this adapter. " | 426 | "Stopping all operations on this adapter. " |
525 | "(debug info 0x%x).\n", | 427 | "(debug info 0x%x).\n", |
526 | zfcp_get_busid_by_adapter(adapter), | 428 | zfcp_get_busid_by_adapter(adapter), |
527 | fsf_req->qtcb->prefix.prot_status); | 429 | qtcb->prefix.prot_status); |
528 | debug_text_event(adapter->erp_dbf, 0, "prot_inval:"); | ||
529 | debug_exception(adapter->erp_dbf, 0, | ||
530 | &fsf_req->qtcb->prefix.prot_status, | ||
531 | sizeof (u32)); | ||
532 | zfcp_erp_adapter_shutdown(adapter, 0); | 430 | zfcp_erp_adapter_shutdown(adapter, 0); |
533 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 431 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
534 | } | 432 | } |
@@ -568,28 +466,18 @@ zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *fsf_req) | |||
568 | "(debug info 0x%x).\n", | 466 | "(debug info 0x%x).\n", |
569 | zfcp_get_busid_by_adapter(fsf_req->adapter), | 467 | zfcp_get_busid_by_adapter(fsf_req->adapter), |
570 | fsf_req->qtcb->header.fsf_command); | 468 | fsf_req->qtcb->header.fsf_command); |
571 | debug_text_exception(fsf_req->adapter->erp_dbf, 0, | ||
572 | "fsf_s_unknown"); | ||
573 | zfcp_erp_adapter_shutdown(fsf_req->adapter, 0); | 469 | zfcp_erp_adapter_shutdown(fsf_req->adapter, 0); |
574 | zfcp_cmd_dbf_event_fsf("unknownc", fsf_req, | ||
575 | &fsf_req->qtcb->header.fsf_status_qual, | ||
576 | sizeof (union fsf_status_qual)); | ||
577 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 470 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
578 | break; | 471 | break; |
579 | 472 | ||
580 | case FSF_FCP_RSP_AVAILABLE: | 473 | case FSF_FCP_RSP_AVAILABLE: |
581 | ZFCP_LOG_DEBUG("FCP Sense data will be presented to the " | 474 | ZFCP_LOG_DEBUG("FCP Sense data will be presented to the " |
582 | "SCSI stack.\n"); | 475 | "SCSI stack.\n"); |
583 | debug_text_event(fsf_req->adapter->erp_dbf, 3, "fsf_s_rsp"); | ||
584 | break; | 476 | break; |
585 | 477 | ||
586 | case FSF_ADAPTER_STATUS_AVAILABLE: | 478 | case FSF_ADAPTER_STATUS_AVAILABLE: |
587 | debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_s_astatus"); | ||
588 | zfcp_fsf_fsfstatus_qual_eval(fsf_req); | 479 | zfcp_fsf_fsfstatus_qual_eval(fsf_req); |
589 | break; | 480 | break; |
590 | |||
591 | default: | ||
592 | break; | ||
593 | } | 481 | } |
594 | 482 | ||
595 | skip_fsfstatus: | 483 | skip_fsfstatus: |
@@ -617,44 +505,28 @@ zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *fsf_req) | |||
617 | 505 | ||
618 | switch (fsf_req->qtcb->header.fsf_status_qual.word[0]) { | 506 | switch (fsf_req->qtcb->header.fsf_status_qual.word[0]) { |
619 | case FSF_SQ_FCP_RSP_AVAILABLE: | 507 | case FSF_SQ_FCP_RSP_AVAILABLE: |
620 | debug_text_event(fsf_req->adapter->erp_dbf, 4, "fsf_sq_rsp"); | ||
621 | break; | 508 | break; |
622 | case FSF_SQ_RETRY_IF_POSSIBLE: | 509 | case FSF_SQ_RETRY_IF_POSSIBLE: |
623 | /* The SCSI-stack may now issue retries or escalate */ | 510 | /* The SCSI-stack may now issue retries or escalate */ |
624 | debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_sq_retry"); | ||
625 | zfcp_cmd_dbf_event_fsf("sqretry", fsf_req, | ||
626 | &fsf_req->qtcb->header.fsf_status_qual, | ||
627 | sizeof (union fsf_status_qual)); | ||
628 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 511 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
629 | break; | 512 | break; |
630 | case FSF_SQ_COMMAND_ABORTED: | 513 | case FSF_SQ_COMMAND_ABORTED: |
631 | /* Carry the aborted state on to upper layer */ | 514 | /* Carry the aborted state on to upper layer */ |
632 | debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_sq_abort"); | ||
633 | zfcp_cmd_dbf_event_fsf("sqabort", fsf_req, | ||
634 | &fsf_req->qtcb->header.fsf_status_qual, | ||
635 | sizeof (union fsf_status_qual)); | ||
636 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTED; | 515 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTED; |
637 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 516 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
638 | break; | 517 | break; |
639 | case FSF_SQ_NO_RECOM: | 518 | case FSF_SQ_NO_RECOM: |
640 | debug_text_exception(fsf_req->adapter->erp_dbf, 0, | ||
641 | "fsf_sq_no_rec"); | ||
642 | ZFCP_LOG_NORMAL("bug: No recommendation could be given for a" | 519 | ZFCP_LOG_NORMAL("bug: No recommendation could be given for a" |
643 | "problem on the adapter %s " | 520 | "problem on the adapter %s " |
644 | "Stopping all operations on this adapter. ", | 521 | "Stopping all operations on this adapter. ", |
645 | zfcp_get_busid_by_adapter(fsf_req->adapter)); | 522 | zfcp_get_busid_by_adapter(fsf_req->adapter)); |
646 | zfcp_erp_adapter_shutdown(fsf_req->adapter, 0); | 523 | zfcp_erp_adapter_shutdown(fsf_req->adapter, 0); |
647 | zfcp_cmd_dbf_event_fsf("sqnrecom", fsf_req, | ||
648 | &fsf_req->qtcb->header.fsf_status_qual, | ||
649 | sizeof (union fsf_status_qual)); | ||
650 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 524 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
651 | break; | 525 | break; |
652 | case FSF_SQ_ULP_PROGRAMMING_ERROR: | 526 | case FSF_SQ_ULP_PROGRAMMING_ERROR: |
653 | ZFCP_LOG_NORMAL("error: not enough SBALs for data transfer " | 527 | ZFCP_LOG_NORMAL("error: not enough SBALs for data transfer " |
654 | "(adapter %s)\n", | 528 | "(adapter %s)\n", |
655 | zfcp_get_busid_by_adapter(fsf_req->adapter)); | 529 | zfcp_get_busid_by_adapter(fsf_req->adapter)); |
656 | debug_text_exception(fsf_req->adapter->erp_dbf, 0, | ||
657 | "fsf_sq_ulp_err"); | ||
658 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 530 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
659 | break; | 531 | break; |
660 | case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: | 532 | case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: |
@@ -668,13 +540,6 @@ zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *fsf_req) | |||
668 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, | 540 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, |
669 | (char *) &fsf_req->qtcb->header.fsf_status_qual, | 541 | (char *) &fsf_req->qtcb->header.fsf_status_qual, |
670 | sizeof (union fsf_status_qual)); | 542 | sizeof (union fsf_status_qual)); |
671 | debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_sq_inval:"); | ||
672 | debug_exception(fsf_req->adapter->erp_dbf, 0, | ||
673 | &fsf_req->qtcb->header.fsf_status_qual.word[0], | ||
674 | sizeof (u32)); | ||
675 | zfcp_cmd_dbf_event_fsf("squndef", fsf_req, | ||
676 | &fsf_req->qtcb->header.fsf_status_qual, | ||
677 | sizeof (union fsf_status_qual)); | ||
678 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 543 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
679 | break; | 544 | break; |
680 | } | 545 | } |
@@ -682,6 +547,110 @@ zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *fsf_req) | |||
682 | return retval; | 547 | return retval; |
683 | } | 548 | } |
684 | 549 | ||
550 | /** | ||
551 | * zfcp_fsf_link_down_info_eval - evaluate link down information block | ||
552 | */ | ||
553 | static void | ||
554 | zfcp_fsf_link_down_info_eval(struct zfcp_adapter *adapter, | ||
555 | struct fsf_link_down_info *link_down) | ||
556 | { | ||
557 | switch (link_down->error_code) { | ||
558 | case FSF_PSQ_LINK_NO_LIGHT: | ||
559 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
560 | "(no light detected)\n", | ||
561 | zfcp_get_busid_by_adapter(adapter)); | ||
562 | break; | ||
563 | case FSF_PSQ_LINK_WRAP_PLUG: | ||
564 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
565 | "(wrap plug detected)\n", | ||
566 | zfcp_get_busid_by_adapter(adapter)); | ||
567 | break; | ||
568 | case FSF_PSQ_LINK_NO_FCP: | ||
569 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
570 | "(adjacent node on link does not support FCP)\n", | ||
571 | zfcp_get_busid_by_adapter(adapter)); | ||
572 | break; | ||
573 | case FSF_PSQ_LINK_FIRMWARE_UPDATE: | ||
574 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
575 | "(firmware update in progress)\n", | ||
576 | zfcp_get_busid_by_adapter(adapter)); | ||
577 | break; | ||
578 | case FSF_PSQ_LINK_INVALID_WWPN: | ||
579 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
580 | "(duplicate or invalid WWPN detected)\n", | ||
581 | zfcp_get_busid_by_adapter(adapter)); | ||
582 | break; | ||
583 | case FSF_PSQ_LINK_NO_NPIV_SUPPORT: | ||
584 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
585 | "(no support for NPIV by Fabric)\n", | ||
586 | zfcp_get_busid_by_adapter(adapter)); | ||
587 | break; | ||
588 | case FSF_PSQ_LINK_NO_FCP_RESOURCES: | ||
589 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
590 | "(out of resource in FCP daughtercard)\n", | ||
591 | zfcp_get_busid_by_adapter(adapter)); | ||
592 | break; | ||
593 | case FSF_PSQ_LINK_NO_FABRIC_RESOURCES: | ||
594 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
595 | "(out of resource in Fabric)\n", | ||
596 | zfcp_get_busid_by_adapter(adapter)); | ||
597 | break; | ||
598 | case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE: | ||
599 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
600 | "(unable to Fabric login)\n", | ||
601 | zfcp_get_busid_by_adapter(adapter)); | ||
602 | break; | ||
603 | case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED: | ||
604 | ZFCP_LOG_NORMAL("WWPN assignment file corrupted on adapter %s\n", | ||
605 | zfcp_get_busid_by_adapter(adapter)); | ||
606 | break; | ||
607 | case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED: | ||
608 | ZFCP_LOG_NORMAL("Mode table corrupted on adapter %s\n", | ||
609 | zfcp_get_busid_by_adapter(adapter)); | ||
610 | break; | ||
611 | case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT: | ||
612 | ZFCP_LOG_NORMAL("No WWPN for assignment table on adapter %s\n", | ||
613 | zfcp_get_busid_by_adapter(adapter)); | ||
614 | break; | ||
615 | default: | ||
616 | ZFCP_LOG_NORMAL("The local link to adapter %s is down " | ||
617 | "(warning: unknown reason code %d)\n", | ||
618 | zfcp_get_busid_by_adapter(adapter), | ||
619 | link_down->error_code); | ||
620 | } | ||
621 | |||
622 | if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) | ||
623 | ZFCP_LOG_DEBUG("Debug information to link down: " | ||
624 | "primary_status=0x%02x " | ||
625 | "ioerr_code=0x%02x " | ||
626 | "action_code=0x%02x " | ||
627 | "reason_code=0x%02x " | ||
628 | "explanation_code=0x%02x " | ||
629 | "vendor_specific_code=0x%02x\n", | ||
630 | link_down->primary_status, | ||
631 | link_down->ioerr_code, | ||
632 | link_down->action_code, | ||
633 | link_down->reason_code, | ||
634 | link_down->explanation_code, | ||
635 | link_down->vendor_specific_code); | ||
636 | |||
637 | if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
638 | &adapter->status)) { | ||
639 | atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | ||
640 | &adapter->status); | ||
641 | switch (link_down->error_code) { | ||
642 | case FSF_PSQ_LINK_NO_LIGHT: | ||
643 | case FSF_PSQ_LINK_WRAP_PLUG: | ||
644 | case FSF_PSQ_LINK_NO_FCP: | ||
645 | case FSF_PSQ_LINK_FIRMWARE_UPDATE: | ||
646 | zfcp_erp_adapter_reopen(adapter, 0); | ||
647 | break; | ||
648 | default: | ||
649 | zfcp_erp_adapter_failed(adapter); | ||
650 | } | ||
651 | } | ||
652 | } | ||
653 | |||
685 | /* | 654 | /* |
686 | * function: zfcp_fsf_req_dispatch | 655 | * function: zfcp_fsf_req_dispatch |
687 | * | 656 | * |
@@ -696,11 +665,6 @@ zfcp_fsf_req_dispatch(struct zfcp_fsf_req *fsf_req) | |||
696 | struct zfcp_adapter *adapter = fsf_req->adapter; | 665 | struct zfcp_adapter *adapter = fsf_req->adapter; |
697 | int retval = 0; | 666 | int retval = 0; |
698 | 667 | ||
699 | if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) { | ||
700 | ZFCP_LOG_TRACE("fsf_req=%p, QTCB=%p\n", fsf_req, fsf_req->qtcb); | ||
701 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, | ||
702 | (char *) fsf_req->qtcb, sizeof(struct fsf_qtcb)); | ||
703 | } | ||
704 | 668 | ||
705 | switch (fsf_req->fsf_command) { | 669 | switch (fsf_req->fsf_command) { |
706 | 670 | ||
@@ -760,13 +724,13 @@ zfcp_fsf_req_dispatch(struct zfcp_fsf_req *fsf_req) | |||
760 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 724 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
761 | ZFCP_LOG_NORMAL("bug: Command issued by the device driver is " | 725 | ZFCP_LOG_NORMAL("bug: Command issued by the device driver is " |
762 | "not supported by the adapter %s\n", | 726 | "not supported by the adapter %s\n", |
763 | zfcp_get_busid_by_adapter(fsf_req->adapter)); | 727 | zfcp_get_busid_by_adapter(adapter)); |
764 | if (fsf_req->fsf_command != fsf_req->qtcb->header.fsf_command) | 728 | if (fsf_req->fsf_command != fsf_req->qtcb->header.fsf_command) |
765 | ZFCP_LOG_NORMAL | 729 | ZFCP_LOG_NORMAL |
766 | ("bug: Command issued by the device driver differs " | 730 | ("bug: Command issued by the device driver differs " |
767 | "from the command returned by the adapter %s " | 731 | "from the command returned by the adapter %s " |
768 | "(debug info 0x%x, 0x%x).\n", | 732 | "(debug info 0x%x, 0x%x).\n", |
769 | zfcp_get_busid_by_adapter(fsf_req->adapter), | 733 | zfcp_get_busid_by_adapter(adapter), |
770 | fsf_req->fsf_command, | 734 | fsf_req->fsf_command, |
771 | fsf_req->qtcb->header.fsf_command); | 735 | fsf_req->qtcb->header.fsf_command); |
772 | } | 736 | } |
@@ -774,8 +738,6 @@ zfcp_fsf_req_dispatch(struct zfcp_fsf_req *fsf_req) | |||
774 | if (!erp_action) | 738 | if (!erp_action) |
775 | return retval; | 739 | return retval; |
776 | 740 | ||
777 | debug_text_event(adapter->erp_dbf, 3, "a_frh"); | ||
778 | debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); | ||
779 | zfcp_erp_async_handler(erp_action, 0); | 741 | zfcp_erp_async_handler(erp_action, 0); |
780 | 742 | ||
781 | return retval; | 743 | return retval; |
@@ -821,7 +783,7 @@ zfcp_fsf_status_read(struct zfcp_adapter *adapter, int req_flags) | |||
821 | goto failed_buf; | 783 | goto failed_buf; |
822 | } | 784 | } |
823 | memset(status_buffer, 0, sizeof (struct fsf_status_read_buffer)); | 785 | memset(status_buffer, 0, sizeof (struct fsf_status_read_buffer)); |
824 | fsf_req->data.status_read.buffer = status_buffer; | 786 | fsf_req->data = (unsigned long) status_buffer; |
825 | 787 | ||
826 | /* insert pointer to respective buffer */ | 788 | /* insert pointer to respective buffer */ |
827 | sbale = zfcp_qdio_sbale_curr(fsf_req); | 789 | sbale = zfcp_qdio_sbale_curr(fsf_req); |
@@ -846,6 +808,7 @@ zfcp_fsf_status_read(struct zfcp_adapter *adapter, int req_flags) | |||
846 | failed_buf: | 808 | failed_buf: |
847 | zfcp_fsf_req_free(fsf_req); | 809 | zfcp_fsf_req_free(fsf_req); |
848 | failed_req_create: | 810 | failed_req_create: |
811 | zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL); | ||
849 | out: | 812 | out: |
850 | write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags); | 813 | write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags); |
851 | return retval; | 814 | return retval; |
@@ -859,7 +822,7 @@ zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *fsf_req) | |||
859 | struct zfcp_port *port; | 822 | struct zfcp_port *port; |
860 | unsigned long flags; | 823 | unsigned long flags; |
861 | 824 | ||
862 | status_buffer = fsf_req->data.status_read.buffer; | 825 | status_buffer = (struct fsf_status_read_buffer *) fsf_req->data; |
863 | adapter = fsf_req->adapter; | 826 | adapter = fsf_req->adapter; |
864 | 827 | ||
865 | read_lock_irqsave(&zfcp_data.config_lock, flags); | 828 | read_lock_irqsave(&zfcp_data.config_lock, flags); |
@@ -918,38 +881,33 @@ zfcp_fsf_status_read_handler(struct zfcp_fsf_req *fsf_req) | |||
918 | int retval = 0; | 881 | int retval = 0; |
919 | struct zfcp_adapter *adapter = fsf_req->adapter; | 882 | struct zfcp_adapter *adapter = fsf_req->adapter; |
920 | struct fsf_status_read_buffer *status_buffer = | 883 | struct fsf_status_read_buffer *status_buffer = |
921 | fsf_req->data.status_read.buffer; | 884 | (struct fsf_status_read_buffer *) fsf_req->data; |
922 | 885 | ||
923 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { | 886 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { |
887 | zfcp_hba_dbf_event_fsf_unsol("dism", adapter, status_buffer); | ||
924 | mempool_free(status_buffer, adapter->pool.data_status_read); | 888 | mempool_free(status_buffer, adapter->pool.data_status_read); |
925 | zfcp_fsf_req_free(fsf_req); | 889 | zfcp_fsf_req_free(fsf_req); |
926 | goto out; | 890 | goto out; |
927 | } | 891 | } |
928 | 892 | ||
893 | zfcp_hba_dbf_event_fsf_unsol("read", adapter, status_buffer); | ||
894 | |||
929 | switch (status_buffer->status_type) { | 895 | switch (status_buffer->status_type) { |
930 | 896 | ||
931 | case FSF_STATUS_READ_PORT_CLOSED: | 897 | case FSF_STATUS_READ_PORT_CLOSED: |
932 | debug_text_event(adapter->erp_dbf, 3, "unsol_pclosed:"); | ||
933 | debug_event(adapter->erp_dbf, 3, | ||
934 | &status_buffer->d_id, sizeof (u32)); | ||
935 | zfcp_fsf_status_read_port_closed(fsf_req); | 898 | zfcp_fsf_status_read_port_closed(fsf_req); |
936 | break; | 899 | break; |
937 | 900 | ||
938 | case FSF_STATUS_READ_INCOMING_ELS: | 901 | case FSF_STATUS_READ_INCOMING_ELS: |
939 | debug_text_event(adapter->erp_dbf, 3, "unsol_els:"); | ||
940 | zfcp_fsf_incoming_els(fsf_req); | 902 | zfcp_fsf_incoming_els(fsf_req); |
941 | break; | 903 | break; |
942 | 904 | ||
943 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: | 905 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: |
944 | debug_text_event(adapter->erp_dbf, 3, "unsol_sense:"); | ||
945 | ZFCP_LOG_INFO("unsolicited sense data received (adapter %s)\n", | 906 | ZFCP_LOG_INFO("unsolicited sense data received (adapter %s)\n", |
946 | zfcp_get_busid_by_adapter(adapter)); | 907 | zfcp_get_busid_by_adapter(adapter)); |
947 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, (char *) status_buffer, | ||
948 | sizeof(struct fsf_status_read_buffer)); | ||
949 | break; | 908 | break; |
950 | 909 | ||
951 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: | 910 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: |
952 | debug_text_event(adapter->erp_dbf, 3, "unsol_bit_err:"); | ||
953 | ZFCP_LOG_NORMAL("Bit error threshold data received:\n"); | 911 | ZFCP_LOG_NORMAL("Bit error threshold data received:\n"); |
954 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, | 912 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, |
955 | (char *) status_buffer, | 913 | (char *) status_buffer, |
@@ -957,17 +915,32 @@ zfcp_fsf_status_read_handler(struct zfcp_fsf_req *fsf_req) | |||
957 | break; | 915 | break; |
958 | 916 | ||
959 | case FSF_STATUS_READ_LINK_DOWN: | 917 | case FSF_STATUS_READ_LINK_DOWN: |
960 | debug_text_event(adapter->erp_dbf, 0, "unsol_link_down:"); | 918 | switch (status_buffer->status_subtype) { |
961 | ZFCP_LOG_INFO("Local link to adapter %s is down\n", | 919 | case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: |
920 | ZFCP_LOG_INFO("Physical link to adapter %s is down\n", | ||
921 | zfcp_get_busid_by_adapter(adapter)); | ||
922 | break; | ||
923 | case FSF_STATUS_READ_SUB_FDISC_FAILED: | ||
924 | ZFCP_LOG_INFO("Local link to adapter %s is down " | ||
925 | "due to failed FDISC login\n", | ||
962 | zfcp_get_busid_by_adapter(adapter)); | 926 | zfcp_get_busid_by_adapter(adapter)); |
963 | atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | 927 | break; |
964 | &adapter->status); | 928 | case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE: |
965 | zfcp_erp_adapter_failed(adapter); | 929 | ZFCP_LOG_INFO("Local link to adapter %s is down " |
930 | "due to firmware update on adapter\n", | ||
931 | zfcp_get_busid_by_adapter(adapter)); | ||
932 | break; | ||
933 | default: | ||
934 | ZFCP_LOG_INFO("Local link to adapter %s is down " | ||
935 | "due to unknown reason\n", | ||
936 | zfcp_get_busid_by_adapter(adapter)); | ||
937 | }; | ||
938 | zfcp_fsf_link_down_info_eval(adapter, | ||
939 | (struct fsf_link_down_info *) &status_buffer->payload); | ||
966 | break; | 940 | break; |
967 | 941 | ||
968 | case FSF_STATUS_READ_LINK_UP: | 942 | case FSF_STATUS_READ_LINK_UP: |
969 | debug_text_event(adapter->erp_dbf, 2, "unsol_link_up:"); | 943 | ZFCP_LOG_NORMAL("Local link to adapter %s was replugged. " |
970 | ZFCP_LOG_INFO("Local link to adapter %s was replugged. " | ||
971 | "Restarting operations on this adapter\n", | 944 | "Restarting operations on this adapter\n", |
972 | zfcp_get_busid_by_adapter(adapter)); | 945 | zfcp_get_busid_by_adapter(adapter)); |
973 | /* All ports should be marked as ready to run again */ | 946 | /* All ports should be marked as ready to run again */ |
@@ -980,35 +953,40 @@ zfcp_fsf_status_read_handler(struct zfcp_fsf_req *fsf_req) | |||
980 | break; | 953 | break; |
981 | 954 | ||
982 | case FSF_STATUS_READ_CFDC_UPDATED: | 955 | case FSF_STATUS_READ_CFDC_UPDATED: |
983 | debug_text_event(adapter->erp_dbf, 2, "unsol_cfdc_update:"); | 956 | ZFCP_LOG_NORMAL("CFDC has been updated on the adapter %s\n", |
984 | ZFCP_LOG_INFO("CFDC has been updated on the adapter %s\n", | ||
985 | zfcp_get_busid_by_adapter(adapter)); | 957 | zfcp_get_busid_by_adapter(adapter)); |
986 | zfcp_erp_adapter_access_changed(adapter); | 958 | zfcp_erp_adapter_access_changed(adapter); |
987 | break; | 959 | break; |
988 | 960 | ||
989 | case FSF_STATUS_READ_CFDC_HARDENED: | 961 | case FSF_STATUS_READ_CFDC_HARDENED: |
990 | debug_text_event(adapter->erp_dbf, 2, "unsol_cfdc_harden:"); | ||
991 | switch (status_buffer->status_subtype) { | 962 | switch (status_buffer->status_subtype) { |
992 | case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE: | 963 | case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE: |
993 | ZFCP_LOG_INFO("CFDC of adapter %s saved on SE\n", | 964 | ZFCP_LOG_NORMAL("CFDC of adapter %s saved on SE\n", |
994 | zfcp_get_busid_by_adapter(adapter)); | 965 | zfcp_get_busid_by_adapter(adapter)); |
995 | break; | 966 | break; |
996 | case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2: | 967 | case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2: |
997 | ZFCP_LOG_INFO("CFDC of adapter %s has been copied " | 968 | ZFCP_LOG_NORMAL("CFDC of adapter %s has been copied " |
998 | "to the secondary SE\n", | 969 | "to the secondary SE\n", |
999 | zfcp_get_busid_by_adapter(adapter)); | 970 | zfcp_get_busid_by_adapter(adapter)); |
1000 | break; | 971 | break; |
1001 | default: | 972 | default: |
1002 | ZFCP_LOG_INFO("CFDC of adapter %s has been hardened\n", | 973 | ZFCP_LOG_NORMAL("CFDC of adapter %s has been hardened\n", |
1003 | zfcp_get_busid_by_adapter(adapter)); | 974 | zfcp_get_busid_by_adapter(adapter)); |
1004 | } | 975 | } |
1005 | break; | 976 | break; |
1006 | 977 | ||
978 | case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: | ||
979 | debug_text_event(adapter->erp_dbf, 2, "unsol_features:"); | ||
980 | ZFCP_LOG_INFO("List of supported features on adapter %s has " | ||
981 | "been changed from 0x%08X to 0x%08X\n", | ||
982 | zfcp_get_busid_by_adapter(adapter), | ||
983 | *(u32*) (status_buffer->payload + 4), | ||
984 | *(u32*) (status_buffer->payload)); | ||
985 | adapter->adapter_features = *(u32*) status_buffer->payload; | ||
986 | break; | ||
987 | |||
1007 | default: | 988 | default: |
1008 | debug_text_event(adapter->erp_dbf, 0, "unsol_unknown:"); | 989 | ZFCP_LOG_NORMAL("warning: An unsolicited status packet of unknown " |
1009 | debug_exception(adapter->erp_dbf, 0, | ||
1010 | &status_buffer->status_type, sizeof (u32)); | ||
1011 | ZFCP_LOG_NORMAL("bug: An unsolicited status packet of unknown " | ||
1012 | "type was received (debug info 0x%x)\n", | 990 | "type was received (debug info 0x%x)\n", |
1013 | status_buffer->status_type); | 991 | status_buffer->status_type); |
1014 | ZFCP_LOG_DEBUG("Dump of status_read_buffer %p:\n", | 992 | ZFCP_LOG_DEBUG("Dump of status_read_buffer %p:\n", |
@@ -1093,7 +1071,7 @@ zfcp_fsf_abort_fcp_command(unsigned long old_req_id, | |||
1093 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 1071 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
1094 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 1072 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
1095 | 1073 | ||
1096 | fsf_req->data.abort_fcp_command.unit = unit; | 1074 | fsf_req->data = (unsigned long) unit; |
1097 | 1075 | ||
1098 | /* set handles of unit and its parent port in QTCB */ | 1076 | /* set handles of unit and its parent port in QTCB */ |
1099 | fsf_req->qtcb->header.lun_handle = unit->handle; | 1077 | fsf_req->qtcb->header.lun_handle = unit->handle; |
@@ -1139,7 +1117,7 @@ static int | |||
1139 | zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *new_fsf_req) | 1117 | zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *new_fsf_req) |
1140 | { | 1118 | { |
1141 | int retval = -EINVAL; | 1119 | int retval = -EINVAL; |
1142 | struct zfcp_unit *unit = new_fsf_req->data.abort_fcp_command.unit; | 1120 | struct zfcp_unit *unit; |
1143 | unsigned char status_qual = | 1121 | unsigned char status_qual = |
1144 | new_fsf_req->qtcb->header.fsf_status_qual.word[0]; | 1122 | new_fsf_req->qtcb->header.fsf_status_qual.word[0]; |
1145 | 1123 | ||
@@ -1150,6 +1128,8 @@ zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *new_fsf_req) | |||
1150 | goto skip_fsfstatus; | 1128 | goto skip_fsfstatus; |
1151 | } | 1129 | } |
1152 | 1130 | ||
1131 | unit = (struct zfcp_unit *) new_fsf_req->data; | ||
1132 | |||
1153 | /* evaluate FSF status in QTCB */ | 1133 | /* evaluate FSF status in QTCB */ |
1154 | switch (new_fsf_req->qtcb->header.fsf_status) { | 1134 | switch (new_fsf_req->qtcb->header.fsf_status) { |
1155 | 1135 | ||
@@ -1364,7 +1344,7 @@ zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool, | |||
1364 | sbale[3].addr = zfcp_sg_to_address(&ct->resp[0]); | 1344 | sbale[3].addr = zfcp_sg_to_address(&ct->resp[0]); |
1365 | sbale[3].length = ct->resp[0].length; | 1345 | sbale[3].length = ct->resp[0].length; |
1366 | sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY; | 1346 | sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY; |
1367 | } else if (adapter->supported_features & | 1347 | } else if (adapter->adapter_features & |
1368 | FSF_FEATURE_ELS_CT_CHAINED_SBALS) { | 1348 | FSF_FEATURE_ELS_CT_CHAINED_SBALS) { |
1369 | /* try to use chained SBALs */ | 1349 | /* try to use chained SBALs */ |
1370 | bytes = zfcp_qdio_sbals_from_sg(fsf_req, | 1350 | bytes = zfcp_qdio_sbals_from_sg(fsf_req, |
@@ -1414,7 +1394,9 @@ zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool, | |||
1414 | fsf_req->qtcb->header.port_handle = port->handle; | 1394 | fsf_req->qtcb->header.port_handle = port->handle; |
1415 | fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class; | 1395 | fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class; |
1416 | fsf_req->qtcb->bottom.support.timeout = ct->timeout; | 1396 | fsf_req->qtcb->bottom.support.timeout = ct->timeout; |
1417 | fsf_req->data.send_ct = ct; | 1397 | fsf_req->data = (unsigned long) ct; |
1398 | |||
1399 | zfcp_san_dbf_event_ct_request(fsf_req); | ||
1418 | 1400 | ||
1419 | /* start QDIO request for this FSF request */ | 1401 | /* start QDIO request for this FSF request */ |
1420 | ret = zfcp_fsf_req_send(fsf_req, ct->timer); | 1402 | ret = zfcp_fsf_req_send(fsf_req, ct->timer); |
@@ -1445,10 +1427,10 @@ zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool, | |||
1445 | * zfcp_fsf_send_ct_handler - handler for Generic Service requests | 1427 | * zfcp_fsf_send_ct_handler - handler for Generic Service requests |
1446 | * @fsf_req: pointer to struct zfcp_fsf_req | 1428 | * @fsf_req: pointer to struct zfcp_fsf_req |
1447 | * | 1429 | * |
1448 | * Data specific for the Generic Service request is passed by | 1430 | * Data specific for the Generic Service request is passed using |
1449 | * fsf_req->data.send_ct | 1431 | * fsf_req->data. There we find the pointer to struct zfcp_send_ct. |
1450 | * Usually a specific handler for the request is called via | 1432 | * Usually a specific handler for the CT request is called which is |
1451 | * fsf_req->data.send_ct->handler at end of this function. | 1433 | * found in this structure. |
1452 | */ | 1434 | */ |
1453 | static int | 1435 | static int |
1454 | zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req) | 1436 | zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req) |
@@ -1462,7 +1444,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req) | |||
1462 | u16 subtable, rule, counter; | 1444 | u16 subtable, rule, counter; |
1463 | 1445 | ||
1464 | adapter = fsf_req->adapter; | 1446 | adapter = fsf_req->adapter; |
1465 | send_ct = fsf_req->data.send_ct; | 1447 | send_ct = (struct zfcp_send_ct *) fsf_req->data; |
1466 | port = send_ct->port; | 1448 | port = send_ct->port; |
1467 | header = &fsf_req->qtcb->header; | 1449 | header = &fsf_req->qtcb->header; |
1468 | bottom = &fsf_req->qtcb->bottom.support; | 1450 | bottom = &fsf_req->qtcb->bottom.support; |
@@ -1474,6 +1456,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req) | |||
1474 | switch (header->fsf_status) { | 1456 | switch (header->fsf_status) { |
1475 | 1457 | ||
1476 | case FSF_GOOD: | 1458 | case FSF_GOOD: |
1459 | zfcp_san_dbf_event_ct_response(fsf_req); | ||
1477 | retval = 0; | 1460 | retval = 0; |
1478 | break; | 1461 | break; |
1479 | 1462 | ||
@@ -1634,7 +1617,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els) | |||
1634 | { | 1617 | { |
1635 | volatile struct qdio_buffer_element *sbale; | 1618 | volatile struct qdio_buffer_element *sbale; |
1636 | struct zfcp_fsf_req *fsf_req; | 1619 | struct zfcp_fsf_req *fsf_req; |
1637 | fc_id_t d_id; | 1620 | u32 d_id; |
1638 | struct zfcp_adapter *adapter; | 1621 | struct zfcp_adapter *adapter; |
1639 | unsigned long lock_flags; | 1622 | unsigned long lock_flags; |
1640 | int bytes; | 1623 | int bytes; |
@@ -1664,7 +1647,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els) | |||
1664 | sbale[3].addr = zfcp_sg_to_address(&els->resp[0]); | 1647 | sbale[3].addr = zfcp_sg_to_address(&els->resp[0]); |
1665 | sbale[3].length = els->resp[0].length; | 1648 | sbale[3].length = els->resp[0].length; |
1666 | sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY; | 1649 | sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY; |
1667 | } else if (adapter->supported_features & | 1650 | } else if (adapter->adapter_features & |
1668 | FSF_FEATURE_ELS_CT_CHAINED_SBALS) { | 1651 | FSF_FEATURE_ELS_CT_CHAINED_SBALS) { |
1669 | /* try to use chained SBALs */ | 1652 | /* try to use chained SBALs */ |
1670 | bytes = zfcp_qdio_sbals_from_sg(fsf_req, | 1653 | bytes = zfcp_qdio_sbals_from_sg(fsf_req, |
@@ -1714,10 +1697,12 @@ zfcp_fsf_send_els(struct zfcp_send_els *els) | |||
1714 | fsf_req->qtcb->bottom.support.d_id = d_id; | 1697 | fsf_req->qtcb->bottom.support.d_id = d_id; |
1715 | fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class; | 1698 | fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class; |
1716 | fsf_req->qtcb->bottom.support.timeout = ZFCP_ELS_TIMEOUT; | 1699 | fsf_req->qtcb->bottom.support.timeout = ZFCP_ELS_TIMEOUT; |
1717 | fsf_req->data.send_els = els; | 1700 | fsf_req->data = (unsigned long) els; |
1718 | 1701 | ||
1719 | sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); | 1702 | sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); |
1720 | 1703 | ||
1704 | zfcp_san_dbf_event_els_request(fsf_req); | ||
1705 | |||
1721 | /* start QDIO request for this FSF request */ | 1706 | /* start QDIO request for this FSF request */ |
1722 | ret = zfcp_fsf_req_send(fsf_req, els->timer); | 1707 | ret = zfcp_fsf_req_send(fsf_req, els->timer); |
1723 | if (ret) { | 1708 | if (ret) { |
@@ -1746,23 +1731,23 @@ zfcp_fsf_send_els(struct zfcp_send_els *els) | |||
1746 | * zfcp_fsf_send_els_handler - handler for ELS commands | 1731 | * zfcp_fsf_send_els_handler - handler for ELS commands |
1747 | * @fsf_req: pointer to struct zfcp_fsf_req | 1732 | * @fsf_req: pointer to struct zfcp_fsf_req |
1748 | * | 1733 | * |
1749 | * Data specific for the ELS command is passed by | 1734 | * Data specific for the ELS command is passed using |
1750 | * fsf_req->data.send_els | 1735 | * fsf_req->data. There we find the pointer to struct zfcp_send_els. |
1751 | * Usually a specific handler for the command is called via | 1736 | * Usually a specific handler for the ELS command is called which is |
1752 | * fsf_req->data.send_els->handler at end of this function. | 1737 | * found in this structure. |
1753 | */ | 1738 | */ |
1754 | static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req) | 1739 | static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req) |
1755 | { | 1740 | { |
1756 | struct zfcp_adapter *adapter; | 1741 | struct zfcp_adapter *adapter; |
1757 | struct zfcp_port *port; | 1742 | struct zfcp_port *port; |
1758 | fc_id_t d_id; | 1743 | u32 d_id; |
1759 | struct fsf_qtcb_header *header; | 1744 | struct fsf_qtcb_header *header; |
1760 | struct fsf_qtcb_bottom_support *bottom; | 1745 | struct fsf_qtcb_bottom_support *bottom; |
1761 | struct zfcp_send_els *send_els; | 1746 | struct zfcp_send_els *send_els; |
1762 | int retval = -EINVAL; | 1747 | int retval = -EINVAL; |
1763 | u16 subtable, rule, counter; | 1748 | u16 subtable, rule, counter; |
1764 | 1749 | ||
1765 | send_els = fsf_req->data.send_els; | 1750 | send_els = (struct zfcp_send_els *) fsf_req->data; |
1766 | adapter = send_els->adapter; | 1751 | adapter = send_els->adapter; |
1767 | port = send_els->port; | 1752 | port = send_els->port; |
1768 | d_id = send_els->d_id; | 1753 | d_id = send_els->d_id; |
@@ -1775,6 +1760,7 @@ static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req) | |||
1775 | switch (header->fsf_status) { | 1760 | switch (header->fsf_status) { |
1776 | 1761 | ||
1777 | case FSF_GOOD: | 1762 | case FSF_GOOD: |
1763 | zfcp_san_dbf_event_els_response(fsf_req); | ||
1778 | retval = 0; | 1764 | retval = 0; |
1779 | break; | 1765 | break; |
1780 | 1766 | ||
@@ -1954,7 +1940,9 @@ zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action) | |||
1954 | 1940 | ||
1955 | erp_action->fsf_req->erp_action = erp_action; | 1941 | erp_action->fsf_req->erp_action = erp_action; |
1956 | erp_action->fsf_req->qtcb->bottom.config.feature_selection = | 1942 | erp_action->fsf_req->qtcb->bottom.config.feature_selection = |
1957 | (FSF_FEATURE_CFDC | FSF_FEATURE_LUN_SHARING); | 1943 | FSF_FEATURE_CFDC | |
1944 | FSF_FEATURE_LUN_SHARING | | ||
1945 | FSF_FEATURE_UPDATE_ALERT; | ||
1958 | 1946 | ||
1959 | /* start QDIO request for this FSF request */ | 1947 | /* start QDIO request for this FSF request */ |
1960 | retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer); | 1948 | retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer); |
@@ -1990,29 +1978,36 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok) | |||
1990 | { | 1978 | { |
1991 | struct fsf_qtcb_bottom_config *bottom; | 1979 | struct fsf_qtcb_bottom_config *bottom; |
1992 | struct zfcp_adapter *adapter = fsf_req->adapter; | 1980 | struct zfcp_adapter *adapter = fsf_req->adapter; |
1981 | struct Scsi_Host *shost = adapter->scsi_host; | ||
1993 | 1982 | ||
1994 | bottom = &fsf_req->qtcb->bottom.config; | 1983 | bottom = &fsf_req->qtcb->bottom.config; |
1995 | ZFCP_LOG_DEBUG("low/high QTCB version 0x%x/0x%x of FSF\n", | 1984 | ZFCP_LOG_DEBUG("low/high QTCB version 0x%x/0x%x of FSF\n", |
1996 | bottom->low_qtcb_version, bottom->high_qtcb_version); | 1985 | bottom->low_qtcb_version, bottom->high_qtcb_version); |
1997 | adapter->fsf_lic_version = bottom->lic_version; | 1986 | adapter->fsf_lic_version = bottom->lic_version; |
1998 | adapter->supported_features = bottom->supported_features; | 1987 | adapter->adapter_features = bottom->adapter_features; |
1988 | adapter->connection_features = bottom->connection_features; | ||
1999 | adapter->peer_wwpn = 0; | 1989 | adapter->peer_wwpn = 0; |
2000 | adapter->peer_wwnn = 0; | 1990 | adapter->peer_wwnn = 0; |
2001 | adapter->peer_d_id = 0; | 1991 | adapter->peer_d_id = 0; |
2002 | 1992 | ||
2003 | if (xchg_ok) { | 1993 | if (xchg_ok) { |
2004 | adapter->wwnn = bottom->nport_serv_param.wwnn; | 1994 | fc_host_node_name(shost) = bottom->nport_serv_param.wwnn; |
2005 | adapter->wwpn = bottom->nport_serv_param.wwpn; | 1995 | fc_host_port_name(shost) = bottom->nport_serv_param.wwpn; |
2006 | adapter->s_id = bottom->s_id & ZFCP_DID_MASK; | 1996 | fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK; |
1997 | fc_host_speed(shost) = bottom->fc_link_speed; | ||
1998 | fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3; | ||
2007 | adapter->fc_topology = bottom->fc_topology; | 1999 | adapter->fc_topology = bottom->fc_topology; |
2008 | adapter->fc_link_speed = bottom->fc_link_speed; | ||
2009 | adapter->hydra_version = bottom->adapter_type; | 2000 | adapter->hydra_version = bottom->adapter_type; |
2001 | if (adapter->physical_wwpn == 0) | ||
2002 | adapter->physical_wwpn = fc_host_port_name(shost); | ||
2003 | if (adapter->physical_s_id == 0) | ||
2004 | adapter->physical_s_id = fc_host_port_id(shost); | ||
2010 | } else { | 2005 | } else { |
2011 | adapter->wwnn = 0; | 2006 | fc_host_node_name(shost) = 0; |
2012 | adapter->wwpn = 0; | 2007 | fc_host_port_name(shost) = 0; |
2013 | adapter->s_id = 0; | 2008 | fc_host_port_id(shost) = 0; |
2009 | fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; | ||
2014 | adapter->fc_topology = 0; | 2010 | adapter->fc_topology = 0; |
2015 | adapter->fc_link_speed = 0; | ||
2016 | adapter->hydra_version = 0; | 2011 | adapter->hydra_version = 0; |
2017 | } | 2012 | } |
2018 | 2013 | ||
@@ -2022,26 +2017,28 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok) | |||
2022 | adapter->peer_wwnn = bottom->plogi_payload.wwnn; | 2017 | adapter->peer_wwnn = bottom->plogi_payload.wwnn; |
2023 | } | 2018 | } |
2024 | 2019 | ||
2025 | if(adapter->supported_features & FSF_FEATURE_HBAAPI_MANAGEMENT){ | 2020 | if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) { |
2026 | adapter->hardware_version = bottom->hardware_version; | 2021 | adapter->hardware_version = bottom->hardware_version; |
2027 | memcpy(adapter->serial_number, bottom->serial_number, 17); | 2022 | memcpy(fc_host_serial_number(shost), bottom->serial_number, |
2028 | EBCASC(adapter->serial_number, sizeof(adapter->serial_number)); | 2023 | min(FC_SERIAL_NUMBER_SIZE, 17)); |
2024 | EBCASC(fc_host_serial_number(shost), | ||
2025 | min(FC_SERIAL_NUMBER_SIZE, 17)); | ||
2029 | } | 2026 | } |
2030 | 2027 | ||
2031 | ZFCP_LOG_NORMAL("The adapter %s reported the following characteristics:\n" | 2028 | ZFCP_LOG_NORMAL("The adapter %s reported the following characteristics:\n" |
2032 | "WWNN 0x%016Lx, " | 2029 | "WWNN 0x%016Lx, " |
2033 | "WWPN 0x%016Lx, " | 2030 | "WWPN 0x%016Lx, " |
2034 | "S_ID 0x%08x,\n" | 2031 | "S_ID 0x%08x,\n" |
2035 | "adapter version 0x%x, " | 2032 | "adapter version 0x%x, " |
2036 | "LIC version 0x%x, " | 2033 | "LIC version 0x%x, " |
2037 | "FC link speed %d Gb/s\n", | 2034 | "FC link speed %d Gb/s\n", |
2038 | zfcp_get_busid_by_adapter(adapter), | 2035 | zfcp_get_busid_by_adapter(adapter), |
2039 | adapter->wwnn, | 2036 | (wwn_t) fc_host_node_name(shost), |
2040 | adapter->wwpn, | 2037 | (wwn_t) fc_host_port_name(shost), |
2041 | (unsigned int) adapter->s_id, | 2038 | fc_host_port_id(shost), |
2042 | adapter->hydra_version, | 2039 | adapter->hydra_version, |
2043 | adapter->fsf_lic_version, | 2040 | adapter->fsf_lic_version, |
2044 | adapter->fc_link_speed); | 2041 | fc_host_speed(shost)); |
2045 | if (ZFCP_QTCB_VERSION < bottom->low_qtcb_version) { | 2042 | if (ZFCP_QTCB_VERSION < bottom->low_qtcb_version) { |
2046 | ZFCP_LOG_NORMAL("error: the adapter %s " | 2043 | ZFCP_LOG_NORMAL("error: the adapter %s " |
2047 | "only supports newer control block " | 2044 | "only supports newer control block " |
@@ -2062,7 +2059,6 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok) | |||
2062 | zfcp_erp_adapter_shutdown(adapter, 0); | 2059 | zfcp_erp_adapter_shutdown(adapter, 0); |
2063 | return -EIO; | 2060 | return -EIO; |
2064 | } | 2061 | } |
2065 | zfcp_set_fc_host_attrs(adapter); | ||
2066 | return 0; | 2062 | return 0; |
2067 | } | 2063 | } |
2068 | 2064 | ||
@@ -2078,11 +2074,12 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req) | |||
2078 | { | 2074 | { |
2079 | struct fsf_qtcb_bottom_config *bottom; | 2075 | struct fsf_qtcb_bottom_config *bottom; |
2080 | struct zfcp_adapter *adapter = fsf_req->adapter; | 2076 | struct zfcp_adapter *adapter = fsf_req->adapter; |
2077 | struct fsf_qtcb *qtcb = fsf_req->qtcb; | ||
2081 | 2078 | ||
2082 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) | 2079 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) |
2083 | return -EIO; | 2080 | return -EIO; |
2084 | 2081 | ||
2085 | switch (fsf_req->qtcb->header.fsf_status) { | 2082 | switch (qtcb->header.fsf_status) { |
2086 | 2083 | ||
2087 | case FSF_GOOD: | 2084 | case FSF_GOOD: |
2088 | if (zfcp_fsf_exchange_config_evaluate(fsf_req, 1)) | 2085 | if (zfcp_fsf_exchange_config_evaluate(fsf_req, 1)) |
@@ -2112,7 +2109,7 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req) | |||
2112 | zfcp_erp_adapter_shutdown(adapter, 0); | 2109 | zfcp_erp_adapter_shutdown(adapter, 0); |
2113 | return -EIO; | 2110 | return -EIO; |
2114 | case FSF_TOPO_FABRIC: | 2111 | case FSF_TOPO_FABRIC: |
2115 | ZFCP_LOG_INFO("Switched fabric fibrechannel " | 2112 | ZFCP_LOG_NORMAL("Switched fabric fibrechannel " |
2116 | "network detected at adapter %s.\n", | 2113 | "network detected at adapter %s.\n", |
2117 | zfcp_get_busid_by_adapter(adapter)); | 2114 | zfcp_get_busid_by_adapter(adapter)); |
2118 | break; | 2115 | break; |
@@ -2130,7 +2127,7 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req) | |||
2130 | zfcp_erp_adapter_shutdown(adapter, 0); | 2127 | zfcp_erp_adapter_shutdown(adapter, 0); |
2131 | return -EIO; | 2128 | return -EIO; |
2132 | } | 2129 | } |
2133 | bottom = &fsf_req->qtcb->bottom.config; | 2130 | bottom = &qtcb->bottom.config; |
2134 | if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) { | 2131 | if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) { |
2135 | ZFCP_LOG_NORMAL("bug: Maximum QTCB size (%d bytes) " | 2132 | ZFCP_LOG_NORMAL("bug: Maximum QTCB size (%d bytes) " |
2136 | "allowed by the adapter %s " | 2133 | "allowed by the adapter %s " |
@@ -2155,12 +2152,10 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req) | |||
2155 | if (zfcp_fsf_exchange_config_evaluate(fsf_req, 0)) | 2152 | if (zfcp_fsf_exchange_config_evaluate(fsf_req, 0)) |
2156 | return -EIO; | 2153 | return -EIO; |
2157 | 2154 | ||
2158 | ZFCP_LOG_INFO("Local link to adapter %s is down\n", | 2155 | atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); |
2159 | zfcp_get_busid_by_adapter(adapter)); | 2156 | |
2160 | atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK | | 2157 | zfcp_fsf_link_down_info_eval(adapter, |
2161 | ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, | 2158 | &qtcb->header.fsf_status_qual.link_down_info); |
2162 | &adapter->status); | ||
2163 | zfcp_erp_adapter_failed(adapter); | ||
2164 | break; | 2159 | break; |
2165 | default: | 2160 | default: |
2166 | debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf-stat-ng"); | 2161 | debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf-stat-ng"); |
@@ -2174,11 +2169,13 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req) | |||
2174 | 2169 | ||
2175 | /** | 2170 | /** |
2176 | * zfcp_fsf_exchange_port_data - request information about local port | 2171 | * zfcp_fsf_exchange_port_data - request information about local port |
2172 | * @erp_action: ERP action for the adapter for which port data is requested | ||
2177 | * @adapter: for which port data is requested | 2173 | * @adapter: for which port data is requested |
2178 | * @data: response to exchange port data request | 2174 | * @data: response to exchange port data request |
2179 | */ | 2175 | */ |
2180 | int | 2176 | int |
2181 | zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter, | 2177 | zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action, |
2178 | struct zfcp_adapter *adapter, | ||
2182 | struct fsf_qtcb_bottom_port *data) | 2179 | struct fsf_qtcb_bottom_port *data) |
2183 | { | 2180 | { |
2184 | volatile struct qdio_buffer_element *sbale; | 2181 | volatile struct qdio_buffer_element *sbale; |
@@ -2187,7 +2184,7 @@ zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter, | |||
2187 | struct zfcp_fsf_req *fsf_req; | 2184 | struct zfcp_fsf_req *fsf_req; |
2188 | struct timer_list *timer; | 2185 | struct timer_list *timer; |
2189 | 2186 | ||
2190 | if(!(adapter->supported_features & FSF_FEATURE_HBAAPI_MANAGEMENT)){ | 2187 | if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT)) { |
2191 | ZFCP_LOG_INFO("error: exchange port data " | 2188 | ZFCP_LOG_INFO("error: exchange port data " |
2192 | "command not supported by adapter %s\n", | 2189 | "command not supported by adapter %s\n", |
2193 | zfcp_get_busid_by_adapter(adapter)); | 2190 | zfcp_get_busid_by_adapter(adapter)); |
@@ -2211,12 +2208,18 @@ zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter, | |||
2211 | goto out; | 2208 | goto out; |
2212 | } | 2209 | } |
2213 | 2210 | ||
2211 | if (erp_action) { | ||
2212 | erp_action->fsf_req = fsf_req; | ||
2213 | fsf_req->erp_action = erp_action; | ||
2214 | } | ||
2215 | |||
2216 | if (data) | ||
2217 | fsf_req->data = (unsigned long) data; | ||
2218 | |||
2214 | sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); | 2219 | sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); |
2215 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; | 2220 | sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; |
2216 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 2221 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
2217 | 2222 | ||
2218 | fsf_req->data.port_data = data; | ||
2219 | |||
2220 | init_timer(timer); | 2223 | init_timer(timer); |
2221 | timer->function = zfcp_fsf_request_timeout_handler; | 2224 | timer->function = zfcp_fsf_request_timeout_handler; |
2222 | timer->data = (unsigned long) adapter; | 2225 | timer->data = (unsigned long) adapter; |
@@ -2228,6 +2231,8 @@ zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter, | |||
2228 | "command on the adapter %s\n", | 2231 | "command on the adapter %s\n", |
2229 | zfcp_get_busid_by_adapter(adapter)); | 2232 | zfcp_get_busid_by_adapter(adapter)); |
2230 | zfcp_fsf_req_free(fsf_req); | 2233 | zfcp_fsf_req_free(fsf_req); |
2234 | if (erp_action) | ||
2235 | erp_action->fsf_req = NULL; | ||
2231 | write_unlock_irqrestore(&adapter->request_queue.queue_lock, | 2236 | write_unlock_irqrestore(&adapter->request_queue.queue_lock, |
2232 | lock_flags); | 2237 | lock_flags); |
2233 | goto out; | 2238 | goto out; |
@@ -2256,21 +2261,42 @@ zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter, | |||
2256 | static void | 2261 | static void |
2257 | zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *fsf_req) | 2262 | zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *fsf_req) |
2258 | { | 2263 | { |
2259 | struct fsf_qtcb_bottom_port *bottom; | 2264 | struct zfcp_adapter *adapter = fsf_req->adapter; |
2260 | struct fsf_qtcb_bottom_port *data = fsf_req->data.port_data; | 2265 | struct Scsi_Host *shost = adapter->scsi_host; |
2266 | struct fsf_qtcb *qtcb = fsf_req->qtcb; | ||
2267 | struct fsf_qtcb_bottom_port *bottom, *data; | ||
2261 | 2268 | ||
2262 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) | 2269 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) |
2263 | return; | 2270 | return; |
2264 | 2271 | ||
2265 | switch (fsf_req->qtcb->header.fsf_status) { | 2272 | switch (qtcb->header.fsf_status) { |
2266 | case FSF_GOOD: | 2273 | case FSF_GOOD: |
2267 | bottom = &fsf_req->qtcb->bottom.port; | 2274 | atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); |
2268 | memcpy(data, bottom, sizeof(*data)); | 2275 | |
2276 | bottom = &qtcb->bottom.port; | ||
2277 | data = (struct fsf_qtcb_bottom_port*) fsf_req->data; | ||
2278 | if (data) | ||
2279 | memcpy(data, bottom, sizeof(struct fsf_qtcb_bottom_port)); | ||
2280 | if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) { | ||
2281 | adapter->physical_wwpn = bottom->wwpn; | ||
2282 | adapter->physical_s_id = bottom->fc_port_id; | ||
2283 | } else { | ||
2284 | adapter->physical_wwpn = fc_host_port_name(shost); | ||
2285 | adapter->physical_s_id = fc_host_port_id(shost); | ||
2286 | } | ||
2287 | fc_host_maxframe_size(shost) = bottom->maximum_frame_size; | ||
2288 | break; | ||
2289 | |||
2290 | case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE: | ||
2291 | atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); | ||
2292 | |||
2293 | zfcp_fsf_link_down_info_eval(adapter, | ||
2294 | &qtcb->header.fsf_status_qual.link_down_info); | ||
2269 | break; | 2295 | break; |
2270 | 2296 | ||
2271 | default: | 2297 | default: |
2272 | debug_text_event(fsf_req->adapter->erp_dbf, 0, "xchg-port-ng"); | 2298 | debug_text_event(adapter->erp_dbf, 0, "xchg-port-ng"); |
2273 | debug_event(fsf_req->adapter->erp_dbf, 0, | 2299 | debug_event(adapter->erp_dbf, 0, |
2274 | &fsf_req->qtcb->header.fsf_status, sizeof(u32)); | 2300 | &fsf_req->qtcb->header.fsf_status, sizeof(u32)); |
2275 | } | 2301 | } |
2276 | } | 2302 | } |
@@ -2312,7 +2338,7 @@ zfcp_fsf_open_port(struct zfcp_erp_action *erp_action) | |||
2312 | 2338 | ||
2313 | erp_action->fsf_req->qtcb->bottom.support.d_id = erp_action->port->d_id; | 2339 | erp_action->fsf_req->qtcb->bottom.support.d_id = erp_action->port->d_id; |
2314 | atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status); | 2340 | atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status); |
2315 | erp_action->fsf_req->data.open_port.port = erp_action->port; | 2341 | erp_action->fsf_req->data = (unsigned long) erp_action->port; |
2316 | erp_action->fsf_req->erp_action = erp_action; | 2342 | erp_action->fsf_req->erp_action = erp_action; |
2317 | 2343 | ||
2318 | /* start QDIO request for this FSF request */ | 2344 | /* start QDIO request for this FSF request */ |
@@ -2353,7 +2379,7 @@ zfcp_fsf_open_port_handler(struct zfcp_fsf_req *fsf_req) | |||
2353 | struct fsf_qtcb_header *header; | 2379 | struct fsf_qtcb_header *header; |
2354 | u16 subtable, rule, counter; | 2380 | u16 subtable, rule, counter; |
2355 | 2381 | ||
2356 | port = fsf_req->data.open_port.port; | 2382 | port = (struct zfcp_port *) fsf_req->data; |
2357 | header = &fsf_req->qtcb->header; | 2383 | header = &fsf_req->qtcb->header; |
2358 | 2384 | ||
2359 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 2385 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
@@ -2566,7 +2592,7 @@ zfcp_fsf_close_port(struct zfcp_erp_action *erp_action) | |||
2566 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; | 2592 | sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; |
2567 | 2593 | ||
2568 | atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status); | 2594 | atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status); |
2569 | erp_action->fsf_req->data.close_port.port = erp_action->port; | 2595 | erp_action->fsf_req->data = (unsigned long) erp_action->port; |
2570 | erp_action->fsf_req->erp_action = erp_action; | 2596 | erp_action->fsf_req->erp_action = erp_action; |
2571 | erp_action->fsf_req->qtcb->header.port_handle = | 2597 | erp_action->fsf_req->qtcb->header.port_handle = |
2572 | erp_action->port->handle; | 2598 | erp_action->port->handle; |
@@ -2606,7 +2632,7 @@ zfcp_fsf_close_port_handler(struct zfcp_fsf_req *fsf_req) | |||
2606 | int retval = -EINVAL; | 2632 | int retval = -EINVAL; |
2607 | struct zfcp_port *port; | 2633 | struct zfcp_port *port; |
2608 | 2634 | ||
2609 | port = fsf_req->data.close_port.port; | 2635 | port = (struct zfcp_port *) fsf_req->data; |
2610 | 2636 | ||
2611 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 2637 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
2612 | /* don't change port status in our bookkeeping */ | 2638 | /* don't change port status in our bookkeeping */ |
@@ -2703,8 +2729,8 @@ zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action) | |||
2703 | atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, | 2729 | atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, |
2704 | &erp_action->port->status); | 2730 | &erp_action->port->status); |
2705 | /* save a pointer to this port */ | 2731 | /* save a pointer to this port */ |
2706 | erp_action->fsf_req->data.close_physical_port.port = erp_action->port; | 2732 | erp_action->fsf_req->data = (unsigned long) erp_action->port; |
2707 | /* port to be closeed */ | 2733 | /* port to be closed */ |
2708 | erp_action->fsf_req->qtcb->header.port_handle = | 2734 | erp_action->fsf_req->qtcb->header.port_handle = |
2709 | erp_action->port->handle; | 2735 | erp_action->port->handle; |
2710 | erp_action->fsf_req->erp_action = erp_action; | 2736 | erp_action->fsf_req->erp_action = erp_action; |
@@ -2747,7 +2773,7 @@ zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *fsf_req) | |||
2747 | struct fsf_qtcb_header *header; | 2773 | struct fsf_qtcb_header *header; |
2748 | u16 subtable, rule, counter; | 2774 | u16 subtable, rule, counter; |
2749 | 2775 | ||
2750 | port = fsf_req->data.close_physical_port.port; | 2776 | port = (struct zfcp_port *) fsf_req->data; |
2751 | header = &fsf_req->qtcb->header; | 2777 | header = &fsf_req->qtcb->header; |
2752 | 2778 | ||
2753 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 2779 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
@@ -2908,10 +2934,11 @@ zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action) | |||
2908 | erp_action->port->handle; | 2934 | erp_action->port->handle; |
2909 | erp_action->fsf_req->qtcb->bottom.support.fcp_lun = | 2935 | erp_action->fsf_req->qtcb->bottom.support.fcp_lun = |
2910 | erp_action->unit->fcp_lun; | 2936 | erp_action->unit->fcp_lun; |
2937 | if (!(erp_action->adapter->connection_features & FSF_FEATURE_NPIV_MODE)) | ||
2911 | erp_action->fsf_req->qtcb->bottom.support.option = | 2938 | erp_action->fsf_req->qtcb->bottom.support.option = |
2912 | FSF_OPEN_LUN_SUPPRESS_BOXING; | 2939 | FSF_OPEN_LUN_SUPPRESS_BOXING; |
2913 | atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status); | 2940 | atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status); |
2914 | erp_action->fsf_req->data.open_unit.unit = erp_action->unit; | 2941 | erp_action->fsf_req->data = (unsigned long) erp_action->unit; |
2915 | erp_action->fsf_req->erp_action = erp_action; | 2942 | erp_action->fsf_req->erp_action = erp_action; |
2916 | 2943 | ||
2917 | /* start QDIO request for this FSF request */ | 2944 | /* start QDIO request for this FSF request */ |
@@ -2955,9 +2982,9 @@ zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
2955 | struct fsf_qtcb_bottom_support *bottom; | 2982 | struct fsf_qtcb_bottom_support *bottom; |
2956 | struct fsf_queue_designator *queue_designator; | 2983 | struct fsf_queue_designator *queue_designator; |
2957 | u16 subtable, rule, counter; | 2984 | u16 subtable, rule, counter; |
2958 | u32 allowed, exclusive, readwrite; | 2985 | int exclusive, readwrite; |
2959 | 2986 | ||
2960 | unit = fsf_req->data.open_unit.unit; | 2987 | unit = (struct zfcp_unit *) fsf_req->data; |
2961 | 2988 | ||
2962 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 2989 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
2963 | /* don't change unit status in our bookkeeping */ | 2990 | /* don't change unit status in our bookkeeping */ |
@@ -2969,10 +2996,6 @@ zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
2969 | bottom = &fsf_req->qtcb->bottom.support; | 2996 | bottom = &fsf_req->qtcb->bottom.support; |
2970 | queue_designator = &header->fsf_status_qual.fsf_queue_designator; | 2997 | queue_designator = &header->fsf_status_qual.fsf_queue_designator; |
2971 | 2998 | ||
2972 | allowed = bottom->lun_access_info & FSF_UNIT_ACCESS_OPEN_LUN_ALLOWED; | ||
2973 | exclusive = bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE; | ||
2974 | readwrite = bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER; | ||
2975 | |||
2976 | atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | | 2999 | atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | |
2977 | ZFCP_STATUS_UNIT_SHARED | | 3000 | ZFCP_STATUS_UNIT_SHARED | |
2978 | ZFCP_STATUS_UNIT_READONLY, | 3001 | ZFCP_STATUS_UNIT_READONLY, |
@@ -3146,10 +3169,15 @@ zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
3146 | unit->handle); | 3169 | unit->handle); |
3147 | /* mark unit as open */ | 3170 | /* mark unit as open */ |
3148 | atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status); | 3171 | atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status); |
3149 | atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | | 3172 | |
3150 | ZFCP_STATUS_COMMON_ACCESS_BOXED, | 3173 | if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) && |
3151 | &unit->status); | 3174 | (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) && |
3152 | if (adapter->supported_features & FSF_FEATURE_LUN_SHARING){ | 3175 | (adapter->ccw_device->id.dev_model != ZFCP_DEVICE_MODEL_PRIV)) { |
3176 | exclusive = (bottom->lun_access_info & | ||
3177 | FSF_UNIT_ACCESS_EXCLUSIVE); | ||
3178 | readwrite = (bottom->lun_access_info & | ||
3179 | FSF_UNIT_ACCESS_OUTBOUND_TRANSFER); | ||
3180 | |||
3153 | if (!exclusive) | 3181 | if (!exclusive) |
3154 | atomic_set_mask(ZFCP_STATUS_UNIT_SHARED, | 3182 | atomic_set_mask(ZFCP_STATUS_UNIT_SHARED, |
3155 | &unit->status); | 3183 | &unit->status); |
@@ -3242,7 +3270,7 @@ zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action) | |||
3242 | erp_action->port->handle; | 3270 | erp_action->port->handle; |
3243 | erp_action->fsf_req->qtcb->header.lun_handle = erp_action->unit->handle; | 3271 | erp_action->fsf_req->qtcb->header.lun_handle = erp_action->unit->handle; |
3244 | atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status); | 3272 | atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status); |
3245 | erp_action->fsf_req->data.close_unit.unit = erp_action->unit; | 3273 | erp_action->fsf_req->data = (unsigned long) erp_action->unit; |
3246 | erp_action->fsf_req->erp_action = erp_action; | 3274 | erp_action->fsf_req->erp_action = erp_action; |
3247 | 3275 | ||
3248 | /* start QDIO request for this FSF request */ | 3276 | /* start QDIO request for this FSF request */ |
@@ -3281,7 +3309,7 @@ zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
3281 | int retval = -EINVAL; | 3309 | int retval = -EINVAL; |
3282 | struct zfcp_unit *unit; | 3310 | struct zfcp_unit *unit; |
3283 | 3311 | ||
3284 | unit = fsf_req->data.close_unit.unit; /* restore unit */ | 3312 | unit = (struct zfcp_unit *) fsf_req->data; |
3285 | 3313 | ||
3286 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 3314 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
3287 | /* don't change unit status in our bookkeeping */ | 3315 | /* don't change unit status in our bookkeeping */ |
@@ -3305,9 +3333,6 @@ zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
3305 | debug_text_event(fsf_req->adapter->erp_dbf, 1, | 3333 | debug_text_event(fsf_req->adapter->erp_dbf, 1, |
3306 | "fsf_s_phand_nv"); | 3334 | "fsf_s_phand_nv"); |
3307 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); | 3335 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); |
3308 | zfcp_cmd_dbf_event_fsf("porthinv", fsf_req, | ||
3309 | &fsf_req->qtcb->header.fsf_status_qual, | ||
3310 | sizeof (union fsf_status_qual)); | ||
3311 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3336 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3312 | break; | 3337 | break; |
3313 | 3338 | ||
@@ -3326,9 +3351,6 @@ zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *fsf_req) | |||
3326 | debug_text_event(fsf_req->adapter->erp_dbf, 1, | 3351 | debug_text_event(fsf_req->adapter->erp_dbf, 1, |
3327 | "fsf_s_lhand_nv"); | 3352 | "fsf_s_lhand_nv"); |
3328 | zfcp_erp_port_reopen(unit->port, 0); | 3353 | zfcp_erp_port_reopen(unit->port, 0); |
3329 | zfcp_cmd_dbf_event_fsf("lunhinv", fsf_req, | ||
3330 | &fsf_req->qtcb->header.fsf_status_qual, | ||
3331 | sizeof (union fsf_status_qual)); | ||
3332 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3354 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3333 | break; | 3355 | break; |
3334 | 3356 | ||
@@ -3436,21 +3458,14 @@ zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter, | |||
3436 | goto failed_req_create; | 3458 | goto failed_req_create; |
3437 | } | 3459 | } |
3438 | 3460 | ||
3439 | /* | 3461 | zfcp_unit_get(unit); |
3440 | * associate FSF request with SCSI request | 3462 | fsf_req->unit = unit; |
3441 | * (need this for look up on abort) | ||
3442 | */ | ||
3443 | fsf_req->data.send_fcp_command_task.fsf_req = fsf_req; | ||
3444 | scsi_cmnd->host_scribble = (char *) &(fsf_req->data); | ||
3445 | 3463 | ||
3446 | /* | 3464 | /* associate FSF request with SCSI request (for look up on abort) */ |
3447 | * associate SCSI command with FSF request | 3465 | scsi_cmnd->host_scribble = (char *) fsf_req; |
3448 | * (need this for look up on normal command completion) | 3466 | |
3449 | */ | 3467 | /* associate SCSI command with FSF request */ |
3450 | fsf_req->data.send_fcp_command_task.scsi_cmnd = scsi_cmnd; | 3468 | fsf_req->data = (unsigned long) scsi_cmnd; |
3451 | fsf_req->data.send_fcp_command_task.start_jiffies = jiffies; | ||
3452 | fsf_req->data.send_fcp_command_task.unit = unit; | ||
3453 | ZFCP_LOG_DEBUG("unit=%p, fcp_lun=0x%016Lx\n", unit, unit->fcp_lun); | ||
3454 | 3469 | ||
3455 | /* set handles of unit and its parent port in QTCB */ | 3470 | /* set handles of unit and its parent port in QTCB */ |
3456 | fsf_req->qtcb->header.lun_handle = unit->handle; | 3471 | fsf_req->qtcb->header.lun_handle = unit->handle; |
@@ -3584,6 +3599,7 @@ zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter, | |||
3584 | send_failed: | 3599 | send_failed: |
3585 | no_fit: | 3600 | no_fit: |
3586 | failed_scsi_cmnd: | 3601 | failed_scsi_cmnd: |
3602 | zfcp_unit_put(unit); | ||
3587 | zfcp_fsf_req_free(fsf_req); | 3603 | zfcp_fsf_req_free(fsf_req); |
3588 | fsf_req = NULL; | 3604 | fsf_req = NULL; |
3589 | scsi_cmnd->host_scribble = NULL; | 3605 | scsi_cmnd->host_scribble = NULL; |
@@ -3640,7 +3656,7 @@ zfcp_fsf_send_fcp_command_task_management(struct zfcp_adapter *adapter, | |||
3640 | * hold a pointer to the unit being target of this | 3656 | * hold a pointer to the unit being target of this |
3641 | * task management request | 3657 | * task management request |
3642 | */ | 3658 | */ |
3643 | fsf_req->data.send_fcp_command_task_management.unit = unit; | 3659 | fsf_req->data = (unsigned long) unit; |
3644 | 3660 | ||
3645 | /* set FSF related fields in QTCB */ | 3661 | /* set FSF related fields in QTCB */ |
3646 | fsf_req->qtcb->header.lun_handle = unit->handle; | 3662 | fsf_req->qtcb->header.lun_handle = unit->handle; |
@@ -3706,9 +3722,9 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3706 | header = &fsf_req->qtcb->header; | 3722 | header = &fsf_req->qtcb->header; |
3707 | 3723 | ||
3708 | if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)) | 3724 | if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)) |
3709 | unit = fsf_req->data.send_fcp_command_task_management.unit; | 3725 | unit = (struct zfcp_unit *) fsf_req->data; |
3710 | else | 3726 | else |
3711 | unit = fsf_req->data.send_fcp_command_task.unit; | 3727 | unit = fsf_req->unit; |
3712 | 3728 | ||
3713 | if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) { | 3729 | if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) { |
3714 | /* go directly to calls of special handlers */ | 3730 | /* go directly to calls of special handlers */ |
@@ -3765,10 +3781,6 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3765 | debug_text_event(fsf_req->adapter->erp_dbf, 1, | 3781 | debug_text_event(fsf_req->adapter->erp_dbf, 1, |
3766 | "fsf_s_hand_mis"); | 3782 | "fsf_s_hand_mis"); |
3767 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); | 3783 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); |
3768 | zfcp_cmd_dbf_event_fsf("handmism", | ||
3769 | fsf_req, | ||
3770 | &header->fsf_status_qual, | ||
3771 | sizeof (union fsf_status_qual)); | ||
3772 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3784 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3773 | break; | 3785 | break; |
3774 | 3786 | ||
@@ -3789,10 +3801,6 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3789 | debug_text_exception(fsf_req->adapter->erp_dbf, 0, | 3801 | debug_text_exception(fsf_req->adapter->erp_dbf, 0, |
3790 | "fsf_s_class_nsup"); | 3802 | "fsf_s_class_nsup"); |
3791 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); | 3803 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); |
3792 | zfcp_cmd_dbf_event_fsf("unsclass", | ||
3793 | fsf_req, | ||
3794 | &header->fsf_status_qual, | ||
3795 | sizeof (union fsf_status_qual)); | ||
3796 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3804 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3797 | break; | 3805 | break; |
3798 | 3806 | ||
@@ -3811,10 +3819,6 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3811 | debug_text_event(fsf_req->adapter->erp_dbf, 1, | 3819 | debug_text_event(fsf_req->adapter->erp_dbf, 1, |
3812 | "fsf_s_fcp_lun_nv"); | 3820 | "fsf_s_fcp_lun_nv"); |
3813 | zfcp_erp_port_reopen(unit->port, 0); | 3821 | zfcp_erp_port_reopen(unit->port, 0); |
3814 | zfcp_cmd_dbf_event_fsf("fluninv", | ||
3815 | fsf_req, | ||
3816 | &header->fsf_status_qual, | ||
3817 | sizeof (union fsf_status_qual)); | ||
3818 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3822 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3819 | break; | 3823 | break; |
3820 | 3824 | ||
@@ -3853,10 +3857,6 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3853 | debug_text_event(fsf_req->adapter->erp_dbf, 0, | 3857 | debug_text_event(fsf_req->adapter->erp_dbf, 0, |
3854 | "fsf_s_dir_ind_nv"); | 3858 | "fsf_s_dir_ind_nv"); |
3855 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); | 3859 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); |
3856 | zfcp_cmd_dbf_event_fsf("dirinv", | ||
3857 | fsf_req, | ||
3858 | &header->fsf_status_qual, | ||
3859 | sizeof (union fsf_status_qual)); | ||
3860 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3860 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3861 | break; | 3861 | break; |
3862 | 3862 | ||
@@ -3872,10 +3872,6 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3872 | debug_text_event(fsf_req->adapter->erp_dbf, 0, | 3872 | debug_text_event(fsf_req->adapter->erp_dbf, 0, |
3873 | "fsf_s_cmd_len_nv"); | 3873 | "fsf_s_cmd_len_nv"); |
3874 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); | 3874 | zfcp_erp_adapter_shutdown(unit->port->adapter, 0); |
3875 | zfcp_cmd_dbf_event_fsf("cleninv", | ||
3876 | fsf_req, | ||
3877 | &header->fsf_status_qual, | ||
3878 | sizeof (union fsf_status_qual)); | ||
3879 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; | 3875 | fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR; |
3880 | break; | 3876 | break; |
3881 | 3877 | ||
@@ -3947,6 +3943,8 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req) | |||
3947 | zfcp_fsf_send_fcp_command_task_management_handler(fsf_req); | 3943 | zfcp_fsf_send_fcp_command_task_management_handler(fsf_req); |
3948 | } else { | 3944 | } else { |
3949 | retval = zfcp_fsf_send_fcp_command_task_handler(fsf_req); | 3945 | retval = zfcp_fsf_send_fcp_command_task_handler(fsf_req); |
3946 | fsf_req->unit = NULL; | ||
3947 | zfcp_unit_put(unit); | ||
3950 | } | 3948 | } |
3951 | return retval; | 3949 | return retval; |
3952 | } | 3950 | } |
@@ -3970,10 +3968,10 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
3970 | u32 sns_len; | 3968 | u32 sns_len; |
3971 | char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu); | 3969 | char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu); |
3972 | unsigned long flags; | 3970 | unsigned long flags; |
3973 | struct zfcp_unit *unit = fsf_req->data.send_fcp_command_task.unit; | 3971 | struct zfcp_unit *unit = fsf_req->unit; |
3974 | 3972 | ||
3975 | read_lock_irqsave(&fsf_req->adapter->abort_lock, flags); | 3973 | read_lock_irqsave(&fsf_req->adapter->abort_lock, flags); |
3976 | scpnt = fsf_req->data.send_fcp_command_task.scsi_cmnd; | 3974 | scpnt = (struct scsi_cmnd *) fsf_req->data; |
3977 | if (unlikely(!scpnt)) { | 3975 | if (unlikely(!scpnt)) { |
3978 | ZFCP_LOG_DEBUG | 3976 | ZFCP_LOG_DEBUG |
3979 | ("Command with fsf_req %p is not associated to " | 3977 | ("Command with fsf_req %p is not associated to " |
@@ -4043,7 +4041,6 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
4043 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, | 4041 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, |
4044 | (char *) &fsf_req->qtcb-> | 4042 | (char *) &fsf_req->qtcb-> |
4045 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); | 4043 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); |
4046 | zfcp_cmd_dbf_event_fsf("clenmis", fsf_req, NULL, 0); | ||
4047 | set_host_byte(&scpnt->result, DID_ERROR); | 4044 | set_host_byte(&scpnt->result, DID_ERROR); |
4048 | goto skip_fsfstatus; | 4045 | goto skip_fsfstatus; |
4049 | case RSP_CODE_FIELD_INVALID: | 4046 | case RSP_CODE_FIELD_INVALID: |
@@ -4062,7 +4059,6 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
4062 | (char *) &fsf_req->qtcb-> | 4059 | (char *) &fsf_req->qtcb-> |
4063 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); | 4060 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); |
4064 | set_host_byte(&scpnt->result, DID_ERROR); | 4061 | set_host_byte(&scpnt->result, DID_ERROR); |
4065 | zfcp_cmd_dbf_event_fsf("codeinv", fsf_req, NULL, 0); | ||
4066 | goto skip_fsfstatus; | 4062 | goto skip_fsfstatus; |
4067 | case RSP_CODE_RO_MISMATCH: | 4063 | case RSP_CODE_RO_MISMATCH: |
4068 | /* hardware bug */ | 4064 | /* hardware bug */ |
@@ -4079,7 +4075,6 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
4079 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, | 4075 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, |
4080 | (char *) &fsf_req->qtcb-> | 4076 | (char *) &fsf_req->qtcb-> |
4081 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); | 4077 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); |
4082 | zfcp_cmd_dbf_event_fsf("codemism", fsf_req, NULL, 0); | ||
4083 | set_host_byte(&scpnt->result, DID_ERROR); | 4078 | set_host_byte(&scpnt->result, DID_ERROR); |
4084 | goto skip_fsfstatus; | 4079 | goto skip_fsfstatus; |
4085 | default: | 4080 | default: |
@@ -4096,7 +4091,6 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
4096 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, | 4091 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, |
4097 | (char *) &fsf_req->qtcb-> | 4092 | (char *) &fsf_req->qtcb-> |
4098 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); | 4093 | bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE); |
4099 | zfcp_cmd_dbf_event_fsf("undeffcp", fsf_req, NULL, 0); | ||
4100 | set_host_byte(&scpnt->result, DID_ERROR); | 4094 | set_host_byte(&scpnt->result, DID_ERROR); |
4101 | goto skip_fsfstatus; | 4095 | goto skip_fsfstatus; |
4102 | } | 4096 | } |
@@ -4158,19 +4152,17 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req) | |||
4158 | skip_fsfstatus: | 4152 | skip_fsfstatus: |
4159 | ZFCP_LOG_DEBUG("scpnt->result =0x%x\n", scpnt->result); | 4153 | ZFCP_LOG_DEBUG("scpnt->result =0x%x\n", scpnt->result); |
4160 | 4154 | ||
4161 | zfcp_cmd_dbf_event_scsi("response", scpnt); | 4155 | if (scpnt->result != 0) |
4156 | zfcp_scsi_dbf_event_result("erro", 3, fsf_req->adapter, scpnt); | ||
4157 | else if (scpnt->retries > 0) | ||
4158 | zfcp_scsi_dbf_event_result("retr", 4, fsf_req->adapter, scpnt); | ||
4159 | else | ||
4160 | zfcp_scsi_dbf_event_result("norm", 6, fsf_req->adapter, scpnt); | ||
4162 | 4161 | ||
4163 | /* cleanup pointer (need this especially for abort) */ | 4162 | /* cleanup pointer (need this especially for abort) */ |
4164 | scpnt->host_scribble = NULL; | 4163 | scpnt->host_scribble = NULL; |
4165 | 4164 | ||
4166 | /* | ||
4167 | * NOTE: | ||
4168 | * according to the outcome of a discussion on linux-scsi we | ||
4169 | * don't need to grab the io_request_lock here since we use | ||
4170 | * the new eh | ||
4171 | */ | ||
4172 | /* always call back */ | 4165 | /* always call back */ |
4173 | |||
4174 | (scpnt->scsi_done) (scpnt); | 4166 | (scpnt->scsi_done) (scpnt); |
4175 | 4167 | ||
4176 | /* | 4168 | /* |
@@ -4198,8 +4190,7 @@ zfcp_fsf_send_fcp_command_task_management_handler(struct zfcp_fsf_req *fsf_req) | |||
4198 | struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *) | 4190 | struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *) |
4199 | &(fsf_req->qtcb->bottom.io.fcp_rsp); | 4191 | &(fsf_req->qtcb->bottom.io.fcp_rsp); |
4200 | char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu); | 4192 | char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu); |
4201 | struct zfcp_unit *unit = | 4193 | struct zfcp_unit *unit = (struct zfcp_unit *) fsf_req->data; |
4202 | fsf_req->data.send_fcp_command_task_management.unit; | ||
4203 | 4194 | ||
4204 | del_timer(&fsf_req->adapter->scsi_er_timer); | 4195 | del_timer(&fsf_req->adapter->scsi_er_timer); |
4205 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { | 4196 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
@@ -4276,7 +4267,7 @@ zfcp_fsf_control_file(struct zfcp_adapter *adapter, | |||
4276 | int direction; | 4267 | int direction; |
4277 | int retval = 0; | 4268 | int retval = 0; |
4278 | 4269 | ||
4279 | if (!(adapter->supported_features & FSF_FEATURE_CFDC)) { | 4270 | if (!(adapter->adapter_features & FSF_FEATURE_CFDC)) { |
4280 | ZFCP_LOG_INFO("cfdc not supported (adapter %s)\n", | 4271 | ZFCP_LOG_INFO("cfdc not supported (adapter %s)\n", |
4281 | zfcp_get_busid_by_adapter(adapter)); | 4272 | zfcp_get_busid_by_adapter(adapter)); |
4282 | retval = -EOPNOTSUPP; | 4273 | retval = -EOPNOTSUPP; |
@@ -4549,52 +4540,6 @@ skip_fsfstatus: | |||
4549 | return retval; | 4540 | return retval; |
4550 | } | 4541 | } |
4551 | 4542 | ||
4552 | |||
4553 | /* | ||
4554 | * function: zfcp_fsf_req_wait_and_cleanup | ||
4555 | * | ||
4556 | * purpose: | ||
4557 | * | ||
4558 | * FIXME(design): signal seems to be <0 !!! | ||
4559 | * returns: 0 - request completed (*status is valid), cleanup succ. | ||
4560 | * <0 - request completed (*status is valid), cleanup failed | ||
4561 | * >0 - signal which interrupted waiting (*status invalid), | ||
4562 | * request not completed, no cleanup | ||
4563 | * | ||
4564 | * *status is a copy of status of completed fsf_req | ||
4565 | */ | ||
4566 | int | ||
4567 | zfcp_fsf_req_wait_and_cleanup(struct zfcp_fsf_req *fsf_req, | ||
4568 | int interruptible, u32 * status) | ||
4569 | { | ||
4570 | int retval = 0; | ||
4571 | int signal = 0; | ||
4572 | |||
4573 | if (interruptible) { | ||
4574 | __wait_event_interruptible(fsf_req->completion_wq, | ||
4575 | fsf_req->status & | ||
4576 | ZFCP_STATUS_FSFREQ_COMPLETED, | ||
4577 | signal); | ||
4578 | if (signal) { | ||
4579 | ZFCP_LOG_DEBUG("Caught signal %i while waiting for the " | ||
4580 | "completion of the request at %p\n", | ||
4581 | signal, fsf_req); | ||
4582 | retval = signal; | ||
4583 | goto out; | ||
4584 | } | ||
4585 | } else { | ||
4586 | __wait_event(fsf_req->completion_wq, | ||
4587 | fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); | ||
4588 | } | ||
4589 | |||
4590 | *status = fsf_req->status; | ||
4591 | |||
4592 | /* cleanup request */ | ||
4593 | zfcp_fsf_req_free(fsf_req); | ||
4594 | out: | ||
4595 | return retval; | ||
4596 | } | ||
4597 | |||
4598 | static inline int | 4543 | static inline int |
4599 | zfcp_fsf_req_sbal_check(unsigned long *flags, | 4544 | zfcp_fsf_req_sbal_check(unsigned long *flags, |
4600 | struct zfcp_qdio_queue *queue, int needed) | 4545 | struct zfcp_qdio_queue *queue, int needed) |
@@ -4610,15 +4555,16 @@ zfcp_fsf_req_sbal_check(unsigned long *flags, | |||
4610 | * set qtcb pointer in fsf_req and initialize QTCB | 4555 | * set qtcb pointer in fsf_req and initialize QTCB |
4611 | */ | 4556 | */ |
4612 | static inline void | 4557 | static inline void |
4613 | zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req *fsf_req, u32 fsf_cmd) | 4558 | zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req *fsf_req) |
4614 | { | 4559 | { |
4615 | if (likely(fsf_req->qtcb != NULL)) { | 4560 | if (likely(fsf_req->qtcb != NULL)) { |
4561 | fsf_req->qtcb->prefix.req_seq_no = fsf_req->adapter->fsf_req_seq_no; | ||
4616 | fsf_req->qtcb->prefix.req_id = (unsigned long)fsf_req; | 4562 | fsf_req->qtcb->prefix.req_id = (unsigned long)fsf_req; |
4617 | fsf_req->qtcb->prefix.ulp_info = ZFCP_ULP_INFO_VERSION; | 4563 | fsf_req->qtcb->prefix.ulp_info = ZFCP_ULP_INFO_VERSION; |
4618 | fsf_req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_cmd]; | 4564 | fsf_req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_req->fsf_command]; |
4619 | fsf_req->qtcb->prefix.qtcb_version = ZFCP_QTCB_VERSION; | 4565 | fsf_req->qtcb->prefix.qtcb_version = ZFCP_QTCB_VERSION; |
4620 | fsf_req->qtcb->header.req_handle = (unsigned long)fsf_req; | 4566 | fsf_req->qtcb->header.req_handle = (unsigned long)fsf_req; |
4621 | fsf_req->qtcb->header.fsf_command = fsf_cmd; | 4567 | fsf_req->qtcb->header.fsf_command = fsf_req->fsf_command; |
4622 | } | 4568 | } |
4623 | } | 4569 | } |
4624 | 4570 | ||
@@ -4686,7 +4632,10 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags, | |||
4686 | goto failed_fsf_req; | 4632 | goto failed_fsf_req; |
4687 | } | 4633 | } |
4688 | 4634 | ||
4689 | zfcp_fsf_req_qtcb_init(fsf_req, fsf_cmd); | 4635 | fsf_req->adapter = adapter; |
4636 | fsf_req->fsf_command = fsf_cmd; | ||
4637 | |||
4638 | zfcp_fsf_req_qtcb_init(fsf_req); | ||
4690 | 4639 | ||
4691 | /* initialize waitqueue which may be used to wait on | 4640 | /* initialize waitqueue which may be used to wait on |
4692 | this request completion */ | 4641 | this request completion */ |
@@ -4708,8 +4657,10 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags, | |||
4708 | goto failed_sbals; | 4657 | goto failed_sbals; |
4709 | } | 4658 | } |
4710 | 4659 | ||
4711 | fsf_req->adapter = adapter; /* pointer to "parent" adapter */ | 4660 | if (fsf_req->qtcb) { |
4712 | fsf_req->fsf_command = fsf_cmd; | 4661 | fsf_req->seq_no = adapter->fsf_req_seq_no; |
4662 | fsf_req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; | ||
4663 | } | ||
4713 | fsf_req->sbal_number = 1; | 4664 | fsf_req->sbal_number = 1; |
4714 | fsf_req->sbal_first = req_queue->free_index; | 4665 | fsf_req->sbal_first = req_queue->free_index; |
4715 | fsf_req->sbal_curr = req_queue->free_index; | 4666 | fsf_req->sbal_curr = req_queue->free_index; |
@@ -4760,9 +4711,9 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer) | |||
4760 | struct zfcp_adapter *adapter; | 4711 | struct zfcp_adapter *adapter; |
4761 | struct zfcp_qdio_queue *req_queue; | 4712 | struct zfcp_qdio_queue *req_queue; |
4762 | volatile struct qdio_buffer_element *sbale; | 4713 | volatile struct qdio_buffer_element *sbale; |
4714 | int inc_seq_no; | ||
4763 | int new_distance_from_int; | 4715 | int new_distance_from_int; |
4764 | unsigned long flags; | 4716 | unsigned long flags; |
4765 | int inc_seq_no = 1; | ||
4766 | int retval = 0; | 4717 | int retval = 0; |
4767 | 4718 | ||
4768 | adapter = fsf_req->adapter; | 4719 | adapter = fsf_req->adapter; |
@@ -4776,23 +4727,13 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer) | |||
4776 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) sbale[1].addr, | 4727 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) sbale[1].addr, |
4777 | sbale[1].length); | 4728 | sbale[1].length); |
4778 | 4729 | ||
4779 | /* set sequence counter in QTCB */ | ||
4780 | if (likely(fsf_req->qtcb)) { | ||
4781 | fsf_req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; | ||
4782 | fsf_req->seq_no = adapter->fsf_req_seq_no; | ||
4783 | ZFCP_LOG_TRACE("FSF request %p of adapter %s gets " | ||
4784 | "FSF sequence counter value of %i\n", | ||
4785 | fsf_req, | ||
4786 | zfcp_get_busid_by_adapter(adapter), | ||
4787 | fsf_req->qtcb->prefix.req_seq_no); | ||
4788 | } else | ||
4789 | inc_seq_no = 0; | ||
4790 | |||
4791 | /* put allocated FSF request at list tail */ | 4730 | /* put allocated FSF request at list tail */ |
4792 | spin_lock_irqsave(&adapter->fsf_req_list_lock, flags); | 4731 | spin_lock_irqsave(&adapter->fsf_req_list_lock, flags); |
4793 | list_add_tail(&fsf_req->list, &adapter->fsf_req_list_head); | 4732 | list_add_tail(&fsf_req->list, &adapter->fsf_req_list_head); |
4794 | spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags); | 4733 | spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags); |
4795 | 4734 | ||
4735 | inc_seq_no = (fsf_req->qtcb != NULL); | ||
4736 | |||
4796 | /* figure out expiration time of timeout and start timeout */ | 4737 | /* figure out expiration time of timeout and start timeout */ |
4797 | if (unlikely(timer)) { | 4738 | if (unlikely(timer)) { |
4798 | timer->expires += jiffies; | 4739 | timer->expires += jiffies; |
@@ -4822,6 +4763,8 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer) | |||
4822 | req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap if needed */ | 4763 | req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap if needed */ |
4823 | new_distance_from_int = zfcp_qdio_determine_pci(req_queue, fsf_req); | 4764 | new_distance_from_int = zfcp_qdio_determine_pci(req_queue, fsf_req); |
4824 | 4765 | ||
4766 | fsf_req->issued = get_clock(); | ||
4767 | |||
4825 | retval = do_QDIO(adapter->ccw_device, | 4768 | retval = do_QDIO(adapter->ccw_device, |
4826 | QDIO_FLAG_SYNC_OUTPUT, | 4769 | QDIO_FLAG_SYNC_OUTPUT, |
4827 | 0, fsf_req->sbal_first, fsf_req->sbal_number, NULL); | 4770 | 0, fsf_req->sbal_first, fsf_req->sbal_number, NULL); |
@@ -4860,15 +4803,11 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer) | |||
4860 | * routines resulting in missing sequence counter values | 4803 | * routines resulting in missing sequence counter values |
4861 | * otherwise, | 4804 | * otherwise, |
4862 | */ | 4805 | */ |
4806 | |||
4863 | /* Don't increase for unsolicited status */ | 4807 | /* Don't increase for unsolicited status */ |
4864 | if (likely(inc_seq_no)) { | 4808 | if (inc_seq_no) |
4865 | adapter->fsf_req_seq_no++; | 4809 | adapter->fsf_req_seq_no++; |
4866 | ZFCP_LOG_TRACE | 4810 | |
4867 | ("FSF sequence counter value of adapter %s " | ||
4868 | "increased to %i\n", | ||
4869 | zfcp_get_busid_by_adapter(adapter), | ||
4870 | adapter->fsf_req_seq_no); | ||
4871 | } | ||
4872 | /* count FSF requests pending */ | 4811 | /* count FSF requests pending */ |
4873 | atomic_inc(&adapter->fsf_reqs_active); | 4812 | atomic_inc(&adapter->fsf_reqs_active); |
4874 | } | 4813 | } |
diff --git a/drivers/s390/scsi/zfcp_fsf.h b/drivers/s390/scsi/zfcp_fsf.h index 07140dfda2a7..48719f055952 100644 --- a/drivers/s390/scsi/zfcp_fsf.h +++ b/drivers/s390/scsi/zfcp_fsf.h | |||
@@ -116,6 +116,7 @@ | |||
116 | #define FSF_INVALID_COMMAND_OPTION 0x000000E5 | 116 | #define FSF_INVALID_COMMAND_OPTION 0x000000E5 |
117 | /* #define FSF_ERROR 0x000000FF */ | 117 | /* #define FSF_ERROR 0x000000FF */ |
118 | 118 | ||
119 | #define FSF_PROT_STATUS_QUAL_SIZE 16 | ||
119 | #define FSF_STATUS_QUALIFIER_SIZE 16 | 120 | #define FSF_STATUS_QUALIFIER_SIZE 16 |
120 | 121 | ||
121 | /* FSF status qualifier, recommendations */ | 122 | /* FSF status qualifier, recommendations */ |
@@ -139,9 +140,18 @@ | |||
139 | #define FSF_SQ_CFDC_SUBTABLE_LUN 0x0004 | 140 | #define FSF_SQ_CFDC_SUBTABLE_LUN 0x0004 |
140 | 141 | ||
141 | /* FSF status qualifier (most significant 4 bytes), local link down */ | 142 | /* FSF status qualifier (most significant 4 bytes), local link down */ |
142 | #define FSF_PSQ_LINK_NOLIGHT 0x00000004 | 143 | #define FSF_PSQ_LINK_NO_LIGHT 0x00000004 |
143 | #define FSF_PSQ_LINK_WRAPPLUG 0x00000008 | 144 | #define FSF_PSQ_LINK_WRAP_PLUG 0x00000008 |
144 | #define FSF_PSQ_LINK_NOFCP 0x00000010 | 145 | #define FSF_PSQ_LINK_NO_FCP 0x00000010 |
146 | #define FSF_PSQ_LINK_FIRMWARE_UPDATE 0x00000020 | ||
147 | #define FSF_PSQ_LINK_INVALID_WWPN 0x00000100 | ||
148 | #define FSF_PSQ_LINK_NO_NPIV_SUPPORT 0x00000200 | ||
149 | #define FSF_PSQ_LINK_NO_FCP_RESOURCES 0x00000400 | ||
150 | #define FSF_PSQ_LINK_NO_FABRIC_RESOURCES 0x00000800 | ||
151 | #define FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE 0x00001000 | ||
152 | #define FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED 0x00002000 | ||
153 | #define FSF_PSQ_LINK_MODE_TABLE_CURRUPTED 0x00004000 | ||
154 | #define FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT 0x00008000 | ||
145 | 155 | ||
146 | /* payload size in status read buffer */ | 156 | /* payload size in status read buffer */ |
147 | #define FSF_STATUS_READ_PAYLOAD_SIZE 4032 | 157 | #define FSF_STATUS_READ_PAYLOAD_SIZE 4032 |
@@ -154,15 +164,21 @@ | |||
154 | #define FSF_STATUS_READ_INCOMING_ELS 0x00000002 | 164 | #define FSF_STATUS_READ_INCOMING_ELS 0x00000002 |
155 | #define FSF_STATUS_READ_SENSE_DATA_AVAIL 0x00000003 | 165 | #define FSF_STATUS_READ_SENSE_DATA_AVAIL 0x00000003 |
156 | #define FSF_STATUS_READ_BIT_ERROR_THRESHOLD 0x00000004 | 166 | #define FSF_STATUS_READ_BIT_ERROR_THRESHOLD 0x00000004 |
157 | #define FSF_STATUS_READ_LINK_DOWN 0x00000005 /* FIXME: really? */ | 167 | #define FSF_STATUS_READ_LINK_DOWN 0x00000005 |
158 | #define FSF_STATUS_READ_LINK_UP 0x00000006 | 168 | #define FSF_STATUS_READ_LINK_UP 0x00000006 |
159 | #define FSF_STATUS_READ_CFDC_UPDATED 0x0000000A | 169 | #define FSF_STATUS_READ_CFDC_UPDATED 0x0000000A |
160 | #define FSF_STATUS_READ_CFDC_HARDENED 0x0000000B | 170 | #define FSF_STATUS_READ_CFDC_HARDENED 0x0000000B |
171 | #define FSF_STATUS_READ_FEATURE_UPDATE_ALERT 0x0000000C | ||
161 | 172 | ||
162 | /* status subtypes in status read buffer */ | 173 | /* status subtypes in status read buffer */ |
163 | #define FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT 0x00000001 | 174 | #define FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT 0x00000001 |
164 | #define FSF_STATUS_READ_SUB_ERROR_PORT 0x00000002 | 175 | #define FSF_STATUS_READ_SUB_ERROR_PORT 0x00000002 |
165 | 176 | ||
177 | /* status subtypes for link down */ | ||
178 | #define FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK 0x00000000 | ||
179 | #define FSF_STATUS_READ_SUB_FDISC_FAILED 0x00000001 | ||
180 | #define FSF_STATUS_READ_SUB_FIRMWARE_UPDATE 0x00000002 | ||
181 | |||
166 | /* status subtypes for CFDC */ | 182 | /* status subtypes for CFDC */ |
167 | #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE 0x00000002 | 183 | #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE 0x00000002 |
168 | #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F | 184 | #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F |
@@ -193,11 +209,15 @@ | |||
193 | #define FSF_QTCB_LOG_SIZE 1024 | 209 | #define FSF_QTCB_LOG_SIZE 1024 |
194 | 210 | ||
195 | /* channel features */ | 211 | /* channel features */ |
196 | #define FSF_FEATURE_QTCB_SUPPRESSION 0x00000001 | ||
197 | #define FSF_FEATURE_CFDC 0x00000002 | 212 | #define FSF_FEATURE_CFDC 0x00000002 |
198 | #define FSF_FEATURE_LUN_SHARING 0x00000004 | 213 | #define FSF_FEATURE_LUN_SHARING 0x00000004 |
199 | #define FSF_FEATURE_HBAAPI_MANAGEMENT 0x00000010 | 214 | #define FSF_FEATURE_HBAAPI_MANAGEMENT 0x00000010 |
200 | #define FSF_FEATURE_ELS_CT_CHAINED_SBALS 0x00000020 | 215 | #define FSF_FEATURE_ELS_CT_CHAINED_SBALS 0x00000020 |
216 | #define FSF_FEATURE_UPDATE_ALERT 0x00000100 | ||
217 | |||
218 | /* host connection features */ | ||
219 | #define FSF_FEATURE_NPIV_MODE 0x00000001 | ||
220 | #define FSF_FEATURE_VM_ASSIGNED_WWPN 0x00000002 | ||
201 | 221 | ||
202 | /* option */ | 222 | /* option */ |
203 | #define FSF_OPEN_LUN_SUPPRESS_BOXING 0x00000001 | 223 | #define FSF_OPEN_LUN_SUPPRESS_BOXING 0x00000001 |
@@ -305,15 +325,23 @@ struct fsf_qual_sequence_error { | |||
305 | u32 res1[3]; | 325 | u32 res1[3]; |
306 | } __attribute__ ((packed)); | 326 | } __attribute__ ((packed)); |
307 | 327 | ||
308 | struct fsf_qual_locallink_error { | 328 | struct fsf_link_down_info { |
309 | u32 code; | 329 | u32 error_code; |
310 | u32 res1[3]; | 330 | u32 res1; |
331 | u8 res2[2]; | ||
332 | u8 primary_status; | ||
333 | u8 ioerr_code; | ||
334 | u8 action_code; | ||
335 | u8 reason_code; | ||
336 | u8 explanation_code; | ||
337 | u8 vendor_specific_code; | ||
311 | } __attribute__ ((packed)); | 338 | } __attribute__ ((packed)); |
312 | 339 | ||
313 | union fsf_prot_status_qual { | 340 | union fsf_prot_status_qual { |
341 | u64 doubleword[FSF_PROT_STATUS_QUAL_SIZE / sizeof(u64)]; | ||
314 | struct fsf_qual_version_error version_error; | 342 | struct fsf_qual_version_error version_error; |
315 | struct fsf_qual_sequence_error sequence_error; | 343 | struct fsf_qual_sequence_error sequence_error; |
316 | struct fsf_qual_locallink_error locallink_error; | 344 | struct fsf_link_down_info link_down_info; |
317 | } __attribute__ ((packed)); | 345 | } __attribute__ ((packed)); |
318 | 346 | ||
319 | struct fsf_qtcb_prefix { | 347 | struct fsf_qtcb_prefix { |
@@ -331,7 +359,9 @@ union fsf_status_qual { | |||
331 | u8 byte[FSF_STATUS_QUALIFIER_SIZE]; | 359 | u8 byte[FSF_STATUS_QUALIFIER_SIZE]; |
332 | u16 halfword[FSF_STATUS_QUALIFIER_SIZE / sizeof (u16)]; | 360 | u16 halfword[FSF_STATUS_QUALIFIER_SIZE / sizeof (u16)]; |
333 | u32 word[FSF_STATUS_QUALIFIER_SIZE / sizeof (u32)]; | 361 | u32 word[FSF_STATUS_QUALIFIER_SIZE / sizeof (u32)]; |
362 | u64 doubleword[FSF_STATUS_QUALIFIER_SIZE / sizeof(u64)]; | ||
334 | struct fsf_queue_designator fsf_queue_designator; | 363 | struct fsf_queue_designator fsf_queue_designator; |
364 | struct fsf_link_down_info link_down_info; | ||
335 | } __attribute__ ((packed)); | 365 | } __attribute__ ((packed)); |
336 | 366 | ||
337 | struct fsf_qtcb_header { | 367 | struct fsf_qtcb_header { |
@@ -406,8 +436,8 @@ struct fsf_qtcb_bottom_config { | |||
406 | u32 low_qtcb_version; | 436 | u32 low_qtcb_version; |
407 | u32 max_qtcb_size; | 437 | u32 max_qtcb_size; |
408 | u32 max_data_transfer_size; | 438 | u32 max_data_transfer_size; |
409 | u32 supported_features; | 439 | u32 adapter_features; |
410 | u8 res1[4]; | 440 | u32 connection_features; |
411 | u32 fc_topology; | 441 | u32 fc_topology; |
412 | u32 fc_link_speed; | 442 | u32 fc_link_speed; |
413 | u32 adapter_type; | 443 | u32 adapter_type; |
@@ -425,7 +455,7 @@ struct fsf_qtcb_bottom_config { | |||
425 | } __attribute__ ((packed)); | 455 | } __attribute__ ((packed)); |
426 | 456 | ||
427 | struct fsf_qtcb_bottom_port { | 457 | struct fsf_qtcb_bottom_port { |
428 | u8 res1[8]; | 458 | u64 wwpn; |
429 | u32 fc_port_id; | 459 | u32 fc_port_id; |
430 | u32 port_type; | 460 | u32 port_type; |
431 | u32 port_state; | 461 | u32 port_state; |
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c index 24e16ec331d9..d719f66a29a4 100644 --- a/drivers/s390/scsi/zfcp_qdio.c +++ b/drivers/s390/scsi/zfcp_qdio.c | |||
@@ -54,8 +54,7 @@ static inline int zfcp_qdio_sbals_from_buffer | |||
54 | static qdio_handler_t zfcp_qdio_request_handler; | 54 | static qdio_handler_t zfcp_qdio_request_handler; |
55 | static qdio_handler_t zfcp_qdio_response_handler; | 55 | static qdio_handler_t zfcp_qdio_response_handler; |
56 | static int zfcp_qdio_handler_error_check(struct zfcp_adapter *, | 56 | static int zfcp_qdio_handler_error_check(struct zfcp_adapter *, |
57 | unsigned int, | 57 | unsigned int, unsigned int, unsigned int, int, int); |
58 | unsigned int, unsigned int); | ||
59 | 58 | ||
60 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO | 59 | #define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO |
61 | 60 | ||
@@ -214,22 +213,12 @@ zfcp_qdio_allocate(struct zfcp_adapter *adapter) | |||
214 | * | 213 | * |
215 | */ | 214 | */ |
216 | static inline int | 215 | static inline int |
217 | zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, | 216 | zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, unsigned int status, |
218 | unsigned int status, | 217 | unsigned int qdio_error, unsigned int siga_error, |
219 | unsigned int qdio_error, unsigned int siga_error) | 218 | int first_element, int elements_processed) |
220 | { | 219 | { |
221 | int retval = 0; | 220 | int retval = 0; |
222 | 221 | ||
223 | if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_TRACE)) { | ||
224 | if (status & QDIO_STATUS_INBOUND_INT) { | ||
225 | ZFCP_LOG_TRACE("status is" | ||
226 | " QDIO_STATUS_INBOUND_INT \n"); | ||
227 | } | ||
228 | if (status & QDIO_STATUS_OUTBOUND_INT) { | ||
229 | ZFCP_LOG_TRACE("status is" | ||
230 | " QDIO_STATUS_OUTBOUND_INT \n"); | ||
231 | } | ||
232 | } | ||
233 | if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) { | 222 | if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) { |
234 | retval = -EIO; | 223 | retval = -EIO; |
235 | 224 | ||
@@ -237,9 +226,10 @@ zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, | |||
237 | "qdio_error=0x%x, siga_error=0x%x)\n", | 226 | "qdio_error=0x%x, siga_error=0x%x)\n", |
238 | status, qdio_error, siga_error); | 227 | status, qdio_error, siga_error); |
239 | 228 | ||
240 | /* Restarting IO on the failed adapter from scratch */ | 229 | zfcp_hba_dbf_event_qdio(adapter, status, qdio_error, siga_error, |
241 | debug_text_event(adapter->erp_dbf, 1, "qdio_err"); | 230 | first_element, elements_processed); |
242 | /* | 231 | /* |
232 | * Restarting IO on the failed adapter from scratch. | ||
243 | * Since we have been using this adapter, it is save to assume | 233 | * Since we have been using this adapter, it is save to assume |
244 | * that it is not failed but recoverable. The card seems to | 234 | * that it is not failed but recoverable. The card seems to |
245 | * report link-up events by self-initiated queue shutdown. | 235 | * report link-up events by self-initiated queue shutdown. |
@@ -282,7 +272,8 @@ zfcp_qdio_request_handler(struct ccw_device *ccw_device, | |||
282 | first_element, elements_processed); | 272 | first_element, elements_processed); |
283 | 273 | ||
284 | if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, | 274 | if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, |
285 | siga_error))) | 275 | siga_error, first_element, |
276 | elements_processed))) | ||
286 | goto out; | 277 | goto out; |
287 | /* | 278 | /* |
288 | * we stored address of struct zfcp_adapter data structure | 279 | * we stored address of struct zfcp_adapter data structure |
@@ -334,7 +325,8 @@ zfcp_qdio_response_handler(struct ccw_device *ccw_device, | |||
334 | queue = &adapter->response_queue; | 325 | queue = &adapter->response_queue; |
335 | 326 | ||
336 | if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, | 327 | if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, |
337 | siga_error))) | 328 | siga_error, first_element, |
329 | elements_processed))) | ||
338 | goto out; | 330 | goto out; |
339 | 331 | ||
340 | /* | 332 | /* |
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c index 31a76065cf28..3dcd1bfba3b4 100644 --- a/drivers/s390/scsi/zfcp_scsi.c +++ b/drivers/s390/scsi/zfcp_scsi.c | |||
@@ -44,7 +44,8 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *); | |||
44 | static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *); | 44 | static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *); |
45 | static int zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *); | 45 | static int zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *); |
46 | static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *); | 46 | static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *); |
47 | static int zfcp_task_management_function(struct zfcp_unit *, u8); | 47 | static int zfcp_task_management_function(struct zfcp_unit *, u8, |
48 | struct scsi_cmnd *); | ||
48 | 49 | ||
49 | static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *, int, scsi_id_t, | 50 | static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *, int, scsi_id_t, |
50 | scsi_lun_t); | 51 | scsi_lun_t); |
@@ -242,7 +243,10 @@ static void | |||
242 | zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) | 243 | zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) |
243 | { | 244 | { |
244 | set_host_byte(&scpnt->result, result); | 245 | set_host_byte(&scpnt->result, result); |
245 | zfcp_cmd_dbf_event_scsi("failing", scpnt); | 246 | if ((scpnt->device != NULL) && (scpnt->device->host != NULL)) |
247 | zfcp_scsi_dbf_event_result("fail", 4, | ||
248 | (struct zfcp_adapter*) scpnt->device->host->hostdata[0], | ||
249 | scpnt); | ||
246 | /* return directly */ | 250 | /* return directly */ |
247 | scpnt->scsi_done(scpnt); | 251 | scpnt->scsi_done(scpnt); |
248 | } | 252 | } |
@@ -414,67 +418,38 @@ zfcp_port_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id) | |||
414 | return (struct zfcp_port *) NULL; | 418 | return (struct zfcp_port *) NULL; |
415 | } | 419 | } |
416 | 420 | ||
417 | /* | 421 | /** |
418 | * function: zfcp_scsi_eh_abort_handler | 422 | * zfcp_scsi_eh_abort_handler - abort the specified SCSI command |
419 | * | 423 | * @scpnt: pointer to scsi_cmnd to be aborted |
420 | * purpose: tries to abort the specified (timed out) SCSI command | 424 | * Return: SUCCESS - command has been aborted and cleaned up in internal |
421 | * | 425 | * bookkeeping, SCSI stack won't be called for aborted command |
422 | * note: We do not need to care for a SCSI command which completes | 426 | * FAILED - otherwise |
423 | * normally but late during this abort routine runs. | ||
424 | * We are allowed to return late commands to the SCSI stack. | ||
425 | * It tracks the state of commands and will handle late commands. | ||
426 | * (Usually, the normal completion of late commands is ignored with | ||
427 | * respect to the running abort operation. Grep for 'done_late' | ||
428 | * in the SCSI stacks sources.) | ||
429 | * | 427 | * |
430 | * returns: SUCCESS - command has been aborted and cleaned up in internal | 428 | * We do not need to care for a SCSI command which completes normally |
431 | * bookkeeping, | 429 | * but late during this abort routine runs. We are allowed to return |
432 | * SCSI stack won't be called for aborted command | 430 | * late commands to the SCSI stack. It tracks the state of commands and |
433 | * FAILED - otherwise | 431 | * will handle late commands. (Usually, the normal completion of late |
432 | * commands is ignored with respect to the running abort operation.) | ||
434 | */ | 433 | */ |
435 | int | 434 | int |
436 | __zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) | 435 | zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) |
437 | { | 436 | { |
437 | struct Scsi_Host *scsi_host; | ||
438 | struct zfcp_adapter *adapter; | ||
439 | struct zfcp_unit *unit; | ||
438 | int retval = SUCCESS; | 440 | int retval = SUCCESS; |
439 | struct zfcp_fsf_req *new_fsf_req, *old_fsf_req; | 441 | struct zfcp_fsf_req *new_fsf_req = NULL; |
440 | struct zfcp_adapter *adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; | 442 | struct zfcp_fsf_req *old_fsf_req; |
441 | struct zfcp_unit *unit = (struct zfcp_unit *) scpnt->device->hostdata; | ||
442 | struct zfcp_port *port = unit->port; | ||
443 | struct Scsi_Host *scsi_host = scpnt->device->host; | ||
444 | union zfcp_req_data *req_data = NULL; | ||
445 | unsigned long flags; | 443 | unsigned long flags; |
446 | u32 status = 0; | 444 | |
447 | 445 | scsi_host = scpnt->device->host; | |
448 | /* the components of a abort_dbf record (fixed size record) */ | 446 | adapter = (struct zfcp_adapter *) scsi_host->hostdata[0]; |
449 | u64 dbf_scsi_cmnd = (unsigned long) scpnt; | 447 | unit = (struct zfcp_unit *) scpnt->device->hostdata; |
450 | char dbf_opcode[ZFCP_ABORT_DBF_LENGTH]; | ||
451 | wwn_t dbf_wwn = port->wwpn; | ||
452 | fcp_lun_t dbf_fcp_lun = unit->fcp_lun; | ||
453 | u64 dbf_retries = scpnt->retries; | ||
454 | u64 dbf_allowed = scpnt->allowed; | ||
455 | u64 dbf_timeout = 0; | ||
456 | u64 dbf_fsf_req = 0; | ||
457 | u64 dbf_fsf_status = 0; | ||
458 | u64 dbf_fsf_qual[2] = { 0, 0 }; | ||
459 | char dbf_result[ZFCP_ABORT_DBF_LENGTH] = "##undef"; | ||
460 | |||
461 | memset(dbf_opcode, 0, ZFCP_ABORT_DBF_LENGTH); | ||
462 | memcpy(dbf_opcode, | ||
463 | scpnt->cmnd, | ||
464 | min(scpnt->cmd_len, (unsigned char) ZFCP_ABORT_DBF_LENGTH)); | ||
465 | 448 | ||
466 | ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n", | 449 | ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n", |
467 | scpnt, zfcp_get_busid_by_adapter(adapter)); | 450 | scpnt, zfcp_get_busid_by_adapter(adapter)); |
468 | 451 | ||
469 | spin_unlock_irq(scsi_host->host_lock); | 452 | /* avoid race condition between late normal completion and abort */ |
470 | |||
471 | /* | ||
472 | * Race condition between normal (late) completion and abort has | ||
473 | * to be avoided. | ||
474 | * The entirity of all accesses to scsi_req have to be atomic. | ||
475 | * scsi_req is usually part of the fsf_req and thus we block the | ||
476 | * release of fsf_req as long as we need to access scsi_req. | ||
477 | */ | ||
478 | write_lock_irqsave(&adapter->abort_lock, flags); | 453 | write_lock_irqsave(&adapter->abort_lock, flags); |
479 | 454 | ||
480 | /* | 455 | /* |
@@ -484,144 +459,47 @@ __zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) | |||
484 | * this routine returns. (scpnt is parameter passed to this routine | 459 | * this routine returns. (scpnt is parameter passed to this routine |
485 | * and must not disappear during abort even on late completion.) | 460 | * and must not disappear during abort even on late completion.) |
486 | */ | 461 | */ |
487 | req_data = (union zfcp_req_data *) scpnt->host_scribble; | 462 | old_fsf_req = (struct zfcp_fsf_req *) scpnt->host_scribble; |
488 | /* DEBUG */ | ||
489 | ZFCP_LOG_DEBUG("req_data=%p\n", req_data); | ||
490 | if (!req_data) { | ||
491 | ZFCP_LOG_DEBUG("late command completion overtook abort\n"); | ||
492 | /* | ||
493 | * That's it. | ||
494 | * Do not initiate abort but return SUCCESS. | ||
495 | */ | ||
496 | write_unlock_irqrestore(&adapter->abort_lock, flags); | ||
497 | retval = SUCCESS; | ||
498 | strncpy(dbf_result, "##late1", ZFCP_ABORT_DBF_LENGTH); | ||
499 | goto out; | ||
500 | } | ||
501 | |||
502 | /* Figure out which fsf_req needs to be aborted. */ | ||
503 | old_fsf_req = req_data->send_fcp_command_task.fsf_req; | ||
504 | |||
505 | dbf_fsf_req = (unsigned long) old_fsf_req; | ||
506 | dbf_timeout = | ||
507 | (jiffies - req_data->send_fcp_command_task.start_jiffies) / HZ; | ||
508 | |||
509 | ZFCP_LOG_DEBUG("old_fsf_req=%p\n", old_fsf_req); | ||
510 | if (!old_fsf_req) { | 463 | if (!old_fsf_req) { |
511 | write_unlock_irqrestore(&adapter->abort_lock, flags); | 464 | write_unlock_irqrestore(&adapter->abort_lock, flags); |
512 | ZFCP_LOG_NORMAL("bug: no old fsf request found\n"); | 465 | zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, new_fsf_req); |
513 | ZFCP_LOG_NORMAL("req_data:\n"); | 466 | retval = SUCCESS; |
514 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, | ||
515 | (char *) req_data, sizeof (union zfcp_req_data)); | ||
516 | ZFCP_LOG_NORMAL("scsi_cmnd:\n"); | ||
517 | ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, | ||
518 | (char *) scpnt, sizeof (struct scsi_cmnd)); | ||
519 | retval = FAILED; | ||
520 | strncpy(dbf_result, "##bug:r", ZFCP_ABORT_DBF_LENGTH); | ||
521 | goto out; | 467 | goto out; |
522 | } | 468 | } |
523 | old_fsf_req->data.send_fcp_command_task.scsi_cmnd = NULL; | 469 | old_fsf_req->data = 0; |
524 | /* mark old request as being aborted */ | ||
525 | old_fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING; | 470 | old_fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING; |
526 | /* | ||
527 | * We have to collect all information (e.g. unit) needed by | ||
528 | * zfcp_fsf_abort_fcp_command before calling that routine | ||
529 | * since that routine is not allowed to access | ||
530 | * fsf_req which it is going to abort. | ||
531 | * This is because of we need to release fsf_req_list_lock | ||
532 | * before calling zfcp_fsf_abort_fcp_command. | ||
533 | * Since this lock will not be held, fsf_req may complete | ||
534 | * late and may be released meanwhile. | ||
535 | */ | ||
536 | ZFCP_LOG_DEBUG("unit 0x%016Lx (%p)\n", unit->fcp_lun, unit); | ||
537 | 471 | ||
538 | /* | 472 | /* don't access old_fsf_req after releasing the abort_lock */ |
539 | * We block (call schedule) | ||
540 | * That's why we must release the lock and enable the | ||
541 | * interrupts before. | ||
542 | * On the other hand we do not need the lock anymore since | ||
543 | * all critical accesses to scsi_req are done. | ||
544 | */ | ||
545 | write_unlock_irqrestore(&adapter->abort_lock, flags); | 473 | write_unlock_irqrestore(&adapter->abort_lock, flags); |
546 | /* call FSF routine which does the abort */ | 474 | /* call FSF routine which does the abort */ |
547 | new_fsf_req = zfcp_fsf_abort_fcp_command((unsigned long) old_fsf_req, | 475 | new_fsf_req = zfcp_fsf_abort_fcp_command((unsigned long) old_fsf_req, |
548 | adapter, unit, 0); | 476 | adapter, unit, 0); |
549 | ZFCP_LOG_DEBUG("new_fsf_req=%p\n", new_fsf_req); | ||
550 | if (!new_fsf_req) { | 477 | if (!new_fsf_req) { |
478 | ZFCP_LOG_INFO("error: initiation of Abort FCP Cmnd failed\n"); | ||
551 | retval = FAILED; | 479 | retval = FAILED; |
552 | ZFCP_LOG_NORMAL("error: initiation of Abort FCP Cmnd " | ||
553 | "failed\n"); | ||
554 | strncpy(dbf_result, "##nores", ZFCP_ABORT_DBF_LENGTH); | ||
555 | goto out; | 480 | goto out; |
556 | } | 481 | } |
557 | 482 | ||
558 | /* wait for completion of abort */ | 483 | /* wait for completion of abort */ |
559 | ZFCP_LOG_DEBUG("waiting for cleanup...\n"); | ||
560 | #if 1 | ||
561 | /* | ||
562 | * FIXME: | ||
563 | * copying zfcp_fsf_req_wait_and_cleanup code is not really nice | ||
564 | */ | ||
565 | __wait_event(new_fsf_req->completion_wq, | 484 | __wait_event(new_fsf_req->completion_wq, |
566 | new_fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); | 485 | new_fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); |
567 | status = new_fsf_req->status; | 486 | |
568 | dbf_fsf_status = new_fsf_req->qtcb->header.fsf_status; | ||
569 | /* | ||
570 | * Ralphs special debug load provides timestamps in the FSF | ||
571 | * status qualifier. This might be specified later if being | ||
572 | * useful for debugging aborts. | ||
573 | */ | ||
574 | dbf_fsf_qual[0] = | ||
575 | *(u64 *) & new_fsf_req->qtcb->header.fsf_status_qual.word[0]; | ||
576 | dbf_fsf_qual[1] = | ||
577 | *(u64 *) & new_fsf_req->qtcb->header.fsf_status_qual.word[2]; | ||
578 | zfcp_fsf_req_free(new_fsf_req); | ||
579 | #else | ||
580 | retval = zfcp_fsf_req_wait_and_cleanup(new_fsf_req, | ||
581 | ZFCP_UNINTERRUPTIBLE, &status); | ||
582 | #endif | ||
583 | ZFCP_LOG_DEBUG("Waiting for cleanup complete, status=0x%x\n", status); | ||
584 | /* status should be valid since signals were not permitted */ | 487 | /* status should be valid since signals were not permitted */ |
585 | if (status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) { | 488 | if (new_fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) { |
489 | zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, new_fsf_req); | ||
586 | retval = SUCCESS; | 490 | retval = SUCCESS; |
587 | strncpy(dbf_result, "##succ", ZFCP_ABORT_DBF_LENGTH); | 491 | } else if (new_fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) { |
588 | } else if (status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) { | 492 | zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, new_fsf_req); |
589 | retval = SUCCESS; | 493 | retval = SUCCESS; |
590 | strncpy(dbf_result, "##late2", ZFCP_ABORT_DBF_LENGTH); | ||
591 | } else { | 494 | } else { |
495 | zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, new_fsf_req); | ||
592 | retval = FAILED; | 496 | retval = FAILED; |
593 | strncpy(dbf_result, "##fail", ZFCP_ABORT_DBF_LENGTH); | ||
594 | } | 497 | } |
595 | 498 | zfcp_fsf_req_free(new_fsf_req); | |
596 | out: | 499 | out: |
597 | debug_event(adapter->abort_dbf, 1, &dbf_scsi_cmnd, sizeof (u64)); | ||
598 | debug_event(adapter->abort_dbf, 1, &dbf_opcode, ZFCP_ABORT_DBF_LENGTH); | ||
599 | debug_event(adapter->abort_dbf, 1, &dbf_wwn, sizeof (wwn_t)); | ||
600 | debug_event(adapter->abort_dbf, 1, &dbf_fcp_lun, sizeof (fcp_lun_t)); | ||
601 | debug_event(adapter->abort_dbf, 1, &dbf_retries, sizeof (u64)); | ||
602 | debug_event(adapter->abort_dbf, 1, &dbf_allowed, sizeof (u64)); | ||
603 | debug_event(adapter->abort_dbf, 1, &dbf_timeout, sizeof (u64)); | ||
604 | debug_event(adapter->abort_dbf, 1, &dbf_fsf_req, sizeof (u64)); | ||
605 | debug_event(adapter->abort_dbf, 1, &dbf_fsf_status, sizeof (u64)); | ||
606 | debug_event(adapter->abort_dbf, 1, &dbf_fsf_qual[0], sizeof (u64)); | ||
607 | debug_event(adapter->abort_dbf, 1, &dbf_fsf_qual[1], sizeof (u64)); | ||
608 | debug_text_event(adapter->abort_dbf, 1, dbf_result); | ||
609 | |||
610 | spin_lock_irq(scsi_host->host_lock); | ||
611 | return retval; | 500 | return retval; |
612 | } | 501 | } |
613 | 502 | ||
614 | int | ||
615 | zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) | ||
616 | { | ||
617 | int rc; | ||
618 | struct Scsi_Host *scsi_host = scpnt->device->host; | ||
619 | spin_lock_irq(scsi_host->host_lock); | ||
620 | rc = __zfcp_scsi_eh_abort_handler(scpnt); | ||
621 | spin_unlock_irq(scsi_host->host_lock); | ||
622 | return rc; | ||
623 | } | ||
624 | |||
625 | /* | 503 | /* |
626 | * function: zfcp_scsi_eh_device_reset_handler | 504 | * function: zfcp_scsi_eh_device_reset_handler |
627 | * | 505 | * |
@@ -651,8 +529,9 @@ zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) | |||
651 | */ | 529 | */ |
652 | if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET, | 530 | if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET, |
653 | &unit->status)) { | 531 | &unit->status)) { |
654 | retval = | 532 | retval = zfcp_task_management_function(unit, |
655 | zfcp_task_management_function(unit, FCP_LOGICAL_UNIT_RESET); | 533 | FCP_LOGICAL_UNIT_RESET, |
534 | scpnt); | ||
656 | if (retval) { | 535 | if (retval) { |
657 | ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit); | 536 | ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit); |
658 | if (retval == -ENOTSUPP) | 537 | if (retval == -ENOTSUPP) |
@@ -668,7 +547,7 @@ zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) | |||
668 | goto out; | 547 | goto out; |
669 | } | 548 | } |
670 | } | 549 | } |
671 | retval = zfcp_task_management_function(unit, FCP_TARGET_RESET); | 550 | retval = zfcp_task_management_function(unit, FCP_TARGET_RESET, scpnt); |
672 | if (retval) { | 551 | if (retval) { |
673 | ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit); | 552 | ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit); |
674 | retval = FAILED; | 553 | retval = FAILED; |
@@ -681,12 +560,12 @@ zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) | |||
681 | } | 560 | } |
682 | 561 | ||
683 | static int | 562 | static int |
684 | zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags) | 563 | zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags, |
564 | struct scsi_cmnd *scpnt) | ||
685 | { | 565 | { |
686 | struct zfcp_adapter *adapter = unit->port->adapter; | 566 | struct zfcp_adapter *adapter = unit->port->adapter; |
687 | int retval; | ||
688 | int status; | ||
689 | struct zfcp_fsf_req *fsf_req; | 567 | struct zfcp_fsf_req *fsf_req; |
568 | int retval = 0; | ||
690 | 569 | ||
691 | /* issue task management function */ | 570 | /* issue task management function */ |
692 | fsf_req = zfcp_fsf_send_fcp_command_task_management | 571 | fsf_req = zfcp_fsf_send_fcp_command_task_management |
@@ -696,70 +575,63 @@ zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags) | |||
696 | "failed for unit 0x%016Lx on port 0x%016Lx on " | 575 | "failed for unit 0x%016Lx on port 0x%016Lx on " |
697 | "adapter %s\n", unit->fcp_lun, unit->port->wwpn, | 576 | "adapter %s\n", unit->fcp_lun, unit->port->wwpn, |
698 | zfcp_get_busid_by_adapter(adapter)); | 577 | zfcp_get_busid_by_adapter(adapter)); |
578 | zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit, scpnt); | ||
699 | retval = -ENOMEM; | 579 | retval = -ENOMEM; |
700 | goto out; | 580 | goto out; |
701 | } | 581 | } |
702 | 582 | ||
703 | retval = zfcp_fsf_req_wait_and_cleanup(fsf_req, | 583 | __wait_event(fsf_req->completion_wq, |
704 | ZFCP_UNINTERRUPTIBLE, &status); | 584 | fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); |
585 | |||
705 | /* | 586 | /* |
706 | * check completion status of task management function | 587 | * check completion status of task management function |
707 | * (status should always be valid since no signals permitted) | ||
708 | */ | 588 | */ |
709 | if (status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) | 589 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) { |
590 | zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt); | ||
710 | retval = -EIO; | 591 | retval = -EIO; |
711 | else if (status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) | 592 | } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) { |
593 | zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt); | ||
712 | retval = -ENOTSUPP; | 594 | retval = -ENOTSUPP; |
713 | else | 595 | } else |
714 | retval = 0; | 596 | zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt); |
597 | |||
598 | zfcp_fsf_req_free(fsf_req); | ||
715 | out: | 599 | out: |
716 | return retval; | 600 | return retval; |
717 | } | 601 | } |
718 | 602 | ||
719 | /* | 603 | /** |
720 | * function: zfcp_scsi_eh_bus_reset_handler | 604 | * zfcp_scsi_eh_bus_reset_handler - reset bus (reopen adapter) |
721 | * | ||
722 | * purpose: | ||
723 | * | ||
724 | * returns: | ||
725 | */ | 605 | */ |
726 | int | 606 | int |
727 | zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *scpnt) | 607 | zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *scpnt) |
728 | { | 608 | { |
729 | int retval = 0; | 609 | struct zfcp_unit *unit = (struct zfcp_unit*) scpnt->device->hostdata; |
730 | struct zfcp_unit *unit; | 610 | struct zfcp_adapter *adapter = unit->port->adapter; |
731 | 611 | ||
732 | unit = (struct zfcp_unit *) scpnt->device->hostdata; | ||
733 | ZFCP_LOG_NORMAL("bus reset because of problems with " | 612 | ZFCP_LOG_NORMAL("bus reset because of problems with " |
734 | "unit 0x%016Lx\n", unit->fcp_lun); | 613 | "unit 0x%016Lx\n", unit->fcp_lun); |
735 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); | 614 | zfcp_erp_adapter_reopen(adapter, 0); |
736 | zfcp_erp_wait(unit->port->adapter); | 615 | zfcp_erp_wait(adapter); |
737 | retval = SUCCESS; | ||
738 | 616 | ||
739 | return retval; | 617 | return SUCCESS; |
740 | } | 618 | } |
741 | 619 | ||
742 | /* | 620 | /** |
743 | * function: zfcp_scsi_eh_host_reset_handler | 621 | * zfcp_scsi_eh_host_reset_handler - reset host (reopen adapter) |
744 | * | ||
745 | * purpose: | ||
746 | * | ||
747 | * returns: | ||
748 | */ | 622 | */ |
749 | int | 623 | int |
750 | zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt) | 624 | zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt) |
751 | { | 625 | { |
752 | int retval = 0; | 626 | struct zfcp_unit *unit = (struct zfcp_unit*) scpnt->device->hostdata; |
753 | struct zfcp_unit *unit; | 627 | struct zfcp_adapter *adapter = unit->port->adapter; |
754 | 628 | ||
755 | unit = (struct zfcp_unit *) scpnt->device->hostdata; | ||
756 | ZFCP_LOG_NORMAL("host reset because of problems with " | 629 | ZFCP_LOG_NORMAL("host reset because of problems with " |
757 | "unit 0x%016Lx\n", unit->fcp_lun); | 630 | "unit 0x%016Lx\n", unit->fcp_lun); |
758 | zfcp_erp_adapter_reopen(unit->port->adapter, 0); | 631 | zfcp_erp_adapter_reopen(adapter, 0); |
759 | zfcp_erp_wait(unit->port->adapter); | 632 | zfcp_erp_wait(adapter); |
760 | retval = SUCCESS; | ||
761 | 633 | ||
762 | return retval; | 634 | return SUCCESS; |
763 | } | 635 | } |
764 | 636 | ||
765 | /* | 637 | /* |
@@ -826,10 +698,16 @@ void | |||
826 | zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter) | 698 | zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter) |
827 | { | 699 | { |
828 | struct Scsi_Host *shost; | 700 | struct Scsi_Host *shost; |
701 | struct zfcp_port *port; | ||
829 | 702 | ||
830 | shost = adapter->scsi_host; | 703 | shost = adapter->scsi_host; |
831 | if (!shost) | 704 | if (!shost) |
832 | return; | 705 | return; |
706 | read_lock_irq(&zfcp_data.config_lock); | ||
707 | list_for_each_entry(port, &adapter->port_list_head, list) | ||
708 | if (port->rport) | ||
709 | port->rport = NULL; | ||
710 | read_unlock_irq(&zfcp_data.config_lock); | ||
833 | fc_remove_host(shost); | 711 | fc_remove_host(shost); |
834 | scsi_remove_host(shost); | 712 | scsi_remove_host(shost); |
835 | scsi_host_put(shost); | 713 | scsi_host_put(shost); |
@@ -904,18 +782,6 @@ zfcp_get_node_name(struct scsi_target *starget) | |||
904 | read_unlock_irqrestore(&zfcp_data.config_lock, flags); | 782 | read_unlock_irqrestore(&zfcp_data.config_lock, flags); |
905 | } | 783 | } |
906 | 784 | ||
907 | void | ||
908 | zfcp_set_fc_host_attrs(struct zfcp_adapter *adapter) | ||
909 | { | ||
910 | struct Scsi_Host *shost = adapter->scsi_host; | ||
911 | |||
912 | fc_host_node_name(shost) = adapter->wwnn; | ||
913 | fc_host_port_name(shost) = adapter->wwpn; | ||
914 | strncpy(fc_host_serial_number(shost), adapter->serial_number, | ||
915 | min(FC_SERIAL_NUMBER_SIZE, 32)); | ||
916 | fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3; | ||
917 | } | ||
918 | |||
919 | struct fc_function_template zfcp_transport_functions = { | 785 | struct fc_function_template zfcp_transport_functions = { |
920 | .get_starget_port_id = zfcp_get_port_id, | 786 | .get_starget_port_id = zfcp_get_port_id, |
921 | .get_starget_port_name = zfcp_get_port_name, | 787 | .get_starget_port_name = zfcp_get_port_name, |
@@ -927,7 +793,10 @@ struct fc_function_template zfcp_transport_functions = { | |||
927 | .show_host_node_name = 1, | 793 | .show_host_node_name = 1, |
928 | .show_host_port_name = 1, | 794 | .show_host_port_name = 1, |
929 | .show_host_supported_classes = 1, | 795 | .show_host_supported_classes = 1, |
796 | .show_host_maxframe_size = 1, | ||
930 | .show_host_serial_number = 1, | 797 | .show_host_serial_number = 1, |
798 | .show_host_speed = 1, | ||
799 | .show_host_port_id = 1, | ||
931 | }; | 800 | }; |
932 | 801 | ||
933 | /** | 802 | /** |
diff --git a/drivers/s390/scsi/zfcp_sysfs_adapter.c b/drivers/s390/scsi/zfcp_sysfs_adapter.c index e7345a74800a..0cd435280e7d 100644 --- a/drivers/s390/scsi/zfcp_sysfs_adapter.c +++ b/drivers/s390/scsi/zfcp_sysfs_adapter.c | |||
@@ -62,21 +62,18 @@ static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, struct devi | |||
62 | static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_adapter_##_name##_show, NULL); | 62 | static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_adapter_##_name##_show, NULL); |
63 | 63 | ||
64 | ZFCP_DEFINE_ADAPTER_ATTR(status, "0x%08x\n", atomic_read(&adapter->status)); | 64 | ZFCP_DEFINE_ADAPTER_ATTR(status, "0x%08x\n", atomic_read(&adapter->status)); |
65 | ZFCP_DEFINE_ADAPTER_ATTR(wwnn, "0x%016llx\n", adapter->wwnn); | ||
66 | ZFCP_DEFINE_ADAPTER_ATTR(wwpn, "0x%016llx\n", adapter->wwpn); | ||
67 | ZFCP_DEFINE_ADAPTER_ATTR(s_id, "0x%06x\n", adapter->s_id); | ||
68 | ZFCP_DEFINE_ADAPTER_ATTR(peer_wwnn, "0x%016llx\n", adapter->peer_wwnn); | 65 | ZFCP_DEFINE_ADAPTER_ATTR(peer_wwnn, "0x%016llx\n", adapter->peer_wwnn); |
69 | ZFCP_DEFINE_ADAPTER_ATTR(peer_wwpn, "0x%016llx\n", adapter->peer_wwpn); | 66 | ZFCP_DEFINE_ADAPTER_ATTR(peer_wwpn, "0x%016llx\n", adapter->peer_wwpn); |
70 | ZFCP_DEFINE_ADAPTER_ATTR(peer_d_id, "0x%06x\n", adapter->peer_d_id); | 67 | ZFCP_DEFINE_ADAPTER_ATTR(peer_d_id, "0x%06x\n", adapter->peer_d_id); |
68 | ZFCP_DEFINE_ADAPTER_ATTR(physical_wwpn, "0x%016llx\n", adapter->physical_wwpn); | ||
69 | ZFCP_DEFINE_ADAPTER_ATTR(physical_s_id, "0x%06x\n", adapter->physical_s_id); | ||
71 | ZFCP_DEFINE_ADAPTER_ATTR(card_version, "0x%04x\n", adapter->hydra_version); | 70 | ZFCP_DEFINE_ADAPTER_ATTR(card_version, "0x%04x\n", adapter->hydra_version); |
72 | ZFCP_DEFINE_ADAPTER_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version); | 71 | ZFCP_DEFINE_ADAPTER_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version); |
73 | ZFCP_DEFINE_ADAPTER_ATTR(fc_link_speed, "%d Gb/s\n", adapter->fc_link_speed); | ||
74 | ZFCP_DEFINE_ADAPTER_ATTR(fc_service_class, "%d\n", adapter->fc_service_class); | 72 | ZFCP_DEFINE_ADAPTER_ATTR(fc_service_class, "%d\n", adapter->fc_service_class); |
75 | ZFCP_DEFINE_ADAPTER_ATTR(fc_topology, "%s\n", | 73 | ZFCP_DEFINE_ADAPTER_ATTR(fc_topology, "%s\n", |
76 | fc_topologies[adapter->fc_topology]); | 74 | fc_topologies[adapter->fc_topology]); |
77 | ZFCP_DEFINE_ADAPTER_ATTR(hardware_version, "0x%08x\n", | 75 | ZFCP_DEFINE_ADAPTER_ATTR(hardware_version, "0x%08x\n", |
78 | adapter->hardware_version); | 76 | adapter->hardware_version); |
79 | ZFCP_DEFINE_ADAPTER_ATTR(serial_number, "%17s\n", adapter->serial_number); | ||
80 | ZFCP_DEFINE_ADAPTER_ATTR(scsi_host_no, "0x%x\n", adapter->scsi_host_no); | 77 | ZFCP_DEFINE_ADAPTER_ATTR(scsi_host_no, "0x%x\n", adapter->scsi_host_no); |
81 | ZFCP_DEFINE_ADAPTER_ATTR(in_recovery, "%d\n", atomic_test_mask | 78 | ZFCP_DEFINE_ADAPTER_ATTR(in_recovery, "%d\n", atomic_test_mask |
82 | (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)); | 79 | (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)); |
@@ -255,21 +252,18 @@ static struct attribute *zfcp_adapter_attrs[] = { | |||
255 | &dev_attr_in_recovery.attr, | 252 | &dev_attr_in_recovery.attr, |
256 | &dev_attr_port_remove.attr, | 253 | &dev_attr_port_remove.attr, |
257 | &dev_attr_port_add.attr, | 254 | &dev_attr_port_add.attr, |
258 | &dev_attr_wwnn.attr, | ||
259 | &dev_attr_wwpn.attr, | ||
260 | &dev_attr_s_id.attr, | ||
261 | &dev_attr_peer_wwnn.attr, | 255 | &dev_attr_peer_wwnn.attr, |
262 | &dev_attr_peer_wwpn.attr, | 256 | &dev_attr_peer_wwpn.attr, |
263 | &dev_attr_peer_d_id.attr, | 257 | &dev_attr_peer_d_id.attr, |
258 | &dev_attr_physical_wwpn.attr, | ||
259 | &dev_attr_physical_s_id.attr, | ||
264 | &dev_attr_card_version.attr, | 260 | &dev_attr_card_version.attr, |
265 | &dev_attr_lic_version.attr, | 261 | &dev_attr_lic_version.attr, |
266 | &dev_attr_fc_link_speed.attr, | ||
267 | &dev_attr_fc_service_class.attr, | 262 | &dev_attr_fc_service_class.attr, |
268 | &dev_attr_fc_topology.attr, | 263 | &dev_attr_fc_topology.attr, |
269 | &dev_attr_scsi_host_no.attr, | 264 | &dev_attr_scsi_host_no.attr, |
270 | &dev_attr_status.attr, | 265 | &dev_attr_status.attr, |
271 | &dev_attr_hardware_version.attr, | 266 | &dev_attr_hardware_version.attr, |
272 | &dev_attr_serial_number.attr, | ||
273 | NULL | 267 | NULL |
274 | }; | 268 | }; |
275 | 269 | ||