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
10 * i/o controls for the dasd driver.
13 #define KMSG_COMPONENT "dasd"
15 #include <linux/interrupt.h>
16 #include <linux/major.h>
18 #include <linux/blkpg.h>
19 #include <linux/slab.h>
20 #include <asm/compat.h>
21 #include <asm/ccwdev.h>
23 #include <asm/uaccess.h>
26 #define PRINTK_HEADER "dasd_ioctl:"
32 dasd_ioctl_api_version(void __user
*argp
)
34 int ver
= DASD_API_VERSION
;
35 return put_user(ver
, (int __user
*)argp
);
40 * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
43 dasd_ioctl_enable(struct block_device
*bdev
)
45 struct dasd_device
*base
;
47 if (!capable(CAP_SYS_ADMIN
))
50 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
54 dasd_enable_device(base
);
55 /* Formatting the dasd device can change the capacity. */
56 mutex_lock(&bdev
->bd_mutex
);
57 i_size_write(bdev
->bd_inode
,
58 (loff_t
)get_capacity(base
->block
->gdp
) << 9);
59 mutex_unlock(&bdev
->bd_mutex
);
60 dasd_put_device(base
);
66 * Used by dasdfmt. Disable I/O operations but allow ioctls.
69 dasd_ioctl_disable(struct block_device
*bdev
)
71 struct dasd_device
*base
;
73 if (!capable(CAP_SYS_ADMIN
))
76 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
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.
87 dasd_set_target_state(base
, DASD_STATE_BASIC
);
89 * Set i_size to zero, since read, write, etc. check against this
92 mutex_lock(&bdev
->bd_mutex
);
93 i_size_write(bdev
->bd_inode
, 0);
94 mutex_unlock(&bdev
->bd_mutex
);
95 dasd_put_device(base
);
102 static int dasd_ioctl_quiesce(struct dasd_block
*block
)
105 struct dasd_device
*base
;
108 if (!capable (CAP_SYS_ADMIN
))
111 pr_info("%s: The DASD has been put in the quiesce "
112 "state\n", dev_name(&base
->cdev
->dev
));
113 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
114 dasd_device_set_stop_bits(base
, DASD_STOPPED_QUIESCE
);
115 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
), flags
);
123 static int dasd_ioctl_resume(struct dasd_block
*block
)
126 struct dasd_device
*base
;
129 if (!capable (CAP_SYS_ADMIN
))
132 pr_info("%s: I/O operations have been resumed "
133 "on the DASD\n", dev_name(&base
->cdev
->dev
));
134 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
135 dasd_device_remove_stop_bits(base
, DASD_STOPPED_QUIESCE
);
136 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
), flags
);
138 dasd_schedule_block_bh(block
);
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.
148 static int dasd_format(struct dasd_block
*block
, struct format_data_t
*fdata
)
150 struct dasd_ccw_req
*cqr
;
151 struct dasd_device
*base
;
155 if (base
->discipline
->format_device
== NULL
)
158 if (base
->state
!= DASD_STATE_BASIC
) {
159 pr_warning("%s: The DASD cannot be formatted while it is "
160 "enabled\n", dev_name(&base
->cdev
->dev
));
164 DBF_DEV_EVENT(DBF_NOTICE
, base
,
165 "formatting units %u to %u (%u B blocks) flags %u",
167 fdata
->stop_unit
, fdata
->blksize
, fdata
->intensity
);
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.
174 if (fdata
->start_unit
== 0) {
175 struct block_device
*bdev
= bdget_disk(block
->gdp
, 0);
176 bdev
->bd_inode
->i_blkbits
= blksize_bits(fdata
->blksize
);
180 while (fdata
->start_unit
<= fdata
->stop_unit
) {
181 cqr
= base
->discipline
->format_device(base
, fdata
);
184 rc
= dasd_sleep_on_interruptible(cqr
);
185 dasd_sfree_request(cqr
, cqr
->memdev
);
187 if (rc
!= -ERESTARTSYS
)
188 pr_err("%s: Formatting unit %d failed with "
189 "rc=%d\n", dev_name(&base
->cdev
->dev
),
190 fdata
->start_unit
, rc
);
202 dasd_ioctl_format(struct block_device
*bdev
, void __user
*argp
)
204 struct dasd_device
*base
;
205 struct format_data_t fdata
;
208 if (!capable(CAP_SYS_ADMIN
))
212 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
215 if (base
->features
& DASD_FEATURE_READONLY
||
216 test_bit(DASD_FLAG_DEVICE_RO
, &base
->flags
)) {
217 dasd_put_device(base
);
220 if (copy_from_user(&fdata
, argp
, sizeof(struct format_data_t
))) {
221 dasd_put_device(base
);
224 if (bdev
!= bdev
->bd_contains
) {
225 pr_warning("%s: The specified DASD is a partition and cannot "
227 dev_name(&base
->cdev
->dev
));
228 dasd_put_device(base
);
231 rc
= dasd_format(base
->block
, &fdata
);
232 dasd_put_device(base
);
236 #ifdef CONFIG_DASD_PROFILE
238 * Reset device profile information
240 static int dasd_ioctl_reset_profile(struct dasd_block
*block
)
242 dasd_profile_reset(&block
->profile
);
247 * Return device profile information
249 static int dasd_ioctl_read_profile(struct dasd_block
*block
, void __user
*argp
)
251 struct dasd_profile_info_t
*data
;
253 data
= kmalloc(sizeof(*data
), GFP_KERNEL
);
257 spin_lock_bh(&block
->profile
.lock
);
258 if (block
->profile
.data
) {
259 data
->dasd_io_reqs
= block
->profile
.data
->dasd_io_reqs
;
260 data
->dasd_io_sects
= block
->profile
.data
->dasd_io_sects
;
261 memcpy(data
->dasd_io_secs
, block
->profile
.data
->dasd_io_secs
,
262 sizeof(data
->dasd_io_secs
));
263 memcpy(data
->dasd_io_times
, block
->profile
.data
->dasd_io_times
,
264 sizeof(data
->dasd_io_times
));
265 memcpy(data
->dasd_io_timps
, block
->profile
.data
->dasd_io_timps
,
266 sizeof(data
->dasd_io_timps
));
267 memcpy(data
->dasd_io_time1
, block
->profile
.data
->dasd_io_time1
,
268 sizeof(data
->dasd_io_time1
));
269 memcpy(data
->dasd_io_time2
, block
->profile
.data
->dasd_io_time2
,
270 sizeof(data
->dasd_io_time2
));
271 memcpy(data
->dasd_io_time2ps
,
272 block
->profile
.data
->dasd_io_time2ps
,
273 sizeof(data
->dasd_io_time2ps
));
274 memcpy(data
->dasd_io_time3
, block
->profile
.data
->dasd_io_time3
,
275 sizeof(data
->dasd_io_time3
));
276 memcpy(data
->dasd_io_nr_req
,
277 block
->profile
.data
->dasd_io_nr_req
,
278 sizeof(data
->dasd_io_nr_req
));
279 spin_unlock_bh(&block
->profile
.lock
);
281 spin_unlock_bh(&block
->profile
.lock
);
284 if (copy_to_user(argp
, data
, sizeof(*data
)))
289 static int dasd_ioctl_reset_profile(struct dasd_block
*block
)
294 static int dasd_ioctl_read_profile(struct dasd_block
*block
, void __user
*argp
)
301 * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
303 static int dasd_ioctl_information(struct dasd_block
*block
,
304 unsigned int cmd
, void __user
*argp
)
306 struct dasd_information2_t
*dasd_info
;
309 struct dasd_device
*base
;
310 struct ccw_device
*cdev
;
311 struct ccw_dev_id dev_id
;
314 if (!base
->discipline
|| !base
->discipline
->fill_info
)
317 dasd_info
= kzalloc(sizeof(struct dasd_information2_t
), GFP_KERNEL
);
318 if (dasd_info
== NULL
)
321 rc
= base
->discipline
->fill_info(base
, dasd_info
);
328 ccw_device_get_id(cdev
, &dev_id
);
330 dasd_info
->devno
= dev_id
.devno
;
331 dasd_info
->schid
= _ccw_device_get_subchannel_number(base
->cdev
);
332 dasd_info
->cu_type
= cdev
->id
.cu_type
;
333 dasd_info
->cu_model
= cdev
->id
.cu_model
;
334 dasd_info
->dev_type
= cdev
->id
.dev_type
;
335 dasd_info
->dev_model
= cdev
->id
.dev_model
;
336 dasd_info
->status
= base
->state
;
338 * The open_count is increased for every opener, that includes
339 * the blkdev_get in dasd_scan_partitions.
340 * This must be hidden from user-space.
342 dasd_info
->open_count
= atomic_read(&block
->open_count
);
344 dasd_info
->open_count
++;
347 * check if device is really formatted
348 * LDL / CDL was returned by 'fill_info'
350 if ((base
->state
< DASD_STATE_READY
) ||
351 (dasd_check_blocksize(block
->bp_block
)))
352 dasd_info
->format
= DASD_FORMAT_NONE
;
354 dasd_info
->features
|=
355 ((base
->features
& DASD_FEATURE_READONLY
) != 0);
357 memcpy(dasd_info
->type
, base
->discipline
->name
, 4);
359 if (block
->request_queue
->request_fn
) {
361 #ifdef DASD_EXTENDED_PROFILING
364 spin_lock_irqsave(&block
->lock
, flags
);
365 list_for_each(l
, &block
->request_queue
->queue_head
)
366 dasd_info
->req_queue_len
++;
367 spin_unlock_irqrestore(&block
->lock
, flags
);
369 #endif /* DASD_EXTENDED_PROFILING */
370 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
371 list_for_each(l
, &base
->ccw_queue
)
372 dasd_info
->chanq_len
++;
373 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
),
378 if (copy_to_user(argp
, dasd_info
,
379 ((cmd
== (unsigned int) BIODASDINFO2
) ?
380 sizeof(struct dasd_information2_t
) :
381 sizeof(struct dasd_information_t
))))
391 dasd_ioctl_set_ro(struct block_device
*bdev
, void __user
*argp
)
393 struct dasd_device
*base
;
396 if (!capable(CAP_SYS_ADMIN
))
398 if (bdev
!= bdev
->bd_contains
)
399 // ro setting is not allowed for partitions
401 if (get_user(intval
, (int __user
*)argp
))
403 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
406 if (!intval
&& test_bit(DASD_FLAG_DEVICE_RO
, &base
->flags
)) {
407 dasd_put_device(base
);
410 set_disk_ro(bdev
->bd_disk
, intval
);
411 rc
= dasd_set_feature(base
->cdev
, DASD_FEATURE_READONLY
, intval
);
412 dasd_put_device(base
);
416 static int dasd_ioctl_readall_cmb(struct dasd_block
*block
, unsigned int cmd
,
417 struct cmbdata __user
*argp
)
419 size_t size
= _IOC_SIZE(cmd
);
423 ret
= cmf_readall(block
->base
->cdev
, &data
);
424 if (!ret
&& copy_to_user(argp
, &data
, min(size
, sizeof(*argp
))))
429 int dasd_ioctl(struct block_device
*bdev
, fmode_t mode
,
430 unsigned int cmd
, unsigned long arg
)
432 struct dasd_block
*block
;
433 struct dasd_device
*base
;
437 if (is_compat_task())
438 argp
= compat_ptr(arg
);
440 argp
= (void __user
*)arg
;
442 if ((_IOC_DIR(cmd
) != _IOC_NONE
) && !arg
) {
443 PRINT_DEBUG("empty data ptr");
447 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
454 rc
= dasd_ioctl_disable(bdev
);
457 rc
= dasd_ioctl_enable(bdev
);
460 rc
= dasd_ioctl_quiesce(block
);
463 rc
= dasd_ioctl_resume(block
);
466 rc
= dasd_ioctl_format(bdev
, argp
);
469 rc
= dasd_ioctl_information(block
, cmd
, argp
);
472 rc
= dasd_ioctl_information(block
, cmd
, argp
);
475 rc
= dasd_ioctl_read_profile(block
, argp
);
478 rc
= dasd_ioctl_reset_profile(block
);
481 rc
= dasd_ioctl_set_ro(bdev
, argp
);
484 rc
= dasd_ioctl_api_version(argp
);
486 case BIODASDCMFENABLE
:
487 rc
= enable_cmf(base
->cdev
);
489 case BIODASDCMFDISABLE
:
490 rc
= disable_cmf(base
->cdev
);
492 case BIODASDREADALLCMB
:
493 rc
= dasd_ioctl_readall_cmb(block
, cmd
, argp
);
496 /* if the discipline has an ioctl method try it. */
497 if (base
->discipline
->ioctl
) {
498 rc
= base
->discipline
->ioctl(block
, cmd
, argp
);
499 if (rc
== -ENOIOCTLCMD
)
504 dasd_put_device(base
);