Commit 8a046024 authored by Hank Janssen's avatar Hank Janssen Committed by Greg Kroah-Hartman
Browse files

staging: hv: Convert camel case struct fields in storvsc_api.h to lowercase 



Convert camel case struct fields in vstorage.h to lowercase

Signed-off-by: default avatarAbhishek Kane <v-abkane@microsoft.com>
Signed-off-by: default avatarHaiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: default avatarHank Janssen <hjanssen@microsoft.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent d2aaba45

drivers/staging/hv/blkvsc.c

+10 −10
Original line number Diff line number Diff line
@@ -51,12 +51,12 @@ static int BlkVscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo) 
	 * id. For IDE devices, the device instance id is formatted as

	 * <bus id> * - <device id> - 8899 - 000000000000.

	 */

	deviceInfo->PathId = Device->deviceInstance.data[3] << 24 |

	deviceInfo->path_id = Device->deviceInstance.data[3] << 24 |

			     Device->deviceInstance.data[2] << 16 |

			     Device->deviceInstance.data[1] << 8  |

			     Device->deviceInstance.data[0];



	deviceInfo->TargetId = Device->deviceInstance.data[5] << 8 |

	deviceInfo->target_id = Device->deviceInstance.data[5] << 8 |

			       Device->deviceInstance.data[4];



	return ret;
@@ -75,7 +75,7 @@ int BlkVscInitialize(struct hv_driver *Driver) 
	Driver->name = gBlkDriverName;

	memcpy(&Driver->deviceType, &gBlkVscDeviceType, sizeof(struct hv_guid));



	storDriver->RequestExtSize = sizeof(struct storvsc_request_extension);

	storDriver->request_ext_size = sizeof(struct storvsc_request_extension);



	/*

	 * Divide the ring buffer data size (which is 1 page less than the ring
@@ -83,20 +83,20 @@ int BlkVscInitialize(struct hv_driver *Driver) 
	 * by the max request size (which is

	 * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)

	 */

	storDriver->MaxOutstandingRequestsPerChannel =

		((storDriver->RingBufferSize - PAGE_SIZE) /

	storDriver->max_outstanding_req_per_channel =

		((storDriver->ring_buffer_size - PAGE_SIZE) /

		  ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET +

			   sizeof(struct vstor_packet) + sizeof(u64),

			   sizeof(u64)));



	DPRINT_INFO(BLKVSC, "max io outstd %u",

		    storDriver->MaxOutstandingRequestsPerChannel);

		    storDriver->max_outstanding_req_per_channel);



	/* Setup the dispatch table */

	storDriver->Base.OnDeviceAdd = BlkVscOnDeviceAdd;

	storDriver->Base.OnDeviceRemove = StorVscOnDeviceRemove;

	storDriver->Base.OnCleanup = StorVscOnCleanup;

	storDriver->OnIORequest	= StorVscOnIORequest;

	storDriver->base.OnDeviceAdd = BlkVscOnDeviceAdd;

	storDriver->base.OnDeviceRemove = StorVscOnDeviceRemove;

	storDriver->base.OnCleanup = StorVscOnCleanup;

	storDriver->on_io_request = StorVscOnIORequest;



	return ret;

}

drivers/staging/hv/blkvsc_drv.c

+60 −55
Original line number Diff line number Diff line
@@ -177,13 +177,13 @@ static int blkvsc_drv_init(int (*drv_init)(struct hv_driver *drv)) 
	struct driver_context *drv_ctx = &g_blkvsc_drv.drv_ctx;

	int ret;



	storvsc_drv_obj->RingBufferSize = blkvsc_ringbuffer_size;

	storvsc_drv_obj->ring_buffer_size = blkvsc_ringbuffer_size;



	/* Callback to client driver to complete the initialization */

	drv_init(&storvsc_drv_obj->Base);

	drv_init(&storvsc_drv_obj->base);



	drv_ctx->driver.name = storvsc_drv_obj->Base.name;

	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->Base.deviceType,

	drv_ctx->driver.name = storvsc_drv_obj->base.name;

	memcpy(&drv_ctx->class_id, &storvsc_drv_obj->base.deviceType,

	       sizeof(struct hv_guid));



	drv_ctx->probe = blkvsc_probe;
@@ -230,8 +230,8 @@ static void blkvsc_drv_exit(void) 
		device_unregister(current_dev);

	}



	if (storvsc_drv_obj->Base.OnCleanup)

		storvsc_drv_obj->Base.OnCleanup(&storvsc_drv_obj->Base);

	if (storvsc_drv_obj->base.OnCleanup)

		storvsc_drv_obj->base.OnCleanup(&storvsc_drv_obj->base);



	vmbus_child_driver_unregister(drv_ctx);
@@ -262,7 +262,7 @@ static int blkvsc_probe(struct device *device) 


	DPRINT_DBG(BLKVSC_DRV, "blkvsc_probe - enter");



	if (!storvsc_drv_obj->Base.OnDeviceAdd) {

	if (!storvsc_drv_obj->base.OnDeviceAdd) {

		DPRINT_ERR(BLKVSC_DRV, "OnDeviceAdd() not set");

		ret = -1;

		goto Cleanup;
@@ -284,7 +284,7 @@ static int blkvsc_probe(struct device *device) 


	blkdev->request_pool = kmem_cache_create(dev_name(&device_ctx->device),

					sizeof(struct blkvsc_request) +

					storvsc_drv_obj->RequestExtSize, 0,

					storvsc_drv_obj->request_ext_size, 0,

					SLAB_HWCACHE_ALIGN, NULL);

	if (!blkdev->request_pool) {

		ret = -ENOMEM;
@@ -293,7 +293,7 @@ static int blkvsc_probe(struct device *device) 




	/* Call to the vsc driver to add the device */

	ret = storvsc_drv_obj->Base.OnDeviceAdd(device_obj, &device_info);

	ret = storvsc_drv_obj->base.OnDeviceAdd(device_obj, &device_info);

	if (ret != 0) {

		DPRINT_ERR(BLKVSC_DRV, "unable to add blkvsc device");

		goto Cleanup;
@@ -301,9 +301,9 @@ static int blkvsc_probe(struct device *device) 


	blkdev->device_ctx = device_ctx;

	/* this identified the device 0 or 1 */

	blkdev->target = device_info.TargetId;

	blkdev->target = device_info.target_id;

	/* this identified the ide ctrl 0 or 1 */

	blkdev->path = device_info.PathId;

	blkdev->path = device_info.path_id;



	dev_set_drvdata(device, blkdev);
@@ -391,7 +391,7 @@ static int blkvsc_probe(struct device *device) 
	return ret;



Remove:

	storvsc_drv_obj->Base.OnDeviceRemove(device_obj);

	storvsc_drv_obj->base.OnDeviceRemove(device_obj);



Cleanup:

	if (blkdev) {
@@ -459,9 +459,9 @@ static int blkvsc_do_flush(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.DataBuffer.PfnArray[0] = 0;

	blkvsc_req->request.DataBuffer.Offset = 0;

	blkvsc_req->request.DataBuffer.Length = 0;

	blkvsc_req->request.data_buffer.PfnArray[0] = 0;

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 0;



	blkvsc_req->cmnd[0] = SYNCHRONIZE_CACHE;

	blkvsc_req->cmd_len = 10;
@@ -506,9 +506,9 @@ static int blkvsc_do_inquiry(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.DataBuffer.Offset = 0;

	blkvsc_req->request.DataBuffer.Length = 64;

	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 64;



	blkvsc_req->cmnd[0] = INQUIRY;

	blkvsc_req->cmnd[1] = 0x1;		/* Get product data */
@@ -593,9 +593,9 @@ static int blkvsc_do_read_capacity(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.DataBuffer.Offset = 0;

	blkvsc_req->request.DataBuffer.Length = 8;

	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 8;



	blkvsc_req->cmnd[0] = READ_CAPACITY;

	blkvsc_req->cmd_len = 16;
@@ -614,7 +614,7 @@ static int blkvsc_do_read_capacity(struct block_device_context *blkdev) 
	wait_event_interruptible(blkvsc_req->wevent, blkvsc_req->cond);



	/* check error */

	if (blkvsc_req->request.Status) {

	if (blkvsc_req->request.status) {

		scsi_normalize_sense(blkvsc_req->sense_buffer,

				     SCSI_SENSE_BUFFERSIZE, &sense_hdr);
@@ -670,9 +670,9 @@ static int blkvsc_do_read_capacity16(struct block_device_context *blkdev) 
	blkvsc_req->req = NULL;

	blkvsc_req->write = 0;



	blkvsc_req->request.DataBuffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.DataBuffer.Offset = 0;

	blkvsc_req->request.DataBuffer.Length = 12;

	blkvsc_req->request.data_buffer.PfnArray[0] = page_to_pfn(page_buf);

	blkvsc_req->request.data_buffer.Offset = 0;

	blkvsc_req->request.data_buffer.Length = 12;



	blkvsc_req->cmnd[0] = 0x9E; /* READ_CAPACITY16; */

	blkvsc_req->cmd_len = 16;
@@ -691,7 +691,7 @@ static int blkvsc_do_read_capacity16(struct block_device_context *blkdev) 
	wait_event_interruptible(blkvsc_req->wevent, blkvsc_req->cond);



	/* check error */

	if (blkvsc_req->request.Status) {

	if (blkvsc_req->request.status) {

		scsi_normalize_sense(blkvsc_req->sense_buffer,

				     SCSI_SENSE_BUFFERSIZE, &sense_hdr);

		if (sense_hdr.asc == 0x3A) {
@@ -741,14 +741,14 @@ static int blkvsc_remove(struct device *device) 


	DPRINT_DBG(BLKVSC_DRV, "blkvsc_remove()\n");



	if (!storvsc_drv_obj->Base.OnDeviceRemove)

	if (!storvsc_drv_obj->base.OnDeviceRemove)

		return -1;



	/*

	 * Call to the vsc driver to let it know that the device is being

	 * removed

	 */

	ret = storvsc_drv_obj->Base.OnDeviceRemove(device_obj);

	ret = storvsc_drv_obj->base.OnDeviceRemove(device_obj);

	if (ret != 0) {

		/* TODO: */

		DPRINT_ERR(BLKVSC_DRV,
@@ -865,38 +865,38 @@ static int blkvsc_submit_request(struct blkvsc_request *blkvsc_req, 
		   (blkvsc_req->write) ? "WRITE" : "READ",

		   (unsigned long) blkvsc_req->sector_start,

		   blkvsc_req->sector_count,

		   blkvsc_req->request.DataBuffer.Offset,

		   blkvsc_req->request.DataBuffer.Length);

		   blkvsc_req->request.data_buffer.Offset,

		   blkvsc_req->request.data_buffer.Length);

#if 0

	for (i = 0; i < (blkvsc_req->request.DataBuffer.Length >> 12); i++) {

	for (i = 0; i < (blkvsc_req->request.data_buffer.Length >> 12); i++) {

		DPRINT_DBG(BLKVSC_DRV, "blkvsc_submit_request() - "

			   "req %p pfn[%d] %llx\n",

			   blkvsc_req, i,

			   blkvsc_req->request.DataBuffer.PfnArray[i]);

			   blkvsc_req->request.data_buffer.PfnArray[i]);

	}

#endif



	storvsc_req = &blkvsc_req->request;

	storvsc_req->Extension = (void *)((unsigned long)blkvsc_req +

	storvsc_req->extension = (void *)((unsigned long)blkvsc_req +

					  sizeof(struct blkvsc_request));



	storvsc_req->Type = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;

	storvsc_req->type = blkvsc_req->write ? WRITE_TYPE : READ_TYPE;



	storvsc_req->OnIOCompletion = request_completion;

	storvsc_req->Context = blkvsc_req;

	storvsc_req->on_io_completion = request_completion;

	storvsc_req->context = blkvsc_req;



	storvsc_req->Host = blkdev->port;

	storvsc_req->Bus = blkdev->path;

	storvsc_req->TargetId = blkdev->target;

	storvsc_req->LunId = 0;	 /* this is not really used at all */

	storvsc_req->host = blkdev->port;

	storvsc_req->bus = blkdev->path;

	storvsc_req->target_id = blkdev->target;

	storvsc_req->lun_id = 0;	 /* this is not really used at all */



	storvsc_req->CdbLen = blkvsc_req->cmd_len;

	storvsc_req->Cdb = blkvsc_req->cmnd;

	storvsc_req->cdb_len = blkvsc_req->cmd_len;

	storvsc_req->cdb = blkvsc_req->cmnd;



	storvsc_req->SenseBuffer = blkvsc_req->sense_buffer;

	storvsc_req->SenseBufferSize = SCSI_SENSE_BUFFERSIZE;

	storvsc_req->sense_buffer = blkvsc_req->sense_buffer;

	storvsc_req->sense_buffer_size = SCSI_SENSE_BUFFERSIZE;



	ret = storvsc_drv_obj->OnIORequest(&blkdev->device_ctx->device_obj,

	ret = storvsc_drv_obj->on_io_request(&blkdev->device_ctx->device_obj,

					   &blkvsc_req->request);

	if (ret == 0)

		blkdev->num_outstanding_reqs++;
@@ -992,8 +992,10 @@ static int blkvsc_do_request(struct block_device_context *blkdev, 


					blkvsc_req->dev = blkdev;

					blkvsc_req->req = req;

					blkvsc_req->request.DataBuffer.Offset = bvec->bv_offset;

					blkvsc_req->request.DataBuffer.Length = 0;

					blkvsc_req->request.data_buffer.Offset

						= bvec->bv_offset;

					blkvsc_req->request.data_buffer.Length

						= 0;



					/* Add to the group */

					blkvsc_req->group = group;
@@ -1007,8 +1009,11 @@ static int blkvsc_do_request(struct block_device_context *blkdev, 
				}



				/* Add the curr bvec/segment to the curr blkvsc_req */

				blkvsc_req->request.DataBuffer.PfnArray[databuf_idx] = page_to_pfn(bvec->bv_page);

				blkvsc_req->request.DataBuffer.Length += bvec->bv_len;

				blkvsc_req->request.data_buffer.

					PfnArray[databuf_idx]

						= page_to_pfn(bvec->bv_page);

				blkvsc_req->request.data_buffer.Length

					+= bvec->bv_len;



				prev_bvec = bvec;
@@ -1073,7 +1078,7 @@ static int blkvsc_do_request(struct block_device_context *blkdev, 
static void blkvsc_cmd_completion(struct hv_storvsc_request *request)

{

	struct blkvsc_request *blkvsc_req =

			(struct blkvsc_request *)request->Context;

			(struct blkvsc_request *)request->context;

	struct block_device_context *blkdev =

			(struct block_device_context *)blkvsc_req->dev;

	struct scsi_sense_hdr sense_hdr;
@@ -1083,7 +1088,7 @@ static void blkvsc_cmd_completion(struct hv_storvsc_request *request) 


	blkdev->num_outstanding_reqs--;



	if (blkvsc_req->request.Status)

	if (blkvsc_req->request.status)

		if (scsi_normalize_sense(blkvsc_req->sense_buffer,

					 SCSI_SENSE_BUFFERSIZE, &sense_hdr))

			scsi_print_sense_hdr("blkvsc", &sense_hdr);
@@ -1095,7 +1100,7 @@ static void blkvsc_cmd_completion(struct hv_storvsc_request *request) 
static void blkvsc_request_completion(struct hv_storvsc_request *request)

{

	struct blkvsc_request *blkvsc_req =

			(struct blkvsc_request *)request->Context;

			(struct blkvsc_request *)request->context;

	struct block_device_context *blkdev =

			(struct block_device_context *)blkvsc_req->dev;

	unsigned long flags;
@@ -1110,7 +1115,7 @@ static void blkvsc_request_completion(struct hv_storvsc_request *request) 
		   (blkvsc_req->write) ? "WRITE" : "READ",

		   (unsigned long)blkvsc_req->sector_start,

		   blkvsc_req->sector_count,

		   blkvsc_req->request.DataBuffer.Length,

		   blkvsc_req->request.data_buffer.Length,

		   blkvsc_req->group->outstanding,

		   blkdev->num_outstanding_reqs);
@@ -1137,7 +1142,7 @@ static void blkvsc_request_completion(struct hv_storvsc_request *request) 
			list_del(&comp_req->req_entry);



			if (!__blk_end_request(comp_req->req,

				(!comp_req->request.Status ? 0 : -EIO),

				(!comp_req->request.status ? 0 : -EIO),

				comp_req->sector_count * blkdev->sector_size)) {

				/*

				 * All the sectors have been xferred ie the
@@ -1195,7 +1200,7 @@ static int blkvsc_cancel_pending_reqs(struct block_device_context *blkdev) 


			if (comp_req->req) {

				ret = __blk_end_request(comp_req->req,

					(!comp_req->request.Status ? 0 : -EIO),

					(!comp_req->request.status ? 0 : -EIO),

					comp_req->sector_count *

					blkdev->sector_size);

drivers/staging/hv/storvsc.c

+34 −33
Original line number Diff line number Diff line
@@ -370,16 +370,16 @@ static void StorVscOnIOCompletion(struct hv_device *Device, 
	/* ASSERT(request->OnIOCompletion != NULL); */



	/* Copy over the status...etc */

	request->Status = VStorPacket->vm_srb.scsi_status;

	request->status = VStorPacket->vm_srb.scsi_status;



	if (request->Status != 0 || VStorPacket->vm_srb.srb_status != 1) {

	if (request->status != 0 || VStorPacket->vm_srb.srb_status != 1) {

		DPRINT_WARN(STORVSC,

			    "cmd 0x%x scsi status 0x%x srb status 0x%x\n",

			    request->Cdb[0], VStorPacket->vm_srb.scsi_status,

			    request->cdb[0], VStorPacket->vm_srb.scsi_status,

			    VStorPacket->vm_srb.srb_status);

	}



	if ((request->Status & 0xFF) == 0x02) {

	if ((request->status & 0xFF) == 0x02) {

		/* CHECK_CONDITION */

		if (VStorPacket->vm_srb.srb_status & 0x80) {

			/* autosense data available */
@@ -389,19 +389,19 @@ static void StorVscOnIOCompletion(struct hv_device *Device, 


			/* ASSERT(VStorPacket->vm_srb.sense_info_length <= */

			/* 	request->SenseBufferSize); */

			memcpy(request->SenseBuffer,

			memcpy(request->sense_buffer,

			       VStorPacket->vm_srb.sense_data,

			       VStorPacket->vm_srb.sense_info_length);



			request->SenseBufferSize =

			request->sense_buffer_size =

					VStorPacket->vm_srb.sense_info_length;

		}

	}



	/* TODO: */

	request->BytesXfer = VStorPacket->vm_srb.data_transfer_length;

	request->bytes_xfer = VStorPacket->vm_srb.data_transfer_length;



	request->OnIOCompletion(request);

	request->on_io_completion(request);



	atomic_dec(&storDevice->NumOutstandingRequests);
@@ -501,7 +501,8 @@ static int StorVscConnectToVsp(struct hv_device *Device) 


	/* Open the channel */

	ret = vmbus_open(Device->channel,

			 storDriver->RingBufferSize, storDriver->RingBufferSize,

			 storDriver->ring_buffer_size,

			 storDriver->ring_buffer_size,

			 (void *)&props,

			 sizeof(struct vmstorage_channel_properties),

			 StorVscOnChannelCallback, Device);
@@ -551,13 +552,13 @@ static int StorVscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo) 
	storChannel->PathId = props->PathId;

	storChannel->TargetId = props->TargetId; */



	storDevice->PortNumber = deviceInfo->PortNumber;

	storDevice->PortNumber = deviceInfo->port_number;

	/* Send it back up */

	ret = StorVscConnectToVsp(Device);



	/* deviceInfo->PortNumber = storDevice->PortNumber; */

	deviceInfo->PathId = storDevice->PathId;

	deviceInfo->TargetId = storDevice->TargetId;

	deviceInfo->path_id = storDevice->PathId;

	deviceInfo->target_id = storDevice->TargetId;



	DPRINT_DBG(STORVSC, "assigned port %u, path %u target %u\n",

		   storDevice->PortNumber, storDevice->PathId,
@@ -672,7 +673,7 @@ static int StorVscOnIORequest(struct hv_device *Device, 
	int ret = 0;



	requestExtension =

		(struct storvsc_request_extension *)Request->Extension;

		(struct storvsc_request_extension *)Request->extension;

	vstorPacket = &requestExtension->VStorPacket;

	storDevice = GetStorDevice(Device);
@@ -681,8 +682,8 @@ static int StorVscOnIORequest(struct hv_device *Device, 
		   requestExtension);



	DPRINT_DBG(STORVSC, "req %p len %d bus %d, target %d, lun %d cdblen %d",

		   Request, Request->DataBuffer.Length, Request->Bus,

		   Request->TargetId, Request->LunId, Request->CdbLen);

		   Request, Request->data_buffer.Length, Request->bus,

		   Request->target_id, Request->lun_id, Request->cdb_len);



	if (!storDevice) {

		DPRINT_ERR(STORVSC, "unable to get stor device..."
@@ -702,19 +703,19 @@ static int StorVscOnIORequest(struct hv_device *Device, 


	vstorPacket->vm_srb.length = sizeof(struct vmscsi_request);



	vstorPacket->vm_srb.port_number = Request->Host;

	vstorPacket->vm_srb.path_id = Request->Bus;

	vstorPacket->vm_srb.target_id = Request->TargetId;

	vstorPacket->vm_srb.lun = Request->LunId;

	vstorPacket->vm_srb.port_number = Request->host;

	vstorPacket->vm_srb.path_id = Request->bus;

	vstorPacket->vm_srb.target_id = Request->target_id;

	vstorPacket->vm_srb.lun = Request->lun_id;



	vstorPacket->vm_srb.sense_info_length = SENSE_BUFFER_SIZE;



	/* Copy over the scsi command descriptor block */

	vstorPacket->vm_srb.cdb_length = Request->CdbLen;

	memcpy(&vstorPacket->vm_srb.cdb, Request->Cdb, Request->CdbLen);

	vstorPacket->vm_srb.cdb_length = Request->cdb_len;

	memcpy(&vstorPacket->vm_srb.cdb, Request->cdb, Request->cdb_len);



	vstorPacket->vm_srb.data_in = Request->Type;

	vstorPacket->vm_srb.data_transfer_length = Request->DataBuffer.Length;

	vstorPacket->vm_srb.data_in = Request->type;

	vstorPacket->vm_srb.data_transfer_length = Request->data_buffer.Length;



	vstorPacket->operation = VSTOR_OPERATION_EXECUTE_SRB;
@@ -728,9 +729,9 @@ static int StorVscOnIORequest(struct hv_device *Device, 
		   vstorPacket->vm_srb.sense_info_length,

		   vstorPacket->vm_srb.cdb_length);



	if (requestExtension->Request->DataBuffer.Length) {

	if (requestExtension->Request->data_buffer.Length) {

		ret = vmbus_sendpacket_multipagebuffer(Device->channel,

				&requestExtension->Request->DataBuffer,

				&requestExtension->Request->data_buffer,

				vstorPacket,

				sizeof(struct vstor_packet),

				(unsigned long)requestExtension);
@@ -785,7 +786,7 @@ int StorVscInitialize(struct hv_driver *Driver) 
	memcpy(&Driver->deviceType, &gStorVscDeviceType,

	       sizeof(struct hv_guid));



	storDriver->RequestExtSize = sizeof(struct storvsc_request_extension);

	storDriver->request_ext_size = sizeof(struct storvsc_request_extension);



	/*

	 * Divide the ring buffer data size (which is 1 page less
@@ -793,22 +794,22 @@ int StorVscInitialize(struct hv_driver *Driver) 
	 * the ring buffer indices) by the max request size (which is

	 * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)

	 */

	storDriver->MaxOutstandingRequestsPerChannel =

		((storDriver->RingBufferSize - PAGE_SIZE) /

	storDriver->max_outstanding_req_per_channel =

		((storDriver->ring_buffer_size - PAGE_SIZE) /

		  ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET +

			   sizeof(struct vstor_packet) + sizeof(u64),

			   sizeof(u64)));



	DPRINT_INFO(STORVSC, "max io %u, currently %u\n",

		    storDriver->MaxOutstandingRequestsPerChannel,

		    storDriver->max_outstanding_req_per_channel,

		    STORVSC_MAX_IO_REQUESTS);



	/* Setup the dispatch table */

	storDriver->Base.OnDeviceAdd	= StorVscOnDeviceAdd;

	storDriver->Base.OnDeviceRemove	= StorVscOnDeviceRemove;

	storDriver->Base.OnCleanup	= StorVscOnCleanup;

	storDriver->base.OnDeviceAdd	= StorVscOnDeviceAdd;

	storDriver->base.OnDeviceRemove	= StorVscOnDeviceRemove;

	storDriver->base.OnCleanup	= StorVscOnCleanup;



	storDriver->OnIORequest		= StorVscOnIORequest;

	storDriver->on_io_request	= StorVscOnIORequest;



	return 0;

}

drivers/staging/hv/storvsc_api.h

+25 −25
Original line number Diff line number Diff line
@@ -53,58 +53,58 @@ enum storvsc_request_type{ 
};



struct hv_storvsc_request {

	enum storvsc_request_type Type;

	u32 Host;

	u32 Bus;

	u32 TargetId;

	u32 LunId;

	u8 *Cdb;

	u32 CdbLen;

	u32 Status;

	u32 BytesXfer;

	enum storvsc_request_type type;

	u32 host;

	u32 bus;

	u32 target_id;

	u32 lun_id;

	u8 *cdb;

	u32 cdb_len;

	u32 status;

	u32 bytes_xfer;



	unsigned char *SenseBuffer;

	u32 SenseBufferSize;

	unsigned char *sense_buffer;

	u32 sense_buffer_size;



	void *Context;

	void *context;



	void (*OnIOCompletion)(struct hv_storvsc_request *Request);

	void (*on_io_completion)(struct hv_storvsc_request *request);



	/* This points to the memory after DataBuffer */

	void *Extension;

	void *extension;



	struct hv_multipage_buffer DataBuffer;

	struct hv_multipage_buffer data_buffer;

};



/* Represents the block vsc driver */

struct storvsc_driver_object {

	/* Must be the first field */

	/* Which is a bug FIXME! */

	struct hv_driver Base;

	struct hv_driver base;



	/* Set by caller (in bytes) */

	u32 RingBufferSize;

	u32 ring_buffer_size;



	/* Allocate this much private extension for each I/O request */

	u32 RequestExtSize;

	u32 request_ext_size;



	/* Maximum # of requests in flight per channel/device */

	u32 MaxOutstandingRequestsPerChannel;

	u32 max_outstanding_req_per_channel;



	/* Specific to this driver */

	int (*OnIORequest)(struct hv_device *Device,

			   struct hv_storvsc_request *Request);

	int (*on_io_request)(struct hv_device *device,

			   struct hv_storvsc_request *request);

};



struct storvsc_device_info {

	unsigned int PortNumber;

	unsigned char PathId;

	unsigned char TargetId;

	unsigned int port_number;

	unsigned char path_id;

	unsigned char target_id;

};



/* Interface */

int StorVscInitialize(struct hv_driver *driver);

int StorVscOnHostReset(struct hv_device *Device);

int StorVscOnHostReset(struct hv_device *device);

int BlkVscInitialize(struct hv_driver *driver);



#endif /* _STORVSC_API_H_ */

drivers/staging/hv/storvsc_drv.c

+46 −45

File changed.

Preview size limit exceeded, changes collapsed.