[deliverable/linux.git] / drivers / s390 / block / dasd_ioctl.c

/*
 * File...........: linux/drivers/s390/block/dasd_ioctl.c
 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
 *		    Horst Hummel <Horst.Hummel@de.ibm.com>
 *		    Carsten Otte <Cotte@de.ibm.com>
 *		    Martin Schwidefsky <schwidefsky@de.ibm.com>
 * Bugreports.to..: <Linux390@de.ibm.com>
 * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999-2001
 *
 * i/o controls for the dasd driver.
 */

#define KMSG_COMPONENT "dasd"

#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/blkpg.h>
#include <linux/slab.h>
#include <asm/compat.h>
#include <asm/ccwdev.h>
#include <asm/cmb.h>
#include <asm/uaccess.h>

/* This is ugly... */
#define PRINTK_HEADER "dasd_ioctl:"

#include "dasd_int.h"


static int
dasd_ioctl_api_version(void __user *argp)
{
	int ver = DASD_API_VERSION;
	return put_user(ver, (int __user *)argp);
}

/*
 * Enable device.
 * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
 */
static int
dasd_ioctl_enable(struct block_device *bdev)
{
	struct dasd_device *base;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	base = dasd_device_from_gendisk(bdev->bd_disk);
	if (!base)
		return -ENODEV;

	dasd_enable_device(base);
	/* Formatting the dasd device can change the capacity. */
	mutex_lock(&bdev->bd_mutex);
	i_size_write(bdev->bd_inode,
		     (loff_t)get_capacity(base->block->gdp) << 9);
	mutex_unlock(&bdev->bd_mutex);
	dasd_put_device(base);
	return 0;
}

/*
 * Disable device.
 * Used by dasdfmt. Disable I/O operations but allow ioctls.
 */
static int
dasd_ioctl_disable(struct block_device *bdev)
{
	struct dasd_device *base;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	base = dasd_device_from_gendisk(bdev->bd_disk);
	if (!base)
		return -ENODEV;
	/*
	 * Man this is sick. We don't do a real disable but only downgrade
	 * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
	 * BIODASDDISABLE to disable accesses to the device via the block
	 * device layer but it still wants to do i/o on the device by
	 * using the BIODASDFMT ioctl. Therefore the correct state for the
	 * device is DASD_STATE_BASIC that allows to do basic i/o.
	 */
	dasd_set_target_state(base, DASD_STATE_BASIC);
	/*
	 * Set i_size to zero, since read, write, etc. check against this
	 * value.
	 */
	mutex_lock(&bdev->bd_mutex);
	i_size_write(bdev->bd_inode, 0);
	mutex_unlock(&bdev->bd_mutex);
	dasd_put_device(base);
	return 0;
}

/*
 * Quiesce device.
 */
static int dasd_ioctl_quiesce(struct dasd_block *block)
{
	unsigned long flags;
	struct dasd_device *base;

	base = block->base;
	if (!capable (CAP_SYS_ADMIN))
		return -EACCES;

	pr_info("%s: The DASD has been put in the quiesce "
		"state\n", dev_name(&base->cdev->dev));
	spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
	dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
	spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
	return 0;
}


/*
 * Resume device.
 */
static int dasd_ioctl_resume(struct dasd_block *block)
{
	unsigned long flags;
	struct dasd_device *base;

	base = block->base;
	if (!capable (CAP_SYS_ADMIN))
		return -EACCES;

	pr_info("%s: I/O operations have been resumed "
		"on the DASD\n", dev_name(&base->cdev->dev));
	spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
	dasd_device_remove_stop_bits(base, DASD_STOPPED_QUIESCE);
	spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);

	dasd_schedule_block_bh(block);
	return 0;
}

/*
 * performs formatting of _device_ according to _fdata_
 * Note: The discipline's format_function is assumed to deliver formatting
 * commands to format a single unit of the device. In terms of the ECKD
 * devices this means CCWs are generated to format a single track.
 */
static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
{
	struct dasd_ccw_req *cqr;
	struct dasd_device *base;
	int rc;

	base = block->base;
	if (base->discipline->format_device == NULL)
		return -EPERM;

	if (base->state != DASD_STATE_BASIC) {
		pr_warning("%s: The DASD cannot be formatted while it is "
			   "enabled\n",  dev_name(&base->cdev->dev));
		return -EBUSY;
	}

	DBF_DEV_EVENT(DBF_NOTICE, base,
		      "formatting units %u to %u (%u B blocks) flags %u",
		      fdata->start_unit,
		      fdata->stop_unit, fdata->blksize, fdata->intensity);

	/* Since dasdfmt keeps the device open after it was disabled,
	 * there still exists an inode for this device.
	 * We must update i_blkbits, otherwise we might get errors when
	 * enabling the device later.
	 */
	if (fdata->start_unit == 0) {
		struct block_device *bdev = bdget_disk(block->gdp, 0);
		bdev->bd_inode->i_blkbits = blksize_bits(fdata->blksize);
		bdput(bdev);
	}

	while (fdata->start_unit <= fdata->stop_unit) {
		cqr = base->discipline->format_device(base, fdata);
		if (IS_ERR(cqr))
			return PTR_ERR(cqr);
		rc = dasd_sleep_on_interruptible(cqr);
		dasd_sfree_request(cqr, cqr->memdev);
		if (rc) {
			if (rc != -ERESTARTSYS)
				pr_err("%s: Formatting unit %d failed with "
				       "rc=%d\n", dev_name(&base->cdev->dev),
				       fdata->start_unit, rc);
			return rc;
		}
		fdata->start_unit++;
	}
	return 0;
}

/*
 * Format device.
 */
static int
dasd_ioctl_format(struct block_device *bdev, void __user *argp)
{
	struct dasd_device *base;
	struct format_data_t fdata;
	int rc;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
	if (!argp)
		return -EINVAL;
	base = dasd_device_from_gendisk(bdev->bd_disk);
	if (!base)
		return -ENODEV;
	if (base->features & DASD_FEATURE_READONLY ||
	    test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
		dasd_put_device(base);
		return -EROFS;
	}
	if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
		dasd_put_device(base);
		return -EFAULT;
	}
	if (bdev != bdev->bd_contains) {
		pr_warning("%s: The specified DASD is a partition and cannot "
			   "be formatted\n",
			   dev_name(&base->cdev->dev));
		dasd_put_device(base);
		return -EINVAL;
	}
	rc = dasd_format(base->block, &fdata);
	dasd_put_device(base);
	return rc;
}

#ifdef CONFIG_DASD_PROFILE
/*
 * Reset device profile information
 */
static int dasd_ioctl_reset_profile(struct dasd_block *block)
{
	memset(&block->profile, 0, sizeof(struct dasd_profile_info_t));
	return 0;
}

/*
 * Return device profile information
 */
static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
{
	if (dasd_profile_level == DASD_PROFILE_OFF)
		return -EIO;
	if (copy_to_user(argp, &block->profile,
			 sizeof(struct dasd_profile_info_t)))
		return -EFAULT;
	return 0;
}
#else
static int dasd_ioctl_reset_profile(struct dasd_block *block)
{
	return -ENOSYS;
}

static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
{
	return -ENOSYS;
}
#endif

/*
 * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
 */
static int dasd_ioctl_information(struct dasd_block *block,
				  unsigned int cmd, void __user *argp)
{
	struct dasd_information2_t *dasd_info;
	unsigned long flags;
	int rc;
	struct dasd_device *base;
	struct ccw_device *cdev;
	struct ccw_dev_id dev_id;

	base = block->base;
	if (!base->discipline || !base->discipline->fill_info)
		return -EINVAL;

	dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
	if (dasd_info == NULL)
		return -ENOMEM;

	rc = base->discipline->fill_info(base, dasd_info);
	if (rc) {
		kfree(dasd_info);
		return rc;
	}

	cdev = base->cdev;
	ccw_device_get_id(cdev, &dev_id);

	dasd_info->devno = dev_id.devno;
	dasd_info->schid = _ccw_device_get_subchannel_number(base->cdev);
	dasd_info->cu_type = cdev->id.cu_type;
	dasd_info->cu_model = cdev->id.cu_model;
	dasd_info->dev_type = cdev->id.dev_type;
	dasd_info->dev_model = cdev->id.dev_model;
	dasd_info->status = base->state;
	/*
	 * The open_count is increased for every opener, that includes
	 * the blkdev_get in dasd_scan_partitions.
	 * This must be hidden from user-space.
	 */
	dasd_info->open_count = atomic_read(&block->open_count);
	if (!block->bdev)
		dasd_info->open_count++;

	/*
	 * check if device is really formatted
	 * LDL / CDL was returned by 'fill_info'
	 */
	if ((base->state < DASD_STATE_READY) ||
	    (dasd_check_blocksize(block->bp_block)))
		dasd_info->format = DASD_FORMAT_NONE;

	dasd_info->features |=
		((base->features & DASD_FEATURE_READONLY) != 0);

	memcpy(dasd_info->type, base->discipline->name, 4);

	if (block->request_queue->request_fn) {
		struct list_head *l;
#ifdef DASD_EXTENDED_PROFILING
		{
			struct list_head *l;
			spin_lock_irqsave(&block->lock, flags);
			list_for_each(l, &block->request_queue->queue_head)
				dasd_info->req_queue_len++;
			spin_unlock_irqrestore(&block->lock, flags);
		}
#endif				/* DASD_EXTENDED_PROFILING */
		spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
		list_for_each(l, &base->ccw_queue)
			dasd_info->chanq_len++;
		spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
				       flags);
	}

	rc = 0;
	if (copy_to_user(argp, dasd_info,
			 ((cmd == (unsigned int) BIODASDINFO2) ?
			  sizeof(struct dasd_information2_t) :
			  sizeof(struct dasd_information_t))))
		rc = -EFAULT;
	kfree(dasd_info);
	return rc;
}

/*
 * Set read only
 */
static int
dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
{
	struct dasd_device *base;
	int intval, rc;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
	if (bdev != bdev->bd_contains)
		// ro setting is not allowed for partitions
		return -EINVAL;
	if (get_user(intval, (int __user *)argp))
		return -EFAULT;
	base = dasd_device_from_gendisk(bdev->bd_disk);
	if (!base)
		return -ENODEV;
	if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
		dasd_put_device(base);
		return -EROFS;
	}
	set_disk_ro(bdev->bd_disk, intval);
	rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval);
	dasd_put_device(base);
	return rc;
}

static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
				  struct cmbdata __user *argp)
{
	size_t size = _IOC_SIZE(cmd);
	struct cmbdata data;
	int ret;

	ret = cmf_readall(block->base->cdev, &data);
	if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
		return -EFAULT;
	return ret;
}

int dasd_ioctl(struct block_device *bdev, fmode_t mode,
	       unsigned int cmd, unsigned long arg)
{
	struct dasd_block *block;
	struct dasd_device *base;
	void __user *argp;
	int rc;

	if (is_compat_task())
		argp = compat_ptr(arg);
	else
		argp = (void __user *)arg;

	if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
		PRINT_DEBUG("empty data ptr");
		return -EINVAL;
	}

	base = dasd_device_from_gendisk(bdev->bd_disk);
	if (!base)
		return -ENODEV;
	block = base->block;
	rc = 0;
	switch (cmd) {
	case BIODASDDISABLE:
		rc = dasd_ioctl_disable(bdev);
		break;
	case BIODASDENABLE:
		rc = dasd_ioctl_enable(bdev);
		break;
	case BIODASDQUIESCE:
		rc = dasd_ioctl_quiesce(block);
		break;
	case BIODASDRESUME:
		rc = dasd_ioctl_resume(block);
		break;
	case BIODASDFMT:
		rc = dasd_ioctl_format(bdev, argp);
		break;
	case BIODASDINFO:
		rc = dasd_ioctl_information(block, cmd, argp);
		break;
	case BIODASDINFO2:
		rc = dasd_ioctl_information(block, cmd, argp);
		break;
	case BIODASDPRRD:
		rc = dasd_ioctl_read_profile(block, argp);
		break;
	case BIODASDPRRST:
		rc = dasd_ioctl_reset_profile(block);
		break;
	case BLKROSET:
		rc = dasd_ioctl_set_ro(bdev, argp);
		break;
	case DASDAPIVER:
		rc = dasd_ioctl_api_version(argp);
		break;
	case BIODASDCMFENABLE:
		rc = enable_cmf(base->cdev);
		break;
	case BIODASDCMFDISABLE:
		rc = disable_cmf(base->cdev);
		break;
	case BIODASDREADALLCMB:
		rc = dasd_ioctl_readall_cmb(block, cmd, argp);
		break;
	default:
		/* if the discipline has an ioctl method try it. */
		if (base->discipline->ioctl) {
			rc = base->discipline->ioctl(block, cmd, argp);
			if (rc == -ENOIOCTLCMD)
				rc = -EINVAL;
		} else
			rc = -EINVAL;
	}
	dasd_put_device(base);
	return rc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* File...........: linux/drivers/s390/block/dasd_ioctl.c
	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	* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999-2001
	9	*
	10	* i/o controls for the dasd driver.
	11	*/
fc19f381 SH	12
	13	#define KMSG_COMPONENT "dasd"
	14
1da177e4 LT	15	#include <linux/interrupt.h>
	16	#include <linux/major.h>
	17	#include <linux/fs.h>
	18	#include <linux/blkpg.h>
5a0e3ad6	19	#include <linux/slab.h>
88034865	20	#include <asm/compat.h>
1da177e4	21	#include <asm/ccwdev.h>
8b2eb664	22	#include <asm/cmb.h>
1da177e4 LT	23	#include <asm/uaccess.h>
	24
	25	/* This is ugly... */
	26	#define PRINTK_HEADER "dasd_ioctl:"
	27
	28	#include "dasd_int.h"
	29
1da177e4	30
1da177e4	31	static int
13c6204f	32	dasd_ioctl_api_version(void __user *argp)
1da177e4 LT	33	{
1da177e4 LT	34	int ver = DASD_API_VERSION;
b5029622	35	return put_user(ver, (int __user *)argp);
1da177e4 LT	36	}
	37
	38	/*
	39	* Enable device.
	40	* used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
	41	*/
	42	static int
13c6204f	43	dasd_ioctl_enable(struct block_device *bdev)
1da177e4	44	{
65f8da47	45	struct dasd_device *base;
1da177e4 LT	46
	47	if (!capable(CAP_SYS_ADMIN))
	48	return -EACCES;
13c6204f	49
65f8da47 SW	50	base = dasd_device_from_gendisk(bdev->bd_disk);
	51	if (!base)
	52	return -ENODEV;
	53
	54	dasd_enable_device(base);
1da177e4	55	/* Formatting the dasd device can change the capacity. */
c039e313	56	mutex_lock(&bdev->bd_mutex);
65f8da47 SW	57	i_size_write(bdev->bd_inode,
65f8da47 SW	58	(loff_t)get_capacity(base->block->gdp) << 9);
c039e313	59	mutex_unlock(&bdev->bd_mutex);
65f8da47	60	dasd_put_device(base);
1da177e4 LT	61	return 0;
	62	}
	63
	64	/*
	65	* Disable device.
	66	* Used by dasdfmt. Disable I/O operations but allow ioctls.
	67	*/
	68	static int
13c6204f	69	dasd_ioctl_disable(struct block_device *bdev)
1da177e4	70	{
65f8da47	71	struct dasd_device *base;
1da177e4 LT	72
	73	if (!capable(CAP_SYS_ADMIN))
	74	return -EACCES;
13c6204f	75
65f8da47 SW	76	base = dasd_device_from_gendisk(bdev->bd_disk);
	77	if (!base)
	78	return -ENODEV;
1da177e4 LT	79	/*
	80	* Man this is sick. We don't do a real disable but only downgrade
	81	* the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
	82	* BIODASDDISABLE to disable accesses to the device via the block
	83	* device layer but it still wants to do i/o on the device by
	84	* using the BIODASDFMT ioctl. Therefore the correct state for the
	85	* device is DASD_STATE_BASIC that allows to do basic i/o.
	86	*/
65f8da47	87	dasd_set_target_state(base, DASD_STATE_BASIC);
1da177e4 LT	88	/*
	89	* Set i_size to zero, since read, write, etc. check against this
	90	* value.
	91	*/
c039e313	92	mutex_lock(&bdev->bd_mutex);
1da177e4	93	i_size_write(bdev->bd_inode, 0);
c039e313	94	mutex_unlock(&bdev->bd_mutex);
65f8da47	95	dasd_put_device(base);
1da177e4 LT	96	return 0;
	97	}
	98
	99	/*
	100	* Quiesce device.
	101	*/
8e09f215	102	static int dasd_ioctl_quiesce(struct dasd_block *block)
1da177e4	103	{
1da177e4	104	unsigned long flags;
8e09f215	105	struct dasd_device *base;
138c014d	106
8e09f215	107	base = block->base;
1da177e4 LT	108	if (!capable (CAP_SYS_ADMIN))
1da177e4 LT	109	return -EACCES;
138c014d	110
ca99dab0 SH	111	pr_info("%s: The DASD has been put in the quiesce "
ca99dab0 SH	112	"state\n", dev_name(&base->cdev->dev));
8e09f215	113	spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
eb6e199b	114	dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
8e09f215	115	spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
1da177e4 LT	116	return 0;
	117	}
	118
	119
	120	/*
fc19f381	121	* Resume device.
1da177e4	122	*/
8e09f215	123	static int dasd_ioctl_resume(struct dasd_block *block)
1da177e4	124	{
1da177e4	125	unsigned long flags;
8e09f215	126	struct dasd_device *base;
138c014d	127
8e09f215	128	base = block->base;
138c014d	129	if (!capable (CAP_SYS_ADMIN))
1da177e4 LT	130	return -EACCES;
1da177e4 LT	131
ca99dab0 SH	132	pr_info("%s: I/O operations have been resumed "
ca99dab0 SH	133	"on the DASD\n", dev_name(&base->cdev->dev));
8e09f215	134	spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
eb6e199b	135	dasd_device_remove_stop_bits(base, DASD_STOPPED_QUIESCE);
8e09f215	136	spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
1da177e4	137
8e09f215	138	dasd_schedule_block_bh(block);
1da177e4 LT	139	return 0;
	140	}
	141
	142	/*
	143	* performs formatting of _device_ according to _fdata_
	144	* Note: The discipline's format_function is assumed to deliver formatting
	145	* commands to format a single unit of the device. In terms of the ECKD
	146	* devices this means CCWs are generated to format a single track.
	147	*/
8e09f215	148	static int dasd_format(struct dasd_block block, struct format_data_t fdata)
1da177e4 LT	149	{
1da177e4 LT	150	struct dasd_ccw_req *cqr;
8e09f215	151	struct dasd_device *base;
1da177e4 LT	152	int rc;
1da177e4 LT	153
8e09f215 SW	154	base = block->base;
8e09f215 SW	155	if (base->discipline->format_device == NULL)
1da177e4 LT	156	return -EPERM;
1da177e4 LT	157
8e09f215	158	if (base->state != DASD_STATE_BASIC) {
ca99dab0 SH	159	pr_warning("%s: The DASD cannot be formatted while it is "
ca99dab0 SH	160	"enabled\n", dev_name(&base->cdev->dev));
1da177e4 LT	161	return -EBUSY;
	162	}
	163
8e09f215	164	DBF_DEV_EVENT(DBF_NOTICE, base,
b44b0ab3	165	"formatting units %u to %u (%u B blocks) flags %u",
1da177e4 LT	166	fdata->start_unit,
	167	fdata->stop_unit, fdata->blksize, fdata->intensity);
	168
	169	/* Since dasdfmt keeps the device open after it was disabled,
	170	* there still exists an inode for this device.
	171	* We must update i_blkbits, otherwise we might get errors when
	172	* enabling the device later.
	173	*/
	174	if (fdata->start_unit == 0) {
8e09f215	175	struct block_device *bdev = bdget_disk(block->gdp, 0);
1da177e4 LT	176	bdev->bd_inode->i_blkbits = blksize_bits(fdata->blksize);
	177	bdput(bdev);
	178	}
	179
	180	while (fdata->start_unit <= fdata->stop_unit) {
8e09f215	181	cqr = base->discipline->format_device(base, fdata);
1da177e4 LT	182	if (IS_ERR(cqr))
	183	return PTR_ERR(cqr);
	184	rc = dasd_sleep_on_interruptible(cqr);
8e09f215	185	dasd_sfree_request(cqr, cqr->memdev);
1da177e4 LT	186	if (rc) {
1da177e4 LT	187	if (rc != -ERESTARTSYS)
ca99dab0 SH	188	pr_err("%s: Formatting unit %d failed with "
	189	"rc=%d\n", dev_name(&base->cdev->dev),
	190	fdata->start_unit, rc);
1da177e4 LT	191	return rc;
	192	}
	193	fdata->start_unit++;
	194	}
	195	return 0;
	196	}
	197
	198	/*
	199	* Format device.
	200	*/
	201	static int
13c6204f	202	dasd_ioctl_format(struct block_device bdev, void __user argp)
1da177e4	203	{
65f8da47	204	struct dasd_device *base;
1da177e4	205	struct format_data_t fdata;
65f8da47	206	int rc;
1da177e4 LT	207
	208	if (!capable(CAP_SYS_ADMIN))
	209	return -EACCES;
13c6204f	210	if (!argp)
1da177e4	211	return -EINVAL;
65f8da47 SW	212	base = dasd_device_from_gendisk(bdev->bd_disk);
	213	if (!base)
	214	return -ENODEV;
	215	if (base->features & DASD_FEATURE_READONLY \|\|
	216	test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
	217	dasd_put_device(base);
1da177e4	218	return -EROFS;
65f8da47 SW	219	}
	220	if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
	221	dasd_put_device(base);
1da177e4	222	return -EFAULT;
65f8da47	223	}
1da177e4	224	if (bdev != bdev->bd_contains) {
ca99dab0 SH	225	pr_warning("%s: The specified DASD is a partition and cannot "
ca99dab0 SH	226	"be formatted\n",
65f8da47 SW	227	dev_name(&base->cdev->dev));
65f8da47 SW	228	dasd_put_device(base);
1da177e4 LT	229	return -EINVAL;
1da177e4 LT	230	}
65f8da47 SW	231	rc = dasd_format(base->block, &fdata);
	232	dasd_put_device(base);
	233	return rc;
1da177e4 LT	234	}
	235
	236	#ifdef CONFIG_DASD_PROFILE
	237	/*
	238	* Reset device profile information
	239	*/
8e09f215	240	static int dasd_ioctl_reset_profile(struct dasd_block *block)
1da177e4	241	{
8e09f215	242	memset(&block->profile, 0, sizeof(struct dasd_profile_info_t));
1da177e4 LT	243	return 0;
	244	}
	245
	246	/*
	247	* Return device profile information
	248	*/
8e09f215	249	static int dasd_ioctl_read_profile(struct dasd_block block, void __user argp)
1da177e4	250	{
9a7af289 HH	251	if (dasd_profile_level == DASD_PROFILE_OFF)
9a7af289 HH	252	return -EIO;
8e09f215 SW	253	if (copy_to_user(argp, &block->profile,
8e09f215 SW	254	sizeof(struct dasd_profile_info_t)))
1da177e4 LT	255	return -EFAULT;
	256	return 0;
	257	}
	258	#else
8e09f215	259	static int dasd_ioctl_reset_profile(struct dasd_block *block)
1da177e4 LT	260	{
	261	return -ENOSYS;
	262	}
	263
8e09f215	264	static int dasd_ioctl_read_profile(struct dasd_block block, void __user argp)
1da177e4 LT	265	{
	266	return -ENOSYS;
	267	}
	268	#endif
	269
	270	/*
	271	* Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
	272	*/
8e09f215 SW	273	static int dasd_ioctl_information(struct dasd_block *block,
8e09f215 SW	274	unsigned int cmd, void __user *argp)
1da177e4	275	{
1da177e4 LT	276	struct dasd_information2_t *dasd_info;
1da177e4 LT	277	unsigned long flags;
c6eb7b77	278	int rc;
8e09f215	279	struct dasd_device *base;
1da177e4	280	struct ccw_device *cdev;
9a92fe48	281	struct ccw_dev_id dev_id;
1da177e4	282
8e09f215	283	base = block->base;
294001a8	284	if (!base->discipline \|\| !base->discipline->fill_info)
1da177e4 LT	285	return -EINVAL;
1da177e4 LT	286
554a826e	287	dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
1da177e4 LT	288	if (dasd_info == NULL)
	289	return -ENOMEM;
	290
8e09f215	291	rc = base->discipline->fill_info(base, dasd_info);
1da177e4 LT	292	if (rc) {
	293	kfree(dasd_info);
	294	return rc;
	295	}
	296
8e09f215	297	cdev = base->cdev;
9a92fe48	298	ccw_device_get_id(cdev, &dev_id);
1da177e4	299
9a92fe48	300	dasd_info->devno = dev_id.devno;
8e09f215	301	dasd_info->schid = _ccw_device_get_subchannel_number(base->cdev);
1da177e4 LT	302	dasd_info->cu_type = cdev->id.cu_type;
	303	dasd_info->cu_model = cdev->id.cu_model;
	304	dasd_info->dev_type = cdev->id.dev_type;
	305	dasd_info->dev_model = cdev->id.dev_model;
8e09f215	306	dasd_info->status = base->state;
57467195 HH	307	/*
	308	* The open_count is increased for every opener, that includes
	309	* the blkdev_get in dasd_scan_partitions.
	310	* This must be hidden from user-space.
	311	*/
8e09f215 SW	312	dasd_info->open_count = atomic_read(&block->open_count);
8e09f215 SW	313	if (!block->bdev)
57467195	314	dasd_info->open_count++;
138c014d	315
1da177e4 LT	316	/*
	317	* check if device is really formatted
	318	* LDL / CDL was returned by 'fill_info'
	319	*/
8e09f215 SW	320	if ((base->state < DASD_STATE_READY) \|\|
8e09f215 SW	321	(dasd_check_blocksize(block->bp_block)))
1da177e4	322	dasd_info->format = DASD_FORMAT_NONE;
f24acd45	323
c6eb7b77	324	dasd_info->features \|=
8e09f215	325	((base->features & DASD_FEATURE_READONLY) != 0);
1da177e4	326
294001a8	327	memcpy(dasd_info->type, base->discipline->name, 4);
554a826e	328
8e09f215	329	if (block->request_queue->request_fn) {
1da177e4 LT	330	struct list_head *l;
	331	#ifdef DASD_EXTENDED_PROFILING
	332	{
	333	struct list_head *l;
8e09f215 SW	334	spin_lock_irqsave(&block->lock, flags);
8e09f215 SW	335	list_for_each(l, &block->request_queue->queue_head)
1da177e4	336	dasd_info->req_queue_len++;
8e09f215	337	spin_unlock_irqrestore(&block->lock, flags);
1da177e4 LT	338	}
1da177e4 LT	339	#endif /* DASD_EXTENDED_PROFILING */
8e09f215 SW	340	spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
8e09f215 SW	341	list_for_each(l, &base->ccw_queue)
1da177e4	342	dasd_info->chanq_len++;
8e09f215	343	spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
1da177e4 LT	344	flags);
	345	}
	346
	347	rc = 0;
13c6204f CH	348	if (copy_to_user(argp, dasd_info,
13c6204f CH	349	((cmd == (unsigned int) BIODASDINFO2) ?
8e09f215 SW	350	sizeof(struct dasd_information2_t) :
8e09f215 SW	351	sizeof(struct dasd_information_t))))
1da177e4 LT	352	rc = -EFAULT;
	353	kfree(dasd_info);
	354	return rc;
	355	}
	356
	357	/*
	358	* Set read only
	359	*/
	360	static int
13c6204f	361	dasd_ioctl_set_ro(struct block_device bdev, void __user argp)
1da177e4	362	{
65f8da47 SW	363	struct dasd_device *base;
65f8da47 SW	364	int intval, rc;
1da177e4 LT	365
	366	if (!capable(CAP_SYS_ADMIN))
	367	return -EACCES;
	368	if (bdev != bdev->bd_contains)
	369	// ro setting is not allowed for partitions
	370	return -EINVAL;
d2c993d8	371	if (get_user(intval, (int __user *)argp))
1da177e4	372	return -EFAULT;
65f8da47 SW	373	base = dasd_device_from_gendisk(bdev->bd_disk);
	374	if (!base)
	375	return -ENODEV;
	376	if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
	377	dasd_put_device(base);
33b62a30	378	return -EROFS;
65f8da47	379	}
1da177e4	380	set_disk_ro(bdev->bd_disk, intval);
65f8da47 SW	381	rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval);
	382	dasd_put_device(base);
	383	return rc;
1da177e4 LT	384	}
1da177e4 LT	385
8e09f215	386	static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
88034865	387	struct cmbdata __user *argp)
8b2eb664	388	{
8b2eb664 CH	389	size_t size = _IOC_SIZE(cmd);
	390	struct cmbdata data;
	391	int ret;
	392
8e09f215	393	ret = cmf_readall(block->base->cdev, &data);
8b2eb664 CH	394	if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
	395	return -EFAULT;
	396	return ret;
	397	}
	398
cfdb00a7 AB	399	int dasd_ioctl(struct block_device *bdev, fmode_t mode,
cfdb00a7 AB	400	unsigned int cmd, unsigned long arg)
1da177e4	401	{
65f8da47 SW	402	struct dasd_block *block;
65f8da47 SW	403	struct dasd_device *base;
88034865	404	void __user *argp;
65f8da47	405	int rc;
88034865 HC	406
	407	if (is_compat_task())
	408	argp = compat_ptr(arg);
	409	else
	410	argp = (void __user *)arg;
1da177e4	411
13c6204f CH	412	if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
	413	PRINT_DEBUG("empty data ptr");
	414	return -EINVAL;
	415	}
1da177e4	416
65f8da47 SW	417	base = dasd_device_from_gendisk(bdev->bd_disk);
	418	if (!base)
	419	return -ENODEV;
	420	block = base->block;
	421	rc = 0;
13c6204f CH	422	switch (cmd) {
13c6204f CH	423	case BIODASDDISABLE:
65f8da47 SW	424	rc = dasd_ioctl_disable(bdev);
65f8da47 SW	425	break;
13c6204f	426	case BIODASDENABLE:
65f8da47 SW	427	rc = dasd_ioctl_enable(bdev);
65f8da47 SW	428	break;
13c6204f	429	case BIODASDQUIESCE:
65f8da47 SW	430	rc = dasd_ioctl_quiesce(block);
65f8da47 SW	431	break;
13c6204f	432	case BIODASDRESUME:
65f8da47 SW	433	rc = dasd_ioctl_resume(block);
65f8da47 SW	434	break;
13c6204f	435	case BIODASDFMT:
65f8da47 SW	436	rc = dasd_ioctl_format(bdev, argp);
65f8da47 SW	437	break;
13c6204f	438	case BIODASDINFO:
65f8da47 SW	439	rc = dasd_ioctl_information(block, cmd, argp);
65f8da47 SW	440	break;
13c6204f	441	case BIODASDINFO2:
65f8da47 SW	442	rc = dasd_ioctl_information(block, cmd, argp);
65f8da47 SW	443	break;
13c6204f	444	case BIODASDPRRD:
65f8da47 SW	445	rc = dasd_ioctl_read_profile(block, argp);
65f8da47 SW	446	break;
13c6204f	447	case BIODASDPRRST:
65f8da47 SW	448	rc = dasd_ioctl_reset_profile(block);
65f8da47 SW	449	break;
13c6204f	450	case BLKROSET:
65f8da47 SW	451	rc = dasd_ioctl_set_ro(bdev, argp);
65f8da47 SW	452	break;
13c6204f	453	case DASDAPIVER:
65f8da47 SW	454	rc = dasd_ioctl_api_version(argp);
65f8da47 SW	455	break;
8b2eb664	456	case BIODASDCMFENABLE:
65f8da47 SW	457	rc = enable_cmf(base->cdev);
65f8da47 SW	458	break;
8b2eb664	459	case BIODASDCMFDISABLE:
65f8da47 SW	460	rc = disable_cmf(base->cdev);
65f8da47 SW	461	break;
8b2eb664	462	case BIODASDREADALLCMB:
65f8da47 SW	463	rc = dasd_ioctl_readall_cmb(block, cmd, argp);
65f8da47 SW	464	break;
13c6204f	465	default:
1107ccfb	466	/* if the discipline has an ioctl method try it. */
65f8da47 SW	467	if (base->discipline->ioctl) {
	468	rc = base->discipline->ioctl(block, cmd, argp);
	469	if (rc == -ENOIOCTLCMD)
	470	rc = -EINVAL;
	471	} else
	472	rc = -EINVAL;
13c6204f	473	}
65f8da47 SW	474	dasd_put_device(base);
65f8da47 SW	475	return rc;
1da177e4	476	}