From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tvrtko Ursulin Subject: Re: [PATCH 3/3] Introduce & use new lightweight SGL iterators Date: Tue, 17 May 2016 11:34:30 +0100 Message-ID: <573AF3B6.3060403@linux.intel.com> References: <1463411944-13533-1-git-send-email-david.s.gordon@intel.com> <1463411944-13533-3-git-send-email-david.s.gordon@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTP id 482406E694 for ; Tue, 17 May 2016 10:34:32 +0000 (UTC) In-Reply-To: <1463411944-13533-3-git-send-email-david.s.gordon@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Dave Gordon , intel-gfx@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org Ck9uIDE2LzA1LzE2IDE2OjE5LCBEYXZlIEdvcmRvbiB3cm90ZToKPiBUaGUgZXhpc3RpbmcgZm9y X2VhY2hfc2dfcGFnZSgpIGl0ZXJhdG9yIGlzIHNvbWV3aGF0IGhlYXZ5d2VpZ2h0LCBhbmQgaXMK PiBsaW1pdGluZyBpOTE1IGRyaXZlciBwZXJmb3JtYW5jZSBpbiBhIGZldyBiZW5jaG1hcmtzLiBT byBoZXJlIHdlCj4gaW50cm9kdWNlIHNvbWV3aGF0IGxpZ2h0ZXIgd2VpZ2h0IGl0ZXJhdG9ycywg cHJpbWFyaWx5IGZvciB1c2Ugd2l0aCBHRU0KPiBvYmplY3RzIG9yIG90aGVyIGNhc2Ugd2hlcmUg d2UgbmVlZCBvbmx5IGRlYWwgd2l0aCB3aG9sZSBhbGlnbmVkIHBhZ2VzLgoKSW50ZXJlc3Rpbmcg aWRlYSwgaWYgZm9yIG5vdGhpbmcgdGhlbiBmb3IgZWxpbWluYXRpbmcgdGhlIGRyZWFkZWQgCnN0 LT5uZW50cyBvZiBmb3JfZWFjaF9zZ19wYWdlLiA6KQoKV2hpY2ggYmVuY2htYXJrcyBpdCBpbXBy b3ZlcyBhbmQgaG93IG11Y2ggZG8geW91IGtub3c/CgpJdCBnZW5lcmF0ZXMgbW9yZSBjb2RlIGZv ciBtZSBidXQgdGhhdCBzZWVtcyB0byBiZSBieSBkZXNpZ24sIHllcz8gCkJlY2F1c2Ugd2hhdCB3 ZXJlIHByZXZpb3VzbHkgY2FsbHMgdG8gX19zZ19wYWdlX2l0ZXJfbmV4dCBpcyBub3cgCmVmZmVj dGl2ZWx5IGlubGluZWQgYW5kIGluc3RlYWQgdGhlcmUgaXMgb25seSBhIGNhbGwgdG8gc2dfbmV4 dCwgd2hpY2ggCl9fc2dfcGFnZV9pdGVyX25leHQgd291bGQgY2FsbCBhbnl3YXkuCgo+IFVubGlr ZSB0aGUgb2xkIGl0ZXJhdG9yLCB0aGUgbmV3IGl0ZXJhdG9ycyB1c2UgYW4gaW50ZXJuYWwgc3Rh dGUKPiBzdHJ1Y3R1cmUgd2hpY2ggaXMgbm90IGludGVuZGVkIHRvIGJlIGFjY2Vzc2VkIGJ5IHRo ZSBjYWxsZXI7IGluc3RlYWQKPiBlYWNoIHRha2VzIGFzIGEgcGFyYW1ldGVyIGFuIG91dHB1dCB2 YXJpYWJsZSB3aGljaCBpcyBzZXQgYmVmb3JlIGVhY2gKPiBpdGVyYXRpb24uIFRoaXMgbWFrZXMg dGhlbSBwYXJ0aWN1bGFybHkgc2ltcGxlIHRvIHVzZSA6KQo+Cj4gT25lIG9mIHRoZSBuZXcgaXRl cmF0b3JzIHByb3ZpZGVzIHRoZSBjYWxsZXIgd2l0aCB0aGUgRE1BIGFkZHJlc3Mgb2YKPiBlYWNo IHBhZ2UgaW4gdHVybjsgdGhlIG90aGVyIHByb3ZpZGVzIHRoZSAnc3RydWN0IHBhZ2UnIHBvaW50 ZXIgcmVxdWlyZWQKPiBieSBtYW55IG1lbW9yeSBtYW5hZ2VtZW50IG9wZXJhdGlvbnMuCj4KPiBW YXJpb3VzIHVzZXMgb2YgZm9yX2VhY2hfc2dfcGFnZSgpIGFyZSB0aGVuIGNvbnZlcnRlZCB0byB0 aGUgbmV3IG1hY3Jvcy4KPgo+IFNpZ25lZC1vZmYtYnk6IERhdmUgR29yZG9uIDxkYXZpZC5zLmdv cmRvbkBpbnRlbC5jb20+Cj4gQ2M6IENocmlzIFdpbHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNv LnVrPgo+IENjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCj4gLS0tCj4gICBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgICAgfCA2MiArKysrKysrKysrKysrKysrKysr KysrKysrLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgICAgICAgICB8IDIw ICsrKystLS0tLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZmVuY2UuYyAgIHwg MTQgKysrLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9ndHQuYyAgICAgfCA3 NiArKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZ2VtX3VzZXJwdHIuYyB8ICA3ICsrLQo+ICAgNSBmaWxlcyBjaGFuZ2VkLCAxMTYg aW5zZXJ0aW9ucygrKSwgNjMgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgK PiBpbmRleCA3MmYwYjAyLi5jMGZjNmFhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCj4g QEAgLTIxMjUsNiArMjEyNSwxMCBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgewo+ ICAgI2RlZmluZSBJTlRFTF9GUk9OVEJVRkZFUl9BTExfTUFTSyhwaXBlKSBcCj4gICAJKDB4ZmYg PDwgKElOVEVMX0ZST05UQlVGRkVSX0JJVFNfUEVSX1BJUEUgKiAocGlwZSkpKQo+Cj4gK3ZvaWQg aTkxNV9nZW1fdHJhY2tfZmIoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9sZCwKPiArCQkg ICAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm5ldywKPiArCQkgICAgICAgdW5zaWdu ZWQgZnJvbnRidWZmZXJfYml0cyk7Cj4gKwo+ICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg ewo+ICAgCXN0cnVjdCBkcm1fZ2VtX29iamVjdCBiYXNlOwo+Cj4gQEAgLTIyNTYsOSArMjI2MCw2 MSBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7Cj4gICB9Owo+ICAgI2RlZmluZSB0b19p bnRlbF9ibyh4KSBjb250YWluZXJfb2YoeCwgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QsIGJh c2UpCj4KPiAtdm9pZCBpOTE1X2dlbV90cmFja19mYihzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2xkLAo+IC0JCSAgICAgICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqbmV3LAo+IC0J CSAgICAgICB1bnNpZ25lZCBmcm9udGJ1ZmZlcl9iaXRzKTsKPiArLyoKPiArICogTmV3IG9wdGlt aXNlZCBTR0wgaXRlcmF0b3IgZm9yIGk5MTUgR0VNIG9iamVjdHMKPiArICovCj4gK3N0cnVjdCBz Z3RfaXRlciB7Cj4gKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNncDsKPiArCXVuaW9uIHsKPiArCQl1 bnNpZ25lZCBsb25nIHBmbjsKPiArCQl1bnNpZ25lZCBsb25nIGRtYTsKCmRtYV9hZGRyX3QKCj4g Kwl9IGl4Owo+ICsJdW5zaWduZWQgaW50IGN1cnI7Cj4gKwl1bnNpZ25lZCBpbnQgbWF4OwoKSSB0 aGluayBzaW5jZSB0aGlzIGNvdW50cyBpbiBieXRlcyBpdCBzaG91bGQgbWF0Y2ggb2JqLT5iYXNl LnNpemUgd2hpY2ggCmlzIGEgc2l6ZV90PwoKQWxzbywgbWF5YmUgdGhlIGl0ZXJhdG9yIHdvdWxk IGJlIG1vcmUgZWZmaWNpZW50IGlmIGl0IGNvdW50ZWQgaW4gcGFnZXM/IApIbSwgcHJvYmFibHkg bWFrZXMgbm8gZGlmZmVyZW5jZSwgYnV0IG1heWJlIHdvcnRoIGV4cGxvcmluZy4gV2FzIGp1c3Qg CnRoaW5raW5nIGFib3V0IGF2b2lkaW5nIHRoZSBuZWVkIHRvIHRvIGNvbnZlcnQgYnl0ZSBwb3Np dGlvbiB0byBwYWdlIApwb3NpdGlvbiBpbiBldmVyeSBpdGVyYXRpb24uCgo+ICt9Owo+ICsKPiAr LyogQ29uc3RydWN0b3IgZm9yIG5ldyBpdGVyYXRvciAqLwo+ICtzdGF0aWMgaW5saW5lIHN0cnVj dCBzZ3RfaXRlcgo+ICtfX3NndF9pdGVyKHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLCBib29sIGRt YSkKPiArewo+ICsJc3RydWN0IHNndF9pdGVyIHMgPSB7IC5zZ3AgPSBzZ2wgfTsKPiArCj4gKwlp ZiAoc2dsKSB7Cj4gKwkJcy5tYXggPSBzLmN1cnIgPSBzZ2wtPm9mZnNldDsKPiArCQlzLm1heCAr PSBzZ2wtPmxlbmd0aDsKPiArCQlpZiAoZG1hKQo+ICsJCQlzLml4LmRtYSA9IHNnX2RtYV9hZGRy ZXNzKHNnbCk7Cj4gKwkJZWxzZQo+ICsJCQlzLml4LnBmbiA9IHBhZ2VfdG9fcGZuKHNnX3BhZ2Uo c2dsKSk7CgpJIHN1cHBvc2Ugd2UgY2FuIHJlbHkgb24gdGhlIGNvbXBpbGVyIHRvIG9wdGltaXpl IG9uZSBicmFuY2ggYXdheSByYXRoZXIgCnRoYW4gaGF2aW5nIHRvIHByb3ZpZGUgdHdvIGl0ZXJh dG9ycy4KCj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHM7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBmb3Jf ZWFjaF9zZ3RfZG1hIC0gaXRlcmF0ZSBvdmVyIHRoZSBETUEgYWRkcmVzc2VzIG9mIHRoZSBnaXZl biBzZ190YWJsZQo+ICsgKiBAX19kbWFwOglETUEgYWRkcmVzcyAob3V0cHV0KQo+ICsgKiBAX19p dGVyOgknc3RydWN0IHNndF9pdGVyJyAoaXRlcmF0b3Igc3RhdGUsIGludGVybmFsKQo+ICsgKiBA X19zZ3Q6CXNnX3RhYmxlIHRvIGl0ZXJhdGUgb3ZlciAoaW5wdXQpCj4gKyAqLwo+ICsjZGVmaW5l IGZvcl9lYWNoX3NndF9kbWEoX19kbWFwLCBfX2l0ZXIsIF9fc2d0KQkJCQlcCj4gKwlmb3IgKChf X2l0ZXIpID0gX19zZ3RfaXRlcigoX19zZ3QpLT5zZ2wsIHRydWUpOwkJCVwKPiArCSAgICAgKChf X2RtYXApID0gKF9faXRlcikuaXguZG1hICsgKF9faXRlcikuY3Vycik7CQlcCj4gKwkgICAgICgo KF9faXRlcikuY3VyciArPSBQQUdFX1NJWkUpIDwgKF9faXRlcikubWF4KSB8fAkJXAo+ICsJCSgo X19pdGVyKSA9IF9fc2d0X2l0ZXIoc2dfbmV4dCgoX19pdGVyKS5zZ3ApLCB0cnVlKSwgMCkpCj4g Kwo+ICsvKioKPiArICogZm9yX2VhY2hfc2d0X3BhZ2UgLSBpdGVyYXRlIG92ZXIgdGhlIHBhZ2Vz IG9mIHRoZSBnaXZlbiBzZ190YWJsZQo+ICsgKiBAX19wcDoJcGFnZSBwb2ludGVyIChvdXRwdXQp Cj4gKyAqIEBfX2l0ZXI6CSdzdHJ1Y3Qgc2d0X2l0ZXInIChpdGVyYXRvciBzdGF0ZSwgaW50ZXJu YWwpCj4gKyAqIEBfX3NndDoJc2dfdGFibGUgdG8gaXRlcmF0ZSBvdmVyIChpbnB1dCkKPiArICov Cj4gKyNkZWZpbmUgZm9yX2VhY2hfc2d0X3BhZ2UoX19wcCwgX19pdGVyLCBfX3NndCkJCQkJXAo+ ICsJZm9yICgoX19pdGVyKSA9IF9fc2d0X2l0ZXIoKF9fc2d0KS0+c2dsLCBmYWxzZSk7CQlcCj4g KwkgICAgICgoX19wcCkgPSAoX19pdGVyKS5peC5wZm4gPT0gMCA/IE5VTEwgOgkJCVwKPiArCQlw Zm5fdG9fcGFnZSgoX19pdGVyKS5peC5wZm4gKyAoKF9faXRlcikuY3VyciA+PiBQQUdFX1NISUZU KSkpO1wKCkkgY291bGQgZmlndXJlIG91dCB3aGF0IGlzIHRoZSBwZm4gPT0gMCBjaGVjayBmb3I/ IFRoZSBvdGhlciBsb29wIGhhcyBubyAKc3VjaCBjaGVja3Mgc28gb25lIG9mIHRoZW0gbG9va3Mg c3VzcGljaW91cyBvciBJIGFtIG1pc3Npbmcgc29tZXRoaW5nLgoKQWxzbyBJIHRoaW5rIHRvIGJl IHdvcnRoIGl0IHlvdSB3b3VsZCBoYXZlIHRvIGhhbmRsZSB0aGUgb2Zmc2V0IGFzIHdlbGwuIApU aGF0IHdheSBhbGwgdXNhZ2VzIGZvciBmb3JfZWFjaF9zZ19wYWdlIGNvdWxkIGJlIGNvbnZlcnRl ZCBhbmQgd2l0aG91dCAKaXQgaXQgbGVhdmVzIGEgbWl4IG9mIG5ldyBhbmQgb2xkLgoKPiArCSAg ICAgKCgoX19pdGVyKS5jdXJyICs9IFBBR0VfU0laRSkgPCAoX19pdGVyKS5tYXgpIHx8CQlcCj4g KwkJKChfX2l0ZXIpID0gX19zZ3RfaXRlcihzZ19uZXh0KChfX2l0ZXIpLnNncCksIGZhbHNlKSwg MCkpCj4KPiAgIC8qKgo+ICAgICogUmVxdWVzdCBxdWV1ZSBzdHJ1Y3R1cmUuCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2dlbS5jCj4gaW5kZXggMzhlNGUxZS4uMGZlN2U5NSAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aTkxNV9nZW0uYwo+IEBAIC0yMTY1LDcgKzIxNjUsOCBAQCBzdGF0aWMgdm9pZCBpOTE1X2dlbV9v YmplY3RfZnJlZV9tbWFwX29mZnNldChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQo+ ICAgc3RhdGljIHZvaWQKPiAgIGk5MTVfZ2VtX29iamVjdF9wdXRfcGFnZXNfZ3R0KHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCj4gICB7Cj4gLQlzdHJ1Y3Qgc2dfcGFnZV9pdGVyIHNn X2l0ZXI7Cj4gKwlzdHJ1Y3Qgc2d0X2l0ZXIgc2d0X2l0ZXI7Cj4gKwlzdHJ1Y3QgcGFnZSAqcGFn ZTsKPiAgIAlpbnQgcmV0Owo+Cj4gICAJQlVHX09OKG9iai0+bWFkdiA9PSBfX0k5MTVfTUFEVl9Q VVJHRUQpOwo+IEBAIC0yMTg3LDkgKzIxODgsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2dlbV9vYmpl Y3RfZnJlZV9tbWFwX29mZnNldChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQo+ICAg CWlmIChvYmotPm1hZHYgPT0gSTkxNV9NQURWX0RPTlRORUVEKQo+ICAgCQlvYmotPmRpcnR5ID0g MDsKPgo+IC0JZm9yX2VhY2hfc2dfcGFnZShvYmotPnBhZ2VzLT5zZ2wsICZzZ19pdGVyLCBvYmot PnBhZ2VzLT5uZW50cywgMCkgewo+IC0JCXN0cnVjdCBwYWdlICpwYWdlID0gc2dfcGFnZV9pdGVy X3BhZ2UoJnNnX2l0ZXIpOwo+IC0KPiArCWZvcl9lYWNoX3NndF9wYWdlKHBhZ2UsIHNndF9pdGVy LCBvYmotPnBhZ2VzKSB7Cj4gICAJCWlmIChvYmotPmRpcnR5KQo+ICAgCQkJc2V0X3BhZ2VfZGly dHkocGFnZSk7Cj4KPiBAQCAtMjI0Niw3ICsyMjQ1LDcgQEAgc3RhdGljIHZvaWQgaTkxNV9nZW1f b2JqZWN0X2ZyZWVfbW1hcF9vZmZzZXQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikK PiAgIAlzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZzsKPiAgIAlzdHJ1Y3Qgc2dfdGFibGUg KnN0Owo+ICAgCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7Cj4gLQlzdHJ1Y3Qgc2dfcGFnZV9pdGVy IHNnX2l0ZXI7Cj4gKwlzdHJ1Y3Qgc2d0X2l0ZXIgc2d0X2l0ZXI7Cj4gICAJc3RydWN0IHBhZ2Ug KnBhZ2U7Cj4gICAJdW5zaWduZWQgbG9uZyBsYXN0X3BmbiA9IDA7CS8qIHN1cHByZXNzIGdjYyB3 YXJuaW5nICovCj4gICAJaW50IHJldDsKPiBAQCAtMjM0Myw4ICsyMzQyLDggQEAgc3RhdGljIHZv aWQgaTkxNV9nZW1fb2JqZWN0X2ZyZWVfbW1hcF9vZmZzZXQoc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaikKPgo+ICAgZXJyX3BhZ2VzOgo+ICAgCXNnX21hcmtfZW5kKHNnKTsKPiAtCWZv cl9lYWNoX3NnX3BhZ2Uoc3QtPnNnbCwgJnNnX2l0ZXIsIHN0LT5uZW50cywgMCkKPiAtCQlwdXRf cGFnZShzZ19wYWdlX2l0ZXJfcGFnZSgmc2dfaXRlcikpOwo+ICsJZm9yX2VhY2hfc2d0X3BhZ2Uo cGFnZSwgc2d0X2l0ZXIsIHN0KQo+ICsJCXB1dF9wYWdlKHBhZ2UpOwo+ICAgCXNnX2ZyZWVfdGFi bGUoc3QpOwo+ICAgCWtmcmVlKHN0KTsKPgo+IEBAIC0yNDAzLDcgKzI0MDIsOCBAQCBzdGF0aWMg dm9pZCAqaTkxNV9nZW1fb2JqZWN0X21hcChjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqKQo+ICAgewo+ICAgCXVuc2lnbmVkIGxvbmcgbl9wYWdlcyA9IG9iai0+YmFzZS5zaXpl ID4+IFBBR0VfU0hJRlQ7Cj4gICAJc3RydWN0IHNnX3RhYmxlICpzZ3QgPSBvYmotPnBhZ2VzOwo+ IC0Jc3RydWN0IHNnX3BhZ2VfaXRlciBzZ19pdGVyOwo+ICsJc3RydWN0IHNndF9pdGVyIHNndF9p dGVyOwo+ICsJc3RydWN0IHBhZ2UgKnBhZ2U7Cj4gICAJc3RydWN0IHBhZ2UgKnN0YWNrX3BhZ2Vz WzMyXTsKPiAgIAlzdHJ1Y3QgcGFnZSAqKnBhZ2VzID0gc3RhY2tfcGFnZXM7Cj4gICAJdW5zaWdu ZWQgbG9uZyBpID0gMDsKPiBAQCAtMjQyMyw4ICsyNDIzLDggQEAgc3RhdGljIHZvaWQgKmk5MTVf Z2VtX29iamVjdF9tYXAoY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKPiAg IAkJfQo+ICAgCX0KPgo+IC0JZm9yX2VhY2hfc2dfcGFnZShzZ3QtPnNnbCwgJnNnX2l0ZXIsIHNn dC0+bmVudHMsIDApCj4gLQkJcGFnZXNbaSsrXSA9IHNnX3BhZ2VfaXRlcl9wYWdlKCZzZ19pdGVy KTsKPiArCWZvcl9lYWNoX3NndF9wYWdlKHBhZ2UsIHNndF9pdGVyLCBzZ3QpCj4gKwkJcGFnZXNb aSsrXSA9IHBhZ2U7Cj4KPiAgIAkvKiBDaGVjayB0aGF0IHdlIGhhdmUgdGhlIGV4cGVjdGVkIG51 bWJlciBvZiBwYWdlcyAqLwo+ICAgCUdFTV9CVUdfT04oaSAhPSBuX3BhZ2VzKTsKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZmVuY2UuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZ2VtX2ZlbmNlLmMKPiBpbmRleCBhMmI5MzhlLi4yYjZiZGMyIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2ZlbmNlLmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9mZW5jZS5jCj4gQEAgLTc0NSwxNSArNzQ1LDE1 IEBAIHZvaWQgaTkxNV9nZW1fcmVzdG9yZV9mZW5jZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldikK PiAgIHZvaWQKPiAgIGk5MTVfZ2VtX29iamVjdF9kb19iaXRfMTdfc3dpenpsZShzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqKQo+ICAgewo+IC0Jc3RydWN0IHNnX3BhZ2VfaXRlciBzZ19p dGVyOwo+ICsJc3RydWN0IHNndF9pdGVyIHNndF9pdGVyOwo+ICsJc3RydWN0IHBhZ2UgKnBhZ2U7 Cj4gICAJaW50IGk7Cj4KPiAgIAlpZiAob2JqLT5iaXRfMTcgPT0gTlVMTCkKPiAgIAkJcmV0dXJu Owo+Cj4gICAJaSA9IDA7Cj4gLQlmb3JfZWFjaF9zZ19wYWdlKG9iai0+cGFnZXMtPnNnbCwgJnNn X2l0ZXIsIG9iai0+cGFnZXMtPm5lbnRzLCAwKSB7Cj4gLQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBz Z19wYWdlX2l0ZXJfcGFnZSgmc2dfaXRlcik7Cj4gKwlmb3JfZWFjaF9zZ3RfcGFnZShwYWdlLCBz Z3RfaXRlciwgb2JqLT5wYWdlcykgewo+ICAgCQljaGFyIG5ld19iaXRfMTcgPSBwYWdlX3RvX3Bo eXMocGFnZSkgPj4gMTc7Cj4gICAJCWlmICgobmV3X2JpdF8xNyAmIDB4MSkgIT0KPiAgIAkJICAg ICh0ZXN0X2JpdChpLCBvYmotPmJpdF8xNykgIT0gMCkpIHsKPiBAQCAtNzc1LDcgKzc3NSw4IEBA IHZvaWQgaTkxNV9nZW1fcmVzdG9yZV9mZW5jZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiAg IHZvaWQKPiAgIGk5MTVfZ2VtX29iamVjdF9zYXZlX2JpdF8xN19zd2l6emxlKHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmopCj4gICB7Cj4gLQlzdHJ1Y3Qgc2dfcGFnZV9pdGVyIHNnX2l0 ZXI7Cj4gKwlzdHJ1Y3Qgc2d0X2l0ZXIgc2d0X2l0ZXI7Cj4gKwlzdHJ1Y3QgcGFnZSAqcGFnZTsK PiAgIAlpbnQgcGFnZV9jb3VudCA9IG9iai0+YmFzZS5zaXplID4+IFBBR0VfU0hJRlQ7Cj4gICAJ aW50IGk7Cj4KPiBAQCAtNzkwLDggKzc5MSw5IEBAIHZvaWQgaTkxNV9nZW1fcmVzdG9yZV9mZW5j ZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiAgIAl9Cj4KPiAgIAlpID0gMDsKPiAtCWZvcl9l YWNoX3NnX3BhZ2Uob2JqLT5wYWdlcy0+c2dsLCAmc2dfaXRlciwgb2JqLT5wYWdlcy0+bmVudHMs IDApIHsKPiAtCQlpZiAocGFnZV90b19waHlzKHNnX3BhZ2VfaXRlcl9wYWdlKCZzZ19pdGVyKSkg JiAoMSA8PCAxNykpCj4gKwo+ICsJZm9yX2VhY2hfc2d0X3BhZ2UocGFnZSwgc2d0X2l0ZXIsIG9i ai0+cGFnZXMpIHsKPiArCQlpZiAocGFnZV90b19waHlzKHBhZ2UpICYgKDEgPDwgMTcpKQo+ICAg CQkJX19zZXRfYml0KGksIG9iai0+Yml0XzE3KTsKPiAgIAkJZWxzZQo+ICAgCQkJX19jbGVhcl9i aXQoaSwgb2JqLT5iaXRfMTcpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dlbV9ndHQuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2d0dC5jCj4gaW5k ZXggN2VhYjYxOS4uNDY2ODQ3NyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dlbV9ndHQuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2d0dC5j Cj4gQEAgLTE4MzksMjAgKzE4MzksMTkgQEAgc3RhdGljIHZvaWQgZ2VuNl9wcGd0dF9pbnNlcnRf ZW50cmllcyhzdHJ1Y3QgaTkxNV9hZGRyZXNzX3NwYWNlICp2bSwKPiAgIAkJCQkgICAgICBlbnVt IGk5MTVfY2FjaGVfbGV2ZWwgY2FjaGVfbGV2ZWwsIHUzMiBmbGFncykKPiAgIHsKPiAgIAlzdHJ1 Y3QgaTkxNV9od19wcGd0dCAqcHBndHQgPSBpOTE1X3ZtX3RvX3BwZ3R0KHZtKTsKPiAtCWdlbjZf cHRlX3QgKnB0X3ZhZGRyOwo+ICAgCXVuc2lnbmVkIGZpcnN0X2VudHJ5ID0gc3RhcnQgPj4gUEFH RV9TSElGVDsKPiAgIAl1bnNpZ25lZCBhY3RfcHQgPSBmaXJzdF9lbnRyeSAvIEdFTjZfUFRFUzsK PiAgIAl1bnNpZ25lZCBhY3RfcHRlID0gZmlyc3RfZW50cnkgJSBHRU42X1BURVM7Cj4gLQlzdHJ1 Y3Qgc2dfcGFnZV9pdGVyIHNnX2l0ZXI7Cj4gKwlnZW42X3B0ZV90ICpwdF92YWRkciA9IE5VTEw7 Cj4gKwlzdHJ1Y3Qgc2d0X2l0ZXIgc2d0X2l0ZXI7Cj4gKwlkbWFfYWRkcl90IGFkZHI7Cj4KPiAt CXB0X3ZhZGRyID0gTlVMTDsKPiAtCWZvcl9lYWNoX3NnX3BhZ2UocGFnZXMtPnNnbCwgJnNnX2l0 ZXIsIHBhZ2VzLT5uZW50cywgMCkgewo+ICsJZm9yX2VhY2hfc2d0X2RtYShhZGRyLCBzZ3RfaXRl ciwgcGFnZXMpIHsKPiAgIAkJaWYgKHB0X3ZhZGRyID09IE5VTEwpCj4gICAJCQlwdF92YWRkciA9 IGttYXBfcHgocHBndHQtPnBkLnBhZ2VfdGFibGVbYWN0X3B0XSk7Cj4KPiAgIAkJcHRfdmFkZHJb YWN0X3B0ZV0gPQo+IC0JCQl2bS0+cHRlX2VuY29kZShzZ19wYWdlX2l0ZXJfZG1hX2FkZHJlc3Mo JnNnX2l0ZXIpLAo+IC0JCQkJICAgICAgIGNhY2hlX2xldmVsLCB0cnVlLCBmbGFncyk7Cj4gKwkJ CXZtLT5wdGVfZW5jb2RlKGFkZHIsIGNhY2hlX2xldmVsLCB0cnVlLCBmbGFncyk7Cj4KPiAgIAkJ aWYgKCsrYWN0X3B0ZSA9PSBHRU42X1BURVMpIHsKPiAgIAkJCWt1bm1hcF9weChwcGd0dCwgcHRf dmFkZHIpOwo+IEBAIC0xODYxLDYgKzE4NjAsNyBAQCBzdGF0aWMgdm9pZCBnZW42X3BwZ3R0X2lu c2VydF9lbnRyaWVzKHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnZtLAo+ICAgCQkJYWN0X3B0 ZSA9IDA7Cj4gICAJCX0KPiAgIAl9Cj4gKwo+ICAgCWlmIChwdF92YWRkcikKPiAgIAkJa3VubWFw X3B4KHBwZ3R0LCBwdF92YWRkcik7Cj4gICB9Cj4gQEAgLTIzNjIsMjIgKzIzNjIsMjAgQEAgc3Rh dGljIHZvaWQgZ2VuOF9nZ3R0X2luc2VydF9lbnRyaWVzKHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3Bh Y2UgKnZtLAo+ICAgewo+ICAgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRv X2k5MTUodm0tPmRldik7Cj4gICAJc3RydWN0IGk5MTVfZ2d0dCAqZ2d0dCA9IGk5MTVfdm1fdG9f Z2d0dCh2bSk7Cj4gLQl1bnNpZ25lZCBmaXJzdF9lbnRyeSA9IHN0YXJ0ID4+IFBBR0VfU0hJRlQ7 Cj4gLQlnZW44X3B0ZV90IF9faW9tZW0gKmd0dF9lbnRyaWVzID0KPiAtCQkoZ2VuOF9wdGVfdCBf X2lvbWVtICopZ2d0dC0+Z3NtICsgZmlyc3RfZW50cnk7Cj4gLQlpbnQgaSA9IDA7Cj4gLQlzdHJ1 Y3Qgc2dfcGFnZV9pdGVyIHNnX2l0ZXI7Cj4gLQlkbWFfYWRkcl90IGFkZHIgPSAwOyAvKiBzaHV0 IHVwIGdjYyAqLwo+ICsJc3RydWN0IHNndF9pdGVyIHNndF9pdGVyOwo+ICsJZ2VuOF9wdGVfdCBf X2lvbWVtICpndHRfZW50cmllczsKPiArCWdlbjhfcHRlX3QgZ3R0X2VudHJ5Owo+ICsJZG1hX2Fk ZHJfdCBhZGRyOwo+ICAgCWludCBycG1fYXRvbWljX3NlcTsKPiArCWludCBpID0gMDsKPgo+ICAg CXJwbV9hdG9taWNfc2VxID0gYXNzZXJ0X3JwbV9hdG9taWNfYmVnaW4oZGV2X3ByaXYpOwo+Cj4g LQlmb3JfZWFjaF9zZ19wYWdlKHN0LT5zZ2wsICZzZ19pdGVyLCBzdC0+bmVudHMsIDApIHsKPiAt CQlhZGRyID0gc2dfZG1hX2FkZHJlc3Moc2dfaXRlci5zZykgKwo+IC0JCQkoc2dfaXRlci5zZ19w Z29mZnNldCA8PCBQQUdFX1NISUZUKTsKPiAtCQlnZW44X3NldF9wdGUoJmd0dF9lbnRyaWVzW2ld LAo+IC0JCQkgICAgIGdlbjhfcHRlX2VuY29kZShhZGRyLCBsZXZlbCwgdHJ1ZSkpOwo+IC0JCWkr KzsKPiArCWd0dF9lbnRyaWVzID0gKGdlbjhfcHRlX3QgX19pb21lbSAqKWdndHQtPmdzbSArIChz dGFydCA+PiBQQUdFX1NISUZUKTsKPiArCj4gKwlmb3JfZWFjaF9zZ3RfZG1hKGFkZHIsIHNndF9p dGVyLCBzdCkgewo+ICsJCWd0dF9lbnRyeSA9IGdlbjhfcHRlX2VuY29kZShhZGRyLCBsZXZlbCwg dHJ1ZSk7Cj4gKwkJZ2VuOF9zZXRfcHRlKCZndHRfZW50cmllc1tpKytdLCBndHRfZW50cnkpOwo+ ICAgCX0KPgo+ICAgCS8qCj4gQEAgLTIzODgsOCArMjM4Niw3IEBAIHN0YXRpYyB2b2lkIGdlbjhf Z2d0dF9pbnNlcnRfZW50cmllcyhzdHJ1Y3QgaTkxNV9hZGRyZXNzX3NwYWNlICp2bSwKPiAgIAkg KiBoYXJkd2FyZSBzaG91bGQgd29yaywgd2UgbXVzdCBrZWVwIHRoaXMgcG9zdGluZyByZWFkIGZv ciBwYXJhbm9pYS4KPiAgIAkgKi8KPiAgIAlpZiAoaSAhPSAwKQo+IC0JCVdBUk5fT04ocmVhZHEo Jmd0dF9lbnRyaWVzW2ktMV0pCj4gLQkJCSE9IGdlbjhfcHRlX2VuY29kZShhZGRyLCBsZXZlbCwg dHJ1ZSkpOwo+ICsJCVdBUk5fT04ocmVhZHEoJmd0dF9lbnRyaWVzW2ktMV0pICE9IGd0dF9lbnRy eSk7Cj4KPiAgIAkvKiBUaGlzIG5leHQgYml0IG1ha2VzIHRoZSBhYm92ZSBwb3N0aW5nIHJlYWQg ZXZlbiBtb3JlIGltcG9ydGFudC4gV2UKPiAgIAkgKiB3YW50IHRvIGZsdXNoIHRoZSBUTEJzIG9u bHkgYWZ0ZXIgd2UncmUgY2VydGFpbiBhbGwgdGhlIFBURSB1cGRhdGVzCj4gQEAgLTI0NDAsMjAg KzI0MzcsMjAgQEAgc3RhdGljIHZvaWQgZ2VuNl9nZ3R0X2luc2VydF9lbnRyaWVzKHN0cnVjdCBp OTE1X2FkZHJlc3Nfc3BhY2UgKnZtLAo+ICAgewo+ICAgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdiA9IHRvX2k5MTUodm0tPmRldik7Cj4gICAJc3RydWN0IGk5MTVfZ2d0dCAqZ2d0 dCA9IGk5MTVfdm1fdG9fZ2d0dCh2bSk7Cj4gLQl1bnNpZ25lZCBmaXJzdF9lbnRyeSA9IHN0YXJ0 ID4+IFBBR0VfU0hJRlQ7Cj4gLQlnZW42X3B0ZV90IF9faW9tZW0gKmd0dF9lbnRyaWVzID0KPiAt CQkoZ2VuNl9wdGVfdCBfX2lvbWVtICopZ2d0dC0+Z3NtICsgZmlyc3RfZW50cnk7Cj4gLQlpbnQg aSA9IDA7Cj4gLQlzdHJ1Y3Qgc2dfcGFnZV9pdGVyIHNnX2l0ZXI7Cj4gLQlkbWFfYWRkcl90IGFk ZHIgPSAwOwo+ICsJc3RydWN0IHNndF9pdGVyIHNndF9pdGVyOwo+ICsJZ2VuNl9wdGVfdCBfX2lv bWVtICpndHRfZW50cmllczsKPiArCWdlbjZfcHRlX3QgZ3R0X2VudHJ5Owo+ICsJZG1hX2FkZHJf dCBhZGRyOwo+ICAgCWludCBycG1fYXRvbWljX3NlcTsKPiArCWludCBpID0gMDsKPgo+ICAgCXJw bV9hdG9taWNfc2VxID0gYXNzZXJ0X3JwbV9hdG9taWNfYmVnaW4oZGV2X3ByaXYpOwo+Cj4gLQlm b3JfZWFjaF9zZ19wYWdlKHN0LT5zZ2wsICZzZ19pdGVyLCBzdC0+bmVudHMsIDApIHsKPiAtCQlh ZGRyID0gc2dfcGFnZV9pdGVyX2RtYV9hZGRyZXNzKCZzZ19pdGVyKTsKPiAtCQlpb3dyaXRlMzIo dm0tPnB0ZV9lbmNvZGUoYWRkciwgbGV2ZWwsIHRydWUsIGZsYWdzKSwgJmd0dF9lbnRyaWVzW2ld KTsKPiAtCQlpKys7Cj4gKwlndHRfZW50cmllcyA9IChnZW42X3B0ZV90IF9faW9tZW0gKilnZ3R0 LT5nc20gKyAoc3RhcnQgPj4gUEFHRV9TSElGVCk7Cj4gKwo+ICsJZm9yX2VhY2hfc2d0X2RtYShh ZGRyLCBzZ3RfaXRlciwgc3QpIHsKPiArCQlndHRfZW50cnkgPSB2bS0+cHRlX2VuY29kZShhZGRy LCBsZXZlbCwgdHJ1ZSwgZmxhZ3MpOwo+ICsJCWlvd3JpdGUzMihndHRfZW50cnksICZndHRfZW50 cmllc1tpKytdKTsKPiAgIAl9Cj4KPiAgIAkvKiBYWFg6IFRoaXMgc2VydmVzIGFzIGEgcG9zdGlu ZyByZWFkIHRvIG1ha2Ugc3VyZSB0aGF0IHRoZSBQVEUgaGFzCj4gQEAgLTI0NjIsMTAgKzI0NTks OCBAQCBzdGF0aWMgdm9pZCBnZW42X2dndHRfaW5zZXJ0X2VudHJpZXMoc3RydWN0IGk5MTVfYWRk cmVzc19zcGFjZSAqdm0sCj4gICAJICogb2YgTlVNQSBhY2Nlc3MgcGF0dGVybnMuIFRoZXJlZm9y ZSwgZXZlbiB3aXRoIHRoZSB3YXkgd2UgYXNzdW1lCj4gICAJICogaGFyZHdhcmUgc2hvdWxkIHdv cmssIHdlIG11c3Qga2VlcCB0aGlzIHBvc3RpbmcgcmVhZCBmb3IgcGFyYW5vaWEuCj4gICAJICov Cj4gLQlpZiAoaSAhPSAwKSB7Cj4gLQkJdW5zaWduZWQgbG9uZyBndHQgPSByZWFkbCgmZ3R0X2Vu dHJpZXNbaS0xXSk7Cj4gLQkJV0FSTl9PTihndHQgIT0gdm0tPnB0ZV9lbmNvZGUoYWRkciwgbGV2 ZWwsIHRydWUsIGZsYWdzKSk7Cj4gLQl9Cj4gKwlpZiAoaSAhPSAwKQo+ICsJCVdBUk5fT04ocmVh ZGwoJmd0dF9lbnRyaWVzW2ktMV0pICE9IGd0dF9lbnRyeSk7Cj4KPiAgIAkvKiBUaGlzIG5leHQg Yml0IG1ha2VzIHRoZSBhYm92ZSBwb3N0aW5nIHJlYWQgZXZlbiBtb3JlIGltcG9ydGFudC4gV2UK PiAgIAkgKiB3YW50IHRvIGZsdXNoIHRoZSBUTEJzIG9ubHkgYWZ0ZXIgd2UncmUgY2VydGFpbiBh bGwgdGhlIFBURSB1cGRhdGVzCj4gQEAgLTMzOTksOSArMzM5NCwxMSBAQCBzdHJ1Y3QgaTkxNV92 bWEgKgo+ICAgaW50ZWxfcm90YXRlX2ZiX29ial9wYWdlcyhzdHJ1Y3QgaW50ZWxfcm90YXRpb25f aW5mbyAqcm90X2luZm8sCj4gICAJCQkgIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmop Cj4gICB7Cj4gKwljb25zdCBzaXplX3Qgbl9wYWdlcyA9IG9iai0+YmFzZS5zaXplIC8gUEFHRV9T SVpFOwo+ICAgCXVuc2lnbmVkIGludCBzaXplX3BhZ2VzID0gcm90X2luZm8tPnBsYW5lWzBdLndp ZHRoICogcm90X2luZm8tPnBsYW5lWzBdLmhlaWdodDsKPiAgIAl1bnNpZ25lZCBpbnQgc2l6ZV9w YWdlc191djsKPiAtCXN0cnVjdCBzZ19wYWdlX2l0ZXIgc2dfaXRlcjsKPiArCXN0cnVjdCBzZ3Rf aXRlciBzZ3RfaXRlcjsKPiArCWRtYV9hZGRyX3QgZG1hX2FkZHI7Cj4gICAJdW5zaWduZWQgbG9u ZyBpOwo+ICAgCWRtYV9hZGRyX3QgKnBhZ2VfYWRkcl9saXN0Owo+ICAgCXN0cnVjdCBzZ190YWJs ZSAqc3Q7Cj4gQEAgLTM0MTAsNyArMzQwNyw3IEBAIHN0cnVjdCBpOTE1X3ZtYSAqCj4gICAJaW50 IHJldCA9IC1FTk9NRU07Cj4KPiAgIAkvKiBBbGxvY2F0ZSBhIHRlbXBvcmFyeSBsaXN0IG9mIHNv dXJjZSBwYWdlcyBmb3IgcmFuZG9tIGFjY2Vzcy4gKi8KPiAtCXBhZ2VfYWRkcl9saXN0ID0gZHJt X21hbGxvY19nZnAob2JqLT5iYXNlLnNpemUgLyBQQUdFX1NJWkUsCj4gKwlwYWdlX2FkZHJfbGlz dCA9IGRybV9tYWxsb2NfZ2ZwKG5fcGFnZXMsCj4gICAJCQkJCXNpemVvZihkbWFfYWRkcl90KSwK PiAgIAkJCQkJR0ZQX1RFTVBPUkFSWSk7Cj4gICAJaWYgKCFwYWdlX2FkZHJfbGlzdCkKPiBAQCAt MzQzMywxMSArMzQzMCwxMCBAQCBzdHJ1Y3QgaTkxNV92bWEgKgo+Cj4gICAJLyogUG9wdWxhdGUg c291cmNlIHBhZ2UgbGlzdCBmcm9tIHRoZSBvYmplY3QuICovCj4gICAJaSA9IDA7Cj4gLQlmb3Jf ZWFjaF9zZ19wYWdlKG9iai0+cGFnZXMtPnNnbCwgJnNnX2l0ZXIsIG9iai0+cGFnZXMtPm5lbnRz LCAwKSB7Cj4gLQkJcGFnZV9hZGRyX2xpc3RbaV0gPSBzZ19wYWdlX2l0ZXJfZG1hX2FkZHJlc3Mo JnNnX2l0ZXIpOwo+IC0JCWkrKzsKPiAtCX0KPiArCWZvcl9lYWNoX3NndF9kbWEoZG1hX2FkZHIs IHNndF9pdGVyLCBvYmotPnBhZ2VzKQo+ICsJCXBhZ2VfYWRkcl9saXN0W2krK10gPSBkbWFfYWRk cjsKPgo+ICsJR0VNX0JVR19PTihpICE9IG5fcGFnZXMpOwo+ICAgCXN0LT5uZW50cyA9IDA7Cj4g ICAJc2cgPSBzdC0+c2dsOwo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZ2VtX3VzZXJwdHIuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX3VzZXJwdHIu Ywo+IGluZGV4IDMyZDk3MjYuLmQyYzE1OTUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9nZW1fdXNlcnB0ci5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9nZW1fdXNlcnB0ci5jCj4gQEAgLTcwNiw3ICs3MDYsOCBAQCBzdHJ1Y3QgZ2V0X3BhZ2VzX3dv cmsgewo+ICAgc3RhdGljIHZvaWQKPiAgIGk5MTVfZ2VtX3VzZXJwdHJfcHV0X3BhZ2VzKHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCj4gICB7Cj4gLQlzdHJ1Y3Qgc2dfcGFnZV9pdGVy IHNnX2l0ZXI7Cj4gKwlzdHJ1Y3Qgc2d0X2l0ZXIgc2d0X2l0ZXI7Cj4gKwlzdHJ1Y3QgcGFnZSAq cGFnZTsKPgo+ICAgCUJVR19PTihvYmotPnVzZXJwdHIud29yayAhPSBOVUxMKTsKPiAgIAlfX2k5 MTVfZ2VtX3VzZXJwdHJfc2V0X2FjdGl2ZShvYmosIGZhbHNlKTsKPiBAQCAtNzE2LDkgKzcxNyw3 IEBAIHN0cnVjdCBnZXRfcGFnZXNfd29yayB7Cj4KPiAgIAlpOTE1X2dlbV9ndHRfZmluaXNoX29i amVjdChvYmopOwo+Cj4gLQlmb3JfZWFjaF9zZ19wYWdlKG9iai0+cGFnZXMtPnNnbCwgJnNnX2l0 ZXIsIG9iai0+cGFnZXMtPm5lbnRzLCAwKSB7Cj4gLQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBzZ19w YWdlX2l0ZXJfcGFnZSgmc2dfaXRlcik7Cj4gLQo+ICsJZm9yX2VhY2hfc2d0X3BhZ2UocGFnZSwg c2d0X2l0ZXIsIG9iai0+cGFnZXMpIHsKPiAgIAkJaWYgKG9iai0+ZGlydHkpCj4gICAJCQlzZXRf cGFnZV9kaXJ0eShwYWdlKTsKPgo+CgpDb3VsZG4ndCBzcG90IGFueSBwcm9ibGVtcyBpbiB0aGlz IGJsb2NrLgoKUmVnYXJkcywKClR2cnRrbwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755220AbcEQKee (ORCPT ); Tue, 17 May 2016 06:34:34 -0400 Received: from mga11.intel.com ([192.55.52.93]:61012 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751303AbcEQKed (ORCPT ); Tue, 17 May 2016 06:34:33 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.26,324,1459839600"; d="scan'208";a="105287737" Subject: Re: [Intel-gfx] [PATCH 3/3] Introduce & use new lightweight SGL iterators To: Dave Gordon , intel-gfx@lists.freedesktop.org References: <1463411944-13533-1-git-send-email-david.s.gordon@intel.com> <1463411944-13533-3-git-send-email-david.s.gordon@intel.com> Cc: linux-kernel@vger.kernel.org From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <573AF3B6.3060403@linux.intel.com> Date: Tue, 17 May 2016 11:34:30 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.6.0 MIME-Version: 1.0 In-Reply-To: <1463411944-13533-3-git-send-email-david.s.gordon@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 16/05/16 16:19, Dave Gordon wrote: > The existing for_each_sg_page() iterator is somewhat heavyweight, and is > limiting i915 driver performance in a few benchmarks. So here we > introduce somewhat lighter weight iterators, primarily for use with GEM > objects or other case where we need only deal with whole aligned pages. Interesting idea, if for nothing then for eliminating the dreaded st->nents of for_each_sg_page. :) Which benchmarks it improves and how much do you know? It generates more code for me but that seems to be by design, yes? Because what were previously calls to __sg_page_iter_next is now effectively inlined and instead there is only a call to sg_next, which __sg_page_iter_next would call anyway. > Unlike the old iterator, the new iterators use an internal state > structure which is not intended to be accessed by the caller; instead > each takes as a parameter an output variable which is set before each > iteration. This makes them particularly simple to use :) > > One of the new iterators provides the caller with the DMA address of > each page in turn; the other provides the 'struct page' pointer required > by many memory management operations. > > Various uses of for_each_sg_page() are then converted to the new macros. > > Signed-off-by: Dave Gordon > Cc: Chris Wilson > Cc: linux-kernel@vger.kernel.org > --- > drivers/gpu/drm/i915/i915_drv.h | 62 +++++++++++++++++++++++++-- > drivers/gpu/drm/i915/i915_gem.c | 20 ++++----- > drivers/gpu/drm/i915/i915_gem_fence.c | 14 +++--- > drivers/gpu/drm/i915/i915_gem_gtt.c | 76 ++++++++++++++++----------------- > drivers/gpu/drm/i915/i915_gem_userptr.c | 7 ++- > 5 files changed, 116 insertions(+), 63 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index 72f0b02..c0fc6aa 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -2125,6 +2125,10 @@ struct drm_i915_gem_object_ops { > #define INTEL_FRONTBUFFER_ALL_MASK(pipe) \ > (0xff << (INTEL_FRONTBUFFER_BITS_PER_PIPE * (pipe))) > > +void i915_gem_track_fb(struct drm_i915_gem_object *old, > + struct drm_i915_gem_object *new, > + unsigned frontbuffer_bits); > + > struct drm_i915_gem_object { > struct drm_gem_object base; > > @@ -2256,9 +2260,61 @@ struct drm_i915_gem_object { > }; > #define to_intel_bo(x) container_of(x, struct drm_i915_gem_object, base) > > -void i915_gem_track_fb(struct drm_i915_gem_object *old, > - struct drm_i915_gem_object *new, > - unsigned frontbuffer_bits); > +/* > + * New optimised SGL iterator for i915 GEM objects > + */ > +struct sgt_iter { > + struct scatterlist *sgp; > + union { > + unsigned long pfn; > + unsigned long dma; dma_addr_t > + } ix; > + unsigned int curr; > + unsigned int max; I think since this counts in bytes it should match obj->base.size which is a size_t? Also, maybe the iterator would be more efficient if it counted in pages? Hm, probably makes no difference, but maybe worth exploring. Was just thinking about avoiding the need to to convert byte position to page position in every iteration. > +}; > + > +/* Constructor for new iterator */ > +static inline struct sgt_iter > +__sgt_iter(struct scatterlist *sgl, bool dma) > +{ > + struct sgt_iter s = { .sgp = sgl }; > + > + if (sgl) { > + s.max = s.curr = sgl->offset; > + s.max += sgl->length; > + if (dma) > + s.ix.dma = sg_dma_address(sgl); > + else > + s.ix.pfn = page_to_pfn(sg_page(sgl)); I suppose we can rely on the compiler to optimize one branch away rather than having to provide two iterators. > + } > + > + return s; > +} > + > +/** > + * for_each_sgt_dma - iterate over the DMA addresses of the given sg_table > + * @__dmap: DMA address (output) > + * @__iter: 'struct sgt_iter' (iterator state, internal) > + * @__sgt: sg_table to iterate over (input) > + */ > +#define for_each_sgt_dma(__dmap, __iter, __sgt) \ > + for ((__iter) = __sgt_iter((__sgt)->sgl, true); \ > + ((__dmap) = (__iter).ix.dma + (__iter).curr); \ > + (((__iter).curr += PAGE_SIZE) < (__iter).max) || \ > + ((__iter) = __sgt_iter(sg_next((__iter).sgp), true), 0)) > + > +/** > + * for_each_sgt_page - iterate over the pages of the given sg_table > + * @__pp: page pointer (output) > + * @__iter: 'struct sgt_iter' (iterator state, internal) > + * @__sgt: sg_table to iterate over (input) > + */ > +#define for_each_sgt_page(__pp, __iter, __sgt) \ > + for ((__iter) = __sgt_iter((__sgt)->sgl, false); \ > + ((__pp) = (__iter).ix.pfn == 0 ? NULL : \ > + pfn_to_page((__iter).ix.pfn + ((__iter).curr >> PAGE_SHIFT)));\ I could figure out what is the pfn == 0 check for? The other loop has no such checks so one of them looks suspicious or I am missing something. Also I think to be worth it you would have to handle the offset as well. That way all usages for for_each_sg_page could be converted and without it it leaves a mix of new and old. > + (((__iter).curr += PAGE_SIZE) < (__iter).max) || \ > + ((__iter) = __sgt_iter(sg_next((__iter).sgp), false), 0)) > > /** > * Request queue structure. > diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c > index 38e4e1e..0fe7e95 100644 > --- a/drivers/gpu/drm/i915/i915_gem.c > +++ b/drivers/gpu/drm/i915/i915_gem.c > @@ -2165,7 +2165,8 @@ static void i915_gem_object_free_mmap_offset(struct drm_i915_gem_object *obj) > static void > i915_gem_object_put_pages_gtt(struct drm_i915_gem_object *obj) > { > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + struct page *page; > int ret; > > BUG_ON(obj->madv == __I915_MADV_PURGED); > @@ -2187,9 +2188,7 @@ static void i915_gem_object_free_mmap_offset(struct drm_i915_gem_object *obj) > if (obj->madv == I915_MADV_DONTNEED) > obj->dirty = 0; > > - for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0) { > - struct page *page = sg_page_iter_page(&sg_iter); > - > + for_each_sgt_page(page, sgt_iter, obj->pages) { > if (obj->dirty) > set_page_dirty(page); > > @@ -2246,7 +2245,7 @@ static void i915_gem_object_free_mmap_offset(struct drm_i915_gem_object *obj) > struct address_space *mapping; > struct sg_table *st; > struct scatterlist *sg; > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > struct page *page; > unsigned long last_pfn = 0; /* suppress gcc warning */ > int ret; > @@ -2343,8 +2342,8 @@ static void i915_gem_object_free_mmap_offset(struct drm_i915_gem_object *obj) > > err_pages: > sg_mark_end(sg); > - for_each_sg_page(st->sgl, &sg_iter, st->nents, 0) > - put_page(sg_page_iter_page(&sg_iter)); > + for_each_sgt_page(page, sgt_iter, st) > + put_page(page); > sg_free_table(st); > kfree(st); > > @@ -2403,7 +2402,8 @@ static void *i915_gem_object_map(const struct drm_i915_gem_object *obj) > { > unsigned long n_pages = obj->base.size >> PAGE_SHIFT; > struct sg_table *sgt = obj->pages; > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + struct page *page; > struct page *stack_pages[32]; > struct page **pages = stack_pages; > unsigned long i = 0; > @@ -2423,8 +2423,8 @@ static void *i915_gem_object_map(const struct drm_i915_gem_object *obj) > } > } > > - for_each_sg_page(sgt->sgl, &sg_iter, sgt->nents, 0) > - pages[i++] = sg_page_iter_page(&sg_iter); > + for_each_sgt_page(page, sgt_iter, sgt) > + pages[i++] = page; > > /* Check that we have the expected number of pages */ > GEM_BUG_ON(i != n_pages); > diff --git a/drivers/gpu/drm/i915/i915_gem_fence.c b/drivers/gpu/drm/i915/i915_gem_fence.c > index a2b938e..2b6bdc2 100644 > --- a/drivers/gpu/drm/i915/i915_gem_fence.c > +++ b/drivers/gpu/drm/i915/i915_gem_fence.c > @@ -745,15 +745,15 @@ void i915_gem_restore_fences(struct drm_device *dev) > void > i915_gem_object_do_bit_17_swizzle(struct drm_i915_gem_object *obj) > { > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + struct page *page; > int i; > > if (obj->bit_17 == NULL) > return; > > i = 0; > - for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0) { > - struct page *page = sg_page_iter_page(&sg_iter); > + for_each_sgt_page(page, sgt_iter, obj->pages) { > char new_bit_17 = page_to_phys(page) >> 17; > if ((new_bit_17 & 0x1) != > (test_bit(i, obj->bit_17) != 0)) { > @@ -775,7 +775,8 @@ void i915_gem_restore_fences(struct drm_device *dev) > void > i915_gem_object_save_bit_17_swizzle(struct drm_i915_gem_object *obj) > { > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + struct page *page; > int page_count = obj->base.size >> PAGE_SHIFT; > int i; > > @@ -790,8 +791,9 @@ void i915_gem_restore_fences(struct drm_device *dev) > } > > i = 0; > - for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0) { > - if (page_to_phys(sg_page_iter_page(&sg_iter)) & (1 << 17)) > + > + for_each_sgt_page(page, sgt_iter, obj->pages) { > + if (page_to_phys(page) & (1 << 17)) > __set_bit(i, obj->bit_17); > else > __clear_bit(i, obj->bit_17); > diff --git a/drivers/gpu/drm/i915/i915_gem_gtt.c b/drivers/gpu/drm/i915/i915_gem_gtt.c > index 7eab619..4668477 100644 > --- a/drivers/gpu/drm/i915/i915_gem_gtt.c > +++ b/drivers/gpu/drm/i915/i915_gem_gtt.c > @@ -1839,20 +1839,19 @@ static void gen6_ppgtt_insert_entries(struct i915_address_space *vm, > enum i915_cache_level cache_level, u32 flags) > { > struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm); > - gen6_pte_t *pt_vaddr; > unsigned first_entry = start >> PAGE_SHIFT; > unsigned act_pt = first_entry / GEN6_PTES; > unsigned act_pte = first_entry % GEN6_PTES; > - struct sg_page_iter sg_iter; > + gen6_pte_t *pt_vaddr = NULL; > + struct sgt_iter sgt_iter; > + dma_addr_t addr; > > - pt_vaddr = NULL; > - for_each_sg_page(pages->sgl, &sg_iter, pages->nents, 0) { > + for_each_sgt_dma(addr, sgt_iter, pages) { > if (pt_vaddr == NULL) > pt_vaddr = kmap_px(ppgtt->pd.page_table[act_pt]); > > pt_vaddr[act_pte] = > - vm->pte_encode(sg_page_iter_dma_address(&sg_iter), > - cache_level, true, flags); > + vm->pte_encode(addr, cache_level, true, flags); > > if (++act_pte == GEN6_PTES) { > kunmap_px(ppgtt, pt_vaddr); > @@ -1861,6 +1860,7 @@ static void gen6_ppgtt_insert_entries(struct i915_address_space *vm, > act_pte = 0; > } > } > + > if (pt_vaddr) > kunmap_px(ppgtt, pt_vaddr); > } > @@ -2362,22 +2362,20 @@ static void gen8_ggtt_insert_entries(struct i915_address_space *vm, > { > struct drm_i915_private *dev_priv = to_i915(vm->dev); > struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm); > - unsigned first_entry = start >> PAGE_SHIFT; > - gen8_pte_t __iomem *gtt_entries = > - (gen8_pte_t __iomem *)ggtt->gsm + first_entry; > - int i = 0; > - struct sg_page_iter sg_iter; > - dma_addr_t addr = 0; /* shut up gcc */ > + struct sgt_iter sgt_iter; > + gen8_pte_t __iomem *gtt_entries; > + gen8_pte_t gtt_entry; > + dma_addr_t addr; > int rpm_atomic_seq; > + int i = 0; > > rpm_atomic_seq = assert_rpm_atomic_begin(dev_priv); > > - for_each_sg_page(st->sgl, &sg_iter, st->nents, 0) { > - addr = sg_dma_address(sg_iter.sg) + > - (sg_iter.sg_pgoffset << PAGE_SHIFT); > - gen8_set_pte(>t_entries[i], > - gen8_pte_encode(addr, level, true)); > - i++; > + gtt_entries = (gen8_pte_t __iomem *)ggtt->gsm + (start >> PAGE_SHIFT); > + > + for_each_sgt_dma(addr, sgt_iter, st) { > + gtt_entry = gen8_pte_encode(addr, level, true); > + gen8_set_pte(>t_entries[i++], gtt_entry); > } > > /* > @@ -2388,8 +2386,7 @@ static void gen8_ggtt_insert_entries(struct i915_address_space *vm, > * hardware should work, we must keep this posting read for paranoia. > */ > if (i != 0) > - WARN_ON(readq(>t_entries[i-1]) > - != gen8_pte_encode(addr, level, true)); > + WARN_ON(readq(>t_entries[i-1]) != gtt_entry); > > /* This next bit makes the above posting read even more important. We > * want to flush the TLBs only after we're certain all the PTE updates > @@ -2440,20 +2437,20 @@ static void gen6_ggtt_insert_entries(struct i915_address_space *vm, > { > struct drm_i915_private *dev_priv = to_i915(vm->dev); > struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm); > - unsigned first_entry = start >> PAGE_SHIFT; > - gen6_pte_t __iomem *gtt_entries = > - (gen6_pte_t __iomem *)ggtt->gsm + first_entry; > - int i = 0; > - struct sg_page_iter sg_iter; > - dma_addr_t addr = 0; > + struct sgt_iter sgt_iter; > + gen6_pte_t __iomem *gtt_entries; > + gen6_pte_t gtt_entry; > + dma_addr_t addr; > int rpm_atomic_seq; > + int i = 0; > > rpm_atomic_seq = assert_rpm_atomic_begin(dev_priv); > > - for_each_sg_page(st->sgl, &sg_iter, st->nents, 0) { > - addr = sg_page_iter_dma_address(&sg_iter); > - iowrite32(vm->pte_encode(addr, level, true, flags), >t_entries[i]); > - i++; > + gtt_entries = (gen6_pte_t __iomem *)ggtt->gsm + (start >> PAGE_SHIFT); > + > + for_each_sgt_dma(addr, sgt_iter, st) { > + gtt_entry = vm->pte_encode(addr, level, true, flags); > + iowrite32(gtt_entry, >t_entries[i++]); > } > > /* XXX: This serves as a posting read to make sure that the PTE has > @@ -2462,10 +2459,8 @@ static void gen6_ggtt_insert_entries(struct i915_address_space *vm, > * of NUMA access patterns. Therefore, even with the way we assume > * hardware should work, we must keep this posting read for paranoia. > */ > - if (i != 0) { > - unsigned long gtt = readl(>t_entries[i-1]); > - WARN_ON(gtt != vm->pte_encode(addr, level, true, flags)); > - } > + if (i != 0) > + WARN_ON(readl(>t_entries[i-1]) != gtt_entry); > > /* This next bit makes the above posting read even more important. We > * want to flush the TLBs only after we're certain all the PTE updates > @@ -3399,9 +3394,11 @@ struct i915_vma * > intel_rotate_fb_obj_pages(struct intel_rotation_info *rot_info, > struct drm_i915_gem_object *obj) > { > + const size_t n_pages = obj->base.size / PAGE_SIZE; > unsigned int size_pages = rot_info->plane[0].width * rot_info->plane[0].height; > unsigned int size_pages_uv; > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + dma_addr_t dma_addr; > unsigned long i; > dma_addr_t *page_addr_list; > struct sg_table *st; > @@ -3410,7 +3407,7 @@ struct i915_vma * > int ret = -ENOMEM; > > /* Allocate a temporary list of source pages for random access. */ > - page_addr_list = drm_malloc_gfp(obj->base.size / PAGE_SIZE, > + page_addr_list = drm_malloc_gfp(n_pages, > sizeof(dma_addr_t), > GFP_TEMPORARY); > if (!page_addr_list) > @@ -3433,11 +3430,10 @@ struct i915_vma * > > /* Populate source page list from the object. */ > i = 0; > - for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0) { > - page_addr_list[i] = sg_page_iter_dma_address(&sg_iter); > - i++; > - } > + for_each_sgt_dma(dma_addr, sgt_iter, obj->pages) > + page_addr_list[i++] = dma_addr; > > + GEM_BUG_ON(i != n_pages); > st->nents = 0; > sg = st->sgl; > > diff --git a/drivers/gpu/drm/i915/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c > index 32d9726..d2c1595 100644 > --- a/drivers/gpu/drm/i915/i915_gem_userptr.c > +++ b/drivers/gpu/drm/i915/i915_gem_userptr.c > @@ -706,7 +706,8 @@ struct get_pages_work { > static void > i915_gem_userptr_put_pages(struct drm_i915_gem_object *obj) > { > - struct sg_page_iter sg_iter; > + struct sgt_iter sgt_iter; > + struct page *page; > > BUG_ON(obj->userptr.work != NULL); > __i915_gem_userptr_set_active(obj, false); > @@ -716,9 +717,7 @@ struct get_pages_work { > > i915_gem_gtt_finish_object(obj); > > - for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0) { > - struct page *page = sg_page_iter_page(&sg_iter); > - > + for_each_sgt_page(page, sgt_iter, obj->pages) { > if (obj->dirty) > set_page_dirty(page); > > Couldn't spot any problems in this block. Regards, Tvrtko