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 Received: from smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4A70EC433EF for ; Mon, 14 Feb 2022 10:02:06 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id CD95A405C8; Mon, 14 Feb 2022 10:02:05 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8bQ1TUxrqHH1; Mon, 14 Feb 2022 10:02:04 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp4.osuosl.org (Postfix) with ESMTPS id B39E44055E; Mon, 14 Feb 2022 10:02:03 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 89176C001A; Mon, 14 Feb 2022 10:02:03 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id D71B2C000B for ; Mon, 14 Feb 2022 10:02:02 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id C1F0D403AC for ; Mon, 14 Feb 2022 10:02:02 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp2.osuosl.org (amavisd-new); dkim=pass (2048-bit key) header.d=intel.com Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id MNXvNPkyKEXo for ; Mon, 14 Feb 2022 10:02:00 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by smtp2.osuosl.org (Postfix) with ESMTPS id B152740128 for ; Mon, 14 Feb 2022 10:02:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644832920; x=1676368920; h=message-id:date:mime-version:subject:to:cc:references: from:in-reply-to:content-transfer-encoding; bh=ipjinYtAKhvrbAhw4wh4jYUm4H1/qbkIoQb9U6XOyoE=; b=PqhDLl/0fZMgkw5RG+/Z/6UkGr/Js7TTpOh7lRnBH1nA66QbmN3B4rFr Hlf0MyFdJRpSPhQv/r1XwuM/EMK8Pw+hayqF05bv6hC83qecad3FGJWOT JyuFFN0TtWU4Si58ixxqSUleKGkwAqNLr9S4JyNzVzW3CAyBCgYuqmARP 740jOasmzrd2klzw5gk4jlzhAkBJZXfWkztkzCmK9aSTgAHRkdjmyz5OT mTGi9jFa3NA5sl7RKg7mXKTA2fx4JzvNxQ01ULeXlrkhsA3bFs5/kP+PZ OrXJGkHVaUf1Bb0FgE60RE/X6R34iFdXh7jP5xTqZEcsfcfI6ZDbgbAdC Q==; X-IronPort-AV: E=McAfee;i="6200,9189,10257"; a="237467926" X-IronPort-AV: E=Sophos;i="5.88,367,1635231600"; d="scan'208";a="237467926" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Feb 2022 02:02:00 -0800 X-IronPort-AV: E=Sophos;i="5.88,367,1635231600"; d="scan'208";a="543383795" Received: from lingshan-mobl.ccr.corp.intel.com (HELO [10.249.175.112]) ([10.249.175.112]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Feb 2022 02:01:58 -0800 Message-ID: <449aa3a3-06c8-1236-241e-42ea5b7d8877@linux.intel.com> Date: Mon, 14 Feb 2022 18:01:56 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0 Thunderbird/91.5.1 Subject: Re: [PATCH V4 4/4] vDPA/ifcvf: implement shared IRQ feature Content-Language: en-US To: Jason Wang , Zhu Lingshan , mst@redhat.com References: <20220203072735.189716-1-lingshan.zhu@intel.com> <20220203072735.189716-5-lingshan.zhu@intel.com> From: Zhu Lingshan In-Reply-To: Cc: netdev@vger.kernel.org, virtualization@lists.linux-foundation.org X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CgpPbiAyLzE0LzIwMjIgMzoxOSBQTSwgSmFzb24gV2FuZyB3cm90ZToKPgo+IOWcqCAyMDIyLzIv MyDkuIvljYgzOjI3LCBaaHUgTGluZ3NoYW4g5YaZ6YGTOgo+PiBPbiBzb21lIHBsYXRmb3Jtcy9k ZXZpY2VzLCB0aGVyZSBtYXkgbm90IGJlIGVub3VnaCBNU0kgdmVjdG9yCj4+IHNsb3RzIGFsbG9j YXRlZCBmb3IgdmlydHF1ZXVlcyBhbmQgY29uZmlnIGNoYW5nZXMuIEluIHN1Y2ggYSBjYXNlLAo+ PiB0aGUgaW50ZXJydXB0IHNvdXJjZXModmlydHF1ZXVlcywgY29uZmlnIGNoYW5nZXMpIG11c3Qg c2hhcmUKPj4gYW4gSVJRL3ZlY3RvciwgdG8gYXZvaWQgaW5pdGlhbGl6YXRpb24gZmFpbHVyZXMs IGtlZXAKPj4gdGhlIGRldmljZSBmdW5jdGlvbmFsLgo+Pgo+PiBUaGlzIGNvbW1pdCBoYW5kbGVz IHRocmVlIGNhc2VzOgo+PiAoMSkgbnVtYmVyIG9mIHRoZSBhbGxvY2F0ZWQgdmVjdG9ycyA9PSB0 aGUgbnVtYmVyIG9mIHZpcnRxdWV1ZXMgKyAxCj4+IChjb25maWcgY2hhbmdlcyksIGV2ZXJ5IHZp cnRxdWV1ZSBhbmQgdGhlIGNvbmZpZyBpbnRlcnJ1cHQgaGFzCj4+IGEgc2VwYXJhdGVkIHZlY3Rv ci9JUlEsIHRoZSBiZXN0IGFuZCB0aGUgbW9zdCBsaWtlbHkgY2FzZS4KPj4gKDIpIG51bWJlciBv ZiB0aGUgYWxsb2NhdGVkIHZlY3RvcnMgaXMgbGVzcyB0aGFuIHRoZSBiZXN0IGNhc2UsIGJ1dAo+ PiBncmVhdGVyIHRoYW4gMS4gSW4gdGhpcyBjYXNlLCBhbGwgdmlydHF1ZXVlcyBzaGFyZSBhIHZl Y3Rvci9JUlEsCj4+IHRoZSBjb25maWcgaW50ZXJydXB0IGhhcyBhIHNlcGFyYXRlZCB2ZWN0b3Iv SVJRCj4+ICgzKSBvbmx5IG9uZSB2ZWN0b3IgaXMgYWxsb2NhdGVkLCBpbiB0aGlzIGNhc2UsIHRo ZSB2aXJ0cXVldWVzIGFuZAo+PiB0aGUgY29uZmlnIGludGVycnVwdCBzaGFyZSBhIHZlY3Rvci9J UlEuIFRoZSB3b3JzdCBhbmQgbW9zdAo+PiB1bmxpa2VseSBjYXNlLgo+Pgo+PiBPdGhlcndpc2Us IGl0IG5lZWRzIHRvIGZhaWwuCj4+Cj4+IFRoaXMgY29tbWl0IGludHJvZHVjZXMgc29tZSBoZWxw ZXIgZnVuY3Rpb25zOgo+PiBpZmN2Zl9zZXRfdnFfdmVjdG9yKCkgYW5kIGlmY3ZmX3NldF9jb25m aWdfdmVjdG9yKCkgc2V0cyB2aXJ0cXVldWUKPj4gdmVjdG9yIGFuZCBjb25maWcgdmVjdG9yIGlu IHRoZSBkZXZpY2UgY29uZmlnIHNwYWNlLCBzbyB0aGF0Cj4+IHRoZSBkZXZpY2UgY2FuIHNlbmQg aW50ZXJydXB0IERNQS4KPj4KPj4gVGhpcyBjb21taXQgYWRkcyBzb21lIGZpZWxkcyBpbiBzdHJ1 Y3QgaWZjdmZfaHcgYW5kIHJlLXBsYWNlZAo+PiB0aGUgZXhpc3RlZCBmaWVsZHMgdG8gYmUgYWxp Z25lZCB3aXRoIHRoZSBjYWNoZWxpbmUuCj4+Cj4+IFNpZ25lZC1vZmYtYnk6IFpodSBMaW5nc2hh biA8bGluZ3NoYW4uemh1QGludGVsLmNvbT4KPj4gLS0tCj4+IMKgIGRyaXZlcnMvdmRwYS9pZmN2 Zi9pZmN2Zl9iYXNlLmMgfMKgIDQ3ICsrKystLQo+PiDCoCBkcml2ZXJzL3ZkcGEvaWZjdmYvaWZj dmZfYmFzZS5oIHzCoCAyMyArKy0KPj4gwqAgZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX21haW4u YyB8IDI0MyArKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLQo+PiDCoCAzIGZpbGVzIGNo YW5nZWQsIDI1NiBpbnNlcnRpb25zKCspLCA1NyBkZWxldGlvbnMoLSkKPj4KPj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9iYXNlLmMgCj4+IGIvZHJpdmVycy92ZHBhL2lm Y3ZmL2lmY3ZmX2Jhc2UuYwo+PiBpbmRleCAzOTc2OTJhZTY3MWMuLjE4ZGNiNjNhYjFlMyAxMDA2 NDQKPj4gLS0tIGEvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuYwo+PiArKysgYi9kcml2 ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfYmFzZS5jCj4+IEBAIC0xNSw2ICsxNSwzNiBAQCBzdHJ1Y3Qg aWZjdmZfYWRhcHRlciAqdmZfdG9fYWRhcHRlcihzdHJ1Y3QgCj4+IGlmY3ZmX2h3ICpodykKPj4g wqDCoMKgwqDCoCByZXR1cm4gY29udGFpbmVyX29mKGh3LCBzdHJ1Y3QgaWZjdmZfYWRhcHRlciwg dmYpOwo+PiDCoCB9Cj4+IMKgICtpbnQgaWZjdmZfc2V0X3ZxX3ZlY3RvcihzdHJ1Y3QgaWZjdmZf aHcgKmh3LCB1MTYgcWlkLCBpbnQgdmVjdG9yKQo+PiArewo+PiArwqDCoMKgIHN0cnVjdCB2aXJ0 aW9fcGNpX2NvbW1vbl9jZmcgX19pb21lbSAqY2ZnID0gaHctPmNvbW1vbl9jZmc7Cj4+ICvCoMKg wqAgc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKmlmY3ZmID0gdmZfdG9fYWRhcHRlcihodyk7Cj4+ICsK Pj4gK8KgwqDCoCBpZmNfaW93cml0ZTE2KHFpZCwgJmNmZy0+cXVldWVfc2VsZWN0KTsKPj4gK8Kg wqDCoCBpZmNfaW93cml0ZTE2KHZlY3RvciwgJmNmZy0+cXVldWVfbXNpeF92ZWN0b3IpOwo+PiAr wqDCoMKgIGlmIChpZmNfaW9yZWFkMTYoJmNmZy0+cXVldWVfbXNpeF92ZWN0b3IpID09IAo+PiBW SVJUSU9fTVNJX05PX1ZFQ1RPUikgewo+PiArwqDCoMKgwqDCoMKgwqAgSUZDVkZfRVJSKGlmY3Zm LT5wZGV2LCAiTm8gbXNpeCB2ZWN0b3IgZm9yIHF1ZXVlICV1XG4iLCBxaWQpOwo+PiArwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPj4gK8KgwqDCoCB9Cj4KPgo+IExldCdz IGxlYXZlIHRoaXMgY2hlY2sgZm9yIHRoZSBjYWxsZXIsIEUuZyBjYW4gY2FsbGVyIHRyeSB0byBh c3NpZ24gCj4gTk9fVkVDVE9SIGR1cmluZyB1bmktbml0PwppZmN2ZiBkcml2ZXIgc2V0cyBOT19W RUNUT1Igd2hlbiBjYWxsIGh3X2Rpc2FibGUoKS4gSSBhbSBub3Qgc3VyZSAKd2hldGhlciBJIGdl dCBpdCwKWWVzIHdlIGNhbiBsZXQgdGhlIGNhbGxlciBjaGVjayBhIHZxIHZlY3RvciwgaG93ZXZl ciB0aGlzIG1heSBjYXVzZSBtb3JlIAp0aGFuIHRocmVlIGxldmVscyBicmFja2V0cywgbWF5IGxv b2tzIHVnbHkuCj4KPgo+PiArCj4+ICvCoMKgwqAgcmV0dXJuIDA7Cj4+ICt9Cj4+ICsKPj4gK2lu dCBpZmN2Zl9zZXRfY29uZmlnX3ZlY3RvcihzdHJ1Y3QgaWZjdmZfaHcgKmh3LCBpbnQgdmVjdG9y KQo+PiArewo+PiArwqDCoMKgIHN0cnVjdCB2aXJ0aW9fcGNpX2NvbW1vbl9jZmcgX19pb21lbSAq Y2ZnID0gaHctPmNvbW1vbl9jZmc7Cj4+ICvCoMKgwqAgc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKmlm Y3ZmID0gdmZfdG9fYWRhcHRlcihodyk7Cj4+ICsKPj4gK8KgwqDCoCBjZmcgPSBody0+Y29tbW9u X2NmZzsKPj4gK8KgwqDCoCBpZmNfaW93cml0ZTE2KHZlY3RvcizCoCAmY2ZnLT5tc2l4X2NvbmZp Zyk7Cj4+ICvCoMKgwqAgaWYgKGlmY19pb3JlYWQxNigmY2ZnLT5tc2l4X2NvbmZpZykgPT0gVklS VElPX01TSV9OT19WRUNUT1IpIHsKPj4gK8KgwqDCoMKgwqDCoMKgIElGQ1ZGX0VSUihpZmN2Zi0+ cGRldiwgIk5vIG1zaXggdmVjdG9yIGZvciBkZXZpY2UgY29uZmlnXG4iKTsKPj4gK8KgwqDCoMKg wqDCoMKgIHJldHVybiAtRUlOVkFMOwo+PiArwqDCoMKgIH0KPgo+Cj4gU2ltaWxhciBxdWVzdGlv biBhcyBhYm92ZS4KPgo+Cj4+ICsKPj4gK8KgwqDCoCByZXR1cm4gMDsKPj4gK30KPj4gKwo+PiDC oCBzdGF0aWMgdm9pZCBfX2lvbWVtICpnZXRfY2FwX2FkZHIoc3RydWN0IGlmY3ZmX2h3ICpodywK Pj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IHZpcnRpb19w Y2lfY2FwICpjYXApCj4+IMKgIHsKPj4gQEAgLTE0MCw2ICsxNzAsOCBAQCBpbnQgaWZjdmZfaW5p dF9odyhzdHJ1Y3QgaWZjdmZfaHcgKmh3LCBzdHJ1Y3QgCj4+IHBjaV9kZXYgKnBkZXYpCj4+IMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgaHctPmNvbW1vbl9jZmcsIGh3LT5ub3RpZnlfYmFzZSwgaHct PmlzciwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBody0+ZGV2X2NmZywgaHctPm5vdGlmeV9v ZmZfbXVsdGlwbGllcik7Cj4+IMKgICvCoMKgwqAgaHctPnZxc19zaGFyZWRfaXJxID0gLUVJTlZB TDsKPj4gKwo+PiDCoMKgwqDCoMKgIHJldHVybiAwOwo+PiDCoCB9Cj4+IMKgIEBAIC0zMjEsMTIg KzM1Myw2IEBAIHN0YXRpYyBpbnQgaWZjdmZfaHdfZW5hYmxlKHN0cnVjdCBpZmN2Zl9odyAqaHcp Cj4+IMKgIMKgwqDCoMKgwqAgaWZjdmYgPSB2Zl90b19hZGFwdGVyKGh3KTsKPj4gwqDCoMKgwqDC oCBjZmcgPSBody0+Y29tbW9uX2NmZzsKPj4gLcKgwqDCoCBpZmNfaW93cml0ZTE2KElGQ1ZGX01T SV9DT05GSUdfT0ZGLCAmY2ZnLT5tc2l4X2NvbmZpZyk7Cj4+IC0KPj4gLcKgwqDCoCBpZiAoaWZj X2lvcmVhZDE2KCZjZmctPm1zaXhfY29uZmlnKSA9PSBWSVJUSU9fTVNJX05PX1ZFQ1RPUikgewo+ PiAtwqDCoMKgwqDCoMKgwqAgSUZDVkZfRVJSKGlmY3ZmLT5wZGV2LCAiTm8gbXNpeCB2ZWN0b3Ig Zm9yIGRldmljZSBjb25maWdcbiIpOwo+PiAtwqDCoMKgwqDCoMKgwqAgcmV0dXJuIC1FSU5WQUw7 Cj4+IC3CoMKgwqAgfQo+PiDCoCDCoMKgwqDCoMKgIGZvciAoaSA9IDA7IGkgPCBody0+bnJfdnJp bmc7IGkrKykgewo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgaWYgKCFody0+dnJpbmdbaV0ucmVhZHkp Cj4+IEBAIC0zNDAsMTUgKzM2Niw2IEBAIHN0YXRpYyBpbnQgaWZjdmZfaHdfZW5hYmxlKHN0cnVj dCBpZmN2Zl9odyAqaHcpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBpZmNfaW93cml0ZTY0X3R3b3Bh cnQoaHctPnZyaW5nW2ldLnVzZWQsICZjZmctPnF1ZXVlX3VzZWRfbG8sCj4+IMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICZjZmctPnF1ZXVlX3VzZWRfaGkpOwo+ PiDCoMKgwqDCoMKgwqDCoMKgwqAgaWZjX2lvd3JpdGUxNihody0+dnJpbmdbaV0uc2l6ZSwgJmNm Zy0+cXVldWVfc2l6ZSk7Cj4+IC3CoMKgwqDCoMKgwqDCoCBpZmNfaW93cml0ZTE2KGkgKyBJRkNW Rl9NU0lfUVVFVUVfT0ZGLCAKPj4gJmNmZy0+cXVldWVfbXNpeF92ZWN0b3IpOwo+PiAtCj4+IC3C oMKgwqDCoMKgwqDCoCBpZiAoaWZjX2lvcmVhZDE2KCZjZmctPnF1ZXVlX21zaXhfdmVjdG9yKSA9 PQo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBWSVJUSU9fTVNJX05PX1ZFQ1RPUikgewo+PiAt wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBJRkNWRl9FUlIoaWZjdmYtPnBkZXYsCj4+IC3CoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICJObyBtc2l4IHZlY3RvciBmb3IgcXVldWUgJXVc biIsIGkpOwo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPj4gLcKg wqDCoMKgwqDCoMKgIH0KPj4gLQo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgaWZjdmZfc2V0X3ZxX3N0 YXRlKGh3LCBpLCBody0+dnJpbmdbaV0ubGFzdF9hdmFpbF9pZHgpOwo+PiDCoMKgwqDCoMKgwqDC oMKgwqAgaWZjX2lvd3JpdGUxNigxLCAmY2ZnLT5xdWV1ZV9lbmFibGUpOwo+PiDCoMKgwqDCoMKg IH0KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9iYXNlLmggCj4+IGIv ZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuaAo+PiBpbmRleCA5NDliNGZiOWQ1NTQuLjlj ZmUwODhjODJlOSAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2Uu aAo+PiArKysgYi9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfYmFzZS5oCj4+IEBAIC0yNyw4ICsy Nyw2IEBACj4+IMKgIMKgICNkZWZpbmUgSUZDVkZfUVVFVUVfQUxJR05NRU5UwqDCoMKgIFBBR0Vf U0laRQo+PiDCoCAjZGVmaW5lIElGQ1ZGX1FVRVVFX01BWMKgwqDCoMKgwqDCoMKgIDMyNzY4Cj4+ IC0jZGVmaW5lIElGQ1ZGX01TSV9DT05GSUdfT0ZGwqDCoMKgIDAKPj4gLSNkZWZpbmUgSUZDVkZf TVNJX1FVRVVFX09GRsKgwqDCoCAxCj4+IMKgICNkZWZpbmUgSUZDVkZfUENJX01BWF9SRVNPVVJD RcKgwqDCoCA2Cj4+IMKgIMKgICNkZWZpbmUgSUZDVkZfTE1fQ0ZHX1NJWkXCoMKgwqDCoMKgwqDC oCAweDQwCj4+IEBAIC00Miw2ICs0MCwxMyBAQAo+PiDCoCAjZGVmaW5lIGlmY3ZmX3ByaXZhdGVf dG9fdmYoYWRhcHRlcikgXAo+PiDCoMKgwqDCoMKgICgmKChzdHJ1Y3QgaWZjdmZfYWRhcHRlciAq KWFkYXB0ZXIpLT52ZikKPj4gwqAgKy8qIGFsbCB2cXMgYW5kIGNvbmZpZyBpbnRlcnJ1cHQgaGFz IGl0cyBvd24gdmVjdG9yICovCj4+ICsjZGVmaW5lIE1TSVhfVkVDVE9SX1BFUl9WUV9BTkRfQ09O RklHwqDCoMKgwqDCoMKgwqAgMQo+PiArLyogYWxsIHZxcyBzaGFyZSBhIHZlY3RvciwgYW5kIGNv bmZpZyBpbnRlcnJ1cHQgaGFzIGEgc2VwYXJhdGUgCj4+IHZlY3RvciAqLwo+PiArI2RlZmluZSBN U0lYX1ZFQ1RPUl9TSEFSRURfVlFfQU5EX0NPTkZJR8KgwqDCoCAyCj4+ICsvKiBhbGwgdnFzIGFu ZCBjb25maWcgaW50ZXJydXB0IHNoYXJlIGEgdmVjdG9yICovCj4+ICsjZGVmaW5lIE1TSVhfVkVD VE9SX0RFVl9TSEFSRUTCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIDMKPgo+Cj4gSSB0aGluayB0aGVy ZSdzIG5vIG11Y2ggdmFsdWUgdG8gZGlmZmVyIDIgZnJvbSAzIGNvbnNpZGVyIGNvbmZpZyAKPiBp bnRlcnJ1cHQgc2hvdWxkIGJlIHJhcmUuCklNSE8gd2Ugc3RpbGwgbmVlZCAyIGFuZCAzLCBiZWNh dXNlIE1TSVhfVkVDVE9SX1NIQVJFRF9WUV9BTkRfQ09ORklHIAptZWFucyB0aGVyZSBhcmUgYXQg bGVhc3QgMiB2ZWN0b3JzLAp0aGUgdnFzIHNoYXJlIG9uZSB2ZWN0b3IsIGNvbmZpZyBjaGFuZ2Ug aGFzIGl0cyBvd24gdmVjdG9yLgpNU0lYX1ZFQ1RPUl9ERVZfU0hBUkVEIG1lYW5zIHRocmVlIGFy ZSBvbmx5IG9uZSB2ZWN0b3IsIGFsbCB2cXMgYW5kIApjb25maWcgY2hhbmdlcyBuZWVkIHRvIHNo YXJlIHRoaXMgdmVjdG9yLgo+Cj4KPgo+PiArCj4+IMKgIHN0YXRpYyBpbmxpbmUgdTggaWZjX2lv cmVhZDgodTggX19pb21lbSAqYWRkcikKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHJldHVybiBpb3Jl YWQ4KGFkZHIpOwo+PiBAQCAtOTcsMjUgKzEwMiwyNyBAQCBzdHJ1Y3QgaWZjdmZfaHcgewo+PiDC oMKgwqDCoMKgIHU4IF9faW9tZW0gKmlzcjsKPj4gwqDCoMKgwqDCoCAvKiBMaXZlIG1pZ3JhdGlv biAqLwo+PiDCoMKgwqDCoMKgIHU4IF9faW9tZW0gKmxtX2NmZzsKPj4gLcKgwqDCoCB1MTYgbnJf dnJpbmc7Cj4KPgo+IEFueSByZWFzb24gZm9yIG1vdmluZyBudl92cmluZywgY29uZmlnX3NpemUs IGFuZCBvdGhlciBzdHVmZnM/CmZvciBjYWNoZWxpbmUgYWxpZ25tZW50Lgo+Cj4KPgo+PiDCoMKg wqDCoMKgIC8qIE5vdGlmaWNhdGlvbiBiYXIgbnVtYmVyICovCj4+IMKgwqDCoMKgwqAgdTggbm90 aWZ5X2JhcjsKPj4gK8KgwqDCoCB1OCBtc2l4X3ZlY3Rvcl9zdGF0dXM7Cj4+ICvCoMKgwqAgLyog dmlydGlvLW5ldCBvciB2aXJ0aW8tYmxrIGRldmljZSBjb25maWcgc2l6ZSAqLwo+PiArwqDCoMKg IHUzMiBjb25maWdfc2l6ZTsKPj4gwqDCoMKgwqDCoCAvKiBOb3RpZmljYWl0b24gYmFyIGFkZHJl c3MgKi8KPj4gwqDCoMKgwqDCoCB2b2lkIF9faW9tZW0gKm5vdGlmeV9iYXNlOwo+PiDCoMKgwqDC oMKgIHBoeXNfYWRkcl90IG5vdGlmeV9iYXNlX3BhOwo+PiDCoMKgwqDCoMKgIHUzMiBub3RpZnlf b2ZmX211bHRpcGxpZXI7Cj4+ICvCoMKgwqAgdTMyIGRldl90eXBlOwo+PiDCoMKgwqDCoMKgIHU2 NCByZXFfZmVhdHVyZXM7Cj4+IMKgwqDCoMKgwqAgdTY0IGh3X2ZlYXR1cmVzOwo+PiAtwqDCoMKg IHUzMiBkZXZfdHlwZTsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgdmlydGlvX3BjaV9jb21tb25fY2Zn IF9faW9tZW0gKmNvbW1vbl9jZmc7Cj4+IMKgwqDCoMKgwqAgdm9pZCBfX2lvbWVtICpkZXZfY2Zn Owo+PiDCoMKgwqDCoMKgIHN0cnVjdCB2cmluZ19pbmZvIHZyaW5nW0lGQ1ZGX01BWF9RVUVVRVNd Owo+PiDCoMKgwqDCoMKgIHZvaWQgX19pb21lbSAqIGNvbnN0ICpiYXNlOwo+PiDCoMKgwqDCoMKg IGNoYXIgY29uZmlnX21zaXhfbmFtZVsyNTZdOwo+PiDCoMKgwqDCoMKgIHN0cnVjdCB2ZHBhX2Nh bGxiYWNrIGNvbmZpZ19jYjsKPj4gLcKgwqDCoCB1bnNpZ25lZCBpbnQgY29uZmlnX2lycTsKPj4g LcKgwqDCoCAvKiB2aXJ0aW8tbmV0IG9yIHZpcnRpby1ibGsgZGV2aWNlIGNvbmZpZyBzaXplICov Cj4+IC3CoMKgwqAgdTMyIGNvbmZpZ19zaXplOwo+PiArwqDCoMKgIGludCBjb25maWdfaXJxOwo+ PiArwqDCoMKgIGludCB2cXNfc2hhcmVkX2lycTsKPj4gK8KgwqDCoCB1MTYgbnJfdnJpbmc7Cj4+ IMKgIH07Cj4+IMKgIMKgIHN0cnVjdCBpZmN2Zl9hZGFwdGVyIHsKPj4gQEAgLTE2MCw0ICsxNjcs NiBAQCBpbnQgaWZjdmZfc2V0X3ZxX3N0YXRlKHN0cnVjdCBpZmN2Zl9odyAqaHcsIHUxNiAKPj4g cWlkLCB1MTYgbnVtKTsKPj4gwqAgc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKnZmX3RvX2FkYXB0ZXIo c3RydWN0IGlmY3ZmX2h3ICpodyk7Cj4+IMKgIGludCBpZmN2Zl9wcm9iZWRfdmlydGlvX25ldChz dHJ1Y3QgaWZjdmZfaHcgKmh3KTsKPj4gwqAgdTMyIGlmY3ZmX2dldF9jb25maWdfc2l6ZShzdHJ1 Y3QgaWZjdmZfaHcgKmh3KTsKPj4gK2ludCBpZmN2Zl9zZXRfdnFfdmVjdG9yKHN0cnVjdCBpZmN2 Zl9odyAqaHcsIHUxNiBxaWQsIGludCB2ZWN0b3IpOwo+PiAraW50IGlmY3ZmX3NldF9jb25maWdf dmVjdG9yKHN0cnVjdCBpZmN2Zl9odyAqaHcsIGludCB2ZWN0b3IpOwo+PiDCoCAjZW5kaWYgLyog X0lGQ1ZGX0hfICovCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFp bi5jIAo+PiBiL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9tYWluLmMKPj4gaW5kZXggNDRjODlh YjBiNmRhLi5jYTQxNDM5OWYwNDAgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvdmRwYS9pZmN2Zi9p ZmN2Zl9tYWluLmMKPj4gKysrIGIvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX21haW4uYwo+PiBA QCAtMTcsNiArMTcsNyBAQAo+PiDCoCAjZGVmaW5lIERSSVZFUl9BVVRIT1LCoMKgICJJbnRlbCBD b3Jwb3JhdGlvbiIKPj4gwqAgI2RlZmluZSBJRkNWRl9EUklWRVJfTkFNRcKgwqDCoMKgwqDCoCAi aWZjdmYiCj4+IMKgICsvKiBoYW5kbGVzIGNvbmZpZyBpbnRlcnJ1cHQgKi8KPgo+Cj4gVGhpcyBz ZWVtcyB1bnJlbGF0ZWQgdG8gdGhlIHNoYXJlZCBJUlEgbG9naWMgYW5kIGl0IGxvb2tzIHVzZWxl c3MgCj4gc2luY2UgaXQncyBlYXNpbHkgdG8gZGVkdWNlIGl0IGZyb20gdGhlIGZ1bmN0aW9uIG5h bWUgYmVsb3cuCk9LLCBkbyB5b3UgbWVhbiB0aGUgY29tbWVudHM/IEkgY2FuIHJlbW92ZSB0aGVz ZSBjb21tZW50cy4KPgo+Cj4+IMKgIHN0YXRpYyBpcnFyZXR1cm5fdCBpZmN2Zl9jb25maWdfY2hh bmdlZChpbnQgaXJxLCB2b2lkICphcmcpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgaWZj dmZfaHcgKnZmID0gYXJnOwo+PiBAQCAtMjcsNiArMjgsNyBAQCBzdGF0aWMgaXJxcmV0dXJuX3Qg aWZjdmZfY29uZmlnX2NoYW5nZWQoaW50IGlycSwgCj4+IHZvaWQgKmFyZykKPj4gwqDCoMKgwqDC oCByZXR1cm4gSVJRX0hBTkRMRUQ7Cj4+IMKgIH0KPj4gwqAgKy8qIGhhbmRsZXMgdnFzIGludGVy cnVwdCAqLwo+Cj4KPiBTbyBkaWQgdGhpcy4KPgo+Cj4+IMKgIHN0YXRpYyBpcnFyZXR1cm5fdCBp ZmN2Zl9pbnRyX2hhbmRsZXIoaW50IGlycSwgdm9pZCAqYXJnKQo+PiDCoCB7Cj4+IMKgwqDCoMKg wqAgc3RydWN0IHZyaW5nX2luZm8gKnZyaW5nID0gYXJnOwo+PiBAQCAtMzcsMjQgKzM5LDc4IEBA IHN0YXRpYyBpcnFyZXR1cm5fdCBpZmN2Zl9pbnRyX2hhbmRsZXIoaW50IGlycSwgCj4+IHZvaWQg KmFyZykKPj4gwqDCoMKgwqDCoCByZXR1cm4gSVJRX0hBTkRMRUQ7Cj4+IMKgIH0KPj4gwqAgKy8q IGhhbmRscyB2cXMgc2hhcmVkIGludGVycnVwdCAqLwo+PiArc3RhdGljIGlycXJldHVybl90IGlm Y3ZmX3ZxX3NoYXJlZF9pbnRyX2hhbmRsZXIoaW50IGlycSwgdm9pZCAqYXJnKQo+PiArewo+PiAr wqDCoMKgIHN0cnVjdCBpZmN2Zl9odyAqdmYgPSBhcmc7Cj4+ICvCoMKgwqAgc3RydWN0IHZyaW5n X2luZm8gKnZyaW5nOwo+PiArwqDCoMKgIGludCBpOwo+PiArCj4+ICvCoMKgwqAgZm9yIChpID0g MDsgaSA8IHZmLT5ucl92cmluZzsgaSsrKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCB2cmluZyA9ICZ2 Zi0+dnJpbmdbaV07Cj4+ICvCoMKgwqDCoMKgwqDCoCBpZiAodnJpbmctPmNiLmNhbGxiYWNrKQo+ PiArIHZmLT52cmluZy0+Y2IuY2FsbGJhY2sodnJpbmctPmNiLnByaXZhdGUpOwo+PiArwqDCoMKg IH0KPj4gKwo+PiArwqDCoMKgIHJldHVybiBJUlFfSEFORExFRDsKPj4gK30KPj4gKwo+PiArLyog aGFuZGxlcyBhIHNoYXJlZCBpbnRlcnJ1cHQgZm9yIHZxcyBhbmQgY29uZmlnICovCj4+ICtzdGF0 aWMgaXJxcmV0dXJuX3QgaWZjdmZfZGV2X3NoYXJlZF9pbnRyX2hhbmRsZXIoaW50IGlycSwgdm9p ZCAqYXJnKQo+PiArewo+PiArwqDCoMKgIHN0cnVjdCBpZmN2Zl9odyAqdmYgPSBhcmc7Cj4+ICvC oMKgwqAgdTggaXNyOwo+PiArCj4+ICvCoMKgwqAgaXNyID0gaWZjX2lvcmVhZDgodmYtPmlzcik7 Cj4KPgo+IFdlIG5lZWQgdG8gZXhhY3RseSB3aGF0IHZwX2ludGVycnVwdCBkbyBoZXJlLiBDaGVj a2luZyBhZ2FpbnN0IHZmLT5pc3IgCj4gZmlyc3QgYW5kIHJldHVybiBJUlFfTk9ORSBpZiBpdCBp cyBub3Qgc2V0Lgo+Cj4gQWx3YXlzIHJldHVybiBJUlFfSEFORExFRCB3aWxsIGJyZWFrIHRoZSBk ZXZpY2Ugd2hvIHNoYXJlcyBhbiBpcnEgd2l0aCAKPiBJRkNWRi4KYXMgd2UgZGlzY3Vzc2VkIGlu IGFub3RoZXIgdGhyZWFkKHNwZWMgaW5jb25zaXN0ZW5jeSBhYm91dCBJU1IpLCBJU1IgbWF5IApv bmx5IHdvcmtzIGZvciBJTlR4IGZvciBub3csCmJ1dCBWRnMgZG9uJ3QgaGF2ZSBJTlR4LCBhbmQg YSBWRiBtYXkgbm90IHNoYXJlIGl0cyB2ZWN0b3JzIHdpdGggb3RoZXIgCmRldmljZXMsIHNvIEkg Z3Vlc3MgaXQgY2FuIHdvcmsKYW5kIG1heSBiZSBvdXIgYmVzdCB0cnkgZm9yIG5vdy4KPgo+Cj4+ ICvCoMKgwqAgaWYgKGlzciAmIFZJUlRJT19QQ0lfSVNSX0NPTkZJRykKPj4gK8KgwqDCoMKgwqDC oMKgIGlmY3ZmX2NvbmZpZ19jaGFuZ2VkKGlycSwgYXJnKTsKPj4gKwo+PiArwqDCoMKgIHJldHVy biBpZmN2Zl92cV9zaGFyZWRfaW50cl9oYW5kbGVyKGlycSwgYXJnKTsKPj4gK30KPj4gKwo+PiDC oCBzdGF0aWMgdm9pZCBpZmN2Zl9mcmVlX2lycV92ZWN0b3JzKHZvaWQgKmRhdGEpCj4+IMKgIHsK Pj4gwqDCoMKgwqDCoCBwY2lfZnJlZV9pcnFfdmVjdG9ycyhkYXRhKTsKPj4gwqAgfQo+PiDCoCAt c3RhdGljIHZvaWQgaWZjdmZfZnJlZV9pcnEoc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKmFkYXB0ZXIs IGludCBxdWV1ZXMpCj4+ICtzdGF0aWMgdm9pZCBpZmN2Zl9mcmVlX3ZxX2lycShzdHJ1Y3QgaWZj dmZfYWRhcHRlciAqYWRhcHRlciwgaW50IAo+PiBxdWV1ZXMpCj4+IMKgIHsKPj4gwqDCoMKgwqDC oCBzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IGFkYXB0ZXItPnBkZXY7Cj4+IMKgwqDCoMKgwqAgc3Ry dWN0IGlmY3ZmX2h3ICp2ZiA9ICZhZGFwdGVyLT52ZjsKPj4gwqDCoMKgwqDCoCBpbnQgaTsKPj4g wqAgK8KgwqDCoCBpZiAodmYtPm1zaXhfdmVjdG9yX3N0YXR1cyA9PSBNU0lYX1ZFQ1RPUl9QRVJf VlFfQU5EX0NPTkZJRykgewo+PiArwqDCoMKgwqDCoMKgwqAgZm9yIChpID0gMDsgaSA8IHF1ZXVl czsgaSsrKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRldm1fZnJlZV9pcnEoJnBkZXYt PmRldiwgdmYtPnZyaW5nW2ldLmlycSwgJnZmLT52cmluZ1tpXSk7Cj4+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIHZmLT52cmluZ1tpXS5pcnEgPSAtRUlOVkFMOwo+PiArwqDCoMKgwqDCoMKgwqAg fQo+PiArwqDCoMKgIH0gZWxzZSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCBkZXZtX2ZyZWVfaXJxKCZw ZGV2LT5kZXYsIHZmLT52cXNfc2hhcmVkX2lycSwgdmYpOwo+PiArwqDCoMKgwqDCoMKgwqAgdmYt PnZxc19zaGFyZWRfaXJxID0gLUVJTlZBTDsKPj4gK8KgwqDCoCB9Cj4+ICt9Cj4+IMKgIC3CoMKg wqAgZm9yIChpID0gMDsgaSA8IHF1ZXVlczsgaSsrKSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCBkZXZt X2ZyZWVfaXJxKCZwZGV2LT5kZXYsIHZmLT52cmluZ1tpXS5pcnEsICZ2Zi0+dnJpbmdbaV0pOwo+ PiAtwqDCoMKgwqDCoMKgwqAgdmYtPnZyaW5nW2ldLmlycSA9IC1FSU5WQUw7Cj4+ICtzdGF0aWMg dm9pZCBpZmN2Zl9mcmVlX2NvbmZpZ19pcnEoc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKmFkYXB0ZXIp Cj4+ICt7Cj4+ICvCoMKgwqAgc3RydWN0IHBjaV9kZXYgKnBkZXYgPSBhZGFwdGVyLT5wZGV2Owo+ PiArwqDCoMKgIHN0cnVjdCBpZmN2Zl9odyAqdmYgPSAmYWRhcHRlci0+dmY7Cj4+ICsKPj4gK8Kg wqDCoCAvKiBJZiB0aGUgaXJxIGlzIHNoYXJlZCBieSBhbGwgdnFzIGFuZCB0aGUgY29uZmlnIGlu dGVycnVwdCwKPj4gK8KgwqDCoMKgICogaXQgaXMgYWxyZWFkeSBmcmVlZCBpbiBpZmN2Zl9mcmVl X3ZxX2lycSwgc28gaGVyZSBvbmx5Cj4+ICvCoMKgwqDCoCAqIG5lZWQgdG8gZnJlZSBjb25maWcg aXJxIHdoZW4gbXNpeF92ZWN0b3Jfc3RhdHVzICE9IAo+PiBNU0lYX1ZFQ1RPUl9ERVZfU0hBUkVE Cj4+ICvCoMKgwqDCoCAqLwo+PiArwqDCoMKgIGlmICh2Zi0+bXNpeF92ZWN0b3Jfc3RhdHVzICE9 IE1TSVhfVkVDVE9SX0RFVl9TSEFSRUQpIHsKPj4gK8KgwqDCoMKgwqDCoMKgIGRldm1fZnJlZV9p cnEoJnBkZXYtPmRldiwgdmYtPmNvbmZpZ19pcnEsIHZmKTsKPj4gK8KgwqDCoMKgwqDCoMKgIHZm LT5jb25maWdfaXJxID0gLUVJTlZBTDsKPj4gwqDCoMKgwqDCoCB9Cj4+ICt9Cj4+ICsKPj4gK3N0 YXRpYyB2b2lkIGlmY3ZmX2ZyZWVfaXJxKHN0cnVjdCBpZmN2Zl9hZGFwdGVyICphZGFwdGVyLCBp bnQgcXVldWVzKQo+PiArewo+PiArwqDCoMKgIHN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gYWRhcHRl ci0+cGRldjsKPj4gwqAgLcKgwqDCoCBkZXZtX2ZyZWVfaXJxKCZwZGV2LT5kZXYsIHZmLT5jb25m aWdfaXJxLCB2Zik7Cj4+ICvCoMKgwqAgaWZjdmZfZnJlZV92cV9pcnEoYWRhcHRlciwgcXVldWVz KTsKPj4gK8KgwqDCoCBpZmN2Zl9mcmVlX2NvbmZpZ19pcnEoYWRhcHRlcik7Cj4+IMKgwqDCoMKg wqAgaWZjdmZfZnJlZV9pcnFfdmVjdG9ycyhwZGV2KTsKPj4gwqAgfQo+PiDCoCBAQCAtODYsNTgg KzE0MiwxNzIgQEAgc3RhdGljIGludCBpZmN2Zl9hbGxvY192ZWN0b3JzKHN0cnVjdCAKPj4gaWZj dmZfYWRhcHRlciAqYWRhcHRlcikKPj4gwqDCoMKgwqDCoCByZXR1cm4gcmV0Owo+PiDCoCB9Cj4+ IMKgIC1zdGF0aWMgaW50IGlmY3ZmX3JlcXVlc3RfaXJxKHN0cnVjdCBpZmN2Zl9hZGFwdGVyICph ZGFwdGVyKQo+PiArc3RhdGljIGludCBpZmN2Zl9yZXF1ZXN0X3Blcl92cV9pcnEoc3RydWN0IGlm Y3ZmX2FkYXB0ZXIgKmFkYXB0ZXIpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgcGNpX2Rl diAqcGRldiA9IGFkYXB0ZXItPnBkZXY7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGlmY3ZmX2h3ICp2 ZiA9ICZhZGFwdGVyLT52ZjsKPj4gLcKgwqDCoCBpbnQgdmVjdG9yLCBudmVjdG9ycywgaSwgcmV0 LCBpcnE7Cj4+IC3CoMKgwqAgdTE2IG1heF9pbnRyOwo+PiArwqDCoMKgIGludCBpLCB2ZWN0b3Is IHJldCwgaXJxOwo+PiDCoCAtwqDCoMKgIG52ZWN0b3JzID0gaWZjdmZfYWxsb2NfdmVjdG9ycyhh ZGFwdGVyKTsKPj4gLcKgwqDCoCBpZiAoIShudmVjdG9ycyA+IDApKQo+PiAtwqDCoMKgwqDCoMKg wqAgcmV0dXJuIG52ZWN0b3JzOwo+PiArwqDCoMKgIGZvciAoaSA9IDA7IGkgPCB2Zi0+bnJfdnJp bmc7IGkrKykgewo+PiArwqDCoMKgwqDCoMKgwqAgc25wcmludGYodmYtPnZyaW5nW2ldLm1zaXhf bmFtZSwgMjU2LCAiaWZjdmZbJXNdLSVkXG4iLCAKPj4gcGNpX25hbWUocGRldiksIGkpOwo+PiAr wqDCoMKgwqDCoMKgwqAgdmVjdG9yID0gaTsKPj4gK8KgwqDCoMKgwqDCoMKgIGlycSA9IHBjaV9p cnFfdmVjdG9yKHBkZXYsIHZlY3Rvcik7Cj4+ICvCoMKgwqDCoMKgwqDCoCByZXQgPSBkZXZtX3Jl cXVlc3RfaXJxKCZwZGV2LT5kZXYsIGlycSwKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIGlmY3ZmX2ludHJfaGFuZGxlciwgMCwKPj4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZmLT52cmluZ1tpXS5tc2l4X25hbWUs Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAmdmYtPnZy aW5nW2ldKTsKPj4gK8KgwqDCoMKgwqDCoMKgIGlmIChyZXQpIHsKPj4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqAgSUZDVkZfRVJSKHBkZXYsICJGYWlsZWQgdG8gcmVxdWVzdCBpcnEgZm9yIHZxICVk XG4iLCBpKTsKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWZjdmZfZnJlZV92cV9pcnEoYWRh cHRlciwgaSk7Cj4+ICvCoMKgwqDCoMKgwqDCoCB9IGVsc2Ugewo+PiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCB2Zi0+dnJpbmdbaV0uaXJxID0gaXJxOwo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBpZmN2Zl9zZXRfdnFfdmVjdG9yKHZmLCBpLCB2ZWN0b3IpOwo+PiArwqDCoMKgwqDCoMKgwqAg fQo+PiArwqDCoMKgIH0KPj4gwqAgLcKgwqDCoCBtYXhfaW50ciA9IHZmLT5ucl92cmluZyArIDE7 Cj4+ICvCoMKgwqAgdmYtPnZxc19zaGFyZWRfaXJxID0gLUVJTlZBTDsKPj4gKwo+PiArwqDCoMKg IHJldHVybiAwOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IGlmY3ZmX3JlcXVlc3Rfc2hhcmVk X3ZxX2lycShzdHJ1Y3QgaWZjdmZfYWRhcHRlciAqYWRhcHRlcikKPj4gK3sKPj4gK8KgwqDCoCBz dHJ1Y3QgcGNpX2RldiAqcGRldiA9IGFkYXB0ZXItPnBkZXY7Cj4+ICvCoMKgwqAgc3RydWN0IGlm Y3ZmX2h3ICp2ZiA9ICZhZGFwdGVyLT52ZjsKPj4gK8KgwqDCoCBpbnQgaSwgdmVjdG9yLCByZXQs IGlycTsKPj4gKwo+PiArwqDCoMKgIHZlY3RvciA9IDA7Cj4+ICvCoMKgwqAgLyogcmV1c2UgbXNp eF9uYW1lWzI1Nl0gc3BhY2Ugb2YgdnJpbmcwIHRvIHN0b3JlIHNoYXJlZCB2cXMgCj4+IGludGVy cnVwdCBuYW1lICovCj4KPgo+IEkgdGhpbmsgd2UgY2FuIHJlbW92ZSB0aGlzIGNvbW1lbnQgc2lu Y2UgdGhlIGNvZGUgaXMgc3RyYWlnaHRmb3J3YXJkLgpzdXJlCj4KPgo+PiArIHNucHJpbnRmKHZm LT52cmluZ1swXS5tc2l4X25hbWUsIDI1NiwgImlmY3ZmWyVzXS12cXMtc2hhcmVkLWlycVxuIiwg Cj4+IHBjaV9uYW1lKHBkZXYpKTsKPj4gK8KgwqDCoCBpcnEgPSBwY2lfaXJxX3ZlY3RvcihwZGV2 LCB2ZWN0b3IpOwo+PiArwqDCoMKgIHJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwg aXJxLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmY3ZmX3ZxX3No YXJlZF9pbnRyX2hhbmRsZXIsIDAsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgdmYtPnZyaW5nWzBdLm1zaXhfbmFtZSwgdmYpOwo+PiArwqDCoMKgIGlmIChyZXQpIHsK Pj4gK8KgwqDCoMKgwqDCoMKgIElGQ1ZGX0VSUihwZGV2LCAiRmFpbGVkIHRvIHJlcXVlc3Qgc2hh cmVkIGlycSBmb3IgdmZcbiIpOwo+PiArCj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gcmV0Owo+ PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIHZmLT52cXNfc2hhcmVkX2lycSA9IGlycTsKPj4g K8KgwqDCoCBmb3IgKGkgPSAwOyBpIDwgdmYtPm5yX3ZyaW5nOyBpKyspIHsKPj4gK8KgwqDCoMKg wqDCoMKgIHZmLT52cmluZ1tpXS5pcnEgPSAtRUlOVkFMOwo+PiArwqDCoMKgwqDCoMKgwqAgaWZj dmZfc2V0X3ZxX3ZlY3Rvcih2ZiwgaSwgdmVjdG9yKTsKPj4gK8KgwqDCoCB9Cj4+ICsKPj4gK8Kg wqDCoCByZXR1cm4gMDsKPj4gKwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IGlmY3ZmX3JlcXVl c3RfZGV2X3NoYXJlZF9pcnEoc3RydWN0IGlmY3ZmX2FkYXB0ZXIgKmFkYXB0ZXIpCj4+ICt7Cj4+ ICvCoMKgwqAgc3RydWN0IHBjaV9kZXYgKnBkZXYgPSBhZGFwdGVyLT5wZGV2Owo+PiArwqDCoMKg IHN0cnVjdCBpZmN2Zl9odyAqdmYgPSAmYWRhcHRlci0+dmY7Cj4+ICvCoMKgwqAgaW50IGksIHZl Y3RvciwgcmV0LCBpcnE7Cj4+ICsKPj4gK8KgwqDCoCB2ZWN0b3IgPSAwOwo+PiArwqDCoMKgIC8q IHJldXNlIG1zaXhfbmFtZVsyNTZdIHNwYWNlIG9mIHZyaW5nMCB0byBzdG9yZSBzaGFyZWQgZGV2 aWNlIAo+PiBpbnRlcnJ1cHQgbmFtZSAqLwo+PiArwqDCoMKgIHNucHJpbnRmKHZmLT52cmluZ1sw XS5tc2l4X25hbWUsIDI1NiwgCj4+ICJpZmN2Zlslc10tZGV2LXNoYXJlZC1pcnFcbiIsIHBjaV9u YW1lKHBkZXYpKTsKPj4gK8KgwqDCoCBpcnEgPSBwY2lfaXJxX3ZlY3RvcihwZGV2LCB2ZWN0b3Ip Owo+PiArwqDCoMKgIHJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwgaXJxLAo+PiAr wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmY3ZmX2Rldl9zaGFyZWRfaW50 cl9oYW5kbGVyLCAwLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZm LT52cmluZ1swXS5tc2l4X25hbWUsIHZmKTsKPj4gK8KgwqDCoCBpZiAocmV0KSB7Cj4+ICvCoMKg wqDCoMKgwqDCoCBJRkNWRl9FUlIocGRldiwgIkZhaWxlZCB0byByZXF1ZXN0IHNoYXJlZCBpcnEg Zm9yIHZmXG4iKTsKPj4gwqAgLcKgwqDCoCByZXQgPSBwY2lfYWxsb2NfaXJxX3ZlY3RvcnMocGRl diwgbWF4X2ludHIsCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBt YXhfaW50ciwgUENJX0lSUV9NU0lYKTsKPj4gLcKgwqDCoCBpZiAocmV0IDwgMCkgewo+PiAtwqDC oMKgwqDCoMKgwqAgSUZDVkZfRVJSKHBkZXYsICJGYWlsZWQgdG8gYWxsb2MgSVJRIHZlY3RvcnNc biIpOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIHJldDsKPj4gwqDCoMKgwqDCoCB9Cj4+ IMKgICvCoMKgwqAgdmYtPnZxc19zaGFyZWRfaXJxID0gaXJxOwo+PiArwqDCoMKgIGZvciAoaSA9 IDA7IGkgPCB2Zi0+bnJfdnJpbmc7IGkrKykgewo+PiArwqDCoMKgwqDCoMKgwqAgdmYtPnZyaW5n W2ldLmlycSA9IC1FSU5WQUw7Cj4+ICvCoMKgwqDCoMKgwqDCoCBpZmN2Zl9zZXRfdnFfdmVjdG9y KHZmLCBpLCB2ZWN0b3IpOwo+PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIHZmLT5jb25maWdf aXJxID0gaXJxOwo+PiArwqDCoMKgIGlmY3ZmX3NldF9jb25maWdfdmVjdG9yKHZmLCB2ZWN0b3Ip Owo+PiArCj4+ICvCoMKgwqAgcmV0dXJuIDA7Cj4+ICsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlu dCBpZmN2Zl9yZXF1ZXN0X3ZxX2lycShzdHJ1Y3QgaWZjdmZfYWRhcHRlciAqYWRhcHRlcikKPj4g K3sKPj4gK8KgwqDCoCBzdHJ1Y3QgaWZjdmZfaHcgKnZmID0gJmFkYXB0ZXItPnZmOwo+PiArwqDC oMKgIGludCByZXQ7Cj4+ICsKPj4gK8KgwqDCoCBpZiAodmYtPm1zaXhfdmVjdG9yX3N0YXR1cyA9 PSBNU0lYX1ZFQ1RPUl9QRVJfVlFfQU5EX0NPTkZJRykKPj4gK8KgwqDCoMKgwqDCoMKgIHJldCA9 IGlmY3ZmX3JlcXVlc3RfcGVyX3ZxX2lycShhZGFwdGVyKTsKPj4gK8KgwqDCoCBlbHNlCj4+ICvC oMKgwqDCoMKgwqDCoCByZXQgPSBpZmN2Zl9yZXF1ZXN0X3NoYXJlZF92cV9pcnEoYWRhcHRlcik7 Cj4+ICsKPj4gK8KgwqDCoCByZXR1cm4gcmV0Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IGlm Y3ZmX3JlcXVlc3RfY29uZmlnX2lycShzdHJ1Y3QgaWZjdmZfYWRhcHRlciAqYWRhcHRlcikKPj4g K3sKPj4gK8KgwqDCoCBzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IGFkYXB0ZXItPnBkZXY7Cj4+ICvC oMKgwqAgc3RydWN0IGlmY3ZmX2h3ICp2ZiA9ICZhZGFwdGVyLT52ZjsKPj4gK8KgwqDCoCBpbnQg Y29uZmlnX3ZlY3RvciwgcmV0Owo+PiArCj4+ICvCoMKgwqAgaWYgKHZmLT5tc2l4X3ZlY3Rvcl9z dGF0dXMgPT0gTVNJWF9WRUNUT1JfREVWX1NIQVJFRCkKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVy biAwOwo+PiArCj4+ICvCoMKgwqAgaWYgKHZmLT5tc2l4X3ZlY3Rvcl9zdGF0dXMgPT0gTVNJWF9W RUNUT1JfUEVSX1ZRX0FORF9DT05GSUcpCj4+ICvCoMKgwqDCoMKgwqDCoCAvKiB2ZWN0b3IgMCB+ IHZmLT5ucl92cmluZyBmb3IgdnFzLCBudW0gdmYtPm5yX3ZyaW5nIHZlY3RvciAKPj4gZm9yIGNv bmZpZyBpbnRlcnJ1cHQgKi8KPj4gK8KgwqDCoMKgwqDCoMKgIGNvbmZpZ192ZWN0b3IgPSB2Zi0+ bnJfdnJpbmc7Cj4+ICsKPj4gK8KgwqDCoCBpZiAodmYtPm1zaXhfdmVjdG9yX3N0YXR1cyA9PSBN U0lYX1ZFQ1RPUl9TSEFSRURfVlFfQU5EX0NPTkZJRykKPj4gK8KgwqDCoMKgwqDCoMKgIC8qIHZl Y3RvciAwIGZvciB2cXMgYW5kIDEgZm9yIGNvbmZpZyBpbnRlcnJ1cHQgKi8KPj4gK8KgwqDCoMKg wqDCoMKgIGNvbmZpZ192ZWN0b3IgPSAxOwo+PiArCj4+IMKgwqDCoMKgwqAgc25wcmludGYodmYt PmNvbmZpZ19tc2l4X25hbWUsIDI1NiwgImlmY3ZmWyVzXS1jb25maWdcbiIsCj4+IMKgwqDCoMKg wqDCoMKgwqDCoMKgIHBjaV9uYW1lKHBkZXYpKTsKPj4gLcKgwqDCoCB2ZWN0b3IgPSAwOwo+PiAt wqDCoMKgIHZmLT5jb25maWdfaXJxID0gcGNpX2lycV92ZWN0b3IocGRldiwgdmVjdG9yKTsKPj4g K8KgwqDCoCB2Zi0+Y29uZmlnX2lycSA9IHBjaV9pcnFfdmVjdG9yKHBkZXYsIGNvbmZpZ192ZWN0 b3IpOwo+PiDCoMKgwqDCoMKgIHJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwgdmYt PmNvbmZpZ19pcnEsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg aWZjdmZfY29uZmlnX2NoYW5nZWQsIDAsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgdmYtPmNvbmZpZ19tc2l4X25hbWUsIHZmKTsKPj4gwqDCoMKgwqDCoCBpZiAo cmV0KSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBJRkNWRl9FUlIocGRldiwgIkZhaWxlZCB0byBy ZXF1ZXN0IGNvbmZpZyBpcnFcbiIpOwo+PiArwqDCoMKgwqDCoMKgwqAgaWZjdmZfZnJlZV92cV9p cnEoYWRhcHRlciwgdmYtPm5yX3ZyaW5nKTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBy ZXQ7Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoCAtwqDCoMKgIGZvciAoaSA9IDA7IGkgPCB2Zi0+bnJf dnJpbmc7IGkrKykgewo+PiAtwqDCoMKgwqDCoMKgwqAgc25wcmludGYodmYtPnZyaW5nW2ldLm1z aXhfbmFtZSwgMjU2LCAiaWZjdmZbJXNdLSVkXG4iLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIHBjaV9uYW1lKHBkZXYpLCBpKTsKPj4gLcKgwqDCoMKgwqDCoMKgIHZlY3RvciA9IGkgKyBJ RkNWRl9NU0lfUVVFVUVfT0ZGOwo+PiAtwqDCoMKgwqDCoMKgwqAgaXJxID0gcGNpX2lycV92ZWN0 b3IocGRldiwgdmVjdG9yKTsKPj4gLcKgwqDCoMKgwqDCoMKgIHJldCA9IGRldm1fcmVxdWVzdF9p cnEoJnBkZXYtPmRldiwgaXJxLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgaWZjdmZfaW50cl9oYW5kbGVyLCAwLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdmYtPnZyaW5nW2ldLm1zaXhfbmFtZSwKPj4gLcKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICZ2Zi0+dnJpbmdbaV0p Owo+PiAtwqDCoMKgwqDCoMKgwqAgaWYgKHJldCkgewo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBJRkNWRl9FUlIocGRldiwKPj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg IkZhaWxlZCB0byByZXF1ZXN0IGlycSBmb3IgdnEgJWRcbiIsIGkpOwo+PiAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBpZmN2Zl9mcmVlX2lycShhZGFwdGVyLCBpKTsKPj4gK8KgwqDCoCBpZmN2Zl9z ZXRfY29uZmlnX3ZlY3Rvcih2ZiwgY29uZmlnX3ZlY3Rvcik7Cj4+IMKgIC3CoMKgwqDCoMKgwqDC oMKgwqDCoMKgIHJldHVybiByZXQ7Cj4+IC3CoMKgwqDCoMKgwqDCoCB9Cj4+ICvCoMKgwqAgcmV0 dXJuIDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbnQgaWZjdmZfcmVxdWVzdF9pcnEoc3RydWN0 IGlmY3ZmX2FkYXB0ZXIgKmFkYXB0ZXIpCj4+ICt7Cj4KPgo+IEFzIHJlcGxpZWQgYWJvdmUsIEkg dGhpbmsgaGF2aW5nIHR3byBtb2RlcyBzaG91bGQgYmUgc3VmZmljaWVudCBhbmQgCj4gdGhlIGNv ZGUgY291bGQgYmUgZ3JlYXRseSBzaW1wbGlmaWVkLgpEbyB5b3UgbWVhbiBpZiB3ZSBkb24ndCBn ZXQgZW5vdWdoIHZlY3RvcnMsIGp1c3QgdXNlIG9ubHkgb25lIHZlY3RvciBmb3IgCnRoZSB2cXMg YW5kIGNvbmZpZyBjaGFuZ2VzPyBJIGd1ZXNzIHRoaXMKb25seSB3b3JrcyBpZiBJU1Igd29yayBm b3IgTVNJWCBhcyB3ZSBleHBlY3RzLCBvciB3ZSBtYXkgd2FzdGUgc29tZSB0aW1lIAppbiB0aGUg ZGV2aWNlIGNvbmZpZyBzcGFjZS4KClRoYW5rcywKWmh1IExpbmdzaGFuCj4KPiBUaGFua3MKPgo+ Cj4+ICvCoMKgwqAgc3RydWN0IGlmY3ZmX2h3ICp2ZiA9ICZhZGFwdGVyLT52ZjsKPj4gK8KgwqDC oCBpbnQgbnZlY3RvcnMsIHJldCwgbWF4X2ludHI7Cj4+IMKgIC3CoMKgwqDCoMKgwqDCoCB2Zi0+ dnJpbmdbaV0uaXJxID0gaXJxOwo+PiArwqDCoMKgIG52ZWN0b3JzID0gaWZjdmZfYWxsb2NfdmVj dG9ycyhhZGFwdGVyKTsKPj4gK8KgwqDCoCBpZiAoIShudmVjdG9ycyA+IDApKQo+PiArwqDCoMKg wqDCoMKgwqAgcmV0dXJuIG52ZWN0b3JzOwo+PiArCj4+ICvCoMKgwqAgdmYtPm1zaXhfdmVjdG9y X3N0YXR1cyA9IE1TSVhfVkVDVE9SX1BFUl9WUV9BTkRfQ09ORklHOwo+PiArwqDCoMKgIG1heF9p bnRyID0gdmYtPm5yX3ZyaW5nICsgMTsKPj4gK8KgwqDCoCBpZiAobnZlY3RvcnMgPCBtYXhfaW50 cikKPj4gK8KgwqDCoMKgwqDCoMKgIHZmLT5tc2l4X3ZlY3Rvcl9zdGF0dXMgPSBNU0lYX1ZFQ1RP Ul9TSEFSRURfVlFfQU5EX0NPTkZJRzsKPj4gKwo+PiArwqDCoMKgIGlmIChudmVjdG9ycyA9PSAx KSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCB2Zi0+bXNpeF92ZWN0b3Jfc3RhdHVzID0gTVNJWF9WRUNU T1JfREVWX1NIQVJFRDsKPj4gK8KgwqDCoMKgwqDCoMKgIHJldCA9IGlmY3ZmX3JlcXVlc3RfZGV2 X3NoYXJlZF9pcnEoYWRhcHRlcik7Cj4+ICsKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiByZXQ7 Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoCArwqDCoMKgIHJldCA9IGlmY3ZmX3JlcXVlc3RfdnFfaXJx KGFkYXB0ZXIpOwo+PiArwqDCoMKgIGlmIChyZXQpCj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4g cmV0Owo+PiArCj4+ICvCoMKgwqAgcmV0ID0gaWZjdmZfcmVxdWVzdF9jb25maWdfaXJxKGFkYXB0 ZXIpOwo+PiArCj4+ICvCoMKgwqAgaWYgKHJldCkKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiBy ZXQ7Cj4+ICsKPj4gwqDCoMKgwqDCoCByZXR1cm4gMDsKPj4gwqAgfQo+PiDCoCBAQCAtNDQxLDcg KzYxMSwxMCBAQCBzdGF0aWMgaW50IGlmY3ZmX3ZkcGFfZ2V0X3ZxX2lycShzdHJ1Y3QgCj4+IHZk cGFfZGV2aWNlICp2ZHBhX2RldiwKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHN0cnVjdCBpZmN2Zl9o dyAqdmYgPSB2ZHBhX3RvX3ZmKHZkcGFfZGV2KTsKPj4gwqAgLcKgwqDCoCByZXR1cm4gdmYtPnZy aW5nW3FpZF0uaXJxOwo+PiArwqDCoMKgIGlmICh2Zi0+dnFzX3NoYXJlZF9pcnEgPCAwKQo+PiAr wqDCoMKgwqDCoMKgwqAgcmV0dXJuIHZmLT52cmluZ1txaWRdLmlycTsKPj4gK8KgwqDCoCBlbHNl Cj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPj4gwqAgfQo+PiDCoCDCoCBzdGF0 aWMgc3RydWN0IHZkcGFfbm90aWZpY2F0aW9uX2FyZWEgCj4+IGlmY3ZmX2dldF92cV9ub3RpZmlj YXRpb24oc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhX2RldiwKPgo+IF9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4gVmlydHVhbGl6YXRpb24gbWFpbGluZyBs aXN0Cj4gVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKPiBodHRwczov L2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlv bgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmlydHVh bGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRp b24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZv L3ZpcnR1YWxpemF0aW9u 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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D9206C433FE for ; Mon, 14 Feb 2022 10:37:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1348033AbiBNKhH (ORCPT ); Mon, 14 Feb 2022 05:37:07 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:46310 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1348260AbiBNKfB (ORCPT ); Mon, 14 Feb 2022 05:35:01 -0500 Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6D4DBBC86 for ; Mon, 14 Feb 2022 02:02:00 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644832920; x=1676368920; h=message-id:date:mime-version:subject:to:cc:references: from:in-reply-to:content-transfer-encoding; bh=ipjinYtAKhvrbAhw4wh4jYUm4H1/qbkIoQb9U6XOyoE=; b=PqhDLl/0fZMgkw5RG+/Z/6UkGr/Js7TTpOh7lRnBH1nA66QbmN3B4rFr Hlf0MyFdJRpSPhQv/r1XwuM/EMK8Pw+hayqF05bv6hC83qecad3FGJWOT JyuFFN0TtWU4Si58ixxqSUleKGkwAqNLr9S4JyNzVzW3CAyBCgYuqmARP 740jOasmzrd2klzw5gk4jlzhAkBJZXfWkztkzCmK9aSTgAHRkdjmyz5OT mTGi9jFa3NA5sl7RKg7mXKTA2fx4JzvNxQ01ULeXlrkhsA3bFs5/kP+PZ OrXJGkHVaUf1Bb0FgE60RE/X6R34iFdXh7jP5xTqZEcsfcfI6ZDbgbAdC Q==; X-IronPort-AV: E=McAfee;i="6200,9189,10257"; a="250004560" X-IronPort-AV: E=Sophos;i="5.88,367,1635231600"; d="scan'208";a="250004560" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Feb 2022 02:02:00 -0800 X-IronPort-AV: E=Sophos;i="5.88,367,1635231600"; d="scan'208";a="543383795" Received: from lingshan-mobl.ccr.corp.intel.com (HELO [10.249.175.112]) ([10.249.175.112]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 14 Feb 2022 02:01:58 -0800 Message-ID: <449aa3a3-06c8-1236-241e-42ea5b7d8877@linux.intel.com> Date: Mon, 14 Feb 2022 18:01:56 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0 Thunderbird/91.5.1 Subject: Re: [PATCH V4 4/4] vDPA/ifcvf: implement shared IRQ feature Content-Language: en-US To: Jason Wang , Zhu Lingshan , mst@redhat.com Cc: netdev@vger.kernel.org, virtualization@lists.linux-foundation.org References: <20220203072735.189716-1-lingshan.zhu@intel.com> <20220203072735.189716-5-lingshan.zhu@intel.com> From: Zhu Lingshan In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On 2/14/2022 3:19 PM, Jason Wang wrote: > > 在 2022/2/3 下午3:27, Zhu Lingshan 写道: >> On some platforms/devices, there may not be enough MSI vector >> slots allocated for virtqueues and config changes. In such a case, >> the interrupt sources(virtqueues, config changes) must share >> an IRQ/vector, to avoid initialization failures, keep >> the device functional. >> >> This commit handles three cases: >> (1) number of the allocated vectors == the number of virtqueues + 1 >> (config changes), every virtqueue and the config interrupt has >> a separated vector/IRQ, the best and the most likely case. >> (2) number of the allocated vectors is less than the best case, but >> greater than 1. In this case, all virtqueues share a vector/IRQ, >> the config interrupt has a separated vector/IRQ >> (3) only one vector is allocated, in this case, the virtqueues and >> the config interrupt share a vector/IRQ. The worst and most >> unlikely case. >> >> Otherwise, it needs to fail. >> >> This commit introduces some helper functions: >> ifcvf_set_vq_vector() and ifcvf_set_config_vector() sets virtqueue >> vector and config vector in the device config space, so that >> the device can send interrupt DMA. >> >> This commit adds some fields in struct ifcvf_hw and re-placed >> the existed fields to be aligned with the cacheline. >> >> Signed-off-by: Zhu Lingshan >> --- >>   drivers/vdpa/ifcvf/ifcvf_base.c |  47 ++++-- >>   drivers/vdpa/ifcvf/ifcvf_base.h |  23 ++- >>   drivers/vdpa/ifcvf/ifcvf_main.c | 243 +++++++++++++++++++++++++++----- >>   3 files changed, 256 insertions(+), 57 deletions(-) >> >> diff --git a/drivers/vdpa/ifcvf/ifcvf_base.c >> b/drivers/vdpa/ifcvf/ifcvf_base.c >> index 397692ae671c..18dcb63ab1e3 100644 >> --- a/drivers/vdpa/ifcvf/ifcvf_base.c >> +++ b/drivers/vdpa/ifcvf/ifcvf_base.c >> @@ -15,6 +15,36 @@ struct ifcvf_adapter *vf_to_adapter(struct >> ifcvf_hw *hw) >>       return container_of(hw, struct ifcvf_adapter, vf); >>   } >>   +int ifcvf_set_vq_vector(struct ifcvf_hw *hw, u16 qid, int vector) >> +{ >> +    struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; >> +    struct ifcvf_adapter *ifcvf = vf_to_adapter(hw); >> + >> +    ifc_iowrite16(qid, &cfg->queue_select); >> +    ifc_iowrite16(vector, &cfg->queue_msix_vector); >> +    if (ifc_ioread16(&cfg->queue_msix_vector) == >> VIRTIO_MSI_NO_VECTOR) { >> +        IFCVF_ERR(ifcvf->pdev, "No msix vector for queue %u\n", qid); >> +            return -EINVAL; >> +    } > > > Let's leave this check for the caller, E.g can caller try to assign > NO_VECTOR during uni-nit? ifcvf driver sets NO_VECTOR when call hw_disable(). I am not sure whether I get it, Yes we can let the caller check a vq vector, however this may cause more than three levels brackets, may looks ugly. > > >> + >> +    return 0; >> +} >> + >> +int ifcvf_set_config_vector(struct ifcvf_hw *hw, int vector) >> +{ >> +    struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; >> +    struct ifcvf_adapter *ifcvf = vf_to_adapter(hw); >> + >> +    cfg = hw->common_cfg; >> +    ifc_iowrite16(vector,  &cfg->msix_config); >> +    if (ifc_ioread16(&cfg->msix_config) == VIRTIO_MSI_NO_VECTOR) { >> +        IFCVF_ERR(ifcvf->pdev, "No msix vector for device config\n"); >> +        return -EINVAL; >> +    } > > > Similar question as above. > > >> + >> +    return 0; >> +} >> + >>   static void __iomem *get_cap_addr(struct ifcvf_hw *hw, >>                     struct virtio_pci_cap *cap) >>   { >> @@ -140,6 +170,8 @@ int ifcvf_init_hw(struct ifcvf_hw *hw, struct >> pci_dev *pdev) >>             hw->common_cfg, hw->notify_base, hw->isr, >>             hw->dev_cfg, hw->notify_off_multiplier); >>   +    hw->vqs_shared_irq = -EINVAL; >> + >>       return 0; >>   } >>   @@ -321,12 +353,6 @@ static int ifcvf_hw_enable(struct ifcvf_hw *hw) >>         ifcvf = vf_to_adapter(hw); >>       cfg = hw->common_cfg; >> -    ifc_iowrite16(IFCVF_MSI_CONFIG_OFF, &cfg->msix_config); >> - >> -    if (ifc_ioread16(&cfg->msix_config) == VIRTIO_MSI_NO_VECTOR) { >> -        IFCVF_ERR(ifcvf->pdev, "No msix vector for device config\n"); >> -        return -EINVAL; >> -    } >>         for (i = 0; i < hw->nr_vring; i++) { >>           if (!hw->vring[i].ready) >> @@ -340,15 +366,6 @@ static int ifcvf_hw_enable(struct ifcvf_hw *hw) >>           ifc_iowrite64_twopart(hw->vring[i].used, &cfg->queue_used_lo, >>                        &cfg->queue_used_hi); >>           ifc_iowrite16(hw->vring[i].size, &cfg->queue_size); >> -        ifc_iowrite16(i + IFCVF_MSI_QUEUE_OFF, >> &cfg->queue_msix_vector); >> - >> -        if (ifc_ioread16(&cfg->queue_msix_vector) == >> -            VIRTIO_MSI_NO_VECTOR) { >> -            IFCVF_ERR(ifcvf->pdev, >> -                  "No msix vector for queue %u\n", i); >> -            return -EINVAL; >> -        } >> - >>           ifcvf_set_vq_state(hw, i, hw->vring[i].last_avail_idx); >>           ifc_iowrite16(1, &cfg->queue_enable); >>       } >> diff --git a/drivers/vdpa/ifcvf/ifcvf_base.h >> b/drivers/vdpa/ifcvf/ifcvf_base.h >> index 949b4fb9d554..9cfe088c82e9 100644 >> --- a/drivers/vdpa/ifcvf/ifcvf_base.h >> +++ b/drivers/vdpa/ifcvf/ifcvf_base.h >> @@ -27,8 +27,6 @@ >>     #define IFCVF_QUEUE_ALIGNMENT    PAGE_SIZE >>   #define IFCVF_QUEUE_MAX        32768 >> -#define IFCVF_MSI_CONFIG_OFF    0 >> -#define IFCVF_MSI_QUEUE_OFF    1 >>   #define IFCVF_PCI_MAX_RESOURCE    6 >>     #define IFCVF_LM_CFG_SIZE        0x40 >> @@ -42,6 +40,13 @@ >>   #define ifcvf_private_to_vf(adapter) \ >>       (&((struct ifcvf_adapter *)adapter)->vf) >>   +/* all vqs and config interrupt has its own vector */ >> +#define MSIX_VECTOR_PER_VQ_AND_CONFIG        1 >> +/* all vqs share a vector, and config interrupt has a separate >> vector */ >> +#define MSIX_VECTOR_SHARED_VQ_AND_CONFIG    2 >> +/* all vqs and config interrupt share a vector */ >> +#define MSIX_VECTOR_DEV_SHARED            3 > > > I think there's no much value to differ 2 from 3 consider config > interrupt should be rare. IMHO we still need 2 and 3, because MSIX_VECTOR_SHARED_VQ_AND_CONFIG means there are at least 2 vectors, the vqs share one vector, config change has its own vector. MSIX_VECTOR_DEV_SHARED means three are only one vector, all vqs and config changes need to share this vector. > > > >> + >>   static inline u8 ifc_ioread8(u8 __iomem *addr) >>   { >>       return ioread8(addr); >> @@ -97,25 +102,27 @@ struct ifcvf_hw { >>       u8 __iomem *isr; >>       /* Live migration */ >>       u8 __iomem *lm_cfg; >> -    u16 nr_vring; > > > Any reason for moving nv_vring, config_size, and other stuffs? for cacheline alignment. > > > >>       /* Notification bar number */ >>       u8 notify_bar; >> +    u8 msix_vector_status; >> +    /* virtio-net or virtio-blk device config size */ >> +    u32 config_size; >>       /* Notificaiton bar address */ >>       void __iomem *notify_base; >>       phys_addr_t notify_base_pa; >>       u32 notify_off_multiplier; >> +    u32 dev_type; >>       u64 req_features; >>       u64 hw_features; >> -    u32 dev_type; >>       struct virtio_pci_common_cfg __iomem *common_cfg; >>       void __iomem *dev_cfg; >>       struct vring_info vring[IFCVF_MAX_QUEUES]; >>       void __iomem * const *base; >>       char config_msix_name[256]; >>       struct vdpa_callback config_cb; >> -    unsigned int config_irq; >> -    /* virtio-net or virtio-blk device config size */ >> -    u32 config_size; >> +    int config_irq; >> +    int vqs_shared_irq; >> +    u16 nr_vring; >>   }; >>     struct ifcvf_adapter { >> @@ -160,4 +167,6 @@ int ifcvf_set_vq_state(struct ifcvf_hw *hw, u16 >> qid, u16 num); >>   struct ifcvf_adapter *vf_to_adapter(struct ifcvf_hw *hw); >>   int ifcvf_probed_virtio_net(struct ifcvf_hw *hw); >>   u32 ifcvf_get_config_size(struct ifcvf_hw *hw); >> +int ifcvf_set_vq_vector(struct ifcvf_hw *hw, u16 qid, int vector); >> +int ifcvf_set_config_vector(struct ifcvf_hw *hw, int vector); >>   #endif /* _IFCVF_H_ */ >> diff --git a/drivers/vdpa/ifcvf/ifcvf_main.c >> b/drivers/vdpa/ifcvf/ifcvf_main.c >> index 44c89ab0b6da..ca414399f040 100644 >> --- a/drivers/vdpa/ifcvf/ifcvf_main.c >> +++ b/drivers/vdpa/ifcvf/ifcvf_main.c >> @@ -17,6 +17,7 @@ >>   #define DRIVER_AUTHOR   "Intel Corporation" >>   #define IFCVF_DRIVER_NAME       "ifcvf" >>   +/* handles config interrupt */ > > > This seems unrelated to the shared IRQ logic and it looks useless > since it's easily to deduce it from the function name below. OK, do you mean the comments? I can remove these comments. > > >>   static irqreturn_t ifcvf_config_changed(int irq, void *arg) >>   { >>       struct ifcvf_hw *vf = arg; >> @@ -27,6 +28,7 @@ static irqreturn_t ifcvf_config_changed(int irq, >> void *arg) >>       return IRQ_HANDLED; >>   } >>   +/* handles vqs interrupt */ > > > So did this. > > >>   static irqreturn_t ifcvf_intr_handler(int irq, void *arg) >>   { >>       struct vring_info *vring = arg; >> @@ -37,24 +39,78 @@ static irqreturn_t ifcvf_intr_handler(int irq, >> void *arg) >>       return IRQ_HANDLED; >>   } >>   +/* handls vqs shared interrupt */ >> +static irqreturn_t ifcvf_vq_shared_intr_handler(int irq, void *arg) >> +{ >> +    struct ifcvf_hw *vf = arg; >> +    struct vring_info *vring; >> +    int i; >> + >> +    for (i = 0; i < vf->nr_vring; i++) { >> +        vring = &vf->vring[i]; >> +        if (vring->cb.callback) >> + vf->vring->cb.callback(vring->cb.private); >> +    } >> + >> +    return IRQ_HANDLED; >> +} >> + >> +/* handles a shared interrupt for vqs and config */ >> +static irqreturn_t ifcvf_dev_shared_intr_handler(int irq, void *arg) >> +{ >> +    struct ifcvf_hw *vf = arg; >> +    u8 isr; >> + >> +    isr = ifc_ioread8(vf->isr); > > > We need to exactly what vp_interrupt do here. Checking against vf->isr > first and return IRQ_NONE if it is not set. > > Always return IRQ_HANDLED will break the device who shares an irq with > IFCVF. as we discussed in another thread(spec inconsistency about ISR), ISR may only works for INTx for now, but VFs don't have INTx, and a VF may not share its vectors with other devices, so I guess it can work and may be our best try for now. > > >> +    if (isr & VIRTIO_PCI_ISR_CONFIG) >> +        ifcvf_config_changed(irq, arg); >> + >> +    return ifcvf_vq_shared_intr_handler(irq, arg); >> +} >> + >>   static void ifcvf_free_irq_vectors(void *data) >>   { >>       pci_free_irq_vectors(data); >>   } >>   -static void ifcvf_free_irq(struct ifcvf_adapter *adapter, int queues) >> +static void ifcvf_free_vq_irq(struct ifcvf_adapter *adapter, int >> queues) >>   { >>       struct pci_dev *pdev = adapter->pdev; >>       struct ifcvf_hw *vf = &adapter->vf; >>       int i; >>   +    if (vf->msix_vector_status == MSIX_VECTOR_PER_VQ_AND_CONFIG) { >> +        for (i = 0; i < queues; i++) { >> +            devm_free_irq(&pdev->dev, vf->vring[i].irq, &vf->vring[i]); >> +            vf->vring[i].irq = -EINVAL; >> +        } >> +    } else { >> +        devm_free_irq(&pdev->dev, vf->vqs_shared_irq, vf); >> +        vf->vqs_shared_irq = -EINVAL; >> +    } >> +} >>   -    for (i = 0; i < queues; i++) { >> -        devm_free_irq(&pdev->dev, vf->vring[i].irq, &vf->vring[i]); >> -        vf->vring[i].irq = -EINVAL; >> +static void ifcvf_free_config_irq(struct ifcvf_adapter *adapter) >> +{ >> +    struct pci_dev *pdev = adapter->pdev; >> +    struct ifcvf_hw *vf = &adapter->vf; >> + >> +    /* If the irq is shared by all vqs and the config interrupt, >> +     * it is already freed in ifcvf_free_vq_irq, so here only >> +     * need to free config irq when msix_vector_status != >> MSIX_VECTOR_DEV_SHARED >> +     */ >> +    if (vf->msix_vector_status != MSIX_VECTOR_DEV_SHARED) { >> +        devm_free_irq(&pdev->dev, vf->config_irq, vf); >> +        vf->config_irq = -EINVAL; >>       } >> +} >> + >> +static void ifcvf_free_irq(struct ifcvf_adapter *adapter, int queues) >> +{ >> +    struct pci_dev *pdev = adapter->pdev; >>   -    devm_free_irq(&pdev->dev, vf->config_irq, vf); >> +    ifcvf_free_vq_irq(adapter, queues); >> +    ifcvf_free_config_irq(adapter); >>       ifcvf_free_irq_vectors(pdev); >>   } >>   @@ -86,58 +142,172 @@ static int ifcvf_alloc_vectors(struct >> ifcvf_adapter *adapter) >>       return ret; >>   } >>   -static int ifcvf_request_irq(struct ifcvf_adapter *adapter) >> +static int ifcvf_request_per_vq_irq(struct ifcvf_adapter *adapter) >>   { >>       struct pci_dev *pdev = adapter->pdev; >>       struct ifcvf_hw *vf = &adapter->vf; >> -    int vector, nvectors, i, ret, irq; >> -    u16 max_intr; >> +    int i, vector, ret, irq; >>   -    nvectors = ifcvf_alloc_vectors(adapter); >> -    if (!(nvectors > 0)) >> -        return nvectors; >> +    for (i = 0; i < vf->nr_vring; i++) { >> +        snprintf(vf->vring[i].msix_name, 256, "ifcvf[%s]-%d\n", >> pci_name(pdev), i); >> +        vector = i; >> +        irq = pci_irq_vector(pdev, vector); >> +        ret = devm_request_irq(&pdev->dev, irq, >> +                       ifcvf_intr_handler, 0, >> +                       vf->vring[i].msix_name, >> +                       &vf->vring[i]); >> +        if (ret) { >> +            IFCVF_ERR(pdev, "Failed to request irq for vq %d\n", i); >> +            ifcvf_free_vq_irq(adapter, i); >> +        } else { >> +            vf->vring[i].irq = irq; >> +            ifcvf_set_vq_vector(vf, i, vector); >> +        } >> +    } >>   -    max_intr = vf->nr_vring + 1; >> +    vf->vqs_shared_irq = -EINVAL; >> + >> +    return 0; >> +} >> + >> +static int ifcvf_request_shared_vq_irq(struct ifcvf_adapter *adapter) >> +{ >> +    struct pci_dev *pdev = adapter->pdev; >> +    struct ifcvf_hw *vf = &adapter->vf; >> +    int i, vector, ret, irq; >> + >> +    vector = 0; >> +    /* reuse msix_name[256] space of vring0 to store shared vqs >> interrupt name */ > > > I think we can remove this comment since the code is straightforward. sure > > >> + snprintf(vf->vring[0].msix_name, 256, "ifcvf[%s]-vqs-shared-irq\n", >> pci_name(pdev)); >> +    irq = pci_irq_vector(pdev, vector); >> +    ret = devm_request_irq(&pdev->dev, irq, >> +                   ifcvf_vq_shared_intr_handler, 0, >> +                   vf->vring[0].msix_name, vf); >> +    if (ret) { >> +        IFCVF_ERR(pdev, "Failed to request shared irq for vf\n"); >> + >> +        return ret; >> +    } >> + >> +    vf->vqs_shared_irq = irq; >> +    for (i = 0; i < vf->nr_vring; i++) { >> +        vf->vring[i].irq = -EINVAL; >> +        ifcvf_set_vq_vector(vf, i, vector); >> +    } >> + >> +    return 0; >> + >> +} >> + >> +static int ifcvf_request_dev_shared_irq(struct ifcvf_adapter *adapter) >> +{ >> +    struct pci_dev *pdev = adapter->pdev; >> +    struct ifcvf_hw *vf = &adapter->vf; >> +    int i, vector, ret, irq; >> + >> +    vector = 0; >> +    /* reuse msix_name[256] space of vring0 to store shared device >> interrupt name */ >> +    snprintf(vf->vring[0].msix_name, 256, >> "ifcvf[%s]-dev-shared-irq\n", pci_name(pdev)); >> +    irq = pci_irq_vector(pdev, vector); >> +    ret = devm_request_irq(&pdev->dev, irq, >> +                   ifcvf_dev_shared_intr_handler, 0, >> +                   vf->vring[0].msix_name, vf); >> +    if (ret) { >> +        IFCVF_ERR(pdev, "Failed to request shared irq for vf\n"); >>   -    ret = pci_alloc_irq_vectors(pdev, max_intr, >> -                    max_intr, PCI_IRQ_MSIX); >> -    if (ret < 0) { >> -        IFCVF_ERR(pdev, "Failed to alloc IRQ vectors\n"); >>           return ret; >>       } >>   +    vf->vqs_shared_irq = irq; >> +    for (i = 0; i < vf->nr_vring; i++) { >> +        vf->vring[i].irq = -EINVAL; >> +        ifcvf_set_vq_vector(vf, i, vector); >> +    } >> + >> +    vf->config_irq = irq; >> +    ifcvf_set_config_vector(vf, vector); >> + >> +    return 0; >> + >> +} >> + >> +static int ifcvf_request_vq_irq(struct ifcvf_adapter *adapter) >> +{ >> +    struct ifcvf_hw *vf = &adapter->vf; >> +    int ret; >> + >> +    if (vf->msix_vector_status == MSIX_VECTOR_PER_VQ_AND_CONFIG) >> +        ret = ifcvf_request_per_vq_irq(adapter); >> +    else >> +        ret = ifcvf_request_shared_vq_irq(adapter); >> + >> +    return ret; >> +} >> + >> +static int ifcvf_request_config_irq(struct ifcvf_adapter *adapter) >> +{ >> +    struct pci_dev *pdev = adapter->pdev; >> +    struct ifcvf_hw *vf = &adapter->vf; >> +    int config_vector, ret; >> + >> +    if (vf->msix_vector_status == MSIX_VECTOR_DEV_SHARED) >> +        return 0; >> + >> +    if (vf->msix_vector_status == MSIX_VECTOR_PER_VQ_AND_CONFIG) >> +        /* vector 0 ~ vf->nr_vring for vqs, num vf->nr_vring vector >> for config interrupt */ >> +        config_vector = vf->nr_vring; >> + >> +    if (vf->msix_vector_status == MSIX_VECTOR_SHARED_VQ_AND_CONFIG) >> +        /* vector 0 for vqs and 1 for config interrupt */ >> +        config_vector = 1; >> + >>       snprintf(vf->config_msix_name, 256, "ifcvf[%s]-config\n", >>            pci_name(pdev)); >> -    vector = 0; >> -    vf->config_irq = pci_irq_vector(pdev, vector); >> +    vf->config_irq = pci_irq_vector(pdev, config_vector); >>       ret = devm_request_irq(&pdev->dev, vf->config_irq, >>                      ifcvf_config_changed, 0, >>                      vf->config_msix_name, vf); >>       if (ret) { >>           IFCVF_ERR(pdev, "Failed to request config irq\n"); >> +        ifcvf_free_vq_irq(adapter, vf->nr_vring); >>           return ret; >>       } >>   -    for (i = 0; i < vf->nr_vring; i++) { >> -        snprintf(vf->vring[i].msix_name, 256, "ifcvf[%s]-%d\n", >> -             pci_name(pdev), i); >> -        vector = i + IFCVF_MSI_QUEUE_OFF; >> -        irq = pci_irq_vector(pdev, vector); >> -        ret = devm_request_irq(&pdev->dev, irq, >> -                       ifcvf_intr_handler, 0, >> -                       vf->vring[i].msix_name, >> -                       &vf->vring[i]); >> -        if (ret) { >> -            IFCVF_ERR(pdev, >> -                  "Failed to request irq for vq %d\n", i); >> -            ifcvf_free_irq(adapter, i); >> +    ifcvf_set_config_vector(vf, config_vector); >>   -            return ret; >> -        } >> +    return 0; >> +} >> + >> +static int ifcvf_request_irq(struct ifcvf_adapter *adapter) >> +{ > > > As replied above, I think having two modes should be sufficient and > the code could be greatly simplified. Do you mean if we don't get enough vectors, just use only one vector for the vqs and config changes? I guess this only works if ISR work for MSIX as we expects, or we may waste some time in the device config space. Thanks, Zhu Lingshan > > Thanks > > >> +    struct ifcvf_hw *vf = &adapter->vf; >> +    int nvectors, ret, max_intr; >>   -        vf->vring[i].irq = irq; >> +    nvectors = ifcvf_alloc_vectors(adapter); >> +    if (!(nvectors > 0)) >> +        return nvectors; >> + >> +    vf->msix_vector_status = MSIX_VECTOR_PER_VQ_AND_CONFIG; >> +    max_intr = vf->nr_vring + 1; >> +    if (nvectors < max_intr) >> +        vf->msix_vector_status = MSIX_VECTOR_SHARED_VQ_AND_CONFIG; >> + >> +    if (nvectors == 1) { >> +        vf->msix_vector_status = MSIX_VECTOR_DEV_SHARED; >> +        ret = ifcvf_request_dev_shared_irq(adapter); >> + >> +        return ret; >>       } >>   +    ret = ifcvf_request_vq_irq(adapter); >> +    if (ret) >> +        return ret; >> + >> +    ret = ifcvf_request_config_irq(adapter); >> + >> +    if (ret) >> +        return ret; >> + >>       return 0; >>   } >>   @@ -441,7 +611,10 @@ static int ifcvf_vdpa_get_vq_irq(struct >> vdpa_device *vdpa_dev, >>   { >>       struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); >>   -    return vf->vring[qid].irq; >> +    if (vf->vqs_shared_irq < 0) >> +        return vf->vring[qid].irq; >> +    else >> +        return -EINVAL; >>   } >>     static struct vdpa_notification_area >> ifcvf_get_vq_notification(struct vdpa_device *vdpa_dev, > > _______________________________________________ > Virtualization mailing list > Virtualization@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/virtualization