aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/s390
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/s390')
-rw-r--r--drivers/s390/scsi/zfcp_aux.c9
-rw-r--r--drivers/s390/scsi/zfcp_ccw.c14
-rw-r--r--drivers/s390/scsi/zfcp_cfdc.c8
-rw-r--r--drivers/s390/scsi/zfcp_dbf.c1177
-rw-r--r--drivers/s390/scsi/zfcp_dbf.h497
-rw-r--r--drivers/s390/scsi/zfcp_erp.c141
-rw-r--r--drivers/s390/scsi/zfcp_ext.h52
-rw-r--r--drivers/s390/scsi/zfcp_fc.c20
-rw-r--r--drivers/s390/scsi/zfcp_fsf.c113
-rw-r--r--drivers/s390/scsi/zfcp_qdio.c10
-rw-r--r--drivers/s390/scsi/zfcp_scsi.c43
-rw-r--r--drivers/s390/scsi/zfcp_sysfs.c9
12 files changed, 745 insertions, 1348 deletions
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 044fb22718d2..51c666fb67a4 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -45,8 +45,8 @@ static char *init_device;
45module_param_named(device, init_device, charp, 0400); 45module_param_named(device, init_device, charp, 0400);
46MODULE_PARM_DESC(device, "specify initial device"); 46MODULE_PARM_DESC(device, "specify initial device");
47 47
48static struct kmem_cache *zfcp_cache_hw_align(const char *name, 48static struct kmem_cache * __init zfcp_cache_hw_align(const char *name,
49 unsigned long size) 49 unsigned long size)
50{ 50{
51 return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL); 51 return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
52} 52}
@@ -311,8 +311,7 @@ int zfcp_status_read_refill(struct zfcp_adapter *adapter)
311 if (zfcp_fsf_status_read(adapter->qdio)) { 311 if (zfcp_fsf_status_read(adapter->qdio)) {
312 if (atomic_read(&adapter->stat_miss) >= 312 if (atomic_read(&adapter->stat_miss) >=
313 adapter->stat_read_buf_num) { 313 adapter->stat_read_buf_num) {
314 zfcp_erp_adapter_reopen(adapter, 0, "axsref1", 314 zfcp_erp_adapter_reopen(adapter, 0, "axsref1");
315 NULL);
316 return 1; 315 return 1;
317 } 316 }
318 break; 317 break;
@@ -459,7 +458,7 @@ void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
459 sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs); 458 sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs);
460 459
461 zfcp_erp_thread_kill(adapter); 460 zfcp_erp_thread_kill(adapter);
462 zfcp_dbf_adapter_unregister(adapter->dbf); 461 zfcp_dbf_adapter_unregister(adapter);
463 zfcp_qdio_destroy(adapter->qdio); 462 zfcp_qdio_destroy(adapter->qdio);
464 463
465 zfcp_ccw_adapter_put(adapter); /* final put to release */ 464 zfcp_ccw_adapter_put(adapter); /* final put to release */
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index 0833c2b51e39..4f7852dd30c7 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -48,7 +48,7 @@ static int zfcp_ccw_activate(struct ccw_device *cdev)
48 48
49 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING); 49 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
50 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 50 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
51 "ccresu2", NULL); 51 "ccresu2");
52 zfcp_erp_wait(adapter); 52 zfcp_erp_wait(adapter);
53 flush_work(&adapter->scan_work); 53 flush_work(&adapter->scan_work);
54 54
@@ -182,7 +182,7 @@ static int zfcp_ccw_set_offline(struct ccw_device *cdev)
182 if (!adapter) 182 if (!adapter)
183 return 0; 183 return 0;
184 184
185 zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL); 185 zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1");
186 zfcp_erp_wait(adapter); 186 zfcp_erp_wait(adapter);
187 187
188 zfcp_ccw_adapter_put(adapter); 188 zfcp_ccw_adapter_put(adapter);
@@ -207,24 +207,24 @@ static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
207 switch (event) { 207 switch (event) {
208 case CIO_GONE: 208 case CIO_GONE:
209 dev_warn(&cdev->dev, "The FCP device has been detached\n"); 209 dev_warn(&cdev->dev, "The FCP device has been detached\n");
210 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL); 210 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
211 break; 211 break;
212 case CIO_NO_PATH: 212 case CIO_NO_PATH:
213 dev_warn(&cdev->dev, 213 dev_warn(&cdev->dev,
214 "The CHPID for the FCP device is offline\n"); 214 "The CHPID for the FCP device is offline\n");
215 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL); 215 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
216 break; 216 break;
217 case CIO_OPER: 217 case CIO_OPER:
218 dev_info(&cdev->dev, "The FCP device is operational again\n"); 218 dev_info(&cdev->dev, "The FCP device is operational again\n");
219 zfcp_erp_set_adapter_status(adapter, 219 zfcp_erp_set_adapter_status(adapter,
220 ZFCP_STATUS_COMMON_RUNNING); 220 ZFCP_STATUS_COMMON_RUNNING);
221 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 221 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
222 "ccnoti4", NULL); 222 "ccnoti4");
223 break; 223 break;
224 case CIO_BOXED: 224 case CIO_BOXED:
225 dev_warn(&cdev->dev, "The FCP device did not respond within " 225 dev_warn(&cdev->dev, "The FCP device did not respond within "
226 "the specified time\n"); 226 "the specified time\n");
227 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL); 227 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
228 break; 228 break;
229 } 229 }
230 230
@@ -243,7 +243,7 @@ static void zfcp_ccw_shutdown(struct ccw_device *cdev)
243 if (!adapter) 243 if (!adapter)
244 return; 244 return;
245 245
246 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL); 246 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
247 zfcp_erp_wait(adapter); 247 zfcp_erp_wait(adapter);
248 zfcp_erp_thread_kill(adapter); 248 zfcp_erp_thread_kill(adapter);
249 249
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index d692e229ecba..46342fee394d 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -288,7 +288,7 @@ void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
288 (status & ZFCP_STATUS_COMMON_ACCESS_BOXED)) 288 (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
289 zfcp_erp_port_reopen(port, 289 zfcp_erp_port_reopen(port,
290 ZFCP_STATUS_COMMON_ERP_FAILED, 290 ZFCP_STATUS_COMMON_ERP_FAILED,
291 "cfaac_1", NULL); 291 "cfaac_1");
292 } 292 }
293 read_unlock_irqrestore(&adapter->port_list_lock, flags); 293 read_unlock_irqrestore(&adapter->port_list_lock, flags);
294 294
@@ -299,7 +299,7 @@ void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
299 (status & ZFCP_STATUS_COMMON_ACCESS_BOXED)) 299 (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
300 zfcp_erp_lun_reopen(sdev, 300 zfcp_erp_lun_reopen(sdev,
301 ZFCP_STATUS_COMMON_ERP_FAILED, 301 ZFCP_STATUS_COMMON_ERP_FAILED,
302 "cfaac_2", NULL); 302 "cfaac_2");
303 } 303 }
304} 304}
305 305
@@ -426,7 +426,7 @@ int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
426 zfcp_scsi_dev_lun(sdev), 426 zfcp_scsi_dev_lun(sdev),
427 (unsigned long long)zfcp_sdev->port->wwpn); 427 (unsigned long long)zfcp_sdev->port->wwpn);
428 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED); 428 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
429 zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6", NULL); 429 zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
430 return -EACCES; 430 return -EACCES;
431 } 431 }
432 432
@@ -437,7 +437,7 @@ int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
437 zfcp_scsi_dev_lun(sdev), 437 zfcp_scsi_dev_lun(sdev),
438 (unsigned long long)zfcp_sdev->port->wwpn); 438 (unsigned long long)zfcp_sdev->port->wwpn);
439 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED); 439 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
440 zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8", NULL); 440 zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
441 return -EACCES; 441 return -EACCES;
442 } 442 }
443 443
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 2cdd6b28ff7f..96d1462e0bf5 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -3,7 +3,7 @@
3 * 3 *
4 * Debug traces for zfcp. 4 * Debug traces for zfcp.
5 * 5 *
6 * Copyright IBM Corporation 2002, 2009 6 * Copyright IBM Corporation 2002, 2010
7 */ 7 */
8 8
9#define KMSG_COMPONENT "zfcp" 9#define KMSG_COMPONENT "zfcp"
@@ -22,980 +22,392 @@ module_param(dbfsize, uint, 0400);
22MODULE_PARM_DESC(dbfsize, 22MODULE_PARM_DESC(dbfsize,
23 "number of pages for each debug feature area (default 4)"); 23 "number of pages for each debug feature area (default 4)");
24 24
25static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len, 25static inline unsigned int zfcp_dbf_plen(unsigned int offset)
26 int level, char *from, int from_len)
27{ 26{
28 int offset; 27 return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC;
29 struct zfcp_dbf_dump *dump = to;
30 int room = to_len - sizeof(*dump);
31
32 for (offset = 0; offset < from_len; offset += dump->size) {
33 memset(to, 0, to_len);
34 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
35 dump->total_size = from_len;
36 dump->offset = offset;
37 dump->size = min(from_len - offset, room);
38 memcpy(dump->data, from + offset, dump->size);
39 debug_event(dbf, level, dump, dump->size + sizeof(*dump));
40 }
41} 28}
42 29
43static void zfcp_dbf_tag(char **p, const char *label, const char *tag) 30static inline
31void zfcp_dbf_pl_write(struct zfcp_dbf *dbf, void *data, u16 length, char *area,
32 u64 req_id)
44{ 33{
45 int i; 34 struct zfcp_dbf_pay *pl = &dbf->pay_buf;
46 35 u16 offset = 0, rec_length;
47 *p += sprintf(*p, "%-24s", label);
48 for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++)
49 *p += sprintf(*p, "%c", tag[i]);
50 *p += sprintf(*p, "\n");
51}
52 36
53static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2) 37 spin_lock(&dbf->pay_lock);
54{ 38 memset(pl, 0, sizeof(*pl));
55 *buf += sprintf(*buf, "%-24s%s\n", s1, s2); 39 pl->fsf_req_id = req_id;
56} 40 memcpy(pl->area, area, ZFCP_DBF_TAG_LEN);
57 41
58static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...) 42 while (offset < length) {
59{ 43 rec_length = min((u16) ZFCP_DBF_PAY_MAX_REC,
60 va_list arg; 44 (u16) (length - offset));
45 memcpy(pl->data, data + offset, rec_length);
46 debug_event(dbf->pay, 1, pl, zfcp_dbf_plen(rec_length));
61 47
62 *buf += sprintf(*buf, "%-24s", s); 48 offset += rec_length;
63 va_start(arg, format); 49 pl->counter++;
64 *buf += vsprintf(*buf, format, arg);
65 va_end(arg);
66 *buf += sprintf(*buf, "\n");
67}
68
69static void zfcp_dbf_outd(char **p, const char *label, char *buffer,
70 int buflen, int offset, int total_size)
71{
72 if (!offset)
73 *p += sprintf(*p, "%-24s ", label);
74 while (buflen--) {
75 if (offset > 0) {
76 if ((offset % 32) == 0)
77 *p += sprintf(*p, "\n%-24c ", ' ');
78 else if ((offset % 4) == 0)
79 *p += sprintf(*p, " ");
80 }
81 *p += sprintf(*p, "%02x", *buffer++);
82 if (++offset == total_size) {
83 *p += sprintf(*p, "\n");
84 break;
85 }
86 } 50 }
87 if (!total_size)
88 *p += sprintf(*p, "\n");
89}
90 51
91static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view, 52 spin_unlock(&dbf->pay_lock);
92 int area, debug_entry_t *entry, char *out_buf)
93{
94 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry);
95 struct timespec t;
96 char *p = out_buf;
97
98 if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) {
99 stck_to_timespec(entry->id.stck, &t);
100 zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu",
101 t.tv_sec, t.tv_nsec);
102 zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid);
103 } else {
104 zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset,
105 dump->total_size);
106 if ((dump->offset + dump->size) == dump->total_size)
107 p += sprintf(p, "\n");
108 }
109 return p - out_buf;
110} 53}
111 54
112void _zfcp_dbf_hba_fsf_response(const char *tag2, int level, 55/**
113 struct zfcp_fsf_req *fsf_req, 56 * zfcp_dbf_hba_fsf_res - trace event for fsf responses
114 struct zfcp_dbf *dbf) 57 * @tag: tag indicating which kind of unsolicited status has been received
58 * @req: request for which a response was received
59 */
60void zfcp_dbf_hba_fsf_res(char *tag, struct zfcp_fsf_req *req)
115{ 61{
116 struct fsf_qtcb *qtcb = fsf_req->qtcb; 62 struct zfcp_dbf *dbf = req->adapter->dbf;
117 union fsf_prot_status_qual *prot_status_qual = 63 struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix;
118 &qtcb->prefix.prot_status_qual; 64 struct fsf_qtcb_header *q_head = &req->qtcb->header;
119 union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; 65 struct zfcp_dbf_hba *rec = &dbf->hba_buf;
120 struct scsi_cmnd *scsi_cmnd;
121 struct zfcp_port *port;
122 struct zfcp_unit *unit;
123 struct zfcp_send_els *send_els;
124 struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
125 struct zfcp_dbf_hba_record_response *response = &rec->u.response;
126 unsigned long flags; 66 unsigned long flags;
127 67
128 spin_lock_irqsave(&dbf->hba_lock, flags); 68 spin_lock_irqsave(&dbf->hba_lock, flags);
129 memset(rec, 0, sizeof(*rec)); 69 memset(rec, 0, sizeof(*rec));
130 strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE);
131 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
132
133 response->fsf_command = fsf_req->fsf_command;
134 response->fsf_reqid = fsf_req->req_id;
135 response->fsf_seqno = fsf_req->seq_no;
136 response->fsf_issued = fsf_req->issued;
137 response->fsf_prot_status = qtcb->prefix.prot_status;
138 response->fsf_status = qtcb->header.fsf_status;
139 memcpy(response->fsf_prot_status_qual,
140 prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE);
141 memcpy(response->fsf_status_qual,
142 fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
143 response->fsf_req_status = fsf_req->status;
144 response->sbal_first = fsf_req->qdio_req.sbal_first;
145 response->sbal_last = fsf_req->qdio_req.sbal_last;
146 response->sbal_response = fsf_req->qdio_req.sbal_response;
147 response->pool = fsf_req->pool != NULL;
148 response->erp_action = (unsigned long)fsf_req->erp_action;
149
150 switch (fsf_req->fsf_command) {
151 case FSF_QTCB_FCP_CMND:
152 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
153 break;
154 scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
155 if (scsi_cmnd) {
156 response->u.fcp.cmnd = (unsigned long)scsi_cmnd;
157 response->u.fcp.data_dir =
158 qtcb->bottom.io.data_direction;
159 }
160 break;
161
162 case FSF_QTCB_OPEN_PORT_WITH_DID:
163 case FSF_QTCB_CLOSE_PORT:
164 case FSF_QTCB_CLOSE_PHYSICAL_PORT:
165 port = (struct zfcp_port *)fsf_req->data;
166 response->u.port.wwpn = port->wwpn;
167 response->u.port.d_id = port->d_id;
168 response->u.port.port_handle = qtcb->header.port_handle;
169 break;
170
171 case FSF_QTCB_OPEN_LUN:
172 case FSF_QTCB_CLOSE_LUN:
173 unit = (struct zfcp_unit *)fsf_req->data;
174 port = unit->port;
175 response->u.unit.wwpn = port->wwpn;
176 response->u.unit.fcp_lun = unit->fcp_lun;
177 response->u.unit.port_handle = qtcb->header.port_handle;
178 response->u.unit.lun_handle = qtcb->header.lun_handle;
179 break;
180
181 case FSF_QTCB_SEND_ELS:
182 send_els = (struct zfcp_send_els *)fsf_req->data;
183 response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id);
184 break;
185
186 case FSF_QTCB_ABORT_FCP_CMND:
187 case FSF_QTCB_SEND_GENERIC:
188 case FSF_QTCB_EXCHANGE_CONFIG_DATA:
189 case FSF_QTCB_EXCHANGE_PORT_DATA:
190 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
191 case FSF_QTCB_UPLOAD_CONTROL_FILE:
192 break;
193 }
194
195 debug_event(dbf->hba, level, rec, sizeof(*rec));
196 70
197 /* have fcp channel microcode fixed to use as little as possible */ 71 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
198 if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) { 72 rec->id = ZFCP_DBF_HBA_RES;
199 /* adjust length skipping trailing zeros */ 73 rec->fsf_req_id = req->req_id;
200 char *buf = (char *)qtcb + qtcb->header.log_start; 74 rec->fsf_req_status = req->status;
201 int len = qtcb->header.log_length; 75 rec->fsf_cmd = req->fsf_command;
202 for (; len && !buf[len - 1]; len--); 76 rec->fsf_seq_no = req->seq_no;
203 zfcp_dbf_hexdump(dbf->hba, rec, sizeof(*rec), level, buf, 77 rec->u.res.req_issued = req->issued;
204 len); 78 rec->u.res.prot_status = q_pref->prot_status;
79 rec->u.res.fsf_status = q_head->fsf_status;
80
81 memcpy(rec->u.res.prot_status_qual, &q_pref->prot_status_qual,
82 FSF_PROT_STATUS_QUAL_SIZE);
83 memcpy(rec->u.res.fsf_status_qual, &q_head->fsf_status_qual,
84 FSF_STATUS_QUALIFIER_SIZE);
85
86 if (req->fsf_command != FSF_QTCB_FCP_CMND) {
87 rec->pl_len = q_head->log_length;
88 zfcp_dbf_pl_write(dbf, (char *)q_pref + q_head->log_start,
89 rec->pl_len, "fsf_res", req->req_id);
205 } 90 }
206 91
207 spin_unlock_irqrestore(&dbf->hba_lock, flags); 92 debug_event(dbf->hba, 1, rec, sizeof(*rec));
208}
209
210void _zfcp_dbf_hba_fsf_unsol(const char *tag, int level, struct zfcp_dbf *dbf,
211 struct fsf_status_read_buffer *status_buffer)
212{
213 struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
214 unsigned long flags;
215
216 spin_lock_irqsave(&dbf->hba_lock, flags);
217 memset(rec, 0, sizeof(*rec));
218 strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE);
219 strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE);
220
221 rec->u.status.failed = atomic_read(&dbf->adapter->stat_miss);
222 if (status_buffer != NULL) {
223 rec->u.status.status_type = status_buffer->status_type;
224 rec->u.status.status_subtype = status_buffer->status_subtype;
225 memcpy(&rec->u.status.queue_designator,
226 &status_buffer->queue_designator,
227 sizeof(struct fsf_queue_designator));
228
229 switch (status_buffer->status_type) {
230 case FSF_STATUS_READ_SENSE_DATA_AVAIL:
231 rec->u.status.payload_size =
232 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL;
233 break;
234
235 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
236 rec->u.status.payload_size =
237 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD;
238 break;
239
240 case FSF_STATUS_READ_LINK_DOWN:
241 switch (status_buffer->status_subtype) {
242 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
243 case FSF_STATUS_READ_SUB_FDISC_FAILED:
244 rec->u.status.payload_size =
245 sizeof(struct fsf_link_down_info);
246 }
247 break;
248
249 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
250 rec->u.status.payload_size =
251 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT;
252 break;
253 }
254 memcpy(&rec->u.status.payload,
255 &status_buffer->payload, rec->u.status.payload_size);
256 }
257
258 debug_event(dbf->hba, level, rec, sizeof(*rec));
259 spin_unlock_irqrestore(&dbf->hba_lock, flags); 93 spin_unlock_irqrestore(&dbf->hba_lock, flags);
260} 94}
261 95
262/** 96/**
263 * zfcp_dbf_hba_qdio - trace event for QDIO related failure 97 * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer
264 * @qdio: qdio structure affected by this QDIO related event 98 * @tag: tag indicating which kind of unsolicited status has been received
265 * @qdio_error: as passed by qdio module 99 * @req: request providing the unsolicited status
266 * @sbal_index: first buffer with error condition, as passed by qdio module
267 * @sbal_count: number of buffers affected, as passed by qdio module
268 */ 100 */
269void zfcp_dbf_hba_qdio(struct zfcp_dbf *dbf, unsigned int qdio_error, 101void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req)
270 int sbal_index, int sbal_count)
271{ 102{
272 struct zfcp_dbf_hba_record *r = &dbf->hba_buf; 103 struct zfcp_dbf *dbf = req->adapter->dbf;
104 struct fsf_status_read_buffer *srb = req->data;
105 struct zfcp_dbf_hba *rec = &dbf->hba_buf;
273 unsigned long flags; 106 unsigned long flags;
274 107
275 spin_lock_irqsave(&dbf->hba_lock, flags); 108 spin_lock_irqsave(&dbf->hba_lock, flags);
276 memset(r, 0, sizeof(*r)); 109 memset(rec, 0, sizeof(*rec));
277 strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); 110
278 r->u.qdio.qdio_error = qdio_error; 111 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
279 r->u.qdio.sbal_index = sbal_index; 112 rec->id = ZFCP_DBF_HBA_USS;
280 r->u.qdio.sbal_count = sbal_count; 113 rec->fsf_req_id = req->req_id;
281 debug_event(dbf->hba, 0, r, sizeof(*r)); 114 rec->fsf_req_status = req->status;
115 rec->fsf_cmd = req->fsf_command;
116
117 if (!srb)
118 goto log;
119
120 rec->u.uss.status_type = srb->status_type;
121 rec->u.uss.status_subtype = srb->status_subtype;
122 rec->u.uss.d_id = ntoh24(srb->d_id);
123 rec->u.uss.lun = srb->fcp_lun;
124 memcpy(&rec->u.uss.queue_designator, &srb->queue_designator,
125 sizeof(rec->u.uss.queue_designator));
126
127 /* status read buffer payload length */
128 rec->pl_len = (!srb->length) ? 0 : srb->length -
129 offsetof(struct fsf_status_read_buffer, payload);
130
131 if (rec->pl_len)
132 zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len,
133 "fsf_uss", req->req_id);
134log:
135 debug_event(dbf->hba, 2, rec, sizeof(*rec));
282 spin_unlock_irqrestore(&dbf->hba_lock, flags); 136 spin_unlock_irqrestore(&dbf->hba_lock, flags);
283} 137}
284 138
285/** 139/**
286 * zfcp_dbf_hba_berr - trace event for bit error threshold 140 * zfcp_dbf_hba_bit_err - trace event for bit error conditions
287 * @dbf: dbf structure affected by this QDIO related event 141 * @tag: tag indicating which kind of unsolicited status has been received
288 * @req: fsf request 142 * @req: request which caused the bit_error condition
289 */ 143 */
290void zfcp_dbf_hba_berr(struct zfcp_dbf *dbf, struct zfcp_fsf_req *req) 144void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req)
291{ 145{
292 struct zfcp_dbf_hba_record *r = &dbf->hba_buf; 146 struct zfcp_dbf *dbf = req->adapter->dbf;
147 struct zfcp_dbf_hba *rec = &dbf->hba_buf;
293 struct fsf_status_read_buffer *sr_buf = req->data; 148 struct fsf_status_read_buffer *sr_buf = req->data;
294 struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
295 unsigned long flags; 149 unsigned long flags;
296 150
297 spin_lock_irqsave(&dbf->hba_lock, flags); 151 spin_lock_irqsave(&dbf->hba_lock, flags);
298 memset(r, 0, sizeof(*r)); 152 memset(rec, 0, sizeof(*rec));
299 strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
300 memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
301 debug_event(dbf->hba, 0, r, sizeof(*r));
302 spin_unlock_irqrestore(&dbf->hba_lock, flags);
303}
304static void zfcp_dbf_hba_view_response(char **p,
305 struct zfcp_dbf_hba_record_response *r)
306{
307 struct timespec t;
308
309 zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command);
310 zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
311 zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno);
312 stck_to_timespec(r->fsf_issued, &t);
313 zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
314 zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status);
315 zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status);
316 zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual,
317 FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE);
318 zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual,
319 FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE);
320 zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status);
321 zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first);
322 zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last);
323 zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response);
324 zfcp_dbf_out(p, "pool", "0x%02x", r->pool);
325
326 switch (r->fsf_command) {
327 case FSF_QTCB_FCP_CMND:
328 if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
329 break;
330 zfcp_dbf_out(p, "data_direction", "0x%04x", r->u.fcp.data_dir);
331 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
332 *p += sprintf(*p, "\n");
333 break;
334
335 case FSF_QTCB_OPEN_PORT_WITH_DID:
336 case FSF_QTCB_CLOSE_PORT:
337 case FSF_QTCB_CLOSE_PHYSICAL_PORT:
338 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn);
339 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id);
340 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle);
341 break;
342
343 case FSF_QTCB_OPEN_LUN:
344 case FSF_QTCB_CLOSE_LUN:
345 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn);
346 zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun);
347 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle);
348 zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle);
349 break;
350
351 case FSF_QTCB_SEND_ELS:
352 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id);
353 break;
354
355 case FSF_QTCB_ABORT_FCP_CMND:
356 case FSF_QTCB_SEND_GENERIC:
357 case FSF_QTCB_EXCHANGE_CONFIG_DATA:
358 case FSF_QTCB_EXCHANGE_PORT_DATA:
359 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
360 case FSF_QTCB_UPLOAD_CONTROL_FILE:
361 break;
362 }
363}
364
365static void zfcp_dbf_hba_view_status(char **p,
366 struct zfcp_dbf_hba_record_status *r)
367{
368 zfcp_dbf_out(p, "failed", "0x%02x", r->failed);
369 zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type);
370 zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype);
371 zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator,
372 sizeof(struct fsf_queue_designator), 0,
373 sizeof(struct fsf_queue_designator));
374 zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0,
375 r->payload_size);
376}
377
378static void zfcp_dbf_hba_view_qdio(char **p, struct zfcp_dbf_hba_record_qdio *r)
379{
380 zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error);
381 zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index);
382 zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
383}
384 153
385static void zfcp_dbf_hba_view_berr(char **p, struct fsf_bit_error_payload *r) 154 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
386{ 155 rec->id = ZFCP_DBF_HBA_BIT;
387 zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count); 156 rec->fsf_req_id = req->req_id;
388 zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count); 157 rec->fsf_req_status = req->status;
389 zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count); 158 rec->fsf_cmd = req->fsf_command;
390 zfcp_dbf_out(p, "prim_seq_err", "%d", 159 memcpy(&rec->u.be, &sr_buf->payload.bit_error,
391 r->primitive_sequence_error_count); 160 sizeof(struct fsf_bit_error_payload));
392 zfcp_dbf_out(p, "inval_trans_word_err", "%d",
393 r->invalid_transmission_word_error_count);
394 zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
395 zfcp_dbf_out(p, "prim_seq_event_to", "%d",
396 r->primitive_sequence_event_timeout_count);
397 zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
398 r->elastic_buffer_overrun_error_count);
399 zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
400 r->advertised_receive_b2b_credit);
401 zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
402 r->current_receive_b2b_credit);
403 zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
404 r->advertised_transmit_b2b_credit);
405 zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
406 r->current_transmit_b2b_credit);
407}
408 161
409static int zfcp_dbf_hba_view_format(debug_info_t *id, struct debug_view *view, 162 debug_event(dbf->hba, 1, rec, sizeof(*rec));
410 char *out_buf, const char *in_buf) 163 spin_unlock_irqrestore(&dbf->hba_lock, flags);
411{
412 struct zfcp_dbf_hba_record *r = (struct zfcp_dbf_hba_record *)in_buf;
413 char *p = out_buf;
414
415 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
416 return 0;
417
418 zfcp_dbf_tag(&p, "tag", r->tag);
419 if (isalpha(r->tag2[0]))
420 zfcp_dbf_tag(&p, "tag2", r->tag2);
421
422 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0)
423 zfcp_dbf_hba_view_response(&p, &r->u.response);
424 else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0)
425 zfcp_dbf_hba_view_status(&p, &r->u.status);
426 else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
427 zfcp_dbf_hba_view_qdio(&p, &r->u.qdio);
428 else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
429 zfcp_dbf_hba_view_berr(&p, &r->u.berr);
430
431 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0)
432 p += sprintf(p, "\n");
433 return p - out_buf;
434} 164}
435 165
436static struct debug_view zfcp_dbf_hba_view = { 166static void zfcp_dbf_set_common(struct zfcp_dbf_rec *rec,
437 .name = "structured", 167 struct zfcp_adapter *adapter,
438 .header_proc = zfcp_dbf_view_header, 168 struct zfcp_port *port,
439 .format_proc = zfcp_dbf_hba_view_format, 169 struct scsi_device *sdev)
440};
441
442static const char *zfcp_dbf_rec_tags[] = {
443 [ZFCP_REC_DBF_ID_THREAD] = "thread",
444 [ZFCP_REC_DBF_ID_TARGET] = "target",
445 [ZFCP_REC_DBF_ID_TRIGGER] = "trigger",
446 [ZFCP_REC_DBF_ID_ACTION] = "action",
447};
448
449static int zfcp_dbf_rec_view_format(debug_info_t *id, struct debug_view *view,
450 char *buf, const char *_rec)
451{ 170{
452 struct zfcp_dbf_rec_record *r = (struct zfcp_dbf_rec_record *)_rec; 171 rec->adapter_status = atomic_read(&adapter->status);
453 char *p = buf; 172 if (port) {
454 char hint[ZFCP_DBF_ID_SIZE + 1]; 173 rec->port_status = atomic_read(&port->status);
455 174 rec->wwpn = port->wwpn;
456 memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE); 175 rec->d_id = port->d_id;
457 hint[ZFCP_DBF_ID_SIZE] = 0; 176 }
458 zfcp_dbf_outs(&p, "tag", zfcp_dbf_rec_tags[r->id]); 177 if (sdev) {
459 zfcp_dbf_outs(&p, "hint", hint); 178 rec->lun_status = atomic_read(&sdev_to_zfcp(sdev)->status);
460 switch (r->id) { 179 rec->lun = zfcp_scsi_dev_lun(sdev);
461 case ZFCP_REC_DBF_ID_THREAD:
462 zfcp_dbf_out(&p, "total", "%d", r->u.thread.total);
463 zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready);
464 zfcp_dbf_out(&p, "running", "%d", r->u.thread.running);
465 break;
466 case ZFCP_REC_DBF_ID_TARGET:
467 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref);
468 zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status);
469 zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count);
470 zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id);
471 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn);
472 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun);
473 break;
474 case ZFCP_REC_DBF_ID_TRIGGER:
475 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref);
476 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action);
477 zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want);
478 zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need);
479 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn);
480 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun);
481 zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as);
482 zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps);
483 zfcp_dbf_out(&p, "lun_status", "0x%08x", r->u.trigger.ls);
484 break;
485 case ZFCP_REC_DBF_ID_ACTION:
486 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action);
487 zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req);
488 zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status);
489 zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step);
490 break;
491 } 180 }
492 p += sprintf(p, "\n");
493 return p - buf;
494} 181}
495 182
496static struct debug_view zfcp_dbf_rec_view = {
497 .name = "structured",
498 .header_proc = zfcp_dbf_view_header,
499 .format_proc = zfcp_dbf_rec_view_format,
500};
501
502/** 183/**
503 * zfcp_dbf_rec_thread - trace event related to recovery thread operation 184 * zfcp_dbf_rec_trig - trace event related to triggered recovery
504 * @id2: identifier for event 185 * @tag: identifier for event
505 * @dbf: reference to dbf structure 186 * @adapter: adapter on which the erp_action should run
506 * This function assumes that the caller is holding erp_lock. 187 * @port: remote port involved in the erp_action
188 * @sdev: scsi device involved in the erp_action
189 * @want: wanted erp_action
190 * @need: required erp_action
191 *
192 * The adapter->erp_lock has to be held.
507 */ 193 */
508void zfcp_dbf_rec_thread(char *id2, struct zfcp_dbf *dbf) 194void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter,
195 struct zfcp_port *port, struct scsi_device *sdev,
196 u8 want, u8 need)
509{ 197{
510 struct zfcp_adapter *adapter = dbf->adapter; 198 struct zfcp_dbf *dbf = adapter->dbf;
511 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 199 struct zfcp_dbf_rec *rec = &dbf->rec_buf;
512 unsigned long flags = 0;
513 struct list_head *entry; 200 struct list_head *entry;
514 unsigned ready = 0, running = 0, total;
515
516 list_for_each(entry, &adapter->erp_ready_head)
517 ready++;
518 list_for_each(entry, &adapter->erp_running_head)
519 running++;
520 total = adapter->erp_total_count;
521
522 spin_lock_irqsave(&dbf->rec_lock, flags);
523 memset(r, 0, sizeof(*r));
524 r->id = ZFCP_REC_DBF_ID_THREAD;
525 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
526 r->u.thread.total = total;
527 r->u.thread.ready = ready;
528 r->u.thread.running = running;
529 debug_event(dbf->rec, 6, r, sizeof(*r));
530 spin_unlock_irqrestore(&dbf->rec_lock, flags);
531}
532
533/**
534 * zfcp_dbf_rec_thread - trace event related to recovery thread operation
535 * @id2: identifier for event
536 * @adapter: adapter
537 * This function assumes that the caller does not hold erp_lock.
538 */
539void zfcp_dbf_rec_thread_lock(char *id2, struct zfcp_dbf *dbf)
540{
541 struct zfcp_adapter *adapter = dbf->adapter;
542 unsigned long flags;
543
544 read_lock_irqsave(&adapter->erp_lock, flags);
545 zfcp_dbf_rec_thread(id2, dbf);
546 read_unlock_irqrestore(&adapter->erp_lock, flags);
547}
548
549static void zfcp_dbf_rec_target(char *id2, void *ref, struct zfcp_dbf *dbf,
550 atomic_t *status, atomic_t *erp_count, u64 wwpn,
551 u32 d_id, u64 fcp_lun)
552{
553 struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
554 unsigned long flags; 201 unsigned long flags;
555 202
556 spin_lock_irqsave(&dbf->rec_lock, flags); 203 spin_lock_irqsave(&dbf->rec_lock, flags);
557 memset(r, 0, sizeof(*r)); 204 memset(rec, 0, sizeof(*rec));
558 r->id = ZFCP_REC_DBF_ID_TARGET;
559 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
560 r->u.target.ref = (unsigned long)ref;
561 r->u.target.status = atomic_read(status);
562 r->u.target.wwpn = wwpn;
563 r->u.target.d_id = d_id;
564 r->u.target.fcp_lun = fcp_lun;
565 r->u.target.erp_count = atomic_read(erp_count);
566 debug_event(dbf->rec, 3, r, sizeof(*r));
567 spin_unlock_irqrestore(&dbf->rec_lock, flags);
568}
569
570/**
571 * zfcp_dbf_rec_adapter - trace event for adapter state change
572 * @id: identifier for trigger of state change
573 * @ref: additional reference (e.g. request)
574 * @dbf: reference to dbf structure
575 */
576void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf)
577{
578 struct zfcp_adapter *adapter = dbf->adapter;
579
580 zfcp_dbf_rec_target(id, ref, dbf, &adapter->status,
581 &adapter->erp_counter, 0, 0,
582 ZFCP_DBF_INVALID_LUN);
583}
584
585/**
586 * zfcp_dbf_rec_port - trace event for port state change
587 * @id: identifier for trigger of state change
588 * @ref: additional reference (e.g. request)
589 * @port: port
590 */
591void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port)
592{
593 struct zfcp_dbf *dbf = port->adapter->dbf;
594 205
595 zfcp_dbf_rec_target(id, ref, dbf, &port->status, 206 rec->id = ZFCP_DBF_REC_TRIG;
596 &port->erp_counter, port->wwpn, port->d_id, 207 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
597 ZFCP_DBF_INVALID_LUN); 208 zfcp_dbf_set_common(rec, adapter, port, sdev);
598}
599 209
600/** 210 list_for_each(entry, &adapter->erp_ready_head)
601 * zfcp_dbf_rec_lun - trace event for LUN state change 211 rec->u.trig.ready++;
602 * @id: identifier for trigger of state change
603 * @ref: additional reference (e.g. request)
604 * @sdev: SCSI device
605 */
606void zfcp_dbf_rec_lun(char *id, void *ref, struct scsi_device *sdev)
607{
608 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
609 struct zfcp_port *port = zfcp_sdev->port;
610 struct zfcp_dbf *dbf = port->adapter->dbf;
611 212
612 zfcp_dbf_rec_target(id, ref, dbf, &zfcp_sdev->status, 213 list_for_each(entry, &adapter->erp_running_head)
613 &zfcp_sdev->erp_counter, port->wwpn, port->d_id, 214 rec->u.trig.running++;
614 zfcp_scsi_dev_lun(sdev));
615}
616 215
617/** 216 rec->u.trig.want = want;
618 * zfcp_dbf_rec_trigger - trace event for triggered error recovery 217 rec->u.trig.need = need;
619 * @id2: identifier for error recovery trigger
620 * @ref: additional reference (e.g. request)
621 * @want: originally requested error recovery action
622 * @need: error recovery action actually initiated
623 * @action: address of error recovery action struct
624 * @adapter: adapter
625 * @port: port
626 * @sdev: SCSI device
627 */
628void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action,
629 struct zfcp_adapter *adapter, struct zfcp_port *port,
630 struct scsi_device *sdev)
631{
632 struct zfcp_dbf *dbf = adapter->dbf;
633 struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
634 unsigned long flags;
635 218
636 spin_lock_irqsave(&dbf->rec_lock, flags); 219 debug_event(dbf->rec, 1, rec, sizeof(*rec));
637 memset(r, 0, sizeof(*r));
638 r->id = ZFCP_REC_DBF_ID_TRIGGER;
639 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
640 r->u.trigger.ref = (unsigned long)ref;
641 r->u.trigger.want = want;
642 r->u.trigger.need = need;
643 r->u.trigger.action = (unsigned long)action;
644 r->u.trigger.as = atomic_read(&adapter->status);
645 if (port) {
646 r->u.trigger.ps = atomic_read(&port->status);
647 r->u.trigger.wwpn = port->wwpn;
648 }
649 if (sdev)
650 r->u.trigger.ls = atomic_read(&sdev_to_zfcp(sdev)->status);
651 r->u.trigger.fcp_lun = sdev ? zfcp_scsi_dev_lun(sdev) :
652 ZFCP_DBF_INVALID_LUN;
653 debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r));
654 spin_unlock_irqrestore(&dbf->rec_lock, flags); 220 spin_unlock_irqrestore(&dbf->rec_lock, flags);
655} 221}
656 222
223
657/** 224/**
658 * zfcp_dbf_rec_action - trace event showing progress of recovery action 225 * zfcp_dbf_rec_run - trace event related to running recovery
659 * @id2: identifier 226 * @tag: identifier for event
660 * @erp_action: error recovery action struct pointer 227 * @erp: erp_action running
661 */ 228 */
662void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action) 229void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp)
663{ 230{
664 struct zfcp_dbf *dbf = erp_action->adapter->dbf; 231 struct zfcp_dbf *dbf = erp->adapter->dbf;
665 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 232 struct zfcp_dbf_rec *rec = &dbf->rec_buf;
666 unsigned long flags; 233 unsigned long flags;
667 234
668 spin_lock_irqsave(&dbf->rec_lock, flags); 235 spin_lock_irqsave(&dbf->rec_lock, flags);
669 memset(r, 0, sizeof(*r)); 236 memset(rec, 0, sizeof(*rec));
670 r->id = ZFCP_REC_DBF_ID_ACTION;
671 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
672 r->u.action.action = (unsigned long)erp_action;
673 r->u.action.status = erp_action->status;
674 r->u.action.step = erp_action->step;
675 r->u.action.fsf_req = erp_action->fsf_req_id;
676 debug_event(dbf->rec, 5, r, sizeof(*r));
677 spin_unlock_irqrestore(&dbf->rec_lock, flags);
678}
679 237
680/** 238 rec->id = ZFCP_DBF_REC_RUN;
681 * zfcp_dbf_san_ct_request - trace event for issued CT request 239 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
682 * @fsf_req: request containing issued CT data 240 zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev);
683 * @d_id: destination id where ct request is sent to
684 */
685void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req, u32 d_id)
686{
687 struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data;
688 struct zfcp_adapter *adapter = fsf_req->adapter;
689 struct zfcp_dbf *dbf = adapter->dbf;
690 struct fc_ct_hdr *hdr = sg_virt(ct->req);
691 struct zfcp_dbf_san_record *r = &dbf->san_buf;
692 struct zfcp_dbf_san_record_ct_request *oct = &r->u.ct_req;
693 int level = 3;
694 unsigned long flags;
695 241
696 spin_lock_irqsave(&dbf->san_lock, flags); 242 rec->u.run.fsf_req_id = erp->fsf_req_id;
697 memset(r, 0, sizeof(*r)); 243 rec->u.run.rec_status = erp->status;
698 strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); 244 rec->u.run.rec_step = erp->step;
699 r->fsf_reqid = fsf_req->req_id; 245 rec->u.run.rec_action = erp->action;
700 r->fsf_seqno = fsf_req->seq_no;
701 oct->d_id = d_id;
702 oct->cmd_req_code = hdr->ct_cmd;
703 oct->revision = hdr->ct_rev;
704 oct->gs_type = hdr->ct_fs_type;
705 oct->gs_subtype = hdr->ct_fs_subtype;
706 oct->options = hdr->ct_options;
707 oct->max_res_size = hdr->ct_mr_size;
708 oct->len = min((int)ct->req->length - (int)sizeof(struct fc_ct_hdr),
709 ZFCP_DBF_SAN_MAX_PAYLOAD);
710 debug_event(dbf->san, level, r, sizeof(*r));
711 zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
712 (void *)hdr + sizeof(struct fc_ct_hdr), oct->len);
713 spin_unlock_irqrestore(&dbf->san_lock, flags);
714}
715 246
716/** 247 if (erp->sdev)
717 * zfcp_dbf_san_ct_response - trace event for completion of CT request 248 rec->u.run.rec_count =
718 * @fsf_req: request containing CT response 249 atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter);
719 */ 250 else if (erp->port)
720void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req) 251 rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);
721{ 252 else
722 struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data; 253 rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);
723 struct zfcp_adapter *adapter = fsf_req->adapter;
724 struct fc_ct_hdr *hdr = sg_virt(ct->resp);
725 struct zfcp_dbf *dbf = adapter->dbf;
726 struct zfcp_dbf_san_record *r = &dbf->san_buf;
727 struct zfcp_dbf_san_record_ct_response *rct = &r->u.ct_resp;
728 int level = 3;
729 unsigned long flags;
730 254
731 spin_lock_irqsave(&dbf->san_lock, flags); 255 debug_event(dbf->rec, 1, rec, sizeof(*rec));
732 memset(r, 0, sizeof(*r)); 256 spin_unlock_irqrestore(&dbf->rec_lock, flags);
733 strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
734 r->fsf_reqid = fsf_req->req_id;
735 r->fsf_seqno = fsf_req->seq_no;
736 rct->cmd_rsp_code = hdr->ct_cmd;
737 rct->revision = hdr->ct_rev;
738 rct->reason_code = hdr->ct_reason;
739 rct->expl = hdr->ct_explan;
740 rct->vendor_unique = hdr->ct_vendor;
741 rct->max_res_size = hdr->ct_mr_size;
742 rct->len = min((int)ct->resp->length - (int)sizeof(struct fc_ct_hdr),
743 ZFCP_DBF_SAN_MAX_PAYLOAD);
744 debug_event(dbf->san, level, r, sizeof(*r));
745 zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
746 (void *)hdr + sizeof(struct fc_ct_hdr), rct->len);
747 spin_unlock_irqrestore(&dbf->san_lock, flags);
748} 257}
749 258
750static void zfcp_dbf_san_els(const char *tag, int level, 259static inline
751 struct zfcp_fsf_req *fsf_req, u32 d_id, 260void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf, void *data, u8 id, u16 len,
752 void *buffer, int buflen) 261 u64 req_id, u32 d_id)
753{ 262{
754 struct zfcp_adapter *adapter = fsf_req->adapter; 263 struct zfcp_dbf_san *rec = &dbf->san_buf;
755 struct zfcp_dbf *dbf = adapter->dbf; 264 u16 rec_len;
756 struct zfcp_dbf_san_record *rec = &dbf->san_buf;
757 unsigned long flags; 265 unsigned long flags;
758 266
759 spin_lock_irqsave(&dbf->san_lock, flags); 267 spin_lock_irqsave(&dbf->san_lock, flags);
760 memset(rec, 0, sizeof(*rec)); 268 memset(rec, 0, sizeof(*rec));
761 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); 269
762 rec->fsf_reqid = fsf_req->req_id; 270 rec->id = id;
763 rec->fsf_seqno = fsf_req->seq_no; 271 rec->fsf_req_id = req_id;
764 rec->u.els.d_id = d_id; 272 rec->d_id = d_id;
765 debug_event(dbf->san, level, rec, sizeof(*rec)); 273 rec_len = min(len, (u16)ZFCP_DBF_SAN_MAX_PAYLOAD);
766 zfcp_dbf_hexdump(dbf->san, rec, sizeof(*rec), level, 274 memcpy(rec->payload, data, rec_len);
767 buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD)); 275 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
276
277 debug_event(dbf->san, 1, rec, sizeof(*rec));
768 spin_unlock_irqrestore(&dbf->san_lock, flags); 278 spin_unlock_irqrestore(&dbf->san_lock, flags);
769} 279}
770 280
771/** 281/**
772 * zfcp_dbf_san_els_request - trace event for issued ELS 282 * zfcp_dbf_san_req - trace event for issued SAN request
773 * @fsf_req: request containing issued ELS 283 * @tag: indentifier for event
284 * @fsf_req: request containing issued CT data
285 * d_id: destination ID
774 */ 286 */
775void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req) 287void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id)
776{ 288{
777 struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; 289 struct zfcp_dbf *dbf = fsf->adapter->dbf;
778 u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); 290 struct zfcp_fsf_ct_els *ct_els = fsf->data;
291 u16 length;
779 292
780 zfcp_dbf_san_els("oels", 2, fsf_req, d_id, 293 length = (u16)(ct_els->req->length + FC_CT_HDR_LEN);
781 sg_virt(els->req), els->req->length); 294 zfcp_dbf_san(tag, dbf, sg_virt(ct_els->req), ZFCP_DBF_SAN_REQ, length,
295 fsf->req_id, d_id);
782} 296}
783 297
784/** 298/**
785 * zfcp_dbf_san_els_response - trace event for completed ELS 299 * zfcp_dbf_san_res - trace event for received SAN request
786 * @fsf_req: request containing ELS response 300 * @tag: indentifier for event
301 * @fsf_req: request containing issued CT data
787 */ 302 */
788void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req) 303void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf)
789{ 304{
790 struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; 305 struct zfcp_dbf *dbf = fsf->adapter->dbf;
791 u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); 306 struct zfcp_fsf_ct_els *ct_els = fsf->data;
307 u16 length;
792 308
793 zfcp_dbf_san_els("rels", 2, fsf_req, d_id, 309 length = (u16)(ct_els->resp->length + FC_CT_HDR_LEN);
794 sg_virt(els->resp), els->resp->length); 310 zfcp_dbf_san(tag, dbf, sg_virt(ct_els->resp), ZFCP_DBF_SAN_RES, length,
311 fsf->req_id, 0);
795} 312}
796 313
797/** 314/**
798 * zfcp_dbf_san_incoming_els - trace event for incomig ELS 315 * zfcp_dbf_san_in_els - trace event for incoming ELS
799 * @fsf_req: request containing unsolicited status buffer with incoming ELS 316 * @tag: indentifier for event
317 * @fsf_req: request containing issued CT data
800 */ 318 */
801void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req) 319void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf)
802{ 320{
803 struct fsf_status_read_buffer *buf = 321 struct zfcp_dbf *dbf = fsf->adapter->dbf;
804 (struct fsf_status_read_buffer *)fsf_req->data; 322 struct fsf_status_read_buffer *srb =
805 int length = (int)buf->length - 323 (struct fsf_status_read_buffer *) fsf->data;
806 (int)((void *)&buf->payload - (void *)buf); 324 u16 length;
807 325
808 zfcp_dbf_san_els("iels", 1, fsf_req, ntoh24(buf->d_id), 326 length = (u16)(srb->length -
809 (void *)buf->payload.data, length); 327 offsetof(struct fsf_status_read_buffer, payload));
810} 328 zfcp_dbf_san(tag, dbf, srb->payload.data, ZFCP_DBF_SAN_ELS, length,
811 329 fsf->req_id, ntoh24(srb->d_id));
812static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view,
813 char *out_buf, const char *in_buf)
814{
815 struct zfcp_dbf_san_record *r = (struct zfcp_dbf_san_record *)in_buf;
816 char *p = out_buf;
817
818 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
819 return 0;
820
821 zfcp_dbf_tag(&p, "tag", r->tag);
822 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
823 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
824
825 if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) {
826 struct zfcp_dbf_san_record_ct_request *ct = &r->u.ct_req;
827 zfcp_dbf_out(&p, "d_id", "0x%06x", ct->d_id);
828 zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code);
829 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
830 zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type);
831 zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype);
832 zfcp_dbf_out(&p, "options", "0x%02x", ct->options);
833 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
834 } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) {
835 struct zfcp_dbf_san_record_ct_response *ct = &r->u.ct_resp;
836 zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code);
837 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
838 zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code);
839 zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl);
840 zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique);
841 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
842 } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 ||
843 strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 ||
844 strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) {
845 struct zfcp_dbf_san_record_els *els = &r->u.els;
846 zfcp_dbf_out(&p, "d_id", "0x%06x", els->d_id);
847 }
848 return p - out_buf;
849} 330}
850 331
851static struct debug_view zfcp_dbf_san_view = { 332/**
852 .name = "structured", 333 * zfcp_dbf_scsi - trace event for scsi commands
853 .header_proc = zfcp_dbf_view_header, 334 * @tag: identifier for event
854 .format_proc = zfcp_dbf_san_view_format, 335 * @sc: pointer to struct scsi_cmnd
855}; 336 * @fsf: pointer to struct zfcp_fsf_req
856 337 */
857void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level, 338void zfcp_dbf_scsi(char *tag, struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf)
858 struct zfcp_dbf *dbf, struct scsi_cmnd *scsi_cmnd,
859 struct zfcp_fsf_req *fsf_req, unsigned long old_req_id)
860{ 339{
861 struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf; 340 struct zfcp_adapter *adapter =
862 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; 341 (struct zfcp_adapter *) sc->device->host->hostdata[0];
863 unsigned long flags; 342 struct zfcp_dbf *dbf = adapter->dbf;
343 struct zfcp_dbf_scsi *rec = &dbf->scsi_buf;
864 struct fcp_resp_with_ext *fcp_rsp; 344 struct fcp_resp_with_ext *fcp_rsp;
865 struct fcp_resp_rsp_info *fcp_rsp_info = NULL; 345 struct fcp_resp_rsp_info *fcp_rsp_info;
866 char *fcp_sns_info = NULL; 346 unsigned long flags;
867 int offset = 0, buflen = 0;
868 347
869 spin_lock_irqsave(&dbf->scsi_lock, flags); 348 spin_lock_irqsave(&dbf->scsi_lock, flags);
870 do { 349 memset(rec, 0, sizeof(*rec));
871 memset(rec, 0, sizeof(*rec));
872 if (offset == 0) {
873 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
874 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
875 if (scsi_cmnd != NULL) {
876 if (scsi_cmnd->device) {
877 rec->scsi_id = scsi_cmnd->device->id;
878 rec->scsi_lun = scsi_cmnd->device->lun;
879 }
880 rec->scsi_result = scsi_cmnd->result;
881 rec->scsi_cmnd = (unsigned long)scsi_cmnd;
882 memcpy(rec->scsi_opcode, scsi_cmnd->cmnd,
883 min((int)scsi_cmnd->cmd_len,
884 ZFCP_DBF_SCSI_OPCODE));
885 rec->scsi_retries = scsi_cmnd->retries;
886 rec->scsi_allowed = scsi_cmnd->allowed;
887 }
888 if (fsf_req != NULL) {
889 fcp_rsp = (struct fcp_resp_with_ext *)
890 &(fsf_req->qtcb->bottom.io.fcp_rsp);
891 fcp_rsp_info = (struct fcp_resp_rsp_info *)
892 &fcp_rsp[1];
893 fcp_sns_info = (char *) &fcp_rsp[1];
894 if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
895 fcp_sns_info += fcp_rsp->ext.fr_sns_len;
896
897 rec->rsp_validity = fcp_rsp->resp.fr_flags;
898 rec->rsp_scsi_status = fcp_rsp->resp.fr_status;
899 rec->rsp_resid = fcp_rsp->ext.fr_resid;
900 if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
901 rec->rsp_code = fcp_rsp_info->rsp_code;
902 if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
903 buflen = min(fcp_rsp->ext.fr_sns_len,
904 (u32)ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO);
905 rec->sns_info_len = buflen;
906 memcpy(rec->sns_info, fcp_sns_info,
907 min(buflen,
908 ZFCP_DBF_SCSI_FCP_SNS_INFO));
909 offset += min(buflen,
910 ZFCP_DBF_SCSI_FCP_SNS_INFO);
911 }
912
913 rec->fsf_reqid = fsf_req->req_id;
914 rec->fsf_seqno = fsf_req->seq_no;
915 rec->fsf_issued = fsf_req->issued;
916 }
917 rec->old_fsf_reqid = old_req_id;
918 } else {
919 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
920 dump->total_size = buflen;
921 dump->offset = offset;
922 dump->size = min(buflen - offset,
923 (int)sizeof(struct
924 zfcp_dbf_scsi_record) -
925 (int)sizeof(struct zfcp_dbf_dump));
926 memcpy(dump->data, fcp_sns_info + offset, dump->size);
927 offset += dump->size;
928 }
929 debug_event(dbf->scsi, level, rec, sizeof(*rec));
930 } while (offset < buflen);
931 spin_unlock_irqrestore(&dbf->scsi_lock, flags);
932}
933 350
934static int zfcp_dbf_scsi_view_format(debug_info_t *id, struct debug_view *view, 351 memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
935 char *out_buf, const char *in_buf) 352 rec->id = ZFCP_DBF_SCSI_CMND;
936{ 353 rec->scsi_result = sc->result;
937 struct zfcp_dbf_scsi_record *r = (struct zfcp_dbf_scsi_record *)in_buf; 354 rec->scsi_retries = sc->retries;
938 struct timespec t; 355 rec->scsi_allowed = sc->allowed;
939 char *p = out_buf; 356 rec->scsi_id = sc->device->id;
940 357 rec->scsi_lun = sc->device->lun;
941 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 358 rec->host_scribble = (unsigned long)sc->host_scribble;
942 return 0; 359
943 360 memcpy(rec->scsi_opcode, sc->cmnd,
944 zfcp_dbf_tag(&p, "tag", r->tag); 361 min((int)sc->cmd_len, ZFCP_DBF_SCSI_OPCODE));
945 zfcp_dbf_tag(&p, "tag2", r->tag2); 362
946 zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id); 363 if (fsf) {
947 zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun); 364 rec->fsf_req_id = fsf->req_id;
948 zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result); 365 fcp_rsp = (struct fcp_resp_with_ext *)
949 zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd); 366 &(fsf->qtcb->bottom.io.fcp_rsp);
950 zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, 367 memcpy(&rec->fcp_rsp, fcp_rsp, FCP_RESP_WITH_EXT);
951 0, ZFCP_DBF_SCSI_OPCODE); 368 if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) {
952 zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries); 369 fcp_rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
953 zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed); 370 rec->fcp_rsp_info = fcp_rsp_info->rsp_code;
954 if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) 371 }
955 zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); 372 if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
956 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 373 rec->pl_len = min((u16)SCSI_SENSE_BUFFERSIZE,
957 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); 374 (u16)ZFCP_DBF_PAY_MAX_REC);
958 stck_to_timespec(r->fsf_issued, &t); 375 zfcp_dbf_pl_write(dbf, sc->sense_buffer, rec->pl_len,
959 zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); 376 "fcp_sns", fsf->req_id);
960 377 }
961 if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) {
962 zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity);
963 zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x",
964 r->rsp_scsi_status);
965 zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid);
966 zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code);
967 zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len);
968 zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info,
969 min((int)r->sns_info_len,
970 ZFCP_DBF_SCSI_FCP_SNS_INFO), 0,
971 r->sns_info_len);
972 } 378 }
973 p += sprintf(p, "\n");
974 return p - out_buf;
975}
976 379
977static struct debug_view zfcp_dbf_scsi_view = { 380 debug_event(dbf->scsi, 1, rec, sizeof(*rec));
978 .name = "structured", 381 spin_unlock_irqrestore(&dbf->scsi_lock, flags);
979 .header_proc = zfcp_dbf_view_header, 382}
980 .format_proc = zfcp_dbf_scsi_view_format,
981};
982 383
983static debug_info_t *zfcp_dbf_reg(const char *name, int level, 384static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size)
984 struct debug_view *view, int size)
985{ 385{
986 struct debug_info *d; 386 struct debug_info *d;
987 387
988 d = debug_register(name, dbfsize, level, size); 388 d = debug_register(name, size, 1, rec_size);
989 if (!d) 389 if (!d)
990 return NULL; 390 return NULL;
991 391
992 debug_register_view(d, &debug_hex_ascii_view); 392 debug_register_view(d, &debug_hex_ascii_view);
993 debug_register_view(d, view); 393 debug_set_level(d, 3);
994 debug_set_level(d, level);
995 394
996 return d; 395 return d;
997} 396}
998 397
398static void zfcp_dbf_unregister(struct zfcp_dbf *dbf)
399{
400 if (!dbf)
401 return;
402
403 debug_unregister(dbf->scsi);
404 debug_unregister(dbf->san);
405 debug_unregister(dbf->hba);
406 debug_unregister(dbf->pay);
407 debug_unregister(dbf->rec);
408 kfree(dbf);
409}
410
999/** 411/**
1000 * zfcp_adapter_debug_register - registers debug feature for an adapter 412 * zfcp_adapter_debug_register - registers debug feature for an adapter
1001 * @adapter: pointer to adapter for which debug features should be registered 413 * @adapter: pointer to adapter for which debug features should be registered
@@ -1003,69 +415,66 @@ static debug_info_t *zfcp_dbf_reg(const char *name, int level,
1003 */ 415 */
1004int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter) 416int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter)
1005{ 417{
1006 char dbf_name[DEBUG_MAX_NAME_LEN]; 418 char name[DEBUG_MAX_NAME_LEN];
1007 struct zfcp_dbf *dbf; 419 struct zfcp_dbf *dbf;
1008 420
1009 dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); 421 dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL);
1010 if (!dbf) 422 if (!dbf)
1011 return -ENOMEM; 423 return -ENOMEM;
1012 424
1013 dbf->adapter = adapter; 425 spin_lock_init(&dbf->pay_lock);
1014
1015 spin_lock_init(&dbf->hba_lock); 426 spin_lock_init(&dbf->hba_lock);
1016 spin_lock_init(&dbf->san_lock); 427 spin_lock_init(&dbf->san_lock);
1017 spin_lock_init(&dbf->scsi_lock); 428 spin_lock_init(&dbf->scsi_lock);
1018 spin_lock_init(&dbf->rec_lock); 429 spin_lock_init(&dbf->rec_lock);
1019 430
1020 /* debug feature area which records recovery activity */ 431 /* debug feature area which records recovery activity */
1021 sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); 432 sprintf(name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
1022 dbf->rec = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_rec_view, 433 dbf->rec = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_rec));
1023 sizeof(struct zfcp_dbf_rec_record));
1024 if (!dbf->rec) 434 if (!dbf->rec)
1025 goto err_out; 435 goto err_out;
1026 436
1027 /* debug feature area which records HBA (FSF and QDIO) conditions */ 437 /* debug feature area which records HBA (FSF and QDIO) conditions */
1028 sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); 438 sprintf(name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
1029 dbf->hba = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_hba_view, 439 dbf->hba = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_hba));
1030 sizeof(struct zfcp_dbf_hba_record));
1031 if (!dbf->hba) 440 if (!dbf->hba)
1032 goto err_out; 441 goto err_out;
1033 442
443 /* debug feature area which records payload info */
444 sprintf(name, "zfcp_%s_pay", dev_name(&adapter->ccw_device->dev));
445 dbf->pay = zfcp_dbf_reg(name, dbfsize * 2, sizeof(struct zfcp_dbf_pay));
446 if (!dbf->pay)
447 goto err_out;
448
1034 /* debug feature area which records SAN command failures and recovery */ 449 /* debug feature area which records SAN command failures and recovery */
1035 sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); 450 sprintf(name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
1036 dbf->san = zfcp_dbf_reg(dbf_name, 6, &zfcp_dbf_san_view, 451 dbf->san = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_san));
1037 sizeof(struct zfcp_dbf_san_record));
1038 if (!dbf->san) 452 if (!dbf->san)
1039 goto err_out; 453 goto err_out;
1040 454
1041 /* debug feature area which records SCSI command failures and recovery */ 455 /* debug feature area which records SCSI command failures and recovery */
1042 sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); 456 sprintf(name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
1043 dbf->scsi = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_scsi_view, 457 dbf->scsi = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_scsi));
1044 sizeof(struct zfcp_dbf_scsi_record));
1045 if (!dbf->scsi) 458 if (!dbf->scsi)
1046 goto err_out; 459 goto err_out;
1047 460
1048 adapter->dbf = dbf; 461 adapter->dbf = dbf;
1049 return 0;
1050 462
463 return 0;
1051err_out: 464err_out:
1052 zfcp_dbf_adapter_unregister(dbf); 465 zfcp_dbf_unregister(dbf);
1053 return -ENOMEM; 466 return -ENOMEM;
1054} 467}
1055 468
1056/** 469/**
1057 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter 470 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
1058 * @dbf: pointer to dbf for which debug features should be unregistered 471 * @adapter: pointer to adapter for which debug features should be unregistered
1059 */ 472 */
1060void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf) 473void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter)
1061{ 474{
1062 if (!dbf) 475 struct zfcp_dbf *dbf = adapter->dbf;
1063 return; 476
1064 debug_unregister(dbf->scsi); 477 adapter->dbf = NULL;
1065 debug_unregister(dbf->san); 478 zfcp_dbf_unregister(dbf);
1066 debug_unregister(dbf->hba);
1067 debug_unregister(dbf->rec);
1068 dbf->adapter->dbf = NULL;
1069 kfree(dbf);
1070} 479}
1071 480
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h
index 04081b1b62b4..714f087eb7a9 100644
--- a/drivers/s390/scsi/zfcp_dbf.h
+++ b/drivers/s390/scsi/zfcp_dbf.h
@@ -1,22 +1,8 @@
1/* 1/*
2 * This file is part of the zfcp device driver for 2 * zfcp device driver
3 * FCP adapters for IBM System z9 and zSeries. 3 * debug feature declarations
4 * 4 *
5 * Copyright IBM Corp. 2008, 2009 5 * Copyright IBM Corp. 2008, 2010
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */ 6 */
21 7
22#ifndef ZFCP_DBF_H 8#ifndef ZFCP_DBF_H
@@ -27,322 +13,350 @@
27#include "zfcp_fsf.h" 13#include "zfcp_fsf.h"
28#include "zfcp_def.h" 14#include "zfcp_def.h"
29 15
30#define ZFCP_DBF_TAG_SIZE 4 16#define ZFCP_DBF_TAG_LEN 7
31#define ZFCP_DBF_ID_SIZE 7
32 17
33#define ZFCP_DBF_INVALID_LUN 0xFFFFFFFFFFFFFFFFull 18#define ZFCP_DBF_INVALID_LUN 0xFFFFFFFFFFFFFFFFull
34 19
35struct zfcp_dbf_dump { 20/**
36 u8 tag[ZFCP_DBF_TAG_SIZE]; 21 * struct zfcp_dbf_rec_trigger - trace record for triggered recovery action
37 u32 total_size; /* size of total dump data */ 22 * @ready: number of ready recovery actions
38 u32 offset; /* how much data has being already dumped */ 23 * @running: number of running recovery actions
39 u32 size; /* how much data comes with this record */ 24 * @want: wanted recovery action
40 u8 data[]; /* dump data */ 25 * @need: needed recovery action
41} __attribute__ ((packed)); 26 */
42 27struct zfcp_dbf_rec_trigger {
43struct zfcp_dbf_rec_record_thread {
44 u32 total;
45 u32 ready; 28 u32 ready;
46 u32 running; 29 u32 running;
47};
48
49struct zfcp_dbf_rec_record_target {
50 u64 ref;
51 u32 status;
52 u32 d_id;
53 u64 wwpn;
54 u64 fcp_lun;
55 u32 erp_count;
56};
57
58struct zfcp_dbf_rec_record_trigger {
59 u8 want; 30 u8 want;
60 u8 need; 31 u8 need;
61 u32 as; 32} __packed;
62 u32 ps;
63 u32 ls;
64 u64 ref;
65 u64 action;
66 u64 wwpn;
67 u64 fcp_lun;
68};
69 33
70struct zfcp_dbf_rec_record_action { 34/**
71 u32 status; 35 * struct zfcp_dbf_rec_running - trace record for running recovery
72 u32 step; 36 * @fsf_req_id: request id for fsf requests
73 u64 action; 37 * @rec_status: status of the fsf request
74 u64 fsf_req; 38 * @rec_step: current step of the recovery action
39 * rec_count: recovery counter
40 */
41struct zfcp_dbf_rec_running {
42 u64 fsf_req_id;
43 u32 rec_status;
44 u16 rec_step;
45 u8 rec_action;
46 u8 rec_count;
47} __packed;
48
49/**
50 * enum zfcp_dbf_rec_id - recovery trace record id
51 * @ZFCP_DBF_REC_TRIG: triggered recovery identifier
52 * @ZFCP_DBF_REC_RUN: running recovery identifier
53 */
54enum zfcp_dbf_rec_id {
55 ZFCP_DBF_REC_TRIG = 1,
56 ZFCP_DBF_REC_RUN = 2,
75}; 57};
76 58
77struct zfcp_dbf_rec_record { 59/**
60 * struct zfcp_dbf_rec - trace record for error recovery actions
61 * @id: unique number of recovery record type
62 * @tag: identifier string specifying the location of initiation
63 * @lun: logical unit number
64 * @wwpn: word wide port number
65 * @d_id: destination ID
66 * @adapter_status: current status of the adapter
67 * @port_status: current status of the port
68 * @lun_status: current status of the lun
69 * @u.trig: structure zfcp_dbf_rec_trigger
70 * @u.run: structure zfcp_dbf_rec_running
71 */
72struct zfcp_dbf_rec {
78 u8 id; 73 u8 id;
79 char id2[7]; 74 char tag[ZFCP_DBF_TAG_LEN];
75 u64 lun;
76 u64 wwpn;
77 u32 d_id;
78 u32 adapter_status;
79 u32 port_status;
80 u32 lun_status;
80 union { 81 union {
81 struct zfcp_dbf_rec_record_action action; 82 struct zfcp_dbf_rec_trigger trig;
82 struct zfcp_dbf_rec_record_thread thread; 83 struct zfcp_dbf_rec_running run;
83 struct zfcp_dbf_rec_record_target target;
84 struct zfcp_dbf_rec_record_trigger trigger;
85 } u; 84 } u;
86}; 85} __packed;
87 86
88enum { 87/**
89 ZFCP_REC_DBF_ID_ACTION, 88 * enum zfcp_dbf_san_id - SAN trace record identifier
90 ZFCP_REC_DBF_ID_THREAD, 89 * @ZFCP_DBF_SAN_REQ: request trace record id
91 ZFCP_REC_DBF_ID_TARGET, 90 * @ZFCP_DBF_SAN_RES: response trace record id
92 ZFCP_REC_DBF_ID_TRIGGER, 91 * @ZFCP_DBF_SAN_ELS: extended link service record id
92 */
93enum zfcp_dbf_san_id {
94 ZFCP_DBF_SAN_REQ = 1,
95 ZFCP_DBF_SAN_RES = 2,
96 ZFCP_DBF_SAN_ELS = 3,
93}; 97};
94 98
95struct zfcp_dbf_hba_record_response { 99/** struct zfcp_dbf_san - trace record for SAN requests and responses
96 u32 fsf_command; 100 * @id: unique number of recovery record type
97 u64 fsf_reqid; 101 * @tag: identifier string specifying the location of initiation
98 u32 fsf_seqno; 102 * @fsf_req_id: request id for fsf requests
99 u64 fsf_issued; 103 * @payload: unformatted information related to request/response
100 u32 fsf_prot_status; 104 * @d_id: destination id
105 */
106struct zfcp_dbf_san {
107 u8 id;
108 char tag[ZFCP_DBF_TAG_LEN];
109 u64 fsf_req_id;
110 u32 d_id;
111#define ZFCP_DBF_SAN_MAX_PAYLOAD (FC_CT_HDR_LEN + 32)
112 char payload[ZFCP_DBF_SAN_MAX_PAYLOAD];
113} __packed;
114
115/**
116 * struct zfcp_dbf_hba_res - trace record for hba responses
117 * @req_issued: timestamp when request was issued
118 * @prot_status: protocol status
119 * @prot_status_qual: protocol status qualifier
120 * @fsf_status: fsf status
121 * @fsf_status_qual: fsf status qualifier
122 */
123struct zfcp_dbf_hba_res {
124 u64 req_issued;
125 u32 prot_status;
126 u8 prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
101 u32 fsf_status; 127 u32 fsf_status;
102 u8 fsf_prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE]; 128 u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
103 u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE]; 129} __packed;
104 u32 fsf_req_status;
105 u8 sbal_first;
106 u8 sbal_last;
107 u8 sbal_response;
108 u8 pool;
109 u64 erp_action;
110 union {
111 struct {
112 u64 cmnd;
113 u32 data_dir;
114 } fcp;
115 struct {
116 u64 wwpn;
117 u32 d_id;
118 u32 port_handle;
119 } port;
120 struct {
121 u64 wwpn;
122 u64 fcp_lun;
123 u32 port_handle;
124 u32 lun_handle;
125 } unit;
126 struct {
127 u32 d_id;
128 } els;
129 } u;
130} __attribute__ ((packed));
131 130
132struct zfcp_dbf_hba_record_status { 131/**
133 u8 failed; 132 * struct zfcp_dbf_hba_uss - trace record for unsolicited status
133 * @status_type: type of unsolicited status
134 * @status_subtype: subtype of unsolicited status
135 * @d_id: destination ID
136 * @lun: logical unit number
137 * @queue_designator: queue designator
138 */
139struct zfcp_dbf_hba_uss {
134 u32 status_type; 140 u32 status_type;
135 u32 status_subtype; 141 u32 status_subtype;
136 struct fsf_queue_designator
137 queue_designator;
138 u32 payload_size;
139#define ZFCP_DBF_UNSOL_PAYLOAD 80
140#define ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL 32
141#define ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD 56
142#define ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT 2 * sizeof(u32)
143 u8 payload[ZFCP_DBF_UNSOL_PAYLOAD];
144} __attribute__ ((packed));
145
146struct zfcp_dbf_hba_record_qdio {
147 u32 qdio_error;
148 u8 sbal_index;
149 u8 sbal_count;
150} __attribute__ ((packed));
151
152struct zfcp_dbf_hba_record {
153 u8 tag[ZFCP_DBF_TAG_SIZE];
154 u8 tag2[ZFCP_DBF_TAG_SIZE];
155 union {
156 struct zfcp_dbf_hba_record_response response;
157 struct zfcp_dbf_hba_record_status status;
158 struct zfcp_dbf_hba_record_qdio qdio;
159 struct fsf_bit_error_payload berr;
160 } u;
161} __attribute__ ((packed));
162
163struct zfcp_dbf_san_record_ct_request {
164 u16 cmd_req_code;
165 u8 revision;
166 u8 gs_type;
167 u8 gs_subtype;
168 u8 options;
169 u16 max_res_size;
170 u32 len;
171 u32 d_id;
172} __attribute__ ((packed));
173
174struct zfcp_dbf_san_record_ct_response {
175 u16 cmd_rsp_code;
176 u8 revision;
177 u8 reason_code;
178 u8 expl;
179 u8 vendor_unique;
180 u16 max_res_size;
181 u32 len;
182} __attribute__ ((packed));
183
184struct zfcp_dbf_san_record_els {
185 u32 d_id; 142 u32 d_id;
186} __attribute__ ((packed)); 143 u64 lun;
144 u64 queue_designator;
145} __packed;
187 146
188struct zfcp_dbf_san_record { 147/**
189 u8 tag[ZFCP_DBF_TAG_SIZE]; 148 * enum zfcp_dbf_hba_id - HBA trace record identifier
190 u64 fsf_reqid; 149 * @ZFCP_DBF_HBA_RES: response trace record
191 u32 fsf_seqno; 150 * @ZFCP_DBF_HBA_USS: unsolicited status trace record
151 * @ZFCP_DBF_HBA_BIT: bit error trace record
152 */
153enum zfcp_dbf_hba_id {
154 ZFCP_DBF_HBA_RES = 1,
155 ZFCP_DBF_HBA_USS = 2,
156 ZFCP_DBF_HBA_BIT = 3,
157};
158
159/**
160 * struct zfcp_dbf_hba - common trace record for HBA records
161 * @id: unique number of recovery record type
162 * @tag: identifier string specifying the location of initiation
163 * @fsf_req_id: request id for fsf requests
164 * @fsf_req_status: status of fsf request
165 * @fsf_cmd: fsf command
166 * @fsf_seq_no: fsf sequence number
167 * @pl_len: length of payload stored as zfcp_dbf_pay
168 * @u: record type specific data
169 */
170struct zfcp_dbf_hba {
171 u8 id;
172 char tag[ZFCP_DBF_TAG_LEN];
173 u64 fsf_req_id;
174 u32 fsf_req_status;
175 u32 fsf_cmd;
176 u32 fsf_seq_no;
177 u16 pl_len;
192 union { 178 union {
193 struct zfcp_dbf_san_record_ct_request ct_req; 179 struct zfcp_dbf_hba_res res;
194 struct zfcp_dbf_san_record_ct_response ct_resp; 180 struct zfcp_dbf_hba_uss uss;
195 struct zfcp_dbf_san_record_els els; 181 struct fsf_bit_error_payload be;
196 } u; 182 } u;
197} __attribute__ ((packed)); 183} __packed;
198 184
199#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024 185/**
186 * enum zfcp_dbf_scsi_id - scsi trace record identifier
187 * @ZFCP_DBF_SCSI_CMND: scsi command trace record
188 */
189enum zfcp_dbf_scsi_id {
190 ZFCP_DBF_SCSI_CMND = 1,
191};
200 192
201struct zfcp_dbf_scsi_record { 193/**
202 u8 tag[ZFCP_DBF_TAG_SIZE]; 194 * struct zfcp_dbf_scsi - common trace record for SCSI records
203 u8 tag2[ZFCP_DBF_TAG_SIZE]; 195 * @id: unique number of recovery record type
196 * @tag: identifier string specifying the location of initiation
197 * @scsi_id: scsi device id
198 * @scsi_lun: scsi device logical unit number
199 * @scsi_result: scsi result
200 * @scsi_retries: current retry number of scsi request
201 * @scsi_allowed: allowed retries
202 * @fcp_rsp_info: FCP response info
203 * @scsi_opcode: scsi opcode
204 * @fsf_req_id: request id of fsf request
205 * @host_scribble: LLD specific data attached to SCSI request
206 * @pl_len: length of paload stored as zfcp_dbf_pay
207 * @fsf_rsp: response for fsf request
208 */
209struct zfcp_dbf_scsi {
210 u8 id;
211 char tag[ZFCP_DBF_TAG_LEN];
204 u32 scsi_id; 212 u32 scsi_id;
205 u32 scsi_lun; 213 u32 scsi_lun;
206 u32 scsi_result; 214 u32 scsi_result;
207 u64 scsi_cmnd;
208#define ZFCP_DBF_SCSI_OPCODE 16
209 u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
210 u8 scsi_retries; 215 u8 scsi_retries;
211 u8 scsi_allowed; 216 u8 scsi_allowed;
212 u64 fsf_reqid; 217 u8 fcp_rsp_info;
213 u32 fsf_seqno; 218#define ZFCP_DBF_SCSI_OPCODE 16
214 u64 fsf_issued; 219 u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
215 u64 old_fsf_reqid; 220 u64 fsf_req_id;
216 u8 rsp_validity; 221 u64 host_scribble;
217 u8 rsp_scsi_status; 222 u16 pl_len;
218 u32 rsp_resid; 223 struct fcp_resp_with_ext fcp_rsp;
219 u8 rsp_code; 224} __packed;
220#define ZFCP_DBF_SCSI_FCP_SNS_INFO 16
221#define ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO 256
222 u32 sns_info_len;
223 u8 sns_info[ZFCP_DBF_SCSI_FCP_SNS_INFO];
224} __attribute__ ((packed));
225 225
226/**
227 * struct zfcp_dbf_pay - trace record for unformatted payload information
228 * @area: area this record is originated from
229 * @counter: ascending record number
230 * @fsf_req_id: request id of fsf request
231 * @data: unformatted data
232 */
233struct zfcp_dbf_pay {
234 u8 counter;
235 char area[ZFCP_DBF_TAG_LEN];
236 u64 fsf_req_id;
237#define ZFCP_DBF_PAY_MAX_REC 0x100
238 char data[ZFCP_DBF_PAY_MAX_REC];
239} __packed;
240
241/**
242 * struct zfcp_dbf - main dbf trace structure
243 * @pay: reference to payload trace area
244 * @rec: reference to recovery trace area
245 * @hba: reference to hba trace area
246 * @san: reference to san trace area
247 * @scsi: reference to scsi trace area
248 * @pay_lock: lock protecting payload trace buffer
249 * @rec_lock: lock protecting recovery trace buffer
250 * @hba_lock: lock protecting hba trace buffer
251 * @san_lock: lock protecting san trace buffer
252 * @scsi_lock: lock protecting scsi trace buffer
253 * @pay_buf: pre-allocated buffer for payload
254 * @rec_buf: pre-allocated buffer for recovery
255 * @hba_buf: pre-allocated buffer for hba
256 * @san_buf: pre-allocated buffer for san
257 * @scsi_buf: pre-allocated buffer for scsi
258 */
226struct zfcp_dbf { 259struct zfcp_dbf {
260 debug_info_t *pay;
227 debug_info_t *rec; 261 debug_info_t *rec;
228 debug_info_t *hba; 262 debug_info_t *hba;
229 debug_info_t *san; 263 debug_info_t *san;
230 debug_info_t *scsi; 264 debug_info_t *scsi;
265 spinlock_t pay_lock;
231 spinlock_t rec_lock; 266 spinlock_t rec_lock;
232 spinlock_t hba_lock; 267 spinlock_t hba_lock;
233 spinlock_t san_lock; 268 spinlock_t san_lock;
234 spinlock_t scsi_lock; 269 spinlock_t scsi_lock;
235 struct zfcp_dbf_rec_record rec_buf; 270 struct zfcp_dbf_pay pay_buf;
236 struct zfcp_dbf_hba_record hba_buf; 271 struct zfcp_dbf_rec rec_buf;
237 struct zfcp_dbf_san_record san_buf; 272 struct zfcp_dbf_hba hba_buf;
238 struct zfcp_dbf_scsi_record scsi_buf; 273 struct zfcp_dbf_san san_buf;
239 struct zfcp_adapter *adapter; 274 struct zfcp_dbf_scsi scsi_buf;
240}; 275};
241 276
242static inline 277static inline
243void zfcp_dbf_hba_fsf_resp(const char *tag2, int level, 278void zfcp_dbf_hba_fsf_resp(char *tag, int level, struct zfcp_fsf_req *req)
244 struct zfcp_fsf_req *req, struct zfcp_dbf *dbf)
245{ 279{
246 if (level <= dbf->hba->level) 280 if (level <= req->adapter->dbf->hba->level)
247 _zfcp_dbf_hba_fsf_response(tag2, level, req, dbf); 281 zfcp_dbf_hba_fsf_res(tag, req);
248} 282}
249 283
250/** 284/**
251 * zfcp_dbf_hba_fsf_response - trace event for request completion 285 * zfcp_dbf_hba_fsf_response - trace event for request completion
252 * @fsf_req: request that has been completed 286 * @req: request that has been completed
253 */ 287 */
254static inline void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req) 288static inline
289void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req)
255{ 290{
256 struct zfcp_dbf *dbf = req->adapter->dbf;
257 struct fsf_qtcb *qtcb = req->qtcb; 291 struct fsf_qtcb *qtcb = req->qtcb;
258 292
259 if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) && 293 if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) &&
260 (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) { 294 (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) {
261 zfcp_dbf_hba_fsf_resp("perr", 1, req, dbf); 295 zfcp_dbf_hba_fsf_resp("fs_perr", 1, req);
262 296
263 } else if (qtcb->header.fsf_status != FSF_GOOD) { 297 } else if (qtcb->header.fsf_status != FSF_GOOD) {
264 zfcp_dbf_hba_fsf_resp("ferr", 1, req, dbf); 298 zfcp_dbf_hba_fsf_resp("fs_ferr", 1, req);
265 299
266 } else if ((req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) || 300 } else if ((req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) ||
267 (req->fsf_command == FSF_QTCB_OPEN_LUN)) { 301 (req->fsf_command == FSF_QTCB_OPEN_LUN)) {
268 zfcp_dbf_hba_fsf_resp("open", 4, req, dbf); 302 zfcp_dbf_hba_fsf_resp("fs_open", 4, req);
269 303
270 } else if (qtcb->header.log_length) { 304 } else if (qtcb->header.log_length) {
271 zfcp_dbf_hba_fsf_resp("qtcb", 5, req, dbf); 305 zfcp_dbf_hba_fsf_resp("fs_qtcb", 5, req);
272 306
273 } else { 307 } else {
274 zfcp_dbf_hba_fsf_resp("norm", 6, req, dbf); 308 zfcp_dbf_hba_fsf_resp("fs_norm", 6, req);
275 } 309 }
276 }
277
278/**
279 * zfcp_dbf_hba_fsf_unsol - trace event for an unsolicited status buffer
280 * @tag: tag indicating which kind of unsolicited status has been received
281 * @dbf: reference to dbf structure
282 * @status_buffer: buffer containing payload of unsolicited status
283 */
284static inline
285void zfcp_dbf_hba_fsf_unsol(const char *tag, struct zfcp_dbf *dbf,
286 struct fsf_status_read_buffer *buf)
287{
288 int level = 2;
289
290 if (level <= dbf->hba->level)
291 _zfcp_dbf_hba_fsf_unsol(tag, level, dbf, buf);
292} 310}
293 311
294static inline 312static inline
295void zfcp_dbf_scsi(const char *tag, const char *tag2, int level, 313void _zfcp_dbf_scsi(char *tag, int level, struct scsi_cmnd *scmd,
296 struct zfcp_dbf *dbf, struct scsi_cmnd *scmd, 314 struct zfcp_fsf_req *req)
297 struct zfcp_fsf_req *req, unsigned long old_id)
298{ 315{
299 if (level <= dbf->scsi->level) 316 struct zfcp_adapter *adapter = (struct zfcp_adapter *)
300 _zfcp_dbf_scsi(tag, tag2, level, dbf, scmd, req, old_id); 317 scmd->device->host->hostdata[0];
318
319 if (level <= adapter->dbf->scsi->level)
320 zfcp_dbf_scsi(tag, scmd, req);
301} 321}
302 322
303/** 323/**
304 * zfcp_dbf_scsi_result - trace event for SCSI command completion 324 * zfcp_dbf_scsi_result - trace event for SCSI command completion
305 * @dbf: adapter dbf trace
306 * @scmd: SCSI command pointer 325 * @scmd: SCSI command pointer
307 * @req: FSF request used to issue SCSI command 326 * @req: FSF request used to issue SCSI command
308 */ 327 */
309static inline 328static inline
310void zfcp_dbf_scsi_result(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd, 329void zfcp_dbf_scsi_result(struct scsi_cmnd *scmd, struct zfcp_fsf_req *req)
311 struct zfcp_fsf_req *req)
312{ 330{
313 if (scmd->result != 0) 331 if (scmd->result != 0)
314 zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0); 332 _zfcp_dbf_scsi("rsl_err", 3, scmd, req);
315 else if (scmd->retries > 0) 333 else if (scmd->retries > 0)
316 zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0); 334 _zfcp_dbf_scsi("rsl_ret", 4, scmd, req);
317 else 335 else
318 zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0); 336 _zfcp_dbf_scsi("rsl_nor", 6, scmd, req);
319} 337}
320 338
321/** 339/**
322 * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command 340 * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command
323 * @dbf: adapter dbf trace
324 * @scmd: SCSI command pointer 341 * @scmd: SCSI command pointer
325 */ 342 */
326static inline 343static inline
327void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd) 344void zfcp_dbf_scsi_fail_send(struct scsi_cmnd *scmd)
328{ 345{
329 zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0); 346 _zfcp_dbf_scsi("rsl_fai", 4, scmd, NULL);
330} 347}
331 348
332/** 349/**
333 * zfcp_dbf_scsi_abort - trace event for SCSI command abort 350 * zfcp_dbf_scsi_abort - trace event for SCSI command abort
334 * @tag: tag indicating success or failure of abort operation 351 * @tag: tag indicating success or failure of abort operation
335 * @adapter: adapter thas has been used to issue SCSI command to be aborted
336 * @scmd: SCSI command to be aborted 352 * @scmd: SCSI command to be aborted
337 * @new_req: request containing abort (might be NULL) 353 * @fsf_req: request containing abort (might be NULL)
338 * @old_id: identifier of request containg SCSI command to be aborted
339 */ 354 */
340static inline 355static inline
341void zfcp_dbf_scsi_abort(const char *tag, struct zfcp_dbf *dbf, 356void zfcp_dbf_scsi_abort(char *tag, struct scsi_cmnd *scmd,
342 struct scsi_cmnd *scmd, struct zfcp_fsf_req *new_req, 357 struct zfcp_fsf_req *fsf_req)
343 unsigned long old_id)
344{ 358{
345 zfcp_dbf_scsi("abrt", tag, 1, dbf, scmd, new_req, old_id); 359 _zfcp_dbf_scsi(tag, 1, scmd, fsf_req);
346} 360}
347 361
348/** 362/**
@@ -352,12 +366,17 @@ void zfcp_dbf_scsi_abort(const char *tag, struct zfcp_dbf *dbf,
352 * @flag: indicates type of reset (Target Reset, Logical Unit Reset) 366 * @flag: indicates type of reset (Target Reset, Logical Unit Reset)
353 */ 367 */
354static inline 368static inline
355void zfcp_dbf_scsi_devreset(const char *tag, struct scsi_cmnd *scmnd, u8 flag) 369void zfcp_dbf_scsi_devreset(char *tag, struct scsi_cmnd *scmnd, u8 flag)
356{ 370{
357 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scmnd->device); 371 char tmp_tag[ZFCP_DBF_TAG_LEN];
372
373 if (flag == FCP_TMF_TGT_RESET)
374 memcpy(tmp_tag, "tr_", 3);
375 else
376 memcpy(tmp_tag, "lr_", 3);
358 377
359 zfcp_dbf_scsi(flag == FCP_TMF_TGT_RESET ? "trst" : "lrst", tag, 1, 378 memcpy(&tmp_tag[3], tag, 4);
360 zfcp_sdev->port->adapter->dbf, scmnd, NULL, 0); 379 _zfcp_dbf_scsi(tmp_tag, 1, scmnd, NULL);
361} 380}
362 381
363#endif /* ZFCP_DBF_H */ 382#endif /* ZFCP_DBF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 0bcd5806bd9a..e003e306f870 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -76,9 +76,9 @@ static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
76 struct zfcp_adapter *adapter = act->adapter; 76 struct zfcp_adapter *adapter = act->adapter;
77 77
78 list_move(&act->list, &act->adapter->erp_ready_head); 78 list_move(&act->list, &act->adapter->erp_ready_head);
79 zfcp_dbf_rec_action("erardy1", act); 79 zfcp_dbf_rec_run("erardy1", act);
80 wake_up(&adapter->erp_ready_wq); 80 wake_up(&adapter->erp_ready_wq);
81 zfcp_dbf_rec_thread("erardy2", adapter->dbf); 81 zfcp_dbf_rec_run("erardy2", act);
82} 82}
83 83
84static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act) 84static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
@@ -236,10 +236,10 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
236static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter, 236static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
237 struct zfcp_port *port, 237 struct zfcp_port *port,
238 struct scsi_device *sdev, 238 struct scsi_device *sdev,
239 char *id, void *ref, u32 act_status) 239 char *id, u32 act_status)
240{ 240{
241 int retval = 1, need; 241 int retval = 1, need;
242 struct zfcp_erp_action *act = NULL; 242 struct zfcp_erp_action *act;
243 243
244 if (!adapter->erp_thread) 244 if (!adapter->erp_thread)
245 return -EIO; 245 return -EIO;
@@ -255,15 +255,14 @@ static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
255 ++adapter->erp_total_count; 255 ++adapter->erp_total_count;
256 list_add_tail(&act->list, &adapter->erp_ready_head); 256 list_add_tail(&act->list, &adapter->erp_ready_head);
257 wake_up(&adapter->erp_ready_wq); 257 wake_up(&adapter->erp_ready_wq);
258 zfcp_dbf_rec_thread("eracte1", adapter->dbf);
259 retval = 0; 258 retval = 0;
260 out: 259 out:
261 zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, sdev); 260 zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
262 return retval; 261 return retval;
263} 262}
264 263
265static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, 264static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
266 int clear_mask, char *id, void *ref) 265 int clear_mask, char *id)
267{ 266{
268 zfcp_erp_adapter_block(adapter, clear_mask); 267 zfcp_erp_adapter_block(adapter, clear_mask);
269 zfcp_scsi_schedule_rports_block(adapter); 268 zfcp_scsi_schedule_rports_block(adapter);
@@ -275,7 +274,7 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
275 return -EIO; 274 return -EIO;
276 } 275 }
277 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, 276 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
278 adapter, NULL, NULL, id, ref, 0); 277 adapter, NULL, NULL, id, 0);
279} 278}
280 279
281/** 280/**
@@ -283,10 +282,8 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
283 * @adapter: Adapter to reopen. 282 * @adapter: Adapter to reopen.
284 * @clear: Status flags to clear. 283 * @clear: Status flags to clear.
285 * @id: Id for debug trace event. 284 * @id: Id for debug trace event.
286 * @ref: Reference for debug trace event.
287 */ 285 */
288void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, 286void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
289 char *id, void *ref)
290{ 287{
291 unsigned long flags; 288 unsigned long flags;
292 289
@@ -299,7 +296,7 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
299 ZFCP_STATUS_COMMON_ERP_FAILED); 296 ZFCP_STATUS_COMMON_ERP_FAILED);
300 else 297 else
301 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter, 298 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
302 NULL, NULL, id, ref, 0); 299 NULL, NULL, id, 0);
303 write_unlock_irqrestore(&adapter->erp_lock, flags); 300 write_unlock_irqrestore(&adapter->erp_lock, flags);
304} 301}
305 302
@@ -308,13 +305,12 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
308 * @adapter: Adapter to shut down. 305 * @adapter: Adapter to shut down.
309 * @clear: Status flags to clear. 306 * @clear: Status flags to clear.
310 * @id: Id for debug trace event. 307 * @id: Id for debug trace event.
311 * @ref: Reference for debug trace event.
312 */ 308 */
313void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear, 309void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
314 char *id, void *ref) 310 char *id)
315{ 311{
316 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 312 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
317 zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref); 313 zfcp_erp_adapter_reopen(adapter, clear | flags, id);
318} 314}
319 315
320/** 316/**
@@ -322,13 +318,11 @@ void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
322 * @port: Port to shut down. 318 * @port: Port to shut down.
323 * @clear: Status flags to clear. 319 * @clear: Status flags to clear.
324 * @id: Id for debug trace event. 320 * @id: Id for debug trace event.
325 * @ref: Reference for debug trace event.
326 */ 321 */
327void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id, 322void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
328 void *ref)
329{ 323{
330 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 324 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
331 zfcp_erp_port_reopen(port, clear | flags, id, ref); 325 zfcp_erp_port_reopen(port, clear | flags, id);
332} 326}
333 327
334static void zfcp_erp_port_block(struct zfcp_port *port, int clear) 328static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
@@ -337,8 +331,8 @@ static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
337 ZFCP_STATUS_COMMON_UNBLOCKED | clear); 331 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
338} 332}
339 333
340static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, 334static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
341 int clear, char *id, void *ref) 335 char *id)
342{ 336{
343 zfcp_erp_port_block(port, clear); 337 zfcp_erp_port_block(port, clear);
344 zfcp_scsi_schedule_rport_block(port); 338 zfcp_scsi_schedule_rport_block(port);
@@ -347,28 +341,26 @@ static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
347 return; 341 return;
348 342
349 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED, 343 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
350 port->adapter, port, NULL, id, ref, 0); 344 port->adapter, port, NULL, id, 0);
351} 345}
352 346
353/** 347/**
354 * zfcp_erp_port_forced_reopen - Forced close of port and open again 348 * zfcp_erp_port_forced_reopen - Forced close of port and open again
355 * @port: Port to force close and to reopen. 349 * @port: Port to force close and to reopen.
350 * @clear: Status flags to clear.
356 * @id: Id for debug trace event. 351 * @id: Id for debug trace event.
357 * @ref: Reference for debug trace event.
358 */ 352 */
359void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id, 353void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
360 void *ref)
361{ 354{
362 unsigned long flags; 355 unsigned long flags;
363 struct zfcp_adapter *adapter = port->adapter; 356 struct zfcp_adapter *adapter = port->adapter;
364 357
365 write_lock_irqsave(&adapter->erp_lock, flags); 358 write_lock_irqsave(&adapter->erp_lock, flags);
366 _zfcp_erp_port_forced_reopen(port, clear, id, ref); 359 _zfcp_erp_port_forced_reopen(port, clear, id);
367 write_unlock_irqrestore(&adapter->erp_lock, flags); 360 write_unlock_irqrestore(&adapter->erp_lock, flags);
368} 361}
369 362
370static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, 363static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
371 void *ref)
372{ 364{
373 zfcp_erp_port_block(port, clear); 365 zfcp_erp_port_block(port, clear);
374 zfcp_scsi_schedule_rport_block(port); 366 zfcp_scsi_schedule_rport_block(port);
@@ -380,24 +372,25 @@ static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
380 } 372 }
381 373
382 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT, 374 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
383 port->adapter, port, NULL, id, ref, 0); 375 port->adapter, port, NULL, id, 0);
384} 376}
385 377
386/** 378/**
387 * zfcp_erp_port_reopen - trigger remote port recovery 379 * zfcp_erp_port_reopen - trigger remote port recovery
388 * @port: port to recover 380 * @port: port to recover
389 * @clear_mask: flags in port status to be cleared 381 * @clear_mask: flags in port status to be cleared
382 * @id: Id for debug trace event.
390 * 383 *
391 * Returns 0 if recovery has been triggered, < 0 if not. 384 * Returns 0 if recovery has been triggered, < 0 if not.
392 */ 385 */
393int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref) 386int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
394{ 387{
395 int retval; 388 int retval;
396 unsigned long flags; 389 unsigned long flags;
397 struct zfcp_adapter *adapter = port->adapter; 390 struct zfcp_adapter *adapter = port->adapter;
398 391
399 write_lock_irqsave(&adapter->erp_lock, flags); 392 write_lock_irqsave(&adapter->erp_lock, flags);
400 retval = _zfcp_erp_port_reopen(port, clear, id, ref); 393 retval = _zfcp_erp_port_reopen(port, clear, id);
401 write_unlock_irqrestore(&adapter->erp_lock, flags); 394 write_unlock_irqrestore(&adapter->erp_lock, flags);
402 395
403 return retval; 396 return retval;
@@ -410,7 +403,7 @@ static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
410} 403}
411 404
412static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id, 405static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
413 void *ref, u32 act_status) 406 u32 act_status)
414{ 407{
415 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 408 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
416 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter; 409 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
@@ -421,17 +414,18 @@ static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
421 return; 414 return;
422 415
423 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter, 416 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
424 zfcp_sdev->port, sdev, id, ref, act_status); 417 zfcp_sdev->port, sdev, id, act_status);
425} 418}
426 419
427/** 420/**
428 * zfcp_erp_lun_reopen - initiate reopen of a LUN 421 * zfcp_erp_lun_reopen - initiate reopen of a LUN
429 * @sdev: SCSI device / LUN to be reopened 422 * @sdev: SCSI device / LUN to be reopened
430 * @clear_mask: specifies flags in LUN status to be cleared 423 * @clear_mask: specifies flags in LUN status to be cleared
424 * @id: Id for debug trace event.
425 *
431 * Return: 0 on success, < 0 on error 426 * Return: 0 on success, < 0 on error
432 */ 427 */
433void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id, 428void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
434 void *ref)
435{ 429{
436 unsigned long flags; 430 unsigned long flags;
437 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 431 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
@@ -439,7 +433,7 @@ void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
439 struct zfcp_adapter *adapter = port->adapter; 433 struct zfcp_adapter *adapter = port->adapter;
440 434
441 write_lock_irqsave(&adapter->erp_lock, flags); 435 write_lock_irqsave(&adapter->erp_lock, flags);
442 _zfcp_erp_lun_reopen(sdev, clear, id, ref, 0); 436 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
443 write_unlock_irqrestore(&adapter->erp_lock, flags); 437 write_unlock_irqrestore(&adapter->erp_lock, flags);
444} 438}
445 439
@@ -448,13 +442,11 @@ void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
448 * @sdev: SCSI device / LUN to shut down. 442 * @sdev: SCSI device / LUN to shut down.
449 * @clear: Status flags to clear. 443 * @clear: Status flags to clear.
450 * @id: Id for debug trace event. 444 * @id: Id for debug trace event.
451 * @ref: Reference for debug trace event.
452 */ 445 */
453void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id, 446void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
454 void *ref)
455{ 447{
456 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 448 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
457 zfcp_erp_lun_reopen(sdev, clear | flags, id, ref); 449 zfcp_erp_lun_reopen(sdev, clear | flags, id);
458} 450}
459 451
460/** 452/**
@@ -476,7 +468,7 @@ void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
476 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 468 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
477 469
478 write_lock_irqsave(&adapter->erp_lock, flags); 470 write_lock_irqsave(&adapter->erp_lock, flags);
479 _zfcp_erp_lun_reopen(sdev, clear, id, NULL, ZFCP_STATUS_ERP_NO_REF); 471 _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
480 write_unlock_irqrestore(&adapter->erp_lock, flags); 472 write_unlock_irqrestore(&adapter->erp_lock, flags);
481 473
482 zfcp_erp_wait(adapter); 474 zfcp_erp_wait(adapter);
@@ -490,14 +482,14 @@ static int status_change_set(unsigned long mask, atomic_t *status)
490static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter) 482static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
491{ 483{
492 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) 484 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
493 zfcp_dbf_rec_adapter("eraubl1", NULL, adapter->dbf); 485 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
494 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status); 486 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
495} 487}
496 488
497static void zfcp_erp_port_unblock(struct zfcp_port *port) 489static void zfcp_erp_port_unblock(struct zfcp_port *port)
498{ 490{
499 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) 491 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
500 zfcp_dbf_rec_port("erpubl1", NULL, port); 492 zfcp_dbf_rec_run("erpubl1", &port->erp_action);
501 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status); 493 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
502} 494}
503 495
@@ -506,14 +498,14 @@ static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
506 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 498 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
507 499
508 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status)) 500 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
509 zfcp_dbf_rec_lun("erlubl1", NULL, sdev); 501 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
510 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status); 502 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
511} 503}
512 504
513static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) 505static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
514{ 506{
515 list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 507 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
516 zfcp_dbf_rec_action("erator1", erp_action); 508 zfcp_dbf_rec_run("erator1", erp_action);
517} 509}
518 510
519static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act) 511static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
@@ -530,11 +522,11 @@ static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
530 if (act->status & (ZFCP_STATUS_ERP_DISMISSED | 522 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
531 ZFCP_STATUS_ERP_TIMEDOUT)) { 523 ZFCP_STATUS_ERP_TIMEDOUT)) {
532 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 524 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
533 zfcp_dbf_rec_action("erscf_1", act); 525 zfcp_dbf_rec_run("erscf_1", act);
534 req->erp_action = NULL; 526 req->erp_action = NULL;
535 } 527 }
536 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 528 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
537 zfcp_dbf_rec_action("erscf_2", act); 529 zfcp_dbf_rec_run("erscf_2", act);
538 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) 530 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
539 act->fsf_req_id = 0; 531 act->fsf_req_id = 0;
540 } else 532 } else
@@ -585,40 +577,40 @@ static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
585} 577}
586 578
587static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, 579static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
588 int clear, char *id, void *ref) 580 int clear, char *id)
589{ 581{
590 struct zfcp_port *port; 582 struct zfcp_port *port;
591 583
592 read_lock(&adapter->port_list_lock); 584 read_lock(&adapter->port_list_lock);
593 list_for_each_entry(port, &adapter->port_list, list) 585 list_for_each_entry(port, &adapter->port_list, list)
594 _zfcp_erp_port_reopen(port, clear, id, ref); 586 _zfcp_erp_port_reopen(port, clear, id);
595 read_unlock(&adapter->port_list_lock); 587 read_unlock(&adapter->port_list_lock);
596} 588}
597 589
598static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear, 590static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
599 char *id, void *ref) 591 char *id)
600{ 592{
601 struct scsi_device *sdev; 593 struct scsi_device *sdev;
602 594
603 shost_for_each_device(sdev, port->adapter->scsi_host) 595 shost_for_each_device(sdev, port->adapter->scsi_host)
604 if (sdev_to_zfcp(sdev)->port == port) 596 if (sdev_to_zfcp(sdev)->port == port)
605 _zfcp_erp_lun_reopen(sdev, clear, id, ref, 0); 597 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
606} 598}
607 599
608static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act) 600static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
609{ 601{
610 switch (act->action) { 602 switch (act->action) {
611 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 603 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
612 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL); 604 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
613 break; 605 break;
614 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 606 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
615 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL); 607 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
616 break; 608 break;
617 case ZFCP_ERP_ACTION_REOPEN_PORT: 609 case ZFCP_ERP_ACTION_REOPEN_PORT:
618 _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL); 610 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
619 break; 611 break;
620 case ZFCP_ERP_ACTION_REOPEN_LUN: 612 case ZFCP_ERP_ACTION_REOPEN_LUN:
621 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", NULL, 0); 613 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
622 break; 614 break;
623 } 615 }
624} 616}
@@ -627,13 +619,13 @@ static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
627{ 619{
628 switch (act->action) { 620 switch (act->action) {
629 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 621 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
630 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL); 622 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
631 break; 623 break;
632 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 624 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
633 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL); 625 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
634 break; 626 break;
635 case ZFCP_ERP_ACTION_REOPEN_PORT: 627 case ZFCP_ERP_ACTION_REOPEN_PORT:
636 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3", NULL); 628 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
637 break; 629 break;
638 } 630 }
639} 631}
@@ -652,17 +644,6 @@ static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
652 read_unlock_irqrestore(&adapter->erp_lock, flags); 644 read_unlock_irqrestore(&adapter->erp_lock, flags);
653} 645}
654 646
655static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
656{
657 struct zfcp_qdio *qdio = act->adapter->qdio;
658
659 if (zfcp_qdio_open(qdio))
660 return ZFCP_ERP_FAILED;
661 init_waitqueue_head(&qdio->req_q_wq);
662 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
663 return ZFCP_ERP_SUCCEEDED;
664}
665
666static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter) 647static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
667{ 648{
668 struct zfcp_port *port; 649 struct zfcp_port *port;
@@ -670,7 +651,7 @@ static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
670 adapter->peer_d_id); 651 adapter->peer_d_id);
671 if (IS_ERR(port)) /* error or port already attached */ 652 if (IS_ERR(port)) /* error or port already attached */
672 return; 653 return;
673 _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL); 654 _zfcp_erp_port_reopen(port, 0, "ereptp1");
674} 655}
675 656
676static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action) 657static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
@@ -693,10 +674,8 @@ static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
693 return ZFCP_ERP_FAILED; 674 return ZFCP_ERP_FAILED;
694 } 675 }
695 676
696 zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
697 wait_event(adapter->erp_ready_wq, 677 wait_event(adapter->erp_ready_wq,
698 !list_empty(&adapter->erp_ready_head)); 678 !list_empty(&adapter->erp_ready_head));
699 zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
700 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) 679 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
701 break; 680 break;
702 681
@@ -735,10 +714,10 @@ static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
735 if (ret) 714 if (ret)
736 return ZFCP_ERP_FAILED; 715 return ZFCP_ERP_FAILED;
737 716
738 zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf); 717 zfcp_dbf_rec_run("erasox1", act);
739 wait_event(adapter->erp_ready_wq, 718 wait_event(adapter->erp_ready_wq,
740 !list_empty(&adapter->erp_ready_head)); 719 !list_empty(&adapter->erp_ready_head));
741 zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf); 720 zfcp_dbf_rec_run("erasox2", act);
742 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 721 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
743 return ZFCP_ERP_FAILED; 722 return ZFCP_ERP_FAILED;
744 723
@@ -788,7 +767,7 @@ static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
788{ 767{
789 struct zfcp_adapter *adapter = act->adapter; 768 struct zfcp_adapter *adapter = act->adapter;
790 769
791 if (zfcp_erp_adapter_strategy_open_qdio(act)) { 770 if (zfcp_qdio_open(adapter->qdio)) {
792 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 771 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
793 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 772 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
794 &adapter->status); 773 &adapter->status);
@@ -1166,7 +1145,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1166 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) { 1145 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1167 _zfcp_erp_adapter_reopen(adapter, 1146 _zfcp_erp_adapter_reopen(adapter,
1168 ZFCP_STATUS_COMMON_ERP_FAILED, 1147 ZFCP_STATUS_COMMON_ERP_FAILED,
1169 "ersscg1", NULL); 1148 "ersscg1");
1170 return ZFCP_ERP_EXIT; 1149 return ZFCP_ERP_EXIT;
1171 } 1150 }
1172 break; 1151 break;
@@ -1176,7 +1155,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1176 if (zfcp_erp_strat_change_det(&port->status, erp_status)) { 1155 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1177 _zfcp_erp_port_reopen(port, 1156 _zfcp_erp_port_reopen(port,
1178 ZFCP_STATUS_COMMON_ERP_FAILED, 1157 ZFCP_STATUS_COMMON_ERP_FAILED,
1179 "ersscg2", NULL); 1158 "ersscg2");
1180 return ZFCP_ERP_EXIT; 1159 return ZFCP_ERP_EXIT;
1181 } 1160 }
1182 break; 1161 break;
@@ -1186,7 +1165,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1186 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) { 1165 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1187 _zfcp_erp_lun_reopen(sdev, 1166 _zfcp_erp_lun_reopen(sdev,
1188 ZFCP_STATUS_COMMON_ERP_FAILED, 1167 ZFCP_STATUS_COMMON_ERP_FAILED,
1189 "ersscg3", NULL, 0); 1168 "ersscg3", 0);
1190 return ZFCP_ERP_EXIT; 1169 return ZFCP_ERP_EXIT;
1191 } 1170 }
1192 break; 1171 break;
@@ -1206,7 +1185,7 @@ static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1206 } 1185 }
1207 1186
1208 list_del(&erp_action->list); 1187 list_del(&erp_action->list);
1209 zfcp_dbf_rec_action("eractd1", erp_action); 1188 zfcp_dbf_rec_run("eractd1", erp_action);
1210 1189
1211 switch (erp_action->action) { 1190 switch (erp_action->action) {
1212 case ZFCP_ERP_ACTION_REOPEN_LUN: 1191 case ZFCP_ERP_ACTION_REOPEN_LUN:
@@ -1313,7 +1292,7 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1313 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1292 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1314 } 1293 }
1315 if (adapter->erp_total_count == adapter->erp_low_mem_count) 1294 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1316 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL); 1295 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1317 else { 1296 else {
1318 zfcp_erp_strategy_memwait(erp_action); 1297 zfcp_erp_strategy_memwait(erp_action);
1319 retval = ZFCP_ERP_CONTINUES; 1298 retval = ZFCP_ERP_CONTINUES;
@@ -1357,11 +1336,9 @@ static int zfcp_erp_thread(void *data)
1357 unsigned long flags; 1336 unsigned long flags;
1358 1337
1359 for (;;) { 1338 for (;;) {
1360 zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
1361 wait_event_interruptible(adapter->erp_ready_wq, 1339 wait_event_interruptible(adapter->erp_ready_wq,
1362 !list_empty(&adapter->erp_ready_head) || 1340 !list_empty(&adapter->erp_ready_head) ||
1363 kthread_should_stop()); 1341 kthread_should_stop());
1364 zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
1365 1342
1366 if (kthread_should_stop()) 1343 if (kthread_should_stop())
1367 break; 1344 break;
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index bf8f3e514839..6e325284fbe7 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -45,47 +45,33 @@ extern void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *);
45 45
46/* zfcp_dbf.c */ 46/* zfcp_dbf.c */
47extern int zfcp_dbf_adapter_register(struct zfcp_adapter *); 47extern int zfcp_dbf_adapter_register(struct zfcp_adapter *);
48extern void zfcp_dbf_adapter_unregister(struct zfcp_dbf *); 48extern void zfcp_dbf_adapter_unregister(struct zfcp_adapter *);
49extern void zfcp_dbf_rec_thread(char *, struct zfcp_dbf *); 49extern void zfcp_dbf_rec_trig(char *, struct zfcp_adapter *,
50extern void zfcp_dbf_rec_thread_lock(char *, struct zfcp_dbf *); 50 struct zfcp_port *, struct scsi_device *, u8, u8);
51extern void zfcp_dbf_rec_adapter(char *, void *, struct zfcp_dbf *); 51extern void zfcp_dbf_rec_run(char *, struct zfcp_erp_action *);
52extern void zfcp_dbf_rec_port(char *, void *, struct zfcp_port *); 52extern void zfcp_dbf_hba_fsf_uss(char *, struct zfcp_fsf_req *);
53extern void zfcp_dbf_rec_lun(char *, void *, struct scsi_device *); 53extern void zfcp_dbf_hba_fsf_res(char *, struct zfcp_fsf_req *);
54extern void zfcp_dbf_rec_trigger(char *, void *, u8, u8, void *, 54extern void zfcp_dbf_hba_bit_err(char *, struct zfcp_fsf_req *);
55 struct zfcp_adapter *, struct zfcp_port *,
56 struct scsi_device *);
57extern void zfcp_dbf_rec_action(char *, struct zfcp_erp_action *);
58extern void _zfcp_dbf_hba_fsf_response(const char *, int, struct zfcp_fsf_req *,
59 struct zfcp_dbf *);
60extern void _zfcp_dbf_hba_fsf_unsol(const char *, int level, struct zfcp_dbf *,
61 struct fsf_status_read_buffer *);
62extern void zfcp_dbf_hba_qdio(struct zfcp_dbf *, unsigned int, int, int);
63extern void zfcp_dbf_hba_berr(struct zfcp_dbf *, struct zfcp_fsf_req *); 55extern void zfcp_dbf_hba_berr(struct zfcp_dbf *, struct zfcp_fsf_req *);
64extern void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *, u32); 56extern void zfcp_dbf_san_req(char *, struct zfcp_fsf_req *, u32);
65extern void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *); 57extern void zfcp_dbf_san_res(char *, struct zfcp_fsf_req *);
66extern void zfcp_dbf_san_els_request(struct zfcp_fsf_req *); 58extern void zfcp_dbf_san_in_els(char *, struct zfcp_fsf_req *);
67extern void zfcp_dbf_san_els_response(struct zfcp_fsf_req *); 59extern void zfcp_dbf_scsi(char *, struct scsi_cmnd *, struct zfcp_fsf_req *);
68extern void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *);
69extern void _zfcp_dbf_scsi(const char *, const char *, int, struct zfcp_dbf *,
70 struct scsi_cmnd *, struct zfcp_fsf_req *,
71 unsigned long);
72 60
73/* zfcp_erp.c */ 61/* zfcp_erp.c */
74extern void zfcp_erp_set_adapter_status(struct zfcp_adapter *, u32); 62extern void zfcp_erp_set_adapter_status(struct zfcp_adapter *, u32);
75extern void zfcp_erp_clear_adapter_status(struct zfcp_adapter *, u32); 63extern void zfcp_erp_clear_adapter_status(struct zfcp_adapter *, u32);
76extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *, void *); 64extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *);
77extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *, 65extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *);
78 void *);
79extern void zfcp_erp_set_port_status(struct zfcp_port *, u32); 66extern void zfcp_erp_set_port_status(struct zfcp_port *, u32);
80extern void zfcp_erp_clear_port_status(struct zfcp_port *, u32); 67extern void zfcp_erp_clear_port_status(struct zfcp_port *, u32);
81extern int zfcp_erp_port_reopen(struct zfcp_port *, int, char *, void *); 68extern int zfcp_erp_port_reopen(struct zfcp_port *, int, char *);
82extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *, void *); 69extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *);
83extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *, 70extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *);
84 void *);
85extern void zfcp_erp_set_lun_status(struct scsi_device *, u32); 71extern void zfcp_erp_set_lun_status(struct scsi_device *, u32);
86extern void zfcp_erp_clear_lun_status(struct scsi_device *, u32); 72extern void zfcp_erp_clear_lun_status(struct scsi_device *, u32);
87extern void zfcp_erp_lun_reopen(struct scsi_device *, int, char *, void *); 73extern void zfcp_erp_lun_reopen(struct scsi_device *, int, char *);
88extern void zfcp_erp_lun_shutdown(struct scsi_device *, int, char *, void *); 74extern void zfcp_erp_lun_shutdown(struct scsi_device *, int, char *);
89extern void zfcp_erp_lun_shutdown_wait(struct scsi_device *, char *); 75extern void zfcp_erp_lun_shutdown_wait(struct scsi_device *, char *);
90extern int zfcp_erp_thread_setup(struct zfcp_adapter *); 76extern int zfcp_erp_thread_setup(struct zfcp_adapter *);
91extern void zfcp_erp_thread_kill(struct zfcp_adapter *); 77extern void zfcp_erp_thread_kill(struct zfcp_adapter *);
@@ -149,6 +135,8 @@ extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *, struct zfcp_qdio_req *,
149extern int zfcp_qdio_open(struct zfcp_qdio *); 135extern int zfcp_qdio_open(struct zfcp_qdio *);
150extern void zfcp_qdio_close(struct zfcp_qdio *); 136extern void zfcp_qdio_close(struct zfcp_qdio *);
151extern void zfcp_qdio_siosl(struct zfcp_adapter *); 137extern void zfcp_qdio_siosl(struct zfcp_adapter *);
138extern struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *,
139 struct qdio_buffer *);
152 140
153/* zfcp_scsi.c */ 141/* zfcp_scsi.c */
154extern struct zfcp_data zfcp_data; 142extern struct zfcp_data zfcp_data;
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 86fd905df48b..30cf91a787a3 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -174,7 +174,7 @@ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
174 if (!port->d_id) 174 if (!port->d_id)
175 zfcp_erp_port_reopen(port, 175 zfcp_erp_port_reopen(port,
176 ZFCP_STATUS_COMMON_ERP_FAILED, 176 ZFCP_STATUS_COMMON_ERP_FAILED,
177 "fcrscn1", NULL); 177 "fcrscn1");
178 } 178 }
179 read_unlock_irqrestore(&adapter->port_list_lock, flags); 179 read_unlock_irqrestore(&adapter->port_list_lock, flags);
180} 180}
@@ -215,7 +215,7 @@ static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
215 read_lock_irqsave(&adapter->port_list_lock, flags); 215 read_lock_irqsave(&adapter->port_list_lock, flags);
216 list_for_each_entry(port, &adapter->port_list, list) 216 list_for_each_entry(port, &adapter->port_list, list)
217 if (port->wwpn == wwpn) { 217 if (port->wwpn == wwpn) {
218 zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req); 218 zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
219 break; 219 break;
220 } 220 }
221 read_unlock_irqrestore(&adapter->port_list_lock, flags); 221 read_unlock_irqrestore(&adapter->port_list_lock, flags);
@@ -251,7 +251,7 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
251 (struct fsf_status_read_buffer *) fsf_req->data; 251 (struct fsf_status_read_buffer *) fsf_req->data;
252 unsigned int els_type = status_buffer->payload.data[0]; 252 unsigned int els_type = status_buffer->payload.data[0];
253 253
254 zfcp_dbf_san_incoming_els(fsf_req); 254 zfcp_dbf_san_in_els("fciels1", fsf_req);
255 if (els_type == ELS_PLOGI) 255 if (els_type == ELS_PLOGI)
256 zfcp_fc_incoming_plogi(fsf_req); 256 zfcp_fc_incoming_plogi(fsf_req);
257 else if (els_type == ELS_LOGO) 257 else if (els_type == ELS_LOGO)
@@ -360,7 +360,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
360 ret = zfcp_fc_ns_gid_pn(port); 360 ret = zfcp_fc_ns_gid_pn(port);
361 if (ret) { 361 if (ret) {
362 /* could not issue gid_pn for some reason */ 362 /* could not issue gid_pn for some reason */
363 zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1", NULL); 363 zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
364 goto out; 364 goto out;
365 } 365 }
366 366
@@ -369,7 +369,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
369 goto out; 369 goto out;
370 } 370 }
371 371
372 zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL); 372 zfcp_erp_port_reopen(port, 0, "fcgpn_3");
373out: 373out:
374 put_device(&port->dev); 374 put_device(&port->dev);
375} 375}
@@ -426,7 +426,7 @@ static void zfcp_fc_adisc_handler(void *data)
426 if (adisc->els.status) { 426 if (adisc->els.status) {
427 /* request rejected or timed out */ 427 /* request rejected or timed out */
428 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 428 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
429 "fcadh_1", NULL); 429 "fcadh_1");
430 goto out; 430 goto out;
431 } 431 }
432 432
@@ -436,7 +436,7 @@ static void zfcp_fc_adisc_handler(void *data)
436 if ((port->wwpn != adisc_resp->adisc_wwpn) || 436 if ((port->wwpn != adisc_resp->adisc_wwpn) ||
437 !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) { 437 !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
438 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 438 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
439 "fcadh_2", NULL); 439 "fcadh_2");
440 goto out; 440 goto out;
441 } 441 }
442 442
@@ -507,7 +507,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
507 507
508 /* send of ADISC was not possible */ 508 /* send of ADISC was not possible */
509 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); 509 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
510 zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL); 510 zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
511 511
512out: 512out:
513 put_device(&port->dev); 513 put_device(&port->dev);
@@ -659,7 +659,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
659 port = zfcp_port_enqueue(adapter, acc->fp_wwpn, 659 port = zfcp_port_enqueue(adapter, acc->fp_wwpn,
660 ZFCP_STATUS_COMMON_NOESC, d_id); 660 ZFCP_STATUS_COMMON_NOESC, d_id);
661 if (!IS_ERR(port)) 661 if (!IS_ERR(port))
662 zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL); 662 zfcp_erp_port_reopen(port, 0, "fcegpf1");
663 else if (PTR_ERR(port) != -EEXIST) 663 else if (PTR_ERR(port) != -EEXIST)
664 ret = PTR_ERR(port); 664 ret = PTR_ERR(port);
665 } 665 }
@@ -671,7 +671,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
671 write_unlock_irqrestore(&adapter->port_list_lock, flags); 671 write_unlock_irqrestore(&adapter->port_list_lock, flags);
672 672
673 list_for_each_entry_safe(port, tmp, &remove_lh, list) { 673 list_for_each_entry_safe(port, tmp, &remove_lh, list) {
674 zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL); 674 zfcp_erp_port_shutdown(port, 0, "fcegpf2");
675 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); 675 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
676 } 676 }
677 677
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 2eb7dd56ab80..60ff9d172c79 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -23,7 +23,7 @@ static void zfcp_fsf_request_timeout_handler(unsigned long data)
23 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 23 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
24 zfcp_qdio_siosl(adapter); 24 zfcp_qdio_siosl(adapter);
25 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 25 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
26 "fsrth_1", NULL); 26 "fsrth_1");
27} 27}
28 28
29static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, 29static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
@@ -65,7 +65,7 @@ static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
65{ 65{
66 dev_err(&req->adapter->ccw_device->dev, "FCP device not " 66 dev_err(&req->adapter->ccw_device->dev, "FCP device not "
67 "operational because of an unsupported FC class\n"); 67 "operational because of an unsupported FC class\n");
68 zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req); 68 zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1");
69 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 69 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
70} 70}
71 71
@@ -98,7 +98,7 @@ static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
98 read_lock_irqsave(&adapter->port_list_lock, flags); 98 read_lock_irqsave(&adapter->port_list_lock, flags);
99 list_for_each_entry(port, &adapter->port_list, list) 99 list_for_each_entry(port, &adapter->port_list, list)
100 if (port->d_id == d_id) { 100 if (port->d_id == d_id) {
101 zfcp_erp_port_reopen(port, 0, "fssrpc1", req); 101 zfcp_erp_port_reopen(port, 0, "fssrpc1");
102 break; 102 break;
103 } 103 }
104 read_unlock_irqrestore(&adapter->port_list_lock, flags); 104 read_unlock_irqrestore(&adapter->port_list_lock, flags);
@@ -211,13 +211,13 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
211 struct fsf_status_read_buffer *sr_buf = req->data; 211 struct fsf_status_read_buffer *sr_buf = req->data;
212 212
213 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { 213 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
214 zfcp_dbf_hba_fsf_unsol("dism", adapter->dbf, sr_buf); 214 zfcp_dbf_hba_fsf_uss("fssrh_1", req);
215 mempool_free(sr_buf, adapter->pool.status_read_data); 215 mempool_free(sr_buf, adapter->pool.status_read_data);
216 zfcp_fsf_req_free(req); 216 zfcp_fsf_req_free(req);
217 return; 217 return;
218 } 218 }
219 219
220 zfcp_dbf_hba_fsf_unsol("read", adapter->dbf, sr_buf); 220 zfcp_dbf_hba_fsf_uss("fssrh_2", req);
221 221
222 switch (sr_buf->status_type) { 222 switch (sr_buf->status_type) {
223 case FSF_STATUS_READ_PORT_CLOSED: 223 case FSF_STATUS_READ_PORT_CLOSED:
@@ -232,7 +232,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
232 dev_warn(&adapter->ccw_device->dev, 232 dev_warn(&adapter->ccw_device->dev,
233 "The error threshold for checksum statistics " 233 "The error threshold for checksum statistics "
234 "has been exceeded\n"); 234 "has been exceeded\n");
235 zfcp_dbf_hba_berr(adapter->dbf, req); 235 zfcp_dbf_hba_bit_err("fssrh_3", req);
236 break; 236 break;
237 case FSF_STATUS_READ_LINK_DOWN: 237 case FSF_STATUS_READ_LINK_DOWN:
238 zfcp_fsf_status_read_link_down(req); 238 zfcp_fsf_status_read_link_down(req);
@@ -247,7 +247,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
247 zfcp_erp_adapter_reopen(adapter, 247 zfcp_erp_adapter_reopen(adapter,
248 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 248 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
249 ZFCP_STATUS_COMMON_ERP_FAILED, 249 ZFCP_STATUS_COMMON_ERP_FAILED,
250 "fssrh_2", req); 250 "fssrh_2");
251 zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0); 251 zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0);
252 252
253 break; 253 break;
@@ -287,7 +287,7 @@ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
287 "The FCP adapter reported a problem " 287 "The FCP adapter reported a problem "
288 "that cannot be recovered\n"); 288 "that cannot be recovered\n");
289 zfcp_qdio_siosl(req->adapter); 289 zfcp_qdio_siosl(req->adapter);
290 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req); 290 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1");
291 break; 291 break;
292 } 292 }
293 /* all non-return stats set FSFREQ_ERROR*/ 293 /* all non-return stats set FSFREQ_ERROR*/
@@ -304,7 +304,7 @@ static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
304 dev_err(&req->adapter->ccw_device->dev, 304 dev_err(&req->adapter->ccw_device->dev,
305 "The FCP adapter does not recognize the command 0x%x\n", 305 "The FCP adapter does not recognize the command 0x%x\n",
306 req->qtcb->header.fsf_command); 306 req->qtcb->header.fsf_command);
307 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req); 307 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1");
308 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 308 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
309 break; 309 break;
310 case FSF_ADAPTER_STATUS_AVAILABLE: 310 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -335,17 +335,17 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
335 "QTCB version 0x%x not supported by FCP adapter " 335 "QTCB version 0x%x not supported by FCP adapter "
336 "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION, 336 "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
337 psq->word[0], psq->word[1]); 337 psq->word[0], psq->word[1]);
338 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req); 338 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1");
339 break; 339 break;
340 case FSF_PROT_ERROR_STATE: 340 case FSF_PROT_ERROR_STATE:
341 case FSF_PROT_SEQ_NUMB_ERROR: 341 case FSF_PROT_SEQ_NUMB_ERROR:
342 zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req); 342 zfcp_erp_adapter_reopen(adapter, 0, "fspse_2");
343 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 343 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
344 break; 344 break;
345 case FSF_PROT_UNSUPP_QTCB_TYPE: 345 case FSF_PROT_UNSUPP_QTCB_TYPE:
346 dev_err(&adapter->ccw_device->dev, 346 dev_err(&adapter->ccw_device->dev,
347 "The QTCB type is not supported by the FCP adapter\n"); 347 "The QTCB type is not supported by the FCP adapter\n");
348 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req); 348 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3");
349 break; 349 break;
350 case FSF_PROT_HOST_CONNECTION_INITIALIZING: 350 case FSF_PROT_HOST_CONNECTION_INITIALIZING:
351 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 351 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
@@ -355,12 +355,12 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
355 dev_err(&adapter->ccw_device->dev, 355 dev_err(&adapter->ccw_device->dev,
356 "0x%Lx is an ambiguous request identifier\n", 356 "0x%Lx is an ambiguous request identifier\n",
357 (unsigned long long)qtcb->bottom.support.req_handle); 357 (unsigned long long)qtcb->bottom.support.req_handle);
358 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req); 358 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4");
359 break; 359 break;
360 case FSF_PROT_LINK_DOWN: 360 case FSF_PROT_LINK_DOWN:
361 zfcp_fsf_link_down_info_eval(req, &psq->link_down_info); 361 zfcp_fsf_link_down_info_eval(req, &psq->link_down_info);
362 /* go through reopen to flush pending requests */ 362 /* go through reopen to flush pending requests */
363 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req); 363 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6");
364 break; 364 break;
365 case FSF_PROT_REEST_QUEUE: 365 case FSF_PROT_REEST_QUEUE:
366 /* All ports should be marked as ready to run again */ 366 /* All ports should be marked as ready to run again */
@@ -369,14 +369,14 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
369 zfcp_erp_adapter_reopen(adapter, 369 zfcp_erp_adapter_reopen(adapter,
370 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 370 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
371 ZFCP_STATUS_COMMON_ERP_FAILED, 371 ZFCP_STATUS_COMMON_ERP_FAILED,
372 "fspse_8", req); 372 "fspse_8");
373 break; 373 break;
374 default: 374 default:
375 dev_err(&adapter->ccw_device->dev, 375 dev_err(&adapter->ccw_device->dev,
376 "0x%x is not a valid transfer protocol status\n", 376 "0x%x is not a valid transfer protocol status\n",
377 qtcb->prefix.prot_status); 377 qtcb->prefix.prot_status);
378 zfcp_qdio_siosl(adapter); 378 zfcp_qdio_siosl(adapter);
379 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req); 379 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9");
380 } 380 }
381 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 381 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
382} 382}
@@ -482,7 +482,7 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
482 dev_err(&adapter->ccw_device->dev, 482 dev_err(&adapter->ccw_device->dev,
483 "Unknown or unsupported arbitrated loop " 483 "Unknown or unsupported arbitrated loop "
484 "fibre channel topology detected\n"); 484 "fibre channel topology detected\n");
485 zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req); 485 zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1");
486 return -EIO; 486 return -EIO;
487 } 487 }
488 488
@@ -518,7 +518,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
518 "FCP adapter maximum QTCB size (%d bytes) " 518 "FCP adapter maximum QTCB size (%d bytes) "
519 "is too small\n", 519 "is too small\n",
520 bottom->max_qtcb_size); 520 bottom->max_qtcb_size);
521 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req); 521 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1");
522 return; 522 return;
523 } 523 }
524 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 524 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
@@ -536,7 +536,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
536 &qtcb->header.fsf_status_qual.link_down_info); 536 &qtcb->header.fsf_status_qual.link_down_info);
537 break; 537 break;
538 default: 538 default:
539 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req); 539 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3");
540 return; 540 return;
541 } 541 }
542 542
@@ -552,14 +552,14 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
552 dev_err(&adapter->ccw_device->dev, 552 dev_err(&adapter->ccw_device->dev,
553 "The FCP adapter only supports newer " 553 "The FCP adapter only supports newer "
554 "control block versions\n"); 554 "control block versions\n");
555 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req); 555 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4");
556 return; 556 return;
557 } 557 }
558 if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) { 558 if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
559 dev_err(&adapter->ccw_device->dev, 559 dev_err(&adapter->ccw_device->dev,
560 "The FCP adapter only supports older " 560 "The FCP adapter only supports older "
561 "control block versions\n"); 561 "control block versions\n");
562 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req); 562 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5");
563 } 563 }
564} 564}
565 565
@@ -700,7 +700,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
700 del_timer(&req->timer); 700 del_timer(&req->timer);
701 /* lookup request again, list might have changed */ 701 /* lookup request again, list might have changed */
702 zfcp_reqlist_find_rm(adapter->req_list, req_id); 702 zfcp_reqlist_find_rm(adapter->req_list, req_id);
703 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req); 703 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1");
704 return -EIO; 704 return -EIO;
705 } 705 }
706 706
@@ -754,10 +754,11 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
754 goto out; 754 goto out;
755 755
756failed_req_send: 756failed_req_send:
757 req->data = NULL;
757 mempool_free(sr_buf, adapter->pool.status_read_data); 758 mempool_free(sr_buf, adapter->pool.status_read_data);
758failed_buf: 759failed_buf:
760 zfcp_dbf_hba_fsf_uss("fssr__1", req);
759 zfcp_fsf_req_free(req); 761 zfcp_fsf_req_free(req);
760 zfcp_dbf_hba_fsf_unsol("fail", adapter->dbf, NULL);
761out: 762out:
762 spin_unlock_irq(&qdio->req_q_lock); 763 spin_unlock_irq(&qdio->req_q_lock);
763 return retval; 764 return retval;
@@ -776,14 +777,13 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
776 case FSF_PORT_HANDLE_NOT_VALID: 777 case FSF_PORT_HANDLE_NOT_VALID:
777 if (fsq->word[0] == fsq->word[1]) { 778 if (fsq->word[0] == fsq->word[1]) {
778 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, 779 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0,
779 "fsafch1", req); 780 "fsafch1");
780 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 781 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
781 } 782 }
782 break; 783 break;
783 case FSF_LUN_HANDLE_NOT_VALID: 784 case FSF_LUN_HANDLE_NOT_VALID:
784 if (fsq->word[0] == fsq->word[1]) { 785 if (fsq->word[0] == fsq->word[1]) {
785 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2", 786 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2");
786 req);
787 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 787 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
788 } 788 }
789 break; 789 break;
@@ -794,14 +794,13 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
794 zfcp_erp_set_port_status(zfcp_sdev->port, 794 zfcp_erp_set_port_status(zfcp_sdev->port,
795 ZFCP_STATUS_COMMON_ACCESS_BOXED); 795 ZFCP_STATUS_COMMON_ACCESS_BOXED);
796 zfcp_erp_port_reopen(zfcp_sdev->port, 796 zfcp_erp_port_reopen(zfcp_sdev->port,
797 ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3", 797 ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3");
798 req);
799 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 798 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
800 break; 799 break;
801 case FSF_LUN_BOXED: 800 case FSF_LUN_BOXED:
802 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED); 801 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
803 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED, 802 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
804 "fsafch4", req); 803 "fsafch4");
805 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 804 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
806 break; 805 break;
807 case FSF_ADAPTER_STATUS_AVAILABLE: 806 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -882,7 +881,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
882 881
883 switch (header->fsf_status) { 882 switch (header->fsf_status) {
884 case FSF_GOOD: 883 case FSF_GOOD:
885 zfcp_dbf_san_ct_response(req); 884 zfcp_dbf_san_res("fsscth1", req);
886 ct->status = 0; 885 ct->status = 0;
887 break; 886 break;
888 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 887 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -902,7 +901,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
902 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 901 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
903 break; 902 break;
904 case FSF_PORT_HANDLE_NOT_VALID: 903 case FSF_PORT_HANDLE_NOT_VALID:
905 zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req); 904 zfcp_erp_adapter_reopen(adapter, 0, "fsscth1");
906 /* fall through */ 905 /* fall through */
907 case FSF_GENERIC_COMMAND_REJECTED: 906 case FSF_GENERIC_COMMAND_REJECTED:
908 case FSF_PAYLOAD_SIZE_MISMATCH: 907 case FSF_PAYLOAD_SIZE_MISMATCH:
@@ -1025,7 +1024,7 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
1025 req->qtcb->header.port_handle = wka_port->handle; 1024 req->qtcb->header.port_handle = wka_port->handle;
1026 req->data = ct; 1025 req->data = ct;
1027 1026
1028 zfcp_dbf_san_ct_request(req, wka_port->d_id); 1027 zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
1029 1028
1030 ret = zfcp_fsf_req_send(req); 1029 ret = zfcp_fsf_req_send(req);
1031 if (ret) 1030 if (ret)
@@ -1053,7 +1052,7 @@ static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1053 1052
1054 switch (header->fsf_status) { 1053 switch (header->fsf_status) {
1055 case FSF_GOOD: 1054 case FSF_GOOD:
1056 zfcp_dbf_san_els_response(req); 1055 zfcp_dbf_san_res("fsselh1", req);
1057 send_els->status = 0; 1056 send_els->status = 0;
1058 break; 1057 break;
1059 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 1058 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -1127,7 +1126,7 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
1127 req->handler = zfcp_fsf_send_els_handler; 1126 req->handler = zfcp_fsf_send_els_handler;
1128 req->data = els; 1127 req->data = els;
1129 1128
1130 zfcp_dbf_san_els_request(req); 1129 zfcp_dbf_san_req("fssels1", req, d_id);
1131 1130
1132 ret = zfcp_fsf_req_send(req); 1131 ret = zfcp_fsf_req_send(req);
1133 if (ret) 1132 if (ret)
@@ -1448,7 +1447,7 @@ static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1448 1447
1449 switch (req->qtcb->header.fsf_status) { 1448 switch (req->qtcb->header.fsf_status) {
1450 case FSF_PORT_HANDLE_NOT_VALID: 1449 case FSF_PORT_HANDLE_NOT_VALID:
1451 zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req); 1450 zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
1452 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1451 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1453 break; 1452 break;
1454 case FSF_ADAPTER_STATUS_AVAILABLE: 1453 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1580,7 +1579,7 @@ static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
1580 1579
1581 if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) { 1580 if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
1582 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1581 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1583 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req); 1582 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
1584 } 1583 }
1585 1584
1586 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE; 1585 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
@@ -1638,7 +1637,7 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1638 1637
1639 switch (header->fsf_status) { 1638 switch (header->fsf_status) {
1640 case FSF_PORT_HANDLE_NOT_VALID: 1639 case FSF_PORT_HANDLE_NOT_VALID:
1641 zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req); 1640 zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
1642 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1641 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1643 break; 1642 break;
1644 case FSF_ACCESS_DENIED: 1643 case FSF_ACCESS_DENIED:
@@ -1654,7 +1653,7 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1654 &sdev_to_zfcp(sdev)->status); 1653 &sdev_to_zfcp(sdev)->status);
1655 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED); 1654 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
1656 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 1655 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
1657 "fscpph2", req); 1656 "fscpph2");
1658 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1657 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1659 break; 1658 break;
1660 case FSF_ADAPTER_STATUS_AVAILABLE: 1659 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1743,7 +1742,7 @@ static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
1743 switch (header->fsf_status) { 1742 switch (header->fsf_status) {
1744 1743
1745 case FSF_PORT_HANDLE_NOT_VALID: 1744 case FSF_PORT_HANDLE_NOT_VALID:
1746 zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1", req); 1745 zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
1747 /* fall through */ 1746 /* fall through */
1748 case FSF_LUN_ALREADY_OPEN: 1747 case FSF_LUN_ALREADY_OPEN:
1749 break; 1748 break;
@@ -1755,8 +1754,7 @@ static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
1755 zfcp_erp_set_port_status(zfcp_sdev->port, 1754 zfcp_erp_set_port_status(zfcp_sdev->port,
1756 ZFCP_STATUS_COMMON_ACCESS_BOXED); 1755 ZFCP_STATUS_COMMON_ACCESS_BOXED);
1757 zfcp_erp_port_reopen(zfcp_sdev->port, 1756 zfcp_erp_port_reopen(zfcp_sdev->port,
1758 ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2", 1757 ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
1759 req);
1760 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1758 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1761 break; 1759 break;
1762 case FSF_LUN_SHARING_VIOLATION: 1760 case FSF_LUN_SHARING_VIOLATION:
@@ -1852,20 +1850,18 @@ static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
1852 1850
1853 switch (req->qtcb->header.fsf_status) { 1851 switch (req->qtcb->header.fsf_status) {
1854 case FSF_PORT_HANDLE_NOT_VALID: 1852 case FSF_PORT_HANDLE_NOT_VALID:
1855 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1", 1853 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
1856 req);
1857 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1854 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1858 break; 1855 break;
1859 case FSF_LUN_HANDLE_NOT_VALID: 1856 case FSF_LUN_HANDLE_NOT_VALID:
1860 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2", req); 1857 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
1861 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1858 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1862 break; 1859 break;
1863 case FSF_PORT_BOXED: 1860 case FSF_PORT_BOXED:
1864 zfcp_erp_set_port_status(zfcp_sdev->port, 1861 zfcp_erp_set_port_status(zfcp_sdev->port,
1865 ZFCP_STATUS_COMMON_ACCESS_BOXED); 1862 ZFCP_STATUS_COMMON_ACCESS_BOXED);
1866 zfcp_erp_port_reopen(zfcp_sdev->port, 1863 zfcp_erp_port_reopen(zfcp_sdev->port,
1867 ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3", 1864 ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
1868 req);
1869 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1865 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1870 break; 1866 break;
1871 case FSF_ADAPTER_STATUS_AVAILABLE: 1867 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -2002,13 +1998,12 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
2002 switch (header->fsf_status) { 1998 switch (header->fsf_status) {
2003 case FSF_HANDLE_MISMATCH: 1999 case FSF_HANDLE_MISMATCH:
2004 case FSF_PORT_HANDLE_NOT_VALID: 2000 case FSF_PORT_HANDLE_NOT_VALID:
2005 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1", 2001 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1");
2006 req);
2007 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2002 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2008 break; 2003 break;
2009 case FSF_FCPLUN_NOT_VALID: 2004 case FSF_FCPLUN_NOT_VALID:
2010 case FSF_LUN_HANDLE_NOT_VALID: 2005 case FSF_LUN_HANDLE_NOT_VALID:
2011 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2", req); 2006 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
2012 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2007 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2013 break; 2008 break;
2014 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 2009 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -2026,7 +2021,7 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
2026 (unsigned long long)zfcp_scsi_dev_lun(sdev), 2021 (unsigned long long)zfcp_scsi_dev_lun(sdev),
2027 (unsigned long long)zfcp_sdev->port->wwpn); 2022 (unsigned long long)zfcp_sdev->port->wwpn);
2028 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0, 2023 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
2029 "fssfch3", req); 2024 "fssfch3");
2030 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2025 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2031 break; 2026 break;
2032 case FSF_CMND_LENGTH_NOT_VALID: 2027 case FSF_CMND_LENGTH_NOT_VALID:
@@ -2037,21 +2032,20 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
2037 (unsigned long long)zfcp_scsi_dev_lun(sdev), 2032 (unsigned long long)zfcp_scsi_dev_lun(sdev),
2038 (unsigned long long)zfcp_sdev->port->wwpn); 2033 (unsigned long long)zfcp_sdev->port->wwpn);
2039 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0, 2034 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
2040 "fssfch4", req); 2035 "fssfch4");
2041 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2036 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2042 break; 2037 break;
2043 case FSF_PORT_BOXED: 2038 case FSF_PORT_BOXED:
2044 zfcp_erp_set_port_status(zfcp_sdev->port, 2039 zfcp_erp_set_port_status(zfcp_sdev->port,
2045 ZFCP_STATUS_COMMON_ACCESS_BOXED); 2040 ZFCP_STATUS_COMMON_ACCESS_BOXED);
2046 zfcp_erp_port_reopen(zfcp_sdev->port, 2041 zfcp_erp_port_reopen(zfcp_sdev->port,
2047 ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5", 2042 ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
2048 req);
2049 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2043 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2050 break; 2044 break;
2051 case FSF_LUN_BOXED: 2045 case FSF_LUN_BOXED:
2052 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED); 2046 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
2053 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED, 2047 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
2054 "fssfch6", req); 2048 "fssfch6");
2055 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2049 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2056 break; 2050 break;
2057 case FSF_ADAPTER_STATUS_AVAILABLE: 2051 case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -2104,7 +2098,7 @@ static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
2104 2098
2105skip_fsfstatus: 2099skip_fsfstatus:
2106 zfcp_fsf_req_trace(req, scpnt); 2100 zfcp_fsf_req_trace(req, scpnt);
2107 zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req); 2101 zfcp_dbf_scsi_result(scpnt, req);
2108 2102
2109 scpnt->host_scribble = NULL; 2103 scpnt->host_scribble = NULL;
2110 (scpnt->scsi_done) (scpnt); 2104 (scpnt->scsi_done) (scpnt);
@@ -2420,3 +2414,12 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
2420 break; 2414 break;
2421 } 2415 }
2422} 2416}
2417
2418struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *qdio,
2419 struct qdio_buffer *sbal)
2420{
2421 struct qdio_buffer_element *sbale = &sbal->element[0];
2422 u64 req_id = (unsigned long) sbale->addr;
2423
2424 return zfcp_reqlist_find(qdio->adapter->req_list, req_id);
2425}
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index a0554beb4179..2511f92302dd 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -41,7 +41,7 @@ static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id,
41 zfcp_qdio_siosl(adapter); 41 zfcp_qdio_siosl(adapter);
42 zfcp_erp_adapter_reopen(adapter, 42 zfcp_erp_adapter_reopen(adapter,
43 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 43 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
44 ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL); 44 ZFCP_STATUS_COMMON_ERP_FAILED, id);
45} 45}
46 46
47static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt) 47static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
@@ -74,7 +74,6 @@ static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
74 struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm; 74 struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
75 75
76 if (unlikely(qdio_err)) { 76 if (unlikely(qdio_err)) {
77 zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
78 zfcp_qdio_handler_error(qdio, "qdireq1", qdio_err); 77 zfcp_qdio_handler_error(qdio, "qdireq1", qdio_err);
79 return; 78 return;
80 } 79 }
@@ -97,7 +96,6 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
97 int sbal_idx, sbal_no; 96 int sbal_idx, sbal_no;
98 97
99 if (unlikely(qdio_err)) { 98 if (unlikely(qdio_err)) {
100 zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
101 zfcp_qdio_handler_error(qdio, "qdires1", qdio_err); 99 zfcp_qdio_handler_error(qdio, "qdires1", qdio_err);
102 return; 100 return;
103 } 101 }
@@ -116,7 +114,7 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
116 * put SBALs back to response queue 114 * put SBALs back to response queue
117 */ 115 */
118 if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count)) 116 if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count))
119 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2", NULL); 117 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2");
120} 118}
121 119
122static struct qdio_buffer_element * 120static struct qdio_buffer_element *
@@ -236,7 +234,7 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
236 if (!ret) { 234 if (!ret) {
237 atomic_inc(&qdio->req_q_full); 235 atomic_inc(&qdio->req_q_full);
238 /* assume hanging outbound queue, try queue recovery */ 236 /* assume hanging outbound queue, try queue recovery */
239 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1", NULL); 237 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
240 } 238 }
241 239
242 spin_lock_irq(&qdio->req_q_lock); 240 spin_lock_irq(&qdio->req_q_lock);
@@ -309,6 +307,7 @@ static int zfcp_qdio_allocate(struct zfcp_qdio *qdio)
309 return -ENOMEM; 307 return -ENOMEM;
310 308
311 zfcp_qdio_setup_init_data(&init_data, qdio); 309 zfcp_qdio_setup_init_data(&init_data, qdio);
310 init_waitqueue_head(&qdio->req_q_wq);
312 311
313 return qdio_allocate(&init_data); 312 return qdio_allocate(&init_data);
314} 313}
@@ -393,6 +392,7 @@ int zfcp_qdio_open(struct zfcp_qdio *qdio)
393 /* set index of first avalable SBALS / number of available SBALS */ 392 /* set index of first avalable SBALS / number of available SBALS */
394 qdio->req_q_idx = 0; 393 qdio->req_q_idx = 0;
395 atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q); 394 atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q);
395 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
396 396
397 return 0; 397 return 0;
398 398
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 63529ed801eb..ddb5800823a9 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -30,6 +30,10 @@ module_param_named(dif, enable_dif, bool, 0600);
30MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support"); 30MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support");
31#endif 31#endif
32 32
33static bool allow_lun_scan = 1;
34module_param(allow_lun_scan, bool, 0600);
35MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
36
33static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth, 37static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
34 int reason) 38 int reason)
35{ 39{
@@ -68,11 +72,8 @@ static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
68 72
69static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) 73static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
70{ 74{
71 struct zfcp_adapter *adapter =
72 (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
73
74 set_host_byte(scpnt, result); 75 set_host_byte(scpnt, result);
75 zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt); 76 zfcp_dbf_scsi_fail_send(scpnt);
76 scpnt->scsi_done(scpnt); 77 scpnt->scsi_done(scpnt);
77} 78}
78 79
@@ -80,7 +81,6 @@ static
80int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt) 81int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
81{ 82{
82 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device); 83 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
83 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
84 struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device)); 84 struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
85 int status, scsi_result, ret; 85 int status, scsi_result, ret;
86 86
@@ -91,7 +91,7 @@ int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
91 scsi_result = fc_remote_port_chkready(rport); 91 scsi_result = fc_remote_port_chkready(rport);
92 if (unlikely(scsi_result)) { 92 if (unlikely(scsi_result)) {
93 scpnt->result = scsi_result; 93 scpnt->result = scsi_result;
94 zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt); 94 zfcp_dbf_scsi_fail_send(scpnt);
95 scpnt->scsi_done(scpnt); 95 scpnt->scsi_done(scpnt);
96 return 0; 96 return 0;
97 } 97 }
@@ -134,6 +134,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
134 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 134 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
135 struct zfcp_port *port; 135 struct zfcp_port *port;
136 struct zfcp_unit *unit; 136 struct zfcp_unit *unit;
137 int npiv = adapter->connection_features & FSF_FEATURE_NPIV_MODE;
137 138
138 port = zfcp_get_port_by_wwpn(adapter, rport->port_name); 139 port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
139 if (!port) 140 if (!port)
@@ -143,7 +144,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
143 if (unit) 144 if (unit)
144 put_device(&unit->dev); 145 put_device(&unit->dev);
145 146
146 if (!unit && !(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) { 147 if (!unit && !(allow_lun_scan && npiv)) {
147 put_device(&port->dev); 148 put_device(&port->dev);
148 return -ENXIO; 149 return -ENXIO;
149 } 150 }
@@ -158,7 +159,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
158 spin_lock_init(&zfcp_sdev->latencies.lock); 159 spin_lock_init(&zfcp_sdev->latencies.lock);
159 160
160 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING); 161 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
161 zfcp_erp_lun_reopen(sdev, 0, "scsla_1", NULL); 162 zfcp_erp_lun_reopen(sdev, 0, "scsla_1");
162 zfcp_erp_wait(port->adapter); 163 zfcp_erp_wait(port->adapter);
163 164
164 return 0; 165 return 0;
@@ -182,8 +183,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
182 old_req = zfcp_reqlist_find(adapter->req_list, old_reqid); 183 old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
183 if (!old_req) { 184 if (!old_req) {
184 write_unlock_irqrestore(&adapter->abort_lock, flags); 185 write_unlock_irqrestore(&adapter->abort_lock, flags);
185 zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL, 186 zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);
186 old_reqid);
187 return FAILED; /* completion could be in progress */ 187 return FAILED; /* completion could be in progress */
188 } 188 }
189 old_req->data = NULL; 189 old_req->data = NULL;
@@ -198,29 +198,32 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
198 198
199 zfcp_erp_wait(adapter); 199 zfcp_erp_wait(adapter);
200 ret = fc_block_scsi_eh(scpnt); 200 ret = fc_block_scsi_eh(scpnt);
201 if (ret) 201 if (ret) {
202 zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);
202 return ret; 203 return ret;
204 }
203 if (!(atomic_read(&adapter->status) & 205 if (!(atomic_read(&adapter->status) &
204 ZFCP_STATUS_COMMON_RUNNING)) { 206 ZFCP_STATUS_COMMON_RUNNING)) {
205 zfcp_dbf_scsi_abort("nres", adapter->dbf, scpnt, NULL, 207 zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);
206 old_reqid);
207 return SUCCESS; 208 return SUCCESS;
208 } 209 }
209 } 210 }
210 if (!abrt_req) 211 if (!abrt_req) {
212 zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);
211 return FAILED; 213 return FAILED;
214 }
212 215
213 wait_for_completion(&abrt_req->completion); 216 wait_for_completion(&abrt_req->completion);
214 217
215 if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) 218 if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
216 dbf_tag = "okay"; 219 dbf_tag = "abrt_ok";
217 else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) 220 else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
218 dbf_tag = "lte2"; 221 dbf_tag = "abrt_nn";
219 else { 222 else {
220 dbf_tag = "fail"; 223 dbf_tag = "abrt_fa";
221 retval = FAILED; 224 retval = FAILED;
222 } 225 }
223 zfcp_dbf_scsi_abort(dbf_tag, adapter->dbf, scpnt, abrt_req, old_reqid); 226 zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);
224 zfcp_fsf_req_free(abrt_req); 227 zfcp_fsf_req_free(abrt_req);
225 return retval; 228 return retval;
226} 229}
@@ -280,7 +283,7 @@ static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
280 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter; 283 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
281 int ret; 284 int ret;
282 285
283 zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt); 286 zfcp_erp_adapter_reopen(adapter, 0, "schrh_1");
284 zfcp_erp_wait(adapter); 287 zfcp_erp_wait(adapter);
285 ret = fc_block_scsi_eh(scpnt); 288 ret = fc_block_scsi_eh(scpnt);
286 if (ret) 289 if (ret)
@@ -518,7 +521,7 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
518 port = zfcp_get_port_by_wwpn(adapter, rport->port_name); 521 port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
519 522
520 if (port) { 523 if (port) {
521 zfcp_erp_port_forced_reopen(port, 0, "sctrpi1", NULL); 524 zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
522 put_device(&port->dev); 525 put_device(&port->dev);
523 } 526 }
524} 527}
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index 2f2c54f4718f..cdc4ff78a7ba 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -105,8 +105,7 @@ static ssize_t zfcp_sysfs_port_failed_store(struct device *dev,
105 return -EINVAL; 105 return -EINVAL;
106 106
107 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_RUNNING); 107 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_RUNNING);
108 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, "sypfai2", 108 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, "sypfai2");
109 NULL);
110 zfcp_erp_wait(port->adapter); 109 zfcp_erp_wait(port->adapter);
111 110
112 return count; 111 return count;
@@ -148,7 +147,7 @@ static ssize_t zfcp_sysfs_unit_failed_store(struct device *dev,
148 if (sdev) { 147 if (sdev) {
149 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING); 148 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
150 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED, 149 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
151 "syufai2", NULL); 150 "syufai2");
152 zfcp_erp_wait(unit->port->adapter); 151 zfcp_erp_wait(unit->port->adapter);
153 } else 152 } else
154 zfcp_unit_scsi_scan(unit); 153 zfcp_unit_scsi_scan(unit);
@@ -198,7 +197,7 @@ static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
198 197
199 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING); 198 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
200 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 199 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
201 "syafai2", NULL); 200 "syafai2");
202 zfcp_erp_wait(adapter); 201 zfcp_erp_wait(adapter);
203out: 202out:
204 zfcp_ccw_adapter_put(adapter); 203 zfcp_ccw_adapter_put(adapter);
@@ -256,7 +255,7 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
256 255
257 put_device(&port->dev); 256 put_device(&port->dev);
258 257
259 zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL); 258 zfcp_erp_port_shutdown(port, 0, "syprs_1");
260 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); 259 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
261 out: 260 out:
262 zfcp_ccw_adapter_put(adapter); 261 zfcp_ccw_adapter_put(adapter);
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-09 12:31:58 -0400