2 * SCSI target lib functions
4 * Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
5 * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
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.
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.
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
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>
33 #include "scsi_tgt_priv.h"
35 static struct workqueue_struct *scsi_tgtd;
36 static struct kmem_cache *scsi_tgt_cmd_cache;
39 * TODO: this struct will be killed when the block layer supports large bios
40 * and James's work struct code is in
43 /* TODO replace work with James b's code */
44 struct work_struct work;
45 /* TODO fix limits of some drivers */
48 struct list_head hash_list;
54 #define TGT_HASH_ORDER 4
55 #define cmd_hashfn(tag) hash_long((unsigned long) (tag), TGT_HASH_ORDER)
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;
64 * Function: scsi_host_get_command()
66 * Purpose: Allocate and setup a scsi command block and blk request
68 * Arguments: shost - scsi host
69 * data_dir - dma data dir
70 * gfp_mask- allocator flags
72 * Returns: The allocated scsi command structure.
74 * This should be called by target LLDs to get a command.
76 struct scsi_cmnd *scsi_host_get_command(struct Scsi_Host *shost,
77 enum dma_data_direction data_dir,
80 int write = (data_dir == DMA_TO_DEVICE);
82 struct scsi_cmnd *cmd;
83 struct scsi_tgt_cmd *tcmd;
85 /* Bail if we can't get a reference to the device */
86 if (!get_device(&shost->shost_gendev))
89 tcmd = kmem_cache_alloc(scsi_tgt_cmd_cache, GFP_ATOMIC);
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.
98 rq = blk_get_request(shost->uspace_req_q, !write, gfp_mask);
102 cmd = __scsi_get_command(shost, gfp_mask);
106 memset(cmd, 0, sizeof(*cmd));
107 cmd->sc_data_direction = data_dir;
108 cmd->jiffies_at_alloc = jiffies;
112 rq->cmd_type = REQ_TYPE_SPECIAL;
113 rq->cmd_flags |= REQ_TYPE_BLOCK_PC;
114 rq->end_io_data = tcmd;
123 kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
125 put_device(&shost->shost_gendev);
129 EXPORT_SYMBOL_GPL(scsi_host_get_command);
132 * Function: scsi_host_put_command()
134 * Purpose: Free a scsi command block
136 * Arguments: shost - scsi host
137 * cmd - command block to free
141 * Notes: The command must not belong to any lists.
143 void scsi_host_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
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;
150 kmem_cache_free(scsi_tgt_cmd_cache, tcmd);
152 spin_lock_irqsave(q->queue_lock, flags);
153 __blk_put_request(q, rq);
154 spin_unlock_irqrestore(q->queue_lock, flags);
156 __scsi_put_command(shost, cmd, &shost->shost_gendev);
158 EXPORT_SYMBOL_GPL(scsi_host_put_command);
160 static void cmd_hashlist_del(struct scsi_cmnd *cmd)
162 struct request_queue *q = cmd->request->q;
163 struct scsi_tgt_queuedata *qdata = q->queuedata;
165 struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
167 spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
168 list_del(&tcmd->hash_list);
169 spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
172 static void scsi_unmap_user_pages(struct scsi_tgt_cmd *tcmd)
174 blk_rq_unmap_user(tcmd->bio);
177 static void scsi_tgt_cmd_destroy(struct work_struct *work)
179 struct scsi_tgt_cmd *tcmd =
180 container_of(work, struct scsi_tgt_cmd, work);
181 struct scsi_cmnd *cmd = tcmd->rq->special;
183 dprintk("cmd %p %d %u\n", cmd, cmd->sc_data_direction,
184 rq_data_dir(cmd->request));
185 scsi_unmap_user_pages(tcmd);
186 scsi_host_put_command(scsi_tgt_cmd_to_host(cmd), cmd);
189 static void init_scsi_tgt_cmd(struct request *rq, struct scsi_tgt_cmd *tcmd,
192 struct scsi_tgt_queuedata *qdata = rq->q->queuedata;
194 struct list_head *head;
196 tcmd->itn_id = itn_id;
199 INIT_WORK(&tcmd->work, scsi_tgt_cmd_destroy);
200 spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
201 head = &qdata->cmd_hash[cmd_hashfn(tag)];
202 list_add(&tcmd->hash_list, head);
203 spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
207 * scsi_tgt_alloc_queue - setup queue used for message passing
210 * This should be called by the LLD after host allocation.
211 * And will be released when the host is released.
213 int scsi_tgt_alloc_queue(struct Scsi_Host *shost)
215 struct scsi_tgt_queuedata *queuedata;
216 struct request_queue *q;
220 * Do we need to send a netlink event or should uspace
221 * just respond to the hotplug event?
223 q = __scsi_alloc_queue(shost, NULL);
227 queuedata = kzalloc(sizeof(*queuedata), GFP_KERNEL);
232 queuedata->shost = shost;
233 q->queuedata = queuedata;
236 * this is a silly hack. We should probably just queue as many
237 * command as is recvd to userspace. uspace can then make
238 * sure we do not overload the HBA
240 q->nr_requests = shost->can_queue;
242 * We currently only support software LLDs so this does
243 * not matter for now. Do we need this for the cards we support?
244 * If so we should make it a host template value.
246 blk_queue_dma_alignment(q, 0);
247 shost->uspace_req_q = q;
249 for (i = 0; i < ARRAY_SIZE(queuedata->cmd_hash); i++)
250 INIT_LIST_HEAD(&queuedata->cmd_hash[i]);
251 spin_lock_init(&queuedata->cmd_hash_lock);
256 blk_cleanup_queue(q);
259 EXPORT_SYMBOL_GPL(scsi_tgt_alloc_queue);
261 void scsi_tgt_free_queue(struct Scsi_Host *shost)
265 struct request_queue *q = shost->uspace_req_q;
266 struct scsi_cmnd *cmd;
267 struct scsi_tgt_queuedata *qdata = q->queuedata;
268 struct scsi_tgt_cmd *tcmd, *n;
271 spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
273 for (i = 0; i < ARRAY_SIZE(qdata->cmd_hash); i++) {
274 list_for_each_entry_safe(tcmd, n, &qdata->cmd_hash[i],
276 list_del(&tcmd->hash_list);
277 list_add(&tcmd->hash_list, &cmds);
281 spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
283 while (!list_empty(&cmds)) {
284 tcmd = list_entry(cmds.next, struct scsi_tgt_cmd, hash_list);
285 list_del(&tcmd->hash_list);
286 cmd = tcmd->rq->special;
288 shost->hostt->eh_abort_handler(cmd);
289 scsi_tgt_cmd_destroy(&tcmd->work);
292 EXPORT_SYMBOL_GPL(scsi_tgt_free_queue);
294 struct Scsi_Host *scsi_tgt_cmd_to_host(struct scsi_cmnd *cmd)
296 struct scsi_tgt_queuedata *queue = cmd->request->q->queuedata;
299 EXPORT_SYMBOL_GPL(scsi_tgt_cmd_to_host);
302 * scsi_tgt_queue_command - queue command for userspace processing
305 * @tag: unique value to identify this command for tmf
307 int scsi_tgt_queue_command(struct scsi_cmnd *cmd, u64 itn_id,
308 struct scsi_lun *scsilun, u64 tag)
310 struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
313 init_scsi_tgt_cmd(cmd->request, tcmd, itn_id, tag);
314 err = scsi_tgt_uspace_send_cmd(cmd, itn_id, scsilun, tag);
316 cmd_hashlist_del(cmd);
320 EXPORT_SYMBOL_GPL(scsi_tgt_queue_command);
323 * This is run from a interrpt handler normally and the unmap
324 * needs process context so we must queue
326 static void scsi_tgt_cmd_done(struct scsi_cmnd *cmd)
328 struct scsi_tgt_cmd *tcmd = cmd->request->end_io_data;
330 dprintk("cmd %p %u\n", cmd, rq_data_dir(cmd->request));
332 scsi_tgt_uspace_send_status(cmd, tcmd->itn_id, tcmd->tag);
334 if (scsi_sglist(cmd))
335 scsi_free_sgtable(cmd);
337 queue_work(scsi_tgtd, &tcmd->work);
340 static int scsi_tgt_transfer_response(struct scsi_cmnd *cmd)
342 struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
345 dprintk("cmd %p %u\n", cmd, rq_data_dir(cmd->request));
347 err = shost->hostt->transfer_response(cmd, scsi_tgt_cmd_done);
349 case SCSI_MLQUEUE_HOST_BUSY:
350 case SCSI_MLQUEUE_DEVICE_BUSY:
356 static int scsi_tgt_init_cmd(struct scsi_cmnd *cmd, gfp_t gfp_mask)
358 struct request *rq = cmd->request;
361 cmd->use_sg = rq->nr_phys_segments;
362 if (scsi_alloc_sgtable(cmd, gfp_mask))
365 cmd->request_bufflen = rq->data_len;
367 dprintk("cmd %p cnt %d %lu\n", cmd, scsi_sg_count(cmd),
369 count = blk_rq_map_sg(rq->q, rq, scsi_sglist(cmd));
370 BUG_ON(count > cmd->use_sg);
375 /* TODO: test this crap and replace bio_map_user with new interface maybe */
376 static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
377 unsigned long uaddr, unsigned int len, int rw)
379 struct request_queue *q = cmd->request->q;
380 struct request *rq = cmd->request;
383 dprintk("%lx %u\n", uaddr, len);
384 err = blk_rq_map_user(q, rq, (void *)uaddr, len);
387 * TODO: need to fixup sg_tablesize, max_segment_size,
388 * max_sectors, etc for modern HW and software drivers
389 * where this value is bogus.
391 * TODO2: we can alloc a reserve buffer of max size
392 * we can handle and do the slow copy path for really large
395 eprintk("Could not handle request of size %u.\n", len);
400 err = scsi_tgt_init_cmd(cmd, GFP_KERNEL);
407 scsi_unmap_user_pages(tcmd);
411 static int scsi_tgt_copy_sense(struct scsi_cmnd *cmd, unsigned long uaddr,
414 char __user *p = (char __user *) uaddr;
416 if (copy_from_user(cmd->sense_buffer, p,
417 min_t(unsigned, SCSI_SENSE_BUFFERSIZE, len))) {
418 printk(KERN_ERR "Could not copy the sense buffer\n");
424 static int scsi_tgt_abort_cmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
426 struct scsi_tgt_cmd *tcmd;
429 err = shost->hostt->eh_abort_handler(cmd);
431 eprintk("fail to abort %p\n", cmd);
433 tcmd = cmd->request->end_io_data;
434 scsi_tgt_cmd_destroy(&tcmd->work);
438 static struct request *tgt_cmd_hash_lookup(struct request_queue *q, u64 tag)
440 struct scsi_tgt_queuedata *qdata = q->queuedata;
441 struct request *rq = NULL;
442 struct list_head *head;
443 struct scsi_tgt_cmd *tcmd;
446 head = &qdata->cmd_hash[cmd_hashfn(tag)];
447 spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
448 list_for_each_entry(tcmd, head, hash_list) {
449 if (tcmd->tag == tag) {
451 list_del(&tcmd->hash_list);
455 spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
460 int scsi_tgt_kspace_exec(int host_no, u64 itn_id, int result, u64 tag,
461 unsigned long uaddr, u32 len, unsigned long sense_uaddr,
462 u32 sense_len, u8 rw)
464 struct Scsi_Host *shost;
465 struct scsi_cmnd *cmd;
467 struct scsi_tgt_cmd *tcmd;
470 dprintk("%d %llu %d %u %lx %u\n", host_no, (unsigned long long) tag,
471 result, len, uaddr, rw);
473 /* TODO: replace with a O(1) alg */
474 shost = scsi_host_lookup(host_no);
476 printk(KERN_ERR "Could not find host no %d\n", host_no);
480 if (!shost->uspace_req_q) {
481 printk(KERN_ERR "Not target scsi host %d\n", host_no);
485 rq = tgt_cmd_hash_lookup(shost->uspace_req_q, tag);
487 printk(KERN_ERR "Could not find tag %llu\n",
488 (unsigned long long) tag);
494 dprintk("cmd %p scb %x result %d len %d bufflen %u %u %x\n",
495 cmd, cmd->cmnd[0], result, len, scsi_bufflen(cmd),
496 rq_data_dir(rq), cmd->cmnd[0]);
498 if (result == TASK_ABORTED) {
499 scsi_tgt_abort_cmd(shost, cmd);
503 * store the userspace values here, the working values are
504 * in the request_* values
506 tcmd = cmd->request->end_io_data;
507 cmd->result = result;
509 if (cmd->result == SAM_STAT_CHECK_CONDITION)
510 scsi_tgt_copy_sense(cmd, sense_uaddr, sense_len);
513 err = scsi_map_user_pages(rq->end_io_data, cmd, uaddr, len, rw);
516 * user-space daemon bugs or OOM
517 * TODO: we can do better for OOM.
519 struct scsi_tgt_queuedata *qdata;
520 struct list_head *head;
523 eprintk("cmd %p ret %d uaddr %lx len %d rw %d\n",
524 cmd, err, uaddr, len, rw);
526 qdata = shost->uspace_req_q->queuedata;
527 head = &qdata->cmd_hash[cmd_hashfn(tcmd->tag)];
529 spin_lock_irqsave(&qdata->cmd_hash_lock, flags);
530 list_add(&tcmd->hash_list, head);
531 spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
536 err = scsi_tgt_transfer_response(cmd);
538 scsi_host_put(shost);
542 int scsi_tgt_tsk_mgmt_request(struct Scsi_Host *shost, u64 itn_id,
543 int function, u64 tag, struct scsi_lun *scsilun,
548 /* TODO: need to retry if this fails. */
549 err = scsi_tgt_uspace_send_tsk_mgmt(shost->host_no, itn_id,
550 function, tag, scsilun, data);
552 eprintk("The task management request lost!\n");
555 EXPORT_SYMBOL_GPL(scsi_tgt_tsk_mgmt_request);
557 int scsi_tgt_kspace_tsk_mgmt(int host_no, u64 itn_id, u64 mid, int result)
559 struct Scsi_Host *shost;
562 dprintk("%d %d %llx\n", host_no, result, (unsigned long long) mid);
564 shost = scsi_host_lookup(host_no);
566 printk(KERN_ERR "Could not find host no %d\n", host_no);
570 if (!shost->uspace_req_q) {
571 printk(KERN_ERR "Not target scsi host %d\n", host_no);
575 err = shost->transportt->tsk_mgmt_response(shost, itn_id, mid, result);
577 scsi_host_put(shost);
581 int scsi_tgt_it_nexus_create(struct Scsi_Host *shost, u64 itn_id,
586 /* TODO: need to retry if this fails. */
587 err = scsi_tgt_uspace_send_it_nexus_request(shost->host_no, itn_id, 0,
590 eprintk("The i_t_neuxs request lost, %d %llx!\n",
591 shost->host_no, (unsigned long long)itn_id);
594 EXPORT_SYMBOL_GPL(scsi_tgt_it_nexus_create);
596 int scsi_tgt_it_nexus_destroy(struct Scsi_Host *shost, u64 itn_id)
600 /* TODO: need to retry if this fails. */
601 err = scsi_tgt_uspace_send_it_nexus_request(shost->host_no,
604 eprintk("The i_t_neuxs request lost, %d %llx!\n",
605 shost->host_no, (unsigned long long)itn_id);
608 EXPORT_SYMBOL_GPL(scsi_tgt_it_nexus_destroy);
610 int scsi_tgt_kspace_it_nexus_rsp(int host_no, u64 itn_id, int result)
612 struct Scsi_Host *shost;
615 dprintk("%d %d%llx\n", host_no, result, (unsigned long long)itn_id);
617 shost = scsi_host_lookup(host_no);
619 printk(KERN_ERR "Could not find host no %d\n", host_no);
623 if (!shost->uspace_req_q) {
624 printk(KERN_ERR "Not target scsi host %d\n", host_no);
628 err = shost->transportt->it_nexus_response(shost, itn_id, result);
630 scsi_host_put(shost);
634 static int __init scsi_tgt_init(void)
638 scsi_tgt_cmd_cache = kmem_cache_create("scsi_tgt_cmd",
639 sizeof(struct scsi_tgt_cmd),
641 if (!scsi_tgt_cmd_cache)
644 scsi_tgtd = create_workqueue("scsi_tgtd");
650 err = scsi_tgt_if_init();
657 destroy_workqueue(scsi_tgtd);
659 kmem_cache_destroy(scsi_tgt_cmd_cache);
663 static void __exit scsi_tgt_exit(void)
665 destroy_workqueue(scsi_tgtd);
667 kmem_cache_destroy(scsi_tgt_cmd_cache);
670 module_init(scsi_tgt_init);
671 module_exit(scsi_tgt_exit);
673 MODULE_DESCRIPTION("SCSI target core");
674 MODULE_LICENSE("GPL");