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
7 * Original driver (sg.c):
8 * Copyright (C) 1992 Lawrence Foard
9 * Version 2 and 3 extensions to driver:
10 * Copyright (C) 1998 - 2014 Douglas Gilbert
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
19 static int sg_version_num
= 30536; /* 2 digits for each component */
20 #define SG_VERSION_STR "3.5.36"
23 * D. P. Gilbert (dgilbert@interlog.com), notes:
24 * - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
25 * the kernel/module needs to be built with CONFIG_SCSI_LOGGING
26 * (otherwise the macros compile to empty statements).
29 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/string.h>
36 #include <linux/aio.h>
37 #include <linux/errno.h>
38 #include <linux/mtio.h>
39 #include <linux/ioctl.h>
40 #include <linux/slab.h>
41 #include <linux/fcntl.h>
42 #include <linux/init.h>
43 #include <linux/poll.h>
44 #include <linux/moduleparam.h>
45 #include <linux/cdev.h>
46 #include <linux/idr.h>
47 #include <linux/seq_file.h>
48 #include <linux/blkdev.h>
49 #include <linux/delay.h>
50 #include <linux/blktrace_api.h>
51 #include <linux/mutex.h>
52 #include <linux/atomic.h>
53 #include <linux/ratelimit.h>
56 #include <scsi/scsi_dbg.h>
57 #include <scsi/scsi_host.h>
58 #include <scsi/scsi_driver.h>
59 #include <scsi/scsi_ioctl.h>
62 #include "scsi_logging.h"
64 #ifdef CONFIG_SCSI_PROC_FS
65 #include <linux/proc_fs.h>
66 static char *sg_version_date
= "20140603";
68 static int sg_proc_init(void);
69 static void sg_proc_cleanup(void);
72 #define SG_ALLOW_DIO_DEF 0
74 #define SG_MAX_DEVS 32768
76 /* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
77 * of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
78 * than 16 bytes are "variable length" whose length is a multiple of 4
80 #define SG_MAX_CDB_SIZE 252
83 * Suppose you want to calculate the formula muldiv(x,m,d)=int(x * m / d)
84 * Then when using 32 bit integers x * m may overflow during the calculation.
85 * Replacing muldiv(x) by muldiv(x)=((x % d) * m) / d + int(x / d) * m
86 * calculates the same, but prevents the overflow when both m and d
87 * are "small" numbers (like HZ and USER_HZ).
88 * Of course an overflow is inavoidable if the result of muldiv doesn't fit
91 #define MULDIV(X,MUL,DIV) ((((X % DIV) * MUL) / DIV) + ((X / DIV) * MUL))
93 #define SG_DEFAULT_TIMEOUT MULDIV(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
95 int sg_big_buff
= SG_DEF_RESERVED_SIZE
;
96 /* N.B. This variable is readable and writeable via
97 /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
98 of this size (or less if there is not enough memory) will be reserved
99 for use by this file descriptor. [Deprecated usage: this variable is also
100 readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
101 the kernel (i.e. it is not a module).] */
102 static int def_reserved_size
= -1; /* picks up init parameter */
103 static int sg_allow_dio
= SG_ALLOW_DIO_DEF
;
105 static int scatter_elem_sz
= SG_SCATTER_SZ
;
106 static int scatter_elem_sz_prev
= SG_SCATTER_SZ
;
108 #define SG_SECTOR_SZ 512
110 static int sg_add_device(struct device
*, struct class_interface
*);
111 static void sg_remove_device(struct device
*, struct class_interface
*);
113 static DEFINE_IDR(sg_index_idr
);
114 static DEFINE_RWLOCK(sg_index_lock
); /* Also used to lock
115 file descriptor list for device */
117 static struct class_interface sg_interface
= {
118 .add_dev
= sg_add_device
,
119 .remove_dev
= sg_remove_device
,
122 typedef struct sg_scatter_hold
{ /* holding area for scsi scatter gather info */
123 unsigned short k_use_sg
; /* Count of kernel scatter-gather pieces */
124 unsigned sglist_len
; /* size of malloc'd scatter-gather list ++ */
125 unsigned bufflen
; /* Size of (aggregate) data buffer */
128 char dio_in_use
; /* 0->indirect IO (or mmap), 1->dio */
129 unsigned char cmd_opcode
; /* first byte of command */
132 struct sg_device
; /* forward declarations */
135 typedef struct sg_request
{ /* SG_MAX_QUEUE requests outstanding per file */
136 struct sg_request
*nextrp
; /* NULL -> tail request (slist) */
137 struct sg_fd
*parentfp
; /* NULL -> not in use */
138 Sg_scatter_hold data
; /* hold buffer, perhaps scatter list */
139 sg_io_hdr_t header
; /* scsi command+info, see <scsi/sg.h> */
140 unsigned char sense_b
[SCSI_SENSE_BUFFERSIZE
];
141 char res_used
; /* 1 -> using reserve buffer, 0 -> not ... */
142 char orphan
; /* 1 -> drop on sight, 0 -> normal */
143 char sg_io_owned
; /* 1 -> packet belongs to SG_IO */
144 /* done protected by rq_list_lock */
145 char done
; /* 0->before bh, 1->before read, 2->read */
148 struct execute_work ew
;
151 typedef struct sg_fd
{ /* holds the state of a file descriptor */
152 struct list_head sfd_siblings
; /* protected by device's sfd_lock */
153 struct sg_device
*parentdp
; /* owning device */
154 wait_queue_head_t read_wait
; /* queue read until command done */
155 rwlock_t rq_list_lock
; /* protect access to list in req_arr */
156 int timeout
; /* defaults to SG_DEFAULT_TIMEOUT */
157 int timeout_user
; /* defaults to SG_DEFAULT_TIMEOUT_USER */
158 Sg_scatter_hold reserve
; /* buffer held for this file descriptor */
159 unsigned save_scat_len
; /* original length of trunc. scat. element */
160 Sg_request
*headrp
; /* head of request slist, NULL->empty */
161 struct fasync_struct
*async_qp
; /* used by asynchronous notification */
162 Sg_request req_arr
[SG_MAX_QUEUE
]; /* used as singly-linked list */
163 char low_dma
; /* as in parent but possibly overridden to 1 */
164 char force_packid
; /* 1 -> pack_id input to read(), 0 -> ignored */
165 char cmd_q
; /* 1 -> allow command queuing, 0 -> don't */
166 unsigned char next_cmd_len
; /* 0: automatic, >0: use on next write() */
167 char keep_orphan
; /* 0 -> drop orphan (def), 1 -> keep for read() */
168 char mmap_called
; /* 0 -> mmap() never called on this fd */
170 struct execute_work ew
;
173 typedef struct sg_device
{ /* holds the state of each scsi generic device */
174 struct scsi_device
*device
;
175 wait_queue_head_t open_wait
; /* queue open() when O_EXCL present */
176 struct mutex open_rel_lock
; /* held when in open() or release() */
177 int sg_tablesize
; /* adapter's max scatter-gather table size */
178 u32 index
; /* device index number */
179 struct list_head sfds
;
180 rwlock_t sfd_lock
; /* protect access to sfd list */
181 atomic_t detaching
; /* 0->device usable, 1->device detaching */
182 bool exclude
; /* 1->open(O_EXCL) succeeded and is active */
183 int open_cnt
; /* count of opens (perhaps < num(sfds) ) */
184 char sgdebug
; /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
185 struct gendisk
*disk
;
186 struct cdev
* cdev
; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
190 /* tasklet or soft irq callback */
191 static void sg_rq_end_io(struct request
*rq
, int uptodate
);
192 static int sg_start_req(Sg_request
*srp
, unsigned char *cmd
);
193 static int sg_finish_rem_req(Sg_request
* srp
);
194 static int sg_build_indirect(Sg_scatter_hold
* schp
, Sg_fd
* sfp
, int buff_size
);
195 static ssize_t
sg_new_read(Sg_fd
* sfp
, char __user
*buf
, size_t count
,
197 static ssize_t
sg_new_write(Sg_fd
*sfp
, struct file
*file
,
198 const char __user
*buf
, size_t count
, int blocking
,
199 int read_only
, int sg_io_owned
, Sg_request
**o_srp
);
200 static int sg_common_write(Sg_fd
* sfp
, Sg_request
* srp
,
201 unsigned char *cmnd
, int timeout
, int blocking
);
202 static int sg_read_oxfer(Sg_request
* srp
, char __user
*outp
, int num_read_xfer
);
203 static void sg_remove_scat(Sg_scatter_hold
* schp
);
204 static void sg_build_reserve(Sg_fd
* sfp
, int req_size
);
205 static void sg_link_reserve(Sg_fd
* sfp
, Sg_request
* srp
, int size
);
206 static void sg_unlink_reserve(Sg_fd
* sfp
, Sg_request
* srp
);
207 static Sg_fd
*sg_add_sfp(Sg_device
* sdp
, int dev
);
208 static void sg_remove_sfp(struct kref
*);
209 static Sg_request
*sg_get_rq_mark(Sg_fd
* sfp
, int pack_id
);
210 static Sg_request
*sg_add_request(Sg_fd
* sfp
);
211 static int sg_remove_request(Sg_fd
* sfp
, Sg_request
* srp
);
212 static int sg_res_in_use(Sg_fd
* sfp
);
213 static Sg_device
*sg_get_dev(int dev
);
214 static void sg_device_destroy(struct kref
*kref
);
216 #define SZ_SG_HEADER sizeof(struct sg_header)
217 #define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
218 #define SZ_SG_IOVEC sizeof(sg_iovec_t)
219 #define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
221 static int sg_allow_access(struct file
*filp
, unsigned char *cmd
)
223 struct sg_fd
*sfp
= filp
->private_data
;
225 if (sfp
->parentdp
->device
->type
== TYPE_SCANNER
)
228 return blk_verify_command(cmd
, filp
->f_mode
& FMODE_WRITE
);
232 open_wait(Sg_device
*sdp
, int flags
)
236 if (flags
& O_EXCL
) {
237 while (sdp
->open_cnt
> 0) {
238 mutex_unlock(&sdp
->open_rel_lock
);
239 retval
= wait_event_interruptible(sdp
->open_wait
,
240 (atomic_read(&sdp
->detaching
) ||
242 mutex_lock(&sdp
->open_rel_lock
);
244 if (retval
) /* -ERESTARTSYS */
246 if (atomic_read(&sdp
->detaching
))
250 while (sdp
->exclude
) {
251 mutex_unlock(&sdp
->open_rel_lock
);
252 retval
= wait_event_interruptible(sdp
->open_wait
,
253 (atomic_read(&sdp
->detaching
) ||
255 mutex_lock(&sdp
->open_rel_lock
);
257 if (retval
) /* -ERESTARTSYS */
259 if (atomic_read(&sdp
->detaching
))
267 /* Returns 0 on success, else a negated errno value */
269 sg_open(struct inode
*inode
, struct file
*filp
)
271 int dev
= iminor(inode
);
272 int flags
= filp
->f_flags
;
273 struct request_queue
*q
;
278 nonseekable_open(inode
, filp
);
279 SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev
, flags
));
280 if ((flags
& O_EXCL
) && (O_RDONLY
== (flags
& O_ACCMODE
)))
281 return -EPERM
; /* Can't lock it with read only access */
282 sdp
= sg_get_dev(dev
);
286 /* This driver's module count bumped by fops_get in <linux/fs.h> */
287 /* Prevent the device driver from vanishing while we sleep */
288 retval
= scsi_device_get(sdp
->device
);
292 retval
= scsi_autopm_get_device(sdp
->device
);
296 /* scsi_block_when_processing_errors() may block so bypass
297 * check if O_NONBLOCK. Permits SCSI commands to be issued
298 * during error recovery. Tread carefully. */
299 if (!((flags
& O_NONBLOCK
) ||
300 scsi_block_when_processing_errors(sdp
->device
))) {
302 /* we are in error recovery for this device */
306 mutex_lock(&sdp
->open_rel_lock
);
307 if (flags
& O_NONBLOCK
) {
308 if (flags
& O_EXCL
) {
309 if (sdp
->open_cnt
> 0) {
311 goto error_mutex_locked
;
316 goto error_mutex_locked
;
320 retval
= open_wait(sdp
, flags
);
321 if (retval
) /* -ERESTARTSYS or -ENODEV */
322 goto error_mutex_locked
;
325 /* N.B. at this point we are holding the open_rel_lock */
329 if (sdp
->open_cnt
< 1) { /* no existing opens */
331 q
= sdp
->device
->request_queue
;
332 sdp
->sg_tablesize
= queue_max_segments(q
);
334 sfp
= sg_add_sfp(sdp
, dev
);
336 retval
= PTR_ERR(sfp
);
340 filp
->private_data
= sfp
;
342 mutex_unlock(&sdp
->open_rel_lock
);
346 kref_put(&sdp
->d_ref
, sg_device_destroy
);
350 if (flags
& O_EXCL
) {
351 sdp
->exclude
= false; /* undo if error */
352 wake_up_interruptible(&sdp
->open_wait
);
355 mutex_unlock(&sdp
->open_rel_lock
);
357 scsi_autopm_put_device(sdp
->device
);
359 scsi_device_put(sdp
->device
);
363 /* Release resources associated with a successful sg_open()
364 * Returns 0 on success, else a negated errno value */
366 sg_release(struct inode
*inode
, struct file
*filp
)
371 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
373 SCSI_LOG_TIMEOUT(3, printk("sg_release: %s\n", sdp
->disk
->disk_name
));
375 mutex_lock(&sdp
->open_rel_lock
);
376 scsi_autopm_put_device(sdp
->device
);
377 kref_put(&sfp
->f_ref
, sg_remove_sfp
);
380 /* possibly many open()s waiting on exlude clearing, start many;
381 * only open(O_EXCL)s wait on 0==open_cnt so only start one */
383 sdp
->exclude
= false;
384 wake_up_interruptible_all(&sdp
->open_wait
);
385 } else if (0 == sdp
->open_cnt
) {
386 wake_up_interruptible(&sdp
->open_wait
);
388 mutex_unlock(&sdp
->open_rel_lock
);
393 sg_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
* ppos
)
398 int req_pack_id
= -1;
400 struct sg_header
*old_hdr
= NULL
;
403 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
405 SCSI_LOG_TIMEOUT(3, printk("sg_read: %s, count=%d\n",
406 sdp
->disk
->disk_name
, (int) count
));
408 if (!access_ok(VERIFY_WRITE
, buf
, count
))
410 if (sfp
->force_packid
&& (count
>= SZ_SG_HEADER
)) {
411 old_hdr
= kmalloc(SZ_SG_HEADER
, GFP_KERNEL
);
414 if (__copy_from_user(old_hdr
, buf
, SZ_SG_HEADER
)) {
418 if (old_hdr
->reply_len
< 0) {
419 if (count
>= SZ_SG_IO_HDR
) {
420 sg_io_hdr_t
*new_hdr
;
421 new_hdr
= kmalloc(SZ_SG_IO_HDR
, GFP_KERNEL
);
426 retval
=__copy_from_user
427 (new_hdr
, buf
, SZ_SG_IO_HDR
);
428 req_pack_id
= new_hdr
->pack_id
;
436 req_pack_id
= old_hdr
->pack_id
;
438 srp
= sg_get_rq_mark(sfp
, req_pack_id
);
439 if (!srp
) { /* now wait on packet to arrive */
440 if (atomic_read(&sdp
->detaching
)) {
444 if (filp
->f_flags
& O_NONBLOCK
) {
448 retval
= wait_event_interruptible(sfp
->read_wait
,
449 (atomic_read(&sdp
->detaching
) ||
450 (srp
= sg_get_rq_mark(sfp
, req_pack_id
))));
451 if (atomic_read(&sdp
->detaching
)) {
456 /* -ERESTARTSYS as signal hit process */
460 if (srp
->header
.interface_id
!= '\0') {
461 retval
= sg_new_read(sfp
, buf
, count
, srp
);
466 if (old_hdr
== NULL
) {
467 old_hdr
= kmalloc(SZ_SG_HEADER
, GFP_KERNEL
);
473 memset(old_hdr
, 0, SZ_SG_HEADER
);
474 old_hdr
->reply_len
= (int) hp
->timeout
;
475 old_hdr
->pack_len
= old_hdr
->reply_len
; /* old, strange behaviour */
476 old_hdr
->pack_id
= hp
->pack_id
;
477 old_hdr
->twelve_byte
=
478 ((srp
->data
.cmd_opcode
>= 0xc0) && (12 == hp
->cmd_len
)) ? 1 : 0;
479 old_hdr
->target_status
= hp
->masked_status
;
480 old_hdr
->host_status
= hp
->host_status
;
481 old_hdr
->driver_status
= hp
->driver_status
;
482 if ((CHECK_CONDITION
& hp
->masked_status
) ||
483 (DRIVER_SENSE
& hp
->driver_status
))
484 memcpy(old_hdr
->sense_buffer
, srp
->sense_b
,
485 sizeof (old_hdr
->sense_buffer
));
486 switch (hp
->host_status
) {
487 /* This setup of 'result' is for backward compatibility and is best
488 ignored by the user who should use target, host + driver status */
490 case DID_PASSTHROUGH
:
497 old_hdr
->result
= EBUSY
;
504 old_hdr
->result
= EIO
;
507 old_hdr
->result
= (srp
->sense_b
[0] == 0 &&
508 hp
->masked_status
== GOOD
) ? 0 : EIO
;
511 old_hdr
->result
= EIO
;
515 /* Now copy the result back to the user buffer. */
516 if (count
>= SZ_SG_HEADER
) {
517 if (__copy_to_user(buf
, old_hdr
, SZ_SG_HEADER
)) {
522 if (count
> old_hdr
->reply_len
)
523 count
= old_hdr
->reply_len
;
524 if (count
> SZ_SG_HEADER
) {
525 if (sg_read_oxfer(srp
, buf
, count
- SZ_SG_HEADER
)) {
531 count
= (old_hdr
->result
== 0) ? 0 : -EIO
;
532 sg_finish_rem_req(srp
);
540 sg_new_read(Sg_fd
* sfp
, char __user
*buf
, size_t count
, Sg_request
* srp
)
542 sg_io_hdr_t
*hp
= &srp
->header
;
546 if (count
< SZ_SG_IO_HDR
) {
551 if ((hp
->mx_sb_len
> 0) && hp
->sbp
) {
552 if ((CHECK_CONDITION
& hp
->masked_status
) ||
553 (DRIVER_SENSE
& hp
->driver_status
)) {
554 int sb_len
= SCSI_SENSE_BUFFERSIZE
;
555 sb_len
= (hp
->mx_sb_len
> sb_len
) ? sb_len
: hp
->mx_sb_len
;
556 len
= 8 + (int) srp
->sense_b
[7]; /* Additional sense length field */
557 len
= (len
> sb_len
) ? sb_len
: len
;
558 if (copy_to_user(hp
->sbp
, srp
->sense_b
, len
)) {
565 if (hp
->masked_status
|| hp
->host_status
|| hp
->driver_status
)
566 hp
->info
|= SG_INFO_CHECK
;
567 if (copy_to_user(buf
, hp
, SZ_SG_IO_HDR
)) {
572 err
= sg_finish_rem_req(srp
);
573 return (0 == err
) ? count
: err
;
577 sg_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
* ppos
)
579 int mxsize
, cmd_size
, k
;
580 int input_size
, blocking
;
581 unsigned char opcode
;
585 struct sg_header old_hdr
;
587 unsigned char cmnd
[SG_MAX_CDB_SIZE
];
589 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
591 SCSI_LOG_TIMEOUT(3, printk("sg_write: %s, count=%d\n",
592 sdp
->disk
->disk_name
, (int) count
));
593 if (atomic_read(&sdp
->detaching
))
595 if (!((filp
->f_flags
& O_NONBLOCK
) ||
596 scsi_block_when_processing_errors(sdp
->device
)))
599 if (!access_ok(VERIFY_READ
, buf
, count
))
600 return -EFAULT
; /* protects following copy_from_user()s + get_user()s */
601 if (count
< SZ_SG_HEADER
)
603 if (__copy_from_user(&old_hdr
, buf
, SZ_SG_HEADER
))
605 blocking
= !(filp
->f_flags
& O_NONBLOCK
);
606 if (old_hdr
.reply_len
< 0)
607 return sg_new_write(sfp
, filp
, buf
, count
,
608 blocking
, 0, 0, NULL
);
609 if (count
< (SZ_SG_HEADER
+ 6))
610 return -EIO
; /* The minimum scsi command length is 6 bytes. */
612 if (!(srp
= sg_add_request(sfp
))) {
613 SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n"));
617 __get_user(opcode
, buf
);
618 if (sfp
->next_cmd_len
> 0) {
619 cmd_size
= sfp
->next_cmd_len
;
620 sfp
->next_cmd_len
= 0; /* reset so only this write() effected */
622 cmd_size
= COMMAND_SIZE(opcode
); /* based on SCSI command group */
623 if ((opcode
>= 0xc0) && old_hdr
.twelve_byte
)
626 SCSI_LOG_TIMEOUT(4, printk(
627 "sg_write: scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode
, cmd_size
));
628 /* Determine buffer size. */
629 input_size
= count
- cmd_size
;
630 mxsize
= (input_size
> old_hdr
.reply_len
) ? input_size
: old_hdr
.reply_len
;
631 mxsize
-= SZ_SG_HEADER
;
632 input_size
-= SZ_SG_HEADER
;
633 if (input_size
< 0) {
634 sg_remove_request(sfp
, srp
);
635 return -EIO
; /* User did not pass enough bytes for this command. */
638 hp
->interface_id
= '\0'; /* indicator of old interface tunnelled */
639 hp
->cmd_len
= (unsigned char) cmd_size
;
643 hp
->dxfer_direction
= (old_hdr
.reply_len
> SZ_SG_HEADER
) ?
644 SG_DXFER_TO_FROM_DEV
: SG_DXFER_TO_DEV
;
646 hp
->dxfer_direction
= (mxsize
> 0) ? SG_DXFER_FROM_DEV
: SG_DXFER_NONE
;
647 hp
->dxfer_len
= mxsize
;
648 if (hp
->dxfer_direction
== SG_DXFER_TO_DEV
)
649 hp
->dxferp
= (char __user
*)buf
+ cmd_size
;
653 hp
->timeout
= old_hdr
.reply_len
; /* structure abuse ... */
654 hp
->flags
= input_size
; /* structure abuse ... */
655 hp
->pack_id
= old_hdr
.pack_id
;
657 if (__copy_from_user(cmnd
, buf
, cmd_size
))
660 * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
661 * but is is possible that the app intended SG_DXFER_TO_DEV, because there
662 * is a non-zero input_size, so emit a warning.
664 if (hp
->dxfer_direction
== SG_DXFER_TO_FROM_DEV
) {
665 static char cmd
[TASK_COMM_LEN
];
666 if (strcmp(current
->comm
, cmd
)) {
667 printk_ratelimited(KERN_WARNING
668 "sg_write: data in/out %d/%d bytes "
669 "for SCSI command 0x%x-- guessing "
670 "data in;\n program %s not setting "
671 "count and/or reply_len properly\n",
672 old_hdr
.reply_len
- (int)SZ_SG_HEADER
,
673 input_size
, (unsigned int) cmnd
[0],
675 strcpy(cmd
, current
->comm
);
678 k
= sg_common_write(sfp
, srp
, cmnd
, sfp
->timeout
, blocking
);
679 return (k
< 0) ? k
: count
;
683 sg_new_write(Sg_fd
*sfp
, struct file
*file
, const char __user
*buf
,
684 size_t count
, int blocking
, int read_only
, int sg_io_owned
,
690 unsigned char cmnd
[SG_MAX_CDB_SIZE
];
692 unsigned long ul_timeout
;
694 if (count
< SZ_SG_IO_HDR
)
696 if (!access_ok(VERIFY_READ
, buf
, count
))
697 return -EFAULT
; /* protects following copy_from_user()s + get_user()s */
699 sfp
->cmd_q
= 1; /* when sg_io_hdr seen, set command queuing on */
700 if (!(srp
= sg_add_request(sfp
))) {
701 SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n"));
704 srp
->sg_io_owned
= sg_io_owned
;
706 if (__copy_from_user(hp
, buf
, SZ_SG_IO_HDR
)) {
707 sg_remove_request(sfp
, srp
);
710 if (hp
->interface_id
!= 'S') {
711 sg_remove_request(sfp
, srp
);
714 if (hp
->flags
& SG_FLAG_MMAP_IO
) {
715 if (hp
->dxfer_len
> sfp
->reserve
.bufflen
) {
716 sg_remove_request(sfp
, srp
);
717 return -ENOMEM
; /* MMAP_IO size must fit in reserve buffer */
719 if (hp
->flags
& SG_FLAG_DIRECT_IO
) {
720 sg_remove_request(sfp
, srp
);
721 return -EINVAL
; /* either MMAP_IO or DIRECT_IO (not both) */
723 if (sg_res_in_use(sfp
)) {
724 sg_remove_request(sfp
, srp
);
725 return -EBUSY
; /* reserve buffer already being used */
728 ul_timeout
= msecs_to_jiffies(srp
->header
.timeout
);
729 timeout
= (ul_timeout
< INT_MAX
) ? ul_timeout
: INT_MAX
;
730 if ((!hp
->cmdp
) || (hp
->cmd_len
< 6) || (hp
->cmd_len
> sizeof (cmnd
))) {
731 sg_remove_request(sfp
, srp
);
734 if (!access_ok(VERIFY_READ
, hp
->cmdp
, hp
->cmd_len
)) {
735 sg_remove_request(sfp
, srp
);
736 return -EFAULT
; /* protects following copy_from_user()s + get_user()s */
738 if (__copy_from_user(cmnd
, hp
->cmdp
, hp
->cmd_len
)) {
739 sg_remove_request(sfp
, srp
);
742 if (read_only
&& sg_allow_access(file
, cmnd
)) {
743 sg_remove_request(sfp
, srp
);
746 k
= sg_common_write(sfp
, srp
, cmnd
, timeout
, blocking
);
755 sg_common_write(Sg_fd
* sfp
, Sg_request
* srp
,
756 unsigned char *cmnd
, int timeout
, int blocking
)
758 int k
, data_dir
, at_head
;
759 Sg_device
*sdp
= sfp
->parentdp
;
760 sg_io_hdr_t
*hp
= &srp
->header
;
762 srp
->data
.cmd_opcode
= cmnd
[0]; /* hold opcode of command */
764 hp
->masked_status
= 0;
768 hp
->driver_status
= 0;
770 SCSI_LOG_TIMEOUT(4, printk("sg_common_write: scsi opcode=0x%02x, cmd_size=%d\n",
771 (int) cmnd
[0], (int) hp
->cmd_len
));
773 k
= sg_start_req(srp
, cmnd
);
775 SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k
));
776 sg_finish_rem_req(srp
);
777 return k
; /* probably out of space --> ENOMEM */
779 if (atomic_read(&sdp
->detaching
)) {
781 blk_end_request_all(srp
->rq
, -EIO
);
782 sg_finish_rem_req(srp
);
786 switch (hp
->dxfer_direction
) {
787 case SG_DXFER_TO_FROM_DEV
:
788 case SG_DXFER_FROM_DEV
:
789 data_dir
= DMA_FROM_DEVICE
;
791 case SG_DXFER_TO_DEV
:
792 data_dir
= DMA_TO_DEVICE
;
794 case SG_DXFER_UNKNOWN
:
795 data_dir
= DMA_BIDIRECTIONAL
;
801 hp
->duration
= jiffies_to_msecs(jiffies
);
802 if (hp
->interface_id
!= '\0' && /* v3 (or later) interface */
803 (SG_FLAG_Q_AT_TAIL
& hp
->flags
))
808 srp
->rq
->timeout
= timeout
;
809 kref_get(&sfp
->f_ref
); /* sg_rq_end_io() does kref_put(). */
810 blk_execute_rq_nowait(sdp
->device
->request_queue
, sdp
->disk
,
811 srp
->rq
, at_head
, sg_rq_end_io
);
815 static int srp_done(Sg_fd
*sfp
, Sg_request
*srp
)
820 read_lock_irqsave(&sfp
->rq_list_lock
, flags
);
822 read_unlock_irqrestore(&sfp
->rq_list_lock
, flags
);
826 static int max_sectors_bytes(struct request_queue
*q
)
828 unsigned int max_sectors
= queue_max_sectors(q
);
830 max_sectors
= min_t(unsigned int, max_sectors
, INT_MAX
>> 9);
832 return max_sectors
<< 9;
836 sg_ioctl(struct file
*filp
, unsigned int cmd_in
, unsigned long arg
)
838 void __user
*p
= (void __user
*)arg
;
840 int result
, val
, read_only
;
844 unsigned long iflags
;
846 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
849 SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: %s, cmd=0x%x\n",
850 sdp
->disk
->disk_name
, (int) cmd_in
));
851 read_only
= (O_RDWR
!= (filp
->f_flags
& O_ACCMODE
));
855 if (atomic_read(&sdp
->detaching
))
857 if (!scsi_block_when_processing_errors(sdp
->device
))
859 if (!access_ok(VERIFY_WRITE
, p
, SZ_SG_IO_HDR
))
861 result
= sg_new_write(sfp
, filp
, p
, SZ_SG_IO_HDR
,
862 1, read_only
, 1, &srp
);
865 result
= wait_event_interruptible(sfp
->read_wait
,
866 (srp_done(sfp
, srp
) || atomic_read(&sdp
->detaching
)));
867 if (atomic_read(&sdp
->detaching
))
869 write_lock_irq(&sfp
->rq_list_lock
);
872 write_unlock_irq(&sfp
->rq_list_lock
);
873 result
= sg_new_read(sfp
, p
, SZ_SG_IO_HDR
, srp
);
874 return (result
< 0) ? result
: 0;
877 write_unlock_irq(&sfp
->rq_list_lock
);
878 return result
; /* -ERESTARTSYS because signal hit process */
880 result
= get_user(val
, ip
);
885 if (val
>= MULDIV (INT_MAX
, USER_HZ
, HZ
))
886 val
= MULDIV (INT_MAX
, USER_HZ
, HZ
);
887 sfp
->timeout_user
= val
;
888 sfp
->timeout
= MULDIV (val
, HZ
, USER_HZ
);
891 case SG_GET_TIMEOUT
: /* N.B. User receives timeout as return value */
892 /* strange ..., for backward compatibility */
893 return sfp
->timeout_user
;
894 case SG_SET_FORCE_LOW_DMA
:
895 result
= get_user(val
, ip
);
900 if ((0 == sfp
->low_dma
) && (0 == sg_res_in_use(sfp
))) {
901 val
= (int) sfp
->reserve
.bufflen
;
902 sg_remove_scat(&sfp
->reserve
);
903 sg_build_reserve(sfp
, val
);
906 if (atomic_read(&sdp
->detaching
))
908 sfp
->low_dma
= sdp
->device
->host
->unchecked_isa_dma
;
912 return put_user((int) sfp
->low_dma
, ip
);
914 if (!access_ok(VERIFY_WRITE
, p
, sizeof (sg_scsi_id_t
)))
917 sg_scsi_id_t __user
*sg_idp
= p
;
919 if (atomic_read(&sdp
->detaching
))
921 __put_user((int) sdp
->device
->host
->host_no
,
923 __put_user((int) sdp
->device
->channel
,
925 __put_user((int) sdp
->device
->id
, &sg_idp
->scsi_id
);
926 __put_user((int) sdp
->device
->lun
, &sg_idp
->lun
);
927 __put_user((int) sdp
->device
->type
, &sg_idp
->scsi_type
);
928 __put_user((short) sdp
->device
->host
->cmd_per_lun
,
929 &sg_idp
->h_cmd_per_lun
);
930 __put_user((short) sdp
->device
->queue_depth
,
931 &sg_idp
->d_queue_depth
);
932 __put_user(0, &sg_idp
->unused
[0]);
933 __put_user(0, &sg_idp
->unused
[1]);
936 case SG_SET_FORCE_PACK_ID
:
937 result
= get_user(val
, ip
);
940 sfp
->force_packid
= val
? 1 : 0;
943 if (!access_ok(VERIFY_WRITE
, ip
, sizeof (int)))
945 read_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
946 for (srp
= sfp
->headrp
; srp
; srp
= srp
->nextrp
) {
947 if ((1 == srp
->done
) && (!srp
->sg_io_owned
)) {
948 read_unlock_irqrestore(&sfp
->rq_list_lock
,
950 __put_user(srp
->header
.pack_id
, ip
);
954 read_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
957 case SG_GET_NUM_WAITING
:
958 read_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
959 for (val
= 0, srp
= sfp
->headrp
; srp
; srp
= srp
->nextrp
) {
960 if ((1 == srp
->done
) && (!srp
->sg_io_owned
))
963 read_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
964 return put_user(val
, ip
);
965 case SG_GET_SG_TABLESIZE
:
966 return put_user(sdp
->sg_tablesize
, ip
);
967 case SG_SET_RESERVED_SIZE
:
968 result
= get_user(val
, ip
);
973 val
= min_t(int, val
,
974 max_sectors_bytes(sdp
->device
->request_queue
));
975 if (val
!= sfp
->reserve
.bufflen
) {
976 if (sg_res_in_use(sfp
) || sfp
->mmap_called
)
978 sg_remove_scat(&sfp
->reserve
);
979 sg_build_reserve(sfp
, val
);
982 case SG_GET_RESERVED_SIZE
:
983 val
= min_t(int, sfp
->reserve
.bufflen
,
984 max_sectors_bytes(sdp
->device
->request_queue
));
985 return put_user(val
, ip
);
986 case SG_SET_COMMAND_Q
:
987 result
= get_user(val
, ip
);
990 sfp
->cmd_q
= val
? 1 : 0;
992 case SG_GET_COMMAND_Q
:
993 return put_user((int) sfp
->cmd_q
, ip
);
994 case SG_SET_KEEP_ORPHAN
:
995 result
= get_user(val
, ip
);
998 sfp
->keep_orphan
= val
;
1000 case SG_GET_KEEP_ORPHAN
:
1001 return put_user((int) sfp
->keep_orphan
, ip
);
1002 case SG_NEXT_CMD_LEN
:
1003 result
= get_user(val
, ip
);
1006 sfp
->next_cmd_len
= (val
> 0) ? val
: 0;
1008 case SG_GET_VERSION_NUM
:
1009 return put_user(sg_version_num
, ip
);
1010 case SG_GET_ACCESS_COUNT
:
1011 /* faked - we don't have a real access count anymore */
1012 val
= (sdp
->device
? 1 : 0);
1013 return put_user(val
, ip
);
1014 case SG_GET_REQUEST_TABLE
:
1015 if (!access_ok(VERIFY_WRITE
, p
, SZ_SG_REQ_INFO
* SG_MAX_QUEUE
))
1018 sg_req_info_t
*rinfo
;
1021 rinfo
= kmalloc(SZ_SG_REQ_INFO
* SG_MAX_QUEUE
,
1025 read_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
1026 for (srp
= sfp
->headrp
, val
= 0; val
< SG_MAX_QUEUE
;
1027 ++val
, srp
= srp
? srp
->nextrp
: srp
) {
1028 memset(&rinfo
[val
], 0, SZ_SG_REQ_INFO
);
1030 rinfo
[val
].req_state
= srp
->done
+ 1;
1031 rinfo
[val
].problem
=
1032 srp
->header
.masked_status
&
1033 srp
->header
.host_status
&
1034 srp
->header
.driver_status
;
1036 rinfo
[val
].duration
=
1037 srp
->header
.duration
;
1039 ms
= jiffies_to_msecs(jiffies
);
1040 rinfo
[val
].duration
=
1041 (ms
> srp
->header
.duration
) ?
1042 (ms
- srp
->header
.duration
) : 0;
1044 rinfo
[val
].orphan
= srp
->orphan
;
1045 rinfo
[val
].sg_io_owned
=
1047 rinfo
[val
].pack_id
=
1048 srp
->header
.pack_id
;
1049 rinfo
[val
].usr_ptr
=
1050 srp
->header
.usr_ptr
;
1053 read_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
1054 result
= __copy_to_user(p
, rinfo
,
1055 SZ_SG_REQ_INFO
* SG_MAX_QUEUE
);
1056 result
= result
? -EFAULT
: 0;
1060 case SG_EMULATED_HOST
:
1061 if (atomic_read(&sdp
->detaching
))
1063 return put_user(sdp
->device
->host
->hostt
->emulated
, ip
);
1065 if (atomic_read(&sdp
->detaching
))
1067 if (filp
->f_flags
& O_NONBLOCK
) {
1068 if (scsi_host_in_recovery(sdp
->device
->host
))
1070 } else if (!scsi_block_when_processing_errors(sdp
->device
))
1072 result
= get_user(val
, ip
);
1075 if (SG_SCSI_RESET_NOTHING
== val
)
1078 case SG_SCSI_RESET_DEVICE
:
1079 val
= SCSI_TRY_RESET_DEVICE
;
1081 case SG_SCSI_RESET_TARGET
:
1082 val
= SCSI_TRY_RESET_TARGET
;
1084 case SG_SCSI_RESET_BUS
:
1085 val
= SCSI_TRY_RESET_BUS
;
1087 case SG_SCSI_RESET_HOST
:
1088 val
= SCSI_TRY_RESET_HOST
;
1093 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
1095 return (scsi_reset_provider(sdp
->device
, val
) ==
1096 SUCCESS
) ? 0 : -EIO
;
1097 case SCSI_IOCTL_SEND_COMMAND
:
1098 if (atomic_read(&sdp
->detaching
))
1101 unsigned char opcode
= WRITE_6
;
1102 Scsi_Ioctl_Command __user
*siocp
= p
;
1104 if (copy_from_user(&opcode
, siocp
->data
, 1))
1106 if (sg_allow_access(filp
, &opcode
))
1109 return sg_scsi_ioctl(sdp
->device
->request_queue
, NULL
, filp
->f_mode
, p
);
1111 result
= get_user(val
, ip
);
1114 sdp
->sgdebug
= (char) val
;
1116 case SCSI_IOCTL_GET_IDLUN
:
1117 case SCSI_IOCTL_GET_BUS_NUMBER
:
1118 case SCSI_IOCTL_PROBE_HOST
:
1119 case SG_GET_TRANSFORM
:
1120 if (atomic_read(&sdp
->detaching
))
1122 return scsi_ioctl(sdp
->device
, cmd_in
, p
);
1124 return put_user(max_sectors_bytes(sdp
->device
->request_queue
),
1127 return blk_trace_setup(sdp
->device
->request_queue
,
1128 sdp
->disk
->disk_name
,
1129 MKDEV(SCSI_GENERIC_MAJOR
, sdp
->index
),
1133 return blk_trace_startstop(sdp
->device
->request_queue
, 1);
1135 return blk_trace_startstop(sdp
->device
->request_queue
, 0);
1136 case BLKTRACETEARDOWN
:
1137 return blk_trace_remove(sdp
->device
->request_queue
);
1140 return -EPERM
; /* don't know so take safe approach */
1141 return scsi_ioctl(sdp
->device
, cmd_in
, p
);
1145 #ifdef CONFIG_COMPAT
1146 static long sg_compat_ioctl(struct file
*filp
, unsigned int cmd_in
, unsigned long arg
)
1150 struct scsi_device
*sdev
;
1152 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
1156 if (sdev
->host
->hostt
->compat_ioctl
) {
1159 ret
= sdev
->host
->hostt
->compat_ioctl(sdev
, cmd_in
, (void __user
*)arg
);
1164 return -ENOIOCTLCMD
;
1169 sg_poll(struct file
*filp
, poll_table
* wait
)
1171 unsigned int res
= 0;
1176 unsigned long iflags
;
1178 sfp
= filp
->private_data
;
1181 sdp
= sfp
->parentdp
;
1184 poll_wait(filp
, &sfp
->read_wait
, wait
);
1185 read_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
1186 for (srp
= sfp
->headrp
; srp
; srp
= srp
->nextrp
) {
1187 /* if any read waiting, flag it */
1188 if ((0 == res
) && (1 == srp
->done
) && (!srp
->sg_io_owned
))
1189 res
= POLLIN
| POLLRDNORM
;
1192 read_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
1194 if (atomic_read(&sdp
->detaching
))
1196 else if (!sfp
->cmd_q
) {
1198 res
|= POLLOUT
| POLLWRNORM
;
1199 } else if (count
< SG_MAX_QUEUE
)
1200 res
|= POLLOUT
| POLLWRNORM
;
1201 SCSI_LOG_TIMEOUT(3, printk("sg_poll: %s, res=0x%x\n",
1202 sdp
->disk
->disk_name
, (int) res
));
1207 sg_fasync(int fd
, struct file
*filp
, int mode
)
1212 if ((!(sfp
= (Sg_fd
*) filp
->private_data
)) || (!(sdp
= sfp
->parentdp
)))
1214 SCSI_LOG_TIMEOUT(3, printk("sg_fasync: %s, mode=%d\n",
1215 sdp
->disk
->disk_name
, mode
));
1217 return fasync_helper(fd
, filp
, mode
, &sfp
->async_qp
);
1221 sg_vma_fault(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
1224 unsigned long offset
, len
, sa
;
1225 Sg_scatter_hold
*rsv_schp
;
1228 if ((NULL
== vma
) || (!(sfp
= (Sg_fd
*) vma
->vm_private_data
)))
1229 return VM_FAULT_SIGBUS
;
1230 rsv_schp
= &sfp
->reserve
;
1231 offset
= vmf
->pgoff
<< PAGE_SHIFT
;
1232 if (offset
>= rsv_schp
->bufflen
)
1233 return VM_FAULT_SIGBUS
;
1234 SCSI_LOG_TIMEOUT(3, printk("sg_vma_fault: offset=%lu, scatg=%d\n",
1235 offset
, rsv_schp
->k_use_sg
));
1237 length
= 1 << (PAGE_SHIFT
+ rsv_schp
->page_order
);
1238 for (k
= 0; k
< rsv_schp
->k_use_sg
&& sa
< vma
->vm_end
; k
++) {
1239 len
= vma
->vm_end
- sa
;
1240 len
= (len
< length
) ? len
: length
;
1242 struct page
*page
= nth_page(rsv_schp
->pages
[k
],
1243 offset
>> PAGE_SHIFT
);
1244 get_page(page
); /* increment page count */
1246 return 0; /* success */
1252 return VM_FAULT_SIGBUS
;
1255 static const struct vm_operations_struct sg_mmap_vm_ops
= {
1256 .fault
= sg_vma_fault
,
1260 sg_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
1263 unsigned long req_sz
, len
, sa
;
1264 Sg_scatter_hold
*rsv_schp
;
1267 if ((!filp
) || (!vma
) || (!(sfp
= (Sg_fd
*) filp
->private_data
)))
1269 req_sz
= vma
->vm_end
- vma
->vm_start
;
1270 SCSI_LOG_TIMEOUT(3, printk("sg_mmap starting, vm_start=%p, len=%d\n",
1271 (void *) vma
->vm_start
, (int) req_sz
));
1273 return -EINVAL
; /* want no offset */
1274 rsv_schp
= &sfp
->reserve
;
1275 if (req_sz
> rsv_schp
->bufflen
)
1276 return -ENOMEM
; /* cannot map more than reserved buffer */
1279 length
= 1 << (PAGE_SHIFT
+ rsv_schp
->page_order
);
1280 for (k
= 0; k
< rsv_schp
->k_use_sg
&& sa
< vma
->vm_end
; k
++) {
1281 len
= vma
->vm_end
- sa
;
1282 len
= (len
< length
) ? len
: length
;
1286 sfp
->mmap_called
= 1;
1287 vma
->vm_flags
|= VM_DONTEXPAND
| VM_DONTDUMP
;
1288 vma
->vm_private_data
= sfp
;
1289 vma
->vm_ops
= &sg_mmap_vm_ops
;
1294 sg_rq_end_io_usercontext(struct work_struct
*work
)
1296 struct sg_request
*srp
= container_of(work
, struct sg_request
, ew
.work
);
1297 struct sg_fd
*sfp
= srp
->parentfp
;
1299 sg_finish_rem_req(srp
);
1300 kref_put(&sfp
->f_ref
, sg_remove_sfp
);
1304 * This function is a "bottom half" handler that is called by the mid
1305 * level when a command is completed (or has failed).
1308 sg_rq_end_io(struct request
*rq
, int uptodate
)
1310 struct sg_request
*srp
= rq
->end_io_data
;
1313 unsigned long iflags
;
1316 int result
, resid
, done
= 1;
1318 if (WARN_ON(srp
->done
!= 0))
1321 sfp
= srp
->parentfp
;
1322 if (WARN_ON(sfp
== NULL
))
1325 sdp
= sfp
->parentdp
;
1326 if (unlikely(atomic_read(&sdp
->detaching
)))
1327 pr_info("%s: device detaching\n", __func__
);
1330 result
= rq
->errors
;
1331 resid
= rq
->resid_len
;
1333 SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
1334 sdp
->disk
->disk_name
, srp
->header
.pack_id
, result
));
1335 srp
->header
.resid
= resid
;
1336 ms
= jiffies_to_msecs(jiffies
);
1337 srp
->header
.duration
= (ms
> srp
->header
.duration
) ?
1338 (ms
- srp
->header
.duration
) : 0;
1340 struct scsi_sense_hdr sshdr
;
1342 srp
->header
.status
= 0xff & result
;
1343 srp
->header
.masked_status
= status_byte(result
);
1344 srp
->header
.msg_status
= msg_byte(result
);
1345 srp
->header
.host_status
= host_byte(result
);
1346 srp
->header
.driver_status
= driver_byte(result
);
1347 if ((sdp
->sgdebug
> 0) &&
1348 ((CHECK_CONDITION
== srp
->header
.masked_status
) ||
1349 (COMMAND_TERMINATED
== srp
->header
.masked_status
)))
1350 __scsi_print_sense(__func__
, sense
,
1351 SCSI_SENSE_BUFFERSIZE
);
1353 /* Following if statement is a patch supplied by Eric Youngdale */
1354 if (driver_byte(result
) != 0
1355 && scsi_normalize_sense(sense
, SCSI_SENSE_BUFFERSIZE
, &sshdr
)
1356 && !scsi_sense_is_deferred(&sshdr
)
1357 && sshdr
.sense_key
== UNIT_ATTENTION
1358 && sdp
->device
->removable
) {
1359 /* Detected possible disc change. Set the bit - this */
1360 /* may be used if there are filesystems using this device */
1361 sdp
->device
->changed
= 1;
1364 /* Rely on write phase to clean out srp status values, so no "else" */
1366 write_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
1367 if (unlikely(srp
->orphan
)) {
1368 if (sfp
->keep_orphan
)
1369 srp
->sg_io_owned
= 0;
1374 write_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
1377 /* Now wake up any sg_read() that is waiting for this
1380 wake_up_interruptible(&sfp
->read_wait
);
1381 kill_fasync(&sfp
->async_qp
, SIGPOLL
, POLL_IN
);
1382 kref_put(&sfp
->f_ref
, sg_remove_sfp
);
1384 INIT_WORK(&srp
->ew
.work
, sg_rq_end_io_usercontext
);
1385 schedule_work(&srp
->ew
.work
);
1389 static const struct file_operations sg_fops
= {
1390 .owner
= THIS_MODULE
,
1394 .unlocked_ioctl
= sg_ioctl
,
1395 #ifdef CONFIG_COMPAT
1396 .compat_ioctl
= sg_compat_ioctl
,
1400 .release
= sg_release
,
1401 .fasync
= sg_fasync
,
1402 .llseek
= no_llseek
,
1405 static struct class *sg_sysfs_class
;
1407 static int sg_sysfs_valid
= 0;
1410 sg_alloc(struct gendisk
*disk
, struct scsi_device
*scsidp
)
1412 struct request_queue
*q
= scsidp
->request_queue
;
1414 unsigned long iflags
;
1418 sdp
= kzalloc(sizeof(Sg_device
), GFP_KERNEL
);
1420 sdev_printk(KERN_WARNING
, scsidp
, "%s: kmalloc Sg_device "
1421 "failure\n", __func__
);
1422 return ERR_PTR(-ENOMEM
);
1425 idr_preload(GFP_KERNEL
);
1426 write_lock_irqsave(&sg_index_lock
, iflags
);
1428 error
= idr_alloc(&sg_index_idr
, sdp
, 0, SG_MAX_DEVS
, GFP_NOWAIT
);
1430 if (error
== -ENOSPC
) {
1431 sdev_printk(KERN_WARNING
, scsidp
,
1432 "Unable to attach sg device type=%d, minor number exceeds %d\n",
1433 scsidp
->type
, SG_MAX_DEVS
- 1);
1436 sdev_printk(KERN_WARNING
, scsidp
, "%s: idr "
1437 "allocation Sg_device failure: %d\n",
1444 SCSI_LOG_TIMEOUT(3, printk("sg_alloc: dev=%d \n", k
));
1445 sprintf(disk
->disk_name
, "sg%d", k
);
1446 disk
->first_minor
= k
;
1448 sdp
->device
= scsidp
;
1449 mutex_init(&sdp
->open_rel_lock
);
1450 INIT_LIST_HEAD(&sdp
->sfds
);
1451 init_waitqueue_head(&sdp
->open_wait
);
1452 atomic_set(&sdp
->detaching
, 0);
1453 rwlock_init(&sdp
->sfd_lock
);
1454 sdp
->sg_tablesize
= queue_max_segments(q
);
1456 kref_init(&sdp
->d_ref
);
1460 write_unlock_irqrestore(&sg_index_lock
, iflags
);
1465 return ERR_PTR(error
);
1471 sg_add_device(struct device
*cl_dev
, struct class_interface
*cl_intf
)
1473 struct scsi_device
*scsidp
= to_scsi_device(cl_dev
->parent
);
1474 struct gendisk
*disk
;
1475 Sg_device
*sdp
= NULL
;
1476 struct cdev
* cdev
= NULL
;
1478 unsigned long iflags
;
1480 disk
= alloc_disk(1);
1482 pr_warn("%s: alloc_disk failed\n", __func__
);
1485 disk
->major
= SCSI_GENERIC_MAJOR
;
1488 cdev
= cdev_alloc();
1490 pr_warn("%s: cdev_alloc failed\n", __func__
);
1493 cdev
->owner
= THIS_MODULE
;
1494 cdev
->ops
= &sg_fops
;
1496 sdp
= sg_alloc(disk
, scsidp
);
1498 pr_warn("%s: sg_alloc failed\n", __func__
);
1499 error
= PTR_ERR(sdp
);
1503 error
= cdev_add(cdev
, MKDEV(SCSI_GENERIC_MAJOR
, sdp
->index
), 1);
1508 if (sg_sysfs_valid
) {
1509 struct device
*sg_class_member
;
1511 sg_class_member
= device_create(sg_sysfs_class
, cl_dev
->parent
,
1512 MKDEV(SCSI_GENERIC_MAJOR
,
1514 sdp
, "%s", disk
->disk_name
);
1515 if (IS_ERR(sg_class_member
)) {
1516 pr_err("%s: device_create failed\n", __func__
);
1517 error
= PTR_ERR(sg_class_member
);
1520 error
= sysfs_create_link(&scsidp
->sdev_gendev
.kobj
,
1521 &sg_class_member
->kobj
, "generic");
1523 pr_err("%s: unable to make symlink 'generic' back "
1524 "to sg%d\n", __func__
, sdp
->index
);
1526 pr_warn("%s: sg_sys Invalid\n", __func__
);
1528 sdev_printk(KERN_NOTICE
, scsidp
, "Attached scsi generic sg%d "
1529 "type %d\n", sdp
->index
, scsidp
->type
);
1531 dev_set_drvdata(cl_dev
, sdp
);
1536 write_lock_irqsave(&sg_index_lock
, iflags
);
1537 idr_remove(&sg_index_idr
, sdp
->index
);
1538 write_unlock_irqrestore(&sg_index_lock
, iflags
);
1549 sg_device_destroy(struct kref
*kref
)
1551 struct sg_device
*sdp
= container_of(kref
, struct sg_device
, d_ref
);
1552 unsigned long flags
;
1554 /* CAUTION! Note that the device can still be found via idr_find()
1555 * even though the refcount is 0. Therefore, do idr_remove() BEFORE
1556 * any other cleanup.
1559 write_lock_irqsave(&sg_index_lock
, flags
);
1560 idr_remove(&sg_index_idr
, sdp
->index
);
1561 write_unlock_irqrestore(&sg_index_lock
, flags
);
1564 printk("sg_device_destroy: %s\n",
1565 sdp
->disk
->disk_name
));
1567 put_disk(sdp
->disk
);
1572 sg_remove_device(struct device
*cl_dev
, struct class_interface
*cl_intf
)
1574 struct scsi_device
*scsidp
= to_scsi_device(cl_dev
->parent
);
1575 Sg_device
*sdp
= dev_get_drvdata(cl_dev
);
1576 unsigned long iflags
;
1582 /* want sdp->detaching non-zero as soon as possible */
1583 val
= atomic_inc_return(&sdp
->detaching
);
1585 return; /* only want to do following once per device */
1587 SCSI_LOG_TIMEOUT(3, printk("%s: %s\n", __func__
,
1588 sdp
->disk
->disk_name
));
1590 read_lock_irqsave(&sdp
->sfd_lock
, iflags
);
1591 list_for_each_entry(sfp
, &sdp
->sfds
, sfd_siblings
) {
1592 wake_up_interruptible_all(&sfp
->read_wait
);
1593 kill_fasync(&sfp
->async_qp
, SIGPOLL
, POLL_HUP
);
1595 wake_up_interruptible_all(&sdp
->open_wait
);
1596 read_unlock_irqrestore(&sdp
->sfd_lock
, iflags
);
1598 sysfs_remove_link(&scsidp
->sdev_gendev
.kobj
, "generic");
1599 device_destroy(sg_sysfs_class
, MKDEV(SCSI_GENERIC_MAJOR
, sdp
->index
));
1600 cdev_del(sdp
->cdev
);
1603 kref_put(&sdp
->d_ref
, sg_device_destroy
);
1606 module_param_named(scatter_elem_sz
, scatter_elem_sz
, int, S_IRUGO
| S_IWUSR
);
1607 module_param_named(def_reserved_size
, def_reserved_size
, int,
1609 module_param_named(allow_dio
, sg_allow_dio
, int, S_IRUGO
| S_IWUSR
);
1611 MODULE_AUTHOR("Douglas Gilbert");
1612 MODULE_DESCRIPTION("SCSI generic (sg) driver");
1613 MODULE_LICENSE("GPL");
1614 MODULE_VERSION(SG_VERSION_STR
);
1615 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR
);
1617 MODULE_PARM_DESC(scatter_elem_sz
, "scatter gather element "
1618 "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
1619 MODULE_PARM_DESC(def_reserved_size
, "size of buffer reserved for each fd");
1620 MODULE_PARM_DESC(allow_dio
, "allow direct I/O (default: 0 (disallow))");
1627 if (scatter_elem_sz
< PAGE_SIZE
) {
1628 scatter_elem_sz
= PAGE_SIZE
;
1629 scatter_elem_sz_prev
= scatter_elem_sz
;
1631 if (def_reserved_size
>= 0)
1632 sg_big_buff
= def_reserved_size
;
1634 def_reserved_size
= sg_big_buff
;
1636 rc
= register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR
, 0),
1640 sg_sysfs_class
= class_create(THIS_MODULE
, "scsi_generic");
1641 if ( IS_ERR(sg_sysfs_class
) ) {
1642 rc
= PTR_ERR(sg_sysfs_class
);
1646 rc
= scsi_register_interface(&sg_interface
);
1648 #ifdef CONFIG_SCSI_PROC_FS
1650 #endif /* CONFIG_SCSI_PROC_FS */
1653 class_destroy(sg_sysfs_class
);
1655 unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR
, 0), SG_MAX_DEVS
);
1662 #ifdef CONFIG_SCSI_PROC_FS
1664 #endif /* CONFIG_SCSI_PROC_FS */
1665 scsi_unregister_interface(&sg_interface
);
1666 class_destroy(sg_sysfs_class
);
1668 unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR
, 0),
1670 idr_destroy(&sg_index_idr
);
1674 sg_start_req(Sg_request
*srp
, unsigned char *cmd
)
1678 Sg_fd
*sfp
= srp
->parentfp
;
1679 sg_io_hdr_t
*hp
= &srp
->header
;
1680 int dxfer_len
= (int) hp
->dxfer_len
;
1681 int dxfer_dir
= hp
->dxfer_direction
;
1682 unsigned int iov_count
= hp
->iovec_count
;
1683 Sg_scatter_hold
*req_schp
= &srp
->data
;
1684 Sg_scatter_hold
*rsv_schp
= &sfp
->reserve
;
1685 struct request_queue
*q
= sfp
->parentdp
->device
->request_queue
;
1686 struct rq_map_data
*md
, map_data
;
1687 int rw
= hp
->dxfer_direction
== SG_DXFER_TO_DEV
? WRITE
: READ
;
1688 unsigned char *long_cmdp
= NULL
;
1690 SCSI_LOG_TIMEOUT(4, printk(KERN_INFO
"sg_start_req: dxfer_len=%d\n",
1693 if (hp
->cmd_len
> BLK_MAX_CDB
) {
1694 long_cmdp
= kzalloc(hp
->cmd_len
, GFP_KERNEL
);
1699 rq
= blk_get_request(q
, rw
, GFP_ATOMIC
);
1705 blk_rq_set_block_pc(rq
);
1707 if (hp
->cmd_len
> BLK_MAX_CDB
)
1708 rq
->cmd
= long_cmdp
;
1709 memcpy(rq
->cmd
, cmd
, hp
->cmd_len
);
1710 rq
->cmd_len
= hp
->cmd_len
;
1713 rq
->end_io_data
= srp
;
1714 rq
->sense
= srp
->sense_b
;
1715 rq
->retries
= SG_DEFAULT_RETRIES
;
1717 if ((dxfer_len
<= 0) || (dxfer_dir
== SG_DXFER_NONE
))
1720 if (sg_allow_dio
&& hp
->flags
& SG_FLAG_DIRECT_IO
&&
1721 dxfer_dir
!= SG_DXFER_UNKNOWN
&& !iov_count
&&
1722 !sfp
->parentdp
->device
->host
->unchecked_isa_dma
&&
1723 blk_rq_aligned(q
, (unsigned long)hp
->dxferp
, dxfer_len
))
1729 if (!sg_res_in_use(sfp
) && dxfer_len
<= rsv_schp
->bufflen
)
1730 sg_link_reserve(sfp
, srp
, dxfer_len
);
1732 res
= sg_build_indirect(req_schp
, sfp
, dxfer_len
);
1737 md
->pages
= req_schp
->pages
;
1738 md
->page_order
= req_schp
->page_order
;
1739 md
->nr_entries
= req_schp
->k_use_sg
;
1741 md
->null_mapped
= hp
->dxferp
? 0 : 1;
1742 if (dxfer_dir
== SG_DXFER_TO_FROM_DEV
)
1749 int len
, size
= sizeof(struct sg_iovec
) * iov_count
;
1752 iov
= memdup_user(hp
->dxferp
, size
);
1754 return PTR_ERR(iov
);
1756 len
= iov_length(iov
, iov_count
);
1757 if (hp
->dxfer_len
< len
) {
1758 iov_count
= iov_shorten(iov
, iov_count
, hp
->dxfer_len
);
1759 len
= hp
->dxfer_len
;
1762 res
= blk_rq_map_user_iov(q
, rq
, md
, (struct sg_iovec
*)iov
,
1767 res
= blk_rq_map_user(q
, rq
, md
, hp
->dxferp
,
1768 hp
->dxfer_len
, GFP_ATOMIC
);
1774 req_schp
->dio_in_use
= 1;
1775 hp
->info
|= SG_INFO_DIRECT_IO
;
1782 sg_finish_rem_req(Sg_request
*srp
)
1786 Sg_fd
*sfp
= srp
->parentfp
;
1787 Sg_scatter_hold
*req_schp
= &srp
->data
;
1789 SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n", (int) srp
->res_used
));
1792 ret
= blk_rq_unmap_user(srp
->bio
);
1794 if (srp
->rq
->cmd
!= srp
->rq
->__cmd
)
1795 kfree(srp
->rq
->cmd
);
1796 blk_put_request(srp
->rq
);
1800 sg_unlink_reserve(sfp
, srp
);
1802 sg_remove_scat(req_schp
);
1804 sg_remove_request(sfp
, srp
);
1810 sg_build_sgat(Sg_scatter_hold
* schp
, const Sg_fd
* sfp
, int tablesize
)
1812 int sg_bufflen
= tablesize
* sizeof(struct page
*);
1813 gfp_t gfp_flags
= GFP_ATOMIC
| __GFP_NOWARN
;
1815 schp
->pages
= kzalloc(sg_bufflen
, gfp_flags
);
1818 schp
->sglist_len
= sg_bufflen
;
1819 return tablesize
; /* number of scat_gath elements allocated */
1823 sg_build_indirect(Sg_scatter_hold
* schp
, Sg_fd
* sfp
, int buff_size
)
1825 int ret_sz
= 0, i
, k
, rem_sz
, num
, mx_sc_elems
;
1826 int sg_tablesize
= sfp
->parentdp
->sg_tablesize
;
1827 int blk_size
= buff_size
, order
;
1828 gfp_t gfp_mask
= GFP_ATOMIC
| __GFP_COMP
| __GFP_NOWARN
;
1833 ++blk_size
; /* don't know why */
1834 /* round request up to next highest SG_SECTOR_SZ byte boundary */
1835 blk_size
= ALIGN(blk_size
, SG_SECTOR_SZ
);
1836 SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n",
1837 buff_size
, blk_size
));
1839 /* N.B. ret_sz carried into this block ... */
1840 mx_sc_elems
= sg_build_sgat(schp
, sfp
, sg_tablesize
);
1841 if (mx_sc_elems
< 0)
1842 return mx_sc_elems
; /* most likely -ENOMEM */
1844 num
= scatter_elem_sz
;
1845 if (unlikely(num
!= scatter_elem_sz_prev
)) {
1846 if (num
< PAGE_SIZE
) {
1847 scatter_elem_sz
= PAGE_SIZE
;
1848 scatter_elem_sz_prev
= PAGE_SIZE
;
1850 scatter_elem_sz_prev
= num
;
1854 gfp_mask
|= GFP_DMA
;
1856 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
1857 gfp_mask
|= __GFP_ZERO
;
1859 order
= get_order(num
);
1861 ret_sz
= 1 << (PAGE_SHIFT
+ order
);
1863 for (k
= 0, rem_sz
= blk_size
; rem_sz
> 0 && k
< mx_sc_elems
;
1864 k
++, rem_sz
-= ret_sz
) {
1866 num
= (rem_sz
> scatter_elem_sz_prev
) ?
1867 scatter_elem_sz_prev
: rem_sz
;
1869 schp
->pages
[k
] = alloc_pages(gfp_mask
, order
);
1870 if (!schp
->pages
[k
])
1873 if (num
== scatter_elem_sz_prev
) {
1874 if (unlikely(ret_sz
> scatter_elem_sz_prev
)) {
1875 scatter_elem_sz
= ret_sz
;
1876 scatter_elem_sz_prev
= ret_sz
;
1880 SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
1881 "ret_sz=%d\n", k
, num
, ret_sz
));
1882 } /* end of for loop */
1884 schp
->page_order
= order
;
1886 SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
1887 "rem_sz=%d\n", k
, rem_sz
));
1889 schp
->bufflen
= blk_size
;
1890 if (rem_sz
> 0) /* must have failed */
1894 for (i
= 0; i
< k
; i
++)
1895 __free_pages(schp
->pages
[i
], order
);
1904 sg_remove_scat(Sg_scatter_hold
* schp
)
1906 SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n", schp
->k_use_sg
));
1907 if (schp
->pages
&& schp
->sglist_len
> 0) {
1908 if (!schp
->dio_in_use
) {
1911 for (k
= 0; k
< schp
->k_use_sg
&& schp
->pages
[k
]; k
++) {
1912 SCSI_LOG_TIMEOUT(5, printk(
1913 "sg_remove_scat: k=%d, pg=0x%p\n",
1914 k
, schp
->pages
[k
]));
1915 __free_pages(schp
->pages
[k
], schp
->page_order
);
1921 memset(schp
, 0, sizeof (*schp
));
1925 sg_read_oxfer(Sg_request
* srp
, char __user
*outp
, int num_read_xfer
)
1927 Sg_scatter_hold
*schp
= &srp
->data
;
1930 SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n",
1932 if ((!outp
) || (num_read_xfer
<= 0))
1935 num
= 1 << (PAGE_SHIFT
+ schp
->page_order
);
1936 for (k
= 0; k
< schp
->k_use_sg
&& schp
->pages
[k
]; k
++) {
1937 if (num
> num_read_xfer
) {
1938 if (__copy_to_user(outp
, page_address(schp
->pages
[k
]),
1943 if (__copy_to_user(outp
, page_address(schp
->pages
[k
]),
1946 num_read_xfer
-= num
;
1947 if (num_read_xfer
<= 0)
1957 sg_build_reserve(Sg_fd
* sfp
, int req_size
)
1959 Sg_scatter_hold
*schp
= &sfp
->reserve
;
1961 SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size
));
1963 if (req_size
< PAGE_SIZE
)
1964 req_size
= PAGE_SIZE
;
1965 if (0 == sg_build_indirect(schp
, sfp
, req_size
))
1968 sg_remove_scat(schp
);
1969 req_size
>>= 1; /* divide by 2 */
1970 } while (req_size
> (PAGE_SIZE
/ 2));
1974 sg_link_reserve(Sg_fd
* sfp
, Sg_request
* srp
, int size
)
1976 Sg_scatter_hold
*req_schp
= &srp
->data
;
1977 Sg_scatter_hold
*rsv_schp
= &sfp
->reserve
;
1981 SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size
));
1984 num
= 1 << (PAGE_SHIFT
+ rsv_schp
->page_order
);
1985 for (k
= 0; k
< rsv_schp
->k_use_sg
; k
++) {
1987 req_schp
->k_use_sg
= k
+ 1;
1988 req_schp
->sglist_len
= rsv_schp
->sglist_len
;
1989 req_schp
->pages
= rsv_schp
->pages
;
1991 req_schp
->bufflen
= size
;
1992 req_schp
->page_order
= rsv_schp
->page_order
;
1998 if (k
>= rsv_schp
->k_use_sg
)
1999 SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
2003 sg_unlink_reserve(Sg_fd
* sfp
, Sg_request
* srp
)
2005 Sg_scatter_hold
*req_schp
= &srp
->data
;
2007 SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n",
2008 (int) req_schp
->k_use_sg
));
2009 req_schp
->k_use_sg
= 0;
2010 req_schp
->bufflen
= 0;
2011 req_schp
->pages
= NULL
;
2012 req_schp
->page_order
= 0;
2013 req_schp
->sglist_len
= 0;
2014 sfp
->save_scat_len
= 0;
2019 sg_get_rq_mark(Sg_fd
* sfp
, int pack_id
)
2022 unsigned long iflags
;
2024 write_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
2025 for (resp
= sfp
->headrp
; resp
; resp
= resp
->nextrp
) {
2026 /* look for requests that are ready + not SG_IO owned */
2027 if ((1 == resp
->done
) && (!resp
->sg_io_owned
) &&
2028 ((-1 == pack_id
) || (resp
->header
.pack_id
== pack_id
))) {
2029 resp
->done
= 2; /* guard against other readers */
2033 write_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
2037 /* always adds to end of list */
2039 sg_add_request(Sg_fd
* sfp
)
2042 unsigned long iflags
;
2044 Sg_request
*rp
= sfp
->req_arr
;
2046 write_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
2049 memset(rp
, 0, sizeof (Sg_request
));
2054 if (0 == sfp
->cmd_q
)
2055 resp
= NULL
; /* command queuing disallowed */
2057 for (k
= 0; k
< SG_MAX_QUEUE
; ++k
, ++rp
) {
2061 if (k
< SG_MAX_QUEUE
) {
2062 memset(rp
, 0, sizeof (Sg_request
));
2064 while (resp
->nextrp
)
2065 resp
= resp
->nextrp
;
2073 resp
->nextrp
= NULL
;
2074 resp
->header
.duration
= jiffies_to_msecs(jiffies
);
2076 write_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
2080 /* Return of 1 for found; 0 for not found */
2082 sg_remove_request(Sg_fd
* sfp
, Sg_request
* srp
)
2084 Sg_request
*prev_rp
;
2086 unsigned long iflags
;
2089 if ((!sfp
) || (!srp
) || (!sfp
->headrp
))
2091 write_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
2092 prev_rp
= sfp
->headrp
;
2093 if (srp
== prev_rp
) {
2094 sfp
->headrp
= prev_rp
->nextrp
;
2095 prev_rp
->parentfp
= NULL
;
2098 while ((rp
= prev_rp
->nextrp
)) {
2100 prev_rp
->nextrp
= rp
->nextrp
;
2101 rp
->parentfp
= NULL
;
2108 write_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
2113 sg_add_sfp(Sg_device
* sdp
, int dev
)
2116 unsigned long iflags
;
2119 sfp
= kzalloc(sizeof(*sfp
), GFP_ATOMIC
| __GFP_NOWARN
);
2121 return ERR_PTR(-ENOMEM
);
2123 init_waitqueue_head(&sfp
->read_wait
);
2124 rwlock_init(&sfp
->rq_list_lock
);
2126 kref_init(&sfp
->f_ref
);
2127 sfp
->timeout
= SG_DEFAULT_TIMEOUT
;
2128 sfp
->timeout_user
= SG_DEFAULT_TIMEOUT_USER
;
2129 sfp
->force_packid
= SG_DEF_FORCE_PACK_ID
;
2130 sfp
->low_dma
= (SG_DEF_FORCE_LOW_DMA
== 0) ?
2131 sdp
->device
->host
->unchecked_isa_dma
: 1;
2132 sfp
->cmd_q
= SG_DEF_COMMAND_Q
;
2133 sfp
->keep_orphan
= SG_DEF_KEEP_ORPHAN
;
2134 sfp
->parentdp
= sdp
;
2135 write_lock_irqsave(&sdp
->sfd_lock
, iflags
);
2136 if (atomic_read(&sdp
->detaching
)) {
2137 write_unlock_irqrestore(&sdp
->sfd_lock
, iflags
);
2138 return ERR_PTR(-ENODEV
);
2140 list_add_tail(&sfp
->sfd_siblings
, &sdp
->sfds
);
2141 write_unlock_irqrestore(&sdp
->sfd_lock
, iflags
);
2142 SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp
));
2143 if (unlikely(sg_big_buff
!= def_reserved_size
))
2144 sg_big_buff
= def_reserved_size
;
2146 bufflen
= min_t(int, sg_big_buff
,
2147 max_sectors_bytes(sdp
->device
->request_queue
));
2148 sg_build_reserve(sfp
, bufflen
);
2149 SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
2150 sfp
->reserve
.bufflen
, sfp
->reserve
.k_use_sg
));
2152 kref_get(&sdp
->d_ref
);
2153 __module_get(THIS_MODULE
);
2158 sg_remove_sfp_usercontext(struct work_struct
*work
)
2160 struct sg_fd
*sfp
= container_of(work
, struct sg_fd
, ew
.work
);
2161 struct sg_device
*sdp
= sfp
->parentdp
;
2163 /* Cleanup any responses which were never read(). */
2165 sg_finish_rem_req(sfp
->headrp
);
2167 if (sfp
->reserve
.bufflen
> 0) {
2169 printk("sg_remove_sfp: bufflen=%d, k_use_sg=%d\n",
2170 (int) sfp
->reserve
.bufflen
,
2171 (int) sfp
->reserve
.k_use_sg
));
2172 sg_remove_scat(&sfp
->reserve
);
2176 printk("sg_remove_sfp: %s, sfp=0x%p\n",
2177 sdp
->disk
->disk_name
,
2181 scsi_device_put(sdp
->device
);
2182 kref_put(&sdp
->d_ref
, sg_device_destroy
);
2183 module_put(THIS_MODULE
);
2187 sg_remove_sfp(struct kref
*kref
)
2189 struct sg_fd
*sfp
= container_of(kref
, struct sg_fd
, f_ref
);
2190 struct sg_device
*sdp
= sfp
->parentdp
;
2191 unsigned long iflags
;
2193 write_lock_irqsave(&sdp
->sfd_lock
, iflags
);
2194 list_del(&sfp
->sfd_siblings
);
2195 write_unlock_irqrestore(&sdp
->sfd_lock
, iflags
);
2197 INIT_WORK(&sfp
->ew
.work
, sg_remove_sfp_usercontext
);
2198 schedule_work(&sfp
->ew
.work
);
2202 sg_res_in_use(Sg_fd
* sfp
)
2204 const Sg_request
*srp
;
2205 unsigned long iflags
;
2207 read_lock_irqsave(&sfp
->rq_list_lock
, iflags
);
2208 for (srp
= sfp
->headrp
; srp
; srp
= srp
->nextrp
)
2211 read_unlock_irqrestore(&sfp
->rq_list_lock
, iflags
);
2215 #ifdef CONFIG_SCSI_PROC_FS
2217 sg_idr_max_id(int id
, void *p
, void *data
)
2231 unsigned long iflags
;
2233 read_lock_irqsave(&sg_index_lock
, iflags
);
2234 idr_for_each(&sg_index_idr
, sg_idr_max_id
, &k
);
2235 read_unlock_irqrestore(&sg_index_lock
, iflags
);
2236 return k
+ 1; /* origin 1 */
2240 /* must be called with sg_index_lock held */
2241 static Sg_device
*sg_lookup_dev(int dev
)
2243 return idr_find(&sg_index_idr
, dev
);
2249 struct sg_device
*sdp
;
2250 unsigned long flags
;
2252 read_lock_irqsave(&sg_index_lock
, flags
);
2253 sdp
= sg_lookup_dev(dev
);
2255 sdp
= ERR_PTR(-ENXIO
);
2256 else if (atomic_read(&sdp
->detaching
)) {
2257 /* If sdp->detaching, then the refcount may already be 0, in
2258 * which case it would be a bug to do kref_get().
2260 sdp
= ERR_PTR(-ENODEV
);
2262 kref_get(&sdp
->d_ref
);
2263 read_unlock_irqrestore(&sg_index_lock
, flags
);
2268 #ifdef CONFIG_SCSI_PROC_FS
2270 static struct proc_dir_entry
*sg_proc_sgp
= NULL
;
2272 static char sg_proc_sg_dirname
[] = "scsi/sg";
2274 static int sg_proc_seq_show_int(struct seq_file
*s
, void *v
);
2276 static int sg_proc_single_open_adio(struct inode
*inode
, struct file
*file
);
2277 static ssize_t
sg_proc_write_adio(struct file
*filp
, const char __user
*buffer
,
2278 size_t count
, loff_t
*off
);
2279 static const struct file_operations adio_fops
= {
2280 .owner
= THIS_MODULE
,
2281 .open
= sg_proc_single_open_adio
,
2283 .llseek
= seq_lseek
,
2284 .write
= sg_proc_write_adio
,
2285 .release
= single_release
,
2288 static int sg_proc_single_open_dressz(struct inode
*inode
, struct file
*file
);
2289 static ssize_t
sg_proc_write_dressz(struct file
*filp
,
2290 const char __user
*buffer
, size_t count
, loff_t
*off
);
2291 static const struct file_operations dressz_fops
= {
2292 .owner
= THIS_MODULE
,
2293 .open
= sg_proc_single_open_dressz
,
2295 .llseek
= seq_lseek
,
2296 .write
= sg_proc_write_dressz
,
2297 .release
= single_release
,
2300 static int sg_proc_seq_show_version(struct seq_file
*s
, void *v
);
2301 static int sg_proc_single_open_version(struct inode
*inode
, struct file
*file
);
2302 static const struct file_operations version_fops
= {
2303 .owner
= THIS_MODULE
,
2304 .open
= sg_proc_single_open_version
,
2306 .llseek
= seq_lseek
,
2307 .release
= single_release
,
2310 static int sg_proc_seq_show_devhdr(struct seq_file
*s
, void *v
);
2311 static int sg_proc_single_open_devhdr(struct inode
*inode
, struct file
*file
);
2312 static const struct file_operations devhdr_fops
= {
2313 .owner
= THIS_MODULE
,
2314 .open
= sg_proc_single_open_devhdr
,
2316 .llseek
= seq_lseek
,
2317 .release
= single_release
,
2320 static int sg_proc_seq_show_dev(struct seq_file
*s
, void *v
);
2321 static int sg_proc_open_dev(struct inode
*inode
, struct file
*file
);
2322 static void * dev_seq_start(struct seq_file
*s
, loff_t
*pos
);
2323 static void * dev_seq_next(struct seq_file
*s
, void *v
, loff_t
*pos
);
2324 static void dev_seq_stop(struct seq_file
*s
, void *v
);
2325 static const struct file_operations dev_fops
= {
2326 .owner
= THIS_MODULE
,
2327 .open
= sg_proc_open_dev
,
2329 .llseek
= seq_lseek
,
2330 .release
= seq_release
,
2332 static const struct seq_operations dev_seq_ops
= {
2333 .start
= dev_seq_start
,
2334 .next
= dev_seq_next
,
2335 .stop
= dev_seq_stop
,
2336 .show
= sg_proc_seq_show_dev
,
2339 static int sg_proc_seq_show_devstrs(struct seq_file
*s
, void *v
);
2340 static int sg_proc_open_devstrs(struct inode
*inode
, struct file
*file
);
2341 static const struct file_operations devstrs_fops
= {
2342 .owner
= THIS_MODULE
,
2343 .open
= sg_proc_open_devstrs
,
2345 .llseek
= seq_lseek
,
2346 .release
= seq_release
,
2348 static const struct seq_operations devstrs_seq_ops
= {
2349 .start
= dev_seq_start
,
2350 .next
= dev_seq_next
,
2351 .stop
= dev_seq_stop
,
2352 .show
= sg_proc_seq_show_devstrs
,
2355 static int sg_proc_seq_show_debug(struct seq_file
*s
, void *v
);
2356 static int sg_proc_open_debug(struct inode
*inode
, struct file
*file
);
2357 static const struct file_operations debug_fops
= {
2358 .owner
= THIS_MODULE
,
2359 .open
= sg_proc_open_debug
,
2361 .llseek
= seq_lseek
,
2362 .release
= seq_release
,
2364 static const struct seq_operations debug_seq_ops
= {
2365 .start
= dev_seq_start
,
2366 .next
= dev_seq_next
,
2367 .stop
= dev_seq_stop
,
2368 .show
= sg_proc_seq_show_debug
,
2372 struct sg_proc_leaf
{
2374 const struct file_operations
* fops
;
2377 static const struct sg_proc_leaf sg_proc_leaf_arr
[] = {
2378 {"allow_dio", &adio_fops
},
2379 {"debug", &debug_fops
},
2380 {"def_reserved_size", &dressz_fops
},
2381 {"device_hdr", &devhdr_fops
},
2382 {"devices", &dev_fops
},
2383 {"device_strs", &devstrs_fops
},
2384 {"version", &version_fops
}
2390 int num_leaves
= ARRAY_SIZE(sg_proc_leaf_arr
);
2393 sg_proc_sgp
= proc_mkdir(sg_proc_sg_dirname
, NULL
);
2396 for (k
= 0; k
< num_leaves
; ++k
) {
2397 const struct sg_proc_leaf
*leaf
= &sg_proc_leaf_arr
[k
];
2398 umode_t mask
= leaf
->fops
->write
? S_IRUGO
| S_IWUSR
: S_IRUGO
;
2399 proc_create(leaf
->name
, mask
, sg_proc_sgp
, leaf
->fops
);
2405 sg_proc_cleanup(void)
2408 int num_leaves
= ARRAY_SIZE(sg_proc_leaf_arr
);
2412 for (k
= 0; k
< num_leaves
; ++k
)
2413 remove_proc_entry(sg_proc_leaf_arr
[k
].name
, sg_proc_sgp
);
2414 remove_proc_entry(sg_proc_sg_dirname
, NULL
);
2418 static int sg_proc_seq_show_int(struct seq_file
*s
, void *v
)
2420 seq_printf(s
, "%d\n", *((int *)s
->private));
2424 static int sg_proc_single_open_adio(struct inode
*inode
, struct file
*file
)
2426 return single_open(file
, sg_proc_seq_show_int
, &sg_allow_dio
);
2430 sg_proc_write_adio(struct file
*filp
, const char __user
*buffer
,
2431 size_t count
, loff_t
*off
)
2436 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
2438 err
= kstrtoul_from_user(buffer
, count
, 0, &num
);
2441 sg_allow_dio
= num
? 1 : 0;
2445 static int sg_proc_single_open_dressz(struct inode
*inode
, struct file
*file
)
2447 return single_open(file
, sg_proc_seq_show_int
, &sg_big_buff
);
2451 sg_proc_write_dressz(struct file
*filp
, const char __user
*buffer
,
2452 size_t count
, loff_t
*off
)
2455 unsigned long k
= ULONG_MAX
;
2457 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
2460 err
= kstrtoul_from_user(buffer
, count
, 0, &k
);
2463 if (k
<= 1048576) { /* limit "big buff" to 1 MB */
2470 static int sg_proc_seq_show_version(struct seq_file
*s
, void *v
)
2472 seq_printf(s
, "%d\t%s [%s]\n", sg_version_num
, SG_VERSION_STR
,
2477 static int sg_proc_single_open_version(struct inode
*inode
, struct file
*file
)
2479 return single_open(file
, sg_proc_seq_show_version
, NULL
);
2482 static int sg_proc_seq_show_devhdr(struct seq_file
*s
, void *v
)
2484 seq_puts(s
, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n");
2488 static int sg_proc_single_open_devhdr(struct inode
*inode
, struct file
*file
)
2490 return single_open(file
, sg_proc_seq_show_devhdr
, NULL
);
2493 struct sg_proc_deviter
{
2498 static void * dev_seq_start(struct seq_file
*s
, loff_t
*pos
)
2500 struct sg_proc_deviter
* it
= kmalloc(sizeof(*it
), GFP_KERNEL
);
2507 it
->max
= sg_last_dev();
2508 if (it
->index
>= it
->max
)
2513 static void * dev_seq_next(struct seq_file
*s
, void *v
, loff_t
*pos
)
2515 struct sg_proc_deviter
* it
= s
->private;
2518 return (it
->index
< it
->max
) ? it
: NULL
;
2521 static void dev_seq_stop(struct seq_file
*s
, void *v
)
2526 static int sg_proc_open_dev(struct inode
*inode
, struct file
*file
)
2528 return seq_open(file
, &dev_seq_ops
);
2531 static int sg_proc_seq_show_dev(struct seq_file
*s
, void *v
)
2533 struct sg_proc_deviter
* it
= (struct sg_proc_deviter
*) v
;
2535 struct scsi_device
*scsidp
;
2536 unsigned long iflags
;
2538 read_lock_irqsave(&sg_index_lock
, iflags
);
2539 sdp
= it
? sg_lookup_dev(it
->index
) : NULL
;
2540 if ((NULL
== sdp
) || (NULL
== sdp
->device
) ||
2541 (atomic_read(&sdp
->detaching
)))
2542 seq_puts(s
, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
2544 scsidp
= sdp
->device
;
2545 seq_printf(s
, "%d\t%d\t%d\t%llu\t%d\t%d\t%d\t%d\t%d\n",
2546 scsidp
->host
->host_no
, scsidp
->channel
,
2547 scsidp
->id
, scsidp
->lun
, (int) scsidp
->type
,
2549 (int) scsidp
->queue_depth
,
2550 (int) scsidp
->device_busy
,
2551 (int) scsi_device_online(scsidp
));
2553 read_unlock_irqrestore(&sg_index_lock
, iflags
);
2557 static int sg_proc_open_devstrs(struct inode
*inode
, struct file
*file
)
2559 return seq_open(file
, &devstrs_seq_ops
);
2562 static int sg_proc_seq_show_devstrs(struct seq_file
*s
, void *v
)
2564 struct sg_proc_deviter
* it
= (struct sg_proc_deviter
*) v
;
2566 struct scsi_device
*scsidp
;
2567 unsigned long iflags
;
2569 read_lock_irqsave(&sg_index_lock
, iflags
);
2570 sdp
= it
? sg_lookup_dev(it
->index
) : NULL
;
2571 scsidp
= sdp
? sdp
->device
: NULL
;
2572 if (sdp
&& scsidp
&& (!atomic_read(&sdp
->detaching
)))
2573 seq_printf(s
, "%8.8s\t%16.16s\t%4.4s\n",
2574 scsidp
->vendor
, scsidp
->model
, scsidp
->rev
);
2576 seq_puts(s
, "<no active device>\n");
2577 read_unlock_irqrestore(&sg_index_lock
, iflags
);
2581 /* must be called while holding sg_index_lock */
2582 static void sg_proc_debug_helper(struct seq_file
*s
, Sg_device
* sdp
)
2584 int k
, m
, new_interface
, blen
, usg
;
2587 const sg_io_hdr_t
*hp
;
2592 list_for_each_entry(fp
, &sdp
->sfds
, sfd_siblings
) {
2594 read_lock(&fp
->rq_list_lock
); /* irqs already disabled */
2595 seq_printf(s
, " FD(%d): timeout=%dms bufflen=%d "
2596 "(res)sgat=%d low_dma=%d\n", k
,
2597 jiffies_to_msecs(fp
->timeout
),
2598 fp
->reserve
.bufflen
,
2599 (int) fp
->reserve
.k_use_sg
,
2601 seq_printf(s
, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
2602 (int) fp
->cmd_q
, (int) fp
->force_packid
,
2603 (int) fp
->keep_orphan
);
2604 for (m
= 0, srp
= fp
->headrp
;
2606 ++m
, srp
= srp
->nextrp
) {
2608 new_interface
= (hp
->interface_id
== '\0') ? 0 : 1;
2609 if (srp
->res_used
) {
2610 if (new_interface
&&
2611 (SG_FLAG_MMAP_IO
& hp
->flags
))
2616 if (SG_INFO_DIRECT_IO_MASK
& hp
->info
)
2622 blen
= srp
->data
.bufflen
;
2623 usg
= srp
->data
.k_use_sg
;
2624 seq_puts(s
, srp
->done
?
2625 ((1 == srp
->done
) ? "rcv:" : "fin:")
2627 seq_printf(s
, " id=%d blen=%d",
2628 srp
->header
.pack_id
, blen
);
2630 seq_printf(s
, " dur=%d", hp
->duration
);
2632 ms
= jiffies_to_msecs(jiffies
);
2633 seq_printf(s
, " t_o/elap=%d/%d",
2634 (new_interface
? hp
->timeout
:
2635 jiffies_to_msecs(fp
->timeout
)),
2636 (ms
> hp
->duration
? ms
- hp
->duration
: 0));
2638 seq_printf(s
, "ms sgat=%d op=0x%02x\n", usg
,
2639 (int) srp
->data
.cmd_opcode
);
2642 seq_puts(s
, " No requests active\n");
2643 read_unlock(&fp
->rq_list_lock
);
2647 static int sg_proc_open_debug(struct inode
*inode
, struct file
*file
)
2649 return seq_open(file
, &debug_seq_ops
);
2652 static int sg_proc_seq_show_debug(struct seq_file
*s
, void *v
)
2654 struct sg_proc_deviter
* it
= (struct sg_proc_deviter
*) v
;
2656 unsigned long iflags
;
2658 if (it
&& (0 == it
->index
))
2659 seq_printf(s
, "max_active_device=%d def_reserved_size=%d\n",
2660 (int)it
->max
, sg_big_buff
);
2662 read_lock_irqsave(&sg_index_lock
, iflags
);
2663 sdp
= it
? sg_lookup_dev(it
->index
) : NULL
;
2666 read_lock(&sdp
->sfd_lock
);
2667 if (!list_empty(&sdp
->sfds
)) {
2668 seq_printf(s
, " >>> device=%s ", sdp
->disk
->disk_name
);
2669 if (atomic_read(&sdp
->detaching
))
2670 seq_puts(s
, "detaching pending close ");
2671 else if (sdp
->device
) {
2672 struct scsi_device
*scsidp
= sdp
->device
;
2674 seq_printf(s
, "%d:%d:%d:%llu em=%d",
2675 scsidp
->host
->host_no
,
2676 scsidp
->channel
, scsidp
->id
,
2678 scsidp
->host
->hostt
->emulated
);
2680 seq_printf(s
, " sg_tablesize=%d excl=%d open_cnt=%d\n",
2681 sdp
->sg_tablesize
, sdp
->exclude
, sdp
->open_cnt
);
2682 sg_proc_debug_helper(s
, sdp
);
2684 read_unlock(&sdp
->sfd_lock
);
2686 read_unlock_irqrestore(&sg_index_lock
, iflags
);
2690 #endif /* CONFIG_SCSI_PROC_FS */
2692 module_init(init_sg
);
2693 module_exit(exit_sg
);