1
2
3
4
5
6
7
8
9
10
11
12#define KMSG_COMPONENT "dasd"
13
14#include <linux/interrupt.h>
15#include <linux/compat.h>
16#include <linux/major.h>
17#include <linux/fs.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>
23#include <asm/cmb.h>
24#include <asm/uaccess.h>
25
26
27#define PRINTK_HEADER "dasd_ioctl:"
28
29#include "dasd_int.h"
30
31
32static int
33dasd_ioctl_api_version(void __user *argp)
34{
35 int ver = DASD_API_VERSION;
36 return put_user(ver, (int __user *)argp);
37}
38
39
40
41
42
43static int
44dasd_ioctl_enable(struct block_device *bdev)
45{
46 struct dasd_device *base;
47
48 if (!capable(CAP_SYS_ADMIN))
49 return -EACCES;
50
51 base = dasd_device_from_gendisk(bdev->bd_disk);
52 if (!base)
53 return -ENODEV;
54
55 dasd_enable_device(base);
56
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);
62 return 0;
63}
64
65
66
67
68
69static int
70dasd_ioctl_disable(struct block_device *bdev)
71{
72 struct dasd_device *base;
73
74 if (!capable(CAP_SYS_ADMIN))
75 return -EACCES;
76
77 base = dasd_device_from_gendisk(bdev->bd_disk);
78 if (!base)
79 return -ENODEV;
80
81
82
83
84
85
86
87
88 dasd_set_target_state(base, DASD_STATE_BASIC);
89
90
91
92
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);
97 return 0;
98}
99
100
101
102
103static int dasd_ioctl_quiesce(struct dasd_block *block)
104{
105 unsigned long flags;
106 struct dasd_device *base;
107
108 base = block->base;
109 if (!capable (CAP_SYS_ADMIN))
110 return -EACCES;
111
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);
117 return 0;
118}
119
120
121
122
123
124static int dasd_ioctl_resume(struct dasd_block *block)
125{
126 unsigned long flags;
127 struct dasd_device *base;
128
129 base = block->base;
130 if (!capable (CAP_SYS_ADMIN))
131 return -EACCES;
132
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);
138
139 dasd_schedule_block_bh(block);
140 return 0;
141}
142
143
144
145
146static int dasd_ioctl_abortio(struct dasd_block *block)
147{
148 unsigned long flags;
149 struct dasd_device *base;
150 struct dasd_ccw_req *cqr, *n;
151
152 base = block->base;
153 if (!capable(CAP_SYS_ADMIN))
154 return -EACCES;
155
156 if (test_and_set_bit(DASD_FLAG_ABORTALL, &base->flags))
157 return 0;
158 DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag set");
159
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);
170 }
171 }
172 spin_unlock(&block->queue_lock);
173 spin_unlock_irqrestore(&block->request_queue_lock, flags);
174
175 dasd_schedule_block_bh(block);
176 return 0;
177}
178
179
180
181
182static int dasd_ioctl_allowio(struct dasd_block *block)
183{
184 struct dasd_device *base;
185
186 base = block->base;
187 if (!capable(CAP_SYS_ADMIN))
188 return -EACCES;
189
190 if (test_and_clear_bit(DASD_FLAG_ABORTALL, &base->flags))
191 DBF_DEV_EVENT(DBF_NOTICE, base, "%s", "abortall flag unset");
192
193 return 0;
194}
195
196
197
198
199
200
201
202static int
203dasd_format(struct dasd_block *block, struct format_data_t *fdata)
204{
205 struct dasd_device *base;
206 int rc;
207
208 base = block->base;
209 if (base->discipline->format_device == NULL)
210 return -EPERM;
211
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));
215 return -EBUSY;
216 }
217
218 DBF_DEV_EVENT(DBF_NOTICE, base,
219 "formatting units %u to %u (%u B blocks) flags %u",
220 fdata->start_unit,
221 fdata->stop_unit, fdata->blksize, fdata->intensity);
222
223
224
225
226
227
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);
231 bdput(bdev);
232 }
233
234 rc = base->discipline->format_device(base, fdata, 1);
235 if (rc == -EAGAIN)
236 rc = base->discipline->format_device(base, fdata, 0);
237
238 return rc;
239}
240
241static int dasd_check_format(struct dasd_block *block,
242 struct format_check_t *cdata)
243{
244 struct dasd_device *base;
245 int rc;
246
247 base = block->base;
248 if (!base->discipline->check_device_format)
249 return -ENOTTY;
250
251 rc = base->discipline->check_device_format(base, cdata, 1);
252 if (rc == -EAGAIN)
253 rc = base->discipline->check_device_format(base, cdata, 0);
254
255 return rc;
256}
257
258
259
260
261static int
262dasd_ioctl_format(struct block_device *bdev, void __user *argp)
263{
264 struct dasd_device *base;
265 struct format_data_t fdata;
266 int rc;
267
268 if (!capable(CAP_SYS_ADMIN))
269 return -EACCES;
270 if (!argp)
271 return -EINVAL;
272 base = dasd_device_from_gendisk(bdev->bd_disk);
273 if (!base)
274 return -ENODEV;
275 if (base->features & DASD_FEATURE_READONLY ||
276 test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
277 dasd_put_device(base);
278 return -EROFS;
279 }
280 if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
281 dasd_put_device(base);
282 return -EFAULT;
283 }
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);
288 return -EINVAL;
289 }
290 rc = dasd_format(base->block, &fdata);
291 dasd_put_device(base);
292
293 return rc;
294}
295
296
297
298
299static int dasd_ioctl_check_format(struct block_device *bdev, void __user *argp)
300{
301 struct format_check_t cdata;
302 struct dasd_device *base;
303 int rc = 0;
304
305 if (!argp)
306 return -EINVAL;
307
308 base = dasd_device_from_gendisk(bdev->bd_disk);
309 if (!base)
310 return -ENODEV;
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));
314 rc = -EINVAL;
315 goto out_err;
316 }
317
318 if (copy_from_user(&cdata, argp, sizeof(cdata))) {
319 rc = -EFAULT;
320 goto out_err;
321 }
322
323 rc = dasd_check_format(base->block, &cdata);
324 if (rc)
325 goto out_err;
326
327 if (copy_to_user(argp, &cdata, sizeof(cdata)))
328 rc = -EFAULT;
329
330out_err:
331 dasd_put_device(base);
332
333 return rc;
334}
335
336#ifdef CONFIG_DASD_PROFILE
337
338
339
340static int dasd_ioctl_reset_profile(struct dasd_block *block)
341{
342 dasd_profile_reset(&block->profile);
343 return 0;
344}
345
346
347
348
349static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
350{
351 struct dasd_profile_info_t *data;
352 int rc = 0;
353
354 data = kmalloc(sizeof(*data), GFP_KERNEL);
355 if (!data)
356 return -ENOMEM;
357
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);
381 } else {
382 spin_unlock_bh(&block->profile.lock);
383 rc = -EIO;
384 goto out;
385 }
386 if (copy_to_user(argp, data, sizeof(*data)))
387 rc = -EFAULT;
388out:
389 kfree(data);
390 return rc;
391}
392#else
393static int dasd_ioctl_reset_profile(struct dasd_block *block)
394{
395 return -ENOTTY;
396}
397
398static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
399{
400 return -ENOTTY;
401}
402#endif
403
404
405
406
407static int dasd_ioctl_information(struct dasd_block *block,
408 unsigned int cmd, void __user *argp)
409{
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;
415 unsigned long flags;
416 int rc;
417
418 base = block->base;
419 if (!base->discipline || !base->discipline->fill_info)
420 return -EINVAL;
421
422 dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
423 if (dasd_info == NULL)
424 return -ENOMEM;
425
426 rc = base->discipline->fill_info(base, dasd_info);
427 if (rc) {
428 kfree(dasd_info);
429 return rc;
430 }
431
432 cdev = base->cdev;
433 ccw_device_get_id(cdev, &dev_id);
434 ccw_device_get_schid(cdev, &sch_id);
435
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;
443
444
445
446
447
448 dasd_info->open_count = atomic_read(&block->open_count);
449 if (!block->bdev)
450 dasd_info->open_count++;
451
452
453
454
455
456 if ((base->state < DASD_STATE_READY) ||
457 (dasd_check_blocksize(block->bp_block)))
458 dasd_info->format = DASD_FORMAT_NONE;
459
460 dasd_info->features |=
461 ((base->features & DASD_FEATURE_READONLY) != 0);
462
463 memcpy(dasd_info->type, base->discipline->name, 4);
464
465 if (block->request_queue->request_fn) {
466 struct list_head *l;
467#ifdef DASD_EXTENDED_PROFILING
468 {
469 struct list_head *l;
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);
474 }
475#endif
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),
480 flags);
481 }
482
483 rc = 0;
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))))
488 rc = -EFAULT;
489 kfree(dasd_info);
490 return rc;
491}
492
493
494
495
496static int
497dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
498{
499 struct dasd_device *base;
500 int intval, rc;
501
502 if (!capable(CAP_SYS_ADMIN))
503 return -EACCES;
504 if (bdev != bdev->bd_contains)
505
506 return -EINVAL;
507 if (get_user(intval, (int __user *)argp))
508 return -EFAULT;
509 base = dasd_device_from_gendisk(bdev->bd_disk);
510 if (!base)
511 return -ENODEV;
512 if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
513 dasd_put_device(base);
514 return -EROFS;
515 }
516 set_disk_ro(bdev->bd_disk, intval);
517 rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval);
518 dasd_put_device(base);
519 return rc;
520}
521
522static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
523 struct cmbdata __user *argp)
524{
525 size_t size = _IOC_SIZE(cmd);
526 struct cmbdata data;
527 int ret;
528
529 ret = cmf_readall(block->base->cdev, &data);
530 if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
531 return -EFAULT;
532 return ret;
533}
534
535int dasd_ioctl(struct block_device *bdev, fmode_t mode,
536 unsigned int cmd, unsigned long arg)
537{
538 struct dasd_block *block;
539 struct dasd_device *base;
540 void __user *argp;
541 int rc;
542
543 if (is_compat_task())
544 argp = compat_ptr(arg);
545 else
546 argp = (void __user *)arg;
547
548 if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
549 PRINT_DEBUG("empty data ptr");
550 return -EINVAL;
551 }
552
553 base = dasd_device_from_gendisk(bdev->bd_disk);
554 if (!base)
555 return -ENODEV;
556 block = base->block;
557 rc = 0;
558 switch (cmd) {
559 case BIODASDDISABLE:
560 rc = dasd_ioctl_disable(bdev);
561 break;
562 case BIODASDENABLE:
563 rc = dasd_ioctl_enable(bdev);
564 break;
565 case BIODASDQUIESCE:
566 rc = dasd_ioctl_quiesce(block);
567 break;
568 case BIODASDRESUME:
569 rc = dasd_ioctl_resume(block);
570 break;
571 case BIODASDABORTIO:
572 rc = dasd_ioctl_abortio(block);
573 break;
574 case BIODASDALLOWIO:
575 rc = dasd_ioctl_allowio(block);
576 break;
577 case BIODASDFMT:
578 rc = dasd_ioctl_format(bdev, argp);
579 break;
580 case BIODASDCHECKFMT:
581 rc = dasd_ioctl_check_format(bdev, argp);
582 break;
583 case BIODASDINFO:
584 rc = dasd_ioctl_information(block, cmd, argp);
585 break;
586 case BIODASDINFO2:
587 rc = dasd_ioctl_information(block, cmd, argp);
588 break;
589 case BIODASDPRRD:
590 rc = dasd_ioctl_read_profile(block, argp);
591 break;
592 case BIODASDPRRST:
593 rc = dasd_ioctl_reset_profile(block);
594 break;
595 case BLKROSET:
596 rc = dasd_ioctl_set_ro(bdev, argp);
597 break;
598 case DASDAPIVER:
599 rc = dasd_ioctl_api_version(argp);
600 break;
601 case BIODASDCMFENABLE:
602 rc = enable_cmf(base->cdev);
603 break;
604 case BIODASDCMFDISABLE:
605 rc = disable_cmf(base->cdev);
606 break;
607 case BIODASDREADALLCMB:
608 rc = dasd_ioctl_readall_cmb(block, cmd, argp);
609 break;
610 default:
611
612 rc = -ENOTTY;
613 if (base->discipline->ioctl)
614 rc = base->discipline->ioctl(block, cmd, argp);
615 }
616 dasd_put_device(base);
617 return rc;
618}
619
