]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/s390/block/dasd_ioctl.c
2 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
3 * Horst Hummel <Horst.Hummel@de.ibm.com>
4 * Carsten Otte <Cotte@de.ibm.com>
5 * Martin Schwidefsky <schwidefsky@de.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
7 * Copyright IBM Corp. 1999, 2001
9 * i/o controls for the dasd driver.
12 #define KMSG_COMPONENT "dasd"
14 #include <linux/interrupt.h>
15 #include <linux/compat.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>
22 #include <asm/schid.h>
24 #include <linux/uaccess.h>
27 #define PRINTK_HEADER "dasd_ioctl:"
33 dasd_ioctl_api_version(void __user
*argp
)
35 int ver
= DASD_API_VERSION
;
36 return put_user(ver
, (int __user
*)argp
);
41 * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
44 dasd_ioctl_enable(struct block_device
*bdev
)
46 struct dasd_device
*base
;
48 if (!capable(CAP_SYS_ADMIN
))
51 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
55 dasd_enable_device(base
);
56 /* Formatting the dasd device can change the capacity. */
57 mutex_lock(&bdev
->bd_mutex
);
58 i_size_write(bdev
->bd_inode
,
59 (loff_t
)get_capacity(base
->block
->gdp
) << 9);
60 mutex_unlock(&bdev
->bd_mutex
);
61 dasd_put_device(base
);
67 * Used by dasdfmt. Disable I/O operations but allow ioctls.
70 dasd_ioctl_disable(struct block_device
*bdev
)
72 struct dasd_device
*base
;
74 if (!capable(CAP_SYS_ADMIN
))
77 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
81 * Man this is sick. We don't do a real disable but only downgrade
82 * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
83 * BIODASDDISABLE to disable accesses to the device via the block
84 * device layer but it still wants to do i/o on the device by
85 * using the BIODASDFMT ioctl. Therefore the correct state for the
86 * device is DASD_STATE_BASIC that allows to do basic i/o.
88 dasd_set_target_state(base
, DASD_STATE_BASIC
);
90 * Set i_size to zero, since read, write, etc. check against this
93 mutex_lock(&bdev
->bd_mutex
);
94 i_size_write(bdev
->bd_inode
, 0);
95 mutex_unlock(&bdev
->bd_mutex
);
96 dasd_put_device(base
);
103 static int dasd_ioctl_quiesce(struct dasd_block
*block
)
106 struct dasd_device
*base
;
109 if (!capable (CAP_SYS_ADMIN
))
112 pr_info("%s: The DASD has been put in the quiesce "
113 "state\n", dev_name(&base
->cdev
->dev
));
114 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
115 dasd_device_set_stop_bits(base
, DASD_STOPPED_QUIESCE
);
116 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
), flags
);
124 static int dasd_ioctl_resume(struct dasd_block
*block
)
127 struct dasd_device
*base
;
130 if (!capable (CAP_SYS_ADMIN
))
133 pr_info("%s: I/O operations have been resumed "
134 "on the DASD\n", dev_name(&base
->cdev
->dev
));
135 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
136 dasd_device_remove_stop_bits(base
, DASD_STOPPED_QUIESCE
);
137 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
), flags
);
139 dasd_schedule_block_bh(block
);
144 * Abort all failfast I/O on a device.
146 static int dasd_ioctl_abortio(struct dasd_block
*block
)
149 struct dasd_device
*base
;
150 struct dasd_ccw_req
*cqr
, *n
;
153 if (!capable(CAP_SYS_ADMIN
))
156 if (test_and_set_bit(DASD_FLAG_ABORTALL
, &base
->flags
))
158 DBF_DEV_EVENT(DBF_NOTICE
, base
, "%s", "abortall flag set");
160 spin_lock_irqsave(&block
->request_queue_lock
, flags
);
161 spin_lock(&block
->queue_lock
);
162 list_for_each_entry_safe(cqr
, n
, &block
->ccw_queue
, blocklist
) {
163 if (test_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
) &&
164 cqr
->callback_data
&&
165 cqr
->callback_data
!= DASD_SLEEPON_START_TAG
&&
166 cqr
->callback_data
!= DASD_SLEEPON_END_TAG
) {
167 spin_unlock(&block
->queue_lock
);
168 blk_abort_request(cqr
->callback_data
);
169 spin_lock(&block
->queue_lock
);
172 spin_unlock(&block
->queue_lock
);
173 spin_unlock_irqrestore(&block
->request_queue_lock
, flags
);
175 dasd_schedule_block_bh(block
);
180 * Allow I/O on a device
182 static int dasd_ioctl_allowio(struct dasd_block
*block
)
184 struct dasd_device
*base
;
187 if (!capable(CAP_SYS_ADMIN
))
190 if (test_and_clear_bit(DASD_FLAG_ABORTALL
, &base
->flags
))
191 DBF_DEV_EVENT(DBF_NOTICE
, base
, "%s", "abortall flag unset");
197 * performs formatting of _device_ according to _fdata_
198 * Note: The discipline's format_function is assumed to deliver formatting
199 * commands to format multiple units of the device. In terms of the ECKD
200 * devices this means CCWs are generated to format multiple tracks.
203 dasd_format(struct dasd_block
*block
, struct format_data_t
*fdata
)
205 struct dasd_device
*base
;
209 if (base
->discipline
->format_device
== NULL
)
212 if (base
->state
!= DASD_STATE_BASIC
) {
213 pr_warn("%s: The DASD cannot be formatted while it is enabled\n",
214 dev_name(&base
->cdev
->dev
));
218 DBF_DEV_EVENT(DBF_NOTICE
, base
,
219 "formatting units %u to %u (%u B blocks) flags %u",
221 fdata
->stop_unit
, fdata
->blksize
, fdata
->intensity
);
223 /* Since dasdfmt keeps the device open after it was disabled,
224 * there still exists an inode for this device.
225 * We must update i_blkbits, otherwise we might get errors when
226 * enabling the device later.
228 if (fdata
->start_unit
== 0) {
229 struct block_device
*bdev
= bdget_disk(block
->gdp
, 0);
230 bdev
->bd_inode
->i_blkbits
= blksize_bits(fdata
->blksize
);
234 rc
= base
->discipline
->format_device(base
, fdata
, 1);
236 rc
= base
->discipline
->format_device(base
, fdata
, 0);
241 static int dasd_check_format(struct dasd_block
*block
,
242 struct format_check_t
*cdata
)
244 struct dasd_device
*base
;
248 if (!base
->discipline
->check_device_format
)
251 rc
= base
->discipline
->check_device_format(base
, cdata
, 1);
253 rc
= base
->discipline
->check_device_format(base
, cdata
, 0);
262 dasd_ioctl_format(struct block_device
*bdev
, void __user
*argp
)
264 struct dasd_device
*base
;
265 struct format_data_t fdata
;
268 if (!capable(CAP_SYS_ADMIN
))
272 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
275 if (base
->features
& DASD_FEATURE_READONLY
||
276 test_bit(DASD_FLAG_DEVICE_RO
, &base
->flags
)) {
277 dasd_put_device(base
);
280 if (copy_from_user(&fdata
, argp
, sizeof(struct format_data_t
))) {
281 dasd_put_device(base
);
284 if (bdev
!= bdev
->bd_contains
) {
285 pr_warn("%s: The specified DASD is a partition and cannot be formatted\n",
286 dev_name(&base
->cdev
->dev
));
287 dasd_put_device(base
);
290 rc
= dasd_format(base
->block
, &fdata
);
291 dasd_put_device(base
);
297 * Check device format
299 static int dasd_ioctl_check_format(struct block_device
*bdev
, void __user
*argp
)
301 struct format_check_t cdata
;
302 struct dasd_device
*base
;
308 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
311 if (bdev
!= bdev
->bd_contains
) {
312 pr_warn("%s: The specified DASD is a partition and cannot be checked\n",
313 dev_name(&base
->cdev
->dev
));
318 if (copy_from_user(&cdata
, argp
, sizeof(cdata
))) {
323 rc
= dasd_check_format(base
->block
, &cdata
);
327 if (copy_to_user(argp
, &cdata
, sizeof(cdata
)))
331 dasd_put_device(base
);
336 #ifdef CONFIG_DASD_PROFILE
338 * Reset device profile information
340 static int dasd_ioctl_reset_profile(struct dasd_block
*block
)
342 dasd_profile_reset(&block
->profile
);
347 * Return device profile information
349 static int dasd_ioctl_read_profile(struct dasd_block
*block
, void __user
*argp
)
351 struct dasd_profile_info_t
*data
;
354 data
= kmalloc(sizeof(*data
), GFP_KERNEL
);
358 spin_lock_bh(&block
->profile
.lock
);
359 if (block
->profile
.data
) {
360 data
->dasd_io_reqs
= block
->profile
.data
->dasd_io_reqs
;
361 data
->dasd_io_sects
= block
->profile
.data
->dasd_io_sects
;
362 memcpy(data
->dasd_io_secs
, block
->profile
.data
->dasd_io_secs
,
363 sizeof(data
->dasd_io_secs
));
364 memcpy(data
->dasd_io_times
, block
->profile
.data
->dasd_io_times
,
365 sizeof(data
->dasd_io_times
));
366 memcpy(data
->dasd_io_timps
, block
->profile
.data
->dasd_io_timps
,
367 sizeof(data
->dasd_io_timps
));
368 memcpy(data
->dasd_io_time1
, block
->profile
.data
->dasd_io_time1
,
369 sizeof(data
->dasd_io_time1
));
370 memcpy(data
->dasd_io_time2
, block
->profile
.data
->dasd_io_time2
,
371 sizeof(data
->dasd_io_time2
));
372 memcpy(data
->dasd_io_time2ps
,
373 block
->profile
.data
->dasd_io_time2ps
,
374 sizeof(data
->dasd_io_time2ps
));
375 memcpy(data
->dasd_io_time3
, block
->profile
.data
->dasd_io_time3
,
376 sizeof(data
->dasd_io_time3
));
377 memcpy(data
->dasd_io_nr_req
,
378 block
->profile
.data
->dasd_io_nr_req
,
379 sizeof(data
->dasd_io_nr_req
));
380 spin_unlock_bh(&block
->profile
.lock
);
382 spin_unlock_bh(&block
->profile
.lock
);
386 if (copy_to_user(argp
, data
, sizeof(*data
)))
393 static int dasd_ioctl_reset_profile(struct dasd_block
*block
)
398 static int dasd_ioctl_read_profile(struct dasd_block
*block
, void __user
*argp
)
405 * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
407 static int dasd_ioctl_information(struct dasd_block
*block
,
408 unsigned int cmd
, void __user
*argp
)
410 struct dasd_information2_t
*dasd_info
;
411 struct subchannel_id sch_id
;
412 struct ccw_dev_id dev_id
;
413 struct dasd_device
*base
;
414 struct ccw_device
*cdev
;
419 if (!base
->discipline
|| !base
->discipline
->fill_info
)
422 dasd_info
= kzalloc(sizeof(struct dasd_information2_t
), GFP_KERNEL
);
423 if (dasd_info
== NULL
)
426 rc
= base
->discipline
->fill_info(base
, dasd_info
);
433 ccw_device_get_id(cdev
, &dev_id
);
434 ccw_device_get_schid(cdev
, &sch_id
);
436 dasd_info
->devno
= dev_id
.devno
;
437 dasd_info
->schid
= sch_id
.sch_no
;
438 dasd_info
->cu_type
= cdev
->id
.cu_type
;
439 dasd_info
->cu_model
= cdev
->id
.cu_model
;
440 dasd_info
->dev_type
= cdev
->id
.dev_type
;
441 dasd_info
->dev_model
= cdev
->id
.dev_model
;
442 dasd_info
->status
= base
->state
;
444 * The open_count is increased for every opener, that includes
445 * the blkdev_get in dasd_scan_partitions.
446 * This must be hidden from user-space.
448 dasd_info
->open_count
= atomic_read(&block
->open_count
);
450 dasd_info
->open_count
++;
453 * check if device is really formatted
454 * LDL / CDL was returned by 'fill_info'
456 if ((base
->state
< DASD_STATE_READY
) ||
457 (dasd_check_blocksize(block
->bp_block
)))
458 dasd_info
->format
= DASD_FORMAT_NONE
;
460 dasd_info
->features
|=
461 ((base
->features
& DASD_FEATURE_READONLY
) != 0);
463 memcpy(dasd_info
->type
, base
->discipline
->name
, 4);
465 if (block
->request_queue
->request_fn
) {
467 #ifdef DASD_EXTENDED_PROFILING
470 spin_lock_irqsave(&block
->lock
, flags
);
471 list_for_each(l
, &block
->request_queue
->queue_head
)
472 dasd_info
->req_queue_len
++;
473 spin_unlock_irqrestore(&block
->lock
, flags
);
475 #endif /* DASD_EXTENDED_PROFILING */
476 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
477 list_for_each(l
, &base
->ccw_queue
)
478 dasd_info
->chanq_len
++;
479 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
),
484 if (copy_to_user(argp
, dasd_info
,
485 ((cmd
== (unsigned int) BIODASDINFO2
) ?
486 sizeof(struct dasd_information2_t
) :
487 sizeof(struct dasd_information_t
))))
497 dasd_ioctl_set_ro(struct block_device
*bdev
, void __user
*argp
)
499 struct dasd_device
*base
;
502 if (!capable(CAP_SYS_ADMIN
))
504 if (bdev
!= bdev
->bd_contains
)
505 // ro setting is not allowed for partitions
507 if (get_user(intval
, (int __user
*)argp
))
509 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
512 if (!intval
&& test_bit(DASD_FLAG_DEVICE_RO
, &base
->flags
)) {
513 dasd_put_device(base
);
516 set_disk_ro(bdev
->bd_disk
, intval
);
517 rc
= dasd_set_feature(base
->cdev
, DASD_FEATURE_READONLY
, intval
);
518 dasd_put_device(base
);
522 static int dasd_ioctl_readall_cmb(struct dasd_block
*block
, unsigned int cmd
,
523 struct cmbdata __user
*argp
)
525 size_t size
= _IOC_SIZE(cmd
);
529 ret
= cmf_readall(block
->base
->cdev
, &data
);
530 if (!ret
&& copy_to_user(argp
, &data
, min(size
, sizeof(*argp
))))
535 int dasd_ioctl(struct block_device
*bdev
, fmode_t mode
,
536 unsigned int cmd
, unsigned long arg
)
538 struct dasd_block
*block
;
539 struct dasd_device
*base
;
543 if (is_compat_task())
544 argp
= compat_ptr(arg
);
546 argp
= (void __user
*)arg
;
548 if ((_IOC_DIR(cmd
) != _IOC_NONE
) && !arg
) {
549 PRINT_DEBUG("empty data ptr");
553 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
560 rc
= dasd_ioctl_disable(bdev
);
563 rc
= dasd_ioctl_enable(bdev
);
566 rc
= dasd_ioctl_quiesce(block
);
569 rc
= dasd_ioctl_resume(block
);
572 rc
= dasd_ioctl_abortio(block
);
575 rc
= dasd_ioctl_allowio(block
);
578 rc
= dasd_ioctl_format(bdev
, argp
);
580 case BIODASDCHECKFMT
:
581 rc
= dasd_ioctl_check_format(bdev
, argp
);
584 rc
= dasd_ioctl_information(block
, cmd
, argp
);
587 rc
= dasd_ioctl_information(block
, cmd
, argp
);
590 rc
= dasd_ioctl_read_profile(block
, argp
);
593 rc
= dasd_ioctl_reset_profile(block
);
596 rc
= dasd_ioctl_set_ro(bdev
, argp
);
599 rc
= dasd_ioctl_api_version(argp
);
601 case BIODASDCMFENABLE
:
602 rc
= enable_cmf(base
->cdev
);
604 case BIODASDCMFDISABLE
:
605 rc
= disable_cmf(base
->cdev
);
607 case BIODASDREADALLCMB
:
608 rc
= dasd_ioctl_readall_cmb(block
, cmd
, argp
);
611 /* if the discipline has an ioctl method try it. */
613 if (base
->discipline
->ioctl
)
614 rc
= base
->discipline
->ioctl(block
, cmd
, argp
);
616 dasd_put_device(base
);