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