Commit 15b2f647 authored by Haiyang Zhang's avatar Haiyang Zhang Committed by Greg Kroah-Hartman
Browse files

staging: hv: Convert camel cased variables in connection.c to lower cases 



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 a6238f21

drivers/staging/hv/channel.c

+24 −24
Original line number Diff line number Diff line
@@ -77,10 +77,10 @@ static void vmbus_setevent(struct vmbus_channel *channel) 
	if (channel->offermsg.monitor_allocated) {

		/* Each u32 represents 32 channels */

		set_bit(channel->offermsg.child_relid & 31,

			(unsigned long *) gVmbusConnection.SendInterruptPage +

			(unsigned long *) vmbus_connection.SendInterruptPage +

			(channel->offermsg.child_relid >> 5));



		monitorpage = gVmbusConnection.MonitorPages;

		monitorpage = vmbus_connection.MonitorPages;

		monitorpage++; /* Get the child to parent monitor page */



		set_bit(channel->monitor_bit,
@@ -100,11 +100,11 @@ static void VmbusChannelClearEvent(struct vmbus_channel *channel) 
	if (Channel->offermsg.monitor_allocated) {

		/* Each u32 represents 32 channels */

		clear_bit(Channel->offermsg.child_relid & 31,

			  (unsigned long *)gVmbusConnection.SendInterruptPage +

			  (unsigned long *)vmbus_connection.SendInterruptPage +

			  (Channel->offermsg.child_relid >> 5));



		monitorPage =

			(struct hv_monitor_page *)gVmbusConnection.MonitorPages;

			(struct hv_monitor_page *)vmbus_connection.MonitorPages;

		monitorPage++; /* Get the child to parent monitor page */



		clear_bit(Channel->monitor_bit,
@@ -133,7 +133,7 @@ void vmbus_get_debug_info(struct vmbus_channel *channel, 
	       &channel->offermsg.offer.InterfaceInstance,

	       sizeof(struct hv_guid));



	monitorpage = (struct hv_monitor_page *)gVmbusConnection.MonitorPages;

	monitorpage = (struct hv_monitor_page *)vmbus_connection.MonitorPages;



	debuginfo->monitorid = channel->offermsg.monitorid;
@@ -265,10 +265,10 @@ int vmbus_open(struct vmbus_channel *newchannel, u32 send_ringbuffer_size, 
	if (userdatalen)

		memcpy(openMsg->userdata, userdata, userdatalen);



	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_add_tail(&openInfo->msglistentry,

		      &gVmbusConnection.ChannelMsgList);

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

		      &vmbus_connection.ChannelMsgList);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	DPRINT_DBG(VMBUS, "Sending channel open msg...");
@@ -289,9 +289,9 @@ int vmbus_open(struct vmbus_channel *newchannel, u32 send_ringbuffer_size, 
			    newchannel, openInfo->response.open_result.status);



Cleanup:

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_del(&openInfo->msglistentry);

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	kfree(openInfo->waitevent);

	kfree(openInfo);
@@ -501,8 +501,8 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer, 
	unsigned long flags;

	int ret = 0;



	next_gpadl_handle = atomic_read(&gVmbusConnection.NextGpadlHandle);

	atomic_inc(&gVmbusConnection.NextGpadlHandle);

	next_gpadl_handle = atomic_read(&vmbus_connection.NextGpadlHandle);

	atomic_inc(&vmbus_connection.NextGpadlHandle);



	ret = create_gpadl_header(kbuffer, size, &msginfo, &msgcount);

	if (ret)
@@ -521,11 +521,11 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer, 


	dump_gpadl_header(gpadlmsg);



	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_add_tail(&msginfo->msglistentry,

		      &gVmbusConnection.ChannelMsgList);

		      &vmbus_connection.ChannelMsgList);



	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);

	DPRINT_DBG(VMBUS, "buffer %p, size %d msg cnt %d",

		   kbuffer, size, msgcount);
@@ -577,9 +577,9 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer, 
	*gpadl_handle = gpadlmsg->gpadl;



Cleanup:

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_del(&msginfo->msglistentry);

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	kfree(msginfo->waitevent);

	kfree(msginfo);
@@ -616,10 +616,10 @@ int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle) 
	msg->child_relid = channel->offermsg.child_relid;

	msg->gpadl = gpadl_handle;



	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_add_tail(&info->msglistentry,

		      &gVmbusConnection.ChannelMsgList);

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

		      &vmbus_connection.ChannelMsgList);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	ret = VmbusPostMessage(msg,

			       sizeof(struct vmbus_channel_gpadl_teardown));
@@ -631,9 +631,9 @@ int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle) 
	osd_waitevent_wait(info->waitevent);



	/* Received a torndown response */

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_del(&info->msglistentry);

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	kfree(info->waitevent);

	kfree(info);
@@ -697,9 +697,9 @@ void vmbus_close(struct vmbus_channel *channel) 
	 */



	if (channel->state == CHANNEL_OPEN_STATE) {

		spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

		spin_lock_irqsave(&vmbus_connection.channel_lock, flags);

		list_del(&channel->listentry);

		spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

		spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);



		free_channel(channel);

	}

drivers/staging/hv/channel_mgmt.c

+24 −24
Original line number Diff line number Diff line
@@ -308,7 +308,7 @@ void free_channel(struct vmbus_channel *channel) 
	 * ie we can't destroy ourselves.

	 */

	INIT_WORK(&channel->work, release_channel);

	queue_work(gVmbusConnection.WorkQueue, &channel->work);

	queue_work(vmbus_connection.WorkQueue, &channel->work);

}
@@ -323,10 +323,10 @@ static void count_hv_channel(void) 
	static int counter;

	unsigned long flags;



	spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);

	if (++counter == MAX_MSG_TYPES)

		complete(&hv_channel_ready);

	spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);

}



/*
@@ -361,9 +361,9 @@ static void vmbus_process_offer(struct work_struct *work) 
	INIT_WORK(&newchannel->work, vmbus_process_rescind_offer);



	/* Make sure this is a new offer */

	spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);



	list_for_each_entry(channel, &gVmbusConnection.ChannelList, listentry) {

	list_for_each_entry(channel, &vmbus_connection.ChannelList, listentry) {

		if (!memcmp(&channel->offermsg.offer.InterfaceType,

			    &newchannel->offermsg.offer.InterfaceType,

			    sizeof(struct hv_guid)) &&
@@ -377,9 +377,9 @@ static void vmbus_process_offer(struct work_struct *work) 


	if (fnew)

		list_add_tail(&newchannel->listentry,

			      &gVmbusConnection.ChannelList);

			      &vmbus_connection.ChannelList);



	spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);



	if (!fnew) {

		DPRINT_DBG(VMBUS, "Ignoring duplicate offer for relid (%d)",
@@ -412,9 +412,9 @@ static void vmbus_process_offer(struct work_struct *work) 
			   "unable to add child device object (relid %d)",

			   newchannel->offermsg.child_relid);



		spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

		spin_lock_irqsave(&vmbus_connection.channel_lock, flags);

		list_del(&newchannel->listentry);

		spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

		spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);



		free_channel(newchannel);

	} else {
@@ -577,9 +577,9 @@ static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr) 
	/*

	 * Find the open msg, copy the result and signal/unblock the wait event

	 */

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);



	list_for_each(curr, &gVmbusConnection.ChannelMsgList) {

	list_for_each(curr, &vmbus_connection.ChannelMsgList) {

/* FIXME: this should probably use list_entry() instead */

		msginfo = (struct vmbus_channel_msginfo *)curr;

		requestheader =
@@ -598,7 +598,7 @@ static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr) 
			}

		}

	}

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);

}



/*
@@ -625,9 +625,9 @@ static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr) 
	 * Find the establish msg, copy the result and signal/unblock the wait

	 * event

	 */

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);



	list_for_each(curr, &gVmbusConnection.ChannelMsgList) {

	list_for_each(curr, &vmbus_connection.ChannelMsgList) {

/* FIXME: this should probably use list_entry() instead */

		msginfo = (struct vmbus_channel_msginfo *)curr;

		requestheader =
@@ -648,7 +648,7 @@ static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr) 
			}

		}

	}

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);

}



/*
@@ -673,9 +673,9 @@ static void vmbus_ongpadl_torndown( 
	/*

	 * Find the open msg, copy the result and signal/unblock the wait event

	 */

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);



	list_for_each(curr, &gVmbusConnection.ChannelMsgList) {

	list_for_each(curr, &vmbus_connection.ChannelMsgList) {

/* FIXME: this should probably use list_entry() instead */

		msginfo = (struct vmbus_channel_msginfo *)curr;

		requestheader =
@@ -694,7 +694,7 @@ static void vmbus_ongpadl_torndown( 
			}

		}

	}

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);

}



/*
@@ -715,9 +715,9 @@ static void vmbus_onversion_response( 
	unsigned long flags;



	version_response = (struct vmbus_channel_version_response *)hdr;

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);



	list_for_each(curr, &gVmbusConnection.ChannelMsgList) {

	list_for_each(curr, &vmbus_connection.ChannelMsgList) {

/* FIXME: this should probably use list_entry() instead */

		msginfo = (struct vmbus_channel_msginfo *)curr;

		requestheader =
@@ -733,7 +733,7 @@ static void vmbus_onversion_response( 
			osd_waitevent_set(msginfo->waitevent);

		}

	}

	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);

}



/* Channel message dispatch table */
@@ -857,9 +857,9 @@ void vmbus_release_unattached_channels(void) 
	struct vmbus_channel *start = NULL;

	unsigned long flags;



	spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);



	list_for_each_entry_safe(channel, pos, &gVmbusConnection.ChannelList,

	list_for_each_entry_safe(channel, pos, &vmbus_connection.ChannelList,

				 listentry) {

		if (channel == start)

			break;
@@ -878,7 +878,7 @@ void vmbus_release_unattached_channels(void) 
		}

	}



	spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);

}



/* eof */

drivers/staging/hv/connection.c

+78 −76
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ 
#include "vmbus_private.h"





struct VMBUS_CONNECTION gVmbusConnection = {

struct VMBUS_CONNECTION vmbus_connection = {

	.ConnectState		= Disconnected,

	.NextGpadlHandle	= ATOMIC_INIT(0xE1E10),

};
@@ -40,86 +40,86 @@ struct VMBUS_CONNECTION gVmbusConnection = { 
int VmbusConnect(void)

{

	int ret = 0;

	struct vmbus_channel_msginfo *msgInfo = NULL;

	struct vmbus_channel_msginfo *msginfo = NULL;

	struct vmbus_channel_initiate_contact *msg;

	unsigned long flags;



	/* Make sure we are not connecting or connected */

	if (gVmbusConnection.ConnectState != Disconnected)

	if (vmbus_connection.ConnectState != Disconnected)

		return -1;



	/* Initialize the vmbus connection */

	gVmbusConnection.ConnectState = Connecting;

	gVmbusConnection.WorkQueue = create_workqueue("hv_vmbus_con");

	if (!gVmbusConnection.WorkQueue) {

	vmbus_connection.ConnectState = Connecting;

	vmbus_connection.WorkQueue = create_workqueue("hv_vmbus_con");

	if (!vmbus_connection.WorkQueue) {

		ret = -1;

		goto Cleanup;

	}



	INIT_LIST_HEAD(&gVmbusConnection.ChannelMsgList);

	spin_lock_init(&gVmbusConnection.channelmsg_lock);

	INIT_LIST_HEAD(&vmbus_connection.ChannelMsgList);

	spin_lock_init(&vmbus_connection.channelmsg_lock);



	INIT_LIST_HEAD(&gVmbusConnection.ChannelList);

	spin_lock_init(&gVmbusConnection.channel_lock);

	INIT_LIST_HEAD(&vmbus_connection.ChannelList);

	spin_lock_init(&vmbus_connection.channel_lock);



	/*

	 * Setup the vmbus event connection for channel interrupt

	 * abstraction stuff

	 */

	gVmbusConnection.InterruptPage = osd_page_alloc(1);

	if (gVmbusConnection.InterruptPage == NULL) {

	vmbus_connection.InterruptPage = osd_page_alloc(1);

	if (vmbus_connection.InterruptPage == NULL) {

		ret = -1;

		goto Cleanup;

	}



	gVmbusConnection.RecvInterruptPage = gVmbusConnection.InterruptPage;

	gVmbusConnection.SendInterruptPage =

		(void *)((unsigned long)gVmbusConnection.InterruptPage +

	vmbus_connection.RecvInterruptPage = vmbus_connection.InterruptPage;

	vmbus_connection.SendInterruptPage =

		(void *)((unsigned long)vmbus_connection.InterruptPage +

			(PAGE_SIZE >> 1));



	/*

	 * Setup the monitor notification facility. The 1st page for

	 * parent->child and the 2nd page for child->parent

	 */

	gVmbusConnection.MonitorPages = osd_page_alloc(2);

	if (gVmbusConnection.MonitorPages == NULL) {

	vmbus_connection.MonitorPages = osd_page_alloc(2);

	if (vmbus_connection.MonitorPages == NULL) {

		ret = -1;

		goto Cleanup;

	}



	msgInfo = kzalloc(sizeof(*msgInfo) +

	msginfo = kzalloc(sizeof(*msginfo) +

			  sizeof(struct vmbus_channel_initiate_contact),

			  GFP_KERNEL);

	if (msgInfo == NULL) {

	if (msginfo == NULL) {

		ret = -ENOMEM;

		goto Cleanup;

	}



	msgInfo->waitevent = osd_waitevent_create();

	if (!msgInfo->waitevent) {

	msginfo->waitevent = osd_waitevent_create();

	if (!msginfo->waitevent) {

		ret = -ENOMEM;

		goto Cleanup;

	}



	msg = (struct vmbus_channel_initiate_contact *)msgInfo->msg;

	msg = (struct vmbus_channel_initiate_contact *)msginfo->msg;



	msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT;

	msg->vmbus_version_requested = VMBUS_REVISION_NUMBER;

	msg->interrupt_page = virt_to_phys(gVmbusConnection.InterruptPage);

	msg->monitor_page1 = virt_to_phys(gVmbusConnection.MonitorPages);

	msg->interrupt_page = virt_to_phys(vmbus_connection.InterruptPage);

	msg->monitor_page1 = virt_to_phys(vmbus_connection.MonitorPages);

	msg->monitor_page2 = virt_to_phys(

			(void *)((unsigned long)gVmbusConnection.MonitorPages +

			(void *)((unsigned long)vmbus_connection.MonitorPages +

				 PAGE_SIZE));



	/*

	 * Add to list before we send the request since we may

	 * receive the response before returning from this routine

	 */

	spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);

	list_add_tail(&msgInfo->msglistentry,

		      &gVmbusConnection.ChannelMsgList);

	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);

	list_add_tail(&msginfo->msglistentry,

		      &vmbus_connection.ChannelMsgList);



	spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);



	DPRINT_DBG(VMBUS, "Vmbus connection - interrupt pfn %llx, "

		   "monitor1 pfn %llx,, monitor2 pfn %llx",
@@ -129,19 +129,19 @@ int VmbusConnect(void) 
	ret = VmbusPostMessage(msg,

			       sizeof(struct vmbus_channel_initiate_contact));

	if (ret != 0) {

		list_del(&msgInfo->msglistentry);

		list_del(&msginfo->msglistentry);

		goto Cleanup;

	}



	/* Wait for the connection response */

	osd_waitevent_wait(msgInfo->waitevent);

	osd_waitevent_wait(msginfo->waitevent);



	list_del(&msgInfo->msglistentry);

	list_del(&msginfo->msglistentry);



	/* Check if successful */

	if (msgInfo->response.version_response.version_supported) {

	if (msginfo->response.version_response.version_supported) {

		DPRINT_INFO(VMBUS, "Vmbus connected!!");

		gVmbusConnection.ConnectState = Connected;

		vmbus_connection.ConnectState = Connected;



	} else {

		DPRINT_ERR(VMBUS, "Vmbus connection failed!!..."
@@ -151,29 +151,29 @@ int VmbusConnect(void) 
		goto Cleanup;

	}



	kfree(msgInfo->waitevent);

	kfree(msgInfo);

	kfree(msginfo->waitevent);

	kfree(msginfo);

	return 0;



Cleanup:

	gVmbusConnection.ConnectState = Disconnected;

	vmbus_connection.ConnectState = Disconnected;



	if (gVmbusConnection.WorkQueue)

		destroy_workqueue(gVmbusConnection.WorkQueue);

	if (vmbus_connection.WorkQueue)

		destroy_workqueue(vmbus_connection.WorkQueue);



	if (gVmbusConnection.InterruptPage) {

		osd_page_free(gVmbusConnection.InterruptPage, 1);

		gVmbusConnection.InterruptPage = NULL;

	if (vmbus_connection.InterruptPage) {

		osd_page_free(vmbus_connection.InterruptPage, 1);

		vmbus_connection.InterruptPage = NULL;

	}



	if (gVmbusConnection.MonitorPages) {

		osd_page_free(gVmbusConnection.MonitorPages, 2);

		gVmbusConnection.MonitorPages = NULL;

	if (vmbus_connection.MonitorPages) {

		osd_page_free(vmbus_connection.MonitorPages, 2);

		vmbus_connection.MonitorPages = NULL;

	}



	if (msgInfo) {

		kfree(msgInfo->waitevent);

		kfree(msgInfo);

	if (msginfo) {

		kfree(msginfo->waitevent);

		kfree(msginfo);

	}



	return ret;
@@ -188,7 +188,7 @@ int VmbusDisconnect(void) 
	struct vmbus_channel_message_header *msg;



	/* Make sure we are connected */

	if (gVmbusConnection.ConnectState != Connected)

	if (vmbus_connection.ConnectState != Connected)

		return -1;



	msg = kzalloc(sizeof(struct vmbus_channel_message_header), GFP_KERNEL);
@@ -202,12 +202,12 @@ int VmbusDisconnect(void) 
	if (ret != 0)

		goto Cleanup;



	osd_page_free(gVmbusConnection.InterruptPage, 1);

	osd_page_free(vmbus_connection.InterruptPage, 1);



	/* TODO: iterate thru the msg list and free up */

	destroy_workqueue(gVmbusConnection.WorkQueue);

	destroy_workqueue(vmbus_connection.WorkQueue);



	gVmbusConnection.ConnectState = Disconnected;

	vmbus_connection.ConnectState = Disconnected;



	DPRINT_INFO(VMBUS, "Vmbus disconnected!!");
@@ -219,22 +219,22 @@ int VmbusDisconnect(void) 
/*

 * GetChannelFromRelId - Get the channel object given its child relative id (ie channel id)

 */

struct vmbus_channel *GetChannelFromRelId(u32 relId)

struct vmbus_channel *GetChannelFromRelId(u32 relid)

{

	struct vmbus_channel *channel;

	struct vmbus_channel *foundChannel  = NULL;

	struct vmbus_channel *found_channel  = NULL;

	unsigned long flags;



	spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);

	list_for_each_entry(channel, &gVmbusConnection.ChannelList, listentry) {

		if (channel->offermsg.child_relid == relId) {

			foundChannel = channel;

	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);

	list_for_each_entry(channel, &vmbus_connection.ChannelList, listentry) {

		if (channel->offermsg.child_relid == relid) {

			found_channel = channel;

			break;

		}

	}

	spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);

	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);



	return foundChannel;

	return found_channel;

}



/*
@@ -243,7 +243,7 @@ struct vmbus_channel *GetChannelFromRelId(u32 relId) 
static void VmbusProcessChannelEvent(void *context)

{

	struct vmbus_channel *channel;

	u32 relId = (u32)(unsigned long)context;

	u32 relid = (u32)(unsigned long)context;



	/* ASSERT(relId > 0); */
@@ -251,7 +251,7 @@ static void VmbusProcessChannelEvent(void *context) 
	 * Find the channel based on this relid and invokes the

	 * channel callback to process the event

	 */

	channel = GetChannelFromRelId(relId);

	channel = GetChannelFromRelId(relid);



	if (channel) {

		vmbus_onchannel_event(channel);
@@ -261,7 +261,7 @@ static void VmbusProcessChannelEvent(void *context) 
		 *			  (void*)channel);

		 */

	} else {

		DPRINT_ERR(VMBUS, "channel not found for relid - %d.", relId);

		DPRINT_ERR(VMBUS, "channel not found for relid - %d.", relid);

	}

}
@@ -274,14 +274,16 @@ void VmbusOnEvents(void) 
	int maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;

	int bit;

	int relid;

	u32 *recvInterruptPage = gVmbusConnection.RecvInterruptPage;

	u32 *recv_int_page = vmbus_connection.RecvInterruptPage;



	/* Check events */

	if (recvInterruptPage) {

	if (recv_int_page) {

		for (dword = 0; dword < maxdword; dword++) {

			if (recvInterruptPage[dword]) {

			if (recv_int_page[dword]) {

				for (bit = 0; bit < 32; bit++) {

					if (test_and_clear_bit(bit, (unsigned long *)&recvInterruptPage[dword])) {

					if (test_and_clear_bit(bit,

						(unsigned long *)

						&recv_int_page[dword])) {

						relid = (dword << 5) + bit;

						DPRINT_DBG(VMBUS, "event detected for relid - %d", relid);
@@ -305,24 +307,24 @@ void VmbusOnEvents(void) 
/*

 * VmbusPostMessage - Send a msg on the vmbus's message connection

 */

int VmbusPostMessage(void *buffer, size_t bufferLen)

int VmbusPostMessage(void *buffer, size_t buflen)

{

	union hv_connection_id connId;

	union hv_connection_id conn_id;



	connId.asu32 = 0;

	connId.u.id = VMBUS_MESSAGE_CONNECTION_ID;

	return hv_post_message(connId, 1, buffer, bufferLen);

	conn_id.asu32 = 0;

	conn_id.u.id = VMBUS_MESSAGE_CONNECTION_ID;

	return hv_post_message(conn_id, 1, buffer, buflen);

}



/*

 * VmbusSetEvent - Send an event notification to the parent

 */

int VmbusSetEvent(u32 childRelId)

int VmbusSetEvent(u32 child_relid)

{

	/* Each u32 represents 32 channels */

	set_bit(childRelId & 31,

		(unsigned long *)gVmbusConnection.SendInterruptPage +

		(childRelId >> 5));

	set_bit(child_relid & 31,

		(unsigned long *)vmbus_connection.SendInterruptPage +

		(child_relid >> 5));



	return hv_signal_event();

}

drivers/staging/hv/vmbus_drv.c

+1 −1
Original line number Diff line number Diff line
@@ -239,7 +239,7 @@ static void vmbus_on_msg_dpc(struct hv_driver *drv) 
				continue;

			INIT_WORK(&ctx->work, vmbus_onmessage_work);

			memcpy(&ctx->msg, msg, sizeof(*msg));

			queue_work(gVmbusConnection.WorkQueue, &ctx->work);

			queue_work(vmbus_connection.WorkQueue, &ctx->work);

		}



		msg->header.message_type = HVMSG_NONE;

drivers/staging/hv/vmbus_private.h

+1 −1
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ struct VMBUS_MSGINFO { 
};





extern struct VMBUS_CONNECTION gVmbusConnection;

extern struct VMBUS_CONNECTION vmbus_connection;



/* General vmbus interface */