[SCSI] scsi tgt: scsi target user and kernel communication interface
[linux-2.6] / drivers / scsi / scsi_tgt_if.c
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 }