Eric Lee / smarc-fsl-linux-kernel

Commit 0b07de85a76e1346e675f0e98437378932473df7

Authored by Adel Gadllah 17 years ago

Committed by Jens Axboe 17 years ago

allow userspace to modify scsi command filter on per device basis

This patch exports the per-gendisk command filter to user space through
sysfs, so it can be changed by the system administrator.
All users of the old cmd filter have been converted to use the new one.

Original patch from Peter Jones.

Signed-off-by: Adel Gadllah <adel.gadllah@gmail.com>
Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

Showing 8 changed files with 389 additions and 159 deletions Inline Diff

block/Makefile
block/bsg.c
block/cmd-filter.c
block/genhd.c
block/scsi_ioctl.c
drivers/scsi/sg.c
include/linux/blkdev.h
include/linux/genhd.h

block/Makefile

Diff comments View file @ 0b07de8

 #
 # Makefile for the kernel block layer
 #
 obj-$(CONFIG_BLOCK) := elevator.o blk-core.o blk-tag.o blk-sysfs.o \
 			blk-barrier.o blk-settings.o blk-ioc.o blk-map.o \
-			blk-exec.o blk-merge.o ioctl.o genhd.o scsi_ioctl.o
+			blk-exec.o blk-merge.o ioctl.o genhd.o scsi_ioctl.o \
+			cmd-filter.o
 obj-$(CONFIG_BLK_DEV_BSG)	+= bsg.o
 obj-$(CONFIG_IOSCHED_NOOP)	+= noop-iosched.o
 obj-$(CONFIG_IOSCHED_AS)	+= as-iosched.o
 obj-$(CONFIG_IOSCHED_DEADLINE)	+= deadline-iosched.o
 obj-$(CONFIG_IOSCHED_CFQ)	+= cfq-iosched.o
 obj-$(CONFIG_BLK_DEV_IO_TRACE)	+= blktrace.o
 obj-$(CONFIG_BLOCK_COMPAT)	+= compat_ioctl.o
 obj-$(CONFIG_BLK_DEV_INTEGRITY)	+= blk-integrity.o

block/bsg.c

Diff comments View file @ 0b07de8

1	/*	1	/*
2	* bsg.c - block layer implementation of the sg v4 interface	2	* bsg.c - block layer implementation of the sg v4 interface
3	*	3	*
4	* Copyright (C) 2004 Jens Axboe <axboe@suse.de> SUSE Labs	4	* Copyright (C) 2004 Jens Axboe <axboe@suse.de> SUSE Labs
5	* Copyright (C) 2004 Peter M. Jones <pjones@redhat.com>	5	* Copyright (C) 2004 Peter M. Jones <pjones@redhat.com>
6	*	6	*
7	* This file is subject to the terms and conditions of the GNU General Public	7	* This file is subject to the terms and conditions of the GNU General Public
8	* License version 2. See the file "COPYING" in the main directory of this	8	* License version 2. See the file "COPYING" in the main directory of this
9	* archive for more details.	9	* archive for more details.
10	*	10	*
11	*/	11	*/
12	#include <linux/module.h>	12	#include <linux/module.h>
13	#include <linux/init.h>	13	#include <linux/init.h>
14	#include <linux/file.h>	14	#include <linux/file.h>
15	#include <linux/blkdev.h>	15	#include <linux/blkdev.h>
16	#include <linux/poll.h>	16	#include <linux/poll.h>
17	#include <linux/cdev.h>	17	#include <linux/cdev.h>
18	#include <linux/percpu.h>	18	#include <linux/percpu.h>
19	#include <linux/uio.h>	19	#include <linux/uio.h>
20	#include <linux/idr.h>	20	#include <linux/idr.h>
21	#include <linux/bsg.h>	21	#include <linux/bsg.h>
22		22
23	#include <scsi/scsi.h>	23	#include <scsi/scsi.h>
24	#include <scsi/scsi_ioctl.h>	24	#include <scsi/scsi_ioctl.h>
25	#include <scsi/scsi_cmnd.h>	25	#include <scsi/scsi_cmnd.h>
26	#include <scsi/scsi_device.h>	26	#include <scsi/scsi_device.h>
27	#include <scsi/scsi_driver.h>	27	#include <scsi/scsi_driver.h>
28	#include <scsi/sg.h>	28	#include <scsi/sg.h>
29		29
30	#define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"	30	#define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
31	#define BSG_VERSION "0.4"	31	#define BSG_VERSION "0.4"
32		32
33	struct bsg_device {	33	struct bsg_device {
34	struct request_queue *queue;	34	struct request_queue *queue;
35	spinlock_t lock;	35	spinlock_t lock;
36	struct list_head busy_list;	36	struct list_head busy_list;
37	struct list_head done_list;	37	struct list_head done_list;
38	struct hlist_node dev_list;	38	struct hlist_node dev_list;
39	atomic_t ref_count;	39	atomic_t ref_count;
40	int queued_cmds;	40	int queued_cmds;
41	int done_cmds;	41	int done_cmds;
42	wait_queue_head_t wq_done;	42	wait_queue_head_t wq_done;
43	wait_queue_head_t wq_free;	43	wait_queue_head_t wq_free;
44	char name[BUS_ID_SIZE];	44	char name[BUS_ID_SIZE];
45	int max_queue;	45	int max_queue;
46	unsigned long flags;	46	unsigned long flags;
		47	struct blk_scsi_cmd_filter *cmd_filter;
		48	mode_t *f_mode;
47	};	49	};
48		50
49	enum {	51	enum {
50	BSG_F_BLOCK = 1,	52	BSG_F_BLOCK = 1,
51	BSG_F_WRITE_PERM = 2,
52	};	53	};
53		54
54	#define BSG_DEFAULT_CMDS 64	55	#define BSG_DEFAULT_CMDS 64
55	#define BSG_MAX_DEVS 32768	56	#define BSG_MAX_DEVS 32768
56		57
57	#undef BSG_DEBUG	58	#undef BSG_DEBUG
58		59
59	#ifdef BSG_DEBUG	60	#ifdef BSG_DEBUG
60	#define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)	61	#define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)
61	#else	62	#else
62	#define dprintk(fmt, args...)	63	#define dprintk(fmt, args...)
63	#endif	64	#endif
64		65
65	static DEFINE_MUTEX(bsg_mutex);	66	static DEFINE_MUTEX(bsg_mutex);
66	static DEFINE_IDR(bsg_minor_idr);	67	static DEFINE_IDR(bsg_minor_idr);
67		68
68	#define BSG_LIST_ARRAY_SIZE 8	69	#define BSG_LIST_ARRAY_SIZE 8
69	static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];	70	static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];
70		71
71	static struct class *bsg_class;	72	static struct class *bsg_class;
72	static int bsg_major;	73	static int bsg_major;
73		74
74	static struct kmem_cache *bsg_cmd_cachep;	75	static struct kmem_cache *bsg_cmd_cachep;
75		76
76	/*	77	/*
77	* our internal command type	78	* our internal command type
78	*/	79	*/
79	struct bsg_command {	80	struct bsg_command {
80	struct bsg_device *bd;	81	struct bsg_device *bd;
81	struct list_head list;	82	struct list_head list;
82	struct request *rq;	83	struct request *rq;
83	struct bio *bio;	84	struct bio *bio;
84	struct bio *bidi_bio;	85	struct bio *bidi_bio;
85	int err;	86	int err;
86	struct sg_io_v4 hdr;	87	struct sg_io_v4 hdr;
87	char sense[SCSI_SENSE_BUFFERSIZE];	88	char sense[SCSI_SENSE_BUFFERSIZE];
88	};	89	};
89		90
90	static void bsg_free_command(struct bsg_command *bc)	91	static void bsg_free_command(struct bsg_command *bc)
91	{	92	{
92	struct bsg_device *bd = bc->bd;	93	struct bsg_device *bd = bc->bd;
93	unsigned long flags;	94	unsigned long flags;
94		95
95	kmem_cache_free(bsg_cmd_cachep, bc);	96	kmem_cache_free(bsg_cmd_cachep, bc);
96		97
97	spin_lock_irqsave(&bd->lock, flags);	98	spin_lock_irqsave(&bd->lock, flags);
98	bd->queued_cmds--;	99	bd->queued_cmds--;
99	spin_unlock_irqrestore(&bd->lock, flags);	100	spin_unlock_irqrestore(&bd->lock, flags);
100		101
101	wake_up(&bd->wq_free);	102	wake_up(&bd->wq_free);
102	}	103	}
103		104
104	static struct bsg_command bsg_alloc_command(struct bsg_device bd)	105	static struct bsg_command bsg_alloc_command(struct bsg_device bd)
105	{	106	{
106	struct bsg_command *bc = ERR_PTR(-EINVAL);	107	struct bsg_command *bc = ERR_PTR(-EINVAL);
107		108
108	spin_lock_irq(&bd->lock);	109	spin_lock_irq(&bd->lock);
109		110
110	if (bd->queued_cmds >= bd->max_queue)	111	if (bd->queued_cmds >= bd->max_queue)
111	goto out;	112	goto out;
112		113
113	bd->queued_cmds++;	114	bd->queued_cmds++;
114	spin_unlock_irq(&bd->lock);	115	spin_unlock_irq(&bd->lock);
115		116
116	bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);	117	bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);
117	if (unlikely(!bc)) {	118	if (unlikely(!bc)) {
118	spin_lock_irq(&bd->lock);	119	spin_lock_irq(&bd->lock);
119	bd->queued_cmds--;	120	bd->queued_cmds--;
120	bc = ERR_PTR(-ENOMEM);	121	bc = ERR_PTR(-ENOMEM);
121	goto out;	122	goto out;
122	}	123	}
123		124
124	bc->bd = bd;	125	bc->bd = bd;
125	INIT_LIST_HEAD(&bc->list);	126	INIT_LIST_HEAD(&bc->list);
126	dprintk("%s: returning free cmd %p\n", bd->name, bc);	127	dprintk("%s: returning free cmd %p\n", bd->name, bc);
127	return bc;	128	return bc;
128	out:	129	out:
129	spin_unlock_irq(&bd->lock);	130	spin_unlock_irq(&bd->lock);
130	return bc;	131	return bc;
131	}	132	}
132		133
133	static inline struct hlist_head *bsg_dev_idx_hash(int index)	134	static inline struct hlist_head *bsg_dev_idx_hash(int index)
134	{	135	{
135	return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];	136	return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];
136	}	137	}
137		138
138	static int bsg_io_schedule(struct bsg_device *bd)	139	static int bsg_io_schedule(struct bsg_device *bd)
139	{	140	{
140	DEFINE_WAIT(wait);	141	DEFINE_WAIT(wait);
141	int ret = 0;	142	int ret = 0;
142		143
143	spin_lock_irq(&bd->lock);	144	spin_lock_irq(&bd->lock);
144		145
145	BUG_ON(bd->done_cmds > bd->queued_cmds);	146	BUG_ON(bd->done_cmds > bd->queued_cmds);
146		147
147	/*	148	/*
148	* -ENOSPC or -ENODATA? I'm going for -ENODATA, meaning "I have no	149	* -ENOSPC or -ENODATA? I'm going for -ENODATA, meaning "I have no
149	* work to do", even though we return -ENOSPC after this same test	150	* work to do", even though we return -ENOSPC after this same test
150	* during bsg_write() -- there, it means our buffer can't have more	151	* during bsg_write() -- there, it means our buffer can't have more
151	* bsg_commands added to it, thus has no space left.	152	* bsg_commands added to it, thus has no space left.
152	*/	153	*/
153	if (bd->done_cmds == bd->queued_cmds) {	154	if (bd->done_cmds == bd->queued_cmds) {
154	ret = -ENODATA;	155	ret = -ENODATA;
155	goto unlock;	156	goto unlock;
156	}	157	}
157		158
158	if (!test_bit(BSG_F_BLOCK, &bd->flags)) {	159	if (!test_bit(BSG_F_BLOCK, &bd->flags)) {
159	ret = -EAGAIN;	160	ret = -EAGAIN;
160	goto unlock;	161	goto unlock;
161	}	162	}
162		163
163	prepare_to_wait(&bd->wq_done, &wait, TASK_UNINTERRUPTIBLE);	164	prepare_to_wait(&bd->wq_done, &wait, TASK_UNINTERRUPTIBLE);
164	spin_unlock_irq(&bd->lock);	165	spin_unlock_irq(&bd->lock);
165	io_schedule();	166	io_schedule();
166	finish_wait(&bd->wq_done, &wait);	167	finish_wait(&bd->wq_done, &wait);
167		168
168	return ret;	169	return ret;
169	unlock:	170	unlock:
170	spin_unlock_irq(&bd->lock);	171	spin_unlock_irq(&bd->lock);
171	return ret;	172	return ret;
172	}	173	}
173		174
174	static int blk_fill_sgv4_hdr_rq(struct request_queue q, struct request rq,	175	static int blk_fill_sgv4_hdr_rq(struct request_queue q, struct request rq,
175	struct sg_io_v4 *hdr, int has_write_perm)	176	struct sg_io_v4 hdr, struct bsg_device bd)
176	{	177	{
177	if (hdr->request_len > BLK_MAX_CDB) {	178	if (hdr->request_len > BLK_MAX_CDB) {
178	rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);	179	rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
179	if (!rq->cmd)	180	if (!rq->cmd)
180	return -ENOMEM;	181	return -ENOMEM;
181	}	182	}
182		183
183	if (copy_from_user(rq->cmd, (void *)(unsigned long)hdr->request,	184	if (copy_from_user(rq->cmd, (void *)(unsigned long)hdr->request,
184	hdr->request_len))	185	hdr->request_len))
185	return -EFAULT;	186	return -EFAULT;
186		187
187	if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {	188	if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {
188	if (blk_verify_command(rq->cmd, has_write_perm))	189	if (blk_cmd_filter_verify_command(bd->cmd_filter, rq->cmd,
		190	bd->f_mode))
189	return -EPERM;	191	return -EPERM;
190	} else if (!capable(CAP_SYS_RAWIO))	192	} else if (!capable(CAP_SYS_RAWIO))
191	return -EPERM;	193	return -EPERM;
192		194
193	/*	195	/*
194	* fill in request structure	196	* fill in request structure
195	*/	197	*/
196	rq->cmd_len = hdr->request_len;	198	rq->cmd_len = hdr->request_len;
197	rq->cmd_type = REQ_TYPE_BLOCK_PC;	199	rq->cmd_type = REQ_TYPE_BLOCK_PC;
198		200
199	rq->timeout = (hdr->timeout * HZ) / 1000;	201	rq->timeout = (hdr->timeout * HZ) / 1000;
200	if (!rq->timeout)	202	if (!rq->timeout)
201	rq->timeout = q->sg_timeout;	203	rq->timeout = q->sg_timeout;
202	if (!rq->timeout)	204	if (!rq->timeout)
203	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;	205	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
204		206
205	return 0;	207	return 0;
206	}	208	}
207		209
208	/*	210	/*
209	* Check if sg_io_v4 from user is allowed and valid	211	* Check if sg_io_v4 from user is allowed and valid
210	*/	212	*/
211	static int	213	static int
212	bsg_validate_sgv4_hdr(struct request_queue q, struct sg_io_v4 hdr, int *rw)	214	bsg_validate_sgv4_hdr(struct request_queue q, struct sg_io_v4 hdr, int *rw)
213	{	215	{
214	int ret = 0;	216	int ret = 0;
215		217
216	if (hdr->guard != 'Q')	218	if (hdr->guard != 'Q')
217	return -EINVAL;	219	return -EINVAL;
218	if (hdr->dout_xfer_len > (q->max_sectors << 9) \|\|	220	if (hdr->dout_xfer_len > (q->max_sectors << 9) \|\|
219	hdr->din_xfer_len > (q->max_sectors << 9))	221	hdr->din_xfer_len > (q->max_sectors << 9))
220	return -EIO;	222	return -EIO;
221		223
222	switch (hdr->protocol) {	224	switch (hdr->protocol) {
223	case BSG_PROTOCOL_SCSI:	225	case BSG_PROTOCOL_SCSI:
224	switch (hdr->subprotocol) {	226	switch (hdr->subprotocol) {
225	case BSG_SUB_PROTOCOL_SCSI_CMD:	227	case BSG_SUB_PROTOCOL_SCSI_CMD:
226	case BSG_SUB_PROTOCOL_SCSI_TRANSPORT:	228	case BSG_SUB_PROTOCOL_SCSI_TRANSPORT:
227	break;	229	break;
228	default:	230	default:
229	ret = -EINVAL;	231	ret = -EINVAL;
230	}	232	}
231	break;	233	break;
232	default:	234	default:
233	ret = -EINVAL;	235	ret = -EINVAL;
234	}	236	}
235		237
236	*rw = hdr->dout_xfer_len ? WRITE : READ;	238	*rw = hdr->dout_xfer_len ? WRITE : READ;
237	return ret;	239	return ret;
238	}	240	}
239		241
240	/*	242	/*
241	* map sg_io_v4 to a request.	243	* map sg_io_v4 to a request.
242	*/	244	*/
243	static struct request *	245	static struct request *
244	bsg_map_hdr(struct bsg_device bd, struct sg_io_v4 hdr)	246	bsg_map_hdr(struct bsg_device bd, struct sg_io_v4 hdr)
245	{	247	{
246	struct request_queue *q = bd->queue;	248	struct request_queue *q = bd->queue;
247	struct request rq, next_rq = NULL;	249	struct request rq, next_rq = NULL;
248	int ret, rw;	250	int ret, rw;
249	unsigned int dxfer_len;	251	unsigned int dxfer_len;
250	void *dxferp = NULL;	252	void *dxferp = NULL;
251		253
252	dprintk("map hdr %llx/%u %llx/%u\n", (unsigned long long) hdr->dout_xferp,	254	dprintk("map hdr %llx/%u %llx/%u\n", (unsigned long long) hdr->dout_xferp,
253	hdr->dout_xfer_len, (unsigned long long) hdr->din_xferp,	255	hdr->dout_xfer_len, (unsigned long long) hdr->din_xferp,
254	hdr->din_xfer_len);	256	hdr->din_xfer_len);
255		257
256	ret = bsg_validate_sgv4_hdr(q, hdr, &rw);	258	ret = bsg_validate_sgv4_hdr(q, hdr, &rw);
257	if (ret)	259	if (ret)
258	return ERR_PTR(ret);	260	return ERR_PTR(ret);
259		261
260	/*	262	/*
261	* map scatter-gather elements seperately and string them to request	263	* map scatter-gather elements seperately and string them to request
262	*/	264	*/
263	rq = blk_get_request(q, rw, GFP_KERNEL);	265	rq = blk_get_request(q, rw, GFP_KERNEL);
264	if (!rq)	266	if (!rq)
265	return ERR_PTR(-ENOMEM);	267	return ERR_PTR(-ENOMEM);
266	ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, test_bit(BSG_F_WRITE_PERM,	268	ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd);
267	&bd->flags));
268	if (ret)	269	if (ret)
269	goto out;	270	goto out;
270		271
271	if (rw == WRITE && hdr->din_xfer_len) {	272	if (rw == WRITE && hdr->din_xfer_len) {
272	if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) {	273	if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) {
273	ret = -EOPNOTSUPP;	274	ret = -EOPNOTSUPP;
274	goto out;	275	goto out;
275	}	276	}
276		277
277	next_rq = blk_get_request(q, READ, GFP_KERNEL);	278	next_rq = blk_get_request(q, READ, GFP_KERNEL);
278	if (!next_rq) {	279	if (!next_rq) {
279	ret = -ENOMEM;	280	ret = -ENOMEM;
280	goto out;	281	goto out;
281	}	282	}
282	rq->next_rq = next_rq;	283	rq->next_rq = next_rq;
283	next_rq->cmd_type = rq->cmd_type;	284	next_rq->cmd_type = rq->cmd_type;
284		285
285	dxferp = (void*)(unsigned long)hdr->din_xferp;	286	dxferp = (void*)(unsigned long)hdr->din_xferp;
286	ret = blk_rq_map_user(q, next_rq, dxferp, hdr->din_xfer_len);	287	ret = blk_rq_map_user(q, next_rq, dxferp, hdr->din_xfer_len);
287	if (ret)	288	if (ret)
288	goto out;	289	goto out;
289	}	290	}
290		291
291	if (hdr->dout_xfer_len) {	292	if (hdr->dout_xfer_len) {
292	dxfer_len = hdr->dout_xfer_len;	293	dxfer_len = hdr->dout_xfer_len;
293	dxferp = (void*)(unsigned long)hdr->dout_xferp;	294	dxferp = (void*)(unsigned long)hdr->dout_xferp;
294	} else if (hdr->din_xfer_len) {	295	} else if (hdr->din_xfer_len) {
295	dxfer_len = hdr->din_xfer_len;	296	dxfer_len = hdr->din_xfer_len;
296	dxferp = (void*)(unsigned long)hdr->din_xferp;	297	dxferp = (void*)(unsigned long)hdr->din_xferp;
297	} else	298	} else
298	dxfer_len = 0;	299	dxfer_len = 0;
299		300
300	if (dxfer_len) {	301	if (dxfer_len) {
301	ret = blk_rq_map_user(q, rq, dxferp, dxfer_len);	302	ret = blk_rq_map_user(q, rq, dxferp, dxfer_len);
302	if (ret)	303	if (ret)
303	goto out;	304	goto out;
304	}	305	}
305	return rq;	306	return rq;
306	out:	307	out:
307	if (rq->cmd != rq->__cmd)	308	if (rq->cmd != rq->__cmd)
308	kfree(rq->cmd);	309	kfree(rq->cmd);
309	blk_put_request(rq);	310	blk_put_request(rq);
310	if (next_rq) {	311	if (next_rq) {
311	blk_rq_unmap_user(next_rq->bio);	312	blk_rq_unmap_user(next_rq->bio);
312	blk_put_request(next_rq);	313	blk_put_request(next_rq);
313	}	314	}
314	return ERR_PTR(ret);	315	return ERR_PTR(ret);
315	}	316	}
316		317
317	/*	318	/*
318	* async completion call-back from the block layer, when scsi/ide/whatever	319	* async completion call-back from the block layer, when scsi/ide/whatever
319	* calls end_that_request_last() on a request	320	* calls end_that_request_last() on a request
320	*/	321	*/
321	static void bsg_rq_end_io(struct request *rq, int uptodate)	322	static void bsg_rq_end_io(struct request *rq, int uptodate)
322	{	323	{
323	struct bsg_command *bc = rq->end_io_data;	324	struct bsg_command *bc = rq->end_io_data;
324	struct bsg_device *bd = bc->bd;	325	struct bsg_device *bd = bc->bd;
325	unsigned long flags;	326	unsigned long flags;
326		327
327	dprintk("%s: finished rq %p bc %p, bio %p stat %d\n",	328	dprintk("%s: finished rq %p bc %p, bio %p stat %d\n",
328	bd->name, rq, bc, bc->bio, uptodate);	329	bd->name, rq, bc, bc->bio, uptodate);
329		330
330	bc->hdr.duration = jiffies_to_msecs(jiffies - bc->hdr.duration);	331	bc->hdr.duration = jiffies_to_msecs(jiffies - bc->hdr.duration);
331		332
332	spin_lock_irqsave(&bd->lock, flags);	333	spin_lock_irqsave(&bd->lock, flags);
333	list_move_tail(&bc->list, &bd->done_list);	334	list_move_tail(&bc->list, &bd->done_list);
334	bd->done_cmds++;	335	bd->done_cmds++;
335	spin_unlock_irqrestore(&bd->lock, flags);	336	spin_unlock_irqrestore(&bd->lock, flags);
336		337
337	wake_up(&bd->wq_done);	338	wake_up(&bd->wq_done);
338	}	339	}
339		340
340	/*	341	/*
341	* do final setup of a 'bc' and submit the matching 'rq' to the block	342	* do final setup of a 'bc' and submit the matching 'rq' to the block
342	* layer for io	343	* layer for io
343	*/	344	*/
344	static void bsg_add_command(struct bsg_device bd, struct request_queue q,	345	static void bsg_add_command(struct bsg_device bd, struct request_queue q,
345	struct bsg_command bc, struct request rq)	346	struct bsg_command bc, struct request rq)
346	{	347	{
347	rq->sense = bc->sense;	348	rq->sense = bc->sense;
348	rq->sense_len = 0;	349	rq->sense_len = 0;
349		350
350	/*	351	/*
351	* add bc command to busy queue and submit rq for io	352	* add bc command to busy queue and submit rq for io
352	*/	353	*/
353	bc->rq = rq;	354	bc->rq = rq;
354	bc->bio = rq->bio;	355	bc->bio = rq->bio;
355	if (rq->next_rq)	356	if (rq->next_rq)
356	bc->bidi_bio = rq->next_rq->bio;	357	bc->bidi_bio = rq->next_rq->bio;
357	bc->hdr.duration = jiffies;	358	bc->hdr.duration = jiffies;
358	spin_lock_irq(&bd->lock);	359	spin_lock_irq(&bd->lock);
359	list_add_tail(&bc->list, &bd->busy_list);	360	list_add_tail(&bc->list, &bd->busy_list);
360	spin_unlock_irq(&bd->lock);	361	spin_unlock_irq(&bd->lock);
361		362
362	dprintk("%s: queueing rq %p, bc %p\n", bd->name, rq, bc);	363	dprintk("%s: queueing rq %p, bc %p\n", bd->name, rq, bc);
363		364
364	rq->end_io_data = bc;	365	rq->end_io_data = bc;
365	blk_execute_rq_nowait(q, NULL, rq, 1, bsg_rq_end_io);	366	blk_execute_rq_nowait(q, NULL, rq, 1, bsg_rq_end_io);
366	}	367	}
367		368
368	static struct bsg_command bsg_next_done_cmd(struct bsg_device bd)	369	static struct bsg_command bsg_next_done_cmd(struct bsg_device bd)
369	{	370	{
370	struct bsg_command *bc = NULL;	371	struct bsg_command *bc = NULL;
371		372
372	spin_lock_irq(&bd->lock);	373	spin_lock_irq(&bd->lock);
373	if (bd->done_cmds) {	374	if (bd->done_cmds) {
374	bc = list_first_entry(&bd->done_list, struct bsg_command, list);	375	bc = list_first_entry(&bd->done_list, struct bsg_command, list);
375	list_del(&bc->list);	376	list_del(&bc->list);
376	bd->done_cmds--;	377	bd->done_cmds--;
377	}	378	}
378	spin_unlock_irq(&bd->lock);	379	spin_unlock_irq(&bd->lock);
379		380
380	return bc;	381	return bc;
381	}	382	}
382		383
383	/*	384	/*
384	* Get a finished command from the done list	385	* Get a finished command from the done list
385	*/	386	*/
386	static struct bsg_command bsg_get_done_cmd(struct bsg_device bd)	387	static struct bsg_command bsg_get_done_cmd(struct bsg_device bd)
387	{	388	{
388	struct bsg_command *bc;	389	struct bsg_command *bc;
389	int ret;	390	int ret;
390		391
391	do {	392	do {
392	bc = bsg_next_done_cmd(bd);	393	bc = bsg_next_done_cmd(bd);
393	if (bc)	394	if (bc)
394	break;	395	break;
395		396
396	if (!test_bit(BSG_F_BLOCK, &bd->flags)) {	397	if (!test_bit(BSG_F_BLOCK, &bd->flags)) {
397	bc = ERR_PTR(-EAGAIN);	398	bc = ERR_PTR(-EAGAIN);
398	break;	399	break;
399	}	400	}
400		401
401	ret = wait_event_interruptible(bd->wq_done, bd->done_cmds);	402	ret = wait_event_interruptible(bd->wq_done, bd->done_cmds);
402	if (ret) {	403	if (ret) {
403	bc = ERR_PTR(-ERESTARTSYS);	404	bc = ERR_PTR(-ERESTARTSYS);
404	break;	405	break;
405	}	406	}
406	} while (1);	407	} while (1);
407		408
408	dprintk("%s: returning done %p\n", bd->name, bc);	409	dprintk("%s: returning done %p\n", bd->name, bc);
409		410
410	return bc;	411	return bc;
411	}	412	}
412		413
413	static int blk_complete_sgv4_hdr_rq(struct request rq, struct sg_io_v4 hdr,	414	static int blk_complete_sgv4_hdr_rq(struct request rq, struct sg_io_v4 hdr,
414	struct bio bio, struct bio bidi_bio)	415	struct bio bio, struct bio bidi_bio)
415	{	416	{
416	int ret = 0;	417	int ret = 0;
417		418
418	dprintk("rq %p bio %p %u\n", rq, bio, rq->errors);	419	dprintk("rq %p bio %p %u\n", rq, bio, rq->errors);
419	/*	420	/*
420	* fill in all the output members	421	* fill in all the output members
421	*/	422	*/
422	hdr->device_status = status_byte(rq->errors);	423	hdr->device_status = status_byte(rq->errors);
423	hdr->transport_status = host_byte(rq->errors);	424	hdr->transport_status = host_byte(rq->errors);
424	hdr->driver_status = driver_byte(rq->errors);	425	hdr->driver_status = driver_byte(rq->errors);
425	hdr->info = 0;	426	hdr->info = 0;
426	if (hdr->device_status \|\| hdr->transport_status \|\| hdr->driver_status)	427	if (hdr->device_status \|\| hdr->transport_status \|\| hdr->driver_status)
427	hdr->info \|= SG_INFO_CHECK;	428	hdr->info \|= SG_INFO_CHECK;
428	hdr->response_len = 0;	429	hdr->response_len = 0;
429		430
430	if (rq->sense_len && hdr->response) {	431	if (rq->sense_len && hdr->response) {
431	int len = min_t(unsigned int, hdr->max_response_len,	432	int len = min_t(unsigned int, hdr->max_response_len,
432	rq->sense_len);	433	rq->sense_len);
433		434
434	ret = copy_to_user((void*)(unsigned long)hdr->response,	435	ret = copy_to_user((void*)(unsigned long)hdr->response,
435	rq->sense, len);	436	rq->sense, len);
436	if (!ret)	437	if (!ret)
437	hdr->response_len = len;	438	hdr->response_len = len;
438	else	439	else
439	ret = -EFAULT;	440	ret = -EFAULT;
440	}	441	}
441		442
442	if (rq->next_rq) {	443	if (rq->next_rq) {
443	hdr->dout_resid = rq->data_len;	444	hdr->dout_resid = rq->data_len;
444	hdr->din_resid = rq->next_rq->data_len;	445	hdr->din_resid = rq->next_rq->data_len;
445	blk_rq_unmap_user(bidi_bio);	446	blk_rq_unmap_user(bidi_bio);
446	blk_put_request(rq->next_rq);	447	blk_put_request(rq->next_rq);
447	} else if (rq_data_dir(rq) == READ)	448	} else if (rq_data_dir(rq) == READ)
448	hdr->din_resid = rq->data_len;	449	hdr->din_resid = rq->data_len;
449	else	450	else
450	hdr->dout_resid = rq->data_len;	451	hdr->dout_resid = rq->data_len;
451		452
452	/*	453	/*
453	* If the request generated a negative error number, return it	454	* If the request generated a negative error number, return it
454	* (providing we aren't already returning an error); if it's	455	* (providing we aren't already returning an error); if it's
455	* just a protocol response (i.e. non negative), that gets	456	* just a protocol response (i.e. non negative), that gets
456	* processed above.	457	* processed above.
457	*/	458	*/
458	if (!ret && rq->errors < 0)	459	if (!ret && rq->errors < 0)
459	ret = rq->errors;	460	ret = rq->errors;
460		461
461	blk_rq_unmap_user(bio);	462	blk_rq_unmap_user(bio);
462	if (rq->cmd != rq->__cmd)	463	if (rq->cmd != rq->__cmd)
463	kfree(rq->cmd);	464	kfree(rq->cmd);
464	blk_put_request(rq);	465	blk_put_request(rq);
465		466
466	return ret;	467	return ret;
467	}	468	}
468		469
469	static int bsg_complete_all_commands(struct bsg_device *bd)	470	static int bsg_complete_all_commands(struct bsg_device *bd)
470	{	471	{
471	struct bsg_command *bc;	472	struct bsg_command *bc;
472	int ret, tret;	473	int ret, tret;
473		474
474	dprintk("%s: entered\n", bd->name);	475	dprintk("%s: entered\n", bd->name);
475		476
476	/*	477	/*
477	* wait for all commands to complete	478	* wait for all commands to complete
478	*/	479	*/
479	ret = 0;	480	ret = 0;
480	do {	481	do {
481	ret = bsg_io_schedule(bd);	482	ret = bsg_io_schedule(bd);
482	/*	483	/*
483	* look for -ENODATA specifically -- we'll sometimes get	484	* look for -ENODATA specifically -- we'll sometimes get
484	* -ERESTARTSYS when we've taken a signal, but we can't	485	* -ERESTARTSYS when we've taken a signal, but we can't
485	* return until we're done freeing the queue, so ignore	486	* return until we're done freeing the queue, so ignore
486	* it. The signal will get handled when we're done freeing	487	* it. The signal will get handled when we're done freeing
487	* the bsg_device.	488	* the bsg_device.
488	*/	489	*/
489	} while (ret != -ENODATA);	490	} while (ret != -ENODATA);
490		491
491	/*	492	/*
492	* discard done commands	493	* discard done commands
493	*/	494	*/
494	ret = 0;	495	ret = 0;
495	do {	496	do {
496	spin_lock_irq(&bd->lock);	497	spin_lock_irq(&bd->lock);
497	if (!bd->queued_cmds) {	498	if (!bd->queued_cmds) {
498	spin_unlock_irq(&bd->lock);	499	spin_unlock_irq(&bd->lock);
499	break;	500	break;
500	}	501	}
501	spin_unlock_irq(&bd->lock);	502	spin_unlock_irq(&bd->lock);
502		503
503	bc = bsg_get_done_cmd(bd);	504	bc = bsg_get_done_cmd(bd);
504	if (IS_ERR(bc))	505	if (IS_ERR(bc))
505	break;	506	break;
506		507
507	tret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,	508	tret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
508	bc->bidi_bio);	509	bc->bidi_bio);
509	if (!ret)	510	if (!ret)
510	ret = tret;	511	ret = tret;
511		512
512	bsg_free_command(bc);	513	bsg_free_command(bc);
513	} while (1);	514	} while (1);
514		515
515	return ret;	516	return ret;
516	}	517	}
517		518
518	static int	519	static int
519	__bsg_read(char __user buf, size_t count, struct bsg_device bd,	520	__bsg_read(char __user buf, size_t count, struct bsg_device bd,
520	const struct iovec iov, ssize_t bytes_read)	521	const struct iovec iov, ssize_t bytes_read)
521	{	522	{
522	struct bsg_command *bc;	523	struct bsg_command *bc;
523	int nr_commands, ret;	524	int nr_commands, ret;
524		525
525	if (count % sizeof(struct sg_io_v4))	526	if (count % sizeof(struct sg_io_v4))
526	return -EINVAL;	527	return -EINVAL;
527		528
528	ret = 0;	529	ret = 0;
529	nr_commands = count / sizeof(struct sg_io_v4);	530	nr_commands = count / sizeof(struct sg_io_v4);
530	while (nr_commands) {	531	while (nr_commands) {
531	bc = bsg_get_done_cmd(bd);	532	bc = bsg_get_done_cmd(bd);
532	if (IS_ERR(bc)) {	533	if (IS_ERR(bc)) {
533	ret = PTR_ERR(bc);	534	ret = PTR_ERR(bc);
534	break;	535	break;
535	}	536	}
536		537
537	/*	538	/*
538	* this is the only case where we need to copy data back	539	* this is the only case where we need to copy data back
539	* after completing the request. so do that here,	540	* after completing the request. so do that here,
540	* bsg_complete_work() cannot do that for us	541	* bsg_complete_work() cannot do that for us
541	*/	542	*/
542	ret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,	543	ret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
543	bc->bidi_bio);	544	bc->bidi_bio);
544		545
545	if (copy_to_user(buf, &bc->hdr, sizeof(bc->hdr)))	546	if (copy_to_user(buf, &bc->hdr, sizeof(bc->hdr)))
546	ret = -EFAULT;	547	ret = -EFAULT;
547		548
548	bsg_free_command(bc);	549	bsg_free_command(bc);
549		550
550	if (ret)	551	if (ret)
551	break;	552	break;
552		553
553	buf += sizeof(struct sg_io_v4);	554	buf += sizeof(struct sg_io_v4);
554	*bytes_read += sizeof(struct sg_io_v4);	555	*bytes_read += sizeof(struct sg_io_v4);
555	nr_commands--;	556	nr_commands--;
556	}	557	}
557		558
558	return ret;	559	return ret;
559	}	560	}
560		561
561	static inline void bsg_set_block(struct bsg_device bd, struct file file)	562	static inline void bsg_set_block(struct bsg_device bd, struct file file)
562	{	563	{
563	if (file->f_flags & O_NONBLOCK)	564	if (file->f_flags & O_NONBLOCK)
564	clear_bit(BSG_F_BLOCK, &bd->flags);	565	clear_bit(BSG_F_BLOCK, &bd->flags);
565	else	566	else
566	set_bit(BSG_F_BLOCK, &bd->flags);	567	set_bit(BSG_F_BLOCK, &bd->flags);
567	}	568	}
568		569
569	static inline void bsg_set_write_perm(struct bsg_device bd, struct file file)	570	static void bsg_set_cmd_filter(struct bsg_device *bd,
		571	struct file *file)
570	{	572	{
571	if (file->f_mode & FMODE_WRITE)	573	struct inode *inode;
572	set_bit(BSG_F_WRITE_PERM, &bd->flags);	574	struct gendisk *disk;
573	else	575
574	clear_bit(BSG_F_WRITE_PERM, &bd->flags);	576	if (!file)
		577	return;
		578
		579	inode = file->f_dentry->d_inode;
		580	if (!inode)
		581	return;
		582
		583	disk = inode->i_bdev->bd_disk;
		584
		585	bd->cmd_filter = &disk->cmd_filter;
		586	bd->f_mode = &file->f_mode;
575	}	587	}
576		588
577	/*	589	/*
578	* Check if the error is a "real" error that we should return.	590	* Check if the error is a "real" error that we should return.
579	*/	591	*/
580	static inline int err_block_err(int ret)	592	static inline int err_block_err(int ret)
581	{	593	{
582	if (ret && ret != -ENOSPC && ret != -ENODATA && ret != -EAGAIN)	594	if (ret && ret != -ENOSPC && ret != -ENODATA && ret != -EAGAIN)
583	return 1;	595	return 1;
584		596
585	return 0;	597	return 0;
586	}	598	}
587		599
588	static ssize_t	600	static ssize_t
589	bsg_read(struct file file, char __user buf, size_t count, loff_t *ppos)	601	bsg_read(struct file file, char __user buf, size_t count, loff_t *ppos)
590	{	602	{
591	struct bsg_device *bd = file->private_data;	603	struct bsg_device *bd = file->private_data;
592	int ret;	604	int ret;
593	ssize_t bytes_read;	605	ssize_t bytes_read;
594		606
595	dprintk("%s: read %Zd bytes\n", bd->name, count);	607	dprintk("%s: read %Zd bytes\n", bd->name, count);
596		608
597	bsg_set_block(bd, file);	609	bsg_set_block(bd, file);
		610	bsg_set_cmd_filter(bd, file);
		611
598	bytes_read = 0;	612	bytes_read = 0;
599	ret = __bsg_read(buf, count, bd, NULL, &bytes_read);	613	ret = __bsg_read(buf, count, bd, NULL, &bytes_read);
600	*ppos = bytes_read;	614	*ppos = bytes_read;
601		615
602	if (!bytes_read \|\| (bytes_read && err_block_err(ret)))	616	if (!bytes_read \|\| (bytes_read && err_block_err(ret)))
603	bytes_read = ret;	617	bytes_read = ret;
604		618
605	return bytes_read;	619	return bytes_read;
606	}	620	}
607		621
608	static int __bsg_write(struct bsg_device bd, const char __user buf,	622	static int __bsg_write(struct bsg_device bd, const char __user buf,
609	size_t count, ssize_t *bytes_written)	623	size_t count, ssize_t *bytes_written)
610	{	624	{
611	struct bsg_command *bc;	625	struct bsg_command *bc;
612	struct request *rq;	626	struct request *rq;
613	int ret, nr_commands;	627	int ret, nr_commands;
614		628
615	if (count % sizeof(struct sg_io_v4))	629	if (count % sizeof(struct sg_io_v4))
616	return -EINVAL;	630	return -EINVAL;
617		631
618	nr_commands = count / sizeof(struct sg_io_v4);	632	nr_commands = count / sizeof(struct sg_io_v4);
619	rq = NULL;	633	rq = NULL;
620	bc = NULL;	634	bc = NULL;
621	ret = 0;	635	ret = 0;
622	while (nr_commands) {	636	while (nr_commands) {
623	struct request_queue *q = bd->queue;	637	struct request_queue *q = bd->queue;
624		638
625	bc = bsg_alloc_command(bd);	639	bc = bsg_alloc_command(bd);
626	if (IS_ERR(bc)) {	640	if (IS_ERR(bc)) {
627	ret = PTR_ERR(bc);	641	ret = PTR_ERR(bc);
628	bc = NULL;	642	bc = NULL;
629	break;	643	break;
630	}	644	}
631		645
632	if (copy_from_user(&bc->hdr, buf, sizeof(bc->hdr))) {	646	if (copy_from_user(&bc->hdr, buf, sizeof(bc->hdr))) {
633	ret = -EFAULT;	647	ret = -EFAULT;
634	break;	648	break;
635	}	649	}
636		650
637	/*	651	/*
638	* get a request, fill in the blanks, and add to request queue	652	* get a request, fill in the blanks, and add to request queue
639	*/	653	*/
640	rq = bsg_map_hdr(bd, &bc->hdr);	654	rq = bsg_map_hdr(bd, &bc->hdr);
641	if (IS_ERR(rq)) {	655	if (IS_ERR(rq)) {
642	ret = PTR_ERR(rq);	656	ret = PTR_ERR(rq);
643	rq = NULL;	657	rq = NULL;
644	break;	658	break;
645	}	659	}
646		660
647	bsg_add_command(bd, q, bc, rq);	661	bsg_add_command(bd, q, bc, rq);
648	bc = NULL;	662	bc = NULL;
649	rq = NULL;	663	rq = NULL;
650	nr_commands--;	664	nr_commands--;
651	buf += sizeof(struct sg_io_v4);	665	buf += sizeof(struct sg_io_v4);
652	*bytes_written += sizeof(struct sg_io_v4);	666	*bytes_written += sizeof(struct sg_io_v4);
653	}	667	}
654		668
655	if (bc)	669	if (bc)
656	bsg_free_command(bc);	670	bsg_free_command(bc);
657		671
658	return ret;	672	return ret;
659	}	673	}
660		674
661	static ssize_t	675	static ssize_t
662	bsg_write(struct file file, const char __user buf, size_t count, loff_t *ppos)	676	bsg_write(struct file file, const char __user buf, size_t count, loff_t *ppos)
663	{	677	{
664	struct bsg_device *bd = file->private_data;	678	struct bsg_device *bd = file->private_data;
665	ssize_t bytes_written;	679	ssize_t bytes_written;
666	int ret;	680	int ret;
667		681
668	dprintk("%s: write %Zd bytes\n", bd->name, count);	682	dprintk("%s: write %Zd bytes\n", bd->name, count);
669		683
670	bsg_set_block(bd, file);	684	bsg_set_block(bd, file);
671	bsg_set_write_perm(bd, file);	685	bsg_set_cmd_filter(bd, file);
672		686
673	bytes_written = 0;	687	bytes_written = 0;
674	ret = __bsg_write(bd, buf, count, &bytes_written);	688	ret = __bsg_write(bd, buf, count, &bytes_written);
675	*ppos = bytes_written;	689	*ppos = bytes_written;
676		690
677	/*	691	/*
678	* return bytes written on non-fatal errors	692	* return bytes written on non-fatal errors
679	*/	693	*/
680	if (!bytes_written \|\| (bytes_written && err_block_err(ret)))	694	if (!bytes_written \|\| (bytes_written && err_block_err(ret)))
681	bytes_written = ret;	695	bytes_written = ret;
682		696
683	dprintk("%s: returning %Zd\n", bd->name, bytes_written);	697	dprintk("%s: returning %Zd\n", bd->name, bytes_written);
684	return bytes_written;	698	return bytes_written;
685	}	699	}
686		700
687	static struct bsg_device *bsg_alloc_device(void)	701	static struct bsg_device *bsg_alloc_device(void)
688	{	702	{
689	struct bsg_device *bd;	703	struct bsg_device *bd;
690		704
691	bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);	705	bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
692	if (unlikely(!bd))	706	if (unlikely(!bd))
693	return NULL;	707	return NULL;
694		708
695	spin_lock_init(&bd->lock);	709	spin_lock_init(&bd->lock);
696		710
697	bd->max_queue = BSG_DEFAULT_CMDS;	711	bd->max_queue = BSG_DEFAULT_CMDS;
698		712
699	INIT_LIST_HEAD(&bd->busy_list);	713	INIT_LIST_HEAD(&bd->busy_list);
700	INIT_LIST_HEAD(&bd->done_list);	714	INIT_LIST_HEAD(&bd->done_list);
701	INIT_HLIST_NODE(&bd->dev_list);	715	INIT_HLIST_NODE(&bd->dev_list);
702		716
703	init_waitqueue_head(&bd->wq_free);	717	init_waitqueue_head(&bd->wq_free);
704	init_waitqueue_head(&bd->wq_done);	718	init_waitqueue_head(&bd->wq_done);
705	return bd;	719	return bd;
706	}	720	}
707		721
708	static void bsg_kref_release_function(struct kref *kref)	722	static void bsg_kref_release_function(struct kref *kref)
709	{	723	{
710	struct bsg_class_device *bcd =	724	struct bsg_class_device *bcd =
711	container_of(kref, struct bsg_class_device, ref);	725	container_of(kref, struct bsg_class_device, ref);
712		726
713	if (bcd->release)	727	if (bcd->release)
714	bcd->release(bcd->parent);	728	bcd->release(bcd->parent);
715		729
716	put_device(bcd->parent);	730	put_device(bcd->parent);
717	}	731	}
718		732
719	static int bsg_put_device(struct bsg_device *bd)	733	static int bsg_put_device(struct bsg_device *bd)
720	{	734	{
721	int ret = 0, do_free;	735	int ret = 0, do_free;
722	struct request_queue *q = bd->queue;	736	struct request_queue *q = bd->queue;
723		737
724	mutex_lock(&bsg_mutex);	738	mutex_lock(&bsg_mutex);
725		739
726	do_free = atomic_dec_and_test(&bd->ref_count);	740	do_free = atomic_dec_and_test(&bd->ref_count);
727	if (!do_free)	741	if (!do_free)
728	goto out;	742	goto out;
729		743
730	dprintk("%s: tearing down\n", bd->name);	744	dprintk("%s: tearing down\n", bd->name);
731		745
732	/*	746	/*
733	* close can always block	747	* close can always block
734	*/	748	*/
735	set_bit(BSG_F_BLOCK, &bd->flags);	749	set_bit(BSG_F_BLOCK, &bd->flags);
736		750
737	/*	751	/*
738	* correct error detection baddies here again. it's the responsibility	752	* correct error detection baddies here again. it's the responsibility
739	* of the app to properly reap commands before close() if it wants	753	* of the app to properly reap commands before close() if it wants
740	* fool-proof error detection	754	* fool-proof error detection
741	*/	755	*/
742	ret = bsg_complete_all_commands(bd);	756	ret = bsg_complete_all_commands(bd);
743		757
744	hlist_del(&bd->dev_list);	758	hlist_del(&bd->dev_list);
745	kfree(bd);	759	kfree(bd);
746	out:	760	out:
747	mutex_unlock(&bsg_mutex);	761	mutex_unlock(&bsg_mutex);
748	kref_put(&q->bsg_dev.ref, bsg_kref_release_function);	762	kref_put(&q->bsg_dev.ref, bsg_kref_release_function);
749	if (do_free)	763	if (do_free)
750	blk_put_queue(q);	764	blk_put_queue(q);
751	return ret;	765	return ret;
752	}	766	}
753		767
754	static struct bsg_device bsg_add_device(struct inode inode,	768	static struct bsg_device bsg_add_device(struct inode inode,
755	struct request_queue *rq,	769	struct request_queue *rq,
756	struct file *file)	770	struct file *file)
757	{	771	{
758	struct bsg_device *bd;	772	struct bsg_device *bd;
759	int ret;	773	int ret;
760	#ifdef BSG_DEBUG	774	#ifdef BSG_DEBUG
761	unsigned char buf[32];	775	unsigned char buf[32];
762	#endif	776	#endif
763	ret = blk_get_queue(rq);	777	ret = blk_get_queue(rq);
764	if (ret)	778	if (ret)
765	return ERR_PTR(-ENXIO);	779	return ERR_PTR(-ENXIO);
766		780
767	bd = bsg_alloc_device();	781	bd = bsg_alloc_device();
768	if (!bd) {	782	if (!bd) {
769	blk_put_queue(rq);	783	blk_put_queue(rq);
770	return ERR_PTR(-ENOMEM);	784	return ERR_PTR(-ENOMEM);
771	}	785	}
772		786
773	bd->queue = rq;	787	bd->queue = rq;
		788
774	bsg_set_block(bd, file);	789	bsg_set_block(bd, file);
		790	bsg_set_cmd_filter(bd, file);
775		791
776	atomic_set(&bd->ref_count, 1);	792	atomic_set(&bd->ref_count, 1);
777	mutex_lock(&bsg_mutex);	793	mutex_lock(&bsg_mutex);
778	hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));	794	hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
779		795
780	strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);	796	strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);
781	dprintk("bound to <%s>, max queue %d\n",	797	dprintk("bound to <%s>, max queue %d\n",
782	format_dev_t(buf, inode->i_rdev), bd->max_queue);	798	format_dev_t(buf, inode->i_rdev), bd->max_queue);
783		799
784	mutex_unlock(&bsg_mutex);	800	mutex_unlock(&bsg_mutex);
785	return bd;	801	return bd;
786	}	802	}
787		803
788	static struct bsg_device __bsg_get_device(int minor, struct request_queue q)	804	static struct bsg_device __bsg_get_device(int minor, struct request_queue q)
789	{	805	{
790	struct bsg_device *bd;	806	struct bsg_device *bd;
791	struct hlist_node *entry;	807	struct hlist_node *entry;
792		808
793	mutex_lock(&bsg_mutex);	809	mutex_lock(&bsg_mutex);
794		810
795	hlist_for_each_entry(bd, entry, bsg_dev_idx_hash(minor), dev_list) {	811	hlist_for_each_entry(bd, entry, bsg_dev_idx_hash(minor), dev_list) {
796	if (bd->queue == q) {	812	if (bd->queue == q) {
797	atomic_inc(&bd->ref_count);	813	atomic_inc(&bd->ref_count);
798	goto found;	814	goto found;
799	}	815	}
800	}	816	}
801	bd = NULL;	817	bd = NULL;
802	found:	818	found:
803	mutex_unlock(&bsg_mutex);	819	mutex_unlock(&bsg_mutex);
804	return bd;	820	return bd;
805	}	821	}
806		822
807	static struct bsg_device bsg_get_device(struct inode inode, struct file *file)	823	static struct bsg_device bsg_get_device(struct inode inode, struct file *file)
808	{	824	{
809	struct bsg_device *bd;	825	struct bsg_device *bd;
810	struct bsg_class_device *bcd;	826	struct bsg_class_device *bcd;
811		827
812	/*	828	/*
813	* find the class device	829	* find the class device
814	*/	830	*/
815	mutex_lock(&bsg_mutex);	831	mutex_lock(&bsg_mutex);
816	bcd = idr_find(&bsg_minor_idr, iminor(inode));	832	bcd = idr_find(&bsg_minor_idr, iminor(inode));
817	if (bcd)	833	if (bcd)
818	kref_get(&bcd->ref);	834	kref_get(&bcd->ref);
819	mutex_unlock(&bsg_mutex);	835	mutex_unlock(&bsg_mutex);
820		836
821	if (!bcd)	837	if (!bcd)
822	return ERR_PTR(-ENODEV);	838	return ERR_PTR(-ENODEV);
823		839
824	bd = __bsg_get_device(iminor(inode), bcd->queue);	840	bd = __bsg_get_device(iminor(inode), bcd->queue);
825	if (bd)	841	if (bd)
826	return bd;	842	return bd;
827		843
828	bd = bsg_add_device(inode, bcd->queue, file);	844	bd = bsg_add_device(inode, bcd->queue, file);
829	if (IS_ERR(bd))	845	if (IS_ERR(bd))
830	kref_put(&bcd->ref, bsg_kref_release_function);	846	kref_put(&bcd->ref, bsg_kref_release_function);
831		847
832	return bd;	848	return bd;
833	}	849	}
834		850
835	static int bsg_open(struct inode inode, struct file file)	851	static int bsg_open(struct inode inode, struct file file)
836	{	852	{
837	struct bsg_device *bd = bsg_get_device(inode, file);	853	struct bsg_device *bd = bsg_get_device(inode, file);
838		854
839	if (IS_ERR(bd))	855	if (IS_ERR(bd))
840	return PTR_ERR(bd);	856	return PTR_ERR(bd);
841		857
842	file->private_data = bd;	858	file->private_data = bd;
843	return 0;	859	return 0;
844	}	860	}
845		861
846	static int bsg_release(struct inode inode, struct file file)	862	static int bsg_release(struct inode inode, struct file file)
847	{	863	{
848	struct bsg_device *bd = file->private_data;	864	struct bsg_device *bd = file->private_data;
849		865
850	file->private_data = NULL;	866	file->private_data = NULL;
851	return bsg_put_device(bd);	867	return bsg_put_device(bd);
852	}	868	}
853		869
854	static unsigned int bsg_poll(struct file file, poll_table wait)	870	static unsigned int bsg_poll(struct file file, poll_table wait)
855	{	871	{
856	struct bsg_device *bd = file->private_data;	872	struct bsg_device *bd = file->private_data;
857	unsigned int mask = 0;	873	unsigned int mask = 0;
858		874
859	poll_wait(file, &bd->wq_done, wait);	875	poll_wait(file, &bd->wq_done, wait);
860	poll_wait(file, &bd->wq_free, wait);	876	poll_wait(file, &bd->wq_free, wait);
861		877
862	spin_lock_irq(&bd->lock);	878	spin_lock_irq(&bd->lock);
863	if (!list_empty(&bd->done_list))	879	if (!list_empty(&bd->done_list))
864	mask \|= POLLIN \| POLLRDNORM;	880	mask \|= POLLIN \| POLLRDNORM;
865	if (bd->queued_cmds >= bd->max_queue)	881	if (bd->queued_cmds >= bd->max_queue)
866	mask \|= POLLOUT;	882	mask \|= POLLOUT;
867	spin_unlock_irq(&bd->lock);	883	spin_unlock_irq(&bd->lock);
868		884
869	return mask;	885	return mask;
870	}	886	}
871		887
872	static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)	888	static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
873	{	889	{
874	struct bsg_device *bd = file->private_data;	890	struct bsg_device *bd = file->private_data;
875	int __user uarg = (int __user ) arg;	891	int __user uarg = (int __user ) arg;
876	int ret;	892	int ret;
877		893
878	switch (cmd) {	894	switch (cmd) {
879	/*	895	/*
880	* our own ioctls	896	* our own ioctls
881	*/	897	*/
882	case SG_GET_COMMAND_Q:	898	case SG_GET_COMMAND_Q:
883	return put_user(bd->max_queue, uarg);	899	return put_user(bd->max_queue, uarg);
884	case SG_SET_COMMAND_Q: {	900	case SG_SET_COMMAND_Q: {
885	int queue;	901	int queue;
886		902
887	if (get_user(queue, uarg))	903	if (get_user(queue, uarg))
888	return -EFAULT;	904	return -EFAULT;
889	if (queue < 1)	905	if (queue < 1)
890	return -EINVAL;	906	return -EINVAL;
891		907
892	spin_lock_irq(&bd->lock);	908	spin_lock_irq(&bd->lock);
893	bd->max_queue = queue;	909	bd->max_queue = queue;
894	spin_unlock_irq(&bd->lock);	910	spin_unlock_irq(&bd->lock);
895	return 0;	911	return 0;
896	}	912	}
897		913
898	/*	914	/*
899	* SCSI/sg ioctls	915	* SCSI/sg ioctls
900	*/	916	*/
901	case SG_GET_VERSION_NUM:	917	case SG_GET_VERSION_NUM:
902	case SCSI_IOCTL_GET_IDLUN:	918	case SCSI_IOCTL_GET_IDLUN:
903	case SCSI_IOCTL_GET_BUS_NUMBER:	919	case SCSI_IOCTL_GET_BUS_NUMBER:
904	case SG_SET_TIMEOUT:	920	case SG_SET_TIMEOUT:
905	case SG_GET_TIMEOUT:	921	case SG_GET_TIMEOUT:
906	case SG_GET_RESERVED_SIZE:	922	case SG_GET_RESERVED_SIZE:
907	case SG_SET_RESERVED_SIZE:	923	case SG_SET_RESERVED_SIZE:
908	case SG_EMULATED_HOST:	924	case SG_EMULATED_HOST:
909	case SCSI_IOCTL_SEND_COMMAND: {	925	case SCSI_IOCTL_SEND_COMMAND: {
910	void __user uarg = (void __user ) arg;	926	void __user uarg = (void __user ) arg;
911	return scsi_cmd_ioctl(file, bd->queue, NULL, cmd, uarg);	927	return scsi_cmd_ioctl(file, bd->queue, NULL, cmd, uarg);
912	}	928	}
913	case SG_IO: {	929	case SG_IO: {
914	struct request *rq;	930	struct request *rq;
915	struct bio bio, bidi_bio = NULL;	931	struct bio bio, bidi_bio = NULL;
916	struct sg_io_v4 hdr;	932	struct sg_io_v4 hdr;
917		933
918	if (copy_from_user(&hdr, uarg, sizeof(hdr)))	934	if (copy_from_user(&hdr, uarg, sizeof(hdr)))
919	return -EFAULT;	935	return -EFAULT;
920		936
921	rq = bsg_map_hdr(bd, &hdr);	937	rq = bsg_map_hdr(bd, &hdr);
922	if (IS_ERR(rq))	938	if (IS_ERR(rq))
923	return PTR_ERR(rq);	939	return PTR_ERR(rq);
924		940
925	bio = rq->bio;	941	bio = rq->bio;
926	if (rq->next_rq)	942	if (rq->next_rq)
927	bidi_bio = rq->next_rq->bio;	943	bidi_bio = rq->next_rq->bio;
928	blk_execute_rq(bd->queue, NULL, rq, 0);	944	blk_execute_rq(bd->queue, NULL, rq, 0);
929	ret = blk_complete_sgv4_hdr_rq(rq, &hdr, bio, bidi_bio);	945	ret = blk_complete_sgv4_hdr_rq(rq, &hdr, bio, bidi_bio);
930		946
931	if (copy_to_user(uarg, &hdr, sizeof(hdr)))	947	if (copy_to_user(uarg, &hdr, sizeof(hdr)))
932	return -EFAULT;	948	return -EFAULT;
933		949
934	return ret;	950	return ret;
935	}	951	}
936	/*	952	/*
937	* block device ioctls	953	* block device ioctls
938	*/	954	*/
939	default:	955	default:
940	#if 0	956	#if 0
941	return ioctl_by_bdev(bd->bdev, cmd, arg);	957	return ioctl_by_bdev(bd->bdev, cmd, arg);
942	#else	958	#else
943	return -ENOTTY;	959	return -ENOTTY;
944	#endif	960	#endif
945	}	961	}
946	}	962	}
947		963
948	static const struct file_operations bsg_fops = {	964	static const struct file_operations bsg_fops = {
949	.read = bsg_read,	965	.read = bsg_read,
950	.write = bsg_write,	966	.write = bsg_write,
951	.poll = bsg_poll,	967	.poll = bsg_poll,
952	.open = bsg_open,	968	.open = bsg_open,
953	.release = bsg_release,	969	.release = bsg_release,
954	.unlocked_ioctl = bsg_ioctl,	970	.unlocked_ioctl = bsg_ioctl,
955	.owner = THIS_MODULE,	971	.owner = THIS_MODULE,
956	};	972	};
957		973
958	void bsg_unregister_queue(struct request_queue *q)	974	void bsg_unregister_queue(struct request_queue *q)
959	{	975	{
960	struct bsg_class_device *bcd = &q->bsg_dev;	976	struct bsg_class_device *bcd = &q->bsg_dev;
961		977
962	if (!bcd->class_dev)	978	if (!bcd->class_dev)
963	return;	979	return;
964		980
965	mutex_lock(&bsg_mutex);	981	mutex_lock(&bsg_mutex);
966	idr_remove(&bsg_minor_idr, bcd->minor);	982	idr_remove(&bsg_minor_idr, bcd->minor);
967	sysfs_remove_link(&q->kobj, "bsg");	983	sysfs_remove_link(&q->kobj, "bsg");
968	device_unregister(bcd->class_dev);	984	device_unregister(bcd->class_dev);
969	bcd->class_dev = NULL;	985	bcd->class_dev = NULL;
970	kref_put(&bcd->ref, bsg_kref_release_function);	986	kref_put(&bcd->ref, bsg_kref_release_function);
971	mutex_unlock(&bsg_mutex);	987	mutex_unlock(&bsg_mutex);
972	}	988	}
973	EXPORT_SYMBOL_GPL(bsg_unregister_queue);	989	EXPORT_SYMBOL_GPL(bsg_unregister_queue);
974		990
975	int bsg_register_queue(struct request_queue q, struct device parent,	991	int bsg_register_queue(struct request_queue q, struct device parent,
976	const char name, void (release)(struct device *))	992	const char name, void (release)(struct device *))
977	{	993	{
978	struct bsg_class_device *bcd;	994	struct bsg_class_device *bcd;
979	dev_t dev;	995	dev_t dev;
980	int ret, minor;	996	int ret, minor;
981	struct device *class_dev = NULL;	997	struct device *class_dev = NULL;
982	const char *devname;	998	const char *devname;
983		999
984	if (name)	1000	if (name)
985	devname = name;	1001	devname = name;
986	else	1002	else
987	devname = parent->bus_id;	1003	devname = parent->bus_id;
988		1004
989	/*	1005	/*
990	* we need a proper transport to send commands, not a stacked device	1006	* we need a proper transport to send commands, not a stacked device
991	*/	1007	*/
992	if (!q->request_fn)	1008	if (!q->request_fn)
993	return 0;	1009	return 0;
994		1010
995	bcd = &q->bsg_dev;	1011	bcd = &q->bsg_dev;
996	memset(bcd, 0, sizeof(*bcd));	1012	memset(bcd, 0, sizeof(*bcd));
997		1013
998	mutex_lock(&bsg_mutex);	1014	mutex_lock(&bsg_mutex);
999		1015
1000	ret = idr_pre_get(&bsg_minor_idr, GFP_KERNEL);	1016	ret = idr_pre_get(&bsg_minor_idr, GFP_KERNEL);
1001	if (!ret) {	1017	if (!ret) {
1002	ret = -ENOMEM;	1018	ret = -ENOMEM;
1003	goto unlock;	1019	goto unlock;
1004	}	1020	}
1005		1021
1006	ret = idr_get_new(&bsg_minor_idr, bcd, &minor);	1022	ret = idr_get_new(&bsg_minor_idr, bcd, &minor);
1007	if (ret < 0)	1023	if (ret < 0)
1008	goto unlock;	1024	goto unlock;
1009		1025
1010	if (minor >= BSG_MAX_DEVS) {	1026	if (minor >= BSG_MAX_DEVS) {
1011	printk(KERN_ERR "bsg: too many bsg devices\n");	1027	printk(KERN_ERR "bsg: too many bsg devices\n");
1012	ret = -EINVAL;	1028	ret = -EINVAL;
1013	goto remove_idr;	1029	goto remove_idr;
1014	}	1030	}
1015		1031
1016	bcd->minor = minor;	1032	bcd->minor = minor;
1017	bcd->queue = q;	1033	bcd->queue = q;
1018	bcd->parent = get_device(parent);	1034	bcd->parent = get_device(parent);
1019	bcd->release = release;	1035	bcd->release = release;
1020	kref_init(&bcd->ref);	1036	kref_init(&bcd->ref);
1021	dev = MKDEV(bsg_major, bcd->minor);	1037	dev = MKDEV(bsg_major, bcd->minor);
1022	class_dev = device_create(bsg_class, parent, dev, "%s", devname);	1038	class_dev = device_create(bsg_class, parent, dev, "%s", devname);
1023	if (IS_ERR(class_dev)) {	1039	if (IS_ERR(class_dev)) {
1024	ret = PTR_ERR(class_dev);	1040	ret = PTR_ERR(class_dev);
1025	goto put_dev;	1041	goto put_dev;
1026	}	1042	}
1027	bcd->class_dev = class_dev;	1043	bcd->class_dev = class_dev;
1028		1044
1029	if (q->kobj.sd) {	1045	if (q->kobj.sd) {
1030	ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");	1046	ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");
1031	if (ret)	1047	if (ret)
1032	goto unregister_class_dev;	1048	goto unregister_class_dev;
1033	}	1049	}
1034		1050
1035	mutex_unlock(&bsg_mutex);	1051	mutex_unlock(&bsg_mutex);
1036	return 0;	1052	return 0;
1037		1053
1038	unregister_class_dev:	1054	unregister_class_dev:
1039	device_unregister(class_dev);	1055	device_unregister(class_dev);
1040	put_dev:	1056	put_dev:
1041	put_device(parent);	1057	put_device(parent);
1042	remove_idr:	1058	remove_idr:
1043	idr_remove(&bsg_minor_idr, minor);	1059	idr_remove(&bsg_minor_idr, minor);
1044	unlock:	1060	unlock:
1045	mutex_unlock(&bsg_mutex);	1061	mutex_unlock(&bsg_mutex);
1046	return ret;	1062	return ret;
1047	}	1063	}
1048	EXPORT_SYMBOL_GPL(bsg_register_queue);	1064	EXPORT_SYMBOL_GPL(bsg_register_queue);
1049		1065
1050	static struct cdev bsg_cdev;	1066	static struct cdev bsg_cdev;
1051		1067
1052	static int __init bsg_init(void)	1068	static int __init bsg_init(void)
1053	{	1069	{
1054	int ret, i;	1070	int ret, i;
1055	dev_t devid;	1071	dev_t devid;
1056		1072
1057	bsg_cmd_cachep = kmem_cache_create("bsg_cmd",	1073	bsg_cmd_cachep = kmem_cache_create("bsg_cmd",
1058	sizeof(struct bsg_command), 0, 0, NULL);	1074	sizeof(struct bsg_command), 0, 0, NULL);
1059	if (!bsg_cmd_cachep) {	1075	if (!bsg_cmd_cachep) {
1060	printk(KERN_ERR "bsg: failed creating slab cache\n");	1076	printk(KERN_ERR "bsg: failed creating slab cache\n");
1061	return -ENOMEM;	1077	return -ENOMEM;
1062	}	1078	}
1063		1079
1064	for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)	1080	for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)
1065	INIT_HLIST_HEAD(&bsg_device_list[i]);	1081	INIT_HLIST_HEAD(&bsg_device_list[i]);
1066		1082
1067	bsg_class = class_create(THIS_MODULE, "bsg");	1083	bsg_class = class_create(THIS_MODULE, "bsg");
1068	if (IS_ERR(bsg_class)) {	1084	if (IS_ERR(bsg_class)) {
1069	ret = PTR_ERR(bsg_class);	1085	ret = PTR_ERR(bsg_class);
1070	goto destroy_kmemcache;	1086	goto destroy_kmemcache;
1071	}	1087	}
1072		1088
1073	ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");	1089	ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
1074	if (ret)	1090	if (ret)
1075	goto destroy_bsg_class;	1091	goto destroy_bsg_class;
1076		1092
1077	bsg_major = MAJOR(devid);	1093	bsg_major = MAJOR(devid);
1078		1094
1079	cdev_init(&bsg_cdev, &bsg_fops);	1095	cdev_init(&bsg_cdev, &bsg_fops);
1080	ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);	1096	ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1081	if (ret)	1097	if (ret)
1082	goto unregister_chrdev;	1098	goto unregister_chrdev;
1083		1099
1084	printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION	1100	printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
1085	" loaded (major %d)\n", bsg_major);	1101	" loaded (major %d)\n", bsg_major);
1086	return 0;	1102	return 0;
1087	unregister_chrdev:	1103	unregister_chrdev:
1088	unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);	1104	unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1089	destroy_bsg_class:	1105	destroy_bsg_class:
1090	class_destroy(bsg_class);	1106	class_destroy(bsg_class);
1091	destroy_kmemcache:	1107	destroy_kmemcache:
1092	kmem_cache_destroy(bsg_cmd_cachep);	1108	kmem_cache_destroy(bsg_cmd_cachep);
1093	return ret;	1109	return ret;
1094	}	1110	}
1095		1111
1096	MODULE_AUTHOR("Jens Axboe");	1112	MODULE_AUTHOR("Jens Axboe");
1097	MODULE_DESCRIPTION(BSG_DESCRIPTION);	1113	MODULE_DESCRIPTION(BSG_DESCRIPTION);
1098	MODULE_LICENSE("GPL");	1114	MODULE_LICENSE("GPL");
1099		1115

block/cmd-filter.c

Diff comments View file @ 0b07de8

File was created	1	/*
	2	* Copyright 2004 Peter M. Jones <pjones@redhat.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	*
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public Licens
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
	17	*
	18	*/
	19
	20	#include <linux/list.h>
	21	#include <linux/genhd.h>
	22	#include <linux/spinlock.h>
	23	#include <linux/parser.h>
	24	#include <linux/capability.h>
	25	#include <linux/bitops.h>
	26
	27	#include <scsi/scsi.h>
	28	#include <linux/cdrom.h>
	29
	30	int blk_cmd_filter_verify_command(struct blk_scsi_cmd_filter *filter,
	31	unsigned char cmd, mode_t f_mode)
	32	{
	33	/* root can do any command. */
	34	if (capable(CAP_SYS_RAWIO))
	35	return 0;
	36
	37	/* if there's no filter set, assume we're filtering everything out */
	38	if (!filter)
	39	return -EPERM;
	40
	41	/* Anybody who can open the device can do a read-safe command */
	42	if (test_bit(cmd[0], filter->read_ok))
	43	return 0;
	44
	45	/* Write-safe commands require a writable open */
	46	if (test_bit(cmd[0], filter->write_ok) && (*f_mode & FMODE_WRITE))
	47	return 0;
	48
	49	return -EPERM;
	50	}
	51	EXPORT_SYMBOL(blk_cmd_filter_verify_command);
	52
	53	int blk_verify_command(struct file file, unsigned char cmd)
	54	{
	55	struct gendisk *disk;
	56	struct inode *inode;
	57
	58	if (!file)
	59	return -EINVAL;
	60
	61	inode = file->f_dentry->d_inode;
	62	if (!inode)
	63	return -EINVAL;
	64
	65	disk = inode->i_bdev->bd_disk;
	66
	67	return blk_cmd_filter_verify_command(&disk->cmd_filter,
	68	cmd, &file->f_mode);
	69	}
	70	EXPORT_SYMBOL(blk_verify_command);
	71
	72	/* and now, the sysfs stuff */
	73	static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter filter, char page,
	74	int rw)
	75	{
	76	char *npage = page;
	77	unsigned long *okbits;
	78	int i;
	79
	80	if (rw == READ)
	81	okbits = filter->read_ok;
	82	else
	83	okbits = filter->write_ok;
	84
	85	for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
	86	if (test_bit(i, okbits)) {
	87	sprintf(npage, "%02x", i);
	88	npage += 2;
	89	if (i < BLK_SCSI_MAX_CMDS - 1)
	90	sprintf(npage++, " ");
	91	}
	92	}
	93
	94	if (npage != page)
	95	npage += sprintf(npage, "\n");
	96
	97	return npage - page;
	98	}
	99
	100	static ssize_t rcf_readcmds_show(struct blk_scsi_cmd_filter filter, char page)
	101	{
	102	return rcf_cmds_show(filter, page, READ);
	103	}
	104
	105	static ssize_t rcf_writecmds_show(struct blk_scsi_cmd_filter *filter,
	106	char *page)
	107	{
	108	return rcf_cmds_show(filter, page, WRITE);
	109	}
	110
	111	static ssize_t rcf_cmds_store(struct blk_scsi_cmd_filter *filter,
	112	const char *page, size_t count, int rw)
	113	{
	114	ssize_t ret = 0;
	115	unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
	116	int cmd, status, len;
	117	substring_t ss;
	118
	119	memset(&okbits, 0, sizeof(okbits));
	120
	121	for (len = strlen(page); len > 0; len -= 3) {
	122	if (len < 2)
	123	break;
	124	ss.from = (char *) page + ret;
	125	ss.to = (char *) page + ret + 2;
	126	ret += 3;
	127	status = match_hex(&ss, &cmd);
	128	/* either of these cases means invalid input, so do nothing. */
	129	if (status \|\| cmd >= BLK_SCSI_MAX_CMDS)
	130	return -EINVAL;
	131
	132	__set_bit(cmd, okbits);
	133	}
	134
	135	if (rw == READ)
	136	target_okbits = filter->read_ok;
	137	else
	138	target_okbits = filter->write_ok;
	139
	140	memmove(target_okbits, okbits, sizeof(okbits));
	141	return count;
	142	}
	143
	144	static ssize_t rcf_readcmds_store(struct blk_scsi_cmd_filter *filter,
	145	const char *page, size_t count)
	146	{
	147	return rcf_cmds_store(filter, page, count, READ);
	148	}
	149
	150	static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,
	151	const char *page, size_t count)
	152	{
	153	return rcf_cmds_store(filter, page, count, WRITE);
	154	}
	155
	156	struct rcf_sysfs_entry {
	157	struct attribute attr;
	158	ssize_t (show)(struct blk_scsi_cmd_filter , char *);
	159	ssize_t (store)(struct blk_scsi_cmd_filter , const char *, size_t);
	160	};
	161
	162	static struct rcf_sysfs_entry rcf_readcmds_entry = {
	163	.attr = { .name = "read_table", .mode = S_IRUGO \| S_IWUSR },
	164	.show = rcf_readcmds_show,
	165	.store = rcf_readcmds_store,
	166	};
	167
	168	static struct rcf_sysfs_entry rcf_writecmds_entry = {
	169	.attr = {.name = "write_table", .mode = S_IRUGO \| S_IWUSR },
	170	.show = rcf_writecmds_show,
	171	.store = rcf_writecmds_store,
	172	};
	173
	174	static struct attribute *default_attrs[] = {
	175	&rcf_readcmds_entry.attr,
	176	&rcf_writecmds_entry.attr,
	177	NULL,
	178	};
	179
	180	#define to_rcf(atr) container_of((atr), struct rcf_sysfs_entry, attr)
	181
	182	static ssize_t
	183	rcf_attr_show(struct kobject kobj, struct attribute attr, char *page)
	184	{
	185	struct rcf_sysfs_entry *entry = to_rcf(attr);
	186	struct blk_scsi_cmd_filter *filter;
	187
	188	filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
	189	if (entry->show)
	190	return entry->show(filter, page);
	191
	192	return 0;
	193	}
	194
	195	static ssize_t
	196	rcf_attr_store(struct kobject kobj, struct attribute attr,
	197	const char *page, size_t length)
	198	{
	199	struct rcf_sysfs_entry *entry = to_rcf(attr);
	200	struct blk_scsi_cmd_filter *filter;
	201
	202	if (!capable(CAP_SYS_RAWIO))
	203	return -EPERM;
	204
	205	if (!entry->store)
	206	return -EINVAL;
	207
	208	filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
	209	return entry->store(filter, page, length);
	210	}
	211
	212	static struct sysfs_ops rcf_sysfs_ops = {
	213	.show = rcf_attr_show,
	214	.store = rcf_attr_store,
	215	};
	216
	217	static struct kobj_type rcf_ktype = {
	218	.sysfs_ops = &rcf_sysfs_ops,
	219	.default_attrs = default_attrs,
	220	};
	221
	222	static void rcf_set_defaults(struct blk_scsi_cmd_filter *filter)
	223	{
	224	/* Basic read-only commands */
	225	__set_bit(TEST_UNIT_READY, filter->read_ok);
	226	__set_bit(REQUEST_SENSE, filter->read_ok);
	227	__set_bit(READ_6, filter->read_ok);
	228	__set_bit(READ_10, filter->read_ok);
	229	__set_bit(READ_12, filter->read_ok);
	230	__set_bit(READ_16, filter->read_ok);
	231	__set_bit(READ_BUFFER, filter->read_ok);
	232	__set_bit(READ_DEFECT_DATA, filter->read_ok);
	233	__set_bit(READ_LONG, filter->read_ok);
	234	__set_bit(INQUIRY, filter->read_ok);
	235	__set_bit(MODE_SENSE, filter->read_ok);
	236	__set_bit(MODE_SENSE_10, filter->read_ok);
	237	__set_bit(LOG_SENSE, filter->read_ok);
	238	__set_bit(START_STOP, filter->read_ok);
	239	__set_bit(GPCMD_VERIFY_10, filter->read_ok);
	240	__set_bit(VERIFY_16, filter->read_ok);
	241	__set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);
	242
	243	/* Audio CD commands */
	244	__set_bit(GPCMD_PLAY_CD, filter->read_ok);
	245	__set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
	246	__set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
	247	__set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
	248	__set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);
	249
	250	/* CD/DVD data reading */
	251	__set_bit(GPCMD_READ_CD, filter->read_ok);
	252	__set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
	253	__set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
	254	__set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
	255	__set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
	256	__set_bit(GPCMD_READ_HEADER, filter->read_ok);
	257	__set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
	258	__set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
	259	__set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
	260	__set_bit(GPCMD_REPORT_KEY, filter->read_ok);
	261	__set_bit(GPCMD_SCAN, filter->read_ok);
	262	__set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
	263	__set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
	264	__set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
	265	__set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
	266	__set_bit(GPCMD_SEEK, filter->read_ok);
	267	__set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);
	268
	269	/* Basic writing commands */
	270	__set_bit(WRITE_6, filter->write_ok);
	271	__set_bit(WRITE_10, filter->write_ok);
	272	__set_bit(WRITE_VERIFY, filter->write_ok);
	273	__set_bit(WRITE_12, filter->write_ok);
	274	__set_bit(WRITE_VERIFY_12, filter->write_ok);
	275	__set_bit(WRITE_16, filter->write_ok);
	276	__set_bit(WRITE_LONG, filter->write_ok);
	277	__set_bit(WRITE_LONG_2, filter->write_ok);
	278	__set_bit(ERASE, filter->write_ok);
	279	__set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
	280	__set_bit(MODE_SELECT, filter->write_ok);
	281	__set_bit(LOG_SELECT, filter->write_ok);
	282	__set_bit(GPCMD_BLANK, filter->write_ok);
	283	__set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
	284	__set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
	285	__set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
	286	__set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
	287	__set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
	288	__set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
	289	__set_bit(GPCMD_SEND_EVENT, filter->write_ok);
	290	__set_bit(GPCMD_SEND_KEY, filter->write_ok);
	291	__set_bit(GPCMD_SEND_OPC, filter->write_ok);
	292	__set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
	293	__set_bit(GPCMD_SET_SPEED, filter->write_ok);
	294	__set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
	295	__set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
	296	__set_bit(GPCMD_SET_STREAMING, filter->write_ok);
	297	}
	298
	299	int blk_register_filter(struct gendisk *disk)
	300	{
	301	int ret;
	302	struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;
	303	struct kobject *parent = kobject_get(disk->holder_dir->parent);
	304
	305	if (!parent)
	306	return -ENODEV;
	307
	308	ret = kobject_init_and_add(&filter->kobj, &rcf_ktype, parent,
	309	"%s", "cmd_filter");
	310
	311	if (ret < 0)
	312	return ret;
	313
	314	rcf_set_defaults(filter);
	315	return 0;
	316	}
	317
	318	void blk_unregister_filter(struct gendisk *disk)
	319	{
	320	struct blk_scsi_cmd_filter *filter = &disk->cmd_filter;
	321
	322	kobject_put(&filter->kobj);
	323	kobject_put(disk->holder_dir->parent);
	324	}
	325
	326

block/genhd.c

Diff comments View file @ 0b07de8

 /*
  *  gendisk handling
  */
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/genhd.h>
 #include <linux/kdev_t.h>
 #include <linux/kernel.h>
 #include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/kmod.h>
 #include <linux/kobj_map.h>
 #include <linux/buffer_head.h>
 #include <linux/mutex.h>
 #include "blk.h"
 static DEFINE_MUTEX(block_class_lock);
 #ifndef CONFIG_SYSFS_DEPRECATED
 struct kobject *block_depr;
 #endif
 static struct device_type disk_type;
 /*
  * Can be deleted altogether. Later.
  *
  */
 static struct blk_major_name {
 	struct blk_major_name *next;
 	int major;
 	char name[16];
 } *major_names[BLKDEV_MAJOR_HASH_SIZE];
 /* index in the above - for now: assume no multimajor ranges */
 static inline int major_to_index(int major)
 {
 	return major % BLKDEV_MAJOR_HASH_SIZE;
 }
 #ifdef CONFIG_PROC_FS
 void blkdev_show(struct seq_file *f, off_t offset)
 {
 	struct blk_major_name *dp;
 	if (offset < BLKDEV_MAJOR_HASH_SIZE) {
 		mutex_lock(&block_class_lock);
 		for (dp = major_names[offset]; dp; dp = dp->next)
 			seq_printf(f, "%3d %s\n", dp->major, dp->name);
 		mutex_unlock(&block_class_lock);
 	}
 }
 #endif /* CONFIG_PROC_FS */
 int register_blkdev(unsigned int major, const char *name)
 {
 	struct blk_major_name **n, *p;
 	int index, ret = 0;
 	mutex_lock(&block_class_lock);
 	/* temporary */
 	if (major == 0) {
 		for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
 			if (major_names[index] == NULL)
 				break;
 		}
 		if (index == 0) {
 			printk("register_blkdev: failed to get major for %s\n",
 			       name);
 			ret = -EBUSY;
 			goto out;
 		}
 		major = index;
 		ret = major;
 	}
 	p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
 	if (p == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	p->major = major;
 	strlcpy(p->name, name, sizeof(p->name));
 	p->next = NULL;
 	index = major_to_index(major);
 	for (n = &major_names[index]; *n; n = &(*n)->next) {
 		if ((*n)->major == major)
 			break;
 	}
 	if (!*n)
 		*n = p;
 	else
 		ret = -EBUSY;
 	if (ret < 0) {
 		printk("register_blkdev: cannot get major %d for %s\n",
 		       major, name);
 		kfree(p);
 	}
 out:
 	mutex_unlock(&block_class_lock);
 	return ret;
 }
 EXPORT_SYMBOL(register_blkdev);
 void unregister_blkdev(unsigned int major, const char *name)
 {
 	struct blk_major_name **n;
 	struct blk_major_name *p = NULL;
 	int index = major_to_index(major);
 	mutex_lock(&block_class_lock);
 	for (n = &major_names[index]; *n; n = &(*n)->next)
 		if ((*n)->major == major)
 			break;
 	if (!*n || strcmp((*n)->name, name)) {
 		WARN_ON(1);
 	} else {
 		p = *n;
 		*n = p->next;
 	}
 	mutex_unlock(&block_class_lock);
 	kfree(p);
 }
 EXPORT_SYMBOL(unregister_blkdev);
 static struct kobj_map *bdev_map;
 /*
  * Register device numbers dev..(dev+range-1)
  * range must be nonzero
  * The hash chain is sorted on range, so that subranges can override.
  */
 void blk_register_region(dev_t devt, unsigned long range, struct module *module,
 			 struct kobject *(*probe)(dev_t, int *, void *),
 			 int (*lock)(dev_t, void *), void *data)
 {
 	kobj_map(bdev_map, devt, range, module, probe, lock, data);
 }
 EXPORT_SYMBOL(blk_register_region);
 void blk_unregister_region(dev_t devt, unsigned long range)
 {
 	kobj_unmap(bdev_map, devt, range);
 }
 EXPORT_SYMBOL(blk_unregister_region);
 static struct kobject *exact_match(dev_t devt, int *part, void *data)
 {
 	struct gendisk *p = data;
 	return &p->dev.kobj;
 }
 static int exact_lock(dev_t devt, void *data)
 {
 	struct gendisk *p = data;
 	if (!get_disk(p))
 		return -1;
 	return 0;
 }
 /**
  * add_disk - add partitioning information to kernel list
  * @disk: per-device partitioning information
  *
  * This function registers the partitioning information in @disk
  * with the kernel.
  */
 void add_disk(struct gendisk *disk)
 {
 	struct backing_dev_info *bdi;
 	disk->flags |= GENHD_FL_UP;
 	blk_register_region(MKDEV(disk->major, disk->first_minor),
 			    disk->minors, NULL, exact_match, exact_lock, disk);
 	register_disk(disk);
 	blk_register_queue(disk);
+	blk_register_filter(disk);
 	bdi = &disk->queue->backing_dev_info;
 	bdi_register_dev(bdi, MKDEV(disk->major, disk->first_minor));
 	sysfs_create_link(&disk->dev.kobj, &bdi->dev->kobj, "bdi");
 }
 EXPORT_SYMBOL(add_disk);
 EXPORT_SYMBOL(del_gendisk);	/* in partitions/check.c */
 void unlink_gendisk(struct gendisk *disk)
 {
+	blk_unregister_filter(disk);
 	sysfs_remove_link(&disk->dev.kobj, "bdi");
 	bdi_unregister(&disk->queue->backing_dev_info);
 	blk_unregister_queue(disk);
 	blk_unregister_region(MKDEV(disk->major, disk->first_minor),
 			      disk->minors);
 }
 /**
  * get_gendisk - get partitioning information for a given device
  * @dev: device to get partitioning information for
  *
  * This function gets the structure containing partitioning
  * information for the given device @dev.
  */
 struct gendisk *get_gendisk(dev_t devt, int *part)
 {
 	struct kobject *kobj = kobj_lookup(bdev_map, devt, part);
 	struct device *dev = kobj_to_dev(kobj);
 	return  kobj ? dev_to_disk(dev) : NULL;
 }
 /*
  * print a full list of all partitions - intended for places where the root
  * filesystem can't be mounted and thus to give the victim some idea of what
  * went wrong
  */
 void __init printk_all_partitions(void)
 {
 	struct device *dev;
 	struct gendisk *sgp;
 	char buf[BDEVNAME_SIZE];
 	int n;
 	mutex_lock(&block_class_lock);
 	/* For each block device... */
 	list_for_each_entry(dev, &block_class.devices, node) {
 		if (dev->type != &disk_type)
 			continue;
 		sgp = dev_to_disk(dev);
 		/*
 		 * Don't show empty devices or things that have been surpressed
 		 */
 		if (get_capacity(sgp) == 0 ||
 		    (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
 			continue;
 		/*
 		 * Note, unlike /proc/partitions, I am showing the numbers in
 		 * hex - the same format as the root= option takes.
 		 */
 		printk("%02x%02x %10llu %s",
 			sgp->major, sgp->first_minor,
 			(unsigned long long)get_capacity(sgp) >> 1,
 			disk_name(sgp, 0, buf));
 		if (sgp->driverfs_dev != NULL &&
 		    sgp->driverfs_dev->driver != NULL)
 			printk(" driver: %s\n",
 				sgp->driverfs_dev->driver->name);
 		else
 			printk(" (driver?)\n");
 		/* now show the partitions */
 		for (n = 0; n < sgp->minors - 1; ++n) {
 			if (sgp->part[n] == NULL)
 				continue;
 			if (sgp->part[n]->nr_sects == 0)
 				continue;
 			printk("  %02x%02x %10llu %s\n",
 				sgp->major, n + 1 + sgp->first_minor,
 				(unsigned long long)sgp->part[n]->nr_sects >> 1,
 				disk_name(sgp, n + 1, buf));
 		}
 	}
 	mutex_unlock(&block_class_lock);
 }
 #ifdef CONFIG_PROC_FS
 /* iterator */
 static void *part_start(struct seq_file *part, loff_t *pos)
 {
 	loff_t k = *pos;
 	struct device *dev;
 	mutex_lock(&block_class_lock);
 	list_for_each_entry(dev, &block_class.devices, node) {
 		if (dev->type != &disk_type)
 			continue;
 		if (!k--)
 			return dev_to_disk(dev);
 	}
 	return NULL;
 }
 static void *part_next(struct seq_file *part, void *v, loff_t *pos)
 {
 	struct gendisk *gp = v;
 	struct device *dev;
 	++*pos;
 	list_for_each_entry(dev, &gp->dev.node, node) {
 		if (&dev->node == &block_class.devices)
 			return NULL;
 		if (dev->type == &disk_type)
 			return dev_to_disk(dev);
 	}
 	return NULL;
 }
 static void part_stop(struct seq_file *part, void *v)
 {
 	mutex_unlock(&block_class_lock);
 }
 static int show_partition(struct seq_file *part, void *v)
 {
 	struct gendisk *sgp = v;
 	int n;
 	char buf[BDEVNAME_SIZE];
 	if (&sgp->dev.node == block_class.devices.next)
 		seq_puts(part, "major minor  #blocks  name\n\n");
 	/* Don't show non-partitionable removeable devices or empty devices */
 	if (!get_capacity(sgp) ||
 			(sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE)))
 		return 0;
 	if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
 		return 0;
 	/* show the full disk and all non-0 size partitions of it */
 	seq_printf(part, "%4d  %4d %10llu %s\n",
 		sgp->major, sgp->first_minor,
 		(unsigned long long)get_capacity(sgp) >> 1,
 		disk_name(sgp, 0, buf));
 	for (n = 0; n < sgp->minors - 1; n++) {
 		if (!sgp->part[n])
 			continue;
 		if (sgp->part[n]->nr_sects == 0)
 			continue;
 		seq_printf(part, "%4d  %4d %10llu %s\n",
 			sgp->major, n + 1 + sgp->first_minor,
 			(unsigned long long)sgp->part[n]->nr_sects >> 1 ,
 			disk_name(sgp, n + 1, buf));
 	}
 	return 0;
 }
 const struct seq_operations partitions_op = {
 	.start	= part_start,
 	.next	= part_next,
 	.stop	= part_stop,
 	.show	= show_partition
 };
 #endif
 static struct kobject *base_probe(dev_t devt, int *part, void *data)
 {
 	if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
 		/* Make old-style 2.4 aliases work */
 		request_module("block-major-%d", MAJOR(devt));
 	return NULL;
 }
 static int __init genhd_device_init(void)
 {
 	int error = class_register(&block_class);
 	if (unlikely(error))
 		return error;
 	bdev_map = kobj_map_init(base_probe, &block_class_lock);
 	blk_dev_init();
 #ifndef CONFIG_SYSFS_DEPRECATED
 	/* create top-level block dir */
 	block_depr = kobject_create_and_add("block", NULL);
 #endif
 	return 0;
 }
 subsys_initcall(genhd_device_init);
 static ssize_t disk_range_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%d\n", disk->minors);
 }
 static ssize_t disk_removable_show(struct device *dev,
 				   struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%d\n",
 		       (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
 }
 static ssize_t disk_ro_show(struct device *dev,
 				   struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%d\n", disk->policy ? 1 : 0);
 }
 static ssize_t disk_size_show(struct device *dev,
 			      struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%llu\n", (unsigned long long)get_capacity(disk));
 }
 static ssize_t disk_capability_show(struct device *dev,
 				    struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%x\n", disk->flags);
 }
 static ssize_t disk_stat_show(struct device *dev,
 			      struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	preempt_disable();
 	disk_round_stats(disk);
 	preempt_enable();
 	return sprintf(buf,
 		"%8lu %8lu %8llu %8u "
 		"%8lu %8lu %8llu %8u "
 		"%8u %8u %8u"
 		"\n",
 		disk_stat_read(disk, ios[READ]),
 		disk_stat_read(disk, merges[READ]),
 		(unsigned long long)disk_stat_read(disk, sectors[READ]),
 		jiffies_to_msecs(disk_stat_read(disk, ticks[READ])),
 		disk_stat_read(disk, ios[WRITE]),
 		disk_stat_read(disk, merges[WRITE]),
 		(unsigned long long)disk_stat_read(disk, sectors[WRITE]),
 		jiffies_to_msecs(disk_stat_read(disk, ticks[WRITE])),
 		disk->in_flight,
 		jiffies_to_msecs(disk_stat_read(disk, io_ticks)),
 		jiffies_to_msecs(disk_stat_read(disk, time_in_queue)));
 }
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static ssize_t disk_fail_show(struct device *dev,
 			      struct device_attribute *attr, char *buf)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	return sprintf(buf, "%d\n", disk->flags & GENHD_FL_FAIL ? 1 : 0);
 }
 static ssize_t disk_fail_store(struct device *dev,
 			       struct device_attribute *attr,
 			       const char *buf, size_t count)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	int i;
 	if (count > 0 && sscanf(buf, "%d", &i) > 0) {
 		if (i == 0)
 			disk->flags &= ~GENHD_FL_FAIL;
 		else
 			disk->flags |= GENHD_FL_FAIL;
 	}
 	return count;
 }
 #endif
 static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
 static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
 static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
 static DEVICE_ATTR(size, S_IRUGO, disk_size_show, NULL);
 static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
 static DEVICE_ATTR(stat, S_IRUGO, disk_stat_show, NULL);
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static struct device_attribute dev_attr_fail =
 	__ATTR(make-it-fail, S_IRUGO|S_IWUSR, disk_fail_show, disk_fail_store);
 #endif
 static struct attribute *disk_attrs[] = {
 	&dev_attr_range.attr,
 	&dev_attr_removable.attr,
 	&dev_attr_ro.attr,
 	&dev_attr_size.attr,
 	&dev_attr_capability.attr,
 	&dev_attr_stat.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 	&dev_attr_fail.attr,
 #endif
 	NULL
 };
 static struct attribute_group disk_attr_group = {
 	.attrs = disk_attrs,
 };
 static struct attribute_group *disk_attr_groups[] = {
 	&disk_attr_group,
 	NULL
 };
 static void disk_release(struct device *dev)
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	kfree(disk->random);
 	kfree(disk->part);
 	free_disk_stats(disk);
 	kfree(disk);
 }
 struct class block_class = {
 	.name		= "block",
 };
 static struct device_type disk_type = {
 	.name		= "disk",
 	.groups		= disk_attr_groups,
 	.release	= disk_release,
 };
 /*
  * aggregate disk stat collector.  Uses the same stats that the sysfs
  * entries do, above, but makes them available through one seq_file.
  *
  * The output looks suspiciously like /proc/partitions with a bunch of
  * extra fields.
  */
 static void *diskstats_start(struct seq_file *part, loff_t *pos)
 {
 	loff_t k = *pos;
 	struct device *dev;
 	mutex_lock(&block_class_lock);
 	list_for_each_entry(dev, &block_class.devices, node) {
 		if (dev->type != &disk_type)
 			continue;
 		if (!k--)
 			return dev_to_disk(dev);
 	}
 	return NULL;
 }
 static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos)
 {
 	struct gendisk *gp = v;
 	struct device *dev;
 	++*pos;
 	list_for_each_entry(dev, &gp->dev.node, node) {
 		if (&dev->node == &block_class.devices)
 			return NULL;
 		if (dev->type == &disk_type)
 			return dev_to_disk(dev);
 	}
 	return NULL;
 }
 static void diskstats_stop(struct seq_file *part, void *v)
 {
 	mutex_unlock(&block_class_lock);
 }
 static int diskstats_show(struct seq_file *s, void *v)
 {
 	struct gendisk *gp = v;
 	char buf[BDEVNAME_SIZE];
 	int n = 0;
 	/*
 	if (&gp->dev.kobj.entry == block_class.devices.next)
 		seq_puts(s,	"major minor name"
 				"     rio rmerge rsect ruse wio wmerge "
 				"wsect wuse running use aveq"
 				"\n\n");
 	*/
 	preempt_disable();
 	disk_round_stats(gp);
 	preempt_enable();
 	seq_printf(s, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
 		gp->major, n + gp->first_minor, disk_name(gp, n, buf),
 		disk_stat_read(gp, ios[0]), disk_stat_read(gp, merges[0]),
 		(unsigned long long)disk_stat_read(gp, sectors[0]),
 		jiffies_to_msecs(disk_stat_read(gp, ticks[0])),
 		disk_stat_read(gp, ios[1]), disk_stat_read(gp, merges[1]),
 		(unsigned long long)disk_stat_read(gp, sectors[1]),
 		jiffies_to_msecs(disk_stat_read(gp, ticks[1])),
 		gp->in_flight,
 		jiffies_to_msecs(disk_stat_read(gp, io_ticks)),
 		jiffies_to_msecs(disk_stat_read(gp, time_in_queue)));
 	/* now show all non-0 size partitions of it */
 	for (n = 0; n < gp->minors - 1; n++) {
 		struct hd_struct *hd = gp->part[n];
 		if (!hd || !hd->nr_sects)
 			continue;
 		preempt_disable();
 		part_round_stats(hd);
 		preempt_enable();
 		seq_printf(s, "%4d %4d %s %lu %lu %llu "
 			   "%u %lu %lu %llu %u %u %u %u\n",
 			   gp->major, n + gp->first_minor + 1,
 			   disk_name(gp, n + 1, buf),
 			   part_stat_read(hd, ios[0]),
 			   part_stat_read(hd, merges[0]),
 			   (unsigned long long)part_stat_read(hd, sectors[0]),
 			   jiffies_to_msecs(part_stat_read(hd, ticks[0])),
 			   part_stat_read(hd, ios[1]),
 			   part_stat_read(hd, merges[1]),
 			   (unsigned long long)part_stat_read(hd, sectors[1]),
 			   jiffies_to_msecs(part_stat_read(hd, ticks[1])),
 			   hd->in_flight,
 			   jiffies_to_msecs(part_stat_read(hd, io_ticks)),
 			   jiffies_to_msecs(part_stat_read(hd, time_in_queue))
 			);
 	}
 	return 0;
 }
 const struct seq_operations diskstats_op = {
 	.start	= diskstats_start,
 	.next	= diskstats_next,
 	.stop	= diskstats_stop,
 	.show	= diskstats_show
 };
 static void media_change_notify_thread(struct work_struct *work)
 {
 	struct gendisk *gd = container_of(work, struct gendisk, async_notify);
 	char event[] = "MEDIA_CHANGE=1";
 	char *envp[] = { event, NULL };
 	/*
 	 * set enviroment vars to indicate which event this is for
 	 * so that user space will know to go check the media status.
 	 */
 	kobject_uevent_env(&gd->dev.kobj, KOBJ_CHANGE, envp);
 	put_device(gd->driverfs_dev);
 }
 #if 0
 void genhd_media_change_notify(struct gendisk *disk)
 {
 	get_device(disk->driverfs_dev);
 	schedule_work(&disk->async_notify);
 }
 EXPORT_SYMBOL_GPL(genhd_media_change_notify);
 #endif  /*  0  */
 dev_t blk_lookup_devt(const char *name, int part)
 {
 	struct device *dev;
 	dev_t devt = MKDEV(0, 0);
 	mutex_lock(&block_class_lock);
 	list_for_each_entry(dev, &block_class.devices, node) {
 		if (dev->type != &disk_type)
 			continue;
 		if (strcmp(dev->bus_id, name) == 0) {
 			struct gendisk *disk = dev_to_disk(dev);
 			if (part < disk->minors)
 				devt = MKDEV(MAJOR(dev->devt),
 					     MINOR(dev->devt) + part);
 			break;
 		}
 	}
 	mutex_unlock(&block_class_lock);
 	return devt;
 }
 EXPORT_SYMBOL(blk_lookup_devt);
 struct gendisk *alloc_disk(int minors)
 {
 	return alloc_disk_node(minors, -1);
 }
 struct gendisk *alloc_disk_node(int minors, int node_id)
 {
 	struct gendisk *disk;
 	disk = kmalloc_node(sizeof(struct gendisk),
 				GFP_KERNEL | __GFP_ZERO, node_id);
 	if (disk) {
 		if (!init_disk_stats(disk)) {
 			kfree(disk);
 			return NULL;
 		}
 		if (minors > 1) {
 			int size = (minors - 1) * sizeof(struct hd_struct *);
 			disk->part = kmalloc_node(size,
 				GFP_KERNEL | __GFP_ZERO, node_id);
 			if (!disk->part) {
 				free_disk_stats(disk);
 				kfree(disk);
 				return NULL;
 			}
 		}
 		disk->minors = minors;
 		rand_initialize_disk(disk);
 		disk->dev.class = &block_class;
 		disk->dev.type = &disk_type;
 		device_initialize(&disk->dev);
 		INIT_WORK(&disk->async_notify,
 			media_change_notify_thread);
 	}
 	return disk;
 }
 EXPORT_SYMBOL(alloc_disk);
 EXPORT_SYMBOL(alloc_disk_node);
 struct kobject *get_disk(struct gendisk *disk)
 {
 	struct module *owner;
 	struct kobject *kobj;
 	if (!disk->fops)
 		return NULL;
 	owner = disk->fops->owner;
 	if (owner && !try_module_get(owner))
 		return NULL;
 	kobj = kobject_get(&disk->dev.kobj);
 	if (kobj == NULL) {
 		module_put(owner);
 		return NULL;
 	}
 	return kobj;
 }
 EXPORT_SYMBOL(get_disk);
 void put_disk(struct gendisk *disk)
 {
 	if (disk)
 		kobject_put(&disk->dev.kobj);
 }
 EXPORT_SYMBOL(put_disk);
 void set_device_ro(struct block_device *bdev, int flag)
 {
 	if (bdev->bd_contains != bdev)
 		bdev->bd_part->policy = flag;
 	else
 		bdev->bd_disk->policy = flag;
 }
 EXPORT_SYMBOL(set_device_ro);
 void set_disk_ro(struct gendisk *disk, int flag)
 {
 	int i;
 	disk->policy = flag;
 	for (i = 0; i < disk->minors - 1; i++)
 		if (disk->part[i]) disk->part[i]->policy = flag;
 }
 EXPORT_SYMBOL(set_disk_ro);
 int bdev_read_only(struct block_device *bdev)
 {
 	if (!bdev)
 		return 0;
 	else if (bdev->bd_contains != bdev)
 		return bdev->bd_part->policy;
 	else
 		return bdev->bd_disk->policy;
 }
 EXPORT_SYMBOL(bdev_read_only);
 int invalidate_partition(struct gendisk *disk, int index)
 {
 	int res = 0;
 	struct block_device *bdev = bdget_disk(disk, index);
 	if (bdev) {
 		fsync_bdev(bdev);
 		res = __invalidate_device(bdev);
 		bdput(bdev);
 	}
 	return res;
 }
 EXPORT_SYMBOL(invalidate_partition);

block/scsi_ioctl.c

Diff comments View file @ 0b07de8

 /*
  * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public Licens
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
  *
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/module.h>
 #include <linux/blkdev.h>
 #include <linux/capability.h>
 #include <linux/completion.h>
 #include <linux/cdrom.h>
 #include <linux/slab.h>
 #include <linux/times.h>
 #include <asm/uaccess.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_ioctl.h>
 #include <scsi/scsi_cmnd.h>
 /* Command group 3 is reserved and should never be used.  */
 const unsigned char scsi_command_size_tbl[8] =
 {
 	6, 10, 10, 12,
 	16, 12, 10, 10
 };
 EXPORT_SYMBOL(scsi_command_size_tbl);
 #include <scsi/sg.h>
 static int sg_get_version(int __user *p)
 {
 	static const int sg_version_num = 30527;
 	return put_user(sg_version_num, p);
 }
 static int scsi_get_idlun(struct request_queue *q, int __user *p)
 {
 	return put_user(0, p);
 }
 static int scsi_get_bus(struct request_queue *q, int __user *p)
 {
 	return put_user(0, p);
 }
 static int sg_get_timeout(struct request_queue *q)
 {
 	return q->sg_timeout / (HZ / USER_HZ);
 }
 static int sg_set_timeout(struct request_queue *q, int __user *p)
 {
 	int timeout, err = get_user(timeout, p);
 	if (!err)
 		q->sg_timeout = timeout * (HZ / USER_HZ);
 	return err;
 }
 static int sg_get_reserved_size(struct request_queue *q, int __user *p)
 {
 	unsigned val = min(q->sg_reserved_size, q->max_sectors << 9);
 	return put_user(val, p);
 }
 static int sg_set_reserved_size(struct request_queue *q, int __user *p)
 {
 	int size, err = get_user(size, p);
 	if (err)
 		return err;
 	if (size < 0)
 		return -EINVAL;
 	if (size > (q->max_sectors << 9))
 		size = q->max_sectors << 9;
 	q->sg_reserved_size = size;
 	return 0;
 }
 /*
  * will always return that we are ATAPI even for a real SCSI drive, I'm not
  * so sure this is worth doing anything about (why would you care??)
  */
 static int sg_emulated_host(struct request_queue *q, int __user *p)
 {
 	return put_user(1, p);
 }
-#define CMD_READ_SAFE	0x01
-#define CMD_WRITE_SAFE	0x02
-#define CMD_WARNED	0x04
-#define safe_for_read(cmd)	[cmd] = CMD_READ_SAFE
-#define safe_for_write(cmd)	[cmd] = CMD_WRITE_SAFE
-int blk_verify_command(unsigned char *cmd, int has_write_perm)
-{
-	static unsigned char cmd_type[256] = {
-		/* Basic read-only commands */
-		safe_for_read(TEST_UNIT_READY),
-		safe_for_read(REQUEST_SENSE),
-		safe_for_read(READ_6),
-		safe_for_read(READ_10),
-		safe_for_read(READ_12),
-		safe_for_read(READ_16),
-		safe_for_read(READ_BUFFER),
-		safe_for_read(READ_DEFECT_DATA),
-		safe_for_read(READ_LONG),
-		safe_for_read(INQUIRY),
-		safe_for_read(MODE_SENSE),
-		safe_for_read(MODE_SENSE_10),
-		safe_for_read(LOG_SENSE),
-		safe_for_read(START_STOP),
-		safe_for_read(GPCMD_VERIFY_10),
-		safe_for_read(VERIFY_16),
-		/* Audio CD commands */
-		safe_for_read(GPCMD_PLAY_CD),
-		safe_for_read(GPCMD_PLAY_AUDIO_10),
-		safe_for_read(GPCMD_PLAY_AUDIO_MSF),
-		safe_for_read(GPCMD_PLAY_AUDIO_TI),
-		safe_for_read(GPCMD_PAUSE_RESUME),
-		/* CD/DVD data reading */
-		safe_for_read(GPCMD_READ_BUFFER_CAPACITY),
-		safe_for_read(GPCMD_READ_CD),
-		safe_for_read(GPCMD_READ_CD_MSF),
-		safe_for_read(GPCMD_READ_DISC_INFO),
-		safe_for_read(GPCMD_READ_CDVD_CAPACITY),
-		safe_for_read(GPCMD_READ_DVD_STRUCTURE),
-		safe_for_read(GPCMD_READ_HEADER),
-		safe_for_read(GPCMD_READ_TRACK_RZONE_INFO),
-		safe_for_read(GPCMD_READ_SUBCHANNEL),
-		safe_for_read(GPCMD_READ_TOC_PMA_ATIP),
-		safe_for_read(GPCMD_REPORT_KEY),
-		safe_for_read(GPCMD_SCAN),
-		safe_for_read(GPCMD_GET_CONFIGURATION),
-		safe_for_read(GPCMD_READ_FORMAT_CAPACITIES),
-		safe_for_read(GPCMD_GET_EVENT_STATUS_NOTIFICATION),
-		safe_for_read(GPCMD_GET_PERFORMANCE),
-		safe_for_read(GPCMD_SEEK),
-		safe_for_read(GPCMD_STOP_PLAY_SCAN),
-		/* Basic writing commands */
-		safe_for_write(WRITE_6),
-		safe_for_write(WRITE_10),
-		safe_for_write(WRITE_VERIFY),
-		safe_for_write(WRITE_12),
-		safe_for_write(WRITE_VERIFY_12),
-		safe_for_write(WRITE_16),
-		safe_for_write(WRITE_LONG),
-		safe_for_write(WRITE_LONG_2),
-		safe_for_write(ERASE),
-		safe_for_write(GPCMD_MODE_SELECT_10),
-		safe_for_write(MODE_SELECT),
-		safe_for_write(LOG_SELECT),
-		safe_for_write(GPCMD_BLANK),
-		safe_for_write(GPCMD_CLOSE_TRACK),
-		safe_for_write(GPCMD_FLUSH_CACHE),
-		safe_for_write(GPCMD_FORMAT_UNIT),
-		safe_for_write(GPCMD_REPAIR_RZONE_TRACK),
-		safe_for_write(GPCMD_RESERVE_RZONE_TRACK),
-		safe_for_write(GPCMD_SEND_DVD_STRUCTURE),
-		safe_for_write(GPCMD_SEND_EVENT),
-		safe_for_write(GPCMD_SEND_KEY),
-		safe_for_write(GPCMD_SEND_OPC),
-		safe_for_write(GPCMD_SEND_CUE_SHEET),
-		safe_for_write(GPCMD_SET_SPEED),
-		safe_for_write(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL),
-		safe_for_write(GPCMD_LOAD_UNLOAD),
-		safe_for_write(GPCMD_SET_STREAMING),
-	};
-	unsigned char type = cmd_type[cmd[0]];
-	/* Anybody who can open the device can do a read-safe command */
-	if (type & CMD_READ_SAFE)
-		return 0;
-	/* Write-safe commands just require a writable open.. */
-	if ((type & CMD_WRITE_SAFE) && has_write_perm)
-		return 0;
-	/* And root can do any command.. */
-	if (capable(CAP_SYS_RAWIO))
-		return 0;
-	if (!type) {
-		cmd_type[cmd[0]] = CMD_WARNED;
-		printk(KERN_WARNING "scsi: unknown opcode 0x%02x\n", cmd[0]);
-	}
-	/* Otherwise fail it with an "Operation not permitted" */
-	return -EPERM;
-}
-EXPORT_SYMBOL_GPL(blk_verify_command);
 static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
-			     struct sg_io_hdr *hdr, int has_write_perm)
+			     struct sg_io_hdr *hdr, struct file *file)
 {
 	if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
 		return -EFAULT;
-	if (blk_verify_command(rq->cmd, has_write_perm))
+	if (blk_verify_command(file, rq->cmd))
 		return -EPERM;
 	/*
 	 * fill in request structure
 	 */
 	rq->cmd_len = hdr->cmd_len;
 	rq->cmd_type = REQ_TYPE_BLOCK_PC;
 	rq->timeout = msecs_to_jiffies(hdr->timeout);
 	if (!rq->timeout)
 		rq->timeout = q->sg_timeout;
 	if (!rq->timeout)
 		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
 	return 0;
 }
 /*
  * unmap a request that was previously mapped to this sg_io_hdr. handles
  * both sg and non-sg sg_io_hdr.
  */
 static int blk_unmap_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr)
 {
 	blk_rq_unmap_user(rq->bio);
 	blk_put_request(rq);
 	return 0;
 }
 static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
 				 struct bio *bio)
 {
 	int r, ret = 0;
 	/*
 	 * fill in all the output members
 	 */
 	hdr->status = rq->errors & 0xff;
 	hdr->masked_status = status_byte(rq->errors);
 	hdr->msg_status = msg_byte(rq->errors);
 	hdr->host_status = host_byte(rq->errors);
 	hdr->driver_status = driver_byte(rq->errors);
 	hdr->info = 0;
 	if (hdr->masked_status || hdr->host_status || hdr->driver_status)
 		hdr->info |= SG_INFO_CHECK;
 	hdr->resid = rq->data_len;
 	hdr->sb_len_wr = 0;
 	if (rq->sense_len && hdr->sbp) {
 		int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);
 		if (!copy_to_user(hdr->sbp, rq->sense, len))
 			hdr->sb_len_wr = len;
 		else
 			ret = -EFAULT;
 	}
 	rq->bio = bio;
 	r = blk_unmap_sghdr_rq(rq, hdr);
 	if (ret)
 		r = ret;
 	return r;
 }
 static int sg_io(struct file *file, struct request_queue *q,
 		struct gendisk *bd_disk, struct sg_io_hdr *hdr)
 {
 	unsigned long start_time;
-	int writing = 0, ret = 0, has_write_perm = 0;
+	int writing = 0, ret = 0;
 	struct request *rq;
 	char sense[SCSI_SENSE_BUFFERSIZE];
 	struct bio *bio;
 	if (hdr->interface_id != 'S')
 		return -EINVAL;
 	if (hdr->cmd_len > BLK_MAX_CDB)
 		return -EINVAL;
 	if (hdr->dxfer_len > (q->max_hw_sectors << 9))
 		return -EIO;
 	if (hdr->dxfer_len)
 		switch (hdr->dxfer_direction) {
 		default:
 			return -EINVAL;
 		case SG_DXFER_TO_DEV:
 			writing = 1;
 			break;
 		case SG_DXFER_TO_FROM_DEV:
 		case SG_DXFER_FROM_DEV:
 			break;
 		}
 	rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
 	if (!rq)
 		return -ENOMEM;
-	if (file)
+	if (blk_fill_sghdr_rq(q, rq, hdr, file)) {
-		has_write_perm = file->f_mode & FMODE_WRITE;
-	if (blk_fill_sghdr_rq(q, rq, hdr, has_write_perm)) {
 		blk_put_request(rq);
 		return -EFAULT;
 	}
 	if (hdr->iovec_count) {
 		const int size = sizeof(struct sg_iovec) * hdr->iovec_count;
 		struct sg_iovec *iov;
 		iov = kmalloc(size, GFP_KERNEL);
 		if (!iov) {
 			ret = -ENOMEM;
 			goto out;
 		}
 		if (copy_from_user(iov, hdr->dxferp, size)) {
 			kfree(iov);
 			ret = -EFAULT;
 			goto out;
 		}
 		ret = blk_rq_map_user_iov(q, rq, iov, hdr->iovec_count,
 					  hdr->dxfer_len);
 		kfree(iov);
 	} else if (hdr->dxfer_len)
 		ret = blk_rq_map_user(q, rq, hdr->dxferp, hdr->dxfer_len);
 	if (ret)
 		goto out;
 	bio = rq->bio;
 	memset(sense, 0, sizeof(sense));
 	rq->sense = sense;
 	rq->sense_len = 0;
 	rq->retries = 0;
 	start_time = jiffies;
 	/* ignore return value. All information is passed back to caller
 	 * (if he doesn't check that is his problem).
 	 * N.B. a non-zero SCSI status is _not_ necessarily an error.
 	 */
 	blk_execute_rq(q, bd_disk, rq, 0);
 	hdr->duration = jiffies_to_msecs(jiffies - start_time);
 	return blk_complete_sghdr_rq(rq, hdr, bio);
 out:
 	blk_put_request(rq);
 	return ret;
 }
 /**
  * sg_scsi_ioctl  --  handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
  * @file:	file this ioctl operates on (optional)
  * @q:		request queue to send scsi commands down
  * @disk:	gendisk to operate on (option)
  * @sic:	userspace structure describing the command to perform
  *
  * Send down the scsi command described by @sic to the device below
  * the request queue @q.  If @file is non-NULL it's used to perform
  * fine-grained permission checks that allow users to send down
  * non-destructive SCSI commands.  If the caller has a struct gendisk
  * available it should be passed in as @disk to allow the low level
  * driver to use the information contained in it.  A non-NULL @disk
  * is only allowed if the caller knows that the low level driver doesn't
  * need it (e.g. in the scsi subsystem).
  *
  * Notes:
  *   -  This interface is deprecated - users should use the SG_IO
  *      interface instead, as this is a more flexible approach to
  *      performing SCSI commands on a device.
  *   -  The SCSI command length is determined by examining the 1st byte
  *      of the given command. There is no way to override this.
  *   -  Data transfers are limited to PAGE_SIZE
  *   -  The length (x + y) must be at least OMAX_SB_LEN bytes long to
  *      accommodate the sense buffer when an error occurs.
  *      The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
  *      old code will not be surprised.
  *   -  If a Unix error occurs (e.g. ENOMEM) then the user will receive
  *      a negative return and the Unix error code in 'errno'.
  *      If the SCSI command succeeds then 0 is returned.
  *      Positive numbers returned are the compacted SCSI error codes (4
  *      bytes in one int) where the lowest byte is the SCSI status.
  */
 #define OMAX_SB_LEN 16          /* For backward compatibility */
 int sg_scsi_ioctl(struct file *file, struct request_queue *q,
 		  struct gendisk *disk, struct scsi_ioctl_command __user *sic)
 {
 	struct request *rq;
 	int err;
 	unsigned int in_len, out_len, bytes, opcode, cmdlen;
 	char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
 	if (!sic)
 		return -EINVAL;
 	/*
 	 * get in an out lengths, verify they don't exceed a page worth of data
 	 */
 	if (get_user(in_len, &sic->inlen))
 		return -EFAULT;
 	if (get_user(out_len, &sic->outlen))
 		return -EFAULT;
 	if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
 		return -EINVAL;
 	if (get_user(opcode, sic->data))
 		return -EFAULT;
 	bytes = max(in_len, out_len);
 	if (bytes) {
 		buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
 		if (!buffer)
 			return -ENOMEM;
 	}
 	rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);
 	cmdlen = COMMAND_SIZE(opcode);
 	/*
 	 * get command and data to send to device, if any
 	 */
 	err = -EFAULT;
 	rq->cmd_len = cmdlen;
 	if (copy_from_user(rq->cmd, sic->data, cmdlen))
 		goto error;
 	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
 		goto error;
-	err = blk_verify_command(rq->cmd, file->f_mode & FMODE_WRITE);
+	err = blk_verify_command(file, rq->cmd);
 	if (err)
 		goto error;
 	/* default.  possible overriden later */
 	rq->retries = 5;
 	switch (opcode) {
 	case SEND_DIAGNOSTIC:
 	case FORMAT_UNIT:
 		rq->timeout = FORMAT_UNIT_TIMEOUT;
 		rq->retries = 1;
 		break;
 	case START_STOP:
 		rq->timeout = START_STOP_TIMEOUT;
 		break;
 	case MOVE_MEDIUM:
 		rq->timeout = MOVE_MEDIUM_TIMEOUT;
 		break;
 	case READ_ELEMENT_STATUS:
 		rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
 		break;
 	case READ_DEFECT_DATA:
 		rq->timeout = READ_DEFECT_DATA_TIMEOUT;
 		rq->retries = 1;
 		break;
 	default:
 		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
 		break;
 	}
 	if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
 		err = DRIVER_ERROR << 24;
 		goto out;
 	}
 	memset(sense, 0, sizeof(sense));
 	rq->sense = sense;
 	rq->sense_len = 0;
 	rq->cmd_type = REQ_TYPE_BLOCK_PC;
 	blk_execute_rq(q, disk, rq, 0);
 out:
 	err = rq->errors & 0xff;	/* only 8 bit SCSI status */
 	if (err) {
 		if (rq->sense_len && rq->sense) {
 			bytes = (OMAX_SB_LEN > rq->sense_len) ?
 				rq->sense_len : OMAX_SB_LEN;
 			if (copy_to_user(sic->data, rq->sense, bytes))
 				err = -EFAULT;
 		}
 	} else {
 		if (copy_to_user(sic->data, buffer, out_len))
 			err = -EFAULT;
 	}
 error:
 	kfree(buffer);
 	blk_put_request(rq);
 	return err;
 }
 EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
 /* Send basic block requests */
 static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
 			      int cmd, int data)
 {
 	struct request *rq;
 	int err;
 	rq = blk_get_request(q, WRITE, __GFP_WAIT);
 	rq->cmd_type = REQ_TYPE_BLOCK_PC;
 	rq->data = NULL;
 	rq->data_len = 0;
 	rq->extra_len = 0;
 	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
 	rq->cmd[0] = cmd;
 	rq->cmd[4] = data;
 	rq->cmd_len = 6;
 	err = blk_execute_rq(q, bd_disk, rq, 0);
 	blk_put_request(rq);
 	return err;
 }
 static inline int blk_send_start_stop(struct request_queue *q,
 				      struct gendisk *bd_disk, int data)
 {
 	return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
 }
 int scsi_cmd_ioctl(struct file *file, struct request_queue *q,
 		   struct gendisk *bd_disk, unsigned int cmd, void __user *arg)
 {
 	int err;
 	if (!q || blk_get_queue(q))
 		return -ENXIO;
 	switch (cmd) {
 		/*
 		 * new sgv3 interface
 		 */
 		case SG_GET_VERSION_NUM:
 			err = sg_get_version(arg);
 			break;
 		case SCSI_IOCTL_GET_IDLUN:
 			err = scsi_get_idlun(q, arg);
 			break;
 		case SCSI_IOCTL_GET_BUS_NUMBER:
 			err = scsi_get_bus(q, arg);
 			break;
 		case SG_SET_TIMEOUT:
 			err = sg_set_timeout(q, arg);
 			break;
 		case SG_GET_TIMEOUT:
 			err = sg_get_timeout(q);
 			break;
 		case SG_GET_RESERVED_SIZE:
 			err = sg_get_reserved_size(q, arg);
 			break;
 		case SG_SET_RESERVED_SIZE:
 			err = sg_set_reserved_size(q, arg);
 			break;
 		case SG_EMULATED_HOST:
 			err = sg_emulated_host(q, arg);
 			break;
 		case SG_IO: {
 			struct sg_io_hdr hdr;
 			err = -EFAULT;
 			if (copy_from_user(&hdr, arg, sizeof(hdr)))
 				break;
 			err = sg_io(file, q, bd_disk, &hdr);
 			if (err == -EFAULT)
 				break;
 			if (copy_to_user(arg, &hdr, sizeof(hdr)))
 				err = -EFAULT;
 			break;
 		}
 		case CDROM_SEND_PACKET: {
 			struct cdrom_generic_command cgc;
 			struct sg_io_hdr hdr;
 			err = -EFAULT;
 			if (copy_from_user(&cgc, arg, sizeof(cgc)))
 				break;
 			cgc.timeout = clock_t_to_jiffies(cgc.timeout);
 			memset(&hdr, 0, sizeof(hdr));
 			hdr.interface_id = 'S';
 			hdr.cmd_len = sizeof(cgc.cmd);
 			hdr.dxfer_len = cgc.buflen;
 			err = 0;
 			switch (cgc.data_direction) {
 				case CGC_DATA_UNKNOWN:
 					hdr.dxfer_direction = SG_DXFER_UNKNOWN;
 					break;
 				case CGC_DATA_WRITE:
 					hdr.dxfer_direction = SG_DXFER_TO_DEV;
 					break;
 				case CGC_DATA_READ:
 					hdr.dxfer_direction = SG_DXFER_FROM_DEV;
 					break;
 				case CGC_DATA_NONE:
 					hdr.dxfer_direction = SG_DXFER_NONE;
 					break;
 				default:
 					err = -EINVAL;
 			}
 			if (err)
 				break;
 			hdr.dxferp = cgc.buffer;
 			hdr.sbp = cgc.sense;
 			if (hdr.sbp)
 				hdr.mx_sb_len = sizeof(struct request_sense);
 			hdr.timeout = cgc.timeout;
 			hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
 			hdr.cmd_len = sizeof(cgc.cmd);
 			err = sg_io(file, q, bd_disk, &hdr);
 			if (err == -EFAULT)
 				break;
 			if (hdr.status)
 				err = -EIO;
 			cgc.stat = err;
 			cgc.buflen = hdr.resid;
 			if (copy_to_user(arg, &cgc, sizeof(cgc)))
 				err = -EFAULT;
 			break;
 		}
 		/*
 		 * old junk scsi send command ioctl
 		 */
 		case SCSI_IOCTL_SEND_COMMAND:
 			printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
 			err = -EINVAL;
 			if (!arg)
 				break;
 			err = sg_scsi_ioctl(file, q, bd_disk, arg);
 			break;
 		case CDROMCLOSETRAY:
 			err = blk_send_start_stop(q, bd_disk, 0x03);
 			break;
 		case CDROMEJECT:
 			err = blk_send_start_stop(q, bd_disk, 0x02);
 			break;
 		default:
 			err = -ENOTTY;
 	}
 	blk_put_queue(q);
 	return err;
 }
 EXPORT_SYMBOL(scsi_cmd_ioctl);

drivers/scsi/sg.c

Diff comments View file @ 0b07de8

 /*
  *  History:
  *  Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
  *           to allow user process control of SCSI devices.
  *  Development Sponsored by Killy Corp. NY NY
  *
  * Original driver (sg.c):
  *        Copyright (C) 1992 Lawrence Foard
  * Version 2 and 3 extensions to driver:
  *        Copyright (C) 1998 - 2005 Douglas Gilbert
  *
  *  Modified  19-JAN-1998  Richard Gooch <rgooch@atnf.csiro.au>  Devfs support
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2, or (at your option)
  * any later version.
  *
  */
 static int sg_version_num = 30534;	/* 2 digits for each component */
 #define SG_VERSION_STR "3.5.34"
 /*
  *  D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes:
  *      - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
  *        the kernel/module needs to be built with CONFIG_SCSI_LOGGING
  *        (otherwise the macros compile to empty statements).
  *
  */
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/mtio.h>
 #include <linux/ioctl.h>
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/moduleparam.h>
 #include <linux/cdev.h>
 #include <linux/idr.h>
 #include <linux/seq_file.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/scatterlist.h>
 #include <linux/blktrace_api.h>
 #include "scsi.h"
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_ioctl.h>
 #include <scsi/sg.h>
 #include "scsi_logging.h"
 #ifdef CONFIG_SCSI_PROC_FS
 #include <linux/proc_fs.h>
 static char *sg_version_date = "20061027";
 static int sg_proc_init(void);
 static void sg_proc_cleanup(void);
 #endif
 #define SG_ALLOW_DIO_DEF 0
 #define SG_ALLOW_DIO_CODE /* compile out by commenting this define */
 #define SG_MAX_DEVS 32768
 /*
  * Suppose you want to calculate the formula muldiv(x,m,d)=int(x * m / d)
  * Then when using 32 bit integers x * m may overflow during the calculation.
  * Replacing muldiv(x) by muldiv(x)=((x % d) * m) / d + int(x / d) * m
  * calculates the same, but prevents the overflow when both m and d
  * are "small" numbers (like HZ and USER_HZ).
  * Of course an overflow is inavoidable if the result of muldiv doesn't fit
  * in 32 bits.
  */
 #define MULDIV(X,MUL,DIV) ((((X % DIV) * MUL) / DIV) + ((X / DIV) * MUL))
 #define SG_DEFAULT_TIMEOUT MULDIV(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
 int sg_big_buff = SG_DEF_RESERVED_SIZE;
 /* N.B. This variable is readable and writeable via
    /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
    of this size (or less if there is not enough memory) will be reserved
    for use by this file descriptor. [Deprecated usage: this variable is also
    readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
    the kernel (i.e. it is not a module).] */
 static int def_reserved_size = -1;	/* picks up init parameter */
 static int sg_allow_dio = SG_ALLOW_DIO_DEF;
 static int scatter_elem_sz = SG_SCATTER_SZ;
 static int scatter_elem_sz_prev = SG_SCATTER_SZ;
 #define SG_SECTOR_SZ 512
 #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1)
 static int sg_add(struct device *, struct class_interface *);
 static void sg_remove(struct device *, struct class_interface *);
 static DEFINE_IDR(sg_index_idr);
 static DEFINE_RWLOCK(sg_index_lock);	/* Also used to lock
 							   file descriptor list for device */
 static struct class_interface sg_interface = {
 	.add_dev	= sg_add,
 	.remove_dev	= sg_remove,
 };
 typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
 	unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
 	unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
 	unsigned bufflen;	/* Size of (aggregate) data buffer */
 	unsigned b_malloc_len;	/* actual len malloc'ed in buffer */
 	struct scatterlist *buffer;/* scatter list */
 	char dio_in_use;	/* 0->indirect IO (or mmap), 1->dio */
 	unsigned char cmd_opcode; /* first byte of command */
 } Sg_scatter_hold;
 struct sg_device;		/* forward declarations */
 struct sg_fd;
 typedef struct sg_request {	/* SG_MAX_QUEUE requests outstanding per file */
 	struct sg_request *nextrp;	/* NULL -> tail request (slist) */
 	struct sg_fd *parentfp;	/* NULL -> not in use */
 	Sg_scatter_hold data;	/* hold buffer, perhaps scatter list */
 	sg_io_hdr_t header;	/* scsi command+info, see <scsi/sg.h> */
 	unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
 	char res_used;		/* 1 -> using reserve buffer, 0 -> not ... */
 	char orphan;		/* 1 -> drop on sight, 0 -> normal */
 	char sg_io_owned;	/* 1 -> packet belongs to SG_IO */
 	volatile char done;	/* 0->before bh, 1->before read, 2->read */
 } Sg_request;
 typedef struct sg_fd {		/* holds the state of a file descriptor */
 	struct sg_fd *nextfp;	/* NULL when last opened fd on this device */
 	struct sg_device *parentdp;	/* owning device */
 	wait_queue_head_t read_wait;	/* queue read until command done */
 	rwlock_t rq_list_lock;	/* protect access to list in req_arr */
 	int timeout;		/* defaults to SG_DEFAULT_TIMEOUT      */
 	int timeout_user;	/* defaults to SG_DEFAULT_TIMEOUT_USER */
 	Sg_scatter_hold reserve;	/* buffer held for this file descriptor */
 	unsigned save_scat_len;	/* original length of trunc. scat. element */
 	Sg_request *headrp;	/* head of request slist, NULL->empty */
 	struct fasync_struct *async_qp;	/* used by asynchronous notification */
 	Sg_request req_arr[SG_MAX_QUEUE];	/* used as singly-linked list */
 	char low_dma;		/* as in parent but possibly overridden to 1 */
 	char force_packid;	/* 1 -> pack_id input to read(), 0 -> ignored */
 	volatile char closed;	/* 1 -> fd closed but request(s) outstanding */
 	char cmd_q;		/* 1 -> allow command queuing, 0 -> don't */
 	char next_cmd_len;	/* 0 -> automatic (def), >0 -> use on next write() */
 	char keep_orphan;	/* 0 -> drop orphan (def), 1 -> keep for read() */
 	char mmap_called;	/* 0 -> mmap() never called on this fd */
 } Sg_fd;
 typedef struct sg_device { /* holds the state of each scsi generic device */
 	struct scsi_device *device;
 	wait_queue_head_t o_excl_wait;	/* queue open() when O_EXCL in use */
 	int sg_tablesize;	/* adapter's max scatter-gather table size */
 	u32 index;		/* device index number */
 	Sg_fd *headfp;		/* first open fd belonging to this device */
 	volatile char detached;	/* 0->attached, 1->detached pending removal */
 	volatile char exclude;	/* opened for exclusive access */
 	char sgdebug;		/* 0->off, 1->sense, 9->dump dev, 10-> all devs */
 	struct gendisk *disk;
 	struct cdev * cdev;	/* char_dev [sysfs: /sys/cdev/major/sg<n>] */
 } Sg_device;
 static int sg_fasync(int fd, struct file *filp, int mode);
 /* tasklet or soft irq callback */
 static void sg_cmd_done(void *data, char *sense, int result, int resid);
 static int sg_start_req(Sg_request * srp);
 static void sg_finish_rem_req(Sg_request * srp);
 static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
 static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp,
 			 int tablesize);
 static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count,
 			   Sg_request * srp);
-static ssize_t sg_new_write(Sg_fd * sfp, const char __user *buf, size_t count,
+static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
-			    int blocking, int read_only, Sg_request ** o_srp);
+			const char __user *buf, size_t count, int blocking,
+			int read_only, Sg_request **o_srp);
 static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
 			   unsigned char *cmnd, int timeout, int blocking);
 static int sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
 		      int wr_xf, int *countp, unsigned char __user **up);
 static int sg_write_xfer(Sg_request * srp);
 static int sg_read_xfer(Sg_request * srp);
 static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer);
 static void sg_remove_scat(Sg_scatter_hold * schp);
 static void sg_build_reserve(Sg_fd * sfp, int req_size);
 static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
 static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
 static struct page *sg_page_malloc(int rqSz, int lowDma, int *retSzp);
 static void sg_page_free(struct page *page, int size);
 static Sg_fd *sg_add_sfp(Sg_device * sdp, int dev);
 static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp);
 static void __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp);
 static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
 static Sg_request *sg_add_request(Sg_fd * sfp);
 static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
 static int sg_res_in_use(Sg_fd * sfp);
-static int sg_allow_access(unsigned char opcode, char dev_type);
 static int sg_build_direct(Sg_request * srp, Sg_fd * sfp, int dxfer_len);
 static Sg_device *sg_get_dev(int dev);
 #ifdef CONFIG_SCSI_PROC_FS
 static int sg_last_dev(void);
 #endif
 #define SZ_SG_HEADER sizeof(struct sg_header)
 #define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
 #define SZ_SG_IOVEC sizeof(sg_iovec_t)
 #define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
 static int
 sg_open(struct inode *inode, struct file *filp)
 {
 	int dev = iminor(inode);
 	int flags = filp->f_flags;
 	struct request_queue *q;
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	int res;
 	int retval;
 	nonseekable_open(inode, filp);
 	SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
 	sdp = sg_get_dev(dev);
 	if ((!sdp) || (!sdp->device))
 		return -ENXIO;
 	if (sdp->detached)
 		return -ENODEV;
 	/* This driver's module count bumped by fops_get in <linux/fs.h> */
 	/* Prevent the device driver from vanishing while we sleep */
 	retval = scsi_device_get(sdp->device);
 	if (retval)
 		return retval;
 	if (!((flags & O_NONBLOCK) ||
 	      scsi_block_when_processing_errors(sdp->device))) {
 		retval = -ENXIO;
 		/* we are in error recovery for this device */
 		goto error_out;
 	}
 	if (flags & O_EXCL) {
 		if (O_RDONLY == (flags & O_ACCMODE)) {
 			retval = -EPERM; /* Can't lock it with read only access */
 			goto error_out;
 		}
 		if (sdp->headfp && (flags & O_NONBLOCK)) {
 			retval = -EBUSY;
 			goto error_out;
 		}
 		res = 0;
 		__wait_event_interruptible(sdp->o_excl_wait,
 			((sdp->headfp || sdp->exclude) ? 0 : (sdp->exclude = 1)), res);
 		if (res) {
 			retval = res;	/* -ERESTARTSYS because signal hit process */
 			goto error_out;
 		}
 	} else if (sdp->exclude) {	/* some other fd has an exclusive lock on dev */
 		if (flags & O_NONBLOCK) {
 			retval = -EBUSY;
 			goto error_out;
 		}
 		res = 0;
 		__wait_event_interruptible(sdp->o_excl_wait, (!sdp->exclude),
 					   res);
 		if (res) {
 			retval = res;	/* -ERESTARTSYS because signal hit process */
 			goto error_out;
 		}
 	}
 	if (sdp->detached) {
 		retval = -ENODEV;
 		goto error_out;
 	}
 	if (!sdp->headfp) {	/* no existing opens on this device */
 		sdp->sgdebug = 0;
 		q = sdp->device->request_queue;
 		sdp->sg_tablesize = min(q->max_hw_segments,
 					q->max_phys_segments);
 	}
 	if ((sfp = sg_add_sfp(sdp, dev)))
 		filp->private_data = sfp;
 	else {
 		if (flags & O_EXCL)
 			sdp->exclude = 0;	/* undo if error */
 		retval = -ENOMEM;
 		goto error_out;
 	}
 	return 0;
       error_out:
 	scsi_device_put(sdp->device);
 	return retval;
 }
 /* Following function was formerly called 'sg_close' */
 static int
 sg_release(struct inode *inode, struct file *filp)
 {
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	SCSI_LOG_TIMEOUT(3, printk("sg_release: %s\n", sdp->disk->disk_name));
 	sg_fasync(-1, filp, 0);	/* remove filp from async notification list */
 	if (0 == sg_remove_sfp(sdp, sfp)) {	/* Returns 1 when sdp gone */
 		if (!sdp->detached) {
 			scsi_device_put(sdp->device);
 		}
 		sdp->exclude = 0;
 		wake_up_interruptible(&sdp->o_excl_wait);
 	}
 	return 0;
 }
 static ssize_t
 sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
 {
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	Sg_request *srp;
 	int req_pack_id = -1;
 	sg_io_hdr_t *hp;
 	struct sg_header *old_hdr = NULL;
 	int retval = 0;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	SCSI_LOG_TIMEOUT(3, printk("sg_read: %s, count=%d\n",
 				   sdp->disk->disk_name, (int) count));
 	if (!access_ok(VERIFY_WRITE, buf, count))
 		return -EFAULT;
 	if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
 		old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
 		if (!old_hdr)
 			return -ENOMEM;
 		if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
 			retval = -EFAULT;
 			goto free_old_hdr;
 		}
 		if (old_hdr->reply_len < 0) {
 			if (count >= SZ_SG_IO_HDR) {
 				sg_io_hdr_t *new_hdr;
 				new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
 				if (!new_hdr) {
 					retval = -ENOMEM;
 					goto free_old_hdr;
 				}
 				retval =__copy_from_user
 				    (new_hdr, buf, SZ_SG_IO_HDR);
 				req_pack_id = new_hdr->pack_id;
 				kfree(new_hdr);
 				if (retval) {
 					retval = -EFAULT;
 					goto free_old_hdr;
 				}
 			}
 		} else
 			req_pack_id = old_hdr->pack_id;
 	}
 	srp = sg_get_rq_mark(sfp, req_pack_id);
 	if (!srp) {		/* now wait on packet to arrive */
 		if (sdp->detached) {
 			retval = -ENODEV;
 			goto free_old_hdr;
 		}
 		if (filp->f_flags & O_NONBLOCK) {
 			retval = -EAGAIN;
 			goto free_old_hdr;
 		}
 		while (1) {
 			retval = 0; /* following macro beats race condition */
 			__wait_event_interruptible(sfp->read_wait,
 				(sdp->detached ||
 				(srp = sg_get_rq_mark(sfp, req_pack_id))),
 				retval);
 			if (sdp->detached) {
 				retval = -ENODEV;
 				goto free_old_hdr;
 			}
 			if (0 == retval)
 				break;
 			/* -ERESTARTSYS as signal hit process */
 			goto free_old_hdr;
 		}
 	}
 	if (srp->header.interface_id != '\0') {
 		retval = sg_new_read(sfp, buf, count, srp);
 		goto free_old_hdr;
 	}
 	hp = &srp->header;
 	if (old_hdr == NULL) {
 		old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
 		if (! old_hdr) {
 			retval = -ENOMEM;
 			goto free_old_hdr;
 		}
 	}
 	memset(old_hdr, 0, SZ_SG_HEADER);
 	old_hdr->reply_len = (int) hp->timeout;
 	old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
 	old_hdr->pack_id = hp->pack_id;
 	old_hdr->twelve_byte =
 	    ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
 	old_hdr->target_status = hp->masked_status;
 	old_hdr->host_status = hp->host_status;
 	old_hdr->driver_status = hp->driver_status;
 	if ((CHECK_CONDITION & hp->masked_status) ||
 	    (DRIVER_SENSE & hp->driver_status))
 		memcpy(old_hdr->sense_buffer, srp->sense_b,
 		       sizeof (old_hdr->sense_buffer));
 	switch (hp->host_status) {
 	/* This setup of 'result' is for backward compatibility and is best
 	   ignored by the user who should use target, host + driver status */
 	case DID_OK:
 	case DID_PASSTHROUGH:
 	case DID_SOFT_ERROR:
 		old_hdr->result = 0;
 		break;
 	case DID_NO_CONNECT:
 	case DID_BUS_BUSY:
 	case DID_TIME_OUT:
 		old_hdr->result = EBUSY;
 		break;
 	case DID_BAD_TARGET:
 	case DID_ABORT:
 	case DID_PARITY:
 	case DID_RESET:
 	case DID_BAD_INTR:
 		old_hdr->result = EIO;
 		break;
 	case DID_ERROR:
 		old_hdr->result = (srp->sense_b[0] == 0 &&
 				  hp->masked_status == GOOD) ? 0 : EIO;
 		break;
 	default:
 		old_hdr->result = EIO;
 		break;
 	}
 	/* Now copy the result back to the user buffer.  */
 	if (count >= SZ_SG_HEADER) {
 		if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
 			retval = -EFAULT;
 			goto free_old_hdr;
 		}
 		buf += SZ_SG_HEADER;
 		if (count > old_hdr->reply_len)
 			count = old_hdr->reply_len;
 		if (count > SZ_SG_HEADER) {
 			if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
 				retval = -EFAULT;
 				goto free_old_hdr;
 			}
 		}
 	} else
 		count = (old_hdr->result == 0) ? 0 : -EIO;
 	sg_finish_rem_req(srp);
 	retval = count;
 free_old_hdr:
 	kfree(old_hdr);
 	return retval;
 }
 static ssize_t
 sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
 {
 	sg_io_hdr_t *hp = &srp->header;
 	int err = 0;
 	int len;
 	if (count < SZ_SG_IO_HDR) {
 		err = -EINVAL;
 		goto err_out;
 	}
 	hp->sb_len_wr = 0;
 	if ((hp->mx_sb_len > 0) && hp->sbp) {
 		if ((CHECK_CONDITION & hp->masked_status) ||
 		    (DRIVER_SENSE & hp->driver_status)) {
 			int sb_len = SCSI_SENSE_BUFFERSIZE;
 			sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
 			len = 8 + (int) srp->sense_b[7];	/* Additional sense length field */
 			len = (len > sb_len) ? sb_len : len;
 			if (copy_to_user(hp->sbp, srp->sense_b, len)) {
 				err = -EFAULT;
 				goto err_out;
 			}
 			hp->sb_len_wr = len;
 		}
 	}
 	if (hp->masked_status || hp->host_status || hp->driver_status)
 		hp->info |= SG_INFO_CHECK;
 	if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
 		err = -EFAULT;
 		goto err_out;
 	}
 	err = sg_read_xfer(srp);
       err_out:
 	sg_finish_rem_req(srp);
 	return (0 == err) ? count : err;
 }
 static ssize_t
 sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
 {
 	int mxsize, cmd_size, k;
 	int input_size, blocking;
 	unsigned char opcode;
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	Sg_request *srp;
 	struct sg_header old_hdr;
 	sg_io_hdr_t *hp;
 	unsigned char cmnd[MAX_COMMAND_SIZE];
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	SCSI_LOG_TIMEOUT(3, printk("sg_write: %s, count=%d\n",
 				   sdp->disk->disk_name, (int) count));
 	if (sdp->detached)
 		return -ENODEV;
 	if (!((filp->f_flags & O_NONBLOCK) ||
 	      scsi_block_when_processing_errors(sdp->device)))
 		return -ENXIO;
 	if (!access_ok(VERIFY_READ, buf, count))
 		return -EFAULT;	/* protects following copy_from_user()s + get_user()s */
 	if (count < SZ_SG_HEADER)
 		return -EIO;
 	if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
 		return -EFAULT;
 	blocking = !(filp->f_flags & O_NONBLOCK);
 	if (old_hdr.reply_len < 0)
-		return sg_new_write(sfp, buf, count, blocking, 0, NULL);
+		return sg_new_write(sfp, filp, buf, count, blocking, 0, NULL);
 	if (count < (SZ_SG_HEADER + 6))
 		return -EIO;	/* The minimum scsi command length is 6 bytes. */
 	if (!(srp = sg_add_request(sfp))) {
 		SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n"));
 		return -EDOM;
 	}
 	buf += SZ_SG_HEADER;
 	__get_user(opcode, buf);
 	if (sfp->next_cmd_len > 0) {
 		if (sfp->next_cmd_len > MAX_COMMAND_SIZE) {
 			SCSI_LOG_TIMEOUT(1, printk("sg_write: command length too long\n"));
 			sfp->next_cmd_len = 0;
 			sg_remove_request(sfp, srp);
 			return -EIO;
 		}
 		cmd_size = sfp->next_cmd_len;
 		sfp->next_cmd_len = 0;	/* reset so only this write() effected */
 	} else {
 		cmd_size = COMMAND_SIZE(opcode);	/* based on SCSI command group */
 		if ((opcode >= 0xc0) && old_hdr.twelve_byte)
 			cmd_size = 12;
 	}
 	SCSI_LOG_TIMEOUT(4, printk(
 		"sg_write:   scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
 /* Determine buffer size.  */
 	input_size = count - cmd_size;
 	mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
 	mxsize -= SZ_SG_HEADER;
 	input_size -= SZ_SG_HEADER;
 	if (input_size < 0) {
 		sg_remove_request(sfp, srp);
 		return -EIO;	/* User did not pass enough bytes for this command. */
 	}
 	hp = &srp->header;
 	hp->interface_id = '\0';	/* indicator of old interface tunnelled */
 	hp->cmd_len = (unsigned char) cmd_size;
 	hp->iovec_count = 0;
 	hp->mx_sb_len = 0;
 	if (input_size > 0)
 		hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
 		    SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
 	else
 		hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE;
 	hp->dxfer_len = mxsize;
 	hp->dxferp = (char __user *)buf + cmd_size;
 	hp->sbp = NULL;
 	hp->timeout = old_hdr.reply_len;	/* structure abuse ... */
 	hp->flags = input_size;	/* structure abuse ... */
 	hp->pack_id = old_hdr.pack_id;
 	hp->usr_ptr = NULL;
 	if (__copy_from_user(cmnd, buf, cmd_size))
 		return -EFAULT;
 	/*
 	 * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
 	 * but is is possible that the app intended SG_DXFER_TO_DEV, because there
 	 * is a non-zero input_size, so emit a warning.
 	 */
 	if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
 		static char cmd[TASK_COMM_LEN];
 		if (strcmp(current->comm, cmd) && printk_ratelimit()) {
 			printk(KERN_WARNING
 			       "sg_write: data in/out %d/%d bytes for SCSI command 0x%x--"
 			       "guessing data in;\n" KERN_WARNING "   "
 			       "program %s not setting count and/or reply_len properly\n",
 			       old_hdr.reply_len - (int)SZ_SG_HEADER,
 			       input_size, (unsigned int) cmnd[0],
 			       current->comm);
 			strcpy(cmd, current->comm);
 		}
 	}
 	k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
 	return (k < 0) ? k : count;
 }
 static ssize_t
-sg_new_write(Sg_fd * sfp, const char __user *buf, size_t count,
+sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
-	     int blocking, int read_only, Sg_request ** o_srp)
+		 size_t count, int blocking, int read_only,
+		 Sg_request **o_srp)
 {
 	int k;
 	Sg_request *srp;
 	sg_io_hdr_t *hp;
 	unsigned char cmnd[MAX_COMMAND_SIZE];
 	int timeout;
 	unsigned long ul_timeout;
 	if (count < SZ_SG_IO_HDR)
 		return -EINVAL;
 	if (!access_ok(VERIFY_READ, buf, count))
 		return -EFAULT; /* protects following copy_from_user()s + get_user()s */
 	sfp->cmd_q = 1;	/* when sg_io_hdr seen, set command queuing on */
 	if (!(srp = sg_add_request(sfp))) {
 		SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n"));
 		return -EDOM;
 	}
 	hp = &srp->header;
 	if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
 		sg_remove_request(sfp, srp);
 		return -EFAULT;
 	}
 	if (hp->interface_id != 'S') {
 		sg_remove_request(sfp, srp);
 		return -ENOSYS;
 	}
 	if (hp->flags & SG_FLAG_MMAP_IO) {
 		if (hp->dxfer_len > sfp->reserve.bufflen) {
 			sg_remove_request(sfp, srp);
 			return -ENOMEM;	/* MMAP_IO size must fit in reserve buffer */
 		}
 		if (hp->flags & SG_FLAG_DIRECT_IO) {
 			sg_remove_request(sfp, srp);
 			return -EINVAL;	/* either MMAP_IO or DIRECT_IO (not both) */
 		}
 		if (sg_res_in_use(sfp)) {
 			sg_remove_request(sfp, srp);
 			return -EBUSY;	/* reserve buffer already being used */
 		}
 	}
 	ul_timeout = msecs_to_jiffies(srp->header.timeout);
 	timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX;
 	if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) {
 		sg_remove_request(sfp, srp);
 		return -EMSGSIZE;
 	}
 	if (!access_ok(VERIFY_READ, hp->cmdp, hp->cmd_len)) {
 		sg_remove_request(sfp, srp);
 		return -EFAULT;	/* protects following copy_from_user()s + get_user()s */
 	}
 	if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
 		sg_remove_request(sfp, srp);
 		return -EFAULT;
 	}
-	if (read_only &&
+	if (read_only && (!blk_verify_command(file, cmnd))) {
-	    (!sg_allow_access(cmnd[0], sfp->parentdp->device->type))) {
 		sg_remove_request(sfp, srp);
 		return -EPERM;
 	}
 	k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
 	if (k < 0)
 		return k;
 	if (o_srp)
 		*o_srp = srp;
 	return count;
 }
 static int
 sg_common_write(Sg_fd * sfp, Sg_request * srp,
 		unsigned char *cmnd, int timeout, int blocking)
 {
 	int k, data_dir;
 	Sg_device *sdp = sfp->parentdp;
 	sg_io_hdr_t *hp = &srp->header;
 	srp->data.cmd_opcode = cmnd[0];	/* hold opcode of command */
 	hp->status = 0;
 	hp->masked_status = 0;
 	hp->msg_status = 0;
 	hp->info = 0;
 	hp->host_status = 0;
 	hp->driver_status = 0;
 	hp->resid = 0;
 	SCSI_LOG_TIMEOUT(4, printk("sg_common_write:  scsi opcode=0x%02x, cmd_size=%d\n",
 			  (int) cmnd[0], (int) hp->cmd_len));
 	if ((k = sg_start_req(srp))) {
 		SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k));
 		sg_finish_rem_req(srp);
 		return k;	/* probably out of space --> ENOMEM */
 	}
 	if ((k = sg_write_xfer(srp))) {
 		SCSI_LOG_TIMEOUT(1, printk("sg_common_write: write_xfer, bad address\n"));
 		sg_finish_rem_req(srp);
 		return k;
 	}
 	if (sdp->detached) {
 		sg_finish_rem_req(srp);
 		return -ENODEV;
 	}
 	switch (hp->dxfer_direction) {
 	case SG_DXFER_TO_FROM_DEV:
 	case SG_DXFER_FROM_DEV:
 		data_dir = DMA_FROM_DEVICE;
 		break;
 	case SG_DXFER_TO_DEV:
 		data_dir = DMA_TO_DEVICE;
 		break;
 	case SG_DXFER_UNKNOWN:
 		data_dir = DMA_BIDIRECTIONAL;
 		break;
 	default:
 		data_dir = DMA_NONE;
 		break;
 	}
 	hp->duration = jiffies_to_msecs(jiffies);
 /* Now send everything of to mid-level. The next time we hear about this
    packet is when sg_cmd_done() is called (i.e. a callback). */
 	if (scsi_execute_async(sdp->device, cmnd, hp->cmd_len, data_dir, srp->data.buffer,
 				hp->dxfer_len, srp->data.k_use_sg, timeout,
 				SG_DEFAULT_RETRIES, srp, sg_cmd_done,
 				GFP_ATOMIC)) {
 		SCSI_LOG_TIMEOUT(1, printk("sg_common_write: scsi_execute_async failed\n"));
 		/*
 		 * most likely out of mem, but could also be a bad map
 		 */
 		sg_finish_rem_req(srp);
 		return -ENOMEM;
 	} else
 		return 0;
 }
 static int
 sg_srp_done(Sg_request *srp, Sg_fd *sfp)
 {
 	unsigned long iflags;
 	int done;
 	read_lock_irqsave(&sfp->rq_list_lock, iflags);
 	done = srp->done;
 	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return done;
 }
 static int
 sg_ioctl(struct inode *inode, struct file *filp,
 	 unsigned int cmd_in, unsigned long arg)
 {
 	void __user *p = (void __user *)arg;
 	int __user *ip = p;
 	int result, val, read_only;
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	Sg_request *srp;
 	unsigned long iflags;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: %s, cmd=0x%x\n",
 				   sdp->disk->disk_name, (int) cmd_in));
 	read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
 	switch (cmd_in) {
 	case SG_IO:
 		{
 			int blocking = 1;	/* ignore O_NONBLOCK flag */
 			if (sdp->detached)
 				return -ENODEV;
 			if (!scsi_block_when_processing_errors(sdp->device))
 				return -ENXIO;
 			if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
 				return -EFAULT;
 			result =
-			    sg_new_write(sfp, p, SZ_SG_IO_HDR,
+			    sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
 					 blocking, read_only, &srp);
 			if (result < 0)
 				return result;
 			srp->sg_io_owned = 1;
 			while (1) {
 				result = 0;	/* following macro to beat race condition */
 				__wait_event_interruptible(sfp->read_wait,
 					(sdp->detached || sfp->closed || sg_srp_done(srp, sfp)),
 							   result);
 				if (sdp->detached)
 					return -ENODEV;
 				if (sfp->closed)
 					return 0;	/* request packet dropped already */
 				if (0 == result)
 					break;
 				srp->orphan = 1;
 				return result;	/* -ERESTARTSYS because signal hit process */
 			}
 			write_lock_irqsave(&sfp->rq_list_lock, iflags);
 			srp->done = 2;
 			write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 			result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
 			return (result < 0) ? result : 0;
 		}
 	case SG_SET_TIMEOUT:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		if (val < 0)
 			return -EIO;
 		if (val >= MULDIV (INT_MAX, USER_HZ, HZ))
 		    val = MULDIV (INT_MAX, USER_HZ, HZ);
 		sfp->timeout_user = val;
 		sfp->timeout = MULDIV (val, HZ, USER_HZ);
 		return 0;
 	case SG_GET_TIMEOUT:	/* N.B. User receives timeout as return value */
 				/* strange ..., for backward compatibility */
 		return sfp->timeout_user;
 	case SG_SET_FORCE_LOW_DMA:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		if (val) {
 			sfp->low_dma = 1;
 			if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
 				val = (int) sfp->reserve.bufflen;
 				sg_remove_scat(&sfp->reserve);
 				sg_build_reserve(sfp, val);
 			}
 		} else {
 			if (sdp->detached)
 				return -ENODEV;
 			sfp->low_dma = sdp->device->host->unchecked_isa_dma;
 		}
 		return 0;
 	case SG_GET_LOW_DMA:
 		return put_user((int) sfp->low_dma, ip);
 	case SG_GET_SCSI_ID:
 		if (!access_ok(VERIFY_WRITE, p, sizeof (sg_scsi_id_t)))
 			return -EFAULT;
 		else {
 			sg_scsi_id_t __user *sg_idp = p;
 			if (sdp->detached)
 				return -ENODEV;
 			__put_user((int) sdp->device->host->host_no,
 				   &sg_idp->host_no);
 			__put_user((int) sdp->device->channel,
 				   &sg_idp->channel);
 			__put_user((int) sdp->device->id, &sg_idp->scsi_id);
 			__put_user((int) sdp->device->lun, &sg_idp->lun);
 			__put_user((int) sdp->device->type, &sg_idp->scsi_type);
 			__put_user((short) sdp->device->host->cmd_per_lun,
 				   &sg_idp->h_cmd_per_lun);
 			__put_user((short) sdp->device->queue_depth,
 				   &sg_idp->d_queue_depth);
 			__put_user(0, &sg_idp->unused[0]);
 			__put_user(0, &sg_idp->unused[1]);
 			return 0;
 		}
 	case SG_SET_FORCE_PACK_ID:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		sfp->force_packid = val ? 1 : 0;
 		return 0;
 	case SG_GET_PACK_ID:
 		if (!access_ok(VERIFY_WRITE, ip, sizeof (int)))
 			return -EFAULT;
 		read_lock_irqsave(&sfp->rq_list_lock, iflags);
 		for (srp = sfp->headrp; srp; srp = srp->nextrp) {
 			if ((1 == srp->done) && (!srp->sg_io_owned)) {
 				read_unlock_irqrestore(&sfp->rq_list_lock,
 						       iflags);
 				__put_user(srp->header.pack_id, ip);
 				return 0;
 			}
 		}
 		read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 		__put_user(-1, ip);
 		return 0;
 	case SG_GET_NUM_WAITING:
 		read_lock_irqsave(&sfp->rq_list_lock, iflags);
 		for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
 			if ((1 == srp->done) && (!srp->sg_io_owned))
 				++val;
 		}
 		read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 		return put_user(val, ip);
 	case SG_GET_SG_TABLESIZE:
 		return put_user(sdp->sg_tablesize, ip);
 	case SG_SET_RESERVED_SIZE:
 		result = get_user(val, ip);
 		if (result)
 			return result;
                 if (val < 0)
                         return -EINVAL;
 		val = min_t(int, val,
 				sdp->device->request_queue->max_sectors * 512);
 		if (val != sfp->reserve.bufflen) {
 			if (sg_res_in_use(sfp) || sfp->mmap_called)
 				return -EBUSY;
 			sg_remove_scat(&sfp->reserve);
 			sg_build_reserve(sfp, val);
 		}
 		return 0;
 	case SG_GET_RESERVED_SIZE:
 		val = min_t(int, sfp->reserve.bufflen,
 				sdp->device->request_queue->max_sectors * 512);
 		return put_user(val, ip);
 	case SG_SET_COMMAND_Q:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		sfp->cmd_q = val ? 1 : 0;
 		return 0;
 	case SG_GET_COMMAND_Q:
 		return put_user((int) sfp->cmd_q, ip);
 	case SG_SET_KEEP_ORPHAN:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		sfp->keep_orphan = val;
 		return 0;
 	case SG_GET_KEEP_ORPHAN:
 		return put_user((int) sfp->keep_orphan, ip);
 	case SG_NEXT_CMD_LEN:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		sfp->next_cmd_len = (val > 0) ? val : 0;
 		return 0;
 	case SG_GET_VERSION_NUM:
 		return put_user(sg_version_num, ip);
 	case SG_GET_ACCESS_COUNT:
 		/* faked - we don't have a real access count anymore */
 		val = (sdp->device ? 1 : 0);
 		return put_user(val, ip);
 	case SG_GET_REQUEST_TABLE:
 		if (!access_ok(VERIFY_WRITE, p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
 			return -EFAULT;
 		else {
 			sg_req_info_t *rinfo;
 			unsigned int ms;
 			rinfo = kmalloc(SZ_SG_REQ_INFO * SG_MAX_QUEUE,
 								GFP_KERNEL);
 			if (!rinfo)
 				return -ENOMEM;
 			read_lock_irqsave(&sfp->rq_list_lock, iflags);
 			for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
 			     ++val, srp = srp ? srp->nextrp : srp) {
 				memset(&rinfo[val], 0, SZ_SG_REQ_INFO);
 				if (srp) {
 					rinfo[val].req_state = srp->done + 1;
 					rinfo[val].problem =
 					    srp->header.masked_status &
 					    srp->header.host_status &
 					    srp->header.driver_status;
 					if (srp->done)
 						rinfo[val].duration =
 							srp->header.duration;
 					else {
 						ms = jiffies_to_msecs(jiffies);
 						rinfo[val].duration =
 						    (ms > srp->header.duration) ?
 						    (ms - srp->header.duration) : 0;
 					}
 					rinfo[val].orphan = srp->orphan;
 					rinfo[val].sg_io_owned =
 							srp->sg_io_owned;
 					rinfo[val].pack_id =
 							srp->header.pack_id;
 					rinfo[val].usr_ptr =
 							srp->header.usr_ptr;
 				}
 			}
 			read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 			result = __copy_to_user(p, rinfo,
 						SZ_SG_REQ_INFO * SG_MAX_QUEUE);
 			result = result ? -EFAULT : 0;
 			kfree(rinfo);
 			return result;
 		}
 	case SG_EMULATED_HOST:
 		if (sdp->detached)
 			return -ENODEV;
 		return put_user(sdp->device->host->hostt->emulated, ip);
 	case SG_SCSI_RESET:
 		if (sdp->detached)
 			return -ENODEV;
 		if (filp->f_flags & O_NONBLOCK) {
 			if (scsi_host_in_recovery(sdp->device->host))
 				return -EBUSY;
 		} else if (!scsi_block_when_processing_errors(sdp->device))
 			return -EBUSY;
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		if (SG_SCSI_RESET_NOTHING == val)
 			return 0;
 		switch (val) {
 		case SG_SCSI_RESET_DEVICE:
 			val = SCSI_TRY_RESET_DEVICE;
 			break;
 		case SG_SCSI_RESET_BUS:
 			val = SCSI_TRY_RESET_BUS;
 			break;
 		case SG_SCSI_RESET_HOST:
 			val = SCSI_TRY_RESET_HOST;
 			break;
 		default:
 			return -EINVAL;
 		}
 		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 			return -EACCES;
 		return (scsi_reset_provider(sdp->device, val) ==
 			SUCCESS) ? 0 : -EIO;
 	case SCSI_IOCTL_SEND_COMMAND:
 		if (sdp->detached)
 			return -ENODEV;
 		if (read_only) {
 			unsigned char opcode = WRITE_6;
 			Scsi_Ioctl_Command __user *siocp = p;
 			if (copy_from_user(&opcode, siocp->data, 1))
 				return -EFAULT;
-			if (!sg_allow_access(opcode, sdp->device->type))
+			if (!blk_verify_command(filp, &opcode))
 				return -EPERM;
 		}
 		return sg_scsi_ioctl(filp, sdp->device->request_queue, NULL, p);
 	case SG_SET_DEBUG:
 		result = get_user(val, ip);
 		if (result)
 			return result;
 		sdp->sgdebug = (char) val;
 		return 0;
 	case SCSI_IOCTL_GET_IDLUN:
 	case SCSI_IOCTL_GET_BUS_NUMBER:
 	case SCSI_IOCTL_PROBE_HOST:
 	case SG_GET_TRANSFORM:
 		if (sdp->detached)
 			return -ENODEV;
 		return scsi_ioctl(sdp->device, cmd_in, p);
 	case BLKSECTGET:
 		return put_user(sdp->device->request_queue->max_sectors * 512,
 				ip);
 	case BLKTRACESETUP:
 		return blk_trace_setup(sdp->device->request_queue,
 				       sdp->disk->disk_name,
 				       sdp->device->sdev_gendev.devt,
 				       (char *)arg);
 	case BLKTRACESTART:
 		return blk_trace_startstop(sdp->device->request_queue, 1);
 	case BLKTRACESTOP:
 		return blk_trace_startstop(sdp->device->request_queue, 0);
 	case BLKTRACETEARDOWN:
 		return blk_trace_remove(sdp->device->request_queue);
 	default:
 		if (read_only)
 			return -EPERM;	/* don't know so take safe approach */
 		return scsi_ioctl(sdp->device, cmd_in, p);
 	}
 }
 #ifdef CONFIG_COMPAT
 static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
 {
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	struct scsi_device *sdev;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	sdev = sdp->device;
 	if (sdev->host->hostt->compat_ioctl) {
 		int ret;
 		ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
 		return ret;
 	}
 	return -ENOIOCTLCMD;
 }
 #endif
 static unsigned int
 sg_poll(struct file *filp, poll_table * wait)
 {
 	unsigned int res = 0;
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	Sg_request *srp;
 	int count = 0;
 	unsigned long iflags;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))
 	    || sfp->closed)
 		return POLLERR;
 	poll_wait(filp, &sfp->read_wait, wait);
 	read_lock_irqsave(&sfp->rq_list_lock, iflags);
 	for (srp = sfp->headrp; srp; srp = srp->nextrp) {
 		/* if any read waiting, flag it */
 		if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
 			res = POLLIN | POLLRDNORM;
 		++count;
 	}
 	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	if (sdp->detached)
 		res |= POLLHUP;
 	else if (!sfp->cmd_q) {
 		if (0 == count)
 			res |= POLLOUT | POLLWRNORM;
 	} else if (count < SG_MAX_QUEUE)
 		res |= POLLOUT | POLLWRNORM;
 	SCSI_LOG_TIMEOUT(3, printk("sg_poll: %s, res=0x%x\n",
 				   sdp->disk->disk_name, (int) res));
 	return res;
 }
 static int
 sg_fasync(int fd, struct file *filp, int mode)
 {
 	int retval;
 	Sg_device *sdp;
 	Sg_fd *sfp;
 	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
 		return -ENXIO;
 	SCSI_LOG_TIMEOUT(3, printk("sg_fasync: %s, mode=%d\n",
 				   sdp->disk->disk_name, mode));
 	retval = fasync_helper(fd, filp, mode, &sfp->async_qp);
 	return (retval < 0) ? retval : 0;
 }
 static int
 sg_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
 	Sg_fd *sfp;
 	unsigned long offset, len, sa;
 	Sg_scatter_hold *rsv_schp;
 	struct scatterlist *sg;
 	int k;
 	if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
 		return VM_FAULT_SIGBUS;
 	rsv_schp = &sfp->reserve;
 	offset = vmf->pgoff << PAGE_SHIFT;
 	if (offset >= rsv_schp->bufflen)
 		return VM_FAULT_SIGBUS;
 	SCSI_LOG_TIMEOUT(3, printk("sg_vma_fault: offset=%lu, scatg=%d\n",
 				   offset, rsv_schp->k_use_sg));
 	sg = rsv_schp->buffer;
 	sa = vma->vm_start;
 	for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end);
 	     ++k, sg = sg_next(sg)) {
 		len = vma->vm_end - sa;
 		len = (len < sg->length) ? len : sg->length;
 		if (offset < len) {
 			struct page *page;
 			page = virt_to_page(page_address(sg_page(sg)) + offset);
 			get_page(page);	/* increment page count */
 			vmf->page = page;
 			return 0; /* success */
 		}
 		sa += len;
 		offset -= len;
 	}
 	return VM_FAULT_SIGBUS;
 }
 static struct vm_operations_struct sg_mmap_vm_ops = {
 	.fault = sg_vma_fault,
 };
 static int
 sg_mmap(struct file *filp, struct vm_area_struct *vma)
 {
 	Sg_fd *sfp;
 	unsigned long req_sz, len, sa;
 	Sg_scatter_hold *rsv_schp;
 	int k;
 	struct scatterlist *sg;
 	if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
 		return -ENXIO;
 	req_sz = vma->vm_end - vma->vm_start;
 	SCSI_LOG_TIMEOUT(3, printk("sg_mmap starting, vm_start=%p, len=%d\n",
 				   (void *) vma->vm_start, (int) req_sz));
 	if (vma->vm_pgoff)
 		return -EINVAL;	/* want no offset */
 	rsv_schp = &sfp->reserve;
 	if (req_sz > rsv_schp->bufflen)
 		return -ENOMEM;	/* cannot map more than reserved buffer */
 	sa = vma->vm_start;
 	sg = rsv_schp->buffer;
 	for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end);
 	     ++k, sg = sg_next(sg)) {
 		len = vma->vm_end - sa;
 		len = (len < sg->length) ? len : sg->length;
 		sa += len;
 	}
 	sfp->mmap_called = 1;
 	vma->vm_flags |= VM_RESERVED;
 	vma->vm_private_data = sfp;
 	vma->vm_ops = &sg_mmap_vm_ops;
 	return 0;
 }
 /* This function is a "bottom half" handler that is called by the
  * mid level when a command is completed (or has failed). */
 static void
 sg_cmd_done(void *data, char *sense, int result, int resid)
 {
 	Sg_request *srp = data;
 	Sg_device *sdp = NULL;
 	Sg_fd *sfp;
 	unsigned long iflags;
 	unsigned int ms;
 	if (NULL == srp) {
 		printk(KERN_ERR "sg_cmd_done: NULL request\n");
 		return;
 	}
 	sfp = srp->parentfp;
 	if (sfp)
 		sdp = sfp->parentdp;
 	if ((NULL == sdp) || sdp->detached) {
 		printk(KERN_INFO "sg_cmd_done: device detached\n");
 		return;
 	}
 	SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
 		sdp->disk->disk_name, srp->header.pack_id, result));
 	srp->header.resid = resid;
 	ms = jiffies_to_msecs(jiffies);
 	srp->header.duration = (ms > srp->header.duration) ?
 				(ms - srp->header.duration) : 0;
 	if (0 != result) {
 		struct scsi_sense_hdr sshdr;
 		memcpy(srp->sense_b, sense, sizeof (srp->sense_b));
 		srp->header.status = 0xff & result;
 		srp->header.masked_status = status_byte(result);
 		srp->header.msg_status = msg_byte(result);
 		srp->header.host_status = host_byte(result);
 		srp->header.driver_status = driver_byte(result);
 		if ((sdp->sgdebug > 0) &&
 		    ((CHECK_CONDITION == srp->header.masked_status) ||
 		     (COMMAND_TERMINATED == srp->header.masked_status)))
 			__scsi_print_sense("sg_cmd_done", sense,
 					   SCSI_SENSE_BUFFERSIZE);
 		/* Following if statement is a patch supplied by Eric Youngdale */
 		if (driver_byte(result) != 0
 		    && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
 		    && !scsi_sense_is_deferred(&sshdr)
 		    && sshdr.sense_key == UNIT_ATTENTION
 		    && sdp->device->removable) {
 			/* Detected possible disc change. Set the bit - this */
 			/* may be used if there are filesystems using this device */
 			sdp->device->changed = 1;
 		}
 	}
 	/* Rely on write phase to clean out srp status values, so no "else" */
 	if (sfp->closed) {	/* whoops this fd already released, cleanup */
 		SCSI_LOG_TIMEOUT(1, printk("sg_cmd_done: already closed, freeing ...\n"));
 		sg_finish_rem_req(srp);
 		srp = NULL;
 		if (NULL == sfp->headrp) {
 			SCSI_LOG_TIMEOUT(1, printk("sg_cmd_done: already closed, final cleanup\n"));
 			if (0 == sg_remove_sfp(sdp, sfp)) {	/* device still present */
 				scsi_device_put(sdp->device);
 			}
 			sfp = NULL;
 		}
 	} else if (srp && srp->orphan) {
 		if (sfp->keep_orphan)
 			srp->sg_io_owned = 0;
 		else {
 			sg_finish_rem_req(srp);
 			srp = NULL;
 		}
 	}
 	if (sfp && srp) {
 		/* Now wake up any sg_read() that is waiting for this packet. */
 		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
 		write_lock_irqsave(&sfp->rq_list_lock, iflags);
 		srp->done = 1;
 		wake_up_interruptible(&sfp->read_wait);
 		write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	}
 }
 static struct file_operations sg_fops = {
 	.owner = THIS_MODULE,
 	.read = sg_read,
 	.write = sg_write,
 	.poll = sg_poll,
 	.ioctl = sg_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = sg_compat_ioctl,
 #endif
 	.open = sg_open,
 	.mmap = sg_mmap,
 	.release = sg_release,
 	.fasync = sg_fasync,
 };
 static struct class *sg_sysfs_class;
 static int sg_sysfs_valid = 0;
 static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
 {
 	struct request_queue *q = scsidp->request_queue;
 	Sg_device *sdp;
 	unsigned long iflags;
 	int error;
 	u32 k;
 	sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
 	if (!sdp) {
 		printk(KERN_WARNING "kmalloc Sg_device failure\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	error = -ENOMEM;
 	if (!idr_pre_get(&sg_index_idr, GFP_KERNEL)) {
 		printk(KERN_WARNING "idr expansion Sg_device failure\n");
 		goto out;
 	}
 	write_lock_irqsave(&sg_index_lock, iflags);
 	error = idr_get_new(&sg_index_idr, sdp, &k);
 	write_unlock_irqrestore(&sg_index_lock, iflags);
 	if (error) {
 		printk(KERN_WARNING "idr allocation Sg_device failure: %d\n",
 		       error);
 		goto out;
 	}
 	if (unlikely(k >= SG_MAX_DEVS))
 		goto overflow;
 	SCSI_LOG_TIMEOUT(3, printk("sg_alloc: dev=%d \n", k));
 	sprintf(disk->disk_name, "sg%d", k);
 	disk->first_minor = k;
 	sdp->disk = disk;
 	sdp->device = scsidp;
 	init_waitqueue_head(&sdp->o_excl_wait);
 	sdp->sg_tablesize = min(q->max_hw_segments, q->max_phys_segments);
 	sdp->index = k;
 	error = 0;
  out:
 	if (error) {
 		kfree(sdp);
 		return ERR_PTR(error);
 	}
 	return sdp;
  overflow:
 	sdev_printk(KERN_WARNING, scsidp,
 		    "Unable to attach sg device type=%d, minor "
 		    "number exceeds %d\n", scsidp->type, SG_MAX_DEVS - 1);
 	error = -ENODEV;
 	goto out;
 }
 static int
 sg_add(struct device *cl_dev, struct class_interface *cl_intf)
 {
 	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
 	struct gendisk *disk;
 	Sg_device *sdp = NULL;
 	struct cdev * cdev = NULL;
 	int error;
 	unsigned long iflags;
 	disk = alloc_disk(1);
 	if (!disk) {
 		printk(KERN_WARNING "alloc_disk failed\n");
 		return -ENOMEM;
 	}
 	disk->major = SCSI_GENERIC_MAJOR;
 	error = -ENOMEM;
 	cdev = cdev_alloc();
 	if (!cdev) {
 		printk(KERN_WARNING "cdev_alloc failed\n");
 		goto out;
 	}
 	cdev->owner = THIS_MODULE;
 	cdev->ops = &sg_fops;
 	sdp = sg_alloc(disk, scsidp);
 	if (IS_ERR(sdp)) {
 		printk(KERN_WARNING "sg_alloc failed\n");
 		error = PTR_ERR(sdp);
 		goto out;
 	}
 	error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
 	if (error)
 		goto cdev_add_err;
 	sdp->cdev = cdev;
 	if (sg_sysfs_valid) {
 		struct device *sg_class_member;
 		sg_class_member = device_create_drvdata(sg_sysfs_class,
 							cl_dev->parent,
 							MKDEV(SCSI_GENERIC_MAJOR,
 							      sdp->index),
 							sdp,
 							"%s", disk->disk_name);
 		if (IS_ERR(sg_class_member)) {
 			printk(KERN_ERR "sg_add: "
 			       "device_create failed\n");
 			error = PTR_ERR(sg_class_member);
 			goto cdev_add_err;
 		}
 		error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
 					  &sg_class_member->kobj, "generic");
 		if (error)
 			printk(KERN_ERR "sg_add: unable to make symlink "
 					"'generic' back to sg%d\n", sdp->index);
 	} else
 		printk(KERN_WARNING "sg_add: sg_sys Invalid\n");
 	sdev_printk(KERN_NOTICE, scsidp,
 		    "Attached scsi generic sg%d type %d\n", sdp->index,
 		    scsidp->type);
 	dev_set_drvdata(cl_dev, sdp);
 	return 0;
 cdev_add_err:
 	write_lock_irqsave(&sg_index_lock, iflags);
 	idr_remove(&sg_index_idr, sdp->index);
 	write_unlock_irqrestore(&sg_index_lock, iflags);
 	kfree(sdp);
 out:
 	put_disk(disk);
 	if (cdev)
 		cdev_del(cdev);
 	return error;
 }
 static void
 sg_remove(struct device *cl_dev, struct class_interface *cl_intf)
 {
 	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
 	Sg_device *sdp = dev_get_drvdata(cl_dev);
 	unsigned long iflags;
 	Sg_fd *sfp;
 	Sg_fd *tsfp;
 	Sg_request *srp;
 	Sg_request *tsrp;
 	int delay;
 	if (!sdp)
 		return;
 	delay = 0;
 	write_lock_irqsave(&sg_index_lock, iflags);
 	if (sdp->headfp) {
 		sdp->detached = 1;
 		for (sfp = sdp->headfp; sfp; sfp = tsfp) {
 			tsfp = sfp->nextfp;
 			for (srp = sfp->headrp; srp; srp = tsrp) {
 				tsrp = srp->nextrp;
 				if (sfp->closed || (0 == sg_srp_done(srp, sfp)))
 					sg_finish_rem_req(srp);
 			}
 			if (sfp->closed) {
 				scsi_device_put(sdp->device);
 				__sg_remove_sfp(sdp, sfp);
 			} else {
 				delay = 1;
 				wake_up_interruptible(&sfp->read_wait);
 				kill_fasync(&sfp->async_qp, SIGPOLL,
 					    POLL_HUP);
 			}
 		}
 		SCSI_LOG_TIMEOUT(3, printk("sg_remove: dev=%d, dirty\n", sdp->index));
 		if (NULL == sdp->headfp) {
 			idr_remove(&sg_index_idr, sdp->index);
 		}
 	} else {	/* nothing active, simple case */
 		SCSI_LOG_TIMEOUT(3, printk("sg_remove: dev=%d\n", sdp->index));
 		idr_remove(&sg_index_idr, sdp->index);
 	}
 	write_unlock_irqrestore(&sg_index_lock, iflags);
 	sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
 	device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
 	cdev_del(sdp->cdev);
 	sdp->cdev = NULL;
 	put_disk(sdp->disk);
 	sdp->disk = NULL;
 	if (NULL == sdp->headfp)
 		kfree(sdp);
 	if (delay)
 		msleep(10);	/* dirty detach so delay device destruction */
 }
 module_param_named(scatter_elem_sz, scatter_elem_sz, int, S_IRUGO | S_IWUSR);
 module_param_named(def_reserved_size, def_reserved_size, int,
 		   S_IRUGO | S_IWUSR);
 module_param_named(allow_dio, sg_allow_dio, int, S_IRUGO | S_IWUSR);
 MODULE_AUTHOR("Douglas Gilbert");
 MODULE_DESCRIPTION("SCSI generic (sg) driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(SG_VERSION_STR);
 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
 MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
                 "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
 MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
 MODULE_PARM_DESC(allow_dio, "allow direct I/O (default: 0 (disallow))");
 static int __init
 init_sg(void)
 {
 	int rc;
 	if (scatter_elem_sz < PAGE_SIZE) {
 		scatter_elem_sz = PAGE_SIZE;
 		scatter_elem_sz_prev = scatter_elem_sz;
 	}
 	if (def_reserved_size >= 0)
 		sg_big_buff = def_reserved_size;
 	else
 		def_reserved_size = sg_big_buff;
 	rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
 				    SG_MAX_DEVS, "sg");
 	if (rc)
 		return rc;
         sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
         if ( IS_ERR(sg_sysfs_class) ) {
 		rc = PTR_ERR(sg_sysfs_class);
 		goto err_out;
         }
 	sg_sysfs_valid = 1;
 	rc = scsi_register_interface(&sg_interface);
 	if (0 == rc) {
 #ifdef CONFIG_SCSI_PROC_FS
 		sg_proc_init();
 #endif				/* CONFIG_SCSI_PROC_FS */
 		return 0;
 	}
 	class_destroy(sg_sysfs_class);
 err_out:
 	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
 	return rc;
 }
 static void __exit
 exit_sg(void)
 {
 #ifdef CONFIG_SCSI_PROC_FS
 	sg_proc_cleanup();
 #endif				/* CONFIG_SCSI_PROC_FS */
 	scsi_unregister_interface(&sg_interface);
 	class_destroy(sg_sysfs_class);
 	sg_sysfs_valid = 0;
 	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
 				 SG_MAX_DEVS);
 	idr_destroy(&sg_index_idr);
 }
 static int
 sg_start_req(Sg_request * srp)
 {
 	int res;
 	Sg_fd *sfp = srp->parentfp;
 	sg_io_hdr_t *hp = &srp->header;
 	int dxfer_len = (int) hp->dxfer_len;
 	int dxfer_dir = hp->dxfer_direction;
 	Sg_scatter_hold *req_schp = &srp->data;
 	Sg_scatter_hold *rsv_schp = &sfp->reserve;
 	SCSI_LOG_TIMEOUT(4, printk("sg_start_req: dxfer_len=%d\n", dxfer_len));
 	if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
 		return 0;
 	if (sg_allow_dio && (hp->flags & SG_FLAG_DIRECT_IO) &&
 	    (dxfer_dir != SG_DXFER_UNKNOWN) && (0 == hp->iovec_count) &&
 	    (!sfp->parentdp->device->host->unchecked_isa_dma)) {
 		res = sg_build_direct(srp, sfp, dxfer_len);
 		if (res <= 0)	/* -ve -> error, 0 -> done, 1 -> try indirect */
 			return res;
 	}
 	if ((!sg_res_in_use(sfp)) && (dxfer_len <= rsv_schp->bufflen))
 		sg_link_reserve(sfp, srp, dxfer_len);
 	else {
 		res = sg_build_indirect(req_schp, sfp, dxfer_len);
 		if (res) {
 			sg_remove_scat(req_schp);
 			return res;
 		}
 	}
 	return 0;
 }
 static void
 sg_finish_rem_req(Sg_request * srp)
 {
 	Sg_fd *sfp = srp->parentfp;
 	Sg_scatter_hold *req_schp = &srp->data;
 	SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n", (int) srp->res_used));
 	if (srp->res_used)
 		sg_unlink_reserve(sfp, srp);
 	else
 		sg_remove_scat(req_schp);
 	sg_remove_request(sfp, srp);
 }
 static int
 sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
 {
 	int sg_bufflen = tablesize * sizeof(struct scatterlist);
 	gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
 	/*
 	 * TODO: test without low_dma, we should not need it since
 	 * the block layer will bounce the buffer for us
 	 *
 	 * XXX(hch): we shouldn't need GFP_DMA for the actual S/G list.
 	 */
 	if (sfp->low_dma)
 		 gfp_flags |= GFP_DMA;
 	schp->buffer = kzalloc(sg_bufflen, gfp_flags);
 	if (!schp->buffer)
 		return -ENOMEM;
 	sg_init_table(schp->buffer, tablesize);
 	schp->sglist_len = sg_bufflen;
 	return tablesize;	/* number of scat_gath elements allocated */
 }
 #ifdef SG_ALLOW_DIO_CODE
 /* vvvvvvvv  following code borrowed from st driver's direct IO vvvvvvvvv */
 	/* TODO: hopefully we can use the generic block layer code */
 /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if
    - mapping of all pages not successful
    (i.e., either completely successful or fails)
 */
 static int
 st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
 	          unsigned long uaddr, size_t count, int rw)
 {
 	unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	unsigned long start = uaddr >> PAGE_SHIFT;
 	const int nr_pages = end - start;
 	int res, i, j;
 	struct page **pages;
 	/* User attempted Overflow! */
 	if ((uaddr + count) < uaddr)
 		return -EINVAL;
 	/* Too big */
         if (nr_pages > max_pages)
 		return -ENOMEM;
 	/* Hmm? */
 	if (count == 0)
 		return 0;
 	if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_ATOMIC)) == NULL)
 		return -ENOMEM;
         /* Try to fault in all of the necessary pages */
 	down_read(&current->mm->mmap_sem);
         /* rw==READ means read from drive, write into memory area */
 	res = get_user_pages(
 		current,
 		current->mm,
 		uaddr,
 		nr_pages,
 		rw == READ,
 		0, /* don't force */
 		pages,
 		NULL);
 	up_read(&current->mm->mmap_sem);
 	/* Errors and no page mapped should return here */
 	if (res < nr_pages)
 		goto out_unmap;
         for (i=0; i < nr_pages; i++) {
                 /* FIXME: flush superflous for rw==READ,
                  * probably wrong function for rw==WRITE
                  */
 		flush_dcache_page(pages[i]);
 		/* ?? Is locking needed? I don't think so */
 		/* if (TestSetPageLocked(pages[i]))
 		   goto out_unlock; */
         }
 	sg_set_page(sgl, pages[0], 0, uaddr & ~PAGE_MASK);
 	if (nr_pages > 1) {
 		sgl[0].length = PAGE_SIZE - sgl[0].offset;
 		count -= sgl[0].length;
 		for (i=1; i < nr_pages ; i++)
 			sg_set_page(&sgl[i], pages[i], count < PAGE_SIZE ? count : PAGE_SIZE, 0);
 	}
 	else {
 		sgl[0].length = count;
 	}
 	kfree(pages);
 	return nr_pages;
  out_unmap:
 	if (res > 0) {
 		for (j=0; j < res; j++)
 			page_cache_release(pages[j]);
 		res = 0;
 	}
 	kfree(pages);
 	return res;
 }
 /* And unmap them... */
 static int
 st_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
 		    int dirtied)
 {
 	int i;
 	for (i=0; i < nr_pages; i++) {
 		struct page *page = sg_page(&sgl[i]);
 		if (dirtied)
 			SetPageDirty(page);
 		/* unlock_page(page); */
 		/* FIXME: cache flush missing for rw==READ
 		 * FIXME: call the correct reference counting function
 		 */
 		page_cache_release(page);
 	}
 	return 0;
 }
 /* ^^^^^^^^  above code borrowed from st driver's direct IO ^^^^^^^^^ */
 #endif
 /* Returns: -ve -> error, 0 -> done, 1 -> try indirect */
 static int
 sg_build_direct(Sg_request * srp, Sg_fd * sfp, int dxfer_len)
 {
 #ifdef SG_ALLOW_DIO_CODE
 	sg_io_hdr_t *hp = &srp->header;
 	Sg_scatter_hold *schp = &srp->data;
 	int sg_tablesize = sfp->parentdp->sg_tablesize;
 	int mx_sc_elems, res;
 	struct scsi_device *sdev = sfp->parentdp->device;
 	if (((unsigned long)hp->dxferp &
 			queue_dma_alignment(sdev->request_queue)) != 0)
 		return 1;
 	mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
         if (mx_sc_elems <= 0) {
                 return 1;
         }
 	res = st_map_user_pages(schp->buffer, mx_sc_elems,
 				(unsigned long)hp->dxferp, dxfer_len,
 				(SG_DXFER_TO_DEV == hp->dxfer_direction) ? 1 : 0);
 	if (res <= 0) {
 		sg_remove_scat(schp);
 		return 1;
 	}
 	schp->k_use_sg = res;
 	schp->dio_in_use = 1;
 	hp->info |= SG_INFO_DIRECT_IO;
 	return 0;
 #else
 	return 1;
 #endif
 }
 static int
 sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
 {
 	struct scatterlist *sg;
 	int ret_sz = 0, k, rem_sz, num, mx_sc_elems;
 	int sg_tablesize = sfp->parentdp->sg_tablesize;
 	int blk_size = buff_size;
 	struct page *p = NULL;
 	if (blk_size < 0)
 		return -EFAULT;
 	if (0 == blk_size)
 		++blk_size;	/* don't know why */
 /* round request up to next highest SG_SECTOR_SZ byte boundary */
 	blk_size = (blk_size + SG_SECTOR_MSK) & (~SG_SECTOR_MSK);
 	SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n",
 				   buff_size, blk_size));
 	/* N.B. ret_sz carried into this block ... */
 	mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
 	if (mx_sc_elems < 0)
 		return mx_sc_elems;	/* most likely -ENOMEM */
 	num = scatter_elem_sz;
 	if (unlikely(num != scatter_elem_sz_prev)) {
 		if (num < PAGE_SIZE) {
 			scatter_elem_sz = PAGE_SIZE;
 			scatter_elem_sz_prev = PAGE_SIZE;
 		} else
 			scatter_elem_sz_prev = num;
 	}
 	for (k = 0, sg = schp->buffer, rem_sz = blk_size;
 	     (rem_sz > 0) && (k < mx_sc_elems);
 	     ++k, rem_sz -= ret_sz, sg = sg_next(sg)) {
 		num = (rem_sz > scatter_elem_sz_prev) ?
 		      scatter_elem_sz_prev : rem_sz;
 		p = sg_page_malloc(num, sfp->low_dma, &ret_sz);
 		if (!p)
 			return -ENOMEM;
 		if (num == scatter_elem_sz_prev) {
 			if (unlikely(ret_sz > scatter_elem_sz_prev)) {
 				scatter_elem_sz = ret_sz;
 				scatter_elem_sz_prev = ret_sz;
 			}
 		}
 		sg_set_page(sg, p, (ret_sz > num) ? num : ret_sz, 0);
 		SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
 				 "ret_sz=%d\n", k, num, ret_sz));
 	}		/* end of for loop */
 	schp->k_use_sg = k;
 	SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
 			 "rem_sz=%d\n", k, rem_sz));
 	schp->bufflen = blk_size;
 	if (rem_sz > 0)	/* must have failed */
 		return -ENOMEM;
 	return 0;
 }
 static int
 sg_write_xfer(Sg_request * srp)
 {
 	sg_io_hdr_t *hp = &srp->header;
 	Sg_scatter_hold *schp = &srp->data;
 	struct scatterlist *sg = schp->buffer;
 	int num_xfer = 0;
 	int j, k, onum, usglen, ksglen, res;
 	int iovec_count = (int) hp->iovec_count;
 	int dxfer_dir = hp->dxfer_direction;
 	unsigned char *p;
 	unsigned char __user *up;
 	int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
 	if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_TO_DEV == dxfer_dir) ||
 	    (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
 		num_xfer = (int) (new_interface ? hp->dxfer_len : hp->flags);
 		if (schp->bufflen < num_xfer)
 			num_xfer = schp->bufflen;
 	}
 	if ((num_xfer <= 0) || (schp->dio_in_use) ||
 	    (new_interface
 	     && ((SG_FLAG_NO_DXFER | SG_FLAG_MMAP_IO) & hp->flags)))
 		return 0;
 	SCSI_LOG_TIMEOUT(4, printk("sg_write_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
 			  num_xfer, iovec_count, schp->k_use_sg));
 	if (iovec_count) {
 		onum = iovec_count;
 		if (!access_ok(VERIFY_READ, hp->dxferp, SZ_SG_IOVEC * onum))
 			return -EFAULT;
 	} else
 		onum = 1;
 	ksglen = sg->length;
 	p = page_address(sg_page(sg));
 	for (j = 0, k = 0; j < onum; ++j) {
 		res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up);
 		if (res)
 			return res;
 		for (; p; sg = sg_next(sg), ksglen = sg->length,
 		     p = page_address(sg_page(sg))) {
 			if (usglen <= 0)
 				break;
 			if (ksglen > usglen) {
 				if (usglen >= num_xfer) {
 					if (__copy_from_user(p, up, num_xfer))
 						return -EFAULT;
 					return 0;
 				}
 				if (__copy_from_user(p, up, usglen))
 					return -EFAULT;
 				p += usglen;
 				ksglen -= usglen;
 				break;
 			} else {
 				if (ksglen >= num_xfer) {
 					if (__copy_from_user(p, up, num_xfer))
 						return -EFAULT;
 					return 0;
 				}
 				if (__copy_from_user(p, up, ksglen))
 					return -EFAULT;
 				up += ksglen;
 				usglen -= ksglen;
 			}
 			++k;
 			if (k >= schp->k_use_sg)
 				return 0;
 		}
 	}
 	return 0;
 }
 static int
 sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
 	   int wr_xf, int *countp, unsigned char __user **up)
 {
 	int num_xfer = (int) hp->dxfer_len;
 	unsigned char __user *p = hp->dxferp;
 	int count;
 	if (0 == sg_num) {
 		if (wr_xf && ('\0' == hp->interface_id))
 			count = (int) hp->flags;	/* holds "old" input_size */
 		else
 			count = num_xfer;
 	} else {
 		sg_iovec_t iovec;
 		if (__copy_from_user(&iovec, p + ind*SZ_SG_IOVEC, SZ_SG_IOVEC))
 			return -EFAULT;
 		p = iovec.iov_base;
 		count = (int) iovec.iov_len;
 	}
 	if (!access_ok(wr_xf ? VERIFY_READ : VERIFY_WRITE, p, count))
 		return -EFAULT;
 	if (up)
 		*up = p;
 	if (countp)
 		*countp = count;
 	return 0;
 }
 static void
 sg_remove_scat(Sg_scatter_hold * schp)
 {
 	SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
 	if (schp->buffer && (schp->sglist_len > 0)) {
 		struct scatterlist *sg = schp->buffer;
 		if (schp->dio_in_use) {
 #ifdef SG_ALLOW_DIO_CODE
 			st_unmap_user_pages(sg, schp->k_use_sg, TRUE);
 #endif
 		} else {
 			int k;
 			for (k = 0; (k < schp->k_use_sg) && sg_page(sg);
 			     ++k, sg = sg_next(sg)) {
 				SCSI_LOG_TIMEOUT(5, printk(
 				    "sg_remove_scat: k=%d, pg=0x%p, len=%d\n",
 				    k, sg_page(sg), sg->length));
 				sg_page_free(sg_page(sg), sg->length);
 			}
 		}
 		kfree(schp->buffer);
 	}
 	memset(schp, 0, sizeof (*schp));
 }
 static int
 sg_read_xfer(Sg_request * srp)
 {
 	sg_io_hdr_t *hp = &srp->header;
 	Sg_scatter_hold *schp = &srp->data;
 	struct scatterlist *sg = schp->buffer;
 	int num_xfer = 0;
 	int j, k, onum, usglen, ksglen, res;
 	int iovec_count = (int) hp->iovec_count;
 	int dxfer_dir = hp->dxfer_direction;
 	unsigned char *p;
 	unsigned char __user *up;
 	int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
 	if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_FROM_DEV == dxfer_dir)
 	    || (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
 		num_xfer = hp->dxfer_len;
 		if (schp->bufflen < num_xfer)
 			num_xfer = schp->bufflen;
 	}
 	if ((num_xfer <= 0) || (schp->dio_in_use) ||
 	    (new_interface
 	     && ((SG_FLAG_NO_DXFER | SG_FLAG_MMAP_IO) & hp->flags)))
 		return 0;
 	SCSI_LOG_TIMEOUT(4, printk("sg_read_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
 			  num_xfer, iovec_count, schp->k_use_sg));
 	if (iovec_count) {
 		onum = iovec_count;
 		if (!access_ok(VERIFY_READ, hp->dxferp, SZ_SG_IOVEC * onum))
 			return -EFAULT;
 	} else
 		onum = 1;
 	p = page_address(sg_page(sg));
 	ksglen = sg->length;
 	for (j = 0, k = 0; j < onum; ++j) {
 		res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up);
 		if (res)
 			return res;
 		for (; p; sg = sg_next(sg), ksglen = sg->length,
 		     p = page_address(sg_page(sg))) {
 			if (usglen <= 0)
 				break;
 			if (ksglen > usglen) {
 				if (usglen >= num_xfer) {
 					if (__copy_to_user(up, p, num_xfer))
 						return -EFAULT;
 					return 0;
 				}
 				if (__copy_to_user(up, p, usglen))
 					return -EFAULT;
 				p += usglen;
 				ksglen -= usglen;
 				break;
 			} else {
 				if (ksglen >= num_xfer) {
 					if (__copy_to_user(up, p, num_xfer))
 						return -EFAULT;
 					return 0;
 				}
 				if (__copy_to_user(up, p, ksglen))
 					return -EFAULT;
 				up += ksglen;
 				usglen -= ksglen;
 			}
 			++k;
 			if (k >= schp->k_use_sg)
 				return 0;
 		}
 	}
 	return 0;
 }
 static int
 sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
 {
 	Sg_scatter_hold *schp = &srp->data;
 	struct scatterlist *sg = schp->buffer;
 	int k, num;
 	SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n",
 				   num_read_xfer));
 	if ((!outp) || (num_read_xfer <= 0))
 		return 0;
 	for (k = 0; (k < schp->k_use_sg) && sg_page(sg); ++k, sg = sg_next(sg)) {
 		num = sg->length;
 		if (num > num_read_xfer) {
 			if (__copy_to_user(outp, page_address(sg_page(sg)),
 					   num_read_xfer))
 				return -EFAULT;
 			break;
 		} else {
 			if (__copy_to_user(outp, page_address(sg_page(sg)),
 					   num))
 				return -EFAULT;
 			num_read_xfer -= num;
 			if (num_read_xfer <= 0)
 				break;
 			outp += num;
 		}
 	}
 	return 0;
 }
 static void
 sg_build_reserve(Sg_fd * sfp, int req_size)
 {
 	Sg_scatter_hold *schp = &sfp->reserve;
 	SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size));
 	do {
 		if (req_size < PAGE_SIZE)
 			req_size = PAGE_SIZE;
 		if (0 == sg_build_indirect(schp, sfp, req_size))
 			return;
 		else
 			sg_remove_scat(schp);
 		req_size >>= 1;	/* divide by 2 */
 	} while (req_size > (PAGE_SIZE / 2));
 }
 static void
 sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
 {
 	Sg_scatter_hold *req_schp = &srp->data;
 	Sg_scatter_hold *rsv_schp = &sfp->reserve;
 	struct scatterlist *sg = rsv_schp->buffer;
 	int k, num, rem;
 	srp->res_used = 1;
 	SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size));
 	rem = size;
 	for (k = 0; k < rsv_schp->k_use_sg; ++k, sg = sg_next(sg)) {
 		num = sg->length;
 		if (rem <= num) {
 			sfp->save_scat_len = num;
 			sg->length = rem;
 			req_schp->k_use_sg = k + 1;
 			req_schp->sglist_len = rsv_schp->sglist_len;
 			req_schp->buffer = rsv_schp->buffer;
 			req_schp->bufflen = size;
 			req_schp->b_malloc_len = rsv_schp->b_malloc_len;
 			break;
 		} else
 			rem -= num;
 	}
 	if (k >= rsv_schp->k_use_sg)
 		SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
 }
 static void
 sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
 {
 	Sg_scatter_hold *req_schp = &srp->data;
 	Sg_scatter_hold *rsv_schp = &sfp->reserve;
 	SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n",
 				   (int) req_schp->k_use_sg));
 	if ((rsv_schp->k_use_sg > 0) && (req_schp->k_use_sg > 0)) {
 		struct scatterlist *sg = rsv_schp->buffer;
 		if (sfp->save_scat_len > 0)
 			(sg + (req_schp->k_use_sg - 1))->length =
 			    (unsigned) sfp->save_scat_len;
 		else
 			SCSI_LOG_TIMEOUT(1, printk ("sg_unlink_reserve: BAD save_scat_len\n"));
 	}
 	req_schp->k_use_sg = 0;
 	req_schp->bufflen = 0;
 	req_schp->buffer = NULL;
 	req_schp->sglist_len = 0;
 	sfp->save_scat_len = 0;
 	srp->res_used = 0;
 }
 static Sg_request *
 sg_get_rq_mark(Sg_fd * sfp, int pack_id)
 {
 	Sg_request *resp;
 	unsigned long iflags;
 	write_lock_irqsave(&sfp->rq_list_lock, iflags);
 	for (resp = sfp->headrp; resp; resp = resp->nextrp) {
 		/* look for requests that are ready + not SG_IO owned */
 		if ((1 == resp->done) && (!resp->sg_io_owned) &&
 		    ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
 			resp->done = 2;	/* guard against other readers */
 			break;
 		}
 	}
 	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return resp;
 }
 #ifdef CONFIG_SCSI_PROC_FS
 static Sg_request *
 sg_get_nth_request(Sg_fd * sfp, int nth)
 {
 	Sg_request *resp;
 	unsigned long iflags;
 	int k;
 	read_lock_irqsave(&sfp->rq_list_lock, iflags);
 	for (k = 0, resp = sfp->headrp; resp && (k < nth);
 	     ++k, resp = resp->nextrp) ;
 	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return resp;
 }
 #endif
 /* always adds to end of list */
 static Sg_request *
 sg_add_request(Sg_fd * sfp)
 {
 	int k;
 	unsigned long iflags;
 	Sg_request *resp;
 	Sg_request *rp = sfp->req_arr;
 	write_lock_irqsave(&sfp->rq_list_lock, iflags);
 	resp = sfp->headrp;
 	if (!resp) {
 		memset(rp, 0, sizeof (Sg_request));
 		rp->parentfp = sfp;
 		resp = rp;
 		sfp->headrp = resp;
 	} else {
 		if (0 == sfp->cmd_q)
 			resp = NULL;	/* command queuing disallowed */
 		else {
 			for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
 				if (!rp->parentfp)
 					break;
 			}
 			if (k < SG_MAX_QUEUE) {
 				memset(rp, 0, sizeof (Sg_request));
 				rp->parentfp = sfp;
 				while (resp->nextrp)
 					resp = resp->nextrp;
 				resp->nextrp = rp;
 				resp = rp;
 			} else
 				resp = NULL;
 		}
 	}
 	if (resp) {
 		resp->nextrp = NULL;
 		resp->header.duration = jiffies_to_msecs(jiffies);
 	}
 	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return resp;
 }
 /* Return of 1 for found; 0 for not found */
 static int
 sg_remove_request(Sg_fd * sfp, Sg_request * srp)
 {
 	Sg_request *prev_rp;
 	Sg_request *rp;
 	unsigned long iflags;
 	int res = 0;
 	if ((!sfp) || (!srp) || (!sfp->headrp))
 		return res;
 	write_lock_irqsave(&sfp->rq_list_lock, iflags);
 	prev_rp = sfp->headrp;
 	if (srp == prev_rp) {
 		sfp->headrp = prev_rp->nextrp;
 		prev_rp->parentfp = NULL;
 		res = 1;
 	} else {
 		while ((rp = prev_rp->nextrp)) {
 			if (srp == rp) {
 				prev_rp->nextrp = rp->nextrp;
 				rp->parentfp = NULL;
 				res = 1;
 				break;
 			}
 			prev_rp = rp;
 		}
 	}
 	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return res;
 }
 #ifdef CONFIG_SCSI_PROC_FS
 static Sg_fd *
 sg_get_nth_sfp(Sg_device * sdp, int nth)
 {
 	Sg_fd *resp;
 	unsigned long iflags;
 	int k;
 	read_lock_irqsave(&sg_index_lock, iflags);
 	for (k = 0, resp = sdp->headfp; resp && (k < nth);
 	     ++k, resp = resp->nextfp) ;
 	read_unlock_irqrestore(&sg_index_lock, iflags);
 	return resp;
 }
 #endif
 static Sg_fd *
 sg_add_sfp(Sg_device * sdp, int dev)
 {
 	Sg_fd *sfp;
 	unsigned long iflags;
 	int bufflen;
 	sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
 	if (!sfp)
 		return NULL;
 	init_waitqueue_head(&sfp->read_wait);
 	rwlock_init(&sfp->rq_list_lock);
 	sfp->timeout = SG_DEFAULT_TIMEOUT;
 	sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
 	sfp->force_packid = SG_DEF_FORCE_PACK_ID;
 	sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ?
 	    sdp->device->host->unchecked_isa_dma : 1;
 	sfp->cmd_q = SG_DEF_COMMAND_Q;
 	sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
 	sfp->parentdp = sdp;
 	write_lock_irqsave(&sg_index_lock, iflags);
 	if (!sdp->headfp)
 		sdp->headfp = sfp;
 	else {			/* add to tail of existing list */
 		Sg_fd *pfp = sdp->headfp;
 		while (pfp->nextfp)
 			pfp = pfp->nextfp;
 		pfp->nextfp = sfp;
 	}
 	write_unlock_irqrestore(&sg_index_lock, iflags);
 	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp));
 	if (unlikely(sg_big_buff != def_reserved_size))
 		sg_big_buff = def_reserved_size;
 	bufflen = min_t(int, sg_big_buff,
 			sdp->device->request_queue->max_sectors * 512);
 	sg_build_reserve(sfp, bufflen);
 	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
 			   sfp->reserve.bufflen, sfp->reserve.k_use_sg));
 	return sfp;
 }
 static void
 __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp)
 {
 	Sg_fd *fp;
 	Sg_fd *prev_fp;
 	prev_fp = sdp->headfp;
 	if (sfp == prev_fp)
 		sdp->headfp = prev_fp->nextfp;
 	else {
 		while ((fp = prev_fp->nextfp)) {
 			if (sfp == fp) {
 				prev_fp->nextfp = fp->nextfp;
 				break;
 			}
 			prev_fp = fp;
 		}
 	}
 	if (sfp->reserve.bufflen > 0) {
 		SCSI_LOG_TIMEOUT(6,
 			printk("__sg_remove_sfp:    bufflen=%d, k_use_sg=%d\n",
 			(int) sfp->reserve.bufflen, (int) sfp->reserve.k_use_sg));
 		sg_remove_scat(&sfp->reserve);
 	}
 	sfp->parentdp = NULL;
 	SCSI_LOG_TIMEOUT(6, printk("__sg_remove_sfp:    sfp=0x%p\n", sfp));
 	kfree(sfp);
 }
 /* Returns 0 in normal case, 1 when detached and sdp object removed */
 static int
 sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp)
 {
 	Sg_request *srp;
 	Sg_request *tsrp;
 	int dirty = 0;
 	int res = 0;
 	for (srp = sfp->headrp; srp; srp = tsrp) {
 		tsrp = srp->nextrp;
 		if (sg_srp_done(srp, sfp))
 			sg_finish_rem_req(srp);
 		else
 			++dirty;
 	}
 	if (0 == dirty) {
 		unsigned long iflags;
 		write_lock_irqsave(&sg_index_lock, iflags);
 		__sg_remove_sfp(sdp, sfp);
 		if (sdp->detached && (NULL == sdp->headfp)) {
 			idr_remove(&sg_index_idr, sdp->index);
 			kfree(sdp);
 			res = 1;
 		}
 		write_unlock_irqrestore(&sg_index_lock, iflags);
 	} else {
 		/* MOD_INC's to inhibit unloading sg and associated adapter driver */
 		/* only bump the access_count if we actually succeeded in
 		 * throwing another counter on the host module */
 		scsi_device_get(sdp->device);	/* XXX: retval ignored? */
 		sfp->closed = 1;	/* flag dirty state on this fd */
 		SCSI_LOG_TIMEOUT(1, printk("sg_remove_sfp: worrisome, %d writes pending\n",
 				  dirty));
 	}
 	return res;
 }
 static int
 sg_res_in_use(Sg_fd * sfp)
 {
 	const Sg_request *srp;
 	unsigned long iflags;
 	read_lock_irqsave(&sfp->rq_list_lock, iflags);
 	for (srp = sfp->headrp; srp; srp = srp->nextrp)
 		if (srp->res_used)
 			break;
 	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 	return srp ? 1 : 0;
 }
 /* The size fetched (value output via retSzp) set when non-NULL return */
 static struct page *
 sg_page_malloc(int rqSz, int lowDma, int *retSzp)
 {
 	struct page *resp = NULL;
 	gfp_t page_mask;
 	int order, a_size;
 	int resSz;
 	if ((rqSz <= 0) || (NULL == retSzp))
 		return resp;
 	if (lowDma)
 		page_mask = GFP_ATOMIC | GFP_DMA | __GFP_COMP | __GFP_NOWARN;
 	else
 		page_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN;
 	for (order = 0, a_size = PAGE_SIZE; a_size < rqSz;
 	     order++, a_size <<= 1) ;
 	resSz = a_size;		/* rounded up if necessary */
 	resp = alloc_pages(page_mask, order);
 	while ((!resp) && order) {
 		--order;
 		a_size >>= 1;	/* divide by 2, until PAGE_SIZE */
 		resp =  alloc_pages(page_mask, order);	/* try half */
 		resSz = a_size;
 	}
 	if (resp) {
 		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 			memset(page_address(resp), 0, resSz);
 		*retSzp = resSz;
 	}
 	return resp;
 }
 static void
 sg_page_free(struct page *page, int size)
 {
 	int order, a_size;
 	if (!page)
 		return;
 	for (order = 0, a_size = PAGE_SIZE; a_size < size;
 	     order++, a_size <<= 1) ;
 	__free_pages(page, order);
 }
 #ifndef MAINTENANCE_IN_CMD
 #define MAINTENANCE_IN_CMD 0xa3
 #endif
-static unsigned char allow_ops[] = { TEST_UNIT_READY, REQUEST_SENSE,
-	INQUIRY, READ_CAPACITY, READ_BUFFER, READ_6, READ_10, READ_12,
-	READ_16, MODE_SENSE, MODE_SENSE_10, LOG_SENSE, REPORT_LUNS,
-	SERVICE_ACTION_IN, RECEIVE_DIAGNOSTIC, READ_LONG, MAINTENANCE_IN_CMD
-};
-static int
-sg_allow_access(unsigned char opcode, char dev_type)
-{
-	int k;
-	if (TYPE_SCANNER == dev_type)	/* TYPE_ROM maybe burner */
-		return 1;
-	for (k = 0; k < sizeof (allow_ops); ++k) {
-		if (opcode == allow_ops[k])
-			return 1;
-	}
-	return 0;
-}
 #ifdef CONFIG_SCSI_PROC_FS
 static int
 sg_idr_max_id(int id, void *p, void *data)
 {
 	int *k = data;
 	if (*k < id)
 		*k = id;
 	return 0;
 }
 static int
 sg_last_dev(void)
 {
 	int k = -1;
 	unsigned long iflags;
 	read_lock_irqsave(&sg_index_lock, iflags);
 	idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
 	read_unlock_irqrestore(&sg_index_lock, iflags);
 	return k + 1;		/* origin 1 */
 }
 #endif
 static Sg_device *
 sg_get_dev(int dev)
 {
 	Sg_device *sdp;
 	unsigned long iflags;
 	read_lock_irqsave(&sg_index_lock, iflags);
 	sdp = idr_find(&sg_index_idr, dev);
 	read_unlock_irqrestore(&sg_index_lock, iflags);
 	return sdp;
 }
 #ifdef CONFIG_SCSI_PROC_FS
 static struct proc_dir_entry *sg_proc_sgp = NULL;
 static char sg_proc_sg_dirname[] = "scsi/sg";
 static int sg_proc_seq_show_int(struct seq_file *s, void *v);
 static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
 static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer,
 			          size_t count, loff_t *off);
 static struct file_operations adio_fops = {
 	/* .owner, .read and .llseek added in sg_proc_init() */
 	.open = sg_proc_single_open_adio,
 	.write = sg_proc_write_adio,
 	.release = single_release,
 };
 static int sg_proc_single_open_dressz(struct inode *inode, struct file *file);
 static ssize_t sg_proc_write_dressz(struct file *filp,
 		const char __user *buffer, size_t count, loff_t *off);
 static struct file_operations dressz_fops = {
 	.open = sg_proc_single_open_dressz,
 	.write = sg_proc_write_dressz,
 	.release = single_release,
 };
 static int sg_proc_seq_show_version(struct seq_file *s, void *v);
 static int sg_proc_single_open_version(struct inode *inode, struct file *file);
 static struct file_operations version_fops = {
 	.open = sg_proc_single_open_version,
 	.release = single_release,
 };
 static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v);
 static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file);
 static struct file_operations devhdr_fops = {
 	.open = sg_proc_single_open_devhdr,
 	.release = single_release,
 };
 static int sg_proc_seq_show_dev(struct seq_file *s, void *v);
 static int sg_proc_open_dev(struct inode *inode, struct file *file);
 static void * dev_seq_start(struct seq_file *s, loff_t *pos);
 static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos);
 static void dev_seq_stop(struct seq_file *s, void *v);
 static struct file_operations dev_fops = {
 	.open = sg_proc_open_dev,
 	.release = seq_release,
 };
 static struct seq_operations dev_seq_ops = {
 	.start = dev_seq_start,
 	.next  = dev_seq_next,
 	.stop  = dev_seq_stop,
 	.show  = sg_proc_seq_show_dev,
 };
 static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v);
 static int sg_proc_open_devstrs(struct inode *inode, struct file *file);
 static struct file_operations devstrs_fops = {
 	.open = sg_proc_open_devstrs,
 	.release = seq_release,
 };
 static struct seq_operations devstrs_seq_ops = {
 	.start = dev_seq_start,
 	.next  = dev_seq_next,
 	.stop  = dev_seq_stop,
 	.show  = sg_proc_seq_show_devstrs,
 };
 static int sg_proc_seq_show_debug(struct seq_file *s, void *v);
 static int sg_proc_open_debug(struct inode *inode, struct file *file);
 static struct file_operations debug_fops = {
 	.open = sg_proc_open_debug,
 	.release = seq_release,
 };
 static struct seq_operations debug_seq_ops = {
 	.start = dev_seq_start,
 	.next  = dev_seq_next,
 	.stop  = dev_seq_stop,
 	.show  = sg_proc_seq_show_debug,
 };
 struct sg_proc_leaf {
 	const char * name;
 	struct file_operations * fops;
 };
 static struct sg_proc_leaf sg_proc_leaf_arr[] = {
 	{"allow_dio", &adio_fops},
 	{"debug", &debug_fops},
 	{"def_reserved_size", &dressz_fops},
 	{"device_hdr", &devhdr_fops},
 	{"devices", &dev_fops},
 	{"device_strs", &devstrs_fops},
 	{"version", &version_fops}
 };
 static int
 sg_proc_init(void)
 {
 	int k, mask;
 	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
 	struct sg_proc_leaf * leaf;
 	sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
 	if (!sg_proc_sgp)
 		return 1;
 	for (k = 0; k < num_leaves; ++k) {
 		leaf = &sg_proc_leaf_arr[k];
 		mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
 		leaf->fops->owner = THIS_MODULE;
 		leaf->fops->read = seq_read;
 		leaf->fops->llseek = seq_lseek;
 		proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
 	}
 	return 0;
 }
 static void
 sg_proc_cleanup(void)
 {
 	int k;
 	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
 	if (!sg_proc_sgp)
 		return;
 	for (k = 0; k < num_leaves; ++k)
 		remove_proc_entry(sg_proc_leaf_arr[k].name, sg_proc_sgp);
 	remove_proc_entry(sg_proc_sg_dirname, NULL);
 }
 static int sg_proc_seq_show_int(struct seq_file *s, void *v)
 {
 	seq_printf(s, "%d\n", *((int *)s->private));
 	return 0;
 }
 static int sg_proc_single_open_adio(struct inode *inode, struct file *file)
 {
 	return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
 }
 static ssize_t
 sg_proc_write_adio(struct file *filp, const char __user *buffer,
 		   size_t count, loff_t *off)
 {
 	int num;
 	char buff[11];
 	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 		return -EACCES;
 	num = (count < 10) ? count : 10;
 	if (copy_from_user(buff, buffer, num))
 		return -EFAULT;
 	buff[num] = '\0';
 	sg_allow_dio = simple_strtoul(buff, NULL, 10) ? 1 : 0;
 	return count;
 }
 static int sg_proc_single_open_dressz(struct inode *inode, struct file *file)
 {
 	return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
 }
 static ssize_t
 sg_proc_write_dressz(struct file *filp, const char __user *buffer,
 		     size_t count, loff_t *off)
 {
 	int num;
 	unsigned long k = ULONG_MAX;
 	char buff[11];
 	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 		return -EACCES;
 	num = (count < 10) ? count : 10;
 	if (copy_from_user(buff, buffer, num))
 		return -EFAULT;
 	buff[num] = '\0';
 	k = simple_strtoul(buff, NULL, 10);
 	if (k <= 1048576) {	/* limit "big buff" to 1 MB */
 		sg_big_buff = k;
 		return count;
 	}
 	return -ERANGE;
 }
 static int sg_proc_seq_show_version(struct seq_file *s, void *v)
 {
 	seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR,
 		   sg_version_date);
 	return 0;
 }
 static int sg_proc_single_open_version(struct inode *inode, struct file *file)
 {
 	return single_open(file, sg_proc_seq_show_version, NULL);
 }
 static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
 {
 	seq_printf(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\t"
 		   "online\n");
 	return 0;
 }
 static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file)
 {
 	return single_open(file, sg_proc_seq_show_devhdr, NULL);
 }
 struct sg_proc_deviter {
 	loff_t	index;
 	size_t	max;
 };
 static void * dev_seq_start(struct seq_file *s, loff_t *pos)
 {
 	struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);
 	s->private = it;
 	if (! it)
 		return NULL;
 	it->index = *pos;
 	it->max = sg_last_dev();
 	if (it->index >= it->max)
 		return NULL;
 	return it;
 }
 static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
 	struct sg_proc_deviter * it = s->private;
 	*pos = ++it->index;
 	return (it->index < it->max) ? it : NULL;
 }
 static void dev_seq_stop(struct seq_file *s, void *v)
 {
 	kfree(s->private);
 }
 static int sg_proc_open_dev(struct inode *inode, struct file *file)
 {
         return seq_open(file, &dev_seq_ops);
 }
 static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
 {
 	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
 	Sg_device *sdp;
 	struct scsi_device *scsidp;
 	sdp = it ? sg_get_dev(it->index) : NULL;
 	if (sdp && (scsidp = sdp->device) && (!sdp->detached))
 		seq_printf(s, "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
 			      scsidp->host->host_no, scsidp->channel,
 			      scsidp->id, scsidp->lun, (int) scsidp->type,
 			      1,
 			      (int) scsidp->queue_depth,
 			      (int) scsidp->device_busy,
 			      (int) scsi_device_online(scsidp));
 	else
 		seq_printf(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
 	return 0;
 }
 static int sg_proc_open_devstrs(struct inode *inode, struct file *file)
 {
         return seq_open(file, &devstrs_seq_ops);
 }
 static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
 {
 	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
 	Sg_device *sdp;
 	struct scsi_device *scsidp;
 	sdp = it ? sg_get_dev(it->index) : NULL;
 	if (sdp && (scsidp = sdp->device) && (!sdp->detached))
 		seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n",
 			   scsidp->vendor, scsidp->model, scsidp->rev);
 	else
 		seq_printf(s, "<no active device>\n");
 	return 0;
 }
 static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
 {
 	int k, m, new_interface, blen, usg;
 	Sg_request *srp;
 	Sg_fd *fp;
 	const sg_io_hdr_t *hp;
 	const char * cp;
 	unsigned int ms;
 	for (k = 0; (fp = sg_get_nth_sfp(sdp, k)); ++k) {
 		seq_printf(s, "   FD(%d): timeout=%dms bufflen=%d "
 			   "(res)sgat=%d low_dma=%d\n", k + 1,
 			   jiffies_to_msecs(fp->timeout),
 			   fp->reserve.bufflen,
 			   (int) fp->reserve.k_use_sg,
 			   (int) fp->low_dma);
 		seq_printf(s, "   cmd_q=%d f_packid=%d k_orphan=%d closed=%d\n",
 			   (int) fp->cmd_q, (int) fp->force_packid,
 			   (int) fp->keep_orphan, (int) fp->closed);
 		for (m = 0; (srp = sg_get_nth_request(fp, m)); ++m) {
 			hp = &srp->header;
 			new_interface = (hp->interface_id == '\0') ? 0 : 1;
 			if (srp->res_used) {
 				if (new_interface &&
 				    (SG_FLAG_MMAP_IO & hp->flags))
 					cp = "     mmap>> ";
 				else
 					cp = "     rb>> ";
 			} else {
 				if (SG_INFO_DIRECT_IO_MASK & hp->info)
 					cp = "     dio>> ";
 				else
 					cp = "     ";
 			}
 			seq_printf(s, cp);
 			blen = srp->data.bufflen;
 			usg = srp->data.k_use_sg;
 			seq_printf(s, srp->done ?
 				   ((1 == srp->done) ?  "rcv:" : "fin:")
 				   : "act:");
 			seq_printf(s, " id=%d blen=%d",
 				   srp->header.pack_id, blen);
 			if (srp->done)
 				seq_printf(s, " dur=%d", hp->duration);
 			else {
 				ms = jiffies_to_msecs(jiffies);
 				seq_printf(s, " t_o/elap=%d/%d",
 					(new_interface ? hp->timeout :
 						  jiffies_to_msecs(fp->timeout)),
 					(ms > hp->duration ? ms - hp->duration : 0));
 			}
 			seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
 				   (int) srp->data.cmd_opcode);
 		}
 		if (0 == m)
 			seq_printf(s, "     No requests active\n");
 	}
 }
 static int sg_proc_open_debug(struct inode *inode, struct file *file)
 {
         return seq_open(file, &debug_seq_ops);
 }
 static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
 {
 	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
 	Sg_device *sdp;
 	if (it && (0 == it->index)) {
 		seq_printf(s, "max_active_device=%d(origin 1)\n",
 			   (int)it->max);
 		seq_printf(s, " def_reserved_size=%d\n", sg_big_buff);
 	}
 	sdp = it ? sg_get_dev(it->index) : NULL;
 	if (sdp) {
 		struct scsi_device *scsidp = sdp->device;
 		if (NULL == scsidp) {
 			seq_printf(s, "device %d detached ??\n",
 				   (int)it->index);
 			return 0;
 		}
 		if (sg_get_nth_sfp(sdp, 0)) {
 			seq_printf(s, " >>> device=%s ",
 				sdp->disk->disk_name);
 			if (sdp->detached)
 				seq_printf(s, "detached pending close ");
 			else
 				seq_printf
 				    (s, "scsi%d chan=%d id=%d lun=%d   em=%d",
 				     scsidp->host->host_no,
 				     scsidp->channel, scsidp->id,
 				     scsidp->lun,
 				     scsidp->host->hostt->emulated);
 			seq_printf(s, " sg_tablesize=%d excl=%d\n",
 				   sdp->sg_tablesize, sdp->exclude);
 		}
 		sg_proc_debug_helper(s, sdp);
 	}
 	return 0;
 }
 #endif				/* CONFIG_SCSI_PROC_FS */
 module_init(init_sg);

include/linux/blkdev.h

Diff comments View file @ 0b07de8

 #ifndef _LINUX_BLKDEV_H
 #define _LINUX_BLKDEV_H
 #ifdef CONFIG_BLOCK
 #include <linux/sched.h>
 #include <linux/major.h>
 #include <linux/genhd.h>
 #include <linux/list.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/pagemap.h>
 #include <linux/backing-dev.h>
 #include <linux/wait.h>
 #include <linux/mempool.h>
 #include <linux/bio.h>
 #include <linux/module.h>
 #include <linux/stringify.h>
 #include <linux/bsg.h>
 #include <asm/scatterlist.h>
 struct scsi_ioctl_command;
 struct request_queue;
 struct elevator_queue;
 typedef struct elevator_queue elevator_t;
 struct request_pm_state;
 struct blk_trace;
 struct request;
 struct sg_io_hdr;
 #define BLKDEV_MIN_RQ	4
 #define BLKDEV_MAX_RQ	128	/* Default maximum */
 struct request;
 typedef void (rq_end_io_fn)(struct request *, int);
 struct request_list {
 	int count[2];
 	int starved[2];
 	int elvpriv;
 	mempool_t *rq_pool;
 	wait_queue_head_t wait[2];
 };
 /*
  * request command types
  */
 enum rq_cmd_type_bits {
 	REQ_TYPE_FS		= 1,	/* fs request */
 	REQ_TYPE_BLOCK_PC,		/* scsi command */
 	REQ_TYPE_SENSE,			/* sense request */
 	REQ_TYPE_PM_SUSPEND,		/* suspend request */
 	REQ_TYPE_PM_RESUME,		/* resume request */
 	REQ_TYPE_PM_SHUTDOWN,		/* shutdown request */
 	REQ_TYPE_FLUSH,			/* flush request */
 	REQ_TYPE_SPECIAL,		/* driver defined type */
 	REQ_TYPE_LINUX_BLOCK,		/* generic block layer message */
 	/*
 	 * for ATA/ATAPI devices. this really doesn't belong here, ide should
 	 * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
 	 * private REQ_LB opcodes to differentiate what type of request this is
 	 */
 	REQ_TYPE_ATA_TASKFILE,
 	REQ_TYPE_ATA_PC,
 };
 /*
  * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
  * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
  * SCSI cdb.
  *
  * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
  * typically to differentiate REQ_TYPE_SPECIAL requests.
  *
  */
 enum {
 	/*
 	 * just examples for now
 	 */
 	REQ_LB_OP_EJECT	= 0x40,		/* eject request */
 	REQ_LB_OP_FLUSH = 0x41,		/* flush device */
 };
 /*
  * request type modified bits. first three bits match BIO_RW* bits, important
  */
 enum rq_flag_bits {
 	__REQ_RW,		/* not set, read. set, write */
 	__REQ_FAILFAST,		/* no low level driver retries */
 	__REQ_SORTED,		/* elevator knows about this request */
 	__REQ_SOFTBARRIER,	/* may not be passed by ioscheduler */
 	__REQ_HARDBARRIER,	/* may not be passed by drive either */
 	__REQ_FUA,		/* forced unit access */
 	__REQ_NOMERGE,		/* don't touch this for merging */
 	__REQ_STARTED,		/* drive already may have started this one */
 	__REQ_DONTPREP,		/* don't call prep for this one */
 	__REQ_QUEUED,		/* uses queueing */
 	__REQ_ELVPRIV,		/* elevator private data attached */
 	__REQ_FAILED,		/* set if the request failed */
 	__REQ_QUIET,		/* don't worry about errors */
 	__REQ_PREEMPT,		/* set for "ide_preempt" requests */
 	__REQ_ORDERED_COLOR,	/* is before or after barrier */
 	__REQ_RW_SYNC,		/* request is sync (O_DIRECT) */
 	__REQ_ALLOCED,		/* request came from our alloc pool */
 	__REQ_RW_META,		/* metadata io request */
 	__REQ_COPY_USER,	/* contains copies of user pages */
 	__REQ_INTEGRITY,	/* integrity metadata has been remapped */
 	__REQ_NR_BITS,		/* stops here */
 };
 #define REQ_RW		(1 << __REQ_RW)
 #define REQ_FAILFAST	(1 << __REQ_FAILFAST)
 #define REQ_SORTED	(1 << __REQ_SORTED)
 #define REQ_SOFTBARRIER	(1 << __REQ_SOFTBARRIER)
 #define REQ_HARDBARRIER	(1 << __REQ_HARDBARRIER)
 #define REQ_FUA		(1 << __REQ_FUA)
 #define REQ_NOMERGE	(1 << __REQ_NOMERGE)
 #define REQ_STARTED	(1 << __REQ_STARTED)
 #define REQ_DONTPREP	(1 << __REQ_DONTPREP)
 #define REQ_QUEUED	(1 << __REQ_QUEUED)
 #define REQ_ELVPRIV	(1 << __REQ_ELVPRIV)
 #define REQ_FAILED	(1 << __REQ_FAILED)
 #define REQ_QUIET	(1 << __REQ_QUIET)
 #define REQ_PREEMPT	(1 << __REQ_PREEMPT)
 #define REQ_ORDERED_COLOR	(1 << __REQ_ORDERED_COLOR)
 #define REQ_RW_SYNC	(1 << __REQ_RW_SYNC)
 #define REQ_ALLOCED	(1 << __REQ_ALLOCED)
 #define REQ_RW_META	(1 << __REQ_RW_META)
 #define REQ_COPY_USER	(1 << __REQ_COPY_USER)
 #define REQ_INTEGRITY	(1 << __REQ_INTEGRITY)
 #define BLK_MAX_CDB	16
 /*
  * try to put the fields that are referenced together in the same cacheline.
  * if you modify this structure, be sure to check block/blk-core.c:rq_init()
  * as well!
  */
 struct request {
 	struct list_head queuelist;
 	struct list_head donelist;
 	struct request_queue *q;
 	unsigned int cmd_flags;
 	enum rq_cmd_type_bits cmd_type;
 	/* Maintain bio traversal state for part by part I/O submission.
 	 * hard_* are block layer internals, no driver should touch them!
 	 */
 	sector_t sector;		/* next sector to submit */
 	sector_t hard_sector;		/* next sector to complete */
 	unsigned long nr_sectors;	/* no. of sectors left to submit */
 	unsigned long hard_nr_sectors;	/* no. of sectors left to complete */
 	/* no. of sectors left to submit in the current segment */
 	unsigned int current_nr_sectors;
 	/* no. of sectors left to complete in the current segment */
 	unsigned int hard_cur_sectors;
 	struct bio *bio;
 	struct bio *biotail;
 	struct hlist_node hash;	/* merge hash */
 	/*
 	 * The rb_node is only used inside the io scheduler, requests
 	 * are pruned when moved to the dispatch queue. So let the
 	 * completion_data share space with the rb_node.
 	 */
 	union {
 		struct rb_node rb_node;	/* sort/lookup */
 		void *completion_data;
 	};
 	/*
 	 * two pointers are available for the IO schedulers, if they need
 	 * more they have to dynamically allocate it.
 	 */
 	void *elevator_private;
 	void *elevator_private2;
 	struct gendisk *rq_disk;
 	unsigned long start_time;
 	/* Number of scatter-gather DMA addr+len pairs after
 	 * physical address coalescing is performed.
 	 */
 	unsigned short nr_phys_segments;
 	/* Number of scatter-gather addr+len pairs after
 	 * physical and DMA remapping hardware coalescing is performed.
 	 * This is the number of scatter-gather entries the driver
 	 * will actually have to deal with after DMA mapping is done.
 	 */
 	unsigned short nr_hw_segments;
 	unsigned short ioprio;
 	void *special;
 	char *buffer;
 	int tag;
 	int errors;
 	int ref_count;
 	/*
 	 * when request is used as a packet command carrier
 	 */
 	unsigned short cmd_len;
 	unsigned char __cmd[BLK_MAX_CDB];
 	unsigned char *cmd;
 	unsigned int data_len;
 	unsigned int extra_len;	/* length of alignment and padding */
 	unsigned int sense_len;
 	void *data;
 	void *sense;
 	unsigned int timeout;
 	int retries;
 	/*
 	 * completion callback.
 	 */
 	rq_end_io_fn *end_io;
 	void *end_io_data;
 	/* for bidi */
 	struct request *next_rq;
 };
 /*
  * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
  * requests. Some step values could eventually be made generic.
  */
 struct request_pm_state
 {
 	/* PM state machine step value, currently driver specific */
 	int	pm_step;
 	/* requested PM state value (S1, S2, S3, S4, ...) */
 	u32	pm_state;
 	void*	data;		/* for driver use */
 };
 #include <linux/elevator.h>
 typedef void (request_fn_proc) (struct request_queue *q);
 typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
 typedef int (prep_rq_fn) (struct request_queue *, struct request *);
 typedef void (unplug_fn) (struct request_queue *);
 struct bio_vec;
 typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *);
 typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
 typedef void (softirq_done_fn)(struct request *);
 typedef int (dma_drain_needed_fn)(struct request *);
 enum blk_queue_state {
 	Queue_down,
 	Queue_up,
 };
 struct blk_queue_tag {
 	struct request **tag_index;	/* map of busy tags */
 	unsigned long *tag_map;		/* bit map of free/busy tags */
 	int busy;			/* current depth */
 	int max_depth;			/* what we will send to device */
 	int real_max_depth;		/* what the array can hold */
 	atomic_t refcnt;		/* map can be shared */
 };
 struct request_queue
 {
 	/*
 	 * Together with queue_head for cacheline sharing
 	 */
 	struct list_head	queue_head;
 	struct request		*last_merge;
 	elevator_t		*elevator;
 	/*
 	 * the queue request freelist, one for reads and one for writes
 	 */
 	struct request_list	rq;
 	request_fn_proc		*request_fn;
 	make_request_fn		*make_request_fn;
 	prep_rq_fn		*prep_rq_fn;
 	unplug_fn		*unplug_fn;
 	merge_bvec_fn		*merge_bvec_fn;
 	prepare_flush_fn	*prepare_flush_fn;
 	softirq_done_fn		*softirq_done_fn;
 	dma_drain_needed_fn	*dma_drain_needed;
 	/*
 	 * Dispatch queue sorting
 	 */
 	sector_t		end_sector;
 	struct request		*boundary_rq;
 	/*
 	 * Auto-unplugging state
 	 */
 	struct timer_list	unplug_timer;
 	int			unplug_thresh;	/* After this many requests */
 	unsigned long		unplug_delay;	/* After this many jiffies */
 	struct work_struct	unplug_work;
 	struct backing_dev_info	backing_dev_info;
 	/*
 	 * The queue owner gets to use this for whatever they like.
 	 * ll_rw_blk doesn't touch it.
 	 */
 	void			*queuedata;
 	/*
 	 * queue needs bounce pages for pages above this limit
 	 */
 	unsigned long		bounce_pfn;
 	gfp_t			bounce_gfp;
 	/*
 	 * various queue flags, see QUEUE_* below
 	 */
 	unsigned long		queue_flags;
 	/*
 	 * protects queue structures from reentrancy. ->__queue_lock should
 	 * _never_ be used directly, it is queue private. always use
 	 * ->queue_lock.
 	 */
 	spinlock_t		__queue_lock;
 	spinlock_t		*queue_lock;
 	/*
 	 * queue kobject
 	 */
 	struct kobject kobj;
 	/*
 	 * queue settings
 	 */
 	unsigned long		nr_requests;	/* Max # of requests */
 	unsigned int		nr_congestion_on;
 	unsigned int		nr_congestion_off;
 	unsigned int		nr_batching;
 	unsigned int		max_sectors;
 	unsigned int		max_hw_sectors;
 	unsigned short		max_phys_segments;
 	unsigned short		max_hw_segments;
 	unsigned short		hardsect_size;
 	unsigned int		max_segment_size;
 	unsigned long		seg_boundary_mask;
 	void			*dma_drain_buffer;
 	unsigned int		dma_drain_size;
 	unsigned int		dma_pad_mask;
 	unsigned int		dma_alignment;
 	struct blk_queue_tag	*queue_tags;
 	struct list_head	tag_busy_list;
 	unsigned int		nr_sorted;
 	unsigned int		in_flight;
 	/*
 	 * sg stuff
 	 */
 	unsigned int		sg_timeout;
 	unsigned int		sg_reserved_size;
 	int			node;
 #ifdef CONFIG_BLK_DEV_IO_TRACE
 	struct blk_trace	*blk_trace;
 #endif
 	/*
 	 * reserved for flush operations
 	 */
 	unsigned int		ordered, next_ordered, ordseq;
 	int			orderr, ordcolor;
 	struct request		pre_flush_rq, bar_rq, post_flush_rq;
 	struct request		*orig_bar_rq;
 	struct mutex		sysfs_lock;
 #if defined(CONFIG_BLK_DEV_BSG)
 	struct bsg_class_device bsg_dev;
 #endif
 };
 #define QUEUE_FLAG_CLUSTER	0	/* cluster several segments into 1 */
 #define QUEUE_FLAG_QUEUED	1	/* uses generic tag queueing */
 #define QUEUE_FLAG_STOPPED	2	/* queue is stopped */
 #define	QUEUE_FLAG_READFULL	3	/* read queue has been filled */
 #define QUEUE_FLAG_WRITEFULL	4	/* write queue has been filled */
 #define QUEUE_FLAG_DEAD		5	/* queue being torn down */
 #define QUEUE_FLAG_REENTER	6	/* Re-entrancy avoidance */
 #define QUEUE_FLAG_PLUGGED	7	/* queue is plugged */
 #define QUEUE_FLAG_ELVSWITCH	8	/* don't use elevator, just do FIFO */
 #define QUEUE_FLAG_BIDI		9	/* queue supports bidi requests */
 #define QUEUE_FLAG_NOMERGES    10	/* disable merge attempts */
 static inline int queue_is_locked(struct request_queue *q)
 {
 #ifdef CONFIG_SMP
 	spinlock_t *lock = q->queue_lock;
 	return lock && spin_is_locked(lock);
 #else
 	return 1;
 #endif
 }
 static inline void queue_flag_set_unlocked(unsigned int flag,
 					   struct request_queue *q)
 {
 	__set_bit(flag, &q->queue_flags);
 }
 static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
 {
 	WARN_ON_ONCE(!queue_is_locked(q));
 	__set_bit(flag, &q->queue_flags);
 }
 static inline void queue_flag_clear_unlocked(unsigned int flag,
 					     struct request_queue *q)
 {
 	__clear_bit(flag, &q->queue_flags);
 }
 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 {
 	WARN_ON_ONCE(!queue_is_locked(q));
 	__clear_bit(flag, &q->queue_flags);
 }
 enum {
 	/*
 	 * Hardbarrier is supported with one of the following methods.
 	 *
 	 * NONE		: hardbarrier unsupported
 	 * DRAIN	: ordering by draining is enough
 	 * DRAIN_FLUSH	: ordering by draining w/ pre and post flushes
 	 * DRAIN_FUA	: ordering by draining w/ pre flush and FUA write
 	 * TAG		: ordering by tag is enough
 	 * TAG_FLUSH	: ordering by tag w/ pre and post flushes
 	 * TAG_FUA	: ordering by tag w/ pre flush and FUA write
 	 */
 	QUEUE_ORDERED_NONE	= 0x00,
 	QUEUE_ORDERED_DRAIN	= 0x01,
 	QUEUE_ORDERED_TAG	= 0x02,
 	QUEUE_ORDERED_PREFLUSH	= 0x10,
 	QUEUE_ORDERED_POSTFLUSH	= 0x20,
 	QUEUE_ORDERED_FUA	= 0x40,
 	QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
 			QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
 	QUEUE_ORDERED_DRAIN_FUA	= QUEUE_ORDERED_DRAIN |
 			QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
 	QUEUE_ORDERED_TAG_FLUSH	= QUEUE_ORDERED_TAG |
 			QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
 	QUEUE_ORDERED_TAG_FUA	= QUEUE_ORDERED_TAG |
 			QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
 	/*
 	 * Ordered operation sequence
 	 */
 	QUEUE_ORDSEQ_STARTED	= 0x01,	/* flushing in progress */
 	QUEUE_ORDSEQ_DRAIN	= 0x02,	/* waiting for the queue to be drained */
 	QUEUE_ORDSEQ_PREFLUSH	= 0x04,	/* pre-flushing in progress */
 	QUEUE_ORDSEQ_BAR	= 0x08,	/* original barrier req in progress */
 	QUEUE_ORDSEQ_POSTFLUSH	= 0x10,	/* post-flushing in progress */
 	QUEUE_ORDSEQ_DONE	= 0x20,
 };
 #define blk_queue_plugged(q)	test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
 #define blk_queue_tagged(q)	test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
 #define blk_queue_stopped(q)	test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
 #define blk_queue_nomerges(q)	test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
 #define blk_queue_flushing(q)	((q)->ordseq)
 #define blk_fs_request(rq)	((rq)->cmd_type == REQ_TYPE_FS)
 #define blk_pc_request(rq)	((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
 #define blk_special_request(rq)	((rq)->cmd_type == REQ_TYPE_SPECIAL)
 #define blk_sense_request(rq)	((rq)->cmd_type == REQ_TYPE_SENSE)
 #define blk_noretry_request(rq)	((rq)->cmd_flags & REQ_FAILFAST)
 #define blk_rq_started(rq)	((rq)->cmd_flags & REQ_STARTED)
 #define blk_account_rq(rq)	(blk_rq_started(rq) && blk_fs_request(rq))
 #define blk_pm_suspend_request(rq)	((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
 #define blk_pm_resume_request(rq)	((rq)->cmd_type == REQ_TYPE_PM_RESUME)
 #define blk_pm_request(rq)	\
 	(blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
 #define blk_sorted_rq(rq)	((rq)->cmd_flags & REQ_SORTED)
 #define blk_barrier_rq(rq)	((rq)->cmd_flags & REQ_HARDBARRIER)
 #define blk_fua_rq(rq)		((rq)->cmd_flags & REQ_FUA)
 #define blk_bidi_rq(rq)		((rq)->next_rq != NULL)
 #define blk_empty_barrier(rq)	(blk_barrier_rq(rq) && blk_fs_request(rq) && !(rq)->hard_nr_sectors)
 /* rq->queuelist of dequeued request must be list_empty() */
 #define blk_queued_rq(rq)	(!list_empty(&(rq)->queuelist))
 #define list_entry_rq(ptr)	list_entry((ptr), struct request, queuelist)
 #define rq_data_dir(rq)		((rq)->cmd_flags & 1)
 /*
  * We regard a request as sync, if it's a READ or a SYNC write.
  */
 #define rq_is_sync(rq)		(rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC)
 #define rq_is_meta(rq)		((rq)->cmd_flags & REQ_RW_META)
 static inline int blk_queue_full(struct request_queue *q, int rw)
 {
 	if (rw == READ)
 		return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
 	return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
 }
 static inline void blk_set_queue_full(struct request_queue *q, int rw)
 {
 	if (rw == READ)
 		queue_flag_set(QUEUE_FLAG_READFULL, q);
 	else
 		queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
 }
 static inline void blk_clear_queue_full(struct request_queue *q, int rw)
 {
 	if (rw == READ)
 		queue_flag_clear(QUEUE_FLAG_READFULL, q);
 	else
 		queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
 }
 /*
  * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
  * it already be started by driver.
  */
 #define RQ_NOMERGE_FLAGS	\
 	(REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
 #define rq_mergeable(rq)	\
 	(!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
 /*
  * q->prep_rq_fn return values
  */
 #define BLKPREP_OK		0	/* serve it */
 #define BLKPREP_KILL		1	/* fatal error, kill */
 #define BLKPREP_DEFER		2	/* leave on queue */
 extern unsigned long blk_max_low_pfn, blk_max_pfn;
 /*
  * standard bounce addresses:
  *
  * BLK_BOUNCE_HIGH	: bounce all highmem pages
  * BLK_BOUNCE_ANY	: don't bounce anything
  * BLK_BOUNCE_ISA	: bounce pages above ISA DMA boundary
  */
 #if BITS_PER_LONG == 32
 #define BLK_BOUNCE_HIGH		((u64)blk_max_low_pfn << PAGE_SHIFT)
 #else
 #define BLK_BOUNCE_HIGH		-1ULL
 #endif
 #define BLK_BOUNCE_ANY		(-1ULL)
 #define BLK_BOUNCE_ISA		(ISA_DMA_THRESHOLD)
 /*
  * default timeout for SG_IO if none specified
  */
 #define BLK_DEFAULT_SG_TIMEOUT	(60 * HZ)
 #ifdef CONFIG_BOUNCE
 extern int init_emergency_isa_pool(void);
 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
 #else
 static inline int init_emergency_isa_pool(void)
 {
 	return 0;
 }
 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
 {
 }
 #endif /* CONFIG_MMU */
 struct req_iterator {
 	int i;
 	struct bio *bio;
 };
 /* This should not be used directly - use rq_for_each_segment */
 #define __rq_for_each_bio(_bio, rq)	\
 	if ((rq->bio))			\
 		for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
 #define rq_for_each_segment(bvl, _rq, _iter)			\
 	__rq_for_each_bio(_iter.bio, _rq)			\
 		bio_for_each_segment(bvl, _iter.bio, _iter.i)
 #define rq_iter_last(rq, _iter)					\
 		(_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
 extern int blk_register_queue(struct gendisk *disk);
 extern void blk_unregister_queue(struct gendisk *disk);
 extern void register_disk(struct gendisk *dev);
 extern void generic_make_request(struct bio *bio);
 extern void blk_rq_init(struct request_queue *q, struct request *rq);
 extern void blk_put_request(struct request *);
 extern void __blk_put_request(struct request_queue *, struct request *);
 extern void blk_end_sync_rq(struct request *rq, int error);
 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
 extern void blk_plug_device(struct request_queue *);
 extern int blk_remove_plug(struct request_queue *);
 extern void blk_recount_segments(struct request_queue *, struct bio *);
 extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
 			  struct gendisk *, unsigned int, void __user *);
 extern int sg_scsi_ioctl(struct file *, struct request_queue *,
 		struct gendisk *, struct scsi_ioctl_command __user *);
 /*
  * Temporary export, until SCSI gets fixed up.
  */
 extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
 			     struct bio *bio);
 /*
  * A queue has just exitted congestion.  Note this in the global counter of
  * congested queues, and wake up anyone who was waiting for requests to be
  * put back.
  */
 static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
 {
 	clear_bdi_congested(&q->backing_dev_info, rw);
 }
 /*
  * A queue has just entered congestion.  Flag that in the queue's VM-visible
  * state flags and increment the global gounter of congested queues.
  */
 static inline void blk_set_queue_congested(struct request_queue *q, int rw)
 {
 	set_bdi_congested(&q->backing_dev_info, rw);
 }
 extern void blk_start_queue(struct request_queue *q);
 extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
 extern void __blk_run_queue(struct request_queue *);
 extern void blk_run_queue(struct request_queue *);
 extern void blk_start_queueing(struct request_queue *);
 extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long);
 extern int blk_rq_unmap_user(struct bio *);
 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
 extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
 			       struct sg_iovec *, int, unsigned int);
 extern int blk_execute_rq(struct request_queue *, struct gendisk *,
 			  struct request *, int);
 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
 				  struct request *, int, rq_end_io_fn *);
-extern int blk_verify_command(unsigned char *, int);
 extern void blk_unplug(struct request_queue *q);
 static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 {
 	return bdev->bd_disk->queue;
 }
 static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
 				       struct page *page)
 {
 	if (bdi && bdi->unplug_io_fn)
 		bdi->unplug_io_fn(bdi, page);
 }
 static inline void blk_run_address_space(struct address_space *mapping)
 {
 	if (mapping)
 		blk_run_backing_dev(mapping->backing_dev_info, NULL);
 }
 /*
  * blk_end_request() and friends.
  * __blk_end_request() and end_request() must be called with
  * the request queue spinlock acquired.
  *
  * Several drivers define their own end_request and call
  * blk_end_request() for parts of the original function.
  * This prevents code duplication in drivers.
  */
 extern int blk_end_request(struct request *rq, int error,
 				unsigned int nr_bytes);
 extern int __blk_end_request(struct request *rq, int error,
 				unsigned int nr_bytes);
 extern int blk_end_bidi_request(struct request *rq, int error,
 				unsigned int nr_bytes, unsigned int bidi_bytes);
 extern void end_request(struct request *, int);
 extern void end_queued_request(struct request *, int);
 extern void end_dequeued_request(struct request *, int);
 extern int blk_end_request_callback(struct request *rq, int error,
 				unsigned int nr_bytes,
 				int (drv_callback)(struct request *));
 extern void blk_complete_request(struct request *);
 /*
  * blk_end_request() takes bytes instead of sectors as a complete size.
  * blk_rq_bytes() returns bytes left to complete in the entire request.
  * blk_rq_cur_bytes() returns bytes left to complete in the current segment.
  */
 extern unsigned int blk_rq_bytes(struct request *rq);
 extern unsigned int blk_rq_cur_bytes(struct request *rq);
 static inline void blkdev_dequeue_request(struct request *req)
 {
 	elv_dequeue_request(req->q, req);
 }
 /*
  * Access functions for manipulating queue properties
  */
 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
 					spinlock_t *lock, int node_id);
 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
 extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 extern int blk_queue_dma_drain(struct request_queue *q,
 			       dma_drain_needed_fn *dma_drain_needed,
 			       void *buf, unsigned int size);
 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
 extern void blk_queue_dma_alignment(struct request_queue *, int);
 extern void blk_queue_update_dma_alignment(struct request_queue *, int);
 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
 extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
 extern int blk_do_ordered(struct request_queue *, struct request **);
 extern unsigned blk_ordered_cur_seq(struct request_queue *);
 extern unsigned blk_ordered_req_seq(struct request *);
 extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
 extern void blk_dump_rq_flags(struct request *, char *);
 extern void generic_unplug_device(struct request_queue *);
 extern void __generic_unplug_device(struct request_queue *);
 extern long nr_blockdev_pages(void);
 int blk_get_queue(struct request_queue *);
 struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 /*
  * tag stuff
  */
 #define blk_queue_tag_depth(q)		((q)->queue_tags->busy)
 #define blk_queue_tag_queue(q)		((q)->queue_tags->busy < (q)->queue_tags->max_depth)
 #define blk_rq_tagged(rq)		((rq)->cmd_flags & REQ_QUEUED)
 extern int blk_queue_start_tag(struct request_queue *, struct request *);
 extern struct request *blk_queue_find_tag(struct request_queue *, int);
 extern void blk_queue_end_tag(struct request_queue *, struct request *);
 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
 extern void blk_queue_free_tags(struct request_queue *);
 extern int blk_queue_resize_tags(struct request_queue *, int);
 extern void blk_queue_invalidate_tags(struct request_queue *);
 extern struct blk_queue_tag *blk_init_tags(int);
 extern void blk_free_tags(struct blk_queue_tag *);
 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
 						int tag)
 {
 	if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
 		return NULL;
 	return bqt->tag_index[tag];
 }
 extern int blkdev_issue_flush(struct block_device *, sector_t *);
+/*
+* command filter functions
+*/
+extern int blk_verify_command(struct file *file, unsigned char *cmd);
+extern int blk_cmd_filter_verify_command(struct blk_scsi_cmd_filter *filter,
+					 unsigned char *cmd, mode_t *f_mode);
+extern int blk_register_filter(struct gendisk *disk);
+extern void blk_unregister_filter(struct gendisk *disk);
 #define MAX_PHYS_SEGMENTS 128
 #define MAX_HW_SEGMENTS 128
 #define SAFE_MAX_SECTORS 255
 #define BLK_DEF_MAX_SECTORS 1024
 #define MAX_SEGMENT_SIZE	65536
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 static inline int queue_hardsect_size(struct request_queue *q)
 {
 	int retval = 512;
 	if (q && q->hardsect_size)
 		retval = q->hardsect_size;
 	return retval;
 }
 static inline int bdev_hardsect_size(struct block_device *bdev)
 {
 	return queue_hardsect_size(bdev_get_queue(bdev));
 }
 static inline int queue_dma_alignment(struct request_queue *q)
 {
 	return q ? q->dma_alignment : 511;
 }
 /* assumes size > 256 */
 static inline unsigned int blksize_bits(unsigned int size)
 {
 	unsigned int bits = 8;
 	do {
 		bits++;
 		size >>= 1;
 	} while (size > 256);
 	return bits;
 }
 static inline unsigned int block_size(struct block_device *bdev)
 {
 	return bdev->bd_block_size;
 }
 typedef struct {struct page *v;} Sector;
 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
 static inline void put_dev_sector(Sector p)
 {
 	page_cache_release(p.v);
 }
 struct work_struct;
 int kblockd_schedule_work(struct work_struct *work);
 void kblockd_flush_work(struct work_struct *work);
 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
 	MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
 	MODULE_ALIAS("block-major-" __stringify(major) "-*")
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 #define INTEGRITY_FLAG_READ	1	/* verify data integrity on read */
 #define INTEGRITY_FLAG_WRITE	2	/* generate data integrity on write */
 struct blk_integrity_exchg {
 	void			*prot_buf;
 	void			*data_buf;
 	sector_t		sector;
 	unsigned int		data_size;
 	unsigned short		sector_size;
 	const char		*disk_name;
 };
 typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
 typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
 typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
 typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
 struct blk_integrity {
 	integrity_gen_fn	*generate_fn;
 	integrity_vrfy_fn	*verify_fn;
 	integrity_set_tag_fn	*set_tag_fn;
 	integrity_get_tag_fn	*get_tag_fn;
 	unsigned short		flags;
 	unsigned short		tuple_size;
 	unsigned short		sector_size;
 	unsigned short		tag_size;
 	const char		*name;
 	struct kobject		kobj;
 };
 extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
 extern void blk_integrity_unregister(struct gendisk *);
 extern int blk_integrity_compare(struct block_device *, struct block_device *);
 extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
 extern int blk_rq_count_integrity_sg(struct request *);
 static inline unsigned short blk_integrity_tuple_size(struct blk_integrity *bi)
 {
 	if (bi)
 		return bi->tuple_size;
 	return 0;
 }
 static inline struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
 {
 	return bdev->bd_disk->integrity;
 }
 static inline unsigned int bdev_get_tag_size(struct block_device *bdev)
 {
 	struct blk_integrity *bi = bdev_get_integrity(bdev);
 	if (bi)
 		return bi->tag_size;
 	return 0;
 }
 static inline int bdev_integrity_enabled(struct block_device *bdev, int rw)
 {
 	struct blk_integrity *bi = bdev_get_integrity(bdev);
 	if (bi == NULL)
 		return 0;
 	if (rw == READ && bi->verify_fn != NULL &&
 	    test_bit(INTEGRITY_FLAG_READ, &bi->flags))
 		return 1;
 	if (rw == WRITE && bi->generate_fn != NULL &&
 	    test_bit(INTEGRITY_FLAG_WRITE, &bi->flags))
 		return 1;
 	return 0;
 }
 static inline int blk_integrity_rq(struct request *rq)
 {
 	return bio_integrity(rq->bio);
 }
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 #define blk_integrity_rq(rq)			(0)
 #define blk_rq_count_integrity_sg(a)		(0)
 #define blk_rq_map_integrity_sg(a, b)		(0)
 #define bdev_get_integrity(a)			(0)
 #define bdev_get_tag_size(a)			(0)
 #define blk_integrity_compare(a, b)		(0)
 #define blk_integrity_register(a, b)		(0)
 #define blk_integrity_unregister(a)		do { } while (0);
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 #else /* CONFIG_BLOCK */
 /*
  * stubs for when the block layer is configured out
  */
 #define buffer_heads_over_limit 0
 static inline long nr_blockdev_pages(void)
 {
 	return 0;
 }
 #endif /* CONFIG_BLOCK */
 #endif

include/linux/genhd.h

Diff comments View file @ 0b07de8

 #ifndef _LINUX_GENHD_H
 #define _LINUX_GENHD_H
 /*
  * 	genhd.h Copyright (C) 1992 Drew Eckhardt
  *	Generic hard disk header file by
  * 		Drew Eckhardt
  *
  *		<drew@colorado.edu>
  */
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #ifdef CONFIG_BLOCK
 #define kobj_to_dev(k) container_of(k, struct device, kobj)
 #define dev_to_disk(device) container_of(device, struct gendisk, dev)
 #define dev_to_part(device) container_of(device, struct hd_struct, dev)
 extern struct device_type part_type;
 extern struct kobject *block_depr;
 extern struct class block_class;
 extern const struct seq_operations partitions_op;
 extern const struct seq_operations diskstats_op;
 enum {
 /* These three have identical behaviour; use the second one if DOS FDISK gets
    confused about extended/logical partitions starting past cylinder 1023. */
 	DOS_EXTENDED_PARTITION = 5,
 	LINUX_EXTENDED_PARTITION = 0x85,
 	WIN98_EXTENDED_PARTITION = 0x0f,
 	SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
 	LINUX_SWAP_PARTITION = 0x82,
 	LINUX_DATA_PARTITION = 0x83,
 	LINUX_LVM_PARTITION = 0x8e,
 	LINUX_RAID_PARTITION = 0xfd,	/* autodetect RAID partition */
 	SOLARIS_X86_PARTITION =	LINUX_SWAP_PARTITION,
 	NEW_SOLARIS_X86_PARTITION = 0xbf,
 	DM6_AUX1PARTITION = 0x51,	/* no DDO:  use xlated geom */
 	DM6_AUX3PARTITION = 0x53,	/* no DDO:  use xlated geom */
 	DM6_PARTITION =	0x54,		/* has DDO: use xlated geom & offset */
 	EZD_PARTITION =	0x55,		/* EZ-DRIVE */
 	FREEBSD_PARTITION = 0xa5,	/* FreeBSD Partition ID */
 	OPENBSD_PARTITION = 0xa6,	/* OpenBSD Partition ID */
 	NETBSD_PARTITION = 0xa9,	/* NetBSD Partition ID */
 	BSDI_PARTITION = 0xb7,		/* BSDI Partition ID */
 	MINIX_PARTITION = 0x81,		/* Minix Partition ID */
 	UNIXWARE_PARTITION = 0x63,	/* Same as GNU_HURD and SCO Unix */
 };
 #include <linux/major.h>
 #include <linux/device.h>
 #include <linux/smp.h>
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/workqueue.h>
 struct partition {
 	unsigned char boot_ind;		/* 0x80 - active */
 	unsigned char head;		/* starting head */
 	unsigned char sector;		/* starting sector */
 	unsigned char cyl;		/* starting cylinder */
 	unsigned char sys_ind;		/* What partition type */
 	unsigned char end_head;		/* end head */
 	unsigned char end_sector;	/* end sector */
 	unsigned char end_cyl;		/* end cylinder */
 	__le32 start_sect;	/* starting sector counting from 0 */
 	__le32 nr_sects;		/* nr of sectors in partition */
 } __attribute__((packed));
 struct disk_stats {
 	unsigned long sectors[2];	/* READs and WRITEs */
 	unsigned long ios[2];
 	unsigned long merges[2];
 	unsigned long ticks[2];
 	unsigned long io_ticks;
 	unsigned long time_in_queue;
 };
 struct hd_struct {
 	sector_t start_sect;
 	sector_t nr_sects;
 	struct device dev;
 	struct kobject *holder_dir;
 	int policy, partno;
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 	int make_it_fail;
 #endif
 	unsigned long stamp;
 	int in_flight;
 #ifdef	CONFIG_SMP
 	struct disk_stats *dkstats;
 #else
 	struct disk_stats dkstats;
 #endif
 };
 #define GENHD_FL_REMOVABLE			1
 #define GENHD_FL_DRIVERFS			2
 #define GENHD_FL_MEDIA_CHANGE_NOTIFY		4
 #define GENHD_FL_CD				8
 #define GENHD_FL_UP				16
 #define GENHD_FL_SUPPRESS_PARTITION_INFO	32
 #define GENHD_FL_FAIL				64
+#define BLK_SCSI_MAX_CMDS	(256)
+#define BLK_SCSI_CMD_PER_LONG	(BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
+struct blk_scsi_cmd_filter {
+	unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
+	unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
+	struct kobject kobj;
+};
 struct gendisk {
 	int major;			/* major number of driver */
 	int first_minor;
 	int minors;                     /* maximum number of minors, =1 for
                                          * disks that can't be partitioned. */
 	char disk_name[32];		/* name of major driver */
 	struct hd_struct **part;	/* [indexed by minor] */
 	struct block_device_operations *fops;
 	struct request_queue *queue;
+	struct blk_scsi_cmd_filter cmd_filter;
 	void *private_data;
 	sector_t capacity;
 	int flags;
 	struct device *driverfs_dev;  // FIXME: remove
 	struct device dev;
 	struct kobject *holder_dir;
 	struct kobject *slave_dir;
 	struct timer_rand_state *random;
 	int policy;
 	atomic_t sync_io;		/* RAID */
 	unsigned long stamp;
 	int in_flight;
 #ifdef	CONFIG_SMP
 	struct disk_stats *dkstats;
 #else
 	struct disk_stats dkstats;
 #endif
 	struct work_struct async_notify;
 #ifdef  CONFIG_BLK_DEV_INTEGRITY
 	struct blk_integrity *integrity;
 #endif
 };
 /*
  * Macros to operate on percpu disk statistics:
  *
  * The __ variants should only be called in critical sections. The full
  * variants disable/enable preemption.
  */
 static inline struct hd_struct *get_part(struct gendisk *gendiskp,
 					 sector_t sector)
 {
 	struct hd_struct *part;
 	int i;
 	for (i = 0; i < gendiskp->minors - 1; i++) {
 		part = gendiskp->part[i];
 		if (part && part->start_sect <= sector
 		    && sector < part->start_sect + part->nr_sects)
 			return part;
 	}
 	return NULL;
 }
 #ifdef	CONFIG_SMP
 #define __disk_stat_add(gendiskp, field, addnd) 	\
 	(per_cpu_ptr(gendiskp->dkstats, smp_processor_id())->field += addnd)
 #define disk_stat_read(gendiskp, field)					\
 ({									\
 	typeof(gendiskp->dkstats->field) res = 0;			\
 	int i;								\
 	for_each_possible_cpu(i)					\
 		res += per_cpu_ptr(gendiskp->dkstats, i)->field;	\
 	res;								\
 })
 static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)	{
 	int i;
 	for_each_possible_cpu(i)
 		memset(per_cpu_ptr(gendiskp->dkstats, i), value,
 				sizeof(struct disk_stats));
 }
 #define __part_stat_add(part, field, addnd)				\
 	(per_cpu_ptr(part->dkstats, smp_processor_id())->field += addnd)
 #define __all_stat_add(gendiskp, part, field, addnd, sector)	\
 ({								\
 	if (part)						\
 		__part_stat_add(part, field, addnd);		\
 	__disk_stat_add(gendiskp, field, addnd);		\
 })
 #define part_stat_read(part, field)					\
 ({									\
 	typeof(part->dkstats->field) res = 0;				\
 	int i;								\
 	for_each_possible_cpu(i)					\
 		res += per_cpu_ptr(part->dkstats, i)->field;		\
 	res;								\
 })
 static inline void part_stat_set_all(struct hd_struct *part, int value)
 {
 	int i;
 	for_each_possible_cpu(i)
 		memset(per_cpu_ptr(part->dkstats, i), value,
 				sizeof(struct disk_stats));
 }
 #else /* !CONFIG_SMP */
 #define __disk_stat_add(gendiskp, field, addnd) \
 				(gendiskp->dkstats.field += addnd)
 #define disk_stat_read(gendiskp, field)	(gendiskp->dkstats.field)
 static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)
 {
 	memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
 }
 #define __part_stat_add(part, field, addnd) \
 	(part->dkstats.field += addnd)
 #define __all_stat_add(gendiskp, part, field, addnd, sector)	\
 ({								\
 	if (part)						\
 		part->dkstats.field += addnd;			\
 	__disk_stat_add(gendiskp, field, addnd);		\
 })
 #define part_stat_read(part, field)	(part->dkstats.field)
 static inline void part_stat_set_all(struct hd_struct *part, int value)
 {
 	memset(&part->dkstats, value, sizeof(struct disk_stats));
 }
 #endif /* CONFIG_SMP */
 #define disk_stat_add(gendiskp, field, addnd)			\
 	do {							\
 		preempt_disable();				\
 		__disk_stat_add(gendiskp, field, addnd);	\
 		preempt_enable();				\
 	} while (0)
 #define __disk_stat_dec(gendiskp, field) __disk_stat_add(gendiskp, field, -1)
 #define disk_stat_dec(gendiskp, field) disk_stat_add(gendiskp, field, -1)
 #define __disk_stat_inc(gendiskp, field) __disk_stat_add(gendiskp, field, 1)
 #define disk_stat_inc(gendiskp, field) disk_stat_add(gendiskp, field, 1)
 #define __disk_stat_sub(gendiskp, field, subnd) \
 		__disk_stat_add(gendiskp, field, -subnd)
 #define disk_stat_sub(gendiskp, field, subnd) \
 		disk_stat_add(gendiskp, field, -subnd)
 #define part_stat_add(gendiskp, field, addnd)		\
 	do {						\
 		preempt_disable();			\
 		__part_stat_add(gendiskp, field, addnd);\
 		preempt_enable();			\
 	} while (0)
 #define __part_stat_dec(gendiskp, field) __part_stat_add(gendiskp, field, -1)
 #define part_stat_dec(gendiskp, field) part_stat_add(gendiskp, field, -1)
 #define __part_stat_inc(gendiskp, field) __part_stat_add(gendiskp, field, 1)
 #define part_stat_inc(gendiskp, field) part_stat_add(gendiskp, field, 1)
 #define __part_stat_sub(gendiskp, field, subnd) \
 		__part_stat_add(gendiskp, field, -subnd)
 #define part_stat_sub(gendiskp, field, subnd) \
 		part_stat_add(gendiskp, field, -subnd)
 #define all_stat_add(gendiskp, part, field, addnd, sector)	\
 	do {							\
 		preempt_disable();				\
 		__all_stat_add(gendiskp, part, field, addnd, sector);	\
 		preempt_enable();				\
 	} while (0)
 #define __all_stat_dec(gendiskp, field, sector) \
 		__all_stat_add(gendiskp, field, -1, sector)
 #define all_stat_dec(gendiskp, field, sector) \
 		all_stat_add(gendiskp, field, -1, sector)
 #define __all_stat_inc(gendiskp, part, field, sector) \
 		__all_stat_add(gendiskp, part, field, 1, sector)
 #define all_stat_inc(gendiskp, part, field, sector) \
 		all_stat_add(gendiskp, part, field, 1, sector)
 #define __all_stat_sub(gendiskp, part, field, subnd, sector) \
 		__all_stat_add(gendiskp, part, field, -subnd, sector)
 #define all_stat_sub(gendiskp, part, field, subnd, sector) \
 		all_stat_add(gendiskp, part, field, -subnd, sector)
 /* Inlines to alloc and free disk stats in struct gendisk */
 #ifdef  CONFIG_SMP
 static inline int init_disk_stats(struct gendisk *disk)
 {
 	disk->dkstats = alloc_percpu(struct disk_stats);
 	if (!disk->dkstats)
 		return 0;
 	return 1;
 }
 static inline void free_disk_stats(struct gendisk *disk)
 {
 	free_percpu(disk->dkstats);
 }
 static inline int init_part_stats(struct hd_struct *part)
 {
 	part->dkstats = alloc_percpu(struct disk_stats);
 	if (!part->dkstats)
 		return 0;
 	return 1;
 }
 static inline void free_part_stats(struct hd_struct *part)
 {
 	free_percpu(part->dkstats);
 }
 #else	/* CONFIG_SMP */
 static inline int init_disk_stats(struct gendisk *disk)
 {
 	return 1;
 }
 static inline void free_disk_stats(struct gendisk *disk)
 {
 }
 static inline int init_part_stats(struct hd_struct *part)
 {
 	return 1;
 }
 static inline void free_part_stats(struct hd_struct *part)
 {
 }
 #endif	/* CONFIG_SMP */
 /* drivers/block/ll_rw_blk.c */
 extern void disk_round_stats(struct gendisk *disk);
 extern void part_round_stats(struct hd_struct *part);
 /* drivers/block/genhd.c */
 extern int get_blkdev_list(char *, int);
 extern void add_disk(struct gendisk *disk);
 extern void del_gendisk(struct gendisk *gp);
 extern void unlink_gendisk(struct gendisk *gp);
 extern struct gendisk *get_gendisk(dev_t dev, int *part);
 extern void set_device_ro(struct block_device *bdev, int flag);
 extern void set_disk_ro(struct gendisk *disk, int flag);
 /* drivers/char/random.c */
 extern void add_disk_randomness(struct gendisk *disk);
 extern void rand_initialize_disk(struct gendisk *disk);
 static inline sector_t get_start_sect(struct block_device *bdev)
 {
 	return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
 }
 static inline sector_t get_capacity(struct gendisk *disk)
 {
 	return disk->capacity;
 }
 static inline void set_capacity(struct gendisk *disk, sector_t size)
 {
 	disk->capacity = size;
 }
 #ifdef CONFIG_SOLARIS_X86_PARTITION
 #define SOLARIS_X86_NUMSLICE	16
 #define SOLARIS_X86_VTOC_SANE	(0x600DDEEEUL)
 struct solaris_x86_slice {
 	__le16 s_tag;		/* ID tag of partition */
 	__le16 s_flag;		/* permission flags */
 	__le32 s_start;		/* start sector no of partition */
 	__le32 s_size;		/* # of blocks in partition */
 };
 struct solaris_x86_vtoc {
 	unsigned int v_bootinfo[3];	/* info needed by mboot (unsupported) */
 	__le32 v_sanity;		/* to verify vtoc sanity */
 	__le32 v_version;		/* layout version */
 	char	v_volume[8];		/* volume name */
 	__le16	v_sectorsz;		/* sector size in bytes */
 	__le16	v_nparts;		/* number of partitions */
 	unsigned int v_reserved[10];	/* free space */
 	struct solaris_x86_slice
 		v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
 	unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
 	char	v_asciilabel[128];	/* for compatibility */
 };
 #endif /* CONFIG_SOLARIS_X86_PARTITION */
 #ifdef CONFIG_BSD_DISKLABEL
 /*
  * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
  * updated by Marc Espie <Marc.Espie@openbsd.org>
  */
 /* check against BSD src/sys/sys/disklabel.h for consistency */
 #define BSD_DISKMAGIC	(0x82564557UL)	/* The disk magic number */
 #define BSD_MAXPARTITIONS	16
 #define OPENBSD_MAXPARTITIONS	16
 #define BSD_FS_UNUSED		0	/* disklabel unused partition entry ID */
 struct bsd_disklabel {
 	__le32	d_magic;		/* the magic number */
 	__s16	d_type;			/* drive type */
 	__s16	d_subtype;		/* controller/d_type specific */
 	char	d_typename[16];		/* type name, e.g. "eagle" */
 	char	d_packname[16];			/* pack identifier */
 	__u32	d_secsize;		/* # of bytes per sector */
 	__u32	d_nsectors;		/* # of data sectors per track */
 	__u32	d_ntracks;		/* # of tracks per cylinder */
 	__u32	d_ncylinders;		/* # of data cylinders per unit */
 	__u32	d_secpercyl;		/* # of data sectors per cylinder */
 	__u32	d_secperunit;		/* # of data sectors per unit */
 	__u16	d_sparespertrack;	/* # of spare sectors per track */
 	__u16	d_sparespercyl;		/* # of spare sectors per cylinder */
 	__u32	d_acylinders;		/* # of alt. cylinders per unit */
 	__u16	d_rpm;			/* rotational speed */
 	__u16	d_interleave;		/* hardware sector interleave */
 	__u16	d_trackskew;		/* sector 0 skew, per track */
 	__u16	d_cylskew;		/* sector 0 skew, per cylinder */
 	__u32	d_headswitch;		/* head switch time, usec */
 	__u32	d_trkseek;		/* track-to-track seek, usec */
 	__u32	d_flags;		/* generic flags */
 #define NDDATA 5
 	__u32	d_drivedata[NDDATA];	/* drive-type specific information */
 #define NSPARE 5
 	__u32	d_spare[NSPARE];	/* reserved for future use */
 	__le32	d_magic2;		/* the magic number (again) */
 	__le16	d_checksum;		/* xor of data incl. partitions */
 			/* filesystem and partition information: */
 	__le16	d_npartitions;		/* number of partitions in following */
 	__le32	d_bbsize;		/* size of boot area at sn0, bytes */
 	__le32	d_sbsize;		/* max size of fs superblock, bytes */
 	struct	bsd_partition {		/* the partition table */
 		__le32	p_size;		/* number of sectors in partition */
 		__le32	p_offset;	/* starting sector */
 		__le32	p_fsize;	/* filesystem basic fragment size */
 		__u8	p_fstype;	/* filesystem type, see below */
 		__u8	p_frag;		/* filesystem fragments per block */
 		__le16	p_cpg;		/* filesystem cylinders per group */
 	} d_partitions[BSD_MAXPARTITIONS];	/* actually may be more */
 };
 #endif	/* CONFIG_BSD_DISKLABEL */
 #ifdef CONFIG_UNIXWARE_DISKLABEL
 /*
  * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
  * and Krzysztof G. Baranowski <kgb@knm.org.pl>
  */
 #define UNIXWARE_DISKMAGIC     (0xCA5E600DUL)	/* The disk magic number */
 #define UNIXWARE_DISKMAGIC2    (0x600DDEEEUL)	/* The slice table magic nr */
 #define UNIXWARE_NUMSLICE      16
 #define UNIXWARE_FS_UNUSED     0		/* Unused slice entry ID */
 struct unixware_slice {
 	__le16   s_label;	/* label */
 	__le16   s_flags;	/* permission flags */
 	__le32   start_sect;	/* starting sector */
 	__le32   nr_sects;	/* number of sectors in slice */
 };
 struct unixware_disklabel {
 	__le32   d_type;               	/* drive type */
 	__le32   d_magic;                /* the magic number */
 	__le32   d_version;              /* version number */
 	char    d_serial[12];           /* serial number of the device */
 	__le32   d_ncylinders;           /* # of data cylinders per device */
 	__le32   d_ntracks;              /* # of tracks per cylinder */
 	__le32   d_nsectors;             /* # of data sectors per track */
 	__le32   d_secsize;              /* # of bytes per sector */
 	__le32   d_part_start;           /* # of first sector of this partition */
 	__le32   d_unknown1[12];         /* ? */
  	__le32	d_alt_tbl;              /* byte offset of alternate table */
  	__le32	d_alt_len;              /* byte length of alternate table */
  	__le32	d_phys_cyl;             /* # of physical cylinders per device */
  	__le32	d_phys_trk;             /* # of physical tracks per cylinder */
  	__le32	d_phys_sec;             /* # of physical sectors per track */
  	__le32	d_phys_bytes;           /* # of physical bytes per sector */
  	__le32	d_unknown2;             /* ? */
 	__le32   d_unknown3;             /* ? */
 	__le32	d_pad[8];               /* pad */
 	struct unixware_vtoc {
 		__le32	v_magic;		/* the magic number */
 		__le32	v_version;		/* version number */
 		char	v_name[8];		/* volume name */
 		__le16	v_nslices;		/* # of slices */
 		__le16	v_unknown1;		/* ? */
 		__le32	v_reserved[10];		/* reserved */
 		struct unixware_slice
 			v_slice[UNIXWARE_NUMSLICE];	/* slice headers */
 	} vtoc;
 };  /* 408 */
 #endif /* CONFIG_UNIXWARE_DISKLABEL */
 #ifdef CONFIG_MINIX_SUBPARTITION
 #   define MINIX_NR_SUBPARTITIONS  4
 #endif /* CONFIG_MINIX_SUBPARTITION */
 #define ADDPART_FLAG_NONE	0
 #define ADDPART_FLAG_RAID	1
 #define ADDPART_FLAG_WHOLEDISK	2
 extern dev_t blk_lookup_devt(const char *name, int part);
 extern char *disk_name (struct gendisk *hd, int part, char *buf);
 extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
 extern void add_partition(struct gendisk *, int, sector_t, sector_t, int);
 extern void delete_partition(struct gendisk *, int);
 extern void printk_all_partitions(void);
 extern struct gendisk *alloc_disk_node(int minors, int node_id);
 extern struct gendisk *alloc_disk(int minors);
 extern struct kobject *get_disk(struct gendisk *disk);
 extern void put_disk(struct gendisk *disk);
 extern void blk_register_region(dev_t devt, unsigned long range,
 			struct module *module,
 			struct kobject *(*probe)(dev_t, int *, void *),
 			int (*lock)(dev_t, void *),
 			void *data);
 extern void blk_unregister_region(dev_t devt, unsigned long range);
 static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
 {
 	return bdget(MKDEV(disk->major, disk->first_minor) + index);
 }
 #else /* CONFIG_BLOCK */
 static inline void printk_all_partitions(void) { }
 static inline dev_t blk_lookup_devt(const char *name, int part)
 {
 	dev_t devt = MKDEV(0, 0);
 	return devt;
 }
 #endif /* CONFIG_BLOCK */
 #endif /* _LINUX_GENHD_H */