From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: [PATCH RFC v8 02/11] vhost: use batched get_vq_desc version Date: Thu, 11 Jun 2020 07:34:19 -0400 Message-ID: <20200611113404.17810-3-mst@redhat.com> References: <20200611113404.17810-1-mst@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20200611113404.17810-1-mst@redhat.com> Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" To: linux-kernel@vger.kernel.org Cc: netdev@vger.kernel.org, eperezma@redhat.com, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org List-Id: virtualization@lists.linuxfoundation.org QXMgdGVzdGluZyBzaG93cyBubyBwZXJmb3JtYW5jZSBjaGFuZ2UsIHN3aXRjaCB0byB0aGF0IG5v dy4KClNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgUy4gVHNpcmtpbiA8bXN0QHJlZGhhdC5jb20+ClNp Z25lZC1vZmYtYnk6IEV1Z2VuaW8gUMOpcmV6IDxlcGVyZXptYUByZWRoYXQuY29tPgpMaW5rOiBo dHRwczovL2xvcmUua2VybmVsLm9yZy9yLzIwMjAwNDAxMTgzMTE4LjgzMzQtMy1lcGVyZXptYUBy ZWRoYXQuY29tClNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgUy4gVHNpcmtpbiA8bXN0QHJlZGhhdC5j b20+Ci0tLQogZHJpdmVycy92aG9zdC90ZXN0LmMgIHwgICAyICstCiBkcml2ZXJzL3Zob3N0L3Zo b3N0LmMgfCAzMTQgKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBk cml2ZXJzL3Zob3N0L3Zob3N0LmggfCAgIDcgKy0KIDMgZmlsZXMgY2hhbmdlZCwgNjEgaW5zZXJ0 aW9ucygrKSwgMjYyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3QvdGVz dC5jIGIvZHJpdmVycy92aG9zdC90ZXN0LmMKaW5kZXggMDQ2NjkyMWY0NzcyLi43ZDY5Nzc4YWFh MjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmhvc3QvdGVzdC5jCisrKyBiL2RyaXZlcnMvdmhvc3Qv dGVzdC5jCkBAIC0xMTksNyArMTE5LDcgQEAgc3RhdGljIGludCB2aG9zdF90ZXN0X29wZW4oc3Ry dWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmYpCiAJZGV2ID0gJm4tPmRldjsKIAl2cXNb VkhPU1RfVEVTVF9WUV0gPSAmbi0+dnFzW1ZIT1NUX1RFU1RfVlFdOwogCW4tPnZxc1tWSE9TVF9U RVNUX1ZRXS5oYW5kbGVfa2ljayA9IGhhbmRsZV92cV9raWNrOwotCXZob3N0X2Rldl9pbml0KGRl diwgdnFzLCBWSE9TVF9URVNUX1ZRX01BWCwgVUlPX01BWElPViwKKwl2aG9zdF9kZXZfaW5pdChk ZXYsIHZxcywgVkhPU1RfVEVTVF9WUV9NQVgsIFVJT19NQVhJT1YgKyA2NCwKIAkJICAgICAgIFZI T1NUX1RFU1RfUEtUX1dFSUdIVCwgVkhPU1RfVEVTVF9XRUlHSFQsIHRydWUsIE5VTEwpOwogCiAJ Zi0+cHJpdmF0ZV9kYXRhID0gbjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3Qvdmhvc3QuYyBi L2RyaXZlcnMvdmhvc3Qvdmhvc3QuYwppbmRleCAxMTQzM2Q3MDk2NTEuLmRmY2RiMzZkNDIyNyAx MDA2NDQKLS0tIGEvZHJpdmVycy92aG9zdC92aG9zdC5jCisrKyBiL2RyaXZlcnMvdmhvc3Qvdmhv c3QuYwpAQCAtMzA0LDYgKzMwNCw3IEBAIHN0YXRpYyB2b2lkIHZob3N0X3ZxX3Jlc2V0KHN0cnVj dCB2aG9zdF9kZXYgKmRldiwKIHsKIAl2cS0+bnVtID0gMTsKIAl2cS0+bmRlc2NzID0gMDsKKwl2 cS0+Zmlyc3RfZGVzYyA9IDA7CiAJdnEtPmRlc2MgPSBOVUxMOwogCXZxLT5hdmFpbCA9IE5VTEw7 CiAJdnEtPnVzZWQgPSBOVUxMOwpAQCAtMzcyLDYgKzM3MywxMSBAQCBzdGF0aWMgaW50IHZob3N0 X3dvcmtlcih2b2lkICpkYXRhKQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IHZob3N0X3Zx X251bV9iYXRjaF9kZXNjcyhzdHJ1Y3Qgdmhvc3RfdmlydHF1ZXVlICp2cSkKK3sKKwlyZXR1cm4g dnEtPm1heF9kZXNjcyAtIFVJT19NQVhJT1Y7Cit9CisKIHN0YXRpYyB2b2lkIHZob3N0X3ZxX2Zy ZWVfaW92ZWNzKHN0cnVjdCB2aG9zdF92aXJ0cXVldWUgKnZxKQogewogCWtmcmVlKHZxLT5kZXNj cyk7CkBAIC0zOTQsNiArNDAwLDkgQEAgc3RhdGljIGxvbmcgdmhvc3RfZGV2X2FsbG9jX2lvdmVj cyhzdHJ1Y3Qgdmhvc3RfZGV2ICpkZXYpCiAJZm9yIChpID0gMDsgaSA8IGRldi0+bnZxczsgKytp KSB7CiAJCXZxID0gZGV2LT52cXNbaV07CiAJCXZxLT5tYXhfZGVzY3MgPSBkZXYtPmlvdl9saW1p dDsKKwkJaWYgKHZob3N0X3ZxX251bV9iYXRjaF9kZXNjcyh2cSkgPCAwKSB7CisJCQlyZXR1cm4g LUVJTlZBTDsKKwkJfQogCQl2cS0+ZGVzY3MgPSBrbWFsbG9jX2FycmF5KHZxLT5tYXhfZGVzY3Ms CiAJCQkJCSAgc2l6ZW9mKCp2cS0+ZGVzY3MpLAogCQkJCQkgIEdGUF9LRVJORUwpOwpAQCAtMTYx MCw2ICsxNjE5LDcgQEAgbG9uZyB2aG9zdF92cmluZ19pb2N0bChzdHJ1Y3Qgdmhvc3RfZGV2ICpk LCB1bnNpZ25lZCBpbnQgaW9jdGwsIHZvaWQgX191c2VyICphcmcKIAkJdnEtPmxhc3RfYXZhaWxf aWR4ID0gcy5udW07CiAJCS8qIEZvcmdldCB0aGUgY2FjaGVkIGluZGV4IHZhbHVlLiAqLwogCQl2 cS0+YXZhaWxfaWR4ID0gdnEtPmxhc3RfYXZhaWxfaWR4OworCQl2cS0+bmRlc2NzID0gdnEtPmZp cnN0X2Rlc2MgPSAwOwogCQlicmVhazsKIAljYXNlIFZIT1NUX0dFVF9WUklOR19CQVNFOgogCQlz LmluZGV4ID0gaWR4OwpAQCAtMjA3OCwyNTMgKzIwODgsNiBAQCBzdGF0aWMgdW5zaWduZWQgbmV4 dF9kZXNjKHN0cnVjdCB2aG9zdF92aXJ0cXVldWUgKnZxLCBzdHJ1Y3QgdnJpbmdfZGVzYyAqZGVz YykKIAlyZXR1cm4gbmV4dDsKIH0KIAotc3RhdGljIGludCBnZXRfaW5kaXJlY3Qoc3RydWN0IHZo b3N0X3ZpcnRxdWV1ZSAqdnEsCi0JCQlzdHJ1Y3QgaW92ZWMgaW92W10sIHVuc2lnbmVkIGludCBp b3Zfc2l6ZSwKLQkJCXVuc2lnbmVkIGludCAqb3V0X251bSwgdW5zaWduZWQgaW50ICppbl9udW0s Ci0JCQlzdHJ1Y3Qgdmhvc3RfbG9nICpsb2csIHVuc2lnbmVkIGludCAqbG9nX251bSwKLQkJCXN0 cnVjdCB2cmluZ19kZXNjICppbmRpcmVjdCkKLXsKLQlzdHJ1Y3QgdnJpbmdfZGVzYyBkZXNjOwot CXVuc2lnbmVkIGludCBpID0gMCwgY291bnQsIGZvdW5kID0gMDsKLQl1MzIgbGVuID0gdmhvc3Qz Ml90b19jcHUodnEsIGluZGlyZWN0LT5sZW4pOwotCXN0cnVjdCBpb3ZfaXRlciBmcm9tOwotCWlu dCByZXQsIGFjY2VzczsKLQotCS8qIFNhbml0eSBjaGVjayAqLwotCWlmICh1bmxpa2VseShsZW4g JSBzaXplb2YgZGVzYykpIHsKLQkJdnFfZXJyKHZxLCAiSW52YWxpZCBsZW5ndGggaW4gaW5kaXJl Y3QgZGVzY3JpcHRvcjogIgotCQkgICAgICAgImxlbiAweCVsbHggbm90IG11bHRpcGxlIG9mIDB4 JXp4XG4iLAotCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZW4sCi0JCSAgICAgICBzaXpl b2YgZGVzYyk7Ci0JCXJldHVybiAtRUlOVkFMOwotCX0KLQotCXJldCA9IHRyYW5zbGF0ZV9kZXNj KHZxLCB2aG9zdDY0X3RvX2NwdSh2cSwgaW5kaXJlY3QtPmFkZHIpLCBsZW4sIHZxLT5pbmRpcmVj dCwKLQkJCSAgICAgVUlPX01BWElPViwgVkhPU1RfQUNDRVNTX1JPKTsKLQlpZiAodW5saWtlbHko cmV0IDwgMCkpIHsKLQkJaWYgKHJldCAhPSAtRUFHQUlOKQotCQkJdnFfZXJyKHZxLCAiVHJhbnNs YXRpb24gZmFpbHVyZSAlZCBpbiBpbmRpcmVjdC5cbiIsIHJldCk7Ci0JCXJldHVybiByZXQ7Ci0J fQotCWlvdl9pdGVyX2luaXQoJmZyb20sIFJFQUQsIHZxLT5pbmRpcmVjdCwgcmV0LCBsZW4pOwot Ci0JLyogV2Ugd2lsbCB1c2UgdGhlIHJlc3VsdCBhcyBhbiBhZGRyZXNzIHRvIHJlYWQgZnJvbSwg c28gbW9zdAotCSAqIGFyY2hpdGVjdHVyZXMgb25seSBuZWVkIGEgY29tcGlsZXIgYmFycmllciBo ZXJlLiAqLwotCXJlYWRfYmFycmllcl9kZXBlbmRzKCk7Ci0KLQljb3VudCA9IGxlbiAvIHNpemVv ZiBkZXNjOwotCS8qIEJ1ZmZlcnMgYXJlIGNoYWluZWQgdmlhIGEgMTYgYml0IG5leHQgZmllbGQs IHNvCi0JICogd2UgY2FuIGhhdmUgYXQgbW9zdCAyXjE2IG9mIHRoZXNlLiAqLwotCWlmICh1bmxp a2VseShjb3VudCA+IFVTSFJUX01BWCArIDEpKSB7Ci0JCXZxX2Vycih2cSwgIkluZGlyZWN0IGJ1 ZmZlciBsZW5ndGggdG9vIGJpZzogJWRcbiIsCi0JCSAgICAgICBpbmRpcmVjdC0+bGVuKTsKLQkJ cmV0dXJuIC1FMkJJRzsKLQl9Ci0KLQlkbyB7Ci0JCXVuc2lnbmVkIGlvdl9jb3VudCA9ICppbl9u dW0gKyAqb3V0X251bTsKLQkJaWYgKHVubGlrZWx5KCsrZm91bmQgPiBjb3VudCkpIHsKLQkJCXZx X2Vycih2cSwgIkxvb3AgZGV0ZWN0ZWQ6IGxhc3Qgb25lIGF0ICV1ICIKLQkJCSAgICAgICAiaW5k aXJlY3Qgc2l6ZSAldVxuIiwKLQkJCSAgICAgICBpLCBjb3VudCk7Ci0JCQlyZXR1cm4gLUVJTlZB TDsKLQkJfQotCQlpZiAodW5saWtlbHkoIWNvcHlfZnJvbV9pdGVyX2Z1bGwoJmRlc2MsIHNpemVv ZihkZXNjKSwgJmZyb20pKSkgewotCQkJdnFfZXJyKHZxLCAiRmFpbGVkIGluZGlyZWN0IGRlc2Ny aXB0b3I6IGlkeCAlZCwgJXp4XG4iLAotCQkJICAgICAgIGksIChzaXplX3Qpdmhvc3Q2NF90b19j cHUodnEsIGluZGlyZWN0LT5hZGRyKSArIGkgKiBzaXplb2YgZGVzYyk7Ci0JCQlyZXR1cm4gLUVJ TlZBTDsKLQkJfQotCQlpZiAodW5saWtlbHkoZGVzYy5mbGFncyAmIGNwdV90b192aG9zdDE2KHZx LCBWUklOR19ERVNDX0ZfSU5ESVJFQ1QpKSkgewotCQkJdnFfZXJyKHZxLCAiTmVzdGVkIGluZGly ZWN0IGRlc2NyaXB0b3I6IGlkeCAlZCwgJXp4XG4iLAotCQkJICAgICAgIGksIChzaXplX3Qpdmhv c3Q2NF90b19jcHUodnEsIGluZGlyZWN0LT5hZGRyKSArIGkgKiBzaXplb2YgZGVzYyk7Ci0JCQly ZXR1cm4gLUVJTlZBTDsKLQkJfQotCi0JCWlmIChkZXNjLmZsYWdzICYgY3B1X3RvX3Zob3N0MTYo dnEsIFZSSU5HX0RFU0NfRl9XUklURSkpCi0JCQlhY2Nlc3MgPSBWSE9TVF9BQ0NFU1NfV087Ci0J CWVsc2UKLQkJCWFjY2VzcyA9IFZIT1NUX0FDQ0VTU19STzsKLQotCQlyZXQgPSB0cmFuc2xhdGVf ZGVzYyh2cSwgdmhvc3Q2NF90b19jcHUodnEsIGRlc2MuYWRkciksCi0JCQkJICAgICB2aG9zdDMy X3RvX2NwdSh2cSwgZGVzYy5sZW4pLCBpb3YgKyBpb3ZfY291bnQsCi0JCQkJICAgICBpb3Zfc2l6 ZSAtIGlvdl9jb3VudCwgYWNjZXNzKTsKLQkJaWYgKHVubGlrZWx5KHJldCA8IDApKSB7Ci0JCQlp ZiAocmV0ICE9IC1FQUdBSU4pCi0JCQkJdnFfZXJyKHZxLCAiVHJhbnNsYXRpb24gZmFpbHVyZSAl ZCBpbmRpcmVjdCBpZHggJWRcbiIsCi0JCQkJCXJldCwgaSk7Ci0JCQlyZXR1cm4gcmV0OwotCQl9 Ci0JCS8qIElmIHRoaXMgaXMgYW4gaW5wdXQgZGVzY3JpcHRvciwgaW5jcmVtZW50IHRoYXQgY291 bnQuICovCi0JCWlmIChhY2Nlc3MgPT0gVkhPU1RfQUNDRVNTX1dPKSB7Ci0JCQkqaW5fbnVtICs9 IHJldDsKLQkJCWlmICh1bmxpa2VseShsb2cgJiYgcmV0KSkgewotCQkJCWxvZ1sqbG9nX251bV0u YWRkciA9IHZob3N0NjRfdG9fY3B1KHZxLCBkZXNjLmFkZHIpOwotCQkJCWxvZ1sqbG9nX251bV0u bGVuID0gdmhvc3QzMl90b19jcHUodnEsIGRlc2MubGVuKTsKLQkJCQkrKypsb2dfbnVtOwotCQkJ fQotCQl9IGVsc2UgewotCQkJLyogSWYgaXQncyBhbiBvdXRwdXQgZGVzY3JpcHRvciwgdGhleSdy ZSBhbGwgc3VwcG9zZWQKLQkJCSAqIHRvIGNvbWUgYmVmb3JlIGFueSBpbnB1dCBkZXNjcmlwdG9y cy4gKi8KLQkJCWlmICh1bmxpa2VseSgqaW5fbnVtKSkgewotCQkJCXZxX2Vycih2cSwgIkluZGly ZWN0IGRlc2NyaXB0b3IgIgotCQkJCSAgICAgICAiaGFzIG91dCBhZnRlciBpbjogaWR4ICVkXG4i LCBpKTsKLQkJCQlyZXR1cm4gLUVJTlZBTDsKLQkJCX0KLQkJCSpvdXRfbnVtICs9IHJldDsKLQkJ fQotCX0gd2hpbGUgKChpID0gbmV4dF9kZXNjKHZxLCAmZGVzYykpICE9IC0xKTsKLQlyZXR1cm4g MDsKLX0KLQotLyogVGhpcyBsb29rcyBpbiB0aGUgdmlydHF1ZXVlIGFuZCBmb3IgdGhlIGZpcnN0 IGF2YWlsYWJsZSBidWZmZXIsIGFuZCBjb252ZXJ0cwotICogaXQgdG8gYW4gaW92ZWMgZm9yIGNv bnZlbmllbnQgYWNjZXNzLiAgU2luY2UgZGVzY3JpcHRvcnMgY29uc2lzdCBvZiBzb21lCi0gKiBu dW1iZXIgb2Ygb3V0cHV0IHRoZW4gc29tZSBudW1iZXIgb2YgaW5wdXQgZGVzY3JpcHRvcnMsIGl0 J3MgYWN0dWFsbHkgdHdvCi0gKiBpb3ZlY3MsIGJ1dCB3ZSBwYWNrIHRoZW0gaW50byBvbmUgYW5k IG5vdGUgaG93IG1hbnkgb2YgZWFjaCB0aGVyZSB3ZXJlLgotICoKLSAqIFRoaXMgZnVuY3Rpb24g cmV0dXJucyB0aGUgZGVzY3JpcHRvciBudW1iZXIgZm91bmQsIG9yIHZxLT5udW0gKHdoaWNoIGlz Ci0gKiBuZXZlciBhIHZhbGlkIGRlc2NyaXB0b3IgbnVtYmVyKSBpZiBub25lIHdhcyBmb3VuZC4g IEEgbmVnYXRpdmUgY29kZSBpcwotICogcmV0dXJuZWQgb24gZXJyb3IuICovCi1pbnQgdmhvc3Rf Z2V0X3ZxX2Rlc2Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsCi0JCSAgICAgIHN0cnVjdCBp b3ZlYyBpb3ZbXSwgdW5zaWduZWQgaW50IGlvdl9zaXplLAotCQkgICAgICB1bnNpZ25lZCBpbnQg Km91dF9udW0sIHVuc2lnbmVkIGludCAqaW5fbnVtLAotCQkgICAgICBzdHJ1Y3Qgdmhvc3RfbG9n ICpsb2csIHVuc2lnbmVkIGludCAqbG9nX251bSkKLXsKLQlzdHJ1Y3QgdnJpbmdfZGVzYyBkZXNj OwotCXVuc2lnbmVkIGludCBpLCBoZWFkLCBmb3VuZCA9IDA7Ci0JdTE2IGxhc3RfYXZhaWxfaWR4 OwotCV9fdmlydGlvMTYgYXZhaWxfaWR4OwotCV9fdmlydGlvMTYgcmluZ19oZWFkOwotCWludCBy ZXQsIGFjY2VzczsKLQotCS8qIENoZWNrIGl0IGlzbid0IGRvaW5nIHZlcnkgc3RyYW5nZSB0aGlu Z3Mgd2l0aCBkZXNjcmlwdG9yIG51bWJlcnMuICovCi0JbGFzdF9hdmFpbF9pZHggPSB2cS0+bGFz dF9hdmFpbF9pZHg7Ci0KLQlpZiAodnEtPmF2YWlsX2lkeCA9PSB2cS0+bGFzdF9hdmFpbF9pZHgp IHsKLQkJaWYgKHVubGlrZWx5KHZob3N0X2dldF9hdmFpbF9pZHgodnEsICZhdmFpbF9pZHgpKSkg ewotCQkJdnFfZXJyKHZxLCAiRmFpbGVkIHRvIGFjY2VzcyBhdmFpbCBpZHggYXQgJXBcbiIsCi0J CQkJJnZxLT5hdmFpbC0+aWR4KTsKLQkJCXJldHVybiAtRUZBVUxUOwotCQl9Ci0JCXZxLT5hdmFp bF9pZHggPSB2aG9zdDE2X3RvX2NwdSh2cSwgYXZhaWxfaWR4KTsKLQotCQlpZiAodW5saWtlbHko KHUxNikodnEtPmF2YWlsX2lkeCAtIGxhc3RfYXZhaWxfaWR4KSA+IHZxLT5udW0pKSB7Ci0JCQl2 cV9lcnIodnEsICJHdWVzdCBtb3ZlZCB1c2VkIGluZGV4IGZyb20gJXUgdG8gJXUiLAotCQkJCWxh c3RfYXZhaWxfaWR4LCB2cS0+YXZhaWxfaWR4KTsKLQkJCXJldHVybiAtRUZBVUxUOwotCQl9Ci0K LQkJLyogSWYgdGhlcmUncyBub3RoaW5nIG5ldyBzaW5jZSBsYXN0IHdlIGxvb2tlZCwgcmV0dXJu Ci0JCSAqIGludmFsaWQuCi0JCSAqLwotCQlpZiAodnEtPmF2YWlsX2lkeCA9PSBsYXN0X2F2YWls X2lkeCkKLQkJCXJldHVybiB2cS0+bnVtOwotCi0JCS8qIE9ubHkgZ2V0IGF2YWlsIHJpbmcgZW50 cmllcyBhZnRlciB0aGV5IGhhdmUgYmVlbgotCQkgKiBleHBvc2VkIGJ5IGd1ZXN0LgotCQkgKi8K LQkJc21wX3JtYigpOwotCX0KLQotCS8qIEdyYWIgdGhlIG5leHQgZGVzY3JpcHRvciBudW1iZXIg dGhleSdyZSBhZHZlcnRpc2luZywgYW5kIGluY3JlbWVudAotCSAqIHRoZSBpbmRleCB3ZSd2ZSBz ZWVuLiAqLwotCWlmICh1bmxpa2VseSh2aG9zdF9nZXRfYXZhaWxfaGVhZCh2cSwgJnJpbmdfaGVh ZCwgbGFzdF9hdmFpbF9pZHgpKSkgewotCQl2cV9lcnIodnEsICJGYWlsZWQgdG8gcmVhZCBoZWFk OiBpZHggJWQgYWRkcmVzcyAlcFxuIiwKLQkJICAgICAgIGxhc3RfYXZhaWxfaWR4LAotCQkgICAg ICAgJnZxLT5hdmFpbC0+cmluZ1tsYXN0X2F2YWlsX2lkeCAlIHZxLT5udW1dKTsKLQkJcmV0dXJu IC1FRkFVTFQ7Ci0JfQotCi0JaGVhZCA9IHZob3N0MTZfdG9fY3B1KHZxLCByaW5nX2hlYWQpOwot Ci0JLyogSWYgdGhlaXIgbnVtYmVyIGlzIHNpbGx5LCB0aGF0J3MgYW4gZXJyb3IuICovCi0JaWYg KHVubGlrZWx5KGhlYWQgPj0gdnEtPm51bSkpIHsKLQkJdnFfZXJyKHZxLCAiR3Vlc3Qgc2F5cyBp bmRleCAldSA+ICV1IGlzIGF2YWlsYWJsZSIsCi0JCSAgICAgICBoZWFkLCB2cS0+bnVtKTsKLQkJ cmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JLyogV2hlbiB3ZSBzdGFydCB0aGVyZSBhcmUgbm9uZSBv ZiBlaXRoZXIgaW5wdXQgbm9yIG91dHB1dC4gKi8KLQkqb3V0X251bSA9ICppbl9udW0gPSAwOwot CWlmICh1bmxpa2VseShsb2cpKQotCQkqbG9nX251bSA9IDA7Ci0KLQlpID0gaGVhZDsKLQlkbyB7 Ci0JCXVuc2lnbmVkIGlvdl9jb3VudCA9ICppbl9udW0gKyAqb3V0X251bTsKLQkJaWYgKHVubGlr ZWx5KGkgPj0gdnEtPm51bSkpIHsKLQkJCXZxX2Vycih2cSwgIkRlc2MgaW5kZXggaXMgJXUgPiAl dSwgaGVhZCA9ICV1IiwKLQkJCSAgICAgICBpLCB2cS0+bnVtLCBoZWFkKTsKLQkJCXJldHVybiAt RUlOVkFMOwotCQl9Ci0JCWlmICh1bmxpa2VseSgrK2ZvdW5kID4gdnEtPm51bSkpIHsKLQkJCXZx X2Vycih2cSwgIkxvb3AgZGV0ZWN0ZWQ6IGxhc3Qgb25lIGF0ICV1ICIKLQkJCSAgICAgICAidnEg c2l6ZSAldSBoZWFkICV1XG4iLAotCQkJICAgICAgIGksIHZxLT5udW0sIGhlYWQpOwotCQkJcmV0 dXJuIC1FSU5WQUw7Ci0JCX0KLQkJcmV0ID0gdmhvc3RfZ2V0X2Rlc2ModnEsICZkZXNjLCBpKTsK LQkJaWYgKHVubGlrZWx5KHJldCkpIHsKLQkJCXZxX2Vycih2cSwgIkZhaWxlZCB0byBnZXQgZGVz Y3JpcHRvcjogaWR4ICVkIGFkZHIgJXBcbiIsCi0JCQkgICAgICAgaSwgdnEtPmRlc2MgKyBpKTsK LQkJCXJldHVybiAtRUZBVUxUOwotCQl9Ci0JCWlmIChkZXNjLmZsYWdzICYgY3B1X3RvX3Zob3N0 MTYodnEsIFZSSU5HX0RFU0NfRl9JTkRJUkVDVCkpIHsKLQkJCXJldCA9IGdldF9pbmRpcmVjdCh2 cSwgaW92LCBpb3Zfc2l6ZSwKLQkJCQkJICAgb3V0X251bSwgaW5fbnVtLAotCQkJCQkgICBsb2cs IGxvZ19udW0sICZkZXNjKTsKLQkJCWlmICh1bmxpa2VseShyZXQgPCAwKSkgewotCQkJCWlmIChy ZXQgIT0gLUVBR0FJTikKLQkJCQkJdnFfZXJyKHZxLCAiRmFpbHVyZSBkZXRlY3RlZCAiCi0JCQkJ CQkiaW4gaW5kaXJlY3QgZGVzY3JpcHRvciBhdCBpZHggJWRcbiIsIGkpOwotCQkJCXJldHVybiBy ZXQ7Ci0JCQl9Ci0JCQljb250aW51ZTsKLQkJfQotCi0JCWlmIChkZXNjLmZsYWdzICYgY3B1X3Rv X3Zob3N0MTYodnEsIFZSSU5HX0RFU0NfRl9XUklURSkpCi0JCQlhY2Nlc3MgPSBWSE9TVF9BQ0NF U1NfV087Ci0JCWVsc2UKLQkJCWFjY2VzcyA9IFZIT1NUX0FDQ0VTU19STzsKLQkJcmV0ID0gdHJh bnNsYXRlX2Rlc2ModnEsIHZob3N0NjRfdG9fY3B1KHZxLCBkZXNjLmFkZHIpLAotCQkJCSAgICAg dmhvc3QzMl90b19jcHUodnEsIGRlc2MubGVuKSwgaW92ICsgaW92X2NvdW50LAotCQkJCSAgICAg aW92X3NpemUgLSBpb3ZfY291bnQsIGFjY2Vzcyk7Ci0JCWlmICh1bmxpa2VseShyZXQgPCAwKSkg ewotCQkJaWYgKHJldCAhPSAtRUFHQUlOKQotCQkJCXZxX2Vycih2cSwgIlRyYW5zbGF0aW9uIGZh aWx1cmUgJWQgZGVzY3JpcHRvciBpZHggJWRcbiIsCi0JCQkJCXJldCwgaSk7Ci0JCQlyZXR1cm4g cmV0OwotCQl9Ci0JCWlmIChhY2Nlc3MgPT0gVkhPU1RfQUNDRVNTX1dPKSB7Ci0JCQkvKiBJZiB0 aGlzIGlzIGFuIGlucHV0IGRlc2NyaXB0b3IsCi0JCQkgKiBpbmNyZW1lbnQgdGhhdCBjb3VudC4g Ki8KLQkJCSppbl9udW0gKz0gcmV0OwotCQkJaWYgKHVubGlrZWx5KGxvZyAmJiByZXQpKSB7Ci0J CQkJbG9nWypsb2dfbnVtXS5hZGRyID0gdmhvc3Q2NF90b19jcHUodnEsIGRlc2MuYWRkcik7Ci0J CQkJbG9nWypsb2dfbnVtXS5sZW4gPSB2aG9zdDMyX3RvX2NwdSh2cSwgZGVzYy5sZW4pOwotCQkJ CSsrKmxvZ19udW07Ci0JCQl9Ci0JCX0gZWxzZSB7Ci0JCQkvKiBJZiBpdCdzIGFuIG91dHB1dCBk ZXNjcmlwdG9yLCB0aGV5J3JlIGFsbCBzdXBwb3NlZAotCQkJICogdG8gY29tZSBiZWZvcmUgYW55 IGlucHV0IGRlc2NyaXB0b3JzLiAqLwotCQkJaWYgKHVubGlrZWx5KCppbl9udW0pKSB7Ci0JCQkJ dnFfZXJyKHZxLCAiRGVzY3JpcHRvciBoYXMgb3V0IGFmdGVyIGluOiAiCi0JCQkJICAgICAgICJp ZHggJWRcbiIsIGkpOwotCQkJCXJldHVybiAtRUlOVkFMOwotCQkJfQotCQkJKm91dF9udW0gKz0g cmV0OwotCQl9Ci0JfSB3aGlsZSAoKGkgPSBuZXh0X2Rlc2ModnEsICZkZXNjKSkgIT0gLTEpOwot Ci0JLyogT24gc3VjY2VzcywgaW5jcmVtZW50IGF2YWlsIGluZGV4LiAqLwotCXZxLT5sYXN0X2F2 YWlsX2lkeCsrOwotCi0JLyogQXNzdW1lIG5vdGlmaWNhdGlvbnMgZnJvbSBndWVzdCBhcmUgZGlz YWJsZWQgYXQgdGhpcyBwb2ludCwKLQkgKiBpZiB0aGV5IGFyZW4ndCB3ZSB3b3VsZCBuZWVkIHRv IHVwZGF0ZSBhdmFpbF9ldmVudCBpbmRleC4gKi8KLQlCVUdfT04oISh2cS0+dXNlZF9mbGFncyAm IFZSSU5HX1VTRURfRl9OT19OT1RJRlkpKTsKLQlyZXR1cm4gaGVhZDsKLX0KLUVYUE9SVF9TWU1C T0xfR1BMKHZob3N0X2dldF92cV9kZXNjKTsKLQogc3RhdGljIHN0cnVjdCB2aG9zdF9kZXNjICpw ZWVrX3NwbGl0X2Rlc2Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEpCiB7CiAJQlVHX09OKCF2 cS0+bmRlc2NzKTsKQEAgLTI0MjgsNyArMjE5MSw3IEBAIHN0YXRpYyBpbnQgZmV0Y2hfaW5kaXJl Y3RfZGVzY3Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsCiAKIC8qIFRoaXMgZnVuY3Rpb24g cmV0dXJucyBhIHZhbHVlID4gMCBpZiBhIGRlc2NyaXB0b3Igd2FzIGZvdW5kLCBvciAwIGlmIG5v bmUgd2VyZSBmb3VuZC4KICAqIEEgbmVnYXRpdmUgY29kZSBpcyByZXR1cm5lZCBvbiBlcnJvci4g Ki8KLXN0YXRpYyBpbnQgZmV0Y2hfZGVzY3Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEpCitz dGF0aWMgaW50IGZldGNoX2J1ZihzdHJ1Y3Qgdmhvc3RfdmlydHF1ZXVlICp2cSkKIHsKIAl1bnNp Z25lZCBpbnQgaSwgaGVhZCwgZm91bmQgPSAwOwogCXN0cnVjdCB2aG9zdF9kZXNjICpsYXN0OwpA QCAtMjQ0MSw3ICsyMjA0LDcgQEAgc3RhdGljIGludCBmZXRjaF9kZXNjcyhzdHJ1Y3Qgdmhvc3Rf dmlydHF1ZXVlICp2cSkKIAkvKiBDaGVjayBpdCBpc24ndCBkb2luZyB2ZXJ5IHN0cmFuZ2UgdGhp bmdzIHdpdGggZGVzY3JpcHRvciBudW1iZXJzLiAqLwogCWxhc3RfYXZhaWxfaWR4ID0gdnEtPmxh c3RfYXZhaWxfaWR4OwogCi0JaWYgKHZxLT5hdmFpbF9pZHggPT0gdnEtPmxhc3RfYXZhaWxfaWR4 KSB7CisJaWYgKHVubGlrZWx5KHZxLT5hdmFpbF9pZHggPT0gdnEtPmxhc3RfYXZhaWxfaWR4KSkg ewogCQlpZiAodW5saWtlbHkodmhvc3RfZ2V0X2F2YWlsX2lkeCh2cSwgJmF2YWlsX2lkeCkpKSB7 CiAJCQl2cV9lcnIodnEsICJGYWlsZWQgdG8gYWNjZXNzIGF2YWlsIGlkeCBhdCAlcFxuIiwKIAkJ CQkmdnEtPmF2YWlsLT5pZHgpOwpAQCAtMjUzMiw2ICsyMjk1LDQxIEBAIHN0YXRpYyBpbnQgZmV0 Y2hfZGVzY3Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEpCiAJcmV0dXJuIDE7CiB9CiAKKy8q IFRoaXMgZnVuY3Rpb24gcmV0dXJucyBhIHZhbHVlID4gMCBpZiBhIGRlc2NyaXB0b3Igd2FzIGZv dW5kLCBvciAwIGlmIG5vbmUgd2VyZSBmb3VuZC4KKyAqIEEgbmVnYXRpdmUgY29kZSBpcyByZXR1 cm5lZCBvbiBlcnJvci4gKi8KK3N0YXRpYyBpbnQgZmV0Y2hfZGVzY3Moc3RydWN0IHZob3N0X3Zp cnRxdWV1ZSAqdnEpCit7CisJaW50IHJldDsKKworCWlmICh1bmxpa2VseSh2cS0+Zmlyc3RfZGVz YyA+PSB2cS0+bmRlc2NzKSkgeworCQl2cS0+Zmlyc3RfZGVzYyA9IDA7CisJCXZxLT5uZGVzY3Mg PSAwOworCX0KKworCWlmICh2cS0+bmRlc2NzKQorCQlyZXR1cm4gMTsKKworCWZvciAocmV0ID0g MTsKKwkgICAgIHJldCA+IDAgJiYgdnEtPm5kZXNjcyA8PSB2aG9zdF92cV9udW1fYmF0Y2hfZGVz Y3ModnEpOworCSAgICAgcmV0ID0gZmV0Y2hfYnVmKHZxKSkKKwkJOworCisJLyogT24gc3VjY2Vz cyB3ZSBleHBlY3Qgc29tZSBkZXNjcyAqLworCUJVR19PTihyZXQgPiAwICYmICF2cS0+bmRlc2Nz KTsKKwlyZXR1cm4gcmV0OworfQorCisvKiBSZXZlcnNlIHRoZSBlZmZlY3RzIG9mIGZldGNoX2Rl c2NzICovCitzdGF0aWMgdm9pZCB1bmZldGNoX2Rlc2NzKHN0cnVjdCB2aG9zdF92aXJ0cXVldWUg KnZxKQoreworCWludCBpOworCisJZm9yIChpID0gdnEtPmZpcnN0X2Rlc2M7IGkgPCB2cS0+bmRl c2NzOyArK2kpCisJCWlmICghKHZxLT5kZXNjc1tpXS5mbGFncyAmIFZSSU5HX0RFU0NfRl9ORVhU KSkKKwkJCXZxLT5sYXN0X2F2YWlsX2lkeCAtPSAxOworCXZxLT5uZGVzY3MgPSAwOworfQorCiAv KiBUaGlzIGxvb2tzIGluIHRoZSB2aXJ0cXVldWUgYW5kIGZvciB0aGUgZmlyc3QgYXZhaWxhYmxl IGJ1ZmZlciwgYW5kIGNvbnZlcnRzCiAgKiBpdCB0byBhbiBpb3ZlYyBmb3IgY29udmVuaWVudCBh Y2Nlc3MuICBTaW5jZSBkZXNjcmlwdG9ycyBjb25zaXN0IG9mIHNvbWUKICAqIG51bWJlciBvZiBv dXRwdXQgdGhlbiBzb21lIG51bWJlciBvZiBpbnB1dCBkZXNjcmlwdG9ycywgaXQncyBhY3R1YWxs eSB0d28KQEAgLTI1NDAsNyArMjMzOCw3IEBAIHN0YXRpYyBpbnQgZmV0Y2hfZGVzY3Moc3RydWN0 IHZob3N0X3ZpcnRxdWV1ZSAqdnEpCiAgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgdGhlIGRlc2Ny aXB0b3IgbnVtYmVyIGZvdW5kLCBvciB2cS0+bnVtICh3aGljaCBpcwogICogbmV2ZXIgYSB2YWxp ZCBkZXNjcmlwdG9yIG51bWJlcikgaWYgbm9uZSB3YXMgZm91bmQuICBBIG5lZ2F0aXZlIGNvZGUg aXMKICAqIHJldHVybmVkIG9uIGVycm9yLiAqLwotaW50IHZob3N0X2dldF92cV9kZXNjX2JhdGNo KHN0cnVjdCB2aG9zdF92aXJ0cXVldWUgKnZxLAoraW50IHZob3N0X2dldF92cV9kZXNjKHN0cnVj dCB2aG9zdF92aXJ0cXVldWUgKnZxLAogCQkgICAgICBzdHJ1Y3QgaW92ZWMgaW92W10sIHVuc2ln bmVkIGludCBpb3Zfc2l6ZSwKIAkJICAgICAgdW5zaWduZWQgaW50ICpvdXRfbnVtLCB1bnNpZ25l ZCBpbnQgKmluX251bSwKIAkJICAgICAgc3RydWN0IHZob3N0X2xvZyAqbG9nLCB1bnNpZ25lZCBp bnQgKmxvZ19udW0pCkBAIC0yNTQ5LDcgKzIzNDcsNyBAQCBpbnQgdmhvc3RfZ2V0X3ZxX2Rlc2Nf YmF0Y2goc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsCiAJaW50IGk7CiAKIAlpZiAocmV0IDw9 IDApCi0JCWdvdG8gZXJyX2ZldGNoOworCQlnb3RvIGVycjsKIAogCS8qIE5vdyBjb252ZXJ0IHRv IElPViAqLwogCS8qIFdoZW4gd2Ugc3RhcnQgdGhlcmUgYXJlIG5vbmUgb2YgZWl0aGVyIGlucHV0 IG5vciBvdXRwdXQuICovCkBAIC0yNTU3LDcgKzIzNTUsNyBAQCBpbnQgdmhvc3RfZ2V0X3ZxX2Rl c2NfYmF0Y2goc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsCiAJaWYgKHVubGlrZWx5KGxvZykp CiAJCSpsb2dfbnVtID0gMDsKIAotCWZvciAoaSA9IDA7IGkgPCB2cS0+bmRlc2NzOyArK2kpIHsK Kwlmb3IgKGkgPSB2cS0+Zmlyc3RfZGVzYzsgaSA8IHZxLT5uZGVzY3M7ICsraSkgewogCQl1bnNp Z25lZCBpb3ZfY291bnQgPSAqaW5fbnVtICsgKm91dF9udW07CiAJCXN0cnVjdCB2aG9zdF9kZXNj ICpkZXNjID0gJnZxLT5kZXNjc1tpXTsKIAkJaW50IGFjY2VzczsKQEAgLTI2MDMsMjQgKzI0MDEs MjYgQEAgaW50IHZob3N0X2dldF92cV9kZXNjX2JhdGNoKHN0cnVjdCB2aG9zdF92aXJ0cXVldWUg KnZxLAogCQl9CiAKIAkJcmV0ID0gZGVzYy0+aWQ7CisKKwkJaWYgKCEoZGVzYy0+ZmxhZ3MgJiBW UklOR19ERVNDX0ZfTkVYVCkpCisJCQlicmVhazsKIAl9CiAKLQl2cS0+bmRlc2NzID0gMDsKKwl2 cS0+Zmlyc3RfZGVzYyA9IGkgKyAxOwogCiAJcmV0dXJuIHJldDsKIAogZXJyOgotCXZob3N0X2Rp c2NhcmRfdnFfZGVzYyh2cSwgMSk7Ci1lcnJfZmV0Y2g6Ci0JdnEtPm5kZXNjcyA9IDA7CisJdW5m ZXRjaF9kZXNjcyh2cSk7CiAKIAlyZXR1cm4gcmV0ID8gcmV0IDogdnEtPm51bTsKIH0KLUVYUE9S VF9TWU1CT0xfR1BMKHZob3N0X2dldF92cV9kZXNjX2JhdGNoKTsKK0VYUE9SVF9TWU1CT0xfR1BM KHZob3N0X2dldF92cV9kZXNjKTsKIAogLyogUmV2ZXJzZSB0aGUgZWZmZWN0IG9mIHZob3N0X2dl dF92cV9kZXNjLiBVc2VmdWwgZm9yIGVycm9yIGhhbmRsaW5nLiAqLwogdm9pZCB2aG9zdF9kaXNj YXJkX3ZxX2Rlc2Moc3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsIGludCBuKQogeworCXVuZmV0 Y2hfZGVzY3ModnEpOwogCXZxLT5sYXN0X2F2YWlsX2lkeCAtPSBuOwogfQogRVhQT1JUX1NZTUJP TF9HUEwodmhvc3RfZGlzY2FyZF92cV9kZXNjKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3Qv dmhvc3QuaCBiL2RyaXZlcnMvdmhvc3Qvdmhvc3QuaAppbmRleCA4NzA4OWQ1MTQ5MGQuLmZlZDM2 YWY1YzQ0NCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aG9zdC92aG9zdC5oCisrKyBiL2RyaXZlcnMv dmhvc3Qvdmhvc3QuaApAQCAtODEsNiArODEsNyBAQCBzdHJ1Y3Qgdmhvc3RfdmlydHF1ZXVlIHsK IAogCXN0cnVjdCB2aG9zdF9kZXNjICpkZXNjczsKIAlpbnQgbmRlc2NzOworCWludCBmaXJzdF9k ZXNjOwogCWludCBtYXhfZGVzY3M7CiAKIAlzdHJ1Y3QgZmlsZSAqa2ljazsKQEAgLTE4OSwxMCAr MTkwLDYgQEAgbG9uZyB2aG9zdF92cmluZ19pb2N0bChzdHJ1Y3Qgdmhvc3RfZGV2ICpkLCB1bnNp Z25lZCBpbnQgaW9jdGwsIHZvaWQgX191c2VyICphcmcKIGJvb2wgdmhvc3RfdnFfYWNjZXNzX29r KHN0cnVjdCB2aG9zdF92aXJ0cXVldWUgKnZxKTsKIGJvb2wgdmhvc3RfbG9nX2FjY2Vzc19vayhz dHJ1Y3Qgdmhvc3RfZGV2ICopOwogCi1pbnQgdmhvc3RfZ2V0X3ZxX2Rlc2NfYmF0Y2goc3RydWN0 IHZob3N0X3ZpcnRxdWV1ZSAqLAotCQkgICAgICBzdHJ1Y3QgaW92ZWMgaW92W10sIHVuc2lnbmVk IGludCBpb3ZfY291bnQsCi0JCSAgICAgIHVuc2lnbmVkIGludCAqb3V0X251bSwgdW5zaWduZWQg aW50ICppbl9udW0sCi0JCSAgICAgIHN0cnVjdCB2aG9zdF9sb2cgKmxvZywgdW5zaWduZWQgaW50 ICpsb2dfbnVtKTsKIGludCB2aG9zdF9nZXRfdnFfZGVzYyhzdHJ1Y3Qgdmhvc3RfdmlydHF1ZXVl ICosCiAJCSAgICAgIHN0cnVjdCBpb3ZlYyBpb3ZbXSwgdW5zaWduZWQgaW50IGlvdl9jb3VudCwK IAkJICAgICAgdW5zaWduZWQgaW50ICpvdXRfbnVtLCB1bnNpZ25lZCBpbnQgKmluX251bSwKQEAg LTI2MSw2ICsyNTgsOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgdmhvc3RfdnFfc2V0X2JhY2tlbmQo c3RydWN0IHZob3N0X3ZpcnRxdWV1ZSAqdnEsCiAJCQkJCXZvaWQgKnByaXZhdGVfZGF0YSkKIHsK IAl2cS0+cHJpdmF0ZV9kYXRhID0gcHJpdmF0ZV9kYXRhOworCXZxLT5uZGVzY3MgPSAwOworCXZx LT5maXJzdF9kZXNjID0gMDsKIH0KIAogLyoqCi0tIApNU1QKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApW aXJ0dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxp bnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 11F38C433E0 for ; Thu, 11 Jun 2020 11:34:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CFE6220760 for ; Thu, 11 Jun 2020 11:34:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="X2TTbU3w" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728060AbgFKLe3 (ORCPT ); Thu, 11 Jun 2020 07:34:29 -0400 Received: from us-smtp-delivery-1.mimecast.com ([205.139.110.120]:56666 "EHLO us-smtp-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728006AbgFKLe1 (ORCPT ); Thu, 11 Jun 2020 07:34:27 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1591875265; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=uzcn/hD20om3pnBwtyMxS4S1lnLEVknCVY1w/DpyCiU=; b=X2TTbU3wpvbizPjjH6zxCiNCK4bBSNHRCkeE4Bzv2X8aw/icPVckm8l7qhFbseO38PngGP Eo0ZBaqqI3D6BBhR1YUiTU0TcDTs0cO6bmI1PIuUb+Zh8lZXXAGrVUuj5eSmD3hkQ16Er6 CxwOoRxYsgJUZEt1WnLzu5490f97KTI= Received: from mail-wm1-f70.google.com (mail-wm1-f70.google.com [209.85.128.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-438-ie5KhTJ_OF2_vDZJcwAHGw-1; Thu, 11 Jun 2020 07:34:23 -0400 X-MC-Unique: ie5KhTJ_OF2_vDZJcwAHGw-1 Received: by mail-wm1-f70.google.com with SMTP id q7so1013238wmj.9 for ; Thu, 11 Jun 2020 04:34:23 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=uzcn/hD20om3pnBwtyMxS4S1lnLEVknCVY1w/DpyCiU=; b=DHYJM1GJT3Ll7/4kQwCstf8OVCqktDJdogb9rDACBKdV+z81B7xTvyyhHvpqMK5IDL Mh8ebse0dSCdK1WX/Bw1qwNXtKUxuWjgcPBp6iTot/cqMMsdWkd33A8NL4mnyMemJTy1 iaEOOjiIjVV8UCeArE/I9oTvdjwFhB93r05J2DlAVzwlU3PI61BNSN5nDwfyuZJglX+s jpwBUesweoUjzPo0WIsOk5K0WJyhnko/uwNOn1PnSqsn3Cz4tQtpCi/Fkfg6zH3TwXPD jmlI/432WoZcIGKPk4aiF/ObyPFAxRBBHgbspW1gmqFcpwozqk5nvoHs/khfkNmMiRFt of7Q== X-Gm-Message-State: AOAM532cJvZfCiCsJ/0tExhDxJEkYM61xBE5ojr1Ai8oSuKWRIht64sJ 1GiIdwfE7X4qTEjtlQRPZ0piUx5y1TEX5jnQ1IiFz77imHeM4RXMDkoFDyct7Xd0RxDnTeSAMYU G3IbzuDmpiMA8 X-Received: by 2002:a05:6000:10c3:: with SMTP id b3mr9573846wrx.53.1591875261848; Thu, 11 Jun 2020 04:34:21 -0700 (PDT) X-Google-Smtp-Source: ABdhPJxBHyoMe3kTcGbrbjIoEErCIDlFe/qTAjZ+Jx+f0oUg66pU5sb6YSGV4O+b9T17f3MsBwA4xA== X-Received: by 2002:a05:6000:10c3:: with SMTP id b3mr9573793wrx.53.1591875261197; Thu, 11 Jun 2020 04:34:21 -0700 (PDT) Received: from redhat.com (bzq-79-181-55-232.red.bezeqint.net. [79.181.55.232]) by smtp.gmail.com with ESMTPSA id t8sm4524885wro.56.2020.06.11.04.34.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Jun 2020 04:34:20 -0700 (PDT) Date: Thu, 11 Jun 2020 07:34:19 -0400 From: "Michael S. Tsirkin" To: linux-kernel@vger.kernel.org Cc: kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, Jason Wang , eperezma@redhat.com Subject: [PATCH RFC v8 02/11] vhost: use batched get_vq_desc version Message-ID: <20200611113404.17810-3-mst@redhat.com> References: <20200611113404.17810-1-mst@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20200611113404.17810-1-mst@redhat.com> X-Mailer: git-send-email 2.27.0.106.g8ac3dc51b1 X-Mutt-Fcc: =sent Sender: kvm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org As testing shows no performance change, switch to that now. Signed-off-by: Michael S. Tsirkin Signed-off-by: Eugenio Pérez Link: https://lore.kernel.org/r/20200401183118.8334-3-eperezma@redhat.com Signed-off-by: Michael S. Tsirkin --- drivers/vhost/test.c | 2 +- drivers/vhost/vhost.c | 314 ++++++++---------------------------------- drivers/vhost/vhost.h | 7 +- 3 files changed, 61 insertions(+), 262 deletions(-) diff --git a/drivers/vhost/test.c b/drivers/vhost/test.c index 0466921f4772..7d69778aaa26 100644 --- a/drivers/vhost/test.c +++ b/drivers/vhost/test.c @@ -119,7 +119,7 @@ static int vhost_test_open(struct inode *inode, struct file *f) dev = &n->dev; vqs[VHOST_TEST_VQ] = &n->vqs[VHOST_TEST_VQ]; n->vqs[VHOST_TEST_VQ].handle_kick = handle_vq_kick; - vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX, UIO_MAXIOV, + vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX, UIO_MAXIOV + 64, VHOST_TEST_PKT_WEIGHT, VHOST_TEST_WEIGHT, true, NULL); f->private_data = n; diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c index 11433d709651..dfcdb36d4227 100644 --- a/drivers/vhost/vhost.c +++ b/drivers/vhost/vhost.c @@ -304,6 +304,7 @@ static void vhost_vq_reset(struct vhost_dev *dev, { vq->num = 1; vq->ndescs = 0; + vq->first_desc = 0; vq->desc = NULL; vq->avail = NULL; vq->used = NULL; @@ -372,6 +373,11 @@ static int vhost_worker(void *data) return 0; } +static int vhost_vq_num_batch_descs(struct vhost_virtqueue *vq) +{ + return vq->max_descs - UIO_MAXIOV; +} + static void vhost_vq_free_iovecs(struct vhost_virtqueue *vq) { kfree(vq->descs); @@ -394,6 +400,9 @@ static long vhost_dev_alloc_iovecs(struct vhost_dev *dev) for (i = 0; i < dev->nvqs; ++i) { vq = dev->vqs[i]; vq->max_descs = dev->iov_limit; + if (vhost_vq_num_batch_descs(vq) < 0) { + return -EINVAL; + } vq->descs = kmalloc_array(vq->max_descs, sizeof(*vq->descs), GFP_KERNEL); @@ -1610,6 +1619,7 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg vq->last_avail_idx = s.num; /* Forget the cached index value. */ vq->avail_idx = vq->last_avail_idx; + vq->ndescs = vq->first_desc = 0; break; case VHOST_GET_VRING_BASE: s.index = idx; @@ -2078,253 +2088,6 @@ static unsigned next_desc(struct vhost_virtqueue *vq, struct vring_desc *desc) return next; } -static int get_indirect(struct vhost_virtqueue *vq, - struct iovec iov[], unsigned int iov_size, - unsigned int *out_num, unsigned int *in_num, - struct vhost_log *log, unsigned int *log_num, - struct vring_desc *indirect) -{ - struct vring_desc desc; - unsigned int i = 0, count, found = 0; - u32 len = vhost32_to_cpu(vq, indirect->len); - struct iov_iter from; - int ret, access; - - /* Sanity check */ - if (unlikely(len % sizeof desc)) { - vq_err(vq, "Invalid length in indirect descriptor: " - "len 0x%llx not multiple of 0x%zx\n", - (unsigned long long)len, - sizeof desc); - return -EINVAL; - } - - ret = translate_desc(vq, vhost64_to_cpu(vq, indirect->addr), len, vq->indirect, - UIO_MAXIOV, VHOST_ACCESS_RO); - if (unlikely(ret < 0)) { - if (ret != -EAGAIN) - vq_err(vq, "Translation failure %d in indirect.\n", ret); - return ret; - } - iov_iter_init(&from, READ, vq->indirect, ret, len); - - /* We will use the result as an address to read from, so most - * architectures only need a compiler barrier here. */ - read_barrier_depends(); - - count = len / sizeof desc; - /* Buffers are chained via a 16 bit next field, so - * we can have at most 2^16 of these. */ - if (unlikely(count > USHRT_MAX + 1)) { - vq_err(vq, "Indirect buffer length too big: %d\n", - indirect->len); - return -E2BIG; - } - - do { - unsigned iov_count = *in_num + *out_num; - if (unlikely(++found > count)) { - vq_err(vq, "Loop detected: last one at %u " - "indirect size %u\n", - i, count); - return -EINVAL; - } - if (unlikely(!copy_from_iter_full(&desc, sizeof(desc), &from))) { - vq_err(vq, "Failed indirect descriptor: idx %d, %zx\n", - i, (size_t)vhost64_to_cpu(vq, indirect->addr) + i * sizeof desc); - return -EINVAL; - } - if (unlikely(desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_INDIRECT))) { - vq_err(vq, "Nested indirect descriptor: idx %d, %zx\n", - i, (size_t)vhost64_to_cpu(vq, indirect->addr) + i * sizeof desc); - return -EINVAL; - } - - if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_WRITE)) - access = VHOST_ACCESS_WO; - else - access = VHOST_ACCESS_RO; - - ret = translate_desc(vq, vhost64_to_cpu(vq, desc.addr), - vhost32_to_cpu(vq, desc.len), iov + iov_count, - iov_size - iov_count, access); - if (unlikely(ret < 0)) { - if (ret != -EAGAIN) - vq_err(vq, "Translation failure %d indirect idx %d\n", - ret, i); - return ret; - } - /* If this is an input descriptor, increment that count. */ - if (access == VHOST_ACCESS_WO) { - *in_num += ret; - if (unlikely(log && ret)) { - log[*log_num].addr = vhost64_to_cpu(vq, desc.addr); - log[*log_num].len = vhost32_to_cpu(vq, desc.len); - ++*log_num; - } - } else { - /* If it's an output descriptor, they're all supposed - * to come before any input descriptors. */ - if (unlikely(*in_num)) { - vq_err(vq, "Indirect descriptor " - "has out after in: idx %d\n", i); - return -EINVAL; - } - *out_num += ret; - } - } while ((i = next_desc(vq, &desc)) != -1); - return 0; -} - -/* This looks in the virtqueue and for the first available buffer, and converts - * it to an iovec for convenient access. Since descriptors consist of some - * number of output then some number of input descriptors, it's actually two - * iovecs, but we pack them into one and note how many of each there were. - * - * This function returns the descriptor number found, or vq->num (which is - * never a valid descriptor number) if none was found. A negative code is - * returned on error. */ -int vhost_get_vq_desc(struct vhost_virtqueue *vq, - struct iovec iov[], unsigned int iov_size, - unsigned int *out_num, unsigned int *in_num, - struct vhost_log *log, unsigned int *log_num) -{ - struct vring_desc desc; - unsigned int i, head, found = 0; - u16 last_avail_idx; - __virtio16 avail_idx; - __virtio16 ring_head; - int ret, access; - - /* Check it isn't doing very strange things with descriptor numbers. */ - last_avail_idx = vq->last_avail_idx; - - if (vq->avail_idx == vq->last_avail_idx) { - if (unlikely(vhost_get_avail_idx(vq, &avail_idx))) { - vq_err(vq, "Failed to access avail idx at %p\n", - &vq->avail->idx); - return -EFAULT; - } - vq->avail_idx = vhost16_to_cpu(vq, avail_idx); - - if (unlikely((u16)(vq->avail_idx - last_avail_idx) > vq->num)) { - vq_err(vq, "Guest moved used index from %u to %u", - last_avail_idx, vq->avail_idx); - return -EFAULT; - } - - /* If there's nothing new since last we looked, return - * invalid. - */ - if (vq->avail_idx == last_avail_idx) - return vq->num; - - /* Only get avail ring entries after they have been - * exposed by guest. - */ - smp_rmb(); - } - - /* Grab the next descriptor number they're advertising, and increment - * the index we've seen. */ - if (unlikely(vhost_get_avail_head(vq, &ring_head, last_avail_idx))) { - vq_err(vq, "Failed to read head: idx %d address %p\n", - last_avail_idx, - &vq->avail->ring[last_avail_idx % vq->num]); - return -EFAULT; - } - - head = vhost16_to_cpu(vq, ring_head); - - /* If their number is silly, that's an error. */ - if (unlikely(head >= vq->num)) { - vq_err(vq, "Guest says index %u > %u is available", - head, vq->num); - return -EINVAL; - } - - /* When we start there are none of either input nor output. */ - *out_num = *in_num = 0; - if (unlikely(log)) - *log_num = 0; - - i = head; - do { - unsigned iov_count = *in_num + *out_num; - if (unlikely(i >= vq->num)) { - vq_err(vq, "Desc index is %u > %u, head = %u", - i, vq->num, head); - return -EINVAL; - } - if (unlikely(++found > vq->num)) { - vq_err(vq, "Loop detected: last one at %u " - "vq size %u head %u\n", - i, vq->num, head); - return -EINVAL; - } - ret = vhost_get_desc(vq, &desc, i); - if (unlikely(ret)) { - vq_err(vq, "Failed to get descriptor: idx %d addr %p\n", - i, vq->desc + i); - return -EFAULT; - } - if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_INDIRECT)) { - ret = get_indirect(vq, iov, iov_size, - out_num, in_num, - log, log_num, &desc); - if (unlikely(ret < 0)) { - if (ret != -EAGAIN) - vq_err(vq, "Failure detected " - "in indirect descriptor at idx %d\n", i); - return ret; - } - continue; - } - - if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_WRITE)) - access = VHOST_ACCESS_WO; - else - access = VHOST_ACCESS_RO; - ret = translate_desc(vq, vhost64_to_cpu(vq, desc.addr), - vhost32_to_cpu(vq, desc.len), iov + iov_count, - iov_size - iov_count, access); - if (unlikely(ret < 0)) { - if (ret != -EAGAIN) - vq_err(vq, "Translation failure %d descriptor idx %d\n", - ret, i); - return ret; - } - if (access == VHOST_ACCESS_WO) { - /* If this is an input descriptor, - * increment that count. */ - *in_num += ret; - if (unlikely(log && ret)) { - log[*log_num].addr = vhost64_to_cpu(vq, desc.addr); - log[*log_num].len = vhost32_to_cpu(vq, desc.len); - ++*log_num; - } - } else { - /* If it's an output descriptor, they're all supposed - * to come before any input descriptors. */ - if (unlikely(*in_num)) { - vq_err(vq, "Descriptor has out after in: " - "idx %d\n", i); - return -EINVAL; - } - *out_num += ret; - } - } while ((i = next_desc(vq, &desc)) != -1); - - /* On success, increment avail index. */ - vq->last_avail_idx++; - - /* Assume notifications from guest are disabled at this point, - * if they aren't we would need to update avail_event index. */ - BUG_ON(!(vq->used_flags & VRING_USED_F_NO_NOTIFY)); - return head; -} -EXPORT_SYMBOL_GPL(vhost_get_vq_desc); - static struct vhost_desc *peek_split_desc(struct vhost_virtqueue *vq) { BUG_ON(!vq->ndescs); @@ -2428,7 +2191,7 @@ static int fetch_indirect_descs(struct vhost_virtqueue *vq, /* This function returns a value > 0 if a descriptor was found, or 0 if none were found. * A negative code is returned on error. */ -static int fetch_descs(struct vhost_virtqueue *vq) +static int fetch_buf(struct vhost_virtqueue *vq) { unsigned int i, head, found = 0; struct vhost_desc *last; @@ -2441,7 +2204,7 @@ static int fetch_descs(struct vhost_virtqueue *vq) /* Check it isn't doing very strange things with descriptor numbers. */ last_avail_idx = vq->last_avail_idx; - if (vq->avail_idx == vq->last_avail_idx) { + if (unlikely(vq->avail_idx == vq->last_avail_idx)) { if (unlikely(vhost_get_avail_idx(vq, &avail_idx))) { vq_err(vq, "Failed to access avail idx at %p\n", &vq->avail->idx); @@ -2532,6 +2295,41 @@ static int fetch_descs(struct vhost_virtqueue *vq) return 1; } +/* This function returns a value > 0 if a descriptor was found, or 0 if none were found. + * A negative code is returned on error. */ +static int fetch_descs(struct vhost_virtqueue *vq) +{ + int ret; + + if (unlikely(vq->first_desc >= vq->ndescs)) { + vq->first_desc = 0; + vq->ndescs = 0; + } + + if (vq->ndescs) + return 1; + + for (ret = 1; + ret > 0 && vq->ndescs <= vhost_vq_num_batch_descs(vq); + ret = fetch_buf(vq)) + ; + + /* On success we expect some descs */ + BUG_ON(ret > 0 && !vq->ndescs); + return ret; +} + +/* Reverse the effects of fetch_descs */ +static void unfetch_descs(struct vhost_virtqueue *vq) +{ + int i; + + for (i = vq->first_desc; i < vq->ndescs; ++i) + if (!(vq->descs[i].flags & VRING_DESC_F_NEXT)) + vq->last_avail_idx -= 1; + vq->ndescs = 0; +} + /* This looks in the virtqueue and for the first available buffer, and converts * it to an iovec for convenient access. Since descriptors consist of some * number of output then some number of input descriptors, it's actually two @@ -2540,7 +2338,7 @@ static int fetch_descs(struct vhost_virtqueue *vq) * This function returns the descriptor number found, or vq->num (which is * never a valid descriptor number) if none was found. A negative code is * returned on error. */ -int vhost_get_vq_desc_batch(struct vhost_virtqueue *vq, +int vhost_get_vq_desc(struct vhost_virtqueue *vq, struct iovec iov[], unsigned int iov_size, unsigned int *out_num, unsigned int *in_num, struct vhost_log *log, unsigned int *log_num) @@ -2549,7 +2347,7 @@ int vhost_get_vq_desc_batch(struct vhost_virtqueue *vq, int i; if (ret <= 0) - goto err_fetch; + goto err; /* Now convert to IOV */ /* When we start there are none of either input nor output. */ @@ -2557,7 +2355,7 @@ int vhost_get_vq_desc_batch(struct vhost_virtqueue *vq, if (unlikely(log)) *log_num = 0; - for (i = 0; i < vq->ndescs; ++i) { + for (i = vq->first_desc; i < vq->ndescs; ++i) { unsigned iov_count = *in_num + *out_num; struct vhost_desc *desc = &vq->descs[i]; int access; @@ -2603,24 +2401,26 @@ int vhost_get_vq_desc_batch(struct vhost_virtqueue *vq, } ret = desc->id; + + if (!(desc->flags & VRING_DESC_F_NEXT)) + break; } - vq->ndescs = 0; + vq->first_desc = i + 1; return ret; err: - vhost_discard_vq_desc(vq, 1); -err_fetch: - vq->ndescs = 0; + unfetch_descs(vq); return ret ? ret : vq->num; } -EXPORT_SYMBOL_GPL(vhost_get_vq_desc_batch); +EXPORT_SYMBOL_GPL(vhost_get_vq_desc); /* Reverse the effect of vhost_get_vq_desc. Useful for error handling. */ void vhost_discard_vq_desc(struct vhost_virtqueue *vq, int n) { + unfetch_descs(vq); vq->last_avail_idx -= n; } EXPORT_SYMBOL_GPL(vhost_discard_vq_desc); diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h index 87089d51490d..fed36af5c444 100644 --- a/drivers/vhost/vhost.h +++ b/drivers/vhost/vhost.h @@ -81,6 +81,7 @@ struct vhost_virtqueue { struct vhost_desc *descs; int ndescs; + int first_desc; int max_descs; struct file *kick; @@ -189,10 +190,6 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg bool vhost_vq_access_ok(struct vhost_virtqueue *vq); bool vhost_log_access_ok(struct vhost_dev *); -int vhost_get_vq_desc_batch(struct vhost_virtqueue *, - struct iovec iov[], unsigned int iov_count, - unsigned int *out_num, unsigned int *in_num, - struct vhost_log *log, unsigned int *log_num); int vhost_get_vq_desc(struct vhost_virtqueue *, struct iovec iov[], unsigned int iov_count, unsigned int *out_num, unsigned int *in_num, @@ -261,6 +258,8 @@ static inline void vhost_vq_set_backend(struct vhost_virtqueue *vq, void *private_data) { vq->private_data = private_data; + vq->ndescs = 0; + vq->first_desc = 0; } /** -- MST