linux/drivers/scsi/storvsc_drv.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2009, Microsoft Corporation.
   3 *
   4 * This program is free software; you can redistribute it and/or modify it
   5 * under the terms and conditions of the GNU General Public License,
   6 * version 2, as published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope it will be useful, but WITHOUT
   9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11 * more details.
  12 *
  13 * You should have received a copy of the GNU General Public License along with
  14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15 * Place - Suite 330, Boston, MA 02111-1307 USA.
  16 *
  17 * Authors:
  18 *   Haiyang Zhang <haiyangz@microsoft.com>
  19 *   Hank Janssen  <hjanssen@microsoft.com>
  20 *   K. Y. Srinivasan <kys@microsoft.com>
  21 */
  22
  23#include <linux/kernel.h>
  24#include <linux/wait.h>
  25#include <linux/sched.h>
  26#include <linux/completion.h>
  27#include <linux/string.h>
  28#include <linux/mm.h>
  29#include <linux/delay.h>
  30#include <linux/init.h>
  31#include <linux/slab.h>
  32#include <linux/module.h>
  33#include <linux/device.h>
  34#include <linux/hyperv.h>
  35#include <linux/mempool.h>
  36#include <scsi/scsi.h>
  37#include <scsi/scsi_cmnd.h>
  38#include <scsi/scsi_host.h>
  39#include <scsi/scsi_device.h>
  40#include <scsi/scsi_tcq.h>
  41#include <scsi/scsi_eh.h>
  42#include <scsi/scsi_devinfo.h>
  43#include <scsi/scsi_dbg.h>
  44
  45/*
  46 * All wire protocol details (storage protocol between the guest and the host)
  47 * are consolidated here.
  48 *
  49 * Begin protocol definitions.
  50 */
  51
  52/*
  53 * Version history:
  54 * V1 Beta: 0.1
  55 * V1 RC < 2008/1/31: 1.0
  56 * V1 RC > 2008/1/31:  2.0
  57 * Win7: 4.2
  58 */
  59
  60#define VMSTOR_CURRENT_MAJOR  4
  61#define VMSTOR_CURRENT_MINOR  2
  62
  63
  64/*  Packet structure describing virtual storage requests. */
  65enum vstor_packet_operation {
  66        VSTOR_OPERATION_COMPLETE_IO             = 1,
  67        VSTOR_OPERATION_REMOVE_DEVICE           = 2,
  68        VSTOR_OPERATION_EXECUTE_SRB             = 3,
  69        VSTOR_OPERATION_RESET_LUN               = 4,
  70        VSTOR_OPERATION_RESET_ADAPTER           = 5,
  71        VSTOR_OPERATION_RESET_BUS               = 6,
  72        VSTOR_OPERATION_BEGIN_INITIALIZATION    = 7,
  73        VSTOR_OPERATION_END_INITIALIZATION      = 8,
  74        VSTOR_OPERATION_QUERY_PROTOCOL_VERSION  = 9,
  75        VSTOR_OPERATION_QUERY_PROPERTIES        = 10,
  76        VSTOR_OPERATION_ENUMERATE_BUS           = 11,
  77        VSTOR_OPERATION_MAXIMUM                 = 11
  78};
  79
  80/*
  81 * Platform neutral description of a scsi request -
  82 * this remains the same across the write regardless of 32/64 bit
  83 * note: it's patterned off the SCSI_PASS_THROUGH structure
  84 */
  85#define STORVSC_MAX_CMD_LEN                     0x10
  86#define STORVSC_SENSE_BUFFER_SIZE               0x12
  87#define STORVSC_MAX_BUF_LEN_WITH_PADDING        0x14
  88
  89struct vmscsi_request {
  90        u16 length;
  91        u8 srb_status;
  92        u8 scsi_status;
  93
  94        u8  port_number;
  95        u8  path_id;
  96        u8  target_id;
  97        u8  lun;
  98
  99        u8  cdb_length;
 100        u8  sense_info_length;
 101        u8  data_in;
 102        u8  reserved;
 103
 104        u32 data_transfer_length;
 105
 106        union {
 107                u8 cdb[STORVSC_MAX_CMD_LEN];
 108                u8 sense_data[STORVSC_SENSE_BUFFER_SIZE];
 109                u8 reserved_array[STORVSC_MAX_BUF_LEN_WITH_PADDING];
 110        };
 111} __attribute((packed));
 112
 113
 114/*
 115 * This structure is sent during the intialization phase to get the different
 116 * properties of the channel.
 117 */
 118struct vmstorage_channel_properties {
 119        u16 protocol_version;
 120        u8  path_id;
 121        u8 target_id;
 122
 123        /* Note: port number is only really known on the client side */
 124        u32  port_number;
 125        u32  flags;
 126        u32   max_transfer_bytes;
 127
 128        /*
 129         * This id is unique for each channel and will correspond with
 130         * vendor specific data in the inquiry data.
 131         */
 132
 133        u64  unique_id;
 134} __packed;
 135
 136/*  This structure is sent during the storage protocol negotiations. */
 137struct vmstorage_protocol_version {
 138        /* Major (MSW) and minor (LSW) version numbers. */
 139        u16 major_minor;
 140
 141        /*
 142         * Revision number is auto-incremented whenever this file is changed
 143         * (See FILL_VMSTOR_REVISION macro above).  Mismatch does not
 144         * definitely indicate incompatibility--but it does indicate mismatched
 145         * builds.
 146         * This is only used on the windows side. Just set it to 0.
 147         */
 148        u16 revision;
 149} __packed;
 150
 151/* Channel Property Flags */
 152#define STORAGE_CHANNEL_REMOVABLE_FLAG          0x1
 153#define STORAGE_CHANNEL_EMULATED_IDE_FLAG       0x2
 154
 155struct vstor_packet {
 156        /* Requested operation type */
 157        enum vstor_packet_operation operation;
 158
 159        /*  Flags - see below for values */
 160        u32 flags;
 161
 162        /* Status of the request returned from the server side. */
 163        u32 status;
 164
 165        /* Data payload area */
 166        union {
 167                /*
 168                 * Structure used to forward SCSI commands from the
 169                 * client to the server.
 170                 */
 171                struct vmscsi_request vm_srb;
 172
 173                /* Structure used to query channel properties. */
 174                struct vmstorage_channel_properties storage_channel_properties;
 175
 176                /* Used during version negotiations. */
 177                struct vmstorage_protocol_version version;
 178        };
 179} __packed;
 180
 181/*
 182 * Packet Flags:
 183 *
 184 * This flag indicates that the server should send back a completion for this
 185 * packet.
 186 */
 187
 188#define REQUEST_COMPLETION_FLAG 0x1
 189
 190/* Matches Windows-end */
 191enum storvsc_request_type {
 192        WRITE_TYPE = 0,
 193        READ_TYPE,
 194        UNKNOWN_TYPE,
 195};
 196
 197/*
 198 * SRB status codes and masks; a subset of the codes used here.
 199 */
 200
 201#define SRB_STATUS_AUTOSENSE_VALID      0x80
 202#define SRB_STATUS_INVALID_LUN  0x20
 203#define SRB_STATUS_SUCCESS      0x01
 204#define SRB_STATUS_ABORTED      0x02
 205#define SRB_STATUS_ERROR        0x04
 206
 207/*
 208 * This is the end of Protocol specific defines.
 209 */
 210
 211
 212/*
 213 * We setup a mempool to allocate request structures for this driver
 214 * on a per-lun basis. The following define specifies the number of
 215 * elements in the pool.
 216 */
 217
 218#define STORVSC_MIN_BUF_NR                              64
 219static int storvsc_ringbuffer_size = (20 * PAGE_SIZE);
 220
 221module_param(storvsc_ringbuffer_size, int, S_IRUGO);
 222MODULE_PARM_DESC(storvsc_ringbuffer_size, "Ring buffer size (bytes)");
 223
 224#define STORVSC_MAX_IO_REQUESTS                         128
 225
 226/*
 227 * In Hyper-V, each port/path/target maps to 1 scsi host adapter.  In
 228 * reality, the path/target is not used (ie always set to 0) so our
 229 * scsi host adapter essentially has 1 bus with 1 target that contains
 230 * up to 256 luns.
 231 */
 232#define STORVSC_MAX_LUNS_PER_TARGET                     64
 233#define STORVSC_MAX_TARGETS                             1
 234#define STORVSC_MAX_CHANNELS                            1
 235
 236
 237
 238struct storvsc_cmd_request {
 239        struct list_head entry;
 240        struct scsi_cmnd *cmd;
 241
 242        unsigned int bounce_sgl_count;
 243        struct scatterlist *bounce_sgl;
 244
 245        struct hv_device *device;
 246
 247        /* Synchronize the request/response if needed */
 248        struct completion wait_event;
 249
 250        unsigned char *sense_buffer;
 251        struct hv_multipage_buffer data_buffer;
 252        struct vstor_packet vstor_packet;
 253};
 254
 255
 256/* A storvsc device is a device object that contains a vmbus channel */
 257struct storvsc_device {
 258        struct hv_device *device;
 259
 260        bool     destroy;
 261        bool     drain_notify;
 262        atomic_t num_outstanding_req;
 263        struct Scsi_Host *host;
 264
 265        wait_queue_head_t waiting_to_drain;
 266
 267        /*
 268         * Each unique Port/Path/Target represents 1 channel ie scsi
 269         * controller. In reality, the pathid, targetid is always 0
 270         * and the port is set by us
 271         */
 272        unsigned int port_number;
 273        unsigned char path_id;
 274        unsigned char target_id;
 275
 276        /* Used for vsc/vsp channel reset process */
 277        struct storvsc_cmd_request init_request;
 278        struct storvsc_cmd_request reset_request;
 279};
 280
 281struct stor_mem_pools {
 282        struct kmem_cache *request_pool;
 283        mempool_t *request_mempool;
 284};
 285
 286struct hv_host_device {
 287        struct hv_device *dev;
 288        unsigned int port;
 289        unsigned char path;
 290        unsigned char target;
 291};
 292
 293struct storvsc_scan_work {
 294        struct work_struct work;
 295        struct Scsi_Host *host;
 296        uint lun;
 297};
 298
 299static void storvsc_device_scan(struct work_struct *work)
 300{
 301        struct storvsc_scan_work *wrk;
 302        uint lun;
 303        struct scsi_device *sdev;
 304
 305        wrk = container_of(work, struct storvsc_scan_work, work);
 306        lun = wrk->lun;
 307
 308        sdev = scsi_device_lookup(wrk->host, 0, 0, lun);
 309        if (!sdev)
 310                goto done;
 311        scsi_rescan_device(&sdev->sdev_gendev);
 312        scsi_device_put(sdev);
 313
 314done:
 315        kfree(wrk);
 316}
 317
 318static void storvsc_bus_scan(struct work_struct *work)
 319{
 320        struct storvsc_scan_work *wrk;
 321        int id, order_id;
 322
 323        wrk = container_of(work, struct storvsc_scan_work, work);
 324        for (id = 0; id < wrk->host->max_id; ++id) {
 325                if (wrk->host->reverse_ordering)
 326                        order_id = wrk->host->max_id - id - 1;
 327                else
 328                        order_id = id;
 329
 330                scsi_scan_target(&wrk->host->shost_gendev, 0,
 331                                order_id, SCAN_WILD_CARD, 1);
 332        }
 333        kfree(wrk);
 334}
 335
 336static void storvsc_remove_lun(struct work_struct *work)
 337{
 338        struct storvsc_scan_work *wrk;
 339        struct scsi_device *sdev;
 340
 341        wrk = container_of(work, struct storvsc_scan_work, work);
 342        if (!scsi_host_get(wrk->host))
 343                goto done;
 344
 345        sdev = scsi_device_lookup(wrk->host, 0, 0, wrk->lun);
 346
 347        if (sdev) {
 348                scsi_remove_device(sdev);
 349                scsi_device_put(sdev);
 350        }
 351        scsi_host_put(wrk->host);
 352
 353done:
 354        kfree(wrk);
 355}
 356
 357/*
 358 * Major/minor macros.  Minor version is in LSB, meaning that earlier flat
 359 * version numbers will be interpreted as "0.x" (i.e., 1 becomes 0.1).
 360 */
 361
 362static inline u16 storvsc_get_version(u8 major, u8 minor)
 363{
 364        u16 version;
 365
 366        version = ((major << 8) | minor);
 367        return version;
 368}
 369
 370/*
 371 * We can get incoming messages from the host that are not in response to
 372 * messages that we have sent out. An example of this would be messages
 373 * received by the guest to notify dynamic addition/removal of LUNs. To
 374 * deal with potential race conditions where the driver may be in the
 375 * midst of being unloaded when we might receive an unsolicited message
 376 * from the host, we have implemented a mechanism to gurantee sequential
 377 * consistency:
 378 *
 379 * 1) Once the device is marked as being destroyed, we will fail all
 380 *    outgoing messages.
 381 * 2) We permit incoming messages when the device is being destroyed,
 382 *    only to properly account for messages already sent out.
 383 */
 384
 385static inline struct storvsc_device *get_out_stor_device(
 386                                        struct hv_device *device)
 387{
 388        struct storvsc_device *stor_device;
 389
 390        stor_device = hv_get_drvdata(device);
 391
 392        if (stor_device && stor_device->destroy)
 393                stor_device = NULL;
 394
 395        return stor_device;
 396}
 397
 398
 399static inline void storvsc_wait_to_drain(struct storvsc_device *dev)
 400{
 401        dev->drain_notify = true;
 402        wait_event(dev->waiting_to_drain,
 403                   atomic_read(&dev->num_outstanding_req) == 0);
 404        dev->drain_notify = false;
 405}
 406
 407static inline struct storvsc_device *get_in_stor_device(
 408                                        struct hv_device *device)
 409{
 410        struct storvsc_device *stor_device;
 411
 412        stor_device = hv_get_drvdata(device);
 413
 414        if (!stor_device)
 415                goto get_in_err;
 416
 417        /*
 418         * If the device is being destroyed; allow incoming
 419         * traffic only to cleanup outstanding requests.
 420         */
 421
 422        if (stor_device->destroy  &&
 423                (atomic_read(&stor_device->num_outstanding_req) == 0))
 424                stor_device = NULL;
 425
 426get_in_err:
 427        return stor_device;
 428
 429}
 430
 431static void destroy_bounce_buffer(struct scatterlist *sgl,
 432                                  unsigned int sg_count)
 433{
 434        int i;
 435        struct page *page_buf;
 436
 437        for (i = 0; i < sg_count; i++) {
 438                page_buf = sg_page((&sgl[i]));
 439                if (page_buf != NULL)
 440                        __free_page(page_buf);
 441        }
 442
 443        kfree(sgl);
 444}
 445
 446static int do_bounce_buffer(struct scatterlist *sgl, unsigned int sg_count)
 447{
 448        int i;
 449
 450        /* No need to check */
 451        if (sg_count < 2)
 452                return -1;
 453
 454        /* We have at least 2 sg entries */
 455        for (i = 0; i < sg_count; i++) {
 456                if (i == 0) {
 457                        /* make sure 1st one does not have hole */
 458                        if (sgl[i].offset + sgl[i].length != PAGE_SIZE)
 459                                return i;
 460                } else if (i == sg_count - 1) {
 461                        /* make sure last one does not have hole */
 462                        if (sgl[i].offset != 0)
 463                                return i;
 464                } else {
 465                        /* make sure no hole in the middle */
 466                        if (sgl[i].length != PAGE_SIZE || sgl[i].offset != 0)
 467                                return i;
 468                }
 469        }
 470        return -1;
 471}
 472
 473static struct scatterlist *create_bounce_buffer(struct scatterlist *sgl,
 474                                                unsigned int sg_count,
 475                                                unsigned int len,
 476                                                int write)
 477{
 478        int i;
 479        int num_pages;
 480        struct scatterlist *bounce_sgl;
 481        struct page *page_buf;
 482        unsigned int buf_len = ((write == WRITE_TYPE) ? 0 : PAGE_SIZE);
 483
 484        num_pages = ALIGN(len, PAGE_SIZE) >> PAGE_SHIFT;
 485
 486        bounce_sgl = kcalloc(num_pages, sizeof(struct scatterlist), GFP_ATOMIC);
 487        if (!bounce_sgl)
 488                return NULL;
 489
 490        sg_init_table(bounce_sgl, num_pages);
 491        for (i = 0; i < num_pages; i++) {
 492                page_buf = alloc_page(GFP_ATOMIC);
 493                if (!page_buf)
 494                        goto cleanup;
 495                sg_set_page(&bounce_sgl[i], page_buf, buf_len, 0);
 496        }
 497
 498        return bounce_sgl;
 499
 500cleanup:
 501        destroy_bounce_buffer(bounce_sgl, num_pages);
 502        return NULL;
 503}
 504
 505/* Disgusting wrapper functions */
 506static inline unsigned long sg_kmap_atomic(struct scatterlist *sgl, int idx)
 507{
 508        void *addr = kmap_atomic(sg_page(sgl + idx));
 509        return (unsigned long)addr;
 510}
 511
 512static inline void sg_kunmap_atomic(unsigned long addr)
 513{
 514        kunmap_atomic((void *)addr);
 515}
 516
 517
 518/* Assume the original sgl has enough room */
 519static unsigned int copy_from_bounce_buffer(struct scatterlist *orig_sgl,
 520                                            struct scatterlist *bounce_sgl,
 521                                            unsigned int orig_sgl_count,
 522                                            unsigned int bounce_sgl_count)
 523{
 524        int i;
 525        int j = 0;
 526        unsigned long src, dest;
 527        unsigned int srclen, destlen, copylen;
 528        unsigned int total_copied = 0;
 529        unsigned long bounce_addr = 0;
 530        unsigned long dest_addr = 0;
 531        unsigned long flags;
 532
 533        local_irq_save(flags);
 534
 535        for (i = 0; i < orig_sgl_count; i++) {
 536                dest_addr = sg_kmap_atomic(orig_sgl,i) + orig_sgl[i].offset;
 537                dest = dest_addr;
 538                destlen = orig_sgl[i].length;
 539
 540                if (bounce_addr == 0)
 541                        bounce_addr = sg_kmap_atomic(bounce_sgl,j);
 542
 543                while (destlen) {
 544                        src = bounce_addr + bounce_sgl[j].offset;
 545                        srclen = bounce_sgl[j].length - bounce_sgl[j].offset;
 546
 547                        copylen = min(srclen, destlen);
 548                        memcpy((void *)dest, (void *)src, copylen);
 549
 550                        total_copied += copylen;
 551                        bounce_sgl[j].offset += copylen;
 552                        destlen -= copylen;
 553                        dest += copylen;
 554
 555                        if (bounce_sgl[j].offset == bounce_sgl[j].length) {
 556                                /* full */
 557                                sg_kunmap_atomic(bounce_addr);
 558                                j++;
 559
 560                                /*
 561                                 * It is possible that the number of elements
 562                                 * in the bounce buffer may not be equal to
 563                                 * the number of elements in the original
 564                                 * scatter list. Handle this correctly.
 565                                 */
 566
 567                                if (j == bounce_sgl_count) {
 568                                        /*
 569                                         * We are done; cleanup and return.
 570                                         */
 571                                        sg_kunmap_atomic(dest_addr - orig_sgl[i].offset);
 572                                        local_irq_restore(flags);
 573                                        return total_copied;
 574                                }
 575
 576                                /* if we need to use another bounce buffer */
 577                                if (destlen || i != orig_sgl_count - 1)
 578                                        bounce_addr = sg_kmap_atomic(bounce_sgl,j);
 579                        } else if (destlen == 0 && i == orig_sgl_count - 1) {
 580                                /* unmap the last bounce that is < PAGE_SIZE */
 581                                sg_kunmap_atomic(bounce_addr);
 582                        }
 583                }
 584
 585                sg_kunmap_atomic(dest_addr - orig_sgl[i].offset);
 586        }
 587
 588        local_irq_restore(flags);
 589
 590        return total_copied;
 591}
 592
 593/* Assume the bounce_sgl has enough room ie using the create_bounce_buffer() */
 594static unsigned int copy_to_bounce_buffer(struct scatterlist *orig_sgl,
 595                                          struct scatterlist *bounce_sgl,
 596                                          unsigned int orig_sgl_count)
 597{
 598        int i;
 599        int j = 0;
 600        unsigned long src, dest;
 601        unsigned int srclen, destlen, copylen;
 602        unsigned int total_copied = 0;
 603        unsigned long bounce_addr = 0;
 604        unsigned long src_addr = 0;
 605        unsigned long flags;
 606
 607        local_irq_save(flags);
 608
 609        for (i = 0; i < orig_sgl_count; i++) {
 610                src_addr = sg_kmap_atomic(orig_sgl,i) + orig_sgl[i].offset;
 611                src = src_addr;
 612                srclen = orig_sgl[i].length;
 613
 614                if (bounce_addr == 0)
 615                        bounce_addr = sg_kmap_atomic(bounce_sgl,j);
 616
 617                while (srclen) {
 618                        /* assume bounce offset always == 0 */
 619                        dest = bounce_addr + bounce_sgl[j].length;
 620                        destlen = PAGE_SIZE - bounce_sgl[j].length;
 621
 622                        copylen = min(srclen, destlen);
 623                        memcpy((void *)dest, (void *)src, copylen);
 624
 625                        total_copied += copylen;
 626                        bounce_sgl[j].length += copylen;
 627                        srclen -= copylen;
 628                        src += copylen;
 629
 630                        if (bounce_sgl[j].length == PAGE_SIZE) {
 631                                /* full..move to next entry */
 632                                sg_kunmap_atomic(bounce_addr);
 633                                j++;
 634
 635                                /* if we need to use another bounce buffer */
 636                                if (srclen || i != orig_sgl_count - 1)
 637                                        bounce_addr = sg_kmap_atomic(bounce_sgl,j);
 638
 639                        } else if (srclen == 0 && i == orig_sgl_count - 1) {
 640                                /* unmap the last bounce that is < PAGE_SIZE */
 641                                sg_kunmap_atomic(bounce_addr);
 642                        }
 643                }
 644
 645                sg_kunmap_atomic(src_addr - orig_sgl[i].offset);
 646        }
 647
 648        local_irq_restore(flags);
 649
 650        return total_copied;
 651}
 652
 653static int storvsc_channel_init(struct hv_device *device)
 654{
 655        struct storvsc_device *stor_device;
 656        struct storvsc_cmd_request *request;
 657        struct vstor_packet *vstor_packet;
 658        int ret, t;
 659
 660        stor_device = get_out_stor_device(device);
 661        if (!stor_device)
 662                return -ENODEV;
 663
 664        request = &stor_device->init_request;
 665        vstor_packet = &request->vstor_packet;
 666
 667        /*
 668         * Now, initiate the vsc/vsp initialization protocol on the open
 669         * channel
 670         */
 671        memset(request, 0, sizeof(struct storvsc_cmd_request));
 672        init_completion(&request->wait_event);
 673        vstor_packet->operation = VSTOR_OPERATION_BEGIN_INITIALIZATION;
 674        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 675
 676        ret = vmbus_sendpacket(device->channel, vstor_packet,
 677                               sizeof(struct vstor_packet),
 678                               (unsigned long)request,
 679                               VM_PKT_DATA_INBAND,
 680                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 681        if (ret != 0)
 682                goto cleanup;
 683
 684        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 685        if (t == 0) {
 686                ret = -ETIMEDOUT;
 687                goto cleanup;
 688        }
 689
 690        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 691            vstor_packet->status != 0)
 692                goto cleanup;
 693
 694
 695        /* reuse the packet for version range supported */
 696        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 697        vstor_packet->operation = VSTOR_OPERATION_QUERY_PROTOCOL_VERSION;
 698        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 699
 700        vstor_packet->version.major_minor =
 701                storvsc_get_version(VMSTOR_CURRENT_MAJOR, VMSTOR_CURRENT_MINOR);
 702
 703        /*
 704         * The revision number is only used in Windows; set it to 0.
 705         */
 706        vstor_packet->version.revision = 0;
 707
 708        ret = vmbus_sendpacket(device->channel, vstor_packet,
 709                               sizeof(struct vstor_packet),
 710                               (unsigned long)request,
 711                               VM_PKT_DATA_INBAND,
 712                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 713        if (ret != 0)
 714                goto cleanup;
 715
 716        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 717        if (t == 0) {
 718                ret = -ETIMEDOUT;
 719                goto cleanup;
 720        }
 721
 722        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 723            vstor_packet->status != 0)
 724                goto cleanup;
 725
 726
 727        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 728        vstor_packet->operation = VSTOR_OPERATION_QUERY_PROPERTIES;
 729        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 730        vstor_packet->storage_channel_properties.port_number =
 731                                        stor_device->port_number;
 732
 733        ret = vmbus_sendpacket(device->channel, vstor_packet,
 734                               sizeof(struct vstor_packet),
 735                               (unsigned long)request,
 736                               VM_PKT_DATA_INBAND,
 737                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 738
 739        if (ret != 0)
 740                goto cleanup;
 741
 742        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 743        if (t == 0) {
 744                ret = -ETIMEDOUT;
 745                goto cleanup;
 746        }
 747
 748        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 749            vstor_packet->status != 0)
 750                goto cleanup;
 751
 752        stor_device->path_id = vstor_packet->storage_channel_properties.path_id;
 753        stor_device->target_id
 754                = vstor_packet->storage_channel_properties.target_id;
 755
 756        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 757        vstor_packet->operation = VSTOR_OPERATION_END_INITIALIZATION;
 758        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 759
 760        ret = vmbus_sendpacket(device->channel, vstor_packet,
 761                               sizeof(struct vstor_packet),
 762                               (unsigned long)request,
 763                               VM_PKT_DATA_INBAND,
 764                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 765
 766        if (ret != 0)
 767                goto cleanup;
 768
 769        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 770        if (t == 0) {
 771                ret = -ETIMEDOUT;
 772                goto cleanup;
 773        }
 774
 775        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 776            vstor_packet->status != 0)
 777                goto cleanup;
 778
 779
 780cleanup:
 781        return ret;
 782}
 783
 784static void storvsc_handle_error(struct vmscsi_request *vm_srb,
 785                                struct scsi_cmnd *scmnd,
 786                                struct Scsi_Host *host,
 787                                u8 asc, u8 ascq)
 788{
 789        struct storvsc_scan_work *wrk;
 790        void (*process_err_fn)(struct work_struct *work);
 791        bool do_work = false;
 792
 793        switch (vm_srb->srb_status) {
 794        case SRB_STATUS_ERROR:
 795                /*
 796                 * If there is an error; offline the device since all
 797                 * error recovery strategies would have already been
 798                 * deployed on the host side. However, if the command
 799                 * were a pass-through command deal with it appropriately.
 800                 */
 801                switch (scmnd->cmnd[0]) {
 802                case ATA_16:
 803                case ATA_12:
 804                        set_host_byte(scmnd, DID_PASSTHROUGH);
 805                        break;
 806                default:
 807                        set_host_byte(scmnd, DID_TARGET_FAILURE);
 808                }
 809                break;
 810        case SRB_STATUS_INVALID_LUN:
 811                do_work = true;
 812                process_err_fn = storvsc_remove_lun;
 813                break;
 814        case (SRB_STATUS_ABORTED | SRB_STATUS_AUTOSENSE_VALID):
 815                if ((asc == 0x2a) && (ascq == 0x9)) {
 816                        do_work = true;
 817                        process_err_fn = storvsc_device_scan;
 818                        /*
 819                         * Retry the I/O that trigerred this.
 820                         */
 821                        set_host_byte(scmnd, DID_REQUEUE);
 822                }
 823                break;
 824        }
 825
 826        if (!do_work)
 827                return;
 828
 829        /*
 830         * We need to schedule work to process this error; schedule it.
 831         */
 832        wrk = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
 833        if (!wrk) {
 834                set_host_byte(scmnd, DID_TARGET_FAILURE);
 835                return;
 836        }
 837
 838        wrk->host = host;
 839        wrk->lun = vm_srb->lun;
 840        INIT_WORK(&wrk->work, process_err_fn);
 841        schedule_work(&wrk->work);
 842}
 843
 844
 845static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
 846{
 847        struct scsi_cmnd *scmnd = cmd_request->cmd;
 848        struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
 849        void (*scsi_done_fn)(struct scsi_cmnd *);
 850        struct scsi_sense_hdr sense_hdr;
 851        struct vmscsi_request *vm_srb;
 852        struct stor_mem_pools *memp = scmnd->device->hostdata;
 853        struct Scsi_Host *host;
 854        struct storvsc_device *stor_dev;
 855        struct hv_device *dev = host_dev->dev;
 856
 857        stor_dev = get_in_stor_device(dev);
 858        host = stor_dev->host;
 859
 860        vm_srb = &cmd_request->vstor_packet.vm_srb;
 861        if (cmd_request->bounce_sgl_count) {
 862                if (vm_srb->data_in == READ_TYPE)
 863                        copy_from_bounce_buffer(scsi_sglist(scmnd),
 864                                        cmd_request->bounce_sgl,
 865                                        scsi_sg_count(scmnd),
 866                                        cmd_request->bounce_sgl_count);
 867                destroy_bounce_buffer(cmd_request->bounce_sgl,
 868                                        cmd_request->bounce_sgl_count);
 869        }
 870
 871        scmnd->result = vm_srb->scsi_status;
 872
 873        if (scmnd->result) {
 874                if (scsi_normalize_sense(scmnd->sense_buffer,
 875                                SCSI_SENSE_BUFFERSIZE, &sense_hdr))
 876                        scsi_print_sense_hdr("storvsc", &sense_hdr);
 877        }
 878
 879        if (vm_srb->srb_status != SRB_STATUS_SUCCESS)
 880                storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
 881                                         sense_hdr.ascq);
 882
 883        scsi_set_resid(scmnd,
 884                cmd_request->data_buffer.len -
 885                vm_srb->data_transfer_length);
 886
 887        scsi_done_fn = scmnd->scsi_done;
 888
 889        scmnd->host_scribble = NULL;
 890        scmnd->scsi_done = NULL;
 891
 892        scsi_done_fn(scmnd);
 893
 894        mempool_free(cmd_request, memp->request_mempool);
 895}
 896
 897static void storvsc_on_io_completion(struct hv_device *device,
 898                                  struct vstor_packet *vstor_packet,
 899                                  struct storvsc_cmd_request *request)
 900{
 901        struct storvsc_device *stor_device;
 902        struct vstor_packet *stor_pkt;
 903
 904        stor_device = hv_get_drvdata(device);
 905        stor_pkt = &request->vstor_packet;
 906
 907        /*
 908         * The current SCSI handling on the host side does
 909         * not correctly handle:
 910         * INQUIRY command with page code parameter set to 0x80
 911         * MODE_SENSE command with cmd[2] == 0x1c
 912         *
 913         * Setup srb and scsi status so this won't be fatal.
 914         * We do this so we can distinguish truly fatal failues
 915         * (srb status == 0x4) and off-line the device in that case.
 916         */
 917
 918        if ((stor_pkt->vm_srb.cdb[0] == INQUIRY) ||
 919           (stor_pkt->vm_srb.cdb[0] == MODE_SENSE)) {
 920                vstor_packet->vm_srb.scsi_status = 0;
 921                vstor_packet->vm_srb.srb_status = SRB_STATUS_SUCCESS;
 922        }
 923
 924
 925        /* Copy over the status...etc */
 926        stor_pkt->vm_srb.scsi_status = vstor_packet->vm_srb.scsi_status;
 927        stor_pkt->vm_srb.srb_status = vstor_packet->vm_srb.srb_status;
 928        stor_pkt->vm_srb.sense_info_length =
 929        vstor_packet->vm_srb.sense_info_length;
 930
 931        if (vstor_packet->vm_srb.scsi_status != 0 ||
 932                vstor_packet->vm_srb.srb_status != SRB_STATUS_SUCCESS){
 933                dev_warn(&device->device,
 934                         "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
 935                         stor_pkt->vm_srb.cdb[0],
 936                         vstor_packet->vm_srb.scsi_status,
 937                         vstor_packet->vm_srb.srb_status);
 938        }
 939
 940        if ((vstor_packet->vm_srb.scsi_status & 0xFF) == 0x02) {
 941                /* CHECK_CONDITION */
 942                if (vstor_packet->vm_srb.srb_status &
 943                        SRB_STATUS_AUTOSENSE_VALID) {
 944                        /* autosense data available */
 945                        dev_warn(&device->device,
 946                                 "stor pkt %p autosense data valid - len %d\n",
 947                                 request,
 948                                 vstor_packet->vm_srb.sense_info_length);
 949
 950                        memcpy(request->sense_buffer,
 951                               vstor_packet->vm_srb.sense_data,
 952                               vstor_packet->vm_srb.sense_info_length);
 953
 954                }
 955        }
 956
 957        stor_pkt->vm_srb.data_transfer_length =
 958        vstor_packet->vm_srb.data_transfer_length;
 959
 960        storvsc_command_completion(request);
 961
 962        if (atomic_dec_and_test(&stor_device->num_outstanding_req) &&
 963                stor_device->drain_notify)
 964                wake_up(&stor_device->waiting_to_drain);
 965
 966
 967}
 968
 969static void storvsc_on_receive(struct hv_device *device,
 970                             struct vstor_packet *vstor_packet,
 971                             struct storvsc_cmd_request *request)
 972{
 973        struct storvsc_scan_work *work;
 974        struct storvsc_device *stor_device;
 975
 976        switch (vstor_packet->operation) {
 977        case VSTOR_OPERATION_COMPLETE_IO:
 978                storvsc_on_io_completion(device, vstor_packet, request);
 979                break;
 980
 981        case VSTOR_OPERATION_REMOVE_DEVICE:
 982        case VSTOR_OPERATION_ENUMERATE_BUS:
 983                stor_device = get_in_stor_device(device);
 984                work = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
 985                if (!work)
 986                        return;
 987
 988                INIT_WORK(&work->work, storvsc_bus_scan);
 989                work->host = stor_device->host;
 990                schedule_work(&work->work);
 991                break;
 992
 993        default:
 994                break;
 995        }
 996}
 997
 998static void storvsc_on_channel_callback(void *context)
 999{
1000        struct hv_device *device = (struct hv_device *)context;
1001        struct storvsc_device *stor_device;
1002        u32 bytes_recvd;
1003        u64 request_id;
1004        unsigned char packet[ALIGN(sizeof(struct vstor_packet), 8)];
1005        struct storvsc_cmd_request *request;
1006        int ret;
1007
1008
1009        stor_device = get_in_stor_device(device);
1010        if (!stor_device)
1011                return;
1012
1013        do {
1014                ret = vmbus_recvpacket(device->channel, packet,
1015                                       ALIGN(sizeof(struct vstor_packet), 8),
1016                                       &bytes_recvd, &request_id);
1017                if (ret == 0 && bytes_recvd > 0) {
1018
1019                        request = (struct storvsc_cmd_request *)
1020                                        (unsigned long)request_id;
1021
1022                        if ((request == &stor_device->init_request) ||
1023                            (request == &stor_device->reset_request)) {
1024
1025                                memcpy(&request->vstor_packet, packet,
1026                                       sizeof(struct vstor_packet));
1027                                complete(&request->wait_event);
1028                        } else {
1029                                storvsc_on_receive(device,
1030                                                (struct vstor_packet *)packet,
1031                                                request);
1032                        }
1033                } else {
1034                        break;
1035                }
1036        } while (1);
1037
1038        return;
1039}
1040
1041static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size)
1042{
1043        struct vmstorage_channel_properties props;
1044        int ret;
1045
1046        memset(&props, 0, sizeof(struct vmstorage_channel_properties));
1047
1048        ret = vmbus_open(device->channel,
1049                         ring_size,
1050                         ring_size,
1051                         (void *)&props,
1052                         sizeof(struct vmstorage_channel_properties),
1053                         storvsc_on_channel_callback, device);
1054
1055        if (ret != 0)
1056                return ret;
1057
1058        ret = storvsc_channel_init(device);
1059
1060        return ret;
1061}
1062
1063static int storvsc_dev_remove(struct hv_device *device)
1064{
1065        struct storvsc_device *stor_device;
1066        unsigned long flags;
1067
1068        stor_device = hv_get_drvdata(device);
1069
1070        spin_lock_irqsave(&device->channel->inbound_lock, flags);
1071        stor_device->destroy = true;
1072        spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
1073
1074        /*
1075         * At this point, all outbound traffic should be disable. We
1076         * only allow inbound traffic (responses) to proceed so that
1077         * outstanding requests can be completed.
1078         */
1079
1080        storvsc_wait_to_drain(stor_device);
1081
1082        /*
1083         * Since we have already drained, we don't need to busy wait
1084         * as was done in final_release_stor_device()
1085         * Note that we cannot set the ext pointer to NULL until
1086         * we have drained - to drain the outgoing packets, we need to
1087         * allow incoming packets.
1088         */
1089        spin_lock_irqsave(&device->channel->inbound_lock, flags);
1090        hv_set_drvdata(device, NULL);
1091        spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
1092
1093        /* Close the channel */
1094        vmbus_close(device->channel);
1095
1096        kfree(stor_device);
1097        return 0;
1098}
1099
1100static int storvsc_do_io(struct hv_device *device,
1101                              struct storvsc_cmd_request *request)
1102{
1103        struct storvsc_device *stor_device;
1104        struct vstor_packet *vstor_packet;
1105        int ret = 0;
1106
1107        vstor_packet = &request->vstor_packet;
1108        stor_device = get_out_stor_device(device);
1109
1110        if (!stor_device)
1111                return -ENODEV;
1112
1113
1114        request->device  = device;
1115
1116
1117        vstor_packet->flags |= REQUEST_COMPLETION_FLAG;
1118
1119        vstor_packet->vm_srb.length = sizeof(struct vmscsi_request);
1120
1121
1122        vstor_packet->vm_srb.sense_info_length = STORVSC_SENSE_BUFFER_SIZE;
1123
1124
1125        vstor_packet->vm_srb.data_transfer_length =
1126        request->data_buffer.len;
1127
1128        vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
1129
1130        if (request->data_buffer.len) {
1131                ret = vmbus_sendpacket_multipagebuffer(device->channel,
1132                                &request->data_buffer,
1133                                vstor_packet,
1134                                sizeof(struct vstor_packet),
1135                                (unsigned long)request);
1136        } else {
1137                ret = vmbus_sendpacket(device->channel, vstor_packet,
1138                               sizeof(struct vstor_packet),
1139                               (unsigned long)request,
1140                               VM_PKT_DATA_INBAND,
1141                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1142        }
1143
1144        if (ret != 0)
1145                return ret;
1146
1147        atomic_inc(&stor_device->num_outstanding_req);
1148
1149        return ret;
1150}
1151
1152static int storvsc_device_alloc(struct scsi_device *sdevice)
1153{
1154        struct stor_mem_pools *memp;
1155        int number = STORVSC_MIN_BUF_NR;
1156
1157        memp = kzalloc(sizeof(struct stor_mem_pools), GFP_KERNEL);
1158        if (!memp)
1159                return -ENOMEM;
1160
1161        memp->request_pool =
1162                kmem_cache_create(dev_name(&sdevice->sdev_dev),
1163                                sizeof(struct storvsc_cmd_request), 0,
1164                                SLAB_HWCACHE_ALIGN, NULL);
1165
1166        if (!memp->request_pool)
1167                goto err0;
1168
1169        memp->request_mempool = mempool_create(number, mempool_alloc_slab,
1170                                                mempool_free_slab,
1171                                                memp->request_pool);
1172
1173        if (!memp->request_mempool)
1174                goto err1;
1175
1176        sdevice->hostdata = memp;
1177
1178        return 0;
1179
1180err1:
1181        kmem_cache_destroy(memp->request_pool);
1182
1183err0:
1184        kfree(memp);
1185        return -ENOMEM;
1186}
1187
1188static void storvsc_device_destroy(struct scsi_device *sdevice)
1189{
1190        struct stor_mem_pools *memp = sdevice->hostdata;
1191
1192        mempool_destroy(memp->request_mempool);
1193        kmem_cache_destroy(memp->request_pool);
1194        kfree(memp);
1195        sdevice->hostdata = NULL;
1196}
1197
1198static int storvsc_device_configure(struct scsi_device *sdevice)
1199{
1200        scsi_adjust_queue_depth(sdevice, MSG_SIMPLE_TAG,
1201                                STORVSC_MAX_IO_REQUESTS);
1202
1203        blk_queue_max_segment_size(sdevice->request_queue, PAGE_SIZE);
1204
1205        blk_queue_bounce_limit(sdevice->request_queue, BLK_BOUNCE_ANY);
1206
1207        sdevice->no_write_same = 1;
1208
1209        return 0;
1210}
1211
1212static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
1213                           sector_t capacity, int *info)
1214{
1215        sector_t nsect = capacity;
1216        sector_t cylinders = nsect;
1217        int heads, sectors_pt;
1218
1219        /*
1220         * We are making up these values; let us keep it simple.
1221         */
1222        heads = 0xff;
1223        sectors_pt = 0x3f;      /* Sectors per track */
1224        sector_div(cylinders, heads * sectors_pt);
1225        if ((sector_t)(cylinders + 1) * heads * sectors_pt < nsect)
1226                cylinders = 0xffff;
1227
1228        info[0] = heads;
1229        info[1] = sectors_pt;
1230        info[2] = (int)cylinders;
1231
1232        return 0;
1233}
1234
1235static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
1236{
1237        struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
1238        struct hv_device *device = host_dev->dev;
1239
1240        struct storvsc_device *stor_device;
1241        struct storvsc_cmd_request *request;
1242        struct vstor_packet *vstor_packet;
1243        int ret, t;
1244
1245
1246        stor_device = get_out_stor_device(device);
1247        if (!stor_device)
1248                return FAILED;
1249
1250        request = &stor_device->reset_request;
1251        vstor_packet = &request->vstor_packet;
1252
1253        init_completion(&request->wait_event);
1254
1255        vstor_packet->operation = VSTOR_OPERATION_RESET_BUS;
1256        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
1257        vstor_packet->vm_srb.path_id = stor_device->path_id;
1258
1259        ret = vmbus_sendpacket(device->channel, vstor_packet,
1260                               sizeof(struct vstor_packet),
1261                               (unsigned long)&stor_device->reset_request,
1262                               VM_PKT_DATA_INBAND,
1263                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1264        if (ret != 0)
1265                return FAILED;
1266
1267        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
1268        if (t == 0)
1269                return TIMEOUT_ERROR;
1270
1271
1272        /*
1273         * At this point, all outstanding requests in the adapter
1274         * should have been flushed out and return to us
1275         * There is a potential race here where the host may be in
1276         * the process of responding when we return from here.
1277         * Just wait for all in-transit packets to be accounted for
1278         * before we return from here.
1279         */
1280        storvsc_wait_to_drain(stor_device);
1281
1282        return SUCCESS;
1283}
1284
1285static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
1286{
1287        bool allowed = true;
1288        u8 scsi_op = scmnd->cmnd[0];
1289
1290        switch (scsi_op) {
1291        /* the host does not handle WRITE_SAME, log accident usage */
1292        case WRITE_SAME:
1293        /*
1294         * smartd sends this command and the host does not handle
1295         * this. So, don't send it.
1296         */
1297        case SET_WINDOW:
1298                scmnd->result = ILLEGAL_REQUEST << 16;
1299                allowed = false;
1300                break;
1301        default:
1302                break;
1303        }
1304        return allowed;
1305}
1306
1307static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
1308{
1309        int ret;
1310        struct hv_host_device *host_dev = shost_priv(host);
1311        struct hv_device *dev = host_dev->dev;
1312        struct storvsc_cmd_request *cmd_request;
1313        unsigned int request_size = 0;
1314        int i;
1315        struct scatterlist *sgl;
1316        unsigned int sg_count = 0;
1317        struct vmscsi_request *vm_srb;
1318        struct stor_mem_pools *memp = scmnd->device->hostdata;
1319
1320        if (!storvsc_scsi_cmd_ok(scmnd)) {
1321                scmnd->scsi_done(scmnd);
1322                return 0;
1323        }
1324
1325        request_size = sizeof(struct storvsc_cmd_request);
1326
1327        cmd_request = mempool_alloc(memp->request_mempool,
1328                                       GFP_ATOMIC);
1329
1330        /*
1331         * We might be invoked in an interrupt context; hence
1332         * mempool_alloc() can fail.
1333         */
1334        if (!cmd_request)
1335                return SCSI_MLQUEUE_DEVICE_BUSY;
1336
1337        memset(cmd_request, 0, sizeof(struct storvsc_cmd_request));
1338
1339        /* Setup the cmd request */
1340        cmd_request->cmd = scmnd;
1341
1342        scmnd->host_scribble = (unsigned char *)cmd_request;
1343
1344        vm_srb = &cmd_request->vstor_packet.vm_srb;
1345
1346
1347        /* Build the SRB */
1348        switch (scmnd->sc_data_direction) {
1349        case DMA_TO_DEVICE:
1350                vm_srb->data_in = WRITE_TYPE;
1351                break;
1352        case DMA_FROM_DEVICE:
1353                vm_srb->data_in = READ_TYPE;
1354                break;
1355        default:
1356                vm_srb->data_in = UNKNOWN_TYPE;
1357                break;
1358        }
1359
1360
1361        vm_srb->port_number = host_dev->port;
1362        vm_srb->path_id = scmnd->device->channel;
1363        vm_srb->target_id = scmnd->device->id;
1364        vm_srb->lun = scmnd->device->lun;
1365
1366        vm_srb->cdb_length = scmnd->cmd_len;
1367
1368        memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
1369
1370        cmd_request->sense_buffer = scmnd->sense_buffer;
1371
1372
1373        cmd_request->data_buffer.len = scsi_bufflen(scmnd);
1374        if (scsi_sg_count(scmnd)) {
1375                sgl = (struct scatterlist *)scsi_sglist(scmnd);
1376                sg_count = scsi_sg_count(scmnd);
1377
1378                /* check if we need to bounce the sgl */
1379                if (do_bounce_buffer(sgl, scsi_sg_count(scmnd)) != -1) {
1380                        cmd_request->bounce_sgl =
1381                                create_bounce_buffer(sgl, scsi_sg_count(scmnd),
1382                                                     scsi_bufflen(scmnd),
1383                                                     vm_srb->data_in);
1384                        if (!cmd_request->bounce_sgl) {
1385                                ret = SCSI_MLQUEUE_HOST_BUSY;
1386                                goto queue_error;
1387                        }
1388
1389                        cmd_request->bounce_sgl_count =
1390                                ALIGN(scsi_bufflen(scmnd), PAGE_SIZE) >>
1391                                        PAGE_SHIFT;
1392
1393                        if (vm_srb->data_in == WRITE_TYPE)
1394                                copy_to_bounce_buffer(sgl,
1395                                        cmd_request->bounce_sgl,
1396                                        scsi_sg_count(scmnd));
1397
1398                        sgl = cmd_request->bounce_sgl;
1399                        sg_count = cmd_request->bounce_sgl_count;
1400                }
1401
1402                cmd_request->data_buffer.offset = sgl[0].offset;
1403
1404                for (i = 0; i < sg_count; i++)
1405                        cmd_request->data_buffer.pfn_array[i] =
1406                                page_to_pfn(sg_page((&sgl[i])));
1407
1408        } else if (scsi_sglist(scmnd)) {
1409                cmd_request->data_buffer.offset =
1410                        virt_to_phys(scsi_sglist(scmnd)) & (PAGE_SIZE-1);
1411                cmd_request->data_buffer.pfn_array[0] =
1412                        virt_to_phys(scsi_sglist(scmnd)) >> PAGE_SHIFT;
1413        }
1414
1415        /* Invokes the vsc to start an IO */
1416        ret = storvsc_do_io(dev, cmd_request);
1417
1418        if (ret == -EAGAIN) {
1419                /* no more space */
1420
1421                if (cmd_request->bounce_sgl_count) {
1422                        destroy_bounce_buffer(cmd_request->bounce_sgl,
1423                                        cmd_request->bounce_sgl_count);
1424
1425                        ret = SCSI_MLQUEUE_DEVICE_BUSY;
1426                        goto queue_error;
1427                }
1428        }
1429
1430        return 0;
1431
1432queue_error:
1433        mempool_free(cmd_request, memp->request_mempool);
1434        scmnd->host_scribble = NULL;
1435        return ret;
1436}
1437
1438static struct scsi_host_template scsi_driver = {
1439        .module =               THIS_MODULE,
1440        .name =                 "storvsc_host_t",
1441        .bios_param =           storvsc_get_chs,
1442        .queuecommand =         storvsc_queuecommand,
1443        .eh_host_reset_handler =        storvsc_host_reset_handler,
1444        .slave_alloc =          storvsc_device_alloc,
1445        .slave_destroy =        storvsc_device_destroy,
1446        .slave_configure =      storvsc_device_configure,
1447        .cmd_per_lun =          1,
1448        /* 64 max_queue * 1 target */
1449        .can_queue =            STORVSC_MAX_IO_REQUESTS*STORVSC_MAX_TARGETS,
1450        .this_id =              -1,
1451        /* no use setting to 0 since ll_blk_rw reset it to 1 */
1452        /* currently 32 */
1453        .sg_tablesize =         MAX_MULTIPAGE_BUFFER_COUNT,
1454        .use_clustering =       DISABLE_CLUSTERING,
1455        /* Make sure we dont get a sg segment crosses a page boundary */
1456        .dma_boundary =         PAGE_SIZE-1,
1457};
1458
1459enum {
1460        SCSI_GUID,
1461        IDE_GUID,
1462};
1463
1464static const struct hv_vmbus_device_id id_table[] = {
1465        /* SCSI guid */
1466        { HV_SCSI_GUID,
1467          .driver_data = SCSI_GUID
1468        },
1469        /* IDE guid */
1470        { HV_IDE_GUID,
1471          .driver_data = IDE_GUID
1472        },
1473        { },
1474};
1475
1476MODULE_DEVICE_TABLE(vmbus, id_table);
1477
1478static int storvsc_probe(struct hv_device *device,
1479                        const struct hv_vmbus_device_id *dev_id)
1480{
1481        int ret;
1482        struct Scsi_Host *host;
1483        struct hv_host_device *host_dev;
1484        bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
1485        int target = 0;
1486        struct storvsc_device *stor_device;
1487
1488        host = scsi_host_alloc(&scsi_driver,
1489                               sizeof(struct hv_host_device));
1490        if (!host)
1491                return -ENOMEM;
1492
1493        host_dev = shost_priv(host);
1494        memset(host_dev, 0, sizeof(struct hv_host_device));
1495
1496        host_dev->port = host->host_no;
1497        host_dev->dev = device;
1498
1499
1500        stor_device = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
1501        if (!stor_device) {
1502                ret = -ENOMEM;
1503                goto err_out0;
1504        }
1505
1506        stor_device->destroy = false;
1507        init_waitqueue_head(&stor_device->waiting_to_drain);
1508        stor_device->device = device;
1509        stor_device->host = host;
1510        hv_set_drvdata(device, stor_device);
1511
1512        stor_device->port_number = host->host_no;
1513        ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size);
1514        if (ret)
1515                goto err_out1;
1516
1517        host_dev->path = stor_device->path_id;
1518        host_dev->target = stor_device->target_id;
1519
1520        /* max # of devices per target */
1521        host->max_lun = STORVSC_MAX_LUNS_PER_TARGET;
1522        /* max # of targets per channel */
1523        host->max_id = STORVSC_MAX_TARGETS;
1524        /* max # of channels */
1525        host->max_channel = STORVSC_MAX_CHANNELS - 1;
1526        /* max cmd length */
1527        host->max_cmd_len = STORVSC_MAX_CMD_LEN;
1528
1529        /* Register the HBA and start the scsi bus scan */
1530        ret = scsi_add_host(host, &device->device);
1531        if (ret != 0)
1532                goto err_out2;
1533
1534        if (!dev_is_ide) {
1535                scsi_scan_host(host);
1536        } else {
1537                target = (device->dev_instance.b[5] << 8 |
1538                         device->dev_instance.b[4]);
1539                ret = scsi_add_device(host, 0, target, 0);
1540                if (ret) {
1541                        scsi_remove_host(host);
1542                        goto err_out2;
1543                }
1544        }
1545        return 0;
1546
1547err_out2:
1548        /*
1549         * Once we have connected with the host, we would need to
1550         * to invoke storvsc_dev_remove() to rollback this state and
1551         * this call also frees up the stor_device; hence the jump around
1552         * err_out1 label.
1553         */
1554        storvsc_dev_remove(device);
1555        goto err_out0;
1556
1557err_out1:
1558        kfree(stor_device);
1559
1560err_out0:
1561        scsi_host_put(host);
1562        return ret;
1563}
1564
1565static int storvsc_remove(struct hv_device *dev)
1566{
1567        struct storvsc_device *stor_device = hv_get_drvdata(dev);
1568        struct Scsi_Host *host = stor_device->host;
1569
1570        scsi_remove_host(host);
1571        storvsc_dev_remove(dev);
1572        scsi_host_put(host);
1573
1574        return 0;
1575}
1576
1577static struct hv_driver storvsc_drv = {
1578        .name = KBUILD_MODNAME,
1579        .id_table = id_table,
1580        .probe = storvsc_probe,
1581        .remove = storvsc_remove,
1582};
1583
1584static int __init storvsc_drv_init(void)
1585{
1586        u32 max_outstanding_req_per_channel;
1587
1588        /*
1589         * Divide the ring buffer data size (which is 1 page less
1590         * than the ring buffer size since that page is reserved for
1591         * the ring buffer indices) by the max request size (which is
1592         * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)
1593         */
1594        max_outstanding_req_per_channel =
1595                ((storvsc_ringbuffer_size - PAGE_SIZE) /
1596                ALIGN(MAX_MULTIPAGE_BUFFER_PACKET +
1597                sizeof(struct vstor_packet) + sizeof(u64),
1598                sizeof(u64)));
1599
1600        if (max_outstanding_req_per_channel <
1601            STORVSC_MAX_IO_REQUESTS)
1602                return -EINVAL;
1603
1604        return vmbus_driver_register(&storvsc_drv);
1605}
1606
1607static void __exit storvsc_drv_exit(void)
1608{
1609        vmbus_driver_unregister(&storvsc_drv);
1610}
1611
1612MODULE_LICENSE("GPL");
1613MODULE_VERSION(HV_DRV_VERSION);
1614MODULE_DESCRIPTION("Microsoft Hyper-V virtual storage driver");
1615module_init(storvsc_drv_init);
1616module_exit(storvsc_drv_exit);
1617
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.