From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 Date: Wed, 17 Apr 2019 16:08:04 +0200 Message-ID: <20190417140804.GD13337@phenom.ffwll.local> References: <20190416183841.1577-1-christian.koenig@amd.com> <20190416183841.1577-4-christian.koenig@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190416183841.1577-4-christian.koenig-5C7GfCeVMHo@public.gmane.org> List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Christian =?iso-8859-1?Q?K=F6nig?= Cc: linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linaro-mm-sig-cunTk1MwBs8s++Sfvej+rw@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, sumit.semwal-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org, linux-media-u79uwXL29TY76Z2rM5mHXA@public.gmane.org T24gVHVlLCBBcHIgMTYsIDIwMTkgYXQgMDg6Mzg6MzJQTSArMDIwMCwgQ2hyaXN0aWFuIEvDtm5p ZyB3cm90ZToKPiBNYWtlIGl0IG1hbmRhdG9yeSBmb3IgZHluYW1pYyBkbWEtYnVmIGNhbGxiYWNr cyB0byBiZSBjYWxsZWQgd2l0aCB0aGUKPiByZXNlcnZhdGlvbiBsb2NrIGhlbGQuCj4gCj4gRm9y IHN0YXRpYyBkbWEtYnVmIGV4cG9ydGVycyB3ZSBzdGlsbCBoYXZlIHRoZSBmYWxsYmFjayBvZiB1 c2luZyBjYWNoZWQgc2d0Lgo+IAo+IHYyOiByZW9yZGVyZWQKPiB2MzogcmViYXNlZCBvbiBzZ3Qg Y2FjaGluZwo+IHY0OiB1c2UgdGhlIGNhY2hlZCBzZ3Qgd2hlbiBwb3NzaWJsZQo+IAo+IFNpZ25l ZC1vZmYtYnk6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KCkkg dGhpbmsgdGhlcmUncyBhIGJpdCBhIHJlYmFzZSBjaGFvcyBnb2luZyBvbjoKLSBzb21lIGNvbW1l bnRzIGxlZnQgYmVoaW5kIHdpdGggbm9fc2d0X2NhY2hlLCB3aGljaCBJIGNhbid0IGZpbmQgYW55 bW9yZQotIHRoZSBmdW5jdGlvbiBzaWduYXR1cmUgcmV3b3JrIG9mIGRtYV9idWZfYXR0YWNoIHNo b3VsZCBpbW8gYmUgc3BsaXQgb3V0CgpOZXh0IGlzc3VlIGlzIHRoYXQgdGhlIHJlc2VydmF0aW9u IG9iamVjdCBsb2NraW5nIGlzIHN0aWxsIGluIHRoZSBwYXRoIG9mCmRtYV9idWZfbWFwLCBzbyBw cm9iYWJseSBzdGlsbCBnb2luZyB0byByZXN1bHQgaW4gdG9ucyBvZiBsb2NrZGVwIHNwbGF0cy4K RXhjZXB0IHRoZSBpOTE1K2FtZGdwdSBwYXRoIHNob3VsZCBub3cgd29yayBkdWUgdG8gdGhlIGZh c3RwYXRoLgoKTm90IHN1cmUgdGhhdCdzIGEgc29sdXRpb24gdGhhdCByZWFsbHkgd29ya3MsIGp1 c3QgaGlkZXMgdGhhdApmdW5kYW1lbnRhbGx5IHdlIHN0aWxsIGhhdmUgdGhhdCBpc3N1ZSBvZiBp bmNvbXBhdGlibGUgbG9ja2luZyBjaGFpbnMKYmV0d2VlbiBkaWZmZXJlbnQgZHJpdmVycy4KLURh bmllbAoKPiAtLS0KPiAgZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYyAgICAgICAgICAgICAgICAg ICAgIHwgMjQgKysrKysrKysrKy0tLS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vYXJtYWRhL2Fy bWFkYV9nZW0uYyAgICAgICAgICAgfCAgNiArKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX3By aW1lLmMgICAgICAgICAgICAgICAgICAgfCAgNiArKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2dlbV9kbWFidWYuYyAgICAgICAgfCAgNiArKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0v dGVncmEvZ2VtLmMgICAgICAgICAgICAgICAgICAgfCAgNiArKysrLQo+ICBkcml2ZXJzL2dwdS9k cm0vdWRsL3VkbF9kbWFidWYuYyAgICAgICAgICAgICAgfCAgNiArKysrLQo+ICAuLi4vY29tbW9u L3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jICAgfCAgNiArKysrLQo+ICAuLi4vbWVk aWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLXNnLmMgfCAgNiArKysrLQo+ICBkcml2 ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRlL3RlZ3JhLXZkZS5jICAgfCAgNiArKysrLQo+ICBp bmNsdWRlL2xpbnV4L2RtYS1idWYuaCAgICAgICAgICAgICAgICAgICAgICAgfCAyMyArKysrKysr KysrKysrKysrLS0KPiAgMTAgZmlsZXMgY2hhbmdlZCwgNzQgaW5zZXJ0aW9ucygrKSwgMjEgZGVs ZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMgYi9k cml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gaW5kZXggZWY0ODBlNWZiMjM5Li44M2M5MmJmZDk2 NGMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwo+ICsrKyBiL2RyaXZl cnMvZG1hLWJ1Zi9kbWEtYnVmLmMKPiBAQCAtNTMyLDggKzUzMiw5IEBAIEVYUE9SVF9TWU1CT0xf R1BMKGRtYV9idWZfcHV0KTsKPiAgLyoqCj4gICAqIGRtYV9idWZfYXR0YWNoIC0gQWRkIHRoZSBk ZXZpY2UgdG8gZG1hX2J1ZidzIGF0dGFjaG1lbnRzIGxpc3Q7IG9wdGlvbmFsbHksCj4gICAqIGNh bGxzIGF0dGFjaCgpIG9mIGRtYV9idWZfb3BzIHRvIGFsbG93IGRldmljZS1zcGVjaWZpYyBhdHRh Y2ggZnVuY3Rpb25hbGl0eQo+IC0gKiBAZG1hYnVmOglbaW5dCWJ1ZmZlciB0byBhdHRhY2ggZGV2 aWNlIHRvLgo+IC0gKiBAZGV2OglbaW5dCWRldmljZSB0byBiZSBhdHRhY2hlZC4KPiArICogQGlu Zm86CVtpbl0JaG9sZHMgYWxsIHRoZSBhdHRhY2ggcmVsYXRlZCBpbmZvcm1hdGlvbiBwcm92aWRl ZAo+ICsgKgkJCWJ5IHRoZSBpbXBvcnRlci4gc2VlICZzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5m bwo+ICsgKgkJCWZvciBmdXJ0aGVyIGRldGFpbHMuCj4gICAqCj4gICAqIFJldHVybnMgc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCBwb2ludGVyIGZvciB0aGlzIGF0dGFjaG1lbnQuIEF0dGFjaG1l bnRzCj4gICAqIG11c3QgYmUgY2xlYW5lZCB1cCBieSBjYWxsaW5nIGRtYV9idWZfZGV0YWNoKCku Cj4gQEAgLTU0NywyMCArNTQ4LDIwIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfcHV0KTsK PiAgICogYWNjZXNzaWJsZSB0byBAZGV2LCBhbmQgY2Fubm90IGJlIG1vdmVkIHRvIGEgbW9yZSBz dWl0YWJsZSBwbGFjZS4gVGhpcyBpcwo+ICAgKiBpbmRpY2F0ZWQgd2l0aCB0aGUgZXJyb3IgY29k ZSAtRUJVU1kuCj4gICAqLwo+IC1zdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0 dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+IC0JCQkJCSAgc3RydWN0IGRldmljZSAqZGV2 KQo+ICtzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0dGFjaChjb25zdCBzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyAqaW5mbykKPiAgewo+ICsJc3RydWN0IGRtYV9idWYgKmRt YWJ1ZiA9IGluZm8tPmRtYWJ1ZjsKPiAgCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFj aDsKPiAgCWludCByZXQ7Cj4gIAo+IC0JaWYgKFdBUk5fT04oIWRtYWJ1ZiB8fCAhZGV2KSkKPiAr CWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWluZm8tPmRldikpCj4gIAkJcmV0dXJuIEVSUl9QVFIo LUVJTlZBTCk7Cj4gIAo+ICAJYXR0YWNoID0ga3phbGxvYyhzaXplb2YoKmF0dGFjaCksIEdGUF9L RVJORUwpOwo+ICAJaWYgKCFhdHRhY2gpCj4gIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cj4g IAo+IC0JYXR0YWNoLT5kZXYgPSBkZXY7Cj4gKwlhdHRhY2gtPmRldiA9IGluZm8tPmRldjsKPiAg CWF0dGFjaC0+ZG1hYnVmID0gZG1hYnVmOwo+ICAKPiAgCW11dGV4X2xvY2soJmRtYWJ1Zi0+bG9j ayk7Cj4gQEAgLTY4OCw5ICs2ODksOSBAQCBzdHJ1Y3Qgc2dfdGFibGUgKmRtYV9idWZfbWFwX2F0 dGFjaG1lbnQoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+ICAJaWYgKGF0dGFj aC0+c2d0KQo+ICAJCXJldHVybiBhdHRhY2gtPnNndDsKPiAgCj4gLQlzZ190YWJsZSA9IGF0dGFj aC0+ZG1hYnVmLT5vcHMtPm1hcF9kbWFfYnVmKGF0dGFjaCwgZGlyZWN0aW9uKTsKPiAtCWlmICgh c2dfdGFibGUpCj4gLQkJc2dfdGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOwo+ICsJcmVzZXJ2YXRp b25fb2JqZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOwo+ICsJc2dfdGFibGUg PSBkbWFfYnVmX21hcF9hdHRhY2htZW50X2xvY2tlZChhdHRhY2gsIGRpcmVjdGlvbik7Cj4gKwly ZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKPiAgCj4gIAly ZXR1cm4gc2dfdGFibGU7Cj4gIH0KPiBAQCAtNzQ0LDggKzc0NSw5IEBAIHZvaWQgZG1hX2J1Zl91 bm1hcF9hdHRhY2htZW50KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKPiAgCWlm IChhdHRhY2gtPnNndCA9PSBzZ190YWJsZSkKPiAgCQlyZXR1cm47Cj4gIAo+IC0JYXR0YWNoLT5k bWFidWYtPm9wcy0+dW5tYXBfZG1hX2J1ZihhdHRhY2gsIHNnX3RhYmxlLAo+IC0JCQkJCQlkaXJl Y3Rpb24pOwo+ICsJcmVzZXJ2YXRpb25fb2JqZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3Ys IE5VTEwpOwo+ICsJZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50X2xvY2tlZChhdHRhY2gsIHNnX3Rh YmxlLCBkaXJlY3Rpb24pOwo+ICsJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhhdHRhY2gtPmRt YWJ1Zi0+cmVzdik7Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl91bm1hcF9hdHRh Y2htZW50KTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRh X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKPiBpbmRleCA2NDJk MGU3MGQwZjguLjE5YzQ3ODIxMDMyZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYXJt YWRhL2FybWFkYV9nZW0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dl bS5jCj4gQEAgLTUwMSw2ICs1MDEsMTAgQEAgYXJtYWRhX2dlbV9wcmltZV9leHBvcnQoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmosCj4gIHN0cnVjdCBk cm1fZ2VtX29iamVjdCAqCj4gIGFybWFkYV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpidWYpCj4gIHsKPiArCXN0cnVjdCBkbWFfYnVmX2F0 dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0gewo+ICsJCS5kZXYgPSBkZXYtPmRldiwKPiArCQkuZG1h YnVmID0gYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwo+ ICAJc3RydWN0IGFybWFkYV9nZW1fb2JqZWN0ICpkb2JqOwo+ICAKPiBAQCAtNTE2LDcgKzUyMCw3 IEBAIGFybWFkYV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVj dCBkbWFfYnVmICpidWYpCj4gIAkJfQo+ICAJfQo+ICAKPiAtCWF0dGFjaCA9IGRtYV9idWZfYXR0 YWNoKGJ1ZiwgZGV2LT5kZXYpOwo+ICsJYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9p bmZvKTsKPiAgCWlmIChJU19FUlIoYXR0YWNoKSkKPiAgCQlyZXR1cm4gRVJSX0NBU1QoYXR0YWNo KTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+IGluZGV4IDIzMWUzZjZkNWY0MS4uMWZhZGY1ZDVlZDMz IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+IEBAIC03MDksNiArNzA5LDEwIEBAIHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqZHJtX2dlbV9wcmltZV9pbXBvcnRfZGV2KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCj4gIAkJCQkJICAgIHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmLAo+ICAJCQkJCSAgICBzdHJ1 Y3QgZGV2aWNlICphdHRhY2hfZGV2KQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5m byBhdHRhY2hfaW5mbyA9IHsKPiArCQkuZGV2ID0gYXR0YWNoX2RldiwKPiArCQkuZG1hYnVmID0g ZG1hX2J1Zgo+ICsJfTsKPiAgCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKPiAg CXN0cnVjdCBzZ190YWJsZSAqc2d0Owo+ICAJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmo7Cj4g QEAgLTcyOSw3ICs3MzMsNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmRybV9nZW1fcHJpbWVf aW1wb3J0X2RldihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJaWYgKCFkZXYtPmRyaXZlci0+ Z2VtX3ByaW1lX2ltcG9ydF9zZ190YWJsZSkKPiAgCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsK PiAgCj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBhdHRhY2hfZGV2KTsKPiAr CWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4gIAlpZiAoSVNfRVJSKGF0 dGFjaCkpCj4gIAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7Cj4gIAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZ2VtX2RtYWJ1Zi5jCj4gaW5kZXggODJlMmNhMTdhNDQxLi5hYTdmNjg1YmQ2Y2Eg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZG1hYnVmLmMKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYwo+IEBAIC0yNzcsNiAr Mjc3LDEwIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaTkx NV9nZW1fb2JqZWN0X2RtYWJ1Zl9vcHMgPSB7Cj4gIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqaTkx NV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCQkJICAgICBz dHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKPiAgewo+ICsJc3RydWN0IGRtYV9idWZfYXR0YWNoX2lu Zm8gYXR0YWNoX2luZm8gPSB7Cj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+ICsJCS5kbWFidWYgPSBk bWFfYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwo+ICAJ c3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKPiAgCWludCByZXQ7Cj4gQEAgLTI5NSw3 ICsyOTksNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmk5MTVfZ2VtX3ByaW1lX2ltcG9ydChz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJfQo+ICAKPiAgCS8qIG5lZWQgdG8gYXR0YWNoICov Cj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBkZXYtPmRldik7Cj4gKwlhdHRh Y2ggPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwo+ICAJaWYgKElTX0VSUihhdHRhY2gp KQo+ICAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gpOwo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3RlZ3JhL2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCj4gaW5k ZXggNGY4MDEwMGZmNWYzLi44ZTZiNmM4NzlhZGQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL3RlZ3JhL2dlbS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCj4gQEAg LTMzMiw2ICszMzIsMTAgQEAgc3RydWN0IHRlZ3JhX2JvICp0ZWdyYV9ib19jcmVhdGVfd2l0aF9o YW5kbGUoc3RydWN0IGRybV9maWxlICpmaWxlLAo+ICBzdGF0aWMgc3RydWN0IHRlZ3JhX2JvICp0 ZWdyYV9ib19pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwKPiAgCQkJCQlzdHJ1Y3QgZG1h X2J1ZiAqYnVmKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5m byA9IHsKPiArCQkuZGV2ID0gZHJtLT5kZXYsCj4gKwkJLmRtYWJ1ZiA9IGJ1Zgo+ICsJfTsKPiAg CXN0cnVjdCB0ZWdyYV9kcm0gKnRlZ3JhID0gZHJtLT5kZXZfcHJpdmF0ZTsKPiAgCXN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKPiAgCXN0cnVjdCB0ZWdyYV9ibyAqYm87Cj4gQEAg LTM0MSw3ICszNDUsNyBAQCBzdGF0aWMgc3RydWN0IHRlZ3JhX2JvICp0ZWdyYV9ib19pbXBvcnQo c3RydWN0IGRybV9kZXZpY2UgKmRybSwKPiAgCWlmIChJU19FUlIoYm8pKQo+ICAJCXJldHVybiBi bzsKPiAgCj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChidWYsIGRybS0+ZGV2KTsKPiArCWF0 dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4gIAlpZiAoSVNfRVJSKGF0dGFj aCkpIHsKPiAgCQllcnIgPSBQVFJfRVJSKGF0dGFjaCk7Cj4gIAkJZ290byBmcmVlOwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYyBiL2RyaXZlcnMvZ3B1L2Ry bS91ZGwvdWRsX2RtYWJ1Zi5jCj4gaW5kZXggNTU2ZjYyNjYyYWE5Li44NmI5MjhmOTc0MmYgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZG1hYnVmLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYwo+IEBAIC0yMjYsNiArMjI2LDEwIEBAIHN0YXRp YyBpbnQgdWRsX3ByaW1lX2NyZWF0ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICBzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKnVkbF9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCj4gIAkJCQlzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKPiAgewo+ICsJc3RydWN0IGRtYV9i dWZfYXR0YWNoX2luZm8gYXR0YWNoX2luZm8gPSB7Cj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+ICsJ CS5kbWFidWYgPSBkbWFfYnVmCj4gKwl9Owo+ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAq YXR0YWNoOwo+ICAJc3RydWN0IHNnX3RhYmxlICpzZzsKPiAgCXN0cnVjdCB1ZGxfZ2VtX29iamVj dCAqdW9iajsKPiBAQCAtMjMzLDcgKzIzNyw3IEBAIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdWRs X2dlbV9wcmltZV9pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiAgCj4gIAkvKiBuZWVk IHRvIGF0dGFjaCAqLwo+ICAJZ2V0X2RldmljZShkZXYtPmRldik7Cj4gLQlhdHRhY2ggPSBkbWFf YnVmX2F0dGFjaChkbWFfYnVmLCBkZXYtPmRldik7Cj4gKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFj aCgmYXR0YWNoX2luZm8pOwo+ICAJaWYgKElTX0VSUihhdHRhY2gpKSB7Cj4gIAkJcHV0X2Rldmlj ZShkZXYtPmRldik7Cj4gIAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jIGIv ZHJpdmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMKPiBp bmRleCBhZmYwYWI3YmY4M2QuLjFmMjY4N2I1ZWIwZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21l ZGlhL2NvbW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1jb250aWcuYwo+ICsrKyBiL2RyaXZl cnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jCj4gQEAgLTY3 Niw2ICs2NzYsMTAgQEAgc3RhdGljIHZvaWQgdmIyX2RjX2RldGFjaF9kbWFidWYodm9pZCAqbWVt X3ByaXYpCj4gIHN0YXRpYyB2b2lkICp2YjJfZGNfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNl ICpkZXYsIHN0cnVjdCBkbWFfYnVmICpkYnVmLAo+ICAJdW5zaWduZWQgbG9uZyBzaXplLCBlbnVt IGRtYV9kYXRhX2RpcmVjdGlvbiBkbWFfZGlyKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPiArCQkuZGV2ID0gZGV2LAo+ICsJCS5kbWFidWYgPSBk YnVmCj4gKwl9Owo+ICAJc3RydWN0IHZiMl9kY19idWYgKmJ1ZjsKPiAgCXN0cnVjdCBkbWFfYnVm X2F0dGFjaG1lbnQgKmRiYTsKPiAgCj4gQEAgLTY5MSw3ICs2OTUsNyBAQCBzdGF0aWMgdm9pZCAq dmIyX2RjX2F0dGFjaF9kbWFidWYoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZG1hX2J1ZiAq ZGJ1ZiwKPiAgCj4gIAlidWYtPmRldiA9IGRldjsKPiAgCS8qIGNyZWF0ZSBhdHRhY2htZW50IGZv ciB0aGUgZG1hYnVmIHdpdGggdGhlIHVzZXIgZGV2aWNlICovCj4gLQlkYmEgPSBkbWFfYnVmX2F0 dGFjaChkYnVmLCBidWYtPmRldik7Cj4gKwlkYmEgPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2lu Zm8pOwo+ICAJaWYgKElTX0VSUihkYmEpKSB7Cj4gIAkJcHJfZXJyKCJmYWlsZWQgdG8gYXR0YWNo IGRtYWJ1ZlxuIik7Cj4gIAkJa2ZyZWUoYnVmKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYyBiL2RyaXZlcnMvbWVkaWEvY29t bW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLXNnLmMKPiBpbmRleCAwMTVlNzM3MDk1Y2QuLmNi ZDYyNmQyMzkzYSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL2NvbW1vbi92aWRlb2J1ZjIv dmlkZW9idWYyLWRtYS1zZy5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYy L3ZpZGVvYnVmMi1kbWEtc2cuYwo+IEBAIC02MDgsNiArNjA4LDEwIEBAIHN0YXRpYyB2b2lkIHZi Ml9kbWFfc2dfZGV0YWNoX2RtYWJ1Zih2b2lkICptZW1fcHJpdikKPiAgc3RhdGljIHZvaWQgKnZi Ml9kbWFfc2dfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVm ICpkYnVmLAo+ICAJdW5zaWduZWQgbG9uZyBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk bWFfZGlyKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9 IHsKPiArCQkuZGV2ID0gZGV2LAo+ICsJCS5kbWFidWYgPSBkYnVmCj4gKwl9Owo+ICAJc3RydWN0 IHZiMl9kbWFfc2dfYnVmICpidWY7Cj4gIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkYmE7 Cj4gIAo+IEBAIC02MjMsNyArNjI3LDcgQEAgc3RhdGljIHZvaWQgKnZiMl9kbWFfc2dfYXR0YWNo X2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpkYnVmLAo+ICAKPiAg CWJ1Zi0+ZGV2ID0gZGV2Owo+ICAJLyogY3JlYXRlIGF0dGFjaG1lbnQgZm9yIHRoZSBkbWFidWYg d2l0aCB0aGUgdXNlciBkZXZpY2UgKi8KPiAtCWRiYSA9IGRtYV9idWZfYXR0YWNoKGRidWYsIGJ1 Zi0+ZGV2KTsKPiArCWRiYSA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4gIAlpZiAo SVNfRVJSKGRiYSkpIHsKPiAgCQlwcl9lcnIoImZhaWxlZCB0byBhdHRhY2ggZG1hYnVmXG4iKTsK PiAgCQlrZnJlZShidWYpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGVn cmEtdmRlL3RlZ3JhLXZkZS5jIGIvZHJpdmVycy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdy YS12ZGUuYwo+IGluZGV4IGFhNmM2YmJhOTYxZS4uNWExMGMxZmFjYzI3IDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvc3RhZ2luZy9tZWRpYS90ZWdyYS12ZGUvdGVncmEtdmRlLmMKPiArKysgYi9kcml2 ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRlL3RlZ3JhLXZkZS5jCj4gQEAgLTU2OCw2ICs1Njgs MTAgQEAgc3RhdGljIGludCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpk ZXYsCj4gIAkJCQkgICBzaXplX3QgKnNpemUsCj4gIAkJCQkgICBlbnVtIGRtYV9kYXRhX2RpcmVj dGlvbiBkbWFfZGlyKQo+ICB7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hf aW5mbyA9IHsKPiArCQkuZGV2ID0gZGV2LAo+ICsJCS5kbWFidWYgPSBkbWFidWYKPiArCX07Cj4g IAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50Owo+ICAJc3RydWN0IGRtYV9i dWYgKmRtYWJ1ZjsKPiAgCXN0cnVjdCBzZ190YWJsZSAqc2d0Owo+IEBAIC01OTEsNyArNTk1LDcg QEAgc3RhdGljIGludCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYs Cj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+IC0JYXR0YWNobWVudCA9IGRtYV9idWZf YXR0YWNoKGRtYWJ1ZiwgZGV2KTsKPiArCWF0dGFjaG1lbnQgPSBkbWFfYnVmX2F0dGFjaCgmYXR0 YWNoX2luZm8pOwo+ICAJaWYgKElTX0VSUihhdHRhY2htZW50KSkgewo+ICAJCWRldl9lcnIoZGV2 LCAiRmFpbGVkIHRvIGF0dGFjaCBkbWFidWZcbiIpOwo+ICAJCWVyciA9IFBUUl9FUlIoYXR0YWNo bWVudCk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9s aW51eC9kbWEtYnVmLmgKPiBpbmRleCAxOGE3OGJlNTM1NDEuLjdlMjM3NThkYjNhNCAxMDA2NDQK PiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvZG1h LWJ1Zi5oCj4gQEAgLTEyOCw2ICsxMjgsOSBAQCBzdHJ1Y3QgZG1hX2J1Zl9vcHMgewo+ICAJICog YW55IG90aGVyIGtpbmQgb2Ygc2hhcmluZyB0aGF0IHRoZSBleHBvcnRlciBtaWdodCB3aXNoIHRv IG1ha2UKPiAgCSAqIGF2YWlsYWJsZSB0byBidWZmZXItdXNlcnMuCj4gIAkgKgo+ICsJICogVGhp cyBpcyBhbHdheXMgY2FsbGVkIHdpdGggdGhlIGRtYWJ1Zi0+cmVzdiBvYmplY3QgbG9ja2VkIHdo ZW4KPiArCSAqIG5vX3NndF9jYWNoZSBpcyB0cnVlLgo+ICsJICoKPiAgCSAqIFJldHVybnM6Cj4g IAkgKgo+ICAJICogQSAmc2dfdGFibGUgc2NhdHRlciBsaXN0IG9mIG9yIHRoZSBiYWNraW5nIHN0 b3JhZ2Ugb2YgdGhlIERNQSBidWZmZXIsCj4gQEAgLTE0OCw2ICsxNTEsOSBAQCBzdHJ1Y3QgZG1h X2J1Zl9vcHMgewo+ICAJICogSXQgc2hvdWxkIGFsc28gdW5waW4gdGhlIGJhY2tpbmcgc3RvcmFn ZSBpZiB0aGlzIGlzIHRoZSBsYXN0IG1hcHBpbmcKPiAgCSAqIG9mIHRoZSBETUEgYnVmZmVyLCBp dCB0aGUgZXhwb3J0ZXIgc3VwcG9ydHMgYmFja2luZyBzdG9yYWdlCj4gIAkgKiBtaWdyYXRpb24u Cj4gKwkgKgo+ICsJICogVGhpcyBpcyBhbHdheXMgY2FsbGVkIHdpdGggdGhlIGRtYWJ1Zi0+cmVz diBvYmplY3QgbG9ja2VkIHdoZW4KPiArCSAqIG5vX3NndF9jYWNoZSBpcyB0cnVlLgo+ICAJICov Cj4gIAl2b2lkICgqdW5tYXBfZG1hX2J1Zikoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqLAo+ ICAJCQkgICAgICBzdHJ1Y3Qgc2dfdGFibGUgKiwKPiBAQCAtMzcwLDYgKzM3NiwxOSBAQCBzdHJ1 Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyB7Cj4gIAlzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyBu YW1lID0geyAuZXhwX25hbWUgPSBLQlVJTERfTU9ETkFNRSwgXAo+ICAJCQkJCSAub3duZXIgPSBU SElTX01PRFVMRSB9Cj4gIAo+ICsvKioKPiArICogc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8g LSBob2xkcyBpbmZvcm1hdGlvbiBuZWVkZWQgdG8gYXR0YWNoIHRvIGEgZG1hX2J1Zgo+ICsgKiBA ZG1hYnVmOgl0aGUgZXhwb3J0ZWQgZG1hX2J1Zgo+ICsgKiBAZGV2Ogl0aGUgZGV2aWNlIHdoaWNo IHdhbnRzIHRvIGltcG9ydCB0aGUgYXR0YWNobWVudAo+ICsgKgo+ICsgKiBUaGlzIHN0cnVjdHVy ZSBob2xkcyB0aGUgaW5mb3JtYXRpb24gcmVxdWlyZWQgdG8gYXR0YWNoIHRvIGEgYnVmZmVyLiBV c2VkCj4gKyAqIHdpdGggZG1hX2J1Zl9hdHRhY2goKSBvbmx5Lgo+ICsgKi8KPiArc3RydWN0IGRt YV9idWZfYXR0YWNoX2luZm8gewo+ICsJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZjsKPiArCXN0cnVj dCBkZXZpY2UgKmRldjsKPiArfTsKPiArCj4gIC8qKgo+ICAgKiBnZXRfZG1hX2J1ZiAtIGNvbnZl bmllbmNlIHdyYXBwZXIgZm9yIGdldF9maWxlLgo+ICAgKiBAZG1hYnVmOglbaW5dCXBvaW50ZXIg dG8gZG1hX2J1Zgo+IEBAIC0zODQsOCArNDAzLDggQEAgc3RhdGljIGlubGluZSB2b2lkIGdldF9k bWFfYnVmKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCj4gIAlnZXRfZmlsZShkbWFidWYtPmZpbGUp Owo+ICB9Cj4gIAo+IC1zdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0dGFjaChz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+IC0JCQkJCQkJc3RydWN0IGRldmljZSAqZGV2KTsKPiAr c3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqCj4gK2RtYV9idWZfYXR0YWNoKGNvbnN0IHN0cnVj dCBkbWFfYnVmX2F0dGFjaF9pbmZvICppbmZvKTsKPiAgdm9pZCBkbWFfYnVmX2RldGFjaChzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICAJCQkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1h YnVmX2F0dGFjaCk7Cj4gIAo+IC0tIAo+IDIuMTcuMQo+IAo+IF9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+IGRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAoKLS0gCkRhbmllbCBWZXR0ZXIKU29mdHdh cmUgRW5naW5lZXIsIEludGVsIENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xsLmNoCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmFtZC1nZnggbWFpbGlu ZyBsaXN0CmFtZC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRl c2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vYW1kLWdmeA== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AEE25C282DA for ; Wed, 17 Apr 2019 14:08:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 60AC021773 for ; Wed, 17 Apr 2019 14:08:15 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="HY6D0TWo" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731960AbfDQOIO (ORCPT ); Wed, 17 Apr 2019 10:08:14 -0400 Received: from mail-ed1-f66.google.com ([209.85.208.66]:33085 "EHLO mail-ed1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730449AbfDQOIK (ORCPT ); Wed, 17 Apr 2019 10:08:10 -0400 Received: by mail-ed1-f66.google.com with SMTP id d55so20317292ede.0 for ; Wed, 17 Apr 2019 07:08:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=sender:date:from:to:cc:subject:message-id:mail-followup-to :references:mime-version:content-disposition :content-transfer-encoding:in-reply-to:user-agent; bh=qALB6qDF5/jkdQMyHB+ezoiwJpE1Uxo49WvJqeWCTeM=; b=HY6D0TWoOBSWrmN952pYb3VDOxBMK6gWoHvA+LWOyv0QRfN7AFIREl6nOBG2GTqKtA AaS1ykK9L6hAqpNktrST49eS8ikp9jAp+RuKCVmjx6oivtOdLmdtOMbi45ENowLyCMMr 61ref21sneXt6gYgq7H9L+VHJboCRpzBL6Foc= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:cc:subject:message-id :mail-followup-to:references:mime-version:content-disposition :content-transfer-encoding:in-reply-to:user-agent; bh=qALB6qDF5/jkdQMyHB+ezoiwJpE1Uxo49WvJqeWCTeM=; b=DLG3Rh2njrwEkY3rGyF4DXPhc7HqKHZbyRJUhjRmHAgGWldSzhZD8mxUjdKCHHJSzo x+acXmr9doJws5crRyv+Q4CPy1dDQ1QWEKC3kL4yeeMydHVXbXn2wZ5A3ES9YFwpwRnf qyiAaD4tJDQcHkLPrMXZK3BgFYnzUwP6t2ubKcfXJ6Xw04EqThX7+uH1gHWixukLuJ1Z 5dEH7OHY5a1zT1czznfGQEFntzRDBHw8jbr6OmIYwfkvcrojzCQM6XjrkRBRF8ubaodt rxDYa2bNv6uil89CD3SwHEoS3vnf98Q5JFOs6cKhOsy/e/pDfXA9lxyb1eZkqxQxAHPm 0E9w== X-Gm-Message-State: APjAAAV/KF6or0XkRWgBJDSp0+a/PZ/MAeeERlmMLYkQjkdc3f7OGU2Y kB9Am7khPmhk+BkCq1k88NtHQQ== X-Google-Smtp-Source: APXvYqy82ZapXuGiMlnUcwyznZ8UKxh2woiZc+zs6JkmMh2vPlbaP75ylNT9Z2d2mruGHv3wBdfjrg== X-Received: by 2002:a50:9707:: with SMTP id c7mr24882554edb.222.1555510087640; Wed, 17 Apr 2019 07:08:07 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id h57sm3823269eda.90.2019.04.17.07.08.06 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 17 Apr 2019 07:08:06 -0700 (PDT) Date: Wed, 17 Apr 2019 16:08:04 +0200 From: Daniel Vetter To: Christian =?iso-8859-1?Q?K=F6nig?= Cc: sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org Subject: Re: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 Message-ID: <20190417140804.GD13337@phenom.ffwll.local> Mail-Followup-To: Christian =?iso-8859-1?Q?K=F6nig?= , sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org References: <20190416183841.1577-1-christian.koenig@amd.com> <20190416183841.1577-4-christian.koenig@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20190416183841.1577-4-christian.koenig@amd.com> X-Operating-System: Linux phenom 4.19.0-1-amd64 User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org On Tue, Apr 16, 2019 at 08:38:32PM +0200, Christian König wrote: > Make it mandatory for dynamic dma-buf callbacks to be called with the > reservation lock held. > > For static dma-buf exporters we still have the fallback of using cached sgt. > > v2: reordered > v3: rebased on sgt caching > v4: use the cached sgt when possible > > Signed-off-by: Christian König I think there's a bit a rebase chaos going on: - some comments left behind with no_sgt_cache, which I can't find anymore - the function signature rework of dma_buf_attach should imo be split out Next issue is that the reservation object locking is still in the path of dma_buf_map, so probably still going to result in tons of lockdep splats. Except the i915+amdgpu path should now work due to the fastpath. Not sure that's a solution that really works, just hides that fundamentally we still have that issue of incompatible locking chains between different drivers. -Daniel > --- > drivers/dma-buf/dma-buf.c | 24 ++++++++++--------- > drivers/gpu/drm/armada/armada_gem.c | 6 ++++- > drivers/gpu/drm/drm_prime.c | 6 ++++- > drivers/gpu/drm/i915/i915_gem_dmabuf.c | 6 ++++- > drivers/gpu/drm/tegra/gem.c | 6 ++++- > drivers/gpu/drm/udl/udl_dmabuf.c | 6 ++++- > .../common/videobuf2/videobuf2-dma-contig.c | 6 ++++- > .../media/common/videobuf2/videobuf2-dma-sg.c | 6 ++++- > drivers/staging/media/tegra-vde/tegra-vde.c | 6 ++++- > include/linux/dma-buf.h | 23 ++++++++++++++++-- > 10 files changed, 74 insertions(+), 21 deletions(-) > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index ef480e5fb239..83c92bfd964c 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -532,8 +532,9 @@ EXPORT_SYMBOL_GPL(dma_buf_put); > /** > * dma_buf_attach - Add the device to dma_buf's attachments list; optionally, > * calls attach() of dma_buf_ops to allow device-specific attach functionality > - * @dmabuf: [in] buffer to attach device to. > - * @dev: [in] device to be attached. > + * @info: [in] holds all the attach related information provided > + * by the importer. see &struct dma_buf_attach_info > + * for further details. > * > * Returns struct dma_buf_attachment pointer for this attachment. Attachments > * must be cleaned up by calling dma_buf_detach(). > @@ -547,20 +548,20 @@ EXPORT_SYMBOL_GPL(dma_buf_put); > * accessible to @dev, and cannot be moved to a more suitable place. This is > * indicated with the error code -EBUSY. > */ > -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > - struct device *dev) > +struct dma_buf_attachment *dma_buf_attach(const struct dma_buf_attach_info *info) > { > + struct dma_buf *dmabuf = info->dmabuf; > struct dma_buf_attachment *attach; > int ret; > > - if (WARN_ON(!dmabuf || !dev)) > + if (WARN_ON(!dmabuf || !info->dev)) > return ERR_PTR(-EINVAL); > > attach = kzalloc(sizeof(*attach), GFP_KERNEL); > if (!attach) > return ERR_PTR(-ENOMEM); > > - attach->dev = dev; > + attach->dev = info->dev; > attach->dmabuf = dmabuf; > > mutex_lock(&dmabuf->lock); > @@ -688,9 +689,9 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, > if (attach->sgt) > return attach->sgt; > > - sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); > - if (!sg_table) > - sg_table = ERR_PTR(-ENOMEM); > + reservation_object_lock(attach->dmabuf->resv, NULL); > + sg_table = dma_buf_map_attachment_locked(attach, direction); > + reservation_object_unlock(attach->dmabuf->resv); > > return sg_table; > } > @@ -744,8 +745,9 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, > if (attach->sgt == sg_table) > return; > > - attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, > - direction); > + reservation_object_lock(attach->dmabuf->resv, NULL); > + dma_buf_unmap_attachment_locked(attach, sg_table, direction); > + reservation_object_unlock(attach->dmabuf->resv); > } > EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); > > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index 642d0e70d0f8..19c47821032f 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -501,6 +501,10 @@ armada_gem_prime_export(struct drm_device *dev, struct drm_gem_object *obj, > struct drm_gem_object * > armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = buf > + }; > struct dma_buf_attachment *attach; > struct armada_gem_object *dobj; > > @@ -516,7 +520,7 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) > } > } > > - attach = dma_buf_attach(buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c > index 231e3f6d5f41..1fadf5d5ed33 100644 > --- a/drivers/gpu/drm/drm_prime.c > +++ b/drivers/gpu/drm/drm_prime.c > @@ -709,6 +709,10 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > struct dma_buf *dma_buf, > struct device *attach_dev) > { > + struct dma_buf_attach_info attach_info = { > + .dev = attach_dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct sg_table *sgt; > struct drm_gem_object *obj; > @@ -729,7 +733,7 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > if (!dev->driver->gem_prime_import_sg_table) > return ERR_PTR(-EINVAL); > > - attach = dma_buf_attach(dma_buf, attach_dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > index 82e2ca17a441..aa7f685bd6ca 100644 > --- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > @@ -277,6 +277,10 @@ static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = { > struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, > struct dma_buf *dma_buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct drm_i915_gem_object *obj; > int ret; > @@ -295,7 +299,7 @@ struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, > } > > /* need to attach */ > - attach = dma_buf_attach(dma_buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) > return ERR_CAST(attach); > > diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c > index 4f80100ff5f3..8e6b6c879add 100644 > --- a/drivers/gpu/drm/tegra/gem.c > +++ b/drivers/gpu/drm/tegra/gem.c > @@ -332,6 +332,10 @@ struct tegra_bo *tegra_bo_create_with_handle(struct drm_file *file, > static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > struct dma_buf *buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = drm->dev, > + .dmabuf = buf > + }; > struct tegra_drm *tegra = drm->dev_private; > struct dma_buf_attachment *attach; > struct tegra_bo *bo; > @@ -341,7 +345,7 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > if (IS_ERR(bo)) > return bo; > > - attach = dma_buf_attach(buf, drm->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) { > err = PTR_ERR(attach); > goto free; > diff --git a/drivers/gpu/drm/udl/udl_dmabuf.c b/drivers/gpu/drm/udl/udl_dmabuf.c > index 556f62662aa9..86b928f9742f 100644 > --- a/drivers/gpu/drm/udl/udl_dmabuf.c > +++ b/drivers/gpu/drm/udl/udl_dmabuf.c > @@ -226,6 +226,10 @@ static int udl_prime_create(struct drm_device *dev, > struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, > struct dma_buf *dma_buf) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev->dev, > + .dmabuf = dma_buf > + }; > struct dma_buf_attachment *attach; > struct sg_table *sg; > struct udl_gem_object *uobj; > @@ -233,7 +237,7 @@ struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, > > /* need to attach */ > get_device(dev->dev); > - attach = dma_buf_attach(dma_buf, dev->dev); > + attach = dma_buf_attach(&attach_info); > if (IS_ERR(attach)) { > put_device(dev->dev); > return ERR_CAST(attach); > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-contig.c b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > index aff0ab7bf83d..1f2687b5eb0e 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-contig.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > @@ -676,6 +676,10 @@ static void vb2_dc_detach_dmabuf(void *mem_priv) > static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > unsigned long size, enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dbuf > + }; > struct vb2_dc_buf *buf; > struct dma_buf_attachment *dba; > > @@ -691,7 +695,7 @@ static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > > buf->dev = dev; > /* create attachment for the dmabuf with the user device */ > - dba = dma_buf_attach(dbuf, buf->dev); > + dba = dma_buf_attach(&attach_info); > if (IS_ERR(dba)) { > pr_err("failed to attach dmabuf\n"); > kfree(buf); > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-sg.c b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > index 015e737095cd..cbd626d2393a 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-sg.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > @@ -608,6 +608,10 @@ static void vb2_dma_sg_detach_dmabuf(void *mem_priv) > static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > unsigned long size, enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dbuf > + }; > struct vb2_dma_sg_buf *buf; > struct dma_buf_attachment *dba; > > @@ -623,7 +627,7 @@ static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, > > buf->dev = dev; > /* create attachment for the dmabuf with the user device */ > - dba = dma_buf_attach(dbuf, buf->dev); > + dba = dma_buf_attach(&attach_info); > if (IS_ERR(dba)) { > pr_err("failed to attach dmabuf\n"); > kfree(buf); > diff --git a/drivers/staging/media/tegra-vde/tegra-vde.c b/drivers/staging/media/tegra-vde/tegra-vde.c > index aa6c6bba961e..5a10c1facc27 100644 > --- a/drivers/staging/media/tegra-vde/tegra-vde.c > +++ b/drivers/staging/media/tegra-vde/tegra-vde.c > @@ -568,6 +568,10 @@ static int tegra_vde_attach_dmabuf(struct device *dev, > size_t *size, > enum dma_data_direction dma_dir) > { > + struct dma_buf_attach_info attach_info = { > + .dev = dev, > + .dmabuf = dmabuf > + }; > struct dma_buf_attachment *attachment; > struct dma_buf *dmabuf; > struct sg_table *sgt; > @@ -591,7 +595,7 @@ static int tegra_vde_attach_dmabuf(struct device *dev, > return -EINVAL; > } > > - attachment = dma_buf_attach(dmabuf, dev); > + attachment = dma_buf_attach(&attach_info); > if (IS_ERR(attachment)) { > dev_err(dev, "Failed to attach dmabuf\n"); > err = PTR_ERR(attachment); > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index 18a78be53541..7e23758db3a4 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -128,6 +128,9 @@ struct dma_buf_ops { > * any other kind of sharing that the exporter might wish to make > * available to buffer-users. > * > + * This is always called with the dmabuf->resv object locked when > + * no_sgt_cache is true. > + * > * Returns: > * > * A &sg_table scatter list of or the backing storage of the DMA buffer, > @@ -148,6 +151,9 @@ struct dma_buf_ops { > * It should also unpin the backing storage if this is the last mapping > * of the DMA buffer, it the exporter supports backing storage > * migration. > + * > + * This is always called with the dmabuf->resv object locked when > + * no_sgt_cache is true. > */ > void (*unmap_dma_buf)(struct dma_buf_attachment *, > struct sg_table *, > @@ -370,6 +376,19 @@ struct dma_buf_export_info { > struct dma_buf_export_info name = { .exp_name = KBUILD_MODNAME, \ > .owner = THIS_MODULE } > > +/** > + * struct dma_buf_attach_info - holds information needed to attach to a dma_buf > + * @dmabuf: the exported dma_buf > + * @dev: the device which wants to import the attachment > + * > + * This structure holds the information required to attach to a buffer. Used > + * with dma_buf_attach() only. > + */ > +struct dma_buf_attach_info { > + struct dma_buf *dmabuf; > + struct device *dev; > +}; > + > /** > * get_dma_buf - convenience wrapper for get_file. > * @dmabuf: [in] pointer to dma_buf > @@ -384,8 +403,8 @@ static inline void get_dma_buf(struct dma_buf *dmabuf) > get_file(dmabuf->file); > } > > -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > - struct device *dev); > +struct dma_buf_attachment * > +dma_buf_attach(const struct dma_buf_attach_info *info); > void dma_buf_detach(struct dma_buf *dmabuf, > struct dma_buf_attachment *dmabuf_attach); > > -- > 2.17.1 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch