K. Y. Srinivasan
2011-Apr-06 21:34 UTC
[RESEND] [PATCH 00/22] Staging: hv: Cleanup-storage-drivers-phase-III
The latest upstream merge changed struct block_device_operations: This merge got rid of blkvsc_media_changed and introduced the function blkvsc_check_events. This broke all the patches that were sent after the tree was closed the last time. This is a resend of this patch-set to account for this change in the kernel. This patch-set deals with some of the style isues in blkvsc_drv.c. We also get rid most of the "dead code" in this file: 1) Get rid of most of the forward declarations in this file. The only remaining forward declarations are to deal with circular dependencies. 2) Get rid of most of the dead code in the file. Some of the functions in this file are place holders - they are not fuly implementedi yet (blkvsc_ioctl(), blkvsc_media_changed(). We have retained some comments/dead code, to help us in the final implementation. Regads, K. Y
K. Y. Srinivasan
2011-Apr-06 21:34 UTC
[PATCH 01/22] Staging: hv: Get rid of the forward declaration of blkvsc_submit_request()
Get rid of the forward declaration of blkvsc_submit_request() by moving the
code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 117 ++++++++++++++++++++-------------------
1 files changed, 59 insertions(+), 58 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index d1ecd60..efcc916 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -184,6 +184,65 @@ static int blk_vsc_initialize(struct hv_driver *driver)
return ret;
}
+
+static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
+ void (*request_completion)(struct hv_storvsc_request *))
+{
+ struct block_device_context *blkdev = blkvsc_req->dev;
+ struct hv_device *device_ctx = blkdev->device_ctx;
+ struct hv_driver *drv + drv_to_hv_drv(device_ctx->device.driver);
+ struct storvsc_driver_object *storvsc_drv_obj + drv->priv;
+ struct hv_storvsc_request *storvsc_req;
+ struct vmscsi_request *vm_srb;
+ int ret;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
+ "req %p type %s start_sector %lu count %ld offset %d "
+ "len %d\n", blkvsc_req,
+ (blkvsc_req->write) ? "WRITE" : "READ",
+ (unsigned long) blkvsc_req->sector_start,
+ blkvsc_req->sector_count,
+ blkvsc_req->request.data_buffer.offset,
+ blkvsc_req->request.data_buffer.len);
+#if 0
+ for (i = 0; i < (blkvsc_req->request.data_buffer.len >> 12); i++)
{
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
+ "req %p pfn[%d] %llx\n",
+ blkvsc_req, i,
+ blkvsc_req->request.data_buffer.pfn_array[i]);
+ }
+#endif
+
+ storvsc_req = &blkvsc_req->request;
+ vm_srb = &storvsc_req->vstor_packet.vm_srb;
+
+ vm_srb->data_in = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;
+
+ storvsc_req->on_io_completion = request_completion;
+ storvsc_req->context = blkvsc_req;
+
+ vm_srb->port_number = blkdev->port;
+ vm_srb->path_id = blkdev->path;
+ vm_srb->target_id = blkdev->target;
+ vm_srb->lun = 0; /* this is not really used at all */
+
+ vm_srb->cdb_length = blkvsc_req->cmd_len;
+
+ memcpy(vm_srb->cdb, blkvsc_req->cmnd, vm_srb->cdb_length);
+
+ storvsc_req->sense_buffer = blkvsc_req->sense_buffer;
+
+ ret = storvsc_drv_obj->on_io_request(blkdev->device_ctx,
+ &blkvsc_req->request);
+ if (ret == 0)
+ blkdev->num_outstanding_reqs++;
+
+ return ret;
+}
+
+
/* Static decl */
static DEFINE_MUTEX(blkvsc_mutex);
static int blkvsc_probe(struct device *dev);
@@ -202,8 +261,6 @@ static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
-static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
- void (*request_completion)(struct hv_storvsc_request *));
static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req);
static void blkvsc_cmd_completion(struct hv_storvsc_request *request);
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
@@ -891,62 +948,6 @@ static void blkvsc_init_rw(struct blkvsc_request
*blkvsc_req)
}
}
-static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req,
- void (*request_completion)(struct hv_storvsc_request *))
-{
- struct block_device_context *blkdev = blkvsc_req->dev;
- struct hv_device *device_ctx = blkdev->device_ctx;
- struct hv_driver *drv - drv_to_hv_drv(device_ctx->device.driver);
- struct storvsc_driver_object *storvsc_drv_obj - drv->priv;
- struct hv_storvsc_request *storvsc_req;
- struct vmscsi_request *vm_srb;
- int ret;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
- "req %p type %s start_sector %lu count %ld offset %d "
- "len %d\n", blkvsc_req,
- (blkvsc_req->write) ? "WRITE" : "READ",
- (unsigned long) blkvsc_req->sector_start,
- blkvsc_req->sector_count,
- blkvsc_req->request.data_buffer.offset,
- blkvsc_req->request.data_buffer.len);
-#if 0
- for (i = 0; i < (blkvsc_req->request.data_buffer.len >> 12); i++)
{
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
- "req %p pfn[%d] %llx\n",
- blkvsc_req, i,
- blkvsc_req->request.data_buffer.pfn_array[i]);
- }
-#endif
-
- storvsc_req = &blkvsc_req->request;
- vm_srb = &storvsc_req->vstor_packet.vm_srb;
-
- vm_srb->data_in = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;
-
- storvsc_req->on_io_completion = request_completion;
- storvsc_req->context = blkvsc_req;
-
- vm_srb->port_number = blkdev->port;
- vm_srb->path_id = blkdev->path;
- vm_srb->target_id = blkdev->target;
- vm_srb->lun = 0; /* this is not really used at all */
-
- vm_srb->cdb_length = blkvsc_req->cmd_len;
-
- memcpy(vm_srb->cdb, blkvsc_req->cmnd, vm_srb->cdb_length);
-
- storvsc_req->sense_buffer = blkvsc_req->sense_buffer;
-
- ret = storvsc_drv_obj->on_io_request(blkdev->device_ctx,
- &blkvsc_req->request);
- if (ret == 0)
- blkdev->num_outstanding_reqs++;
-
- return ret;
-}
/*
* We break the request into 1 or more blkvsc_requests and submit
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 02/22] Staging: hv: Get rid of the forward declaration of blkvsc_check_events()
Get rid of the forward declaration of blkvsc_check_events()
by moving the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 17 ++++++++---------
1 files changed, 8 insertions(+), 9 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index efcc916..4452700 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -243,6 +243,14 @@ static int blkvsc_submit_request(struct blkvsc_request
*blkvsc_req,
}
+static unsigned int blkvsc_check_events(struct gendisk *gd,
+ unsigned int clearing)
+{
+ DPRINT_DBG(BLKVSC_DRV, "- enter\n");
+ return DISK_EVENT_MEDIA_CHANGE;
+}
+
+
/* Static decl */
static DEFINE_MUTEX(blkvsc_mutex);
static int blkvsc_probe(struct device *dev);
@@ -251,8 +259,6 @@ static void blkvsc_shutdown(struct device *device);
static int blkvsc_open(struct block_device *bdev, fmode_t mode);
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
-static unsigned int blkvsc_check_events(struct gendisk *gd,
- unsigned int clearing);
static int blkvsc_revalidate_disk(struct gendisk *gd);
static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg);
static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
@@ -1407,13 +1413,6 @@ static int blkvsc_release(struct gendisk *disk, fmode_t
mode)
return 0;
}
-static unsigned int blkvsc_check_events(struct gendisk *gd,
- unsigned int clearing)
-{
- DPRINT_DBG(BLKVSC_DRV, "- enter\n");
- return DISK_EVENT_MEDIA_CHANGE;
-}
-
static int blkvsc_revalidate_disk(struct gendisk *gd)
{
struct block_device_context *blkdev = gd->private_data;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 03/22] Staging: hv: Get rid of the forward declaration of blkvsc_open()
Get rid of the forward declaration of blkvsc_open() by moving the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 49 +++++++++++++++++++--------------------
1 files changed, 24 insertions(+), 25 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 4452700..173abe3 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -106,6 +106,7 @@ struct block_device_context {
int users;
};
+static DEFINE_MUTEX(blkvsc_mutex);
static const char *g_blk_driver_name = "blkvsc";
@@ -251,13 +252,34 @@ static unsigned int blkvsc_check_events(struct gendisk
*gd,
}
+static int blkvsc_open(struct block_device *bdev, fmode_t mode)
+{
+ struct block_device_context *blkdev = bdev->bd_disk->private_data;
+
+ DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
+ blkdev->gd->disk_name);
+
+ mutex_lock(&blkvsc_mutex);
+ spin_lock(&blkdev->lock);
+
+ if (!blkdev->users && blkdev->device_type == DVD_TYPE) {
+ spin_unlock(&blkdev->lock);
+ check_disk_change(bdev);
+ spin_lock(&blkdev->lock);
+ }
+
+ blkdev->users++;
+
+ spin_unlock(&blkdev->lock);
+ mutex_unlock(&blkvsc_mutex);
+ return 0;
+}
+
/* Static decl */
-static DEFINE_MUTEX(blkvsc_mutex);
static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device);
static void blkvsc_shutdown(struct device *device);
-static int blkvsc_open(struct block_device *bdev, fmode_t mode);
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
static int blkvsc_revalidate_disk(struct gendisk *gd);
static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg);
@@ -1368,29 +1390,6 @@ static void blkvsc_request(struct request_queue *queue)
}
}
-static int blkvsc_open(struct block_device *bdev, fmode_t mode)
-{
- struct block_device_context *blkdev = bdev->bd_disk->private_data;
-
- DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
- blkdev->gd->disk_name);
-
- mutex_lock(&blkvsc_mutex);
- spin_lock(&blkdev->lock);
-
- if (!blkdev->users && blkdev->device_type == DVD_TYPE) {
- spin_unlock(&blkdev->lock);
- check_disk_change(bdev);
- spin_lock(&blkdev->lock);
- }
-
- blkdev->users++;
-
- spin_unlock(&blkdev->lock);
- mutex_unlock(&blkvsc_mutex);
- return 0;
-}
-
static int blkvsc_release(struct gendisk *disk, fmode_t mode)
{
struct block_device_context *blkdev = disk->private_data;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 04/22] Staging: hv: Get rid of the forward declaration of blkvsc_getgeo()
Get rid of the forward declaration of blkvsc_getgeo() by moving the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 162 +++++++++++++++++++-------------------
1 files changed, 81 insertions(+), 81 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 173abe3..69048e3 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -275,6 +275,87 @@ static int blkvsc_open(struct block_device *bdev, fmode_t
mode)
return 0;
}
+
+static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg)
+{
+ sector_t total_sectors = get_capacity(bd->bd_disk);
+ sector_t cylinder_times_heads = 0;
+ sector_t temp = 0;
+
+ int sectors_per_track = 0;
+ int heads = 0;
+ int cylinders = 0;
+ int rem = 0;
+
+ if (total_sectors > (65535 * 16 * 255))
+ total_sectors = (65535 * 16 * 255);
+
+ if (total_sectors >= (65535 * 16 * 63)) {
+ sectors_per_track = 255;
+ heads = 16;
+
+ cylinder_times_heads = total_sectors;
+ /* sector_div stores the quotient in cylinder_times_heads */
+ rem = sector_div(cylinder_times_heads, sectors_per_track);
+ } else {
+ sectors_per_track = 17;
+
+ cylinder_times_heads = total_sectors;
+ /* sector_div stores the quotient in cylinder_times_heads */
+ rem = sector_div(cylinder_times_heads, sectors_per_track);
+
+ temp = cylinder_times_heads + 1023;
+ /* sector_div stores the quotient in temp */
+ rem = sector_div(temp, 1024);
+
+ heads = temp;
+
+ if (heads < 4)
+ heads = 4;
+
+
+ if (cylinder_times_heads >= (heads * 1024) || (heads > 16)) {
+ sectors_per_track = 31;
+ heads = 16;
+
+ cylinder_times_heads = total_sectors;
+ /*
+ * sector_div stores the quotient in
+ * cylinder_times_heads
+ */
+ rem = sector_div(cylinder_times_heads,
+ sectors_per_track);
+ }
+
+ if (cylinder_times_heads >= (heads * 1024)) {
+ sectors_per_track = 63;
+ heads = 16;
+
+ cylinder_times_heads = total_sectors;
+ /*
+ * sector_div stores the quotient in
+ * cylinder_times_heads
+ */
+ rem = sector_div(cylinder_times_heads,
+ sectors_per_track);
+ }
+ }
+
+ temp = cylinder_times_heads;
+ /* sector_div stores the quotient in temp */
+ rem = sector_div(temp, heads);
+ cylinders = temp;
+
+ hg->heads = heads;
+ hg->sectors = sectors_per_track;
+ hg->cylinders = cylinders;
+
+ DPRINT_INFO(BLKVSC_DRV, "CHS (%d, %d, %d)", cylinders, heads,
+ sectors_per_track);
+
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device);
@@ -282,7 +363,6 @@ static void blkvsc_shutdown(struct device *device);
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
static int blkvsc_revalidate_disk(struct gendisk *gd);
-static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg);
static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
unsigned cmd, unsigned long argument);
static void blkvsc_request(struct request_queue *queue);
@@ -1427,86 +1507,6 @@ static int blkvsc_revalidate_disk(struct gendisk *gd)
return 0;
}
-static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg)
-{
- sector_t total_sectors = get_capacity(bd->bd_disk);
- sector_t cylinder_times_heads = 0;
- sector_t temp = 0;
-
- int sectors_per_track = 0;
- int heads = 0;
- int cylinders = 0;
- int rem = 0;
-
- if (total_sectors > (65535 * 16 * 255))
- total_sectors = (65535 * 16 * 255);
-
- if (total_sectors >= (65535 * 16 * 63)) {
- sectors_per_track = 255;
- heads = 16;
-
- cylinder_times_heads = total_sectors;
- /* sector_div stores the quotient in cylinder_times_heads */
- rem = sector_div(cylinder_times_heads, sectors_per_track);
- } else {
- sectors_per_track = 17;
-
- cylinder_times_heads = total_sectors;
- /* sector_div stores the quotient in cylinder_times_heads */
- rem = sector_div(cylinder_times_heads, sectors_per_track);
-
- temp = cylinder_times_heads + 1023;
- /* sector_div stores the quotient in temp */
- rem = sector_div(temp, 1024);
-
- heads = temp;
-
- if (heads < 4)
- heads = 4;
-
-
- if (cylinder_times_heads >= (heads * 1024) || (heads > 16)) {
- sectors_per_track = 31;
- heads = 16;
-
- cylinder_times_heads = total_sectors;
- /*
- * sector_div stores the quotient in
- * cylinder_times_heads
- */
- rem = sector_div(cylinder_times_heads,
- sectors_per_track);
- }
-
- if (cylinder_times_heads >= (heads * 1024)) {
- sectors_per_track = 63;
- heads = 16;
-
- cylinder_times_heads = total_sectors;
- /*
- * sector_div stores the quotient in
- * cylinder_times_heads
- */
- rem = sector_div(cylinder_times_heads,
- sectors_per_track);
- }
- }
-
- temp = cylinder_times_heads;
- /* sector_div stores the quotient in temp */
- rem = sector_div(temp, heads);
- cylinders = temp;
-
- hg->heads = heads;
- hg->sectors = sectors_per_track;
- hg->cylinders = cylinders;
-
- DPRINT_INFO(BLKVSC_DRV, "CHS (%d, %d, %d)", cylinders, heads,
- sectors_per_track);
-
- return 0;
-}
-
static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
unsigned cmd, unsigned long argument)
{
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 05/22] Staging: hv: Get rid of the forward declaration of blkvsc_init_rw()
Get rid of the forward declaration of blkvsc_init_rw() by moving the
code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 117 ++++++++++++++++++++-------------------
1 files changed, 59 insertions(+), 58 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 69048e3..5f14bb6 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -356,6 +356,65 @@ static int blkvsc_getgeo(struct block_device *bd, struct
hd_geometry *hg)
return 0;
}
+
+static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req)
+{
+ /* ASSERT(blkvsc_req->req); */
+ /* ASSERT(blkvsc_req->sector_count <+
(MAX_MULTIPAGE_BUFFER_COUNT*8)); */
+
+ blkvsc_req->cmd_len = 16;
+
+ if (blkvsc_req->sector_start > 0xffffffff) {
+ if (rq_data_dir(blkvsc_req->req)) {
+ blkvsc_req->write = 1;
+ blkvsc_req->cmnd[0] = WRITE_16;
+ } else {
+ blkvsc_req->write = 0;
+ blkvsc_req->cmnd[0] = READ_16;
+ }
+
+ blkvsc_req->cmnd[1] |+ (blkvsc_req->req->cmd_flags & REQ_FUA)
? 0x8 : 0;
+
+ *(unsigned long long *)&blkvsc_req->cmnd[2] +
cpu_to_be64(blkvsc_req->sector_start);
+ *(unsigned int *)&blkvsc_req->cmnd[10] +
cpu_to_be32(blkvsc_req->sector_count);
+ } else if ((blkvsc_req->sector_count > 0xff) ||
+ (blkvsc_req->sector_start > 0x1fffff)) {
+ if (rq_data_dir(blkvsc_req->req)) {
+ blkvsc_req->write = 1;
+ blkvsc_req->cmnd[0] = WRITE_10;
+ } else {
+ blkvsc_req->write = 0;
+ blkvsc_req->cmnd[0] = READ_10;
+ }
+
+ blkvsc_req->cmnd[1] |+ (blkvsc_req->req->cmd_flags & REQ_FUA)
? 0x8 : 0;
+
+ *(unsigned int *)&blkvsc_req->cmnd[2] +
cpu_to_be32(blkvsc_req->sector_start);
+ *(unsigned short *)&blkvsc_req->cmnd[7] +
cpu_to_be16(blkvsc_req->sector_count);
+ } else {
+ if (rq_data_dir(blkvsc_req->req)) {
+ blkvsc_req->write = 1;
+ blkvsc_req->cmnd[0] = WRITE_6;
+ } else {
+ blkvsc_req->write = 0;
+ blkvsc_req->cmnd[0] = READ_6;
+ }
+
+ *(unsigned int *)&blkvsc_req->cmnd[1] +
cpu_to_be32(blkvsc_req->sector_start) >> 8;
+ blkvsc_req->cmnd[1] &= 0x1f;
+ blkvsc_req->cmnd[4] = (unsigned char)blkvsc_req->sector_count;
+ }
+}
+
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device);
@@ -369,7 +428,6 @@ static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
-static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req);
static void blkvsc_cmd_completion(struct hv_storvsc_request *request);
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity(struct block_device_context *blkdev);
@@ -1000,63 +1058,6 @@ static int blkvsc_remove(struct device *device)
return ret;
}
-static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req)
-{
- /* ASSERT(blkvsc_req->req); */
- /* ASSERT(blkvsc_req->sector_count <= (MAX_MULTIPAGE_BUFFER_COUNT*8));
*/
-
- blkvsc_req->cmd_len = 16;
-
- if (blkvsc_req->sector_start > 0xffffffff) {
- if (rq_data_dir(blkvsc_req->req)) {
- blkvsc_req->write = 1;
- blkvsc_req->cmnd[0] = WRITE_16;
- } else {
- blkvsc_req->write = 0;
- blkvsc_req->cmnd[0] = READ_16;
- }
-
- blkvsc_req->cmnd[1] |- (blkvsc_req->req->cmd_flags & REQ_FUA)
? 0x8 : 0;
-
- *(unsigned long long *)&blkvsc_req->cmnd[2] -
cpu_to_be64(blkvsc_req->sector_start);
- *(unsigned int *)&blkvsc_req->cmnd[10] -
cpu_to_be32(blkvsc_req->sector_count);
- } else if ((blkvsc_req->sector_count > 0xff) ||
- (blkvsc_req->sector_start > 0x1fffff)) {
- if (rq_data_dir(blkvsc_req->req)) {
- blkvsc_req->write = 1;
- blkvsc_req->cmnd[0] = WRITE_10;
- } else {
- blkvsc_req->write = 0;
- blkvsc_req->cmnd[0] = READ_10;
- }
-
- blkvsc_req->cmnd[1] |- (blkvsc_req->req->cmd_flags & REQ_FUA)
? 0x8 : 0;
-
- *(unsigned int *)&blkvsc_req->cmnd[2] -
cpu_to_be32(blkvsc_req->sector_start);
- *(unsigned short *)&blkvsc_req->cmnd[7] -
cpu_to_be16(blkvsc_req->sector_count);
- } else {
- if (rq_data_dir(blkvsc_req->req)) {
- blkvsc_req->write = 1;
- blkvsc_req->cmnd[0] = WRITE_6;
- } else {
- blkvsc_req->write = 0;
- blkvsc_req->cmnd[0] = READ_6;
- }
-
- *(unsigned int *)&blkvsc_req->cmnd[1] -
cpu_to_be32(blkvsc_req->sector_start) >> 8;
- blkvsc_req->cmnd[1] &= 0x1f;
- blkvsc_req->cmnd[4] = (unsigned char)blkvsc_req->sector_count;
- }
-}
-
-
/*
* We break the request into 1 or more blkvsc_requests and submit
* them. If we cant submit them all, we put them on the
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 06/22] Staging: hv: Get rid of the forward declaration of blkvsc_ioctl()
Get rid of the forward declaration of blkvsc_ioctl() by moving the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 56 ++++++++++++++++++--------------------
1 files changed, 27 insertions(+), 29 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 5f14bb6..a16f38c 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -415,6 +415,33 @@ static void blkvsc_init_rw(struct blkvsc_request
*blkvsc_req)
}
+static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
+ unsigned cmd, unsigned long argument)
+{
+/* struct block_device_context *blkdev = bd->bd_disk->private_data; */
+ int ret;
+
+ switch (cmd) {
+ /*
+ * TODO: I think there is certain format for HDIO_GET_IDENTITY rather
+ * than just a GUID. Commented it out for now.
+ */
+#if 0
+ case HDIO_GET_IDENTITY:
+ DPRINT_INFO(BLKVSC_DRV, "HDIO_GET_IDENTITY\n");
+ if (copy_to_user((void __user *)arg, blkdev->device_id,
+ blkdev->device_id_len))
+ ret = -EFAULT;
+ break;
+#endif
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device);
@@ -422,8 +449,6 @@ static void blkvsc_shutdown(struct device *device);
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
static int blkvsc_revalidate_disk(struct gendisk *gd);
-static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
- unsigned cmd, unsigned long argument);
static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
@@ -1508,33 +1533,6 @@ static int blkvsc_revalidate_disk(struct gendisk *gd)
return 0;
}
-static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
- unsigned cmd, unsigned long argument)
-{
-/* struct block_device_context *blkdev = bd->bd_disk->private_data; */
- int ret;
-
- switch (cmd) {
- /*
- * TODO: I think there is certain format for HDIO_GET_IDENTITY rather
- * than just a GUID. Commented it out for now.
- */
-#if 0
- case HDIO_GET_IDENTITY:
- DPRINT_INFO(BLKVSC_DRV, "HDIO_GET_IDENTITY\n");
- if (copy_to_user((void __user *)arg, blkdev->device_id,
- blkdev->device_id_len))
- ret = -EFAULT;
- break;
-#endif
- default:
- ret = -EINVAL;
- break;
- }
-
- return ret;
-}
-
static int __init blkvsc_init(void)
{
int ret;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 07/22] Staging: hv: Get rid of the forward declaration of blkvsc_cmd_completion()
Get rid of the forward declaration of blkvsc_cmd_completion() by moving the
code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 48 +++++++++++++++++++-------------------
1 files changed, 24 insertions(+), 24 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index a16f38c..068daee 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -442,6 +442,30 @@ static int blkvsc_ioctl(struct block_device *bd, fmode_t
mode,
return ret;
}
+static void blkvsc_cmd_completion(struct hv_storvsc_request *request)
+{
+ struct blkvsc_request *blkvsc_req + (struct blkvsc_request
*)request->context;
+ struct block_device_context *blkdev + (struct block_device_context
*)blkvsc_req->dev;
+ struct scsi_sense_hdr sense_hdr;
+ struct vmscsi_request *vm_srb;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_cmd_completion() - req %p\n",
+ blkvsc_req);
+
+ vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
+ blkdev->num_outstanding_reqs--;
+
+ if (vm_srb->scsi_status)
+ if (scsi_normalize_sense(blkvsc_req->sense_buffer,
+ SCSI_SENSE_BUFFERSIZE, &sense_hdr))
+ scsi_print_sense_hdr("blkvsc", &sense_hdr);
+
+ complete(&blkvsc_req->request.wait_event);
+}
+
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device);
@@ -453,7 +477,6 @@ static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
-static void blkvsc_cmd_completion(struct hv_storvsc_request *request);
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity16(struct block_device_context *blkdev);
@@ -1257,29 +1280,6 @@ static int blkvsc_do_request(struct block_device_context
*blkdev,
return pending;
}
-static void blkvsc_cmd_completion(struct hv_storvsc_request *request)
-{
- struct blkvsc_request *blkvsc_req - (struct blkvsc_request
*)request->context;
- struct block_device_context *blkdev - (struct block_device_context
*)blkvsc_req->dev;
- struct scsi_sense_hdr sense_hdr;
- struct vmscsi_request *vm_srb;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_cmd_completion() - req %p\n",
- blkvsc_req);
-
- vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
- blkdev->num_outstanding_reqs--;
-
- if (vm_srb->scsi_status)
- if (scsi_normalize_sense(blkvsc_req->sense_buffer,
- SCSI_SENSE_BUFFERSIZE, &sense_hdr))
- scsi_print_sense_hdr("blkvsc", &sense_hdr);
-
- complete(&blkvsc_req->request.wait_event);
-}
-
static void blkvsc_request_completion(struct hv_storvsc_request *request)
{
struct blkvsc_request *blkvsc_req --
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 08/22] Staging: hv: Get rid of the forward declaration of blkvsc_do_flush()
Get rid of the forward declaration of blkvsc_do_flush() by moving the code
around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 71 +++++++++++++++++++--------------------
1 files changed, 35 insertions(+), 36 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 068daee..94f090e 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -465,6 +465,41 @@ static void blkvsc_cmd_completion(struct hv_storvsc_request
*request)
complete(&blkvsc_req->request.wait_event);
}
+static int blkvsc_do_flush(struct block_device_context *blkdev)
+{
+ struct blkvsc_request *blkvsc_req;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_flush()\n");
+
+ if (blkdev->device_type != HARDDISK_TYPE)
+ return 0;
+
+ blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
+ if (!blkvsc_req)
+ return -ENOMEM;
+
+ memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
+ init_completion(&blkvsc_req->request.wait_event);
+ blkvsc_req->dev = blkdev;
+ blkvsc_req->req = NULL;
+ blkvsc_req->write = 0;
+
+ blkvsc_req->request.data_buffer.pfn_array[0] = 0;
+ blkvsc_req->request.data_buffer.offset = 0;
+ blkvsc_req->request.data_buffer.len = 0;
+
+ blkvsc_req->cmnd[0] = SYNCHRONIZE_CACHE;
+ blkvsc_req->cmd_len = 10;
+
+ blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
+
+ wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
+
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
@@ -480,7 +515,6 @@ static int blkvsc_do_request(struct block_device_context
*blkdev,
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity16(struct block_device_context *blkdev);
-static int blkvsc_do_flush(struct block_device_context *blkdev);
static int blkvsc_cancel_pending_reqs(struct block_device_context *blkdev);
static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
@@ -771,41 +805,6 @@ static void blkvsc_shutdown(struct device *device)
spin_unlock_irqrestore(&blkdev->lock, flags);
}
-static int blkvsc_do_flush(struct block_device_context *blkdev)
-{
- struct blkvsc_request *blkvsc_req;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_flush()\n");
-
- if (blkdev->device_type != HARDDISK_TYPE)
- return 0;
-
- blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
- if (!blkvsc_req)
- return -ENOMEM;
-
- memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
- init_completion(&blkvsc_req->request.wait_event);
- blkvsc_req->dev = blkdev;
- blkvsc_req->req = NULL;
- blkvsc_req->write = 0;
-
- blkvsc_req->request.data_buffer.pfn_array[0] = 0;
- blkvsc_req->request.data_buffer.offset = 0;
- blkvsc_req->request.data_buffer.len = 0;
-
- blkvsc_req->cmnd[0] = SYNCHRONIZE_CACHE;
- blkvsc_req->cmd_len = 10;
-
- blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
-
- wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
-
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
-
- return 0;
-}
-
/* Do a scsi INQUIRY cmd here to get the device type (ie disk or dvd) */
static int blkvsc_do_inquiry(struct block_device_context *blkdev)
{
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 10/22] Staging: hv: Get rid of the forward declaration of blkvsc_remove()
Get rid of the forward declaration of blkvsc_remove() by moving the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 130 +++++++++++++++++++-------------------
1 files changed, 65 insertions(+), 65 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 2829266..a98ed8f 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -580,9 +580,73 @@ out:
return ret;
}
+
+/*
+ * blkvsc_remove() - Callback when our device is removed
+ */
+static int blkvsc_remove(struct device *device)
+{
+ struct hv_driver *drv + drv_to_hv_drv(device->driver);
+ struct storvsc_driver_object *storvsc_drv_obj + drv->priv;
+ struct hv_device *device_obj = device_to_hv_device(device);
+ struct block_device_context *blkdev = dev_get_drvdata(device);
+ unsigned long flags;
+ int ret;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_remove()\n");
+
+ if (!storvsc_drv_obj->base.dev_rm)
+ return -1;
+
+ /*
+ * Call to the vsc driver to let it know that the device is being
+ * removed
+ */
+ ret = storvsc_drv_obj->base.dev_rm(device_obj);
+ if (ret != 0) {
+ /* TODO: */
+ DPRINT_ERR(BLKVSC_DRV,
+ "unable to remove blkvsc device (ret %d)", ret);
+ }
+
+ /* Get to a known state */
+ spin_lock_irqsave(&blkdev->lock, flags);
+
+ blkdev->shutting_down = 1;
+
+ blk_stop_queue(blkdev->gd->queue);
+
+ spin_unlock_irqrestore(&blkdev->lock, flags);
+
+ while (blkdev->num_outstanding_reqs) {
+ DPRINT_INFO(STORVSC, "waiting for %d requests to complete...",
+ blkdev->num_outstanding_reqs);
+ udelay(100);
+ }
+
+ blkvsc_do_flush(blkdev);
+
+ spin_lock_irqsave(&blkdev->lock, flags);
+
+ blkvsc_cancel_pending_reqs(blkdev);
+
+ spin_unlock_irqrestore(&blkdev->lock, flags);
+
+ blk_cleanup_queue(blkdev->gd->queue);
+
+ del_gendisk(blkdev->gd);
+
+ kmem_cache_destroy(blkdev->request_pool);
+
+ kfree(blkdev);
+
+ return ret;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
-static int blkvsc_remove(struct device *device);
static void blkvsc_shutdown(struct device *device);
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
@@ -1120,70 +1184,6 @@ static int blkvsc_do_read_capacity16(struct
block_device_context *blkdev)
}
/*
- * blkvsc_remove() - Callback when our device is removed
- */
-static int blkvsc_remove(struct device *device)
-{
- struct hv_driver *drv - drv_to_hv_drv(device->driver);
- struct storvsc_driver_object *storvsc_drv_obj - drv->priv;
- struct hv_device *device_obj = device_to_hv_device(device);
- struct block_device_context *blkdev = dev_get_drvdata(device);
- unsigned long flags;
- int ret;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_remove()\n");
-
- if (!storvsc_drv_obj->base.dev_rm)
- return -1;
-
- /*
- * Call to the vsc driver to let it know that the device is being
- * removed
- */
- ret = storvsc_drv_obj->base.dev_rm(device_obj);
- if (ret != 0) {
- /* TODO: */
- DPRINT_ERR(BLKVSC_DRV,
- "unable to remove blkvsc device (ret %d)", ret);
- }
-
- /* Get to a known state */
- spin_lock_irqsave(&blkdev->lock, flags);
-
- blkdev->shutting_down = 1;
-
- blk_stop_queue(blkdev->gd->queue);
-
- spin_unlock_irqrestore(&blkdev->lock, flags);
-
- while (blkdev->num_outstanding_reqs) {
- DPRINT_INFO(STORVSC, "waiting for %d requests to complete...",
- blkdev->num_outstanding_reqs);
- udelay(100);
- }
-
- blkvsc_do_flush(blkdev);
-
- spin_lock_irqsave(&blkdev->lock, flags);
-
- blkvsc_cancel_pending_reqs(blkdev);
-
- spin_unlock_irqrestore(&blkdev->lock, flags);
-
- blk_cleanup_queue(blkdev->gd->queue);
-
- del_gendisk(blkdev->gd);
-
- kmem_cache_destroy(blkdev->request_pool);
-
- kfree(blkdev);
-
- return ret;
-}
-
-/*
* We break the request into 1 or more blkvsc_requests and submit
* them. If we cant submit them all, we put them on the
* pending_list. The blkvsc_request() will work on the pending_list.
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 11/22] Staging: hv: Get rid of the forward declaration of blkvsc_shutdown()
Get rid of the forward declaration of blkvsc_shutdown() by moving the
code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 70 +++++++++++++++++++--------------------
1 files changed, 34 insertions(+), 36 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index a98ed8f..1fb68b7 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -645,10 +645,42 @@ static int blkvsc_remove(struct device *device)
return ret;
}
+static void blkvsc_shutdown(struct device *device)
+{
+ struct block_device_context *blkdev = dev_get_drvdata(device);
+ unsigned long flags;
+
+ if (!blkdev)
+ return;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_shutdown - users %d disk %s\n",
+ blkdev->users, blkdev->gd->disk_name);
+
+ spin_lock_irqsave(&blkdev->lock, flags);
+
+ blkdev->shutting_down = 1;
+
+ blk_stop_queue(blkdev->gd->queue);
+
+ spin_unlock_irqrestore(&blkdev->lock, flags);
+
+ while (blkdev->num_outstanding_reqs) {
+ DPRINT_INFO(STORVSC, "waiting for %d requests to complete...",
+ blkdev->num_outstanding_reqs);
+ udelay(100);
+ }
+
+ blkvsc_do_flush(blkdev);
+
+ spin_lock_irqsave(&blkdev->lock, flags);
+
+ blkvsc_cancel_pending_reqs(blkdev);
+
+ spin_unlock_irqrestore(&blkdev->lock, flags);
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
-static void blkvsc_shutdown(struct device *device);
-
static int blkvsc_release(struct gendisk *disk, fmode_t mode);
static int blkvsc_revalidate_disk(struct gendisk *gd);
static void blkvsc_request(struct request_queue *queue);
@@ -913,40 +945,6 @@ Cleanup:
return ret;
}
-static void blkvsc_shutdown(struct device *device)
-{
- struct block_device_context *blkdev = dev_get_drvdata(device);
- unsigned long flags;
-
- if (!blkdev)
- return;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_shutdown - users %d disk %s\n",
- blkdev->users, blkdev->gd->disk_name);
-
- spin_lock_irqsave(&blkdev->lock, flags);
-
- blkdev->shutting_down = 1;
-
- blk_stop_queue(blkdev->gd->queue);
-
- spin_unlock_irqrestore(&blkdev->lock, flags);
-
- while (blkdev->num_outstanding_reqs) {
- DPRINT_INFO(STORVSC, "waiting for %d requests to complete...",
- blkdev->num_outstanding_reqs);
- udelay(100);
- }
-
- blkvsc_do_flush(blkdev);
-
- spin_lock_irqsave(&blkdev->lock, flags);
-
- blkvsc_cancel_pending_reqs(blkdev);
-
- spin_unlock_irqrestore(&blkdev->lock, flags);
-}
-
/* Do a scsi INQUIRY cmd here to get the device type (ie disk or dvd) */
static int blkvsc_do_inquiry(struct block_device_context *blkdev)
{
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 12/22] Staging: hv: Get rid of the forward declaration for blkvsc_release()
Get rid of the forward declaration for blkvsc_release() by moving the code
around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 45 +++++++++++++++++++--------------------
1 files changed, 22 insertions(+), 23 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 1fb68b7..799f5ad 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -679,9 +679,30 @@ static void blkvsc_shutdown(struct device *device)
spin_unlock_irqrestore(&blkdev->lock, flags);
}
+static int blkvsc_release(struct gendisk *disk, fmode_t mode)
+{
+ struct block_device_context *blkdev = disk->private_data;
+
+ DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
+ blkdev->gd->disk_name);
+
+ mutex_lock(&blkvsc_mutex);
+ spin_lock(&blkdev->lock);
+ if (blkdev->users == 1) {
+ spin_unlock(&blkdev->lock);
+ blkvsc_do_flush(blkdev);
+ spin_lock(&blkdev->lock);
+ }
+
+ blkdev->users--;
+
+ spin_unlock(&blkdev->lock);
+ mutex_unlock(&blkvsc_mutex);
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
-static int blkvsc_release(struct gendisk *disk, fmode_t mode);
static int blkvsc_revalidate_disk(struct gendisk *gd);
static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
@@ -1492,28 +1513,6 @@ static void blkvsc_request(struct request_queue *queue)
}
}
-static int blkvsc_release(struct gendisk *disk, fmode_t mode)
-{
- struct block_device_context *blkdev = disk->private_data;
-
- DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
- blkdev->gd->disk_name);
-
- mutex_lock(&blkvsc_mutex);
- spin_lock(&blkdev->lock);
- if (blkdev->users == 1) {
- spin_unlock(&blkdev->lock);
- blkvsc_do_flush(blkdev);
- spin_lock(&blkdev->lock);
- }
-
- blkdev->users--;
-
- spin_unlock(&blkdev->lock);
- mutex_unlock(&blkvsc_mutex);
- return 0;
-}
-
static int blkvsc_revalidate_disk(struct gendisk *gd)
{
struct block_device_context *blkdev = gd->private_data;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 13/22] Staging: hv: Get rid of the forward declaration for blkvsc_do_read_capacity()
Get rid of the forward declaration for blkvsc_do_read_capacity() by moving
the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 152 +++++++++++++++++++-------------------
1 files changed, 76 insertions(+), 76 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 799f5ad..dedb5a36 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -701,6 +701,82 @@ static int blkvsc_release(struct gendisk *disk, fmode_t
mode)
return 0;
}
+
+/* Do a scsi READ_CAPACITY cmd here to get the size of the disk */
+static int blkvsc_do_read_capacity(struct block_device_context *blkdev)
+{
+ struct blkvsc_request *blkvsc_req;
+ struct page *page_buf;
+ unsigned char *buf;
+ struct scsi_sense_hdr sense_hdr;
+ struct vmscsi_request *vm_srb;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_read_capacity()\n");
+
+ blkdev->sector_size = 0;
+ blkdev->capacity = 0;
+ blkdev->media_not_present = 0; /* assume a disk is present */
+
+ blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
+ if (!blkvsc_req)
+ return -ENOMEM;
+
+ memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
+ page_buf = alloc_page(GFP_KERNEL);
+ if (!page_buf) {
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+ return -ENOMEM;
+ }
+
+ vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
+ init_completion(&blkvsc_req->request.wait_event);
+ blkvsc_req->dev = blkdev;
+ blkvsc_req->req = NULL;
+ blkvsc_req->write = 0;
+
+ blkvsc_req->request.data_buffer.pfn_array[0] + page_to_pfn(page_buf);
+ blkvsc_req->request.data_buffer.offset = 0;
+ blkvsc_req->request.data_buffer.len = 8;
+
+ blkvsc_req->cmnd[0] = READ_CAPACITY;
+ blkvsc_req->cmd_len = 16;
+
+ blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
+
+ DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
+ blkvsc_req);
+
+ wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
+
+ /* check error */
+ if (vm_srb->scsi_status) {
+ scsi_normalize_sense(blkvsc_req->sense_buffer,
+ SCSI_SENSE_BUFFERSIZE, &sense_hdr);
+
+ if (sense_hdr.asc == 0x3A) {
+ /* Medium not present */
+ blkdev->media_not_present = 1;
+ }
+ return 0;
+ }
+ buf = kmap(page_buf);
+
+ /* be to le */
+ blkdev->capacity = ((buf[0] << 24) | (buf[1] << 16) |
+ (buf[2] << 8) | buf[3]) + 1;
+ blkdev->sector_size = (buf[4] << 24) | (buf[5] << 16) |
+ (buf[6] << 8) | buf[7];
+
+ kunmap(page_buf);
+
+ __free_page(page_buf);
+
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_revalidate_disk(struct gendisk *gd);
@@ -709,7 +785,6 @@ static void blkvsc_request_completion(struct
hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
-static int blkvsc_do_read_capacity(struct block_device_context *blkdev);
static int blkvsc_do_read_capacity16(struct block_device_context *blkdev);
static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
@@ -1044,81 +1119,6 @@ static int blkvsc_do_inquiry(struct block_device_context
*blkdev)
return 0;
}
-/* Do a scsi READ_CAPACITY cmd here to get the size of the disk */
-static int blkvsc_do_read_capacity(struct block_device_context *blkdev)
-{
- struct blkvsc_request *blkvsc_req;
- struct page *page_buf;
- unsigned char *buf;
- struct scsi_sense_hdr sense_hdr;
- struct vmscsi_request *vm_srb;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_read_capacity()\n");
-
- blkdev->sector_size = 0;
- blkdev->capacity = 0;
- blkdev->media_not_present = 0; /* assume a disk is present */
-
- blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
- if (!blkvsc_req)
- return -ENOMEM;
-
- memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
- page_buf = alloc_page(GFP_KERNEL);
- if (!page_buf) {
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
- return -ENOMEM;
- }
-
- vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
- init_completion(&blkvsc_req->request.wait_event);
- blkvsc_req->dev = blkdev;
- blkvsc_req->req = NULL;
- blkvsc_req->write = 0;
-
- blkvsc_req->request.data_buffer.pfn_array[0] - page_to_pfn(page_buf);
- blkvsc_req->request.data_buffer.offset = 0;
- blkvsc_req->request.data_buffer.len = 8;
-
- blkvsc_req->cmnd[0] = READ_CAPACITY;
- blkvsc_req->cmd_len = 16;
-
- blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
-
- DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
- blkvsc_req);
-
- wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
-
- /* check error */
- if (vm_srb->scsi_status) {
- scsi_normalize_sense(blkvsc_req->sense_buffer,
- SCSI_SENSE_BUFFERSIZE, &sense_hdr);
-
- if (sense_hdr.asc == 0x3A) {
- /* Medium not present */
- blkdev->media_not_present = 1;
- }
- return 0;
- }
- buf = kmap(page_buf);
-
- /* be to le */
- blkdev->capacity = ((buf[0] << 24) | (buf[1] << 16) |
- (buf[2] << 8) | buf[3]) + 1;
- blkdev->sector_size = (buf[4] << 24) | (buf[5] << 16) |
- (buf[6] << 8) | buf[7];
-
- kunmap(page_buf);
-
- __free_page(page_buf);
-
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
-
- return 0;
-}
-
static int blkvsc_do_read_capacity16(struct block_device_context *blkdev)
{
struct blkvsc_request *blkvsc_req;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 14/22] Staging: hv: Get rid of the forward declaration of blkvsc_do_read_capacity16()
Get rid of the forward declaration of blkvsc_do_read_capacity16() by moving
the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 168 +++++++++++++++++++-------------------
1 files changed, 84 insertions(+), 84 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index dedb5a36..49caad7 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -777,6 +777,90 @@ static int blkvsc_do_read_capacity(struct
block_device_context *blkdev)
return 0;
}
+
+static int blkvsc_do_read_capacity16(struct block_device_context *blkdev)
+{
+ struct blkvsc_request *blkvsc_req;
+ struct page *page_buf;
+ unsigned char *buf;
+ struct scsi_sense_hdr sense_hdr;
+ struct vmscsi_request *vm_srb;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_read_capacity16()\n");
+
+ blkdev->sector_size = 0;
+ blkdev->capacity = 0;
+ blkdev->media_not_present = 0; /* assume a disk is present */
+
+ blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
+ if (!blkvsc_req)
+ return -ENOMEM;
+
+ memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
+ vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
+ page_buf = alloc_page(GFP_KERNEL);
+ if (!page_buf) {
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+ return -ENOMEM;
+ }
+
+ init_completion(&blkvsc_req->request.wait_event);
+ blkvsc_req->dev = blkdev;
+ blkvsc_req->req = NULL;
+ blkvsc_req->write = 0;
+
+ blkvsc_req->request.data_buffer.pfn_array[0] + page_to_pfn(page_buf);
+ blkvsc_req->request.data_buffer.offset = 0;
+ blkvsc_req->request.data_buffer.len = 12;
+
+ blkvsc_req->cmnd[0] = 0x9E; /* READ_CAPACITY16; */
+ blkvsc_req->cmd_len = 16;
+
+ /*
+ * Set this here since the completion routine may be invoked
+ * and completed before we return
+ */
+
+ blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
+
+ DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
+ blkvsc_req);
+
+ wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
+
+ /* check error */
+ if (vm_srb->scsi_status) {
+ scsi_normalize_sense(blkvsc_req->sense_buffer,
+ SCSI_SENSE_BUFFERSIZE, &sense_hdr);
+ if (sense_hdr.asc == 0x3A) {
+ /* Medium not present */
+ blkdev->media_not_present = 1;
+ }
+ return 0;
+ }
+ buf = kmap(page_buf);
+
+ /* be to le */
+ blkdev->capacity = be64_to_cpu(*(unsigned long long *) &buf[0]) + 1;
+ blkdev->sector_size = be32_to_cpu(*(unsigned int *)&buf[8]);
+
+#if 0
+ blkdev->capacity = ((buf[0] << 24) | (buf[1] << 16) |
+ (buf[2] << 8) | buf[3]) + 1;
+ blkdev->sector_size = (buf[4] << 24) | (buf[5] << 16) |
+ (buf[6] << 8) | buf[7];
+#endif
+
+ kunmap(page_buf);
+
+ __free_page(page_buf);
+
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static int blkvsc_revalidate_disk(struct gendisk *gd);
@@ -785,7 +869,6 @@ static void blkvsc_request_completion(struct
hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
static int blkvsc_do_inquiry(struct block_device_context *blkdev);
-static int blkvsc_do_read_capacity16(struct block_device_context *blkdev);
static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
@@ -1119,89 +1202,6 @@ static int blkvsc_do_inquiry(struct block_device_context
*blkdev)
return 0;
}
-static int blkvsc_do_read_capacity16(struct block_device_context *blkdev)
-{
- struct blkvsc_request *blkvsc_req;
- struct page *page_buf;
- unsigned char *buf;
- struct scsi_sense_hdr sense_hdr;
- struct vmscsi_request *vm_srb;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_read_capacity16()\n");
-
- blkdev->sector_size = 0;
- blkdev->capacity = 0;
- blkdev->media_not_present = 0; /* assume a disk is present */
-
- blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
- if (!blkvsc_req)
- return -ENOMEM;
-
- memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
- vm_srb = &blkvsc_req->request.vstor_packet.vm_srb;
- page_buf = alloc_page(GFP_KERNEL);
- if (!page_buf) {
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
- return -ENOMEM;
- }
-
- init_completion(&blkvsc_req->request.wait_event);
- blkvsc_req->dev = blkdev;
- blkvsc_req->req = NULL;
- blkvsc_req->write = 0;
-
- blkvsc_req->request.data_buffer.pfn_array[0] - page_to_pfn(page_buf);
- blkvsc_req->request.data_buffer.offset = 0;
- blkvsc_req->request.data_buffer.len = 12;
-
- blkvsc_req->cmnd[0] = 0x9E; /* READ_CAPACITY16; */
- blkvsc_req->cmd_len = 16;
-
- /*
- * Set this here since the completion routine may be invoked
- * and completed before we return
- */
-
- blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
-
- DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
- blkvsc_req);
-
- wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
-
- /* check error */
- if (vm_srb->scsi_status) {
- scsi_normalize_sense(blkvsc_req->sense_buffer,
- SCSI_SENSE_BUFFERSIZE, &sense_hdr);
- if (sense_hdr.asc == 0x3A) {
- /* Medium not present */
- blkdev->media_not_present = 1;
- }
- return 0;
- }
- buf = kmap(page_buf);
-
- /* be to le */
- blkdev->capacity = be64_to_cpu(*(unsigned long long *) &buf[0]) + 1;
- blkdev->sector_size = be32_to_cpu(*(unsigned int *)&buf[8]);
-
-#if 0
- blkdev->capacity = ((buf[0] << 24) | (buf[1] << 16) |
- (buf[2] << 8) | buf[3]) + 1;
- blkdev->sector_size = (buf[4] << 24) | (buf[5] << 16) |
- (buf[6] << 8) | buf[7];
-#endif
-
- kunmap(page_buf);
-
- __free_page(page_buf);
-
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
-
- return 0;
-}
-
/*
* We break the request into 1 or more blkvsc_requests and submit
* them. If we cant submit them all, we put them on the
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 15/22] Staging: hv: Get rid of the forward declaration of blkvsc_revalidate_disk()
Get rid of the forward declaration of blkvsc_revalidate_disk() by moving
the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 31 +++++++++++++++----------------
1 files changed, 15 insertions(+), 16 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 49caad7..35dacf0 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -861,9 +861,23 @@ static int blkvsc_do_read_capacity16(struct
block_device_context *blkdev)
return 0;
}
+static int blkvsc_revalidate_disk(struct gendisk *gd)
+{
+ struct block_device_context *blkdev = gd->private_data;
+
+ DPRINT_DBG(BLKVSC_DRV, "- enter\n");
+
+ if (blkdev->device_type == DVD_TYPE) {
+ blkvsc_do_read_capacity(blkdev);
+ set_capacity(blkdev->gd, blkdev->capacity *
+ (blkdev->sector_size/512));
+ blk_queue_logical_block_size(gd->queue, blkdev->sector_size);
+ }
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
-static int blkvsc_revalidate_disk(struct gendisk *gd);
static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
@@ -1513,21 +1527,6 @@ static void blkvsc_request(struct request_queue *queue)
}
}
-static int blkvsc_revalidate_disk(struct gendisk *gd)
-{
- struct block_device_context *blkdev = gd->private_data;
-
- DPRINT_DBG(BLKVSC_DRV, "- enter\n");
-
- if (blkdev->device_type == DVD_TYPE) {
- blkvsc_do_read_capacity(blkdev);
- set_capacity(blkdev->gd, blkdev->capacity *
- (blkdev->sector_size/512));
- blk_queue_logical_block_size(gd->queue, blkdev->sector_size);
- }
- return 0;
-}
-
static int __init blkvsc_init(void)
{
int ret;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 16/22] Staging: hv: Get rid of the forward declaration for blkvsc_do_inquiry()
Get rid of the forward declaration for blkvsc_do_inquiry() by moving the code
around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 158 +++++++++++++++++++-------------------
1 files changed, 79 insertions(+), 79 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 35dacf0..f7bf42f 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -876,13 +876,91 @@ static int blkvsc_revalidate_disk(struct gendisk *gd)
return 0;
}
+
+/* Do a scsi INQUIRY cmd here to get the device type (ie disk or dvd) */
+static int blkvsc_do_inquiry(struct block_device_context *blkdev)
+{
+ struct blkvsc_request *blkvsc_req;
+ struct page *page_buf;
+ unsigned char *buf;
+ unsigned char device_type;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_inquiry()\n");
+
+ blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
+ if (!blkvsc_req)
+ return -ENOMEM;
+
+ memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
+ page_buf = alloc_page(GFP_KERNEL);
+ if (!page_buf) {
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+ return -ENOMEM;
+ }
+
+ init_completion(&blkvsc_req->request.wait_event);
+ blkvsc_req->dev = blkdev;
+ blkvsc_req->req = NULL;
+ blkvsc_req->write = 0;
+
+ blkvsc_req->request.data_buffer.pfn_array[0] + page_to_pfn(page_buf);
+ blkvsc_req->request.data_buffer.offset = 0;
+ blkvsc_req->request.data_buffer.len = 64;
+
+ blkvsc_req->cmnd[0] = INQUIRY;
+ blkvsc_req->cmnd[1] = 0x1; /* Get product data */
+ blkvsc_req->cmnd[2] = 0x83; /* mode page 83 */
+ blkvsc_req->cmnd[4] = 64;
+ blkvsc_req->cmd_len = 6;
+
+ blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
+
+ DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
+ blkvsc_req);
+
+ wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
+
+ buf = kmap(page_buf);
+
+ /* print_hex_dump_bytes("", DUMP_PREFIX_NONE, buf, 64); */
+ /* be to le */
+ device_type = buf[0] & 0x1F;
+
+ if (device_type == 0x0) {
+ blkdev->device_type = HARDDISK_TYPE;
+ } else if (device_type == 0x5) {
+ blkdev->device_type = DVD_TYPE;
+ } else {
+ /* TODO: this is currently unsupported device type */
+ blkdev->device_type = UNKNOWN_DEV_TYPE;
+ }
+
+ DPRINT_DBG(BLKVSC_DRV, "device type %d\n", device_type);
+
+ blkdev->device_id_len = buf[7];
+ if (blkdev->device_id_len > 64)
+ blkdev->device_id_len = 64;
+
+ memcpy(blkdev->device_id, &buf[8], blkdev->device_id_len);
+ /* printk_hex_dump_bytes("", DUMP_PREFIX_NONE, blkdev->device_id,
+ * blkdev->device_id_len); */
+
+ kunmap(page_buf);
+
+ __free_page(page_buf);
+
+ kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+
+ return 0;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static void blkvsc_request(struct request_queue *queue);
static void blkvsc_request_completion(struct hv_storvsc_request *request);
static int blkvsc_do_request(struct block_device_context *blkdev,
struct request *req);
-static int blkvsc_do_inquiry(struct block_device_context *blkdev);
static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
@@ -1138,84 +1216,6 @@ Cleanup:
return ret;
}
-/* Do a scsi INQUIRY cmd here to get the device type (ie disk or dvd) */
-static int blkvsc_do_inquiry(struct block_device_context *blkdev)
-{
- struct blkvsc_request *blkvsc_req;
- struct page *page_buf;
- unsigned char *buf;
- unsigned char device_type;
-
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_do_inquiry()\n");
-
- blkvsc_req = kmem_cache_zalloc(blkdev->request_pool, GFP_KERNEL);
- if (!blkvsc_req)
- return -ENOMEM;
-
- memset(blkvsc_req, 0, sizeof(struct blkvsc_request));
- page_buf = alloc_page(GFP_KERNEL);
- if (!page_buf) {
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
- return -ENOMEM;
- }
-
- init_completion(&blkvsc_req->request.wait_event);
- blkvsc_req->dev = blkdev;
- blkvsc_req->req = NULL;
- blkvsc_req->write = 0;
-
- blkvsc_req->request.data_buffer.pfn_array[0] - page_to_pfn(page_buf);
- blkvsc_req->request.data_buffer.offset = 0;
- blkvsc_req->request.data_buffer.len = 64;
-
- blkvsc_req->cmnd[0] = INQUIRY;
- blkvsc_req->cmnd[1] = 0x1; /* Get product data */
- blkvsc_req->cmnd[2] = 0x83; /* mode page 83 */
- blkvsc_req->cmnd[4] = 64;
- blkvsc_req->cmd_len = 6;
-
- blkvsc_submit_request(blkvsc_req, blkvsc_cmd_completion);
-
- DPRINT_DBG(BLKVSC_DRV, "waiting %p to complete\n",
- blkvsc_req);
-
- wait_for_completion_interruptible(&blkvsc_req->request.wait_event);
-
- buf = kmap(page_buf);
-
- /* print_hex_dump_bytes("", DUMP_PREFIX_NONE, buf, 64); */
- /* be to le */
- device_type = buf[0] & 0x1F;
-
- if (device_type == 0x0) {
- blkdev->device_type = HARDDISK_TYPE;
- } else if (device_type == 0x5) {
- blkdev->device_type = DVD_TYPE;
- } else {
- /* TODO: this is currently unsupported device type */
- blkdev->device_type = UNKNOWN_DEV_TYPE;
- }
-
- DPRINT_DBG(BLKVSC_DRV, "device type %d\n", device_type);
-
- blkdev->device_id_len = buf[7];
- if (blkdev->device_id_len > 64)
- blkdev->device_id_len = 64;
-
- memcpy(blkdev->device_id, &buf[8], blkdev->device_id_len);
- /* printk_hex_dump_bytes("", DUMP_PREFIX_NONE, blkdev->device_id,
- * blkdev->device_id_len); */
-
- kunmap(page_buf);
-
- __free_page(page_buf);
-
- kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
-
- return 0;
-}
-
/*
* We break the request into 1 or more blkvsc_requests and submit
* them. If we cant submit them all, we put them on the
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 17/22] Staging: hv: Get rid of the forward declaration for blkvsc_do_request()
Get rid of the forward declaration for blkvsc_do_request() by moving the
code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 370 ++++++++++++++++++++-------------------
1 files changed, 193 insertions(+), 177 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index f7bf42f..9d4fcbd 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -118,6 +118,12 @@ static const struct hv_guid g_blk_device_type = {
}
};
+/*
+ * There is a circular dependency involving blkvsc_request_completion()
+ * and blkvsc_do_request().
+ */
+static void blkvsc_request_completion(struct hv_storvsc_request *request);
+
static int blk_vsc_on_device_add(struct hv_device *device,
void *additional_info)
{
@@ -955,12 +961,196 @@ static int blkvsc_do_inquiry(struct block_device_context
*blkdev)
return 0;
}
+
+/*
+ * We break the request into 1 or more blkvsc_requests and submit
+ * them. If we cant submit them all, we put them on the
+ * pending_list. The blkvsc_request() will work on the pending_list.
+ */
+static int blkvsc_do_request(struct block_device_context *blkdev,
+ struct request *req)
+{
+ struct bio *bio = NULL;
+ struct bio_vec *bvec = NULL;
+ struct bio_vec *prev_bvec = NULL;
+ struct blkvsc_request *blkvsc_req = NULL;
+ struct blkvsc_request *tmp;
+ int databuf_idx = 0;
+ int seg_idx = 0;
+ sector_t start_sector;
+ unsigned long num_sectors = 0;
+ int ret = 0;
+ int pending = 0;
+ struct blkvsc_request_group *group = NULL;
+
+ DPRINT_DBG(BLKVSC_DRV, "blkdev %p req %p sect %lu\n", blkdev, req,
+ (unsigned long)blk_rq_pos(req));
+
+ /* Create a group to tie req to list of blkvsc_reqs */
+ group = kmem_cache_zalloc(blkdev->request_pool, GFP_ATOMIC);
+ if (!group)
+ return -ENOMEM;
+
+ INIT_LIST_HEAD(&group->blkvsc_req_list);
+ group->outstanding = group->status = 0;
+
+ start_sector = blk_rq_pos(req);
+
+ /* foreach bio in the request */
+ if (req->bio) {
+ for (bio = req->bio; bio; bio = bio->bi_next) {
+ /*
+ * Map this bio into an existing or new storvsc request
+ */
+ bio_for_each_segment(bvec, bio, seg_idx) {
+ DPRINT_DBG(BLKVSC_DRV, "bio_for_each_segment() "
+ "- req %p bio %p bvec %p seg_idx %d "
+ "databuf_idx %d\n", req, bio, bvec,
+ seg_idx, databuf_idx);
+
+ /* Get a new storvsc request */
+ /* 1st-time */
+ if ((!blkvsc_req) ||
+ (databuf_idx >= MAX_MULTIPAGE_BUFFER_COUNT)
+ /* hole at the begin of page */
+ || (bvec->bv_offset != 0) ||
+ /* hold at the end of page */
+ (prev_bvec &&
+ (prev_bvec->bv_len != PAGE_SIZE))) {
+ /* submit the prev one */
+ if (blkvsc_req) {
+ blkvsc_req->sector_start + start_sector;
+ sector_div(
+ blkvsc_req->sector_start,
+ (blkdev->sector_size >> 9));
+
+ blkvsc_req->sector_count + num_sectors /
+ (blkdev->sector_size >> 9);
+ blkvsc_init_rw(blkvsc_req);
+ }
+
+ /*
+ * Create new blkvsc_req to represent
+ * the current bvec
+ */
+ blkvsc_req + kmem_cache_zalloc(
+ blkdev->request_pool, GFP_ATOMIC);
+ if (!blkvsc_req) {
+ /* free up everything */
+ list_for_each_entry_safe(
+ blkvsc_req, tmp,
+ &group->blkvsc_req_list,
+ req_entry) {
+ list_del(
+ &blkvsc_req->req_entry);
+ kmem_cache_free(
+ blkdev->request_pool,
+ blkvsc_req);
+ }
+
+ kmem_cache_free(
+ blkdev->request_pool, group);
+ return -ENOMEM;
+ }
+
+ memset(blkvsc_req, 0,
+ sizeof(struct blkvsc_request));
+
+ blkvsc_req->dev = blkdev;
+ blkvsc_req->req = req;
+ blkvsc_req->request.
+ data_buffer.offset
+ = bvec->bv_offset;
+ blkvsc_req->request.
+ data_buffer.len = 0;
+
+ /* Add to the group */
+ blkvsc_req->group = group;
+ blkvsc_req->group->outstanding++;
+ list_add_tail(&blkvsc_req->req_entry,
+ &blkvsc_req->group->blkvsc_req_list);
+
+ start_sector += num_sectors;
+ num_sectors = 0;
+ databuf_idx = 0;
+ }
+
+ /*
+ * Add the curr bvec/segment to the curr
+ * blkvsc_req
+ */
+ blkvsc_req->request.data_buffer.
+ pfn_array[databuf_idx]
+ = page_to_pfn(bvec->bv_page);
+ blkvsc_req->request.data_buffer.len
+ += bvec->bv_len;
+
+ prev_bvec = bvec;
+
+ databuf_idx++;
+ num_sectors += bvec->bv_len >> 9;
+
+ } /* bio_for_each_segment */
+
+ } /* rq_for_each_bio */
+ }
+
+ /* Handle the last one */
+ if (blkvsc_req) {
+ DPRINT_DBG(BLKVSC_DRV, "blkdev %p req %p group %p count %d\n",
+ blkdev, req, blkvsc_req->group,
+ blkvsc_req->group->outstanding);
+
+ blkvsc_req->sector_start = start_sector;
+ sector_div(blkvsc_req->sector_start,
+ (blkdev->sector_size >> 9));
+
+ blkvsc_req->sector_count = num_sectors /
+ (blkdev->sector_size >> 9);
+
+ blkvsc_init_rw(blkvsc_req);
+ }
+
+ list_for_each_entry(blkvsc_req, &group->blkvsc_req_list, req_entry) {
+ if (pending) {
+ DPRINT_DBG(BLKVSC_DRV, "adding blkvsc_req to "
+ "pending_list - blkvsc_req %p start_sect %lu"
+ " sect_count %ld (%lu %ld)\n", blkvsc_req,
+ (unsigned long)blkvsc_req->sector_start,
+ blkvsc_req->sector_count,
+ (unsigned long)start_sector,
+ (unsigned long)num_sectors);
+
+ list_add_tail(&blkvsc_req->pend_entry,
+ &blkdev->pending_list);
+ } else {
+ ret = blkvsc_submit_request(blkvsc_req,
+ blkvsc_request_completion);
+ if (ret == -1) {
+ pending = 1;
+ list_add_tail(&blkvsc_req->pend_entry,
+ &blkdev->pending_list);
+ }
+
+ DPRINT_DBG(BLKVSC_DRV, "submitted blkvsc_req %p "
+ "start_sect %lu sect_count %ld (%lu %ld) "
+ "ret %d\n", blkvsc_req,
+ (unsigned long)blkvsc_req->sector_start,
+ blkvsc_req->sector_count,
+ (unsigned long)start_sector,
+ num_sectors, ret);
+ }
+ }
+
+ return pending;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static void blkvsc_request(struct request_queue *queue);
-static void blkvsc_request_completion(struct hv_storvsc_request *request);
-static int blkvsc_do_request(struct block_device_context *blkdev,
- struct request *req);
static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
@@ -1216,180 +1406,6 @@ Cleanup:
return ret;
}
-/*
- * We break the request into 1 or more blkvsc_requests and submit
- * them. If we cant submit them all, we put them on the
- * pending_list. The blkvsc_request() will work on the pending_list.
- */
-static int blkvsc_do_request(struct block_device_context *blkdev,
- struct request *req)
-{
- struct bio *bio = NULL;
- struct bio_vec *bvec = NULL;
- struct bio_vec *prev_bvec = NULL;
- struct blkvsc_request *blkvsc_req = NULL;
- struct blkvsc_request *tmp;
- int databuf_idx = 0;
- int seg_idx = 0;
- sector_t start_sector;
- unsigned long num_sectors = 0;
- int ret = 0;
- int pending = 0;
- struct blkvsc_request_group *group = NULL;
-
- DPRINT_DBG(BLKVSC_DRV, "blkdev %p req %p sect %lu\n", blkdev, req,
- (unsigned long)blk_rq_pos(req));
-
- /* Create a group to tie req to list of blkvsc_reqs */
- group = kmem_cache_zalloc(blkdev->request_pool, GFP_ATOMIC);
- if (!group)
- return -ENOMEM;
-
- INIT_LIST_HEAD(&group->blkvsc_req_list);
- group->outstanding = group->status = 0;
-
- start_sector = blk_rq_pos(req);
-
- /* foreach bio in the request */
- if (req->bio) {
- for (bio = req->bio; bio; bio = bio->bi_next) {
- /*
- * Map this bio into an existing or new storvsc request
- */
- bio_for_each_segment(bvec, bio, seg_idx) {
- DPRINT_DBG(BLKVSC_DRV, "bio_for_each_segment() "
- "- req %p bio %p bvec %p seg_idx %d "
- "databuf_idx %d\n", req, bio, bvec,
- seg_idx, databuf_idx);
-
- /* Get a new storvsc request */
- /* 1st-time */
- if ((!blkvsc_req) ||
- (databuf_idx >= MAX_MULTIPAGE_BUFFER_COUNT)
- /* hole at the begin of page */
- || (bvec->bv_offset != 0) ||
- /* hold at the end of page */
- (prev_bvec &&
- (prev_bvec->bv_len != PAGE_SIZE))) {
- /* submit the prev one */
- if (blkvsc_req) {
- blkvsc_req->sector_start = start_sector;
- sector_div(blkvsc_req->sector_start, (blkdev->sector_size >>
9));
-
- blkvsc_req->sector_count = num_sectors / (blkdev->sector_size
>> 9);
- blkvsc_init_rw(blkvsc_req);
- }
-
- /*
- * Create new blkvsc_req to represent
- * the current bvec
- */
- blkvsc_req - kmem_cache_zalloc(
- blkdev->request_pool, GFP_ATOMIC);
- if (!blkvsc_req) {
- /* free up everything */
- list_for_each_entry_safe(
- blkvsc_req, tmp,
- &group->blkvsc_req_list,
- req_entry) {
- list_del(&blkvsc_req->req_entry);
- kmem_cache_free(blkdev->request_pool, blkvsc_req);
- }
-
- kmem_cache_free(blkdev->request_pool, group);
- return -ENOMEM;
- }
-
- memset(blkvsc_req, 0,
- sizeof(struct blkvsc_request));
-
- blkvsc_req->dev = blkdev;
- blkvsc_req->req = req;
- blkvsc_req->request.
- data_buffer.offset
- = bvec->bv_offset;
- blkvsc_req->request.
- data_buffer.len = 0;
-
- /* Add to the group */
- blkvsc_req->group = group;
- blkvsc_req->group->outstanding++;
- list_add_tail(&blkvsc_req->req_entry,
- &blkvsc_req->group->blkvsc_req_list);
-
- start_sector += num_sectors;
- num_sectors = 0;
- databuf_idx = 0;
- }
-
- /* Add the curr bvec/segment to the curr blkvsc_req */
- blkvsc_req->request.data_buffer.
- pfn_array[databuf_idx]
- = page_to_pfn(bvec->bv_page);
- blkvsc_req->request.data_buffer.len
- += bvec->bv_len;
-
- prev_bvec = bvec;
-
- databuf_idx++;
- num_sectors += bvec->bv_len >> 9;
-
- } /* bio_for_each_segment */
-
- } /* rq_for_each_bio */
- }
-
- /* Handle the last one */
- if (blkvsc_req) {
- DPRINT_DBG(BLKVSC_DRV, "blkdev %p req %p group %p count %d\n",
- blkdev, req, blkvsc_req->group,
- blkvsc_req->group->outstanding);
-
- blkvsc_req->sector_start = start_sector;
- sector_div(blkvsc_req->sector_start,
- (blkdev->sector_size >> 9));
-
- blkvsc_req->sector_count = num_sectors /
- (blkdev->sector_size >> 9);
-
- blkvsc_init_rw(blkvsc_req);
- }
-
- list_for_each_entry(blkvsc_req, &group->blkvsc_req_list, req_entry) {
- if (pending) {
- DPRINT_DBG(BLKVSC_DRV, "adding blkvsc_req to "
- "pending_list - blkvsc_req %p start_sect %lu"
- " sect_count %ld (%lu %ld)\n", blkvsc_req,
- (unsigned long)blkvsc_req->sector_start,
- blkvsc_req->sector_count,
- (unsigned long)start_sector,
- (unsigned long)num_sectors);
-
- list_add_tail(&blkvsc_req->pend_entry,
- &blkdev->pending_list);
- } else {
- ret = blkvsc_submit_request(blkvsc_req,
- blkvsc_request_completion);
- if (ret == -1) {
- pending = 1;
- list_add_tail(&blkvsc_req->pend_entry,
- &blkdev->pending_list);
- }
-
- DPRINT_DBG(BLKVSC_DRV, "submitted blkvsc_req %p "
- "start_sect %lu sect_count %ld (%lu %ld) "
- "ret %d\n", blkvsc_req,
- (unsigned long)blkvsc_req->sector_start,
- blkvsc_req->sector_count,
- (unsigned long)start_sector,
- num_sectors, ret);
- }
- }
-
- return pending;
-}
-
static void blkvsc_request_completion(struct hv_storvsc_request *request)
{
struct blkvsc_request *blkvsc_req --
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 18/22] Staging: hv: Get rid of the forward declaration for blkvsc_do_pending_reqs()
Get rid of the forward declaration for blkvsc_do_pending_reqs() by moving
the code around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 45 +++++++++++++++++++--------------------
1 files changed, 22 insertions(+), 23 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 9d4fcbd..66590f6 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -1148,10 +1148,31 @@ static int blkvsc_do_request(struct block_device_context
*blkdev,
return pending;
}
+static int blkvsc_do_pending_reqs(struct block_device_context *blkdev)
+{
+ struct blkvsc_request *pend_req, *tmp;
+ int ret = 0;
+
+ /* Flush the pending list first */
+ list_for_each_entry_safe(pend_req, tmp, &blkdev->pending_list,
+ pend_entry) {
+ DPRINT_DBG(BLKVSC_DRV, "working off pending_list - %p\n",
+ pend_req);
+
+ ret = blkvsc_submit_request(pend_req,
+ blkvsc_request_completion);
+ if (ret != 0)
+ break;
+ else
+ list_del(&pend_req->pend_entry);
+ }
+
+ return ret;
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
static void blkvsc_request(struct request_queue *queue);
-static int blkvsc_do_pending_reqs(struct block_device_context *blkdev);
static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
module_param(blkvsc_ringbuffer_size, int, S_IRUGO);
@@ -1479,28 +1500,6 @@ static void blkvsc_request_completion(struct
hv_storvsc_request *request)
spin_unlock_irqrestore(&blkdev->lock, flags);
}
-static int blkvsc_do_pending_reqs(struct block_device_context *blkdev)
-{
- struct blkvsc_request *pend_req, *tmp;
- int ret = 0;
-
- /* Flush the pending list first */
- list_for_each_entry_safe(pend_req, tmp, &blkdev->pending_list,
- pend_entry) {
- DPRINT_DBG(BLKVSC_DRV, "working off pending_list - %p\n",
- pend_req);
-
- ret = blkvsc_submit_request(pend_req,
- blkvsc_request_completion);
- if (ret != 0)
- break;
- else
- list_del(&pend_req->pend_entry);
- }
-
- return ret;
-}
-
static void blkvsc_request(struct request_queue *queue)
{
struct block_device_context *blkdev = NULL;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 19/22] Staging: hv: Get rid of the forward declaration for blkvsc_request()
Get rid of the forward declaration for blkvsc_request() by moving the code
around.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 86 +++++++++++++++++++-------------------
1 files changed, 43 insertions(+), 43 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 66590f6..55ba9de 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -1170,9 +1170,51 @@ static int blkvsc_do_pending_reqs(struct
block_device_context *blkdev)
return ret;
}
+
+static void blkvsc_request(struct request_queue *queue)
+{
+ struct block_device_context *blkdev = NULL;
+ struct request *req;
+ int ret = 0;
+
+ DPRINT_DBG(BLKVSC_DRV, "- enter\n");
+ while ((req = blk_peek_request(queue)) != NULL) {
+ DPRINT_DBG(BLKVSC_DRV, "- req %p\n", req);
+
+ blkdev = req->rq_disk->private_data;
+ if (blkdev->shutting_down || req->cmd_type != REQ_TYPE_FS ||
+ blkdev->media_not_present) {
+ __blk_end_request_cur(req, 0);
+ continue;
+ }
+
+ ret = blkvsc_do_pending_reqs(blkdev);
+
+ if (ret != 0) {
+ DPRINT_DBG(BLKVSC_DRV,
+ "- stop queue - pending_list not empty\n");
+ blk_stop_queue(queue);
+ break;
+ }
+
+ blk_start_request(req);
+
+ ret = blkvsc_do_request(blkdev, req);
+ if (ret > 0) {
+ DPRINT_DBG(BLKVSC_DRV, "- stop queue - no room\n");
+ blk_stop_queue(queue);
+ break;
+ } else if (ret < 0) {
+ DPRINT_DBG(BLKVSC_DRV, "- stop queue - no mem\n");
+ blk_requeue_request(queue, req);
+ blk_stop_queue(queue);
+ break;
+ }
+ }
+}
+
/* Static decl */
static int blkvsc_probe(struct device *dev);
-static void blkvsc_request(struct request_queue *queue);
static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
module_param(blkvsc_ringbuffer_size, int, S_IRUGO);
@@ -1500,48 +1542,6 @@ static void blkvsc_request_completion(struct
hv_storvsc_request *request)
spin_unlock_irqrestore(&blkdev->lock, flags);
}
-static void blkvsc_request(struct request_queue *queue)
-{
- struct block_device_context *blkdev = NULL;
- struct request *req;
- int ret = 0;
-
- DPRINT_DBG(BLKVSC_DRV, "- enter\n");
- while ((req = blk_peek_request(queue)) != NULL) {
- DPRINT_DBG(BLKVSC_DRV, "- req %p\n", req);
-
- blkdev = req->rq_disk->private_data;
- if (blkdev->shutting_down || req->cmd_type != REQ_TYPE_FS ||
- blkdev->media_not_present) {
- __blk_end_request_cur(req, 0);
- continue;
- }
-
- ret = blkvsc_do_pending_reqs(blkdev);
-
- if (ret != 0) {
- DPRINT_DBG(BLKVSC_DRV,
- "- stop queue - pending_list not empty\n");
- blk_stop_queue(queue);
- break;
- }
-
- blk_start_request(req);
-
- ret = blkvsc_do_request(blkdev, req);
- if (ret > 0) {
- DPRINT_DBG(BLKVSC_DRV, "- stop queue - no room\n");
- blk_stop_queue(queue);
- break;
- } else if (ret < 0) {
- DPRINT_DBG(BLKVSC_DRV, "- stop queue - no mem\n");
- blk_requeue_request(queue, req);
- blk_stop_queue(queue);
- break;
- }
- }
-}
-
static int __init blkvsc_init(void)
{
int ret;
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 20/22] Staging: hv: Move some definitions/declarations to be earlier in the file
Move some definitions/declarations to be earlier in the file.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 11 ++++++++---
1 files changed, 8 insertions(+), 3 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 55ba9de..865b4dc 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -124,6 +124,14 @@ static const struct hv_guid g_blk_device_type = {
*/
static void blkvsc_request_completion(struct hv_storvsc_request *request);
+static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
+
+/*
+ * There is a circular dependency involving blkvsc_probe()
+ * and block_ops.
+ */
+static int blkvsc_probe(struct device *dev);
+
static int blk_vsc_on_device_add(struct hv_device *device,
void *additional_info)
{
@@ -1213,10 +1221,7 @@ static void blkvsc_request(struct request_queue *queue)
}
}
-/* Static decl */
-static int blkvsc_probe(struct device *dev);
-static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE;
module_param(blkvsc_ringbuffer_size, int, S_IRUGO);
MODULE_PARM_DESC(ring_size, "Ring buffer size (in bytes)");
--
1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 21/22] Staging: hv: Move module parameter to earlier in the file
Move module parameter to be earlier in the file. Signed-off-by: K. Y. Srinivasan <kys at microsoft.com> Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com> Signed-off-by: Abhishek Kane <v-abkane at microsoft.com> Signed-off-by: Hank Janssen <hjanssen at microsoft.com> --- drivers/staging/hv/blkvsc_drv.c | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-) diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c index 865b4dc..6ad1cad 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -126,6 +126,9 @@ static void blkvsc_request_completion(struct hv_storvsc_request *request); static int blkvsc_ringbuffer_size = BLKVSC_RING_BUFFER_SIZE; +module_param(blkvsc_ringbuffer_size, int, S_IRUGO); +MODULE_PARM_DESC(ring_size, "Ring buffer size (in bytes)"); + /* * There is a circular dependency involving blkvsc_probe() * and block_ops. @@ -1222,9 +1225,6 @@ static void blkvsc_request(struct request_queue *queue) } -module_param(blkvsc_ringbuffer_size, int, S_IRUGO); -MODULE_PARM_DESC(ring_size, "Ring buffer size (in bytes)"); - /* The one and only one */ static struct storvsc_driver_object g_blkvsc_drv; -- 1.7.4.1
K. Y. Srinivasan
2011-Apr-06 21:35 UTC
[PATCH 22/22] Staging: hv: Get rid of some dead code in blkvsc_drv.c
Get rid of some dead code in blkvsc_drv.c.
Signed-off-by: K. Y. Srinivasan <kys at microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz at microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane at microsoft.com>
Signed-off-by: Hank Janssen <hjanssen at microsoft.com>
---
drivers/staging/hv/blkvsc_drv.c | 26 --------------------------
1 files changed, 0 insertions(+), 26 deletions(-)
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 6ad1cad..0b85995 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -172,7 +172,6 @@ static int blk_vsc_initialize(struct hv_driver *driver)
stor_driver = hvdr_to_stordr(driver);
/* Make sure we are at least 2 pages since 1 page is used for control */
- /* ASSERT(stor_driver->RingBufferSize >= (PAGE_SIZE << 1)); */
driver->name = g_blk_driver_name;
memcpy(&driver->dev_type, &g_blk_device_type, sizeof(struct
hv_guid));
@@ -224,14 +223,6 @@ static int blkvsc_submit_request(struct blkvsc_request
*blkvsc_req,
blkvsc_req->sector_count,
blkvsc_req->request.data_buffer.offset,
blkvsc_req->request.data_buffer.len);
-#if 0
- for (i = 0; i < (blkvsc_req->request.data_buffer.len >> 12); i++)
{
- DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "
- "req %p pfn[%d] %llx\n",
- blkvsc_req, i,
- blkvsc_req->request.data_buffer.pfn_array[i]);
- }
-#endif
storvsc_req = &blkvsc_req->request;
vm_srb = &storvsc_req->vstor_packet.vm_srb;
@@ -376,9 +367,6 @@ static int blkvsc_getgeo(struct block_device *bd, struct
hd_geometry *hg)
static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req)
{
- /* ASSERT(blkvsc_req->req); */
- /* ASSERT(blkvsc_req->sector_count <-
(MAX_MULTIPAGE_BUFFER_COUNT*8)); */
blkvsc_req->cmd_len = 16;
@@ -435,7 +423,6 @@ static void blkvsc_init_rw(struct blkvsc_request
*blkvsc_req)
static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
unsigned cmd, unsigned long argument)
{
-/* struct block_device_context *blkdev = bd->bd_disk->private_data; */
int ret;
switch (cmd) {
@@ -862,13 +849,6 @@ static int blkvsc_do_read_capacity16(struct
block_device_context *blkdev)
blkdev->capacity = be64_to_cpu(*(unsigned long long *) &buf[0]) + 1;
blkdev->sector_size = be32_to_cpu(*(unsigned int *)&buf[8]);
-#if 0
- blkdev->capacity = ((buf[0] << 24) | (buf[1] << 16) |
- (buf[2] << 8) | buf[3]) + 1;
- blkdev->sector_size = (buf[4] << 24) | (buf[5] << 16) |
- (buf[6] << 8) | buf[7];
-#endif
-
kunmap(page_buf);
__free_page(page_buf);
@@ -940,7 +920,6 @@ static int blkvsc_do_inquiry(struct block_device_context
*blkdev)
buf = kmap(page_buf);
- /* print_hex_dump_bytes("", DUMP_PREFIX_NONE, buf, 64); */
/* be to le */
device_type = buf[0] & 0x1F;
@@ -960,8 +939,6 @@ static int blkvsc_do_inquiry(struct block_device_context
*blkdev)
blkdev->device_id_len = 64;
memcpy(blkdev->device_id, &buf[8], blkdev->device_id_len);
- /* printk_hex_dump_bytes("", DUMP_PREFIX_NONE, blkdev->device_id,
- * blkdev->device_id_len); */
kunmap(page_buf);
@@ -1346,8 +1323,6 @@ static int blkvsc_probe(struct device *device)
/* Initialize what we can here */
spin_lock_init(&blkdev->lock);
- /* ASSERT(sizeof(struct blkvsc_request_group) <= */
- /* sizeof(struct blkvsc_request)); */
blkdev->request_pool =
kmem_cache_create(dev_name(&device_obj->device),
sizeof(struct blkvsc_request), 0,
@@ -1484,7 +1459,6 @@ static void blkvsc_request_completion(struct
hv_storvsc_request *request)
struct blkvsc_request *comp_req, *tmp;
struct vmscsi_request *vm_srb;
- /* ASSERT(blkvsc_req->group); */
DPRINT_DBG(BLKVSC_DRV, "blkdev %p blkvsc_req %p group %p type %s "
"sect_start %lu sect_count %ld len %d group outstd %d "
--
1.7.4.1