[PATCH] slab: remove kmem_cache_t
[linux-3.10.git] / 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 #include <../drivers/md/dm-bio-list.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 replace the lists with a large bio */
46         struct bio_list xfer_done_list;
47         struct bio_list xfer_list;
48
49         struct list_head hash_list;
50         struct request *rq;
51         u64 tag;
52
53         void *buffer;
54         unsigned bufflen;
55 };
56
57 #define TGT_HASH_ORDER  4
58 #define cmd_hashfn(tag) hash_long((unsigned long) (tag), TGT_HASH_ORDER)
59
60 struct scsi_tgt_queuedata {
61         struct Scsi_Host *shost;
62         struct list_head cmd_hash[1 << TGT_HASH_ORDER];
63         spinlock_t cmd_hash_lock;
64 };
65
66 /*
67  * Function:    scsi_host_get_command()
68  *
69  * Purpose:     Allocate and setup a scsi command block and blk request
70  *
71  * Arguments:   shost   - scsi host
72  *              data_dir - dma data dir
73  *              gfp_mask- allocator flags
74  *
75  * Returns:     The allocated scsi command structure.
76  *
77  * This should be called by target LLDs to get a command.
78  */
79 struct scsi_cmnd *scsi_host_get_command(struct Scsi_Host *shost,
80                                         enum dma_data_direction data_dir,
81                                         gfp_t gfp_mask)
82 {
83         int write = (data_dir == DMA_TO_DEVICE);
84         struct request *rq;
85         struct scsi_cmnd *cmd;
86         struct scsi_tgt_cmd *tcmd;
87
88         /* Bail if we can't get a reference to the device */
89         if (!get_device(&shost->shost_gendev))
90                 return NULL;
91
92         tcmd = kmem_cache_alloc(scsi_tgt_cmd_cache, GFP_ATOMIC);
93         if (!tcmd)
94                 goto put_dev;
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         bio_list_init(&tcmd->xfer_list);
115         bio_list_init(&tcmd->xfer_done_list);
116         tcmd->rq = rq;
117
118         return cmd;
119
120 release_rq:
121         blk_put_request(rq);
122 free_tcmd:
123         kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
124 put_dev:
125         put_device(&shost->shost_gendev);
126         return NULL;
127
128 }
129 EXPORT_SYMBOL_GPL(scsi_host_get_command);
130
131 /*
132  * Function:    scsi_host_put_command()
133  *
134  * Purpose:     Free a scsi command block
135  *
136  * Arguments:   shost   - scsi host
137  *              cmd     - command block to free
138  *
139  * Returns:     Nothing.
140  *
141  * Notes:       The command must not belong to any lists.
142  */
143 void scsi_host_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
144 {
145         struct request_queue *q = shost->uspace_req_q;
146         struct request *rq = cmd->request;
147         struct scsi_tgt_cmd *tcmd = rq->end_io_data;
148         unsigned long flags;
149
150         kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
151
152         spin_lock_irqsave(q->queue_lock, flags);
153         __blk_put_request(q, rq);
154         spin_unlock_irqrestore(q->queue_lock, flags);
155
156         __scsi_put_command(shost, cmd, &shost->shost_gendev);
157 }
158 EXPORT_SYMBOL_GPL(scsi_host_put_command);
159
160 static void scsi_unmap_user_pages(struct scsi_tgt_cmd *tcmd)
161 {
162         struct bio *bio;
163
164         /* must call bio_endio in case bio was bounced */
165         while ((bio = bio_list_pop(&tcmd->xfer_done_list))) {
166                 bio_endio(bio, bio->bi_size, 0);
167                 bio_unmap_user(bio);
168         }
169
170         while ((bio = bio_list_pop(&tcmd->xfer_list))) {
171                 bio_endio(bio, bio->bi_size, 0);
172                 bio_unmap_user(bio);
173         }
174 }
175
176 static void cmd_hashlist_del(struct scsi_cmnd *cmd)
177 {
178         struct request_queue *q = cmd->request->q;
179         struct scsi_tgt_queuedata *qdata = q->queuedata;
180         unsigned long flags;
181         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
182
183         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
184         list_del(&tcmd->hash_list);
185         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
186 }
187
188 static void scsi_tgt_cmd_destroy(struct work_struct *work)
189 {
190         struct scsi_tgt_cmd *tcmd =
191                 container_of(work, struct scsi_tgt_cmd, work);
192         struct scsi_cmnd *cmd = tcmd->rq->special;
193
194         dprintk("cmd %p %d %lu\n", cmd, cmd->sc_data_direction,
195                 rq_data_dir(cmd->request));
196         /*
197          * We fix rq->cmd_flags here since when we told bio_map_user
198          * to write vm for WRITE commands, blk_rq_bio_prep set
199          * rq_data_dir the flags to READ.
200          */
201         if (cmd->sc_data_direction == DMA_TO_DEVICE)
202                 cmd->request->cmd_flags |= REQ_RW;
203         else
204                 cmd->request->cmd_flags &= ~REQ_RW;
205
206         scsi_unmap_user_pages(tcmd);
207         scsi_host_put_command(scsi_tgt_cmd_to_host(cmd), cmd);
208 }
209
210 static void init_scsi_tgt_cmd(struct request *rq, struct scsi_tgt_cmd *tcmd,
211                               u64 tag)
212 {
213         struct scsi_tgt_queuedata *qdata = rq->q->queuedata;
214         unsigned long flags;
215         struct list_head *head;
216
217         tcmd->tag = tag;
218         INIT_WORK(&tcmd->work, scsi_tgt_cmd_destroy);
219         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
220         head = &qdata->cmd_hash[cmd_hashfn(tag)];
221         list_add(&tcmd->hash_list, head);
222         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
223 }
224
225 /*
226  * scsi_tgt_alloc_queue - setup queue used for message passing
227  * shost: scsi host
228  *
229  * This should be called by the LLD after host allocation.
230  * And will be released when the host is released.
231  */
232 int scsi_tgt_alloc_queue(struct Scsi_Host *shost)
233 {
234         struct scsi_tgt_queuedata *queuedata;
235         struct request_queue *q;
236         int err, i;
237
238         /*
239          * Do we need to send a netlink event or should uspace
240          * just respond to the hotplug event?
241          */
242         q = __scsi_alloc_queue(shost, NULL);
243         if (!q)
244                 return -ENOMEM;
245
246         queuedata = kzalloc(sizeof(*queuedata), GFP_KERNEL);
247         if (!queuedata) {
248                 err = -ENOMEM;
249                 goto cleanup_queue;
250         }
251         queuedata->shost = shost;
252         q->queuedata = queuedata;
253
254         /*
255          * this is a silly hack. We should probably just queue as many
256          * command as is recvd to userspace. uspace can then make
257          * sure we do not overload the HBA
258          */
259         q->nr_requests = shost->hostt->can_queue;
260         /*
261          * We currently only support software LLDs so this does
262          * not matter for now. Do we need this for the cards we support?
263          * If so we should make it a host template value.
264          */
265         blk_queue_dma_alignment(q, 0);
266         shost->uspace_req_q = q;
267
268         for (i = 0; i < ARRAY_SIZE(queuedata->cmd_hash); i++)
269                 INIT_LIST_HEAD(&queuedata->cmd_hash[i]);
270         spin_lock_init(&queuedata->cmd_hash_lock);
271
272         return 0;
273
274 cleanup_queue:
275         blk_cleanup_queue(q);
276         return err;
277 }
278 EXPORT_SYMBOL_GPL(scsi_tgt_alloc_queue);
279
280 void scsi_tgt_free_queue(struct Scsi_Host *shost)
281 {
282         int i;
283         unsigned long flags;
284         struct request_queue *q = shost->uspace_req_q;
285         struct scsi_cmnd *cmd;
286         struct scsi_tgt_queuedata *qdata = q->queuedata;
287         struct scsi_tgt_cmd *tcmd, *n;
288         LIST_HEAD(cmds);
289
290         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
291
292         for (i = 0; i < ARRAY_SIZE(qdata->cmd_hash); i++) {
293                 list_for_each_entry_safe(tcmd, n, &qdata->cmd_hash[i],
294                                          hash_list) {
295                         list_del(&tcmd->hash_list);
296                         list_add(&tcmd->hash_list, &cmds);
297                 }
298         }
299
300         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
301
302         while (!list_empty(&cmds)) {
303                 tcmd = list_entry(cmds.next, struct scsi_tgt_cmd, hash_list);
304                 list_del(&tcmd->hash_list);
305                 cmd = tcmd->rq->special;
306
307                 shost->hostt->eh_abort_handler(cmd);
308                 scsi_tgt_cmd_destroy(&tcmd->work);
309         }
310 }
311 EXPORT_SYMBOL_GPL(scsi_tgt_free_queue);
312
313 struct Scsi_Host *scsi_tgt_cmd_to_host(struct scsi_cmnd *cmd)
314 {
315         struct scsi_tgt_queuedata *queue = cmd->request->q->queuedata;
316         return queue->shost;
317 }
318 EXPORT_SYMBOL_GPL(scsi_tgt_cmd_to_host);
319
320 /*
321  * scsi_tgt_queue_command - queue command for userspace processing
322  * @cmd:        scsi command
323  * @scsilun:    scsi lun
324  * @tag:        unique value to identify this command for tmf
325  */
326 int scsi_tgt_queue_command(struct scsi_cmnd *cmd, struct scsi_lun *scsilun,
327                            u64 tag)
328 {
329         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
330         int err;
331
332         init_scsi_tgt_cmd(cmd->request, tcmd, tag);
333         err = scsi_tgt_uspace_send_cmd(cmd, scsilun, tag);
334         if (err)
335                 cmd_hashlist_del(cmd);
336
337         return err;
338 }
339 EXPORT_SYMBOL_GPL(scsi_tgt_queue_command);
340
341 /*
342  * This is run from a interrpt handler normally and the unmap
343  * needs process context so we must queue
344  */
345 static void scsi_tgt_cmd_done(struct scsi_cmnd *cmd)
346 {
347         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
348
349         dprintk("cmd %p %lu\n", cmd, rq_data_dir(cmd->request));
350
351         scsi_tgt_uspace_send_status(cmd, tcmd->tag);
352         queue_work(scsi_tgtd, &tcmd->work);
353 }
354
355 static int __scsi_tgt_transfer_response(struct scsi_cmnd *cmd)
356 {
357         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
358         int err;
359
360         dprintk("cmd %p %lu\n", cmd, rq_data_dir(cmd->request));
361
362         err = shost->hostt->transfer_response(cmd, scsi_tgt_cmd_done);
363         switch (err) {
364         case SCSI_MLQUEUE_HOST_BUSY:
365         case SCSI_MLQUEUE_DEVICE_BUSY:
366                 return -EAGAIN;
367         }
368
369         return 0;
370 }
371
372 static void scsi_tgt_transfer_response(struct scsi_cmnd *cmd)
373 {
374         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
375         int err;
376
377         err = __scsi_tgt_transfer_response(cmd);
378         if (!err)
379                 return;
380
381         cmd->result = DID_BUS_BUSY << 16;
382         err = scsi_tgt_uspace_send_status(cmd, tcmd->tag);
383         if (err <= 0)
384                 /* the eh will have to pick this up */
385                 printk(KERN_ERR "Could not send cmd %p status\n", cmd);
386 }
387
388 static int scsi_tgt_init_cmd(struct scsi_cmnd *cmd, gfp_t gfp_mask)
389 {
390         struct request *rq = cmd->request;
391         struct scsi_tgt_cmd *tcmd = rq->end_io_data;
392         int count;
393
394         cmd->use_sg = rq->nr_phys_segments;
395         cmd->request_buffer = scsi_alloc_sgtable(cmd, gfp_mask);
396         if (!cmd->request_buffer)
397                 return -ENOMEM;
398
399         cmd->request_bufflen = rq->data_len;
400
401         dprintk("cmd %p addr %p cnt %d %lu\n", cmd, tcmd->buffer, cmd->use_sg,
402                 rq_data_dir(rq));
403         count = blk_rq_map_sg(rq->q, rq, cmd->request_buffer);
404         if (likely(count <= cmd->use_sg)) {
405                 cmd->use_sg = count;
406                 return 0;
407         }
408
409         eprintk("cmd %p addr %p cnt %d\n", cmd, tcmd->buffer, cmd->use_sg);
410         scsi_free_sgtable(cmd->request_buffer, cmd->sglist_len);
411         return -EINVAL;
412 }
413
414 /* TODO: test this crap and replace bio_map_user with new interface maybe */
415 static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
416                                int rw)
417 {
418         struct request_queue *q = cmd->request->q;
419         struct request *rq = cmd->request;
420         void *uaddr = tcmd->buffer;
421         unsigned int len = tcmd->bufflen;
422         struct bio *bio;
423         int err;
424
425         while (len > 0) {
426                 dprintk("%lx %u\n", (unsigned long) uaddr, len);
427                 bio = bio_map_user(q, NULL, (unsigned long) uaddr, len, rw);
428                 if (IS_ERR(bio)) {
429                         err = PTR_ERR(bio);
430                         dprintk("fail to map %lx %u %d %x\n",
431                                 (unsigned long) uaddr, len, err, cmd->cmnd[0]);
432                         goto unmap_bios;
433                 }
434
435                 uaddr += bio->bi_size;
436                 len -= bio->bi_size;
437
438                 /*
439                  * The first bio is added and merged. We could probably
440                  * try to add others using scsi_merge_bio() but for now
441                  * we keep it simple. The first bio should be pretty large
442                  * (either hitting the 1 MB bio pages limit or a queue limit)
443                  * already but for really large IO we may want to try and
444                  * merge these.
445                  */
446                 if (!rq->bio) {
447                         blk_rq_bio_prep(q, rq, bio);
448                         rq->data_len = bio->bi_size;
449                 } else
450                         /* put list of bios to transfer in next go around */
451                         bio_list_add(&tcmd->xfer_list, bio);
452         }
453
454         cmd->offset = 0;
455         err = scsi_tgt_init_cmd(cmd, GFP_KERNEL);
456         if (err)
457                 goto unmap_bios;
458
459         return 0;
460
461 unmap_bios:
462         if (rq->bio) {
463                 bio_unmap_user(rq->bio);
464                 while ((bio = bio_list_pop(&tcmd->xfer_list)))
465                         bio_unmap_user(bio);
466         }
467
468         return err;
469 }
470
471 static int scsi_tgt_transfer_data(struct scsi_cmnd *);
472
473 static void scsi_tgt_data_transfer_done(struct scsi_cmnd *cmd)
474 {
475         struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
476         struct bio *bio;
477         int err;
478
479         /* should we free resources here on error ? */
480         if (cmd->result) {
481 send_uspace_err:
482                 err = scsi_tgt_uspace_send_status(cmd, tcmd->tag);
483                 if (err <= 0)
484                         /* the tgt uspace eh will have to pick this up */
485                         printk(KERN_ERR "Could not send cmd %p status\n", cmd);
486                 return;
487         }
488
489         dprintk("cmd %p request_bufflen %u bufflen %u\n",
490                 cmd, cmd->request_bufflen, tcmd->bufflen);
491
492         scsi_free_sgtable(cmd->request_buffer, cmd->sglist_len);
493         bio_list_add(&tcmd->xfer_done_list, cmd->request->bio);
494
495         tcmd->buffer += cmd->request_bufflen;
496         cmd->offset += cmd->request_bufflen;
497
498         if (!tcmd->xfer_list.head) {
499                 scsi_tgt_transfer_response(cmd);
500                 return;
501         }
502
503         dprintk("cmd2 %p request_bufflen %u bufflen %u\n",
504                 cmd, cmd->request_bufflen, tcmd->bufflen);
505
506         bio = bio_list_pop(&tcmd->xfer_list);
507         BUG_ON(!bio);
508
509         blk_rq_bio_prep(cmd->request->q, cmd->request, bio);
510         cmd->request->data_len = bio->bi_size;
511         err = scsi_tgt_init_cmd(cmd, GFP_ATOMIC);
512         if (err) {
513                 cmd->result = DID_ERROR << 16;
514                 goto send_uspace_err;
515         }
516
517         if (scsi_tgt_transfer_data(cmd)) {
518                 cmd->result = DID_NO_CONNECT << 16;
519                 goto send_uspace_err;
520         }
521 }
522
523 static int scsi_tgt_transfer_data(struct scsi_cmnd *cmd)
524 {
525         int err;
526         struct Scsi_Host *host = scsi_tgt_cmd_to_host(cmd);
527
528         err = host->hostt->transfer_data(cmd, scsi_tgt_data_transfer_done);
529         switch (err) {
530                 case SCSI_MLQUEUE_HOST_BUSY:
531                 case SCSI_MLQUEUE_DEVICE_BUSY:
532                         return -EAGAIN;
533         default:
534                 return 0;
535         }
536 }
537
538 static int scsi_tgt_copy_sense(struct scsi_cmnd *cmd, unsigned long uaddr,
539                                 unsigned len)
540 {
541         char __user *p = (char __user *) uaddr;
542
543         if (copy_from_user(cmd->sense_buffer, p,
544                            min_t(unsigned, SCSI_SENSE_BUFFERSIZE, len))) {
545                 printk(KERN_ERR "Could not copy the sense buffer\n");
546                 return -EIO;
547         }
548         return 0;
549 }
550
551 static int scsi_tgt_abort_cmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
552 {
553         struct scsi_tgt_cmd *tcmd;
554         int err;
555
556         err = shost->hostt->eh_abort_handler(cmd);
557         if (err)
558                 eprintk("fail to abort %p\n", cmd);
559
560         tcmd = cmd->request->end_io_data;
561         scsi_tgt_cmd_destroy(&tcmd->work);
562         return err;
563 }
564
565 static struct request *tgt_cmd_hash_lookup(struct request_queue *q, u64 tag)
566 {
567         struct scsi_tgt_queuedata *qdata = q->queuedata;
568         struct request *rq = NULL;
569         struct list_head *head;
570         struct scsi_tgt_cmd *tcmd;
571         unsigned long flags;
572
573         head = &qdata->cmd_hash[cmd_hashfn(tag)];
574         spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
575         list_for_each_entry(tcmd, head, hash_list) {
576                 if (tcmd->tag == tag) {
577                         rq = tcmd->rq;
578                         list_del(&tcmd->hash_list);
579                         break;
580                 }
581         }
582         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
583
584         return rq;
585 }
586
587 int scsi_tgt_kspace_exec(int host_no, u64 tag, int result, u32 len,
588                          unsigned long uaddr, u8 rw)
589 {
590         struct Scsi_Host *shost;
591         struct scsi_cmnd *cmd;
592         struct request *rq;
593         struct scsi_tgt_cmd *tcmd;
594         int err = 0;
595
596         dprintk("%d %llu %d %u %lx %u\n", host_no, (unsigned long long) tag,
597                 result, len, uaddr, rw);
598
599         /* TODO: replace with a O(1) alg */
600         shost = scsi_host_lookup(host_no);
601         if (IS_ERR(shost)) {
602                 printk(KERN_ERR "Could not find host no %d\n", host_no);
603                 return -EINVAL;
604         }
605
606         if (!shost->uspace_req_q) {
607                 printk(KERN_ERR "Not target scsi host %d\n", host_no);
608                 goto done;
609         }
610
611         rq = tgt_cmd_hash_lookup(shost->uspace_req_q, tag);
612         if (!rq) {
613                 printk(KERN_ERR "Could not find tag %llu\n",
614                        (unsigned long long) tag);
615                 err = -EINVAL;
616                 goto done;
617         }
618         cmd = rq->special;
619
620         dprintk("cmd %p result %d len %d bufflen %u %lu %x\n", cmd,
621                 result, len, cmd->request_bufflen, rq_data_dir(rq), cmd->cmnd[0]);
622
623         if (result == TASK_ABORTED) {
624                 scsi_tgt_abort_cmd(shost, cmd);
625                 goto done;
626         }
627         /*
628          * store the userspace values here, the working values are
629          * in the request_* values
630          */
631         tcmd = cmd->request->end_io_data;
632         tcmd->buffer = (void *)uaddr;
633         tcmd->bufflen = len;
634         cmd->result = result;
635
636         if (!tcmd->bufflen || cmd->request_buffer) {
637                 err = __scsi_tgt_transfer_response(cmd);
638                 goto done;
639         }
640
641         /*
642          * TODO: Do we need to handle case where request does not
643          * align with LLD.
644          */
645         err = scsi_map_user_pages(rq->end_io_data, cmd, rw);
646         if (err) {
647                 eprintk("%p %d\n", cmd, err);
648                 err = -EAGAIN;
649                 goto done;
650         }
651
652         /* userspace failure */
653         if (cmd->result) {
654                 if (status_byte(cmd->result) == CHECK_CONDITION)
655                         scsi_tgt_copy_sense(cmd, uaddr, len);
656                 err = __scsi_tgt_transfer_response(cmd);
657                 goto done;
658         }
659         /* ask the target LLD to transfer the data to the buffer */
660         err = scsi_tgt_transfer_data(cmd);
661
662 done:
663         scsi_host_put(shost);
664         return err;
665 }
666
667 int scsi_tgt_tsk_mgmt_request(struct Scsi_Host *shost, int function, u64 tag,
668                               struct scsi_lun *scsilun, void *data)
669 {
670         int err;
671
672         /* TODO: need to retry if this fails. */
673         err = scsi_tgt_uspace_send_tsk_mgmt(shost->host_no, function,
674                                             tag, scsilun, data);
675         if (err < 0)
676                 eprintk("The task management request lost!\n");
677         return err;
678 }
679 EXPORT_SYMBOL_GPL(scsi_tgt_tsk_mgmt_request);
680
681 int scsi_tgt_kspace_tsk_mgmt(int host_no, u64 mid, int result)
682 {
683         struct Scsi_Host *shost;
684         int err = -EINVAL;
685
686         dprintk("%d %d %llx\n", host_no, result, (unsigned long long) mid);
687
688         shost = scsi_host_lookup(host_no);
689         if (IS_ERR(shost)) {
690                 printk(KERN_ERR "Could not find host no %d\n", host_no);
691                 return err;
692         }
693
694         if (!shost->uspace_req_q) {
695                 printk(KERN_ERR "Not target scsi host %d\n", host_no);
696                 goto done;
697         }
698
699         err = shost->hostt->tsk_mgmt_response(mid, result);
700 done:
701         scsi_host_put(shost);
702         return err;
703 }
704
705 static int __init scsi_tgt_init(void)
706 {
707         int err;
708
709         scsi_tgt_cmd_cache = kmem_cache_create("scsi_tgt_cmd",
710                                                sizeof(struct scsi_tgt_cmd),
711                                                0, 0, NULL, NULL);
712         if (!scsi_tgt_cmd_cache)
713                 return -ENOMEM;
714
715         scsi_tgtd = create_workqueue("scsi_tgtd");
716         if (!scsi_tgtd) {
717                 err = -ENOMEM;
718                 goto free_kmemcache;
719         }
720
721         err = scsi_tgt_if_init();
722         if (err)
723                 goto destroy_wq;
724
725         return 0;
726
727 destroy_wq:
728         destroy_workqueue(scsi_tgtd);
729 free_kmemcache:
730         kmem_cache_destroy(scsi_tgt_cmd_cache);
731         return err;
732 }
733
734 static void __exit scsi_tgt_exit(void)
735 {
736         destroy_workqueue(scsi_tgtd);
737         scsi_tgt_if_exit();
738         kmem_cache_destroy(scsi_tgt_cmd_cache);
739 }
740
741 module_init(scsi_tgt_init);
742 module_exit(scsi_tgt_exit);
743
744 MODULE_DESCRIPTION("SCSI target core");
745 MODULE_LICENSE("GPL");