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