K. Y. Srinivasan
2011-Mar-28 17:00 UTC
[PATCH 00/22] Staging: hv: Cleanup-storage-drivers-phase-III
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-Mar-28 17:00 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 9af5347..a931e4c 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); @@ -201,8 +260,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); @@ -889,62 +946,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-Mar-28 17:00 UTC
[PATCH 02/22] Staging: hv: Get rid of the forward declaration of blkvsc_media_changed()
Get rid of the forward declaration of blkvsc_media_changed() 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 | 11 +++++------ 1 files changed, 5 insertions(+), 6 deletions(-) diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c index a931e4c..4b97348 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -242,6 +242,11 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req, return ret; } +static int blkvsc_media_changed(struct gendisk *gd) +{ + DPRINT_DBG(BLKVSC_DRV, "- enter\n"); + return 1; +} /* Static decl */ static DEFINE_MUTEX(blkvsc_mutex); @@ -251,7 +256,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 int blkvsc_media_changed(struct gendisk *gd); 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, @@ -1405,11 +1409,6 @@ static int blkvsc_release(struct gendisk *disk, fmode_t mode) return 0; } -static int blkvsc_media_changed(struct gendisk *gd) -{ - DPRINT_DBG(BLKVSC_DRV, "- enter\n"); - return 1; -} static int blkvsc_revalidate_disk(struct gendisk *gd) { -- 1.7.4.1
K. Y. Srinivasan
2011-Mar-28 17:00 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 4b97348..cd3a019 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"; @@ -248,13 +249,34 @@ static int blkvsc_media_changed(struct gendisk *gd) return 1; } +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); @@ -1364,29 +1386,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-Mar-28 17:00 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 cd3a019..a0c1fe8 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -272,6 +272,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); @@ -279,7 +360,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); @@ -1424,86 +1504,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-Mar-28 17:00 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 a0c1fe8..e9d45eb 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -353,6 +353,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); @@ -366,7 +425,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); @@ -996,63 +1054,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-Mar-28 17:00 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 e9d45eb..30a37a2 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -412,6 +412,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); @@ -419,8 +446,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, @@ -1505,33 +1530,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-Mar-28 17:00 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 30a37a2..8e575d9 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -439,6 +439,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); @@ -450,7 +474,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); @@ -1253,29 +1276,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-Mar-28 17:00 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 8e575d9..f673337 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -462,6 +462,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); @@ -477,7 +512,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); @@ -767,41 +801,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-Mar-28 17:00 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 c1e673b..f67d983 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -577,9 +577,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); @@ -1116,70 +1180,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-Mar-28 17:00 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 f67d983..1b05369 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -642,10 +642,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); @@ -909,40 +941,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-Mar-28 17:00 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 1b05369..720d54b 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -676,9 +676,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); @@ -1488,28 +1509,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) { -- 1.7.4.1
K. Y. Srinivasan
2011-Mar-28 17:00 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 720d54b..b93c8b7 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -698,6 +698,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); @@ -706,7 +782,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); @@ -1040,81 +1115,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-Mar-28 17:00 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 b93c8b7..86a7587 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -774,6 +774,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); @@ -782,7 +866,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; @@ -1115,89 +1198,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-Mar-28 17:00 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 | 32 +++++++++++++++----------------- 1 files changed, 15 insertions(+), 17 deletions(-) diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c index 86a7587..5079859 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -858,9 +858,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, @@ -1509,22 +1523,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-Mar-28 17:00 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 5079859..71059c6 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -873,13 +873,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; @@ -1134,84 +1212,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-Mar-28 17:00 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 71059c6..01f6f84 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) { @@ -952,12 +958,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; @@ -1212,180 +1402,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-Mar-28 17:00 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 01f6f84..535f315 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -1145,10 +1145,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); @@ -1475,28 +1496,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-Mar-28 17:00 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 535f315..c45677b 100644 --- a/drivers/staging/hv/blkvsc_drv.c +++ b/drivers/staging/hv/blkvsc_drv.c @@ -1167,9 +1167,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); @@ -1496,48 +1538,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-Mar-28 17:00 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 c45677b..95653da 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) { @@ -1210,10 +1218,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-Mar-28 17:00 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 95653da..14cc2ed 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. @@ -1219,9 +1222,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-Mar-28 17:00 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 14cc2ed..9faccbe 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; @@ -373,9 +364,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; @@ -432,7 +420,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) { @@ -859,13 +846,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); @@ -937,7 +917,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; @@ -957,8 +936,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); @@ -1343,8 +1320,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, @@ -1480,7 +1455,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
Greg KH
2011-Apr-05 04:59 UTC
[PATCH 00/22] Staging: hv: Cleanup-storage-drivers-phase-III
On Mon, Mar 28, 2011 at 10:00:15AM -0700, K. Y. Srinivasan wrote:> 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.For some reason, this patch series fails to apply after the first one. So I've not applied any of them, care to resync and resend? thanks, greg k-h
Possibly Parallel Threads
- [PATCH 00/22] Staging: hv: Cleanup-storage-drivers-phase-III
- [RESEND][PATCH 00/22] Staging: hv: Cleanup storage drivers - Phase IV
- [RESEND][PATCH 00/22] Staging: hv: Cleanup storage drivers - Phase IV
- [PATCH 00/22] Staging: hv: Cleanup storage drivers - Phase IV
- [PATCH 00/22] Staging: hv: Cleanup storage drivers - Phase IV