Merge branch 'netvsc-bug-fixes-and-cleanups'
Stephen Hemminger says: ==================== netvsc: bug fixes and cleanups These fix NAPI issues and bugs found during testing of shutdown testing. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
4deece6c9f
|
|
@ -686,7 +686,7 @@ struct net_device_context {
|
|||
/* point back to our device context */
|
||||
struct hv_device *device_ctx;
|
||||
/* netvsc_device */
|
||||
struct netvsc_device *nvdev;
|
||||
struct netvsc_device __rcu *nvdev;
|
||||
/* reconfigure work */
|
||||
struct delayed_work dwork;
|
||||
/* last reconfig time */
|
||||
|
|
@ -708,9 +708,6 @@ struct net_device_context {
|
|||
u32 speed;
|
||||
struct netvsc_ethtool_stats eth_stats;
|
||||
|
||||
/* the device is going away */
|
||||
bool start_remove;
|
||||
|
||||
/* State to manage the associated VF interface. */
|
||||
struct net_device __rcu *vf_netdev;
|
||||
|
||||
|
|
@ -723,6 +720,7 @@ struct net_device_context {
|
|||
/* Per channel data */
|
||||
struct netvsc_channel {
|
||||
struct vmbus_channel *channel;
|
||||
const struct vmpacket_descriptor *desc;
|
||||
struct napi_struct napi;
|
||||
struct multi_send_data msd;
|
||||
struct multi_recv_comp mrc;
|
||||
|
|
@ -763,8 +761,8 @@ struct netvsc_device {
|
|||
|
||||
u32 max_chn;
|
||||
u32 num_chn;
|
||||
spinlock_t sc_lock; /* Protects num_sc_offered variable */
|
||||
u32 num_sc_offered;
|
||||
|
||||
refcount_t sc_offered;
|
||||
|
||||
/* Holds rndis device info */
|
||||
void *extension;
|
||||
|
|
@ -779,6 +777,8 @@ struct netvsc_device {
|
|||
atomic_t open_cnt;
|
||||
|
||||
struct netvsc_channel chan_table[VRSS_CHANNEL_MAX];
|
||||
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
static inline struct netvsc_device *
|
||||
|
|
|
|||
|
|
@ -80,8 +80,10 @@ static struct netvsc_device *alloc_net_device(void)
|
|||
return net_device;
|
||||
}
|
||||
|
||||
static void free_netvsc_device(struct netvsc_device *nvdev)
|
||||
static void free_netvsc_device(struct rcu_head *head)
|
||||
{
|
||||
struct netvsc_device *nvdev
|
||||
= container_of(head, struct netvsc_device, rcu);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < VRSS_CHANNEL_MAX; i++)
|
||||
|
|
@ -90,6 +92,10 @@ static void free_netvsc_device(struct netvsc_device *nvdev)
|
|||
kfree(nvdev);
|
||||
}
|
||||
|
||||
static void free_netvsc_device_rcu(struct netvsc_device *nvdev)
|
||||
{
|
||||
call_rcu(&nvdev->rcu, free_netvsc_device);
|
||||
}
|
||||
|
||||
static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
|
||||
{
|
||||
|
|
@ -551,7 +557,7 @@ void netvsc_device_remove(struct hv_device *device)
|
|||
|
||||
netvsc_disconnect_vsp(device);
|
||||
|
||||
net_device_ctx->nvdev = NULL;
|
||||
RCU_INIT_POINTER(net_device_ctx->nvdev, NULL);
|
||||
|
||||
/*
|
||||
* At this point, no one should be accessing net_device
|
||||
|
|
@ -566,7 +572,7 @@ void netvsc_device_remove(struct hv_device *device)
|
|||
napi_disable(&net_device->chan_table[i].napi);
|
||||
|
||||
/* Release all resources */
|
||||
free_netvsc_device(net_device);
|
||||
free_netvsc_device_rcu(net_device);
|
||||
}
|
||||
|
||||
#define RING_AVAIL_PERCENT_HIWATER 20
|
||||
|
|
@ -599,7 +605,6 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device,
|
|||
{
|
||||
struct sk_buff *skb = (struct sk_buff *)(unsigned long)desc->trans_id;
|
||||
struct net_device *ndev = hv_get_drvdata(device);
|
||||
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
||||
struct vmbus_channel *channel = device->channel;
|
||||
u16 q_idx = 0;
|
||||
int queue_sends;
|
||||
|
|
@ -633,7 +638,6 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device,
|
|||
wake_up(&net_device->wait_drain);
|
||||
|
||||
if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
|
||||
!net_device_ctx->start_remove &&
|
||||
(hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HIWATER ||
|
||||
queue_sends < 1))
|
||||
netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx));
|
||||
|
|
@ -702,8 +706,7 @@ static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device,
|
|||
packet->page_buf_cnt;
|
||||
|
||||
/* Add padding */
|
||||
if (skb && skb->xmit_more && remain &&
|
||||
!packet->cp_partial) {
|
||||
if (skb->xmit_more && remain && !packet->cp_partial) {
|
||||
padding = net_device->pkt_align - remain;
|
||||
rndis_msg->msg_len += padding;
|
||||
packet->total_data_buflen += padding;
|
||||
|
|
@ -861,9 +864,7 @@ int netvsc_send(struct hv_device *device,
|
|||
if (msdp->pkt)
|
||||
msd_len = msdp->pkt->total_data_buflen;
|
||||
|
||||
try_batch = (skb != NULL) && msd_len > 0 && msdp->count <
|
||||
net_device->max_pkt;
|
||||
|
||||
try_batch = msd_len > 0 && msdp->count < net_device->max_pkt;
|
||||
if (try_batch && msd_len + pktlen + net_device->pkt_align <
|
||||
net_device->send_section_size) {
|
||||
section_index = msdp->pkt->send_buf_index;
|
||||
|
|
@ -873,7 +874,7 @@ int netvsc_send(struct hv_device *device,
|
|||
section_index = msdp->pkt->send_buf_index;
|
||||
packet->cp_partial = true;
|
||||
|
||||
} else if ((skb != NULL) && pktlen + net_device->pkt_align <
|
||||
} else if (pktlen + net_device->pkt_align <
|
||||
net_device->send_section_size) {
|
||||
section_index = netvsc_get_next_send_section(net_device);
|
||||
if (section_index != NETVSC_INVALID_INDEX) {
|
||||
|
|
@ -1173,7 +1174,6 @@ static int netvsc_process_raw_pkt(struct hv_device *device,
|
|||
struct vmbus_channel *channel,
|
||||
struct netvsc_device *net_device,
|
||||
struct net_device *ndev,
|
||||
u64 request_id,
|
||||
const struct vmpacket_descriptor *desc)
|
||||
{
|
||||
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
||||
|
|
@ -1195,7 +1195,7 @@ static int netvsc_process_raw_pkt(struct hv_device *device,
|
|||
|
||||
default:
|
||||
netdev_err(ndev, "unhandled packet type %d, tid %llx\n",
|
||||
desc->type, request_id);
|
||||
desc->type, desc->trans_id);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1222,28 +1222,20 @@ int netvsc_poll(struct napi_struct *napi, int budget)
|
|||
u16 q_idx = channel->offermsg.offer.sub_channel_index;
|
||||
struct net_device *ndev = hv_get_drvdata(device);
|
||||
struct netvsc_device *net_device = net_device_to_netvsc_device(ndev);
|
||||
const struct vmpacket_descriptor *desc;
|
||||
int work_done = 0;
|
||||
|
||||
desc = hv_pkt_iter_first(channel);
|
||||
while (desc) {
|
||||
int count;
|
||||
/* If starting a new interval */
|
||||
if (!nvchan->desc)
|
||||
nvchan->desc = hv_pkt_iter_first(channel);
|
||||
|
||||
count = netvsc_process_raw_pkt(device, channel, net_device,
|
||||
ndev, desc->trans_id, desc);
|
||||
work_done += count;
|
||||
desc = __hv_pkt_iter_next(channel, desc);
|
||||
|
||||
/* If receive packet budget is exhausted, reschedule */
|
||||
if (work_done >= budget) {
|
||||
work_done = budget;
|
||||
break;
|
||||
}
|
||||
while (nvchan->desc && work_done < budget) {
|
||||
work_done += netvsc_process_raw_pkt(device, channel, net_device,
|
||||
ndev, nvchan->desc);
|
||||
nvchan->desc = hv_pkt_iter_next(channel, nvchan->desc);
|
||||
}
|
||||
hv_pkt_iter_close(channel);
|
||||
|
||||
/* If budget was not exhausted and
|
||||
* not doing busy poll
|
||||
/* If receive ring was exhausted
|
||||
* and not doing busy poll
|
||||
* then re-enable host interrupts
|
||||
* and reschedule if ring is not empty.
|
||||
*/
|
||||
|
|
@ -1253,7 +1245,9 @@ int netvsc_poll(struct napi_struct *napi, int budget)
|
|||
napi_reschedule(napi);
|
||||
|
||||
netvsc_chk_recv_comp(net_device, channel, q_idx);
|
||||
return work_done;
|
||||
|
||||
/* Driver may overshoot since multiple packets per descriptor */
|
||||
return min(work_done, budget);
|
||||
}
|
||||
|
||||
/* Call back when data is available in host ring buffer.
|
||||
|
|
@ -1263,10 +1257,12 @@ void netvsc_channel_cb(void *context)
|
|||
{
|
||||
struct netvsc_channel *nvchan = context;
|
||||
|
||||
/* disable interupts from host */
|
||||
hv_begin_read(&nvchan->channel->inbound);
|
||||
if (napi_schedule_prep(&nvchan->napi)) {
|
||||
/* disable interupts from host */
|
||||
hv_begin_read(&nvchan->channel->inbound);
|
||||
|
||||
napi_schedule(&nvchan->napi);
|
||||
__napi_schedule(&nvchan->napi);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1325,9 +1321,7 @@ int netvsc_device_add(struct hv_device *device,
|
|||
/* Writing nvdev pointer unlocks netvsc_send(), make sure chn_table is
|
||||
* populated.
|
||||
*/
|
||||
wmb();
|
||||
|
||||
net_device_ctx->nvdev = net_device;
|
||||
rcu_assign_pointer(net_device_ctx->nvdev, net_device);
|
||||
|
||||
/* Connect with the NetVsp */
|
||||
ret = netvsc_connect_vsp(device);
|
||||
|
|
@ -1346,7 +1340,7 @@ close:
|
|||
vmbus_close(device->channel);
|
||||
|
||||
cleanup:
|
||||
free_netvsc_device(net_device);
|
||||
free_netvsc_device(&net_device->rcu);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ static void do_set_multicast(struct work_struct *w)
|
|||
container_of(w, struct net_device_context, work);
|
||||
struct hv_device *device_obj = ndevctx->device_ctx;
|
||||
struct net_device *ndev = hv_get_drvdata(device_obj);
|
||||
struct netvsc_device *nvdev = ndevctx->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndevctx->nvdev);
|
||||
struct rndis_device *rdev;
|
||||
|
||||
if (!nvdev)
|
||||
|
|
@ -116,7 +116,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 netvsc_device *nvdev = net_device_ctx->nvdev;
|
||||
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
int ret;
|
||||
u32 aread, awrite, i, msec = 10, retry = 0, retry_max = 20;
|
||||
struct vmbus_channel *chn;
|
||||
|
|
@ -637,9 +637,9 @@ int netvsc_recv_callback(struct net_device *net,
|
|||
const struct ndis_pkt_8021q_info *vlan)
|
||||
{
|
||||
struct net_device_context *net_device_ctx = netdev_priv(net);
|
||||
struct netvsc_device *net_device = net_device_ctx->nvdev;
|
||||
struct netvsc_device *net_device;
|
||||
u16 q_idx = channel->offermsg.offer.sub_channel_index;
|
||||
struct netvsc_channel *nvchan = &net_device->chan_table[q_idx];
|
||||
struct netvsc_channel *nvchan;
|
||||
struct net_device *vf_netdev;
|
||||
struct sk_buff *skb;
|
||||
struct netvsc_stats *rx_stats;
|
||||
|
|
@ -655,6 +655,11 @@ int netvsc_recv_callback(struct net_device *net,
|
|||
* interface in the guest.
|
||||
*/
|
||||
rcu_read_lock();
|
||||
net_device = rcu_dereference(net_device_ctx->nvdev);
|
||||
if (unlikely(!net_device))
|
||||
goto drop;
|
||||
|
||||
nvchan = &net_device->chan_table[q_idx];
|
||||
vf_netdev = rcu_dereference(net_device_ctx->vf_netdev);
|
||||
if (vf_netdev && (vf_netdev->flags & IFF_UP))
|
||||
net = vf_netdev;
|
||||
|
|
@ -663,6 +668,7 @@ int netvsc_recv_callback(struct net_device *net,
|
|||
skb = netvsc_alloc_recv_skb(net, &nvchan->napi,
|
||||
csum_info, vlan, data, len);
|
||||
if (unlikely(!skb)) {
|
||||
drop:
|
||||
++net->stats.rx_dropped;
|
||||
rcu_read_unlock();
|
||||
return NVSP_STAT_FAIL;
|
||||
|
|
@ -704,7 +710,7 @@ static void netvsc_get_channels(struct net_device *net,
|
|||
struct ethtool_channels *channel)
|
||||
{
|
||||
struct net_device_context *net_device_ctx = netdev_priv(net);
|
||||
struct netvsc_device *nvdev = net_device_ctx->nvdev;
|
||||
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
|
||||
if (nvdev) {
|
||||
channel->max_combined = nvdev->max_chn;
|
||||
|
|
@ -741,8 +747,9 @@ static int netvsc_set_channels(struct net_device *net,
|
|||
{
|
||||
struct net_device_context *net_device_ctx = netdev_priv(net);
|
||||
struct hv_device *dev = net_device_ctx->device_ctx;
|
||||
struct netvsc_device *nvdev = net_device_ctx->nvdev;
|
||||
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
unsigned int count = channels->combined_count;
|
||||
bool was_running;
|
||||
int ret;
|
||||
|
||||
/* We do not support separate count for rx, tx, or other */
|
||||
|
|
@ -753,7 +760,7 @@ static int netvsc_set_channels(struct net_device *net,
|
|||
if (count > net->num_tx_queues || count > net->num_rx_queues)
|
||||
return -EINVAL;
|
||||
|
||||
if (net_device_ctx->start_remove || !nvdev || nvdev->destroy)
|
||||
if (!nvdev || nvdev->destroy)
|
||||
return -ENODEV;
|
||||
|
||||
if (nvdev->nvsp_version < NVSP_PROTOCOL_VERSION_5)
|
||||
|
|
@ -762,11 +769,13 @@ static int netvsc_set_channels(struct net_device *net,
|
|||
if (count > nvdev->max_chn)
|
||||
return -EINVAL;
|
||||
|
||||
ret = netvsc_close(net);
|
||||
if (ret)
|
||||
return ret;
|
||||
was_running = netif_running(net);
|
||||
if (was_running) {
|
||||
ret = netvsc_close(net);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
net_device_ctx->start_remove = true;
|
||||
rndis_filter_device_remove(dev, nvdev);
|
||||
|
||||
ret = netvsc_set_queues(net, dev, count);
|
||||
|
|
@ -775,8 +784,8 @@ static int netvsc_set_channels(struct net_device *net,
|
|||
else
|
||||
netvsc_set_queues(net, dev, nvdev->num_chn);
|
||||
|
||||
netvsc_open(net);
|
||||
net_device_ctx->start_remove = false;
|
||||
if (was_running)
|
||||
ret = netvsc_open(net);
|
||||
|
||||
/* We may have missed link change notifications */
|
||||
schedule_delayed_work(&net_device_ctx->dwork, 0);
|
||||
|
|
@ -842,24 +851,27 @@ static int netvsc_set_link_ksettings(struct net_device *dev,
|
|||
static int netvsc_change_mtu(struct net_device *ndev, int mtu)
|
||||
{
|
||||
struct net_device_context *ndevctx = netdev_priv(ndev);
|
||||
struct netvsc_device *nvdev = ndevctx->nvdev;
|
||||
struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
|
||||
struct hv_device *hdev = ndevctx->device_ctx;
|
||||
struct netvsc_device_info device_info;
|
||||
bool was_running;
|
||||
int ret;
|
||||
|
||||
if (ndevctx->start_remove || !nvdev || nvdev->destroy)
|
||||
if (!nvdev || nvdev->destroy)
|
||||
return -ENODEV;
|
||||
|
||||
ret = netvsc_close(ndev);
|
||||
if (ret)
|
||||
goto out;
|
||||
was_running = netif_running(ndev);
|
||||
if (was_running) {
|
||||
ret = netvsc_close(ndev);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
memset(&device_info, 0, sizeof(device_info));
|
||||
device_info.ring_size = ring_size;
|
||||
device_info.num_chn = nvdev->num_chn;
|
||||
device_info.max_num_vrss_chns = nvdev->num_chn;
|
||||
|
||||
ndevctx->start_remove = true;
|
||||
rndis_filter_device_remove(hdev, nvdev);
|
||||
|
||||
/* 'nvdev' has been freed in rndis_filter_device_remove() ->
|
||||
|
|
@ -872,9 +884,8 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
|
|||
|
||||
rndis_filter_device_add(hdev, &device_info);
|
||||
|
||||
out:
|
||||
netvsc_open(ndev);
|
||||
ndevctx->start_remove = false;
|
||||
if (was_running)
|
||||
ret = netvsc_open(ndev);
|
||||
|
||||
/* We may have missed link change notifications */
|
||||
schedule_delayed_work(&ndevctx->dwork, 0);
|
||||
|
|
@ -886,7 +897,7 @@ static void netvsc_get_stats64(struct net_device *net,
|
|||
struct rtnl_link_stats64 *t)
|
||||
{
|
||||
struct net_device_context *ndev_ctx = netdev_priv(net);
|
||||
struct netvsc_device *nvdev = ndev_ctx->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndev_ctx->nvdev);
|
||||
int i;
|
||||
|
||||
if (!nvdev)
|
||||
|
|
@ -971,7 +982,10 @@ static const struct {
|
|||
static int netvsc_get_sset_count(struct net_device *dev, int string_set)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *nvdev = ndc->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
||||
|
||||
if (!nvdev)
|
||||
return -ENODEV;
|
||||
|
||||
switch (string_set) {
|
||||
case ETH_SS_STATS:
|
||||
|
|
@ -985,13 +999,16 @@ static void netvsc_get_ethtool_stats(struct net_device *dev,
|
|||
struct ethtool_stats *stats, u64 *data)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *nvdev = ndc->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
||||
const void *nds = &ndc->eth_stats;
|
||||
const struct netvsc_stats *qstats;
|
||||
unsigned int start;
|
||||
u64 packets, bytes;
|
||||
int i, j;
|
||||
|
||||
if (!nvdev)
|
||||
return;
|
||||
|
||||
for (i = 0; i < NETVSC_GLOBAL_STATS_LEN; i++)
|
||||
data[i] = *(unsigned long *)(nds + netvsc_stats[i].offset);
|
||||
|
||||
|
|
@ -1020,10 +1037,13 @@ static void netvsc_get_ethtool_stats(struct net_device *dev,
|
|||
static void netvsc_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *nvdev = ndc->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
||||
u8 *p = data;
|
||||
int i;
|
||||
|
||||
if (!nvdev)
|
||||
return;
|
||||
|
||||
switch (stringset) {
|
||||
case ETH_SS_STATS:
|
||||
for (i = 0; i < ARRAY_SIZE(netvsc_stats); i++)
|
||||
|
|
@ -1075,7 +1095,10 @@ netvsc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
|
|||
u32 *rules)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *nvdev = ndc->nvdev;
|
||||
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
||||
|
||||
if (!nvdev)
|
||||
return -ENODEV;
|
||||
|
||||
switch (info->cmd) {
|
||||
case ETHTOOL_GRXRINGS:
|
||||
|
|
@ -1111,10 +1134,13 @@ static int netvsc_get_rxfh(struct net_device *dev, u32 *indir, u8 *key,
|
|||
u8 *hfunc)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *ndev = ndc->nvdev;
|
||||
struct netvsc_device *ndev = rcu_dereference(ndc->nvdev);
|
||||
struct rndis_device *rndis_dev = ndev->extension;
|
||||
int i;
|
||||
|
||||
if (!ndev)
|
||||
return -ENODEV;
|
||||
|
||||
if (hfunc)
|
||||
*hfunc = ETH_RSS_HASH_TOP; /* Toeplitz */
|
||||
|
||||
|
|
@ -1133,10 +1159,13 @@ static int netvsc_set_rxfh(struct net_device *dev, const u32 *indir,
|
|||
const u8 *key, const u8 hfunc)
|
||||
{
|
||||
struct net_device_context *ndc = netdev_priv(dev);
|
||||
struct netvsc_device *ndev = ndc->nvdev;
|
||||
struct netvsc_device *ndev = rtnl_dereference(ndc->nvdev);
|
||||
struct rndis_device *rndis_dev = ndev->extension;
|
||||
int i;
|
||||
|
||||
if (!ndev)
|
||||
return -ENODEV;
|
||||
|
||||
if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
|
|
@ -1210,10 +1239,10 @@ static void netvsc_link_change(struct work_struct *w)
|
|||
unsigned long flags, next_reconfig, delay;
|
||||
|
||||
rtnl_lock();
|
||||
if (ndev_ctx->start_remove)
|
||||
net_device = rtnl_dereference(ndev_ctx->nvdev);
|
||||
if (!net_device)
|
||||
goto out_unlock;
|
||||
|
||||
net_device = ndev_ctx->nvdev;
|
||||
rdev = net_device->extension;
|
||||
|
||||
next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT;
|
||||
|
|
@ -1354,7 +1383,7 @@ static int netvsc_register_vf(struct net_device *vf_netdev)
|
|||
return NOTIFY_DONE;
|
||||
|
||||
net_device_ctx = netdev_priv(ndev);
|
||||
netvsc_dev = net_device_ctx->nvdev;
|
||||
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
if (!netvsc_dev || rtnl_dereference(net_device_ctx->vf_netdev))
|
||||
return NOTIFY_DONE;
|
||||
|
||||
|
|
@ -1380,7 +1409,7 @@ static int netvsc_vf_up(struct net_device *vf_netdev)
|
|||
return NOTIFY_DONE;
|
||||
|
||||
net_device_ctx = netdev_priv(ndev);
|
||||
netvsc_dev = net_device_ctx->nvdev;
|
||||
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
|
||||
netdev_info(ndev, "VF up: %s\n", vf_netdev->name);
|
||||
|
||||
|
|
@ -1414,7 +1443,7 @@ static int netvsc_vf_down(struct net_device *vf_netdev)
|
|||
return NOTIFY_DONE;
|
||||
|
||||
net_device_ctx = netdev_priv(ndev);
|
||||
netvsc_dev = net_device_ctx->nvdev;
|
||||
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
||||
|
||||
netdev_info(ndev, "VF down: %s\n", vf_netdev->name);
|
||||
netvsc_switch_datapath(ndev, false);
|
||||
|
|
@ -1474,8 +1503,6 @@ static int netvsc_probe(struct hv_device *dev,
|
|||
|
||||
hv_set_drvdata(dev, net);
|
||||
|
||||
net_device_ctx->start_remove = false;
|
||||
|
||||
INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change);
|
||||
INIT_WORK(&net_device_ctx->work, do_set_multicast);
|
||||
|
||||
|
|
@ -1492,8 +1519,7 @@ static int netvsc_probe(struct hv_device *dev,
|
|||
/* Notify the netvsc driver of the new device */
|
||||
memset(&device_info, 0, sizeof(device_info));
|
||||
device_info.ring_size = ring_size;
|
||||
device_info.max_num_vrss_chns = min_t(u32, VRSS_CHANNEL_DEFAULT,
|
||||
num_online_cpus());
|
||||
device_info.num_chn = VRSS_CHANNEL_DEFAULT;
|
||||
ret = rndis_filter_device_add(dev, &device_info);
|
||||
if (ret != 0) {
|
||||
netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
|
||||
|
|
@ -1509,6 +1535,7 @@ static int netvsc_probe(struct hv_device *dev,
|
|||
NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
|
||||
net->vlan_features = net->features;
|
||||
|
||||
/* RCU not necessary here, device not registered */
|
||||
nvdev = net_device_ctx->nvdev;
|
||||
netif_set_real_num_tx_queues(net, nvdev->num_chn);
|
||||
netif_set_real_num_rx_queues(net, nvdev->num_chn);
|
||||
|
|
@ -1544,26 +1571,20 @@ static int netvsc_remove(struct hv_device *dev)
|
|||
|
||||
ndev_ctx = netdev_priv(net);
|
||||
|
||||
/* Avoid racing with netvsc_change_mtu()/netvsc_set_channels()
|
||||
* removing the device.
|
||||
*/
|
||||
rtnl_lock();
|
||||
ndev_ctx->start_remove = true;
|
||||
rtnl_unlock();
|
||||
netif_device_detach(net);
|
||||
|
||||
cancel_delayed_work_sync(&ndev_ctx->dwork);
|
||||
cancel_work_sync(&ndev_ctx->work);
|
||||
|
||||
/* Stop outbound asap */
|
||||
netif_tx_disable(net);
|
||||
|
||||
unregister_netdev(net);
|
||||
|
||||
/*
|
||||
* Call to the vsc driver to let it know that the device is being
|
||||
* removed
|
||||
* removed. Also blocks mtu and channel changes.
|
||||
*/
|
||||
rtnl_lock();
|
||||
rndis_filter_device_remove(dev, ndev_ctx->nvdev);
|
||||
rtnl_unlock();
|
||||
|
||||
unregister_netdev(net);
|
||||
|
||||
hv_set_drvdata(dev, NULL);
|
||||
|
||||
|
|
|
|||
|
|
@ -819,16 +819,14 @@ int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
|
|||
{
|
||||
struct rndis_request *request;
|
||||
struct rndis_set_request *set;
|
||||
struct rndis_set_complete *set_complete;
|
||||
int ret;
|
||||
|
||||
request = get_rndis_request(dev, RNDIS_MSG_SET,
|
||||
RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
|
||||
sizeof(u32));
|
||||
if (!request) {
|
||||
ret = -ENOMEM;
|
||||
goto cleanup;
|
||||
}
|
||||
if (!request)
|
||||
return -ENOMEM;
|
||||
|
||||
|
||||
/* Setup the rndis set */
|
||||
set = &request->request_msg.msg.set_req;
|
||||
|
|
@ -840,15 +838,11 @@ int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
|
|||
&new_filter, sizeof(u32));
|
||||
|
||||
ret = rndis_filter_send_request(dev, request);
|
||||
if (ret != 0)
|
||||
goto cleanup;
|
||||
if (ret == 0)
|
||||
wait_for_completion(&request->wait_event);
|
||||
|
||||
wait_for_completion(&request->wait_event);
|
||||
put_rndis_request(dev, request);
|
||||
|
||||
set_complete = &request->response_msg.msg.set_complete;
|
||||
cleanup:
|
||||
if (request)
|
||||
put_rndis_request(dev, request);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -926,8 +920,6 @@ static void rndis_filter_halt_device(struct rndis_device *dev)
|
|||
struct rndis_halt_request *halt;
|
||||
struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
|
||||
struct netvsc_device *nvdev = net_device_ctx->nvdev;
|
||||
struct hv_device *hdev = net_device_ctx->device_ctx;
|
||||
ulong flags;
|
||||
|
||||
/* Attempt to do a rndis device halt */
|
||||
request = get_rndis_request(dev, RNDIS_MSG_HALT,
|
||||
|
|
@ -945,9 +937,10 @@ static void rndis_filter_halt_device(struct rndis_device *dev)
|
|||
dev->state = RNDIS_DEV_UNINITIALIZED;
|
||||
|
||||
cleanup:
|
||||
spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
|
||||
nvdev->destroy = true;
|
||||
spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
|
||||
|
||||
/* Force flag to be ordered before waiting */
|
||||
wmb();
|
||||
|
||||
/* Wait for all send completions */
|
||||
wait_event(nvdev->wait_drain, netvsc_device_idle(nvdev));
|
||||
|
|
@ -997,7 +990,6 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
|
|||
struct netvsc_device *nvscdev = net_device_to_netvsc_device(ndev);
|
||||
u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
|
||||
struct netvsc_channel *nvchan;
|
||||
unsigned long flags;
|
||||
int ret;
|
||||
|
||||
if (chn_index >= nvscdev->num_chn)
|
||||
|
|
@ -1019,10 +1011,7 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
|
|||
|
||||
napi_enable(&nvchan->napi);
|
||||
|
||||
spin_lock_irqsave(&nvscdev->sc_lock, flags);
|
||||
nvscdev->num_sc_offered--;
|
||||
spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
|
||||
if (nvscdev->num_sc_offered == 0)
|
||||
if (refcount_dec_and_test(&nvscdev->sc_offered))
|
||||
complete(&nvscdev->channel_init_wait);
|
||||
}
|
||||
|
||||
|
|
@ -1039,12 +1028,9 @@ int rndis_filter_device_add(struct hv_device *dev,
|
|||
struct ndis_recv_scale_cap rsscap;
|
||||
u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
|
||||
unsigned int gso_max_size = GSO_MAX_SIZE;
|
||||
u32 mtu, size;
|
||||
u32 num_rss_qs;
|
||||
u32 sc_delta;
|
||||
u32 mtu, size, num_rss_qs;
|
||||
const struct cpumask *node_cpu_mask;
|
||||
u32 num_possible_rss_qs;
|
||||
unsigned long flags;
|
||||
int i, ret;
|
||||
|
||||
rndis_device = get_rndis_device();
|
||||
|
|
@ -1067,7 +1053,7 @@ int rndis_filter_device_add(struct hv_device *dev,
|
|||
net_device->max_chn = 1;
|
||||
net_device->num_chn = 1;
|
||||
|
||||
spin_lock_init(&net_device->sc_lock);
|
||||
refcount_set(&net_device->sc_offered, 0);
|
||||
|
||||
net_device->extension = rndis_device;
|
||||
rndis_device->ndev = net;
|
||||
|
|
@ -1181,34 +1167,30 @@ int rndis_filter_device_add(struct hv_device *dev,
|
|||
if (ret || rsscap.num_recv_que < 2)
|
||||
goto out;
|
||||
|
||||
net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);
|
||||
|
||||
num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);
|
||||
|
||||
/*
|
||||
* We will limit the VRSS channels to the number CPUs in the NUMA node
|
||||
* the primary channel is currently bound to.
|
||||
*
|
||||
* This also guarantees that num_possible_rss_qs <= num_online_cpus
|
||||
*/
|
||||
node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
|
||||
num_possible_rss_qs = cpumask_weight(node_cpu_mask);
|
||||
num_possible_rss_qs = min_t(u32, cpumask_weight(node_cpu_mask),
|
||||
rsscap.num_recv_que);
|
||||
|
||||
net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, num_possible_rss_qs);
|
||||
|
||||
/* We will use the given number of channels if available. */
|
||||
if (device_info->num_chn && device_info->num_chn < net_device->max_chn)
|
||||
net_device->num_chn = device_info->num_chn;
|
||||
else
|
||||
net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);
|
||||
|
||||
num_rss_qs = net_device->num_chn - 1;
|
||||
net_device->num_chn = min(net_device->max_chn, device_info->num_chn);
|
||||
|
||||
for (i = 0; i < ITAB_NUM; i++)
|
||||
rndis_device->ind_table[i] = ethtool_rxfh_indir_default(i,
|
||||
net_device->num_chn);
|
||||
|
||||
net_device->num_sc_offered = num_rss_qs;
|
||||
|
||||
if (net_device->num_chn == 1)
|
||||
goto out;
|
||||
num_rss_qs = net_device->num_chn - 1;
|
||||
if (num_rss_qs == 0)
|
||||
return 0;
|
||||
|
||||
refcount_set(&net_device->sc_offered, num_rss_qs);
|
||||
vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
|
||||
|
||||
init_packet = &net_device->channel_init_pkt;
|
||||
|
|
@ -1224,32 +1206,23 @@ int rndis_filter_device_add(struct hv_device *dev,
|
|||
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
||||
if (ret)
|
||||
goto out;
|
||||
wait_for_completion(&net_device->channel_init_wait);
|
||||
|
||||
if (init_packet->msg.v5_msg.subchn_comp.status !=
|
||||
NVSP_STAT_SUCCESS) {
|
||||
if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {
|
||||
ret = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
wait_for_completion(&net_device->channel_init_wait);
|
||||
|
||||
net_device->num_chn = 1 +
|
||||
init_packet->msg.v5_msg.subchn_comp.num_subchannels;
|
||||
|
||||
ret = rndis_filter_set_rss_param(rndis_device, netvsc_hash_key,
|
||||
net_device->num_chn);
|
||||
|
||||
/*
|
||||
* Set the number of sub-channels to be received.
|
||||
*/
|
||||
spin_lock_irqsave(&net_device->sc_lock, flags);
|
||||
sc_delta = num_rss_qs - (net_device->num_chn - 1);
|
||||
net_device->num_sc_offered -= sc_delta;
|
||||
spin_unlock_irqrestore(&net_device->sc_lock, flags);
|
||||
|
||||
/* ignore failues from setting rss parameters, still have channels */
|
||||
rndis_filter_set_rss_param(rndis_device, netvsc_hash_key,
|
||||
net_device->num_chn);
|
||||
out:
|
||||
if (ret) {
|
||||
net_device->max_chn = 1;
|
||||
net_device->num_chn = 1;
|
||||
net_device->num_sc_offered = 0;
|
||||
}
|
||||
|
||||
return 0; /* return 0 because primary channel can be used alone */
|
||||
|
|
@ -1264,12 +1237,6 @@ void rndis_filter_device_remove(struct hv_device *dev,
|
|||
{
|
||||
struct rndis_device *rndis_dev = net_dev->extension;
|
||||
|
||||
/* If not all subchannel offers are complete, wait for them until
|
||||
* completion to avoid race.
|
||||
*/
|
||||
if (net_dev->num_sc_offered > 0)
|
||||
wait_for_completion(&net_dev->channel_init_wait);
|
||||
|
||||
/* Halt and release the rndis device */
|
||||
rndis_filter_halt_device(rndis_dev);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue