aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/s390/scsi/zfcp_erp.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/s390/scsi/zfcp_erp.c')
-rw-r--r--drivers/s390/scsi/zfcp_erp.c741
1 files changed, 334 insertions, 407 deletions
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 160b432c907f..e1b4f800e226 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -21,6 +21,7 @@ enum zfcp_erp_act_flags {
21 ZFCP_STATUS_ERP_DISMISSING = 0x00100000, 21 ZFCP_STATUS_ERP_DISMISSING = 0x00100000,
22 ZFCP_STATUS_ERP_DISMISSED = 0x00200000, 22 ZFCP_STATUS_ERP_DISMISSED = 0x00200000,
23 ZFCP_STATUS_ERP_LOWMEM = 0x00400000, 23 ZFCP_STATUS_ERP_LOWMEM = 0x00400000,
24 ZFCP_STATUS_ERP_NO_REF = 0x00800000,
24}; 25};
25 26
26enum zfcp_erp_steps { 27enum zfcp_erp_steps {
@@ -29,12 +30,12 @@ enum zfcp_erp_steps {
29 ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010, 30 ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
30 ZFCP_ERP_STEP_PORT_CLOSING = 0x0100, 31 ZFCP_ERP_STEP_PORT_CLOSING = 0x0100,
31 ZFCP_ERP_STEP_PORT_OPENING = 0x0800, 32 ZFCP_ERP_STEP_PORT_OPENING = 0x0800,
32 ZFCP_ERP_STEP_UNIT_CLOSING = 0x1000, 33 ZFCP_ERP_STEP_LUN_CLOSING = 0x1000,
33 ZFCP_ERP_STEP_UNIT_OPENING = 0x2000, 34 ZFCP_ERP_STEP_LUN_OPENING = 0x2000,
34}; 35};
35 36
36enum zfcp_erp_act_type { 37enum zfcp_erp_act_type {
37 ZFCP_ERP_ACTION_REOPEN_UNIT = 1, 38 ZFCP_ERP_ACTION_REOPEN_LUN = 1,
38 ZFCP_ERP_ACTION_REOPEN_PORT = 2, 39 ZFCP_ERP_ACTION_REOPEN_PORT = 2,
39 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3, 40 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
40 ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4, 41 ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4,
@@ -56,9 +57,8 @@ enum zfcp_erp_act_result {
56 57
57static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask) 58static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
58{ 59{
59 zfcp_erp_modify_adapter_status(adapter, "erablk1", NULL, 60 zfcp_erp_clear_adapter_status(adapter,
60 ZFCP_STATUS_COMMON_UNBLOCKED | mask, 61 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
61 ZFCP_CLEAR);
62} 62}
63 63
64static int zfcp_erp_action_exists(struct zfcp_erp_action *act) 64static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
@@ -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)
@@ -88,24 +88,24 @@ static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
88 zfcp_erp_action_ready(act); 88 zfcp_erp_action_ready(act);
89} 89}
90 90
91static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit) 91static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
92{ 92{
93 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE) 93 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
94 zfcp_erp_action_dismiss(&unit->erp_action); 94
95 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
96 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
95} 97}
96 98
97static void zfcp_erp_action_dismiss_port(struct zfcp_port *port) 99static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
98{ 100{
99 struct zfcp_unit *unit; 101 struct scsi_device *sdev;
100 102
101 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE) 103 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
102 zfcp_erp_action_dismiss(&port->erp_action); 104 zfcp_erp_action_dismiss(&port->erp_action);
103 else { 105 else
104 read_lock(&port->unit_list_lock); 106 shost_for_each_device(sdev, port->adapter->scsi_host)
105 list_for_each_entry(unit, &port->unit_list, list) 107 if (sdev_to_zfcp(sdev)->port == port)
106 zfcp_erp_action_dismiss_unit(unit); 108 zfcp_erp_action_dismiss_lun(sdev);
107 read_unlock(&port->unit_list_lock);
108 }
109} 109}
110 110
111static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter) 111static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
@@ -124,15 +124,17 @@ static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
124 124
125static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter, 125static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
126 struct zfcp_port *port, 126 struct zfcp_port *port,
127 struct zfcp_unit *unit) 127 struct scsi_device *sdev)
128{ 128{
129 int need = want; 129 int need = want;
130 int u_status, p_status, a_status; 130 int l_status, p_status, a_status;
131 struct zfcp_scsi_dev *zfcp_sdev;
131 132
132 switch (want) { 133 switch (want) {
133 case ZFCP_ERP_ACTION_REOPEN_UNIT: 134 case ZFCP_ERP_ACTION_REOPEN_LUN:
134 u_status = atomic_read(&unit->status); 135 zfcp_sdev = sdev_to_zfcp(sdev);
135 if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE) 136 l_status = atomic_read(&zfcp_sdev->status);
137 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
136 return 0; 138 return 0;
137 p_status = atomic_read(&port->status); 139 p_status = atomic_read(&port->status);
138 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) || 140 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
@@ -154,6 +156,8 @@ static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
154 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) || 156 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
155 a_status & ZFCP_STATUS_COMMON_ERP_FAILED) 157 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
156 return 0; 158 return 0;
159 if (p_status & ZFCP_STATUS_COMMON_NOESC)
160 return need;
157 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED)) 161 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
158 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER; 162 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
159 /* fall through */ 163 /* fall through */
@@ -169,22 +173,29 @@ static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
169 return need; 173 return need;
170} 174}
171 175
172static struct zfcp_erp_action *zfcp_erp_setup_act(int need, 176static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
173 struct zfcp_adapter *adapter, 177 struct zfcp_adapter *adapter,
174 struct zfcp_port *port, 178 struct zfcp_port *port,
175 struct zfcp_unit *unit) 179 struct scsi_device *sdev)
176{ 180{
177 struct zfcp_erp_action *erp_action; 181 struct zfcp_erp_action *erp_action;
178 u32 status = 0; 182 struct zfcp_scsi_dev *zfcp_sdev;
179 183
180 switch (need) { 184 switch (need) {
181 case ZFCP_ERP_ACTION_REOPEN_UNIT: 185 case ZFCP_ERP_ACTION_REOPEN_LUN:
182 if (!get_device(&unit->dev)) 186 zfcp_sdev = sdev_to_zfcp(sdev);
183 return NULL; 187 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
184 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); 188 if (scsi_device_get(sdev))
185 erp_action = &unit->erp_action; 189 return NULL;
186 if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING)) 190 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
187 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 191 &zfcp_sdev->status);
192 erp_action = &zfcp_sdev->erp_action;
193 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
194 erp_action->port = port;
195 erp_action->sdev = sdev;
196 if (!(atomic_read(&zfcp_sdev->status) &
197 ZFCP_STATUS_COMMON_RUNNING))
198 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
188 break; 199 break;
189 200
190 case ZFCP_ERP_ACTION_REOPEN_PORT: 201 case ZFCP_ERP_ACTION_REOPEN_PORT:
@@ -194,8 +205,10 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
194 zfcp_erp_action_dismiss_port(port); 205 zfcp_erp_action_dismiss_port(port);
195 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); 206 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
196 erp_action = &port->erp_action; 207 erp_action = &port->erp_action;
208 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
209 erp_action->port = port;
197 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING)) 210 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
198 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 211 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
199 break; 212 break;
200 213
201 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 214 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
@@ -203,66 +216,65 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
203 zfcp_erp_action_dismiss_adapter(adapter); 216 zfcp_erp_action_dismiss_adapter(adapter);
204 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status); 217 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
205 erp_action = &adapter->erp_action; 218 erp_action = &adapter->erp_action;
219 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
206 if (!(atomic_read(&adapter->status) & 220 if (!(atomic_read(&adapter->status) &
207 ZFCP_STATUS_COMMON_RUNNING)) 221 ZFCP_STATUS_COMMON_RUNNING))
208 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 222 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
209 break; 223 break;
210 224
211 default: 225 default:
212 return NULL; 226 return NULL;
213 } 227 }
214 228
215 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
216 erp_action->adapter = adapter; 229 erp_action->adapter = adapter;
217 erp_action->port = port;
218 erp_action->unit = unit;
219 erp_action->action = need; 230 erp_action->action = need;
220 erp_action->status = status; 231 erp_action->status = act_status;
221 232
222 return erp_action; 233 return erp_action;
223} 234}
224 235
225static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter, 236static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
226 struct zfcp_port *port, 237 struct zfcp_port *port,
227 struct zfcp_unit *unit, char *id, void *ref) 238 struct scsi_device *sdev,
239 char *id, u32 act_status)
228{ 240{
229 int retval = 1, need; 241 int retval = 1, need;
230 struct zfcp_erp_action *act = NULL; 242 struct zfcp_erp_action *act;
231 243
232 if (!adapter->erp_thread) 244 if (!adapter->erp_thread)
233 return -EIO; 245 return -EIO;
234 246
235 need = zfcp_erp_required_act(want, adapter, port, unit); 247 need = zfcp_erp_required_act(want, adapter, port, sdev);
236 if (!need) 248 if (!need)
237 goto out; 249 goto out;
238 250
239 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status); 251 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
240 act = zfcp_erp_setup_act(need, adapter, port, unit);
241 if (!act) 252 if (!act)
242 goto out; 253 goto out;
254 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
243 ++adapter->erp_total_count; 255 ++adapter->erp_total_count;
244 list_add_tail(&act->list, &adapter->erp_ready_head); 256 list_add_tail(&act->list, &adapter->erp_ready_head);
245 wake_up(&adapter->erp_ready_wq); 257 wake_up(&adapter->erp_ready_wq);
246 zfcp_dbf_rec_thread("eracte1", adapter->dbf);
247 retval = 0; 258 retval = 0;
248 out: 259 out:
249 zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, unit); 260 zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
250 return retval; 261 return retval;
251} 262}
252 263
253static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, 264static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
254 int clear_mask, char *id, void *ref) 265 int clear_mask, char *id)
255{ 266{
256 zfcp_erp_adapter_block(adapter, clear_mask); 267 zfcp_erp_adapter_block(adapter, clear_mask);
257 zfcp_scsi_schedule_rports_block(adapter); 268 zfcp_scsi_schedule_rports_block(adapter);
258 269
259 /* ensure propagation of failed status to new devices */ 270 /* ensure propagation of failed status to new devices */
260 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 271 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
261 zfcp_erp_adapter_failed(adapter, "erareo1", NULL); 272 zfcp_erp_set_adapter_status(adapter,
273 ZFCP_STATUS_COMMON_ERP_FAILED);
262 return -EIO; 274 return -EIO;
263 } 275 }
264 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, 276 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
265 adapter, NULL, NULL, id, ref); 277 adapter, NULL, NULL, id, 0);
266} 278}
267 279
268/** 280/**
@@ -270,10 +282,8 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
270 * @adapter: Adapter to reopen. 282 * @adapter: Adapter to reopen.
271 * @clear: Status flags to clear. 283 * @clear: Status flags to clear.
272 * @id: Id for debug trace event. 284 * @id: Id for debug trace event.
273 * @ref: Reference for debug trace event.
274 */ 285 */
275void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, 286void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
276 char *id, void *ref)
277{ 287{
278 unsigned long flags; 288 unsigned long flags;
279 289
@@ -282,10 +292,11 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
282 292
283 write_lock_irqsave(&adapter->erp_lock, flags); 293 write_lock_irqsave(&adapter->erp_lock, flags);
284 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) 294 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
285 zfcp_erp_adapter_failed(adapter, "erareo1", NULL); 295 zfcp_erp_set_adapter_status(adapter,
296 ZFCP_STATUS_COMMON_ERP_FAILED);
286 else 297 else
287 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter, 298 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
288 NULL, NULL, id, ref); 299 NULL, NULL, id, 0);
289 write_unlock_irqrestore(&adapter->erp_lock, flags); 300 write_unlock_irqrestore(&adapter->erp_lock, flags);
290} 301}
291 302
@@ -294,13 +305,12 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
294 * @adapter: Adapter to shut down. 305 * @adapter: Adapter to shut down.
295 * @clear: Status flags to clear. 306 * @clear: Status flags to clear.
296 * @id: Id for debug trace event. 307 * @id: Id for debug trace event.
297 * @ref: Reference for debug trace event.
298 */ 308 */
299void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear, 309void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
300 char *id, void *ref) 310 char *id)
301{ 311{
302 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 312 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
303 zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref); 313 zfcp_erp_adapter_reopen(adapter, clear | flags, id);
304} 314}
305 315
306/** 316/**
@@ -308,38 +318,21 @@ void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
308 * @port: Port to shut down. 318 * @port: Port to shut down.
309 * @clear: Status flags to clear. 319 * @clear: Status flags to clear.
310 * @id: Id for debug trace event. 320 * @id: Id for debug trace event.
311 * @ref: Reference for debug trace event.
312 */
313void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id,
314 void *ref)
315{
316 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
317 zfcp_erp_port_reopen(port, clear | flags, id, ref);
318}
319
320/**
321 * zfcp_erp_unit_shutdown - Shutdown unit
322 * @unit: Unit to shut down.
323 * @clear: Status flags to clear.
324 * @id: Id for debug trace event.
325 * @ref: Reference for debug trace event.
326 */ 321 */
327void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, 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_unit_reopen(unit, 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)
335{ 329{
336 zfcp_erp_modify_port_status(port, "erpblk1", NULL, 330 zfcp_erp_clear_port_status(port,
337 ZFCP_STATUS_COMMON_UNBLOCKED | clear, 331 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
338 ZFCP_CLEAR);
339} 332}
340 333
341static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, 334static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
342 int clear, char *id, void *ref) 335 char *id)
343{ 336{
344 zfcp_erp_port_block(port, clear); 337 zfcp_erp_port_block(port, clear);
345 zfcp_scsi_schedule_rport_block(port); 338 zfcp_scsi_schedule_rport_block(port);
@@ -348,136 +341,171 @@ static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
348 return; 341 return;
349 342
350 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED, 343 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
351 port->adapter, port, NULL, id, ref); 344 port->adapter, port, NULL, id, 0);
352} 345}
353 346
354/** 347/**
355 * 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
356 * @port: Port to force close and to reopen. 349 * @port: Port to force close and to reopen.
350 * @clear: Status flags to clear.
357 * @id: Id for debug trace event. 351 * @id: Id for debug trace event.
358 * @ref: Reference for debug trace event.
359 */ 352 */
360void 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)
361 void *ref)
362{ 354{
363 unsigned long flags; 355 unsigned long flags;
364 struct zfcp_adapter *adapter = port->adapter; 356 struct zfcp_adapter *adapter = port->adapter;
365 357
366 write_lock_irqsave(&adapter->erp_lock, flags); 358 write_lock_irqsave(&adapter->erp_lock, flags);
367 _zfcp_erp_port_forced_reopen(port, clear, id, ref); 359 _zfcp_erp_port_forced_reopen(port, clear, id);
368 write_unlock_irqrestore(&adapter->erp_lock, flags); 360 write_unlock_irqrestore(&adapter->erp_lock, flags);
369} 361}
370 362
371static 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)
372 void *ref)
373{ 364{
374 zfcp_erp_port_block(port, clear); 365 zfcp_erp_port_block(port, clear);
375 zfcp_scsi_schedule_rport_block(port); 366 zfcp_scsi_schedule_rport_block(port);
376 367
377 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 368 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
378 /* ensure propagation of failed status to new devices */ 369 /* ensure propagation of failed status to new devices */
379 zfcp_erp_port_failed(port, "erpreo1", NULL); 370 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
380 return -EIO; 371 return -EIO;
381 } 372 }
382 373
383 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT, 374 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
384 port->adapter, port, NULL, id, ref); 375 port->adapter, port, NULL, id, 0);
385} 376}
386 377
387/** 378/**
388 * zfcp_erp_port_reopen - trigger remote port recovery 379 * zfcp_erp_port_reopen - trigger remote port recovery
389 * @port: port to recover 380 * @port: port to recover
390 * @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.
391 * 383 *
392 * Returns 0 if recovery has been triggered, < 0 if not. 384 * Returns 0 if recovery has been triggered, < 0 if not.
393 */ 385 */
394int 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)
395{ 387{
396 int retval; 388 int retval;
397 unsigned long flags; 389 unsigned long flags;
398 struct zfcp_adapter *adapter = port->adapter; 390 struct zfcp_adapter *adapter = port->adapter;
399 391
400 write_lock_irqsave(&adapter->erp_lock, flags); 392 write_lock_irqsave(&adapter->erp_lock, flags);
401 retval = _zfcp_erp_port_reopen(port, clear, id, ref); 393 retval = _zfcp_erp_port_reopen(port, clear, id);
402 write_unlock_irqrestore(&adapter->erp_lock, flags); 394 write_unlock_irqrestore(&adapter->erp_lock, flags);
403 395
404 return retval; 396 return retval;
405} 397}
406 398
407static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask) 399static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
408{ 400{
409 zfcp_erp_modify_unit_status(unit, "erublk1", NULL, 401 zfcp_erp_clear_lun_status(sdev,
410 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 402 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
411 ZFCP_CLEAR);
412} 403}
413 404
414static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id, 405static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
415 void *ref) 406 u32 act_status)
416{ 407{
417 struct zfcp_adapter *adapter = unit->port->adapter; 408 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
409 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
418 410
419 zfcp_erp_unit_block(unit, clear); 411 zfcp_erp_lun_block(sdev, clear);
420 412
421 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) 413 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
422 return; 414 return;
423 415
424 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT, 416 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
425 adapter, unit->port, unit, id, ref); 417 zfcp_sdev->port, sdev, id, act_status);
426} 418}
427 419
428/** 420/**
429 * zfcp_erp_unit_reopen - initiate reopen of a unit 421 * zfcp_erp_lun_reopen - initiate reopen of a LUN
430 * @unit: unit to be reopened 422 * @sdev: SCSI device / LUN to be reopened
431 * @clear_mask: specifies flags in unit status to be cleared 423 * @clear_mask: specifies flags in LUN status to be cleared
424 * @id: Id for debug trace event.
425 *
432 * Return: 0 on success, < 0 on error 426 * Return: 0 on success, < 0 on error
433 */ 427 */
434void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id, 428void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
435 void *ref)
436{ 429{
437 unsigned long flags; 430 unsigned long flags;
438 struct zfcp_port *port = unit->port; 431 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
432 struct zfcp_port *port = zfcp_sdev->port;
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_unit_reopen(unit, clear, id, ref); 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
446static int status_change_set(unsigned long mask, atomic_t *status) 440/**
441 * zfcp_erp_lun_shutdown - Shutdown LUN
442 * @sdev: SCSI device / LUN to shut down.
443 * @clear: Status flags to clear.
444 * @id: Id for debug trace event.
445 */
446void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
447{ 447{
448 return (atomic_read(status) ^ mask) & mask; 448 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
449 zfcp_erp_lun_reopen(sdev, clear | flags, id);
449} 450}
450 451
451static int status_change_clear(unsigned long mask, atomic_t *status) 452/**
453 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
454 * @sdev: SCSI device / LUN to shut down.
455 * @id: Id for debug trace event.
456 *
457 * Do not acquire a reference for the LUN when creating the ERP
458 * action. It is safe, because this function waits for the ERP to
459 * complete first. This allows to shutdown the LUN, even when the SCSI
460 * device is in the state SDEV_DEL when scsi_device_get will fail.
461 */
462void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
452{ 463{
453 return atomic_read(status) & mask; 464 unsigned long flags;
465 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
466 struct zfcp_port *port = zfcp_sdev->port;
467 struct zfcp_adapter *adapter = port->adapter;
468 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
469
470 write_lock_irqsave(&adapter->erp_lock, flags);
471 _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
472 write_unlock_irqrestore(&adapter->erp_lock, flags);
473
474 zfcp_erp_wait(adapter);
475}
476
477static int status_change_set(unsigned long mask, atomic_t *status)
478{
479 return (atomic_read(status) ^ mask) & mask;
454} 480}
455 481
456static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter) 482static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
457{ 483{
458 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) 484 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
459 zfcp_dbf_rec_adapter("eraubl1", NULL, adapter->dbf); 485 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
460 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status); 486 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
461} 487}
462 488
463static void zfcp_erp_port_unblock(struct zfcp_port *port) 489static void zfcp_erp_port_unblock(struct zfcp_port *port)
464{ 490{
465 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) 491 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
466 zfcp_dbf_rec_port("erpubl1", NULL, port); 492 zfcp_dbf_rec_run("erpubl1", &port->erp_action);
467 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status); 493 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
468} 494}
469 495
470static void zfcp_erp_unit_unblock(struct zfcp_unit *unit) 496static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
471{ 497{
472 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status)) 498 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
473 zfcp_dbf_rec_unit("eruubl1", NULL, unit); 499
474 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status); 500 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
501 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
502 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
475} 503}
476 504
477static 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)
478{ 506{
479 list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 507 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
480 zfcp_dbf_rec_action("erator1", erp_action); 508 zfcp_dbf_rec_run("erator1", erp_action);
481} 509}
482 510
483static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act) 511static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
@@ -494,11 +522,11 @@ static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
494 if (act->status & (ZFCP_STATUS_ERP_DISMISSED | 522 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
495 ZFCP_STATUS_ERP_TIMEDOUT)) { 523 ZFCP_STATUS_ERP_TIMEDOUT)) {
496 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 524 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
497 zfcp_dbf_rec_action("erscf_1", act); 525 zfcp_dbf_rec_run("erscf_1", act);
498 req->erp_action = NULL; 526 req->erp_action = NULL;
499 } 527 }
500 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 528 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
501 zfcp_dbf_rec_action("erscf_2", act); 529 zfcp_dbf_rec_run("erscf_2", act);
502 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) 530 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
503 act->fsf_req_id = 0; 531 act->fsf_req_id = 0;
504 } else 532 } else
@@ -549,41 +577,40 @@ static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
549} 577}
550 578
551static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, 579static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
552 int clear, char *id, void *ref) 580 int clear, char *id)
553{ 581{
554 struct zfcp_port *port; 582 struct zfcp_port *port;
555 583
556 read_lock(&adapter->port_list_lock); 584 read_lock(&adapter->port_list_lock);
557 list_for_each_entry(port, &adapter->port_list, list) 585 list_for_each_entry(port, &adapter->port_list, list)
558 _zfcp_erp_port_reopen(port, clear, id, ref); 586 _zfcp_erp_port_reopen(port, clear, id);
559 read_unlock(&adapter->port_list_lock); 587 read_unlock(&adapter->port_list_lock);
560} 588}
561 589
562static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, 590static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
563 char *id, void *ref) 591 char *id)
564{ 592{
565 struct zfcp_unit *unit; 593 struct scsi_device *sdev;
566 594
567 read_lock(&port->unit_list_lock); 595 shost_for_each_device(sdev, port->adapter->scsi_host)
568 list_for_each_entry(unit, &port->unit_list, list) 596 if (sdev_to_zfcp(sdev)->port == port)
569 _zfcp_erp_unit_reopen(unit, clear, id, ref); 597 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
570 read_unlock(&port->unit_list_lock);
571} 598}
572 599
573static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act) 600static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
574{ 601{
575 switch (act->action) { 602 switch (act->action) {
576 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 603 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
577 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL); 604 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
578 break; 605 break;
579 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 606 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
580 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL); 607 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
581 break; 608 break;
582 case ZFCP_ERP_ACTION_REOPEN_PORT: 609 case ZFCP_ERP_ACTION_REOPEN_PORT:
583 _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL); 610 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
584 break; 611 break;
585 case ZFCP_ERP_ACTION_REOPEN_UNIT: 612 case ZFCP_ERP_ACTION_REOPEN_LUN:
586 _zfcp_erp_unit_reopen(act->unit, 0, "ersff_4", NULL); 613 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
587 break; 614 break;
588 } 615 }
589} 616}
@@ -592,13 +619,13 @@ static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
592{ 619{
593 switch (act->action) { 620 switch (act->action) {
594 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 621 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
595 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL); 622 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
596 break; 623 break;
597 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 624 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
598 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL); 625 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
599 break; 626 break;
600 case ZFCP_ERP_ACTION_REOPEN_PORT: 627 case ZFCP_ERP_ACTION_REOPEN_PORT:
601 _zfcp_erp_unit_reopen_all(act->port, 0, "ersfs_3", NULL); 628 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
602 break; 629 break;
603 } 630 }
604} 631}
@@ -617,17 +644,6 @@ static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
617 read_unlock_irqrestore(&adapter->erp_lock, flags); 644 read_unlock_irqrestore(&adapter->erp_lock, flags);
618} 645}
619 646
620static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
621{
622 struct zfcp_qdio *qdio = act->adapter->qdio;
623
624 if (zfcp_qdio_open(qdio))
625 return ZFCP_ERP_FAILED;
626 init_waitqueue_head(&qdio->req_q_wq);
627 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
628 return ZFCP_ERP_SUCCEEDED;
629}
630
631static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter) 647static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
632{ 648{
633 struct zfcp_port *port; 649 struct zfcp_port *port;
@@ -635,7 +651,7 @@ static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
635 adapter->peer_d_id); 651 adapter->peer_d_id);
636 if (IS_ERR(port)) /* error or port already attached */ 652 if (IS_ERR(port)) /* error or port already attached */
637 return; 653 return;
638 _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL); 654 _zfcp_erp_port_reopen(port, 0, "ereptp1");
639} 655}
640 656
641static 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)
@@ -658,10 +674,8 @@ static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
658 return ZFCP_ERP_FAILED; 674 return ZFCP_ERP_FAILED;
659 } 675 }
660 676
661 zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
662 wait_event(adapter->erp_ready_wq, 677 wait_event(adapter->erp_ready_wq,
663 !list_empty(&adapter->erp_ready_head)); 678 !list_empty(&adapter->erp_ready_head));
664 zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
665 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) 679 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
666 break; 680 break;
667 681
@@ -700,10 +714,10 @@ static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
700 if (ret) 714 if (ret)
701 return ZFCP_ERP_FAILED; 715 return ZFCP_ERP_FAILED;
702 716
703 zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf); 717 zfcp_dbf_rec_run("erasox1", act);
704 wait_event(adapter->erp_ready_wq, 718 wait_event(adapter->erp_ready_wq,
705 !list_empty(&adapter->erp_ready_head)); 719 !list_empty(&adapter->erp_ready_head));
706 zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf); 720 zfcp_dbf_rec_run("erasox2", act);
707 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 721 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
708 return ZFCP_ERP_FAILED; 722 return ZFCP_ERP_FAILED;
709 723
@@ -718,7 +732,7 @@ static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
718 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED) 732 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
719 return ZFCP_ERP_FAILED; 733 return ZFCP_ERP_FAILED;
720 734
721 if (mempool_resize(act->adapter->pool.status_read_data, 735 if (mempool_resize(act->adapter->pool.sr_data,
722 act->adapter->stat_read_buf_num, GFP_KERNEL)) 736 act->adapter->stat_read_buf_num, GFP_KERNEL))
723 return ZFCP_ERP_FAILED; 737 return ZFCP_ERP_FAILED;
724 738
@@ -742,9 +756,8 @@ static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
742 zfcp_fsf_req_dismiss_all(adapter); 756 zfcp_fsf_req_dismiss_all(adapter);
743 adapter->fsf_req_seq_no = 0; 757 adapter->fsf_req_seq_no = 0;
744 zfcp_fc_wka_ports_force_offline(adapter->gs); 758 zfcp_fc_wka_ports_force_offline(adapter->gs);
745 /* all ports and units are closed */ 759 /* all ports and LUNs are closed */
746 zfcp_erp_modify_adapter_status(adapter, "erascl1", NULL, 760 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
747 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
748 761
749 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 762 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
750 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status); 763 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
@@ -754,7 +767,7 @@ static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
754{ 767{
755 struct zfcp_adapter *adapter = act->adapter; 768 struct zfcp_adapter *adapter = act->adapter;
756 769
757 if (zfcp_erp_adapter_strategy_open_qdio(act)) { 770 if (zfcp_qdio_open(adapter->qdio)) {
758 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 771 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
759 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 772 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
760 &adapter->status); 773 &adapter->status);
@@ -861,7 +874,7 @@ static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
861 struct zfcp_port *port = act->port; 874 struct zfcp_port *port = act->port;
862 875
863 if (port->wwpn != adapter->peer_wwpn) { 876 if (port->wwpn != adapter->peer_wwpn) {
864 zfcp_erp_port_failed(port, "eroptp1", NULL); 877 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
865 return ZFCP_ERP_FAILED; 878 return ZFCP_ERP_FAILED;
866 } 879 }
867 port->d_id = adapter->peer_d_id; 880 port->d_id = adapter->peer_d_id;
@@ -933,82 +946,87 @@ close_init_done:
933 return zfcp_erp_port_strategy_open_common(erp_action); 946 return zfcp_erp_port_strategy_open_common(erp_action);
934} 947}
935 948
936static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit) 949static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
937{ 950{
951 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
952
938 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | 953 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
939 ZFCP_STATUS_UNIT_SHARED | 954 ZFCP_STATUS_LUN_SHARED | ZFCP_STATUS_LUN_READONLY,
940 ZFCP_STATUS_UNIT_READONLY, 955 &zfcp_sdev->status);
941 &unit->status);
942} 956}
943 957
944static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action) 958static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
945{ 959{
946 int retval = zfcp_fsf_close_unit(erp_action); 960 int retval = zfcp_fsf_close_lun(erp_action);
947 if (retval == -ENOMEM) 961 if (retval == -ENOMEM)
948 return ZFCP_ERP_NOMEM; 962 return ZFCP_ERP_NOMEM;
949 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING; 963 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
950 if (retval) 964 if (retval)
951 return ZFCP_ERP_FAILED; 965 return ZFCP_ERP_FAILED;
952 return ZFCP_ERP_CONTINUES; 966 return ZFCP_ERP_CONTINUES;
953} 967}
954 968
955static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action) 969static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
956{ 970{
957 int retval = zfcp_fsf_open_unit(erp_action); 971 int retval = zfcp_fsf_open_lun(erp_action);
958 if (retval == -ENOMEM) 972 if (retval == -ENOMEM)
959 return ZFCP_ERP_NOMEM; 973 return ZFCP_ERP_NOMEM;
960 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING; 974 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
961 if (retval) 975 if (retval)
962 return ZFCP_ERP_FAILED; 976 return ZFCP_ERP_FAILED;
963 return ZFCP_ERP_CONTINUES; 977 return ZFCP_ERP_CONTINUES;
964} 978}
965 979
966static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action) 980static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
967{ 981{
968 struct zfcp_unit *unit = erp_action->unit; 982 struct scsi_device *sdev = erp_action->sdev;
983 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
969 984
970 switch (erp_action->step) { 985 switch (erp_action->step) {
971 case ZFCP_ERP_STEP_UNINITIALIZED: 986 case ZFCP_ERP_STEP_UNINITIALIZED:
972 zfcp_erp_unit_strategy_clearstati(unit); 987 zfcp_erp_lun_strategy_clearstati(sdev);
973 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 988 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
974 return zfcp_erp_unit_strategy_close(erp_action); 989 return zfcp_erp_lun_strategy_close(erp_action);
975 /* already closed, fall through */ 990 /* already closed, fall through */
976 case ZFCP_ERP_STEP_UNIT_CLOSING: 991 case ZFCP_ERP_STEP_LUN_CLOSING:
977 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 992 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
978 return ZFCP_ERP_FAILED; 993 return ZFCP_ERP_FAILED;
979 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 994 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
980 return ZFCP_ERP_EXIT; 995 return ZFCP_ERP_EXIT;
981 return zfcp_erp_unit_strategy_open(erp_action); 996 return zfcp_erp_lun_strategy_open(erp_action);
982 997
983 case ZFCP_ERP_STEP_UNIT_OPENING: 998 case ZFCP_ERP_STEP_LUN_OPENING:
984 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 999 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
985 return ZFCP_ERP_SUCCEEDED; 1000 return ZFCP_ERP_SUCCEEDED;
986 } 1001 }
987 return ZFCP_ERP_FAILED; 1002 return ZFCP_ERP_FAILED;
988} 1003}
989 1004
990static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result) 1005static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
991{ 1006{
1007 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1008
992 switch (result) { 1009 switch (result) {
993 case ZFCP_ERP_SUCCEEDED : 1010 case ZFCP_ERP_SUCCEEDED :
994 atomic_set(&unit->erp_counter, 0); 1011 atomic_set(&zfcp_sdev->erp_counter, 0);
995 zfcp_erp_unit_unblock(unit); 1012 zfcp_erp_lun_unblock(sdev);
996 break; 1013 break;
997 case ZFCP_ERP_FAILED : 1014 case ZFCP_ERP_FAILED :
998 atomic_inc(&unit->erp_counter); 1015 atomic_inc(&zfcp_sdev->erp_counter);
999 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) { 1016 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1000 dev_err(&unit->port->adapter->ccw_device->dev, 1017 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1001 "ERP failed for unit 0x%016Lx on " 1018 "ERP failed for LUN 0x%016Lx on "
1002 "port 0x%016Lx\n", 1019 "port 0x%016Lx\n",
1003 (unsigned long long)unit->fcp_lun, 1020 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1004 (unsigned long long)unit->port->wwpn); 1021 (unsigned long long)zfcp_sdev->port->wwpn);
1005 zfcp_erp_unit_failed(unit, "erusck1", NULL); 1022 zfcp_erp_set_lun_status(sdev,
1023 ZFCP_STATUS_COMMON_ERP_FAILED);
1006 } 1024 }
1007 break; 1025 break;
1008 } 1026 }
1009 1027
1010 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1028 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1011 zfcp_erp_unit_block(unit, 0); 1029 zfcp_erp_lun_block(sdev, 0);
1012 result = ZFCP_ERP_EXIT; 1030 result = ZFCP_ERP_EXIT;
1013 } 1031 }
1014 return result; 1032 return result;
@@ -1032,7 +1050,8 @@ static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1032 dev_err(&port->adapter->ccw_device->dev, 1050 dev_err(&port->adapter->ccw_device->dev,
1033 "ERP failed for remote port 0x%016Lx\n", 1051 "ERP failed for remote port 0x%016Lx\n",
1034 (unsigned long long)port->wwpn); 1052 (unsigned long long)port->wwpn);
1035 zfcp_erp_port_failed(port, "erpsck1", NULL); 1053 zfcp_erp_set_port_status(port,
1054 ZFCP_STATUS_COMMON_ERP_FAILED);
1036 } 1055 }
1037 break; 1056 break;
1038 } 1057 }
@@ -1059,7 +1078,8 @@ static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1059 dev_err(&adapter->ccw_device->dev, 1078 dev_err(&adapter->ccw_device->dev,
1060 "ERP cannot recover an error " 1079 "ERP cannot recover an error "
1061 "on the FCP device\n"); 1080 "on the FCP device\n");
1062 zfcp_erp_adapter_failed(adapter, "erasck1", NULL); 1081 zfcp_erp_set_adapter_status(adapter,
1082 ZFCP_STATUS_COMMON_ERP_FAILED);
1063 } 1083 }
1064 break; 1084 break;
1065 } 1085 }
@@ -1076,12 +1096,12 @@ static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1076{ 1096{
1077 struct zfcp_adapter *adapter = erp_action->adapter; 1097 struct zfcp_adapter *adapter = erp_action->adapter;
1078 struct zfcp_port *port = erp_action->port; 1098 struct zfcp_port *port = erp_action->port;
1079 struct zfcp_unit *unit = erp_action->unit; 1099 struct scsi_device *sdev = erp_action->sdev;
1080 1100
1081 switch (erp_action->action) { 1101 switch (erp_action->action) {
1082 1102
1083 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1103 case ZFCP_ERP_ACTION_REOPEN_LUN:
1084 result = zfcp_erp_strategy_check_unit(unit, result); 1104 result = zfcp_erp_strategy_check_lun(sdev, result);
1085 break; 1105 break;
1086 1106
1087 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1107 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
@@ -1116,7 +1136,8 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1116 int action = act->action; 1136 int action = act->action;
1117 struct zfcp_adapter *adapter = act->adapter; 1137 struct zfcp_adapter *adapter = act->adapter;
1118 struct zfcp_port *port = act->port; 1138 struct zfcp_port *port = act->port;
1119 struct zfcp_unit *unit = act->unit; 1139 struct scsi_device *sdev = act->sdev;
1140 struct zfcp_scsi_dev *zfcp_sdev;
1120 u32 erp_status = act->status; 1141 u32 erp_status = act->status;
1121 1142
1122 switch (action) { 1143 switch (action) {
@@ -1124,7 +1145,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1124 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) { 1145 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1125 _zfcp_erp_adapter_reopen(adapter, 1146 _zfcp_erp_adapter_reopen(adapter,
1126 ZFCP_STATUS_COMMON_ERP_FAILED, 1147 ZFCP_STATUS_COMMON_ERP_FAILED,
1127 "ersscg1", NULL); 1148 "ersscg1");
1128 return ZFCP_ERP_EXIT; 1149 return ZFCP_ERP_EXIT;
1129 } 1150 }
1130 break; 1151 break;
@@ -1134,16 +1155,17 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1134 if (zfcp_erp_strat_change_det(&port->status, erp_status)) { 1155 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1135 _zfcp_erp_port_reopen(port, 1156 _zfcp_erp_port_reopen(port,
1136 ZFCP_STATUS_COMMON_ERP_FAILED, 1157 ZFCP_STATUS_COMMON_ERP_FAILED,
1137 "ersscg2", NULL); 1158 "ersscg2");
1138 return ZFCP_ERP_EXIT; 1159 return ZFCP_ERP_EXIT;
1139 } 1160 }
1140 break; 1161 break;
1141 1162
1142 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1163 case ZFCP_ERP_ACTION_REOPEN_LUN:
1143 if (zfcp_erp_strat_change_det(&unit->status, erp_status)) { 1164 zfcp_sdev = sdev_to_zfcp(sdev);
1144 _zfcp_erp_unit_reopen(unit, 1165 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1145 ZFCP_STATUS_COMMON_ERP_FAILED, 1166 _zfcp_erp_lun_reopen(sdev,
1146 "ersscg3", NULL); 1167 ZFCP_STATUS_COMMON_ERP_FAILED,
1168 "ersscg3", 0);
1147 return ZFCP_ERP_EXIT; 1169 return ZFCP_ERP_EXIT;
1148 } 1170 }
1149 break; 1171 break;
@@ -1154,6 +1176,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1154static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 1176static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1155{ 1177{
1156 struct zfcp_adapter *adapter = erp_action->adapter; 1178 struct zfcp_adapter *adapter = erp_action->adapter;
1179 struct zfcp_scsi_dev *zfcp_sdev;
1157 1180
1158 adapter->erp_total_count--; 1181 adapter->erp_total_count--;
1159 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1182 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
@@ -1162,12 +1185,13 @@ static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1162 } 1185 }
1163 1186
1164 list_del(&erp_action->list); 1187 list_del(&erp_action->list);
1165 zfcp_dbf_rec_action("eractd1", erp_action); 1188 zfcp_dbf_rec_run("eractd1", erp_action);
1166 1189
1167 switch (erp_action->action) { 1190 switch (erp_action->action) {
1168 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1191 case ZFCP_ERP_ACTION_REOPEN_LUN:
1192 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1169 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 1193 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1170 &erp_action->unit->status); 1194 &zfcp_sdev->status);
1171 break; 1195 break;
1172 1196
1173 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1197 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
@@ -1187,11 +1211,12 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1187{ 1211{
1188 struct zfcp_adapter *adapter = act->adapter; 1212 struct zfcp_adapter *adapter = act->adapter;
1189 struct zfcp_port *port = act->port; 1213 struct zfcp_port *port = act->port;
1190 struct zfcp_unit *unit = act->unit; 1214 struct scsi_device *sdev = act->sdev;
1191 1215
1192 switch (act->action) { 1216 switch (act->action) {
1193 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1217 case ZFCP_ERP_ACTION_REOPEN_LUN:
1194 put_device(&unit->dev); 1218 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1219 scsi_device_put(sdev);
1195 break; 1220 break;
1196 1221
1197 case ZFCP_ERP_ACTION_REOPEN_PORT: 1222 case ZFCP_ERP_ACTION_REOPEN_PORT:
@@ -1206,8 +1231,10 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1206 if (result == ZFCP_ERP_SUCCEEDED) { 1231 if (result == ZFCP_ERP_SUCCEEDED) {
1207 register_service_level(&adapter->service_level); 1232 register_service_level(&adapter->service_level);
1208 queue_work(adapter->work_queue, &adapter->scan_work); 1233 queue_work(adapter->work_queue, &adapter->scan_work);
1234 queue_work(adapter->work_queue, &adapter->ns_up_work);
1209 } else 1235 } else
1210 unregister_service_level(&adapter->service_level); 1236 unregister_service_level(&adapter->service_level);
1237
1211 kref_put(&adapter->ref, zfcp_adapter_release); 1238 kref_put(&adapter->ref, zfcp_adapter_release);
1212 break; 1239 break;
1213 } 1240 }
@@ -1222,8 +1249,8 @@ static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1222 return zfcp_erp_port_forced_strategy(erp_action); 1249 return zfcp_erp_port_forced_strategy(erp_action);
1223 case ZFCP_ERP_ACTION_REOPEN_PORT: 1250 case ZFCP_ERP_ACTION_REOPEN_PORT:
1224 return zfcp_erp_port_strategy(erp_action); 1251 return zfcp_erp_port_strategy(erp_action);
1225 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1252 case ZFCP_ERP_ACTION_REOPEN_LUN:
1226 return zfcp_erp_unit_strategy(erp_action); 1253 return zfcp_erp_lun_strategy(erp_action);
1227 } 1254 }
1228 return ZFCP_ERP_FAILED; 1255 return ZFCP_ERP_FAILED;
1229} 1256}
@@ -1267,7 +1294,7 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1267 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1294 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1268 } 1295 }
1269 if (adapter->erp_total_count == adapter->erp_low_mem_count) 1296 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1270 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL); 1297 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1271 else { 1298 else {
1272 zfcp_erp_strategy_memwait(erp_action); 1299 zfcp_erp_strategy_memwait(erp_action);
1273 retval = ZFCP_ERP_CONTINUES; 1300 retval = ZFCP_ERP_CONTINUES;
@@ -1311,11 +1338,9 @@ static int zfcp_erp_thread(void *data)
1311 unsigned long flags; 1338 unsigned long flags;
1312 1339
1313 for (;;) { 1340 for (;;) {
1314 zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
1315 wait_event_interruptible(adapter->erp_ready_wq, 1341 wait_event_interruptible(adapter->erp_ready_wq,
1316 !list_empty(&adapter->erp_ready_head) || 1342 !list_empty(&adapter->erp_ready_head) ||
1317 kthread_should_stop()); 1343 kthread_should_stop());
1318 zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
1319 1344
1320 if (kthread_should_stop()) 1345 if (kthread_should_stop())
1321 break; 1346 break;
@@ -1376,42 +1401,6 @@ void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1376} 1401}
1377 1402
1378/** 1403/**
1379 * zfcp_erp_adapter_failed - Set adapter status to failed.
1380 * @adapter: Failed adapter.
1381 * @id: Event id for debug trace.
1382 * @ref: Reference for debug trace.
1383 */
1384void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, char *id, void *ref)
1385{
1386 zfcp_erp_modify_adapter_status(adapter, id, ref,
1387 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1388}
1389
1390/**
1391 * zfcp_erp_port_failed - Set port status to failed.
1392 * @port: Failed port.
1393 * @id: Event id for debug trace.
1394 * @ref: Reference for debug trace.
1395 */
1396void zfcp_erp_port_failed(struct zfcp_port *port, char *id, void *ref)
1397{
1398 zfcp_erp_modify_port_status(port, id, ref,
1399 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1400}
1401
1402/**
1403 * zfcp_erp_unit_failed - Set unit status to failed.
1404 * @unit: Failed unit.
1405 * @id: Event id for debug trace.
1406 * @ref: Reference for debug trace.
1407 */
1408void zfcp_erp_unit_failed(struct zfcp_unit *unit, char *id, void *ref)
1409{
1410 zfcp_erp_modify_unit_status(unit, id, ref,
1411 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1412}
1413
1414/**
1415 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1404 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1416 * @adapter: adapter for which to wait for completion of its error recovery 1405 * @adapter: adapter for which to wait for completion of its error recovery
1417 */ 1406 */
@@ -1423,210 +1412,148 @@ void zfcp_erp_wait(struct zfcp_adapter *adapter)
1423} 1412}
1424 1413
1425/** 1414/**
1426 * zfcp_erp_modify_adapter_status - change adapter status bits 1415 * zfcp_erp_set_adapter_status - set adapter status bits
1427 * @adapter: adapter to change the status 1416 * @adapter: adapter to change the status
1428 * @id: id for the debug trace
1429 * @ref: reference for the debug trace
1430 * @mask: status bits to change 1417 * @mask: status bits to change
1431 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1432 * 1418 *
1433 * Changes in common status bits are propagated to attached ports and units. 1419 * Changes in common status bits are propagated to attached ports and LUNs.
1434 */ 1420 */
1435void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, char *id, 1421void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1436 void *ref, u32 mask, int set_or_clear)
1437{ 1422{
1438 struct zfcp_port *port; 1423 struct zfcp_port *port;
1424 struct scsi_device *sdev;
1439 unsigned long flags; 1425 unsigned long flags;
1440 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1426 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1441 1427
1442 if (set_or_clear == ZFCP_SET) { 1428 atomic_set_mask(mask, &adapter->status);
1443 if (status_change_set(mask, &adapter->status))
1444 zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
1445 atomic_set_mask(mask, &adapter->status);
1446 } else {
1447 if (status_change_clear(mask, &adapter->status))
1448 zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
1449 atomic_clear_mask(mask, &adapter->status);
1450 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1451 atomic_set(&adapter->erp_counter, 0);
1452 }
1453 1429
1454 if (common_mask) { 1430 if (!common_mask)
1455 read_lock_irqsave(&adapter->port_list_lock, flags); 1431 return;
1456 list_for_each_entry(port, &adapter->port_list, list) 1432
1457 zfcp_erp_modify_port_status(port, id, ref, common_mask, 1433 read_lock_irqsave(&adapter->port_list_lock, flags);
1458 set_or_clear); 1434 list_for_each_entry(port, &adapter->port_list, list)
1459 read_unlock_irqrestore(&adapter->port_list_lock, flags); 1435 atomic_set_mask(common_mask, &port->status);
1460 } 1436 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1437
1438 shost_for_each_device(sdev, adapter->scsi_host)
1439 atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1461} 1440}
1462 1441
1463/** 1442/**
1464 * zfcp_erp_modify_port_status - change port status bits 1443 * zfcp_erp_clear_adapter_status - clear adapter status bits
1465 * @port: port to change the status bits 1444 * @adapter: adapter to change the status
1466 * @id: id for the debug trace
1467 * @ref: reference for the debug trace
1468 * @mask: status bits to change 1445 * @mask: status bits to change
1469 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1470 * 1446 *
1471 * Changes in common status bits are propagated to attached units. 1447 * Changes in common status bits are propagated to attached ports and LUNs.
1472 */ 1448 */
1473void zfcp_erp_modify_port_status(struct zfcp_port *port, char *id, void *ref, 1449void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1474 u32 mask, int set_or_clear)
1475{ 1450{
1476 struct zfcp_unit *unit; 1451 struct zfcp_port *port;
1452 struct scsi_device *sdev;
1477 unsigned long flags; 1453 unsigned long flags;
1478 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1454 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1455 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1479 1456
1480 if (set_or_clear == ZFCP_SET) { 1457 atomic_clear_mask(mask, &adapter->status);
1481 if (status_change_set(mask, &port->status)) 1458
1482 zfcp_dbf_rec_port(id, ref, port); 1459 if (!common_mask)
1483 atomic_set_mask(mask, &port->status); 1460 return;
1484 } else { 1461
1485 if (status_change_clear(mask, &port->status)) 1462 if (clear_counter)
1486 zfcp_dbf_rec_port(id, ref, port); 1463 atomic_set(&adapter->erp_counter, 0);
1487 atomic_clear_mask(mask, &port->status); 1464
1488 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1465 read_lock_irqsave(&adapter->port_list_lock, flags);
1466 list_for_each_entry(port, &adapter->port_list, list) {
1467 atomic_clear_mask(common_mask, &port->status);
1468 if (clear_counter)
1489 atomic_set(&port->erp_counter, 0); 1469 atomic_set(&port->erp_counter, 0);
1490 } 1470 }
1471 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1491 1472
1492 if (common_mask) { 1473 shost_for_each_device(sdev, adapter->scsi_host) {
1493 read_lock_irqsave(&port->unit_list_lock, flags); 1474 atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1494 list_for_each_entry(unit, &port->unit_list, list) 1475 if (clear_counter)
1495 zfcp_erp_modify_unit_status(unit, id, ref, common_mask, 1476 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1496 set_or_clear);
1497 read_unlock_irqrestore(&port->unit_list_lock, flags);
1498 } 1477 }
1499} 1478}
1500 1479
1501/** 1480/**
1502 * zfcp_erp_modify_unit_status - change unit status bits 1481 * zfcp_erp_set_port_status - set port status bits
1503 * @unit: unit to change the status bits 1482 * @port: port to change the status
1504 * @id: id for the debug trace
1505 * @ref: reference for the debug trace
1506 * @mask: status bits to change 1483 * @mask: status bits to change
1507 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR 1484 *
1508 */ 1485 * Changes in common status bits are propagated to attached LUNs.
1509void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, char *id, void *ref,
1510 u32 mask, int set_or_clear)
1511{
1512 if (set_or_clear == ZFCP_SET) {
1513 if (status_change_set(mask, &unit->status))
1514 zfcp_dbf_rec_unit(id, ref, unit);
1515 atomic_set_mask(mask, &unit->status);
1516 } else {
1517 if (status_change_clear(mask, &unit->status))
1518 zfcp_dbf_rec_unit(id, ref, unit);
1519 atomic_clear_mask(mask, &unit->status);
1520 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1521 atomic_set(&unit->erp_counter, 0);
1522 }
1523 }
1524}
1525
1526/**
1527 * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
1528 * @port: The "boxed" port.
1529 * @id: The debug trace id.
1530 * @id: Reference for the debug trace.
1531 */ 1486 */
1532void zfcp_erp_port_boxed(struct zfcp_port *port, char *id, void *ref) 1487void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1533{ 1488{
1534 zfcp_erp_modify_port_status(port, id, ref, 1489 struct scsi_device *sdev;
1535 ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET); 1490 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1536 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1537}
1538 1491
1539/** 1492 atomic_set_mask(mask, &port->status);
1540 * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
1541 * @port: The "boxed" unit.
1542 * @id: The debug trace id.
1543 * @id: Reference for the debug trace.
1544 */
1545void zfcp_erp_unit_boxed(struct zfcp_unit *unit, char *id, void *ref)
1546{
1547 zfcp_erp_modify_unit_status(unit, id, ref,
1548 ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1549 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1550}
1551 1493
1552/** 1494 if (!common_mask)
1553 * zfcp_erp_port_access_denied - Adapter denied access to port. 1495 return;
1554 * @port: port where access has been denied 1496
1555 * @id: id for debug trace 1497 shost_for_each_device(sdev, port->adapter->scsi_host)
1556 * @ref: reference for debug trace 1498 if (sdev_to_zfcp(sdev)->port == port)
1557 * 1499 atomic_set_mask(common_mask,
1558 * Since the adapter has denied access, stop using the port and the 1500 &sdev_to_zfcp(sdev)->status);
1559 * attached units.
1560 */
1561void zfcp_erp_port_access_denied(struct zfcp_port *port, char *id, void *ref)
1562{
1563 zfcp_erp_modify_port_status(port, id, ref,
1564 ZFCP_STATUS_COMMON_ERP_FAILED |
1565 ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1566} 1501}
1567 1502
1568/** 1503/**
1569 * zfcp_erp_unit_access_denied - Adapter denied access to unit. 1504 * zfcp_erp_clear_port_status - clear port status bits
1570 * @unit: unit where access has been denied 1505 * @port: adapter to change the status
1571 * @id: id for debug trace 1506 * @mask: status bits to change
1572 * @ref: reference for debug trace
1573 * 1507 *
1574 * Since the adapter has denied access, stop using the unit. 1508 * Changes in common status bits are propagated to attached LUNs.
1575 */ 1509 */
1576void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, char *id, void *ref) 1510void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1577{ 1511{
1578 zfcp_erp_modify_unit_status(unit, id, ref, 1512 struct scsi_device *sdev;
1579 ZFCP_STATUS_COMMON_ERP_FAILED | 1513 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1580 ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET); 1514 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1581}
1582 1515
1583static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, char *id, 1516 atomic_clear_mask(mask, &port->status);
1584 void *ref) 1517
1585{ 1518 if (!common_mask)
1586 int status = atomic_read(&unit->status);
1587 if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1588 ZFCP_STATUS_COMMON_ACCESS_BOXED)))
1589 return; 1519 return;
1590 1520
1591 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1521 if (clear_counter)
1522 atomic_set(&port->erp_counter, 0);
1523
1524 shost_for_each_device(sdev, port->adapter->scsi_host)
1525 if (sdev_to_zfcp(sdev)->port == port) {
1526 atomic_clear_mask(common_mask,
1527 &sdev_to_zfcp(sdev)->status);
1528 if (clear_counter)
1529 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1530 }
1592} 1531}
1593 1532
1594static void zfcp_erp_port_access_changed(struct zfcp_port *port, char *id, 1533/**
1595 void *ref) 1534 * zfcp_erp_set_lun_status - set lun status bits
1535 * @sdev: SCSI device / lun to set the status bits
1536 * @mask: status bits to change
1537 */
1538void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1596{ 1539{
1597 struct zfcp_unit *unit; 1540 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1598 unsigned long flags;
1599 int status = atomic_read(&port->status);
1600
1601 if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1602 ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
1603 read_lock_irqsave(&port->unit_list_lock, flags);
1604 list_for_each_entry(unit, &port->unit_list, list)
1605 zfcp_erp_unit_access_changed(unit, id, ref);
1606 read_unlock_irqrestore(&port->unit_list_lock, flags);
1607 return;
1608 }
1609 1541
1610 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1542 atomic_set_mask(mask, &zfcp_sdev->status);
1611} 1543}
1612 1544
1613/** 1545/**
1614 * zfcp_erp_adapter_access_changed - Process change in adapter ACT 1546 * zfcp_erp_clear_lun_status - clear lun status bits
1615 * @adapter: Adapter where the Access Control Table (ACT) changed 1547 * @sdev: SCSi device / lun to clear the status bits
1616 * @id: Id for debug trace 1548 * @mask: status bits to change
1617 * @ref: Reference for debug trace
1618 */ 1549 */
1619void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, char *id, 1550void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1620 void *ref)
1621{ 1551{
1622 unsigned long flags; 1552 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1623 struct zfcp_port *port;
1624 1553
1625 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 1554 atomic_clear_mask(mask, &zfcp_sdev->status);
1626 return;
1627 1555
1628 read_lock_irqsave(&adapter->port_list_lock, flags); 1556 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1629 list_for_each_entry(port, &adapter->port_list, list) 1557 atomic_set(&zfcp_sdev->erp_counter, 0);
1630 zfcp_erp_port_access_changed(port, id, ref);
1631 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1632} 1558}
1559
generated by cgit v1.2.2 (git 2.25.0) at 2025-07-31 00:00:03 -0400