2 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public Licens
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
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 <linux/uaccess.h>
33 #include <linux/raid/md_u.h>
34 #include <linux/mtio.h>
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_ioctl.h>
38 #include <scsi/scsi_cmnd.h>
40 struct blk_cmd_filter
{
41 unsigned long read_ok
[BLK_SCSI_CMD_PER_LONG
];
42 unsigned long write_ok
[BLK_SCSI_CMD_PER_LONG
];
45 static struct blk_cmd_filter blk_default_cmd_filter
;
47 /* Command group 3 is reserved and should never be used. */
48 const unsigned char scsi_command_size_tbl
[8] =
53 EXPORT_SYMBOL(scsi_command_size_tbl
);
57 static int sg_get_version(int __user
*p
)
59 static const int sg_version_num
= 30527;
60 return put_user(sg_version_num
, p
);
63 static int scsi_get_idlun(struct request_queue
*q
, int __user
*p
)
65 return put_user(0, p
);
68 static int scsi_get_bus(struct request_queue
*q
, int __user
*p
)
70 return put_user(0, p
);
73 static int sg_get_timeout(struct request_queue
*q
)
75 return jiffies_to_clock_t(q
->sg_timeout
);
78 static int sg_set_timeout(struct request_queue
*q
, int __user
*p
)
80 int timeout
, err
= get_user(timeout
, p
);
83 q
->sg_timeout
= clock_t_to_jiffies(timeout
);
88 static int max_sectors_bytes(struct request_queue
*q
)
90 unsigned int max_sectors
= queue_max_sectors(q
);
92 max_sectors
= min_t(unsigned int, max_sectors
, INT_MAX
>> 9);
94 return max_sectors
<< 9;
97 static int sg_get_reserved_size(struct request_queue
*q
, int __user
*p
)
99 int val
= min_t(int, q
->sg_reserved_size
, max_sectors_bytes(q
));
101 return put_user(val
, p
);
104 static int sg_set_reserved_size(struct request_queue
*q
, int __user
*p
)
106 int size
, err
= get_user(size
, p
);
114 q
->sg_reserved_size
= min(size
, max_sectors_bytes(q
));
119 * will always return that we are ATAPI even for a real SCSI drive, I'm not
120 * so sure this is worth doing anything about (why would you care??)
122 static int sg_emulated_host(struct request_queue
*q
, int __user
*p
)
124 return put_user(1, p
);
127 static void blk_set_cmd_filter_defaults(struct blk_cmd_filter
*filter
)
129 /* Basic read-only commands */
130 __set_bit(TEST_UNIT_READY
, filter
->read_ok
);
131 __set_bit(REQUEST_SENSE
, filter
->read_ok
);
132 __set_bit(READ_6
, filter
->read_ok
);
133 __set_bit(READ_10
, filter
->read_ok
);
134 __set_bit(READ_12
, filter
->read_ok
);
135 __set_bit(READ_16
, filter
->read_ok
);
136 __set_bit(READ_BUFFER
, filter
->read_ok
);
137 __set_bit(READ_DEFECT_DATA
, filter
->read_ok
);
138 __set_bit(READ_CAPACITY
, filter
->read_ok
);
139 __set_bit(READ_LONG
, filter
->read_ok
);
140 __set_bit(INQUIRY
, filter
->read_ok
);
141 __set_bit(MODE_SENSE
, filter
->read_ok
);
142 __set_bit(MODE_SENSE_10
, filter
->read_ok
);
143 __set_bit(LOG_SENSE
, filter
->read_ok
);
144 __set_bit(START_STOP
, filter
->read_ok
);
145 __set_bit(GPCMD_VERIFY_10
, filter
->read_ok
);
146 __set_bit(VERIFY_16
, filter
->read_ok
);
147 __set_bit(REPORT_LUNS
, filter
->read_ok
);
148 __set_bit(SERVICE_ACTION_IN_16
, filter
->read_ok
);
149 __set_bit(RECEIVE_DIAGNOSTIC
, filter
->read_ok
);
150 __set_bit(MAINTENANCE_IN
, filter
->read_ok
);
151 __set_bit(GPCMD_READ_BUFFER_CAPACITY
, filter
->read_ok
);
153 /* Audio CD commands */
154 __set_bit(GPCMD_PLAY_CD
, filter
->read_ok
);
155 __set_bit(GPCMD_PLAY_AUDIO_10
, filter
->read_ok
);
156 __set_bit(GPCMD_PLAY_AUDIO_MSF
, filter
->read_ok
);
157 __set_bit(GPCMD_PLAY_AUDIO_TI
, filter
->read_ok
);
158 __set_bit(GPCMD_PAUSE_RESUME
, filter
->read_ok
);
160 /* CD/DVD data reading */
161 __set_bit(GPCMD_READ_CD
, filter
->read_ok
);
162 __set_bit(GPCMD_READ_CD_MSF
, filter
->read_ok
);
163 __set_bit(GPCMD_READ_DISC_INFO
, filter
->read_ok
);
164 __set_bit(GPCMD_READ_CDVD_CAPACITY
, filter
->read_ok
);
165 __set_bit(GPCMD_READ_DVD_STRUCTURE
, filter
->read_ok
);
166 __set_bit(GPCMD_READ_HEADER
, filter
->read_ok
);
167 __set_bit(GPCMD_READ_TRACK_RZONE_INFO
, filter
->read_ok
);
168 __set_bit(GPCMD_READ_SUBCHANNEL
, filter
->read_ok
);
169 __set_bit(GPCMD_READ_TOC_PMA_ATIP
, filter
->read_ok
);
170 __set_bit(GPCMD_REPORT_KEY
, filter
->read_ok
);
171 __set_bit(GPCMD_SCAN
, filter
->read_ok
);
172 __set_bit(GPCMD_GET_CONFIGURATION
, filter
->read_ok
);
173 __set_bit(GPCMD_READ_FORMAT_CAPACITIES
, filter
->read_ok
);
174 __set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION
, filter
->read_ok
);
175 __set_bit(GPCMD_GET_PERFORMANCE
, filter
->read_ok
);
176 __set_bit(GPCMD_SEEK
, filter
->read_ok
);
177 __set_bit(GPCMD_STOP_PLAY_SCAN
, filter
->read_ok
);
179 /* Basic writing commands */
180 __set_bit(WRITE_6
, filter
->write_ok
);
181 __set_bit(WRITE_10
, filter
->write_ok
);
182 __set_bit(WRITE_VERIFY
, filter
->write_ok
);
183 __set_bit(WRITE_12
, filter
->write_ok
);
184 __set_bit(WRITE_VERIFY_12
, filter
->write_ok
);
185 __set_bit(WRITE_16
, filter
->write_ok
);
186 __set_bit(WRITE_LONG
, filter
->write_ok
);
187 __set_bit(WRITE_LONG_2
, filter
->write_ok
);
188 __set_bit(WRITE_SAME
, filter
->write_ok
);
189 __set_bit(WRITE_SAME_16
, filter
->write_ok
);
190 __set_bit(WRITE_SAME_32
, filter
->write_ok
);
191 __set_bit(ERASE
, filter
->write_ok
);
192 __set_bit(GPCMD_MODE_SELECT_10
, filter
->write_ok
);
193 __set_bit(MODE_SELECT
, filter
->write_ok
);
194 __set_bit(LOG_SELECT
, filter
->write_ok
);
195 __set_bit(GPCMD_BLANK
, filter
->write_ok
);
196 __set_bit(GPCMD_CLOSE_TRACK
, filter
->write_ok
);
197 __set_bit(GPCMD_FLUSH_CACHE
, filter
->write_ok
);
198 __set_bit(GPCMD_FORMAT_UNIT
, filter
->write_ok
);
199 __set_bit(GPCMD_REPAIR_RZONE_TRACK
, filter
->write_ok
);
200 __set_bit(GPCMD_RESERVE_RZONE_TRACK
, filter
->write_ok
);
201 __set_bit(GPCMD_SEND_DVD_STRUCTURE
, filter
->write_ok
);
202 __set_bit(GPCMD_SEND_EVENT
, filter
->write_ok
);
203 __set_bit(GPCMD_SEND_KEY
, filter
->write_ok
);
204 __set_bit(GPCMD_SEND_OPC
, filter
->write_ok
);
205 __set_bit(GPCMD_SEND_CUE_SHEET
, filter
->write_ok
);
206 __set_bit(GPCMD_SET_SPEED
, filter
->write_ok
);
207 __set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
, filter
->write_ok
);
208 __set_bit(GPCMD_LOAD_UNLOAD
, filter
->write_ok
);
209 __set_bit(GPCMD_SET_STREAMING
, filter
->write_ok
);
210 __set_bit(GPCMD_SET_READ_AHEAD
, filter
->write_ok
);
213 int blk_verify_command(unsigned char *cmd
, fmode_t has_write_perm
)
215 struct blk_cmd_filter
*filter
= &blk_default_cmd_filter
;
217 /* root can do any command. */
218 if (capable(CAP_SYS_RAWIO
))
221 /* Anybody who can open the device can do a read-safe command */
222 if (test_bit(cmd
[0], filter
->read_ok
))
225 /* Write-safe commands require a writable open */
226 if (test_bit(cmd
[0], filter
->write_ok
) && has_write_perm
)
231 EXPORT_SYMBOL(blk_verify_command
);
233 static int blk_fill_sghdr_rq(struct request_queue
*q
, struct request
*rq
,
234 struct sg_io_hdr
*hdr
, fmode_t mode
)
236 struct scsi_request
*req
= scsi_req(rq
);
238 if (copy_from_user(req
->cmd
, hdr
->cmdp
, hdr
->cmd_len
))
240 if (blk_verify_command(req
->cmd
, mode
& FMODE_WRITE
))
244 * fill in request structure
246 req
->cmd_len
= hdr
->cmd_len
;
248 rq
->timeout
= msecs_to_jiffies(hdr
->timeout
);
250 rq
->timeout
= q
->sg_timeout
;
252 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
253 if (rq
->timeout
< BLK_MIN_SG_TIMEOUT
)
254 rq
->timeout
= BLK_MIN_SG_TIMEOUT
;
259 static int blk_complete_sghdr_rq(struct request
*rq
, struct sg_io_hdr
*hdr
,
262 struct scsi_request
*req
= scsi_req(rq
);
266 * fill in all the output members
268 hdr
->status
= req
->result
& 0xff;
269 hdr
->masked_status
= status_byte(req
->result
);
270 hdr
->msg_status
= msg_byte(req
->result
);
271 hdr
->host_status
= host_byte(req
->result
);
272 hdr
->driver_status
= driver_byte(req
->result
);
274 if (hdr
->masked_status
|| hdr
->host_status
|| hdr
->driver_status
)
275 hdr
->info
|= SG_INFO_CHECK
;
276 hdr
->resid
= req
->resid_len
;
279 if (req
->sense_len
&& hdr
->sbp
) {
280 int len
= min((unsigned int) hdr
->mx_sb_len
, req
->sense_len
);
282 if (!copy_to_user(hdr
->sbp
, req
->sense
, len
))
283 hdr
->sb_len_wr
= len
;
288 r
= blk_rq_unmap_user(bio
);
295 static int sg_io(struct request_queue
*q
, struct gendisk
*bd_disk
,
296 struct sg_io_hdr
*hdr
, fmode_t mode
)
298 unsigned long start_time
;
303 struct scsi_request
*req
;
306 if (hdr
->interface_id
!= 'S')
309 if (hdr
->dxfer_len
> (queue_max_hw_sectors(q
) << 9))
313 switch (hdr
->dxfer_direction
) {
316 case SG_DXFER_TO_DEV
:
319 case SG_DXFER_TO_FROM_DEV
:
320 case SG_DXFER_FROM_DEV
:
323 if (hdr
->flags
& SG_FLAG_Q_AT_HEAD
)
327 rq
= blk_get_request(q
, writing
? REQ_OP_SCSI_OUT
: REQ_OP_SCSI_IN
,
333 if (hdr
->cmd_len
> BLK_MAX_CDB
) {
334 req
->cmd
= kzalloc(hdr
->cmd_len
, GFP_KERNEL
);
336 goto out_put_request
;
339 ret
= blk_fill_sghdr_rq(q
, rq
, hdr
, mode
);
344 if (hdr
->iovec_count
) {
346 struct iovec
*iov
= NULL
;
348 ret
= import_iovec(rq_data_dir(rq
),
349 hdr
->dxferp
, hdr
->iovec_count
,
354 /* SG_IO howto says that the shorter of the two wins */
355 iov_iter_truncate(&i
, hdr
->dxfer_len
);
357 ret
= blk_rq_map_user_iov(q
, rq
, NULL
, &i
, GFP_KERNEL
);
359 } else if (hdr
->dxfer_len
)
360 ret
= blk_rq_map_user(q
, rq
, NULL
, hdr
->dxferp
, hdr
->dxfer_len
,
369 start_time
= jiffies
;
371 /* ignore return value. All information is passed back to caller
372 * (if he doesn't check that is his problem).
373 * N.B. a non-zero SCSI status is _not_ necessarily an error.
375 blk_execute_rq(q
, bd_disk
, rq
, at_head
);
377 hdr
->duration
= jiffies_to_msecs(jiffies
- start_time
);
379 ret
= blk_complete_sghdr_rq(rq
, hdr
, bio
);
382 scsi_req_free_cmd(req
);
389 * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
390 * @file: file this ioctl operates on (optional)
391 * @q: request queue to send scsi commands down
392 * @disk: gendisk to operate on (option)
393 * @sic: userspace structure describing the command to perform
395 * Send down the scsi command described by @sic to the device below
396 * the request queue @q. If @file is non-NULL it's used to perform
397 * fine-grained permission checks that allow users to send down
398 * non-destructive SCSI commands. If the caller has a struct gendisk
399 * available it should be passed in as @disk to allow the low level
400 * driver to use the information contained in it. A non-NULL @disk
401 * is only allowed if the caller knows that the low level driver doesn't
402 * need it (e.g. in the scsi subsystem).
405 * - This interface is deprecated - users should use the SG_IO
406 * interface instead, as this is a more flexible approach to
407 * performing SCSI commands on a device.
408 * - The SCSI command length is determined by examining the 1st byte
409 * of the given command. There is no way to override this.
410 * - Data transfers are limited to PAGE_SIZE
411 * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
412 * accommodate the sense buffer when an error occurs.
413 * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
414 * old code will not be surprised.
415 * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
416 * a negative return and the Unix error code in 'errno'.
417 * If the SCSI command succeeds then 0 is returned.
418 * Positive numbers returned are the compacted SCSI error codes (4
419 * bytes in one int) where the lowest byte is the SCSI status.
421 #define OMAX_SB_LEN 16 /* For backward compatibility */
422 int sg_scsi_ioctl(struct request_queue
*q
, struct gendisk
*disk
, fmode_t mode
,
423 struct scsi_ioctl_command __user
*sic
)
426 struct scsi_request
*req
;
428 unsigned int in_len
, out_len
, bytes
, opcode
, cmdlen
;
435 * get in an out lengths, verify they don't exceed a page worth of data
437 if (get_user(in_len
, &sic
->inlen
))
439 if (get_user(out_len
, &sic
->outlen
))
441 if (in_len
> PAGE_SIZE
|| out_len
> PAGE_SIZE
)
443 if (get_user(opcode
, sic
->data
))
446 bytes
= max(in_len
, out_len
);
448 buffer
= kzalloc(bytes
, q
->bounce_gfp
| GFP_USER
| __GFP_NOWARN
);
454 rq
= blk_get_request(q
, in_len
? REQ_OP_SCSI_OUT
: REQ_OP_SCSI_IN
,
458 goto error_free_buffer
;
462 cmdlen
= COMMAND_SIZE(opcode
);
465 * get command and data to send to device, if any
468 req
->cmd_len
= cmdlen
;
469 if (copy_from_user(req
->cmd
, sic
->data
, cmdlen
))
472 if (in_len
&& copy_from_user(buffer
, sic
->data
+ cmdlen
, in_len
))
475 err
= blk_verify_command(req
->cmd
, mode
& FMODE_WRITE
);
479 /* default. possible overriden later */
483 case SEND_DIAGNOSTIC
:
485 rq
->timeout
= FORMAT_UNIT_TIMEOUT
;
489 rq
->timeout
= START_STOP_TIMEOUT
;
492 rq
->timeout
= MOVE_MEDIUM_TIMEOUT
;
494 case READ_ELEMENT_STATUS
:
495 rq
->timeout
= READ_ELEMENT_STATUS_TIMEOUT
;
497 case READ_DEFECT_DATA
:
498 rq
->timeout
= READ_DEFECT_DATA_TIMEOUT
;
502 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
506 if (bytes
&& blk_rq_map_kern(q
, rq
, buffer
, bytes
, __GFP_RECLAIM
)) {
507 err
= DRIVER_ERROR
<< 24;
511 blk_execute_rq(q
, disk
, rq
, 0);
513 err
= req
->result
& 0xff; /* only 8 bit SCSI status */
515 if (req
->sense_len
&& req
->sense
) {
516 bytes
= (OMAX_SB_LEN
> req
->sense_len
) ?
517 req
->sense_len
: OMAX_SB_LEN
;
518 if (copy_to_user(sic
->data
, req
->sense
, bytes
))
522 if (copy_to_user(sic
->data
, buffer
, out_len
))
534 EXPORT_SYMBOL_GPL(sg_scsi_ioctl
);
536 /* Send basic block requests */
537 static int __blk_send_generic(struct request_queue
*q
, struct gendisk
*bd_disk
,
543 rq
= blk_get_request(q
, REQ_OP_SCSI_OUT
, __GFP_RECLAIM
);
546 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
547 scsi_req(rq
)->cmd
[0] = cmd
;
548 scsi_req(rq
)->cmd
[4] = data
;
549 scsi_req(rq
)->cmd_len
= 6;
550 blk_execute_rq(q
, bd_disk
, rq
, 0);
551 err
= scsi_req(rq
)->result
? -EIO
: 0;
557 static inline int blk_send_start_stop(struct request_queue
*q
,
558 struct gendisk
*bd_disk
, int data
)
560 return __blk_send_generic(q
, bd_disk
, GPCMD_START_STOP_UNIT
, data
);
563 int scsi_cmd_ioctl(struct request_queue
*q
, struct gendisk
*bd_disk
, fmode_t mode
,
564 unsigned int cmd
, void __user
*arg
)
575 case SG_GET_VERSION_NUM
:
576 err
= sg_get_version(arg
);
578 case SCSI_IOCTL_GET_IDLUN
:
579 err
= scsi_get_idlun(q
, arg
);
581 case SCSI_IOCTL_GET_BUS_NUMBER
:
582 err
= scsi_get_bus(q
, arg
);
585 err
= sg_set_timeout(q
, arg
);
588 err
= sg_get_timeout(q
);
590 case SG_GET_RESERVED_SIZE
:
591 err
= sg_get_reserved_size(q
, arg
);
593 case SG_SET_RESERVED_SIZE
:
594 err
= sg_set_reserved_size(q
, arg
);
596 case SG_EMULATED_HOST
:
597 err
= sg_emulated_host(q
, arg
);
600 struct sg_io_hdr hdr
;
603 if (copy_from_user(&hdr
, arg
, sizeof(hdr
)))
605 err
= sg_io(q
, bd_disk
, &hdr
, mode
);
609 if (copy_to_user(arg
, &hdr
, sizeof(hdr
)))
613 case CDROM_SEND_PACKET
: {
614 struct cdrom_generic_command cgc
;
615 struct sg_io_hdr hdr
;
618 if (copy_from_user(&cgc
, arg
, sizeof(cgc
)))
620 cgc
.timeout
= clock_t_to_jiffies(cgc
.timeout
);
621 memset(&hdr
, 0, sizeof(hdr
));
622 hdr
.interface_id
= 'S';
623 hdr
.cmd_len
= sizeof(cgc
.cmd
);
624 hdr
.dxfer_len
= cgc
.buflen
;
626 switch (cgc
.data_direction
) {
627 case CGC_DATA_UNKNOWN
:
628 hdr
.dxfer_direction
= SG_DXFER_UNKNOWN
;
631 hdr
.dxfer_direction
= SG_DXFER_TO_DEV
;
634 hdr
.dxfer_direction
= SG_DXFER_FROM_DEV
;
637 hdr
.dxfer_direction
= SG_DXFER_NONE
;
645 hdr
.dxferp
= cgc
.buffer
;
648 hdr
.mx_sb_len
= sizeof(struct request_sense
);
649 hdr
.timeout
= jiffies_to_msecs(cgc
.timeout
);
650 hdr
.cmdp
= ((struct cdrom_generic_command __user
*) arg
)->cmd
;
651 hdr
.cmd_len
= sizeof(cgc
.cmd
);
653 err
= sg_io(q
, bd_disk
, &hdr
, mode
);
661 cgc
.buflen
= hdr
.resid
;
662 if (copy_to_user(arg
, &cgc
, sizeof(cgc
)))
669 * old junk scsi send command ioctl
671 case SCSI_IOCTL_SEND_COMMAND
:
672 printk(KERN_WARNING
"program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current
->comm
);
677 err
= sg_scsi_ioctl(q
, bd_disk
, mode
, arg
);
680 err
= blk_send_start_stop(q
, bd_disk
, 0x03);
683 err
= blk_send_start_stop(q
, bd_disk
, 0x02);
691 EXPORT_SYMBOL(scsi_cmd_ioctl
);
693 int scsi_verify_blk_ioctl(struct block_device
*bd
, unsigned int cmd
)
695 if (bd
&& bd
== bd
->bd_contains
)
698 /* Actually none of these is particularly useful on a partition,
702 case SCSI_IOCTL_GET_IDLUN
:
703 case SCSI_IOCTL_GET_BUS_NUMBER
:
704 case SCSI_IOCTL_GET_PCI
:
705 case SCSI_IOCTL_PROBE_HOST
:
706 case SG_GET_VERSION_NUM
:
709 case SG_GET_RESERVED_SIZE
:
710 case SG_SET_RESERVED_SIZE
:
711 case SG_EMULATED_HOST
:
715 case CDROM_GET_CAPABILITY
:
716 case CDROM_DRIVE_STATUS
:
721 case 0x801c6d02: /* MTIOCGET32 */
723 /* Keep this until we remove the printk below. udev sends it
724 * and we do not want to spam dmesg about it. CD-ROMs do
725 * not have partitions, so we get here only for disks.
732 if (capable(CAP_SYS_RAWIO
))
735 /* In particular, rule out all resets and host-specific ioctls. */
736 printk_ratelimited(KERN_WARNING
737 "%s: sending ioctl %x to a partition!\n", current
->comm
, cmd
);
741 EXPORT_SYMBOL(scsi_verify_blk_ioctl
);
743 int scsi_cmd_blk_ioctl(struct block_device
*bd
, fmode_t mode
,
744 unsigned int cmd
, void __user
*arg
)
748 ret
= scsi_verify_blk_ioctl(bd
, cmd
);
752 return scsi_cmd_ioctl(bd
->bd_disk
->queue
, bd
->bd_disk
, mode
, cmd
, arg
);
754 EXPORT_SYMBOL(scsi_cmd_blk_ioctl
);
757 * scsi_req_init - initialize certain fields of a scsi_request structure
758 * @req: Pointer to a scsi_request structure.
759 * Initializes .__cmd[], .cmd, .cmd_len and .sense_len but no other members
760 * of struct scsi_request.
762 void scsi_req_init(struct scsi_request
*req
)
764 memset(req
->__cmd
, 0, sizeof(req
->__cmd
));
765 req
->cmd
= req
->__cmd
;
766 req
->cmd_len
= BLK_MAX_CDB
;
769 EXPORT_SYMBOL(scsi_req_init
);
771 static int __init
blk_scsi_ioctl_init(void)
773 blk_set_cmd_filter_defaults(&blk_default_cmd_filter
);
776 fs_initcall(blk_scsi_ioctl_init
);