tree f6c31f8464c56132d3b67d16f89012d3bf08312e
parent 75e6047431872dadd0b13503b374e48ccd71a507
author Jason Wang <jasowang@redhat.com> 1289400341 +0000
committer David S. Miller <davem@davemloft.net> 1289593278 -0800

virtio-net: init link state correctly

For device that supports VIRTIO_NET_F_STATUS, there's no need to
assume the link is up and we need to call nerif_carrier_off() before
querying device status, otherwise we may get wrong operstate after
diver was loaded because the link watch event was not fired as
expected.

For device that does not support VIRITO_NET_F_STATUS, we could not get
its status through virtnet_update_status() and what we can only do is
always assuming the link is up.

Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: David S. Miller <davem@davemloft.net>
