drivers/s390/block/dasd_alias.c

   1 /*
   2  * PAV alias management for the DASD ECKD discipline
   3  *
   4  * Copyright IBM Corp. 2007
   5  * Author(s): Stefan Weinhuber <wein@de.ibm.com>
   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;
 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);
 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  */
 186 int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
 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  */
 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         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)
 324                 spin_lock_irqsave_nested(get_ccwdev_lock(device->cdev), flags,
 325                                          CDEV_NESTED_SECOND);
 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;
 426         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
 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;
 438         ccw->cmd_code = DASD_ECKD_CCW_PSF;
 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++;
 447         ccw->cmd_code = DASD_ECKD_CCW_RSSD;
 448         ccw->count = sizeof(*(lcu->uac));
 449         ccw->cda = (__u32)(addr_t) lcu->uac;
 450
 451         cqr->buildclk = get_tod_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 */
 505         spin_lock_irqsave_nested(get_ccwdev_lock(refdev->cdev), flags,
 506                                  CDEV_NESTED_FIRST);
 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
 601 int dasd_alias_add_device(struct dasd_device *device)
 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 */
 613         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
 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
 629 int dasd_alias_update_add_device(struct dasd_device *device)
 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
 637 int dasd_alias_remove_device(struct dasd_device *device)
 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
 654 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
 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 ||
 669             lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
 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;
 724         ccw->cmd_code = DASD_ECKD_CCW_RSCK;
 725         ccw->flags = 0 ;
 726         ccw->count = 16;
 727         ccw->cda = (__u32)(addr_t) cqr->data;
 728         ((char *)cqr->data)[0] = reason;
 729
 730         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
 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_tod_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;
 753                 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
 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;
 765                 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
 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) {
 837                 dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
 838                 return;
 839         }
 840         spin_lock(get_ccwdev_lock(pos->cdev));
 841         dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
 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
 855         list_for_each_entry(pos, &lcu->active_devices, alias_list)
 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);
 875                 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
 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);
 881                 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
 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);
 888                         dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
 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);
 894                         dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
 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);
 918         dasd_device_remove_stop_bits(device,
 919                                      (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
 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  */
 935 void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
 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 };