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