[net-next-2.6.git] / drivers / scsi / scsi_tgt_if.c

/*
 * SCSI target kernel/user interface functions
 *
 * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
 * Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
 *
 * 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 of the
 * License, or (at your option) any later version.
 *
 * 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 License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */
#include <linux/miscdevice.h>
#include <linux/file.h>
#include <net/tcp.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tgt.h>
#include <scsi/scsi_tgt_if.h>

#include "scsi_tgt_priv.h"

struct tgt_ring {
	u32 tr_idx;
	unsigned long tr_pages[TGT_RING_PAGES];
	spinlock_t tr_lock;
};

/* tx_ring : kernel->user, rx_ring : user->kernel */
static struct tgt_ring tx_ring, rx_ring;
static DECLARE_WAIT_QUEUE_HEAD(tgt_poll_wait);

static inline void tgt_ring_idx_inc(struct tgt_ring *ring)
{
	if (ring->tr_idx == TGT_MAX_EVENTS - 1)
		ring->tr_idx = 0;
	else
		ring->tr_idx++;
}

static struct tgt_event *tgt_head_event(struct tgt_ring *ring, u32 idx)
{
	u32 pidx, off;

	pidx = idx / TGT_EVENT_PER_PAGE;
	off = idx % TGT_EVENT_PER_PAGE;

	return (struct tgt_event *)
		(ring->tr_pages[pidx] + sizeof(struct tgt_event) * off);
}

static int tgt_uspace_send_event(u32 type, struct tgt_event *p)
{
	struct tgt_event *ev;
	struct tgt_ring *ring = &tx_ring;
	unsigned long flags;
	int err = 0;

	spin_lock_irqsave(&ring->tr_lock, flags);

	ev = tgt_head_event(ring, ring->tr_idx);
	if (!ev->hdr.status)
		tgt_ring_idx_inc(ring);
	else
		err = -BUSY;

	spin_unlock_irqrestore(&ring->tr_lock, flags);

	if (err)
		return err;

	memcpy(ev, p, sizeof(*ev));
	ev->hdr.type = type;
	mb();
	ev->hdr.status = 1;

	flush_dcache_page(virt_to_page(ev));

	wake_up_interruptible(&tgt_poll_wait);

	return 0;
}

int scsi_tgt_uspace_send_cmd(struct scsi_cmnd *cmd, struct scsi_lun *lun, u64 tag)
{
	struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
	struct tgt_event ev;
	int err;

	memset(&ev, 0, sizeof(ev));
	ev.p.cmd_req.host_no = shost->host_no;
	ev.p.cmd_req.data_len = cmd->request_bufflen;
	memcpy(ev.p.cmd_req.scb, cmd->cmnd, sizeof(ev.p.cmd_req.scb));
	memcpy(ev.p.cmd_req.lun, lun, sizeof(ev.p.cmd_req.lun));
	ev.p.cmd_req.attribute = cmd->tag;
	ev.p.cmd_req.tag = tag;

	dprintk("%p %d %u %x %llx\n", cmd, shost->host_no,
		ev.p.cmd_req.data_len, cmd->tag,
		(unsigned long long) ev.p.cmd_req.tag);

	err = tgt_uspace_send_event(TGT_KEVENT_CMD_REQ, &ev);
	if (err)
		eprintk("tx buf is full, could not send\n");

	return err;
}

int scsi_tgt_uspace_send_status(struct scsi_cmnd *cmd, u64 tag)
{
	struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
	struct tgt_event ev;
	int err;

	memset(&ev, 0, sizeof(ev));
	ev.p.cmd_done.host_no = shost->host_no;
	ev.p.cmd_done.tag = tag;
	ev.p.cmd_done.result = cmd->result;

	dprintk("%p %d %llu %u %x\n", cmd, shost->host_no,
		(unsigned long long) ev.p.cmd_req.tag,
		ev.p.cmd_req.data_len, cmd->tag);

	err = tgt_uspace_send_event(TGT_KEVENT_CMD_DONE, &ev);
	if (err)
		eprintk("tx buf is full, could not send\n");

	return err;
}

int scsi_tgt_uspace_send_tsk_mgmt(int host_no, int function, u64 tag,
				  struct scsi_lun *scsilun, void *data)
{
	struct tgt_event ev;
	int err;

	memset(&ev, 0, sizeof(ev));
	ev.p.tsk_mgmt_req.host_no = host_no;
	ev.p.tsk_mgmt_req.function = function;
	ev.p.tsk_mgmt_req.tag = tag;
	memcpy(ev.p.tsk_mgmt_req.lun, scsilun, sizeof(ev.p.tsk_mgmt_req.lun));
	ev.p.tsk_mgmt_req.mid = (u64) (unsigned long) data;

	dprintk("%d %x %llx %llx\n", host_no, function, (unsigned long long) tag,
		(unsigned long long) ev.p.tsk_mgmt_req.mid);

	err = tgt_uspace_send_event(TGT_KEVENT_TSK_MGMT_REQ, &ev);
	if (err)
		eprintk("tx buf is full, could not send\n");

	return err;
}

static int event_recv_msg(struct tgt_event *ev)
{
	int err = 0;

	switch (ev->hdr.type) {
	case TGT_UEVENT_CMD_RSP:
		err = scsi_tgt_kspace_exec(ev->p.cmd_rsp.host_no,
					   ev->p.cmd_rsp.tag,
					   ev->p.cmd_rsp.result,
					   ev->p.cmd_rsp.len,
					   ev->p.cmd_rsp.uaddr,
					   ev->p.cmd_rsp.rw);
		break;
	case TGT_UEVENT_TSK_MGMT_RSP:
		err = scsi_tgt_kspace_tsk_mgmt(ev->p.tsk_mgmt_rsp.host_no,
					       ev->p.tsk_mgmt_rsp.mid,
					       ev->p.tsk_mgmt_rsp.result);
		break;
	default:
		eprintk("unknown type %d\n", ev->hdr.type);
		err = -EINVAL;
	}

	return err;
}

static ssize_t tgt_write(struct file *file, const char __user * buffer,
			 size_t count, loff_t * ppos)
{
	struct tgt_event *ev;
	struct tgt_ring *ring = &rx_ring;

	while (1) {
		ev = tgt_head_event(ring, ring->tr_idx);
		/* do we need this? */
		flush_dcache_page(virt_to_page(ev));

		if (!ev->hdr.status)
			break;

		tgt_ring_idx_inc(ring);
		event_recv_msg(ev);
		ev->hdr.status = 0;
	};

	return count;
}

static unsigned int tgt_poll(struct file * file, struct poll_table_struct *wait)
{
	struct tgt_event *ev;
	struct tgt_ring *ring = &tx_ring;
	unsigned long flags;
	unsigned int mask = 0;
	u32 idx;

	poll_wait(file, &tgt_poll_wait, wait);

	spin_lock_irqsave(&ring->tr_lock, flags);

	idx = ring->tr_idx ? ring->tr_idx - 1 : TGT_MAX_EVENTS - 1;
	ev = tgt_head_event(ring, idx);
	if (ev->hdr.status)
		mask |= POLLIN | POLLRDNORM;

	spin_unlock_irqrestore(&ring->tr_lock, flags);

	return mask;
}

static int uspace_ring_map(struct vm_area_struct *vma, unsigned long addr,
			   struct tgt_ring *ring)
{
	int i, err;

	for (i = 0; i < TGT_RING_PAGES; i++) {
		struct page *page = virt_to_page(ring->tr_pages[i]);
		err = vm_insert_page(vma, addr, page);
		if (err)
			return err;
		addr += PAGE_SIZE;
	}

	return 0;
}

static int tgt_mmap(struct file *filp, struct vm_area_struct *vma)
{
	unsigned long addr;
	int err;

	if (vma->vm_pgoff)
		return -EINVAL;

	if (vma->vm_end - vma->vm_start != TGT_RING_SIZE * 2) {
		eprintk("mmap size must be %lu, not %lu \n",
			TGT_RING_SIZE * 2, vma->vm_end - vma->vm_start);
		return -EINVAL;
	}

	addr = vma->vm_start;
	err = uspace_ring_map(vma, addr, &tx_ring);
	if (err)
		return err;
	err = uspace_ring_map(vma, addr + TGT_RING_SIZE, &rx_ring);

	return err;
}

static int tgt_open(struct inode *inode, struct file *file)
{
	tx_ring.tr_idx = rx_ring.tr_idx = 0;

	return 0;
}

static struct file_operations tgt_fops = {
	.owner		= THIS_MODULE,
	.open		= tgt_open,
	.poll		= tgt_poll,
	.write		= tgt_write,
	.mmap		= tgt_mmap,
};

static struct miscdevice tgt_miscdev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "tgt",
	.fops = &tgt_fops,
};

static void tgt_ring_exit(struct tgt_ring *ring)
{
	int i;

	for (i = 0; i < TGT_RING_PAGES; i++)
		free_page(ring->tr_pages[i]);
}

static int tgt_ring_init(struct tgt_ring *ring)
{
	int i;

	spin_lock_init(&ring->tr_lock);

	for (i = 0; i < TGT_RING_PAGES; i++) {
		ring->tr_pages[i] = get_zeroed_page(GFP_KERNEL);
		if (!ring->tr_pages[i]) {
			eprintk("out of memory\n");
			return -ENOMEM;
		}
	}

	return 0;
}

void scsi_tgt_if_exit(void)
{
	tgt_ring_exit(&tx_ring);
	tgt_ring_exit(&rx_ring);
	misc_deregister(&tgt_miscdev);
}

int scsi_tgt_if_init(void)
{
	int err;

	err = tgt_ring_init(&tx_ring);
	if (err)
		return err;

	err = tgt_ring_init(&rx_ring);
	if (err)
		goto free_tx_ring;

	err = misc_register(&tgt_miscdev);
	if (err)
		goto free_rx_ring;

	return 0;
free_rx_ring:
	tgt_ring_exit(&rx_ring);
free_tx_ring:
	tgt_ring_exit(&tx_ring);

	return err;
}
Commit	Line	Data
97f78759 FT	1	/*
	2	* SCSI target kernel/user interface functions
	3	*
	4	* Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
	5	* Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of the
	10	* License, or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	20	* 02110-1301 USA
	21	*/
	22	#include <linux/miscdevice.h>
	23	#include <linux/file.h>
	24	#include <net/tcp.h>
	25	#include <scsi/scsi.h>
	26	#include <scsi/scsi_cmnd.h>
	27	#include <scsi/scsi_device.h>
	28	#include <scsi/scsi_host.h>
	29	#include <scsi/scsi_tgt.h>
	30	#include <scsi/scsi_tgt_if.h>
	31
	32	#include "scsi_tgt_priv.h"
	33
	34	struct tgt_ring {
	35	u32 tr_idx;
	36	unsigned long tr_pages[TGT_RING_PAGES];
	37	spinlock_t tr_lock;
	38	};
	39
	40	/* tx_ring : kernel->user, rx_ring : user->kernel */
	41	static struct tgt_ring tx_ring, rx_ring;
	42	static DECLARE_WAIT_QUEUE_HEAD(tgt_poll_wait);
	43
	44	static inline void tgt_ring_idx_inc(struct tgt_ring *ring)
	45	{
	46	if (ring->tr_idx == TGT_MAX_EVENTS - 1)
	47	ring->tr_idx = 0;
	48	else
	49	ring->tr_idx++;
	50	}
	51
	52	static struct tgt_event tgt_head_event(struct tgt_ring ring, u32 idx)
	53	{
	54	u32 pidx, off;
	55
	56	pidx = idx / TGT_EVENT_PER_PAGE;
	57	off = idx % TGT_EVENT_PER_PAGE;
	58
	59	return (struct tgt_event *)
	60	(ring->tr_pages[pidx] + sizeof(struct tgt_event) * off);
	61	}
	62
	63	static int tgt_uspace_send_event(u32 type, struct tgt_event *p)
	64	{
65	struct tgt_event *ev;
66	struct tgt_ring *ring = &tx_ring;
67	unsigned long flags;
68	int err = 0;
69
70	spin_lock_irqsave(&ring->tr_lock, flags);
71
72	ev = tgt_head_event(ring, ring->tr_idx);
73	if (!ev->hdr.status)
74	tgt_ring_idx_inc(ring);
75	else
76	err = -BUSY;
77
78	spin_unlock_irqrestore(&ring->tr_lock, flags);
79
80	if (err)
81	return err;
82
83	memcpy(ev, p, sizeof(*ev));
84	ev->hdr.type = type;
85	mb();
86	ev->hdr.status = 1;
87
88	flush_dcache_page(virt_to_page(ev));
89
90	wake_up_interruptible(&tgt_poll_wait);
91
92	return 0;
93	}
94
95	int scsi_tgt_uspace_send_cmd(struct scsi_cmnd cmd, struct scsi_lun lun, u64 tag)
96	{
97	struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
98	struct tgt_event ev;
99	int err;
100
101	memset(&ev, 0, sizeof(ev));
102	ev.p.cmd_req.host_no = shost->host_no;
103	ev.p.cmd_req.data_len = cmd->request_bufflen;
104	memcpy(ev.p.cmd_req.scb, cmd->cmnd, sizeof(ev.p.cmd_req.scb));
105	memcpy(ev.p.cmd_req.lun, lun, sizeof(ev.p.cmd_req.lun));
106	ev.p.cmd_req.attribute = cmd->tag;
107	ev.p.cmd_req.tag = tag;
108
109	dprintk("%p %d %u %x %llx\n", cmd, shost->host_no,
110	ev.p.cmd_req.data_len, cmd->tag,
111	(unsigned long long) ev.p.cmd_req.tag);
112
113	err = tgt_uspace_send_event(TGT_KEVENT_CMD_REQ, &ev);
114	if (err)
115	eprintk("tx buf is full, could not send\n");
116
117	return err;
118	}
119
120	int scsi_tgt_uspace_send_status(struct scsi_cmnd *cmd, u64 tag)
121	{
122	struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
123	struct tgt_event ev;
124	int err;
125
126	memset(&ev, 0, sizeof(ev));
127	ev.p.cmd_done.host_no = shost->host_no;
128	ev.p.cmd_done.tag = tag;
129	ev.p.cmd_done.result = cmd->result;
130
131	dprintk("%p %d %llu %u %x\n", cmd, shost->host_no,
132	(unsigned long long) ev.p.cmd_req.tag,
133	ev.p.cmd_req.data_len, cmd->tag);
134
135	err = tgt_uspace_send_event(TGT_KEVENT_CMD_DONE, &ev);
136	if (err)
137	eprintk("tx buf is full, could not send\n");
138
139	return err;
140	}
141
142	int scsi_tgt_uspace_send_tsk_mgmt(int host_no, int function, u64 tag,
143	struct scsi_lun scsilun, void data)
144	{
145	struct tgt_event ev;
146	int err;
147
148	memset(&ev, 0, sizeof(ev));
149	ev.p.tsk_mgmt_req.host_no = host_no;
150	ev.p.tsk_mgmt_req.function = function;
151	ev.p.tsk_mgmt_req.tag = tag;
152	memcpy(ev.p.tsk_mgmt_req.lun, scsilun, sizeof(ev.p.tsk_mgmt_req.lun));
153	ev.p.tsk_mgmt_req.mid = (u64) (unsigned long) data;
154
155	dprintk("%d %x %llx %llx\n", host_no, function, (unsigned long long) tag,
156	(unsigned long long) ev.p.tsk_mgmt_req.mid);
157
158	err = tgt_uspace_send_event(TGT_KEVENT_TSK_MGMT_REQ, &ev);
159	if (err)
160	eprintk("tx buf is full, could not send\n");
161
162	return err;
163	}
164
165	static int event_recv_msg(struct tgt_event *ev)
166	{
167	int err = 0;
168
169	switch (ev->hdr.type) {
170	case TGT_UEVENT_CMD_RSP:
171	err = scsi_tgt_kspace_exec(ev->p.cmd_rsp.host_no,
172	ev->p.cmd_rsp.tag,
173	ev->p.cmd_rsp.result,
174	ev->p.cmd_rsp.len,
175	ev->p.cmd_rsp.uaddr,
176	ev->p.cmd_rsp.rw);
177	break;
178	case TGT_UEVENT_TSK_MGMT_RSP:
179	err = scsi_tgt_kspace_tsk_mgmt(ev->p.tsk_mgmt_rsp.host_no,
180	ev->p.tsk_mgmt_rsp.mid,
181	ev->p.tsk_mgmt_rsp.result);
182	break;
183	default:
184	eprintk("unknown type %d\n", ev->hdr.type);
185	err = -EINVAL;
186	}
187
188	return err;
189	}
190
191	static ssize_t tgt_write(struct file file, const char __user buffer,
192	size_t count, loff_t * ppos)
193	{
194	struct tgt_event *ev;
195	struct tgt_ring *ring = &rx_ring;
196
197	while (1) {
198	ev = tgt_head_event(ring, ring->tr_idx);
199	/* do we need this? */
200	flush_dcache_page(virt_to_page(ev));
201
202	if (!ev->hdr.status)
203	break;
204
205	tgt_ring_idx_inc(ring);
206	event_recv_msg(ev);
207	ev->hdr.status = 0;
208	};
209
210	return count;
211	}
212
213	static unsigned int tgt_poll(struct file * file, struct poll_table_struct *wait)
214	{
215	struct tgt_event *ev;
216	struct tgt_ring *ring = &tx_ring;
217	unsigned long flags;
218	unsigned int mask = 0;
219	u32 idx;
220
221	poll_wait(file, &tgt_poll_wait, wait);
222
223	spin_lock_irqsave(&ring->tr_lock, flags);
224
225	idx = ring->tr_idx ? ring->tr_idx - 1 : TGT_MAX_EVENTS - 1;
226	ev = tgt_head_event(ring, idx);
227	if (ev->hdr.status)
228	mask \|= POLLIN \| POLLRDNORM;
229
230	spin_unlock_irqrestore(&ring->tr_lock, flags);
231
232	return mask;
233	}
234
235	static int uspace_ring_map(struct vm_area_struct *vma, unsigned long addr,
236	struct tgt_ring *ring)
237	{
238	int i, err;
239
240	for (i = 0; i < TGT_RING_PAGES; i++) {
241	struct page *page = virt_to_page(ring->tr_pages[i]);
242	err = vm_insert_page(vma, addr, page);
243	if (err)
244	return err;
245	addr += PAGE_SIZE;
246	}
247
248	return 0;
249	}
250
251	static int tgt_mmap(struct file filp, struct vm_area_struct vma)
252	{
253	unsigned long addr;
254	int err;
255
256	if (vma->vm_pgoff)
257	return -EINVAL;
258
259	if (vma->vm_end - vma->vm_start != TGT_RING_SIZE * 2) {
260	eprintk("mmap size must be %lu, not %lu \n",
261	TGT_RING_SIZE * 2, vma->vm_end - vma->vm_start);
262	return -EINVAL;
263	}
264
265	addr = vma->vm_start;
266	err = uspace_ring_map(vma, addr, &tx_ring);
267	if (err)
268	return err;
269	err = uspace_ring_map(vma, addr + TGT_RING_SIZE, &rx_ring);
270
271	return err;
272	}
273
274	static int tgt_open(struct inode inode, struct file file)
275	{
276	tx_ring.tr_idx = rx_ring.tr_idx = 0;
277
278	return 0;
279	}
280
281	static struct file_operations tgt_fops = {
282	.owner = THIS_MODULE,
283	.open = tgt_open,
284	.poll = tgt_poll,
285	.write = tgt_write,
286	.mmap = tgt_mmap,
287	};
288
289	static struct miscdevice tgt_miscdev = {
290	.minor = MISC_DYNAMIC_MINOR,
291	.name = "tgt",
292	.fops = &tgt_fops,
293	};
294
295	static void tgt_ring_exit(struct tgt_ring *ring)
296	{
297	int i;
298
299	for (i = 0; i < TGT_RING_PAGES; i++)
300	free_page(ring->tr_pages[i]);
301	}
302
303	static int tgt_ring_init(struct tgt_ring *ring)
304	{
305	int i;
306
307	spin_lock_init(&ring->tr_lock);
308
309	for (i = 0; i < TGT_RING_PAGES; i++) {
310	ring->tr_pages[i] = get_zeroed_page(GFP_KERNEL);
311	if (!ring->tr_pages[i]) {
312	eprintk("out of memory\n");
313	return -ENOMEM;
314	}
315	}
316
317	return 0;
318	}
319
320	void scsi_tgt_if_exit(void)
321	{
322	tgt_ring_exit(&tx_ring);
323	tgt_ring_exit(&rx_ring);
324	misc_deregister(&tgt_miscdev);
325	}
326
327	int scsi_tgt_if_init(void)
328	{
329	int err;
330
331	err = tgt_ring_init(&tx_ring);
332	if (err)
333	return err;
334
335	err = tgt_ring_init(&rx_ring);
336	if (err)
337	goto free_tx_ring;
338
339	err = misc_register(&tgt_miscdev);
340	if (err)
341	goto free_rx_ring;
342
343	return 0;
344	free_rx_ring:
345	tgt_ring_exit(&rx_ring);
346	free_tx_ring:
347	tgt_ring_exit(&tx_ring);
348
349	return err;
350	}