From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [RFC v2] virtio: support packed ring Date: Tue, 17 Apr 2018 05:17:41 +0300 Message-ID: <20180417051343-mutt-send-email-mst@kernel.org> References: <20180401141216.8969-1-tiwei.bie@intel.com> <20180413071529.f4esh654dakodf4f@debian> <8dee7d62-ac0b-54ba-6bec-4bc4a6fb34e9@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: <8dee7d62-ac0b-54ba-6bec-4bc4a6fb34e9@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, wexu@redhat.com List-Id: virtualization@lists.linuxfoundation.org T24gVHVlLCBBcHIgMTcsIDIwMTggYXQgMTA6MTE6NThBTSArMDgwMCwgSmFzb24gV2FuZyB3cm90 ZToKPiAKPiAKPiBPbiAyMDE45bm0MDTmnIgxM+aXpSAxNToxNSwgVGl3ZWkgQmllIHdyb3RlOgo+ ID4gT24gRnJpLCBBcHIgMTMsIDIwMTggYXQgMTI6MzA6MjRQTSArMDgwMCwgSmFzb24gV2FuZyB3 cm90ZToKPiA+ID4gT24gMjAxOOW5tDA05pyIMDHml6UgMjI6MTIsIFRpd2VpIEJpZSB3cm90ZToK PiA+ID4gPiBIZWxsbyBldmVyeW9uZSwKPiA+ID4gPiAKPiA+ID4gPiBUaGlzIFJGQyBpbXBsZW1l bnRzIHBhY2tlZCByaW5nIHN1cHBvcnQgZm9yIHZpcnRpbyBkcml2ZXIuCj4gPiA+ID4gCj4gPiA+ ID4gVGhlIGNvZGUgd2FzIHRlc3RlZCB3aXRoIERQREsgdmhvc3QgKHRlc3RwbWQvdmhvc3QtUE1E KSBpbXBsZW1lbnRlZAo+ID4gPiA+IGJ5IEplbnMgYXQgaHR0cDovL2RwZGsub3JnL21sL2FyY2hp dmVzL2Rldi8yMDE4LUphbnVhcnkvMDg5NDE3Lmh0bWwKPiA+ID4gPiBNaW5vciBjaGFuZ2VzIGFy ZSBuZWVkZWQgZm9yIHRoZSB2aG9zdCBjb2RlLCBlLmcuIHRvIGtpY2sgdGhlIGd1ZXN0Lgo+ID4g PiA+IAo+ID4gPiA+IFRPRE86Cj4gPiA+ID4gLSBSZWZpbmVtZW50cyBhbmQgYnVnIGZpeGVzOwo+ ID4gPiA+IC0gU3BsaXQgaW50byBzbWFsbCBwYXRjaGVzOwo+ID4gPiA+IC0gVGVzdCBpbmRpcmVj dCBkZXNjcmlwdG9yIHN1cHBvcnQ7Cj4gPiA+ID4gLSBUZXN0L2ZpeCBldmVudCBzdXBwcmVzc2lv biBzdXBwb3J0Owo+ID4gPiA+IC0gVGVzdCBkZXZpY2VzIG90aGVyIHRoYW4gbmV0Owo+ID4gPiA+ IAo+ID4gPiA+IFJGQyB2MSAtPiBSRkMgdjI6Cj4gPiA+ID4gLSBBZGQgaW5kaXJlY3QgZGVzY3Jp cHRvciBzdXBwb3J0IC0gY29tcGlsZSB0ZXN0IG9ubHk7Cj4gPiA+ID4gLSBBZGQgZXZlbnQgc3Vw cHJlc3Npb24gc3VwcHJ0IC0gY29tcGlsZSB0ZXN0IG9ubHk7Cj4gPiA+ID4gLSBNb3ZlIHZyaW5n X3BhY2tlZF9pbml0KCkgb3V0IG9mIHVhcGkgKEphc29uLCBNU1QpOwo+ID4gPiA+IC0gTWVyZ2Ug dHdvIGxvb3BzIGludG8gb25lIGluIHZpcnRxdWV1ZV9hZGRfcGFja2VkKCkgKEphc29uKTsKPiA+ ID4gPiAtIFNwbGl0IHZyaW5nX3VubWFwX29uZSgpIGZvciBwYWNrZWQgcmluZyBhbmQgc3BsaXQg cmluZyAoSmFzb24pOwo+ID4gPiA+IC0gQXZvaWQgdXNpbmcgJyUnIG9wZXJhdG9yIChKYXNvbik7 Cj4gPiA+ID4gLSBSZW5hbWUgZnJlZV9oZWFkIC0+IG5leHRfYXZhaWxfaWR4IChKYXNvbik7Cj4g PiA+ID4gLSBBZGQgY29tbWVudHMgZm9yIHZpcnRpb193bWIoKSBpbiB2aXJ0cXVldWVfYWRkX3Bh Y2tlZCgpIChKYXNvbik7Cj4gPiA+ID4gLSBTb21lIG90aGVyIHJlZmluZW1lbnRzIGFuZCBidWcg Zml4ZXM7Cj4gPiA+ID4gCj4gPiA+ID4gVGhhbmtzIQo+ID4gPiA+IAo+ID4gPiA+IFNpZ25lZC1v ZmYtYnk6IFRpd2VpIEJpZSA8dGl3ZWkuYmllQGludGVsLmNvbT4KPiA+ID4gPiAtLS0KPiA+ID4g PiAgICBkcml2ZXJzL3ZpcnRpby92aXJ0aW9fcmluZy5jICAgICAgIHwgMTA5NCArKysrKysrKysr KysrKysrKysrKysrKysrKysrKy0tLS0tLS0KPiA+ID4gPiAgICBpbmNsdWRlL2xpbnV4L3ZpcnRp b19yaW5nLmggICAgICAgIHwgICAgOCArLQo+ID4gPiA+ICAgIGluY2x1ZGUvdWFwaS9saW51eC92 aXJ0aW9fY29uZmlnLmggfCAgIDEyICstCj4gPiA+ID4gICAgaW5jbHVkZS91YXBpL2xpbnV4L3Zp cnRpb19yaW5nLmggICB8ICAgNjEgKysKPiA+ID4gPiAgICA0IGZpbGVzIGNoYW5nZWQsIDk4MCBp bnNlcnRpb25zKCspLCAxOTUgZGVsZXRpb25zKC0pCj4gPiBbLi4uXQo+ID4gPiA+ICtzdGF0aWMg c3RydWN0IHZyaW5nX3BhY2tlZF9kZXNjICphbGxvY19pbmRpcmVjdF9wYWNrZWQoc3RydWN0IHZp cnRxdWV1ZSAqX3ZxLAo+ID4gPiA+ICsJCQkJCQkgICAgICAgdW5zaWduZWQgaW50IHRvdGFsX3Nn LAo+ID4gPiA+ICsJCQkJCQkgICAgICAgZ2ZwX3QgZ2ZwKQo+ID4gPiA+ICt7Cj4gPiA+ID4gKwlz dHJ1Y3QgdnJpbmdfcGFja2VkX2Rlc2MgKmRlc2M7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJLyoKPiA+ ID4gPiArCSAqIFdlIHJlcXVpcmUgbG93bWVtIG1hcHBpbmdzIGZvciB0aGUgZGVzY3JpcHRvcnMg YmVjYXVzZQo+ID4gPiA+ICsJICogb3RoZXJ3aXNlIHZpcnRfdG9fcGh5cyB3aWxsIGdpdmUgdXMg Ym9ndXMgYWRkcmVzc2VzIGluIHRoZQo+ID4gPiA+ICsJICogdmlydHF1ZXVlLgo+ID4gPiA+ICsJ ICovCj4gPiA+ID4gKwlnZnAgJj0gfl9fR0ZQX0hJR0hNRU07Cj4gPiA+ID4gKwo+ID4gPiA+ICsJ ZGVzYyA9IGttYWxsb2ModG90YWxfc2cgKiBzaXplb2Yoc3RydWN0IHZyaW5nX3BhY2tlZF9kZXNj KSwgZ2ZwKTsKPiA+ID4gQ2FuIHdlIHNpbXBseSBjaGVjayB2cS0+cGFja2VkIGhlcmUgdG8gYXZv aWQgZHVwbGljYXRpbmcgaGVscGVycz8KPiA+IFRoZW4gaXQgd291bGQgYmUgc29tZXRoaW5nIGxp a2UgdGhpczoKPiA+IAo+ID4gc3RhdGljIHZvaWQgKmFsbG9jX2luZGlyZWN0KHN0cnVjdCB2aXJ0 cXVldWUgKl92cSwgdW5zaWduZWQgaW50IHRvdGFsX3NnLAo+ID4gCQkJICAgIGdmcF90IGdmcCkK PiA+IHsKPiA+IAlzdHJ1Y3QgdnJpbmdfdmlydHF1ZXVlICp2cSA9IHRvX3Z2cShfdnEpOwo+ID4g CXZvaWQgKmRhdGE7Cj4gPiAKPiA+IAkvKgo+ID4gCSAqIFdlIHJlcXVpcmUgbG93bWVtIG1hcHBp bmdzIGZvciB0aGUgZGVzY3JpcHRvcnMgYmVjYXVzZQo+ID4gCSAqIG90aGVyd2lzZSB2aXJ0X3Rv X3BoeXMgd2lsbCBnaXZlIHVzIGJvZ3VzIGFkZHJlc3NlcyBpbiB0aGUKPiA+IAkgKiB2aXJ0cXVl dWUuCj4gPiAJICovCj4gPiAJZ2ZwICY9IH5fX0dGUF9ISUdITUVNOwo+ID4gCj4gPiAJaWYgKHZx LT5wYWNrZWQpIHsKPiA+IAkJZGF0YSA9IGttYWxsb2ModG90YWxfc2cgKiBzaXplb2Yoc3RydWN0 IHZyaW5nX3BhY2tlZF9kZXNjKSwKPiA+IAkJCQlnZnApOwo+ID4gCQlpZiAoIWRhdGEpCj4gPiAJ CQlyZXR1cm4gTlVMTDsKPiA+IAl9IGVsc2Ugewo+ID4gCQlzdHJ1Y3QgdnJpbmdfZGVzYyAqZGVz YzsKPiA+IAkJdW5zaWduZWQgaW50IGk7Cj4gPiAKPiA+IAkJZGVzYyA9IGttYWxsb2ModG90YWxf c2cgKiBzaXplb2Yoc3RydWN0IHZyaW5nX2Rlc2MpLCBnZnApOwo+ID4gCQlpZiAoIWRlc2MpCj4g PiAJCQlyZXR1cm4gTlVMTDsKPiA+IAo+ID4gCQlmb3IgKGkgPSAwOyBpIDwgdG90YWxfc2c7IGkr KykKPiA+IAkJCWRlc2NbaV0ubmV4dCA9IGNwdV90b192aXJ0aW8xNihfdnEtPnZkZXYsIGkgKyAx KTsKPiA+IAo+ID4gCQlkYXRhID0gZGVzYzsKPiA+IAl9Cj4gPiAKPiA+IAlyZXR1cm4gZGF0YTsK PiA+IH0KPiA+IAo+ID4gSSB3b3VsZCBwcmVmZXIgdG8gaGF2ZSB0d28gc2ltcGxlciBoZWxwZXJz IChhbmQgdG8gdGhlIGNhbGxlcnMsCj4gPiBpdCdzIGFscmVhZHkgdmVyeSBjbGVhciBhYm91dCB3 aGljaCBvbmUgdGhleSBzaG91bGQgY2FsbCksIGkuZS4KPiA+IHRoZSBjdXJyZW50IGltcGxlbWVu dGF0aW9uOgo+ID4gCj4gPiBzdGF0aWMgc3RydWN0IHZyaW5nX3BhY2tlZF9kZXNjICphbGxvY19p bmRpcmVjdF9wYWNrZWQoc3RydWN0IHZpcnRxdWV1ZSAqX3ZxLAo+ID4gCQkJCQkJICAgICAgIHVu c2lnbmVkIGludCB0b3RhbF9zZywKPiA+IAkJCQkJCSAgICAgICBnZnBfdCBnZnApCj4gPiB7Cj4g PiAJc3RydWN0IHZyaW5nX3BhY2tlZF9kZXNjICpkZXNjOwo+ID4gCj4gPiAJLyoKPiA+IAkgKiBX ZSByZXF1aXJlIGxvd21lbSBtYXBwaW5ncyBmb3IgdGhlIGRlc2NyaXB0b3JzIGJlY2F1c2UKPiA+ IAkgKiBvdGhlcndpc2UgdmlydF90b19waHlzIHdpbGwgZ2l2ZSB1cyBib2d1cyBhZGRyZXNzZXMg aW4gdGhlCj4gPiAJICogdmlydHF1ZXVlLgo+ID4gCSAqLwo+ID4gCWdmcCAmPSB+X19HRlBfSElH SE1FTTsKPiA+IAo+ID4gCWRlc2MgPSBrbWFsbG9jKHRvdGFsX3NnICogc2l6ZW9mKHN0cnVjdCB2 cmluZ19wYWNrZWRfZGVzYyksIGdmcCk7Cj4gPiAKPiA+IAlyZXR1cm4gZGVzYzsKPiA+IH0KPiA+ IAo+ID4gc3RhdGljIHN0cnVjdCB2cmluZ19kZXNjICphbGxvY19pbmRpcmVjdF9zcGxpdChzdHJ1 Y3QgdmlydHF1ZXVlICpfdnEsCj4gPiAJCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgdG90YWxfc2cs Cj4gPiAJCQkJCSAgICAgICBnZnBfdCBnZnApCj4gPiB7Cj4gPiAJc3RydWN0IHZyaW5nX2Rlc2Mg KmRlc2M7Cj4gPiAJdW5zaWduZWQgaW50IGk7Cj4gPiAKPiA+IAkvKgo+ID4gCSAqIFdlIHJlcXVp cmUgbG93bWVtIG1hcHBpbmdzIGZvciB0aGUgZGVzY3JpcHRvcnMgYmVjYXVzZQo+ID4gCSAqIG90 aGVyd2lzZSB2aXJ0X3RvX3BoeXMgd2lsbCBnaXZlIHVzIGJvZ3VzIGFkZHJlc3NlcyBpbiB0aGUK PiA+IAkgKiB2aXJ0cXVldWUuCj4gPiAJICovCj4gPiAJZ2ZwICY9IH5fX0dGUF9ISUdITUVNOwo+ ID4gCj4gPiAJZGVzYyA9IGttYWxsb2ModG90YWxfc2cgKiBzaXplb2Yoc3RydWN0IHZyaW5nX2Rl c2MpLCBnZnApOwo+ID4gCWlmICghZGVzYykKPiA+IAkJcmV0dXJuIE5VTEw7Cj4gPiAKPiA+IAlm b3IgKGkgPSAwOyBpIDwgdG90YWxfc2c7IGkrKykKPiA+IAkJZGVzY1tpXS5uZXh0ID0gY3B1X3Rv X3ZpcnRpbzE2KF92cS0+dmRldiwgaSArIDEpOwo+ID4gCXJldHVybiBkZXNjOwo+ID4gfQo+IAo+ IFllYWgsIEkgbWlzcyB0aGF0IHNwbGl0IHZlcnNpb24gbmVlZHMgYSBkZXNjIGxpc3QuCj4gCj4g PiAKPiA+ID4gPiArCj4gPiA+ID4gKwlyZXR1cm4gZGVzYzsKPiA+ID4gPiArfQo+ID4gWy4uLl0K PiA+ID4gPiArc3RhdGljIGlubGluZSBpbnQgdmlydHF1ZXVlX2FkZF9wYWNrZWQoc3RydWN0IHZp cnRxdWV1ZSAqX3ZxLAo+ID4gPiA+ICsJCQkJICAgICAgIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dz W10sCj4gPiA+ID4gKwkJCQkgICAgICAgdW5zaWduZWQgaW50IHRvdGFsX3NnLAo+ID4gPiA+ICsJ CQkJICAgICAgIHVuc2lnbmVkIGludCBvdXRfc2dzLAo+ID4gPiA+ICsJCQkJICAgICAgIHVuc2ln bmVkIGludCBpbl9zZ3MsCj4gPiA+ID4gKwkJCQkgICAgICAgdm9pZCAqZGF0YSwKPiA+ID4gPiAr CQkJCSAgICAgICB2b2lkICpjdHgsCj4gPiA+ID4gKwkJCQkgICAgICAgZ2ZwX3QgZ2ZwKQo+ID4g PiA+ICt7Cj4gPiA+ID4gKwlzdHJ1Y3QgdnJpbmdfdmlydHF1ZXVlICp2cSA9IHRvX3Z2cShfdnEp Owo+ID4gPiA+ICsJc3RydWN0IHZyaW5nX3BhY2tlZF9kZXNjICpkZXNjOwo+ID4gPiA+ICsJc3Ry dWN0IHNjYXR0ZXJsaXN0ICpzZzsKPiA+ID4gPiArCXVuc2lnbmVkIGludCBpLCBuLCBkZXNjc191 c2VkLCB1bmluaXRpYWxpemVkX3ZhcihwcmV2KSwgZXJyX2lkeDsKPiA+ID4gPiArCV9fdmlydGlv MTYgdW5pbml0aWFsaXplZF92YXIoaGVhZF9mbGFncyksIGZsYWdzOwo+ID4gPiA+ICsJaW50IGhl YWQsIHdyYXBfY291bnRlcjsKPiA+ID4gPiArCWJvb2wgaW5kaXJlY3Q7Cj4gPiA+ID4gKwo+ID4g PiA+ICsJU1RBUlRfVVNFKHZxKTsKPiA+ID4gPiArCj4gPiA+ID4gKwlCVUdfT04oZGF0YSA9PSBO VUxMKTsKPiA+ID4gPiArCUJVR19PTihjdHggJiYgdnEtPmluZGlyZWN0KTsKPiA+ID4gPiArCj4g PiA+ID4gKwlpZiAodW5saWtlbHkodnEtPmJyb2tlbikpIHsKPiA+ID4gPiArCQlFTkRfVVNFKHZx KTsKPiA+ID4gPiArCQlyZXR1cm4gLUVJTzsKPiA+ID4gPiArCX0KPiA+ID4gPiArCj4gPiA+ID4g KyNpZmRlZiBERUJVRwo+ID4gPiA+ICsJewo+ID4gPiA+ICsJCWt0aW1lX3Qgbm93ID0ga3RpbWVf Z2V0KCk7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJCS8qIE5vIGtpY2sgb3IgZ2V0LCB3aXRoIC4xIHNl Y29uZCBiZXR3ZWVuPyAgV2Fybi4gKi8KPiA+ID4gPiArCQlpZiAodnEtPmxhc3RfYWRkX3RpbWVf dmFsaWQpCj4gPiA+ID4gKwkJCVdBUk5fT04oa3RpbWVfdG9fbXMoa3RpbWVfc3ViKG5vdywgdnEt Pmxhc3RfYWRkX3RpbWUpKQo+ID4gPiA+ICsJCQkJCSAgICA+IDEwMCk7Cj4gPiA+ID4gKwkJdnEt Pmxhc3RfYWRkX3RpbWUgPSBub3c7Cj4gPiA+ID4gKwkJdnEtPmxhc3RfYWRkX3RpbWVfdmFsaWQg PSB0cnVlOwo+ID4gPiA+ICsJfQo+ID4gPiA+ICsjZW5kaWYKPiA+ID4gPiArCj4gPiA+ID4gKwlC VUdfT04odG90YWxfc2cgPT0gMCk7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJaGVhZCA9IHZxLT5uZXh0 X2F2YWlsX2lkeDsKPiA+ID4gPiArCXdyYXBfY291bnRlciA9IHZxLT53cmFwX2NvdW50ZXI7Cj4g PiA+ID4gKwo+ID4gPiA+ICsJLyogSWYgdGhlIGhvc3Qgc3VwcG9ydHMgaW5kaXJlY3QgZGVzY3Jp cHRvciB0YWJsZXMsIGFuZCB3ZSBoYXZlIG11bHRpcGxlCj4gPiA+ID4gKwkgKiBidWZmZXJzLCB0 aGVuIGdvIGluZGlyZWN0LiBGSVhNRTogdHVuZSB0aGlzIHRocmVzaG9sZCAqLwo+ID4gPiA+ICsJ aWYgKHZxLT5pbmRpcmVjdCAmJiB0b3RhbF9zZyA+IDEgJiYgdnEtPnZxLm51bV9mcmVlKQo+ID4g PiBMZXQncyBpbnRyb2R1Y2UgYSBoZWxwZXIgbGlrZSB2aXJ0cXVldWVfbmVlZF9pbmRpcmVjdCgp IHRvIGF2b2lkIGR1cGxpY2F0aW5nCj4gPiA+IGNvZGVzIGFuZCBGSVhNRS4KPiA+IE9rYXkuCj4g PiAKPiA+ID4gPiArCQlkZXNjID0gYWxsb2NfaW5kaXJlY3RfcGFja2VkKF92cSwgdG90YWxfc2cs IGdmcCk7Cj4gPiA+ID4gKwllbHNlIHsKPiA+ID4gPiArCQlkZXNjID0gTlVMTDsKPiA+ID4gPiAr CQlXQVJOX09OX09OQ0UodG90YWxfc2cgPiB2cS0+dnJpbmdfcGFja2VkLm51bSAmJiAhdnEtPmlu ZGlyZWN0KTsKPiA+ID4gPiArCX0KPiA+ID4gPiArCj4gPiA+ID4gKwlpZiAoZGVzYykgewo+ID4g PiA+ICsJCS8qIFVzZSBhIHNpbmdsZSBidWZmZXIgd2hpY2ggZG9lc24ndCBjb250aW51ZSAqLwo+ ID4gPiA+ICsJCWluZGlyZWN0ID0gdHJ1ZTsKPiA+ID4gPiArCQkvKiBTZXQgdXAgcmVzdCB0byB1 c2UgdGhpcyBpbmRpcmVjdCB0YWJsZS4gKi8KPiA+ID4gPiArCQlpID0gMDsKPiA+ID4gPiArCQlk ZXNjc191c2VkID0gMTsKPiA+ID4gPiArCX0gZWxzZSB7Cj4gPiA+ID4gKwkJaW5kaXJlY3QgPSBm YWxzZTsKPiA+ID4gPiArCQlkZXNjID0gdnEtPnZyaW5nX3BhY2tlZC5kZXNjOwo+ID4gPiA+ICsJ CWkgPSBoZWFkOwo+ID4gPiA+ICsJCWRlc2NzX3VzZWQgPSB0b3RhbF9zZzsKPiA+ID4gPiArCX0K PiA+ID4gPiArCj4gPiA+ID4gKwlpZiAodnEtPnZxLm51bV9mcmVlIDwgZGVzY3NfdXNlZCkgewo+ ID4gPiA+ICsJCXByX2RlYnVnKCJDYW4ndCBhZGQgYnVmIGxlbiAlaSAtIGF2YWlsID0gJWlcbiIs Cj4gPiA+ID4gKwkJCSBkZXNjc191c2VkLCB2cS0+dnEubnVtX2ZyZWUpOwo+ID4gPiA+ICsJCS8q IEZJWE1FOiBmb3IgaGlzdG9yaWNhbCByZWFzb25zLCB3ZSBmb3JjZSBhIG5vdGlmeSBoZXJlIGlm Cj4gPiA+ID4gKwkJICogdGhlcmUgYXJlIG91dGdvaW5nIHBhcnRzIHRvIHRoZSBidWZmZXIuICBQ cmVzdW1hYmx5IHRoZQo+ID4gPiA+ICsJCSAqIGhvc3Qgc2hvdWxkIHNlcnZpY2UgdGhlIHJpbmcg QVNBUC4gKi8KPiA+ID4gPiArCQlpZiAob3V0X3NncykKPiA+ID4gPiArCQkJdnEtPm5vdGlmeSgm dnEtPnZxKTsKPiA+ID4gPiArCQlpZiAoaW5kaXJlY3QpCj4gPiA+ID4gKwkJCWtmcmVlKGRlc2Mp Owo+ID4gPiA+ICsJCUVORF9VU0UodnEpOwo+ID4gPiA+ICsJCXJldHVybiAtRU5PU1BDOwo+ID4g PiA+ICsJfQo+ID4gPiA+ICsKPiA+ID4gPiArCWZvciAobiA9IDA7IG4gPCBvdXRfc2dzICsgaW5f c2dzOyBuKyspIHsKPiA+ID4gPiArCQlmb3IgKHNnID0gc2dzW25dOyBzZzsgc2cgPSBzZ19uZXh0 KHNnKSkgewo+ID4gPiA+ICsJCQlkbWFfYWRkcl90IGFkZHIgPSB2cmluZ19tYXBfb25lX3NnKHZx LCBzZywgbiA8IG91dF9zZ3MgPwo+ID4gPiA+ICsJCQkJCQlETUFfVE9fREVWSUNFIDogRE1BX0ZS T01fREVWSUNFKTsKPiA+ID4gPiArCQkJaWYgKHZyaW5nX21hcHBpbmdfZXJyb3IodnEsIGFkZHIp KQo+ID4gPiA+ICsJCQkJZ290byB1bm1hcF9yZWxlYXNlOwo+ID4gPiA+ICsKPiA+ID4gPiArCQkJ ZmxhZ3MgPSBjcHVfdG9fdmlydGlvMTYoX3ZxLT52ZGV2LCBWUklOR19ERVNDX0ZfTkVYVCB8Cj4g PiA+ID4gKwkJCQkJKG4gPCBvdXRfc2dzID8gMCA6IFZSSU5HX0RFU0NfRl9XUklURSkgfAo+ID4g PiA+ICsJCQkJCVZSSU5HX0RFU0NfRl9BVkFJTCh2cS0+d3JhcF9jb3VudGVyKSB8Cj4gPiA+ID4g KwkJCQkJVlJJTkdfREVTQ19GX1VTRUQoIXZxLT53cmFwX2NvdW50ZXIpKTsKPiA+ID4gPiArCQkJ aWYgKCFpbmRpcmVjdCAmJiBpID09IGhlYWQpCj4gPiA+ID4gKwkJCQloZWFkX2ZsYWdzID0gZmxh Z3M7Cj4gPiA+ID4gKwkJCWVsc2UKPiA+ID4gPiArCQkJCWRlc2NbaV0uZmxhZ3MgPSBmbGFnczsK PiA+ID4gPiArCj4gPiA+ID4gKwkJCWRlc2NbaV0uYWRkciA9IGNwdV90b192aXJ0aW82NChfdnEt PnZkZXYsIGFkZHIpOwo+ID4gPiA+ICsJCQlkZXNjW2ldLmxlbiA9IGNwdV90b192aXJ0aW8zMihf dnEtPnZkZXYsIHNnLT5sZW5ndGgpOwo+ID4gPiA+ICsJCQlkZXNjW2ldLmlkID0gY3B1X3RvX3Zp cnRpbzMyKF92cS0+dmRldiwgaGVhZCk7Cj4gPiA+IFNpbWlsYXIgdG8gVjEsIHdlIG9ubHkgbmVl ZCB0aGlzIGZvciB0aGUgbGFzdCBkZXNjcmlwdG9yLgo+ID4gT2theSwgd2lsbCBqdXN0IHNldCBp dCBmb3IgdGhlIGxhc3QgZGVzYy4KPiA+IAo+ID4gPiA+ICsJCQlwcmV2ID0gaTsKPiA+ID4gSXQg bG9va3MgdG8gbWUgdGhlcmUncyBubyBuZWVkIHRvIHRyYWNrIHByZXYgaW5zaWRlIHRoZSBsb29w IGhlcmUuCj4gPiA+IAo+ID4gPiA+ICsJCQlpKys7Cj4gPiA+ID4gKwkJCWlmICghaW5kaXJlY3Qg JiYgaSA+PSB2cS0+dnJpbmdfcGFja2VkLm51bSkgewo+ID4gPiA+ICsJCQkJaSA9IDA7Cj4gPiA+ ID4gKwkJCQl2cS0+d3JhcF9jb3VudGVyIF49IDE7Cj4gPiA+ID4gKwkJCX0KPiA+ID4gPiArCQl9 Cj4gPiA+ID4gKwl9Cj4gPiA+ID4gKwkvKiBMYXN0IG9uZSBkb2Vzbid0IGNvbnRpbnVlLiAqLwo+ ID4gPiA+ICsJaWYgKHRvdGFsX3NnID09IDEpCj4gPiA+ID4gKwkJaGVhZF9mbGFncyAmPSBjcHVf dG9fdmlydGlvMTYoX3ZxLT52ZGV2LCB+VlJJTkdfREVTQ19GX05FWFQpOwo+ID4gPiA+ICsJZWxz ZQo+ID4gPiA+ICsJCWRlc2NbcHJldl0uZmxhZ3MgJj0gY3B1X3RvX3ZpcnRpbzE2KF92cS0+dmRl diwgflZSSU5HX0RFU0NfRl9ORVhUKTsKPiA+ID4gVGhlIG9ubHkgY2FzZSB3aGVuIHByZXYgIT0g aSAtIDEgaXMgaSA9PSAwLCB3ZSBjYW4gYWRkIGEgaWYgaGVyZS4KPiA+IEl0J3MganVzdCBhIG1p cnJvciBvZiB0aGUgZXhpc3RpbmcgaW1wbGVtZW50YXRpb24gaW4gc3BsaXQgcmluZy4KPiA+IEl0 IHNlZW1zIHRoYXQgc3BsaXQgcmluZyBpbXBsZW1lbnRhdGlvbiBuZWVkcyB0aGlzIGp1c3QgYmVj YXVzZQo+ID4gaXQncyBtdWNoIGhhcmRlciBmb3IgaXQgdG8gZmluZCB0aGUgcHJldiwgd2hpY2gg aXMgbm90IHRydWUgZm9yCj4gPiBwYWNrZWQgcmluZy4gU28gSSdsbCB0YWtlIHlvdXIgc3VnZ2Vz dGlvbi4gVGhhbmtzIQo+ID4gCj4gPiBbLi4uXQo+ID4gPiA+ICtzdGF0aWMgYm9vbCB2aXJ0cXVl dWVfa2lja19wcmVwYXJlX3BhY2tlZChzdHJ1Y3QgdmlydHF1ZXVlICpfdnEpCj4gPiA+ID4gK3sK PiA+ID4gPiArCXN0cnVjdCB2cmluZ192aXJ0cXVldWUgKnZxID0gdG9fdnZxKF92cSk7Cj4gPiA+ ID4gKwl1MTYgbmV3LCBvbGQsIG9mZl93cmFwOwo+ID4gPiA+ICsJYm9vbCBuZWVkc19raWNrOwo+ ID4gPiA+ICsKPiA+ID4gPiArCVNUQVJUX1VTRSh2cSk7Cj4gPiA+ID4gKwkvKiBXZSBuZWVkIHRv IGV4cG9zZSB0aGUgbmV3IGZsYWdzIHZhbHVlIGJlZm9yZSBjaGVja2luZyBub3RpZmljYXRpb24K PiA+ID4gPiArCSAqIHN1cHByZXNzaW9ucy4gKi8KPiA+ID4gPiArCXZpcnRpb19tYih2cS0+d2Vh a19iYXJyaWVycyk7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJb2xkID0gdnEtPm5leHRfYXZhaWxfaWR4 IC0gdnEtPm51bV9hZGRlZDsKPiA+ID4gPiArCW5ldyA9IHZxLT5uZXh0X2F2YWlsX2lkeDsKPiA+ ID4gPiArCXZxLT5udW1fYWRkZWQgPSAwOwo+ID4gPiA+ICsKPiA+ID4gPiArI2lmZGVmIERFQlVH Cj4gPiA+ID4gKwlpZiAodnEtPmxhc3RfYWRkX3RpbWVfdmFsaWQpIHsKPiA+ID4gPiArCQlXQVJO X09OKGt0aW1lX3RvX21zKGt0aW1lX3N1YihrdGltZV9nZXQoKSwKPiA+ID4gPiArCQkJCQkgICAg ICB2cS0+bGFzdF9hZGRfdGltZSkpID4gMTAwKTsKPiA+ID4gPiArCX0KPiA+ID4gPiArCXZxLT5s YXN0X2FkZF90aW1lX3ZhbGlkID0gZmFsc2U7Cj4gPiA+ID4gKyNlbmRpZgo+ID4gPiA+ICsKPiA+ ID4gPiArCW9mZl93cmFwID0gdmlydGlvMTZfdG9fY3B1KF92cS0+dmRldiwgdnEtPnZyaW5nX3Bh Y2tlZC5kZXZpY2UtPm9mZl93cmFwKTsKPiA+ID4gPiArCj4gPiA+ID4gKwlpZiAodnEtPmV2ZW50 KSB7Cj4gPiA+IEl0IGxvb2tzIHRvIG1lIHdlIHNob3VsZCBleGFtaW5lIFJJTkdfRVZFTlRfRkxB R1NfREVTQyBpbiBkZXNjX2V2ZW50X2ZsYWdzCj4gPiA+IGluc3RlYWQgb2YgdnEtPmV2ZW50IGhl cmUuIFNwZWMgZG9lcyBub3QgZm9yY2VzIHRvIHVzZSBldmVuZl9vZmYgYW5kCj4gPiA+IGV2ZW50 X3dyYXAgaWYgZXZlbnQgaW5kZXggaXMgZW5hYmxlZC4KPiA+ID4gCj4gPiA+ID4gKwkJLy8gRklY TUU6IGZpeCB0aGlzIQo+ID4gPiA+ICsJCW5lZWRzX2tpY2sgPSAoKG9mZl93cmFwID4+IDE1KSA9 PSB2cS0+d3JhcF9jb3VudGVyKSAmJgo+ID4gPiA+ICsJCQkgICAgIHZyaW5nX25lZWRfZXZlbnQo b2ZmX3dyYXAgJiB+KDE8PDE1KSwgbmV3LCBvbGQpOwo+ID4gPiBXaHkgbmVlZCBhICYgaGVyZT8K PiA+IEJlY2F1c2Ugd3JhcF9jb3VudGVyICh0aGUgbW9zdCBzaWduaWZpY2FudCBiaXQgaW4gb2Zm X3dyYXApCj4gPiBpc24ndCBwYXJ0IG9mIHRoZSBpbmRleC4KPiA+IAo+ID4gPiA+ICsJfSBlbHNl IHsKPiA+ID4gTmVlZCBhIHNtcF9ybWIoKSB0byBtYWtlIHN1cmUgZGVzY19ldmVudF9mbGFncyB3 YXMgY2hlY2tlZCBiZWZvcmUgZmxhZ3MuCj4gPiBJIGRvbid0IGdldCB5b3VyIHBvaW50LCBpZiBt eSB1bmRlcnN0YW5kaW5nIGlzIGNvcnJlY3QsCj4gPiBkZXNjX2V2ZW50X2ZsYWdzIGlzIHZxLT52 cmluZ19wYWNrZWQuZGV2aWNlLT5mbGFncy4gU28KPiA+IHdoYXQncyB0aGUgImZsYWdzIj8KPiAK PiBTb3JyeSwgSSBtZWFuIHdlIG5lZWQgY2hlY2sgZGV2aWNlLmZsYWdzIGJlZm9yZSBvZmZfd2Fy cC4gU28gaXQgbmVlZHMgYW4KPiBzbXBfcm1iKCkgaW4gdGhlIG1pZGRsZS4KCkl0J3MgYmVzdCB0 byBqdXN0IHJlYWQgYWxsIGZsYWdzIGF0b21pY2FsbHkgYXMgdTMyLgoKPiBJdCBsb29rcyB0byBt ZSB0aGVyZSdzIG5vIGd1YXJhbnRlZSB0aGF0Cj4gVlJJTkdfRVZFTlRfRl9ERVNDIGlzIHNldCBp ZiBldmVudCBpbmRleCBpcyBzdXBwb3J0ZWQuCj4gCj4gPiAKPiA+ID4gPiArCQluZWVkc19raWNr ID0gKHZxLT52cmluZ19wYWNrZWQuZGV2aWNlLT5mbGFncyAhPQo+ID4gPiA+ICsJCQkgICAgICBj cHVfdG9fdmlydGlvMTYoX3ZxLT52ZGV2LCBWUklOR19FVkVOVF9GX0RJU0FCTEUpKTsKPiA+ID4g PiArCX0KPiA+ID4gPiArCUVORF9VU0UodnEpOwo+ID4gPiA+ICsJcmV0dXJuIG5lZWRzX2tpY2s7 Cj4gPiA+ID4gK30KPiA+IFsuLi5dCj4gPiA+ID4gK3N0YXRpYyBpbnQgZGV0YWNoX2J1Zl9wYWNr ZWQoc3RydWN0IHZyaW5nX3ZpcnRxdWV1ZSAqdnEsIHVuc2lnbmVkIGludCBoZWFkLAo+ID4gPiA+ ICsJCQkgICAgICB2b2lkICoqY3R4KQo+ID4gPiA+ICt7Cj4gPiA+ID4gKwlzdHJ1Y3QgdnJpbmdf cGFja2VkX2Rlc2MgKmRlc2M7Cj4gPiA+ID4gKwl1bnNpZ25lZCBpbnQgaSwgajsKPiA+ID4gPiAr Cj4gPiA+ID4gKwkvKiBDbGVhciBkYXRhIHB0ci4gKi8KPiA+ID4gPiArCXZxLT5kZXNjX3N0YXRl W2hlYWRdLmRhdGEgPSBOVUxMOwo+ID4gPiA+ICsKPiA+ID4gPiArCWkgPSBoZWFkOwo+ID4gPiA+ ICsKPiA+ID4gPiArCWZvciAoaiA9IDA7IGogPCB2cS0+ZGVzY19zdGF0ZVtoZWFkXS5udW07IGor Kykgewo+ID4gPiA+ICsJCWRlc2MgPSAmdnEtPnZyaW5nX3BhY2tlZC5kZXNjW2ldOwo+ID4gPiA+ ICsJCXZyaW5nX3VubWFwX29uZV9wYWNrZWQodnEsIGRlc2MpOwo+ID4gPiA+ICsJCWRlc2MtPmZs YWdzID0gMHgwOwo+ID4gPiBMb29rcyBsaWtlIHRoaXMgaXMgdW5uZWNlc3NhcnkuCj4gPiBJdCdz IHNhZmVyIHRvIHplcm8gaXQuIElmIHdlIGRvbid0IHplcm8gaXQsIGFmdGVyIHdlCj4gPiBjYWxs IHZpcnRxdWV1ZV9kZXRhY2hfdW51c2VkX2J1Zl9wYWNrZWQoKSB3aGljaCBjYWxscwo+ID4gdGhp cyBmdW5jdGlvbiwgdGhlIGRlc2MgaXMgc3RpbGwgYXZhaWxhYmxlIHRvIHRoZQo+ID4gZGV2aWNl Lgo+IAo+IFdlbGwgZGV0YWNoX3VudXNlZF9idWZfcGFja2VkKCkgc2hvdWxkIGJlIGNhbGxlZCBh ZnRlciBkZXZpY2UgaXMgc3RvcHBlZCwKPiBvdGhlcndpc2UgZXZlbiBpZiB5b3UgdHJ5IHRvIGNs ZWFyLCB0aGVyZSB3aWxsIHN0aWxsIGJlIGEgd2luZG93IHRoYXQgZGV2aWNlCj4gbWF5IHVzZSBp dC4KPiAKPiA+IAo+ID4gPiA+ICsJCWkrKzsKPiA+ID4gPiArCQlpZiAoaSA+PSB2cS0+dnJpbmdf cGFja2VkLm51bSkKPiA+ID4gPiArCQkJaSA9IDA7Cj4gPiA+ID4gKwl9Cj4gPiBbLi4uXQo+ID4g PiA+ICtzdGF0aWMgdW5zaWduZWQgdmlydHF1ZXVlX2VuYWJsZV9jYl9wcmVwYXJlX3BhY2tlZChz dHJ1Y3QgdmlydHF1ZXVlICpfdnEpCj4gPiA+ID4gK3sKPiA+ID4gPiArCXN0cnVjdCB2cmluZ192 aXJ0cXVldWUgKnZxID0gdG9fdnZxKF92cSk7Cj4gPiA+ID4gKwl1MTYgbGFzdF91c2VkX2lkeCwg d3JhcF9jb3VudGVyLCBvZmZfd3JhcDsKPiA+ID4gPiArCj4gPiA+ID4gKwlTVEFSVF9VU0UodnEp Owo+ID4gPiA+ICsKPiA+ID4gPiArCWxhc3RfdXNlZF9pZHggPSB2cS0+bGFzdF91c2VkX2lkeDsK PiA+ID4gPiArCXdyYXBfY291bnRlciA9IHZxLT53cmFwX2NvdW50ZXI7Cj4gPiA+ID4gKwo+ID4g PiA+ICsJaWYgKGxhc3RfdXNlZF9pZHggPiB2cS0+bmV4dF9hdmFpbF9pZHgpCj4gPiA+ID4gKwkJ d3JhcF9jb3VudGVyIF49IDE7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJb2ZmX3dyYXAgPSBsYXN0X3Vz ZWRfaWR4IHwgKHdyYXBfY291bnRlciA8PCAxNSk7Cj4gPiA+ID4gKwo+ID4gPiA+ICsJLyogV2Ug b3B0aW1pc3RpY2FsbHkgdHVybiBiYWNrIG9uIGludGVycnVwdHMsIHRoZW4gY2hlY2sgaWYgdGhl cmUgd2FzCj4gPiA+ID4gKwkgKiBtb3JlIHRvIGRvLiAqLwo+ID4gPiA+ICsJLyogRGVwZW5kaW5n IG9uIHRoZSBWSVJUSU9fUklOR19GX0VWRU5UX0lEWCBmZWF0dXJlLCB3ZSBuZWVkIHRvCj4gPiA+ ID4gKwkgKiBlaXRoZXIgY2xlYXIgdGhlIGZsYWdzIGJpdCBvciBwb2ludCB0aGUgZXZlbnQgaW5k ZXggYXQgdGhlIG5leHQKPiA+ID4gPiArCSAqIGVudHJ5LiBBbHdheXMgZG8gYm90aCB0byBrZWVw IGNvZGUgc2ltcGxlLiAqLwo+ID4gPiA+ICsJaWYgKHZxLT5ldmVudF9mbGFnc19zaGFkb3cgPT0g VlJJTkdfRVZFTlRfRl9ESVNBQkxFKSB7Cj4gPiA+ID4gKwkJdnEtPmV2ZW50X2ZsYWdzX3NoYWRv dyA9IHZxLT5ldmVudCA/IFZSSU5HX0VWRU5UX0ZfREVTQzoKPiA+ID4gPiArCQkJCQkJICAgICBW UklOR19FVkVOVF9GX0VOQUJMRTsKPiA+ID4gPiArCQl2cS0+dnJpbmdfcGFja2VkLmRyaXZlci0+ ZmxhZ3MgPSBjcHVfdG9fdmlydGlvMTYoX3ZxLT52ZGV2LAo+ID4gPiA+ICsJCQkJCQkJdnEtPmV2 ZW50X2ZsYWdzX3NoYWRvdyk7Cj4gPiA+ID4gKwl9Cj4gPiA+IEEgc21wX3dtYigpIGlzIG1pc3Nl ZCBoZXJlPwo+ID4gPiAKPiA+ID4gPiArCXZxLT52cmluZ19wYWNrZWQuZHJpdmVyLT5vZmZfd3Jh cCA9IGNwdV90b192aXJ0aW8xNihfdnEtPnZkZXYsIG9mZl93cmFwKTsKPiA+ID4gQW5kIGFjY29y ZGluZyB0byB0aGUgc3BlYywgaXQgbG9va3MgdG8gbWUgd3JpdGUgYSBWUklOR19FVkVOVF9GX0VO QUJMRSBpcwo+ID4gPiBzdWZmaWNpZW50IGhlcmUuCj4gPiBJIGRpZG4ndCB0aGluayBtdWNoIHdo ZW4gaW1wbGVtZW50aW5nIHRoZSBldmVudCBzdXBwcmVzc2lvbgo+ID4gZm9yIHBhY2tlZCByaW5n IHByZXZpb3VzbHkuIEFmdGVyIEkgc2F3IHlvdXIgY29tbWVudHMsIEkgZm91bmQKPiA+IHNvbWV0 aGluZyBuZXcuIEluZGVlZCwgdW5saWtlIHRoZSBzcGxpdCByaW5nLCBmb3IgdGhlIHBhY2tlZAo+ ID4gcmluZywgc3BlYyBkb2Vzbid0IHNheSB3ZSBtdXN0IHVzZSBWUklOR19FVkVOVF9GX0RFU0Mg d2hlbgo+ID4gRVZFTlRfSURYIGlzIG5lZ290aWF0ZWQuIFNvIGRvIHlvdSB0aGluayBiZWxvdyB0 aG91Z2h0IGlzCj4gPiByaWdodCBvciBtYWtlcyBzZW5zZT8KPiA+IAo+ID4gLSBGb3IgdmlydHF1 ZXVlX2VuYWJsZV9jYl9wcmVwYXJlKCksIHdlIGp1c3QgbmVlZCB0byBlbmFibGUKPiA+ICAgIHRo ZSByaW5nIGJ5IHNldHRpbmcgZmxhZ3MgdG8gVlJJTkdfRVZFTlRfRl9FTkFCTEUgaW4gYW55Cj4g PiAgICBjYXNlLgo+ID4gCj4gPiAtIFdlIHdpbGwgdHJ5IHRvIHVzZSBWUklOR19FVkVOVF9GX0RF U0MgKGlmIEVWRU5UX0lEWCBpcwo+ID4gICAgbmVnb3RpYXRlZCkgb25seSB3aGVuIHdlIHdhbnQg dG8gZGVsYXkgdGhlIGludGVycnVwdHMKPiA+ICAgIHZpcnRxdWV1ZV9lbmFibGVfY2JfZGVsYXll ZCgpLgo+IAo+IFRoaXMgbG9va3MgZ29vZCB0byBtZS4KCkkgc3VzcGVjdCB0aGlzIHdpbGwgbGVh ZCB0byBleHRyYSBpbnRlcnJ1cHRzIGlmIGhvc3QgaXMgZmFzdC4KU28gSSB0aGluayBmb3Igbm93 IHdlIHNob3VsZCBhbHdheXMgdXNlIFZSSU5HX0VWRU5UX0ZfREVTQwppZiBFVkVOVF9JRFggaXMg bmVnb3RpYXRlZC4KClZSSU5HX0VWRU5UX0ZfRElTQUJMRSBtYWtlcyBtb3JlIHNlbnNlIHRvIG1l LgoKCj4gPiAKPiA+ID4gPiArCUVORF9VU0UodnEpOwo+ID4gPiA+ICsJcmV0dXJuIGxhc3RfdXNl ZF9pZHg7Cj4gPiA+ID4gK30KPiA+ID4gPiArCj4gPiBbLi4uXQo+ID4gPiA+IEBAIC0xMTU3LDE0 ICsxODUyLDE4IEBAIHZvaWQgdnJpbmdfdHJhbnNwb3J0X2ZlYXR1cmVzKHN0cnVjdCB2aXJ0aW9f ZGV2aWNlICp2ZGV2KQo+ID4gPiA+ICAgIAlmb3IgKGkgPSBWSVJUSU9fVFJBTlNQT1JUX0ZfU1RB UlQ7IGkgPCBWSVJUSU9fVFJBTlNQT1JUX0ZfRU5EOyBpKyspIHsKPiA+ID4gPiAgICAJCXN3aXRj aCAoaSkgewo+ID4gPiA+IC0JCWNhc2UgVklSVElPX1JJTkdfRl9JTkRJUkVDVF9ERVNDOgo+ID4g PiA+ICsjaWYgMAo+ID4gPiA+ICsJCWNhc2UgVklSVElPX1JJTkdfRl9JTkRJUkVDVF9ERVNDOiAv LyBGSVhNRSBub3QgdGVzdGVkIHlldC4KPiA+ID4gPiAgICAJCQlicmVhazsKPiA+ID4gPiAtCQlj YXNlIFZJUlRJT19SSU5HX0ZfRVZFTlRfSURYOgo+ID4gPiA+ICsJCWNhc2UgVklSVElPX1JJTkdf Rl9FVkVOVF9JRFg6IC8vIEZJWE1FIHByb2JhYmx5IG5vdCB3b3JrLgo+ID4gPiA+ICAgIAkJCWJy ZWFrOwo+ID4gPiA+ICsjZW5kaWYKPiA+ID4gSXQgd291bGQgYmUgYmV0dGVyIGlmIHlvdSBjYW4g c3BsaXQgRVZFTlRfSURYIGFuZCBJTkRJUkVDVF9ERVNDIGludG8KPiA+ID4gc2VwYXJhdGUgcGF0 Y2hlcyB0b28uCj4gPiBTdXJlLiBXaWxsIGRvIGl0IGluIHRoZSBuZXh0IHZlcnNpb24uCj4gPiAK PiA+IFRoYW5rcyBmb3IgdGhlIHJldmlldyEKPiAKPiBUaGFua3MuCj4gCj4gPiA+IFRoYW5rcwo+ ID4gPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmly dHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5k YXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL3ZpcnR1YWxpemF0aW9u From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752145AbeDQCRn (ORCPT ); Mon, 16 Apr 2018 22:17:43 -0400 Received: from mx3-rdu2.redhat.com ([66.187.233.73]:59118 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751172AbeDQCRm (ORCPT ); Mon, 16 Apr 2018 22:17:42 -0400 Date: Tue, 17 Apr 2018 05:17:41 +0300 From: "Michael S. Tsirkin" To: Jason Wang Cc: Tiwei Bie , wexu@redhat.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, jfreimann@redhat.com Subject: Re: [RFC v2] virtio: support packed ring Message-ID: <20180417051343-mutt-send-email-mst@kernel.org> References: <20180401141216.8969-1-tiwei.bie@intel.com> <20180413071529.f4esh654dakodf4f@debian> <8dee7d62-ac0b-54ba-6bec-4bc4a6fb34e9@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <8dee7d62-ac0b-54ba-6bec-4bc4a6fb34e9@redhat.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Apr 17, 2018 at 10:11:58AM +0800, Jason Wang wrote: > > > On 2018年04月13日 15:15, Tiwei Bie wrote: > > On Fri, Apr 13, 2018 at 12:30:24PM +0800, Jason Wang wrote: > > > On 2018年04月01日 22:12, Tiwei Bie wrote: > > > > Hello everyone, > > > > > > > > This RFC implements packed ring support for virtio driver. > > > > > > > > The code was tested with DPDK vhost (testpmd/vhost-PMD) implemented > > > > by Jens at http://dpdk.org/ml/archives/dev/2018-January/089417.html > > > > Minor changes are needed for the vhost code, e.g. to kick the guest. > > > > > > > > TODO: > > > > - Refinements and bug fixes; > > > > - Split into small patches; > > > > - Test indirect descriptor support; > > > > - Test/fix event suppression support; > > > > - Test devices other than net; > > > > > > > > RFC v1 -> RFC v2: > > > > - Add indirect descriptor support - compile test only; > > > > - Add event suppression supprt - compile test only; > > > > - Move vring_packed_init() out of uapi (Jason, MST); > > > > - Merge two loops into one in virtqueue_add_packed() (Jason); > > > > - Split vring_unmap_one() for packed ring and split ring (Jason); > > > > - Avoid using '%' operator (Jason); > > > > - Rename free_head -> next_avail_idx (Jason); > > > > - Add comments for virtio_wmb() in virtqueue_add_packed() (Jason); > > > > - Some other refinements and bug fixes; > > > > > > > > Thanks! > > > > > > > > Signed-off-by: Tiwei Bie > > > > --- > > > > drivers/virtio/virtio_ring.c | 1094 +++++++++++++++++++++++++++++------- > > > > include/linux/virtio_ring.h | 8 +- > > > > include/uapi/linux/virtio_config.h | 12 +- > > > > include/uapi/linux/virtio_ring.h | 61 ++ > > > > 4 files changed, 980 insertions(+), 195 deletions(-) > > [...] > > > > +static struct vring_packed_desc *alloc_indirect_packed(struct virtqueue *_vq, > > > > + unsigned int total_sg, > > > > + gfp_t gfp) > > > > +{ > > > > + struct vring_packed_desc *desc; > > > > + > > > > + /* > > > > + * We require lowmem mappings for the descriptors because > > > > + * otherwise virt_to_phys will give us bogus addresses in the > > > > + * virtqueue. > > > > + */ > > > > + gfp &= ~__GFP_HIGHMEM; > > > > + > > > > + desc = kmalloc(total_sg * sizeof(struct vring_packed_desc), gfp); > > > Can we simply check vq->packed here to avoid duplicating helpers? > > Then it would be something like this: > > > > static void *alloc_indirect(struct virtqueue *_vq, unsigned int total_sg, > > gfp_t gfp) > > { > > struct vring_virtqueue *vq = to_vvq(_vq); > > void *data; > > > > /* > > * We require lowmem mappings for the descriptors because > > * otherwise virt_to_phys will give us bogus addresses in the > > * virtqueue. > > */ > > gfp &= ~__GFP_HIGHMEM; > > > > if (vq->packed) { > > data = kmalloc(total_sg * sizeof(struct vring_packed_desc), > > gfp); > > if (!data) > > return NULL; > > } else { > > struct vring_desc *desc; > > unsigned int i; > > > > desc = kmalloc(total_sg * sizeof(struct vring_desc), gfp); > > if (!desc) > > return NULL; > > > > for (i = 0; i < total_sg; i++) > > desc[i].next = cpu_to_virtio16(_vq->vdev, i + 1); > > > > data = desc; > > } > > > > return data; > > } > > > > I would prefer to have two simpler helpers (and to the callers, > > it's already very clear about which one they should call), i.e. > > the current implementation: > > > > static struct vring_packed_desc *alloc_indirect_packed(struct virtqueue *_vq, > > unsigned int total_sg, > > gfp_t gfp) > > { > > struct vring_packed_desc *desc; > > > > /* > > * We require lowmem mappings for the descriptors because > > * otherwise virt_to_phys will give us bogus addresses in the > > * virtqueue. > > */ > > gfp &= ~__GFP_HIGHMEM; > > > > desc = kmalloc(total_sg * sizeof(struct vring_packed_desc), gfp); > > > > return desc; > > } > > > > static struct vring_desc *alloc_indirect_split(struct virtqueue *_vq, > > unsigned int total_sg, > > gfp_t gfp) > > { > > struct vring_desc *desc; > > unsigned int i; > > > > /* > > * We require lowmem mappings for the descriptors because > > * otherwise virt_to_phys will give us bogus addresses in the > > * virtqueue. > > */ > > gfp &= ~__GFP_HIGHMEM; > > > > desc = kmalloc(total_sg * sizeof(struct vring_desc), gfp); > > if (!desc) > > return NULL; > > > > for (i = 0; i < total_sg; i++) > > desc[i].next = cpu_to_virtio16(_vq->vdev, i + 1); > > return desc; > > } > > Yeah, I miss that split version needs a desc list. > > > > > > > + > > > > + return desc; > > > > +} > > [...] > > > > +static inline int virtqueue_add_packed(struct virtqueue *_vq, > > > > + struct scatterlist *sgs[], > > > > + unsigned int total_sg, > > > > + unsigned int out_sgs, > > > > + unsigned int in_sgs, > > > > + void *data, > > > > + void *ctx, > > > > + gfp_t gfp) > > > > +{ > > > > + struct vring_virtqueue *vq = to_vvq(_vq); > > > > + struct vring_packed_desc *desc; > > > > + struct scatterlist *sg; > > > > + unsigned int i, n, descs_used, uninitialized_var(prev), err_idx; > > > > + __virtio16 uninitialized_var(head_flags), flags; > > > > + int head, wrap_counter; > > > > + bool indirect; > > > > + > > > > + START_USE(vq); > > > > + > > > > + BUG_ON(data == NULL); > > > > + BUG_ON(ctx && vq->indirect); > > > > + > > > > + if (unlikely(vq->broken)) { > > > > + END_USE(vq); > > > > + return -EIO; > > > > + } > > > > + > > > > +#ifdef DEBUG > > > > + { > > > > + ktime_t now = ktime_get(); > > > > + > > > > + /* No kick or get, with .1 second between? Warn. */ > > > > + if (vq->last_add_time_valid) > > > > + WARN_ON(ktime_to_ms(ktime_sub(now, vq->last_add_time)) > > > > + > 100); > > > > + vq->last_add_time = now; > > > > + vq->last_add_time_valid = true; > > > > + } > > > > +#endif > > > > + > > > > + BUG_ON(total_sg == 0); > > > > + > > > > + head = vq->next_avail_idx; > > > > + wrap_counter = vq->wrap_counter; > > > > + > > > > + /* If the host supports indirect descriptor tables, and we have multiple > > > > + * buffers, then go indirect. FIXME: tune this threshold */ > > > > + if (vq->indirect && total_sg > 1 && vq->vq.num_free) > > > Let's introduce a helper like virtqueue_need_indirect() to avoid duplicating > > > codes and FIXME. > > Okay. > > > > > > + desc = alloc_indirect_packed(_vq, total_sg, gfp); > > > > + else { > > > > + desc = NULL; > > > > + WARN_ON_ONCE(total_sg > vq->vring_packed.num && !vq->indirect); > > > > + } > > > > + > > > > + if (desc) { > > > > + /* Use a single buffer which doesn't continue */ > > > > + indirect = true; > > > > + /* Set up rest to use this indirect table. */ > > > > + i = 0; > > > > + descs_used = 1; > > > > + } else { > > > > + indirect = false; > > > > + desc = vq->vring_packed.desc; > > > > + i = head; > > > > + descs_used = total_sg; > > > > + } > > > > + > > > > + if (vq->vq.num_free < descs_used) { > > > > + pr_debug("Can't add buf len %i - avail = %i\n", > > > > + descs_used, vq->vq.num_free); > > > > + /* FIXME: for historical reasons, we force a notify here if > > > > + * there are outgoing parts to the buffer. Presumably the > > > > + * host should service the ring ASAP. */ > > > > + if (out_sgs) > > > > + vq->notify(&vq->vq); > > > > + if (indirect) > > > > + kfree(desc); > > > > + END_USE(vq); > > > > + return -ENOSPC; > > > > + } > > > > + > > > > + for (n = 0; n < out_sgs + in_sgs; n++) { > > > > + for (sg = sgs[n]; sg; sg = sg_next(sg)) { > > > > + dma_addr_t addr = vring_map_one_sg(vq, sg, n < out_sgs ? > > > > + DMA_TO_DEVICE : DMA_FROM_DEVICE); > > > > + if (vring_mapping_error(vq, addr)) > > > > + goto unmap_release; > > > > + > > > > + flags = cpu_to_virtio16(_vq->vdev, VRING_DESC_F_NEXT | > > > > + (n < out_sgs ? 0 : VRING_DESC_F_WRITE) | > > > > + VRING_DESC_F_AVAIL(vq->wrap_counter) | > > > > + VRING_DESC_F_USED(!vq->wrap_counter)); > > > > + if (!indirect && i == head) > > > > + head_flags = flags; > > > > + else > > > > + desc[i].flags = flags; > > > > + > > > > + desc[i].addr = cpu_to_virtio64(_vq->vdev, addr); > > > > + desc[i].len = cpu_to_virtio32(_vq->vdev, sg->length); > > > > + desc[i].id = cpu_to_virtio32(_vq->vdev, head); > > > Similar to V1, we only need this for the last descriptor. > > Okay, will just set it for the last desc. > > > > > > + prev = i; > > > It looks to me there's no need to track prev inside the loop here. > > > > > > > + i++; > > > > + if (!indirect && i >= vq->vring_packed.num) { > > > > + i = 0; > > > > + vq->wrap_counter ^= 1; > > > > + } > > > > + } > > > > + } > > > > + /* Last one doesn't continue. */ > > > > + if (total_sg == 1) > > > > + head_flags &= cpu_to_virtio16(_vq->vdev, ~VRING_DESC_F_NEXT); > > > > + else > > > > + desc[prev].flags &= cpu_to_virtio16(_vq->vdev, ~VRING_DESC_F_NEXT); > > > The only case when prev != i - 1 is i == 0, we can add a if here. > > It's just a mirror of the existing implementation in split ring. > > It seems that split ring implementation needs this just because > > it's much harder for it to find the prev, which is not true for > > packed ring. So I'll take your suggestion. Thanks! > > > > [...] > > > > +static bool virtqueue_kick_prepare_packed(struct virtqueue *_vq) > > > > +{ > > > > + struct vring_virtqueue *vq = to_vvq(_vq); > > > > + u16 new, old, off_wrap; > > > > + bool needs_kick; > > > > + > > > > + START_USE(vq); > > > > + /* We need to expose the new flags value before checking notification > > > > + * suppressions. */ > > > > + virtio_mb(vq->weak_barriers); > > > > + > > > > + old = vq->next_avail_idx - vq->num_added; > > > > + new = vq->next_avail_idx; > > > > + vq->num_added = 0; > > > > + > > > > +#ifdef DEBUG > > > > + if (vq->last_add_time_valid) { > > > > + WARN_ON(ktime_to_ms(ktime_sub(ktime_get(), > > > > + vq->last_add_time)) > 100); > > > > + } > > > > + vq->last_add_time_valid = false; > > > > +#endif > > > > + > > > > + off_wrap = virtio16_to_cpu(_vq->vdev, vq->vring_packed.device->off_wrap); > > > > + > > > > + if (vq->event) { > > > It looks to me we should examine RING_EVENT_FLAGS_DESC in desc_event_flags > > > instead of vq->event here. Spec does not forces to use evenf_off and > > > event_wrap if event index is enabled. > > > > > > > + // FIXME: fix this! > > > > + needs_kick = ((off_wrap >> 15) == vq->wrap_counter) && > > > > + vring_need_event(off_wrap & ~(1<<15), new, old); > > > Why need a & here? > > Because wrap_counter (the most significant bit in off_wrap) > > isn't part of the index. > > > > > > + } else { > > > Need a smp_rmb() to make sure desc_event_flags was checked before flags. > > I don't get your point, if my understanding is correct, > > desc_event_flags is vq->vring_packed.device->flags. So > > what's the "flags"? > > Sorry, I mean we need check device.flags before off_warp. So it needs an > smp_rmb() in the middle. It's best to just read all flags atomically as u32. > It looks to me there's no guarantee that > VRING_EVENT_F_DESC is set if event index is supported. > > > > > > > + needs_kick = (vq->vring_packed.device->flags != > > > > + cpu_to_virtio16(_vq->vdev, VRING_EVENT_F_DISABLE)); > > > > + } > > > > + END_USE(vq); > > > > + return needs_kick; > > > > +} > > [...] > > > > +static int detach_buf_packed(struct vring_virtqueue *vq, unsigned int head, > > > > + void **ctx) > > > > +{ > > > > + struct vring_packed_desc *desc; > > > > + unsigned int i, j; > > > > + > > > > + /* Clear data ptr. */ > > > > + vq->desc_state[head].data = NULL; > > > > + > > > > + i = head; > > > > + > > > > + for (j = 0; j < vq->desc_state[head].num; j++) { > > > > + desc = &vq->vring_packed.desc[i]; > > > > + vring_unmap_one_packed(vq, desc); > > > > + desc->flags = 0x0; > > > Looks like this is unnecessary. > > It's safer to zero it. If we don't zero it, after we > > call virtqueue_detach_unused_buf_packed() which calls > > this function, the desc is still available to the > > device. > > Well detach_unused_buf_packed() should be called after device is stopped, > otherwise even if you try to clear, there will still be a window that device > may use it. > > > > > > > + i++; > > > > + if (i >= vq->vring_packed.num) > > > > + i = 0; > > > > + } > > [...] > > > > +static unsigned virtqueue_enable_cb_prepare_packed(struct virtqueue *_vq) > > > > +{ > > > > + struct vring_virtqueue *vq = to_vvq(_vq); > > > > + u16 last_used_idx, wrap_counter, off_wrap; > > > > + > > > > + START_USE(vq); > > > > + > > > > + last_used_idx = vq->last_used_idx; > > > > + wrap_counter = vq->wrap_counter; > > > > + > > > > + if (last_used_idx > vq->next_avail_idx) > > > > + wrap_counter ^= 1; > > > > + > > > > + off_wrap = last_used_idx | (wrap_counter << 15); > > > > + > > > > + /* We optimistically turn back on interrupts, then check if there was > > > > + * more to do. */ > > > > + /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to > > > > + * either clear the flags bit or point the event index at the next > > > > + * entry. Always do both to keep code simple. */ > > > > + if (vq->event_flags_shadow == VRING_EVENT_F_DISABLE) { > > > > + vq->event_flags_shadow = vq->event ? VRING_EVENT_F_DESC: > > > > + VRING_EVENT_F_ENABLE; > > > > + vq->vring_packed.driver->flags = cpu_to_virtio16(_vq->vdev, > > > > + vq->event_flags_shadow); > > > > + } > > > A smp_wmb() is missed here? > > > > > > > + vq->vring_packed.driver->off_wrap = cpu_to_virtio16(_vq->vdev, off_wrap); > > > And according to the spec, it looks to me write a VRING_EVENT_F_ENABLE is > > > sufficient here. > > I didn't think much when implementing the event suppression > > for packed ring previously. After I saw your comments, I found > > something new. Indeed, unlike the split ring, for the packed > > ring, spec doesn't say we must use VRING_EVENT_F_DESC when > > EVENT_IDX is negotiated. So do you think below thought is > > right or makes sense? > > > > - For virtqueue_enable_cb_prepare(), we just need to enable > > the ring by setting flags to VRING_EVENT_F_ENABLE in any > > case. > > > > - We will try to use VRING_EVENT_F_DESC (if EVENT_IDX is > > negotiated) only when we want to delay the interrupts > > virtqueue_enable_cb_delayed(). > > This looks good to me. I suspect this will lead to extra interrupts if host is fast. So I think for now we should always use VRING_EVENT_F_DESC if EVENT_IDX is negotiated. VRING_EVENT_F_DISABLE makes more sense to me. > > > > > > + END_USE(vq); > > > > + return last_used_idx; > > > > +} > > > > + > > [...] > > > > @@ -1157,14 +1852,18 @@ void vring_transport_features(struct virtio_device *vdev) > > > > for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++) { > > > > switch (i) { > > > > - case VIRTIO_RING_F_INDIRECT_DESC: > > > > +#if 0 > > > > + case VIRTIO_RING_F_INDIRECT_DESC: // FIXME not tested yet. > > > > break; > > > > - case VIRTIO_RING_F_EVENT_IDX: > > > > + case VIRTIO_RING_F_EVENT_IDX: // FIXME probably not work. > > > > break; > > > > +#endif > > > It would be better if you can split EVENT_IDX and INDIRECT_DESC into > > > separate patches too. > > Sure. Will do it in the next version. > > > > Thanks for the review! > > Thanks. > > > > Thanks > > >