Lines Matching refs:device
101 struct dasd_device *device;
108 struct dasd_device *device;
121 struct dasd_device *device;
140 /* set ECKD specific ccw-device options */
146 "ccw-device options");
215 * it is an EAV device or not
217 static int dasd_eckd_track_from_irb(struct irb *irb, struct dasd_device *device,
220 struct dasd_eckd_private *private = device->private;
227 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
232 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
253 struct dasd_device *device)
255 struct dasd_eckd_private *private = device->private;
281 unsigned int totrk, int cmd, struct dasd_device *device,
284 struct dasd_eckd_private *private = device->private;
325 rc = set_timestamp(ccw, data, device);
330 rc = set_timestamp(ccw, data, device);
338 rc = set_timestamp(ccw, data, device);
349 rc = set_timestamp(ccw, data, device);
352 dev_err(&device->cdev->dev,
389 int count, int cmd, struct dasd_device *device,
392 struct dasd_eckd_private *private = device->private;
517 DBF_DEV_EVENT(DBF_ERR, device,
607 struct dasd_device * device, int reclen)
609 struct dasd_eckd_private *private = device->private;
613 DBF_DEV_EVENT(DBF_INFO, device,
695 DBF_DEV_EVENT(DBF_ERR, device, "unknown locate record "
770 * Generate device unique id that specifies the physical device.
772 static int dasd_eckd_generate_uid(struct dasd_device *device)
774 struct dasd_eckd_private *private = device->private;
781 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
783 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
787 static int dasd_eckd_get_uid(struct dasd_device *device, struct dasd_uid *uid)
789 struct dasd_eckd_private *private = device->private;
793 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
795 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
802 * compare device UID with data of a given dasd_eckd_private structure
805 static int dasd_eckd_compare_path_uid(struct dasd_device *device,
812 dasd_eckd_get_uid(device, &device_uid);
817 static void dasd_eckd_fill_rcd_cqr(struct dasd_device *device,
825 * support for virtual device SNEQ
839 cqr->startdev = device;
840 cqr->memdev = device;
854 * to show support for virtual device SNEQ
874 static int dasd_eckd_read_conf_immediately(struct dasd_device *device,
885 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
889 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buffer, lpm);
898 static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
911 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
923 device, NULL);
925 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
930 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buf, lpm);
1005 static void dasd_eckd_store_conf_data(struct dasd_device *device,
1008 struct dasd_eckd_private *private = device->private;
1019 cdp = device->path[chp].conf_data;
1024 ccw_device_get_schid(device->cdev, &sch_id);
1025 device->path[chp].conf_data = conf_data;
1026 device->path[chp].cssid = sch_id.cssid;
1027 device->path[chp].ssid = sch_id.ssid;
1028 chp_desc = ccw_device_get_chp_desc(device->cdev, chp);
1030 device->path[chp].chpid = chp_desc->chpid;
1035 static void dasd_eckd_clear_conf_data(struct dasd_device *device)
1037 struct dasd_eckd_private *private = device->private;
1043 kfree(device->path[i].conf_data);
1044 device->path[i].conf_data = NULL;
1045 device->path[i].cssid = 0;
1046 device->path[i].ssid = 0;
1047 device->path[i].chpid = 0;
1048 dasd_path_notoper(device, i);
1052 static void dasd_eckd_read_fc_security(struct dasd_device *device)
1054 struct dasd_eckd_private *private = device->private;
1063 device->path[chp].fc_security = 0;
1069 device->path[chp].fc_security = esm[chp];
1071 device->path[chp].fc_security = 0;
1093 static int dasd_eckd_check_cabling(struct dasd_device *device,
1097 struct dasd_eckd_private *private = device->private;
1105 if (dasd_eckd_compare_path_uid(device, &path_conf)) {
1108 dev_err(&device->cdev->dev,
1109 "Not all channel paths lead to the same device, path %02X leads to device %s instead of %s\n",
1117 static int dasd_eckd_read_conf(struct dasd_device *device)
1125 private = device->private;
1126 opm = ccw_device_get_path_mask(device->cdev);
1133 rc = dasd_eckd_read_conf_lpm(device, &conf_data,
1136 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1142 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1146 dasd_path_add_opm(device, opm);
1152 dasd_eckd_clear_conf_data(device);
1162 * build device UID that other path data
1165 dasd_eckd_generate_uid(device);
1167 } else if (dasd_eckd_check_cabling(device, conf_data, lpm)) {
1168 dasd_path_add_cablepm(device, lpm);
1175 dasd_eckd_store_conf_data(device, conf_data, pos);
1179 dasd_path_add_nppm(device, lpm);
1182 dasd_path_add_ppm(device, lpm);
1185 if (!dasd_path_get_opm(device)) {
1186 dasd_path_set_opm(device, lpm);
1187 dasd_generic_path_operational(device);
1189 dasd_path_add_opm(device, lpm);
1196 static u32 get_fcx_max_data(struct dasd_device *device)
1198 struct dasd_eckd_private *private = device->private;
1214 mdc = ccw_device_get_mdc(device->cdev, 0);
1216 dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n");
1223 static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm)
1225 struct dasd_eckd_private *private = device->private;
1230 mdc = ccw_device_get_mdc(device->cdev, lpm);
1232 dev_warn(&device->cdev->dev,
1240 dev_warn(&device->cdev->dev,
1251 static int rebuild_device_uid(struct dasd_device *device,
1254 struct dasd_eckd_private *private = device->private;
1255 __u8 lpm, opm = dasd_path_get_opm(device);
1264 rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
1271 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1285 rc = dasd_eckd_generate_uid(device);
1290 static void dasd_eckd_path_available_action(struct dasd_device *device,
1314 rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
1330 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1335 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1336 "path verification: device is stopped,"
1340 dev_warn(&device->cdev->dev,
1341 "Reading device feature codes failed "
1345 if (verify_fcx_max_data(device, lpm)) {
1369 * compare path UID with device UID only if at least
1371 * in other case the device UID may have changed and
1372 * the first working path UID will be used as device UID
1374 if (dasd_path_get_opm(device) &&
1375 dasd_eckd_compare_path_uid(device, &path_conf)) {
1378 * rebuild the device UID with at least one
1380 * has changed the device
1387 if (rebuild_device_uid(device, data) ||
1389 device, &path_conf)) {
1391 dev_err(&device->cdev->dev,
1394 "to a different device %s\n",
1418 dasd_eckd_store_conf_data(device, conf_data, pos);
1423 * the device opm mask. We could avoid that race here by using
1427 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1428 if (!dasd_path_get_opm(device) && opm) {
1429 dasd_path_set_opm(device, opm);
1430 dasd_generic_path_operational(device);
1432 dasd_path_add_opm(device, opm);
1434 dasd_path_add_nppm(device, npm);
1435 dasd_path_add_ppm(device, ppm);
1437 dasd_path_add_tbvpm(device, epm);
1438 dasd_device_set_timer(device, 50);
1440 dasd_path_add_cablepm(device, cablepm);
1441 dasd_path_add_nohpfpm(device, hpfpm);
1442 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1444 dasd_path_create_kobj(device, pos);
1451 struct dasd_device *device;
1454 device = data->device;
1456 /* delay path verification until device was resumed */
1457 if (test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
1462 if (test_and_set_bit(DASD_FLAG_PATH_VERIFY, &device->flags)) {
1468 dasd_eckd_path_available_action(device, data);
1470 dasd_eckd_read_fc_security(device);
1472 clear_bit(DASD_FLAG_PATH_VERIFY, &device->flags);
1473 dasd_put_device(device);
1480 static int dasd_eckd_pe_handler(struct dasd_device *device,
1495 dasd_get_device(device);
1496 data->device = device;
1503 static void dasd_eckd_reset_path(struct dasd_device *device, __u8 pm)
1505 struct dasd_eckd_private *private = device->private;
1509 private->fcx_max_data = get_fcx_max_data(device);
1510 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1511 dasd_path_set_tbvpm(device, pm ? : dasd_path_get_notoperpm(device));
1512 dasd_schedule_device_bh(device);
1513 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1516 static int dasd_eckd_read_features(struct dasd_device *device)
1518 struct dasd_eckd_private *private = device->private;
1529 device, NULL);
1531 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not "
1535 cqr->startdev = device;
1536 cqr->memdev = device;
1572 dev_warn(&device->cdev->dev, "Reading device feature codes"
1579 static int dasd_eckd_read_vol_info(struct dasd_device *device)
1581 struct dasd_eckd_private *private = device->private;
1589 /* This command cannot be executed on an alias device */
1596 sizeof(*prssdp) + sizeof(*vsq), device, NULL);
1598 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1635 cqr->startdev = device;
1636 cqr->memdev = device;
1639 cqr->expires = device->default_expires * HZ;
1647 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1659 static int dasd_eckd_is_ese(struct dasd_device *device)
1661 struct dasd_eckd_private *private = device->private;
1666 static int dasd_eckd_ext_pool_id(struct dasd_device *device)
1668 struct dasd_eckd_private *private = device->private;
1678 static int dasd_eckd_space_configured(struct dasd_device *device)
1680 struct dasd_eckd_private *private = device->private;
1683 rc = dasd_eckd_read_vol_info(device);
1692 static int dasd_eckd_space_allocated(struct dasd_device *device)
1694 struct dasd_eckd_private *private = device->private;
1697 rc = dasd_eckd_read_vol_info(device);
1702 static int dasd_eckd_logical_capacity(struct dasd_device *device)
1704 struct dasd_eckd_private *private = device->private;
1712 struct dasd_device *device;
1716 device = data->device;
1720 base = device;
1722 dasd_generic_space_avail(device);
1724 dev_warn(&device->cdev->dev, "No space left in the extent pool\n");
1725 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "out of space");
1728 dasd_put_device(device);
1732 static int dasd_eckd_ext_pool_exhaust(struct dasd_device *device,
1741 dasd_get_device(device);
1742 data->device = device;
1756 static void dasd_eckd_cpy_ext_pool_data(struct dasd_device *device,
1759 struct dasd_eckd_private *private = device->private;
1760 int pool_id = dasd_eckd_ext_pool_id(device);
1774 static int dasd_eckd_read_ext_pool_info(struct dasd_device *device)
1776 struct dasd_eckd_private *private = device->private;
1783 /* This command cannot be executed on an alias device */
1789 sizeof(*prssdp) + sizeof(*lcq), device, NULL);
1791 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1819 cqr->startdev = device;
1820 cqr->memdev = device;
1823 cqr->expires = device->default_expires * HZ;
1829 dasd_eckd_cpy_ext_pool_data(device, lcq);
1831 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1841 * Depending on the device type, the extent size is specified either as
1845 static int dasd_eckd_ext_size(struct dasd_device *device)
1847 struct dasd_eckd_private *private = device->private;
1860 static int dasd_eckd_ext_pool_warn_thrshld(struct dasd_device *device)
1862 struct dasd_eckd_private *private = device->private;
1867 static int dasd_eckd_ext_pool_cap_at_warnlevel(struct dasd_device *device)
1869 struct dasd_eckd_private *private = device->private;
1877 static int dasd_eckd_ext_pool_oos(struct dasd_device *device)
1879 struct dasd_eckd_private *private = device->private;
1887 static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device,
1896 device, NULL);
1899 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1915 cqr->startdev = device;
1916 cqr->memdev = device;
1931 dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav,
1937 cqr = dasd_eckd_build_psf_ssc(device, enable_pav);
1959 * Valide storage server of current device.
1961 static int dasd_eckd_validate_server(struct dasd_device *device,
1964 struct dasd_eckd_private *private = device->private;
1974 rc = dasd_eckd_psf_ssc(device, enable_pav, flags);
1978 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x "
1988 struct dasd_device *device = container_of(work, struct dasd_device,
1993 if (dasd_eckd_validate_server(device, flags)
1996 schedule_work(&device->kick_validate);
2000 dasd_put_device(device);
2003 static void dasd_eckd_kick_validate_server(struct dasd_device *device)
2005 dasd_get_device(device);
2006 /* exit if device not online or in offline processing */
2007 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
2008 device->state < DASD_STATE_ONLINE) {
2009 dasd_put_device(device);
2013 if (!schedule_work(&device->kick_validate))
2014 dasd_put_device(device);
2018 * return if the device is the copy relation primary if a copy relation is active
2020 static int dasd_device_is_primary(struct dasd_device *device)
2022 if (!device->copy)
2025 if (device->copy->active->device == device)
2031 static int dasd_eckd_alloc_block(struct dasd_device *device)
2036 if (!dasd_device_is_primary(device))
2039 dasd_eckd_get_uid(device, &temp_uid);
2043 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
2047 device->block = block;
2048 block->base = device;
2053 static bool dasd_eckd_pprc_enabled(struct dasd_device *device)
2055 struct dasd_eckd_private *private = device->private;
2061 * Check device characteristics.
2062 * If the device is accessible using ECKD discipline, the device is enabled.
2065 dasd_eckd_check_characteristics(struct dasd_device *device)
2067 struct dasd_eckd_private *private = device->private;
2073 INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server);
2075 INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check);
2077 if (!ccw_device_is_pathgroup(device->cdev)) {
2078 dev_warn(&device->cdev->dev,
2082 if (!ccw_device_is_multipath(device->cdev)) {
2083 dev_info(&device->cdev->dev,
2089 dev_warn(&device->cdev->dev,
2094 device->private = private;
2105 rc = dasd_eckd_read_conf(device);
2110 device->default_expires = DASD_EXPIRES;
2111 device->default_retries = DASD_RETRIES;
2112 device->path_thrhld = DASD_ECKD_PATH_THRHLD;
2113 device->path_interval = DASD_ECKD_PATH_INTERVAL;
2114 device->aq_timeouts = DASD_RETRIES_MAX;
2123 device->default_expires = value;
2127 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
2130 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
2131 "Read device characteristic failed, rc=%d", rc);
2135 /* setup PPRC for device from devmap */
2136 rc = dasd_devmap_set_device_copy_relation(device->cdev,
2137 dasd_eckd_pprc_enabled(device));
2139 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
2144 /* check if block device is needed and allocate in case */
2145 rc = dasd_eckd_alloc_block(device);
2150 rc = dasd_alias_make_device_known_to_lcu(device);
2154 dasd_eckd_validate_server(device, 0);
2156 /* device may report different configuration data after LCU setup */
2157 rc = dasd_eckd_read_conf(device);
2161 dasd_eckd_read_fc_security(device);
2162 dasd_path_create_kobjects(device);
2165 dasd_eckd_read_features(device);
2168 dasd_eckd_read_vol_info(device);
2171 dasd_eckd_read_ext_pool_info(device);
2173 if ((device->features & DASD_FEATURE_USERAW) &&
2175 dev_err(&device->cdev->dev, "The storage server does not "
2188 private->fcx_max_data = get_fcx_max_data(device);
2190 readonly = dasd_device_is_ro(device);
2192 set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
2194 dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
2203 readonly ? ", read-only device" : "");
2207 dasd_alias_disconnect_device_from_lcu(device);
2209 dasd_free_block(device->block);
2210 device->block = NULL;
2212 dasd_eckd_clear_conf_data(device);
2213 dasd_path_remove_kobjects(device);
2214 kfree(device->private);
2215 device->private = NULL;
2219 static void dasd_eckd_uncheck_device(struct dasd_device *device)
2221 struct dasd_eckd_private *private = device->private;
2226 dasd_alias_disconnect_device_from_lcu(device);
2231 dasd_eckd_clear_conf_data(device);
2232 dasd_path_remove_kobjects(device);
2236 dasd_eckd_analysis_ccw(struct dasd_device *device)
2238 struct dasd_eckd_private *private = device->private;
2248 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device,
2255 DASD_ECKD_CCW_READ_COUNT, device, 0);
2260 DASD_ECKD_CCW_READ_COUNT, device, 0);
2276 DASD_ECKD_CCW_READ_COUNT, device, 0);
2285 cqr->startdev = device;
2286 cqr->memdev = device;
2316 * the device to continue the startup sequence. This will call
2323 struct dasd_device *device = init_cqr->startdev;
2324 struct dasd_eckd_private *private = device->private;
2327 dasd_sfree_request(init_cqr, device);
2328 dasd_kick_device(device);
2352 struct dasd_device *device = block->base;
2353 struct dasd_eckd_private *private = device->private;
2363 init_cqr = dasd_eckd_analysis_ccw(device);
2366 dasd_sfree_request(init_cqr, device);
2369 if (device->features & DASD_FEATURE_USERAW) {
2377 dev_warn(&device->cdev->dev, "The DASD is not formatted\n");
2380 dev_err(&device->cdev->dev,
2416 dev_warn(&device->cdev->dev,
2426 dev_warn(&device->cdev->dev,
2441 dev_info(&device->cdev->dev,
2464 static int dasd_eckd_basic_to_ready(struct dasd_device *device)
2466 return dasd_alias_add_device(device);
2469 static int dasd_eckd_online_to_ready(struct dasd_device *device)
2471 if (cancel_work_sync(&device->reload_device))
2472 dasd_put_device(device);
2473 if (cancel_work_sync(&device->kick_validate))
2474 dasd_put_device(device);
2479 static int dasd_eckd_basic_to_known(struct dasd_device *device)
2481 return dasd_alias_remove_device(device);
3004 struct dasd_device *device;
3072 device = cqr->startdev;
3073 private = device->private;
3087 dasd_ffree_request(cqr, device);
3174 struct dasd_device *device = cqr->startdev;
3175 struct dasd_eckd_private *private = device->private;
3180 dasd_ffree_request(cqr, device);
3574 struct dasd_device *device = (struct dasd_device *) cqr->startdev;
3575 struct ccw_device *cdev = device->cdev;
3596 static void dasd_eckd_check_for_device_change(struct dasd_device *device,
3602 struct dasd_eckd_private *private = device->private;
3611 if (!device->block && private->lcu &&
3612 device->state == DASD_STATE_ONLINE &&
3613 !test_bit(DASD_FLAG_OFFLINE, &device->flags) &&
3614 !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
3615 /* schedule worker to reload device */
3616 dasd_reload_device(device);
3618 dasd_generic_handle_state_change(device);
3629 if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) {
3630 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
3631 "eckd suc: device already notified");
3636 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
3638 clear_bit(DASD_FLAG_SUC, &device->flags);
3643 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
3646 dasd_get_device(device);
3647 if (!schedule_work(&device->suc_work))
3648 dasd_put_device(device);
3656 dasd_3990_erp_handle_sim(device, sense);
3660 /* loss of device reservation is handled via base devices only
3663 if (device->block && (sense[27] & DASD_SENSE_BIT_0) &&
3666 test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) {
3667 if (device->features & DASD_FEATURE_FAILONSLCK)
3668 set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
3669 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
3670 dev_err(&device->cdev->dev,
3671 "The device reservation was lost\n");
3675 static int dasd_eckd_ras_sanity_checks(struct dasd_device *device,
3679 struct dasd_eckd_private *private = device->private;
3686 dev_warn(&device->cdev->dev,
3691 dev_warn(&device->cdev->dev,
3696 dev_warn(&device->cdev->dev,
3738 static int dasd_in_copy_relation(struct dasd_device *device)
3743 if (!dasd_eckd_pprc_enabled(device))
3750 rc = dasd_eckd_query_pprc_status(device, temp);
3762 dasd_eckd_dso_ras(struct dasd_device *device, struct dasd_block *block,
3766 struct dasd_eckd_private *private = device->private;
3783 if (dasd_eckd_ras_sanity_checks(device, first_trk, last_trk))
3786 copy_relation = dasd_in_copy_relation(device);
3794 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
3801 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, size, device, rq);
3803 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
3858 cqr->startdev = device;
3859 cqr->memdev = device;
3862 cqr->expires = device->default_expires * HZ;
3869 static int dasd_eckd_release_space_full(struct dasd_device *device)
3874 cqr = dasd_eckd_dso_ras(device, NULL, NULL, 0, 0, 0);
3885 static int dasd_eckd_release_space_trks(struct dasd_device *device,
3888 struct dasd_eckd_private *private = device->private;
3889 struct dasd_block *block = device->block;
3901 device_exts = private->real_cyl / dasd_eckd_ext_size(device);
3902 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
3904 /* Make sure device limits are not exceeded */
3916 cqr = dasd_eckd_dso_ras(device, NULL, NULL, cur_pos, stop, 1);
3938 device = cqr->startdev;
3939 private = device->private;
3944 dasd_sfree_request(cqr, device);
3953 static int dasd_eckd_release_space(struct dasd_device *device,
3957 return dasd_eckd_release_space_full(device);
3959 return dasd_eckd_release_space_trks(device, rdata->start_unit,
4948 * Modify ccw/tcw in cqr so it can be started on a base device.
5023 dasd_eckd_fill_info(struct dasd_device * device,
5026 struct dasd_eckd_private *private = device->private;
5046 * Release device ioctl.
5048 * (see dasd_eckd_reserve) device.
5051 dasd_eckd_release(struct dasd_device *device)
5062 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
5079 cqr->startdev = device;
5080 cqr->memdev = device;
5090 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5100 * Reserve device ioctl.
5106 dasd_eckd_reserve(struct dasd_device *device)
5117 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
5134 cqr->startdev = device;
5135 cqr->memdev = device;
5145 set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5155 * Steal lock ioctl - unconditional reserve device.
5156 * Buils a channel programm to break a device's reservation.
5160 dasd_eckd_steal_lock(struct dasd_device *device)
5171 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
5188 cqr->startdev = device;
5189 cqr->memdev = device;
5199 set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5214 static int dasd_eckd_snid(struct dasd_device *device,
5231 sizeof(struct dasd_snid_data), device,
5249 cqr->startdev = device;
5250 cqr->memdev = device;
5281 dasd_eckd_performance(struct dasd_device *device, void __user *argp)
5292 device, NULL);
5294 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
5298 cqr->startdev = device;
5299 cqr->memdev = device;
5345 dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp)
5347 struct dasd_eckd_private *private = device->private;
5369 dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp)
5371 struct dasd_eckd_private *private = device->private;
5383 dev_info(&device->cdev->dev,
5393 static int dasd_symm_io(struct dasd_device *device, void __user *argp)
5422 DBF_DEV_EVENT(DBF_WARNING, device,
5446 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2, 0, device, NULL);
5448 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
5454 cqr->startdev = device;
5455 cqr->memdev = device;
5494 DBF_DEV_EVENT(DBF_WARNING, device,
5503 struct dasd_device *device = block->base;
5507 return dasd_eckd_get_attrib(device, argp);
5509 return dasd_eckd_set_attrib(device, argp);
5511 return dasd_eckd_performance(device, argp);
5513 return dasd_eckd_release(device);
5515 return dasd_eckd_reserve(device);
5517 return dasd_eckd_steal_lock(device);
5519 return dasd_eckd_snid(device, argp);
5521 return dasd_symm_io(device, argp);
5567 dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb,
5576 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : "
5581 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : %s",
5591 static void dasd_eckd_dump_sense_ccw(struct dasd_device *device,
5600 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
5606 " I/O status report for device %s:\n",
5607 dev_name(&device->cdev->dev));
5616 " device %s: Failing CCW: %p\n",
5617 dev_name(&device->cdev->dev),
5689 static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
5699 DBF_DEV_EVENT(DBF_WARNING, device, " %s",
5705 " I/O status report for device %s:\n",
5706 dev_name(&device->cdev->dev));
5717 " device %s: Failing TCW: %p\n",
5718 dev_name(&device->cdev->dev),
5818 static void dasd_eckd_dump_sense(struct dasd_device *device,
5836 dasd_eckd_dump_sense_tcw(device, req, irb);
5851 dasd_eckd_dump_sense_ccw(device, req, irb);
5855 static int dasd_eckd_reload_device(struct dasd_device *device)
5857 struct dasd_eckd_private *private = device->private;
5864 * remove device from alias handling to prevent new requests
5865 * from being scheduled on the wrong alias device
5867 dasd_alias_remove_device(device);
5869 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
5871 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
5874 rc = dasd_eckd_read_conf(device);
5878 dasd_eckd_read_fc_security(device);
5880 rc = dasd_eckd_generate_uid(device);
5885 * add device to alias management
5887 dasd_alias_update_add_device(device);
5889 dasd_eckd_get_uid(device, &uid);
5893 dev_info(&device->cdev->dev,
5894 "An Alias device was reassigned to a new base device "
5903 static int dasd_eckd_read_message_buffer(struct dasd_device *device,
5916 device, NULL);
5918 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
5925 cqr->startdev = device;
5926 cqr->memdev = device;
5978 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
5985 static int dasd_eckd_query_host_access(struct dasd_device *device,
5988 struct dasd_eckd_private *private = device->private;
5996 if (!device->block && private->lcu->pav == HYPER_PAV)
6005 device, NULL);
6007 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6013 dasd_sfree_request(cqr, device);
6014 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6018 cqr->startdev = device;
6019 cqr->memdev = device;
6056 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6069 static int dasd_eckd_host_access_count(struct dasd_device *device)
6079 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6083 rc = dasd_eckd_query_host_access(device, access);
6105 static int dasd_hosts_print(struct dasd_device *device, struct seq_file *m)
6115 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6119 rc = dasd_eckd_query_host_access(device, access);
6158 return copy->entry[i].device;
6164 * set the new active/primary device
6192 static int dasd_eckd_copy_pair_swap(struct dasd_device *device, char *prim_busid,
6200 copy = device->copy;
6203 primary = copy->active->device;
6215 * usually the device should be quiesced for swap
6216 * for paranoia stop device and requeue requests again
6222 /* swap DASD internal device <> block assignment */
6227 /* set new primary device in COPY relation */
6230 /* swap blocklayer device link */
6234 /* re-enable device */
6245 static int dasd_eckd_query_pprc_status(struct dasd_device *device,
6256 device, NULL);
6258 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6262 cqr->startdev = device;
6263 cqr->memdev = device;
6297 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6310 static int dasd_eckd_nop(struct dasd_device *device)
6316 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 1, device, NULL);
6318 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6322 cqr->startdev = device;
6323 cqr->memdev = device;
6337 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6345 static int dasd_eckd_device_ping(struct dasd_device *device)
6347 return dasd_eckd_nop(device);
6354 dasd_eckd_psf_cuir_response(struct dasd_device *device, int response,
6365 device, NULL);
6368 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
6376 psf_cuir->chpid = device->path[pos].chpid;
6378 psf_cuir->cssid = device->path[pos].cssid;
6379 psf_cuir->ssid = device->path[pos].ssid;
6386 cqr->startdev = device;
6387 cqr->memdev = device;
6406 static struct dasd_conf_data *dasd_eckd_get_ref_conf(struct dasd_device *device,
6416 conf_data = device->path[pos].conf_data;
6422 return device->path[pathmask_to_pos(lpum)].conf_data;
6427 * analysing the path and device selection data provided in the CUIR request.
6428 * Returns a path mask containing CUIR affected paths for the give device.
6434 static int dasd_eckd_cuir_scope(struct dasd_device *device, __u8 lpum,
6452 ref_conf_data = dasd_eckd_get_ref_conf(device, lpum, cuir);
6465 conf_data = device->path[path].conf_data;
6484 /* device and path match the reference values
6491 static void dasd_eckd_cuir_notify_user(struct dasd_device *device,
6502 device->path[pos].cssid,
6503 device->path[pos].chpid);
6506 device->path[pos].cssid,
6507 device->path[pos].chpid);
6512 static int dasd_eckd_cuir_remove_path(struct dasd_device *device, __u8 lpum,
6517 tbcpm = dasd_eckd_cuir_scope(device, lpum, cuir);
6519 if (!(dasd_path_get_opm(device) & tbcpm))
6521 if (!(dasd_path_get_opm(device) & ~tbcpm)) {
6526 /* remove device from operational path mask */
6527 dasd_path_remove_opm(device, tbcpm);
6528 dasd_path_add_cuirpm(device, tbcpm);
6534 * return an error if the last path to a device would be removed
6540 static int dasd_eckd_cuir_quiesce(struct dasd_device *device, __u8 lpum,
6543 struct dasd_eckd_private *private = device->private;
6595 dasd_eckd_cuir_notify_user(device, paths, CUIR_QUIESCE);
6601 static int dasd_eckd_cuir_resume(struct dasd_device *device, __u8 lpum,
6604 struct dasd_eckd_private *private = device->private;
6660 dasd_eckd_cuir_notify_user(device, paths, CUIR_RESUME);
6664 static void dasd_eckd_handle_cuir(struct dasd_device *device, void *messages,
6670 DBF_DEV_EVENT(DBF_WARNING, device,
6677 if (dasd_eckd_cuir_quiesce(device, lpum, cuir))
6683 dasd_eckd_cuir_resume(device, lpum, cuir);
6688 dasd_eckd_psf_cuir_response(device, response,
6690 DBF_DEV_EVENT(DBF_WARNING, device,
6694 device->discipline->check_attention(device, lpum);
6697 static void dasd_eckd_oos_resume(struct dasd_device *device)
6699 struct dasd_eckd_private *private = device->private;
6733 static void dasd_eckd_handle_oos(struct dasd_device *device, void *messages,
6741 dev_warn(&device->cdev->dev,
6743 dasd_eckd_oos_resume(device);
6747 dev_warn(&device->cdev->dev,
6752 dev_info(&device->cdev->dev,
6758 dasd_eckd_read_ext_pool_info(device);
6761 device->discipline->check_attention(device, lpum);
6768 struct dasd_device *device;
6772 device = data->device;
6775 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
6779 rc = dasd_eckd_read_message_buffer(device, messages, data->lpum);
6785 dasd_eckd_handle_cuir(device, messages, data->lpum);
6788 dasd_eckd_handle_oos(device, messages, data->lpum);
6791 dasd_put_device(device);
6796 static int dasd_eckd_check_attention(struct dasd_device *device, __u8 lpum)
6804 dasd_get_device(device);
6805 data->device = device;
6811 static int dasd_eckd_disable_hpf_path(struct dasd_device *device, __u8 lpum)
6813 if (~lpum & dasd_path_get_opm(device)) {
6814 dasd_path_add_nohpfpm(device, lpum);
6815 dasd_path_remove_opm(device, lpum);
6816 dev_err(&device->cdev->dev,
6824 static void dasd_eckd_disable_hpf_device(struct dasd_device *device)
6826 struct dasd_eckd_private *private = device->private;
6828 dev_err(&device->cdev->dev,
6833 static int dasd_eckd_hpf_enabled(struct dasd_device *device)
6835 struct dasd_eckd_private *private = device->private;
6840 static void dasd_eckd_handle_hpf_error(struct dasd_device *device,
6843 struct dasd_eckd_private *private = device->private;
6847 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
6848 "Trying to disable HPF for a non HPF device");
6852 dasd_eckd_disable_hpf_device(device);
6854 if (dasd_eckd_disable_hpf_path(device, irb->esw.esw1.lpum))
6856 dasd_eckd_disable_hpf_device(device);
6857 dasd_path_set_tbvpm(device,
6858 dasd_path_get_hpfpm(device));
6861 * prevent that any new I/O ist started on the device and schedule a
6864 dasd_device_set_stop_bits(device, DASD_STOPPED_NOT_ACC);
6865 dasd_schedule_requeue(device);
6875 struct dasd_device *device = block->base;
6878 if (device->features & DASD_FEATURE_USERAW) {