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