aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/s390/cio/device_pgid.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/s390/cio/device_pgid.c')
-rw-r--r--drivers/s390/cio/device_pgid.c876
1 files changed, 371 insertions, 505 deletions
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index cb27bd4cc231..ce493144b054 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -1,594 +1,460 @@
1/* 1/*
2 * drivers/s390/cio/device_pgid.c 2 * CCW device PGID and path verification I/O handling.
3 * 3 *
4 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, 4 * Copyright IBM Corp. 2002,2009
5 * IBM Corporation 5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
6 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com) 6 * Martin Schwidefsky <schwidefsky@de.ibm.com>
7 * Martin Schwidefsky (schwidefsky@de.ibm.com) 7 * Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
8 *
9 * Path Group ID functions.
10 */ 8 */
11 9
12#include <linux/module.h> 10#include <linux/kernel.h>
13#include <linux/init.h> 11#include <linux/string.h>
14 12#include <linux/types.h>
13#include <linux/errno.h>
14#include <linux/bitops.h>
15#include <asm/ccwdev.h> 15#include <asm/ccwdev.h>
16#include <asm/cio.h> 16#include <asm/cio.h>
17#include <asm/delay.h>
18#include <asm/lowcore.h>
19 17
20#include "cio.h" 18#include "cio.h"
21#include "cio_debug.h" 19#include "cio_debug.h"
22#include "css.h"
23#include "device.h" 20#include "device.h"
24#include "ioasm.h"
25#include "io_sch.h" 21#include "io_sch.h"
26 22
23#define PGID_RETRIES 5
24#define PGID_TIMEOUT (10 * HZ)
25
27/* 26/*
28 * Helper function called from interrupt context to decide whether an 27 * Process path verification data and report result.
29 * operation should be tried again.
30 */ 28 */
31static int __ccw_device_should_retry(union scsw *scsw) 29static void verify_done(struct ccw_device *cdev, int rc)
32{ 30{
33 /* CC is only valid if start function bit is set. */ 31 struct subchannel *sch = to_subchannel(cdev->dev.parent);
34 if ((scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && scsw->cmd.cc == 1) 32 struct ccw_dev_id *id = &cdev->private->dev_id;
35 return 1; 33 int mpath = !cdev->private->flags.pgid_single;
36 /* No more activity. For sense and set PGID we stubbornly try again. */ 34 int pgroup = cdev->private->options.pgroup;
37 if (!scsw->cmd.actl) 35
38 return 1; 36 if (rc)
39 return 0; 37 goto out;
38 /* Ensure consistent multipathing state at device and channel. */
39 if (sch->config.mp != mpath) {
40 sch->config.mp = mpath;
41 rc = cio_commit_config(sch);
42 }
43out:
44 CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
45 "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
46 sch->vpm);
47 ccw_device_verify_done(cdev, rc);
40} 48}
41 49
42/* 50/*
43 * Start Sense Path Group ID helper function. Used in ccw_device_recog 51 * Create channel program to perform a NOOP.
44 * and ccw_device_sense_pgid.
45 */ 52 */
46static int 53static void nop_build_cp(struct ccw_device *cdev)
47__ccw_device_sense_pgid_start(struct ccw_device *cdev)
48{ 54{
49 struct subchannel *sch; 55 struct ccw_request *req = &cdev->private->req;
50 struct ccw1 *ccw; 56 struct ccw1 *cp = cdev->private->iccws;
51 int ret; 57
52 int i; 58 cp->cmd_code = CCW_CMD_NOOP;
53 59 cp->cda = 0;
54 sch = to_subchannel(cdev->dev.parent); 60 cp->count = 0;
55 /* Return if we already checked on all paths. */ 61 cp->flags = CCW_FLAG_SLI;
56 if (cdev->private->imask == 0) 62 req->cp = cp;
57 return (sch->lpm == 0) ? -ENODEV : -EACCES;
58 i = 8 - ffs(cdev->private->imask);
59
60 /* Setup sense path group id channel program. */
61 ccw = cdev->private->iccws;
62 ccw->cmd_code = CCW_CMD_SENSE_PGID;
63 ccw->count = sizeof (struct pgid);
64 ccw->flags = CCW_FLAG_SLI;
65
66 /* Reset device status. */
67 memset(&cdev->private->irb, 0, sizeof(struct irb));
68 /* Try on every path. */
69 ret = -ENODEV;
70 while (cdev->private->imask != 0) {
71 /* Try every path multiple times. */
72 ccw->cda = (__u32) __pa (&cdev->private->pgid[i]);
73 if (cdev->private->iretry > 0) {
74 cdev->private->iretry--;
75 /* Reset internal retry indication. */
76 cdev->private->flags.intretry = 0;
77 ret = cio_start (sch, cdev->private->iccws,
78 cdev->private->imask);
79 /* ret is 0, -EBUSY, -EACCES or -ENODEV */
80 if (ret != -EACCES)
81 return ret;
82 CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel "
83 "0.%x.%04x, lpm %02X, became 'not "
84 "operational'\n",
85 cdev->private->dev_id.devno,
86 sch->schid.ssid,
87 sch->schid.sch_no, cdev->private->imask);
88
89 }
90 cdev->private->imask >>= 1;
91 cdev->private->iretry = 5;
92 i++;
93 }
94
95 return ret;
96} 63}
97 64
98void 65/*
99ccw_device_sense_pgid_start(struct ccw_device *cdev) 66 * Perform NOOP on a single path.
67 */
68static void nop_do(struct ccw_device *cdev)
100{ 69{
101 int ret; 70 struct subchannel *sch = to_subchannel(cdev->dev.parent);
102 71 struct ccw_request *req = &cdev->private->req;
103 /* Set a timeout of 60s */ 72
104 ccw_device_set_timeout(cdev, 60*HZ); 73 /* Adjust lpm. */
105 74 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm);
106 cdev->private->state = DEV_STATE_SENSE_PGID; 75 if (!req->lpm)
107 cdev->private->imask = 0x80; 76 goto out_nopath;
108 cdev->private->iretry = 5; 77 nop_build_cp(cdev);
109 memset (&cdev->private->pgid, 0, sizeof (cdev->private->pgid)); 78 ccw_request_start(cdev);
110 ret = __ccw_device_sense_pgid_start(cdev); 79 return;
111 if (ret && ret != -EBUSY) 80
112 ccw_device_sense_pgid_done(cdev, ret); 81out_nopath:
82 verify_done(cdev, sch->vpm ? 0 : -EACCES);
113} 83}
114 84
115/* 85/*
116 * Called from interrupt context to check if a valid answer 86 * Adjust NOOP I/O status.
117 * to Sense Path Group ID was received.
118 */ 87 */
119static int 88static enum io_status nop_filter(struct ccw_device *cdev, void *data,
120__ccw_device_check_sense_pgid(struct ccw_device *cdev) 89 struct irb *irb, enum io_status status)
121{ 90{
122 struct subchannel *sch; 91 /* Only subchannel status might indicate a path error. */
123 struct irb *irb; 92 if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
124 int i; 93 return IO_DONE;
125 94 return status;
126 sch = to_subchannel(cdev->dev.parent);
127 irb = &cdev->private->irb;
128 if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
129 /* Retry Sense PGID if requested. */
130 if (cdev->private->flags.intretry) {
131 cdev->private->flags.intretry = 0;
132 return -EAGAIN;
133 }
134 return -ETIME;
135 }
136 if (irb->esw.esw0.erw.cons &&
137 (irb->ecw[0]&(SNS0_CMD_REJECT|SNS0_INTERVENTION_REQ))) {
138 /*
139 * If the device doesn't support the Sense Path Group ID
140 * command further retries wouldn't help ...
141 */
142 return -EOPNOTSUPP;
143 }
144 if (irb->esw.esw0.erw.cons) {
145 CIO_MSG_EVENT(2, "SNID - device 0.%x.%04x, unit check, "
146 "lpum %02X, cnt %02d, sns : "
147 "%02X%02X%02X%02X %02X%02X%02X%02X ...\n",
148 cdev->private->dev_id.ssid,
149 cdev->private->dev_id.devno,
150 irb->esw.esw0.sublog.lpum,
151 irb->esw.esw0.erw.scnt,
152 irb->ecw[0], irb->ecw[1],
153 irb->ecw[2], irb->ecw[3],
154 irb->ecw[4], irb->ecw[5],
155 irb->ecw[6], irb->ecw[7]);
156 return -EAGAIN;
157 }
158 if (irb->scsw.cmd.cc == 3) {
159 u8 lpm;
160
161 lpm = to_io_private(sch)->orb.cmd.lpm;
162 CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel 0.%x.%04x,"
163 " lpm %02X, became 'not operational'\n",
164 cdev->private->dev_id.devno, sch->schid.ssid,
165 sch->schid.sch_no, lpm);
166 return -EACCES;
167 }
168 i = 8 - ffs(cdev->private->imask);
169 if (cdev->private->pgid[i].inf.ps.state2 == SNID_STATE2_RESVD_ELSE) {
170 CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel 0.%x.%04x "
171 "is reserved by someone else\n",
172 cdev->private->dev_id.devno, sch->schid.ssid,
173 sch->schid.sch_no);
174 return -EUSERS;
175 }
176 return 0;
177} 95}
178 96
179/* 97/*
180 * Got interrupt for Sense Path Group ID. 98 * Process NOOP request result for a single path.
181 */ 99 */
182void 100static void nop_callback(struct ccw_device *cdev, void *data, int rc)
183ccw_device_sense_pgid_irq(struct ccw_device *cdev, enum dev_event dev_event)
184{ 101{
185 struct subchannel *sch; 102 struct subchannel *sch = to_subchannel(cdev->dev.parent);
186 struct irb *irb; 103 struct ccw_request *req = &cdev->private->req;
187 int ret; 104
188 105 if (rc == 0)
189 irb = (struct irb *) __LC_IRB; 106 sch->vpm |= req->lpm;
190 107 else if (rc != -EACCES)
191 if (irb->scsw.cmd.stctl == 108 goto err;
192 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) { 109 req->lpm >>= 1;
193 if (__ccw_device_should_retry(&irb->scsw)) { 110 nop_do(cdev);
194 ret = __ccw_device_sense_pgid_start(cdev); 111 return;
195 if (ret && ret != -EBUSY) 112
196 ccw_device_sense_pgid_done(cdev, ret); 113err:
197 } 114 verify_done(cdev, rc);
198 return;
199 }
200 if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
201 return;
202 sch = to_subchannel(cdev->dev.parent);
203 ret = __ccw_device_check_sense_pgid(cdev);
204 memset(&cdev->private->irb, 0, sizeof(struct irb));
205 switch (ret) {
206 /* 0, -ETIME, -EOPNOTSUPP, -EAGAIN, -EACCES or -EUSERS */
207 case -EOPNOTSUPP: /* Sense Path Group ID not supported */
208 ccw_device_sense_pgid_done(cdev, -EOPNOTSUPP);
209 break;
210 case -ETIME: /* Sense path group id stopped by timeout. */
211 ccw_device_sense_pgid_done(cdev, -ETIME);
212 break;
213 case -EACCES: /* channel is not operational. */
214 sch->lpm &= ~cdev->private->imask;
215 /* Fall through. */
216 case 0: /* Sense Path Group ID successful. */
217 cdev->private->imask >>= 1;
218 cdev->private->iretry = 5;
219 /* Fall through. */
220 case -EAGAIN: /* Try again. */
221 ret = __ccw_device_sense_pgid_start(cdev);
222 if (ret != 0 && ret != -EBUSY)
223 ccw_device_sense_pgid_done(cdev, ret);
224 break;
225 case -EUSERS: /* device is reserved for someone else. */
226 ccw_device_sense_pgid_done(cdev, -EUSERS);
227 break;
228 }
229} 115}
230 116
231/* 117/*
232 * Path Group ID helper function. 118 * Create channel program to perform SET PGID on a single path.
233 */ 119 */
234static int 120static void spid_build_cp(struct ccw_device *cdev, u8 fn)
235__ccw_device_do_pgid(struct ccw_device *cdev, __u8 func)
236{ 121{
237 struct subchannel *sch; 122 struct ccw_request *req = &cdev->private->req;
238 struct ccw1 *ccw; 123 struct ccw1 *cp = cdev->private->iccws;
239 int ret; 124 int i = 8 - ffs(req->lpm);
240 125 struct pgid *pgid = &cdev->private->pgid[i];
241 sch = to_subchannel(cdev->dev.parent); 126
242 127 pgid->inf.fc = fn;
243 /* Setup sense path group id channel program. */ 128 cp->cmd_code = CCW_CMD_SET_PGID;
244 cdev->private->pgid[0].inf.fc = func; 129 cp->cda = (u32) (addr_t) pgid;
245 ccw = cdev->private->iccws; 130 cp->count = sizeof(*pgid);
246 if (cdev->private->flags.pgid_single) 131 cp->flags = CCW_FLAG_SLI;
247 cdev->private->pgid[0].inf.fc |= SPID_FUNC_SINGLE_PATH; 132 req->cp = cp;
248 else
249 cdev->private->pgid[0].inf.fc |= SPID_FUNC_MULTI_PATH;
250 ccw->cmd_code = CCW_CMD_SET_PGID;
251 ccw->cda = (__u32) __pa (&cdev->private->pgid[0]);
252 ccw->count = sizeof (struct pgid);
253 ccw->flags = CCW_FLAG_SLI;
254
255 /* Reset device status. */
256 memset(&cdev->private->irb, 0, sizeof(struct irb));
257
258 /* Try multiple times. */
259 ret = -EACCES;
260 if (cdev->private->iretry > 0) {
261 cdev->private->iretry--;
262 /* Reset internal retry indication. */
263 cdev->private->flags.intretry = 0;
264 ret = cio_start (sch, cdev->private->iccws,
265 cdev->private->imask);
266 /* We expect an interrupt in case of success or busy
267 * indication. */
268 if ((ret == 0) || (ret == -EBUSY))
269 return ret;
270 }
271 /* PGID command failed on this path. */
272 CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel "
273 "0.%x.%04x, lpm %02X, became 'not operational'\n",
274 cdev->private->dev_id.devno, sch->schid.ssid,
275 sch->schid.sch_no, cdev->private->imask);
276 return ret;
277} 133}
278 134
279/* 135/*
280 * Helper function to send a nop ccw down a path. 136 * Perform establish/resign SET PGID on a single path.
281 */ 137 */
282static int __ccw_device_do_nop(struct ccw_device *cdev) 138static void spid_do(struct ccw_device *cdev)
283{ 139{
284 struct subchannel *sch; 140 struct subchannel *sch = to_subchannel(cdev->dev.parent);
285 struct ccw1 *ccw; 141 struct ccw_request *req = &cdev->private->req;
286 int ret; 142 u8 fn;
287 143
288 sch = to_subchannel(cdev->dev.parent); 144 /* Adjust lpm if paths are not set in pam. */
289 145 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam);
290 /* Setup nop channel program. */ 146 if (!req->lpm)
291 ccw = cdev->private->iccws; 147 goto out_nopath;
292 ccw->cmd_code = CCW_CMD_NOOP; 148 /* Channel program setup. */
293 ccw->cda = 0; 149 if (req->lpm & sch->opm)
294 ccw->count = 0; 150 fn = SPID_FUNC_ESTABLISH;
295 ccw->flags = CCW_FLAG_SLI; 151 else
296 152 fn = SPID_FUNC_RESIGN;
297 /* Reset device status. */ 153 if (!cdev->private->flags.pgid_single)
298 memset(&cdev->private->irb, 0, sizeof(struct irb)); 154 fn |= SPID_FUNC_MULTI_PATH;
299 155 spid_build_cp(cdev, fn);
300 /* Try multiple times. */ 156 ccw_request_start(cdev);
301 ret = -EACCES; 157 return;
302 if (cdev->private->iretry > 0) { 158
303 cdev->private->iretry--; 159out_nopath:
304 /* Reset internal retry indication. */ 160 verify_done(cdev, sch->vpm ? 0 : -EACCES);
305 cdev->private->flags.intretry = 0;
306 ret = cio_start (sch, cdev->private->iccws,
307 cdev->private->imask);
308 /* We expect an interrupt in case of success or busy
309 * indication. */
310 if ((ret == 0) || (ret == -EBUSY))
311 return ret;
312 }
313 /* nop command failed on this path. */
314 CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel "
315 "0.%x.%04x, lpm %02X, became 'not operational'\n",
316 cdev->private->dev_id.devno, sch->schid.ssid,
317 sch->schid.sch_no, cdev->private->imask);
318 return ret;
319} 161}
320 162
163static void verify_start(struct ccw_device *cdev);
321 164
322/* 165/*
323 * Called from interrupt context to check if a valid answer 166 * Process SET PGID request result for a single path.
324 * to Set Path Group ID was received.
325 */ 167 */
326static int 168static void spid_callback(struct ccw_device *cdev, void *data, int rc)
327__ccw_device_check_pgid(struct ccw_device *cdev)
328{ 169{
329 struct subchannel *sch; 170 struct subchannel *sch = to_subchannel(cdev->dev.parent);
330 struct irb *irb; 171 struct ccw_request *req = &cdev->private->req;
331 172
332 sch = to_subchannel(cdev->dev.parent); 173 switch (rc) {
333 irb = &cdev->private->irb; 174 case 0:
334 if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) { 175 sch->vpm |= req->lpm & sch->opm;
335 /* Retry Set PGID if requested. */ 176 break;
336 if (cdev->private->flags.intretry) { 177 case -EACCES:
337 cdev->private->flags.intretry = 0; 178 break;
338 return -EAGAIN; 179 case -EOPNOTSUPP:
180 if (!cdev->private->flags.pgid_single) {
181 /* Try without multipathing. */
182 cdev->private->flags.pgid_single = 1;
183 goto out_restart;
339 } 184 }
340 return -ETIME; 185 /* Try without pathgrouping. */
341 } 186 cdev->private->options.pgroup = 0;
342 if (irb->esw.esw0.erw.cons) { 187 goto out_restart;
343 if (irb->ecw[0] & SNS0_CMD_REJECT) 188 default:
344 return -EOPNOTSUPP; 189 goto err;
345 /* Hmm, whatever happened, try again. */
346 CIO_MSG_EVENT(2, "SPID - device 0.%x.%04x, unit check, "
347 "cnt %02d, "
348 "sns : %02X%02X%02X%02X %02X%02X%02X%02X ...\n",
349 cdev->private->dev_id.ssid,
350 cdev->private->dev_id.devno,
351 irb->esw.esw0.erw.scnt,
352 irb->ecw[0], irb->ecw[1],
353 irb->ecw[2], irb->ecw[3],
354 irb->ecw[4], irb->ecw[5],
355 irb->ecw[6], irb->ecw[7]);
356 return -EAGAIN;
357 }
358 if (irb->scsw.cmd.cc == 3) {
359 CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel 0.%x.%04x,"
360 " lpm %02X, became 'not operational'\n",
361 cdev->private->dev_id.devno, sch->schid.ssid,
362 sch->schid.sch_no, cdev->private->imask);
363 return -EACCES;
364 } 190 }
365 return 0; 191 req->lpm >>= 1;
192 spid_do(cdev);
193 return;
194
195out_restart:
196 verify_start(cdev);
197 return;
198err:
199 verify_done(cdev, rc);
200}
201
202static int pgid_cmp(struct pgid *p1, struct pgid *p2)
203{
204 return memcmp((char *) p1 + 1, (char *) p2 + 1,
205 sizeof(struct pgid) - 1);
366} 206}
367 207
368/* 208/*
369 * Called from interrupt context to check the path status after a nop has 209 * Determine pathgroup state from PGID data.
370 * been send.
371 */ 210 */
372static int __ccw_device_check_nop(struct ccw_device *cdev) 211static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
212 int *mismatch, int *reserved, int *reset)
373{ 213{
374 struct subchannel *sch; 214 struct pgid *pgid = &cdev->private->pgid[0];
375 struct irb *irb; 215 struct pgid *first = NULL;
376 216 int lpm;
377 sch = to_subchannel(cdev->dev.parent); 217 int i;
378 irb = &cdev->private->irb; 218
379 if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) { 219 *mismatch = 0;
380 /* Retry NOP if requested. */ 220 *reserved = 0;
381 if (cdev->private->flags.intretry) { 221 *reset = 0;
382 cdev->private->flags.intretry = 0; 222 for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
383 return -EAGAIN; 223 if ((cdev->private->pgid_valid_mask & lpm) == 0)
224 continue;
225 if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
226 *reserved = 1;
227 if (pgid->inf.ps.state1 == SNID_STATE1_RESET) {
228 /* A PGID was reset. */
229 *reset = 1;
230 continue;
384 } 231 }
385 return -ETIME; 232 if (!first) {
386 } 233 first = pgid;
387 if (irb->scsw.cmd.cc == 3) { 234 continue;
388 CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel 0.%x.%04x," 235 }
389 " lpm %02X, became 'not operational'\n", 236 if (pgid_cmp(pgid, first) != 0)
390 cdev->private->dev_id.devno, sch->schid.ssid, 237 *mismatch = 1;
391 sch->schid.sch_no, cdev->private->imask);
392 return -EACCES;
393 } 238 }
394 return 0; 239 if (!first)
240 first = &channel_subsystems[0]->global_pgid;
241 *p = first;
395} 242}
396 243
397static void 244static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
398__ccw_device_verify_start(struct ccw_device *cdev)
399{ 245{
400 struct subchannel *sch; 246 int i;
401 __u8 func; 247
402 int ret; 248 for (i = 0; i < 8; i++)
403 249 memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
404 sch = to_subchannel(cdev->dev.parent); 250}
405 /* Repeat for all paths. */ 251
406 for (; cdev->private->imask; cdev->private->imask >>= 1, 252/*
407 cdev->private->iretry = 5) { 253 * Process SENSE PGID data and report result.
408 if ((cdev->private->imask & sch->schib.pmcw.pam) == 0) 254 */
409 /* Path not available, try next. */ 255static void snid_done(struct ccw_device *cdev, int rc)
410 continue; 256{
411 if (cdev->private->options.pgroup) { 257 struct ccw_dev_id *id = &cdev->private->dev_id;
412 if (sch->opm & cdev->private->imask) 258 struct pgid *pgid;
413 func = SPID_FUNC_ESTABLISH; 259 int mismatch = 0;
414 else 260 int reserved = 0;
415 func = SPID_FUNC_RESIGN; 261 int reset = 0;
416 ret = __ccw_device_do_pgid(cdev, func); 262
417 } else 263 if (rc)
418 ret = __ccw_device_do_nop(cdev); 264 goto out;
419 /* We expect an interrupt in case of success or busy 265 pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
420 * indication. */ 266 if (!mismatch) {
421 if (ret == 0 || ret == -EBUSY) 267 pgid_fill(cdev, pgid);
422 return; 268 cdev->private->flags.pgid_rdy = 1;
423 /* Permanent path failure, try next. */
424 } 269 }
425 /* Done with all paths. */ 270 if (reserved)
426 ccw_device_verify_done(cdev, (sch->vpm != 0) ? 0 : -EACCES); 271 rc = -EUSERS;
272out:
273 CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x mism=%d "
274 "rsvd=%d reset=%d\n", id->ssid, id->devno, rc,
275 cdev->private->pgid_valid_mask, mismatch, reserved,
276 reset);
277 ccw_device_sense_pgid_done(cdev, rc);
427} 278}
428 279
429/* 280/*
430 * Got interrupt for Set Path Group ID. 281 * Create channel program to perform a SENSE PGID on a single path.
431 */ 282 */
432void 283static void snid_build_cp(struct ccw_device *cdev)
433ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
434{ 284{
435 struct subchannel *sch; 285 struct ccw_request *req = &cdev->private->req;
436 struct irb *irb; 286 struct ccw1 *cp = cdev->private->iccws;
437 int ret; 287 int i = 8 - ffs(req->lpm);
288
289 /* Channel program setup. */
290 cp->cmd_code = CCW_CMD_SENSE_PGID;
291 cp->cda = (u32) (addr_t) &cdev->private->pgid[i];
292 cp->count = sizeof(struct pgid);
293 cp->flags = CCW_FLAG_SLI;
294 req->cp = cp;
295}
438 296
439 irb = (struct irb *) __LC_IRB; 297/*
298 * Perform SENSE PGID on a single path.
299 */
300static void snid_do(struct ccw_device *cdev)
301{
302 struct subchannel *sch = to_subchannel(cdev->dev.parent);
303 struct ccw_request *req = &cdev->private->req;
304
305 /* Adjust lpm if paths are not set in pam. */
306 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam);
307 if (!req->lpm)
308 goto out_nopath;
309 snid_build_cp(cdev);
310 ccw_request_start(cdev);
311 return;
312
313out_nopath:
314 snid_done(cdev, cdev->private->pgid_valid_mask ? 0 : -EACCES);
315}
440 316
441 if (irb->scsw.cmd.stctl == 317/*
442 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) { 318 * Process SENSE PGID request result for single path.
443 if (__ccw_device_should_retry(&irb->scsw)) 319 */
444 __ccw_device_verify_start(cdev); 320static void snid_callback(struct ccw_device *cdev, void *data, int rc)
445 return; 321{
446 } 322 struct ccw_request *req = &cdev->private->req;
447 if (ccw_device_accumulate_and_sense(cdev, irb) != 0) 323
448 return; 324 if (rc == 0)
449 sch = to_subchannel(cdev->dev.parent); 325 cdev->private->pgid_valid_mask |= req->lpm;
450 if (cdev->private->options.pgroup) 326 else if (rc != -EACCES)
451 ret = __ccw_device_check_pgid(cdev); 327 goto err;
452 else 328 req->lpm >>= 1;
453 ret = __ccw_device_check_nop(cdev); 329 snid_do(cdev);
454 memset(&cdev->private->irb, 0, sizeof(struct irb)); 330 return;
331
332err:
333 snid_done(cdev, rc);
334}
455 335
456 switch (ret) { 336/**
457 /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */ 337 * ccw_device_sense_pgid_start - perform SENSE PGID
458 case 0: 338 * @cdev: ccw device
459 /* Path verification ccw finished successfully, update lpm. */ 339 *
460 sch->vpm |= sch->opm & cdev->private->imask; 340 * Execute a SENSE PGID channel program on each path to @cdev to update its
461 /* Go on with next path. */ 341 * PGID information. When finished, call ccw_device_sense_id_done with a
462 cdev->private->imask >>= 1; 342 * return code specifying the result.
463 cdev->private->iretry = 5; 343 */
464 __ccw_device_verify_start(cdev); 344void ccw_device_sense_pgid_start(struct ccw_device *cdev)
465 break; 345{
466 case -EOPNOTSUPP: 346 struct ccw_request *req = &cdev->private->req;
467 /* 347
468 * One of those strange devices which claim to be able 348 CIO_TRACE_EVENT(4, "snid");
469 * to do multipathing but not for Set Path Group ID. 349 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
470 */ 350 /* Initialize PGID data. */
471 if (cdev->private->flags.pgid_single) 351 memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
472 cdev->private->options.pgroup = 0; 352 cdev->private->flags.pgid_rdy = 0;
473 else 353 cdev->private->pgid_valid_mask = 0;
474 cdev->private->flags.pgid_single = 1; 354 /* Initialize request data. */
475 /* Retry */ 355 memset(req, 0, sizeof(*req));
476 sch->vpm = 0; 356 req->timeout = PGID_TIMEOUT;
477 cdev->private->imask = 0x80; 357 req->maxretries = PGID_RETRIES;
478 cdev->private->iretry = 5; 358 req->callback = snid_callback;
479 /* fall through. */ 359 req->lpm = 0x80;
480 case -EAGAIN: /* Try again. */ 360 snid_do(cdev);
481 __ccw_device_verify_start(cdev);
482 break;
483 case -ETIME: /* Set path group id stopped by timeout. */
484 ccw_device_verify_done(cdev, -ETIME);
485 break;
486 case -EACCES: /* channel is not operational. */
487 cdev->private->imask >>= 1;
488 cdev->private->iretry = 5;
489 __ccw_device_verify_start(cdev);
490 break;
491 }
492} 361}
493 362
494void 363/*
495ccw_device_verify_start(struct ccw_device *cdev) 364 * Perform path verification.
365 */
366static void verify_start(struct ccw_device *cdev)
496{ 367{
497 struct subchannel *sch = to_subchannel(cdev->dev.parent); 368 struct subchannel *sch = to_subchannel(cdev->dev.parent);
369 struct ccw_request *req = &cdev->private->req;
498 370
499 cdev->private->flags.pgid_single = 0;
500 cdev->private->imask = 0x80;
501 cdev->private->iretry = 5;
502
503 /* Start with empty vpm. */
504 sch->vpm = 0; 371 sch->vpm = 0;
505 372 /* Initialize request data. */
506 /* Get current pam. */ 373 memset(req, 0, sizeof(*req));
507 if (cio_update_schib(sch)) { 374 req->timeout = PGID_TIMEOUT;
508 ccw_device_verify_done(cdev, -ENODEV); 375 req->maxretries = PGID_RETRIES;
509 return; 376 req->lpm = 0x80;
377 if (cdev->private->options.pgroup) {
378 req->callback = spid_callback;
379 spid_do(cdev);
380 } else {
381 req->filter = nop_filter;
382 req->callback = nop_callback;
383 nop_do(cdev);
510 } 384 }
511 /* After 60s path verification is considered to have failed. */
512 ccw_device_set_timeout(cdev, 60*HZ);
513 __ccw_device_verify_start(cdev);
514} 385}
515 386
516static void 387/**
517__ccw_device_disband_start(struct ccw_device *cdev) 388 * ccw_device_verify_start - perform path verification
389 * @cdev: ccw device
390 *
391 * Perform an I/O on each available channel path to @cdev to determine which
392 * paths are operational. The resulting path mask is stored in sch->vpm.
393 * If device options specify pathgrouping, establish a pathgroup for the
394 * operational paths. When finished, call ccw_device_verify_done with a
395 * return code specifying the result.
396 */
397void ccw_device_verify_start(struct ccw_device *cdev)
518{ 398{
519 struct subchannel *sch; 399 CIO_TRACE_EVENT(4, "vrfy");
520 int ret; 400 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
521 401 if (!cdev->private->flags.pgid_rdy) {
522 sch = to_subchannel(cdev->dev.parent); 402 /* No pathgrouping possible. */
523 while (cdev->private->imask != 0) { 403 cdev->private->options.pgroup = 0;
524 if (sch->lpm & cdev->private->imask) { 404 cdev->private->flags.pgid_single = 1;
525 ret = __ccw_device_do_pgid(cdev, SPID_FUNC_DISBAND); 405 } else
526 if (ret == 0) 406 cdev->private->flags.pgid_single = 0;
527 return; 407 cdev->private->flags.doverify = 0;
528 } 408 verify_start(cdev);
529 cdev->private->iretry = 5;
530 cdev->private->imask >>= 1;
531 }
532 ccw_device_disband_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
533} 409}
534 410
535/* 411/*
536 * Got interrupt for Unset Path Group ID. 412 * Process disband SET PGID request result.
537 */ 413 */
538void 414static void disband_callback(struct ccw_device *cdev, void *data, int rc)
539ccw_device_disband_irq(struct ccw_device *cdev, enum dev_event dev_event)
540{ 415{
541 struct subchannel *sch; 416 struct subchannel *sch = to_subchannel(cdev->dev.parent);
542 struct irb *irb; 417 struct ccw_dev_id *id = &cdev->private->dev_id;
543 int ret; 418
544 419 if (rc)
545 irb = (struct irb *) __LC_IRB; 420 goto out;
546 421 /* Ensure consistent multipathing state at device and channel. */
547 if (irb->scsw.cmd.stctl == 422 cdev->private->flags.pgid_single = 1;
548 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) { 423 if (sch->config.mp) {
549 if (__ccw_device_should_retry(&irb->scsw)) 424 sch->config.mp = 0;
550 __ccw_device_disband_start(cdev); 425 rc = cio_commit_config(sch);
551 return;
552 }
553 if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
554 return;
555 sch = to_subchannel(cdev->dev.parent);
556 ret = __ccw_device_check_pgid(cdev);
557 memset(&cdev->private->irb, 0, sizeof(struct irb));
558 switch (ret) {
559 /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
560 case 0: /* disband successful. */
561 ccw_device_disband_done(cdev, ret);
562 break;
563 case -EOPNOTSUPP:
564 /*
565 * One of those strange devices which claim to be able
566 * to do multipathing but not for Unset Path Group ID.
567 */
568 cdev->private->flags.pgid_single = 1;
569 /* fall through. */
570 case -EAGAIN: /* Try again. */
571 __ccw_device_disband_start(cdev);
572 break;
573 case -ETIME: /* Set path group id stopped by timeout. */
574 ccw_device_disband_done(cdev, -ETIME);
575 break;
576 case -EACCES: /* channel is not operational. */
577 cdev->private->imask >>= 1;
578 cdev->private->iretry = 5;
579 __ccw_device_disband_start(cdev);
580 break;
581 } 426 }
427out:
428 CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
429 rc);
430 ccw_device_disband_done(cdev, rc);
582} 431}
583 432
584void 433/**
585ccw_device_disband_start(struct ccw_device *cdev) 434 * ccw_device_disband_start - disband pathgroup
435 * @cdev: ccw device
436 *
437 * Execute a SET PGID channel program on @cdev to disband a previously
438 * established pathgroup. When finished, call ccw_device_disband_done with
439 * a return code specifying the result.
440 */
441void ccw_device_disband_start(struct ccw_device *cdev)
586{ 442{
587 /* After 60s disbanding is considered to have failed. */ 443 struct subchannel *sch = to_subchannel(cdev->dev.parent);
588 ccw_device_set_timeout(cdev, 60*HZ); 444 struct ccw_request *req = &cdev->private->req;
589 445 u8 fn;
590 cdev->private->flags.pgid_single = 0; 446
591 cdev->private->iretry = 5; 447 CIO_TRACE_EVENT(4, "disb");
592 cdev->private->imask = 0x80; 448 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
593 __ccw_device_disband_start(cdev); 449 /* Request setup. */
450 memset(req, 0, sizeof(*req));
451 req->timeout = PGID_TIMEOUT;
452 req->maxretries = PGID_RETRIES;
453 req->lpm = sch->schib.pmcw.pam & sch->opm;
454 req->callback = disband_callback;
455 fn = SPID_FUNC_DISBAND;
456 if (!cdev->private->flags.pgid_single)
457 fn |= SPID_FUNC_MULTI_PATH;
458 spid_build_cp(cdev, fn);
459 ccw_request_start(cdev);
594} 460}
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-03 08:20:03 -0500