lkml.org 
[lkml]   [2011]   [Feb]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 2/6] Staging: hv: Rename vm_device to hyperv_device
Date
Rename the vm_device abstraction as hyperv_device.

Signed-off-by: K. Y. Srinivasan <kys@microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: Hank Janssen <hjanssen@microsoft.com>

---
drivers/staging/hv/blkvsc.c | 4 +-
drivers/staging/hv/blkvsc_drv.c | 8 ++--
drivers/staging/hv/channel_mgmt.h | 2 +-
drivers/staging/hv/netvsc.c | 56 +++++++++++++++++++----------------
drivers/staging/hv/netvsc.h | 2 +-
drivers/staging/hv/netvsc_api.h | 12 ++++----
drivers/staging/hv/netvsc_drv.c | 14 ++++----
drivers/staging/hv/rndis_filter.c | 18 ++++++------
drivers/staging/hv/storvsc.c | 36 ++++++++++++-----------
drivers/staging/hv/storvsc_api.h | 4 +-
drivers/staging/hv/storvsc_drv.c | 10 +++---
drivers/staging/hv/vmbus.h | 6 ++--
drivers/staging/hv/vmbus_api.h | 8 ++--
drivers/staging/hv/vmbus_drv.c | 50 ++++++++++++++++----------------
drivers/staging/hv/vmbus_private.h | 12 ++++----
15 files changed, 124 insertions(+), 118 deletions(-)
diff --git a/drivers/staging/hv/blkvsc.c b/drivers/staging/hv/blkvsc.c
index ecface3..47ccec2 100644
--- a/drivers/staging/hv/blkvsc.c
+++ b/drivers/staging/hv/blkvsc.c
@@ -35,8 +35,8 @@ static const struct hv_guid g_blk_device_type = {
}
};

-static int blk_vsc_on_device_add(struct vm_device *device,
- void *additional_info)
+static int
+blk_vsc_on_device_add(struct hyperv_device *device, void *additional_info)
{
struct storvsc_device_info *device_info;
int ret = 0;
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 6d1a783..58ab0e8 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -95,7 +95,7 @@ struct blkvsc_request {
/* Per device structure */
struct block_device_context {
/* point back to our device context */
- struct vm_device *device_ctx;
+ struct hyperv_device *device_ctx;
struct kmem_cache *request_pool;
spinlock_t lock;
struct gendisk *gd;
@@ -249,7 +249,7 @@ static int blkvsc_probe(struct device *device)
(struct blkvsc_driver_context *)driver_ctx;
struct storvsc_driver_object *storvsc_drv_obj =
&blkvsc_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);

struct block_device_context *blkdev = NULL;
struct storvsc_device_info device_info;
@@ -733,7 +733,7 @@ static int blkvsc_remove(struct device *device)
(struct blkvsc_driver_context *)driver_ctx;
struct storvsc_driver_object *storvsc_drv_obj =
&blkvsc_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);
struct block_device_context *blkdev = dev_get_drvdata(device);
unsigned long flags;
int ret;
@@ -848,7 +848,7 @@ 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 vm_device *device_ctx = blkdev->device_ctx;
+ struct hyperv_device *device_ctx = blkdev->device_ctx;
struct driver_context *driver_ctx =
driver_to_driver_context(device_ctx->device.driver);
struct blkvsc_driver_context *blkvsc_drv_ctx =
diff --git a/drivers/staging/hv/channel_mgmt.h b/drivers/staging/hv/channel_mgmt.h
index b3a9214..7b42883 100644
--- a/drivers/staging/hv/channel_mgmt.h
+++ b/drivers/staging/hv/channel_mgmt.h
@@ -228,7 +228,7 @@ enum vmbus_channel_state {
struct vmbus_channel {
struct list_head listentry;

- struct vm_device *device_obj;
+ struct hyperv_device *device_obj;

struct timer_list poll_timer; /* SA-111 workaround */
struct work_struct work;
diff --git a/drivers/staging/hv/netvsc.c b/drivers/staging/hv/netvsc.c
index ff8e5be..7841cae 100644
--- a/drivers/staging/hv/netvsc.c
+++ b/drivers/staging/hv/netvsc.c
@@ -44,40 +44,41 @@ static const struct hv_guid netvsc_device_type = {
}
};

-static int netvsc_device_add(struct vm_device *device, void *additional_info);
+static int netvsc_device_add(struct hyperv_device *device,
+ void *additional_info);

-static int netvsc_device_remove(struct vm_device *device);
+static int netvsc_device_remove(struct hyperv_device *device);

static void netvsc_cleanup(struct hv_driver *driver);

static void netvsc_channel_cb(void *context);

-static int netvsc_init_send_buf(struct vm_device *device);
+static int netvsc_init_send_buf(struct hyperv_device *device);

-static int netvsc_init_recv_buf(struct vm_device *device);
+static int netvsc_init_recv_buf(struct hyperv_device *device);

static int netvsc_destroy_send_buf(struct netvsc_device *net_device);

static int netvsc_destroy_recv_buf(struct netvsc_device *net_device);

-static int netvsc_connect_vsp(struct vm_device *device);
+static int netvsc_connect_vsp(struct hyperv_device *device);

-static void netvsc_send_completion(struct vm_device *device,
+static void netvsc_send_completion(struct hyperv_device *device,
struct vmpacket_descriptor *packet);

-static int netvsc_send(struct vm_device *device,
+static int netvsc_send(struct hyperv_device *device,
struct hv_netvsc_packet *packet);

-static void netvsc_receive(struct vm_device *device,
+static void netvsc_receive(struct hyperv_device *device,
struct vmpacket_descriptor *packet);

static void netvsc_receive_completion(void *context);

-static void netvsc_send_recv_completion(struct vm_device *device,
+static void netvsc_send_recv_completion(struct hyperv_device *device,
u64 transaction_id);


-static struct netvsc_device *alloc_net_device(struct vm_device *device)
+static struct netvsc_device *alloc_net_device(struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -103,7 +104,8 @@ static void free_net_device(struct netvsc_device *device)


/* Get the net device object iff exists and its refcount > 1 */
-static struct netvsc_device *get_outbound_net_device(struct vm_device *device)
+static struct netvsc_device *
+get_outbound_net_device(struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -117,7 +119,8 @@ static struct netvsc_device *get_outbound_net_device(struct vm_device *device)
}

/* Get the net device object iff exists and its refcount > 0 */
-static struct netvsc_device *get_inbound_net_device(struct vm_device *device)
+static struct netvsc_device *
+get_inbound_net_device(struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -130,7 +133,7 @@ static struct netvsc_device *get_inbound_net_device(struct vm_device *device)
return net_device;
}

-static void put_net_device(struct vm_device *device)
+static void put_net_device(struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -140,7 +143,7 @@ static void put_net_device(struct vm_device *device)
}

static struct netvsc_device *release_outbound_net_device(
- struct vm_device *device)
+ struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -156,7 +159,7 @@ static struct netvsc_device *release_outbound_net_device(
}

static struct netvsc_device *release_inbound_net_device(
- struct vm_device *device)
+ struct hyperv_device *device)
{
struct netvsc_device *net_device;

@@ -200,7 +203,7 @@ int netvsc_initialize(struct hv_driver *drv)
return 0;
}

-static int netvsc_init_recv_buf(struct vm_device *device)
+static int netvsc_init_recv_buf(struct hyperv_device *device)
{
int ret = 0;
struct netvsc_device *net_device;
@@ -330,7 +333,7 @@ exit:
return ret;
}

-static int netvsc_init_send_buf(struct vm_device *device)
+static int netvsc_init_send_buf(struct hyperv_device *device)
{
int ret = 0;
struct netvsc_device *net_device;
@@ -572,7 +575,7 @@ static int netvsc_destroy_send_buf(struct netvsc_device *net_device)
}


-static int netvsc_connect_vsp(struct vm_device *device)
+static int netvsc_connect_vsp(struct hyperv_device *device)
{
int ret;
struct netvsc_device *net_device;
@@ -688,7 +691,8 @@ static void NetVscDisconnectFromVsp(struct netvsc_device *net_device)
* netvsc_device_add - Callback when the device belonging to this
* driver is added
*/
-static int netvsc_device_add(struct vm_device *device, void *additional_info)
+static int
+netvsc_device_add(struct hyperv_device *device, void *additional_info)
{
int ret = 0;
int i;
@@ -781,7 +785,7 @@ cleanup:
/*
* netvsc_device_remove - Callback when the root bus device is removed
*/
-static int netvsc_device_remove(struct vm_device *device)
+static int netvsc_device_remove(struct hyperv_device *device)
{
struct netvsc_device *net_device;
struct hv_netvsc_packet *netvsc_packet, *pos;
@@ -837,7 +841,7 @@ static void netvsc_cleanup(struct hv_driver *drv)
{
}

-static void netvsc_send_completion(struct vm_device *device,
+static void netvsc_send_completion(struct hyperv_device *device,
struct vmpacket_descriptor *packet)
{
struct netvsc_device *net_device;
@@ -886,7 +890,7 @@ static void netvsc_send_completion(struct vm_device *device,
put_net_device(device);
}

-static int netvsc_send(struct vm_device *device,
+static int netvsc_send(struct hyperv_device *device,
struct hv_netvsc_packet *packet)
{
struct netvsc_device *net_device;
@@ -940,7 +944,7 @@ static int netvsc_send(struct vm_device *device,
return ret;
}

-static void netvsc_receive(struct vm_device *device,
+static void netvsc_receive(struct hyperv_device *device,
struct vmpacket_descriptor *packet)
{
struct netvsc_device *net_device;
@@ -1137,7 +1141,7 @@ static void netvsc_receive(struct vm_device *device,
put_net_device(device);
}

-static void netvsc_send_recv_completion(struct vm_device *device,
+static void netvsc_send_recv_completion(struct hyperv_device *device,
u64 transaction_id)
{
struct nvsp_message recvcompMessage;
@@ -1186,7 +1190,7 @@ retry_send_cmplt:
static void netvsc_receive_completion(void *context)
{
struct hv_netvsc_packet *packet = context;
- struct vm_device *device = (struct vm_device *)packet->device;
+ struct hyperv_device *device = (struct hyperv_device *)packet->device;
struct netvsc_device *net_device;
u64 transaction_id = 0;
bool fsend_receive_comp = false;
@@ -1235,7 +1239,7 @@ static void netvsc_receive_completion(void *context)
static void netvsc_channel_cb(void *context)
{
int ret;
- struct vm_device *device = context;
+ struct hyperv_device *device = context;
struct netvsc_device *net_device;
u32 bytes_recvd;
u64 request_id;
diff --git a/drivers/staging/hv/netvsc.h b/drivers/staging/hv/netvsc.h
index b2709eb..ea3a05f 100644
--- a/drivers/staging/hv/netvsc.h
+++ b/drivers/staging/hv/netvsc.h
@@ -293,7 +293,7 @@ struct nvsp_message {

/* Per netvsc channel-specific */
struct netvsc_device {
- struct vm_device *dev;
+ struct hyperv_device *dev;

atomic_t refcnt;
atomic_t num_outstanding_sends;
diff --git a/drivers/staging/hv/netvsc_api.h b/drivers/staging/hv/netvsc_api.h
index a9cfeff..e43ff7b 100644
--- a/drivers/staging/hv/netvsc_api.h
+++ b/drivers/staging/hv/netvsc_api.h
@@ -49,7 +49,7 @@ struct hv_netvsc_packet {
/* Bookkeeping stuff */
struct list_head list_ent;

- struct vm_device *device;
+ struct hyperv_device *device;
bool is_data_pkt;

/*
@@ -93,12 +93,12 @@ struct netvsc_driver {
* This is set by the caller to allow us to callback when we
* receive a packet from the "wire"
*/
- int (*recv_cb)(struct vm_device *dev,
+ int (*recv_cb)(struct hyperv_device *dev,
struct hv_netvsc_packet *packet);
- void (*link_status_change)(struct vm_device *dev, u32 status);
+ void (*link_status_change)(struct hyperv_device *dev, u32 status);

/* Specific to this driver */
- int (*send)(struct vm_device *dev, struct hv_netvsc_packet *packet);
+ int (*send)(struct hyperv_device *dev, struct hv_netvsc_packet *packet);

void *ctx;
};
@@ -110,7 +110,7 @@ struct netvsc_device_info {

/* Interface */
int netvsc_initialize(struct hv_driver *drv);
-int rndis_filter_open(struct vm_device *dev);
-int rndis_filter_close(struct vm_device *dev);
+int rndis_filter_open(struct hyperv_device *dev);
+int rndis_filter_close(struct hyperv_device *dev);

#endif /* _NETVSC_API_H_ */
diff --git a/drivers/staging/hv/netvsc_drv.c b/drivers/staging/hv/netvsc_drv.c
index 055986f..31cbbab 100644
--- a/drivers/staging/hv/netvsc_drv.c
+++ b/drivers/staging/hv/netvsc_drv.c
@@ -44,7 +44,7 @@

struct net_device_context {
/* point back to our device context */
- struct vm_device *device_ctx;
+ struct hyperv_device *device_ctx;
unsigned long avail;
};

@@ -76,7 +76,7 @@ static void netvsc_set_multicast_list(struct net_device *net)
static int netvsc_open(struct net_device *net)
{
struct net_device_context *net_device_ctx = netdev_priv(net);
- struct vm_device *device_obj = net_device_ctx->device_ctx;
+ struct hyperv_device *device_obj = net_device_ctx->device_ctx;
int ret = 0;

if (netif_carrier_ok(net)) {
@@ -99,7 +99,7 @@ static int netvsc_open(struct net_device *net)
static int netvsc_close(struct net_device *net)
{
struct net_device_context *net_device_ctx = netdev_priv(net);
- struct vm_device *device_obj = net_device_ctx->device_ctx;
+ struct hyperv_device *device_obj = net_device_ctx->device_ctx;
int ret;

netif_stop_queue(net);
@@ -223,7 +223,7 @@ static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
/*
* netvsc_linkstatus_callback - Link up/down notification
*/
-static void netvsc_linkstatus_callback(struct vm_device *device_obj,
+static void netvsc_linkstatus_callback(struct hyperv_device *device_obj,
unsigned int status)
{
struct net_device *net = dev_get_drvdata(&device_obj->device);
@@ -248,7 +248,7 @@ static void netvsc_linkstatus_callback(struct vm_device *device_obj,
* netvsc_recv_callback - Callback when we receive a packet from the
* "wire" on the specified device.
*/
-static int netvsc_recv_callback(struct vm_device *device_obj,
+static int netvsc_recv_callback(struct hyperv_device *device_obj,
struct hv_netvsc_packet *packet)
{
struct net_device *net = dev_get_drvdata(&device_obj->device);
@@ -343,7 +343,7 @@ static int netvsc_probe(struct device *device)
struct netvsc_driver_context *net_drv_ctx =
(struct netvsc_driver_context *)driver_ctx;
struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);
struct net_device *net = NULL;
struct net_device_context *net_device_ctx;
struct netvsc_device_info device_info;
@@ -414,7 +414,7 @@ static int netvsc_remove(struct device *device)
struct netvsc_driver_context *net_drv_ctx =
(struct netvsc_driver_context *)driver_ctx;
struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);
struct net_device *net = dev_get_drvdata(&device_obj->device);
int ret;

diff --git a/drivers/staging/hv/rndis_filter.c b/drivers/staging/hv/rndis_filter.c
index e0b1b44..b718fa9 100644
--- a/drivers/staging/hv/rndis_filter.c
+++ b/drivers/staging/hv/rndis_filter.c
@@ -85,14 +85,14 @@ struct rndis_filter_packet {
};


-static int rndis_filte_device_add(struct vm_device *dev,
+static int rndis_filte_device_add(struct hyperv_device *dev,
void *additional_info);

-static int rndis_filter_device_remove(struct vm_device *dev);
+static int rndis_filter_device_remove(struct hyperv_device *dev);

static void rndis_filter_cleanup(struct hv_driver *drv);

-static int rndis_filter_send(struct vm_device *dev,
+static int rndis_filter_send(struct hyperv_device *dev,
struct hv_netvsc_packet *pkt);

static void rndis_filter_send_completion(void *ctx);
@@ -376,7 +376,7 @@ static void rndis_filter_receive_data(struct rndis_device *dev,
pkt);
}

-static int rndis_filter_receive(struct vm_device *dev,
+static int rndis_filter_receive(struct hyperv_device *dev,
struct hv_netvsc_packet *pkt)
{
struct netvsc_device *net_dev = dev->ext;
@@ -754,7 +754,7 @@ static int rndis_filter_close_device(struct rndis_device *dev)
return ret;
}

-static int rndis_filte_device_add(struct vm_device *dev,
+static int rndis_filte_device_add(struct hyperv_device *dev,
void *additional_info)
{
int ret;
@@ -817,7 +817,7 @@ static int rndis_filte_device_add(struct vm_device *dev,
return ret;
}

-static int rndis_filter_device_remove(struct vm_device *dev)
+static int rndis_filter_device_remove(struct hyperv_device *dev)
{
struct netvsc_device *net_dev = dev->ext;
struct rndis_device *rndis_dev = net_dev->extension;
@@ -838,7 +838,7 @@ static void rndis_filter_cleanup(struct hv_driver *drv)
{
}

-int rndis_filter_open(struct vm_device *dev)
+int rndis_filter_open(struct hyperv_device *dev)
{
struct netvsc_device *netDevice = dev->ext;

@@ -848,7 +848,7 @@ int rndis_filter_open(struct vm_device *dev)
return rndis_filter_open_device(netDevice->extension);
}

-int rndis_filter_close(struct vm_device *dev)
+int rndis_filter_close(struct hyperv_device *dev)
{
struct netvsc_device *netDevice = dev->ext;

@@ -858,7 +858,7 @@ int rndis_filter_close(struct vm_device *dev)
return rndis_filter_close_device(netDevice->extension);
}

-static int rndis_filter_send(struct vm_device *dev,
+static int rndis_filter_send(struct hyperv_device *dev,
struct hv_netvsc_packet *pkt)
{
int ret;
diff --git a/drivers/staging/hv/storvsc.c b/drivers/staging/hv/storvsc.c
index 7b75ab5..6000b0d 100644
--- a/drivers/staging/hv/storvsc.c
+++ b/drivers/staging/hv/storvsc.c
@@ -38,7 +38,7 @@ struct storvsc_request_extension {
/* LIST_ENTRY ListEntry; */

struct hv_storvsc_request *request;
- struct vm_device *device;
+ struct hyperv_device *device;

/* Synchronize the request/response if needed */
int wait_condition;
@@ -49,7 +49,7 @@ struct storvsc_request_extension {

/* A storvsc device is a device object that contains a vmbus channel */
struct storvsc_device {
- struct vm_device *device;
+ struct hyperv_device *device;

/* 0 indicates the device is being destroyed */
atomic_t ref_count;
@@ -85,7 +85,8 @@ static const struct hv_guid gStorVscDeviceType = {
};


-static inline struct storvsc_device *alloc_stor_device(struct vm_device *device)
+static inline struct storvsc_device *
+alloc_stor_device(struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -110,7 +111,8 @@ static inline void free_stor_device(struct storvsc_device *device)
}

/* Get the stordevice object iff exists and its refcount > 1 */
-static inline struct storvsc_device *get_stor_device(struct vm_device *device)
+static inline struct storvsc_device *
+get_stor_device(struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -125,7 +127,7 @@ static inline struct storvsc_device *get_stor_device(struct vm_device *device)

/* Get the stordevice object iff exists and its refcount > 0 */
static inline struct storvsc_device *must_get_stor_device(
- struct vm_device *device)
+ struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -138,7 +140,7 @@ static inline struct storvsc_device *must_get_stor_device(
return stor_device;
}

-static inline void put_stor_device(struct vm_device *device)
+static inline void put_stor_device(struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -151,7 +153,7 @@ static inline void put_stor_device(struct vm_device *device)

/* Drop ref count to 1 to effectively disable get_stor_device() */
static inline struct storvsc_device *release_stor_device(
- struct vm_device *device)
+ struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -167,7 +169,7 @@ static inline struct storvsc_device *release_stor_device(

/* Drop ref count to 0. No one can use stor_device object. */
static inline struct storvsc_device *final_release_stor_device(
- struct vm_device *device)
+ struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -182,7 +184,7 @@ static inline struct storvsc_device *final_release_stor_device(
return stor_device;
}

-static int stor_vsc_channel_init(struct vm_device *device)
+static int stor_vsc_channel_init(struct hyperv_device *device)
{
struct storvsc_device *stor_device;
struct storvsc_request_extension *request;
@@ -363,7 +365,7 @@ cleanup:
return ret;
}

-static void stor_vsc_on_io_completion(struct vm_device *device,
+static void stor_vsc_on_io_completion(struct hyperv_device *device,
struct vstor_packet *vstor_packet,
struct storvsc_request_extension *request_ext)
{
@@ -427,7 +429,7 @@ static void stor_vsc_on_io_completion(struct vm_device *device,
put_stor_device(device);
}

-static void stor_vsc_on_receive(struct vm_device *device,
+static void stor_vsc_on_receive(struct hyperv_device *device,
struct vstor_packet *vstor_packet,
struct storvsc_request_extension *request_ext)
{
@@ -450,7 +452,7 @@ static void stor_vsc_on_receive(struct vm_device *device,

static void stor_vsc_on_channel_callback(void *context)
{
- struct vm_device *device = (struct vm_device *)context;
+ struct hyperv_device *device = (struct hyperv_device *)context;
struct storvsc_device *stor_device;
u32 bytes_recvd;
u64 request_id;
@@ -510,7 +512,7 @@ static void stor_vsc_on_channel_callback(void *context)
return;
}

-static int stor_vsc_connect_to_vsp(struct vm_device *device)
+static int stor_vsc_connect_to_vsp(struct hyperv_device *device)
{
struct vmstorage_channel_properties props;
struct storvsc_driver_object *stor_driver;
@@ -544,7 +546,7 @@ static int stor_vsc_connect_to_vsp(struct vm_device *device)
* stor_vsc_on_device_add - Callback when the device belonging to this driver
* is added
*/
-static int stor_vsc_on_device_add(struct vm_device *device,
+static int stor_vsc_on_device_add(struct hyperv_device *device,
void *additional_info)
{
struct storvsc_device *stor_device;
@@ -593,7 +595,7 @@ cleanup:
/*
* stor_vsc_on_device_remove - Callback when the our device is being removed
*/
-static int stor_vsc_on_device_remove(struct vm_device *device)
+static int stor_vsc_on_device_remove(struct hyperv_device *device)
{
struct storvsc_device *stor_device;

@@ -627,7 +629,7 @@ static int stor_vsc_on_device_remove(struct vm_device *device)
return 0;
}

-int stor_vsc_on_host_reset(struct vm_device *device)
+int stor_vsc_on_host_reset(struct hyperv_device *device)
{
struct storvsc_device *stor_device;
struct storvsc_request_extension *request;
@@ -686,7 +688,7 @@ cleanup:
/*
* stor_vsc_on_io_request - Callback to initiate an I/O request
*/
-static int stor_vsc_on_io_request(struct vm_device *device,
+static int stor_vsc_on_io_request(struct hyperv_device *device,
struct hv_storvsc_request *request)
{
struct storvsc_device *stor_device;
diff --git a/drivers/staging/hv/storvsc_api.h b/drivers/staging/hv/storvsc_api.h
index 8bed6f5..c2915b4 100644
--- a/drivers/staging/hv/storvsc_api.h
+++ b/drivers/staging/hv/storvsc_api.h
@@ -92,7 +92,7 @@ struct storvsc_driver_object {
u32 max_outstanding_req_per_channel;

/* Specific to this driver */
- int (*on_io_request)(struct vm_device *device,
+ int (*on_io_request)(struct hyperv_device *device,
struct hv_storvsc_request *request);
};

@@ -104,7 +104,7 @@ struct storvsc_device_info {

/* Interface */
int stor_vsc_initialize(struct hv_driver *driver);
-int stor_vsc_on_host_reset(struct vm_device *device);
+int stor_vsc_on_host_reset(struct hyperv_device *device);
int blk_vsc_initialize(struct hv_driver *driver);

#endif /* _STORVSC_API_H_ */
diff --git a/drivers/staging/hv/storvsc_drv.c b/drivers/staging/hv/storvsc_drv.c
index 216d8ff..2b9a097 100644
--- a/drivers/staging/hv/storvsc_drv.c
+++ b/drivers/staging/hv/storvsc_drv.c
@@ -43,7 +43,7 @@ struct host_device_context {
/* must be 1st field
* FIXME this is a bug */
/* point back to our device context */
- struct vm_device *device_ctx;
+ struct hyperv_device *device_ctx;
struct kmem_cache *request_pool;
unsigned int port;
unsigned char path;
@@ -226,7 +226,7 @@ static int storvsc_probe(struct device *device)
(struct storvsc_driver_context *)driver_ctx;
struct storvsc_driver_object *storvsc_drv_obj =
&storvsc_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);
struct Scsi_Host *host;
struct host_device_context *host_device_ctx;
struct storvsc_device_info device_info;
@@ -310,7 +310,7 @@ static int storvsc_remove(struct device *device)
(struct storvsc_driver_context *)driver_ctx;
struct storvsc_driver_object *storvsc_drv_obj =
&storvsc_drv_ctx->drv_obj;
- struct vm_device *device_obj = device_to_vm_device(device);
+ struct hyperv_device *device_obj = device_to_hyperv_device(device);
struct Scsi_Host *host = dev_get_drvdata(device);
struct host_device_context *host_device_ctx =
(struct host_device_context *)host->hostdata;
@@ -600,7 +600,7 @@ static int storvsc_queuecommand_lck(struct scsi_cmnd *scmnd,
int ret;
struct host_device_context *host_device_ctx =
(struct host_device_context *)scmnd->device->host->hostdata;
- struct vm_device *device_ctx = host_device_ctx->device_ctx;
+ struct hyperv_device *device_ctx = host_device_ctx->device_ctx;
struct driver_context *driver_ctx =
driver_to_driver_context(device_ctx->device.driver);
struct storvsc_driver_context *storvsc_drv_ctx =
@@ -838,7 +838,7 @@ static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
int ret;
struct host_device_context *host_device_ctx =
(struct host_device_context *)scmnd->device->host->hostdata;
- struct vm_device *device_ctx = host_device_ctx->device_ctx;
+ struct hyperv_device *device_ctx = host_device_ctx->device_ctx;

DPRINT_INFO(STORVSC_DRV, "sdev (%p) dev obj (%p) - host resetting...",
scmnd->device, device_ctx);
diff --git a/drivers/staging/hv/vmbus.h b/drivers/staging/hv/vmbus.h
index e56e61a..1ac7e56 100644
--- a/drivers/staging/hv/vmbus.h
+++ b/drivers/staging/hv/vmbus.h
@@ -43,7 +43,7 @@ struct driver_context {
void (*shutdown)(struct device *);
};

-struct vm_device {
+struct hyperv_device {
char name[64];
struct work_struct probe_failed_work_item;
struct hv_guid class_id; /* device type id */
@@ -56,9 +56,9 @@ struct vm_device {
};


-static inline struct vm_device *device_to_vm_device(struct device *d)
+static inline struct hyperv_device *device_to_hyperv_device(struct device *d)
{
- return container_of(d, struct vm_device, device);
+ return container_of(d, struct hyperv_device, device);
}

static inline struct driver_context *driver_to_driver_context(struct device_driver *d)
diff --git a/drivers/staging/hv/vmbus_api.h b/drivers/staging/hv/vmbus_api.h
index bf84fb0..260086f 100644
--- a/drivers/staging/hv/vmbus_api.h
+++ b/drivers/staging/hv/vmbus_api.h
@@ -56,7 +56,7 @@ struct hv_multipage_buffer {
#pragma pack(pop)

struct hv_driver;
-struct vm_device;
+struct hyperv_device;

struct hv_dev_port_info {
u32 int_mask;
@@ -66,7 +66,7 @@ struct hv_dev_port_info {
u32 bytes_avail_towrite;
};

-struct vm_device_info {
+struct hyperv_device_info {
u32 chn_id;
u32 chn_state;
struct hv_guid chn_type;
@@ -91,8 +91,8 @@ struct hv_driver {
/* the device type supported by this driver */
struct hv_guid class_id;

- int (*dev_add)(struct vm_device *device, void *data);
- int (*dev_rm)(struct vm_device *device);
+ int (*dev_add)(struct hyperv_device *device, void *data);
+ int (*dev_rm)(struct hyperv_device *device);
void (*cleanup)(struct hv_driver *driver);
};

diff --git a/drivers/staging/hv/vmbus_drv.c b/drivers/staging/hv/vmbus_drv.c
index 531b68d..38152df 100644
--- a/drivers/staging/hv/vmbus_drv.c
+++ b/drivers/staging/hv/vmbus_drv.c
@@ -54,7 +54,7 @@ struct vmbus_driver_context {
struct tasklet_struct event_dpc;

/* The bus root device */
- struct vm_device device_ctx;
+ struct hyperv_device device_ctx;
};

static int vmbus_match(struct device *device, struct device_driver *driver);
@@ -145,12 +145,12 @@ static const struct hv_guid device_id = {
}
};

-static struct vm_device *vmbus_device; /* vmbus root device */
+static struct hyperv_device *vmbus_device; /* vmbus root device */

/*
* vmbus_child_dev_add - Registers the child device with the vmbus
*/
-int vmbus_child_dev_add(struct vm_device *child_dev)
+int vmbus_child_dev_add(struct hyperv_device *child_dev)
{
return vmbus_child_device_register(vmbus_device, child_dev);
}
@@ -158,7 +158,7 @@ int vmbus_child_dev_add(struct vm_device *child_dev)
/*
* vmbus_dev_add - Callback when the root bus device is added
*/
-static int vmbus_dev_add(struct vm_device *dev, void *info)
+static int vmbus_dev_add(struct hyperv_device *dev, void *info)
{
u32 *irqvector = info;
int ret;
@@ -183,7 +183,7 @@ static int vmbus_dev_add(struct vm_device *dev, void *info)
/*
* vmbus_dev_rm - Callback when the root bus device is removed
*/
-static int vmbus_dev_rm(struct vm_device *dev)
+static int vmbus_dev_rm(struct hyperv_device *dev)
{
int ret = 0;

@@ -299,8 +299,8 @@ static int vmbus_on_isr(struct hv_driver *drv)
return ret;
}

-static void get_channel_info(struct vm_device *device,
- struct vm_device_info *info)
+static void get_channel_info(struct hyperv_device *device,
+ struct hyperv_device_info *info)
{
struct vmbus_channel_debug_info debug_info;

@@ -354,10 +354,10 @@ static ssize_t vmbus_show_device_attr(struct device *dev,
struct device_attribute *dev_attr,
char *buf)
{
- struct vm_device *device_ctx = device_to_vm_device(dev);
- struct vm_device_info device_info;
+ struct hyperv_device *device_ctx = device_to_hyperv_device(dev);
+ struct hyperv_device_info device_info;

- memset(&device_info, 0, sizeof(struct vm_device_info));
+ memset(&device_info, 0, sizeof(struct hyperv_device_info));

get_channel_info(device_ctx, &device_info);

@@ -464,7 +464,7 @@ static int vmbus_bus_init(void)
{
struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;
struct hv_driver *driver = &vmbus_drv.drv_obj;
- struct vm_device *dev_ctx = &vmbus_drv.device_ctx;
+ struct hyperv_device *dev_ctx = &vmbus_drv.device_ctx;
int ret;
unsigned int vector;

@@ -535,7 +535,7 @@ static int vmbus_bus_init(void)
DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector);

/* Call to bus driver to add the root device */
- memset(dev_ctx, 0, sizeof(struct vm_device));
+ memset(dev_ctx, 0, sizeof(struct hyperv_device));

ret = driver->dev_add(dev_ctx, &vector);
if (ret != 0) {
@@ -590,7 +590,7 @@ static void vmbus_bus_exit(void)
struct hv_driver *driver = &vmbus_drv.drv_obj;
struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;

- struct vm_device *dev_ctx = &vmbus_drv.device_ctx;
+ struct hyperv_device *dev_ctx = &vmbus_drv.device_ctx;

/* Remove the root device */
if (driver->dev_rm)
@@ -667,14 +667,14 @@ EXPORT_SYMBOL(vmbus_child_driver_unregister);
* vmbus_child_device_create - Creates and registers a new child device
* on the vmbus.
*/
-struct vm_device *vmbus_child_device_create(struct hv_guid *type,
+struct hyperv_device *vmbus_child_device_create(struct hv_guid *type,
struct hv_guid *instance,
struct vmbus_channel *channel)
{
- struct vm_device *child_device_ctx;
+ struct hyperv_device *child_device_ctx;

/* Allocate the new child device */
- child_device_ctx = kzalloc(sizeof(struct vm_device), GFP_KERNEL);
+ child_device_ctx = kzalloc(sizeof(struct hyperv_device), GFP_KERNEL);
if (!child_device_ctx) {
DPRINT_ERR(VMBUS_DRV,
"unable to allocate device_context for child device");
@@ -711,8 +711,8 @@ struct vm_device *vmbus_child_device_create(struct hv_guid *type,
/*
* vmbus_child_device_register - Register the child device on the specified bus
*/
-int vmbus_child_device_register(struct vm_device *root_device_obj,
- struct vm_device *child_device_obj)
+int vmbus_child_device_register(struct hyperv_device *root_device_obj,
+ struct hyperv_device *child_device_obj)
{
int ret = 0;
static atomic_t device_num = ATOMIC_INIT(0);
@@ -752,7 +752,7 @@ int vmbus_child_device_register(struct vm_device *root_device_obj,
* vmbus_child_device_unregister - Remove the specified child device
* from the vmbus.
*/
-void vmbus_child_device_unregister(struct vm_device *device_obj)
+void vmbus_child_device_unregister(struct hyperv_device *device_obj)
{

DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)",
@@ -777,7 +777,7 @@ void vmbus_child_device_unregister(struct vm_device *device_obj)
*/
static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
{
- struct vm_device *device_ctx = device_to_vm_device(device);
+ struct hyperv_device *device_ctx = device_to_hyperv_device(device);
int ret;

DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={"
@@ -850,7 +850,7 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
{
int match = 0;
struct driver_context *driver_ctx = driver_to_driver_context(driver);
- struct vm_device *device_ctx = device_to_vm_device(device);
+ struct hyperv_device *device_ctx = device_to_hyperv_device(device);

/* We found our driver ? */
if (memcmp(&device_ctx->class_id, &driver_ctx->class_id,
@@ -882,7 +882,7 @@ static int vmbus_match(struct device *device, struct device_driver *driver)
*/
static void vmbus_probe_failed_cb(struct work_struct *context)
{
- struct vm_device *device_ctx = (struct vm_device *)context;
+ struct hyperv_device *device_ctx = (struct hyperv_device *)context;

/*
* Kick off the process of unregistering the device.
@@ -901,8 +901,8 @@ static int vmbus_probe(struct device *child_device)
int ret = 0;
struct driver_context *driver_ctx =
driver_to_driver_context(child_device->driver);
- struct vm_device *device_ctx =
- device_to_vm_device(child_device);
+ struct hyperv_device *device_ctx =
+ device_to_hyperv_device(child_device);

/* Let the specific open-source driver handles the probe if it can */
if (driver_ctx->probe) {
@@ -1008,7 +1008,7 @@ static void vmbus_bus_release(struct device *device)
*/
static void vmbus_device_release(struct device *device)
{
- struct vm_device *device_ctx = device_to_vm_device(device);
+ struct hyperv_device *device_ctx = device_to_hyperv_device(device);

kfree(device_ctx);

diff --git a/drivers/staging/hv/vmbus_private.h b/drivers/staging/hv/vmbus_private.h
index 206218c..4a8f2e8 100644
--- a/drivers/staging/hv/vmbus_private.h
+++ b/drivers/staging/hv/vmbus_private.h
@@ -103,18 +103,18 @@ extern struct vmbus_connection vmbus_connection;

/* General vmbus interface */

-struct vm_device *vmbus_child_device_create(struct hv_guid *type,
+struct hyperv_device *vmbus_child_device_create(struct hv_guid *type,
struct hv_guid *instance,
struct vmbus_channel *channel);

-int vmbus_child_dev_add(struct vm_device *device);
-int vmbus_child_device_register(struct vm_device *root_device_obj,
- struct vm_device *child_device_obj);
-void vmbus_child_device_unregister(struct vm_device *device_obj);
+int vmbus_child_dev_add(struct hyperv_device *device);
+int vmbus_child_device_register(struct hyperv_device *root_device_obj,
+ struct hyperv_device *child_device_obj);
+void vmbus_child_device_unregister(struct hyperv_device *device_obj);

/* static void */
/* VmbusChildDeviceDestroy( */
-/* struct vm_device *); */
+/* struct hyperv_device *); */

struct vmbus_channel *relid2channel(u32 relid);

--
1.5.5.6


\
 
 \ /
  Last update: 2011-02-26 02:59    [W:0.648 / U:0.036 seconds]
©2003-2014 Jasper Spaans. Advertise on this site