1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
5 #include <linux/compat.h>
6 #include <linux/kernel.h>
7 #include <linux/errno.h>
8 #include <linux/string.h>
9 #include <linux/module.h>
10 #include <linux/blkdev.h>
11 #include <linux/capability.h>
12 #include <linux/completion.h>
13 #include <linux/cdrom.h>
14 #include <linux/ratelimit.h>
15 #include <linux/slab.h>
16 #include <linux/times.h>
17 #include <linux/uio.h>
18 #include <linux/uaccess.h>
20 #include <scsi/scsi.h>
21 #include <scsi/scsi_ioctl.h>
22 #include <scsi/scsi_cmnd.h>
25 struct blk_cmd_filter
{
26 unsigned long read_ok
[BLK_SCSI_CMD_PER_LONG
];
27 unsigned long write_ok
[BLK_SCSI_CMD_PER_LONG
];
30 static struct blk_cmd_filter blk_default_cmd_filter
;
32 /* Command group 3 is reserved and should never be used. */
33 const unsigned char scsi_command_size_tbl
[8] =
38 EXPORT_SYMBOL(scsi_command_size_tbl
);
40 static int sg_get_version(int __user
*p
)
42 static const int sg_version_num
= 30527;
43 return put_user(sg_version_num
, p
);
46 static int scsi_get_idlun(struct request_queue
*q
, int __user
*p
)
48 return put_user(0, p
);
51 static int scsi_get_bus(struct request_queue
*q
, int __user
*p
)
53 return put_user(0, p
);
56 static int sg_get_timeout(struct request_queue
*q
)
58 return jiffies_to_clock_t(q
->sg_timeout
);
61 static int sg_set_timeout(struct request_queue
*q
, int __user
*p
)
63 int timeout
, err
= get_user(timeout
, p
);
66 q
->sg_timeout
= clock_t_to_jiffies(timeout
);
71 static int max_sectors_bytes(struct request_queue
*q
)
73 unsigned int max_sectors
= queue_max_sectors(q
);
75 max_sectors
= min_t(unsigned int, max_sectors
, INT_MAX
>> 9);
77 return max_sectors
<< 9;
80 static int sg_get_reserved_size(struct request_queue
*q
, int __user
*p
)
82 int val
= min_t(int, q
->sg_reserved_size
, max_sectors_bytes(q
));
84 return put_user(val
, p
);
87 static int sg_set_reserved_size(struct request_queue
*q
, int __user
*p
)
89 int size
, err
= get_user(size
, p
);
97 q
->sg_reserved_size
= min(size
, max_sectors_bytes(q
));
102 * will always return that we are ATAPI even for a real SCSI drive, I'm not
103 * so sure this is worth doing anything about (why would you care??)
105 static int sg_emulated_host(struct request_queue
*q
, int __user
*p
)
107 return put_user(1, p
);
110 static void blk_set_cmd_filter_defaults(struct blk_cmd_filter
*filter
)
112 /* Basic read-only commands */
113 __set_bit(TEST_UNIT_READY
, filter
->read_ok
);
114 __set_bit(REQUEST_SENSE
, filter
->read_ok
);
115 __set_bit(READ_6
, filter
->read_ok
);
116 __set_bit(READ_10
, filter
->read_ok
);
117 __set_bit(READ_12
, filter
->read_ok
);
118 __set_bit(READ_16
, filter
->read_ok
);
119 __set_bit(READ_BUFFER
, filter
->read_ok
);
120 __set_bit(READ_DEFECT_DATA
, filter
->read_ok
);
121 __set_bit(READ_CAPACITY
, filter
->read_ok
);
122 __set_bit(READ_LONG
, filter
->read_ok
);
123 __set_bit(INQUIRY
, filter
->read_ok
);
124 __set_bit(MODE_SENSE
, filter
->read_ok
);
125 __set_bit(MODE_SENSE_10
, filter
->read_ok
);
126 __set_bit(LOG_SENSE
, filter
->read_ok
);
127 __set_bit(START_STOP
, filter
->read_ok
);
128 __set_bit(GPCMD_VERIFY_10
, filter
->read_ok
);
129 __set_bit(VERIFY_16
, filter
->read_ok
);
130 __set_bit(REPORT_LUNS
, filter
->read_ok
);
131 __set_bit(SERVICE_ACTION_IN_16
, filter
->read_ok
);
132 __set_bit(RECEIVE_DIAGNOSTIC
, filter
->read_ok
);
133 __set_bit(MAINTENANCE_IN
, filter
->read_ok
);
134 __set_bit(GPCMD_READ_BUFFER_CAPACITY
, filter
->read_ok
);
136 /* Audio CD commands */
137 __set_bit(GPCMD_PLAY_CD
, filter
->read_ok
);
138 __set_bit(GPCMD_PLAY_AUDIO_10
, filter
->read_ok
);
139 __set_bit(GPCMD_PLAY_AUDIO_MSF
, filter
->read_ok
);
140 __set_bit(GPCMD_PLAY_AUDIO_TI
, filter
->read_ok
);
141 __set_bit(GPCMD_PAUSE_RESUME
, filter
->read_ok
);
143 /* CD/DVD data reading */
144 __set_bit(GPCMD_READ_CD
, filter
->read_ok
);
145 __set_bit(GPCMD_READ_CD_MSF
, filter
->read_ok
);
146 __set_bit(GPCMD_READ_DISC_INFO
, filter
->read_ok
);
147 __set_bit(GPCMD_READ_CDVD_CAPACITY
, filter
->read_ok
);
148 __set_bit(GPCMD_READ_DVD_STRUCTURE
, filter
->read_ok
);
149 __set_bit(GPCMD_READ_HEADER
, filter
->read_ok
);
150 __set_bit(GPCMD_READ_TRACK_RZONE_INFO
, filter
->read_ok
);
151 __set_bit(GPCMD_READ_SUBCHANNEL
, filter
->read_ok
);
152 __set_bit(GPCMD_READ_TOC_PMA_ATIP
, filter
->read_ok
);
153 __set_bit(GPCMD_REPORT_KEY
, filter
->read_ok
);
154 __set_bit(GPCMD_SCAN
, filter
->read_ok
);
155 __set_bit(GPCMD_GET_CONFIGURATION
, filter
->read_ok
);
156 __set_bit(GPCMD_READ_FORMAT_CAPACITIES
, filter
->read_ok
);
157 __set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION
, filter
->read_ok
);
158 __set_bit(GPCMD_GET_PERFORMANCE
, filter
->read_ok
);
159 __set_bit(GPCMD_SEEK
, filter
->read_ok
);
160 __set_bit(GPCMD_STOP_PLAY_SCAN
, filter
->read_ok
);
162 /* Basic writing commands */
163 __set_bit(WRITE_6
, filter
->write_ok
);
164 __set_bit(WRITE_10
, filter
->write_ok
);
165 __set_bit(WRITE_VERIFY
, filter
->write_ok
);
166 __set_bit(WRITE_12
, filter
->write_ok
);
167 __set_bit(WRITE_VERIFY_12
, filter
->write_ok
);
168 __set_bit(WRITE_16
, filter
->write_ok
);
169 __set_bit(WRITE_LONG
, filter
->write_ok
);
170 __set_bit(WRITE_LONG_2
, filter
->write_ok
);
171 __set_bit(WRITE_SAME
, filter
->write_ok
);
172 __set_bit(WRITE_SAME_16
, filter
->write_ok
);
173 __set_bit(WRITE_SAME_32
, filter
->write_ok
);
174 __set_bit(ERASE
, filter
->write_ok
);
175 __set_bit(GPCMD_MODE_SELECT_10
, filter
->write_ok
);
176 __set_bit(MODE_SELECT
, filter
->write_ok
);
177 __set_bit(LOG_SELECT
, filter
->write_ok
);
178 __set_bit(GPCMD_BLANK
, filter
->write_ok
);
179 __set_bit(GPCMD_CLOSE_TRACK
, filter
->write_ok
);
180 __set_bit(GPCMD_FLUSH_CACHE
, filter
->write_ok
);
181 __set_bit(GPCMD_FORMAT_UNIT
, filter
->write_ok
);
182 __set_bit(GPCMD_REPAIR_RZONE_TRACK
, filter
->write_ok
);
183 __set_bit(GPCMD_RESERVE_RZONE_TRACK
, filter
->write_ok
);
184 __set_bit(GPCMD_SEND_DVD_STRUCTURE
, filter
->write_ok
);
185 __set_bit(GPCMD_SEND_EVENT
, filter
->write_ok
);
186 __set_bit(GPCMD_SEND_KEY
, filter
->write_ok
);
187 __set_bit(GPCMD_SEND_OPC
, filter
->write_ok
);
188 __set_bit(GPCMD_SEND_CUE_SHEET
, filter
->write_ok
);
189 __set_bit(GPCMD_SET_SPEED
, filter
->write_ok
);
190 __set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
, filter
->write_ok
);
191 __set_bit(GPCMD_LOAD_UNLOAD
, filter
->write_ok
);
192 __set_bit(GPCMD_SET_STREAMING
, filter
->write_ok
);
193 __set_bit(GPCMD_SET_READ_AHEAD
, filter
->write_ok
);
196 __set_bit(ZBC_OUT
, filter
->write_ok
);
197 __set_bit(ZBC_IN
, filter
->read_ok
);
200 int blk_verify_command(unsigned char *cmd
, fmode_t mode
)
202 struct blk_cmd_filter
*filter
= &blk_default_cmd_filter
;
204 /* root can do any command. */
205 if (capable(CAP_SYS_RAWIO
))
208 /* Anybody who can open the device can do a read-safe command */
209 if (test_bit(cmd
[0], filter
->read_ok
))
212 /* Write-safe commands require a writable open */
213 if (test_bit(cmd
[0], filter
->write_ok
) && (mode
& FMODE_WRITE
))
218 EXPORT_SYMBOL(blk_verify_command
);
220 static int blk_fill_sghdr_rq(struct request_queue
*q
, struct request
*rq
,
221 struct sg_io_hdr
*hdr
, fmode_t mode
)
223 struct scsi_request
*req
= scsi_req(rq
);
225 if (copy_from_user(req
->cmd
, hdr
->cmdp
, hdr
->cmd_len
))
227 if (blk_verify_command(req
->cmd
, mode
))
231 * fill in request structure
233 req
->cmd_len
= hdr
->cmd_len
;
235 rq
->timeout
= msecs_to_jiffies(hdr
->timeout
);
237 rq
->timeout
= q
->sg_timeout
;
239 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
240 if (rq
->timeout
< BLK_MIN_SG_TIMEOUT
)
241 rq
->timeout
= BLK_MIN_SG_TIMEOUT
;
246 static int blk_complete_sghdr_rq(struct request
*rq
, struct sg_io_hdr
*hdr
,
249 struct scsi_request
*req
= scsi_req(rq
);
253 * fill in all the output members
255 hdr
->status
= req
->result
& 0xff;
256 hdr
->masked_status
= status_byte(req
->result
);
257 hdr
->msg_status
= COMMAND_COMPLETE
;
258 hdr
->host_status
= host_byte(req
->result
);
259 hdr
->driver_status
= 0;
260 if (scsi_status_is_check_condition(hdr
->status
))
261 hdr
->driver_status
= DRIVER_SENSE
;
263 if (hdr
->masked_status
|| hdr
->host_status
|| hdr
->driver_status
)
264 hdr
->info
|= SG_INFO_CHECK
;
265 hdr
->resid
= req
->resid_len
;
268 if (req
->sense_len
&& hdr
->sbp
) {
269 int len
= min((unsigned int) hdr
->mx_sb_len
, req
->sense_len
);
271 if (!copy_to_user(hdr
->sbp
, req
->sense
, len
))
272 hdr
->sb_len_wr
= len
;
277 r
= blk_rq_unmap_user(bio
);
284 static int sg_io(struct request_queue
*q
, struct gendisk
*bd_disk
,
285 struct sg_io_hdr
*hdr
, fmode_t mode
)
287 unsigned long start_time
;
292 struct scsi_request
*req
;
295 if (hdr
->interface_id
!= 'S')
298 if (hdr
->dxfer_len
> (queue_max_hw_sectors(q
) << 9))
302 switch (hdr
->dxfer_direction
) {
305 case SG_DXFER_TO_DEV
:
308 case SG_DXFER_TO_FROM_DEV
:
309 case SG_DXFER_FROM_DEV
:
312 if (hdr
->flags
& SG_FLAG_Q_AT_HEAD
)
316 rq
= blk_get_request(q
, writing
? REQ_OP_DRV_OUT
: REQ_OP_DRV_IN
, 0);
321 if (hdr
->cmd_len
> BLK_MAX_CDB
) {
322 req
->cmd
= kzalloc(hdr
->cmd_len
, GFP_KERNEL
);
324 goto out_put_request
;
327 ret
= blk_fill_sghdr_rq(q
, rq
, hdr
, mode
);
332 if (hdr
->iovec_count
) {
334 struct iovec
*iov
= NULL
;
336 ret
= import_iovec(rq_data_dir(rq
), hdr
->dxferp
,
337 hdr
->iovec_count
, 0, &iov
, &i
);
341 /* SG_IO howto says that the shorter of the two wins */
342 iov_iter_truncate(&i
, hdr
->dxfer_len
);
344 ret
= blk_rq_map_user_iov(q
, rq
, NULL
, &i
, GFP_KERNEL
);
346 } else if (hdr
->dxfer_len
)
347 ret
= blk_rq_map_user(q
, rq
, NULL
, hdr
->dxferp
, hdr
->dxfer_len
,
356 start_time
= jiffies
;
358 blk_execute_rq(bd_disk
, rq
, at_head
);
360 hdr
->duration
= jiffies_to_msecs(jiffies
- start_time
);
362 ret
= blk_complete_sghdr_rq(rq
, hdr
, bio
);
365 scsi_req_free_cmd(req
);
372 * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
373 * @q: request queue to send scsi commands down
374 * @disk: gendisk to operate on (option)
375 * @mode: mode used to open the file through which the ioctl has been
377 * @sic: userspace structure describing the command to perform
379 * Send down the scsi command described by @sic to the device below
380 * the request queue @q. If @file is non-NULL it's used to perform
381 * fine-grained permission checks that allow users to send down
382 * non-destructive SCSI commands. If the caller has a struct gendisk
383 * available it should be passed in as @disk to allow the low level
384 * driver to use the information contained in it. A non-NULL @disk
385 * is only allowed if the caller knows that the low level driver doesn't
386 * need it (e.g. in the scsi subsystem).
389 * - This interface is deprecated - users should use the SG_IO
390 * interface instead, as this is a more flexible approach to
391 * performing SCSI commands on a device.
392 * - The SCSI command length is determined by examining the 1st byte
393 * of the given command. There is no way to override this.
394 * - Data transfers are limited to PAGE_SIZE
395 * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
396 * accommodate the sense buffer when an error occurs.
397 * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
398 * old code will not be surprised.
399 * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
400 * a negative return and the Unix error code in 'errno'.
401 * If the SCSI command succeeds then 0 is returned.
402 * Positive numbers returned are the compacted SCSI error codes (4
403 * bytes in one int) where the lowest byte is the SCSI status.
405 int sg_scsi_ioctl(struct request_queue
*q
, struct gendisk
*disk
, fmode_t mode
,
406 struct scsi_ioctl_command __user
*sic
)
408 enum { OMAX_SB_LEN
= 16 }; /* For backward compatibility */
410 struct scsi_request
*req
;
412 unsigned int in_len
, out_len
, bytes
, opcode
, cmdlen
;
419 * get in an out lengths, verify they don't exceed a page worth of data
421 if (get_user(in_len
, &sic
->inlen
))
423 if (get_user(out_len
, &sic
->outlen
))
425 if (in_len
> PAGE_SIZE
|| out_len
> PAGE_SIZE
)
427 if (get_user(opcode
, sic
->data
))
430 bytes
= max(in_len
, out_len
);
432 buffer
= kzalloc(bytes
, GFP_NOIO
| GFP_USER
| __GFP_NOWARN
);
438 rq
= blk_get_request(q
, in_len
? REQ_OP_DRV_OUT
: REQ_OP_DRV_IN
, 0);
441 goto error_free_buffer
;
445 cmdlen
= COMMAND_SIZE(opcode
);
448 * get command and data to send to device, if any
451 req
->cmd_len
= cmdlen
;
452 if (copy_from_user(req
->cmd
, sic
->data
, cmdlen
))
455 if (in_len
&& copy_from_user(buffer
, sic
->data
+ cmdlen
, in_len
))
458 err
= blk_verify_command(req
->cmd
, mode
);
462 /* default. possible overriden later */
466 case SEND_DIAGNOSTIC
:
468 rq
->timeout
= FORMAT_UNIT_TIMEOUT
;
472 rq
->timeout
= START_STOP_TIMEOUT
;
475 rq
->timeout
= MOVE_MEDIUM_TIMEOUT
;
477 case READ_ELEMENT_STATUS
:
478 rq
->timeout
= READ_ELEMENT_STATUS_TIMEOUT
;
480 case READ_DEFECT_DATA
:
481 rq
->timeout
= READ_DEFECT_DATA_TIMEOUT
;
485 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
490 err
= blk_rq_map_kern(q
, rq
, buffer
, bytes
, GFP_NOIO
);
495 blk_execute_rq(disk
, rq
, 0);
497 err
= req
->result
& 0xff; /* only 8 bit SCSI status */
499 if (req
->sense_len
&& req
->sense
) {
500 bytes
= (OMAX_SB_LEN
> req
->sense_len
) ?
501 req
->sense_len
: OMAX_SB_LEN
;
502 if (copy_to_user(sic
->data
, req
->sense
, bytes
))
506 if (copy_to_user(sic
->data
, buffer
, out_len
))
518 EXPORT_SYMBOL_GPL(sg_scsi_ioctl
);
520 /* Send basic block requests */
521 static int __blk_send_generic(struct request_queue
*q
, struct gendisk
*bd_disk
,
527 rq
= blk_get_request(q
, REQ_OP_DRV_OUT
, 0);
530 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
531 scsi_req(rq
)->cmd
[0] = cmd
;
532 scsi_req(rq
)->cmd
[4] = data
;
533 scsi_req(rq
)->cmd_len
= 6;
534 blk_execute_rq(bd_disk
, rq
, 0);
535 err
= scsi_req(rq
)->result
? -EIO
: 0;
541 static inline int blk_send_start_stop(struct request_queue
*q
,
542 struct gendisk
*bd_disk
, int data
)
544 return __blk_send_generic(q
, bd_disk
, GPCMD_START_STOP_UNIT
, data
);
547 int put_sg_io_hdr(const struct sg_io_hdr
*hdr
, void __user
*argp
)
550 if (in_compat_syscall()) {
551 struct compat_sg_io_hdr hdr32
= {
552 .interface_id
= hdr
->interface_id
,
553 .dxfer_direction
= hdr
->dxfer_direction
,
554 .cmd_len
= hdr
->cmd_len
,
555 .mx_sb_len
= hdr
->mx_sb_len
,
556 .iovec_count
= hdr
->iovec_count
,
557 .dxfer_len
= hdr
->dxfer_len
,
558 .dxferp
= (uintptr_t)hdr
->dxferp
,
559 .cmdp
= (uintptr_t)hdr
->cmdp
,
560 .sbp
= (uintptr_t)hdr
->sbp
,
561 .timeout
= hdr
->timeout
,
563 .pack_id
= hdr
->pack_id
,
564 .usr_ptr
= (uintptr_t)hdr
->usr_ptr
,
565 .status
= hdr
->status
,
566 .masked_status
= hdr
->masked_status
,
567 .msg_status
= hdr
->msg_status
,
568 .sb_len_wr
= hdr
->sb_len_wr
,
569 .host_status
= hdr
->host_status
,
570 .driver_status
= hdr
->driver_status
,
572 .duration
= hdr
->duration
,
576 if (copy_to_user(argp
, &hdr32
, sizeof(hdr32
)))
583 if (copy_to_user(argp
, hdr
, sizeof(*hdr
)))
588 EXPORT_SYMBOL(put_sg_io_hdr
);
590 int get_sg_io_hdr(struct sg_io_hdr
*hdr
, const void __user
*argp
)
593 struct compat_sg_io_hdr hdr32
;
595 if (in_compat_syscall()) {
596 if (copy_from_user(&hdr32
, argp
, sizeof(hdr32
)))
599 *hdr
= (struct sg_io_hdr
) {
600 .interface_id
= hdr32
.interface_id
,
601 .dxfer_direction
= hdr32
.dxfer_direction
,
602 .cmd_len
= hdr32
.cmd_len
,
603 .mx_sb_len
= hdr32
.mx_sb_len
,
604 .iovec_count
= hdr32
.iovec_count
,
605 .dxfer_len
= hdr32
.dxfer_len
,
606 .dxferp
= compat_ptr(hdr32
.dxferp
),
607 .cmdp
= compat_ptr(hdr32
.cmdp
),
608 .sbp
= compat_ptr(hdr32
.sbp
),
609 .timeout
= hdr32
.timeout
,
610 .flags
= hdr32
.flags
,
611 .pack_id
= hdr32
.pack_id
,
612 .usr_ptr
= compat_ptr(hdr32
.usr_ptr
),
613 .status
= hdr32
.status
,
614 .masked_status
= hdr32
.masked_status
,
615 .msg_status
= hdr32
.msg_status
,
616 .sb_len_wr
= hdr32
.sb_len_wr
,
617 .host_status
= hdr32
.host_status
,
618 .driver_status
= hdr32
.driver_status
,
619 .resid
= hdr32
.resid
,
620 .duration
= hdr32
.duration
,
628 if (copy_from_user(hdr
, argp
, sizeof(*hdr
)))
633 EXPORT_SYMBOL(get_sg_io_hdr
);
636 struct compat_cdrom_generic_command
{
637 unsigned char cmd
[CDROM_PACKET_SIZE
];
638 compat_caddr_t buffer
;
639 compat_uint_t buflen
;
641 compat_caddr_t sense
;
642 unsigned char data_direction
;
643 unsigned char pad
[3];
645 compat_int_t timeout
;
646 compat_caddr_t unused
;
650 static int scsi_get_cdrom_generic_arg(struct cdrom_generic_command
*cgc
,
651 const void __user
*arg
)
654 if (in_compat_syscall()) {
655 struct compat_cdrom_generic_command cgc32
;
657 if (copy_from_user(&cgc32
, arg
, sizeof(cgc32
)))
660 *cgc
= (struct cdrom_generic_command
) {
661 .buffer
= compat_ptr(cgc32
.buffer
),
662 .buflen
= cgc32
.buflen
,
664 .sense
= compat_ptr(cgc32
.sense
),
665 .data_direction
= cgc32
.data_direction
,
666 .quiet
= cgc32
.quiet
,
667 .timeout
= cgc32
.timeout
,
668 .unused
= compat_ptr(cgc32
.unused
),
670 memcpy(&cgc
->cmd
, &cgc32
.cmd
, CDROM_PACKET_SIZE
);
674 if (copy_from_user(cgc
, arg
, sizeof(*cgc
)))
680 static int scsi_put_cdrom_generic_arg(const struct cdrom_generic_command
*cgc
,
684 if (in_compat_syscall()) {
685 struct compat_cdrom_generic_command cgc32
= {
686 .buffer
= (uintptr_t)(cgc
->buffer
),
687 .buflen
= cgc
->buflen
,
689 .sense
= (uintptr_t)(cgc
->sense
),
690 .data_direction
= cgc
->data_direction
,
692 .timeout
= cgc
->timeout
,
693 .unused
= (uintptr_t)(cgc
->unused
),
695 memcpy(&cgc32
.cmd
, &cgc
->cmd
, CDROM_PACKET_SIZE
);
697 if (copy_to_user(arg
, &cgc32
, sizeof(cgc32
)))
703 if (copy_to_user(arg
, cgc
, sizeof(*cgc
)))
709 static int scsi_cdrom_send_packet(struct request_queue
*q
,
710 struct gendisk
*bd_disk
,
711 fmode_t mode
, void __user
*arg
)
713 struct cdrom_generic_command cgc
;
714 struct sg_io_hdr hdr
;
717 err
= scsi_get_cdrom_generic_arg(&cgc
, arg
);
721 cgc
.timeout
= clock_t_to_jiffies(cgc
.timeout
);
722 memset(&hdr
, 0, sizeof(hdr
));
723 hdr
.interface_id
= 'S';
724 hdr
.cmd_len
= sizeof(cgc
.cmd
);
725 hdr
.dxfer_len
= cgc
.buflen
;
726 switch (cgc
.data_direction
) {
727 case CGC_DATA_UNKNOWN
:
728 hdr
.dxfer_direction
= SG_DXFER_UNKNOWN
;
731 hdr
.dxfer_direction
= SG_DXFER_TO_DEV
;
734 hdr
.dxfer_direction
= SG_DXFER_FROM_DEV
;
737 hdr
.dxfer_direction
= SG_DXFER_NONE
;
743 hdr
.dxferp
= cgc
.buffer
;
746 hdr
.mx_sb_len
= sizeof(struct request_sense
);
747 hdr
.timeout
= jiffies_to_msecs(cgc
.timeout
);
748 hdr
.cmdp
= ((struct cdrom_generic_command __user
*) arg
)->cmd
;
749 hdr
.cmd_len
= sizeof(cgc
.cmd
);
751 err
= sg_io(q
, bd_disk
, &hdr
, mode
);
759 cgc
.buflen
= hdr
.resid
;
760 if (scsi_put_cdrom_generic_arg(&cgc
, arg
))
766 int scsi_cmd_ioctl(struct request_queue
*q
, struct gendisk
*bd_disk
, fmode_t mode
,
767 unsigned int cmd
, void __user
*arg
)
778 case SG_GET_VERSION_NUM
:
779 err
= sg_get_version(arg
);
781 case SCSI_IOCTL_GET_IDLUN
:
782 err
= scsi_get_idlun(q
, arg
);
784 case SCSI_IOCTL_GET_BUS_NUMBER
:
785 err
= scsi_get_bus(q
, arg
);
788 err
= sg_set_timeout(q
, arg
);
791 err
= sg_get_timeout(q
);
793 case SG_GET_RESERVED_SIZE
:
794 err
= sg_get_reserved_size(q
, arg
);
796 case SG_SET_RESERVED_SIZE
:
797 err
= sg_set_reserved_size(q
, arg
);
799 case SG_EMULATED_HOST
:
800 err
= sg_emulated_host(q
, arg
);
803 struct sg_io_hdr hdr
;
805 err
= get_sg_io_hdr(&hdr
, arg
);
808 err
= sg_io(q
, bd_disk
, &hdr
, mode
);
812 if (put_sg_io_hdr(&hdr
, arg
))
816 case CDROM_SEND_PACKET
:
817 err
= scsi_cdrom_send_packet(q
, bd_disk
, mode
, arg
);
821 * old junk scsi send command ioctl
823 case SCSI_IOCTL_SEND_COMMAND
:
824 printk(KERN_WARNING
"program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current
->comm
);
829 err
= sg_scsi_ioctl(q
, bd_disk
, mode
, arg
);
832 err
= blk_send_start_stop(q
, bd_disk
, 0x03);
835 err
= blk_send_start_stop(q
, bd_disk
, 0x02);
843 EXPORT_SYMBOL(scsi_cmd_ioctl
);
845 int scsi_verify_blk_ioctl(struct block_device
*bd
, unsigned int cmd
)
847 if (bd
&& !bdev_is_partition(bd
))
850 if (capable(CAP_SYS_RAWIO
))
855 EXPORT_SYMBOL(scsi_verify_blk_ioctl
);
857 int scsi_cmd_blk_ioctl(struct block_device
*bd
, fmode_t mode
,
858 unsigned int cmd
, void __user
*arg
)
862 ret
= scsi_verify_blk_ioctl(bd
, cmd
);
866 return scsi_cmd_ioctl(bd
->bd_disk
->queue
, bd
->bd_disk
, mode
, cmd
, arg
);
868 EXPORT_SYMBOL(scsi_cmd_blk_ioctl
);
871 * scsi_req_init - initialize certain fields of a scsi_request structure
872 * @req: Pointer to a scsi_request structure.
873 * Initializes .__cmd[], .cmd, .cmd_len and .sense_len but no other members
874 * of struct scsi_request.
876 void scsi_req_init(struct scsi_request
*req
)
878 memset(req
->__cmd
, 0, sizeof(req
->__cmd
));
879 req
->cmd
= req
->__cmd
;
880 req
->cmd_len
= BLK_MAX_CDB
;
883 EXPORT_SYMBOL(scsi_req_init
);
885 static int __init
blk_scsi_ioctl_init(void)
887 blk_set_cmd_filter_defaults(&blk_default_cmd_filter
);
890 fs_initcall(blk_scsi_ioctl_init
);