Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
4 : : */
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>
19 : :
20 : : #include <scsi/scsi.h>
21 : : #include <scsi/scsi_ioctl.h>
22 : : #include <scsi/scsi_cmnd.h>
23 : : #include <scsi/sg.h>
24 : :
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];
28 : : };
29 : :
30 : : static struct blk_cmd_filter blk_default_cmd_filter;
31 : :
32 : : /* Command group 3 is reserved and should never be used. */
33 : : const unsigned char scsi_command_size_tbl[8] =
34 : : {
35 : : 6, 10, 10, 12,
36 : : 16, 12, 10, 10
37 : : };
38 : : EXPORT_SYMBOL(scsi_command_size_tbl);
39 : :
40 : : #include <scsi/sg.h>
41 : :
42 : 0 : static int sg_get_version(int __user *p)
43 : : {
44 : 0 : static const int sg_version_num = 30527;
45 : 0 : return put_user(sg_version_num, p);
46 : : }
47 : :
48 : 0 : static int scsi_get_idlun(struct request_queue *q, int __user *p)
49 : : {
50 : 0 : return put_user(0, p);
51 : : }
52 : :
53 : 0 : static int scsi_get_bus(struct request_queue *q, int __user *p)
54 : : {
55 : 0 : return put_user(0, p);
56 : : }
57 : :
58 : 0 : static int sg_get_timeout(struct request_queue *q)
59 : : {
60 : 0 : return jiffies_to_clock_t(q->sg_timeout);
61 : : }
62 : :
63 : 0 : static int sg_set_timeout(struct request_queue *q, int __user *p)
64 : : {
65 : 0 : int timeout, err = get_user(timeout, p);
66 : :
67 [ # # ]: 0 : if (!err)
68 : 0 : q->sg_timeout = clock_t_to_jiffies(timeout);
69 : :
70 : : return err;
71 : : }
72 : :
73 : 0 : static int max_sectors_bytes(struct request_queue *q)
74 : : {
75 : 0 : unsigned int max_sectors = queue_max_sectors(q);
76 : :
77 : 0 : max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);
78 : :
79 : 0 : return max_sectors << 9;
80 : : }
81 : :
82 : 0 : static int sg_get_reserved_size(struct request_queue *q, int __user *p)
83 : : {
84 : 0 : int val = min_t(int, q->sg_reserved_size, max_sectors_bytes(q));
85 : :
86 : 0 : return put_user(val, p);
87 : : }
88 : :
89 : 0 : static int sg_set_reserved_size(struct request_queue *q, int __user *p)
90 : : {
91 : 0 : int size, err = get_user(size, p);
92 : :
93 [ # # ]: 0 : if (err)
94 : : return err;
95 : :
96 [ # # ]: 0 : if (size < 0)
97 : : return -EINVAL;
98 : :
99 : 0 : q->sg_reserved_size = min(size, max_sectors_bytes(q));
100 : 0 : return 0;
101 : : }
102 : :
103 : : /*
104 : : * will always return that we are ATAPI even for a real SCSI drive, I'm not
105 : : * so sure this is worth doing anything about (why would you care??)
106 : : */
107 : 0 : static int sg_emulated_host(struct request_queue *q, int __user *p)
108 : : {
109 : 0 : return put_user(1, p);
110 : : }
111 : :
112 : 3 : static void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
113 : : {
114 : : /* Basic read-only commands */
115 : 3 : __set_bit(TEST_UNIT_READY, filter->read_ok);
116 : 3 : __set_bit(REQUEST_SENSE, filter->read_ok);
117 : 3 : __set_bit(READ_6, filter->read_ok);
118 : 3 : __set_bit(READ_10, filter->read_ok);
119 : 3 : __set_bit(READ_12, filter->read_ok);
120 : 3 : __set_bit(READ_16, filter->read_ok);
121 : 3 : __set_bit(READ_BUFFER, filter->read_ok);
122 : 3 : __set_bit(READ_DEFECT_DATA, filter->read_ok);
123 : 3 : __set_bit(READ_CAPACITY, filter->read_ok);
124 : 3 : __set_bit(READ_LONG, filter->read_ok);
125 : 3 : __set_bit(INQUIRY, filter->read_ok);
126 : 3 : __set_bit(MODE_SENSE, filter->read_ok);
127 : 3 : __set_bit(MODE_SENSE_10, filter->read_ok);
128 : 3 : __set_bit(LOG_SENSE, filter->read_ok);
129 : 3 : __set_bit(START_STOP, filter->read_ok);
130 : 3 : __set_bit(GPCMD_VERIFY_10, filter->read_ok);
131 : 3 : __set_bit(VERIFY_16, filter->read_ok);
132 : 3 : __set_bit(REPORT_LUNS, filter->read_ok);
133 : 3 : __set_bit(SERVICE_ACTION_IN_16, filter->read_ok);
134 : 3 : __set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
135 : 3 : __set_bit(MAINTENANCE_IN, filter->read_ok);
136 : 3 : __set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);
137 : :
138 : : /* Audio CD commands */
139 : 3 : __set_bit(GPCMD_PLAY_CD, filter->read_ok);
140 : 3 : __set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
141 : 3 : __set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
142 : 3 : __set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
143 : 3 : __set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);
144 : :
145 : : /* CD/DVD data reading */
146 : 3 : __set_bit(GPCMD_READ_CD, filter->read_ok);
147 : 3 : __set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
148 : 3 : __set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
149 : 3 : __set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
150 : 3 : __set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
151 : 3 : __set_bit(GPCMD_READ_HEADER, filter->read_ok);
152 : 3 : __set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
153 : 3 : __set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
154 : 3 : __set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
155 : 3 : __set_bit(GPCMD_REPORT_KEY, filter->read_ok);
156 : 3 : __set_bit(GPCMD_SCAN, filter->read_ok);
157 : 3 : __set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
158 : 3 : __set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
159 : 3 : __set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
160 : 3 : __set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
161 : 3 : __set_bit(GPCMD_SEEK, filter->read_ok);
162 : 3 : __set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);
163 : :
164 : : /* Basic writing commands */
165 : 3 : __set_bit(WRITE_6, filter->write_ok);
166 : 3 : __set_bit(WRITE_10, filter->write_ok);
167 : 3 : __set_bit(WRITE_VERIFY, filter->write_ok);
168 : 3 : __set_bit(WRITE_12, filter->write_ok);
169 : 3 : __set_bit(WRITE_VERIFY_12, filter->write_ok);
170 : 3 : __set_bit(WRITE_16, filter->write_ok);
171 : 3 : __set_bit(WRITE_LONG, filter->write_ok);
172 : 3 : __set_bit(WRITE_LONG_2, filter->write_ok);
173 : 3 : __set_bit(WRITE_SAME, filter->write_ok);
174 : 3 : __set_bit(WRITE_SAME_16, filter->write_ok);
175 : 3 : __set_bit(WRITE_SAME_32, filter->write_ok);
176 : 3 : __set_bit(ERASE, filter->write_ok);
177 : 3 : __set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
178 : 3 : __set_bit(MODE_SELECT, filter->write_ok);
179 : 3 : __set_bit(LOG_SELECT, filter->write_ok);
180 : 3 : __set_bit(GPCMD_BLANK, filter->write_ok);
181 : 3 : __set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
182 : 3 : __set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
183 : 3 : __set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
184 : 3 : __set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
185 : 3 : __set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
186 : 3 : __set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
187 : 3 : __set_bit(GPCMD_SEND_EVENT, filter->write_ok);
188 : 3 : __set_bit(GPCMD_SEND_KEY, filter->write_ok);
189 : 3 : __set_bit(GPCMD_SEND_OPC, filter->write_ok);
190 : 3 : __set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
191 : 3 : __set_bit(GPCMD_SET_SPEED, filter->write_ok);
192 : 3 : __set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
193 : 3 : __set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
194 : 3 : __set_bit(GPCMD_SET_STREAMING, filter->write_ok);
195 : 3 : __set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
196 : 3 : }
197 : :
198 : 27 : int blk_verify_command(unsigned char *cmd, fmode_t mode)
199 : : {
200 : 27 : struct blk_cmd_filter *filter = &blk_default_cmd_filter;
201 : :
202 : : /* root can do any command. */
203 [ - + ]: 27 : if (capable(CAP_SYS_RAWIO))
204 : : return 0;
205 : :
206 : : /* Anybody who can open the device can do a read-safe command */
207 [ # # ]: 0 : if (test_bit(cmd[0], filter->read_ok))
208 : : return 0;
209 : :
210 : : /* Write-safe commands require a writable open */
211 [ # # # # ]: 0 : if (test_bit(cmd[0], filter->write_ok) && (mode & FMODE_WRITE))
212 : 0 : return 0;
213 : :
214 : : return -EPERM;
215 : : }
216 : : EXPORT_SYMBOL(blk_verify_command);
217 : :
218 : : static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
219 : : struct sg_io_hdr *hdr, fmode_t mode)
220 : : {
221 : : struct scsi_request *req = scsi_req(rq);
222 : :
223 : : if (copy_from_user(req->cmd, hdr->cmdp, hdr->cmd_len))
224 : : return -EFAULT;
225 : : if (blk_verify_command(req->cmd, mode))
226 : : return -EPERM;
227 : :
228 : : /*
229 : : * fill in request structure
230 : : */
231 : : req->cmd_len = hdr->cmd_len;
232 : :
233 : : rq->timeout = msecs_to_jiffies(hdr->timeout);
234 : : if (!rq->timeout)
235 : : rq->timeout = q->sg_timeout;
236 : : if (!rq->timeout)
237 : : rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
238 : : if (rq->timeout < BLK_MIN_SG_TIMEOUT)
239 : : rq->timeout = BLK_MIN_SG_TIMEOUT;
240 : :
241 : : return 0;
242 : : }
243 : :
244 : 27 : static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
245 : : struct bio *bio)
246 : : {
247 [ + + ]: 27 : struct scsi_request *req = scsi_req(rq);
248 : 27 : int r, ret = 0;
249 : :
250 : : /*
251 : : * fill in all the output members
252 : : */
253 : 27 : hdr->status = req->result & 0xff;
254 : 27 : hdr->masked_status = status_byte(req->result);
255 : 27 : hdr->msg_status = msg_byte(req->result);
256 : 27 : hdr->host_status = host_byte(req->result);
257 : 27 : hdr->driver_status = driver_byte(req->result);
258 : 27 : hdr->info = 0;
259 [ + + - + ]: 27 : if (hdr->masked_status || hdr->host_status || hdr->driver_status)
260 : 9 : hdr->info |= SG_INFO_CHECK;
261 : 27 : hdr->resid = req->resid_len;
262 : 27 : hdr->sb_len_wr = 0;
263 : :
264 [ + + + - ]: 27 : if (req->sense_len && hdr->sbp) {
265 : 9 : int len = min((unsigned int) hdr->mx_sb_len, req->sense_len);
266 : :
267 [ - + + - ]: 18 : if (!copy_to_user(hdr->sbp, req->sense, len))
268 : 9 : hdr->sb_len_wr = len;
269 : : else
270 : : ret = -EFAULT;
271 : : }
272 : :
273 : 27 : r = blk_rq_unmap_user(bio);
274 [ + - ]: 27 : if (!ret)
275 : 27 : ret = r;
276 : :
277 : 27 : return ret;
278 : : }
279 : :
280 : 45 : static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
281 : : struct sg_io_hdr *hdr, fmode_t mode)
282 : : {
283 : 45 : unsigned long start_time;
284 : 45 : ssize_t ret = 0;
285 : 45 : int writing = 0;
286 : 45 : int at_head = 0;
287 : 45 : struct request *rq;
288 : 45 : struct scsi_request *req;
289 : 45 : struct bio *bio;
290 : :
291 [ + + ]: 45 : if (hdr->interface_id != 'S')
292 : : return -EINVAL;
293 : :
294 [ + - ]: 27 : if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
295 : : return -EIO;
296 : :
297 [ - + ]: 27 : if (hdr->dxfer_len)
298 [ - + - ]: 27 : switch (hdr->dxfer_direction) {
299 : : default:
300 : : return -EINVAL;
301 : 0 : case SG_DXFER_TO_DEV:
302 : 0 : writing = 1;
303 : 0 : break;
304 : : case SG_DXFER_TO_FROM_DEV:
305 : : case SG_DXFER_FROM_DEV:
306 : : break;
307 : : }
308 [ - + ]: 27 : if (hdr->flags & SG_FLAG_Q_AT_HEAD)
309 : 0 : at_head = 1;
310 : :
311 : 27 : ret = -ENOMEM;
312 : 27 : rq = blk_get_request(q, writing ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
313 [ - + ]: 27 : if (IS_ERR(rq))
314 : 0 : return PTR_ERR(rq);
315 [ - + ]: 27 : req = scsi_req(rq);
316 : :
317 [ - + ]: 27 : if (hdr->cmd_len > BLK_MAX_CDB) {
318 : 0 : req->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
319 [ # # ]: 0 : if (!req->cmd)
320 : 0 : goto out_put_request;
321 : : }
322 : :
323 : 27 : ret = blk_fill_sghdr_rq(q, rq, hdr, mode);
324 [ - + ]: 27 : if (ret < 0)
325 : 0 : goto out_free_cdb;
326 : :
327 : 27 : ret = 0;
328 [ - + ]: 27 : if (hdr->iovec_count) {
329 : 0 : struct iov_iter i;
330 : 0 : struct iovec *iov = NULL;
331 : :
332 : : #ifdef CONFIG_COMPAT
333 [ # # # # ]: 0 : if (in_compat_syscall())
334 : 0 : ret = compat_import_iovec(rq_data_dir(rq),
335 : 0 : hdr->dxferp, hdr->iovec_count,
336 : : 0, &iov, &i);
337 : : else
338 : : #endif
339 : 0 : ret = import_iovec(rq_data_dir(rq),
340 : 0 : hdr->dxferp, hdr->iovec_count,
341 : : 0, &iov, &i);
342 [ # # ]: 0 : if (ret < 0)
343 : 0 : goto out_free_cdb;
344 : :
345 : : /* SG_IO howto says that the shorter of the two wins */
346 [ # # ]: 0 : iov_iter_truncate(&i, hdr->dxfer_len);
347 : :
348 : 0 : ret = blk_rq_map_user_iov(q, rq, NULL, &i, GFP_KERNEL);
349 : 0 : kfree(iov);
350 [ + - ]: 27 : } else if (hdr->dxfer_len)
351 : 27 : ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
352 : : GFP_KERNEL);
353 : :
354 [ - + ]: 27 : if (ret)
355 : 0 : goto out_free_cdb;
356 : :
357 : 27 : bio = rq->bio;
358 : 27 : req->retries = 0;
359 : :
360 : 27 : start_time = jiffies;
361 : :
362 : : /* ignore return value. All information is passed back to caller
363 : : * (if he doesn't check that is his problem).
364 : : * N.B. a non-zero SCSI status is _not_ necessarily an error.
365 : : */
366 : 27 : blk_execute_rq(q, bd_disk, rq, at_head);
367 : :
368 : 27 : hdr->duration = jiffies_to_msecs(jiffies - start_time);
369 : :
370 : 27 : ret = blk_complete_sghdr_rq(rq, hdr, bio);
371 : :
372 : 27 : out_free_cdb:
373 [ - + ]: 27 : scsi_req_free_cmd(req);
374 : 27 : out_put_request:
375 : 27 : blk_put_request(rq);
376 : 27 : return ret;
377 : : }
378 : :
379 : : /**
380 : : * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
381 : : * @q: request queue to send scsi commands down
382 : : * @disk: gendisk to operate on (option)
383 : : * @mode: mode used to open the file through which the ioctl has been
384 : : * submitted
385 : : * @sic: userspace structure describing the command to perform
386 : : *
387 : : * Send down the scsi command described by @sic to the device below
388 : : * the request queue @q. If @file is non-NULL it's used to perform
389 : : * fine-grained permission checks that allow users to send down
390 : : * non-destructive SCSI commands. If the caller has a struct gendisk
391 : : * available it should be passed in as @disk to allow the low level
392 : : * driver to use the information contained in it. A non-NULL @disk
393 : : * is only allowed if the caller knows that the low level driver doesn't
394 : : * need it (e.g. in the scsi subsystem).
395 : : *
396 : : * Notes:
397 : : * - This interface is deprecated - users should use the SG_IO
398 : : * interface instead, as this is a more flexible approach to
399 : : * performing SCSI commands on a device.
400 : : * - The SCSI command length is determined by examining the 1st byte
401 : : * of the given command. There is no way to override this.
402 : : * - Data transfers are limited to PAGE_SIZE
403 : : * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
404 : : * accommodate the sense buffer when an error occurs.
405 : : * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
406 : : * old code will not be surprised.
407 : : * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
408 : : * a negative return and the Unix error code in 'errno'.
409 : : * If the SCSI command succeeds then 0 is returned.
410 : : * Positive numbers returned are the compacted SCSI error codes (4
411 : : * bytes in one int) where the lowest byte is the SCSI status.
412 : : */
413 : 0 : int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
414 : : struct scsi_ioctl_command __user *sic)
415 : : {
416 : 0 : enum { OMAX_SB_LEN = 16 }; /* For backward compatibility */
417 : 0 : struct request *rq;
418 : 0 : struct scsi_request *req;
419 : 0 : int err;
420 : 0 : unsigned int in_len, out_len, bytes, opcode, cmdlen;
421 : 0 : char *buffer = NULL;
422 : :
423 [ # # ]: 0 : if (!sic)
424 : : return -EINVAL;
425 : :
426 : : /*
427 : : * get in an out lengths, verify they don't exceed a page worth of data
428 : : */
429 [ # # ]: 0 : if (get_user(in_len, &sic->inlen))
430 : : return -EFAULT;
431 [ # # ]: 0 : if (get_user(out_len, &sic->outlen))
432 : : return -EFAULT;
433 [ # # ]: 0 : if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
434 : : return -EINVAL;
435 [ # # ]: 0 : if (get_user(opcode, sic->data))
436 : : return -EFAULT;
437 : :
438 : 0 : bytes = max(in_len, out_len);
439 [ # # ]: 0 : if (bytes) {
440 : 0 : buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
441 [ # # ]: 0 : if (!buffer)
442 : : return -ENOMEM;
443 : :
444 : : }
445 : :
446 [ # # ]: 0 : rq = blk_get_request(q, in_len ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
447 [ # # ]: 0 : if (IS_ERR(rq)) {
448 : 0 : err = PTR_ERR(rq);
449 : 0 : goto error_free_buffer;
450 : : }
451 [ # # ]: 0 : req = scsi_req(rq);
452 : :
453 : 0 : cmdlen = COMMAND_SIZE(opcode);
454 : :
455 : : /*
456 : : * get command and data to send to device, if any
457 : : */
458 : 0 : err = -EFAULT;
459 : 0 : req->cmd_len = cmdlen;
460 [ # # # # ]: 0 : if (copy_from_user(req->cmd, sic->data, cmdlen))
461 : 0 : goto error;
462 : :
463 [ # # # # : 0 : if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
# # ]
464 : 0 : goto error;
465 : :
466 : 0 : err = blk_verify_command(req->cmd, mode);
467 [ # # ]: 0 : if (err)
468 : 0 : goto error;
469 : :
470 : : /* default. possible overriden later */
471 : 0 : req->retries = 5;
472 : :
473 [ # # # # : 0 : switch (opcode) {
# # ]
474 : 0 : case SEND_DIAGNOSTIC:
475 : : case FORMAT_UNIT:
476 : 0 : rq->timeout = FORMAT_UNIT_TIMEOUT;
477 : 0 : req->retries = 1;
478 : 0 : break;
479 : 0 : case START_STOP:
480 : 0 : rq->timeout = START_STOP_TIMEOUT;
481 : 0 : break;
482 : 0 : case MOVE_MEDIUM:
483 : 0 : rq->timeout = MOVE_MEDIUM_TIMEOUT;
484 : 0 : break;
485 : 0 : case READ_ELEMENT_STATUS:
486 : 0 : rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
487 : 0 : break;
488 : 0 : case READ_DEFECT_DATA:
489 : 0 : rq->timeout = READ_DEFECT_DATA_TIMEOUT;
490 : 0 : req->retries = 1;
491 : 0 : break;
492 : 0 : default:
493 : 0 : rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
494 : 0 : break;
495 : : }
496 : :
497 [ # # # # ]: 0 : if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, GFP_NOIO)) {
498 : 0 : err = DRIVER_ERROR << 24;
499 : 0 : goto error;
500 : : }
501 : :
502 : 0 : blk_execute_rq(q, disk, rq, 0);
503 : :
504 : 0 : err = req->result & 0xff; /* only 8 bit SCSI status */
505 [ # # ]: 0 : if (err) {
506 [ # # # # ]: 0 : if (req->sense_len && req->sense) {
507 : 0 : bytes = (OMAX_SB_LEN > req->sense_len) ?
508 : : req->sense_len : OMAX_SB_LEN;
509 [ # # # # ]: 0 : if (copy_to_user(sic->data, req->sense, bytes))
510 : 0 : err = -EFAULT;
511 : : }
512 : : } else {
513 [ # # # # ]: 0 : if (copy_to_user(sic->data, buffer, out_len))
514 : 0 : err = -EFAULT;
515 : : }
516 : :
517 : 0 : error:
518 : 0 : blk_put_request(rq);
519 : :
520 : 0 : error_free_buffer:
521 : 0 : kfree(buffer);
522 : :
523 : 0 : return err;
524 : : }
525 : : EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
526 : :
527 : : /* Send basic block requests */
528 : 0 : static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
529 : : int cmd, int data)
530 : : {
531 : 0 : struct request *rq;
532 : 0 : int err;
533 : :
534 : 0 : rq = blk_get_request(q, REQ_OP_SCSI_OUT, 0);
535 [ # # ]: 0 : if (IS_ERR(rq))
536 : 0 : return PTR_ERR(rq);
537 : 0 : rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
538 : 0 : scsi_req(rq)->cmd[0] = cmd;
539 : 0 : scsi_req(rq)->cmd[4] = data;
540 : 0 : scsi_req(rq)->cmd_len = 6;
541 : 0 : blk_execute_rq(q, bd_disk, rq, 0);
542 [ # # ]: 0 : err = scsi_req(rq)->result ? -EIO : 0;
543 : 0 : blk_put_request(rq);
544 : :
545 : 0 : return err;
546 : : }
547 : :
548 : 0 : static inline int blk_send_start_stop(struct request_queue *q,
549 : : struct gendisk *bd_disk, int data)
550 : : {
551 : 0 : return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
552 : : }
553 : :
554 : 45 : int put_sg_io_hdr(const struct sg_io_hdr *hdr, void __user *argp)
555 : : {
556 : : #ifdef CONFIG_COMPAT
557 [ - + - + ]: 45 : if (in_compat_syscall()) {
558 : 0 : struct compat_sg_io_hdr hdr32 = {
559 : 0 : .interface_id = hdr->interface_id,
560 : 0 : .dxfer_direction = hdr->dxfer_direction,
561 : 0 : .cmd_len = hdr->cmd_len,
562 : 0 : .mx_sb_len = hdr->mx_sb_len,
563 : 0 : .iovec_count = hdr->iovec_count,
564 : 0 : .dxfer_len = hdr->dxfer_len,
565 : 0 : .dxferp = (uintptr_t)hdr->dxferp,
566 : 0 : .cmdp = (uintptr_t)hdr->cmdp,
567 : 0 : .sbp = (uintptr_t)hdr->sbp,
568 : 0 : .timeout = hdr->timeout,
569 : 0 : .flags = hdr->flags,
570 : 0 : .pack_id = hdr->pack_id,
571 : 0 : .usr_ptr = (uintptr_t)hdr->usr_ptr,
572 : 0 : .status = hdr->status,
573 : 0 : .masked_status = hdr->masked_status,
574 : 0 : .msg_status = hdr->msg_status,
575 : 0 : .sb_len_wr = hdr->sb_len_wr,
576 : 0 : .host_status = hdr->host_status,
577 : 0 : .driver_status = hdr->driver_status,
578 : 0 : .resid = hdr->resid,
579 : 0 : .duration = hdr->duration,
580 : 0 : .info = hdr->info,
581 : : };
582 : :
583 [ # # ]: 0 : if (copy_to_user(argp, &hdr32, sizeof(hdr32)))
584 : : return -EFAULT;
585 : :
586 : 0 : return 0;
587 : : }
588 : : #endif
589 : :
590 [ - + - + ]: 90 : if (copy_to_user(argp, hdr, sizeof(*hdr)))
591 : 0 : return -EFAULT;
592 : :
593 : : return 0;
594 : : }
595 : : EXPORT_SYMBOL(put_sg_io_hdr);
596 : :
597 : 45 : int get_sg_io_hdr(struct sg_io_hdr *hdr, const void __user *argp)
598 : : {
599 : : #ifdef CONFIG_COMPAT
600 : 45 : struct compat_sg_io_hdr hdr32;
601 : :
602 [ - + - + ]: 45 : if (in_compat_syscall()) {
603 [ # # ]: 0 : if (copy_from_user(&hdr32, argp, sizeof(hdr32)))
604 : : return -EFAULT;
605 : :
606 : 0 : *hdr = (struct sg_io_hdr) {
607 : 0 : .interface_id = hdr32.interface_id,
608 : 0 : .dxfer_direction = hdr32.dxfer_direction,
609 : 0 : .cmd_len = hdr32.cmd_len,
610 : 0 : .mx_sb_len = hdr32.mx_sb_len,
611 : 0 : .iovec_count = hdr32.iovec_count,
612 : 0 : .dxfer_len = hdr32.dxfer_len,
613 : 0 : .dxferp = compat_ptr(hdr32.dxferp),
614 : 0 : .cmdp = compat_ptr(hdr32.cmdp),
615 : 0 : .sbp = compat_ptr(hdr32.sbp),
616 : 0 : .timeout = hdr32.timeout,
617 : 0 : .flags = hdr32.flags,
618 : 0 : .pack_id = hdr32.pack_id,
619 : 0 : .usr_ptr = compat_ptr(hdr32.usr_ptr),
620 : 0 : .status = hdr32.status,
621 : 0 : .masked_status = hdr32.masked_status,
622 : 0 : .msg_status = hdr32.msg_status,
623 : 0 : .sb_len_wr = hdr32.sb_len_wr,
624 : 0 : .host_status = hdr32.host_status,
625 : 0 : .driver_status = hdr32.driver_status,
626 : 0 : .resid = hdr32.resid,
627 : 0 : .duration = hdr32.duration,
628 : 0 : .info = hdr32.info,
629 : : };
630 : :
631 : 0 : return 0;
632 : : }
633 : : #endif
634 : :
635 [ - + - + ]: 90 : if (copy_from_user(hdr, argp, sizeof(*hdr)))
636 : 0 : return -EFAULT;
637 : :
638 : : return 0;
639 : : }
640 : : EXPORT_SYMBOL(get_sg_io_hdr);
641 : :
642 : : #ifdef CONFIG_COMPAT
643 : : struct compat_cdrom_generic_command {
644 : : unsigned char cmd[CDROM_PACKET_SIZE];
645 : : compat_caddr_t buffer;
646 : : compat_uint_t buflen;
647 : : compat_int_t stat;
648 : : compat_caddr_t sense;
649 : : unsigned char data_direction;
650 : : compat_int_t quiet;
651 : : compat_int_t timeout;
652 : : compat_caddr_t reserved[1];
653 : : };
654 : : #endif
655 : :
656 : 0 : static int scsi_get_cdrom_generic_arg(struct cdrom_generic_command *cgc,
657 : : const void __user *arg)
658 : : {
659 : : #ifdef CONFIG_COMPAT
660 [ # # # # ]: 0 : if (in_compat_syscall()) {
661 : 0 : struct compat_cdrom_generic_command cgc32;
662 : :
663 [ # # ]: 0 : if (copy_from_user(&cgc32, arg, sizeof(cgc32)))
664 : : return -EFAULT;
665 : :
666 : 0 : *cgc = (struct cdrom_generic_command) {
667 : 0 : .buffer = compat_ptr(cgc32.buffer),
668 : 0 : .buflen = cgc32.buflen,
669 : 0 : .stat = cgc32.stat,
670 : 0 : .sense = compat_ptr(cgc32.sense),
671 : 0 : .data_direction = cgc32.data_direction,
672 : 0 : .quiet = cgc32.quiet,
673 : 0 : .timeout = cgc32.timeout,
674 : 0 : .reserved[0] = compat_ptr(cgc32.reserved[0]),
675 : : };
676 : 0 : memcpy(&cgc->cmd, &cgc32.cmd, CDROM_PACKET_SIZE);
677 : 0 : return 0;
678 : : }
679 : : #endif
680 [ # # # # ]: 0 : if (copy_from_user(cgc, arg, sizeof(*cgc)))
681 : 0 : return -EFAULT;
682 : :
683 : : return 0;
684 : : }
685 : :
686 : 0 : static int scsi_put_cdrom_generic_arg(const struct cdrom_generic_command *cgc,
687 : : void __user *arg)
688 : : {
689 : : #ifdef CONFIG_COMPAT
690 [ # # # # ]: 0 : if (in_compat_syscall()) {
691 : 0 : struct compat_cdrom_generic_command cgc32 = {
692 : 0 : .buffer = (uintptr_t)(cgc->buffer),
693 : 0 : .buflen = cgc->buflen,
694 : 0 : .stat = cgc->stat,
695 : 0 : .sense = (uintptr_t)(cgc->sense),
696 : 0 : .data_direction = cgc->data_direction,
697 : 0 : .quiet = cgc->quiet,
698 : 0 : .timeout = cgc->timeout,
699 : 0 : .reserved[0] = (uintptr_t)(cgc->reserved[0]),
700 : : };
701 : 0 : memcpy(&cgc32.cmd, &cgc->cmd, CDROM_PACKET_SIZE);
702 : :
703 [ # # ]: 0 : if (copy_to_user(arg, &cgc32, sizeof(cgc32)))
704 : : return -EFAULT;
705 : :
706 : 0 : return 0;
707 : : }
708 : : #endif
709 [ # # # # ]: 0 : if (copy_to_user(arg, cgc, sizeof(*cgc)))
710 : 0 : return -EFAULT;
711 : :
712 : : return 0;
713 : : }
714 : :
715 : 0 : static int scsi_cdrom_send_packet(struct request_queue *q,
716 : : struct gendisk *bd_disk,
717 : : fmode_t mode, void __user *arg)
718 : : {
719 : 0 : struct cdrom_generic_command cgc;
720 : 0 : struct sg_io_hdr hdr;
721 : 0 : int err;
722 : :
723 : 0 : err = scsi_get_cdrom_generic_arg(&cgc, arg);
724 [ # # ]: 0 : if (err)
725 : : return err;
726 : :
727 : 0 : cgc.timeout = clock_t_to_jiffies(cgc.timeout);
728 : 0 : memset(&hdr, 0, sizeof(hdr));
729 : 0 : hdr.interface_id = 'S';
730 : 0 : hdr.cmd_len = sizeof(cgc.cmd);
731 : 0 : hdr.dxfer_len = cgc.buflen;
732 [ # # # # : 0 : switch (cgc.data_direction) {
# ]
733 : 0 : case CGC_DATA_UNKNOWN:
734 : 0 : hdr.dxfer_direction = SG_DXFER_UNKNOWN;
735 : 0 : break;
736 : 0 : case CGC_DATA_WRITE:
737 : 0 : hdr.dxfer_direction = SG_DXFER_TO_DEV;
738 : 0 : break;
739 : 0 : case CGC_DATA_READ:
740 : 0 : hdr.dxfer_direction = SG_DXFER_FROM_DEV;
741 : 0 : break;
742 : 0 : case CGC_DATA_NONE:
743 : 0 : hdr.dxfer_direction = SG_DXFER_NONE;
744 : 0 : break;
745 : : default:
746 : : return -EINVAL;
747 : : }
748 : :
749 : 0 : hdr.dxferp = cgc.buffer;
750 : 0 : hdr.sbp = cgc.sense;
751 [ # # ]: 0 : if (hdr.sbp)
752 : 0 : hdr.mx_sb_len = sizeof(struct request_sense);
753 : 0 : hdr.timeout = jiffies_to_msecs(cgc.timeout);
754 : 0 : hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
755 : 0 : hdr.cmd_len = sizeof(cgc.cmd);
756 : :
757 : 0 : err = sg_io(q, bd_disk, &hdr, mode);
758 [ # # ]: 0 : if (err == -EFAULT)
759 : : return -EFAULT;
760 : :
761 [ # # ]: 0 : if (hdr.status)
762 : : return -EIO;
763 : :
764 : 0 : cgc.stat = err;
765 : 0 : cgc.buflen = hdr.resid;
766 [ # # ]: 0 : if (scsi_put_cdrom_generic_arg(&cgc, arg))
767 : 0 : return -EFAULT;
768 : :
769 : : return err;
770 : : }
771 : :
772 : 60 : int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mode,
773 : : unsigned int cmd, void __user *arg)
774 : : {
775 : 60 : int err;
776 : :
777 [ + - ]: 60 : if (!q)
778 : : return -ENXIO;
779 : :
780 [ - - - - : 60 : switch (cmd) {
- - - - +
- - - -
+ ]
781 : : /*
782 : : * new sgv3 interface
783 : : */
784 : : case SG_GET_VERSION_NUM:
785 : 0 : err = sg_get_version(arg);
786 : 0 : break;
787 : : case SCSI_IOCTL_GET_IDLUN:
788 : 0 : err = scsi_get_idlun(q, arg);
789 : 0 : break;
790 : : case SCSI_IOCTL_GET_BUS_NUMBER:
791 : 0 : err = scsi_get_bus(q, arg);
792 : 0 : break;
793 : 0 : case SG_SET_TIMEOUT:
794 : 0 : err = sg_set_timeout(q, arg);
795 : : break;
796 : 0 : case SG_GET_TIMEOUT:
797 : 0 : err = sg_get_timeout(q);
798 : 0 : break;
799 : : case SG_GET_RESERVED_SIZE:
800 : 0 : err = sg_get_reserved_size(q, arg);
801 : 0 : break;
802 : : case SG_SET_RESERVED_SIZE:
803 : 0 : err = sg_set_reserved_size(q, arg);
804 : : break;
805 : : case SG_EMULATED_HOST:
806 : 0 : err = sg_emulated_host(q, arg);
807 : 0 : break;
808 : 45 : case SG_IO: {
809 : 45 : struct sg_io_hdr hdr;
810 : :
811 : 45 : err = get_sg_io_hdr(&hdr, arg);
812 [ + - ]: 45 : if (err)
813 : : break;
814 : 45 : err = sg_io(q, bd_disk, &hdr, mode);
815 [ + - ]: 45 : if (err == -EFAULT)
816 : : break;
817 : :
818 [ - + ]: 45 : if (put_sg_io_hdr(&hdr, arg))
819 : 0 : err = -EFAULT;
820 : : break;
821 : : }
822 : 0 : case CDROM_SEND_PACKET:
823 : 0 : err = scsi_cdrom_send_packet(q, bd_disk, mode, arg);
824 : 0 : break;
825 : :
826 : : /*
827 : : * old junk scsi send command ioctl
828 : : */
829 : : case SCSI_IOCTL_SEND_COMMAND:
830 : 0 : printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
831 : 0 : err = -EINVAL;
832 [ # # ]: 0 : if (!arg)
833 : : break;
834 : :
835 : 0 : err = sg_scsi_ioctl(q, bd_disk, mode, arg);
836 : 0 : break;
837 : : case CDROMCLOSETRAY:
838 : 0 : err = blk_send_start_stop(q, bd_disk, 0x03);
839 : 0 : break;
840 : : case CDROMEJECT:
841 : 0 : err = blk_send_start_stop(q, bd_disk, 0x02);
842 : 0 : break;
843 : : default:
844 : : err = -ENOTTY;
845 : : }
846 : :
847 : 0 : return err;
848 : : }
849 : : EXPORT_SYMBOL(scsi_cmd_ioctl);
850 : :
851 : 93 : int scsi_verify_blk_ioctl(struct block_device *bd, unsigned int cmd)
852 : : {
853 [ - + + - : 93 : if (bd && bd == bd->bd_contains)
- + ]
854 : : return 0;
855 : :
856 [ # # # # ]: 0 : if (capable(CAP_SYS_RAWIO))
857 : 0 : return 0;
858 : :
859 : : return -ENOIOCTLCMD;
860 : : }
861 : : EXPORT_SYMBOL(scsi_verify_blk_ioctl);
862 : :
863 : 60 : int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
864 : : unsigned int cmd, void __user *arg)
865 : : {
866 : 60 : int ret;
867 : :
868 [ + - ]: 60 : ret = scsi_verify_blk_ioctl(bd, cmd);
869 : : if (ret < 0)
870 : : return ret;
871 : :
872 : 60 : return scsi_cmd_ioctl(bd->bd_disk->queue, bd->bd_disk, mode, cmd, arg);
873 : : }
874 : : EXPORT_SYMBOL(scsi_cmd_blk_ioctl);
875 : :
876 : : /**
877 : : * scsi_req_init - initialize certain fields of a scsi_request structure
878 : : * @req: Pointer to a scsi_request structure.
879 : : * Initializes .__cmd[], .cmd, .cmd_len and .sense_len but no other members
880 : : * of struct scsi_request.
881 : : */
882 : 3368 : void scsi_req_init(struct scsi_request *req)
883 : : {
884 : 3368 : memset(req->__cmd, 0, sizeof(req->__cmd));
885 : 3368 : req->cmd = req->__cmd;
886 : 3368 : req->cmd_len = BLK_MAX_CDB;
887 : 3368 : req->sense_len = 0;
888 : 3368 : }
889 : : EXPORT_SYMBOL(scsi_req_init);
890 : :
891 : 3 : static int __init blk_scsi_ioctl_init(void)
892 : : {
893 : 3 : blk_set_cmd_filter_defaults(&blk_default_cmd_filter);
894 : 3 : return 0;
895 : : }
896 : : fs_initcall(blk_scsi_ioctl_init);
|
