Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 <asm/cacheflush.h>
 33 
 34 #include "scsi_tgt_priv.h"
 35 
 36 #if TGT_RING_SIZE < PAGE_SIZE
 37 #  define TGT_RING_SIZE PAGE_SIZE
 38 #endif
 39 
 40 #define TGT_RING_PAGES (TGT_RING_SIZE >> PAGE_SHIFT)
 41 #define TGT_EVENT_PER_PAGE (PAGE_SIZE / sizeof(struct tgt_event))
 42 #define TGT_MAX_EVENTS (TGT_EVENT_PER_PAGE * TGT_RING_PAGES)
 43 
 44 struct tgt_ring {
 45         u32 tr_idx;
 46         unsigned long tr_pages[TGT_RING_PAGES];
 47         spinlock_t tr_lock;
 48 };
 49 
 50 /* tx_ring : kernel->user, rx_ring : user->kernel */
 51 static struct tgt_ring tx_ring, rx_ring;
 52 static DECLARE_WAIT_QUEUE_HEAD(tgt_poll_wait);
 53 
 54 static inline void tgt_ring_idx_inc(struct tgt_ring *ring)
 55 {
 56         if (ring->tr_idx == TGT_MAX_EVENTS - 1)
 57                 ring->tr_idx = 0;
 58         else
 59                 ring->tr_idx++;
 60 }
 61 
 62 static struct tgt_event *tgt_head_event(struct tgt_ring *ring, u32 idx)
 63 {
 64         u32 pidx, off;
 65 
 66         pidx = idx / TGT_EVENT_PER_PAGE;
 67         off = idx % TGT_EVENT_PER_PAGE;
 68 
 69         return (struct tgt_event *)
 70                 (ring->tr_pages[pidx] + sizeof(struct tgt_event) * off);
 71 }
 72 
 73 static int tgt_uspace_send_event(u32 type, struct tgt_event *p)
 74 {
 75         struct tgt_event *ev;
 76         struct tgt_ring *ring = &tx_ring;
 77         unsigned long flags;
 78         int err = 0;
 79 
 80         spin_lock_irqsave(&ring->tr_lock, flags);
 81 
 82         ev = tgt_head_event(ring, ring->tr_idx);
 83         if (!ev->hdr.status)
 84                 tgt_ring_idx_inc(ring);
 85         else
 86                 err = -BUSY;
 87 
 88         spin_unlock_irqrestore(&ring->tr_lock, flags);
 89 
 90         if (err)
 91                 return err;
 92 
 93         memcpy(ev, p, sizeof(*ev));
 94         ev->hdr.type = type;
 95         mb();
 96         ev->hdr.status = 1;
 97 
 98         flush_dcache_page(virt_to_page(ev));
 99 
100         wake_up_interruptible(&tgt_poll_wait);
101 
102         return 0;
103 }
104 
105 int scsi_tgt_uspace_send_cmd(struct scsi_cmnd *cmd, u64 itn_id,
106                              struct scsi_lun *lun, u64 tag)
107 {
108         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
109         struct tgt_event ev;
110         int err;
111 
112         memset(&ev, 0, sizeof(ev));
113         ev.p.cmd_req.host_no = shost->host_no;
114         ev.p.cmd_req.itn_id = itn_id;
115         ev.p.cmd_req.data_len = scsi_bufflen(cmd);
116         memcpy(ev.p.cmd_req.scb, cmd->cmnd, sizeof(ev.p.cmd_req.scb));
117         memcpy(ev.p.cmd_req.lun, lun, sizeof(ev.p.cmd_req.lun));
118         ev.p.cmd_req.attribute = cmd->tag;
119         ev.p.cmd_req.tag = tag;
120 
121         dprintk("%p %d %u %x %llx\n", cmd, shost->host_no,
122                 ev.p.cmd_req.data_len, cmd->tag,
123                 (unsigned long long) ev.p.cmd_req.tag);
124 
125         err = tgt_uspace_send_event(TGT_KEVENT_CMD_REQ, &ev);
126         if (err)
127                 eprintk("tx buf is full, could not send\n");
128 
129         return err;
130 }
131 
132 int scsi_tgt_uspace_send_status(struct scsi_cmnd *cmd, u64 itn_id, u64 tag)
133 {
134         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
135         struct tgt_event ev;
136         int err;
137 
138         memset(&ev, 0, sizeof(ev));
139         ev.p.cmd_done.host_no = shost->host_no;
140         ev.p.cmd_done.itn_id = itn_id;
141         ev.p.cmd_done.tag = tag;
142         ev.p.cmd_done.result = cmd->result;
143 
144         dprintk("%p %d %llu %u %x\n", cmd, shost->host_no,
145                 (unsigned long long) ev.p.cmd_req.tag,
146                 ev.p.cmd_req.data_len, cmd->tag);
147 
148         err = tgt_uspace_send_event(TGT_KEVENT_CMD_DONE, &ev);
149         if (err)
150                 eprintk("tx buf is full, could not send\n");
151 
152         return err;
153 }
154 
155 int scsi_tgt_uspace_send_tsk_mgmt(int host_no, u64 itn_id, int function,
156                                   u64 tag, struct scsi_lun *scsilun, void *data)
157 {
158         struct tgt_event ev;
159         int err;
160 
161         memset(&ev, 0, sizeof(ev));
162         ev.p.tsk_mgmt_req.host_no = host_no;
163         ev.p.tsk_mgmt_req.itn_id = itn_id;
164         ev.p.tsk_mgmt_req.function = function;
165         ev.p.tsk_mgmt_req.tag = tag;
166         memcpy(ev.p.tsk_mgmt_req.lun, scsilun, sizeof(ev.p.tsk_mgmt_req.lun));
167         ev.p.tsk_mgmt_req.mid = (u64) (unsigned long) data;
168 
169         dprintk("%d %x %llx %llx\n", host_no, function, (unsigned long long) tag,
170                 (unsigned long long) ev.p.tsk_mgmt_req.mid);
171 
172         err = tgt_uspace_send_event(TGT_KEVENT_TSK_MGMT_REQ, &ev);
173         if (err)
174                 eprintk("tx buf is full, could not send\n");
175 
176         return err;
177 }
178 
179 int scsi_tgt_uspace_send_it_nexus_request(int host_no, u64 itn_id,
180                                           int function, char *initiator_id)
181 {
182         struct tgt_event ev;
183         int err;
184 
185         memset(&ev, 0, sizeof(ev));
186         ev.p.it_nexus_req.host_no = host_no;
187         ev.p.it_nexus_req.function = function;
188         ev.p.it_nexus_req.itn_id = itn_id;
189         if (initiator_id)
190                 strncpy(ev.p.it_nexus_req.initiator_id, initiator_id,
191                         sizeof(ev.p.it_nexus_req.initiator_id));
192 
193         dprintk("%d %x %llx\n", host_no, function, (unsigned long long)itn_id);
194 
195         err = tgt_uspace_send_event(TGT_KEVENT_IT_NEXUS_REQ, &ev);
196         if (err)
197                 eprintk("tx buf is full, could not send\n");
198 
199         return err;
200 }
201 
202 static int event_recv_msg(struct tgt_event *ev)
203 {
204         int err = 0;
205 
206         switch (ev->hdr.type) {
207         case TGT_UEVENT_CMD_RSP:
208                 err = scsi_tgt_kspace_exec(ev->p.cmd_rsp.host_no,
209                                            ev->p.cmd_rsp.itn_id,
210                                            ev->p.cmd_rsp.result,
211                                            ev->p.cmd_rsp.tag,
212                                            ev->p.cmd_rsp.uaddr,
213                                            ev->p.cmd_rsp.len,
214                                            ev->p.cmd_rsp.sense_uaddr,
215                                            ev->p.cmd_rsp.sense_len,
216                                            ev->p.cmd_rsp.rw);
217                 break;
218         case TGT_UEVENT_TSK_MGMT_RSP:
219                 err = scsi_tgt_kspace_tsk_mgmt(ev->p.tsk_mgmt_rsp.host_no,
220                                                ev->p.tsk_mgmt_rsp.itn_id,
221                                                ev->p.tsk_mgmt_rsp.mid,
222                                                ev->p.tsk_mgmt_rsp.result);
223                 break;
224         case TGT_UEVENT_IT_NEXUS_RSP:
225                 err = scsi_tgt_kspace_it_nexus_rsp(ev->p.it_nexus_rsp.host_no,
226                                                    ev->p.it_nexus_rsp.itn_id,
227                                                    ev->p.it_nexus_rsp.result);
228                 break;
229         default:
230                 eprintk("unknown type %d\n", ev->hdr.type);
231                 err = -EINVAL;
232         }
233 
234         return err;
235 }
236 
237 static ssize_t tgt_write(struct file *file, const char __user * buffer,
238                          size_t count, loff_t * ppos)
239 {
240         struct tgt_event *ev;
241         struct tgt_ring *ring = &rx_ring;
242 
243         while (1) {
244                 ev = tgt_head_event(ring, ring->tr_idx);
245                 /* do we need this? */
246                 flush_dcache_page(virt_to_page(ev));
247 
248                 if (!ev->hdr.status)
249                         break;
250 
251                 tgt_ring_idx_inc(ring);
252                 event_recv_msg(ev);
253                 ev->hdr.status = 0;
254         };
255 
256         return count;
257 }
258 
259 static unsigned int tgt_poll(struct file * file, struct poll_table_struct *wait)
260 {
261         struct tgt_event *ev;
262         struct tgt_ring *ring = &tx_ring;
263         unsigned long flags;
264         unsigned int mask = 0;
265         u32 idx;
266 
267         poll_wait(file, &tgt_poll_wait, wait);
268 
269         spin_lock_irqsave(&ring->tr_lock, flags);
270 
271         idx = ring->tr_idx ? ring->tr_idx - 1 : TGT_MAX_EVENTS - 1;
272         ev = tgt_head_event(ring, idx);
273         if (ev->hdr.status)
274                 mask |= POLLIN | POLLRDNORM;
275 
276         spin_unlock_irqrestore(&ring->tr_lock, flags);
277 
278         return mask;
279 }
280 
281 static int uspace_ring_map(struct vm_area_struct *vma, unsigned long addr,
282                            struct tgt_ring *ring)
283 {
284         int i, err;
285 
286         for (i = 0; i < TGT_RING_PAGES; i++) {
287                 struct page *page = virt_to_page(ring->tr_pages[i]);
288                 err = vm_insert_page(vma, addr, page);
289                 if (err)
290                         return err;
291                 addr += PAGE_SIZE;
292         }
293 
294         return 0;
295 }
296 
297 static int tgt_mmap(struct file *filp, struct vm_area_struct *vma)
298 {
299         unsigned long addr;
300         int err;
301 
302         if (vma->vm_pgoff)
303                 return -EINVAL;
304 
305         if (vma->vm_end - vma->vm_start != TGT_RING_SIZE * 2) {
306                 eprintk("mmap size must be %lu, not %lu \n",
307                         TGT_RING_SIZE * 2, vma->vm_end - vma->vm_start);
308                 return -EINVAL;
309         }
310 
311         addr = vma->vm_start;
312         err = uspace_ring_map(vma, addr, &tx_ring);
313         if (err)
314                 return err;
315         err = uspace_ring_map(vma, addr + TGT_RING_SIZE, &rx_ring);
316 
317         return err;
318 }
319 
320 static int tgt_open(struct inode *inode, struct file *file)
321 {
322         tx_ring.tr_idx = rx_ring.tr_idx = 0;
323 
324         return 0;
325 }
326 
327 static const struct file_operations tgt_fops = {
328         .owner          = THIS_MODULE,
329         .open           = tgt_open,
330         .poll           = tgt_poll,
331         .write          = tgt_write,
332         .mmap           = tgt_mmap,
333 };
334 
335 static struct miscdevice tgt_miscdev = {
336         .minor = MISC_DYNAMIC_MINOR,
337         .name = "tgt",
338         .fops = &tgt_fops,
339 };
340 
341 static void tgt_ring_exit(struct tgt_ring *ring)
342 {
343         int i;
344 
345         for (i = 0; i < TGT_RING_PAGES; i++)
346                 free_page(ring->tr_pages[i]);
347 }
348 
349 static int tgt_ring_init(struct tgt_ring *ring)
350 {
351         int i;
352 
353         spin_lock_init(&ring->tr_lock);
354 
355         for (i = 0; i < TGT_RING_PAGES; i++) {
356                 ring->tr_pages[i] = get_zeroed_page(GFP_KERNEL);
357                 if (!ring->tr_pages[i]) {
358                         eprintk("out of memory\n");
359                         return -ENOMEM;
360                 }
361         }
362 
363         return 0;
364 }
365 
366 void scsi_tgt_if_exit(void)
367 {
368         tgt_ring_exit(&tx_ring);
369         tgt_ring_exit(&rx_ring);
370         misc_deregister(&tgt_miscdev);
371 }
372 
373 int scsi_tgt_if_init(void)
374 {
375         int err;
376 
377         err = tgt_ring_init(&tx_ring);
378         if (err)
379                 return err;
380 
381         err = tgt_ring_init(&rx_ring);
382         if (err)
383                 goto free_tx_ring;
384 
385         err = misc_register(&tgt_miscdev);
386         if (err)
387                 goto free_rx_ring;
388 
389         return 0;
390 free_rx_ring:
391         tgt_ring_exit(&rx_ring);
392 free_tx_ring:
393         tgt_ring_exit(&tx_ring);
394 
395         return err;
396 }
397 
  This page was automatically generated by the LXR engine.