Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : * Changes:
4 : * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 08/23/2000
5 : * - get rid of some verify_areas and use __copy*user and __get/put_user
6 : * for the ones that remain
7 : */
8 : #include <linux/module.h>
9 : #include <linux/blkdev.h>
10 : #include <linux/interrupt.h>
11 : #include <linux/errno.h>
12 : #include <linux/kernel.h>
13 : #include <linux/sched.h>
14 : #include <linux/mm.h>
15 : #include <linux/string.h>
16 : #include <linux/uaccess.h>
17 :
18 : #include <scsi/scsi.h>
19 : #include <scsi/scsi_cmnd.h>
20 : #include <scsi/scsi_device.h>
21 : #include <scsi/scsi_eh.h>
22 : #include <scsi/scsi_host.h>
23 : #include <scsi/scsi_ioctl.h>
24 : #include <scsi/sg.h>
25 : #include <scsi/scsi_dbg.h>
26 :
27 : #include "scsi_logging.h"
28 :
29 : #define NORMAL_RETRIES 5
30 : #define IOCTL_NORMAL_TIMEOUT (10 * HZ)
31 :
32 : #define MAX_BUF PAGE_SIZE
33 :
34 : /**
35 : * ioctl_probe -- return host identification
36 : * @host: host to identify
37 : * @buffer: userspace buffer for identification
38 : *
39 : * Return an identifying string at @buffer, if @buffer is non-NULL, filling
40 : * to the length stored at * (int *) @buffer.
41 : */
42 0 : static int ioctl_probe(struct Scsi_Host *host, void __user *buffer)
43 : {
44 0 : unsigned int len, slen;
45 0 : const char *string;
46 :
47 0 : if (buffer) {
48 0 : if (get_user(len, (unsigned int __user *) buffer))
49 : return -EFAULT;
50 :
51 0 : if (host->hostt->info)
52 0 : string = host->hostt->info(host);
53 : else
54 0 : string = host->hostt->name;
55 0 : if (string) {
56 0 : slen = strlen(string);
57 0 : if (len > slen)
58 0 : len = slen + 1;
59 0 : if (copy_to_user(buffer, string, len))
60 0 : return -EFAULT;
61 : }
62 : }
63 : return 1;
64 : }
65 :
66 : /*
67 :
68 : * The SCSI_IOCTL_SEND_COMMAND ioctl sends a command out to the SCSI host.
69 : * The IOCTL_NORMAL_TIMEOUT and NORMAL_RETRIES variables are used.
70 : *
71 : * dev is the SCSI device struct ptr, *(int *) arg is the length of the
72 : * input data, if any, not including the command string & counts,
73 : * *((int *)arg + 1) is the output buffer size in bytes.
74 : *
75 : * *(char *) ((int *) arg)[2] the actual command byte.
76 : *
77 : * Note that if more than MAX_BUF bytes are requested to be transferred,
78 : * the ioctl will fail with error EINVAL.
79 : *
80 : * This size *does not* include the initial lengths that were passed.
81 : *
82 : * The SCSI command is read from the memory location immediately after the
83 : * length words, and the input data is right after the command. The SCSI
84 : * routines know the command size based on the opcode decode.
85 : *
86 : * The output area is then filled in starting from the command byte.
87 : */
88 :
89 0 : static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
90 : int timeout, int retries)
91 : {
92 0 : int result;
93 0 : struct scsi_sense_hdr sshdr;
94 :
95 0 : SCSI_LOG_IOCTL(1, sdev_printk(KERN_INFO, sdev,
96 0 : "Trying ioctl with scsi command %d\n", *cmd));
97 :
98 0 : result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0,
99 : &sshdr, timeout, retries, NULL);
100 :
101 0 : SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
102 0 : "Ioctl returned 0x%x\n", result));
103 :
104 0 : if (driver_byte(result) == DRIVER_SENSE &&
105 0 : scsi_sense_valid(&sshdr)) {
106 0 : switch (sshdr.sense_key) {
107 0 : case ILLEGAL_REQUEST:
108 0 : if (cmd[0] == ALLOW_MEDIUM_REMOVAL)
109 0 : sdev->lockable = 0;
110 : else
111 0 : sdev_printk(KERN_INFO, sdev,
112 : "ioctl_internal_command: "
113 : "ILLEGAL REQUEST "
114 : "asc=0x%x ascq=0x%x\n",
115 : sshdr.asc, sshdr.ascq);
116 : break;
117 0 : case NOT_READY: /* This happens if there is no disc in drive */
118 0 : if (sdev->removable)
119 : break;
120 0 : fallthrough;
121 : case UNIT_ATTENTION:
122 0 : if (sdev->removable) {
123 0 : sdev->changed = 1;
124 0 : result = 0; /* This is no longer considered an error */
125 0 : break;
126 : }
127 0 : fallthrough; /* for non-removable media */
128 : default:
129 0 : sdev_printk(KERN_INFO, sdev,
130 : "ioctl_internal_command return code = %x\n",
131 : result);
132 0 : scsi_print_sense_hdr(sdev, NULL, &sshdr);
133 0 : break;
134 : }
135 0 : }
136 :
137 0 : SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
138 0 : "IOCTL Releasing command\n"));
139 0 : return result;
140 : }
141 :
142 0 : int scsi_set_medium_removal(struct scsi_device *sdev, char state)
143 : {
144 0 : char scsi_cmd[MAX_COMMAND_SIZE];
145 0 : int ret;
146 :
147 0 : if (!sdev->removable || !sdev->lockable)
148 : return 0;
149 :
150 0 : scsi_cmd[0] = ALLOW_MEDIUM_REMOVAL;
151 0 : scsi_cmd[1] = 0;
152 0 : scsi_cmd[2] = 0;
153 0 : scsi_cmd[3] = 0;
154 0 : scsi_cmd[4] = state;
155 0 : scsi_cmd[5] = 0;
156 :
157 0 : ret = ioctl_internal_command(sdev, scsi_cmd,
158 : IOCTL_NORMAL_TIMEOUT, NORMAL_RETRIES);
159 0 : if (ret == 0)
160 0 : sdev->locked = (state == SCSI_REMOVAL_PREVENT);
161 : return ret;
162 : }
163 : EXPORT_SYMBOL(scsi_set_medium_removal);
164 :
165 : /*
166 : * The scsi_ioctl_get_pci() function places into arg the value
167 : * pci_dev::slot_name (8 characters) for the PCI device (if any).
168 : * Returns: 0 on success
169 : * -ENXIO if there isn't a PCI device pointer
170 : * (could be because the SCSI driver hasn't been
171 : * updated yet, or because it isn't a SCSI
172 : * device)
173 : * any copy_to_user() error on failure there
174 : */
175 0 : static int scsi_ioctl_get_pci(struct scsi_device *sdev, void __user *arg)
176 : {
177 0 : struct device *dev = scsi_get_device(sdev->host);
178 0 : const char *name;
179 :
180 0 : if (!dev)
181 : return -ENXIO;
182 :
183 0 : name = dev_name(dev);
184 :
185 : /* compatibility with old ioctl which only returned
186 : * 20 characters */
187 0 : return copy_to_user(arg, name, min(strlen(name), (size_t)20))
188 0 : ? -EFAULT: 0;
189 : }
190 :
191 :
192 0 : static int scsi_ioctl_common(struct scsi_device *sdev, int cmd, void __user *arg)
193 : {
194 0 : char scsi_cmd[MAX_COMMAND_SIZE];
195 0 : struct scsi_sense_hdr sense_hdr;
196 :
197 : /* Check for deprecated ioctls ... all the ioctls which don't
198 : * follow the new unique numbering scheme are deprecated */
199 0 : switch (cmd) {
200 : case SCSI_IOCTL_SEND_COMMAND:
201 : case SCSI_IOCTL_TEST_UNIT_READY:
202 : case SCSI_IOCTL_BENCHMARK_COMMAND:
203 : case SCSI_IOCTL_SYNC:
204 : case SCSI_IOCTL_START_UNIT:
205 : case SCSI_IOCTL_STOP_UNIT:
206 0 : printk(KERN_WARNING "program %s is using a deprecated SCSI "
207 0 : "ioctl, please convert it to SG_IO\n", current->comm);
208 0 : break;
209 : default:
210 : break;
211 : }
212 :
213 0 : switch (cmd) {
214 0 : case SCSI_IOCTL_GET_IDLUN: {
215 0 : struct scsi_idlun v = {
216 0 : .dev_id = (sdev->id & 0xff)
217 0 : + ((sdev->lun & 0xff) << 8)
218 0 : + ((sdev->channel & 0xff) << 16)
219 0 : + ((sdev->host->host_no & 0xff) << 24),
220 0 : .host_unique_id = sdev->host->unique_id
221 : };
222 0 : if (copy_to_user(arg, &v, sizeof(struct scsi_idlun)))
223 0 : return -EFAULT;
224 : return 0;
225 : }
226 0 : case SCSI_IOCTL_GET_BUS_NUMBER:
227 0 : return put_user(sdev->host->host_no, (int __user *)arg);
228 0 : case SCSI_IOCTL_PROBE_HOST:
229 0 : return ioctl_probe(sdev->host, arg);
230 0 : case SCSI_IOCTL_SEND_COMMAND:
231 0 : if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
232 0 : return -EACCES;
233 0 : return sg_scsi_ioctl(sdev->request_queue, NULL, 0, arg);
234 0 : case SCSI_IOCTL_DOORLOCK:
235 0 : return scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
236 0 : case SCSI_IOCTL_DOORUNLOCK:
237 0 : return scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
238 0 : case SCSI_IOCTL_TEST_UNIT_READY:
239 0 : return scsi_test_unit_ready(sdev, IOCTL_NORMAL_TIMEOUT,
240 : NORMAL_RETRIES, &sense_hdr);
241 0 : case SCSI_IOCTL_START_UNIT:
242 0 : scsi_cmd[0] = START_STOP;
243 0 : scsi_cmd[1] = 0;
244 0 : scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
245 0 : scsi_cmd[4] = 1;
246 0 : return ioctl_internal_command(sdev, scsi_cmd,
247 : START_STOP_TIMEOUT, NORMAL_RETRIES);
248 0 : case SCSI_IOCTL_STOP_UNIT:
249 0 : scsi_cmd[0] = START_STOP;
250 0 : scsi_cmd[1] = 0;
251 0 : scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
252 0 : scsi_cmd[4] = 0;
253 0 : return ioctl_internal_command(sdev, scsi_cmd,
254 : START_STOP_TIMEOUT, NORMAL_RETRIES);
255 0 : case SCSI_IOCTL_GET_PCI:
256 0 : return scsi_ioctl_get_pci(sdev, arg);
257 0 : case SG_SCSI_RESET:
258 0 : return scsi_ioctl_reset(sdev, arg);
259 : }
260 : return -ENOIOCTLCMD;
261 : }
262 :
263 : /**
264 : * scsi_ioctl - Dispatch ioctl to scsi device
265 : * @sdev: scsi device receiving ioctl
266 : * @cmd: which ioctl is it
267 : * @arg: data associated with ioctl
268 : *
269 : * Description: The scsi_ioctl() function differs from most ioctls in that it
270 : * does not take a major/minor number as the dev field. Rather, it takes
271 : * a pointer to a &struct scsi_device.
272 : */
273 0 : int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
274 : {
275 0 : int ret = scsi_ioctl_common(sdev, cmd, arg);
276 :
277 0 : if (ret != -ENOIOCTLCMD)
278 : return ret;
279 :
280 0 : if (sdev->host->hostt->ioctl)
281 0 : return sdev->host->hostt->ioctl(sdev, cmd, arg);
282 :
283 : return -EINVAL;
284 : }
285 : EXPORT_SYMBOL(scsi_ioctl);
286 :
287 : #ifdef CONFIG_COMPAT
288 0 : int scsi_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
289 : {
290 0 : int ret = scsi_ioctl_common(sdev, cmd, arg);
291 :
292 0 : if (ret != -ENOIOCTLCMD)
293 : return ret;
294 :
295 0 : if (sdev->host->hostt->compat_ioctl)
296 0 : return sdev->host->hostt->compat_ioctl(sdev, cmd, arg);
297 :
298 : return ret;
299 : }
300 : EXPORT_SYMBOL(scsi_compat_ioctl);
301 : #endif
302 :
303 : /*
304 : * We can process a reset even when a device isn't fully operable.
305 : */
306 0 : int scsi_ioctl_block_when_processing_errors(struct scsi_device *sdev, int cmd,
307 : bool ndelay)
308 : {
309 0 : if (cmd == SG_SCSI_RESET && ndelay) {
310 0 : if (scsi_host_in_recovery(sdev->host))
311 0 : return -EAGAIN;
312 : } else {
313 0 : if (!scsi_block_when_processing_errors(sdev))
314 0 : return -ENODEV;
315 : }
316 :
317 : return 0;
318 : }
319 : EXPORT_SYMBOL_GPL(scsi_ioctl_block_when_processing_errors);
|
