drivers/scsi/scsi_tgt_lib.c

   1 /*
   2  * SCSI target lib functions
   3  *
   4  * Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
   5  * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
   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/blkdev.h>
  23 #include <linux/hash.h>
  24 #include <linux/module.h>
  25 #include <linux/pagemap.h>
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_cmnd.h>
  28 #include <scsi/scsi_device.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_tgt.h>
  31
  32 #include "scsi_tgt_priv.h"
  33
  34 static struct workqueue_struct *scsi_tgtd;
  35 static struct kmem_cache *scsi_tgt_cmd_cache;
  36
  37 /*
  38  * TODO: this struct will be killed when the block layer supports large bios
  39  * and James's work struct code is in
  40  */
  41 struct scsi_tgt_cmd {
  42         /* TODO replace work with James b's code */
  43         struct work_struct work;
  44         /* TODO fix limits of some drivers */
  45         struct bio *bio;
  46
  47         struct list_head hash_list;
  48         struct request *rq;
  49         u64 tag;
  50 };
  51
  52 #define TGT_HASH_ORDER  4
  53 #define cmd_hashfn(tag) hash_long((unsigned long) (tag), TGT_HASH_ORDER)
  54
  55 struct scsi_tgt_queuedata {
  56         struct Scsi_Host *shost;
  57         struct list_head cmd_hash[1 << TGT_HASH_ORDER];
  58         spinlock_t cmd_hash_lock;
  59 };
  60
  61 /*
  62  * Function:    scsi_host_get_command()
  63  *
  64  * Purpose:     Allocate and setup a scsi command block and blk request
  65  *
  66  * Arguments:   shost   - scsi host
  67  *              data_dir - dma data dir
  68  *              gfp_mask- allocator flags
  69  *
  70  * Returns:     The allocated scsi command structure.
  71  *
  72  * This should be called by target LLDs to get a command.
  73  */
  74 struct scsi_cmnd *scsi_host_get_command(struct Scsi_Host *shost,
  75                                         enum dma_data_direction data_dir,
  76                                         gfp_t gfp_mask)
  77 {
  78         int write = (data_dir == DMA_TO_DEVICE);
  79         struct request *rq;
  80         struct scsi_cmnd *cmd;
  81         struct scsi_tgt_cmd *tcmd;
  82
  83         /* Bail if we can't get a reference to the device */
  84         if (!get_device(&shost->shost_gendev))
  85                 return NULL;
  86
  87         tcmd = kmem_cache_alloc(scsi_tgt_cmd_cache, GFP_ATOMIC);
  88         if (!tcmd)
  89                 goto put_dev;
  90
  91         /*
  92          * The blk helpers are used to the READ/WRITE requests
  93          * transfering data from a initiator point of view. Since
  94          * we are in target mode we want the opposite.
  95          */
  96         rq = blk_get_request(shost->uspace_req_q, !write, gfp_mask);
  97         if (!rq)
  98                 goto free_tcmd;
  99
 100         cmd = __scsi_get_command(shost, gfp_mask);
 101         if (!cmd)
 102                 goto release_rq;
 103
 104         memset(cmd, 0, sizeof(*cmd));
 105         cmd->sc_data_direction = data_dir;
 106         cmd->jiffies_at_alloc = jiffies;
 107         cmd->request = rq;
 108
 109         rq->special = cmd;
 110         rq->cmd_type = REQ_TYPE_SPECIAL;
 111         rq->cmd_flags |= REQ_TYPE_BLOCK_PC;
 112         rq->end_io_data = tcmd;
 113
 114         tcmd->rq = rq;
 115
 116         return cmd;
 117
 118 release_rq:
 119         blk_put_request(rq);
 120 free_tcmd:
 121         kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
 122 put_dev:
 123         put_device(&shost->shost_gendev);
 124         return NULL;
 125
 126 }
 127 EXPORT_SYMBOL_GPL(scsi_host_get_command);
 128
 129 /*
 130  * Function:    scsi_host_put_command()
 131  *
 132  * Purpose:     Free a scsi command block
 133  *
 134  * Arguments:   shost   - scsi host
 135  *              cmd     - command block to free
 136  *
 137  * Returns:     Nothing.
 138  *
 139  * Notes:       The command must not belong to any lists.
 140  */
 141 void scsi_host_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 142 {
 143         struct request_queue *q = shost->uspace_req_q;
 144         struct request *rq = cmd->request;
 145         struct scsi_tgt_cmd *tcmd = rq->end_io_data;
 146         unsigned long flags;
 147
 148         kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
 149
 150         spin_lock_irqsave(q->queue_lock, flags);
 151         __blk_put_request(q, rq);
 152         spin_unlock_irqrestore(q->queue_lock, flags);
 153
 154         __scsi_put_command(shost, cmd, &shost->shost_gendev);
 155 }
 156 EXPORT_SYMBOL_GPL(scsi_host_put_command);
 157
 158 static void cmd_hashlist_del(struct scsi_cmnd *cmd)
 159 {
 160         struct request_queue *q = cmd->request->q;
 161         struct scsi_tgt_queuedata *qdata = q->queuedata;
 162         unsigned long flags;
 163         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
 164
 165         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
 166         list_del(&tcmd->hash_list);
 167         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
 168 }
 169
 170 static void scsi_unmap_user_pages(struct scsi_tgt_cmd *tcmd)
 171 {
 172         blk_rq_unmap_user(tcmd->bio);
 173 }
 174
 175 static void scsi_tgt_cmd_destroy(struct work_struct *work)
 176 {
 177         struct scsi_tgt_cmd *tcmd =
 178                 container_of(work, struct scsi_tgt_cmd, work);
 179         struct scsi_cmnd *cmd = tcmd->rq->special;
 180
 181         dprintk("cmd %p %d %lu\n", cmd, cmd->sc_data_direction,
 182                 rq_data_dir(cmd->request));
 183         scsi_unmap_user_pages(tcmd);
 184         scsi_host_put_command(scsi_tgt_cmd_to_host(cmd), cmd);
 185 }
 186
 187 static void init_scsi_tgt_cmd(struct request *rq, struct scsi_tgt_cmd *tcmd,
 188                               u64 tag)
 189 {
 190         struct scsi_tgt_queuedata *qdata = rq->q->queuedata;
 191         unsigned long flags;
 192         struct list_head *head;
 193
 194         tcmd->tag = tag;
 195         tcmd->bio = NULL;
 196         INIT_WORK(&tcmd->work, scsi_tgt_cmd_destroy);
 197         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
 198         head = &qdata->cmd_hash[cmd_hashfn(tag)];
 199         list_add(&tcmd->hash_list, head);
 200         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
 201 }
 202
 203 /*
 204  * scsi_tgt_alloc_queue - setup queue used for message passing
 205  * shost: scsi host
 206  *
 207  * This should be called by the LLD after host allocation.
 208  * And will be released when the host is released.
 209  */
 210 int scsi_tgt_alloc_queue(struct Scsi_Host *shost)
 211 {
 212         struct scsi_tgt_queuedata *queuedata;
 213         struct request_queue *q;
 214         int err, i;
 215
 216         /*
 217          * Do we need to send a netlink event or should uspace
 218          * just respond to the hotplug event?
 219          */
 220         q = __scsi_alloc_queue(shost, NULL);
 221         if (!q)
 222                 return -ENOMEM;
 223
 224         queuedata = kzalloc(sizeof(*queuedata), GFP_KERNEL);
 225         if (!queuedata) {
 226                 err = -ENOMEM;
 227                 goto cleanup_queue;
 228         }
 229         queuedata->shost = shost;
 230         q->queuedata = queuedata;
 231
 232         /*
 233          * this is a silly hack. We should probably just queue as many
 234          * command as is recvd to userspace. uspace can then make
 235          * sure we do not overload the HBA
 236          */
 237         q->nr_requests = shost->hostt->can_queue;
 238         /*
 239          * We currently only support software LLDs so this does
 240          * not matter for now. Do we need this for the cards we support?
 241          * If so we should make it a host template value.
 242          */
 243         blk_queue_dma_alignment(q, 0);
 244         shost->uspace_req_q = q;
 245
 246         for (i = 0; i < ARRAY_SIZE(queuedata->cmd_hash); i++)
 247                 INIT_LIST_HEAD(&queuedata->cmd_hash[i]);
 248         spin_lock_init(&queuedata->cmd_hash_lock);
 249
 250         return 0;
 251
 252 cleanup_queue:
 253         blk_cleanup_queue(q);
 254         return err;
 255 }
 256 EXPORT_SYMBOL_GPL(scsi_tgt_alloc_queue);
 257
 258 void scsi_tgt_free_queue(struct Scsi_Host *shost)
 259 {
 260         int i;
 261         unsigned long flags;
 262         struct request_queue *q = shost->uspace_req_q;
 263         struct scsi_cmnd *cmd;
 264         struct scsi_tgt_queuedata *qdata = q->queuedata;
 265         struct scsi_tgt_cmd *tcmd, *n;
 266         LIST_HEAD(cmds);
 267
 268         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
 269
 270         for (i = 0; i < ARRAY_SIZE(qdata->cmd_hash); i++) {
 271                 list_for_each_entry_safe(tcmd, n, &qdata->cmd_hash[i],
 272                                          hash_list) {
 273                         list_del(&tcmd->hash_list);
 274                         list_add(&tcmd->hash_list, &cmds);
 275                 }
 276         }
 277
 278         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
 279
 280         while (!list_empty(&cmds)) {
 281                 tcmd = list_entry(cmds.next, struct scsi_tgt_cmd, hash_list);
 282                 list_del(&tcmd->hash_list);
 283                 cmd = tcmd->rq->special;
 284
 285                 shost->hostt->eh_abort_handler(cmd);
 286                 scsi_tgt_cmd_destroy(&tcmd->work);
 287         }
 288 }
 289 EXPORT_SYMBOL_GPL(scsi_tgt_free_queue);
 290
 291 struct Scsi_Host *scsi_tgt_cmd_to_host(struct scsi_cmnd *cmd)
 292 {
 293         struct scsi_tgt_queuedata *queue = cmd->request->q->queuedata;
 294         return queue->shost;
 295 }
 296 EXPORT_SYMBOL_GPL(scsi_tgt_cmd_to_host);
 297
 298 /*
 299  * scsi_tgt_queue_command - queue command for userspace processing
 300  * @cmd:        scsi command
 301  * @scsilun:    scsi lun
 302  * @tag:        unique value to identify this command for tmf
 303  */
 304 int scsi_tgt_queue_command(struct scsi_cmnd *cmd, struct scsi_lun *scsilun,
 305                            u64 tag)
 306 {
 307         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
 308         int err;
 309
 310         init_scsi_tgt_cmd(cmd->request, tcmd, tag);
 311         err = scsi_tgt_uspace_send_cmd(cmd, scsilun, tag);
 312         if (err)
 313                 cmd_hashlist_del(cmd);
 314
 315         return err;
 316 }
 317 EXPORT_SYMBOL_GPL(scsi_tgt_queue_command);
 318
 319 /*
 320  * This is run from a interrpt handler normally and the unmap
 321  * needs process context so we must queue
 322  */
 323 static void scsi_tgt_cmd_done(struct scsi_cmnd *cmd)
 324 {
 325         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
 326
 327         dprintk("cmd %p %lu\n", cmd, rq_data_dir(cmd->request));
 328
 329         scsi_tgt_uspace_send_status(cmd, tcmd->tag);
 330
 331         if (cmd->request_buffer)
 332                 scsi_free_sgtable(cmd->request_buffer, cmd->sglist_len);
 333
 334         queue_work(scsi_tgtd, &tcmd->work);
 335 }
 336
 337 static int scsi_tgt_transfer_response(struct scsi_cmnd *cmd)
 338 {
 339         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
 340         int err;
 341
 342         dprintk("cmd %p %lu\n", cmd, rq_data_dir(cmd->request));
 343
 344         err = shost->hostt->transfer_response(cmd, scsi_tgt_cmd_done);
 345         switch (err) {
 346         case SCSI_MLQUEUE_HOST_BUSY:
 347         case SCSI_MLQUEUE_DEVICE_BUSY:
 348                 return -EAGAIN;
 349         }
 350         return 0;
 351 }
 352
 353 static int scsi_tgt_init_cmd(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 354 {
 355         struct request *rq = cmd->request;
 356         int count;
 357
 358         cmd->use_sg = rq->nr_phys_segments;
 359         cmd->request_buffer = scsi_alloc_sgtable(cmd, gfp_mask);
 360         if (!cmd->request_buffer)
 361                 return -ENOMEM;
 362
 363         cmd->request_bufflen = rq->data_len;
 364
 365         dprintk("cmd %p cnt %d %lu\n", cmd, cmd->use_sg, rq_data_dir(rq));
 366         count = blk_rq_map_sg(rq->q, rq, cmd->request_buffer);
 367         if (likely(count <= cmd->use_sg)) {
 368                 cmd->use_sg = count;
 369                 return 0;
 370         }
 371
 372         eprintk("cmd %p cnt %d\n", cmd, cmd->use_sg);
 373         scsi_free_sgtable(cmd->request_buffer, cmd->sglist_len);
 374         return -EINVAL;
 375 }
 376
 377 /* TODO: test this crap and replace bio_map_user with new interface maybe */
 378 static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
 379                                unsigned long uaddr, unsigned int len, int rw)
 380 {
 381         struct request_queue *q = cmd->request->q;
 382         struct request *rq = cmd->request;
 383         int err;
 384
 385         dprintk("%lx %u\n", uaddr, len);
 386         err = blk_rq_map_user(q, rq, (void *)uaddr, len);
 387         if (err) {
 388                 /*
 389                  * TODO: need to fixup sg_tablesize, max_segment_size,
 390                  * max_sectors, etc for modern HW and software drivers
 391                  * where this value is bogus.
 392                  *
 393                  * TODO2: we can alloc a reserve buffer of max size
 394                  * we can handle and do the slow copy path for really large
 395                  * IO.
 396                  */
 397                 eprintk("Could not handle request of size %u.\n", len);
 398                 return err;
 399         }
 400
 401         tcmd->bio = rq->bio;
 402         err = scsi_tgt_init_cmd(cmd, GFP_KERNEL);
 403         if (err)
 404                 goto unmap_rq;
 405
 406         return 0;
 407
 408 unmap_rq:
 409         scsi_unmap_user_pages(tcmd);
 410         return err;
 411 }
 412
 413 static int scsi_tgt_copy_sense(struct scsi_cmnd *cmd, unsigned long uaddr,
 414                                 unsigned len)
 415 {
 416         char __user *p = (char __user *) uaddr;
 417
 418         if (copy_from_user(cmd->sense_buffer, p,
 419                            min_t(unsigned, SCSI_SENSE_BUFFERSIZE, len))) {
 420                 printk(KERN_ERR "Could not copy the sense buffer\n");
 421                 return -EIO;
 422         }
 423         return 0;
 424 }
 425
 426 static int scsi_tgt_abort_cmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 427 {
 428         struct scsi_tgt_cmd *tcmd;
 429         int err;
 430
 431         err = shost->hostt->eh_abort_handler(cmd);
 432         if (err)
 433                 eprintk("fail to abort %p\n", cmd);
 434
 435         tcmd = cmd->request->end_io_data;
 436         scsi_tgt_cmd_destroy(&tcmd->work);
 437         return err;
 438 }
 439
 440 static struct request *tgt_cmd_hash_lookup(struct request_queue *q, u64 tag)
 441 {
 442         struct scsi_tgt_queuedata *qdata = q->queuedata;
 443         struct request *rq = NULL;
 444         struct list_head *head;
 445         struct scsi_tgt_cmd *tcmd;
 446         unsigned long flags;
 447
 448         head = &qdata->cmd_hash[cmd_hashfn(tag)];
 449         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
 450         list_for_each_entry(tcmd, head, hash_list) {
 451                 if (tcmd->tag == tag) {
 452                         rq = tcmd->rq;
 453                         list_del(&tcmd->hash_list);
 454                         break;
 455                 }
 456         }
 457         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
 458
 459         return rq;
 460 }
 461
 462 int scsi_tgt_kspace_exec(int host_no, int result, u64 tag,
 463                          unsigned long uaddr, u32 len, unsigned long sense_uaddr,
 464                          u32 sense_len, u8 rw)
 465 {
 466         struct Scsi_Host *shost;
 467         struct scsi_cmnd *cmd;
 468         struct request *rq;
 469         struct scsi_tgt_cmd *tcmd;
 470         int err = 0;
 471
 472         dprintk("%d %llu %d %u %lx %u\n", host_no, (unsigned long long) tag,
 473                 result, len, uaddr, rw);
 474
 475         /* TODO: replace with a O(1) alg */
 476         shost = scsi_host_lookup(host_no);
 477         if (IS_ERR(shost)) {
 478                 printk(KERN_ERR "Could not find host no %d\n", host_no);
 479                 return -EINVAL;
 480         }
 481
 482         if (!shost->uspace_req_q) {
 483                 printk(KERN_ERR "Not target scsi host %d\n", host_no);
 484                 goto done;
 485         }
 486
 487         rq = tgt_cmd_hash_lookup(shost->uspace_req_q, tag);
 488         if (!rq) {
 489                 printk(KERN_ERR "Could not find tag %llu\n",
 490                        (unsigned long long) tag);
 491                 err = -EINVAL;
 492                 goto done;
 493         }
 494         cmd = rq->special;
 495
 496         dprintk("cmd %p scb %x result %d len %d bufflen %u %lu %x\n",
 497                 cmd, cmd->cmnd[0], result, len, cmd->request_bufflen,
 498                 rq_data_dir(rq), cmd->cmnd[0]);
 499
 500         if (result == TASK_ABORTED) {
 501                 scsi_tgt_abort_cmd(shost, cmd);
 502                 goto done;
 503         }
 504         /*
 505          * store the userspace values here, the working values are
 506          * in the request_* values
 507          */
 508         tcmd = cmd->request->end_io_data;
 509         cmd->result = result;
 510
 511         if (cmd->result == SAM_STAT_CHECK_CONDITION)
 512                 scsi_tgt_copy_sense(cmd, sense_uaddr, sense_len);
 513
 514         if (len) {
 515                 err = scsi_map_user_pages(rq->end_io_data, cmd, uaddr, len, rw);
 516                 if (err) {
 517                         /*
 518                          * user-space daemon bugs or OOM
 519                          * TODO: we can do better for OOM.
 520                          */
 521                         struct scsi_tgt_queuedata *qdata;
 522                         struct list_head *head;
 523                         unsigned long flags;
 524
 525                         eprintk("cmd %p ret %d uaddr %lx len %d rw %d\n",
 526                                 cmd, err, uaddr, len, rw);
 527
 528                         qdata = shost->uspace_req_q->queuedata;
 529                         head = &qdata->cmd_hash[cmd_hashfn(tcmd->tag)];
 530
 531                         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
 532                         list_add(&tcmd->hash_list, head);
 533                         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
 534
 535                         goto done;
 536                 }
 537         }
 538         err = scsi_tgt_transfer_response(cmd);
 539 done:
 540         scsi_host_put(shost);
 541         return err;
 542 }
 543
 544 int scsi_tgt_tsk_mgmt_request(struct Scsi_Host *shost, int function, u64 tag,
 545                               struct scsi_lun *scsilun, void *data)
 546 {
 547         int err;
 548
 549         /* TODO: need to retry if this fails. */
 550         err = scsi_tgt_uspace_send_tsk_mgmt(shost->host_no, function,
 551                                             tag, scsilun, data);
 552         if (err < 0)
 553                 eprintk("The task management request lost!\n");
 554         return err;
 555 }
 556 EXPORT_SYMBOL_GPL(scsi_tgt_tsk_mgmt_request);
 557
 558 int scsi_tgt_kspace_tsk_mgmt(int host_no, u64 mid, int result)
 559 {
 560         struct Scsi_Host *shost;
 561         int err = -EINVAL;
 562
 563         dprintk("%d %d %llx\n", host_no, result, (unsigned long long) mid);
 564
 565         shost = scsi_host_lookup(host_no);
 566         if (IS_ERR(shost)) {
 567                 printk(KERN_ERR "Could not find host no %d\n", host_no);
 568                 return err;
 569         }
 570
 571         if (!shost->uspace_req_q) {
 572                 printk(KERN_ERR "Not target scsi host %d\n", host_no);
 573                 goto done;
 574         }
 575
 576         err = shost->hostt->tsk_mgmt_response(mid, result);
 577 done:
 578         scsi_host_put(shost);
 579         return err;
 580 }
 581
 582 static int __init scsi_tgt_init(void)
 583 {
 584         int err;
 585
 586         scsi_tgt_cmd_cache = kmem_cache_create("scsi_tgt_cmd",
 587                                                sizeof(struct scsi_tgt_cmd),
 588                                                0, 0, NULL, NULL);
 589         if (!scsi_tgt_cmd_cache)
 590                 return -ENOMEM;
 591
 592         scsi_tgtd = create_workqueue("scsi_tgtd");
 593         if (!scsi_tgtd) {
 594                 err = -ENOMEM;
 595                 goto free_kmemcache;
 596         }
 597
 598         err = scsi_tgt_if_init();
 599         if (err)
 600                 goto destroy_wq;
 601
 602         return 0;
 603
 604 destroy_wq:
 605         destroy_workqueue(scsi_tgtd);
 606 free_kmemcache:
 607         kmem_cache_destroy(scsi_tgt_cmd_cache);
 608         return err;
 609 }
 610
 611 static void __exit scsi_tgt_exit(void)
 612 {
 613         destroy_workqueue(scsi_tgtd);
 614         scsi_tgt_if_exit();
 615         kmem_cache_destroy(scsi_tgt_cmd_cache);
 616 }
 617
 618 module_init(scsi_tgt_init);
 619 module_exit(scsi_tgt_exit);
 620
 621 MODULE_DESCRIPTION("SCSI target core");
 622 MODULE_LICENSE("GPL");