From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [PATCH net-next] virtio-net: switch to use build_skb() for small buffer Date: Wed, 22 Feb 2017 05:42:29 +0200 Message-ID: <20170222053753-mutt-send-email-mst@kernel.org> References: <1487666788-9658-1-git-send-email-jasowang@redhat.com> <20170221162849-mutt-send-email-mst@kernel.org> <35244d06-2d0d-3f2e-0cd1-43137988c869@redhat.com> <20170222050601-mutt-send-email-mst@kernel.org> <49577dad-3f6f-e6b3-4f93-2b919b066068@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: <49577dad-3f6f-e6b3-4f93-2b919b066068@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: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org List-Id: virtualization@lists.linuxfoundation.org T24gV2VkLCBGZWIgMjIsIDIwMTcgYXQgMTE6MTc6NTBBTSArMDgwMCwgSmFzb24gV2FuZyB3cm90 ZToKPiAKPiAKPiBPbiAyMDE35bm0MDLmnIgyMuaXpSAxMTowNiwgTWljaGFlbCBTLiBUc2lya2lu IHdyb3RlOgo+ID4gT24gV2VkLCBGZWIgMjIsIDIwMTcgYXQgMTA6NTg6MDhBTSArMDgwMCwgSmFz b24gV2FuZyB3cm90ZToKPiA+ID4gCj4gPiA+IE9uIDIwMTflubQwMuaciDIx5pelIDIyOjM3LCBN aWNoYWVsIFMuIFRzaXJraW4gd3JvdGU6Cj4gPiA+ID4gT24gVHVlLCBGZWIgMjEsIDIwMTcgYXQg MDQ6NDY6MjhQTSArMDgwMCwgSmFzb24gV2FuZyB3cm90ZToKPiA+ID4gPiA+IFRoaXMgcGF0Y2gg c3dpdGNoIHRvIHVzZSBidWlsZF9za2IoKSBmb3Igc21hbGwgYnVmZmVyIHdoaWNoIGNhbiBoYXZl Cj4gPiA+ID4gPiBiZXR0ZXIgcGVyZm9ybWFuY2UgZm9yIGJvdGggVENQIGFuZCBYRFAgKHNpbmNl IHdlIGNhbiB3b3JrIGF0IHBhZ2UKPiA+ID4gPiA+IGJlZm9yZSBza2IgY3JlYXRpb24pLiBJdCBh bHNvIHJlbW92ZSBsb3RzIG9mIFhEUCBjb2RlcyBzaW5jZSBib3RoCj4gPiA+ID4gPiBtZXJnZWFi bGUgYW5kIHNtYWxsIGJ1ZmZlciB1c2UgcGFnZSBmcmFnIGR1cmluZyByZWZpbGwgbm93Lgo+ID4g PiA+ID4gCj4gPiA+ID4gPiAgICAgICAgICAgICAgICAgICAgICAgICAgQmVmb3JlICAgfCBBZnRl cgo+ID4gPiA+ID4gWERQX0RST1AoeGRwMSkgNjRCICA6ICAxMS4xTXBwcyB8IDE0LjRNcHBzCj4g PiA+ID4gPiAKPiA+ID4gPiA+IFRlc3RlZCB3aXRoIHhkcDEveGRwMi94ZHBfaXBfdHhfdHVubmVs IGFuZCBuZXRwZXJmLgo+ID4gPiA+ID4gCj4gPiA+ID4gPiBTaWduZWQtb2ZmLWJ5OiBKYXNvbiBX YW5nPGphc293YW5nQHJlZGhhdC5jb20+Cj4gPiA+ID4gVGhhbmtzIQo+ID4gPiA+IEkgaGFkIGEg c2ltaWxhciBwYXRjaCBmb3IgbWVyZ2VhYmxlIHRvbywgdGhvdWdoIGl0J3MgdHJpY2tpZXIgdGhl cmUKPiA+ID4gPiBhcyBob3N0IGhhcyBhIGxvdCBvZiBmbGV4aWJpbGl0eSBpbiBzaXppbmcgYnVm ZmVycy4KPiA+ID4gPiBMb29rcyBsaWtlIGEgZ29vZCBpbnRlcm1lZGlhdGUgc3RlcCB0byBtZS4K PiA+ID4gWWVzLCBJIHRoaW5rIGl0J3MgbW9yZSB0cmlja3kgZm9yIHRoZSBjYXNlIG9mIG1lcmdl YWJsZSBidWZmZXI6Cj4gPiA+IAo+ID4gPiAxKSB3ZSBuZWVkIHJlc2VydmUgTkVUX1NLQl9QQUQg KyBORVRfSVBfQUxJR04gZm9yIGVhY2ggYnVmZmVyLCB0aGlzIHdpbGwKPiA+ID4gYnJlYWsgcngg ZnJhZyBjb2FsZXNjaW5nCj4gPiA+IDIpIG5lZWQgdGFpbHJvb20gZm9yIHNrYl9zaGluZm8sIHNv IGl0IHdvbid0IHdvcmsgZm9yIGFsbCBzaXplIG9mIHBhY2tldAo+ID4gPiAKPiA+ID4gVGhhbmtz Cj4gPiBIYXZlIHlvdSBzZWVuIG15IHByb3RvdHlwZT8KPiAKPiBOb3QgeWV0LCBwbGVhc2UgZ2l2 ZSBtZSBhIHBvaW50ZXIuCj4gCj4gPiAgIEl0IHdvcmtzIHdpdGggcWVtdSBpbiBwcmFjdGljZSwK PiA+IGp1c3QgbmVlZHMgdG8gY292ZXIgYSBidW5jaCBvZiBjb3JuZXIgY2FzZXMuCj4gCj4gU291 bmRzIGdvb2QsIGlmIHlvdSB3aXNoIEkgY2FuIGhlbHAgdG8gZmluYWxpemUgaXQuCj4gCj4gVGhh bmtzCj4gCj4gPiAKPiA+ID4gPiAKPiA+ID4gPiBBY2tlZC1ieTogTWljaGFlbCBTLiBUc2lya2lu PG1zdEByZWRoYXQuY29tPgo+ID4gPiA+IAoKCkdyZWF0ISBIZXJlIGl0IGlzIEkgdGhpbmsgaXQn cyBvbiB0b3Agb2YgNC45IG9yIHNvLiBJc3N1ZXMgdG8gYWRkcmVzczoKLSB3aGVuIHJpbmcgaXMg dmVyeSBzbWFsbCB0aGlzIG1pZ2h0IGNhdXNlIHVzIG5vdCB0bwogIGJlIGFibGUgdG8gZml0IGV2 ZW4gYSBzaW5nbGUgcGFja2V0IGluIHRoZSB3aG9sZSBxdWV1ZS4KICBMaW1pdCBsb2dpYyB0byB3 aGVuIHJpbmcgaXMgYmlnIGVub3VnaD8KLSBJZiBlLmcuIGhlYWRlciBpcyBzcGxpdCBhY3Jvc3Mg bWFueSBidWZmZXJzLCB0aGlzIHdvbid0IHdvcmsKICBjb3JyZWN0bHkuIERldGVjdCBhbmQgY29w eT8KCkNvdWxkIGJlIG1vcmUgaXNzdWVzIHRoYXQgSSBmb3Jnb3QuIEl0IG1pZ2h0IGJlIGEgZ29v ZCBpZGVhIHRvCmZpcnN0IGZpbmlzaCBteSBidWZmZXIgY3R4IGhhY2suIFdpbGwgc2ltcGxpZnkg dGhlIGxvZ2ljLgoKCmNvbW1pdCA3N2MxNzcwOTFhN2M4NDczZTNmMGVkMTQ4YWZhMmI0NzY1Yjhi MGY3CkF1dGhvcjogTWljaGFlbCBTLiBUc2lya2luIDxtc3RAcmVkaGF0LmNvbT4KRGF0ZTogICBT dW4gRmViIDIxIDIwOjIyOjMxIDIwMTYgKzAyMDAKCiAgICB2aXJ0aW9fbmV0OiBzd2l0Y2ggdG8g YnVpbGRfc2tiIGZvciBtcmdfcnhidWYKICAgIAogICAgRm9yIHNtYWxsIHBhY2tldHMgZGF0YSBj b3B5IHdhcyBvYnNlcnZlZCB0bwogICAgdGFrZSB1cCBhYm91dCAxNSUgQ1BVIHRpbWUuIFN3aXRj aCB0byBidWlsZF9za2IKICAgIGFuZCBhdm9pZCB0aGUgY29weSB3aGVuIHVzaW5nIG1lcmdlYWJs ZSByeCBidWZmZXJzLgogICAgCiAgICBBcyBhIGJvbnVzLCBtZWRpdW0tc2l6ZSBza2JzIHRoYXQg Zml0IGluIGEgcGFnZSB3aWxsIGJlCiAgICBjb21wbGV0ZWx5IGxpbmVhci4KICAgIAogICAgT2Yg Y291cnNlLCB3ZSBub3cgbmVlZCB0byBsb3dlciB0aGUgbG93ZXIgYm91bmQgb24gcGFja2V0IHNp emUsCiAgICB0byBtYWtlIHN1cmUgYSBzYW5lIG51bWJlciBvZiBza2JzIGZpdHMgaW4gcnggc29j a2V0IGJ1ZmZlci4KICAgIEJ5IGhvdyBtdWNoPyBJIGRvbid0IGtub3cgeWV0LgogICAgCiAgICBJ dCBtaWdodCBhbHNvIGJlIHVzZWZ1bCB0byBwcmVmZXRjaCB0aGUgcGFja2V0IGJ1ZmZlciBzaW5j ZQogICAgbmV0IHN0YWNrIHdpbGwgbGlrZWx5IHVzZSBpdCBzb29uLgoKICAgIFRPRE86IGl0IGFw cGVhcnMgdGhhdCBMaW51eCB3b24ndCBoYW5kbGUgY29ycmVjdGx5IHRoZSBjYXNlIG9mIGZpcnN0 CiAgICBidWZmZXIgYmVpbmcgdmVyeSBzbWFsbCAob3IgY29uc2lzdGluZyBleGNsdXNpdmVseSBv ZiB2aXJ0aW8gaGVhZGVyKS4KICAgIFRoaXMgaXMgYWxyZWFkeSB0aGUgY2FzZSBmb3IgY3VycmVu dCBjb2RlLCBzbyBkb24ndCBib3RoZXIKICAgIHRlc3RpbmcgeWV0LgogICAgVE9ETzogbWlnaHQg YmUgdW5mYWlyIHRvIHRoZSBsYXN0IHBhY2tldCBpbiBhIGZyYWdtZW50IGFzIHdlIGluY2x1ZGUK ICAgIHJlbWFpbmluZyBzcGFjZSBpZiBhbnkgaW4gaXRzIHRydWVzaXplLgogICAgCiAgICBTaWdu ZWQtb2ZmLWJ5OiBNaWNoYWVsIFMuIFRzaXJraW4gPG1zdEByZWRoYXQuY29tPgoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYyBiL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYwpp bmRleCBiNDI1ZmExLi5hNmI5OTZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC92aXJ0aW9fbmV0 LmMKKysrIGIvZHJpdmVycy9uZXQvdmlydGlvX25ldC5jCkBAIC0zOCw2ICszOCw4IEBAIG1vZHVs ZV9wYXJhbShnc28sIGJvb2wsIDA0NDQpOwogCiAvKiBGSVhNRTogTVRVIGluIGNvbmZpZy4gKi8K ICNkZWZpbmUgR09PRF9QQUNLRVRfTEVOIChFVEhfSExFTiArIFZMQU5fSExFTiArIEVUSF9EQVRB X0xFTikKKy8vI2RlZmluZSBNSU5fUEFDS0VUX0FMTE9DIEdPT0RfUEFDS0VUX0xFTgorI2RlZmlu ZSBNSU5fUEFDS0VUX0FMTE9DIDEyOAogI2RlZmluZSBHT09EX0NPUFlfTEVOCTEyOAogCiAvKiBS WCBwYWNrZXQgc2l6ZSBFV01BLiBUaGUgYXZlcmFnZSBwYWNrZXQgc2l6ZSBpcyB1c2VkIHRvIGRl dGVybWluZSB0aGUgcGFja2V0CkBAIC0yNDYsNiArMjQ4LDkgQEAgc3RhdGljIHZvaWQgKm1lcmdl YWJsZV9jdHhfdG9fYnVmX2FkZHJlc3ModW5zaWduZWQgbG9uZyBtcmdfY3R4KQogc3RhdGljIHVu c2lnbmVkIGxvbmcgbWVyZ2VhYmxlX2J1Zl90b19jdHgodm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQg dHJ1ZXNpemUpCiB7CiAJdW5zaWduZWQgaW50IHNpemUgPSB0cnVlc2l6ZSAvIE1FUkdFQUJMRV9C VUZGRVJfQUxJR047CisKKwlCVUdfT04oKHVuc2lnbmVkIGxvbmcpYnVmICYgKE1FUkdFQUJMRV9C VUZGRVJfQUxJR04gLSAxKSk7CisJQlVHX09OKHNpemUgLSAxID49IE1FUkdFQUJMRV9CVUZGRVJf QUxJR04pOwogCXJldHVybiAodW5zaWduZWQgbG9uZylidWYgfCAoc2l6ZSAtIDEpOwogfQogCkBA IC0zNTQsMjUgKzM1OSw1NCBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKnJlY2VpdmVfYmlnKHN0 cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJcmV0dXJuIE5VTEw7CiB9CiAKKyNkZWZpbmUgVk5FVF9T S0JfUEFEIChORVRfU0tCX1BBRCArIE5FVF9JUF9BTElHTikKKyNkZWZpbmUgVk5FVF9TS0JfQlVH IChWTkVUX1NLQl9QQUQgPCBzaXplb2Yoc3RydWN0IHZpcnRpb19uZXRfaGRyX21yZ19yeGJ1Zikp CisjZGVmaW5lIFZORVRfU0tCX0xFTihsZW4pICgobGVuKSAtIHNpemVvZihzdHJ1Y3QgdmlydGlv X25ldF9oZHJfbXJnX3J4YnVmKSkKKyNkZWZpbmUgVk5FVF9TS0JfT0ZGIFZORVRfU0tCX0xFTihW TkVUX1NLQl9QQUQpCisKK3N0YXRpYyBzdHJ1Y3Qgc2tfYnVmZiAqdm5ldF9idWlsZF9za2Ioc3Ry dWN0IHZpcnRuZXRfaW5mbyAqdmksCisJCQkJICAgICAgdm9pZCAqYnVmLAorCQkJCSAgICAgIHVu c2lnbmVkIGludCBsZW4sIHVuc2lnbmVkIGludCB0cnVlc2l6ZSkKK3sKKwlzdHJ1Y3Qgc2tfYnVm ZiAqc2tiID0gYnVpbGRfc2tiKGJ1ZiwgdHJ1ZXNpemUpOworCisJaWYgKCFza2IpCisJCXJldHVy biBOVUxMOworCisJc2tiX3Jlc2VydmUoc2tiLCBWTkVUX1NLQl9QQUQpOworCXNrYl9wdXQoc2ti LCBWTkVUX1NLQl9MRU4obGVuKSk7CisKKwlyZXR1cm4gc2tiOworfQorCiBzdGF0aWMgc3RydWN0 IHNrX2J1ZmYgKnJlY2VpdmVfbWVyZ2VhYmxlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCQkJ CSBzdHJ1Y3QgdmlydG5ldF9pbmZvICp2aSwKIAkJCQkJIHN0cnVjdCByZWNlaXZlX3F1ZXVlICpy cSwKIAkJCQkJIHVuc2lnbmVkIGxvbmcgY3R4LAotCQkJCQkgdW5zaWduZWQgaW50IGxlbikKKwkJ CQkJIHVuc2lnbmVkIGludCBsZW4sCisJCQkJCSBzdHJ1Y3QgdmlydGlvX25ldF9oZHJfbXJnX3J4 YnVmICpoZHIpCiB7CiAJdm9pZCAqYnVmID0gbWVyZ2VhYmxlX2N0eF90b19idWZfYWRkcmVzcyhj dHgpOwotCXN0cnVjdCB2aXJ0aW9fbmV0X2hkcl9tcmdfcnhidWYgKmhkciA9IGJ1ZjsKLQl1MTYg bnVtX2J1ZiA9IHZpcnRpbzE2X3RvX2NwdSh2aS0+dmRldiwgaGRyLT5udW1fYnVmZmVycyk7CisJ dTE2IG51bV9idWY7CiAJc3RydWN0IHBhZ2UgKnBhZ2UgPSB2aXJ0X3RvX2hlYWRfcGFnZShidWYp OwotCWludCBvZmZzZXQgPSBidWYgLSBwYWdlX2FkZHJlc3MocGFnZSk7Ci0JdW5zaWduZWQgaW50 IHRydWVzaXplID0gbWF4KGxlbiwgbWVyZ2VhYmxlX2N0eF90b19idWZfdHJ1ZXNpemUoY3R4KSk7 CisJdW5zaWduZWQgaW50IHRydWVzaXplID0gbWVyZ2VhYmxlX2N0eF90b19idWZfdHJ1ZXNpemUo Y3R4KTsKKwlpbnQgb2Zmc2V0OworCXN0cnVjdCBza19idWZmICpoZWFkX3NrYjsKKwlzdHJ1Y3Qg c2tfYnVmZiAqY3Vycl9za2I7CisKKwlCVUdfT04obGVuID4gdHJ1ZXNpemUpOwogCi0Jc3RydWN0 IHNrX2J1ZmYgKmhlYWRfc2tiID0gcGFnZV90b19za2IodmksIHJxLCBwYWdlLCBvZmZzZXQsIGxl biwKLQkJCQkJICAgICAgIHRydWVzaXplKTsKLQlzdHJ1Y3Qgc2tfYnVmZiAqY3Vycl9za2IgPSBo ZWFkX3NrYjsKKwkvKiBjb3B5IGhlYWRlcjogYnVpbGRfc2tiIHdpbGwgb3ZlcndyaXRlIGl0ICov CisJbWVtY3B5KGhkciwgYnVmICsgVk5FVF9TS0JfT0ZGLCBzaXplb2YgKmhkcik7CisKKwloZWFk X3NrYiA9IHZuZXRfYnVpbGRfc2tiKHZpLCBidWYsIGxlbiwgdHJ1ZXNpemUpOworCWN1cnJfc2ti ID0gaGVhZF9za2I7CisKKwludW1fYnVmID0gdmlydGlvMTZfdG9fY3B1KHZpLT52ZGV2LCBoZHIt Pm51bV9idWZmZXJzKTsKIAogCWlmICh1bmxpa2VseSghY3Vycl9za2IpKQogCQlnb3RvIGVycl9z a2I7CisKIAl3aGlsZSAoLS1udW1fYnVmKSB7CiAJCWludCBudW1fc2tiX2ZyYWdzOwogCkBAIC0z ODYsNyArNDIwLDcgQEAgc3RhdGljIHN0cnVjdCBza19idWZmICpyZWNlaXZlX21lcmdlYWJsZShz dHJ1Y3QgbmV0X2RldmljZSAqZGV2LAogCQkJZ290byBlcnJfYnVmOwogCQl9CiAKLQkJYnVmID0g bWVyZ2VhYmxlX2N0eF90b19idWZfYWRkcmVzcyhjdHgpOworCQlidWYgPSBtZXJnZWFibGVfY3R4 X3RvX2J1Zl9hZGRyZXNzKGN0eCkgKyBWTkVUX1NLQl9PRkY7CiAJCXBhZ2UgPSB2aXJ0X3RvX2hl YWRfcGFnZShidWYpOwogCiAJCW51bV9za2JfZnJhZ3MgPSBza2Jfc2hpbmZvKGN1cnJfc2tiKS0+ bnJfZnJhZ3M7CkBAIC00MDMsNyArNDM3LDggQEAgc3RhdGljIHN0cnVjdCBza19idWZmICpyZWNl aXZlX21lcmdlYWJsZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAogCQkJaGVhZF9za2ItPnRydWVz aXplICs9IG5za2ItPnRydWVzaXplOwogCQkJbnVtX3NrYl9mcmFncyA9IDA7CiAJCX0KLQkJdHJ1 ZXNpemUgPSBtYXgobGVuLCBtZXJnZWFibGVfY3R4X3RvX2J1Zl90cnVlc2l6ZShjdHgpKTsKKwkJ dHJ1ZXNpemUgPSBtZXJnZWFibGVfY3R4X3RvX2J1Zl90cnVlc2l6ZShjdHgpOworCQlCVUdfT04o bGVuID4gdHJ1ZXNpemUpOwogCQlpZiAoY3Vycl9za2IgIT0gaGVhZF9za2IpIHsKIAkJCWhlYWRf c2tiLT5kYXRhX2xlbiArPSBsZW47CiAJCQloZWFkX3NrYi0+bGVuICs9IGxlbjsKQEAgLTQ0OSw2 ICs0ODQsNyBAQCBzdGF0aWMgdm9pZCByZWNlaXZlX2J1ZihzdHJ1Y3QgdmlydG5ldF9pbmZvICp2 aSwgc3RydWN0IHJlY2VpdmVfcXVldWUgKnJxLAogCXN0cnVjdCB2aXJ0bmV0X3N0YXRzICpzdGF0 cyA9IHRoaXNfY3B1X3B0cih2aS0+c3RhdHMpOwogCXN0cnVjdCBza19idWZmICpza2I7CiAJc3Ry dWN0IHZpcnRpb19uZXRfaGRyX21yZ19yeGJ1ZiAqaGRyOworCXN0cnVjdCB2aXJ0aW9fbmV0X2hk cl9tcmdfcnhidWYgaGRyMDsKIAogCWlmICh1bmxpa2VseShsZW4gPCB2aS0+aGRyX2xlbiArIEVU SF9ITEVOKSkgewogCQlwcl9kZWJ1ZygiJXM6IHNob3J0IHBhY2tldCAlaVxuIiwgZGV2LT5uYW1l LCBsZW4pOwpAQCAtNDY1LDE3ICs1MDEsMjQgQEAgc3RhdGljIHZvaWQgcmVjZWl2ZV9idWYoc3Ry dWN0IHZpcnRuZXRfaW5mbyAqdmksIHN0cnVjdCByZWNlaXZlX3F1ZXVlICpycSwKIAkJcmV0dXJu OwogCX0KIAotCWlmICh2aS0+bWVyZ2VhYmxlX3J4X2J1ZnMpCi0JCXNrYiA9IHJlY2VpdmVfbWVy Z2VhYmxlKGRldiwgdmksIHJxLCAodW5zaWduZWQgbG9uZylidWYsIGxlbik7Ci0JZWxzZSBpZiAo dmktPmJpZ19wYWNrZXRzKQorCWlmICh2aS0+bWVyZ2VhYmxlX3J4X2J1ZnMpIHsKKwkJc2tiID0g cmVjZWl2ZV9tZXJnZWFibGUoZGV2LCB2aSwgcnEsICh1bnNpZ25lZCBsb25nKWJ1ZiwgbGVuLAor CQkJCQkmaGRyMCk7CisJCWlmICh1bmxpa2VseSghc2tiKSkKKwkJCXJldHVybjsKKwkJaGRyID0g JmhkcjA7CisJfSBlbHNlIGlmICh2aS0+YmlnX3BhY2tldHMpIHsKIAkJc2tiID0gcmVjZWl2ZV9i aWcoZGV2LCB2aSwgcnEsIGJ1ZiwgbGVuKTsKLQllbHNlCisJCWlmICh1bmxpa2VseSghc2tiKSkK KwkJCXJldHVybjsKKwkJaGRyID0gc2tiX3ZuZXRfaGRyKHNrYik7CisJfSBlbHNlIHsKIAkJc2ti ID0gcmVjZWl2ZV9zbWFsbCh2aSwgYnVmLCBsZW4pOworCQlpZiAodW5saWtlbHkoIXNrYikpCisJ CQlyZXR1cm47CisJCWhkciA9IHNrYl92bmV0X2hkcihza2IpOworCX0KIAotCWlmICh1bmxpa2Vs eSghc2tiKSkKLQkJcmV0dXJuOwotCi0JaGRyID0gc2tiX3ZuZXRfaGRyKHNrYik7CiAKIAl1NjRf c3RhdHNfdXBkYXRlX2JlZ2luKCZzdGF0cy0+cnhfc3luY3ApOwogCXN0YXRzLT5yeF9ieXRlcyAr PSBza2ItPmxlbjsKQEAgLTU4MSwxMSArNjI0LDE0IEBAIHN0YXRpYyBpbnQgYWRkX3JlY3ZidWZf YmlnKHN0cnVjdCB2aXJ0bmV0X2luZm8gKnZpLCBzdHJ1Y3QgcmVjZWl2ZV9xdWV1ZSAqcnEsCiAK IHN0YXRpYyB1bnNpZ25lZCBpbnQgZ2V0X21lcmdlYWJsZV9idWZfbGVuKHN0cnVjdCBld21hX3Br dF9sZW4gKmF2Z19wa3RfbGVuKQogewotCWNvbnN0IHNpemVfdCBoZHJfbGVuID0gc2l6ZW9mKHN0 cnVjdCB2aXJ0aW9fbmV0X2hkcl9tcmdfcnhidWYpOworCXVuc2lnbmVkIGludCBoZHI7CiAJdW5z aWduZWQgaW50IGxlbjsKIAotCWxlbiA9IGhkcl9sZW4gKyBjbGFtcF90KHVuc2lnbmVkIGludCwg ZXdtYV9wa3RfbGVuX3JlYWQoYXZnX3BrdF9sZW4pLAotCQkJR09PRF9QQUNLRVRfTEVOLCBQQUdF X1NJWkUgLSBoZHJfbGVuKTsKKwloZHIgPSBBTElHTihWTkVUX1NLQl9QQUQgKyBTS0JfREFUQV9B TElHTihzaXplb2Yoc3RydWN0IHNrYl9zaGFyZWRfaW5mbykpLAorCQkgICAgTUVSR0VBQkxFX0JV RkZFUl9BTElHTik7CisKKwlsZW4gPSBoZHIgKyBjbGFtcF90KHVuc2lnbmVkIGludCwgZXdtYV9w a3RfbGVuX3JlYWQoYXZnX3BrdF9sZW4pLAorCQkJICAgIE1JTl9QQUNLRVRfQUxMT0MsIFBBR0Vf U0laRSAtIGhkcik7CiAJcmV0dXJuIEFMSUdOKGxlbiwgTUVSR0VBQkxFX0JVRkZFUl9BTElHTik7 CiB9CiAKQEAgLTYwMSw4ICs2NDcsMTEgQEAgc3RhdGljIGludCBhZGRfcmVjdmJ1Zl9tZXJnZWFi bGUoc3RydWN0IHJlY2VpdmVfcXVldWUgKnJxLCBnZnBfdCBnZnApCiAJaWYgKHVubGlrZWx5KCFz a2JfcGFnZV9mcmFnX3JlZmlsbChsZW4sIGFsbG9jX2ZyYWcsIGdmcCkpKQogCQlyZXR1cm4gLUVO T01FTTsKIAotCWJ1ZiA9IChjaGFyICopcGFnZV9hZGRyZXNzKGFsbG9jX2ZyYWctPnBhZ2UpICsg YWxsb2NfZnJhZy0+b2Zmc2V0OwotCWN0eCA9IG1lcmdlYWJsZV9idWZfdG9fY3R4KGJ1ZiwgbGVu KTsKKwlCVUlMRF9CVUdfT04oVk5FVF9TS0JfQlVHKTsKKworCWJ1ZiA9IChjaGFyICopcGFnZV9h ZGRyZXNzKGFsbG9jX2ZyYWctPnBhZ2UpICsgYWxsb2NfZnJhZy0+b2Zmc2V0ICsKKwkJVk5FVF9T S0JfT0ZGOworCS8vY3R4ID0gbWVyZ2VhYmxlX2J1Zl90b19jdHgoYnVmIC0gVk5FVF9TS0JfT0ZG LCBsZW4pOwogCWdldF9wYWdlKGFsbG9jX2ZyYWctPnBhZ2UpOwogCWFsbG9jX2ZyYWctPm9mZnNl dCArPSBsZW47CiAJaG9sZSA9IGFsbG9jX2ZyYWctPnNpemUgLSBhbGxvY19mcmFnLT5vZmZzZXQ7 CkBAIC02MTUsOCArNjY0LDEwIEBAIHN0YXRpYyBpbnQgYWRkX3JlY3ZidWZfbWVyZ2VhYmxlKHN0 cnVjdCByZWNlaXZlX3F1ZXVlICpycSwgZ2ZwX3QgZ2ZwKQogCQlsZW4gKz0gaG9sZTsKIAkJYWxs b2NfZnJhZy0+b2Zmc2V0ICs9IGhvbGU7CiAJfQorCWN0eCA9IG1lcmdlYWJsZV9idWZfdG9fY3R4 KGJ1ZiAtIFZORVRfU0tCX09GRiwgbGVuKTsKIAotCXNnX2luaXRfb25lKHJxLT5zZywgYnVmLCBs ZW4pOworCXNnX2luaXRfb25lKHJxLT5zZywgYnVmLAorCQkgICAgbGVuIC0gVk5FVF9TS0JfT0ZG IC0gU0tCX0RBVEFfQUxJR04oc2l6ZW9mKHN0cnVjdCBza2Jfc2hhcmVkX2luZm8pKSk7CiAJZXJy ID0gdmlydHF1ZXVlX2FkZF9pbmJ1ZihycS0+dnEsIHJxLT5zZywgMSwgKHZvaWQgKiljdHgsIGdm cCk7CiAJaWYgKGVyciA8IDApCiAJCXB1dF9wYWdlKHZpcnRfdG9faGVhZF9wYWdlKGJ1ZikpOwpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXph dGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5v cmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmly dHVhbGl6YXRpb24= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754053AbdBVDmp (ORCPT ); Tue, 21 Feb 2017 22:42:45 -0500 Received: from mx1.redhat.com ([209.132.183.28]:44262 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753359AbdBVDmf (ORCPT ); Tue, 21 Feb 2017 22:42:35 -0500 Date: Wed, 22 Feb 2017 05:42:29 +0200 From: "Michael S. Tsirkin" To: Jason Wang Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH net-next] virtio-net: switch to use build_skb() for small buffer Message-ID: <20170222053753-mutt-send-email-mst@kernel.org> References: <1487666788-9658-1-git-send-email-jasowang@redhat.com> <20170221162849-mutt-send-email-mst@kernel.org> <35244d06-2d0d-3f2e-0cd1-43137988c869@redhat.com> <20170222050601-mutt-send-email-mst@kernel.org> <49577dad-3f6f-e6b3-4f93-2b919b066068@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <49577dad-3f6f-e6b3-4f93-2b919b066068@redhat.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Wed, 22 Feb 2017 03:42:31 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Feb 22, 2017 at 11:17:50AM +0800, Jason Wang wrote: > > > On 2017年02月22日 11:06, Michael S. Tsirkin wrote: > > On Wed, Feb 22, 2017 at 10:58:08AM +0800, Jason Wang wrote: > > > > > > On 2017年02月21日 22:37, Michael S. Tsirkin wrote: > > > > On Tue, Feb 21, 2017 at 04:46:28PM +0800, Jason Wang wrote: > > > > > This patch switch to use build_skb() for small buffer which can have > > > > > better performance for both TCP and XDP (since we can work at page > > > > > before skb creation). It also remove lots of XDP codes since both > > > > > mergeable and small buffer use page frag during refill now. > > > > > > > > > > Before | After > > > > > XDP_DROP(xdp1) 64B : 11.1Mpps | 14.4Mpps > > > > > > > > > > Tested with xdp1/xdp2/xdp_ip_tx_tunnel and netperf. > > > > > > > > > > Signed-off-by: Jason Wang > > > > Thanks! > > > > I had a similar patch for mergeable too, though it's trickier there > > > > as host has a lot of flexibility in sizing buffers. > > > > Looks like a good intermediate step to me. > > > Yes, I think it's more tricky for the case of mergeable buffer: > > > > > > 1) we need reserve NET_SKB_PAD + NET_IP_ALIGN for each buffer, this will > > > break rx frag coalescing > > > 2) need tailroom for skb_shinfo, so it won't work for all size of packet > > > > > > Thanks > > Have you seen my prototype? > > Not yet, please give me a pointer. > > > It works with qemu in practice, > > just needs to cover a bunch of corner cases. > > Sounds good, if you wish I can help to finalize it. > > Thanks > > > > > > > > > > > Acked-by: Michael S. Tsirkin > > > > Great! Here it is I think it's on top of 4.9 or so. Issues to address: - when ring is very small this might cause us not to be able to fit even a single packet in the whole queue. Limit logic to when ring is big enough? - If e.g. header is split across many buffers, this won't work correctly. Detect and copy? Could be more issues that I forgot. It might be a good idea to first finish my buffer ctx hack. Will simplify the logic. commit 77c177091a7c8473e3f0ed148afa2b4765b8b0f7 Author: Michael S. Tsirkin Date: Sun Feb 21 20:22:31 2016 +0200 virtio_net: switch to build_skb for mrg_rxbuf For small packets data copy was observed to take up about 15% CPU time. Switch to build_skb and avoid the copy when using mergeable rx buffers. As a bonus, medium-size skbs that fit in a page will be completely linear. Of course, we now need to lower the lower bound on packet size, to make sure a sane number of skbs fits in rx socket buffer. By how much? I don't know yet. It might also be useful to prefetch the packet buffer since net stack will likely use it soon. TODO: it appears that Linux won't handle correctly the case of first buffer being very small (or consisting exclusively of virtio header). This is already the case for current code, so don't bother testing yet. TODO: might be unfair to the last packet in a fragment as we include remaining space if any in its truesize. Signed-off-by: Michael S. Tsirkin diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c index b425fa1..a6b996f 100644 --- a/drivers/net/virtio_net.c +++ b/drivers/net/virtio_net.c @@ -38,6 +38,8 @@ module_param(gso, bool, 0444); /* FIXME: MTU in config. */ #define GOOD_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN) +//#define MIN_PACKET_ALLOC GOOD_PACKET_LEN +#define MIN_PACKET_ALLOC 128 #define GOOD_COPY_LEN 128 /* RX packet size EWMA. The average packet size is used to determine the packet @@ -246,6 +248,9 @@ static void *mergeable_ctx_to_buf_address(unsigned long mrg_ctx) static unsigned long mergeable_buf_to_ctx(void *buf, unsigned int truesize) { unsigned int size = truesize / MERGEABLE_BUFFER_ALIGN; + + BUG_ON((unsigned long)buf & (MERGEABLE_BUFFER_ALIGN - 1)); + BUG_ON(size - 1 >= MERGEABLE_BUFFER_ALIGN); return (unsigned long)buf | (size - 1); } @@ -354,25 +359,54 @@ static struct sk_buff *receive_big(struct net_device *dev, return NULL; } +#define VNET_SKB_PAD (NET_SKB_PAD + NET_IP_ALIGN) +#define VNET_SKB_BUG (VNET_SKB_PAD < sizeof(struct virtio_net_hdr_mrg_rxbuf)) +#define VNET_SKB_LEN(len) ((len) - sizeof(struct virtio_net_hdr_mrg_rxbuf)) +#define VNET_SKB_OFF VNET_SKB_LEN(VNET_SKB_PAD) + +static struct sk_buff *vnet_build_skb(struct virtnet_info *vi, + void *buf, + unsigned int len, unsigned int truesize) +{ + struct sk_buff *skb = build_skb(buf, truesize); + + if (!skb) + return NULL; + + skb_reserve(skb, VNET_SKB_PAD); + skb_put(skb, VNET_SKB_LEN(len)); + + return skb; +} + static struct sk_buff *receive_mergeable(struct net_device *dev, struct virtnet_info *vi, struct receive_queue *rq, unsigned long ctx, - unsigned int len) + unsigned int len, + struct virtio_net_hdr_mrg_rxbuf *hdr) { void *buf = mergeable_ctx_to_buf_address(ctx); - struct virtio_net_hdr_mrg_rxbuf *hdr = buf; - u16 num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers); + u16 num_buf; struct page *page = virt_to_head_page(buf); - int offset = buf - page_address(page); - unsigned int truesize = max(len, mergeable_ctx_to_buf_truesize(ctx)); + unsigned int truesize = mergeable_ctx_to_buf_truesize(ctx); + int offset; + struct sk_buff *head_skb; + struct sk_buff *curr_skb; + + BUG_ON(len > truesize); - struct sk_buff *head_skb = page_to_skb(vi, rq, page, offset, len, - truesize); - struct sk_buff *curr_skb = head_skb; + /* copy header: build_skb will overwrite it */ + memcpy(hdr, buf + VNET_SKB_OFF, sizeof *hdr); + + head_skb = vnet_build_skb(vi, buf, len, truesize); + curr_skb = head_skb; + + num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers); if (unlikely(!curr_skb)) goto err_skb; + while (--num_buf) { int num_skb_frags; @@ -386,7 +420,7 @@ static struct sk_buff *receive_mergeable(struct net_device *dev, goto err_buf; } - buf = mergeable_ctx_to_buf_address(ctx); + buf = mergeable_ctx_to_buf_address(ctx) + VNET_SKB_OFF; page = virt_to_head_page(buf); num_skb_frags = skb_shinfo(curr_skb)->nr_frags; @@ -403,7 +437,8 @@ static struct sk_buff *receive_mergeable(struct net_device *dev, head_skb->truesize += nskb->truesize; num_skb_frags = 0; } - truesize = max(len, mergeable_ctx_to_buf_truesize(ctx)); + truesize = mergeable_ctx_to_buf_truesize(ctx); + BUG_ON(len > truesize); if (curr_skb != head_skb) { head_skb->data_len += len; head_skb->len += len; @@ -449,6 +484,7 @@ static void receive_buf(struct virtnet_info *vi, struct receive_queue *rq, struct virtnet_stats *stats = this_cpu_ptr(vi->stats); struct sk_buff *skb; struct virtio_net_hdr_mrg_rxbuf *hdr; + struct virtio_net_hdr_mrg_rxbuf hdr0; if (unlikely(len < vi->hdr_len + ETH_HLEN)) { pr_debug("%s: short packet %i\n", dev->name, len); @@ -465,17 +501,24 @@ static void receive_buf(struct virtnet_info *vi, struct receive_queue *rq, return; } - if (vi->mergeable_rx_bufs) - skb = receive_mergeable(dev, vi, rq, (unsigned long)buf, len); - else if (vi->big_packets) + if (vi->mergeable_rx_bufs) { + skb = receive_mergeable(dev, vi, rq, (unsigned long)buf, len, + &hdr0); + if (unlikely(!skb)) + return; + hdr = &hdr0; + } else if (vi->big_packets) { skb = receive_big(dev, vi, rq, buf, len); - else + if (unlikely(!skb)) + return; + hdr = skb_vnet_hdr(skb); + } else { skb = receive_small(vi, buf, len); + if (unlikely(!skb)) + return; + hdr = skb_vnet_hdr(skb); + } - if (unlikely(!skb)) - return; - - hdr = skb_vnet_hdr(skb); u64_stats_update_begin(&stats->rx_syncp); stats->rx_bytes += skb->len; @@ -581,11 +624,14 @@ static int add_recvbuf_big(struct virtnet_info *vi, struct receive_queue *rq, static unsigned int get_mergeable_buf_len(struct ewma_pkt_len *avg_pkt_len) { - const size_t hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf); + unsigned int hdr; unsigned int len; - len = hdr_len + clamp_t(unsigned int, ewma_pkt_len_read(avg_pkt_len), - GOOD_PACKET_LEN, PAGE_SIZE - hdr_len); + hdr = ALIGN(VNET_SKB_PAD + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)), + MERGEABLE_BUFFER_ALIGN); + + len = hdr + clamp_t(unsigned int, ewma_pkt_len_read(avg_pkt_len), + MIN_PACKET_ALLOC, PAGE_SIZE - hdr); return ALIGN(len, MERGEABLE_BUFFER_ALIGN); } @@ -601,8 +647,11 @@ static int add_recvbuf_mergeable(struct receive_queue *rq, gfp_t gfp) if (unlikely(!skb_page_frag_refill(len, alloc_frag, gfp))) return -ENOMEM; - buf = (char *)page_address(alloc_frag->page) + alloc_frag->offset; - ctx = mergeable_buf_to_ctx(buf, len); + BUILD_BUG_ON(VNET_SKB_BUG); + + buf = (char *)page_address(alloc_frag->page) + alloc_frag->offset + + VNET_SKB_OFF; + //ctx = mergeable_buf_to_ctx(buf - VNET_SKB_OFF, len); get_page(alloc_frag->page); alloc_frag->offset += len; hole = alloc_frag->size - alloc_frag->offset; @@ -615,8 +664,10 @@ static int add_recvbuf_mergeable(struct receive_queue *rq, gfp_t gfp) len += hole; alloc_frag->offset += hole; } + ctx = mergeable_buf_to_ctx(buf - VNET_SKB_OFF, len); - sg_init_one(rq->sg, buf, len); + sg_init_one(rq->sg, buf, + len - VNET_SKB_OFF - SKB_DATA_ALIGN(sizeof(struct skb_shared_info))); err = virtqueue_add_inbuf(rq->vq, rq->sg, 1, (void *)ctx, gfp); if (err < 0) put_page(virt_to_head_page(buf));