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