drivers/s390/block/dasd_ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
   4  *                  Horst Hummel <Horst.Hummel@de.ibm.com>
   5  *                  Carsten Otte <Cotte@de.ibm.com>
   6  *                  Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  * Bugreports.to..: <Linux390@de.ibm.com>
   8  * Copyright IBM Corp. 1999, 2001
   9  *
  10  * i/o controls for the dasd driver.
  11  */
  12
  13 #define KMSG_COMPONENT "dasd"
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/compat.h>
  17 #include <linux/major.h>
  18 #include <linux/fs.h>
  19 #include <linux/blkpg.h>
  20 #include <linux/slab.h>
  21 #include <asm/compat.h>
  22 #include <asm/ccwdev.h>
  23 #include <asm/schid.h>
  24 #include <asm/cmb.h>
  25 #include <linux/uaccess.h>
  26
  27 /* This is ugly... */
  28 #define PRINTK_HEADER "dasd_ioctl:"
  29
  30 #include "dasd_int.h"
  31
  32
  33 static int
  34 dasd_ioctl_api_version(void __user *argp)
  35 {
  36         int ver = DASD_API_VERSION;
  37         return put_user(ver, (int __user *)argp);
  38 }
  39
  40 /*
  41  * Enable device.
  42  * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
  43  */
  44 static int
  45 dasd_ioctl_enable(struct block_device *bdev)
  46 {
  47         struct dasd_device *base;
  48
  49         if (!capable(CAP_SYS_ADMIN))
  50                 return -EACCES;
  51
  52         base = dasd_device_from_gendisk(bdev->bd_disk);
  53         if (!base)
  54                 return -ENODEV;
  55
  56         dasd_enable_device(base);
  57         /* Formatting the dasd device can change the capacity. */
  58         mutex_lock(&bdev->bd_mutex);
  59         i_size_write(bdev->bd_inode,
  60                      (loff_t)get_capacity(base->block->gdp) << 9);
  61         mutex_unlock(&bdev->bd_mutex);
  62         dasd_put_device(base);
  63         return 0;
  64 }
  65
  66 /*
  67  * Disable device.
  68  * Used by dasdfmt. Disable I/O operations but allow ioctls.
  69  */
  70 static int
  71 dasd_ioctl_disable(struct block_device *bdev)
  72 {
  73         struct dasd_device *base;
  74
  75         if (!capable(CAP_SYS_ADMIN))
  76                 return -EACCES;
  77
  78         base = dasd_device_from_gendisk(bdev->bd_disk);
  79         if (!base)
  80                 return -ENODEV;
  81         /*
  82          * Man this is sick. We don't do a real disable but only downgrade
  83          * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
  84          * BIODASDDISABLE to disable accesses to the device via the block
  85          * device layer but it still wants to do i/o on the device by
  86          * using the BIODASDFMT ioctl. Therefore the correct state for the
  87          * device is DASD_STATE_BASIC that allows to do basic i/o.
  88          */
  89         dasd_set_target_state(base, DASD_STATE_BASIC);
  90         /*
  91          * Set i_size to zero, since read, write, etc. check against this
  92          * value.
  93          */
  94         mutex_lock(&bdev->bd_mutex);
  95         i_size_write(bdev->bd_inode, 0);
  96         mutex_unlock(&bdev->bd_mutex);
  97         dasd_put_device(base);
  98         return 0;
  99 }
 100
 101 /*
 102  * Quiesce device.
 103  */
 104 static int dasd_ioctl_quiesce(struct dasd_block *block)
 105 {
 106         unsigned long flags;
 107         struct dasd_device *base;
 108
 109         base = block->base;
 110         if (!capable (CAP_SYS_ADMIN))
 111                 return -EACCES;
 112
 113         pr_info("%s: The DASD has been put in the quiesce "
 114                 "state\n", dev_name(&base->cdev->dev));
 115         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
 116         dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
 117         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
 118         return 0;
 119 }
 120
 121
 122 /*
 123  * Resume device.
 124  */
 125 static int dasd_ioctl_resume(struct dasd_block *block)
 126 {
 127         unsigned long flags;
 128         struct dasd_device *base;
 129
 130         base = block->base;
 131         if (!capable (CAP_SYS_ADMIN))
 132                 return -EACCES;
 133
 134         pr_info("%s: I/O operations have been resumed "
 135                 "on the DASD\n", dev_name(&base->cdev->dev));
 136         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
 137         dasd_device_remove_stop_bits(base, DASD_STOPPED_QUIESCE);
 138         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
 139
 140         dasd_schedule_block_bh(block);
 141         dasd_schedule_device_bh(base);
 142         return 0;
 143 }
 144
 145 /*
 146  * Abort all failfast I/O on a device.
 147  */
 148 static int dasd_ioctl_abortio(struct dasd_block *block)
 149 {
 150         unsigned long flags;
 151         struct dasd_device *base;
 152         struct dasd_ccw_req *cqr, *n;
 153
 154         base = block->base;
 155         if (!capable(CAP_SYS_ADMIN))
 156                 return -EACCES;
 157
 158         if (test_and_set_bit(DASD_FLAG_ABORTALL, &base->flags))
 159                 return 0;
 160         DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag set");
 161
 162         spin_lock_irqsave(&block->request_queue_lock, flags);
 163         spin_lock(&block->queue_lock);
 164         list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) {
 165                 if (test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
 166                     cqr->callback_data &&
 167                     cqr->callback_data != DASD_SLEEPON_START_TAG &&
 168                     cqr->callback_data != DASD_SLEEPON_END_TAG) {
 169                         spin_unlock(&block->queue_lock);
 170                         blk_abort_request(cqr->callback_data);
 171                         spin_lock(&block->queue_lock);
 172                 }
 173         }
 174         spin_unlock(&block->queue_lock);
 175         spin_unlock_irqrestore(&block->request_queue_lock, flags);
 176
 177         dasd_schedule_block_bh(block);
 178         return 0;
 179 }
 180
 181 /*
 182  * Allow I/O on a device
 183  */
 184 static int dasd_ioctl_allowio(struct dasd_block *block)
 185 {
 186         struct dasd_device *base;
 187
 188         base = block->base;
 189         if (!capable(CAP_SYS_ADMIN))
 190                 return -EACCES;
 191
 192         if (test_and_clear_bit(DASD_FLAG_ABORTALL, &base->flags))
 193                 DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag unset");
 194
 195         return 0;
 196 }
 197
 198 /*
 199  * performs formatting of _device_ according to _fdata_
 200  * Note: The discipline's format_function is assumed to deliver formatting
 201  * commands to format multiple units of the device. In terms of the ECKD
 202  * devices this means CCWs are generated to format multiple tracks.
 203  */
 204 static int
 205 dasd_format(struct dasd_block *block, struct format_data_t *fdata)
 206 {
 207         struct dasd_device *base;
 208         int rc;
 209
 210         base = block->base;
 211         if (base->discipline->format_device == NULL)
 212                 return -EPERM;
 213
 214         if (base->state != DASD_STATE_BASIC) {
 215                 pr_warn("%s: The DASD cannot be formatted while it is enabled\n",
 216                         dev_name(&base->cdev->dev));
 217                 return -EBUSY;
 218         }
 219
 220         DBF_DEV_EVENT(DBF_NOTICE, base,
 221                       "formatting units %u to %u (%u B blocks) flags %u",
 222                       fdata->start_unit,
 223                       fdata->stop_unit, fdata->blksize, fdata->intensity);
 224
 225         /* Since dasdfmt keeps the device open after it was disabled,
 226          * there still exists an inode for this device.
 227          * We must update i_blkbits, otherwise we might get errors when
 228          * enabling the device later.
 229          */
 230         if (fdata->start_unit == 0) {
 231                 struct block_device *bdev = bdget_disk(block->gdp, 0);
 232                 bdev->bd_inode->i_blkbits = blksize_bits(fdata->blksize);
 233                 bdput(bdev);
 234         }
 235
 236         rc = base->discipline->format_device(base, fdata, 1);
 237         if (rc == -EAGAIN)
 238                 rc = base->discipline->format_device(base, fdata, 0);
 239
 240         return rc;
 241 }
 242
 243 static int dasd_check_format(struct dasd_block *block,
 244                              struct format_check_t *cdata)
 245 {
 246         struct dasd_device *base;
 247         int rc;
 248
 249         base = block->base;
 250         if (!base->discipline->check_device_format)
 251                 return -ENOTTY;
 252
 253         rc = base->discipline->check_device_format(base, cdata, 1);
 254         if (rc == -EAGAIN)
 255                 rc = base->discipline->check_device_format(base, cdata, 0);
 256
 257         return rc;
 258 }
 259
 260 /*
 261  * Format device.
 262  */
 263 static int
 264 dasd_ioctl_format(struct block_device *bdev, void __user *argp)
 265 {
 266         struct dasd_device *base;
 267         struct format_data_t fdata;
 268         int rc;
 269
 270         if (!capable(CAP_SYS_ADMIN))
 271                 return -EACCES;
 272         if (!argp)
 273                 return -EINVAL;
 274         base = dasd_device_from_gendisk(bdev->bd_disk);
 275         if (!base)
 276                 return -ENODEV;
 277         if (base->features & DASD_FEATURE_READONLY ||
 278             test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
 279                 dasd_put_device(base);
 280                 return -EROFS;
 281         }
 282         if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
 283                 dasd_put_device(base);
 284                 return -EFAULT;
 285         }
 286         if (bdev != bdev->bd_contains) {
 287                 pr_warn("%s: The specified DASD is a partition and cannot be formatted\n",
 288                         dev_name(&base->cdev->dev));
 289                 dasd_put_device(base);
 290                 return -EINVAL;
 291         }
 292         rc = dasd_format(base->block, &fdata);
 293         dasd_put_device(base);
 294
 295         return rc;
 296 }
 297
 298 /*
 299  * Check device format
 300  */
 301 static int dasd_ioctl_check_format(struct block_device *bdev, void __user *argp)
 302 {
 303         struct format_check_t cdata;
 304         struct dasd_device *base;
 305         int rc = 0;
 306
 307         if (!argp)
 308                 return -EINVAL;
 309
 310         base = dasd_device_from_gendisk(bdev->bd_disk);
 311         if (!base)
 312                 return -ENODEV;
 313         if (bdev != bdev->bd_contains) {
 314                 pr_warn("%s: The specified DASD is a partition and cannot be checked\n",
 315                         dev_name(&base->cdev->dev));
 316                 rc = -EINVAL;
 317                 goto out_err;
 318         }
 319
 320         if (copy_from_user(&cdata, argp, sizeof(cdata))) {
 321                 rc = -EFAULT;
 322                 goto out_err;
 323         }
 324
 325         rc = dasd_check_format(base->block, &cdata);
 326         if (rc)
 327                 goto out_err;
 328
 329         if (copy_to_user(argp, &cdata, sizeof(cdata)))
 330                 rc = -EFAULT;
 331
 332 out_err:
 333         dasd_put_device(base);
 334
 335         return rc;
 336 }
 337
 338 #ifdef CONFIG_DASD_PROFILE
 339 /*
 340  * Reset device profile information
 341  */
 342 static int dasd_ioctl_reset_profile(struct dasd_block *block)
 343 {
 344         dasd_profile_reset(&block->profile);
 345         return 0;
 346 }
 347
 348 /*
 349  * Return device profile information
 350  */
 351 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
 352 {
 353         struct dasd_profile_info_t *data;
 354         int rc = 0;
 355
 356         data = kmalloc(sizeof(*data), GFP_KERNEL);
 357         if (!data)
 358                 return -ENOMEM;
 359
 360         spin_lock_bh(&block->profile.lock);
 361         if (block->profile.data) {
 362                 data->dasd_io_reqs = block->profile.data->dasd_io_reqs;
 363                 data->dasd_io_sects = block->profile.data->dasd_io_sects;
 364                 memcpy(data->dasd_io_secs, block->profile.data->dasd_io_secs,
 365                        sizeof(data->dasd_io_secs));
 366                 memcpy(data->dasd_io_times, block->profile.data->dasd_io_times,
 367                        sizeof(data->dasd_io_times));
 368                 memcpy(data->dasd_io_timps, block->profile.data->dasd_io_timps,
 369                        sizeof(data->dasd_io_timps));
 370                 memcpy(data->dasd_io_time1, block->profile.data->dasd_io_time1,
 371                        sizeof(data->dasd_io_time1));
 372                 memcpy(data->dasd_io_time2, block->profile.data->dasd_io_time2,
 373                        sizeof(data->dasd_io_time2));
 374                 memcpy(data->dasd_io_time2ps,
 375                        block->profile.data->dasd_io_time2ps,
 376                        sizeof(data->dasd_io_time2ps));
 377                 memcpy(data->dasd_io_time3, block->profile.data->dasd_io_time3,
 378                        sizeof(data->dasd_io_time3));
 379                 memcpy(data->dasd_io_nr_req,
 380                        block->profile.data->dasd_io_nr_req,
 381                        sizeof(data->dasd_io_nr_req));
 382                 spin_unlock_bh(&block->profile.lock);
 383         } else {
 384                 spin_unlock_bh(&block->profile.lock);
 385                 rc = -EIO;
 386                 goto out;
 387         }
 388         if (copy_to_user(argp, data, sizeof(*data)))
 389                 rc = -EFAULT;
 390 out:
 391         kfree(data);
 392         return rc;
 393 }
 394 #else
 395 static int dasd_ioctl_reset_profile(struct dasd_block *block)
 396 {
 397         return -ENOTTY;
 398 }
 399
 400 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
 401 {
 402         return -ENOTTY;
 403 }
 404 #endif
 405
 406 /*
 407  * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
 408  */
 409 static int dasd_ioctl_information(struct dasd_block *block,
 410                                   unsigned int cmd, void __user *argp)
 411 {
 412         struct dasd_information2_t *dasd_info;
 413         struct subchannel_id sch_id;
 414         struct ccw_dev_id dev_id;
 415         struct dasd_device *base;
 416         struct ccw_device *cdev;
 417         unsigned long flags;
 418         int rc;
 419
 420         base = block->base;
 421         if (!base->discipline || !base->discipline->fill_info)
 422                 return -EINVAL;
 423
 424         dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
 425         if (dasd_info == NULL)
 426                 return -ENOMEM;
 427
 428         rc = base->discipline->fill_info(base, dasd_info);
 429         if (rc) {
 430                 kfree(dasd_info);
 431                 return rc;
 432         }
 433
 434         cdev = base->cdev;
 435         ccw_device_get_id(cdev, &dev_id);
 436         ccw_device_get_schid(cdev, &sch_id);
 437
 438         dasd_info->devno = dev_id.devno;
 439         dasd_info->schid = sch_id.sch_no;
 440         dasd_info->cu_type = cdev->id.cu_type;
 441         dasd_info->cu_model = cdev->id.cu_model;
 442         dasd_info->dev_type = cdev->id.dev_type;
 443         dasd_info->dev_model = cdev->id.dev_model;
 444         dasd_info->status = base->state;
 445         /*
 446          * The open_count is increased for every opener, that includes
 447          * the blkdev_get in dasd_scan_partitions.
 448          * This must be hidden from user-space.
 449          */
 450         dasd_info->open_count = atomic_read(&block->open_count);
 451         if (!block->bdev)
 452                 dasd_info->open_count++;
 453
 454         /*
 455          * check if device is really formatted
 456          * LDL / CDL was returned by 'fill_info'
 457          */
 458         if ((base->state < DASD_STATE_READY) ||
 459             (dasd_check_blocksize(block->bp_block)))
 460                 dasd_info->format = DASD_FORMAT_NONE;
 461
 462         dasd_info->features |=
 463                 ((base->features & DASD_FEATURE_READONLY) != 0);
 464
 465         memcpy(dasd_info->type, base->discipline->name, 4);
 466
 467         if (block->request_queue->request_fn) {
 468                 struct list_head *l;
 469 #ifdef DASD_EXTENDED_PROFILING
 470                 {
 471                         struct list_head *l;
 472                         spin_lock_irqsave(&block->lock, flags);
 473                         list_for_each(l, &block->request_queue->queue_head)
 474                                 dasd_info->req_queue_len++;
 475                         spin_unlock_irqrestore(&block->lock, flags);
 476                 }
 477 #endif                          /* DASD_EXTENDED_PROFILING */
 478                 spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
 479                 list_for_each(l, &base->ccw_queue)
 480                         dasd_info->chanq_len++;
 481                 spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
 482                                        flags);
 483         }
 484
 485         rc = 0;
 486         if (copy_to_user(argp, dasd_info,
 487                          ((cmd == (unsigned int) BIODASDINFO2) ?
 488                           sizeof(struct dasd_information2_t) :
 489                           sizeof(struct dasd_information_t))))
 490                 rc = -EFAULT;
 491         kfree(dasd_info);
 492         return rc;
 493 }
 494
 495 /*
 496  * Set read only
 497  */
 498 static int
 499 dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
 500 {
 501         struct dasd_device *base;
 502         int intval, rc;
 503
 504         if (!capable(CAP_SYS_ADMIN))
 505                 return -EACCES;
 506         if (bdev != bdev->bd_contains)
 507                 // ro setting is not allowed for partitions
 508                 return -EINVAL;
 509         if (get_user(intval, (int __user *)argp))
 510                 return -EFAULT;
 511         base = dasd_device_from_gendisk(bdev->bd_disk);
 512         if (!base)
 513                 return -ENODEV;
 514         if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
 515                 dasd_put_device(base);
 516                 return -EROFS;
 517         }
 518         set_disk_ro(bdev->bd_disk, intval);
 519         rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval);
 520         dasd_put_device(base);
 521         return rc;
 522 }
 523
 524 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
 525                                   struct cmbdata __user *argp)
 526 {
 527         size_t size = _IOC_SIZE(cmd);
 528         struct cmbdata data;
 529         int ret;
 530
 531         ret = cmf_readall(block->base->cdev, &data);
 532         if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
 533                 return -EFAULT;
 534         return ret;
 535 }
 536
 537 int dasd_ioctl(struct block_device *bdev, fmode_t mode,
 538                unsigned int cmd, unsigned long arg)
 539 {
 540         struct dasd_block *block;
 541         struct dasd_device *base;
 542         void __user *argp;
 543         int rc;
 544
 545         if (is_compat_task())
 546                 argp = compat_ptr(arg);
 547         else
 548                 argp = (void __user *)arg;
 549
 550         if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
 551                 PRINT_DEBUG("empty data ptr");
 552                 return -EINVAL;
 553         }
 554
 555         base = dasd_device_from_gendisk(bdev->bd_disk);
 556         if (!base)
 557                 return -ENODEV;
 558         block = base->block;
 559         rc = 0;
 560         switch (cmd) {
 561         case BIODASDDISABLE:
 562                 rc = dasd_ioctl_disable(bdev);
 563                 break;
 564         case BIODASDENABLE:
 565                 rc = dasd_ioctl_enable(bdev);
 566                 break;
 567         case BIODASDQUIESCE:
 568                 rc = dasd_ioctl_quiesce(block);
 569                 break;
 570         case BIODASDRESUME:
 571                 rc = dasd_ioctl_resume(block);
 572                 break;
 573         case BIODASDABORTIO:
 574                 rc = dasd_ioctl_abortio(block);
 575                 break;
 576         case BIODASDALLOWIO:
 577                 rc = dasd_ioctl_allowio(block);
 578                 break;
 579         case BIODASDFMT:
 580                 rc = dasd_ioctl_format(bdev, argp);
 581                 break;
 582         case BIODASDCHECKFMT:
 583                 rc = dasd_ioctl_check_format(bdev, argp);
 584                 break;
 585         case BIODASDINFO:
 586                 rc = dasd_ioctl_information(block, cmd, argp);
 587                 break;
 588         case BIODASDINFO2:
 589                 rc = dasd_ioctl_information(block, cmd, argp);
 590                 break;
 591         case BIODASDPRRD:
 592                 rc = dasd_ioctl_read_profile(block, argp);
 593                 break;
 594         case BIODASDPRRST:
 595                 rc = dasd_ioctl_reset_profile(block);
 596                 break;
 597         case BLKROSET:
 598                 rc = dasd_ioctl_set_ro(bdev, argp);
 599                 break;
 600         case DASDAPIVER:
 601                 rc = dasd_ioctl_api_version(argp);
 602                 break;
 603         case BIODASDCMFENABLE:
 604                 rc = enable_cmf(base->cdev);
 605                 break;
 606         case BIODASDCMFDISABLE:
 607                 rc = disable_cmf(base->cdev);
 608                 break;
 609         case BIODASDREADALLCMB:
 610                 rc = dasd_ioctl_readall_cmb(block, cmd, argp);
 611                 break;
 612         default:
 613                 /* if the discipline has an ioctl method try it. */
 614                 rc = -ENOTTY;
 615                 if (base->discipline->ioctl)
 616                         rc = base->discipline->ioctl(block, cmd, argp);
 617         }
 618         dasd_put_device(base);
 619         return rc;
 620 }