*
*/
-#define KERNEL_2_6_27
-
#include <linux/kernel.h>
+#include <linux/mm.h>
#include "include/logging.h"
#include "include/NetVscApi.h"
#include "RndisFilter.h"
-//
-// Data types
-//
+
+/* Data types */
+
typedef struct _RNDIS_FILTER_DRIVER_OBJECT {
- // The original driver
+ /* The original driver */
NETVSC_DRIVER_OBJECT InnerDriver;
} RNDIS_FILTER_DRIVER_OBJECT;
} RNDIS_DEVICE_STATE;
typedef struct _RNDIS_DEVICE {
- NETVSC_DEVICE *NetDevice;
+ struct NETVSC_DEVICE *NetDevice;
RNDIS_DEVICE_STATE State;
u32 LinkStatus;
u32 NewRequestId;
- HANDLE RequestLock;
+ spinlock_t request_lock;
LIST_ENTRY RequestList;
- UCHAR HwMacAddr[HW_MACADDR_LEN];
+ unsigned char HwMacAddr[HW_MACADDR_LEN];
} RNDIS_DEVICE;
typedef struct _RNDIS_REQUEST {
LIST_ENTRY ListEntry;
- HANDLE WaitEvent;
+ struct osd_waitevent *WaitEvent;
- // FIXME: We assumed a fixed size response here. If we do ever need to handle a bigger response,
- // we can either define a max response message or add a response buffer variable above this field
+ /* FIXME: We assumed a fixed size response here. If we do ever need to handle a bigger response, */
+ /* we can either define a max response message or add a response buffer variable above this field */
RNDIS_MESSAGE ResponseMessage;
- // Simplify allocation by having a netvsc packet inline
- NETVSC_PACKET Packet;
+ /* Simplify allocation by having a netvsc packet inline */
+ struct hv_netvsc_packet Packet;
PAGE_BUFFER Buffer;
- // FIXME: We assumed a fixed size request here.
+ /* FIXME: We assumed a fixed size request here. */
RNDIS_MESSAGE RequestMessage;
} RNDIS_REQUEST;
RNDIS_MESSAGE Message;
} RNDIS_FILTER_PACKET;
-//
-// Internal routines
-//
+
+/* Internal routines */
+
static int
RndisFilterSendRequest(
RNDIS_DEVICE *Device,
RndisFilterReceiveData(
RNDIS_DEVICE *Device,
RNDIS_MESSAGE *Message,
- NETVSC_PACKET *Packet
+ struct hv_netvsc_packet *Packet
);
static int
RndisFilterOnReceive(
- DEVICE_OBJECT *Device,
- NETVSC_PACKET *Packet
+ struct hv_device *Device,
+ struct hv_netvsc_packet *Packet
);
static int
static int
RndisFilterOnDeviceAdd(
- DEVICE_OBJECT *Device,
+ struct hv_device *Device,
void *AdditionalInfo
);
static int
RndisFilterOnDeviceRemove(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
);
static void
RndisFilterOnCleanup(
- DRIVER_OBJECT *Driver
+ struct hv_driver *Driver
);
static int
RndisFilterOnOpen(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
);
static int
RndisFilterOnClose(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
);
static int
RndisFilterOnSend(
- DEVICE_OBJECT *Device,
- NETVSC_PACKET *Packet
+ struct hv_device *Device,
+ struct hv_netvsc_packet *Packet
);
static void
void *Context
);
-//
-// Global var
-//
-// The one and only
-RNDIS_FILTER_DRIVER_OBJECT gRndisFilter;
+/* Global var */
+
+
+/* The one and only */
+static RNDIS_FILTER_DRIVER_OBJECT gRndisFilter;
static inline RNDIS_DEVICE* GetRndisDevice(void)
{
RNDIS_DEVICE *device;
- device = MemAllocZeroed(sizeof(RNDIS_DEVICE));
+ device = kzalloc(sizeof(RNDIS_DEVICE), GFP_KERNEL);
if (!device)
{
return NULL;
}
- device->RequestLock = SpinlockCreate();
- if (!device->RequestLock)
- {
- MemFree(device);
- return NULL;
- }
+ spin_lock_init(&device->request_lock);
INITIALIZE_LIST_HEAD(&device->RequestList);
static inline void PutRndisDevice(RNDIS_DEVICE *Device)
{
- SpinlockClose(Device->RequestLock);
- MemFree(Device);
+ kfree(Device);
}
static inline RNDIS_REQUEST* GetRndisRequest(RNDIS_DEVICE *Device, u32 MessageType, u32 MessageLength)
RNDIS_REQUEST *request;
RNDIS_MESSAGE *rndisMessage;
RNDIS_SET_REQUEST *set;
+ unsigned long flags;
- request = MemAllocZeroed(sizeof(RNDIS_REQUEST));
+ request = kzalloc(sizeof(RNDIS_REQUEST), GFP_KERNEL);
if (!request)
{
return NULL;
request->WaitEvent = WaitEventCreate();
if (!request->WaitEvent)
{
- MemFree(request);
+ kfree(request);
return NULL;
}
rndisMessage->NdisMessageType = MessageType;
rndisMessage->MessageLength = MessageLength;
- // Set the request id. This field is always after the rndis header for request/response packet types so
- // we just used the SetRequest as a template
+ /* Set the request id. This field is always after the rndis header for request/response packet types so */
+ /* we just used the SetRequest as a template */
set = &rndisMessage->Message.SetRequest;
set->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
- // Add to the request list
- SpinlockAcquire(Device->RequestLock);
+ /* Add to the request list */
+ spin_lock_irqsave(&Device->request_lock, flags);
INSERT_TAIL_LIST(&Device->RequestList, &request->ListEntry);
- SpinlockRelease(Device->RequestLock);
+ spin_unlock_irqrestore(&Device->request_lock, flags);
return request;
}
static inline void PutRndisRequest(RNDIS_DEVICE *Device, RNDIS_REQUEST *Request)
{
- SpinlockAcquire(Device->RequestLock);
+ unsigned long flags;
+
+ spin_lock_irqsave(&Device->request_lock, flags);
REMOVE_ENTRY_LIST(&Request->ListEntry);
- SpinlockRelease(Device->RequestLock);
+ spin_unlock_irqrestore(&Device->request_lock, flags);
WaitEventClose(Request->WaitEvent);
- MemFree(Request);
+ kfree(Request);
}
static inline void DumpRndisMessage(RNDIS_MESSAGE *RndisMessage)
)
{
int ret=0;
- NETVSC_PACKET *packet;
+ struct hv_netvsc_packet *packet;
DPRINT_ENTER(NETVSC);
- // Setup the packet to send it
+ /* Setup the packet to send it */
packet = &Request->Packet;
- packet->IsDataPacket = FALSE;
+ packet->IsDataPacket = false;
packet->TotalDataBufferLength = Request->RequestMessage.MessageLength;
packet->PageBufferCount = 1;
packet->PageBuffers[0].Pfn = GetPhysicalAddress(&Request->RequestMessage) >> PAGE_SHIFT;
packet->PageBuffers[0].Length = Request->RequestMessage.MessageLength;
- packet->PageBuffers[0].Offset = (ULONG_PTR)&Request->RequestMessage & (PAGE_SIZE -1);
+ packet->PageBuffers[0].Offset = (unsigned long)&Request->RequestMessage & (PAGE_SIZE -1);
- packet->Completion.Send.SendCompletionContext = Request;//packet;
+ packet->Completion.Send.SendCompletionContext = Request;/* packet; */
packet->Completion.Send.OnSendCompletion = RndisFilterOnSendRequestCompletion;
- packet->Completion.Send.SendCompletionTid = (ULONG_PTR)Device;
+ packet->Completion.Send.SendCompletionTid = (unsigned long)Device;
ret = gRndisFilter.InnerDriver.OnSend(Device->NetDevice->Device, packet);
DPRINT_EXIT(NETVSC);
LIST_ENTRY *anchor;
LIST_ENTRY *curr;
RNDIS_REQUEST *request=NULL;
- BOOL found=FALSE;
+ bool found = false;
+ unsigned long flags;
DPRINT_ENTER(NETVSC);
- SpinlockAcquire(Device->RequestLock);
+ spin_lock_irqsave(&Device->request_lock, flags);
ITERATE_LIST_ENTRIES(anchor, curr, &Device->RequestList)
{
request = CONTAINING_RECORD(curr, RNDIS_REQUEST, ListEntry);
- // All request/response message contains RequestId as the 1st field
+ /* All request/response message contains RequestId as the 1st field */
if (request->RequestMessage.Message.InitializeRequest.RequestId == Response->Message.InitializeComplete.RequestId)
{
DPRINT_DBG(NETVSC, "found rndis request for this response (id 0x%x req type 0x%x res type 0x%x)",
request->RequestMessage.Message.InitializeRequest.RequestId, request->RequestMessage.NdisMessageType, Response->NdisMessageType);
- found = TRUE;
+ found = true;
break;
}
}
- SpinlockRelease(Device->RequestLock);
+ spin_unlock_irqrestore(&Device->request_lock, flags);
if (found)
{
}
else
{
- DPRINT_ERR(NETVSC, "rndis response buffer overflow detected (size %u max %u)", Response->MessageLength, sizeof(RNDIS_FILTER_PACKET));
+ DPRINT_ERR(NETVSC, "rndis response buffer overflow detected (size %u max %zu)", Response->MessageLength, sizeof(RNDIS_FILTER_PACKET));
- if (Response->NdisMessageType == REMOTE_NDIS_RESET_CMPLT) // does not have a request id field
+ if (Response->NdisMessageType == REMOTE_NDIS_RESET_CMPLT) /* does not have a request id field */
{
request->ResponseMessage.Message.ResetComplete.Status = STATUS_BUFFER_OVERFLOW;
}
}
else
{
- // TODO:
+ /* TODO: */
}
}
RndisFilterReceiveData(
RNDIS_DEVICE *Device,
RNDIS_MESSAGE *Message,
- NETVSC_PACKET *Packet
+ struct hv_netvsc_packet *Packet
)
{
RNDIS_PACKET *rndisPacket;
DPRINT_ENTER(NETVSC);
- // empty ethernet frame ??
+ /* empty ethernet frame ?? */
ASSERT(Packet->PageBuffers[0].Length > RNDIS_MESSAGE_SIZE(RNDIS_PACKET));
rndisPacket = &Message->Message.Packet;
- // FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this
- // netvsc packet (ie TotalDataBufferLength != MessageLength)
+ /* FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this */
+ /* netvsc packet (ie TotalDataBufferLength != MessageLength) */
- // Remove the rndis header and pass it back up the stack
+ /* Remove the rndis header and pass it back up the stack */
dataOffset = RNDIS_HEADER_SIZE + rndisPacket->DataOffset;
Packet->TotalDataBufferLength -= dataOffset;
Packet->PageBuffers[0].Offset += dataOffset;
Packet->PageBuffers[0].Length -= dataOffset;
- Packet->IsDataPacket = TRUE;
+ Packet->IsDataPacket = true;
gRndisFilter.InnerDriver.OnReceiveCallback(Device->NetDevice->Device, Packet);
static int
RndisFilterOnReceive(
- DEVICE_OBJECT *Device,
- NETVSC_PACKET *Packet
+ struct hv_device *Device,
+ struct hv_netvsc_packet *Packet
)
{
- NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
+ struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
RNDIS_DEVICE *rndisDevice;
RNDIS_MESSAGE rndisMessage;
RNDIS_MESSAGE *rndisHeader;
DPRINT_ENTER(NETVSC);
ASSERT(netDevice);
- //Make sure the rndis device state is initialized
+ /* Make sure the rndis device state is initialized */
if (!netDevice->Extension)
{
DPRINT_ERR(NETVSC, "got rndis message but no rndis device...dropping this message!");
rndisHeader = (RNDIS_MESSAGE*)PageMapVirtualAddress(Packet->PageBuffers[0].Pfn);
- rndisHeader = (void*)((ULONG_PTR)rndisHeader + Packet->PageBuffers[0].Offset);
+ rndisHeader = (void*)((unsigned long)rndisHeader + Packet->PageBuffers[0].Offset);
- // Make sure we got a valid rndis message
- // FIXME: There seems to be a bug in set completion msg where its MessageLength is 16 bytes but
- // the ByteCount field in the xfer page range shows 52 bytes
+ /* Make sure we got a valid rndis message */
+ /* FIXME: There seems to be a bug in set completion msg where its MessageLength is 16 bytes but */
+ /* the ByteCount field in the xfer page range shows 52 bytes */
#if 0
if ( Packet->TotalDataBufferLength != rndisHeader->MessageLength )
{
- PageUnmapVirtualAddress((void*)(ULONG_PTR)rndisHeader - Packet->PageBuffers[0].Offset);
+ PageUnmapVirtualAddress((void*)(unsigned long)rndisHeader - Packet->PageBuffers[0].Offset);
DPRINT_ERR(NETVSC, "invalid rndis message? (expected %u bytes got %u)...dropping this message!",
rndisHeader->MessageLength, Packet->TotalDataBufferLength);
if ((rndisHeader->NdisMessageType != REMOTE_NDIS_PACKET_MSG) && (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE)))
{
- DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow detected (got %u, max %u)...marking it an error!",
+ DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow detected (got %u, max %zu)...marking it an error!",
rndisHeader->MessageLength, sizeof(RNDIS_MESSAGE));
}
memcpy(&rndisMessage, rndisHeader, (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE))?sizeof(RNDIS_MESSAGE):rndisHeader->MessageLength);
- PageUnmapVirtualAddress((void*)(ULONG_PTR)rndisHeader - Packet->PageBuffers[0].Offset);
+ PageUnmapVirtualAddress((void*)(unsigned long)rndisHeader - Packet->PageBuffers[0].Offset);
DumpRndisMessage(&rndisMessage);
switch (rndisMessage.NdisMessageType)
{
- // data msg
+ /* data msg */
case REMOTE_NDIS_PACKET_MSG:
RndisFilterReceiveData(rndisDevice, &rndisMessage, Packet);
break;
- // completion msgs
+ /* completion msgs */
case REMOTE_NDIS_INITIALIZE_CMPLT:
case REMOTE_NDIS_QUERY_CMPLT:
case REMOTE_NDIS_SET_CMPLT:
- //case REMOTE_NDIS_RESET_CMPLT:
- //case REMOTE_NDIS_KEEPALIVE_CMPLT:
+ /* case REMOTE_NDIS_RESET_CMPLT: */
+ /* case REMOTE_NDIS_KEEPALIVE_CMPLT: */
RndisFilterReceiveResponse(rndisDevice, &rndisMessage);
break;
- // notification msgs
+ /* notification msgs */
case REMOTE_NDIS_INDICATE_STATUS_MSG:
RndisFilterReceiveIndicateStatus(rndisDevice, &rndisMessage);
break;
goto Cleanup;
}
- // Setup the rndis query
+ /* Setup the rndis query */
query = &request->RequestMessage.Message.QueryRequest;
query->Oid = Oid;
query->InformationBufferOffset = sizeof(RNDIS_QUERY_REQUEST);
WaitEventWait(request->WaitEvent);
- // Copy the response back
+ /* Copy the response back */
queryComplete = &request->ResponseMessage.Message.QueryComplete;
if (queryComplete->InformationBufferLength > inresultSize)
}
memcpy(Result,
- (void*)((ULONG_PTR)queryComplete + queryComplete->InformationBufferOffset),
+ (void*)((unsigned long)queryComplete + queryComplete->InformationBufferOffset),
queryComplete->InformationBufferLength);
*ResultSize = queryComplete->InformationBufferLength;
goto Cleanup;
}
- // Setup the rndis set
+ /* Setup the rndis set */
set = &request->RequestMessage.Message.SetRequest;
set->Oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
set->InformationBufferLength = sizeof(u32);
set->InformationBufferOffset = sizeof(RNDIS_SET_REQUEST);
- memcpy((void*)(ULONG_PTR)set + sizeof(RNDIS_SET_REQUEST), &NewFilter, sizeof(u32));
+ memcpy((void*)(unsigned long)set + sizeof(RNDIS_SET_REQUEST), &NewFilter, sizeof(u32));
ret = RndisFilterSendRequest(Device, request);
if (ret != 0)
{
ret = -1;
DPRINT_ERR(NETVSC, "timeout before we got a set response...");
- // We cant deallocate the request since we may still receive a send completion for it.
+ /* We cant deallocate the request since we may still receive a send completion for it. */
goto Exit;
}
else
{
DPRINT_ENTER(NETVSC);
- DPRINT_DBG(NETVSC, "sizeof(RNDIS_FILTER_PACKET) == %d", sizeof(RNDIS_FILTER_PACKET));
+ DPRINT_DBG(NETVSC, "sizeof(RNDIS_FILTER_PACKET) == %zd", sizeof(RNDIS_FILTER_PACKET));
Driver->RequestExtSize = sizeof(RNDIS_FILTER_PACKET);
- Driver->AdditionalRequestPageBufferCount = 1; // For rndis header
+ Driver->AdditionalRequestPageBufferCount = 1; /* For rndis header */
- //Driver->Context = rndisDriver;
+ /* Driver->Context = rndisDriver; */
memset(&gRndisFilter, 0, sizeof(RNDIS_FILTER_DRIVER_OBJECT));
ASSERT(Driver->OnLinkStatusChanged);
rndisDriver->OnLinkStatusChanged = Driver->OnLinkStatusChanged;*/
- // Save the original dispatch handlers before we override it
+ /* Save the original dispatch handlers before we override it */
gRndisFilter.InnerDriver.Base.OnDeviceAdd = Driver->Base.OnDeviceAdd;
gRndisFilter.InnerDriver.Base.OnDeviceRemove = Driver->Base.OnDeviceRemove;
gRndisFilter.InnerDriver.Base.OnCleanup = Driver->Base.OnCleanup;
gRndisFilter.InnerDriver.OnReceiveCallback = Driver->OnReceiveCallback;
gRndisFilter.InnerDriver.OnLinkStatusChanged = Driver->OnLinkStatusChanged;
- // Override
+ /* Override */
Driver->Base.OnDeviceAdd = RndisFilterOnDeviceAdd;
Driver->Base.OnDeviceRemove = RndisFilterOnDeviceRemove;
Driver->Base.OnCleanup = RndisFilterOnCleanup;
Driver->OnSend = RndisFilterOnSend;
Driver->OnOpen = RndisFilterOnOpen;
Driver->OnClose = RndisFilterOnClose;
- //Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus;
+ /* Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus; */
Driver->OnReceiveCallback = RndisFilterOnReceive;
DPRINT_EXIT(NETVSC);
goto Cleanup;
}
- // Setup the rndis set
+ /* Setup the rndis set */
init = &request->RequestMessage.Message.InitializeRequest;
init->MajorVersion = RNDIS_MAJOR_VERSION;
init->MinorVersion = RNDIS_MINOR_VERSION;
- init->MaxTransferSize = 2048; // FIXME: Use 1536 - rounded ethernet frame size
+ init->MaxTransferSize = 2048; /* FIXME: Use 1536 - rounded ethernet frame size */
Device->State = RNDIS_DEV_INITIALIZING;
DPRINT_ENTER(NETVSC);
- // Attempt to do a rndis device halt
+ /* Attempt to do a rndis device halt */
request = GetRndisRequest(Device, REMOTE_NDIS_HALT_MSG, RNDIS_MESSAGE_SIZE(RNDIS_HALT_REQUEST));
if (!request)
{
goto Cleanup;
}
- // Setup the rndis set
+ /* Setup the rndis set */
halt = &request->RequestMessage.Message.HaltRequest;
halt->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
- // Ignore return since this msg is optional.
+ /* Ignore return since this msg is optional. */
RndisFilterSendRequest(Device, request);
Device->State = RNDIS_DEV_UNINITIALIZED;
}
-int
+static int
RndisFilterOnDeviceAdd(
- DEVICE_OBJECT *Device,
+ struct hv_device *Device,
void *AdditionalInfo
)
{
int ret;
- NETVSC_DEVICE *netDevice;
+ struct NETVSC_DEVICE *netDevice;
RNDIS_DEVICE *rndisDevice;
NETVSC_DEVICE_INFO *deviceInfo = (NETVSC_DEVICE_INFO*)AdditionalInfo;
DPRINT_ENTER(NETVSC);
- //rndisDevice = MemAlloc(sizeof(RNDIS_DEVICE));
rndisDevice = GetRndisDevice();
if (!rndisDevice)
{
DPRINT_DBG(NETVSC, "rndis device object allocated - %p", rndisDevice);
- // Let the inner driver handle this first to create the netvsc channel
- // NOTE! Once the channel is created, we may get a receive callback
- // (RndisFilterOnReceive()) before this call is completed
+ /* Let the inner driver handle this first to create the netvsc channel */
+ /* NOTE! Once the channel is created, we may get a receive callback */
+ /* (RndisFilterOnReceive()) before this call is completed */
ret = gRndisFilter.InnerDriver.Base.OnDeviceAdd(Device, AdditionalInfo);
if (ret != 0)
{
return ret;
}
- //
- // Initialize the rndis device
- //
- netDevice = (NETVSC_DEVICE*)Device->Extension;
+
+ /* Initialize the rndis device */
+
+ netDevice = (struct NETVSC_DEVICE*)Device->Extension;
ASSERT(netDevice);
ASSERT(netDevice->Device);
netDevice->Extension = rndisDevice;
rndisDevice->NetDevice = netDevice;
- // Send the rndis initialization message
+ /* Send the rndis initialization message */
ret = RndisFilterInitDevice(rndisDevice);
if (ret != 0)
{
- // TODO: If rndis init failed, we will need to shut down the channel
+ /* TODO: If rndis init failed, we will need to shut down the channel */
}
- // Get the mac address
+ /* Get the mac address */
ret = RndisFilterQueryDeviceMac(rndisDevice);
if (ret != 0)
{
- // TODO: shutdown rndis device and the channel
+ /* TODO: shutdown rndis device and the channel */
}
DPRINT_INFO(NETVSC, "Device 0x%p mac addr %02x%02x%02x%02x%02x%02x",
static int
RndisFilterOnDeviceRemove(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
)
{
- NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
+ struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
RNDIS_DEVICE *rndisDevice = (RNDIS_DEVICE*)netDevice->Extension;
DPRINT_ENTER(NETVSC);
- // Halt and release the rndis device
+ /* Halt and release the rndis device */
RndisFilterHaltDevice(rndisDevice);
PutRndisDevice(rndisDevice);
netDevice->Extension = NULL;
- // Pass control to inner driver to remove the device
+ /* Pass control to inner driver to remove the device */
gRndisFilter.InnerDriver.Base.OnDeviceRemove(Device);
DPRINT_EXIT(NETVSC);
static void
RndisFilterOnCleanup(
- DRIVER_OBJECT *Driver
+ struct hv_driver *Driver
)
{
DPRINT_ENTER(NETVSC);
static int
RndisFilterOnOpen(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
)
{
int ret;
- NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
+ struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
DPRINT_ENTER(NETVSC);
static int
RndisFilterOnClose(
- DEVICE_OBJECT *Device
+ struct hv_device *Device
)
{
int ret;
- NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
+ struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
DPRINT_ENTER(NETVSC);
static int
RndisFilterOnSend(
- DEVICE_OBJECT *Device,
- NETVSC_PACKET *Packet
+ struct hv_device *Device,
+ struct hv_netvsc_packet *Packet
)
{
int ret=0;
DPRINT_ENTER(NETVSC);
- // Add the rndis header
+ /* Add the rndis header */
filterPacket = (RNDIS_FILTER_PACKET*)Packet->Extension;
ASSERT(filterPacket);
rndisPacket->DataOffset = sizeof(RNDIS_PACKET);
rndisPacket->DataLength = Packet->TotalDataBufferLength;
- Packet->IsDataPacket = TRUE;
+ Packet->IsDataPacket = true;
Packet->PageBuffers[0].Pfn = GetPhysicalAddress(rndisMessage) >> PAGE_SHIFT;
- Packet->PageBuffers[0].Offset = (ULONG_PTR)rndisMessage & (PAGE_SIZE-1);
+ Packet->PageBuffers[0].Offset = (unsigned long)rndisMessage & (PAGE_SIZE-1);
Packet->PageBuffers[0].Length = rndisMessageSize;
- // Save the packet send completion and context
+ /* Save the packet send completion and context */
filterPacket->OnCompletion = Packet->Completion.Send.OnSendCompletion;
filterPacket->CompletionContext = Packet->Completion.Send.SendCompletionContext;
- // Use ours
+ /* Use ours */
Packet->Completion.Send.OnSendCompletion = RndisFilterOnSendCompletion;
Packet->Completion.Send.SendCompletionContext = filterPacket;
ret = gRndisFilter.InnerDriver.OnSend(Device, Packet);
if (ret != 0)
{
- // Reset the completion to originals to allow retries from above
+ /* Reset the completion to originals to allow retries from above */
Packet->Completion.Send.OnSendCompletion = filterPacket->OnCompletion;
Packet->Completion.Send.SendCompletionContext = filterPacket->CompletionContext;
}
DPRINT_ENTER(NETVSC);
- // Pass it back to the original handler
+ /* Pass it back to the original handler */
filterPacket->OnCompletion(filterPacket->CompletionContext);
DPRINT_EXIT(NETVSC);
{
DPRINT_ENTER(NETVSC);
- // Noop
+ /* Noop */
DPRINT_EXIT(NETVSC);
}
projects / deliverable / linux.git / blobdiff