1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * PAV alias management for the DASD ECKD discipline
4 *
5 * Copyright IBM Corp. 2007
6 * Author(s): Stefan Weinhuber <wein@de.ibm.com>
7 */
8
9 #include <linux/list.h>
10 #include <linux/slab.h>
11 #include <asm/ebcdic.h>
12 #include "dasd_int.h"
13 #include "dasd_eckd.h"
14
15 /*
16 * General concept of alias management:
17 * - PAV and DASD alias management is specific to the eckd discipline.
18 * - A device is connected to an lcu as long as the device exists.
19 * dasd_alias_make_device_known_to_lcu will be called wenn the
20 * device is checked by the eckd discipline and
21 * dasd_alias_disconnect_device_from_lcu will be called
22 * before the device is deleted.
23 * - The dasd_alias_add_device / dasd_alias_remove_device
24 * functions mark the point when a device is 'ready for service'.
25 * - A summary unit check is a rare occasion, but it is mandatory to
26 * support it. It requires some complex recovery actions before the
27 * devices can be used again (see dasd_alias_handle_summary_unit_check).
28 * - dasd_alias_get_start_dev will find an alias device that can be used
29 * instead of the base device and does some (very simple) load balancing.
30 * This is the function that gets called for each I/O, so when improving
31 * something, this function should get faster or better, the rest has just
32 * to be correct.
33 */
34
35
36 static void summary_unit_check_handling_work(struct work_struct *);
37 static void lcu_update_work(struct work_struct *);
38 static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);
39
40 static struct alias_root aliastree = {
41 .serverlist = LIST_HEAD_INIT(aliastree.serverlist),
42 .lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
43 };
44
_find_server(struct dasd_uid * uid)45 static struct alias_server *_find_server(struct dasd_uid *uid)
46 {
47 struct alias_server *pos;
48 list_for_each_entry(pos, &aliastree.serverlist, server) {
49 if (!strncmp(pos->uid.vendor, uid->vendor,
50 sizeof(uid->vendor))
51 && !strncmp(pos->uid.serial, uid->serial,
52 sizeof(uid->serial)))
53 return pos;
54 }
55 return NULL;
56 }
57
_find_lcu(struct alias_server * server,struct dasd_uid * uid)58 static struct alias_lcu *_find_lcu(struct alias_server *server,
59 struct dasd_uid *uid)
60 {
61 struct alias_lcu *pos;
62 list_for_each_entry(pos, &server->lculist, lcu) {
63 if (pos->uid.ssid == uid->ssid)
64 return pos;
65 }
66 return NULL;
67 }
68
_find_group(struct alias_lcu * lcu,struct dasd_uid * uid)69 static struct alias_pav_group *_find_group(struct alias_lcu *lcu,
70 struct dasd_uid *uid)
71 {
72 struct alias_pav_group *pos;
73 __u8 search_unit_addr;
74
75 /* for hyper pav there is only one group */
76 if (lcu->pav == HYPER_PAV) {
77 if (list_empty(&lcu->grouplist))
78 return NULL;
79 else
80 return list_first_entry(&lcu->grouplist,
81 struct alias_pav_group, group);
82 }
83
84 /* for base pav we have to find the group that matches the base */
85 if (uid->type == UA_BASE_DEVICE)
86 search_unit_addr = uid->real_unit_addr;
87 else
88 search_unit_addr = uid->base_unit_addr;
89 list_for_each_entry(pos, &lcu->grouplist, group) {
90 if (pos->uid.base_unit_addr == search_unit_addr &&
91 !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit)))
92 return pos;
93 }
94 return NULL;
95 }
96
_allocate_server(struct dasd_uid * uid)97 static struct alias_server *_allocate_server(struct dasd_uid *uid)
98 {
99 struct alias_server *server;
100
101 server = kzalloc(sizeof(*server), GFP_KERNEL);
102 if (!server)
103 return ERR_PTR(-ENOMEM);
104 memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));
105 memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));
106 INIT_LIST_HEAD(&server->server);
107 INIT_LIST_HEAD(&server->lculist);
108 return server;
109 }
110
_free_server(struct alias_server * server)111 static void _free_server(struct alias_server *server)
112 {
113 kfree(server);
114 }
115
_allocate_lcu(struct dasd_uid * uid)116 static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
117 {
118 struct alias_lcu *lcu;
119
120 lcu = kzalloc(sizeof(*lcu), GFP_KERNEL);
121 if (!lcu)
122 return ERR_PTR(-ENOMEM);
123 lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA);
124 if (!lcu->uac)
125 goto out_err1;
126 lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA);
127 if (!lcu->rsu_cqr)
128 goto out_err2;
129 lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1),
130 GFP_KERNEL | GFP_DMA);
131 if (!lcu->rsu_cqr->cpaddr)
132 goto out_err3;
133 lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA);
134 if (!lcu->rsu_cqr->data)
135 goto out_err4;
136
137 memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor));
138 memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial));
139 lcu->uid.ssid = uid->ssid;
140 lcu->pav = NO_PAV;
141 lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING;
142 INIT_LIST_HEAD(&lcu->lcu);
143 INIT_LIST_HEAD(&lcu->inactive_devices);
144 INIT_LIST_HEAD(&lcu->active_devices);
145 INIT_LIST_HEAD(&lcu->grouplist);
146 INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
147 INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
148 spin_lock_init(&lcu->lock);
149 init_completion(&lcu->lcu_setup);
150 return lcu;
151
152 out_err4:
153 kfree(lcu->rsu_cqr->cpaddr);
154 out_err3:
155 kfree(lcu->rsu_cqr);
156 out_err2:
157 kfree(lcu->uac);
158 out_err1:
159 kfree(lcu);
160 return ERR_PTR(-ENOMEM);
161 }
162
_free_lcu(struct alias_lcu * lcu)163 static void _free_lcu(struct alias_lcu *lcu)
164 {
165 kfree(lcu->rsu_cqr->data);
166 kfree(lcu->rsu_cqr->cpaddr);
167 kfree(lcu->rsu_cqr);
168 kfree(lcu->uac);
169 kfree(lcu);
170 }
171
172 /*
173 * This is the function that will allocate all the server and lcu data,
174 * so this function must be called first for a new device.
175 * If the return value is 1, the lcu was already known before, if it
176 * is 0, this is a new lcu.
177 * Negative return code indicates that something went wrong (e.g. -ENOMEM)
178 */
dasd_alias_make_device_known_to_lcu(struct dasd_device * device)179 int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
180 {
181 struct dasd_eckd_private *private = device->private;
182 unsigned long flags;
183 struct alias_server *server, *newserver;
184 struct alias_lcu *lcu, *newlcu;
185 struct dasd_uid uid;
186
187 device->discipline->get_uid(device, &uid);
188 spin_lock_irqsave(&aliastree.lock, flags);
189 server = _find_server(&uid);
190 if (!server) {
191 spin_unlock_irqrestore(&aliastree.lock, flags);
192 newserver = _allocate_server(&uid);
193 if (IS_ERR(newserver))
194 return PTR_ERR(newserver);
195 spin_lock_irqsave(&aliastree.lock, flags);
196 server = _find_server(&uid);
197 if (!server) {
198 list_add(&newserver->server, &aliastree.serverlist);
199 server = newserver;
200 } else {
201 /* someone was faster */
202 _free_server(newserver);
203 }
204 }
205
206 lcu = _find_lcu(server, &uid);
207 if (!lcu) {
208 spin_unlock_irqrestore(&aliastree.lock, flags);
209 newlcu = _allocate_lcu(&uid);
210 if (IS_ERR(newlcu))
211 return PTR_ERR(newlcu);
212 spin_lock_irqsave(&aliastree.lock, flags);
213 lcu = _find_lcu(server, &uid);
214 if (!lcu) {
215 list_add(&newlcu->lcu, &server->lculist);
216 lcu = newlcu;
217 } else {
218 /* someone was faster */
219 _free_lcu(newlcu);
220 }
221 }
222 spin_lock(&lcu->lock);
223 list_add(&device->alias_list, &lcu->inactive_devices);
224 private->lcu = lcu;
225 spin_unlock(&lcu->lock);
226 spin_unlock_irqrestore(&aliastree.lock, flags);
227
228 return 0;
229 }
230
231 /*
232 * This function removes a device from the scope of alias management.
233 * The complicated part is to make sure that it is not in use by
234 * any of the workers. If necessary cancel the work.
235 */
dasd_alias_disconnect_device_from_lcu(struct dasd_device * device)236 void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
237 {
238 struct dasd_eckd_private *private = device->private;
239 unsigned long flags;
240 struct alias_lcu *lcu;
241 struct alias_server *server;
242 int was_pending;
243 struct dasd_uid uid;
244
245 lcu = private->lcu;
246 /* nothing to do if already disconnected */
247 if (!lcu)
248 return;
249 device->discipline->get_uid(device, &uid);
250 spin_lock_irqsave(&lcu->lock, flags);
251 /* make sure that the workers don't use this device */
252 if (device == lcu->suc_data.device) {
253 spin_unlock_irqrestore(&lcu->lock, flags);
254 cancel_work_sync(&lcu->suc_data.worker);
255 spin_lock_irqsave(&lcu->lock, flags);
256 if (device == lcu->suc_data.device) {
257 dasd_put_device(device);
258 lcu->suc_data.device = NULL;
259 }
260 }
261 was_pending = 0;
262 if (device == lcu->ruac_data.device) {
263 spin_unlock_irqrestore(&lcu->lock, flags);
264 was_pending = 1;
265 cancel_delayed_work_sync(&lcu->ruac_data.dwork);
266 spin_lock_irqsave(&lcu->lock, flags);
267 if (device == lcu->ruac_data.device) {
268 dasd_put_device(device);
269 lcu->ruac_data.device = NULL;
270 }
271 }
272 private->lcu = NULL;
273 spin_unlock_irqrestore(&lcu->lock, flags);
274
275 spin_lock_irqsave(&aliastree.lock, flags);
276 spin_lock(&lcu->lock);
277 list_del_init(&device->alias_list);
278 if (list_empty(&lcu->grouplist) &&
279 list_empty(&lcu->active_devices) &&
280 list_empty(&lcu->inactive_devices)) {
281 list_del(&lcu->lcu);
282 spin_unlock(&lcu->lock);
283 _free_lcu(lcu);
284 lcu = NULL;
285 } else {
286 if (was_pending)
287 _schedule_lcu_update(lcu, NULL);
288 spin_unlock(&lcu->lock);
289 }
290 server = _find_server(&uid);
291 if (server && list_empty(&server->lculist)) {
292 list_del(&server->server);
293 _free_server(server);
294 }
295 spin_unlock_irqrestore(&aliastree.lock, flags);
296 }
297
298 /*
299 * This function assumes that the unit address configuration stored
300 * in the lcu is up to date and will update the device uid before
301 * adding it to a pav group.
302 */
303
_add_device_to_lcu(struct alias_lcu * lcu,struct dasd_device * device,struct dasd_device * pos)304 static int _add_device_to_lcu(struct alias_lcu *lcu,
305 struct dasd_device *device,
306 struct dasd_device *pos)
307 {
308
309 struct dasd_eckd_private *private = device->private;
310 struct alias_pav_group *group;
311 struct dasd_uid uid;
312
313 spin_lock(get_ccwdev_lock(device->cdev));
314 private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type;
315 private->uid.base_unit_addr =
316 lcu->uac->unit[private->uid.real_unit_addr].base_ua;
317 uid = private->uid;
318 spin_unlock(get_ccwdev_lock(device->cdev));
319 /* if we have no PAV anyway, we don't need to bother with PAV groups */
320 if (lcu->pav == NO_PAV) {
321 list_move(&device->alias_list, &lcu->active_devices);
322 return 0;
323 }
324 group = _find_group(lcu, &uid);
325 if (!group) {
326 group = kzalloc(sizeof(*group), GFP_ATOMIC);
327 if (!group)
328 return -ENOMEM;
329 memcpy(group->uid.vendor, uid.vendor, sizeof(uid.vendor));
330 memcpy(group->uid.serial, uid.serial, sizeof(uid.serial));
331 group->uid.ssid = uid.ssid;
332 if (uid.type == UA_BASE_DEVICE)
333 group->uid.base_unit_addr = uid.real_unit_addr;
334 else
335 group->uid.base_unit_addr = uid.base_unit_addr;
336 memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit));
337 INIT_LIST_HEAD(&group->group);
338 INIT_LIST_HEAD(&group->baselist);
339 INIT_LIST_HEAD(&group->aliaslist);
340 list_add(&group->group, &lcu->grouplist);
341 }
342 if (uid.type == UA_BASE_DEVICE)
343 list_move(&device->alias_list, &group->baselist);
344 else
345 list_move(&device->alias_list, &group->aliaslist);
346 private->pavgroup = group;
347 return 0;
348 };
349
_remove_device_from_lcu(struct alias_lcu * lcu,struct dasd_device * device)350 static void _remove_device_from_lcu(struct alias_lcu *lcu,
351 struct dasd_device *device)
352 {
353 struct dasd_eckd_private *private = device->private;
354 struct alias_pav_group *group;
355
356 list_move(&device->alias_list, &lcu->inactive_devices);
357 group = private->pavgroup;
358 if (!group)
359 return;
360 private->pavgroup = NULL;
361 if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) {
362 list_del(&group->group);
363 kfree(group);
364 return;
365 }
366 if (group->next == device)
367 group->next = NULL;
368 };
369
370 static int
suborder_not_supported(struct dasd_ccw_req * cqr)371 suborder_not_supported(struct dasd_ccw_req *cqr)
372 {
373 char *sense;
374 char reason;
375 char msg_format;
376 char msg_no;
377
378 /*
379 * intrc values ENODEV, ENOLINK and EPERM
380 * will be optained from sleep_on to indicate that no
381 * IO operation can be started
382 */
383 if (cqr->intrc == -ENODEV)
384 return 1;
385
386 if (cqr->intrc == -ENOLINK)
387 return 1;
388
389 if (cqr->intrc == -EPERM)
390 return 1;
391
392 sense = dasd_get_sense(&cqr->irb);
393 if (!sense)
394 return 0;
395
396 reason = sense[0];
397 msg_format = (sense[7] & 0xF0);
398 msg_no = (sense[7] & 0x0F);
399
400 /* command reject, Format 0 MSG 4 - invalid parameter */
401 if ((reason == 0x80) && (msg_format == 0x00) && (msg_no == 0x04))
402 return 1;
403
404 return 0;
405 }
406
read_unit_address_configuration(struct dasd_device * device,struct alias_lcu * lcu)407 static int read_unit_address_configuration(struct dasd_device *device,
408 struct alias_lcu *lcu)
409 {
410 struct dasd_psf_prssd_data *prssdp;
411 struct dasd_ccw_req *cqr;
412 struct ccw1 *ccw;
413 int rc;
414 unsigned long flags;
415
416 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
417 (sizeof(struct dasd_psf_prssd_data)),
418 device, NULL);
419 if (IS_ERR(cqr))
420 return PTR_ERR(cqr);
421 cqr->startdev = device;
422 cqr->memdev = device;
423 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
424 cqr->retries = 10;
425 cqr->expires = 20 * HZ;
426
427 /* Prepare for Read Subsystem Data */
428 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
429 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
430 prssdp->order = PSF_ORDER_PRSSD;
431 prssdp->suborder = 0x0e; /* Read unit address configuration */
432 /* all other bytes of prssdp must be zero */
433
434 ccw = cqr->cpaddr;
435 ccw->cmd_code = DASD_ECKD_CCW_PSF;
436 ccw->count = sizeof(struct dasd_psf_prssd_data);
437 ccw->flags |= CCW_FLAG_CC;
438 ccw->cda = virt_to_dma32(prssdp);
439
440 /* Read Subsystem Data - feature codes */
441 memset(lcu->uac, 0, sizeof(*(lcu->uac)));
442
443 ccw++;
444 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
445 ccw->count = sizeof(*(lcu->uac));
446 ccw->cda = virt_to_dma32(lcu->uac);
447
448 cqr->buildclk = get_tod_clock();
449 cqr->status = DASD_CQR_FILLED;
450
451 /* need to unset flag here to detect race with summary unit check */
452 spin_lock_irqsave(&lcu->lock, flags);
453 lcu->flags &= ~NEED_UAC_UPDATE;
454 spin_unlock_irqrestore(&lcu->lock, flags);
455
456 rc = dasd_sleep_on(cqr);
457 if (!rc)
458 goto out;
459
460 if (suborder_not_supported(cqr)) {
461 /* suborder not supported or device unusable for IO */
462 rc = -EOPNOTSUPP;
463 } else {
464 /* IO failed but should be retried */
465 spin_lock_irqsave(&lcu->lock, flags);
466 lcu->flags |= NEED_UAC_UPDATE;
467 spin_unlock_irqrestore(&lcu->lock, flags);
468 }
469 out:
470 dasd_sfree_request(cqr, cqr->memdev);
471 return rc;
472 }
473
_lcu_update(struct dasd_device * refdev,struct alias_lcu * lcu)474 static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
475 {
476 unsigned long flags;
477 struct alias_pav_group *pavgroup, *tempgroup;
478 struct dasd_device *device, *tempdev;
479 int i, rc;
480 struct dasd_eckd_private *private;
481
482 spin_lock_irqsave(&lcu->lock, flags);
483 list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
484 list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
485 alias_list) {
486 list_move(&device->alias_list, &lcu->active_devices);
487 private = device->private;
488 private->pavgroup = NULL;
489 }
490 list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
491 alias_list) {
492 list_move(&device->alias_list, &lcu->active_devices);
493 private = device->private;
494 private->pavgroup = NULL;
495 }
496 list_del(&pavgroup->group);
497 kfree(pavgroup);
498 }
499 spin_unlock_irqrestore(&lcu->lock, flags);
500
501 rc = read_unit_address_configuration(refdev, lcu);
502 if (rc)
503 return rc;
504
505 spin_lock_irqsave(&lcu->lock, flags);
506 /*
507 * there is another update needed skip the remaining handling
508 * the data might already be outdated
509 * but especially do not add the device to an LCU with pending
510 * update
511 */
512 if (lcu->flags & NEED_UAC_UPDATE)
513 goto out;
514 lcu->pav = NO_PAV;
515 for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
516 switch (lcu->uac->unit[i].ua_type) {
517 case UA_BASE_PAV_ALIAS:
518 lcu->pav = BASE_PAV;
519 break;
520 case UA_HYPER_PAV_ALIAS:
521 lcu->pav = HYPER_PAV;
522 break;
523 }
524 if (lcu->pav != NO_PAV)
525 break;
526 }
527
528 list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
529 alias_list) {
530 _add_device_to_lcu(lcu, device, refdev);
531 }
532 out:
533 spin_unlock_irqrestore(&lcu->lock, flags);
534 return 0;
535 }
536
lcu_update_work(struct work_struct * work)537 static void lcu_update_work(struct work_struct *work)
538 {
539 struct alias_lcu *lcu;
540 struct read_uac_work_data *ruac_data;
541 struct dasd_device *device;
542 unsigned long flags;
543 int rc;
544
545 ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
546 lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
547 device = ruac_data->device;
548 rc = _lcu_update(device, lcu);
549 /*
550 * Need to check flags again, as there could have been another
551 * prepare_update or a new device a new device while we were still
552 * processing the data
553 */
554 spin_lock_irqsave(&lcu->lock, flags);
555 if ((rc && (rc != -EOPNOTSUPP)) || (lcu->flags & NEED_UAC_UPDATE)) {
556 DBF_DEV_EVENT(DBF_WARNING, device, "could not update"
557 " alias data in lcu (rc = %d), retry later", rc);
558 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ))
559 dasd_put_device(device);
560 } else {
561 dasd_put_device(device);
562 lcu->ruac_data.device = NULL;
563 lcu->flags &= ~UPDATE_PENDING;
564 }
565 spin_unlock_irqrestore(&lcu->lock, flags);
566 }
567
_schedule_lcu_update(struct alias_lcu * lcu,struct dasd_device * device)568 static int _schedule_lcu_update(struct alias_lcu *lcu,
569 struct dasd_device *device)
570 {
571 struct dasd_device *usedev = NULL;
572 struct alias_pav_group *group;
573
574 lcu->flags |= NEED_UAC_UPDATE;
575 if (lcu->ruac_data.device) {
576 /* already scheduled or running */
577 return 0;
578 }
579 if (device && !list_empty(&device->alias_list))
580 usedev = device;
581
582 if (!usedev && !list_empty(&lcu->grouplist)) {
583 group = list_first_entry(&lcu->grouplist,
584 struct alias_pav_group, group);
585 if (!list_empty(&group->baselist))
586 usedev = list_first_entry(&group->baselist,
587 struct dasd_device,
588 alias_list);
589 else if (!list_empty(&group->aliaslist))
590 usedev = list_first_entry(&group->aliaslist,
591 struct dasd_device,
592 alias_list);
593 }
594 if (!usedev && !list_empty(&lcu->active_devices)) {
595 usedev = list_first_entry(&lcu->active_devices,
596 struct dasd_device, alias_list);
597 }
598 /*
599 * if we haven't found a proper device yet, give up for now, the next
600 * device that will be set active will trigger an lcu update
601 */
602 if (!usedev)
603 return -EINVAL;
604 dasd_get_device(usedev);
605 lcu->ruac_data.device = usedev;
606 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 0))
607 dasd_put_device(usedev);
608 return 0;
609 }
610
dasd_alias_add_device(struct dasd_device * device)611 int dasd_alias_add_device(struct dasd_device *device)
612 {
613 struct dasd_eckd_private *private = device->private;
614 __u8 uaddr = private->uid.real_unit_addr;
615 struct alias_lcu *lcu = private->lcu;
616 unsigned long flags;
617 int rc;
618
619 rc = 0;
620 spin_lock_irqsave(&lcu->lock, flags);
621 /*
622 * Check if device and lcu type differ. If so, the uac data may be
623 * outdated and needs to be updated.
624 */
625 if (private->uid.type != lcu->uac->unit[uaddr].ua_type) {
626 lcu->flags |= UPDATE_PENDING;
627 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
628 "uid type mismatch - trigger rescan");
629 }
630 if (!(lcu->flags & UPDATE_PENDING)) {
631 rc = _add_device_to_lcu(lcu, device, device);
632 if (rc)
633 lcu->flags |= UPDATE_PENDING;
634 }
635 if (lcu->flags & UPDATE_PENDING) {
636 list_move(&device->alias_list, &lcu->active_devices);
637 private->pavgroup = NULL;
638 _schedule_lcu_update(lcu, device);
639 }
640 spin_unlock_irqrestore(&lcu->lock, flags);
641 return rc;
642 }
643
dasd_alias_update_add_device(struct dasd_device * device)644 int dasd_alias_update_add_device(struct dasd_device *device)
645 {
646 struct dasd_eckd_private *private = device->private;
647
648 private->lcu->flags |= UPDATE_PENDING;
649 return dasd_alias_add_device(device);
650 }
651
dasd_alias_remove_device(struct dasd_device * device)652 int dasd_alias_remove_device(struct dasd_device *device)
653 {
654 struct dasd_eckd_private *private = device->private;
655 struct alias_lcu *lcu = private->lcu;
656 unsigned long flags;
657
658 /* nothing to do if already removed */
659 if (!lcu)
660 return 0;
661 spin_lock_irqsave(&lcu->lock, flags);
662 _remove_device_from_lcu(lcu, device);
663 spin_unlock_irqrestore(&lcu->lock, flags);
664 return 0;
665 }
666
dasd_alias_get_start_dev(struct dasd_device * base_device)667 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
668 {
669 struct dasd_eckd_private *alias_priv, *private = base_device->private;
670 struct alias_lcu *lcu = private->lcu;
671 struct dasd_device *alias_device;
672 struct alias_pav_group *group;
673 unsigned long flags;
674
675 if (!lcu)
676 return NULL;
677 if (lcu->pav == NO_PAV ||
678 lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
679 return NULL;
680 if (unlikely(!(private->features.feature[8] & 0x01))) {
681 /*
682 * PAV enabled but prefix not, very unlikely
683 * seems to be a lost pathgroup
684 * use base device to do IO
685 */
686 DBF_DEV_EVENT(DBF_ERR, base_device, "%s",
687 "Prefix not enabled with PAV enabled\n");
688 return NULL;
689 }
690
691 spin_lock_irqsave(&lcu->lock, flags);
692 group = private->pavgroup;
693 if (!group) {
694 spin_unlock_irqrestore(&lcu->lock, flags);
695 return NULL;
696 }
697 alias_device = group->next;
698 if (!alias_device) {
699 if (list_empty(&group->aliaslist)) {
700 spin_unlock_irqrestore(&lcu->lock, flags);
701 return NULL;
702 } else {
703 alias_device = list_first_entry(&group->aliaslist,
704 struct dasd_device,
705 alias_list);
706 }
707 }
708 if (list_is_last(&alias_device->alias_list, &group->aliaslist))
709 group->next = list_first_entry(&group->aliaslist,
710 struct dasd_device, alias_list);
711 else
712 group->next = list_first_entry(&alias_device->alias_list,
713 struct dasd_device, alias_list);
714 spin_unlock_irqrestore(&lcu->lock, flags);
715 alias_priv = alias_device->private;
716 if ((alias_priv->count < private->count) && !alias_device->stopped &&
717 !test_bit(DASD_FLAG_OFFLINE, &alias_device->flags))
718 return alias_device;
719 else
720 return NULL;
721 }
722
723 /*
724 * Summary unit check handling depends on the way alias devices
725 * are handled so it is done here rather then in dasd_eckd.c
726 */
reset_summary_unit_check(struct alias_lcu * lcu,struct dasd_device * device,char reason)727 static int reset_summary_unit_check(struct alias_lcu *lcu,
728 struct dasd_device *device,
729 char reason)
730 {
731 struct dasd_ccw_req *cqr;
732 int rc = 0;
733 struct ccw1 *ccw;
734
735 cqr = lcu->rsu_cqr;
736 memcpy((char *) &cqr->magic, "ECKD", 4);
737 ASCEBC((char *) &cqr->magic, 4);
738 ccw = cqr->cpaddr;
739 ccw->cmd_code = DASD_ECKD_CCW_RSCK;
740 ccw->flags = CCW_FLAG_SLI;
741 ccw->count = 16;
742 ccw->cda = virt_to_dma32(cqr->data);
743 ((char *)cqr->data)[0] = reason;
744
745 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
746 cqr->retries = 255; /* set retry counter to enable basic ERP */
747 cqr->startdev = device;
748 cqr->memdev = device;
749 cqr->block = NULL;
750 cqr->expires = 5 * HZ;
751 cqr->buildclk = get_tod_clock();
752 cqr->status = DASD_CQR_FILLED;
753
754 rc = dasd_sleep_on_immediatly(cqr);
755 return rc;
756 }
757
_restart_all_base_devices_on_lcu(struct alias_lcu * lcu)758 static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
759 {
760 struct alias_pav_group *pavgroup;
761 struct dasd_device *device;
762 struct dasd_eckd_private *private;
763
764 /* active and inactive list can contain alias as well as base devices */
765 list_for_each_entry(device, &lcu->active_devices, alias_list) {
766 private = device->private;
767 if (private->uid.type != UA_BASE_DEVICE)
768 continue;
769 dasd_schedule_block_bh(device->block);
770 dasd_schedule_device_bh(device);
771 }
772 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
773 private = device->private;
774 if (private->uid.type != UA_BASE_DEVICE)
775 continue;
776 dasd_schedule_block_bh(device->block);
777 dasd_schedule_device_bh(device);
778 }
779 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
780 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
781 dasd_schedule_block_bh(device->block);
782 dasd_schedule_device_bh(device);
783 }
784 }
785 }
786
flush_all_alias_devices_on_lcu(struct alias_lcu * lcu)787 static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
788 {
789 struct alias_pav_group *pavgroup;
790 struct dasd_device *device, *temp;
791 struct dasd_eckd_private *private;
792 unsigned long flags;
793 LIST_HEAD(active);
794
795 /*
796 * Problem here ist that dasd_flush_device_queue may wait
797 * for termination of a request to complete. We can't keep
798 * the lcu lock during that time, so we must assume that
799 * the lists may have changed.
800 * Idea: first gather all active alias devices in a separate list,
801 * then flush the first element of this list unlocked, and afterwards
802 * check if it is still on the list before moving it to the
803 * active_devices list.
804 */
805
806 spin_lock_irqsave(&lcu->lock, flags);
807 list_for_each_entry_safe(device, temp, &lcu->active_devices,
808 alias_list) {
809 private = device->private;
810 if (private->uid.type == UA_BASE_DEVICE)
811 continue;
812 list_move(&device->alias_list, &active);
813 }
814
815 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
816 list_splice_init(&pavgroup->aliaslist, &active);
817 }
818 while (!list_empty(&active)) {
819 device = list_first_entry(&active, struct dasd_device,
820 alias_list);
821 spin_unlock_irqrestore(&lcu->lock, flags);
822 dasd_flush_device_queue(device);
823 spin_lock_irqsave(&lcu->lock, flags);
824 /*
825 * only move device around if it wasn't moved away while we
826 * were waiting for the flush
827 */
828 if (device == list_first_entry(&active,
829 struct dasd_device, alias_list)) {
830 list_move(&device->alias_list, &lcu->active_devices);
831 private = device->private;
832 private->pavgroup = NULL;
833 }
834 }
835 spin_unlock_irqrestore(&lcu->lock, flags);
836 }
837
_stop_all_devices_on_lcu(struct alias_lcu * lcu)838 static void _stop_all_devices_on_lcu(struct alias_lcu *lcu)
839 {
840 struct alias_pav_group *pavgroup;
841 struct dasd_device *device;
842
843 list_for_each_entry(device, &lcu->active_devices, alias_list) {
844 spin_lock(get_ccwdev_lock(device->cdev));
845 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
846 spin_unlock(get_ccwdev_lock(device->cdev));
847 }
848 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
849 spin_lock(get_ccwdev_lock(device->cdev));
850 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
851 spin_unlock(get_ccwdev_lock(device->cdev));
852 }
853 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
854 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
855 spin_lock(get_ccwdev_lock(device->cdev));
856 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
857 spin_unlock(get_ccwdev_lock(device->cdev));
858 }
859 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
860 spin_lock(get_ccwdev_lock(device->cdev));
861 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
862 spin_unlock(get_ccwdev_lock(device->cdev));
863 }
864 }
865 }
866
_unstop_all_devices_on_lcu(struct alias_lcu * lcu)867 static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
868 {
869 struct alias_pav_group *pavgroup;
870 struct dasd_device *device;
871
872 list_for_each_entry(device, &lcu->active_devices, alias_list) {
873 spin_lock(get_ccwdev_lock(device->cdev));
874 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
875 spin_unlock(get_ccwdev_lock(device->cdev));
876 }
877 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
878 spin_lock(get_ccwdev_lock(device->cdev));
879 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
880 spin_unlock(get_ccwdev_lock(device->cdev));
881 }
882 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
883 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
884 spin_lock(get_ccwdev_lock(device->cdev));
885 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
886 spin_unlock(get_ccwdev_lock(device->cdev));
887 }
888 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
889 spin_lock(get_ccwdev_lock(device->cdev));
890 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
891 spin_unlock(get_ccwdev_lock(device->cdev));
892 }
893 }
894 }
895
summary_unit_check_handling_work(struct work_struct * work)896 static void summary_unit_check_handling_work(struct work_struct *work)
897 {
898 struct alias_lcu *lcu;
899 struct summary_unit_check_work_data *suc_data;
900 unsigned long flags;
901 struct dasd_device *device;
902
903 suc_data = container_of(work, struct summary_unit_check_work_data,
904 worker);
905 lcu = container_of(suc_data, struct alias_lcu, suc_data);
906 device = suc_data->device;
907
908 /* 1. flush alias devices */
909 flush_all_alias_devices_on_lcu(lcu);
910
911 /* 2. reset summary unit check */
912 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
913 dasd_device_remove_stop_bits(device,
914 (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
915 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
916 reset_summary_unit_check(lcu, device, suc_data->reason);
917
918 spin_lock_irqsave(&lcu->lock, flags);
919 _unstop_all_devices_on_lcu(lcu);
920 _restart_all_base_devices_on_lcu(lcu);
921 /* 3. read new alias configuration */
922 _schedule_lcu_update(lcu, device);
923 lcu->suc_data.device = NULL;
924 dasd_put_device(device);
925 spin_unlock_irqrestore(&lcu->lock, flags);
926 }
927
dasd_alias_handle_summary_unit_check(struct work_struct * work)928 void dasd_alias_handle_summary_unit_check(struct work_struct *work)
929 {
930 struct dasd_device *device = container_of(work, struct dasd_device,
931 suc_work);
932 struct dasd_eckd_private *private = device->private;
933 struct alias_lcu *lcu;
934 unsigned long flags;
935
936 lcu = private->lcu;
937 if (!lcu) {
938 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
939 "device not ready to handle summary"
940 " unit check (no lcu structure)");
941 goto out;
942 }
943 spin_lock_irqsave(&lcu->lock, flags);
944 /* If this device is about to be removed just return and wait for
945 * the next interrupt on a different device
946 */
947 if (list_empty(&device->alias_list)) {
948 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
949 "device is in offline processing,"
950 " don't do summary unit check handling");
951 goto out_unlock;
952 }
953 if (lcu->suc_data.device) {
954 /* already scheduled or running */
955 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
956 "previous instance of summary unit check worker"
957 " still pending");
958 goto out_unlock;
959 }
960 _stop_all_devices_on_lcu(lcu);
961 /* prepare for lcu_update */
962 lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
963 lcu->suc_data.reason = private->suc_reason;
964 lcu->suc_data.device = device;
965 dasd_get_device(device);
966 if (!schedule_work(&lcu->suc_data.worker))
967 dasd_put_device(device);
968 out_unlock:
969 spin_unlock_irqrestore(&lcu->lock, flags);
970 out:
971 clear_bit(DASD_FLAG_SUC, &device->flags);
972 dasd_put_device(device);
973 };
974