Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
0004  *          Horst Hummel <Horst.Hummel@de.ibm.com>
0005  *          Carsten Otte <Cotte@de.ibm.com>
0006  *          Martin Schwidefsky <schwidefsky@de.ibm.com>
0007  * Bugreports.to..: <Linux390@de.ibm.com>
0008  * Copyright IBM Corp. 1999, 2001
0009  *
0010  * i/o controls for the dasd driver.
0011  */
0012 
0013 #define KMSG_COMPONENT "dasd"
0014 
0015 #include <linux/interrupt.h>
0016 #include <linux/compat.h>
0017 #include <linux/major.h>
0018 #include <linux/fs.h>
0019 #include <linux/blkpg.h>
0020 #include <linux/slab.h>
0021 #include <asm/ccwdev.h>
0022 #include <asm/schid.h>
0023 #include <asm/cmb.h>
0024 #include <linux/uaccess.h>
0025 #include <linux/dasd_mod.h>
0026 
0027 /* This is ugly... */
0028 #define PRINTK_HEADER "dasd_ioctl:"
0029 
0030 #include "dasd_int.h"
0031 
0032 
0033 static int
0034 dasd_ioctl_api_version(void __user *argp)
0035 {
0036     int ver = DASD_API_VERSION;
0037     return put_user(ver, (int __user *)argp);
0038 }
0039 
0040 /*
0041  * Enable device.
0042  * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
0043  */
0044 static int
0045 dasd_ioctl_enable(struct block_device *bdev)
0046 {
0047     struct dasd_device *base;
0048 
0049     if (!capable(CAP_SYS_ADMIN))
0050         return -EACCES;
0051 
0052     base = dasd_device_from_gendisk(bdev->bd_disk);
0053     if (!base)
0054         return -ENODEV;
0055 
0056     dasd_enable_device(base);
0057     dasd_put_device(base);
0058     return 0;
0059 }
0060 
0061 /*
0062  * Disable device.
0063  * Used by dasdfmt. Disable I/O operations but allow ioctls.
0064  */
0065 static int
0066 dasd_ioctl_disable(struct block_device *bdev)
0067 {
0068     struct dasd_device *base;
0069 
0070     if (!capable(CAP_SYS_ADMIN))
0071         return -EACCES;
0072 
0073     base = dasd_device_from_gendisk(bdev->bd_disk);
0074     if (!base)
0075         return -ENODEV;
0076     /*
0077      * Man this is sick. We don't do a real disable but only downgrade
0078      * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
0079      * BIODASDDISABLE to disable accesses to the device via the block
0080      * device layer but it still wants to do i/o on the device by
0081      * using the BIODASDFMT ioctl. Therefore the correct state for the
0082      * device is DASD_STATE_BASIC that allows to do basic i/o.
0083      */
0084     dasd_set_target_state(base, DASD_STATE_BASIC);
0085     /*
0086      * Set i_size to zero, since read, write, etc. check against this
0087      * value.
0088      */
0089     set_capacity(bdev->bd_disk, 0);
0090     dasd_put_device(base);
0091     return 0;
0092 }
0093 
0094 /*
0095  * Quiesce device.
0096  */
0097 static int dasd_ioctl_quiesce(struct dasd_block *block)
0098 {
0099     unsigned long flags;
0100     struct dasd_device *base;
0101 
0102     base = block->base;
0103     if (!capable (CAP_SYS_ADMIN))
0104         return -EACCES;
0105 
0106     pr_info("%s: The DASD has been put in the quiesce "
0107         "state\n", dev_name(&base->cdev->dev));
0108     spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
0109     dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
0110     spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
0111     return 0;
0112 }
0113 
0114 
0115 /*
0116  * Resume device.
0117  */
0118 static int dasd_ioctl_resume(struct dasd_block *block)
0119 {
0120     unsigned long flags;
0121     struct dasd_device *base;
0122 
0123     base = block->base;
0124     if (!capable (CAP_SYS_ADMIN))
0125         return -EACCES;
0126 
0127     pr_info("%s: I/O operations have been resumed "
0128         "on the DASD\n", dev_name(&base->cdev->dev));
0129     spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
0130     dasd_device_remove_stop_bits(base, DASD_STOPPED_QUIESCE);
0131     spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
0132 
0133     dasd_schedule_block_bh(block);
0134     return 0;
0135 }
0136 
0137 /*
0138  * Abort all failfast I/O on a device.
0139  */
0140 static int dasd_ioctl_abortio(struct dasd_block *block)
0141 {
0142     unsigned long flags;
0143     struct dasd_device *base;
0144     struct dasd_ccw_req *cqr, *n;
0145 
0146     base = block->base;
0147     if (!capable(CAP_SYS_ADMIN))
0148         return -EACCES;
0149 
0150     if (test_and_set_bit(DASD_FLAG_ABORTALL, &base->flags))
0151         return 0;
0152     DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag set");
0153 
0154     spin_lock_irqsave(&block->request_queue_lock, flags);
0155     spin_lock(&block->queue_lock);
0156     list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) {
0157         if (test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
0158             cqr->callback_data &&
0159             cqr->callback_data != DASD_SLEEPON_START_TAG &&
0160             cqr->callback_data != DASD_SLEEPON_END_TAG) {
0161             spin_unlock(&block->queue_lock);
0162             blk_abort_request(cqr->callback_data);
0163             spin_lock(&block->queue_lock);
0164         }
0165     }
0166     spin_unlock(&block->queue_lock);
0167     spin_unlock_irqrestore(&block->request_queue_lock, flags);
0168 
0169     dasd_schedule_block_bh(block);
0170     return 0;
0171 }
0172 
0173 /*
0174  * Allow I/O on a device
0175  */
0176 static int dasd_ioctl_allowio(struct dasd_block *block)
0177 {
0178     struct dasd_device *base;
0179 
0180     base = block->base;
0181     if (!capable(CAP_SYS_ADMIN))
0182         return -EACCES;
0183 
0184     if (test_and_clear_bit(DASD_FLAG_ABORTALL, &base->flags))
0185         DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag unset");
0186 
0187     return 0;
0188 }
0189 
0190 /*
0191  * performs formatting of _device_ according to _fdata_
0192  * Note: The discipline's format_function is assumed to deliver formatting
0193  * commands to format multiple units of the device. In terms of the ECKD
0194  * devices this means CCWs are generated to format multiple tracks.
0195  */
0196 static int
0197 dasd_format(struct dasd_block *block, struct format_data_t *fdata)
0198 {
0199     struct dasd_device *base;
0200     int rc;
0201 
0202     base = block->base;
0203     if (base->discipline->format_device == NULL)
0204         return -EPERM;
0205 
0206     if (base->state != DASD_STATE_BASIC) {
0207         pr_warn("%s: The DASD cannot be formatted while it is enabled\n",
0208             dev_name(&base->cdev->dev));
0209         return -EBUSY;
0210     }
0211 
0212     DBF_DEV_EVENT(DBF_NOTICE, base,
0213               "formatting units %u to %u (%u B blocks) flags %u",
0214               fdata->start_unit,
0215               fdata->stop_unit, fdata->blksize, fdata->intensity);
0216 
0217     /* Since dasdfmt keeps the device open after it was disabled,
0218      * there still exists an inode for this device.
0219      * We must update i_blkbits, otherwise we might get errors when
0220      * enabling the device later.
0221      */
0222     if (fdata->start_unit == 0) {
0223         block->gdp->part0->bd_inode->i_blkbits =
0224             blksize_bits(fdata->blksize);
0225     }
0226 
0227     rc = base->discipline->format_device(base, fdata, 1);
0228     if (rc == -EAGAIN)
0229         rc = base->discipline->format_device(base, fdata, 0);
0230 
0231     return rc;
0232 }
0233 
0234 static int dasd_check_format(struct dasd_block *block,
0235                  struct format_check_t *cdata)
0236 {
0237     struct dasd_device *base;
0238     int rc;
0239 
0240     base = block->base;
0241     if (!base->discipline->check_device_format)
0242         return -ENOTTY;
0243 
0244     rc = base->discipline->check_device_format(base, cdata, 1);
0245     if (rc == -EAGAIN)
0246         rc = base->discipline->check_device_format(base, cdata, 0);
0247 
0248     return rc;
0249 }
0250 
0251 /*
0252  * Format device.
0253  */
0254 static int
0255 dasd_ioctl_format(struct block_device *bdev, void __user *argp)
0256 {
0257     struct dasd_device *base;
0258     struct format_data_t fdata;
0259     int rc;
0260 
0261     if (!capable(CAP_SYS_ADMIN))
0262         return -EACCES;
0263     if (!argp)
0264         return -EINVAL;
0265     base = dasd_device_from_gendisk(bdev->bd_disk);
0266     if (!base)
0267         return -ENODEV;
0268     if (base->features & DASD_FEATURE_READONLY ||
0269         test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
0270         dasd_put_device(base);
0271         return -EROFS;
0272     }
0273     if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
0274         dasd_put_device(base);
0275         return -EFAULT;
0276     }
0277     if (bdev_is_partition(bdev)) {
0278         pr_warn("%s: The specified DASD is a partition and cannot be formatted\n",
0279             dev_name(&base->cdev->dev));
0280         dasd_put_device(base);
0281         return -EINVAL;
0282     }
0283     rc = dasd_format(base->block, &fdata);
0284     dasd_put_device(base);
0285 
0286     return rc;
0287 }
0288 
0289 /*
0290  * Check device format
0291  */
0292 static int dasd_ioctl_check_format(struct block_device *bdev, void __user *argp)
0293 {
0294     struct format_check_t cdata;
0295     struct dasd_device *base;
0296     int rc = 0;
0297 
0298     if (!argp)
0299         return -EINVAL;
0300 
0301     base = dasd_device_from_gendisk(bdev->bd_disk);
0302     if (!base)
0303         return -ENODEV;
0304     if (bdev_is_partition(bdev)) {
0305         pr_warn("%s: The specified DASD is a partition and cannot be checked\n",
0306             dev_name(&base->cdev->dev));
0307         rc = -EINVAL;
0308         goto out_err;
0309     }
0310 
0311     if (copy_from_user(&cdata, argp, sizeof(cdata))) {
0312         rc = -EFAULT;
0313         goto out_err;
0314     }
0315 
0316     rc = dasd_check_format(base->block, &cdata);
0317     if (rc)
0318         goto out_err;
0319 
0320     if (copy_to_user(argp, &cdata, sizeof(cdata)))
0321         rc = -EFAULT;
0322 
0323 out_err:
0324     dasd_put_device(base);
0325 
0326     return rc;
0327 }
0328 
0329 static int dasd_release_space(struct dasd_device *device,
0330                   struct format_data_t *rdata)
0331 {
0332     if (!device->discipline->is_ese && !device->discipline->is_ese(device))
0333         return -ENOTSUPP;
0334     if (!device->discipline->release_space)
0335         return -ENOTSUPP;
0336 
0337     return device->discipline->release_space(device, rdata);
0338 }
0339 
0340 /*
0341  * Release allocated space
0342  */
0343 static int dasd_ioctl_release_space(struct block_device *bdev, void __user *argp)
0344 {
0345     struct format_data_t rdata;
0346     struct dasd_device *base;
0347     int rc = 0;
0348 
0349     if (!capable(CAP_SYS_ADMIN))
0350         return -EACCES;
0351     if (!argp)
0352         return -EINVAL;
0353 
0354     base = dasd_device_from_gendisk(bdev->bd_disk);
0355     if (!base)
0356         return -ENODEV;
0357     if (base->features & DASD_FEATURE_READONLY ||
0358         test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
0359         rc = -EROFS;
0360         goto out_err;
0361     }
0362     if (bdev_is_partition(bdev)) {
0363         pr_warn("%s: The specified DASD is a partition and tracks cannot be released\n",
0364             dev_name(&base->cdev->dev));
0365         rc = -EINVAL;
0366         goto out_err;
0367     }
0368 
0369     if (copy_from_user(&rdata, argp, sizeof(rdata))) {
0370         rc = -EFAULT;
0371         goto out_err;
0372     }
0373 
0374     rc = dasd_release_space(base, &rdata);
0375 
0376 out_err:
0377     dasd_put_device(base);
0378 
0379     return rc;
0380 }
0381 
0382 #ifdef CONFIG_DASD_PROFILE
0383 /*
0384  * Reset device profile information
0385  */
0386 static int dasd_ioctl_reset_profile(struct dasd_block *block)
0387 {
0388     dasd_profile_reset(&block->profile);
0389     return 0;
0390 }
0391 
0392 /*
0393  * Return device profile information
0394  */
0395 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
0396 {
0397     struct dasd_profile_info_t *data;
0398     int rc = 0;
0399 
0400     data = kmalloc(sizeof(*data), GFP_KERNEL);
0401     if (!data)
0402         return -ENOMEM;
0403 
0404     spin_lock_bh(&block->profile.lock);
0405     if (block->profile.data) {
0406         data->dasd_io_reqs = block->profile.data->dasd_io_reqs;
0407         data->dasd_io_sects = block->profile.data->dasd_io_sects;
0408         memcpy(data->dasd_io_secs, block->profile.data->dasd_io_secs,
0409                sizeof(data->dasd_io_secs));
0410         memcpy(data->dasd_io_times, block->profile.data->dasd_io_times,
0411                sizeof(data->dasd_io_times));
0412         memcpy(data->dasd_io_timps, block->profile.data->dasd_io_timps,
0413                sizeof(data->dasd_io_timps));
0414         memcpy(data->dasd_io_time1, block->profile.data->dasd_io_time1,
0415                sizeof(data->dasd_io_time1));
0416         memcpy(data->dasd_io_time2, block->profile.data->dasd_io_time2,
0417                sizeof(data->dasd_io_time2));
0418         memcpy(data->dasd_io_time2ps,
0419                block->profile.data->dasd_io_time2ps,
0420                sizeof(data->dasd_io_time2ps));
0421         memcpy(data->dasd_io_time3, block->profile.data->dasd_io_time3,
0422                sizeof(data->dasd_io_time3));
0423         memcpy(data->dasd_io_nr_req,
0424                block->profile.data->dasd_io_nr_req,
0425                sizeof(data->dasd_io_nr_req));
0426         spin_unlock_bh(&block->profile.lock);
0427     } else {
0428         spin_unlock_bh(&block->profile.lock);
0429         rc = -EIO;
0430         goto out;
0431     }
0432     if (copy_to_user(argp, data, sizeof(*data)))
0433         rc = -EFAULT;
0434 out:
0435     kfree(data);
0436     return rc;
0437 }
0438 #else
0439 static int dasd_ioctl_reset_profile(struct dasd_block *block)
0440 {
0441     return -ENOTTY;
0442 }
0443 
0444 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
0445 {
0446     return -ENOTTY;
0447 }
0448 #endif
0449 
0450 /*
0451  * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
0452  */
0453 static int __dasd_ioctl_information(struct dasd_block *block,
0454         struct dasd_information2_t *dasd_info)
0455 {
0456     struct subchannel_id sch_id;
0457     struct ccw_dev_id dev_id;
0458     struct dasd_device *base;
0459     struct ccw_device *cdev;
0460     struct list_head *l;
0461     unsigned long flags;
0462     int rc;
0463 
0464     base = block->base;
0465     if (!base->discipline || !base->discipline->fill_info)
0466         return -EINVAL;
0467 
0468     rc = base->discipline->fill_info(base, dasd_info);
0469     if (rc)
0470         return rc;
0471 
0472     cdev = base->cdev;
0473     ccw_device_get_id(cdev, &dev_id);
0474     ccw_device_get_schid(cdev, &sch_id);
0475 
0476     dasd_info->devno = dev_id.devno;
0477     dasd_info->schid = sch_id.sch_no;
0478     dasd_info->cu_type = cdev->id.cu_type;
0479     dasd_info->cu_model = cdev->id.cu_model;
0480     dasd_info->dev_type = cdev->id.dev_type;
0481     dasd_info->dev_model = cdev->id.dev_model;
0482     dasd_info->status = base->state;
0483     /*
0484      * The open_count is increased for every opener, that includes
0485      * the blkdev_get in dasd_scan_partitions.
0486      * This must be hidden from user-space.
0487      */
0488     dasd_info->open_count = atomic_read(&block->open_count);
0489     if (!block->bdev)
0490         dasd_info->open_count++;
0491 
0492     /*
0493      * check if device is really formatted
0494      * LDL / CDL was returned by 'fill_info'
0495      */
0496     if ((base->state < DASD_STATE_READY) ||
0497         (dasd_check_blocksize(block->bp_block)))
0498         dasd_info->format = DASD_FORMAT_NONE;
0499 
0500     dasd_info->features |=
0501         ((base->features & DASD_FEATURE_READONLY) != 0);
0502 
0503     memcpy(dasd_info->type, base->discipline->name, 4);
0504 
0505     spin_lock_irqsave(&block->queue_lock, flags);
0506     list_for_each(l, &base->ccw_queue)
0507         dasd_info->chanq_len++;
0508     spin_unlock_irqrestore(&block->queue_lock, flags);
0509     return 0;
0510 }
0511 
0512 static int dasd_ioctl_information(struct dasd_block *block, void __user *argp,
0513         size_t copy_size)
0514 {
0515     struct dasd_information2_t *dasd_info;
0516     int error;
0517 
0518     dasd_info = kzalloc(sizeof(*dasd_info), GFP_KERNEL);
0519     if (!dasd_info)
0520         return -ENOMEM;
0521 
0522     error = __dasd_ioctl_information(block, dasd_info);
0523     if (!error && copy_to_user(argp, dasd_info, copy_size))
0524         error = -EFAULT;
0525     kfree(dasd_info);
0526     return error;
0527 }
0528 
0529 /*
0530  * Set read only
0531  */
0532 int dasd_set_read_only(struct block_device *bdev, bool ro)
0533 {
0534     struct dasd_device *base;
0535     int rc;
0536 
0537     /* do not manipulate hardware state for partitions */
0538     if (bdev_is_partition(bdev))
0539         return 0;
0540 
0541     base = dasd_device_from_gendisk(bdev->bd_disk);
0542     if (!base)
0543         return -ENODEV;
0544     if (!ro && test_bit(DASD_FLAG_DEVICE_RO, &base->flags))
0545         rc = -EROFS;
0546     else
0547         rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, ro);
0548     dasd_put_device(base);
0549     return rc;
0550 }
0551 
0552 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
0553                   struct cmbdata __user *argp)
0554 {
0555     size_t size = _IOC_SIZE(cmd);
0556     struct cmbdata data;
0557     int ret;
0558 
0559     ret = cmf_readall(block->base->cdev, &data);
0560     if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
0561         return -EFAULT;
0562     return ret;
0563 }
0564 
0565 int dasd_ioctl(struct block_device *bdev, fmode_t mode,
0566            unsigned int cmd, unsigned long arg)
0567 {
0568     struct dasd_block *block;
0569     struct dasd_device *base;
0570     void __user *argp;
0571     int rc;
0572 
0573     if (is_compat_task())
0574         argp = compat_ptr(arg);
0575     else
0576         argp = (void __user *)arg;
0577 
0578     if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg)
0579         return -EINVAL;
0580 
0581     base = dasd_device_from_gendisk(bdev->bd_disk);
0582     if (!base)
0583         return -ENODEV;
0584     block = base->block;
0585     rc = 0;
0586     switch (cmd) {
0587     case BIODASDDISABLE:
0588         rc = dasd_ioctl_disable(bdev);
0589         break;
0590     case BIODASDENABLE:
0591         rc = dasd_ioctl_enable(bdev);
0592         break;
0593     case BIODASDQUIESCE:
0594         rc = dasd_ioctl_quiesce(block);
0595         break;
0596     case BIODASDRESUME:
0597         rc = dasd_ioctl_resume(block);
0598         break;
0599     case BIODASDABORTIO:
0600         rc = dasd_ioctl_abortio(block);
0601         break;
0602     case BIODASDALLOWIO:
0603         rc = dasd_ioctl_allowio(block);
0604         break;
0605     case BIODASDFMT:
0606         rc = dasd_ioctl_format(bdev, argp);
0607         break;
0608     case BIODASDCHECKFMT:
0609         rc = dasd_ioctl_check_format(bdev, argp);
0610         break;
0611     case BIODASDINFO:
0612         rc = dasd_ioctl_information(block, argp,
0613                 sizeof(struct dasd_information_t));
0614         break;
0615     case BIODASDINFO2:
0616         rc = dasd_ioctl_information(block, argp,
0617                 sizeof(struct dasd_information2_t));
0618         break;
0619     case BIODASDPRRD:
0620         rc = dasd_ioctl_read_profile(block, argp);
0621         break;
0622     case BIODASDPRRST:
0623         rc = dasd_ioctl_reset_profile(block);
0624         break;
0625     case DASDAPIVER:
0626         rc = dasd_ioctl_api_version(argp);
0627         break;
0628     case BIODASDCMFENABLE:
0629         rc = enable_cmf(base->cdev);
0630         break;
0631     case BIODASDCMFDISABLE:
0632         rc = disable_cmf(base->cdev);
0633         break;
0634     case BIODASDREADALLCMB:
0635         rc = dasd_ioctl_readall_cmb(block, cmd, argp);
0636         break;
0637     case BIODASDRAS:
0638         rc = dasd_ioctl_release_space(bdev, argp);
0639         break;
0640     default:
0641         /* if the discipline has an ioctl method try it. */
0642         rc = -ENOTTY;
0643         if (base->discipline->ioctl)
0644             rc = base->discipline->ioctl(block, cmd, argp);
0645     }
0646     dasd_put_device(base);
0647     return rc;
0648 }
0649 
0650 
0651 /**
0652  * dasd_biodasdinfo() - fill out the dasd information structure
0653  * @disk: [in] pointer to gendisk structure that references a DASD
0654  * @info: [out] pointer to the dasd_information2_t structure
0655  *
0656  * Provide access to DASD specific information.
0657  * The gendisk structure is checked if it belongs to the DASD driver by
0658  * comparing the gendisk->fops pointer.
0659  * If it does not belong to the DASD driver -EINVAL is returned.
0660  * Otherwise the provided dasd_information2_t structure is filled out.
0661  *
0662  * Returns:
0663  *   %0 on success and a negative error value on failure.
0664  */
0665 int dasd_biodasdinfo(struct gendisk *disk, struct dasd_information2_t *info)
0666 {
0667     struct dasd_device *base;
0668     int error;
0669 
0670     if (disk->fops != &dasd_device_operations)
0671         return -EINVAL;
0672 
0673     base = dasd_device_from_gendisk(disk);
0674     if (!base)
0675         return -ENODEV;
0676     error = __dasd_ioctl_information(base->block, info);
0677     dasd_put_device(base);
0678     return error;
0679 }
0680 /* export that symbol_get in partition detection is possible */
0681 EXPORT_SYMBOL_GPL(dasd_biodasdinfo);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!