?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.4.0-test9
[davej-history.git] / drivers / scsi / sg.c
blob6d5b92f1fbef0bb19d0f03ba6f59d9562f46fcd0
1 /*
2 * History:
3 * Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
4 * to allow user process control of SCSI devices.
5 * Development Sponsored by Killy Corp. NY NY
6 *
7 * Original driver (sg.c):
8 * Copyright (C) 1992 Lawrence Foard
9 * Version 2 and 3 extensions to driver:
10 * Copyright (C) 1998 - 2000 Douglas Gilbert
11 *
12 * Modified 19-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
17 * any later version.
18 *
19 */
20 #include <linux/config.h>
21 #ifdef CONFIG_PROC_FS
22 static char * sg_version_str = "Version: 3.1.17 (20001002)";
23 #endif
24 static int sg_version_num = 30117; /* 2 digits for each component */
25 /*
26 * D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes:
27 * - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
28 * the kernel/module needs to be built with CONFIG_SCSI_LOGGING
29 * (otherwise the macros compile to empty statements).
30 * Then before running the program to be debugged enter:
31 * # echo "scsi log timeout 7" > /proc/scsi/scsi
32 * This will send copious output to the console and the log which
33 * is usually /var/log/messages. To turn off debugging enter:
34 * # echo "scsi log timeout 0" > /proc/scsi/scsi
35 * The 'timeout' token was chosen because it is relatively unused.
36 * The token 'hlcomplete' should be used but that triggers too
37 * much output from the sd device driver. To dump the current
38 * state of the SCSI mid level data structures enter:
39 * # echo "scsi dump 1" > /proc/scsi/scsi
40 * To dump the state of sg's data structures use:
41 * # cat /proc/scsi/sg/debug
42 *
43 */
44 #include <linux/module.h>
45
46 #include <linux/fs.h>
47 #include <linux/kernel.h>
48 #include <linux/sched.h>
49 #include <linux/string.h>
50 #include <linux/mm.h>
51 #include <linux/errno.h>
52 #include <linux/mtio.h>
53 #include <linux/ioctl.h>
54 #include <linux/fcntl.h>
55 #include <linux/init.h>
56 #include <linux/poll.h>
57 #include <linux/smp_lock.h>
58
59 #include <asm/io.h>
60 #include <asm/uaccess.h>
61 #include <asm/system.h>
62
63 #include <linux/blk.h>
64 #include "scsi.h"
65 #include "hosts.h"
66 #include <scsi/scsi_ioctl.h>
67 #include <scsi/sg.h>
68
69 #ifdef CONFIG_PROC_FS
70 #include <linux/proc_fs.h>
71 static int sg_proc_init(void);
72 static void sg_proc_cleanup(void);
73 #endif
74
75 #ifndef LINUX_VERSION_CODE
76 #include <linux/version.h>
77 #endif /* LINUX_VERSION_CODE */
78
79 /* #define SG_ALLOW_DIO */
80 #ifdef SG_ALLOW_DIO
81 #include <linux/iobuf.h>
82 #endif
83
84 int sg_big_buff = SG_DEF_RESERVED_SIZE;
85 /* N.B. This variable is readable and writeable via
86 /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
87 of this size (or less if there is not enough memory) will be reserved
88 for use by this file descriptor. [Deprecated usage: this variable is also
89 readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
90 the kernel (i.e. it is not a module).] */
91 static int def_reserved_size = -1; /* picks up init parameter */
92
93 #define SG_SECTOR_SZ 512
94 #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1)
95
96 #define SG_LOW_POOL_THRESHHOLD 30
97 #define SG_MAX_POOL_SECTORS 320 /* Max. number of pool sectors to take */
98
99 static int sg_pool_secs_avail = SG_MAX_POOL_SECTORS;
100
101 #define SG_HEAP_PAGE 1 /* heap from kernel via get_free_pages() */
102 #define SG_HEAP_KMAL 2 /* heap from kernel via kmalloc() */
103 #define SG_HEAP_POOL 3 /* heap from scsi dma pool (mid-level) */
104 #define SG_USER_MEM 4 /* memory belongs to user space */
105
106 #define SG_DEV_ARR_LUMP 6 /* amount to over allocate sg_dev_arr by */
107
108
109 static int sg_init(void);
110 static int sg_attach(Scsi_Device *);
111 static void sg_finish(void);
112 static int sg_detect(Scsi_Device *);
113 static void sg_detach(Scsi_Device *);
114
115 static Scsi_Request * dummy_cmdp = 0; /* only used for sizeof */
116
117 static rwlock_t sg_dev_arr_lock = RW_LOCK_UNLOCKED; /* Also used to lock
118 file descriptor list for device */
119
120 static struct Scsi_Device_Template sg_template =
121 {
122 tag:"sg",
123 scsi_type:0xff,
124 major:SCSI_GENERIC_MAJOR,
125 detect:sg_detect,
126 init:sg_init,
127 finish:sg_finish,
128 attach:sg_attach,
129 detach:sg_detach
130 };
131
132
133 typedef struct sg_scatter_hold /* holding area for scsi scatter gather info */
134 {
135 unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
136 unsigned short sglist_len; /* size of malloc'd scatter-gather list */
137 unsigned bufflen; /* Size of (aggregate) data buffer */
138 unsigned b_malloc_len; /* actual len malloc'ed in buffer */
139 void * buffer; /* Data buffer or scatter list,12 bytes each*/
140 struct kiobuf * kiobp; /* for direct IO information */
141 char mapped; /* indicates kiobp has locked pages */
142 char buffer_mem_src; /* heap whereabouts of 'buffer' */
143 unsigned char cmd_opcode; /* first byte of command */
144 } Sg_scatter_hold; /* 24 bytes long on i386 */
145
146 struct sg_device; /* forward declarations */
147 struct sg_fd;
148
149 typedef struct sg_request /* SG_MAX_QUEUE requests outstanding per file */
150 {
151 Scsi_Request * my_cmdp; /* != 0 when request with lower levels */
152 struct sg_request * nextrp; /* NULL -> tail request (slist) */
153 struct sg_fd * parentfp; /* NULL -> not in use */
154 Sg_scatter_hold data; /* hold buffer, perhaps scatter list */
155 sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */
156 unsigned char sense_b[sizeof(dummy_cmdp->sr_sense_buffer)];
157 char res_used; /* 1 -> using reserve buffer, 0 -> not ... */
158 char orphan; /* 1 -> drop on sight, 0 -> normal */
159 char sg_io_owned; /* 1 -> packet belongs to SG_IO */
160 char done; /* 0->before bh, 1->before read, 2->read */
161 } Sg_request; /* 168 bytes long on i386 */
162
163 typedef struct sg_fd /* holds the state of a file descriptor */
164 {
165 struct sg_fd * nextfp; /* NULL when last opened fd on this device */
166 struct sg_device * parentdp; /* owning device */
167 wait_queue_head_t read_wait; /* queue read until command done */
168 rwlock_t rq_list_lock; /* protect access to list in req_arr */
169 int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
170 Sg_scatter_hold reserve; /* buffer held for this file descriptor */
171 unsigned save_scat_len; /* original length of trunc. scat. element */
172 Sg_request * headrp; /* head of request slist, NULL->empty */
173 struct fasync_struct * async_qp; /* used by asynchronous notification */
174 Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */
175 char low_dma; /* as in parent but possibly overridden to 1 */
176 char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */
177 char closed; /* 1 -> fd closed but request(s) outstanding */
178 char fd_mem_src; /* heap whereabouts of this Sg_fd object */
179 char cmd_q; /* 1 -> allow command queuing, 0 -> don't */
180 char next_cmd_len; /* 0 -> automatic (def), >0 -> use on next write() */
181 char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */
182 } Sg_fd; /* 2768 bytes long on i386 */
183
184 typedef struct sg_device /* holds the state of each scsi generic device */
185 {
186 Scsi_Device * device;
187 wait_queue_head_t o_excl_wait; /* queue open() when O_EXCL in use */
188 int sg_tablesize; /* adapter's max scatter-gather table size */
189 Sg_fd * headfp; /* first open fd belonging to this device */
190 devfs_handle_t de;
191 kdev_t i_rdev; /* holds device major+minor number */
192 char exclude; /* opened for exclusive access */
193 char sgdebug; /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
194 char detached; /* 0->attached, 1->detached pending removal */
195 } Sg_device; /* 44 bytes long on i386 */
196
197
198 static int sg_fasync(int fd, struct file * filp, int mode);
199 static void sg_cmd_done_bh(Scsi_Cmnd * SCpnt);
200 static int sg_start_req(Sg_request * srp);
201 static void sg_finish_rem_req(Sg_request * srp);
202 static int sg_build_indi(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
203 static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp);
204 static ssize_t sg_new_read(Sg_fd * sfp, char * buf, size_t count,
205 Sg_request * srp);
206 static ssize_t sg_new_write(Sg_fd * sfp, const char * buf, size_t count,
207 int blocking, int read_only, Sg_request ** o_srp);
208 static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
209 unsigned char * cmnd, int timeout, int blocking);
210 static int sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
211 int wr_xf, int * countp, unsigned char ** up);
212 static int sg_write_xfer(Sg_request * srp);
213 static int sg_read_xfer(Sg_request * srp);
214 static void sg_read_oxfer(Sg_request * srp, char * outp, int num_read_xfer);
215 static void sg_remove_scat(Sg_scatter_hold * schp);
216 static char * sg_get_sgat_msa(Sg_scatter_hold * schp);
217 static void sg_build_reserve(Sg_fd * sfp, int req_size);
218 static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
219 static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
220 static char * sg_malloc(const Sg_fd * sfp, int size, int * retSzp,
221 int * mem_srcp);
222 static void sg_free(char * buff, int size, int mem_src);
223 static char * sg_low_malloc(int rqSz, int lowDma, int mem_src,
224 int * retSzp);
225 static void sg_low_free(char * buff, int size, int mem_src);
226 static Sg_fd * sg_add_sfp(Sg_device * sdp, int dev);
227 static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp);
228 static Sg_request * sg_get_rq_mark(Sg_fd * sfp, int pack_id);
229 static Sg_request * sg_add_request(Sg_fd * sfp);
230 static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
231 static int sg_res_in_use(Sg_fd * sfp);
232 static int sg_dio_in_use(Sg_fd * sfp);
233 static void sg_clr_srpnt(Scsi_Request * SRpnt);
234 static void sg_shorten_timeout(Scsi_Request * srpnt);
235 static int sg_ms_to_jif(unsigned int msecs);
236 static unsigned sg_jif_to_ms(int jifs);
237 static int sg_allow_access(unsigned char opcode, char dev_type);
238 static int sg_build_dir(Sg_request * srp, Sg_fd * sfp, int dxfer_len);
239 static void sg_unmap_and(Sg_scatter_hold * schp, int free_also);
240 static Sg_device * sg_get_dev(int dev);
241 #ifdef CONFIG_PROC_FS
242 static int sg_last_dev(void);
243 #endif
244
245 static Sg_device ** sg_dev_arr = NULL;
246
247 static const int size_sg_header = sizeof(struct sg_header);
248 static const int size_sg_io_hdr = sizeof(sg_io_hdr_t);
249 static const int size_sg_iovec = sizeof(sg_iovec_t);
250 static const int size_sg_req_info = sizeof(sg_req_info_t);
251
252
253 static int sg_open(struct inode * inode, struct file * filp)
254 {
255 int dev = MINOR(inode->i_rdev);
256 int flags = filp->f_flags;
257 Sg_device * sdp;
258 Sg_fd * sfp;
259 int res;
260
261 sdp = sg_get_dev(dev);
262 if ((! sdp) || (! sdp->device) || (! sdp->device->host))
263 return -ENXIO;
264 if (sdp->i_rdev != inode->i_rdev)
265 printk("sg_open: inode maj=%d, min=%d sdp maj=%d, min=%d\n",
266 MAJOR(inode->i_rdev), MINOR(inode->i_rdev),
267 MAJOR(sdp->i_rdev), MINOR(sdp->i_rdev));
268 /* If we are in the middle of error recovery, don't let anyone
269 * else try and use this device. Also, if error recovery fails, it
270 * may try and take the device offline, in which case all further
271 * access to the device is prohibited. */
272 if (! ((flags & O_NONBLOCK) ||
273 scsi_block_when_processing_errors(sdp->device)))
274 return -ENXIO;
275
276 SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
277
278 if (flags & O_EXCL) {
279 if (O_RDONLY == (flags & O_ACCMODE))
280 return -EACCES; /* Can't lock it with read only access */
281 if (sdp->headfp && (flags & O_NONBLOCK))
282 return -EBUSY;
283 res = 0; /* following is a macro that beats race condition */
284 __wait_event_interruptible(sdp->o_excl_wait,
285 ((sdp->headfp || sdp->exclude) ? 0 : (sdp->exclude = 1)),
286 res);
287 if (res)
288 return res; /* -ERESTARTSYS because signal hit process */
289 }
290 else if (sdp->exclude) { /* some other fd has an exclusive lock on dev */
291 if (flags & O_NONBLOCK)
292 return -EBUSY;
293 res = 0; /* following is a macro that beats race condition */
294 __wait_event_interruptible(sdp->o_excl_wait, (! sdp->exclude), res);
295 if (res)
296 return res; /* -ERESTARTSYS because signal hit process */
297 }
298 if (! sdp->headfp) { /* no existing opens on this device */
299 sdp->sgdebug = 0;
300 sdp->sg_tablesize = sdp->device->host->sg_tablesize;
301 }
302 if ((sfp = sg_add_sfp(sdp, dev)))
303 filp->private_data = sfp;
304 else {
305 if (flags & O_EXCL) sdp->exclude = 0; /* undo if error */
306 return -ENOMEM;
307 }
308
309 if (sdp->device->host->hostt->module)
310 __MOD_INC_USE_COUNT(sdp->device->host->hostt->module);
311 return 0;
312 }
313
314 /* Following function was formerly called 'sg_close' */
315 static int sg_release(struct inode * inode, struct file * filp)
316 {
317 Sg_device * sdp;
318 Sg_fd * sfp;
319
320 lock_kernel();
321 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp))) {
322 unlock_kernel();
323 return -ENXIO;
324 }
325 SCSI_LOG_TIMEOUT(3, printk("sg_release: dev=%d\n", MINOR(sdp->i_rdev)));
326 sg_fasync(-1, filp, 0); /* remove filp from async notification list */
327 sg_remove_sfp(sdp, sfp);
328 if (! sdp->headfp)
329 filp->private_data = NULL;
330
331 if (sdp->device->host->hostt->module)
332 __MOD_DEC_USE_COUNT(sdp->device->host->hostt->module);
333 sdp->exclude = 0;
334 wake_up_interruptible(&sdp->o_excl_wait);
335 unlock_kernel();
336 return 0;
337 }
338
339 static ssize_t sg_read(struct file * filp, char * buf,
340 size_t count, loff_t *ppos)
341 {
342 int k, res;
343 Sg_device * sdp;
344 Sg_fd * sfp;
345 Sg_request * srp;
346 int req_pack_id = -1;
347 struct sg_header old_hdr;
348 sg_io_hdr_t new_hdr;
349 sg_io_hdr_t * hp;
350
351 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
352 return -ENXIO;
353 SCSI_LOG_TIMEOUT(3, printk("sg_read: dev=%d, count=%d\n",
354 MINOR(sdp->i_rdev), (int)count));
355 if (ppos != &filp->f_pos)
356 ; /* FIXME: Hmm. Seek to the right place, or fail? */
357 if ((k = verify_area(VERIFY_WRITE, buf, count)))
358 return k;
359 if (sfp->force_packid && (count >= size_sg_header)) {
360 __copy_from_user(&old_hdr, buf, size_sg_header);
361 if (old_hdr.reply_len < 0) {
362 if (count >= size_sg_io_hdr) {
363 __copy_from_user(&new_hdr, buf, size_sg_io_hdr);
364 req_pack_id = new_hdr.pack_id;
365 }
366 }
367 else
368 req_pack_id = old_hdr.pack_id;
369 }
370 srp = sg_get_rq_mark(sfp, req_pack_id);
371 if (! srp) { /* now wait on packet to arrive */
372 if (filp->f_flags & O_NONBLOCK)
373 return -EAGAIN;
374 while (1) {
375 int dio = sg_dio_in_use(sfp);
376 res = 0; /* following is a macro that beats race condition */
377 __wait_event_interruptible(sfp->read_wait,
378 (srp = sg_get_rq_mark(sfp, req_pack_id)),
379 res);
380 if (0 == res)
381 break;
382 else if (! dio) /* only let signal out if no dio */
383 return res; /* -ERESTARTSYS because signal hit process */
384 }
385 }
386 if (srp->header.interface_id != '\0')
387 return sg_new_read(sfp, buf, count, srp);
388
389 hp = &srp->header;
390 memset(&old_hdr, 0, size_sg_header);
391 old_hdr.reply_len = (int)hp->timeout;
392 old_hdr.pack_len = old_hdr.reply_len; /* very old, strange behaviour */
393 old_hdr.pack_id = hp->pack_id;
394 old_hdr.twelve_byte =
395 ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
396 old_hdr.target_status = hp->masked_status;
397 old_hdr.host_status = hp->host_status;
398 old_hdr.driver_status = hp->driver_status;
399 if ((CHECK_CONDITION & hp->masked_status) ||
400 (DRIVER_SENSE & hp->driver_status))
401 memcpy(old_hdr.sense_buffer, srp->sense_b,
402 sizeof(old_hdr.sense_buffer));
403 switch (hp->host_status)
404 { /* This setup of 'result' is for backward compatibility and is best
405 ignored by the user who should use target, host + driver status */
406 case DID_OK:
407 case DID_PASSTHROUGH:
408 case DID_SOFT_ERROR:
409 old_hdr.result = 0;
410 break;
411 case DID_NO_CONNECT:
412 case DID_BUS_BUSY:
413 case DID_TIME_OUT:
414 old_hdr.result = EBUSY;
415 break;
416 case DID_BAD_TARGET:
417 case DID_ABORT:
418 case DID_PARITY:
419 case DID_RESET:
420 case DID_BAD_INTR:
421 old_hdr.result = EIO;
422 break;
423 case DID_ERROR:
424 old_hdr.result =
425 (srp->sense_b[0] == 0 && hp->masked_status == GOOD) ? 0 : EIO;
426 break;
427 default:
428 old_hdr.result = EIO;
429 break;
430 }
431
432 /* Now copy the result back to the user buffer. */
433 if (count >= size_sg_header) {
434 __copy_to_user(buf, &old_hdr, size_sg_header);
435 buf += size_sg_header;
436 if (count > old_hdr.reply_len)
437 count = old_hdr.reply_len;
438 if (count > size_sg_header)
439 sg_read_oxfer(srp, buf, count - size_sg_header);
440 }
441 else
442 count = (old_hdr.result == 0) ? 0 : -EIO;
443 sg_finish_rem_req(srp);
444 return count;
445 }
446
447 static ssize_t sg_new_read(Sg_fd * sfp, char * buf, size_t count,
448 Sg_request * srp)
449 {
450 sg_io_hdr_t * hp = &srp->header;
451 int k, len;
452
453 if (count < size_sg_io_hdr)
454 return -EINVAL;
455 hp->sb_len_wr = 0;
456 if ((hp->mx_sb_len > 0) && hp->sbp) {
457 if ((CHECK_CONDITION & hp->masked_status) ||
458 (DRIVER_SENSE & hp->driver_status)) {
459 int sb_len = sizeof(dummy_cmdp->sr_sense_buffer);
460 sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
461 len = 8 + (int)srp->sense_b[7]; /* Additional sense length field */
462 len = (len > sb_len) ? sb_len : len;
463 if ((k = verify_area(VERIFY_WRITE, hp->sbp, len)))
464 return k;
465 __copy_to_user(hp->sbp, srp->sense_b, len);
466 hp->sb_len_wr = len;
467 }
468 }
469 if (hp->masked_status || hp->host_status || hp->driver_status)
470 hp->info |= SG_INFO_CHECK;
471 copy_to_user(buf, hp, size_sg_io_hdr);
472
473 k = sg_read_xfer(srp);
474 if (k) return k; /* probably -EFAULT, bad addr in dxferp or iovec list */
475 sg_finish_rem_req(srp);
476 return count;
477 }
478
479
480 static ssize_t sg_write(struct file * filp, const char * buf,
481 size_t count, loff_t *ppos)
482 {
483 int mxsize, cmd_size, k;
484 int input_size, blocking;
485 unsigned char opcode;
486 Sg_device * sdp;
487 Sg_fd * sfp;
488 Sg_request * srp;
489 struct sg_header old_hdr;
490 sg_io_hdr_t * hp;
491 unsigned char cmnd[sizeof(dummy_cmdp->sr_cmnd)];
492
493 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
494 return -ENXIO;
495 SCSI_LOG_TIMEOUT(3, printk("sg_write: dev=%d, count=%d\n",
496 MINOR(sdp->i_rdev), (int)count));
497
498 if (! ((filp->f_flags & O_NONBLOCK) ||
499 scsi_block_when_processing_errors(sdp->device)))
500 return -ENXIO;
501 if (ppos != &filp->f_pos)
502 ; /* FIXME: Hmm. Seek to the right place, or fail? */
503
504 if ((k = verify_area(VERIFY_READ, buf, count)))
505 return k; /* protects following copy_from_user()s + get_user()s */
506 if (count < size_sg_header)
507 return -EIO;
508 __copy_from_user(&old_hdr, buf, size_sg_header);
509 blocking = !(filp->f_flags & O_NONBLOCK);
510 if (old_hdr.reply_len < 0)
511 return sg_new_write(sfp, buf, count, blocking, 0, NULL);
512 if (count < (size_sg_header + 6))
513 return -EIO; /* The minimum scsi command length is 6 bytes. */
514
515 if (! (srp = sg_add_request(sfp))) {
516 SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n"));
517 return -EDOM;
518 }
519 buf += size_sg_header;
520 __get_user(opcode, buf);
521 if (sfp->next_cmd_len > 0) {
522 if (sfp->next_cmd_len > MAX_COMMAND_SIZE) {
523 SCSI_LOG_TIMEOUT(1, printk("sg_write: command length too long\n"));
524 sfp->next_cmd_len = 0;
525 sg_remove_request(sfp, srp);
526 return -EIO;
527 }
528 cmd_size = sfp->next_cmd_len;
529 sfp->next_cmd_len = 0; /* reset so only this write() effected */
530 }
531 else {
532 cmd_size = COMMAND_SIZE(opcode); /* based on SCSI command group */
533 if ((opcode >= 0xc0) && old_hdr.twelve_byte)
534 cmd_size = 12;
535 }
536 SCSI_LOG_TIMEOUT(4, printk("sg_write: scsi opcode=0x%02x, cmd_size=%d\n",
537 (int)opcode, cmd_size));
538 /* Determine buffer size. */
539 input_size = count - cmd_size;
540 mxsize = (input_size > old_hdr.reply_len) ? input_size :
541 old_hdr.reply_len;
542 mxsize -= size_sg_header;
543 input_size -= size_sg_header;
544 if (input_size < 0) {
545 sg_remove_request(sfp, srp);
546 return -EIO; /* User did not pass enough bytes for this command. */
547 }
548 hp = &srp->header;
549 hp->interface_id = '\0'; /* indicator of old interface tunnelled */
550 hp->cmd_len = (unsigned char)cmd_size;
551 hp->iovec_count = 0;
552 hp->mx_sb_len = 0;
553 #if 0
554 hp->dxfer_direction = SG_DXFER_UNKNOWN;
555 #else
556 if (input_size > 0)
557 hp->dxfer_direction = ((old_hdr.reply_len - size_sg_header) > 0) ?
558 SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
559 else
560 hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV :
561 SG_DXFER_NONE;
562 #endif
563 hp->dxfer_len = mxsize;
564 hp->dxferp = (unsigned char *)buf + cmd_size;
565 hp->sbp = NULL;
566 hp->timeout = old_hdr.reply_len; /* structure abuse ... */
567 hp->flags = input_size; /* structure abuse ... */
568 hp->pack_id = old_hdr.pack_id;
569 hp->usr_ptr = NULL;
570 __copy_from_user(cmnd, buf, cmd_size);
571 k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
572 return (k < 0) ? k : count;
573 }
574
575 static ssize_t sg_new_write(Sg_fd * sfp, const char * buf, size_t count,
576 int blocking, int read_only, Sg_request ** o_srp)
577 {
578 int k;
579 Sg_request * srp;
580 sg_io_hdr_t * hp;
581 unsigned char cmnd[sizeof(dummy_cmdp->sr_cmnd)];
582 int timeout;
583
584 if (count < size_sg_io_hdr)
585 return -EINVAL;
586 if ((k = verify_area(VERIFY_READ, buf, count)))
587 return k; /* protects following copy_from_user()s + get_user()s */
588
589 sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
590 if (! (srp = sg_add_request(sfp))) {
591 SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n"));
592 return -EDOM;
593 }
594 hp = &srp->header;
595 __copy_from_user(hp, buf, size_sg_io_hdr);
596 if (hp->interface_id != 'S') {
597 sg_remove_request(sfp, srp);
598 return -ENOSYS;
599 }
600 timeout = sg_ms_to_jif(srp->header.timeout);
601 if ((! hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof(cmnd))) {
602 sg_remove_request(sfp, srp);
603 return -EMSGSIZE;
604 }
605 if ((k = verify_area(VERIFY_READ, hp->cmdp, hp->cmd_len))) {
606 sg_remove_request(sfp, srp);
607 return k; /* protects following copy_from_user()s + get_user()s */
608 }
609 __copy_from_user(cmnd, hp->cmdp, hp->cmd_len);
610 if (read_only &&
611 (! sg_allow_access(cmnd[0], sfp->parentdp->device->type))) {
612 sg_remove_request(sfp, srp);
613 return -EACCES;
614 }
615 k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
616 if (k < 0) return k;
617 if (o_srp) *o_srp = srp;
618 return count;
619 }
620
621 static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
622 unsigned char * cmnd, int timeout, int blocking)
623 {
624 int k;
625 Scsi_Request * SRpnt;
626 Sg_device * sdp = sfp->parentdp;
627 sg_io_hdr_t * hp = &srp->header;
628
629 srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
630 hp->status = 0;
631 hp->masked_status = 0;
632 hp->msg_status = 0;
633 hp->info = 0;
634 hp->host_status = 0;
635 hp->driver_status = 0;
636 hp->resid = 0;
637 SCSI_LOG_TIMEOUT(4,
638 printk("sg_common_write: scsi opcode=0x%02x, cmd_size=%d\n",
639 (int)cmnd[0], (int)hp->cmd_len));
640
641 if ((k = sg_start_req(srp))) {
642 SCSI_LOG_TIMEOUT(1, printk("sg_write: start_req err=%d\n", k));
643 sg_finish_rem_req(srp);
644 return k; /* probably out of space --> ENOMEM */
645 }
646 if ((k = sg_write_xfer(srp))) {
647 SCSI_LOG_TIMEOUT(1, printk("sg_write: write_xfer, bad address\n"));
648 sg_finish_rem_req(srp);
649 return k;
650 }
651 /* SCSI_LOG_TIMEOUT(7, printk("sg_write: allocating device\n")); */
652 SRpnt = scsi_allocate_request(sdp->device);
653
654 /* SCSI_LOG_TIMEOUT(7, printk("sg_write: device allocated\n")); */
655 srp->my_cmdp = SRpnt;
656 SRpnt->sr_request.rq_dev = sdp->i_rdev;
657 SRpnt->sr_request.rq_status = RQ_ACTIVE;
658 SRpnt->sr_sense_buffer[0] = 0;
659 SRpnt->sr_cmd_len = hp->cmd_len;
660 /* Set the LUN field in the command structure, overriding user input */
661 if (! (hp->flags & SG_FLAG_LUN_INHIBIT))
662 cmnd[1] = (cmnd[1] & 0x1f) | (sdp->device->lun << 5);
663
664 /* SCSI_LOG_TIMEOUT(7, printk("sg_write: do cmd\n")); */
665 SRpnt->sr_use_sg = srp->data.k_use_sg;
666 SRpnt->sr_sglist_len = srp->data.sglist_len;
667 SRpnt->sr_bufflen = srp->data.bufflen;
668 SRpnt->sr_underflow = 0;
669 SRpnt->sr_buffer = srp->data.buffer;
670 switch (hp->dxfer_direction) {
671 case SG_DXFER_TO_FROM_DEV:
672 case SG_DXFER_FROM_DEV:
673 SRpnt->sr_data_direction = SCSI_DATA_READ; break;
674 case SG_DXFER_TO_DEV:
675 SRpnt->sr_data_direction = SCSI_DATA_WRITE; break;
676 case SG_DXFER_UNKNOWN:
677 SRpnt->sr_data_direction = SCSI_DATA_UNKNOWN; break;
678 default:
679 SRpnt->sr_data_direction = SCSI_DATA_NONE; break;
680 }
681 srp->data.k_use_sg = 0;
682 srp->data.sglist_len = 0;
683 srp->data.bufflen = 0;
684 srp->data.buffer = NULL;
685 hp->duration = jiffies; /* unit jiffies now, millisecs after done */
686 /* Now send everything of to mid-level. The next time we hear about this
687 packet is when sg_cmd_done_bh() is called (i.e. a callback). */
688 scsi_do_req(SRpnt, (void *)cmnd,
689 (void *)SRpnt->sr_buffer, hp->dxfer_len,
690 sg_cmd_done_bh, timeout, SG_DEFAULT_RETRIES);
691 /* dxfer_len overwrites SRpnt->sr_bufflen, hence need for b_malloc_len */
692 return 0;
693 }
694
695 static int sg_ioctl(struct inode * inode, struct file * filp,
696 unsigned int cmd_in, unsigned long arg)
697 {
698 int result, val, read_only;
699 Sg_device * sdp;
700 Sg_fd * sfp;
701 Sg_request * srp;
702 unsigned long iflags;
703
704 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
705 return -ENXIO;
706 SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: dev=%d, cmd=0x%x\n",
707 MINOR(sdp->i_rdev), (int)cmd_in));
708 read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
709
710 switch(cmd_in)
711 {
712 case SG_IO:
713 {
714 int blocking = 1; /* ignore O_NONBLOCK flag */
715
716 if(! scsi_block_when_processing_errors(sdp->device) )
717 return -ENXIO;
718 result = verify_area(VERIFY_WRITE, (void *)arg, size_sg_io_hdr);
719 if (result) return result;
720 result = sg_new_write(sfp, (const char *)arg, size_sg_io_hdr,
721 blocking, read_only, &srp);
722 if (result < 0) return result;
723 srp->sg_io_owned = 1;
724 while (1) {
725 int dio = sg_dio_in_use(sfp);
726 result = 0; /* following macro to beat race condition */
727 __wait_event_interruptible(sfp->read_wait,
728 (sfp->closed || srp->done), result);
729 if (sfp->closed)
730 return 0; /* request packet dropped already */
731 if (0 == result)
732 break;
733 else if (! dio) { /* only let signal out if no dio */
734 srp->orphan = 1;
735 return result; /* -ERESTARTSYS because signal hit process */
736 }
737 }
738 srp->done = 2;
739 result = sg_new_read(sfp, (char *)arg, size_sg_io_hdr, srp);
740 return (result < 0) ? result : 0;
741 }
742 case SG_SET_TIMEOUT:
743 result = get_user(val, (int *)arg);
744 if (result) return result;
745 if (val < 0)
746 return -EIO;
747 sfp->timeout = val;
748 return 0;
749 case SG_GET_TIMEOUT: /* N.B. User receives timeout as return value */
750 return sfp->timeout; /* strange ..., for backward compatibility */
751 case SG_SET_FORCE_LOW_DMA:
752 result = get_user(val, (int *)arg);
753 if (result) return result;
754 if (val) {
755 sfp->low_dma = 1;
756 if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
757 val = (int)sfp->reserve.bufflen;
758 sg_remove_scat(&sfp->reserve);
759 sg_build_reserve(sfp, val);
760 }
761 }
762 else
763 sfp->low_dma = sdp->device->host->unchecked_isa_dma;
764 return 0;
765 case SG_GET_LOW_DMA:
766 return put_user((int)sfp->low_dma, (int *)arg);
767 case SG_GET_SCSI_ID:
768 result = verify_area(VERIFY_WRITE, (void *)arg, sizeof(sg_scsi_id_t));
769 if (result) return result;
770 else {
771 sg_scsi_id_t * sg_idp = (sg_scsi_id_t *)arg;
772 __put_user((int)sdp->device->host->host_no, &sg_idp->host_no);
773 __put_user((int)sdp->device->channel, &sg_idp->channel);
774 __put_user((int)sdp->device->id, &sg_idp->scsi_id);
775 __put_user((int)sdp->device->lun, &sg_idp->lun);
776 __put_user((int)sdp->device->type, &sg_idp->scsi_type);
777 __put_user((short)sdp->device->host->cmd_per_lun,
778 &sg_idp->h_cmd_per_lun);
779 __put_user((short)sdp->device->queue_depth,
780 &sg_idp->d_queue_depth);
781 __put_user(0, &sg_idp->unused[0]);
782 __put_user(0, &sg_idp->unused[1]);
783 return 0;
784 }
785 case SG_SET_FORCE_PACK_ID:
786 result = get_user(val, (int *)arg);
787 if (result) return result;
788 sfp->force_packid = val ? 1 : 0;
789 return 0;
790 case SG_GET_PACK_ID:
791 result = verify_area(VERIFY_WRITE, (void *) arg, sizeof(int));
792 if (result) return result;
793 read_lock_irqsave(&sfp->rq_list_lock, iflags);
794 for (srp = sfp->headrp; srp; srp = srp->nextrp) {
795 if ((1 == srp->done) && (! srp->sg_io_owned)) {
796 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
797 __put_user(srp->header.pack_id, (int *)arg);
798 return 0;
799 }
800 }
801 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
802 __put_user(-1, (int *)arg);
803 return 0;
804 case SG_GET_NUM_WAITING:
805 read_lock_irqsave(&sfp->rq_list_lock, iflags);
806 for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
807 if ((1 == srp->done) && (! srp->sg_io_owned))
808 ++val;
809 }
810 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
811 return put_user(val, (int *)arg);
812 case SG_GET_SG_TABLESIZE:
813 return put_user(sdp->sg_tablesize, (int *)arg);
814 case SG_SET_RESERVED_SIZE:
815 result = get_user(val, (int *)arg);
816 if (result) return result;
817 if (val != sfp->reserve.bufflen) {
818 if (sg_res_in_use(sfp))
819 return -EBUSY;
820 sg_remove_scat(&sfp->reserve);
821 sg_build_reserve(sfp, val);
822 }
823 return 0;
824 case SG_GET_RESERVED_SIZE:
825 val = (int)sfp->reserve.bufflen;
826 return put_user(val, (int *)arg);
827 case SG_SET_COMMAND_Q:
828 result = get_user(val, (int *)arg);
829 if (result) return result;
830 sfp->cmd_q = val ? 1 : 0;
831 return 0;
832 case SG_GET_COMMAND_Q:
833 return put_user((int)sfp->cmd_q, (int *)arg);
834 case SG_SET_KEEP_ORPHAN:
835 result = get_user(val, (int *)arg);
836 if (result) return result;
837 sfp->keep_orphan = val;
838 return 0;
839 case SG_GET_KEEP_ORPHAN:
840 return put_user((int)sfp->keep_orphan, (int *)arg);
841 case SG_NEXT_CMD_LEN:
842 result = get_user(val, (int *)arg);
843 if (result) return result;
844 sfp->next_cmd_len = (val > 0) ? val : 0;
845 return 0;
846 case SG_GET_VERSION_NUM:
847 return put_user(sg_version_num, (int *)arg);
848 case SG_GET_REQUEST_TABLE:
849 result = verify_area(VERIFY_WRITE, (void *) arg,
850 size_sg_req_info * SG_MAX_QUEUE);
851 if (result) return result;
852 else {
853 sg_req_info_t rinfo[SG_MAX_QUEUE];
854 Sg_request * srp;
855 read_lock_irqsave(&sfp->rq_list_lock, iflags);
856 for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
857 ++val, srp = srp ? srp->nextrp : srp) {
858 memset(&rinfo[val], 0, size_sg_req_info);
859 if (srp) {
860 rinfo[val].req_state = srp->done + 1;
861 rinfo[val].problem = srp->header.masked_status &
862 srp->header.host_status & srp->header.driver_status;
863 rinfo[val].duration = srp->done ?
864 srp->header.duration :
865 sg_jif_to_ms(jiffies - srp->header.duration);
866 rinfo[val].orphan = srp->orphan;
867 rinfo[val].sg_io_owned = srp->sg_io_owned;
868 rinfo[val].pack_id = srp->header.pack_id;
869 rinfo[val].usr_ptr = srp->header.usr_ptr;
870 }
871 }
872 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
873 __copy_to_user((void *)arg, rinfo, size_sg_req_info * SG_MAX_QUEUE);
874 return 0;
875 }
876 case SG_EMULATED_HOST:
877 return put_user(sdp->device->host->hostt->emulated, (int *)arg);
878 case SG_SCSI_RESET:
879 if (filp->f_flags & O_NONBLOCK) {
880 if (sdp->device->host->in_recovery)
881 return -EBUSY;
882 }
883 else if (! scsi_block_when_processing_errors(sdp->device))
884 return -EBUSY;
885 result = get_user(val, (int *)arg);
886 if (result) return result;
887 if (SG_SCSI_RESET_NOTHING == val)
888 return 0;
889 #ifdef SCSI_TRY_RESET_DEVICE
890 switch (val)
891 {
892 case SG_SCSI_RESET_DEVICE:
893 val = SCSI_TRY_RESET_DEVICE;
894 break;
895 case SG_SCSI_RESET_BUS:
896 val = SCSI_TRY_RESET_BUS;
897 break;
898 case SG_SCSI_RESET_HOST:
899 val = SCSI_TRY_RESET_HOST;
900 break;
901 default:
902 return -EINVAL;
903 }
904 if(! capable(CAP_SYS_ADMIN)) return -EACCES;
905 return (scsi_reset_provider(sdp->device, val) == SUCCESS) ? 0 : -EIO;
906 #else
907 SCSI_LOG_TIMEOUT(1, printk("sg_ioctl: SG_RESET_SCSI not supported\n"));
908 result = -EINVAL;
909 #endif
910 case SCSI_IOCTL_SEND_COMMAND:
911 if (read_only) {
912 unsigned char opcode = WRITE_6;
913 Scsi_Ioctl_Command * siocp = (void *)arg;
914
915 copy_from_user(&opcode, siocp->data, 1);
916 if (! sg_allow_access(opcode, sdp->device->type))
917 return -EACCES;
918 }
919 return scsi_ioctl_send_command(sdp->device, (void *)arg);
920 case SG_SET_DEBUG:
921 result = get_user(val, (int *)arg);
922 if (result) return result;
923 sdp->sgdebug = (char)val;
924 return 0;
925 case SCSI_IOCTL_GET_IDLUN:
926 case SCSI_IOCTL_GET_BUS_NUMBER:
927 case SCSI_IOCTL_PROBE_HOST:
928 case SG_GET_TRANSFORM:
929 return scsi_ioctl(sdp->device, cmd_in, (void *)arg);
930 default:
931 if (read_only)
932 return -EACCES; /* don't know so take safe approach */
933 return scsi_ioctl(sdp->device, cmd_in, (void *)arg);
934 }
935 }
936
937 static unsigned int sg_poll(struct file * filp, poll_table * wait)
938 {
939 unsigned int res = 0;
940 Sg_device * sdp;
941 Sg_fd * sfp;
942 Sg_request * srp;
943 int count = 0;
944 unsigned long iflags;
945
946 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
947 return POLLERR;
948 poll_wait(filp, &sfp->read_wait, wait);
949 read_lock_irqsave(&sfp->rq_list_lock, iflags);
950 for (srp = sfp->headrp; srp; srp = srp->nextrp) {
951 /* if any read waiting, flag it */
952 if ((0 == res) && (1 == srp->done) && (! srp->sg_io_owned))
953 res = POLLIN | POLLRDNORM;
954 ++count;
955 }
956 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
957 if (! sfp->cmd_q) {
958 if (0 == count)
959 res |= POLLOUT | POLLWRNORM;
960 }
961 else if (count < SG_MAX_QUEUE)
962 res |= POLLOUT | POLLWRNORM;
963 SCSI_LOG_TIMEOUT(3, printk("sg_poll: dev=%d, res=0x%x\n",
964 MINOR(sdp->i_rdev), (int)res));
965 return res;
966 }
967
968 static int sg_fasync(int fd, struct file * filp, int mode)
969 {
970 int retval;
971 Sg_device * sdp;
972 Sg_fd * sfp;
973
974 if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
975 return -ENXIO;
976 SCSI_LOG_TIMEOUT(3, printk("sg_fasync: dev=%d, mode=%d\n",
977 MINOR(sdp->i_rdev), mode));
978
979 retval = fasync_helper(fd, filp, mode, &sfp->async_qp);
980 return (retval < 0) ? retval : 0;
981 }
982
983 /* This function is a "bottom half" handler that is called by the
984 * mid level when a command is completed (or has failed). */
985 static void sg_cmd_done_bh(Scsi_Cmnd * SCpnt)
986 {
987 Scsi_Request * SRpnt = SCpnt->sc_request;
988 int dev = MINOR(SRpnt->sr_request.rq_dev);
989 Sg_device * sdp = NULL;
990 Sg_fd * sfp;
991 Sg_request * srp = NULL;
992
993 read_lock(&sg_dev_arr_lock);
994 if (sg_dev_arr && (dev >= 0)) {
995 if (dev < sg_template.dev_max)
996 sdp = sg_dev_arr[dev];
997 }
998 if (NULL == sdp) {
999 read_unlock(&sg_dev_arr_lock);
1000 SCSI_LOG_TIMEOUT(1, printk("sg...bh: bad args dev=%d\n", dev));
1001 scsi_release_request(SRpnt);
1002 SRpnt = NULL;
1003 return;
1004 }
1005 sfp = sdp->headfp;
1006 while (sfp) {
1007 read_lock(&sfp->rq_list_lock);
1008 for (srp = sfp->headrp; srp; srp = srp->nextrp) {
1009 if (SRpnt == srp->my_cmdp)
1010 break;
1011 }
1012 read_unlock(&sfp->rq_list_lock);
1013 if (srp)
1014 break;
1015 sfp = sfp->nextfp;
1016 }
1017 read_unlock(&sg_dev_arr_lock);
1018 if (! srp) {
1019 SCSI_LOG_TIMEOUT(1, printk("sg...bh: req missing, dev=%d\n", dev));
1020 scsi_release_request(SRpnt);
1021 SRpnt = NULL;
1022 return;
1023 }
1024 /* First transfer ownership of data buffers to sg_device object. */
1025 srp->data.k_use_sg = SRpnt->sr_use_sg;
1026 srp->data.sglist_len = SRpnt->sr_sglist_len;
1027 srp->data.bufflen = SRpnt->sr_bufflen;
1028 srp->data.buffer = SRpnt->sr_buffer;
1029 sg_clr_srpnt(SRpnt);
1030 srp->my_cmdp = NULL;
1031 srp->done = 1;
1032
1033 SCSI_LOG_TIMEOUT(4, printk("sg...bh: dev=%d, pack_id=%d, res=0x%x\n",
1034 dev, srp->header.pack_id, (int)SRpnt->sr_result));
1035 srp->header.resid = SCpnt->resid;
1036 /* sg_unmap_and(&srp->data, 0); */ /* unmap locked pages a.s.a.p. */
1037 /* N.B. unit of duration changes here from jiffies to millisecs */
1038 srp->header.duration = sg_jif_to_ms(jiffies - (int)srp->header.duration);
1039 if (0 != SRpnt->sr_result) {
1040 memcpy(srp->sense_b, SRpnt->sr_sense_buffer, sizeof(srp->sense_b));
1041 srp->header.status = 0xff & SRpnt->sr_result;
1042 srp->header.masked_status = status_byte(SRpnt->sr_result);
1043 srp->header.msg_status = msg_byte(SRpnt->sr_result);
1044 srp->header.host_status = host_byte(SRpnt->sr_result);
1045 srp->header.driver_status = driver_byte(SRpnt->sr_result);
1046 if ((sdp->sgdebug > 0) &&
1047 ((CHECK_CONDITION == srp->header.masked_status) ||
1048 (COMMAND_TERMINATED == srp->header.masked_status)))
1049 print_req_sense("sg_cmd_done_bh", SRpnt);
1050
1051 /* Following if statement is a patch supplied by Eric Youngdale */
1052 if (driver_byte(SRpnt->sr_result) != 0
1053 && (SRpnt->sr_sense_buffer[0] & 0x7f) == 0x70
1054 && (SRpnt->sr_sense_buffer[2] & 0xf) == UNIT_ATTENTION
1055 && sdp->device->removable) {
1056 /* Detected disc change. Set the bit - this may be used if */
1057 /* there are filesystems using this device. */
1058 sdp->device->changed = 1;
1059 }
1060 }
1061 /* Rely on write phase to clean out srp status values, so no "else" */
1062
1063 scsi_release_request(SRpnt);
1064 SRpnt = NULL;
1065 if (sfp->closed) { /* whoops this fd already released, cleanup */
1066 SCSI_LOG_TIMEOUT(1,
1067 printk("sg...bh: already closed, freeing ...\n"));
1068 /* should check if module is unloaded <<<<<<< */
1069 sg_finish_rem_req(srp);
1070 srp = NULL;
1071 if (NULL == sfp->headrp) {
1072 SCSI_LOG_TIMEOUT(1,
1073 printk("sg...bh: already closed, final cleanup\n"));
1074 sg_remove_sfp(sdp, sfp);
1075 sfp = NULL;
1076 }
1077 }
1078 else if (srp && srp->orphan) {
1079 if (sfp->keep_orphan)
1080 srp->sg_io_owned = 0;
1081 else {
1082 sg_finish_rem_req(srp);
1083 srp = NULL;
1084 }
1085 }
1086 if (sfp && srp) {
1087 /* Now wake up any sg_read() that is waiting for this packet. */
1088 wake_up_interruptible(&sfp->read_wait);
1089 kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
1090 }
1091 }
1092
1093 static struct file_operations sg_fops = {
1094 owner: THIS_MODULE,
1095 read: sg_read,
1096 write: sg_write,
1097 poll: sg_poll,
1098 ioctl: sg_ioctl,
1099 open: sg_open,
1100 release: sg_release,
1101 fasync: sg_fasync,
1102 };
1103
1104
1105 static int sg_detect(Scsi_Device * scsidp)
1106 {
1107 switch (scsidp->type) {
1108 case TYPE_DISK:
1109 case TYPE_MOD:
1110 case TYPE_ROM:
1111 case TYPE_WORM:
1112 case TYPE_TAPE: break;
1113 default:
1114 printk("Detected scsi generic sg%d at scsi%d,"
1115 " channel %d, id %d, lun %d, type %d\n",
1116 sg_template.dev_noticed,
1117 scsidp->host->host_no, scsidp->channel,
1118 scsidp->id, scsidp->lun, scsidp->type);
1119 }
1120 sg_template.dev_noticed++;
1121 return 1;
1122 }
1123
1124 /* Driver initialization */
1125 static int sg_init()
1126 {
1127 static int sg_registered = 0;
1128 unsigned long iflags;
1129
1130 if ((sg_template.dev_noticed == 0) || sg_dev_arr)
1131 return 0;
1132
1133 write_lock_irqsave(&sg_dev_arr_lock, iflags);
1134 if(!sg_registered) {
1135 if (devfs_register_chrdev(SCSI_GENERIC_MAJOR,"sg",&sg_fops))
1136 {
1137 printk("Unable to get major %d for generic SCSI device\n",
1138 SCSI_GENERIC_MAJOR);
1139 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1140 return 1;
1141 }
1142 sg_registered++;
1143 }
1144
1145 SCSI_LOG_TIMEOUT(3, printk("sg_init\n"));
1146 sg_template.dev_max = sg_template.dev_noticed + SG_DEV_ARR_LUMP;
1147 sg_dev_arr = (Sg_device **)kmalloc(sg_template.dev_max *
1148 sizeof(Sg_device *), GFP_ATOMIC);
1149 if (NULL == sg_dev_arr) {
1150 printk("sg_init: no space for sg_dev_arr\n");
1151 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1152 return 1;
1153 }
1154 memset(sg_dev_arr, 0, sg_template.dev_max * sizeof(Sg_device *));
1155 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1156 #ifdef CONFIG_PROC_FS
1157 sg_proc_init();
1158 #endif /* CONFIG_PROC_FS */
1159 return 0;
1160 }
1161
1162 #ifndef MODULE
1163 static int __init sg_def_reserved_size_setup(char *str)
1164 {
1165 int tmp;
1166
1167 if (get_option(&str, &tmp) == 1) {
1168 def_reserved_size = tmp;
1169 if (tmp >= 0)
1170 sg_big_buff = tmp;
1171 return 1;
1172 } else {
1173 printk("sg_def_reserved_size : usage sg_def_reserved_size=n "
1174 "(n could be 65536, 131072 or 262144)\n");
1175 return 0;
1176 }
1177 }
1178
1179 __setup("sg_def_reserved_size=", sg_def_reserved_size_setup);
1180 #endif
1181
1182
1183 static int sg_attach(Scsi_Device * scsidp)
1184 {
1185 Sg_device * sdp;
1186 unsigned long iflags;
1187 int k;
1188
1189 write_lock_irqsave(&sg_dev_arr_lock, iflags);
1190 if (sg_template.nr_dev >= sg_template.dev_max) { /* try to resize */
1191 Sg_device ** tmp_da;
1192 int tmp_dev_max = sg_template.nr_dev + SG_DEV_ARR_LUMP;
1193
1194 tmp_da = (Sg_device **)kmalloc(tmp_dev_max *
1195 sizeof(Sg_device *), GFP_ATOMIC);
1196 if (NULL == tmp_da) {
1197 scsidp->attached--;
1198 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1199 printk("sg_attach: device array cannot be resized\n");
1200 return 1;
1201 }
1202 memset(tmp_da, 0, tmp_dev_max * sizeof(Sg_device *));
1203 memcpy(tmp_da, sg_dev_arr, sg_template.dev_max * sizeof(Sg_device *));
1204 kfree((char *)sg_dev_arr);
1205 sg_dev_arr = tmp_da;
1206 sg_template.dev_max = tmp_dev_max;
1207 }
1208
1209 for(k = 0; k < sg_template.dev_max; k++)
1210 if(! sg_dev_arr[k]) break;
1211 if(k < sg_template.dev_max)
1212 sdp = (Sg_device *)kmalloc(sizeof(Sg_device), GFP_ATOMIC);
1213 else
1214 sdp = NULL;
1215 if (NULL == sdp) {
1216 scsidp->attached--;
1217 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1218 printk("sg_attach: Sg_device cannot be allocated\n");
1219 return 1;
1220 }
1221
1222 SCSI_LOG_TIMEOUT(3, printk("sg_attach: dev=%d \n", k));
1223 sdp->device = scsidp;
1224 init_waitqueue_head(&sdp->o_excl_wait);
1225 sdp->headfp= NULL;
1226 sdp->exclude = 0;
1227 sdp->sgdebug = 0;
1228 sdp->detached = 0;
1229 sdp->sg_tablesize = scsidp->host ? scsidp->host->sg_tablesize : 0;
1230 sdp->i_rdev = MKDEV(SCSI_GENERIC_MAJOR, k);
1231 sdp->de = devfs_register (scsidp->de, "generic", DEVFS_FL_DEFAULT,
1232 SCSI_GENERIC_MAJOR, k,
1233 S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
1234 &sg_fops, NULL);
1235 sg_template.nr_dev++;
1236 sg_dev_arr[k] = sdp;
1237 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1238 return 0;
1239 }
1240
1241 /* Called at 'finish' of init process, after all attaches */
1242 static void sg_finish(void)
1243 {
1244 SCSI_LOG_TIMEOUT(3, printk("sg_finish: dma_free_sectors=%u\n",
1245 scsi_dma_free_sectors));
1246 }
1247
1248 static void sg_detach(Scsi_Device * scsidp)
1249 {
1250 Sg_device * sdp;
1251 unsigned long iflags;
1252 Sg_fd * sfp;
1253 Sg_request * srp;
1254 int k;
1255
1256 if (NULL == sg_dev_arr)
1257 return;
1258 write_lock_irqsave(&sg_dev_arr_lock, iflags);
1259 for (k = 0; k < sg_template.dev_max; k++) {
1260 sdp = sg_dev_arr[k];
1261 if ((NULL == sdp) || (sdp->device != scsidp))
1262 continue; /* dirty but lowers nesting */
1263 if (sdp->headfp) {
1264 for (sfp = sdp->headfp; sfp; sfp = sfp->nextfp) {
1265 /* no lock on request list here */
1266 for (srp = sfp->headrp; srp; srp = srp->nextrp) {
1267 if (! srp->done) {
1268 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1269 sg_shorten_timeout(srp->my_cmdp);
1270 write_lock_irqsave(&sg_dev_arr_lock, iflags);
1271 }
1272 }
1273 }
1274 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1275 SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d, dirty, sleep(3)\n", k));
1276 scsi_sleep(3); /* sleep 3 jiffies, hoping for timeout to go off */
1277 devfs_unregister (sdp->de);
1278 sdp->de = NULL;
1279 sdp->detached = 1;
1280 write_lock_irqsave(&sg_dev_arr_lock, iflags);
1281 }
1282 else {
1283 SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d\n", k));
1284 devfs_unregister (sdp->de);
1285 kfree((char *)sdp);
1286 sg_dev_arr[k] = NULL;
1287 }
1288 scsidp->attached--;
1289 sg_template.nr_dev--;
1290 /* avoid associated device /dev/sg? being incremented
1291 * each time module is inserted/removed , <dan@lectra.fr> */
1292 sg_template.dev_noticed--;
1293 break;
1294 }
1295 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1296 return;
1297 }
1298
1299 MODULE_AUTHOR("Douglas Gilbert");
1300 MODULE_DESCRIPTION("SCSI generic (sg) driver");
1301 MODULE_PARM(def_reserved_size, "i");
1302 MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
1303
1304 static int __init init_sg(void) {
1305 if (def_reserved_size >= 0)
1306 sg_big_buff = def_reserved_size;
1307 sg_template.module = THIS_MODULE;
1308 return scsi_register_module(MODULE_SCSI_DEV, &sg_template);
1309 }
1310
1311 static void __exit exit_sg( void)
1312 {
1313 #ifdef CONFIG_PROC_FS
1314 sg_proc_cleanup();
1315 #endif /* CONFIG_PROC_FS */
1316 scsi_unregister_module(MODULE_SCSI_DEV, &sg_template);
1317 devfs_unregister_chrdev(SCSI_GENERIC_MAJOR, "sg");
1318 if(sg_dev_arr != NULL) {
1319 /* Really worrying situation of writes still pending and get here */
1320 /* Strategy: shorten timeout on release + wait on detach ... */
1321 kfree((char *)sg_dev_arr);
1322 sg_dev_arr = NULL;
1323 }
1324 sg_template.dev_max = 0;
1325 }
1326
1327
1328 #if 0
1329 extern void scsi_times_out (Scsi_Cmnd * SCpnt);
1330 extern void scsi_old_times_out (Scsi_Cmnd * SCpnt);
1331 #endif
1332
1333 /* Can't see clean way to abort a command so shorten timeout to 1 jiffy */
1334 static void sg_shorten_timeout(Scsi_Request * srpnt)
1335 {
1336 #if 0 /* scsi_syms.c is very miserly about exported functions */
1337 scsi_delete_timer(scpnt);
1338 if (! scpnt)
1339 return;
1340 scpnt->timeout_per_command = 1; /* try 1 jiffy (perhaps 0 jiffies) */
1341 if (scpnt->host->hostt->use_new_eh_code)
1342 scsi_add_timer(scpnt, scpnt->timeout_per_command, scsi_times_out);
1343 else
1344 scsi_add_timer(scpnt, scpnt->timeout_per_command,
1345 scsi_old_times_out);
1346 #else
1347 scsi_sleep(HZ); /* just sleep 1 second and hope ... */
1348 #endif
1349 }
1350
1351 static int sg_start_req(Sg_request * srp)
1352 {
1353 int res;
1354 Sg_fd * sfp = srp->parentfp;
1355 sg_io_hdr_t * hp = &srp->header;
1356 int dxfer_len = (int)hp->dxfer_len;
1357 int dxfer_dir = hp->dxfer_direction;
1358 Sg_scatter_hold * req_schp = &srp->data;
1359 Sg_scatter_hold * rsv_schp = &sfp->reserve;
1360
1361 SCSI_LOG_TIMEOUT(4, printk("sg_start_req: dxfer_len=%d\n", dxfer_len));
1362 if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1363 return 0;
1364 if ((hp->flags & SG_FLAG_DIRECT_IO) &&
1365 (dxfer_dir != SG_DXFER_UNKNOWN) &&
1366 (0 == hp->iovec_count) &&
1367 (! sfp->parentdp->device->host->unchecked_isa_dma)) {
1368 res = sg_build_dir(srp, sfp, dxfer_len);
1369 if (res <= 0) /* -ve -> error, 0 -> done, 1 -> try indirect */
1370 return res;
1371 }
1372 if ((! sg_res_in_use(sfp)) && (dxfer_len <= rsv_schp->bufflen)) {
1373 sg_link_reserve(sfp, srp, dxfer_len);
1374 }
1375 else {
1376 res = sg_build_indi(req_schp, sfp, dxfer_len);
1377 if (res) {
1378 sg_remove_scat(req_schp);
1379 return res;
1380 }
1381 }
1382 return 0;
1383 }
1384
1385 static void sg_finish_rem_req(Sg_request * srp)
1386 {
1387 Sg_fd * sfp = srp->parentfp;
1388 Sg_scatter_hold * req_schp = &srp->data;
1389
1390 SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n",
1391 (int)srp->res_used));
1392 sg_unmap_and(&srp->data, 1);
1393 if (srp->res_used)
1394 sg_unlink_reserve(sfp, srp);
1395 else
1396 sg_remove_scat(req_schp);
1397 sg_remove_request(sfp, srp);
1398 }
1399
1400 static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp)
1401 {
1402 int mem_src, ret_sz;
1403 int sg_bufflen = PAGE_SIZE;
1404 int elem_sz = sizeof(struct scatterlist) + sizeof(char);
1405 int mx_sc_elems = (sg_bufflen / elem_sz) - 1;
1406
1407 mem_src = SG_HEAP_KMAL;
1408 schp->buffer = (struct scatterlist *)sg_malloc(sfp, sg_bufflen,
1409 &ret_sz, &mem_src);
1410 schp->buffer_mem_src = (char)mem_src;
1411 if (! schp->buffer)
1412 return -ENOMEM;
1413 else if (ret_sz != sg_bufflen) {
1414 sg_bufflen = ret_sz;
1415 mx_sc_elems = (sg_bufflen / elem_sz) - 1;
1416 }
1417 schp->sglist_len = sg_bufflen;
1418 memset(schp->buffer, 0, sg_bufflen);
1419 return mx_sc_elems; /* number of scat_gath elements allocated */
1420 }
1421
1422 static void sg_unmap_and(Sg_scatter_hold * schp, int free_also)
1423 {
1424 #ifdef SG_ALLOW_DIO
1425 if (schp && schp->kiobp) {
1426 if (schp->mapped) {
1427 unmap_kiobuf(schp->kiobp);
1428 schp->mapped = 0;
1429 }
1430 if (free_also) {
1431 free_kiovec(1, &schp->kiobp);
1432 schp->kiobp = NULL;
1433 }
1434 }
1435 #endif
1436 }
1437
1438 static int sg_build_dir(Sg_request * srp, Sg_fd * sfp, int dxfer_len)
1439 {
1440 #ifdef SG_ALLOW_DIO
1441 int res, k, split, offset, num, mx_sc_elems, rem_sz;
1442 struct kiobuf * kp;
1443 char * mem_src_arr;
1444 struct scatterlist * sclp;
1445 unsigned long addr, prev_addr;
1446 sg_io_hdr_t * hp = &srp->header;
1447 Sg_scatter_hold * schp = &srp->data;
1448 int sg_tablesize = sfp->parentdp->sg_tablesize;
1449
1450 res = alloc_kiovec(1, &schp->kiobp);
1451 if (0 != res) {
1452 SCSI_LOG_TIMEOUT(5, printk("sg_build_dir: alloc_kiovec res=%d\n", res));
1453 return 1;
1454 }
1455 res = map_user_kiobuf((SG_DXFER_TO_DEV == hp->dxfer_direction) ? 1 : 0,
1456 schp->kiobp, (unsigned long)hp->dxferp, dxfer_len);
1457 if (0 != res) {
1458 SCSI_LOG_TIMEOUT(5,
1459 printk("sg_build_dir: map_user_kiobuf res=%d\n", res));
1460 sg_unmap_and(schp, 1);
1461 return 1;
1462 }
1463 schp->mapped = 1;
1464 kp = schp->kiobp;
1465 prev_addr = (unsigned long) page_address(kp->maplist[0]);
1466 for (k = 1, split = 0; k < kp->nr_pages; ++k, prev_addr = addr) {
1467 addr = (unsigned long) page_address(kp->maplist[k]);
1468 if ((prev_addr + PAGE_SIZE) != addr) {
1469 split = k;
1470 break;
1471 }
1472 }
1473 if (! split) {
1474 schp->k_use_sg = 0;
1475 schp->buffer = page_address(kp->maplist[0]) + kp->offset;
1476 schp->bufflen = dxfer_len;
1477 schp->buffer_mem_src = SG_USER_MEM;
1478 schp->b_malloc_len = dxfer_len;
1479 hp->info |= SG_INFO_DIRECT_IO;
1480 return 0;
1481 }
1482 mx_sc_elems = sg_build_sgat(schp, sfp);
1483 if (mx_sc_elems <= 1) {
1484 sg_unmap_and(schp, 1);
1485 sg_remove_scat(schp);
1486 return 1;
1487 }
1488 mem_src_arr = schp->buffer + (mx_sc_elems * sizeof(struct scatterlist));
1489 for (k = 0, sclp = schp->buffer, rem_sz = dxfer_len;
1490 (k < sg_tablesize) && (rem_sz > 0) && (k < mx_sc_elems);
1491 ++k, ++sclp) {
1492 offset = (0 == k) ? kp->offset : 0;
1493 num = (rem_sz > (PAGE_SIZE - offset)) ? (PAGE_SIZE - offset) :
1494 rem_sz;
1495 sclp->address = page_address(kp->maplist[k]) + offset;
1496 sclp->length = num;
1497 mem_src_arr[k] = SG_USER_MEM;
1498 rem_sz -= num;
1499 SCSI_LOG_TIMEOUT(5,
1500 printk("sg_build_dir: k=%d, a=0x%p, len=%d, ms=%d\n",
1501 k, sclp->address, num, mem_src_arr[k]));
1502 }
1503 schp->k_use_sg = k;
1504 SCSI_LOG_TIMEOUT(5,
1505 printk("sg_build_dir: k_use_sg=%d, rem_sz=%d\n", k, rem_sz));
1506 schp->bufflen = dxfer_len;
1507 if (rem_sz > 0) { /* must have failed */
1508 sg_unmap_and(schp, 1);
1509 sg_remove_scat(schp);
1510 return 1; /* out of scatter gather elements, try indirect */
1511 }
1512 hp->info |= SG_INFO_DIRECT_IO;
1513 return 0;
1514 #else
1515 return 1;
1516 #endif /* SG_ALLOW_DIO */
1517 }
1518
1519 static int sg_build_indi(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
1520 {
1521 int ret_sz, mem_src;
1522 int blk_size = buff_size;
1523 char * p = NULL;
1524
1525 if ((blk_size < 0) || (! sfp))
1526 return -EFAULT;
1527 if (0 == blk_size)
1528 ++blk_size; /* don't know why */
1529 /* round request up to next highest SG_SECTOR_SZ byte boundary */
1530 blk_size = (blk_size + SG_SECTOR_MSK) & (~SG_SECTOR_MSK);
1531 SCSI_LOG_TIMEOUT(4, printk("sg_build_indi: buff_size=%d, blk_size=%d\n",
1532 buff_size, blk_size));
1533 if (blk_size <= SG_SCATTER_SZ) {
1534 mem_src = SG_HEAP_PAGE;
1535 p = sg_malloc(sfp, blk_size, &ret_sz, &mem_src);
1536 if (! p)
1537 return -ENOMEM;
1538 if (blk_size == ret_sz) { /* got it on the first attempt */
1539 schp->k_use_sg = 0;
1540 schp->buffer = p;
1541 schp->bufflen = blk_size;
1542 schp->buffer_mem_src = (char)mem_src;
1543 schp->b_malloc_len = blk_size;
1544 return 0;
1545 }
1546 }
1547 else {
1548 mem_src = SG_HEAP_PAGE;
1549 p = sg_malloc(sfp, SG_SCATTER_SZ, &ret_sz, &mem_src);
1550 if (! p)
1551 return -ENOMEM;
1552 }
1553 /* Want some local declarations, so start new block ... */
1554 { /* lets try and build a scatter gather list */
1555 struct scatterlist * sclp;
1556 int k, rem_sz, num;
1557 int mx_sc_elems;
1558 int sg_tablesize = sfp->parentdp->sg_tablesize;
1559 int first = 1;
1560 char * mem_src_arr;
1561
1562 /* N.B. ret_sz and mem_src carried into this block ... */
1563 mx_sc_elems = sg_build_sgat(schp, sfp);
1564 if (mx_sc_elems < 0)
1565 return mx_sc_elems; /* most likely -ENOMEM */
1566 mem_src_arr = schp->buffer +
1567 (mx_sc_elems * sizeof(struct scatterlist));
1568
1569 for (k = 0, sclp = schp->buffer, rem_sz = blk_size;
1570 (k < sg_tablesize) && (rem_sz > 0) && (k < mx_sc_elems);
1571 ++k, rem_sz -= ret_sz, ++sclp) {
1572 if (first)
1573 first = 0;
1574 else {
1575 num = (rem_sz > SG_SCATTER_SZ) ? SG_SCATTER_SZ : rem_sz;
1576 mem_src = SG_HEAP_PAGE;
1577 p = sg_malloc(sfp, num, &ret_sz, &mem_src);
1578 if (! p)
1579 break;
1580 }
1581 sclp->address = p;
1582 sclp->length = ret_sz;
1583 mem_src_arr[k] = mem_src;
1584
1585 SCSI_LOG_TIMEOUT(5,
1586 printk("sg_build_build: k=%d, a=0x%p, len=%d, ms=%d\n",
1587 k, sclp->address, ret_sz, mem_src));
1588 } /* end of for loop */
1589 schp->k_use_sg = k;
1590 SCSI_LOG_TIMEOUT(5,
1591 printk("sg_build_indi: k_use_sg=%d, rem_sz=%d\n", k, rem_sz));
1592 schp->bufflen = blk_size;
1593 if (rem_sz > 0) /* must have failed */
1594 return -ENOMEM;
1595 }
1596 return 0;
1597 }
1598
1599 static int sg_write_xfer(Sg_request * srp)
1600 {
1601 sg_io_hdr_t * hp = &srp->header;
1602 Sg_scatter_hold * schp = &srp->data;
1603 int num_xfer = 0;
1604 int j, k, onum, usglen, ksglen, res, ok;
1605 int iovec_count = (int)hp->iovec_count;
1606 int dxfer_dir = hp->dxfer_direction;
1607 unsigned char * p;
1608 unsigned char * up;
1609 int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
1610
1611 if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_TO_DEV == dxfer_dir) ||
1612 (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
1613 num_xfer = (int)(new_interface ? hp->dxfer_len : hp->flags);
1614 if (schp->bufflen < num_xfer)
1615 num_xfer = schp->bufflen;
1616 }
1617 if ((num_xfer <= 0) || (new_interface && (SG_FLAG_NO_DXFER & hp->flags)))
1618 return 0;
1619
1620 SCSI_LOG_TIMEOUT(4,
1621 printk("sg_write_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
1622 num_xfer, iovec_count, schp->k_use_sg));
1623 if (iovec_count) {
1624 onum = iovec_count;
1625 if ((k = verify_area(VERIFY_READ, hp->dxferp,
1626 size_sg_iovec * onum)))
1627 return k;
1628 }
1629 else
1630 onum = 1;
1631
1632 if (0 == schp->k_use_sg) { /* kernel has single buffer */
1633 if (SG_USER_MEM != schp->buffer_mem_src) { /* else nothing to do */
1634
1635 for (j = 0, p = schp->buffer; j < onum; ++j) {
1636 res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up);
1637 if (res) return res;
1638 usglen = (num_xfer > usglen) ? usglen : num_xfer;
1639 __copy_from_user(p, up, usglen);
1640 p += usglen;
1641 num_xfer -= usglen;
1642 if (num_xfer <= 0)
1643 return 0;
1644 }
1645 }
1646 }
1647 else { /* kernel using scatter gather list */
1648 struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1649 char * mem_src_arr = sg_get_sgat_msa(schp);
1650 ksglen = (int)sclp->length;
1651 p = sclp->address;
1652
1653 for (j = 0, k = 0; j < onum; ++j) {
1654 res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up);
1655 if (res) return res;
1656
1657 for (; (k < schp->k_use_sg) && p;
1658 ++k, ++sclp, ksglen = (int)sclp->length, p = sclp->address) {
1659 ok = (SG_USER_MEM != mem_src_arr[k]);
1660 if (usglen <= 0)
1661 break;
1662 if (ksglen > usglen) {
1663 if (usglen >= num_xfer) {
1664 if (ok) __copy_from_user(p, up, num_xfer);
1665 return 0;
1666 }
1667 if (ok) __copy_from_user(p, up, usglen);
1668 p += usglen;
1669 ksglen -= usglen;
1670 break;
1671 }
1672 else {
1673 if (ksglen >= num_xfer) {
1674 if (ok) __copy_from_user(p, up, num_xfer);
1675 return 0;
1676 }
1677 if (ok) __copy_from_user(p, up, ksglen);
1678 up += ksglen;
1679 usglen -= ksglen;
1680 }
1681 }
1682 }
1683 }
1684 return 0;
1685 }
1686
1687 static int sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
1688 int wr_xf, int * countp, unsigned char ** up)
1689 {
1690 int num_xfer = (int)hp->dxfer_len;
1691 unsigned char * p;
1692 int count, k;
1693 sg_iovec_t u_iovec;
1694
1695 if (0 == sg_num) {
1696 p = (unsigned char *)hp->dxferp;
1697 if (wr_xf && ('\0' == hp->interface_id))
1698 count = (int)hp->flags; /* holds "old" input_size */
1699 else
1700 count = num_xfer;
1701 }
1702 else {
1703 __copy_from_user(&u_iovec,
1704 (unsigned char *)hp->dxferp + (ind * size_sg_iovec),
1705 size_sg_iovec);
1706 p = (unsigned char *)u_iovec.iov_base;
1707 count = (int)u_iovec.iov_len;
1708 }
1709 if ((k = verify_area(wr_xf ? VERIFY_READ : VERIFY_WRITE, p, count)))
1710 return k;
1711 if (up) *up = p;
1712 if (countp) *countp = count;
1713 return 0;
1714 }
1715
1716 static char * sg_get_sgat_msa(Sg_scatter_hold * schp)
1717 {
1718 int elem_sz = sizeof(struct scatterlist) + sizeof(char);
1719 int mx_sc_elems = (schp->sglist_len / elem_sz) - 1;
1720 return schp->buffer + (sizeof(struct scatterlist) * mx_sc_elems);
1721 }
1722
1723 static void sg_remove_scat(Sg_scatter_hold * schp)
1724 {
1725 SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n",
1726 schp->k_use_sg));
1727 if (schp->buffer && schp->sglist_len) {
1728 int k, mem_src;
1729 struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1730 char * mem_src_arr = sg_get_sgat_msa(schp);
1731
1732 for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) {
1733 mem_src = mem_src_arr[k];
1734 SCSI_LOG_TIMEOUT(5,
1735 printk("sg_remove_scat: k=%d, a=0x%p, len=%d, ms=%d\n",
1736 k, sclp->address, sclp->length, mem_src));
1737 sg_free(sclp->address, sclp->length, mem_src);
1738 sclp->address = NULL;
1739 sclp->length = 0;
1740 }
1741 sg_free(schp->buffer, schp->sglist_len, schp->buffer_mem_src);
1742 }
1743 else if (schp->buffer)
1744 sg_free(schp->buffer, schp->b_malloc_len, schp->buffer_mem_src);
1745 memset(schp, 0, sizeof(*schp));
1746 }
1747
1748 static int sg_read_xfer(Sg_request * srp)
1749 {
1750 sg_io_hdr_t * hp = &srp->header;
1751 Sg_scatter_hold * schp = &srp->data;
1752 int num_xfer = 0;
1753 int j, k, onum, usglen, ksglen, res, ok;
1754 int iovec_count = (int)hp->iovec_count;
1755 int dxfer_dir = hp->dxfer_direction;
1756 unsigned char * p;
1757 unsigned char * up;
1758 int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
1759
1760 if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_FROM_DEV == dxfer_dir) ||
1761 (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
1762 num_xfer = hp->dxfer_len;
1763 if (schp->bufflen < num_xfer)
1764 num_xfer = schp->bufflen;
1765 }
1766 if ((num_xfer <= 0) || (new_interface && (SG_FLAG_NO_DXFER & hp->flags)))
1767 return 0;
1768
1769 SCSI_LOG_TIMEOUT(4,
1770 printk("sg_read_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
1771 num_xfer, iovec_count, schp->k_use_sg));
1772 if (iovec_count) {
1773 onum = iovec_count;
1774 if ((k = verify_area(VERIFY_READ, hp->dxferp,
1775 size_sg_iovec * onum)))
1776 return k;
1777 }
1778 else
1779 onum = 1;
1780
1781 if (0 == schp->k_use_sg) { /* kernel has single buffer */
1782 if (SG_USER_MEM != schp->buffer_mem_src) { /* else nothing to do */
1783
1784 for (j = 0, p = schp->buffer; j < onum; ++j) {
1785 res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up);
1786 if (res) return res;
1787 usglen = (num_xfer > usglen) ? usglen : num_xfer;
1788 __copy_to_user(up, p, usglen);
1789 p += usglen;
1790 num_xfer -= usglen;
1791 if (num_xfer <= 0)
1792 return 0;
1793 }
1794 }
1795 }
1796 else { /* kernel using scatter gather list */
1797 struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1798 char * mem_src_arr = sg_get_sgat_msa(schp);
1799 ksglen = (int)sclp->length;
1800 p = sclp->address;
1801
1802 for (j = 0, k = 0; j < onum; ++j) {
1803 res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up);
1804 if (res) return res;
1805
1806 for (; (k < schp->k_use_sg) && p;
1807 ++k, ++sclp, ksglen = (int)sclp->length, p = sclp->address) {
1808 ok = (SG_USER_MEM != mem_src_arr[k]);
1809 if (usglen <= 0)
1810 break;
1811 if (ksglen > usglen) {
1812 if (usglen >= num_xfer) {
1813 if (ok) __copy_to_user(up, p, num_xfer);
1814 return 0;
1815 }
1816 if (ok) __copy_to_user(up, p, usglen);
1817 p += usglen;
1818 ksglen -= usglen;
1819 break;
1820 }
1821 else {
1822 if (ksglen >= num_xfer) {
1823 if (ok) __copy_to_user(up, p, num_xfer);
1824 return 0;
1825 }
1826 if (ok) __copy_to_user(up, p, ksglen);
1827 up += ksglen;
1828 usglen -= ksglen;
1829 }
1830 }
1831 }
1832 }
1833 return 0;
1834 }
1835
1836 static void sg_read_oxfer(Sg_request * srp, char * outp, int num_read_xfer)
1837 {
1838 Sg_scatter_hold * schp = &srp->data;
1839
1840 SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n",
1841 num_read_xfer));
1842 if ((! outp) || (num_read_xfer <= 0))
1843 return;
1844 if(schp->k_use_sg > 0) {
1845 int k, num;
1846 struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1847
1848 for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) {
1849 num = (int)sclp->length;
1850 if (num > num_read_xfer) {
1851 __copy_to_user(outp, sclp->address, num_read_xfer);
1852 break;
1853 }
1854 else {
1855 __copy_to_user(outp, sclp->address, num);
1856 num_read_xfer -= num;
1857 if (num_read_xfer <= 0)
1858 break;
1859 outp += num;
1860 }
1861 }
1862 }
1863 else
1864 __copy_to_user(outp, schp->buffer, num_read_xfer);
1865 }
1866
1867 static void sg_build_reserve(Sg_fd * sfp, int req_size)
1868 {
1869 Sg_scatter_hold * schp = &sfp->reserve;
1870
1871 SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size));
1872 do {
1873 if (req_size < PAGE_SIZE)
1874 req_size = PAGE_SIZE;
1875 if (0 == sg_build_indi(schp, sfp, req_size))
1876 return;
1877 else
1878 sg_remove_scat(schp);
1879 req_size >>= 1; /* divide by 2 */
1880 } while (req_size > (PAGE_SIZE / 2));
1881 }
1882
1883 static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
1884 {
1885 Sg_scatter_hold * req_schp = &srp->data;
1886 Sg_scatter_hold * rsv_schp = &sfp->reserve;
1887
1888 srp->res_used = 1;
1889 SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size));
1890 size = (size + 1) & (~1); /* round to even for aha1542 */
1891 if (rsv_schp->k_use_sg > 0) {
1892 int k, num;
1893 int rem = size;
1894 struct scatterlist * sclp = (struct scatterlist *)rsv_schp->buffer;
1895
1896 for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) {
1897 num = (int)sclp->length;
1898 if (rem <= num) {
1899 if (0 == k) {
1900 req_schp->k_use_sg = 0;
1901 req_schp->buffer = sclp->address;
1902 }
1903 else {
1904 sfp->save_scat_len = num;
1905 sclp->length = (unsigned)rem;
1906 req_schp->k_use_sg = k + 1;
1907 req_schp->sglist_len = rsv_schp->sglist_len;
1908 req_schp->buffer = rsv_schp->buffer;
1909 }
1910 req_schp->bufflen = size;
1911 req_schp->buffer_mem_src = rsv_schp->buffer_mem_src;
1912 req_schp->b_malloc_len = rsv_schp->b_malloc_len;
1913 break;
1914 }
1915 else
1916 rem -= num;
1917 }
1918 if (k >= rsv_schp->k_use_sg)
1919 SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
1920 }
1921 else {
1922 req_schp->k_use_sg = 0;
1923 req_schp->bufflen = size;
1924 req_schp->buffer = rsv_schp->buffer;
1925 req_schp->buffer_mem_src = rsv_schp->buffer_mem_src;
1926 req_schp->b_malloc_len = rsv_schp->b_malloc_len;
1927 }
1928 }
1929
1930 static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
1931 {
1932 Sg_scatter_hold * req_schp = &srp->data;
1933 Sg_scatter_hold * rsv_schp = &sfp->reserve;
1934
1935 SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n",
1936 (int)req_schp->k_use_sg));
1937 if ((rsv_schp->k_use_sg > 0) && (req_schp->k_use_sg > 0)) {
1938 struct scatterlist * sclp = (struct scatterlist *)rsv_schp->buffer;
1939
1940 if (sfp->save_scat_len > 0)
1941 (sclp + (req_schp->k_use_sg - 1))->length =
1942 (unsigned)sfp->save_scat_len;
1943 else
1944 SCSI_LOG_TIMEOUT(1, printk(
1945 "sg_unlink_reserve: BAD save_scat_len\n"));
1946 }
1947 req_schp->k_use_sg = 0;
1948 req_schp->bufflen = 0;
1949 req_schp->buffer = NULL;
1950 req_schp->sglist_len = 0;
1951 sfp->save_scat_len = 0;
1952 srp->res_used = 0;
1953 }
1954
1955 static Sg_request * sg_get_rq_mark(Sg_fd * sfp, int pack_id)
1956 {
1957 Sg_request * resp;
1958 unsigned long iflags;
1959
1960 write_lock_irqsave(&sfp->rq_list_lock, iflags);
1961 for (resp = sfp->headrp; resp; resp = resp->nextrp) {
1962 /* look for requests that are ready + not SG_IO owned */
1963 if ((1 == resp->done) && (! resp->sg_io_owned) &&
1964 ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
1965 resp->done = 2; /* guard against other readers */
1966 break;
1967 }
1968 }
1969 write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1970 return resp;
1971 }
1972
1973 #ifdef CONFIG_PROC_FS
1974 static Sg_request * sg_get_nth_request(Sg_fd * sfp, int nth)
1975 {
1976 Sg_request * resp;
1977 unsigned long iflags;
1978 int k;
1979
1980 read_lock_irqsave(&sfp->rq_list_lock, iflags);
1981 for (k = 0, resp = sfp->headrp; resp && (k < nth);
1982 ++k, resp = resp->nextrp)
1983 ;
1984 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1985 return resp;
1986 }
1987 #endif
1988
1989 /* always adds to end of list */
1990 static Sg_request * sg_add_request(Sg_fd * sfp)
1991 {
1992 int k;
1993 unsigned long iflags;
1994 Sg_request * resp;
1995 Sg_request * rp = sfp->req_arr;
1996
1997 write_lock_irqsave(&sfp->rq_list_lock, iflags);
1998 resp = sfp->headrp;
1999 if (! resp) {
2000 memset(rp, 0, sizeof(Sg_request));
2001 rp->parentfp = sfp;
2002 resp = rp;
2003 sfp->headrp = resp;
2004 }
2005 else {
2006 if (0 == sfp->cmd_q)
2007 resp = NULL; /* command queuing disallowed */
2008 else {
2009 for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
2010 if (! rp->parentfp)
2011 break;
2012 }
2013 if (k < SG_MAX_QUEUE) {
2014 memset(rp, 0, sizeof(Sg_request));
2015 rp->parentfp = sfp;
2016 while (resp->nextrp)
2017 resp = resp->nextrp;
2018 resp->nextrp = rp;
2019 resp = rp;
2020 }
2021 else
2022 resp = NULL;
2023 }
2024 }
2025 if (resp) {
2026 resp->nextrp = NULL;
2027 resp->header.duration = jiffies;
2028 resp->my_cmdp = NULL;
2029 resp->data.kiobp = NULL;
2030 }
2031 write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2032 return resp;
2033 }
2034
2035 /* Return of 1 for found; 0 for not found */
2036 static int sg_remove_request(Sg_fd * sfp, Sg_request * srp)
2037 {
2038 Sg_request * prev_rp;
2039 Sg_request * rp;
2040 unsigned long iflags;
2041 int res = 0;
2042
2043 if ((! sfp) || (! srp) || (! sfp->headrp))
2044 return res;
2045 write_lock_irqsave(&sfp->rq_list_lock, iflags);
2046 prev_rp = sfp->headrp;
2047 if (srp == prev_rp) {
2048 sfp->headrp = prev_rp->nextrp;
2049 prev_rp->parentfp = NULL;
2050 res = 1;
2051 }
2052 else {
2053 while ((rp = prev_rp->nextrp)) {
2054 if (srp == rp) {
2055 prev_rp->nextrp = rp->nextrp;
2056 rp->parentfp = NULL;
2057 res = 1;
2058 break;
2059 }
2060 prev_rp = rp;
2061 }
2062 }
2063 write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2064 return res;
2065 }
2066
2067 #ifdef CONFIG_PROC_FS
2068 static Sg_fd * sg_get_nth_sfp(Sg_device * sdp, int nth)
2069 {
2070 Sg_fd * resp;
2071 unsigned long iflags;
2072 int k;
2073
2074 read_lock_irqsave(&sg_dev_arr_lock, iflags);
2075 for (k = 0, resp = sdp->headfp; resp && (k < nth);
2076 ++k, resp = resp->nextfp)
2077 ;
2078 read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2079 return resp;
2080 }
2081 #endif
2082
2083 static Sg_fd * sg_add_sfp(Sg_device * sdp, int dev)
2084 {
2085 Sg_fd * sfp;
2086 unsigned long iflags;
2087
2088 sfp = (Sg_fd *)sg_low_malloc(sizeof(Sg_fd), 0, SG_HEAP_KMAL, 0);
2089 if (! sfp)
2090 return NULL;
2091 memset(sfp, 0, sizeof(Sg_fd));
2092 sfp->fd_mem_src = SG_HEAP_KMAL;
2093 init_waitqueue_head(&sfp->read_wait);
2094 sfp->rq_list_lock = RW_LOCK_UNLOCKED;
2095
2096 sfp->timeout = SG_DEFAULT_TIMEOUT;
2097 sfp->force_packid = SG_DEF_FORCE_PACK_ID;
2098 sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ?
2099 sdp->device->host->unchecked_isa_dma : 1;
2100 sfp->cmd_q = SG_DEF_COMMAND_Q;
2101 sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
2102 sfp->parentdp = sdp;
2103 write_lock_irqsave(&sg_dev_arr_lock, iflags);
2104 if (! sdp->headfp)
2105 sdp->headfp = sfp;
2106 else { /* add to tail of existing list */
2107 Sg_fd * pfp = sdp->headfp;
2108 while (pfp->nextfp)
2109 pfp = pfp->nextfp;
2110 pfp->nextfp = sfp;
2111 }
2112 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2113 SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p, m_s=%d\n",
2114 sfp, (int)sfp->fd_mem_src));
2115 sg_build_reserve(sfp, sg_big_buff);
2116 SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
2117 sfp->reserve.bufflen, sfp->reserve.k_use_sg));
2118 return sfp;
2119 }
2120
2121 static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp)
2122 {
2123 Sg_request * srp;
2124 Sg_request * tsrp;
2125 int dirty = 0;
2126 int res = 0;
2127
2128 srp = sfp->headrp;
2129 if (srp) {
2130 while (srp) {
2131 tsrp = srp->nextrp;
2132 if (srp->done)
2133 sg_finish_rem_req(srp);
2134 else
2135 ++dirty;
2136 srp = tsrp;
2137 }
2138 }
2139 if (0 == dirty) {
2140 Sg_fd * fp;
2141 Sg_fd * prev_fp;
2142 unsigned long iflags;
2143
2144 write_lock_irqsave(&sg_dev_arr_lock, iflags);
2145 prev_fp = sdp->headfp;
2146 if (sfp == prev_fp)
2147 sdp->headfp = prev_fp->nextfp;
2148 else {
2149 while ((fp = prev_fp->nextfp)) {
2150 if (sfp == fp) {
2151 prev_fp->nextfp = fp->nextfp;
2152 break;
2153 }
2154 prev_fp = fp;
2155 }
2156 }
2157 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2158 if (sfp->reserve.bufflen > 0) {
2159 SCSI_LOG_TIMEOUT(6, printk("sg_remove_sfp: bufflen=%d, k_use_sg=%d\n",
2160 (int)sfp->reserve.bufflen, (int)sfp->reserve.k_use_sg));
2161 sg_remove_scat(&sfp->reserve);
2162 }
2163 sfp->parentdp = NULL;
2164 SCSI_LOG_TIMEOUT(6, printk("sg_remove_sfp: sfp=0x%p\n", sfp));
2165 sg_low_free((char *)sfp, sizeof(Sg_fd), sfp->fd_mem_src);
2166 if (sdp->detached && (NULL == sdp->headfp)) {
2167 int k, maxd;
2168
2169 maxd = sg_template.dev_max;
2170 for (k = 0; k < maxd; ++k) {
2171 if (sdp == sg_dev_arr[k])
2172 break;
2173 }
2174 if (k < maxd)
2175 sg_dev_arr[k] = NULL;
2176 kfree((char *)sdp);
2177 }
2178 res = 1;
2179 }
2180 else {
2181 sfp->closed = 1; /* flag dirty state on this fd */
2182 SCSI_LOG_TIMEOUT(1, printk(
2183 "sg_remove_sfp: worrisome, %d writes pending\n", dirty));
2184 }
2185 return res;
2186 }
2187
2188 static int sg_res_in_use(Sg_fd * sfp)
2189 {
2190 const Sg_request * srp;
2191 unsigned long iflags;
2192
2193 read_lock_irqsave(&sfp->rq_list_lock, iflags);
2194 for (srp = sfp->headrp; srp; srp = srp->nextrp)
2195 if (srp->res_used) break;
2196 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2197 return srp ? 1 : 0;
2198 }
2199
2200 static int sg_dio_in_use(Sg_fd * sfp)
2201 {
2202 const Sg_request * srp;
2203 unsigned long iflags;
2204
2205 read_lock_irqsave(&sfp->rq_list_lock, iflags);
2206 for (srp = sfp->headrp; srp; srp = srp->nextrp)
2207 if ((! srp->done) && srp->data.kiobp) break;
2208 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2209 return srp ? 1 : 0;
2210 }
2211
2212 /* If retSzp==NULL want exact size or fail */
2213 /* sg_low_malloc() should always be called from a process context allowing
2214 GFP_KERNEL to be used instead of GFP_ATOMIC */
2215 static char * sg_low_malloc(int rqSz, int lowDma, int mem_src, int * retSzp)
2216 {
2217 char * resp = NULL;
2218 int page_mask = lowDma ? (GFP_KERNEL | GFP_DMA) : GFP_KERNEL;
2219
2220 if (rqSz <= 0)
2221 return resp;
2222 if (SG_HEAP_KMAL == mem_src) {
2223 page_mask = lowDma ? (GFP_ATOMIC | GFP_DMA) : GFP_ATOMIC;
2224 /* Seen kmalloc(..,GFP_KERNEL) hang for 40 secs! */
2225 resp = kmalloc(rqSz, page_mask);
2226 if (resp && retSzp) *retSzp = rqSz;
2227 return resp;
2228 }
2229 if (SG_HEAP_POOL == mem_src) {
2230 int num_sect = rqSz / SG_SECTOR_SZ;
2231
2232 if (0 != (rqSz & SG_SECTOR_MSK)) {
2233 if (! retSzp)
2234 return resp;
2235 ++num_sect;
2236 rqSz = num_sect * SG_SECTOR_SZ;
2237 }
2238 while (num_sect > 0) {
2239 if ((num_sect <= sg_pool_secs_avail) &&
2240 (scsi_dma_free_sectors > (SG_LOW_POOL_THRESHHOLD + num_sect))) {
2241 resp = scsi_malloc(rqSz);
2242 if (resp) {
2243 if (retSzp) *retSzp = rqSz;
2244 sg_pool_secs_avail -= num_sect;
2245 return resp;
2246 }
2247 }
2248 if (! retSzp)
2249 return resp;
2250 num_sect /= 2; /* try half as many */
2251 rqSz = num_sect * SG_SECTOR_SZ;
2252 }
2253 }
2254 else if (SG_HEAP_PAGE == mem_src) {
2255 int order, a_size;
2256 int resSz = rqSz;
2257
2258 for (order = 0, a_size = PAGE_SIZE;
2259 a_size < rqSz; order++, a_size <<= 1)
2260 ;
2261 resp = (char *)__get_free_pages(page_mask, order);
2262 while ((! resp) && order && retSzp) {
2263 --order;
2264 a_size >>= 1; /* divide by 2, until PAGE_SIZE */
2265 resp = (char *)__get_free_pages(page_mask, order); /* try half */
2266 resSz = a_size;
2267 }
2268 if (retSzp) *retSzp = resSz;
2269 }
2270 else
2271 printk("sg_low_malloc: bad mem_src=%d, rqSz=%df\n", mem_src, rqSz);
2272 return resp;
2273 }
2274
2275 static char * sg_malloc(const Sg_fd * sfp, int size, int * retSzp,
2276 int * mem_srcp)
2277 {
2278 char * resp = NULL;
2279
2280 if (retSzp) *retSzp = size;
2281 if (size <= 0)
2282 ;
2283 else {
2284 int low_dma = sfp->low_dma;
2285 int l_ms = -1; /* invalid value */
2286
2287 switch (*mem_srcp)
2288 {
2289 case SG_HEAP_PAGE:
2290 l_ms = (size < PAGE_SIZE) ? SG_HEAP_POOL : SG_HEAP_PAGE;
2291 resp = sg_low_malloc(size, low_dma, l_ms, 0);
2292 if (resp)
2293 break;
2294 resp = sg_low_malloc(size, low_dma, l_ms, &size);
2295 if (! resp) {
2296 l_ms = (SG_HEAP_POOL == l_ms) ? SG_HEAP_PAGE : SG_HEAP_POOL;
2297 resp = sg_low_malloc(size, low_dma, l_ms, &size);
2298 if (! resp) {
2299 l_ms = SG_HEAP_KMAL;
2300 resp = sg_low_malloc(size, low_dma, l_ms, &size);
2301 }
2302 }
2303 if (resp && retSzp) *retSzp = size;
2304 break;
2305 case SG_HEAP_KMAL:
2306 l_ms = SG_HEAP_PAGE;
2307 resp = sg_low_malloc(size, low_dma, l_ms, 0);
2308 if (resp)
2309 break;
2310 l_ms = SG_HEAP_POOL;
2311 resp = sg_low_malloc(size, low_dma, l_ms, &size);
2312 if (resp && retSzp) *retSzp = size;
2313 break;
2314 default:
2315 SCSI_LOG_TIMEOUT(1, printk("sg_malloc: bad ms=%d\n", *mem_srcp));
2316 break;
2317 }
2318 if (resp) *mem_srcp = l_ms;
2319 }
2320 SCSI_LOG_TIMEOUT(6, printk("sg_malloc: size=%d, ms=%d, ret=0x%p\n",
2321 size, *mem_srcp, resp));
2322 return resp;
2323 }
2324
2325 static void sg_low_free(char * buff, int size, int mem_src)
2326 {
2327 if (! buff) return;
2328 switch (mem_src) {
2329 case SG_HEAP_POOL:
2330 {
2331 int num_sect = size / SG_SECTOR_SZ;
2332
2333 scsi_free(buff, size);
2334 sg_pool_secs_avail += num_sect;
2335 }
2336 break;
2337 case SG_HEAP_KMAL:
2338 kfree(buff); /* size not used */
2339 break;
2340 case SG_HEAP_PAGE:
2341 {
2342 int order, a_size;
2343 for (order = 0, a_size = PAGE_SIZE;
2344 a_size < size; order++, a_size <<= 1)
2345 ;
2346 free_pages((unsigned long)buff, order);
2347 }
2348 break;
2349 case SG_USER_MEM:
2350 break; /* nothing to do */
2351 default:
2352 printk("sg_low_free: bad mem_src=%d, buff=0x%p, rqSz=%df\n",
2353 mem_src, buff, size);
2354 break;
2355 }
2356 }
2357
2358 static void sg_free(char * buff, int size, int mem_src)
2359 {
2360 SCSI_LOG_TIMEOUT(6,
2361 printk("sg_free: buff=0x%p, size=%d\n", buff, size));
2362 if ((! buff) || (size <= 0))
2363 ;
2364 else
2365 sg_low_free(buff, size, mem_src);
2366 }
2367
2368 static void sg_clr_srpnt(Scsi_Request * SRpnt)
2369 {
2370 SRpnt->sr_use_sg = 0;
2371 SRpnt->sr_sglist_len = 0;
2372 SRpnt->sr_bufflen = 0;
2373 SRpnt->sr_buffer = NULL;
2374 SRpnt->sr_underflow = 0;
2375 SRpnt->sr_request.rq_dev = MKDEV(0, 0); /* "sg" _disowns_ command blk */
2376 }
2377
2378 static int sg_ms_to_jif(unsigned int msecs)
2379 {
2380 if ((UINT_MAX / 2U) < msecs)
2381 return INT_MAX; /* special case, set largest possible */
2382 else
2383 return ((int)msecs < (INT_MAX / 1000)) ? (((int)msecs * HZ) / 1000)
2384 : (((int)msecs / 1000) * HZ);
2385 }
2386
2387 static unsigned sg_jif_to_ms(int jifs)
2388 {
2389 if (jifs <= 0)
2390 return 0U;
2391 else {
2392 unsigned int j = (unsigned int)jifs;
2393 return (j < (UINT_MAX / 1000)) ? ((j * 1000) / HZ) : ((j / HZ) * 1000);
2394 }
2395 }
2396
2397 static unsigned char allow_ops[] = {TEST_UNIT_READY, INQUIRY,
2398 READ_CAPACITY, READ_BUFFER, READ_6, READ_10, READ_12,
2399 MODE_SENSE, MODE_SENSE_10};
2400
2401 static int sg_allow_access(unsigned char opcode, char dev_type)
2402 {
2403 int k;
2404
2405 if (TYPE_SCANNER == dev_type) /* TYPE_ROM maybe burner */
2406 return 1;
2407 for (k = 0; k < sizeof(allow_ops); ++k) {
2408 if (opcode == allow_ops[k])
2409 return 1;
2410 }
2411 return 0;
2412 }
2413
2414
2415 #ifdef CONFIG_PROC_FS
2416 static int sg_last_dev()
2417 {
2418 int k;
2419 unsigned long iflags;
2420
2421 read_lock_irqsave(&sg_dev_arr_lock, iflags);
2422 for (k = sg_template.dev_max - 1; k >= 0; --k)
2423 if (sg_dev_arr[k] && sg_dev_arr[k]->device) break;
2424 read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2425 return k + 1; /* origin 1 */
2426 }
2427 #endif
2428
2429 static Sg_device * sg_get_dev(int dev)
2430 {
2431 Sg_device * sdp = NULL;
2432 unsigned long iflags;
2433
2434 if (sg_dev_arr && (dev >= 0))
2435 {
2436 read_lock_irqsave(&sg_dev_arr_lock, iflags);
2437 if (dev < sg_template.dev_max)
2438 sdp = sg_dev_arr[dev];
2439 read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2440 }
2441 return sdp;
2442 }
2443
2444 #ifdef CONFIG_PROC_FS
2445
2446 static struct proc_dir_entry * sg_proc_sgp = NULL;
2447
2448 static const char * sg_proc_sg_dirname = "sg";
2449 static const char * sg_proc_leaf_names[] = {"def_reserved_size", "debug",
2450 "devices", "device_hdr", "device_strs",
2451 "hosts", "host_hdr", "host_strs", "version"};
2452
2453 static int sg_proc_dressz_read(char * buffer, char ** start, off_t offset,
2454 int size, int * eof, void * data);
2455 static int sg_proc_dressz_info(char * buffer, int * len, off_t * begin,
2456 off_t offset, int size);
2457 static int sg_proc_dressz_write(struct file * filp, const char * buffer,
2458 unsigned long count, void * data);
2459 static int sg_proc_debug_read(char * buffer, char ** start, off_t offset,
2460 int size, int * eof, void * data);
2461 static int sg_proc_debug_info(char * buffer, int * len, off_t * begin,
2462 off_t offset, int size);
2463 static int sg_proc_dev_read(char * buffer, char ** start, off_t offset,
2464 int size, int * eof, void * data);
2465 static int sg_proc_dev_info(char * buffer, int * len, off_t * begin,
2466 off_t offset, int size);
2467 static int sg_proc_devhdr_read(char * buffer, char ** start, off_t offset,
2468 int size, int * eof, void * data);
2469 static int sg_proc_devhdr_info(char * buffer, int * len, off_t * begin,
2470 off_t offset, int size);
2471 static int sg_proc_devstrs_read(char * buffer, char ** start, off_t offset,
2472 int size, int * eof, void * data);
2473 static int sg_proc_devstrs_info(char * buffer, int * len, off_t * begin,
2474 off_t offset, int size);
2475 static int sg_proc_host_read(char * buffer, char ** start, off_t offset,
2476 int size, int * eof, void * data);
2477 static int sg_proc_host_info(char * buffer, int * len, off_t * begin,
2478 off_t offset, int size);
2479 static int sg_proc_hosthdr_read(char * buffer, char ** start, off_t offset,
2480 int size, int * eof, void * data);
2481 static int sg_proc_hosthdr_info(char * buffer, int * len, off_t * begin,
2482 off_t offset, int size);
2483 static int sg_proc_hoststrs_read(char * buffer, char ** start, off_t offset,
2484 int size, int * eof, void * data);
2485 static int sg_proc_hoststrs_info(char * buffer, int * len, off_t * begin,
2486 off_t offset, int size);
2487 static int sg_proc_version_read(char * buffer, char ** start, off_t offset,
2488 int size, int * eof, void * data);
2489 static int sg_proc_version_info(char * buffer, int * len, off_t * begin,
2490 off_t offset, int size);
2491 static read_proc_t * sg_proc_leaf_reads[] = {
2492 sg_proc_dressz_read, sg_proc_debug_read,
2493 sg_proc_dev_read, sg_proc_devhdr_read, sg_proc_devstrs_read,
2494 sg_proc_host_read, sg_proc_hosthdr_read, sg_proc_hoststrs_read,
2495 sg_proc_version_read};
2496 static write_proc_t * sg_proc_leaf_writes[] = {
2497 sg_proc_dressz_write, 0, 0, 0, 0, 0, 0, 0, 0};
2498
2499 #define PRINT_PROC(fmt,args...) \
2500 do { \
2501 *len += sprintf(buffer + *len, fmt, ##args); \
2502 if (*begin + *len > offset + size) \
2503 return 0; \
2504 if (*begin + *len < offset) { \
2505 *begin += *len; \
2506 *len = 0; \
2507 } \
2508 } while(0)
2509
2510 #define SG_PROC_READ_FN(infofp) \
2511 do { \
2512 int len = 0; \
2513 off_t begin = 0; \
2514 *eof = infofp(buffer, &len, &begin, offset, size); \
2515 if (offset >= (begin + len)) \
2516 return 0; \
2517 *start = buffer + offset - begin; \
2518 return (size < (begin + len - offset)) ? \
2519 size : begin + len - offset; \
2520 } while(0)
2521
2522
2523 static int sg_proc_init()
2524 {
2525 int k, mask;
2526 int leaves = sizeof(sg_proc_leaf_names) / sizeof(sg_proc_leaf_names[0]);
2527 struct proc_dir_entry * pdep;
2528
2529 if (! proc_scsi)
2530 return 1;
2531 sg_proc_sgp = create_proc_entry(sg_proc_sg_dirname,
2532 S_IFDIR | S_IRUGO | S_IXUGO, proc_scsi);
2533 if (! sg_proc_sgp)
2534 return 1;
2535 for (k = 0; k < leaves; ++k) {
2536 mask = sg_proc_leaf_writes[k] ? S_IRUGO | S_IWUSR : S_IRUGO;
2537 pdep = create_proc_entry(sg_proc_leaf_names[k], mask, sg_proc_sgp);
2538 if (pdep) {
2539 pdep->read_proc = sg_proc_leaf_reads[k];
2540 if (sg_proc_leaf_writes[k])
2541 pdep->write_proc = sg_proc_leaf_writes[k];
2542 }
2543 }
2544 return 0;
2545 }
2546
2547 static void sg_proc_cleanup()
2548 {
2549 int k;
2550 int leaves = sizeof(sg_proc_leaf_names) / sizeof(sg_proc_leaf_names[0]);
2551
2552 if ((! proc_scsi) || (! sg_proc_sgp))
2553 return;
2554 for (k = 0; k < leaves; ++k)
2555 remove_proc_entry(sg_proc_leaf_names[k], sg_proc_sgp);
2556 remove_proc_entry(sg_proc_sg_dirname, proc_scsi);
2557 }
2558
2559 static int sg_proc_dressz_read(char * buffer, char ** start, off_t offset,
2560 int size, int * eof, void * data)
2561 { SG_PROC_READ_FN(sg_proc_dressz_info); }
2562
2563 static int sg_proc_dressz_info(char * buffer, int * len, off_t * begin,
2564 off_t offset, int size)
2565 {
2566 PRINT_PROC("%d\n", sg_big_buff);
2567 return 1;
2568 }
2569
2570 static int sg_proc_dressz_write(struct file * filp, const char * buffer,
2571 unsigned long count, void * data)
2572 {
2573 int num;
2574 unsigned long k = ULONG_MAX;
2575 char buff[11];
2576
2577 if (! capable(CAP_SYS_ADMIN))
2578 return -EACCES;
2579 num = (count < 10) ? count : 10;
2580 copy_from_user(buff, buffer, num);
2581 buff[count] = '\0';
2582 k = simple_strtoul(buff, 0, 10);
2583 if (k <= 1048576) {
2584 sg_big_buff = k;
2585 return count;
2586 }
2587 return -ERANGE;
2588 }
2589
2590 static int sg_proc_debug_read(char * buffer, char ** start, off_t offset,
2591 int size, int * eof, void * data)
2592 { SG_PROC_READ_FN(sg_proc_debug_info); }
2593
2594 static int sg_proc_debug_info(char * buffer, int * len, off_t * begin,
2595 off_t offset, int size)
2596 {
2597 Sg_device * sdp;
2598 const sg_io_hdr_t * hp;
2599 int j, max_dev;
2600
2601 if (NULL == sg_dev_arr) {
2602 PRINT_PROC("sg_dev_arr NULL, driver not initialized\n");
2603 return 1;
2604 }
2605 max_dev = sg_last_dev();
2606 PRINT_PROC("dev_max(currently)=%d max_active_device=%d (origin 1)\n",
2607 sg_template.dev_max, max_dev);
2608 PRINT_PROC(" scsi_dma_free_sectors=%u sg_pool_secs_aval=%d "
2609 "def_reserved_size=%d\n",
2610 scsi_dma_free_sectors, sg_pool_secs_avail, sg_big_buff);
2611 for (j = 0; j < max_dev; ++j) {
2612 if ((sdp = sg_get_dev(j))) {
2613 Sg_fd * fp;
2614 Sg_request * srp;
2615 struct scsi_device * scsidp;
2616 int dev, k, m, blen, usg;
2617
2618 if (! (scsidp = sdp->device)) {
2619 PRINT_PROC("device %d detached ??\n", j);
2620 continue;
2621 }
2622 dev = MINOR(sdp->i_rdev);
2623
2624 if (sg_get_nth_sfp(sdp, 0)) {
2625 PRINT_PROC(" >>> device=sg%d ", dev);
2626 PRINT_PROC("scsi%d chan=%d id=%d lun=%d em=%d sg_tablesize=%d"
2627 " excl=%d\n", scsidp->host->host_no, scsidp->channel,
2628 scsidp->id, scsidp->lun, scsidp->host->hostt->emulated,
2629 sdp->sg_tablesize, sdp->exclude);
2630 }
2631 for (k = 0; (fp = sg_get_nth_sfp(sdp, k)); ++k) {
2632 PRINT_PROC(" FD(%d): timeout=%dms bufflen=%d "
2633 "(res)sgat=%d low_dma=%d\n", k + 1,
2634 sg_jif_to_ms(fp->timeout), fp->reserve.bufflen,
2635 (int)fp->reserve.k_use_sg, (int)fp->low_dma);
2636 PRINT_PROC(" cmd_q=%d f_packid=%d k_orphan=%d closed=%d\n",
2637 (int)fp->cmd_q, (int)fp->force_packid,
2638 (int)fp->keep_orphan, (int)fp->closed);
2639 for (m = 0; (srp = sg_get_nth_request(fp, m)); ++m) {
2640 hp = &srp->header;
2641 /* stop indenting so far ... */
2642 PRINT_PROC(srp->res_used ? " rb>> " :
2643 ((SG_INFO_DIRECT_IO_MASK & hp->info) ? " dio>> " : " "));
2644 blen = srp->my_cmdp ? srp->my_cmdp->sr_bufflen : srp->data.bufflen;
2645 usg = srp->my_cmdp ? srp->my_cmdp->sr_use_sg : srp->data.k_use_sg;
2646 PRINT_PROC(srp->done ? ((1 == srp->done) ? "rcv:" : "fin:")
2647 : (srp->my_cmdp ? "act:" : "prior:"));
2648 PRINT_PROC(" id=%d blen=%d", srp->header.pack_id, blen);
2649 if (srp->done)
2650 PRINT_PROC(" dur=%d", hp->duration);
2651 else
2652 PRINT_PROC(" t_o/elap=%d/%d", ((hp->interface_id == '\0') ?
2653 sg_jif_to_ms(fp->timeout) : hp->timeout),
2654 sg_jif_to_ms(hp->duration ? (jiffies - hp->duration) : 0));
2655 PRINT_PROC("ms sgat=%d op=0x%02x\n", usg, (int)srp->data.cmd_opcode);
2656 /* reset indenting */
2657 }
2658 if (0 == m)
2659 PRINT_PROC(" No requests active\n");
2660 }
2661 }
2662 }
2663 return 1;
2664 }
2665
2666 static int sg_proc_dev_read(char * buffer, char ** start, off_t offset,
2667 int size, int * eof, void * data)
2668 { SG_PROC_READ_FN(sg_proc_dev_info); }
2669
2670 static int sg_proc_dev_info(char * buffer, int * len, off_t * begin,
2671 off_t offset, int size)
2672 {
2673 Sg_device * sdp;
2674 int j, max_dev;
2675 struct scsi_device * scsidp;
2676
2677 max_dev = sg_last_dev();
2678 for (j = 0; j < max_dev; ++j) {
2679 sdp = sg_get_dev(j);
2680 if (sdp && (scsidp = sdp->device))
2681 PRINT_PROC("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
2682 scsidp->host->host_no, scsidp->channel, scsidp->id,
2683 scsidp->lun, (int)scsidp->type, (int)scsidp->access_count,
2684 (int)scsidp->queue_depth, (int)scsidp->device_busy);
2685 else
2686 PRINT_PROC("-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
2687 }
2688 return 1;
2689 }
2690
2691 static int sg_proc_devhdr_read(char * buffer, char ** start, off_t offset,
2692 int size, int * eof, void * data)
2693 { SG_PROC_READ_FN(sg_proc_devhdr_info); }
2694
2695 static int sg_proc_devhdr_info(char * buffer, int * len, off_t * begin,
2696 off_t offset, int size)
2697 {
2698 PRINT_PROC("host\tchan\tid\tlun\ttype\tbopens\tqdepth\tbusy\n");
2699 return 1;
2700 }
2701
2702 static int sg_proc_devstrs_read(char * buffer, char ** start, off_t offset,
2703 int size, int * eof, void * data)
2704 { SG_PROC_READ_FN(sg_proc_devstrs_info); }
2705
2706 static int sg_proc_devstrs_info(char * buffer, int * len, off_t * begin,
2707 off_t offset, int size)
2708 {
2709 Sg_device * sdp;
2710 int j, max_dev;
2711 struct scsi_device * scsidp;
2712
2713 max_dev = sg_last_dev();
2714 for (j = 0; j < max_dev; ++j) {
2715 sdp = sg_get_dev(j);
2716 if (sdp && (scsidp = sdp->device))
2717 PRINT_PROC("%8.8s\t%16.16s\t%4.4s\n",
2718 scsidp->vendor, scsidp->model, scsidp->rev);
2719 else
2720 PRINT_PROC("<no active device>\n");
2721 }
2722 return 1;
2723 }
2724
2725 static int sg_proc_host_read(char * buffer, char ** start, off_t offset,
2726 int size, int * eof, void * data)
2727 { SG_PROC_READ_FN(sg_proc_host_info); }
2728
2729 static int sg_proc_host_info(char * buffer, int * len, off_t * begin,
2730 off_t offset, int size)
2731 {
2732 struct Scsi_Host * shp;
2733 int k;
2734
2735 for (k = 0, shp = scsi_hostlist; shp; shp = shp->next, ++k) {
2736 for ( ; k < shp->host_no; ++k)
2737 PRINT_PROC("-1\t-1\t-1\t-1\t-1\t-1\n");
2738 PRINT_PROC("%u\t%hu\t%hd\t%hu\t%d\t%d\n",
2739 shp->unique_id, shp->host_busy, shp->cmd_per_lun,
2740 shp->sg_tablesize, (int)shp->unchecked_isa_dma,
2741 (int)shp->hostt->emulated);
2742 }
2743 return 1;
2744 }
2745
2746 static int sg_proc_hosthdr_read(char * buffer, char ** start, off_t offset,
2747 int size, int * eof, void * data)
2748 { SG_PROC_READ_FN(sg_proc_hosthdr_info); }
2749
2750 static int sg_proc_hosthdr_info(char * buffer, int * len, off_t * begin,
2751 off_t offset, int size)
2752 {
2753 PRINT_PROC("uid\tbusy\tcpl\tscatg\tisa\temul\n");
2754 return 1;
2755 }
2756
2757 static int sg_proc_hoststrs_read(char * buffer, char ** start, off_t offset,
2758 int size, int * eof, void * data)
2759 { SG_PROC_READ_FN(sg_proc_hoststrs_info); }
2760
2761 static int sg_proc_hoststrs_info(char * buffer, int * len, off_t * begin,
2762 off_t offset, int size)
2763 {
2764 struct Scsi_Host * shp;
2765 int k;
2766
2767 for (k = 0, shp = scsi_hostlist; shp; shp = shp->next, ++k) {
2768 for ( ; k < shp->host_no; ++k)
2769 PRINT_PROC("<no active host>\n");
2770 PRINT_PROC("%s\n", shp->hostt->info ? shp->hostt->info(shp) :
2771 (shp->hostt->name ? shp->hostt->name : "<no name>"));
2772 }
2773 return 1;
2774 }
2775
2776 static int sg_proc_version_read(char * buffer, char ** start, off_t offset,
2777 int size, int * eof, void * data)
2778 { SG_PROC_READ_FN(sg_proc_version_info); }
2779
2780 static int sg_proc_version_info(char * buffer, int * len, off_t * begin,
2781 off_t offset, int size)
2782 {
2783 PRINT_PROC("%d\t%s\n", sg_version_num, sg_version_str);
2784 return 1;
2785 }
2786 #endif /* CONFIG_PROC_FS */
2787
2788
2789 module_init(init_sg);
2790 module_exit(exit_sg);
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux