Branch data 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 : : unsigned int len, slen;
45 : : 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 : : 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 : : int result;
93 : : struct scsi_sense_hdr sshdr;
94 : :
95 : : SCSI_LOG_IOCTL(1, sdev_printk(KERN_INFO, sdev,
96 : : "Trying ioctl with scsi command %d\n", *cmd));
97 : :
98 : : result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0,
99 : : &sshdr, timeout, retries, NULL);
100 : :
101 : : SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
102 : : "Ioctl returned 0x%x\n", result));
103 : :
104 [ # # # # ]: 0 : if (driver_byte(result) == DRIVER_SENSE &&
105 : : scsi_sense_valid(&sshdr)) {
106 [ # # # # ]: 0 : switch (sshdr.sense_key) {
107 : : 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 : : case NOT_READY: /* This happens if there is no disc in drive */
118 [ # # ]: 0 : if (sdev->removable)
119 : : break;
120 : : /* FALLTHROUGH */
121 : : case UNIT_ATTENTION:
122 [ # # ]: 0 : if (sdev->removable) {
123 : 0 : sdev->changed = 1;
124 : : result = 0; /* This is no longer considered an error */
125 : 0 : break;
126 : : }
127 : : /* 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 : : }
136 : :
137 : : SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
138 : : "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 : : char scsi_cmd[MAX_COMMAND_SIZE];
145 : : 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 : 0 : 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 : : const char *name;
179 : :
180 [ # # ]: 0 : if (!dev)
181 : : return -ENXIO;
182 : :
183 : : 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 : : /**
193 : : * scsi_ioctl - Dispatch ioctl to scsi device
194 : : * @sdev: scsi device receiving ioctl
195 : : * @cmd: which ioctl is it
196 : : * @arg: data associated with ioctl
197 : : *
198 : : * Description: The scsi_ioctl() function differs from most ioctls in that it
199 : : * does not take a major/minor number as the dev field. Rather, it takes
200 : : * a pointer to a &struct scsi_device.
201 : : */
202 : 0 : int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
203 : : {
204 : : char scsi_cmd[MAX_COMMAND_SIZE];
205 : : struct scsi_sense_hdr sense_hdr;
206 : :
207 : : /* Check for deprecated ioctls ... all the ioctls which don't
208 : : * follow the new unique numbering scheme are deprecated */
209 [ # # ]: 0 : switch (cmd) {
210 : : case SCSI_IOCTL_SEND_COMMAND:
211 : : case SCSI_IOCTL_TEST_UNIT_READY:
212 : : case SCSI_IOCTL_BENCHMARK_COMMAND:
213 : : case SCSI_IOCTL_SYNC:
214 : : case SCSI_IOCTL_START_UNIT:
215 : : case SCSI_IOCTL_STOP_UNIT:
216 : 0 : printk(KERN_WARNING "program %s is using a deprecated SCSI "
217 : 0 : "ioctl, please convert it to SG_IO\n", current->comm);
218 : 0 : break;
219 : : default:
220 : : break;
221 : : }
222 : :
223 [ # # # # : 0 : switch (cmd) {
# # # # #
# # # ]
224 : : case SCSI_IOCTL_GET_IDLUN:
225 [ # # ]: 0 : if (!access_ok(arg, sizeof(struct scsi_idlun)))
226 : : return -EFAULT;
227 : :
228 : 0 : __put_user((sdev->id & 0xff)
229 : : + ((sdev->lun & 0xff) << 8)
230 : : + ((sdev->channel & 0xff) << 16)
231 : : + ((sdev->host->host_no & 0xff) << 24),
232 : : &((struct scsi_idlun __user *)arg)->dev_id);
233 : 0 : __put_user(sdev->host->unique_id,
234 : : &((struct scsi_idlun __user *)arg)->host_unique_id);
235 : 0 : return 0;
236 : : case SCSI_IOCTL_GET_BUS_NUMBER:
237 : 0 : return put_user(sdev->host->host_no, (int __user *)arg);
238 : : case SCSI_IOCTL_PROBE_HOST:
239 : 0 : return ioctl_probe(sdev->host, arg);
240 : : case SCSI_IOCTL_SEND_COMMAND:
241 [ # # # # ]: 0 : if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
242 : : return -EACCES;
243 : 0 : return sg_scsi_ioctl(sdev->request_queue, NULL, 0, arg);
244 : : case SCSI_IOCTL_DOORLOCK:
245 : 0 : return scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
246 : : case SCSI_IOCTL_DOORUNLOCK:
247 : 0 : return scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
248 : : case SCSI_IOCTL_TEST_UNIT_READY:
249 : 0 : return scsi_test_unit_ready(sdev, IOCTL_NORMAL_TIMEOUT,
250 : : NORMAL_RETRIES, &sense_hdr);
251 : : case SCSI_IOCTL_START_UNIT:
252 : 0 : scsi_cmd[0] = START_STOP;
253 : 0 : scsi_cmd[1] = 0;
254 : 0 : scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
255 : 0 : scsi_cmd[4] = 1;
256 : 0 : return ioctl_internal_command(sdev, scsi_cmd,
257 : : START_STOP_TIMEOUT, NORMAL_RETRIES);
258 : : case SCSI_IOCTL_STOP_UNIT:
259 : 0 : scsi_cmd[0] = START_STOP;
260 : 0 : scsi_cmd[1] = 0;
261 : 0 : scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
262 : 0 : scsi_cmd[4] = 0;
263 : 0 : return ioctl_internal_command(sdev, scsi_cmd,
264 : : START_STOP_TIMEOUT, NORMAL_RETRIES);
265 : : case SCSI_IOCTL_GET_PCI:
266 : 0 : return scsi_ioctl_get_pci(sdev, arg);
267 : : case SG_SCSI_RESET:
268 : 0 : return scsi_ioctl_reset(sdev, arg);
269 : : default:
270 [ # # ]: 0 : if (sdev->host->hostt->ioctl)
271 : 0 : return sdev->host->hostt->ioctl(sdev, cmd, arg);
272 : : }
273 : : return -EINVAL;
274 : : }
275 : : EXPORT_SYMBOL(scsi_ioctl);
276 : :
277 : : /*
278 : : * We can process a reset even when a device isn't fully operable.
279 : : */
280 : 0 : int scsi_ioctl_block_when_processing_errors(struct scsi_device *sdev, int cmd,
281 : : bool ndelay)
282 : : {
283 [ # # ]: 0 : if (cmd == SG_SCSI_RESET && ndelay) {
284 [ # # ]: 0 : if (scsi_host_in_recovery(sdev->host))
285 : : return -EAGAIN;
286 : : } else {
287 [ # # ]: 0 : if (!scsi_block_when_processing_errors(sdev))
288 : : return -ENODEV;
289 : : }
290 : :
291 : : return 0;
292 : : }
293 : : EXPORT_SYMBOL_GPL(scsi_ioctl_block_when_processing_errors);
|
