2 * PAV alias management for the DASD ECKD discipline
4 * Copyright IBM Corp. 2007
5 * Author(s): Stefan Weinhuber <wein@de.ibm.com>
8 #define KMSG_COMPONENT "dasd-eckd"
10 #include <linux/list.h>
11 #include <linux/slab.h>
12 #include <asm/ebcdic.h>
14 #include "dasd_eckd.h"
18 #endif /* PRINTK_HEADER */
19 #define PRINTK_HEADER "dasd(eckd):"
23 * General concept of alias management:
24 * - PAV and DASD alias management is specific to the eckd discipline.
25 * - A device is connected to an lcu as long as the device exists.
26 * dasd_alias_make_device_known_to_lcu will be called wenn the
27 * device is checked by the eckd discipline and
28 * dasd_alias_disconnect_device_from_lcu will be called
29 * before the device is deleted.
30 * - The dasd_alias_add_device / dasd_alias_remove_device
31 * functions mark the point when a device is 'ready for service'.
32 * - A summary unit check is a rare occasion, but it is mandatory to
33 * support it. It requires some complex recovery actions before the
34 * devices can be used again (see dasd_alias_handle_summary_unit_check).
35 * - dasd_alias_get_start_dev will find an alias device that can be used
36 * instead of the base device and does some (very simple) load balancing.
37 * This is the function that gets called for each I/O, so when improving
38 * something, this function should get faster or better, the rest has just
43 static void summary_unit_check_handling_work(struct work_struct *);
44 static void lcu_update_work(struct work_struct *);
45 static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);
47 static struct alias_root aliastree = {
48 .serverlist = LIST_HEAD_INIT(aliastree.serverlist),
49 .lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
52 static struct alias_server *_find_server(struct dasd_uid *uid)
54 struct alias_server *pos;
55 list_for_each_entry(pos, &aliastree.serverlist, server) {
56 if (!strncmp(pos->uid.vendor, uid->vendor,
58 && !strncmp(pos->uid.serial, uid->serial,
65 static struct alias_lcu *_find_lcu(struct alias_server *server,
68 struct alias_lcu *pos;
69 list_for_each_entry(pos, &server->lculist, lcu) {
70 if (pos->uid.ssid == uid->ssid)
76 static struct alias_pav_group *_find_group(struct alias_lcu *lcu,
79 struct alias_pav_group *pos;
80 __u8 search_unit_addr;
82 /* for hyper pav there is only one group */
83 if (lcu->pav == HYPER_PAV) {
84 if (list_empty(&lcu->grouplist))
87 return list_first_entry(&lcu->grouplist,
88 struct alias_pav_group, group);
91 /* for base pav we have to find the group that matches the base */
92 if (uid->type == UA_BASE_DEVICE)
93 search_unit_addr = uid->real_unit_addr;
95 search_unit_addr = uid->base_unit_addr;
96 list_for_each_entry(pos, &lcu->grouplist, group) {
97 if (pos->uid.base_unit_addr == search_unit_addr &&
98 !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit)))
104 static struct alias_server *_allocate_server(struct dasd_uid *uid)
106 struct alias_server *server;
108 server = kzalloc(sizeof(*server), GFP_KERNEL);
110 return ERR_PTR(-ENOMEM);
111 memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));
112 memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));
113 INIT_LIST_HEAD(&server->server);
114 INIT_LIST_HEAD(&server->lculist);
118 static void _free_server(struct alias_server *server)
123 static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
125 struct alias_lcu *lcu;
127 lcu = kzalloc(sizeof(*lcu), GFP_KERNEL);
129 return ERR_PTR(-ENOMEM);
130 lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA);
133 lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA);
136 lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1),
137 GFP_KERNEL | GFP_DMA);
138 if (!lcu->rsu_cqr->cpaddr)
140 lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA);
141 if (!lcu->rsu_cqr->data)
144 memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor));
145 memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial));
146 lcu->uid.ssid = uid->ssid;
148 lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING;
149 INIT_LIST_HEAD(&lcu->lcu);
150 INIT_LIST_HEAD(&lcu->inactive_devices);
151 INIT_LIST_HEAD(&lcu->active_devices);
152 INIT_LIST_HEAD(&lcu->grouplist);
153 INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
154 INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
155 spin_lock_init(&lcu->lock);
156 init_completion(&lcu->lcu_setup);
160 kfree(lcu->rsu_cqr->cpaddr);
167 return ERR_PTR(-ENOMEM);
170 static void _free_lcu(struct alias_lcu *lcu)
172 kfree(lcu->rsu_cqr->data);
173 kfree(lcu->rsu_cqr->cpaddr);
180 * This is the function that will allocate all the server and lcu data,
181 * so this function must be called first for a new device.
182 * If the return value is 1, the lcu was already known before, if it
183 * is 0, this is a new lcu.
184 * Negative return code indicates that something went wrong (e.g. -ENOMEM)
186 int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
188 struct dasd_eckd_private *private = device->private;
190 struct alias_server *server, *newserver;
191 struct alias_lcu *lcu, *newlcu;
194 device->discipline->get_uid(device, &uid);
195 spin_lock_irqsave(&aliastree.lock, flags);
196 server = _find_server(&uid);
198 spin_unlock_irqrestore(&aliastree.lock, flags);
199 newserver = _allocate_server(&uid);
200 if (IS_ERR(newserver))
201 return PTR_ERR(newserver);
202 spin_lock_irqsave(&aliastree.lock, flags);
203 server = _find_server(&uid);
205 list_add(&newserver->server, &aliastree.serverlist);
208 /* someone was faster */
209 _free_server(newserver);
213 lcu = _find_lcu(server, &uid);
215 spin_unlock_irqrestore(&aliastree.lock, flags);
216 newlcu = _allocate_lcu(&uid);
218 return PTR_ERR(newlcu);
219 spin_lock_irqsave(&aliastree.lock, flags);
220 lcu = _find_lcu(server, &uid);
222 list_add(&newlcu->lcu, &server->lculist);
225 /* someone was faster */
229 spin_lock(&lcu->lock);
230 list_add(&device->alias_list, &lcu->inactive_devices);
232 spin_unlock(&lcu->lock);
233 spin_unlock_irqrestore(&aliastree.lock, flags);
239 * This function removes a device from the scope of alias management.
240 * The complicated part is to make sure that it is not in use by
241 * any of the workers. If necessary cancel the work.
243 void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
245 struct dasd_eckd_private *private = device->private;
247 struct alias_lcu *lcu;
248 struct alias_server *server;
253 /* nothing to do if already disconnected */
256 device->discipline->get_uid(device, &uid);
257 spin_lock_irqsave(&lcu->lock, flags);
258 list_del_init(&device->alias_list);
259 /* make sure that the workers don't use this device */
260 if (device == lcu->suc_data.device) {
261 spin_unlock_irqrestore(&lcu->lock, flags);
262 cancel_work_sync(&lcu->suc_data.worker);
263 spin_lock_irqsave(&lcu->lock, flags);
264 if (device == lcu->suc_data.device) {
265 dasd_put_device(device);
266 lcu->suc_data.device = NULL;
270 if (device == lcu->ruac_data.device) {
271 spin_unlock_irqrestore(&lcu->lock, flags);
273 cancel_delayed_work_sync(&lcu->ruac_data.dwork);
274 spin_lock_irqsave(&lcu->lock, flags);
275 if (device == lcu->ruac_data.device) {
276 dasd_put_device(device);
277 lcu->ruac_data.device = NULL;
281 spin_unlock_irqrestore(&lcu->lock, flags);
283 spin_lock_irqsave(&aliastree.lock, flags);
284 spin_lock(&lcu->lock);
285 if (list_empty(&lcu->grouplist) &&
286 list_empty(&lcu->active_devices) &&
287 list_empty(&lcu->inactive_devices)) {
289 spin_unlock(&lcu->lock);
294 _schedule_lcu_update(lcu, NULL);
295 spin_unlock(&lcu->lock);
297 server = _find_server(&uid);
298 if (server && list_empty(&server->lculist)) {
299 list_del(&server->server);
300 _free_server(server);
302 spin_unlock_irqrestore(&aliastree.lock, flags);
306 * This function assumes that the unit address configuration stored
307 * in the lcu is up to date and will update the device uid before
308 * adding it to a pav group.
311 static int _add_device_to_lcu(struct alias_lcu *lcu,
312 struct dasd_device *device,
313 struct dasd_device *pos)
316 struct dasd_eckd_private *private = device->private;
317 struct alias_pav_group *group;
320 private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type;
321 private->uid.base_unit_addr =
322 lcu->uac->unit[private->uid.real_unit_addr].base_ua;
325 /* if we have no PAV anyway, we don't need to bother with PAV groups */
326 if (lcu->pav == NO_PAV) {
327 list_move(&device->alias_list, &lcu->active_devices);
331 group = _find_group(lcu, &uid);
333 group = kzalloc(sizeof(*group), GFP_ATOMIC);
336 memcpy(group->uid.vendor, uid.vendor, sizeof(uid.vendor));
337 memcpy(group->uid.serial, uid.serial, sizeof(uid.serial));
338 group->uid.ssid = uid.ssid;
339 if (uid.type == UA_BASE_DEVICE)
340 group->uid.base_unit_addr = uid.real_unit_addr;
342 group->uid.base_unit_addr = uid.base_unit_addr;
343 memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit));
344 INIT_LIST_HEAD(&group->group);
345 INIT_LIST_HEAD(&group->baselist);
346 INIT_LIST_HEAD(&group->aliaslist);
347 list_add(&group->group, &lcu->grouplist);
349 if (uid.type == UA_BASE_DEVICE)
350 list_move(&device->alias_list, &group->baselist);
352 list_move(&device->alias_list, &group->aliaslist);
353 private->pavgroup = group;
357 static void _remove_device_from_lcu(struct alias_lcu *lcu,
358 struct dasd_device *device)
360 struct dasd_eckd_private *private = device->private;
361 struct alias_pav_group *group;
363 list_move(&device->alias_list, &lcu->inactive_devices);
364 group = private->pavgroup;
367 private->pavgroup = NULL;
368 if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) {
369 list_del(&group->group);
373 if (group->next == device)
378 suborder_not_supported(struct dasd_ccw_req *cqr)
385 sense = dasd_get_sense(&cqr->irb);
390 msg_format = (sense[7] & 0xF0);
391 msg_no = (sense[7] & 0x0F);
393 /* command reject, Format 0 MSG 4 - invalid parameter */
394 if ((reason == 0x80) && (msg_format == 0x00) && (msg_no == 0x04))
401 * This function tries to lock all devices on an lcu via trylock
402 * return NULL on success otherwise return first failed device
404 static struct dasd_device *_trylock_all_devices_on_lcu(struct alias_lcu *lcu,
405 struct dasd_device *pos)
408 struct alias_pav_group *pavgroup;
409 struct dasd_device *device;
411 list_for_each_entry(device, &lcu->active_devices, alias_list) {
414 if (!spin_trylock(get_ccwdev_lock(device->cdev)))
417 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
420 if (!spin_trylock(get_ccwdev_lock(device->cdev)))
423 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
424 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
427 if (!spin_trylock(get_ccwdev_lock(device->cdev)))
430 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
433 if (!spin_trylock(get_ccwdev_lock(device->cdev)))
441 * unlock all devices except the one that is specified as pos
442 * stop if enddev is specified and reached
444 static void _unlock_all_devices_on_lcu(struct alias_lcu *lcu,
445 struct dasd_device *pos,
446 struct dasd_device *enddev)
449 struct alias_pav_group *pavgroup;
450 struct dasd_device *device;
452 list_for_each_entry(device, &lcu->active_devices, alias_list) {
455 if (device == enddev)
457 spin_unlock(get_ccwdev_lock(device->cdev));
459 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
462 if (device == enddev)
464 spin_unlock(get_ccwdev_lock(device->cdev));
466 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
467 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
470 if (device == enddev)
472 spin_unlock(get_ccwdev_lock(device->cdev));
474 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
477 if (device == enddev)
479 spin_unlock(get_ccwdev_lock(device->cdev));
485 * this function is needed because the locking order
486 * device lock -> lcu lock
487 * needs to be assured when iterating over devices in an LCU
489 * if a device is specified in pos then the device lock is already hold
491 static void _trylock_and_lock_lcu_irqsave(struct alias_lcu *lcu,
492 struct dasd_device *pos,
493 unsigned long *flags)
495 struct dasd_device *failed;
498 spin_lock_irqsave(&lcu->lock, *flags);
499 failed = _trylock_all_devices_on_lcu(lcu, pos);
501 _unlock_all_devices_on_lcu(lcu, pos, failed);
502 spin_unlock_irqrestore(&lcu->lock, *flags);
508 static void _trylock_and_lock_lcu(struct alias_lcu *lcu,
509 struct dasd_device *pos)
511 struct dasd_device *failed;
514 spin_lock(&lcu->lock);
515 failed = _trylock_all_devices_on_lcu(lcu, pos);
517 _unlock_all_devices_on_lcu(lcu, pos, failed);
518 spin_unlock(&lcu->lock);
524 static int read_unit_address_configuration(struct dasd_device *device,
525 struct alias_lcu *lcu)
527 struct dasd_psf_prssd_data *prssdp;
528 struct dasd_ccw_req *cqr;
533 cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
534 (sizeof(struct dasd_psf_prssd_data)),
538 cqr->startdev = device;
539 cqr->memdev = device;
540 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
542 cqr->expires = 20 * HZ;
544 /* Prepare for Read Subsystem Data */
545 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
546 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
547 prssdp->order = PSF_ORDER_PRSSD;
548 prssdp->suborder = 0x0e; /* Read unit address configuration */
549 /* all other bytes of prssdp must be zero */
552 ccw->cmd_code = DASD_ECKD_CCW_PSF;
553 ccw->count = sizeof(struct dasd_psf_prssd_data);
554 ccw->flags |= CCW_FLAG_CC;
555 ccw->cda = (__u32)(addr_t) prssdp;
557 /* Read Subsystem Data - feature codes */
558 memset(lcu->uac, 0, sizeof(*(lcu->uac)));
561 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
562 ccw->count = sizeof(*(lcu->uac));
563 ccw->cda = (__u32)(addr_t) lcu->uac;
565 cqr->buildclk = get_tod_clock();
566 cqr->status = DASD_CQR_FILLED;
568 /* need to unset flag here to detect race with summary unit check */
569 spin_lock_irqsave(&lcu->lock, flags);
570 lcu->flags &= ~NEED_UAC_UPDATE;
571 spin_unlock_irqrestore(&lcu->lock, flags);
574 rc = dasd_sleep_on(cqr);
575 if (rc && suborder_not_supported(cqr))
577 } while (rc && (cqr->retries > 0));
579 spin_lock_irqsave(&lcu->lock, flags);
580 lcu->flags |= NEED_UAC_UPDATE;
581 spin_unlock_irqrestore(&lcu->lock, flags);
583 dasd_kfree_request(cqr, cqr->memdev);
587 static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
590 struct alias_pav_group *pavgroup, *tempgroup;
591 struct dasd_device *device, *tempdev;
593 struct dasd_eckd_private *private;
595 spin_lock_irqsave(&lcu->lock, flags);
596 list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
597 list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
599 list_move(&device->alias_list, &lcu->active_devices);
600 private = device->private;
601 private->pavgroup = NULL;
603 list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
605 list_move(&device->alias_list, &lcu->active_devices);
606 private = device->private;
607 private->pavgroup = NULL;
609 list_del(&pavgroup->group);
612 spin_unlock_irqrestore(&lcu->lock, flags);
614 rc = read_unit_address_configuration(refdev, lcu);
618 _trylock_and_lock_lcu_irqsave(lcu, NULL, &flags);
620 for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
621 switch (lcu->uac->unit[i].ua_type) {
622 case UA_BASE_PAV_ALIAS:
625 case UA_HYPER_PAV_ALIAS:
626 lcu->pav = HYPER_PAV;
629 if (lcu->pav != NO_PAV)
633 list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
635 _add_device_to_lcu(lcu, device, refdev);
637 _unlock_all_devices_on_lcu(lcu, NULL, NULL);
638 spin_unlock_irqrestore(&lcu->lock, flags);
642 static void lcu_update_work(struct work_struct *work)
644 struct alias_lcu *lcu;
645 struct read_uac_work_data *ruac_data;
646 struct dasd_device *device;
650 ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
651 lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
652 device = ruac_data->device;
653 rc = _lcu_update(device, lcu);
655 * Need to check flags again, as there could have been another
656 * prepare_update or a new device a new device while we were still
657 * processing the data
659 spin_lock_irqsave(&lcu->lock, flags);
660 if ((rc && (rc != -EOPNOTSUPP)) || (lcu->flags & NEED_UAC_UPDATE)) {
661 DBF_DEV_EVENT(DBF_WARNING, device, "could not update"
662 " alias data in lcu (rc = %d), retry later", rc);
663 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ))
664 dasd_put_device(device);
666 dasd_put_device(device);
667 lcu->ruac_data.device = NULL;
668 lcu->flags &= ~UPDATE_PENDING;
670 spin_unlock_irqrestore(&lcu->lock, flags);
673 static int _schedule_lcu_update(struct alias_lcu *lcu,
674 struct dasd_device *device)
676 struct dasd_device *usedev = NULL;
677 struct alias_pav_group *group;
679 lcu->flags |= NEED_UAC_UPDATE;
680 if (lcu->ruac_data.device) {
681 /* already scheduled or running */
684 if (device && !list_empty(&device->alias_list))
687 if (!usedev && !list_empty(&lcu->grouplist)) {
688 group = list_first_entry(&lcu->grouplist,
689 struct alias_pav_group, group);
690 if (!list_empty(&group->baselist))
691 usedev = list_first_entry(&group->baselist,
694 else if (!list_empty(&group->aliaslist))
695 usedev = list_first_entry(&group->aliaslist,
699 if (!usedev && !list_empty(&lcu->active_devices)) {
700 usedev = list_first_entry(&lcu->active_devices,
701 struct dasd_device, alias_list);
704 * if we haven't found a proper device yet, give up for now, the next
705 * device that will be set active will trigger an lcu update
709 dasd_get_device(usedev);
710 lcu->ruac_data.device = usedev;
711 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 0))
712 dasd_put_device(usedev);
716 int dasd_alias_add_device(struct dasd_device *device)
718 struct dasd_eckd_private *private = device->private;
719 struct alias_lcu *lcu;
725 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
726 spin_lock(&lcu->lock);
727 if (!(lcu->flags & UPDATE_PENDING)) {
728 rc = _add_device_to_lcu(lcu, device, device);
730 lcu->flags |= UPDATE_PENDING;
732 if (lcu->flags & UPDATE_PENDING) {
733 list_move(&device->alias_list, &lcu->active_devices);
734 _schedule_lcu_update(lcu, device);
736 spin_unlock(&lcu->lock);
737 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
741 int dasd_alias_update_add_device(struct dasd_device *device)
743 struct dasd_eckd_private *private = device->private;
745 private->lcu->flags |= UPDATE_PENDING;
746 return dasd_alias_add_device(device);
749 int dasd_alias_remove_device(struct dasd_device *device)
751 struct dasd_eckd_private *private = device->private;
752 struct alias_lcu *lcu = private->lcu;
755 /* nothing to do if already removed */
758 spin_lock_irqsave(&lcu->lock, flags);
759 _remove_device_from_lcu(lcu, device);
760 spin_unlock_irqrestore(&lcu->lock, flags);
764 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
766 struct dasd_eckd_private *alias_priv, *private = base_device->private;
767 struct alias_pav_group *group = private->pavgroup;
768 struct alias_lcu *lcu = private->lcu;
769 struct dasd_device *alias_device;
774 if (lcu->pav == NO_PAV ||
775 lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
777 if (unlikely(!(private->features.feature[8] & 0x01))) {
779 * PAV enabled but prefix not, very unlikely
780 * seems to be a lost pathgroup
781 * use base device to do IO
783 DBF_DEV_EVENT(DBF_ERR, base_device, "%s",
784 "Prefix not enabled with PAV enabled\n");
788 spin_lock_irqsave(&lcu->lock, flags);
789 alias_device = group->next;
791 if (list_empty(&group->aliaslist)) {
792 spin_unlock_irqrestore(&lcu->lock, flags);
795 alias_device = list_first_entry(&group->aliaslist,
800 if (list_is_last(&alias_device->alias_list, &group->aliaslist))
801 group->next = list_first_entry(&group->aliaslist,
802 struct dasd_device, alias_list);
804 group->next = list_first_entry(&alias_device->alias_list,
805 struct dasd_device, alias_list);
806 spin_unlock_irqrestore(&lcu->lock, flags);
807 alias_priv = alias_device->private;
808 if ((alias_priv->count < private->count) && !alias_device->stopped &&
809 !test_bit(DASD_FLAG_OFFLINE, &alias_device->flags))
816 * Summary unit check handling depends on the way alias devices
817 * are handled so it is done here rather then in dasd_eckd.c
819 static int reset_summary_unit_check(struct alias_lcu *lcu,
820 struct dasd_device *device,
823 struct dasd_ccw_req *cqr;
828 strncpy((char *) &cqr->magic, "ECKD", 4);
829 ASCEBC((char *) &cqr->magic, 4);
831 ccw->cmd_code = DASD_ECKD_CCW_RSCK;
832 ccw->flags = CCW_FLAG_SLI;
834 ccw->cda = (__u32)(addr_t) cqr->data;
835 ((char *)cqr->data)[0] = reason;
837 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
838 cqr->retries = 255; /* set retry counter to enable basic ERP */
839 cqr->startdev = device;
840 cqr->memdev = device;
842 cqr->expires = 5 * HZ;
843 cqr->buildclk = get_tod_clock();
844 cqr->status = DASD_CQR_FILLED;
846 rc = dasd_sleep_on_immediatly(cqr);
850 static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
852 struct alias_pav_group *pavgroup;
853 struct dasd_device *device;
854 struct dasd_eckd_private *private;
856 /* active and inactive list can contain alias as well as base devices */
857 list_for_each_entry(device, &lcu->active_devices, alias_list) {
858 private = device->private;
859 if (private->uid.type != UA_BASE_DEVICE)
861 dasd_schedule_block_bh(device->block);
862 dasd_schedule_device_bh(device);
864 list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
865 private = device->private;
866 if (private->uid.type != UA_BASE_DEVICE)
868 dasd_schedule_block_bh(device->block);
869 dasd_schedule_device_bh(device);
871 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
872 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
873 dasd_schedule_block_bh(device->block);
874 dasd_schedule_device_bh(device);
879 static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
881 struct alias_pav_group *pavgroup;
882 struct dasd_device *device, *temp;
883 struct dasd_eckd_private *private;
889 * Problem here ist that dasd_flush_device_queue may wait
890 * for termination of a request to complete. We can't keep
891 * the lcu lock during that time, so we must assume that
892 * the lists may have changed.
893 * Idea: first gather all active alias devices in a separate list,
894 * then flush the first element of this list unlocked, and afterwards
895 * check if it is still on the list before moving it to the
896 * active_devices list.
899 spin_lock_irqsave(&lcu->lock, flags);
900 list_for_each_entry_safe(device, temp, &lcu->active_devices,
902 private = device->private;
903 if (private->uid.type == UA_BASE_DEVICE)
905 list_move(&device->alias_list, &active);
908 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
909 list_splice_init(&pavgroup->aliaslist, &active);
911 while (!list_empty(&active)) {
912 device = list_first_entry(&active, struct dasd_device,
914 spin_unlock_irqrestore(&lcu->lock, flags);
915 rc = dasd_flush_device_queue(device);
916 spin_lock_irqsave(&lcu->lock, flags);
918 * only move device around if it wasn't moved away while we
919 * were waiting for the flush
921 if (device == list_first_entry(&active,
922 struct dasd_device, alias_list)) {
923 list_move(&device->alias_list, &lcu->active_devices);
924 private = device->private;
925 private->pavgroup = NULL;
928 spin_unlock_irqrestore(&lcu->lock, flags);
931 static void _stop_all_devices_on_lcu(struct alias_lcu *lcu)
933 struct alias_pav_group *pavgroup;
934 struct dasd_device *device;
936 list_for_each_entry(device, &lcu->active_devices, alias_list)
937 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
938 list_for_each_entry(device, &lcu->inactive_devices, alias_list)
939 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
940 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
941 list_for_each_entry(device, &pavgroup->baselist, alias_list)
942 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
943 list_for_each_entry(device, &pavgroup->aliaslist, alias_list)
944 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
948 static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
950 struct alias_pav_group *pavgroup;
951 struct dasd_device *device;
953 list_for_each_entry(device, &lcu->active_devices, alias_list)
954 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
955 list_for_each_entry(device, &lcu->inactive_devices, alias_list)
956 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
957 list_for_each_entry(pavgroup, &lcu->grouplist, group) {
958 list_for_each_entry(device, &pavgroup->baselist, alias_list)
959 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
960 list_for_each_entry(device, &pavgroup->aliaslist, alias_list)
961 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
965 static void summary_unit_check_handling_work(struct work_struct *work)
967 struct alias_lcu *lcu;
968 struct summary_unit_check_work_data *suc_data;
970 struct dasd_device *device;
972 suc_data = container_of(work, struct summary_unit_check_work_data,
974 lcu = container_of(suc_data, struct alias_lcu, suc_data);
975 device = suc_data->device;
977 /* 1. flush alias devices */
978 flush_all_alias_devices_on_lcu(lcu);
980 /* 2. reset summary unit check */
981 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
982 dasd_device_remove_stop_bits(device,
983 (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
984 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
985 reset_summary_unit_check(lcu, device, suc_data->reason);
987 _trylock_and_lock_lcu_irqsave(lcu, NULL, &flags);
988 _unstop_all_devices_on_lcu(lcu);
989 _restart_all_base_devices_on_lcu(lcu);
990 /* 3. read new alias configuration */
991 _schedule_lcu_update(lcu, device);
992 lcu->suc_data.device = NULL;
993 dasd_put_device(device);
994 _unlock_all_devices_on_lcu(lcu, NULL, NULL);
995 spin_unlock_irqrestore(&lcu->lock, flags);
999 * note: this will be called from int handler context (cdev locked)
1001 void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
1004 struct dasd_eckd_private *private = device->private;
1005 struct alias_lcu *lcu;
1009 sense = dasd_get_sense(irb);
1012 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
1013 "eckd handle summary unit check: reason", reason);
1015 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1016 "eckd handle summary unit check:"
1017 " no reason code available");
1023 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1024 "device not ready to handle summary"
1025 " unit check (no lcu structure)");
1028 _trylock_and_lock_lcu(lcu, device);
1029 /* If this device is about to be removed just return and wait for
1030 * the next interrupt on a different device
1032 if (list_empty(&device->alias_list)) {
1033 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1034 "device is in offline processing,"
1035 " don't do summary unit check handling");
1036 _unlock_all_devices_on_lcu(lcu, device, NULL);
1037 spin_unlock(&lcu->lock);
1040 if (lcu->suc_data.device) {
1041 /* already scheduled or running */
1042 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1043 "previous instance of summary unit check worker"
1045 _unlock_all_devices_on_lcu(lcu, device, NULL);
1046 spin_unlock(&lcu->lock);
1049 _stop_all_devices_on_lcu(lcu);
1050 /* prepare for lcu_update */
1051 private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
1052 lcu->suc_data.reason = reason;
1053 lcu->suc_data.device = device;
1054 dasd_get_device(device);
1055 _unlock_all_devices_on_lcu(lcu, device, NULL);
1056 spin_unlock(&lcu->lock);
1057 if (!schedule_work(&lcu->suc_data.worker))
1058 dasd_put_device(device);