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
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>
14 #include <linux/string.h>
15 #include <asm/uaccess.h>
17 #include <scsi/scsi.h>
18 #include <scsi/scsi_device.h>
19 #include <scsi/scsi_eh.h>
20 #include <scsi/scsi_host.h>
21 #include <scsi/scsi_ioctl.h>
22 #include <scsi/scsi_request.h>
24 #include <scsi/scsi_dbg.h>
26 #include "scsi_logging.h"
28 #define NORMAL_RETRIES 5
29 #define IOCTL_NORMAL_TIMEOUT (10 * HZ)
31 #define MAX_BUF PAGE_SIZE
34 * If we are told to probe a host, we will return 0 if the host is not
35 * present, 1 if the host is present, and will return an identifying
36 * string at *arg, if arg is non null, filling to the length stored at
40 static int ioctl_probe(struct Scsi_Host
*host
, void __user
*buffer
)
42 unsigned int len
, slen
;
44 int temp
= host
->hostt
->present
;
47 if (get_user(len
, (unsigned int __user
*) buffer
))
50 if (host
->hostt
->info
)
51 string
= host
->hostt
->info(host
);
53 string
= host
->hostt
->name
;
55 slen
= strlen(string
);
58 if (copy_to_user(buffer
, string
, len
))
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.
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.
74 * *(char *) ((int *) arg)[2] the actual command byte.
76 * Note that if more than MAX_BUF bytes are requested to be transferred,
77 * the ioctl will fail with error EINVAL.
79 * This size *does not* include the initial lengths that were passed.
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.
85 * The output area is then filled in starting from the command byte.
88 static int ioctl_internal_command(struct scsi_device
*sdev
, char *cmd
,
89 int timeout
, int retries
)
92 struct scsi_sense_hdr sshdr
;
93 char sense
[SCSI_SENSE_BUFFERSIZE
];
95 SCSI_LOG_IOCTL(1, printk("Trying ioctl with scsi command %d\n", *cmd
));
98 memset(sense
, 0, sizeof(*sense
));
99 result
= scsi_execute_req(sdev
, cmd
, DMA_NONE
, NULL
, 0,
100 sense
, timeout
, retries
);
102 SCSI_LOG_IOCTL(2, printk("Ioctl returned 0x%x\n", result
));
104 if ((driver_byte(result
) & DRIVER_SENSE
) &&
105 (scsi_normalize_sense(sense
, sizeof(*sense
), &sshdr
))) {
106 switch (sshdr
.sense_key
) {
107 case ILLEGAL_REQUEST
:
108 if (cmd
[0] == ALLOW_MEDIUM_REMOVAL
)
111 printk(KERN_INFO
"ioctl_internal_command: "
112 "ILLEGAL REQUEST asc=0x%x ascq=0x%x\n",
113 sshdr
.asc
, sshdr
.ascq
);
115 case NOT_READY
: /* This happens if there is no disc in drive */
116 if (sdev
->removable
&& (cmd
[0] != TEST_UNIT_READY
)) {
117 printk(KERN_INFO
"Device not ready. Make sure"
118 " there is a disc in the drive.\n");
122 if (sdev
->removable
) {
124 result
= 0; /* This is no longer considered an error */
127 default: /* Fall through for non-removable media */
128 printk(KERN_INFO
"ioctl_internal_command: <%d %d %d "
129 "%d> return code = %x\n",
135 __scsi_print_sense(" ", sense
, sizeof(*sense
));
140 SCSI_LOG_IOCTL(2, printk("IOCTL Releasing command\n"));
144 int scsi_set_medium_removal(struct scsi_device
*sdev
, char state
)
146 char scsi_cmd
[MAX_COMMAND_SIZE
];
149 if (!sdev
->removable
|| !sdev
->lockable
)
152 scsi_cmd
[0] = ALLOW_MEDIUM_REMOVAL
;
159 ret
= ioctl_internal_command(sdev
, scsi_cmd
,
160 IOCTL_NORMAL_TIMEOUT
, NORMAL_RETRIES
);
162 sdev
->locked
= (state
== SCSI_REMOVAL_PREVENT
);
165 EXPORT_SYMBOL(scsi_set_medium_removal
);
168 * This interface is deprecated - users should use the scsi generic (sg)
169 * interface instead, as this is a more flexible approach to performing
170 * generic SCSI commands on a device.
172 * The structure that we are passed should look like:
175 * unsigned int inlen; [i] Length of data to be written to device
176 * unsigned int outlen; [i] Length of data to be read from device
177 * unsigned char cmd[x]; [i] SCSI command (6 <= x <= 12).
178 * [o] Data read from device starts here.
179 * [o] On error, sense buffer starts here.
180 * unsigned char wdata[y]; [i] Data written to device starts here.
183 * - The SCSI command length is determined by examining the 1st byte
184 * of the given command. There is no way to override this.
185 * - Data transfers are limited to PAGE_SIZE (4K on i386, 8K on alpha).
186 * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
187 * accommodate the sense buffer when an error occurs.
188 * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
189 * old code will not be surprised.
190 * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
191 * a negative return and the Unix error code in 'errno'.
192 * If the SCSI command succeeds then 0 is returned.
193 * Positive numbers returned are the compacted SCSI error codes (4
194 * bytes in one int) where the lowest byte is the SCSI status.
195 * See the drivers/scsi/scsi.h file for more information on this.
198 #define OMAX_SB_LEN 16 /* Old sense buffer length */
200 int scsi_ioctl_send_command(struct scsi_device
*sdev
,
201 struct scsi_ioctl_command __user
*sic
)
204 unsigned char cmd
[MAX_COMMAND_SIZE
];
205 unsigned char sense
[SCSI_SENSE_BUFFERSIZE
];
207 unsigned char opcode
;
208 unsigned int inlen
, outlen
, cmdlen
;
209 unsigned int needed
, buf_needed
;
210 int timeout
, retries
, result
;
211 int data_direction
, gfp_mask
= GFP_KERNEL
;
216 if (sdev
->host
->unchecked_isa_dma
)
220 * Verify that we can read at least this much.
222 if (!access_ok(VERIFY_READ
, sic
, sizeof(Scsi_Ioctl_Command
)))
225 if(__get_user(inlen
, &sic
->inlen
))
228 if(__get_user(outlen
, &sic
->outlen
))
232 * We do not transfer more than MAX_BUF with this interface.
233 * If the user needs to transfer more data than this, they
234 * should use scsi_generics (sg) instead.
238 if (outlen
> MAX_BUF
)
242 if(get_user(opcode
, cmd_in
))
245 needed
= buf_needed
= (inlen
> outlen
? inlen
: outlen
);
247 buf_needed
= (buf_needed
+ 511) & ~511;
248 if (buf_needed
> MAX_BUF
)
249 buf_needed
= MAX_BUF
;
250 buf
= kmalloc(buf_needed
, gfp_mask
);
253 memset(buf
, 0, buf_needed
);
255 data_direction
= DMA_FROM_DEVICE
;
256 } else if (outlen
== 0 ) {
257 data_direction
= DMA_TO_DEVICE
;
260 * Can this ever happen?
262 data_direction
= DMA_BIDIRECTIONAL
;
267 data_direction
= DMA_NONE
;
271 * Obtain the command from the user's address space.
273 cmdlen
= COMMAND_SIZE(opcode
);
277 if (!access_ok(VERIFY_READ
, cmd_in
, cmdlen
+ inlen
))
280 if(__copy_from_user(cmd
, cmd_in
, cmdlen
))
284 * Obtain the data to be sent to the device (if any).
287 if(copy_from_user(buf
, cmd_in
+ cmdlen
, inlen
))
291 case SEND_DIAGNOSTIC
:
293 timeout
= FORMAT_UNIT_TIMEOUT
;
297 timeout
= START_STOP_TIMEOUT
;
298 retries
= NORMAL_RETRIES
;
301 timeout
= MOVE_MEDIUM_TIMEOUT
;
302 retries
= NORMAL_RETRIES
;
304 case READ_ELEMENT_STATUS
:
305 timeout
= READ_ELEMENT_STATUS_TIMEOUT
;
306 retries
= NORMAL_RETRIES
;
308 case READ_DEFECT_DATA
:
309 timeout
= READ_DEFECT_DATA_TIMEOUT
;
313 timeout
= IOCTL_NORMAL_TIMEOUT
;
314 retries
= NORMAL_RETRIES
;
318 result
= scsi_execute_req(sdev
, cmd
, data_direction
, buf
, needed
,
319 sense
, timeout
, retries
);
322 * If there was an error condition, pass the info back to the user.
325 int sb_len
= sizeof(*sense
);
327 sb_len
= (sb_len
> OMAX_SB_LEN
) ? OMAX_SB_LEN
: sb_len
;
328 if (copy_to_user(cmd_in
, sense
, sb_len
))
331 if (copy_to_user(cmd_in
, buf
, outlen
))
339 EXPORT_SYMBOL(scsi_ioctl_send_command
);
342 * The scsi_ioctl_get_pci() function places into arg the value
343 * pci_dev::slot_name (8 characters) for the PCI device (if any).
344 * Returns: 0 on success
345 * -ENXIO if there isn't a PCI device pointer
346 * (could be because the SCSI driver hasn't been
347 * updated yet, or because it isn't a SCSI
349 * any copy_to_user() error on failure there
351 static int scsi_ioctl_get_pci(struct scsi_device
*sdev
, void __user
*arg
)
353 struct device
*dev
= scsi_get_device(sdev
->host
);
357 return copy_to_user(arg
, dev
->bus_id
, sizeof(dev
->bus_id
))? -EFAULT
: 0;
362 * the scsi_ioctl() function differs from most ioctls in that it does
363 * not take a major/minor number as the dev field. Rather, it takes
364 * a pointer to a scsi_devices[] element, a structure.
366 int scsi_ioctl(struct scsi_device
*sdev
, int cmd
, void __user
*arg
)
368 char scsi_cmd
[MAX_COMMAND_SIZE
];
370 /* No idea how this happens.... */
375 * If we are in the middle of error recovery, don't let anyone
376 * else try and use this device. Also, if error recovery fails, it
377 * may try and take the device offline, in which case all further
378 * access to the device is prohibited.
380 if (!scsi_block_when_processing_errors(sdev
))
383 /* Check for deprecated ioctls ... all the ioctls which don't
384 * follow the new unique numbering scheme are deprecated */
386 case SCSI_IOCTL_SEND_COMMAND
:
387 case SCSI_IOCTL_TEST_UNIT_READY
:
388 case SCSI_IOCTL_BENCHMARK_COMMAND
:
389 case SCSI_IOCTL_SYNC
:
390 case SCSI_IOCTL_START_UNIT
:
391 case SCSI_IOCTL_STOP_UNIT
:
392 printk(KERN_WARNING
"program %s is using a deprecated SCSI "
393 "ioctl, please convert it to SG_IO\n", current
->comm
);
400 case SCSI_IOCTL_GET_IDLUN
:
401 if (!access_ok(VERIFY_WRITE
, arg
, sizeof(struct scsi_idlun
)))
404 __put_user((sdev
->id
& 0xff)
405 + ((sdev
->lun
& 0xff) << 8)
406 + ((sdev
->channel
& 0xff) << 16)
407 + ((sdev
->host
->host_no
& 0xff) << 24),
408 &((struct scsi_idlun __user
*)arg
)->dev_id
);
409 __put_user(sdev
->host
->unique_id
,
410 &((struct scsi_idlun __user
*)arg
)->host_unique_id
);
412 case SCSI_IOCTL_GET_BUS_NUMBER
:
413 return put_user(sdev
->host
->host_no
, (int __user
*)arg
);
414 case SCSI_IOCTL_PROBE_HOST
:
415 return ioctl_probe(sdev
->host
, arg
);
416 case SCSI_IOCTL_SEND_COMMAND
:
417 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
419 return scsi_ioctl_send_command(sdev
, arg
);
420 case SCSI_IOCTL_DOORLOCK
:
421 return scsi_set_medium_removal(sdev
, SCSI_REMOVAL_PREVENT
);
422 case SCSI_IOCTL_DOORUNLOCK
:
423 return scsi_set_medium_removal(sdev
, SCSI_REMOVAL_ALLOW
);
424 case SCSI_IOCTL_TEST_UNIT_READY
:
425 return scsi_test_unit_ready(sdev
, IOCTL_NORMAL_TIMEOUT
,
427 case SCSI_IOCTL_START_UNIT
:
428 scsi_cmd
[0] = START_STOP
;
430 scsi_cmd
[2] = scsi_cmd
[3] = scsi_cmd
[5] = 0;
432 return ioctl_internal_command(sdev
, scsi_cmd
,
433 START_STOP_TIMEOUT
, NORMAL_RETRIES
);
434 case SCSI_IOCTL_STOP_UNIT
:
435 scsi_cmd
[0] = START_STOP
;
437 scsi_cmd
[2] = scsi_cmd
[3] = scsi_cmd
[5] = 0;
439 return ioctl_internal_command(sdev
, scsi_cmd
,
440 START_STOP_TIMEOUT
, NORMAL_RETRIES
);
441 case SCSI_IOCTL_GET_PCI
:
442 return scsi_ioctl_get_pci(sdev
, arg
);
444 if (sdev
->host
->hostt
->ioctl
)
445 return sdev
->host
->hostt
->ioctl(sdev
, cmd
, arg
);
449 EXPORT_SYMBOL(scsi_ioctl
);
452 * the scsi_nonblock_ioctl() function is designed for ioctls which may
453 * be executed even if the device is in recovery.
455 int scsi_nonblockable_ioctl(struct scsi_device
*sdev
, int cmd
,
456 void __user
*arg
, struct file
*filp
)
460 /* The first set of iocts may be executed even if we're doing
461 * error processing, as long as the device was opened
463 if (filp
&& filp
->f_flags
& O_NONBLOCK
) {
464 if (sdev
->host
->shost_state
== SHOST_RECOVERY
)
466 } else if (!scsi_block_when_processing_errors(sdev
))
471 result
= get_user(val
, (int __user
*)arg
);
474 if (val
== SG_SCSI_RESET_NOTHING
)
477 case SG_SCSI_RESET_DEVICE
:
478 val
= SCSI_TRY_RESET_DEVICE
;
480 case SG_SCSI_RESET_BUS
:
481 val
= SCSI_TRY_RESET_BUS
;
483 case SG_SCSI_RESET_HOST
:
484 val
= SCSI_TRY_RESET_HOST
;
489 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
491 return (scsi_reset_provider(sdev
, val
) ==
496 EXPORT_SYMBOL(scsi_nonblockable_ioctl
);