1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/errno.h>
21#include <linux/string.h>
22#include <linux/module.h>
23#include <linux/blkdev.h>
24#include <linux/capability.h>
25#include <linux/completion.h>
26#include <linux/cdrom.h>
27#include <linux/ratelimit.h>
28#include <linux/slab.h>
29#include <linux/times.h>
30#include <linux/uio.h>
31#include <asm/uaccess.h>
32
33#include <scsi/scsi.h>
34#include <scsi/scsi_ioctl.h>
35#include <scsi/scsi_cmnd.h>
36
37struct blk_cmd_filter {
38 unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
39 unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
40};
41
42static struct blk_cmd_filter blk_default_cmd_filter;
43
44
45const unsigned char scsi_command_size_tbl[8] =
46{
47 6, 10, 10, 12,
48 16, 12, 10, 10
49};
50EXPORT_SYMBOL(scsi_command_size_tbl);
51
52#include <scsi/sg.h>
53
54static int sg_get_version(int __user *p)
55{
56 static const int sg_version_num = 30527;
57 return put_user(sg_version_num, p);
58}
59
60static int scsi_get_idlun(struct request_queue *q, int __user *p)
61{
62 return put_user(0, p);
63}
64
65static int scsi_get_bus(struct request_queue *q, int __user *p)
66{
67 return put_user(0, p);
68}
69
70static int sg_get_timeout(struct request_queue *q)
71{
72 return jiffies_to_clock_t(q->sg_timeout);
73}
74
75static int sg_set_timeout(struct request_queue *q, int __user *p)
76{
77 int timeout, err = get_user(timeout, p);
78
79 if (!err)
80 q->sg_timeout = clock_t_to_jiffies(timeout);
81
82 return err;
83}
84
85static int max_sectors_bytes(struct request_queue *q)
86{
87 unsigned int max_sectors = queue_max_sectors(q);
88
89 max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);
90
91 return max_sectors << 9;
92}
93
94static int sg_get_reserved_size(struct request_queue *q, int __user *p)
95{
96 int val = min_t(int, q->sg_reserved_size, max_sectors_bytes(q));
97
98 return put_user(val, p);
99}
100
101static int sg_set_reserved_size(struct request_queue *q, int __user *p)
102{
103 int size, err = get_user(size, p);
104
105 if (err)
106 return err;
107
108 if (size < 0)
109 return -EINVAL;
110
111 q->sg_reserved_size = min(size, max_sectors_bytes(q));
112 return 0;
113}
114
115
116
117
118
119static int sg_emulated_host(struct request_queue *q, int __user *p)
120{
121 return put_user(1, p);
122}
123
124static void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
125{
126
127 __set_bit(TEST_UNIT_READY, filter->read_ok);
128 __set_bit(REQUEST_SENSE, filter->read_ok);
129 __set_bit(READ_6, filter->read_ok);
130 __set_bit(READ_10, filter->read_ok);
131 __set_bit(READ_12, filter->read_ok);
132 __set_bit(READ_16, filter->read_ok);
133 __set_bit(READ_BUFFER, filter->read_ok);
134 __set_bit(READ_DEFECT_DATA, filter->read_ok);
135 __set_bit(READ_CAPACITY, filter->read_ok);
136 __set_bit(READ_LONG, filter->read_ok);
137 __set_bit(INQUIRY, filter->read_ok);
138 __set_bit(MODE_SENSE, filter->read_ok);
139 __set_bit(MODE_SENSE_10, filter->read_ok);
140 __set_bit(LOG_SENSE, filter->read_ok);
141 __set_bit(START_STOP, filter->read_ok);
142 __set_bit(GPCMD_VERIFY_10, filter->read_ok);
143 __set_bit(VERIFY_16, filter->read_ok);
144 __set_bit(REPORT_LUNS, filter->read_ok);
145 __set_bit(SERVICE_ACTION_IN_16, filter->read_ok);
146 __set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
147 __set_bit(MAINTENANCE_IN, filter->read_ok);
148 __set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);
149
150
151 __set_bit(GPCMD_PLAY_CD, filter->read_ok);
152 __set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
153 __set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
154 __set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
155 __set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);
156
157
158 __set_bit(GPCMD_READ_CD, filter->read_ok);
159 __set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
160 __set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
161 __set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
162 __set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
163 __set_bit(GPCMD_READ_HEADER, filter->read_ok);
164 __set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
165 __set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
166 __set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
167 __set_bit(GPCMD_REPORT_KEY, filter->read_ok);
168 __set_bit(GPCMD_SCAN, filter->read_ok);
169 __set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
170 __set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
171 __set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
172 __set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
173 __set_bit(GPCMD_SEEK, filter->read_ok);
174 __set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);
175
176
177 __set_bit(WRITE_6, filter->write_ok);
178 __set_bit(WRITE_10, filter->write_ok);
179 __set_bit(WRITE_VERIFY, filter->write_ok);
180 __set_bit(WRITE_12, filter->write_ok);
181 __set_bit(WRITE_VERIFY_12, filter->write_ok);
182 __set_bit(WRITE_16, filter->write_ok);
183 __set_bit(WRITE_LONG, filter->write_ok);
184 __set_bit(WRITE_LONG_2, filter->write_ok);
185 __set_bit(ERASE, filter->write_ok);
186 __set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
187 __set_bit(MODE_SELECT, filter->write_ok);
188 __set_bit(LOG_SELECT, filter->write_ok);
189 __set_bit(GPCMD_BLANK, filter->write_ok);
190 __set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
191 __set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
192 __set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
193 __set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
194 __set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
195 __set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
196 __set_bit(GPCMD_SEND_EVENT, filter->write_ok);
197 __set_bit(GPCMD_SEND_KEY, filter->write_ok);
198 __set_bit(GPCMD_SEND_OPC, filter->write_ok);
199 __set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
200 __set_bit(GPCMD_SET_SPEED, filter->write_ok);
201 __set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
202 __set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
203 __set_bit(GPCMD_SET_STREAMING, filter->write_ok);
204 __set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
205}
206
207int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm)
208{
209 struct blk_cmd_filter *filter = &blk_default_cmd_filter;
210
211
212 if (capable(CAP_SYS_RAWIO))
213 return 0;
214
215
216 if (test_bit(cmd[0], filter->read_ok))
217 return 0;
218
219
220 if (test_bit(cmd[0], filter->write_ok) && has_write_perm)
221 return 0;
222
223 return -EPERM;
224}
225EXPORT_SYMBOL(blk_verify_command);
226
227static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
228 struct sg_io_hdr *hdr, fmode_t mode)
229{
230 if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
231 return -EFAULT;
232 if (blk_verify_command(rq->cmd, mode & FMODE_WRITE))
233 return -EPERM;
234
235
236
237
238 rq->cmd_len = hdr->cmd_len;
239
240 rq->timeout = msecs_to_jiffies(hdr->timeout);
241 if (!rq->timeout)
242 rq->timeout = q->sg_timeout;
243 if (!rq->timeout)
244 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
245 if (rq->timeout < BLK_MIN_SG_TIMEOUT)
246 rq->timeout = BLK_MIN_SG_TIMEOUT;
247
248 return 0;
249}
250
251static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
252 struct bio *bio)
253{
254 int r, ret = 0;
255
256
257
258
259 hdr->status = rq->errors & 0xff;
260 hdr->masked_status = status_byte(rq->errors);
261 hdr->msg_status = msg_byte(rq->errors);
262 hdr->host_status = host_byte(rq->errors);
263 hdr->driver_status = driver_byte(rq->errors);
264 hdr->info = 0;
265 if (hdr->masked_status || hdr->host_status || hdr->driver_status)
266 hdr->info |= SG_INFO_CHECK;
267 hdr->resid = rq->resid_len;
268 hdr->sb_len_wr = 0;
269
270 if (rq->sense_len && hdr->sbp) {
271 int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);
272
273 if (!copy_to_user(hdr->sbp, rq->sense, len))
274 hdr->sb_len_wr = len;
275 else
276 ret = -EFAULT;
277 }
278
279 r = blk_rq_unmap_user(bio);
280 if (!ret)
281 ret = r;
282
283 return ret;
284}
285
286static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
287 struct sg_io_hdr *hdr, fmode_t mode)
288{
289 unsigned long start_time;
290 ssize_t ret = 0;
291 int writing = 0;
292 int at_head = 0;
293 struct request *rq;
294 char sense[SCSI_SENSE_BUFFERSIZE];
295 struct bio *bio;
296
297 if (hdr->interface_id != 'S')
298 return -EINVAL;
299
300 if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
301 return -EIO;
302
303 if (hdr->dxfer_len)
304 switch (hdr->dxfer_direction) {
305 default:
306 return -EINVAL;
307 case SG_DXFER_TO_DEV:
308 writing = 1;
309 break;
310 case SG_DXFER_TO_FROM_DEV:
311 case SG_DXFER_FROM_DEV:
312 break;
313 }
314 if (hdr->flags & SG_FLAG_Q_AT_HEAD)
315 at_head = 1;
316
317 ret = -ENOMEM;
318 rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
319 if (IS_ERR(rq))
320 return PTR_ERR(rq);
321 blk_rq_set_block_pc(rq);
322
323 if (hdr->cmd_len > BLK_MAX_CDB) {
324 rq->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
325 if (!rq->cmd)
326 goto out_put_request;
327 }
328
329 ret = blk_fill_sghdr_rq(q, rq, hdr, mode);
330 if (ret < 0)
331 goto out_free_cdb;
332
333 ret = 0;
334 if (hdr->iovec_count) {
335 struct iov_iter i;
336 struct iovec *iov = NULL;
337
338 ret = import_iovec(rq_data_dir(rq),
339 hdr->dxferp, hdr->iovec_count,
340 0, &iov, &i);
341 if (ret < 0)
342 goto out_free_cdb;
343
344
345 iov_iter_truncate(&i, hdr->dxfer_len);
346
347 ret = blk_rq_map_user_iov(q, rq, NULL, &i, GFP_KERNEL);
348 kfree(iov);
349 } else if (hdr->dxfer_len)
350 ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
351 GFP_KERNEL);
352
353 if (ret)
354 goto out_free_cdb;
355
356 bio = rq->bio;
357 memset(sense, 0, sizeof(sense));
358 rq->sense = sense;
359 rq->sense_len = 0;
360 rq->retries = 0;
361
362 start_time = jiffies;
363
364
365
366
367
368 blk_execute_rq(q, bd_disk, rq, at_head);
369
370 hdr->duration = jiffies_to_msecs(jiffies - start_time);
371
372 ret = blk_complete_sghdr_rq(rq, hdr, bio);
373
374out_free_cdb:
375 if (rq->cmd != rq->__cmd)
376 kfree(rq->cmd);
377out_put_request:
378 blk_put_request(rq);
379 return ret;
380}
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415#define OMAX_SB_LEN 16
416int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
417 struct scsi_ioctl_command __user *sic)
418{
419 struct request *rq;
420 int err;
421 unsigned int in_len, out_len, bytes, opcode, cmdlen;
422 char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
423
424 if (!sic)
425 return -EINVAL;
426
427
428
429
430 if (get_user(in_len, &sic->inlen))
431 return -EFAULT;
432 if (get_user(out_len, &sic->outlen))
433 return -EFAULT;
434 if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
435 return -EINVAL;
436 if (get_user(opcode, sic->data))
437 return -EFAULT;
438
439 bytes = max(in_len, out_len);
440 if (bytes) {
441 buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
442 if (!buffer)
443 return -ENOMEM;
444
445 }
446
447 rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_RECLAIM);
448 if (IS_ERR(rq)) {
449 err = PTR_ERR(rq);
450 goto error_free_buffer;
451 }
452 blk_rq_set_block_pc(rq);
453
454 cmdlen = COMMAND_SIZE(opcode);
455
456
457
458
459 err = -EFAULT;
460 rq->cmd_len = cmdlen;
461 if (copy_from_user(rq->cmd, sic->data, cmdlen))
462 goto error;
463
464 if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
465 goto error;
466
467 err = blk_verify_command(rq->cmd, mode & FMODE_WRITE);
468 if (err)
469 goto error;
470
471
472 rq->retries = 5;
473
474 switch (opcode) {
475 case SEND_DIAGNOSTIC:
476 case FORMAT_UNIT:
477 rq->timeout = FORMAT_UNIT_TIMEOUT;
478 rq->retries = 1;
479 break;
480 case START_STOP:
481 rq->timeout = START_STOP_TIMEOUT;
482 break;
483 case MOVE_MEDIUM:
484 rq->timeout = MOVE_MEDIUM_TIMEOUT;
485 break;
486 case READ_ELEMENT_STATUS:
487 rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
488 break;
489 case READ_DEFECT_DATA:
490 rq->timeout = READ_DEFECT_DATA_TIMEOUT;
491 rq->retries = 1;
492 break;
493 default:
494 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
495 break;
496 }
497
498 if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_RECLAIM)) {
499 err = DRIVER_ERROR << 24;
500 goto error;
501 }
502
503 memset(sense, 0, sizeof(sense));
504 rq->sense = sense;
505 rq->sense_len = 0;
506
507 blk_execute_rq(q, disk, rq, 0);
508
509 err = rq->errors & 0xff;
510 if (err) {
511 if (rq->sense_len && rq->sense) {
512 bytes = (OMAX_SB_LEN > rq->sense_len) ?
513 rq->sense_len : OMAX_SB_LEN;
514 if (copy_to_user(sic->data, rq->sense, bytes))
515 err = -EFAULT;
516 }
517 } else {
518 if (copy_to_user(sic->data, buffer, out_len))
519 err = -EFAULT;
520 }
521
522error:
523 blk_put_request(rq);
524
525error_free_buffer:
526 kfree(buffer);
527
528 return err;
529}
530EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
531
532
533static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
534 int cmd, int data)
535{
536 struct request *rq;
537 int err;
538
539 rq = blk_get_request(q, WRITE, __GFP_RECLAIM);
540 if (IS_ERR(rq))
541 return PTR_ERR(rq);
542 blk_rq_set_block_pc(rq);
543 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
544 rq->cmd[0] = cmd;
545 rq->cmd[4] = data;
546 rq->cmd_len = 6;
547 err = blk_execute_rq(q, bd_disk, rq, 0);
548 blk_put_request(rq);
549
550 return err;
551}
552
553static inline int blk_send_start_stop(struct request_queue *q,
554 struct gendisk *bd_disk, int data)
555{
556 return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
557}
558
559int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mode,
560 unsigned int cmd, void __user *arg)
561{
562 int err;
563
564 if (!q)
565 return -ENXIO;
566
567 switch (cmd) {
568
569
570
571 case SG_GET_VERSION_NUM:
572 err = sg_get_version(arg);
573 break;
574 case SCSI_IOCTL_GET_IDLUN:
575 err = scsi_get_idlun(q, arg);
576 break;
577 case SCSI_IOCTL_GET_BUS_NUMBER:
578 err = scsi_get_bus(q, arg);
579 break;
580 case SG_SET_TIMEOUT:
581 err = sg_set_timeout(q, arg);
582 break;
583 case SG_GET_TIMEOUT:
584 err = sg_get_timeout(q);
585 break;
586 case SG_GET_RESERVED_SIZE:
587 err = sg_get_reserved_size(q, arg);
588 break;
589 case SG_SET_RESERVED_SIZE:
590 err = sg_set_reserved_size(q, arg);
591 break;
592 case SG_EMULATED_HOST:
593 err = sg_emulated_host(q, arg);
594 break;
595 case SG_IO: {
596 struct sg_io_hdr hdr;
597
598 err = -EFAULT;
599 if (copy_from_user(&hdr, arg, sizeof(hdr)))
600 break;
601 err = sg_io(q, bd_disk, &hdr, mode);
602 if (err == -EFAULT)
603 break;
604
605 if (copy_to_user(arg, &hdr, sizeof(hdr)))
606 err = -EFAULT;
607 break;
608 }
609 case CDROM_SEND_PACKET: {
610 struct cdrom_generic_command cgc;
611 struct sg_io_hdr hdr;
612
613 err = -EFAULT;
614 if (copy_from_user(&cgc, arg, sizeof(cgc)))
615 break;
616 cgc.timeout = clock_t_to_jiffies(cgc.timeout);
617 memset(&hdr, 0, sizeof(hdr));
618 hdr.interface_id = 'S';
619 hdr.cmd_len = sizeof(cgc.cmd);
620 hdr.dxfer_len = cgc.buflen;
621 err = 0;
622 switch (cgc.data_direction) {
623 case CGC_DATA_UNKNOWN:
624 hdr.dxfer_direction = SG_DXFER_UNKNOWN;
625 break;
626 case CGC_DATA_WRITE:
627 hdr.dxfer_direction = SG_DXFER_TO_DEV;
628 break;
629 case CGC_DATA_READ:
630 hdr.dxfer_direction = SG_DXFER_FROM_DEV;
631 break;
632 case CGC_DATA_NONE:
633 hdr.dxfer_direction = SG_DXFER_NONE;
634 break;
635 default:
636 err = -EINVAL;
637 }
638 if (err)
639 break;
640
641 hdr.dxferp = cgc.buffer;
642 hdr.sbp = cgc.sense;
643 if (hdr.sbp)
644 hdr.mx_sb_len = sizeof(struct request_sense);
645 hdr.timeout = jiffies_to_msecs(cgc.timeout);
646 hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
647 hdr.cmd_len = sizeof(cgc.cmd);
648
649 err = sg_io(q, bd_disk, &hdr, mode);
650 if (err == -EFAULT)
651 break;
652
653 if (hdr.status)
654 err = -EIO;
655
656 cgc.stat = err;
657 cgc.buflen = hdr.resid;
658 if (copy_to_user(arg, &cgc, sizeof(cgc)))
659 err = -EFAULT;
660
661 break;
662 }
663
664
665
666
667 case SCSI_IOCTL_SEND_COMMAND:
668 printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
669 err = -EINVAL;
670 if (!arg)
671 break;
672
673 err = sg_scsi_ioctl(q, bd_disk, mode, arg);
674 break;
675 case CDROMCLOSETRAY:
676 err = blk_send_start_stop(q, bd_disk, 0x03);
677 break;
678 case CDROMEJECT:
679 err = blk_send_start_stop(q, bd_disk, 0x02);
680 break;
681 default:
682 err = -ENOTTY;
683 }
684
685 return err;
686}
687EXPORT_SYMBOL(scsi_cmd_ioctl);
688
689int scsi_verify_blk_ioctl(struct block_device *bd, unsigned int cmd)
690{
691 if (bd && bd == bd->bd_contains)
692 return 0;
693
694
695
696
697 switch (cmd) {
698 case SCSI_IOCTL_GET_IDLUN:
699 case SCSI_IOCTL_GET_BUS_NUMBER:
700 case SCSI_IOCTL_GET_PCI:
701 case SCSI_IOCTL_PROBE_HOST:
702 case SG_GET_VERSION_NUM:
703 case SG_SET_TIMEOUT:
704 case SG_GET_TIMEOUT:
705 case SG_GET_RESERVED_SIZE:
706 case SG_SET_RESERVED_SIZE:
707 case SG_EMULATED_HOST:
708 return 0;
709 case CDROM_GET_CAPABILITY:
710
711
712
713
714 return -ENOIOCTLCMD;
715 default:
716 break;
717 }
718
719 if (capable(CAP_SYS_RAWIO))
720 return 0;
721
722
723 printk_ratelimited(KERN_WARNING
724 "%s: sending ioctl %x to a partition!\n", current->comm, cmd);
725
726 return -ENOIOCTLCMD;
727}
728EXPORT_SYMBOL(scsi_verify_blk_ioctl);
729
730int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
731 unsigned int cmd, void __user *arg)
732{
733 int ret;
734
735 ret = scsi_verify_blk_ioctl(bd, cmd);
736 if (ret < 0)
737 return ret;
738
739 return scsi_cmd_ioctl(bd->bd_disk->queue, bd->bd_disk, mode, cmd, arg);
740}
741EXPORT_SYMBOL(scsi_cmd_blk_ioctl);
742
743static int __init blk_scsi_ioctl_init(void)
744{
745 blk_set_cmd_filter_defaults(&blk_default_cmd_filter);
746 return 0;
747}
748fs_initcall(blk_scsi_ioctl_init);
749