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