![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi_ioctl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to scsi_ioctl.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /*
2: * Don't import our own symbols, as this would severely mess up our
3: * symbol tables.
4: */
5: #define _SCSI_SYMS_VER_
6: #define __NO_VERSION__
7: #include <linux/module.h>
8:
9: #include <asm/io.h>
10: #include <asm/segment.h>
11: #include <asm/system.h>
12:
13: #include <linux/errno.h>
14: #include <linux/kernel.h>
15: #include <linux/sched.h>
16: #include <linux/mm.h>
17: #include <linux/string.h>
18:
19: #include <linux/blk.h>
20: #include "scsi.h"
21: #include "hosts.h"
22: #include "scsi_ioctl.h"
23:
24: #define MAX_RETRIES 5
25: #define MAX_TIMEOUT 900
26: #define MAX_BUF 4096
27:
28: #define max(a,b) (((a) > (b)) ? (a) : (b))
29:
30: /*
31: * If we are told to probe a host, we will return 0 if the host is not
32: * present, 1 if the host is present, and will return an identifying
33: * string at *arg, if arg is non null, filling to the length stored at
34: * (int *) arg
35: */
36:
37: static int ioctl_probe(struct Scsi_Host * host, void *buffer)
38: {
39: int temp, result;
40: unsigned int len,slen;
41: const char * string;
42:
43: if ((temp = host->hostt->present) && buffer) {
44: result = verify_area(VERIFY_READ, buffer, sizeof(long));
45: if (result) return result;
46:
47: len = get_user ((unsigned int *) buffer);
48: if(host->hostt->info)
49: string = host->hostt->info(host);
50: else
51: string = host->hostt->name;
52: if(string) {
53: slen = strlen(string);
54: if (len > slen)
55: len = slen + 1;
56: result = verify_area(VERIFY_WRITE, buffer, len);
57: if (result) return result;
58:
59: memcpy_tofs (buffer, string, len);
60: }
61: }
62: return temp;
63: }
64:
65: /*
66: *
67: * The SCSI_IOCTL_SEND_COMMAND ioctl sends a command out to the SCSI host.
68: * The MAX_TIMEOUT and MAX_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 no more than MAX_BUF data bytes will be transfered. Since
77: * SCSI block device size is 512 bytes, I figured 1K was good.
78: * but (WDE) changed it to 8192 to handle large bad track buffers.
79: * ERY: I changed this to a dynamic allocation using scsi_malloc - we were
80: * getting a kernel stack overflow which was crashing the system when we
81: * were using 8192 bytes.
82: *
83: * This size *does not* include the initial lengths that were passed.
84: *
85: * The SCSI command is read from the memory location immediately after the
86: * length words, and the input data is right after the command. The SCSI
87: * routines know the command size based on the opcode decode.
88: *
89: * The output area is then filled in starting from the command byte.
90: */
91:
92: static void scsi_ioctl_done (Scsi_Cmnd * SCpnt)
93: {
94: struct request * req;
95:
96: req = &SCpnt->request;
97: req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
98:
99: if (req->sem != NULL) {
100: up(req->sem);
101: }
102: }
103:
104: static int ioctl_internal_command(Scsi_Device *dev, char * cmd)
105: {
106: int result;
107: Scsi_Cmnd * SCpnt;
108:
109: SCpnt = allocate_device(NULL, dev, 1);
110: {
111: struct semaphore sem = MUTEX_LOCKED;
112: SCpnt->request.sem = &sem;
113: scsi_do_cmd(SCpnt, cmd, NULL, 0,
114: scsi_ioctl_done, MAX_TIMEOUT,
115: MAX_RETRIES);
116: down(&sem);
117: }
118:
119: if(driver_byte(SCpnt->result) != 0)
120: switch(SCpnt->sense_buffer[2] & 0xf) {
121: case ILLEGAL_REQUEST:
122: if(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
123: else printk("SCSI device (ioctl) reports ILLEGAL REQUEST.\n");
124: break;
125: case NOT_READY: /* This happens if there is no disc in drive */
126: if(dev->removable){
127: printk(KERN_INFO "Device not ready. Make sure there is a disc in the drive.\n");
128: break;
129: };
130: case UNIT_ATTENTION:
131: if (dev->removable){
132: dev->changed = 1;
133: SCpnt->result = 0; /* This is no longer considered an error */
134: printk(KERN_INFO "Disc change detected.\n");
135: break;
136: };
137: default: /* Fall through for non-removable media */
138: printk("SCSI error: host %d id %d lun %d return code = %x\n",
139: dev->host->host_no,
140: dev->id,
141: dev->lun,
142: SCpnt->result);
143: printk("\tSense class %x, sense error %x, extended sense %x\n",
144: sense_class(SCpnt->sense_buffer[0]),
145: sense_error(SCpnt->sense_buffer[0]),
146: SCpnt->sense_buffer[2] & 0xf);
147:
148: };
149:
150: result = SCpnt->result;
151: SCpnt->request.rq_status = RQ_INACTIVE;
152: wake_up(&SCpnt->device->device_wait);
153: return result;
154: }
155:
156: /*
157: * This interface is depreciated - users should use the scsi generics
158: * interface instead, as this is a more flexible approach to performing
159: * generic SCSI commands on a device.
160: */
161: static int ioctl_command(Scsi_Device *dev, void *buffer)
162: {
163: char * buf;
164: char cmd[12];
165: char * cmd_in;
166: Scsi_Cmnd * SCpnt;
167: unsigned char opcode;
168: int inlen, outlen, cmdlen;
169: int needed, buf_needed;
170: int result;
171:
172: if (!buffer)
173: return -EINVAL;
174:
175:
176: /*
177: * Verify that we can read at least this much.
178: */
179: result = verify_area(VERIFY_READ, buffer, 2*sizeof(long) + 1);
180: if (result) return result;
181:
182: /*
183: * The structure that we are passed should look like:
184: *
185: * struct sdata{
186: * int inlen;
187: * int outlen;
188: * char cmd[]; # However many bytes are used for cmd.
189: * char data[];
190: */
191: inlen = get_user((unsigned int *) buffer);
192: outlen = get_user( ((unsigned int *) buffer) + 1);
193:
194: /*
195: * We do not transfer more than MAX_BUF with this interface.
196: * If the user needs to transfer more data than this, they
197: * should use scsi_generics instead.
198: */
199: if( inlen > MAX_BUF ) inlen = MAX_BUF;
200: if( outlen > MAX_BUF ) outlen = MAX_BUF;
201:
202: cmd_in = (char *) ( ((int *)buffer) + 2);
203: opcode = get_user(cmd_in);
204:
205: needed = buf_needed = (inlen > outlen ? inlen : outlen);
206: if(buf_needed){
207: buf_needed = (buf_needed + 511) & ~511;
208: if (buf_needed > MAX_BUF) buf_needed = MAX_BUF;
209: buf = (char *) scsi_malloc(buf_needed);
210: if (!buf) return -ENOMEM;
211: memset(buf, 0, buf_needed);
212: } else
213: buf = NULL;
214:
215: /*
216: * Obtain the command from the user's address space.
217: */
218: cmdlen = COMMAND_SIZE(opcode);
219:
220: result = verify_area(VERIFY_READ, cmd_in,
221: cmdlen + inlen > MAX_BUF ? MAX_BUF : inlen);
222: if (result) return result;
223:
224: memcpy_fromfs ((void *) cmd, cmd_in, cmdlen);
225:
226: /*
227: * Obtain the data to be sent to the device (if any).
228: */
229: memcpy_fromfs ((void *) buf,
230: (void *) (cmd_in + cmdlen),
231: inlen);
232:
233: /*
234: * Set the lun field to the correct value.
235: */
236: cmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5);
237:
238: #ifndef DEBUG_NO_CMD
239:
240: SCpnt = allocate_device(NULL, dev, 1);
241:
242: {
243: struct semaphore sem = MUTEX_LOCKED;
244: SCpnt->request.sem = &sem;
245: scsi_do_cmd(SCpnt, cmd, buf, needed, scsi_ioctl_done, MAX_TIMEOUT,
246: MAX_RETRIES);
247: down(&sem);
248: }
249:
250: /*
251: * If there was an error condition, pass the info back to the user.
252: */
253: if(SCpnt->result) {
254: result = verify_area(VERIFY_WRITE,
255: cmd_in,
256: sizeof(SCpnt->sense_buffer));
257: if (result) return result;
258: memcpy_tofs((void *) cmd_in,
259: SCpnt->sense_buffer,
260: sizeof(SCpnt->sense_buffer));
261: } else {
262: result = verify_area(VERIFY_WRITE, cmd_in, outlen);
263: if (result) return result;
264: memcpy_tofs ((void *) cmd_in, buf, outlen);
265: }
266: result = SCpnt->result;
267:
268: SCpnt->request.rq_status = RQ_INACTIVE;
269:
270: if (buf) scsi_free(buf, buf_needed);
271:
272: if(SCpnt->device->scsi_request_fn)
273: (*SCpnt->device->scsi_request_fn)();
274:
275: wake_up(&SCpnt->device->device_wait);
276: return result;
277: #else
278: {
279: int i;
280: printk("scsi_ioctl : device %d. command = ", dev->id);
281: for (i = 0; i < 12; ++i)
282: printk("%02x ", cmd[i]);
283: printk("\nbuffer =");
284: for (i = 0; i < 20; ++i)
285: printk("%02x ", buf[i]);
286: printk("\n");
287: printk("inlen = %d, outlen = %d, cmdlen = %d\n",
288: inlen, outlen, cmdlen);
289: printk("buffer = %d, cmd_in = %d\n", buffer, cmd_in);
290: }
291: return 0;
292: #endif
293: }
294:
295: /*
296: * the scsi_ioctl() function differs from most ioctls in that it does
297: * not take a major/minor number as the dev filed. Rather, it takes
298: * a pointer to a scsi_devices[] element, a structure.
299: */
300: int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
301: {
302: int result;
303: char scsi_cmd[12];
304:
305: /* No idea how this happens.... */
306: if (!dev) return -ENXIO;
307:
308: switch (cmd) {
309: case SCSI_IOCTL_GET_IDLUN:
310: result = verify_area(VERIFY_WRITE, (void *) arg, 2*sizeof(long));
311: if (result) return result;
312:
313: put_user(dev->id
314: + (dev->lun << 8)
315: + (dev->channel << 16)
316: + ((dev->host->hostt->proc_dir->low_ino & 0xff) << 24),
317: (unsigned long *) arg);
318: put_user( dev->host->unique_id, (unsigned long *) arg+1);
319: return 0;
320: case SCSI_IOCTL_TAGGED_ENABLE:
321: if(!suser()) return -EACCES;
322: if(!dev->tagged_supported) return -EINVAL;
323: dev->tagged_queue = 1;
324: dev->current_tag = 1;
325: break;
326: case SCSI_IOCTL_TAGGED_DISABLE:
327: if(!suser()) return -EACCES;
328: if(!dev->tagged_supported) return -EINVAL;
329: dev->tagged_queue = 0;
330: dev->current_tag = 0;
331: break;
332: case SCSI_IOCTL_PROBE_HOST:
333: return ioctl_probe(dev->host, arg);
334: case SCSI_IOCTL_SEND_COMMAND:
335: if(!suser()) return -EACCES;
336: return ioctl_command((Scsi_Device *) dev, arg);
337: case SCSI_IOCTL_DOORLOCK:
338: if (!dev->removable || !dev->lockable) return 0;
339: scsi_cmd[0] = ALLOW_MEDIUM_REMOVAL;
340: scsi_cmd[1] = dev->lun << 5;
341: scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
342: scsi_cmd[4] = SCSI_REMOVAL_PREVENT;
343: return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
344: break;
345: case SCSI_IOCTL_DOORUNLOCK:
346: if (!dev->removable || !dev->lockable) return 0;
347: scsi_cmd[0] = ALLOW_MEDIUM_REMOVAL;
348: scsi_cmd[1] = dev->lun << 5;
349: scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
350: scsi_cmd[4] = SCSI_REMOVAL_ALLOW;
351: return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
352: case SCSI_IOCTL_TEST_UNIT_READY:
353: scsi_cmd[0] = TEST_UNIT_READY;
354: scsi_cmd[1] = dev->lun << 5;
355: scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
356: scsi_cmd[4] = 0;
357: return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
358: break;
359: default :
360: return -EINVAL;
361: }
362: return -EINVAL;
363: }
364:
365: /*
366: * Just like scsi_ioctl, only callable from kernel space with no
367: * fs segment fiddling.
368: */
369:
370: int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) {
371: unsigned long oldfs;
372: int tmp;
373: oldfs = get_fs();
374: set_fs(get_ds());
375: tmp = scsi_ioctl (dev, cmd, arg);
376: set_fs(oldfs);
377: return tmp;
378: }
379:
380: /*
381: * Overrides for Emacs so that we almost follow Linus's tabbing style.
382: * Emacs will notice this stuff at the end of the file and automatically
383: * adjust the settings for this buffer only. This must remain at the end
384: * of the file.
385: * ---------------------------------------------------------------------------
386: * Local variables:
387: * c-indent-level: 4
388: * c-brace-imaginary-offset: 0
389: * c-brace-offset: -4
390: * c-argdecl-indent: 4
391: * c-label-offset: -4
392: * c-continued-statement-offset: 4
393: * c-continued-brace-offset: 0
394: * indent-tabs-mode: nil
395: * tab-width: 8
396: * End:
397: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.