From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [PATCH RFC] virtio_net: fix error handling for mergeable buffers Date: Wed, 20 Nov 2013 16:20:32 +0200 Message-ID: <20131120142032.GA13492@redhat.com> References: <1384938447-3775-1-git-send-email-jasowang@redhat.com> <20131120132657.GA8455@redhat.com> <125586345.27477452.1384955642143.JavaMail.root@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <125586345.27477452.1384955642143.JavaMail.root@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: virtualization-bounces@lists.linux-foundation.org Errors-To: virtualization-bounces@lists.linux-foundation.org To: Jason Wang Cc: Michael Dalton , netdev@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, Eric Dumazet , Shirley Ma List-Id: virtualization@lists.linuxfoundation.org T24gV2VkLCBOb3YgMjAsIDIwMTMgYXQgMDg6NTQ6MDJBTSAtMDUwMCwgSmFzb24gV2FuZyB3cm90 ZToKPiAKPiAKPiAtLS0tLSDljp/lp4vpgq7ku7YgLS0tLS0KPiA+IE9uIFdlZCwgTm92IDIwLCAy MDEzIGF0IDA1OjA3OjI1UE0gKzA4MDAsIEphc29uIFdhbmcgd3JvdGU6Cj4gPiA+IFdoZW4gbWVy Z2VhYmxlIGJ1ZmZlciB3ZXJlIHVzZWQsIHdlIG9ubHkgcHV0IHRoZSBmaXJzdCBwYWdlIGJ1ZiBs ZWF2ZSB0aGUKPiA+ID4gcmVzdAo+ID4gPiBvZiBidWZmZXJzIGluIHRoZSB2aXJ0IHF1ZXVlLiBU aGlzIHdpbGwgY2F1c2UgdGhlIGRyaXZlciBjb3VsZCBub3QgZ2V0IHRoZQo+ID4gPiBjb3JyZWN0 IGhlYWQgYnVmZmVyIGFueSBtb3JlLiBGaXggdGhpcyBieSBkcm9wcGluZyB0aGUgcmVzdCBvZiBi dWZmZXJzIGZvcgo+ID4gPiB0aGlzCj4gPiA+IHBhY2tldC4KPiA+ID4gCj4gPiA+IFRoZSBidWcg d2FzIGludHJvZHVjZWQgYnkgY29tbWl0IDlhYjg2YmJjZjhiZTc1NTI1NmYwYTVlOTk0ZTBiMzhh ZjZiNGQzOTkKPiA+ID4gKHZpcnRpb19uZXQ6IERlZmVyIHNrYiBhbGxvY2F0aW9uIGluIHJlY2Vp dmUgcGF0aCkuCj4gPiA+IAo+ID4gPiBDYzogUnVzdHkgUnVzc2VsbCA8cnVzdHlAcnVzdGNvcnAu Y29tLmF1Pgo+ID4gPiBDYzogTWljaGFlbCBTLiBUc2lya2luIDxtc3RAcmVkaGF0LmNvbT4KPiA+ ID4gQ2M6IE1pY2hhZWwgRGFsdG9uIDxtd2RhbHRvbkBnb29nbGUuY29tPgo+ID4gPiBDYzogRXJp YyBEdW1hemV0IDxlZHVtYXpldEBnb29nbGUuY29tPgo+ID4gPiBDYzogU2hpcmxleSBNYSA8eG1h QHVzLmlibS5jb20+Cj4gPiA+IFNpZ25lZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJl ZGhhdC5jb20+Cj4gPiAKPiA+IEp1c3QgdG8gY2xhcmlmeSBteSBwcmV2aW91cyBjb21tZW50OiBp dCB3YXMgbm90IGFib3V0IHRoZQo+ID4gaWRlYSBvZiBhZGRpbmcgZHJvcF9tZXJnZWFibGVfYnVm ZmVyIC0gcmF0aGVyLCBJIHRoaW5rIHRoYXQKPiA+IGFkZGluZyBrbm93bGVkZ2UgYWJvdXQgbWVy Z2VhYmxlIGJ1ZmZlcnMgaW50byBwYWdlX3RvX3NrYiBjcmVhdGVzIGFuCj4gPiB1Z2x5IGludGVy bmFsIEFQSS4KPiA+IAo+ID4gTGV0J3MgbW92ZSB0aGUgY2FsbCB0byBwYWdlX3RvX3NrYiB3aXRo aW4gcmVjZWl2ZV9tZXJnZWFibGUgaW5zdGVhZDoKPiA+IGl0J3MgYWxzbyBuaWNlIHRoYXQgaW50 IG9mZnNldCA9IGJ1ZiAtIHBhZ2VfYWRkcmVzcyhwYWdlKSBsb2dpYwo+ID4gaXMgbm90IHNwcmVh ZCBhcm91bmQgbGlrZSBpdCB3YXMuCj4gPiAKPiA+IEFsc28sIGl0J3Mgbm90IG5pY2UgdGhhdCB3 ZSBpZ25vcmUgbGVuZ3RoIGVycm9ycyB3aGVuIHdlIGRyb3AKPiA+IHBhY2tldHMgYmVjYXVzZSBv ZiBPT00uCj4gPiAKPiA+IFNvIEkgY2FtZSB1cCB3aXRoIHRoZSBmb2xsb3dpbmcgLSBpdCBzZWVt cyB0byB3b3JrIGJ1dCBJIGRpZG4ndAo+ID4gc3RyZXNzIHRlc3QgeWV0Lgo+IAo+IEkndmUgbm8g b2JqZWN0aW9uIG9uIHRoaXMuIEJ1dCBJJ3ZlIHJhdGhlciBsaWtlIG15IHNtYWxsIGFuZCBkaXJl Y3QgcGF0Y2ggCj4gdG8gYmUgYXBwbGllZCB0byAtbmV0IGZpcnN0LiBJdCBoYXMgbG93ZXIgcmlz ayBhbmQgd2FzIG11Y2ggbW9yZSBlYXNpZXIgdG8gCj4gYmUgYmFja3BvcnRlZCB0byBzdGFibGUg dHJlZXMuIFRoZW4gd2UgY2FuIGRvIHRoZSByZS1mYWN0b3IgbGlrZSB0aGlzIGluIAo+IG5ldC1u ZXh0LiAKCkl0IG1ha2VzIHRoZSBpbnRlcmZhY2VzIHRvbyBtZXNzeS4gV2UgYXJlIG5vdCBpbiBj b2RlIGZyZWV6ZSBpbiAtbmV0IC0Kb25seSBmZWF0dXJlIGZyZWV6ZSwgc28gbm8gcmVhc29uIHRv IG1ha2UgY29kZSBsaWtlIHNwYWdldHR5LAphbmQgaXQncyBvbmx5IDI1IGxpbmVzIGNoYW5nZWQg YXMgY29tcGFyZWQgdG8gNDAuCkl0J3Mgbm90IGEgaHVnZSByZWZhY3RvcmluZy4KCkl0J3MganVz dCBhcyBlYXN5IHRvIGJhY2twb3J0IG15IHBhdGNoIHRvby4KWW91IGp1c3QgZHJvcCB0aGUgZ290 byBpbiB0aGUgbmV3IGNvZGUgcGF0aCB3ZSBhZGRlZC4KCkxldCBtZSBzaG93IHlvdSAodW50ZXN0 ZWQpIC0geW91ciBwYXRjaCBpcyBub3Qgc21hbGxlci4KClNpZ25lZC1vZmYtYnk6IE1pY2hhZWwg Uy4gVHNpcmtpbiA8bXN0QHJlZGhhdC5jb20+CgoKCmNvbW1pdCA5YjQ0MmZlOTcwZDVjNzEzMTFk NDMxNGVkZWYyNmVlMmViMTZlN2ZiCkF1dGhvcjogTWljaGFlbCBTLiBUc2lya2luIDxtc3RAcmVk aGF0LmNvbT4KRGF0ZTogICBXZWQgTm92IDIwIDEyOjQ0OjE0IDIwMTMgKzAyMDAKCiAgICB2aXJ0 aW9fbmV0OiBmaXggcmVzb3VyY2UgbGVhayBvbiBhbGxvYyBmYWlsdXJlCiAgICAKICAgIHZpcnRp byBuZXQgZ290IGNvbmZ1c2VkLCBzdGFydGVkIGRyb3BwaW5nIHBhY2tldHMuCiAgICAKICAgIFNp Z25lZC1vZmYtYnk6IE1pY2hhZWwgUy4gVHNpcmtpbiA8bXN0QHJlZGhhdC5jb20+CgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvdmlydGlvX25ldC5jIGIvZHJpdmVycy9uZXQvdmlydGlvX25ldC5j CmluZGV4IDlmYmRmY2QuLmRmNGI5ZDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3ZpcnRpb19u ZXQuYworKysgYi9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMKQEAgLTI5NywxMyArMjk3LDIyIEBA IHN0YXRpYyBzdHJ1Y3Qgc2tfYnVmZiAqcGFnZV90b19za2Ioc3RydWN0IHJlY2VpdmVfcXVldWUg KnJxLAogCXJldHVybiBza2I7CiB9CiAKLXN0YXRpYyBpbnQgcmVjZWl2ZV9tZXJnZWFibGUoc3Ry dWN0IHJlY2VpdmVfcXVldWUgKnJxLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQorc3RhdGljIHN0cnVj dCBza19idWZmICpyZWNlaXZlX21lcmdlYWJsZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAorCQkJ CQkgc3RydWN0IHJlY2VpdmVfcXVldWUgKnJxLAorCQkJCQkgc3RydWN0IHBhZ2UgKnBhZ2UsCisJ CQkJCSB1bnNpZ25lZCBpbnQgbGVuKQogewotCXN0cnVjdCBza2Jfdm5ldF9oZHIgKmhkciA9IHNr Yl92bmV0X2hkcihza2IpOwotCXN0cnVjdCBwYWdlICpwYWdlOwotCWludCBudW1fYnVmLCBpLCBs ZW47CisJc3RydWN0IHNrYl92bmV0X2hkciAqaGRyID0gcGFnZV9hZGRyZXNzKGJ1Zik7CisJaW50 IG51bV9idWYgPSBoZHItPm1oZHIubnVtX2J1ZmZlcnM7CisJc3RydWN0IHNrX2J1ZmYgKnNrYiA9 IHBhZ2VfdG9fc2tiKHJxLCBwYWdlLCBsZW4pOworCWludCBpOworCisJc2tiID0gcGFnZV90b19z a2IocnEsIHBhZ2UsIGxlbik7CisKKwlpZiAodW5saWtlbHkoIXNrYikpCisJCWdvdG8gZXJyX3Nr YjsKKwogCi0JbnVtX2J1ZiA9IGhkci0+bWhkci5udW1fYnVmZmVyczsKIAl3aGlsZSAoLS1udW1f YnVmKSB7CiAJCWkgPSBza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzOwogCQlpZiAoaSA+PSBNQVhf U0tCX0ZSQUdTKSB7CkBAIC0zMTMsMTAgKzMyMiwxMCBAQCBzdGF0aWMgaW50IHJlY2VpdmVfbWVy Z2VhYmxlKHN0cnVjdCByZWNlaXZlX3F1ZXVlICpycSwgc3RydWN0IHNrX2J1ZmYgKnNrYikKIAkJ fQogCQlwYWdlID0gdmlydHF1ZXVlX2dldF9idWYocnEtPnZxLCAmbGVuKTsKIAkJaWYgKCFwYWdl KSB7Ci0JCQlwcl9kZWJ1ZygiJXM6IHJ4IGVycm9yOiAlZCBidWZmZXJzIG1pc3NpbmdcbiIsCi0J CQkJIHNrYi0+ZGV2LT5uYW1lLCBoZHItPm1oZHIubnVtX2J1ZmZlcnMpOwotCQkJc2tiLT5kZXYt PnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKLQkJCXJldHVybiAtRUlOVkFMOworCQkJcHJfZGVi dWcoIiVzOiByeCBlcnJvcjogJWQgYnVmZmVycyAlZCBtaXNzaW5nXG4iLAorCQkJCSBkZXYtPm5h bWUsIGhkci0+bWhkci5udW1fYnVmZmVycywgbnVtX2J1Zik7CisJCQlkZXYtPnN0YXRzLnJ4X2xl bmd0aF9lcnJvcnMrKzsKKwkJCWdvdG8gZXJyX2J1ZjsKIAkJfQogCiAJCWlmIChsZW4gPiBQQUdF X1NJWkUpCkBAIC0zMjYsNyArMzM1LDI1IEBAIHN0YXRpYyBpbnQgcmVjZWl2ZV9tZXJnZWFibGUo c3RydWN0IHJlY2VpdmVfcXVldWUgKnJxLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQogCiAJCS0tcnEt Pm51bTsKIAl9Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHNrYjsKK2Vycl9za2I6CisJcHV0X3BhZ2Uo cGFnZSk7CitlcnJfYnVmOgorCWRldi0+c3RhdHMucnhfZHJvcHBlZCsrOworCWRldl9rZnJlZV9z a2IoaGVhZF9za2IpOworCXdoaWxlICgtLW51bV9idWYpIHsKKwkJYnVmID0gdmlydHF1ZXVlX2dl dF9idWYocnEtPnZxLCAmbGVuKTsKKwkJaWYgKHVubGlrZWx5KCFidWYpKSB7CisJCQlwcl9kZWJ1 ZygiJXM6IHJ4IGVycm9yOiAlZCBidWZmZXJzIG1pc3NpbmdcbiIsCisJCQkJIGRldi0+bmFtZSwg bnVtX2J1Zik7CisJCQlkZXYtPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKKwkJCWJyZWFrOwor CQl9CisJCXBhZ2UgPSBidWY7CisJCWdpdmVfcGFnZXMocnEsIHBhZ2UpOworCQktLXJxLT5udW07 CisJfQorCXJldHVybiBOVUxMOwogfQogCiBzdGF0aWMgdm9pZCByZWNlaXZlX2J1ZihzdHJ1Y3Qg cmVjZWl2ZV9xdWV1ZSAqcnEsIHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKQEAgLTM1NCwx NyArMzgxLDE4IEBAIHN0YXRpYyB2b2lkIHJlY2VpdmVfYnVmKHN0cnVjdCByZWNlaXZlX3F1ZXVl ICpycSwgdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQogCQlza2JfdHJpbShza2IsIGxlbik7 CiAJfSBlbHNlIHsKIAkJcGFnZSA9IGJ1ZjsKLQkJc2tiID0gcGFnZV90b19za2IocnEsIHBhZ2Us IGxlbik7Ci0JCWlmICh1bmxpa2VseSghc2tiKSkgewotCQkJZGV2LT5zdGF0cy5yeF9kcm9wcGVk Kys7Ci0JCQlnaXZlX3BhZ2VzKHJxLCBwYWdlKTsKLQkJCXJldHVybjsKLQkJfQotCQlpZiAodmkt Pm1lcmdlYWJsZV9yeF9idWZzKQotCQkJaWYgKHJlY2VpdmVfbWVyZ2VhYmxlKHJxLCBza2IpKSB7 Ci0JCQkJZGV2X2tmcmVlX3NrYihza2IpOworCQlpZiAodmktPm1lcmdlYWJsZV9yeF9idWZzKSB7 CisJCQlza2IgPSByZWNlaXZlX21lcmdlYWJsZShkZXYsIHJxLCBwYWdlLCBsZW4pOworCQkJaWYg KHVubGlrZWx5KCFza2IpKQorCQkJCXJldHVybjsKKwkJfSBlbHNlIHsKKwkJCXNrYiA9IHBhZ2Vf dG9fc2tiKHJxLCBwYWdlLCBsZW4pOworCQkJaWYgKHVubGlrZWx5KCFza2IpKSB7CisJCQkJZGV2 LT5zdGF0cy5yeF9kcm9wcGVkKys7CisJCQkJZ2l2ZV9wYWdlcyhycSwgcGFnZSk7CiAJCQkJcmV0 dXJuOwogCQkJfQorCQl9CiAJfQogCiAJaGRyID0gc2tiX3ZuZXRfaGRyKHNrYik7Cl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1h aWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRw czovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXph dGlvbg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752269Ab3KTORe (ORCPT ); Wed, 20 Nov 2013 09:17:34 -0500 Received: from mx1.redhat.com ([209.132.183.28]:18383 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750796Ab3KTORb (ORCPT ); Wed, 20 Nov 2013 09:17:31 -0500 Date: Wed, 20 Nov 2013 16:20:32 +0200 From: "Michael S. Tsirkin" To: Jason Wang Cc: rusty@rustcorp.com.au, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Michael Dalton , Eric Dumazet , Shirley Ma Subject: Re: [PATCH RFC] virtio_net: fix error handling for mergeable buffers Message-ID: <20131120142032.GA13492@redhat.com> References: <1384938447-3775-1-git-send-email-jasowang@redhat.com> <20131120132657.GA8455@redhat.com> <125586345.27477452.1384955642143.JavaMail.root@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <125586345.27477452.1384955642143.JavaMail.root@redhat.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Nov 20, 2013 at 08:54:02AM -0500, Jason Wang wrote: > > > ----- 原始邮件 ----- > > On Wed, Nov 20, 2013 at 05:07:25PM +0800, Jason Wang wrote: > > > When mergeable buffer were used, we only put the first page buf leave the > > > rest > > > of buffers in the virt queue. This will cause the driver could not get the > > > correct head buffer any more. Fix this by dropping the rest of buffers for > > > this > > > packet. > > > > > > The bug was introduced by commit 9ab86bbcf8be755256f0a5e994e0b38af6b4d399 > > > (virtio_net: Defer skb allocation in receive path). > > > > > > Cc: Rusty Russell > > > Cc: Michael S. Tsirkin > > > Cc: Michael Dalton > > > Cc: Eric Dumazet > > > Cc: Shirley Ma > > > Signed-off-by: Jason Wang > > > > Just to clarify my previous comment: it was not about the > > idea of adding drop_mergeable_buffer - rather, I think that > > adding knowledge about mergeable buffers into page_to_skb creates an > > ugly internal API. > > > > Let's move the call to page_to_skb within receive_mergeable instead: > > it's also nice that int offset = buf - page_address(page) logic > > is not spread around like it was. > > > > Also, it's not nice that we ignore length errors when we drop > > packets because of OOM. > > > > So I came up with the following - it seems to work but I didn't > > stress test yet. > > I've no objection on this. But I've rather like my small and direct patch > to be applied to -net first. It has lower risk and was much more easier to > be backported to stable trees. Then we can do the re-factor like this in > net-next. It makes the interfaces too messy. We are not in code freeze in -net - only feature freeze, so no reason to make code like spagetty, and it's only 25 lines changed as compared to 40. It's not a huge refactoring. It's just as easy to backport my patch too. You just drop the goto in the new code path we added. Let me show you (untested) - your patch is not smaller. Signed-off-by: Michael S. Tsirkin commit 9b442fe970d5c71311d4314edef26ee2eb16e7fb Author: Michael S. Tsirkin Date: Wed Nov 20 12:44:14 2013 +0200 virtio_net: fix resource leak on alloc failure virtio net got confused, started dropping packets. Signed-off-by: Michael S. Tsirkin diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c index 9fbdfcd..df4b9d0 100644 --- a/drivers/net/virtio_net.c +++ b/drivers/net/virtio_net.c @@ -297,13 +297,22 @@ static struct sk_buff *page_to_skb(struct receive_queue *rq, return skb; } -static int receive_mergeable(struct receive_queue *rq, struct sk_buff *skb) +static struct sk_buff *receive_mergeable(struct net_device *dev, + struct receive_queue *rq, + struct page *page, + unsigned int len) { - struct skb_vnet_hdr *hdr = skb_vnet_hdr(skb); - struct page *page; - int num_buf, i, len; + struct skb_vnet_hdr *hdr = page_address(buf); + int num_buf = hdr->mhdr.num_buffers; + struct sk_buff *skb = page_to_skb(rq, page, len); + int i; + + skb = page_to_skb(rq, page, len); + + if (unlikely(!skb)) + goto err_skb; + - num_buf = hdr->mhdr.num_buffers; while (--num_buf) { i = skb_shinfo(skb)->nr_frags; if (i >= MAX_SKB_FRAGS) { @@ -313,10 +322,10 @@ static int receive_mergeable(struct receive_queue *rq, struct sk_buff *skb) } page = virtqueue_get_buf(rq->vq, &len); if (!page) { - pr_debug("%s: rx error: %d buffers missing\n", - skb->dev->name, hdr->mhdr.num_buffers); - skb->dev->stats.rx_length_errors++; - return -EINVAL; + pr_debug("%s: rx error: %d buffers %d missing\n", + dev->name, hdr->mhdr.num_buffers, num_buf); + dev->stats.rx_length_errors++; + goto err_buf; } if (len > PAGE_SIZE) @@ -326,7 +335,25 @@ static int receive_mergeable(struct receive_queue *rq, struct sk_buff *skb) --rq->num; } - return 0; + return skb; +err_skb: + put_page(page); +err_buf: + dev->stats.rx_dropped++; + dev_kfree_skb(head_skb); + while (--num_buf) { + buf = virtqueue_get_buf(rq->vq, &len); + if (unlikely(!buf)) { + pr_debug("%s: rx error: %d buffers missing\n", + dev->name, num_buf); + dev->stats.rx_length_errors++; + break; + } + page = buf; + give_pages(rq, page); + --rq->num; + } + return NULL; } static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len) @@ -354,17 +381,18 @@ static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len) skb_trim(skb, len); } else { page = buf; - skb = page_to_skb(rq, page, len); - if (unlikely(!skb)) { - dev->stats.rx_dropped++; - give_pages(rq, page); - return; - } - if (vi->mergeable_rx_bufs) - if (receive_mergeable(rq, skb)) { - dev_kfree_skb(skb); + if (vi->mergeable_rx_bufs) { + skb = receive_mergeable(dev, rq, page, len); + if (unlikely(!skb)) + return; + } else { + skb = page_to_skb(rq, page, len); + if (unlikely(!skb)) { + dev->stats.rx_dropped++; + give_pages(rq, page); return; } + } } hdr = skb_vnet_hdr(skb);