From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?Q?Christian_K=c3=b6nig?= Subject: Re: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 Date: Wed, 17 Apr 2019 19:10:42 +0200 Message-ID: References: <20190416183841.1577-1-christian.koenig@amd.com> <20190416183841.1577-4-christian.koenig@amd.com> <20190417140804.GD13337@phenom.ffwll.local> <20190417142632.GF13337@phenom.ffwll.local> Reply-To: christian.koenig-5C7GfCeVMHo@public.gmane.org Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190417142632.GF13337-dv86pmgwkMBes7Z6vYuT8azUEOm+Xw19@public.gmane.org> Content-Language: en-US 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.koenig-5C7GfCeVMHo@public.gmane.org, sumit.semwal-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org, linux-media-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linaro-mm-sig-cunTk1MwBs8s++Sfvej+rw@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org QW0gMTcuMDQuMTkgdW0gMTY6MjYgc2NocmllYiBEYW5pZWwgVmV0dGVyOgo+IE9uIFdlZCwgQXBy IDE3LCAyMDE5IGF0IDA0OjE0OjMyUE0gKzAyMDAsIENocmlzdGlhbiBLw7ZuaWcgd3JvdGU6Cj4+ IEFtIDE3LjA0LjE5IHVtIDE2OjA4IHNjaHJpZWIgRGFuaWVsIFZldHRlcjoKPj4+IE9uIFR1ZSwg QXByIDE2LCAyMDE5IGF0IDA4OjM4OjMyUE0gKzAyMDAsIENocmlzdGlhbiBLw7ZuaWcgd3JvdGU6 Cj4+Pj4gTWFrZSBpdCBtYW5kYXRvcnkgZm9yIGR5bmFtaWMgZG1hLWJ1ZiBjYWxsYmFja3MgdG8g YmUgY2FsbGVkIHdpdGggdGhlCj4+Pj4gcmVzZXJ2YXRpb24gbG9jayBoZWxkLgo+Pj4+Cj4+Pj4g Rm9yIHN0YXRpYyBkbWEtYnVmIGV4cG9ydGVycyB3ZSBzdGlsbCBoYXZlIHRoZSBmYWxsYmFjayBv ZiB1c2luZyBjYWNoZWQgc2d0Lgo+Pj4+Cj4+Pj4gdjI6IHJlb3JkZXJlZAo+Pj4+IHYzOiByZWJh c2VkIG9uIHNndCBjYWNoaW5nCj4+Pj4gdjQ6IHVzZSB0aGUgY2FjaGVkIHNndCB3aGVuIHBvc3Np YmxlCj4+Pj4KPj4+PiBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4u a29lbmlnQGFtZC5jb20+Cj4+PiBJIHRoaW5rIHRoZXJlJ3MgYSBiaXQgYSByZWJhc2UgY2hhb3Mg Z29pbmcgb246Cj4+PiAtIHNvbWUgY29tbWVudHMgbGVmdCBiZWhpbmQgd2l0aCBub19zZ3RfY2Fj aGUsIHdoaWNoIEkgY2FuJ3QgZmluZCBhbnltb3JlCj4+PiAtIHRoZSBmdW5jdGlvbiBzaWduYXR1 cmUgcmV3b3JrIG9mIGRtYV9idWZfYXR0YWNoIHNob3VsZCBpbW8gYmUgc3BsaXQgb3V0Cj4+IEFo LCBjcmFwIHRob3VnaHQgSSd2ZSBnb3QgYWxsIG9mIHRob3NlLiBHb2luZyB0byBmaXggdGhhdC4K Pj4KPj4+IE5leHQgaXNzdWUgaXMgdGhhdCB0aGUgcmVzZXJ2YXRpb24gb2JqZWN0IGxvY2tpbmcg aXMgc3RpbGwgaW4gdGhlIHBhdGggb2YKPj4+IGRtYV9idWZfbWFwLCBzbyBwcm9iYWJseSBzdGls bCBnb2luZyB0byByZXN1bHQgaW4gdG9ucyBvZiBsb2NrZGVwIHNwbGF0cy4KPj4+IEV4Y2VwdCB0 aGUgaTkxNSthbWRncHUgcGF0aCBzaG91bGQgbm93IHdvcmsgZHVlIHRvIHRoZSBmYXN0cGF0aC4K Pj4gSSBhY3R1YWxseSBmb3VuZCBhIHNvbHV0aW9uIGZvciB0aGF0IDopCj4+Cj4+IFRoZSBpZGVh IGlzIG5vdyB0aGF0IHdlIGFsd2F5cyBjYWNoZSB0aGUgc2d0IGluIHRoZSBhdHRhY2htZW50IHVu bGVzcyB0aGUKPj4gZHluYW1pYyBmbGFnIChwcmV2aW91c2x5IG5vX3NndF9jYWNoZSBmbGFnKSBp cyBzZXQuIEFuZCB0aGlzIGNhY2hlZCBzZ3QgaXMKPj4gY3JlYXRlZCB3aXRob3V0IGhvbGRpbmcg dGhlIGxvY2suCj4gWWVhaCBJIHRoaW5rIHRoYXQgaWRlYSB3b3Jrcy4KPgo+PiBXZSBlaXRoZXIg bmVlZCB0byBkb2N1bWVudCB0aGF0IHJlYWxseSB3ZWxsIG9yIG1heWJlIHNwbGl0IHRoZSBtYXBw aW5nCj4+IGNhbGxiYWNrcyBpbnRvIG1hcC91bm1hcCBhbmQgbWFwX2xvY2svdW5tYXBfbG9ja2Vk LiBPcGluaW9ucz8KPiBJIHRoaW5rIHRoZSBpbXBsZW1lbnRhdGlvbiBkb2Vzbid0LiBFeHBvcnRl ciBjYW4ndCBkZWNpZGUgb24gaXRzIG93bgo+IHdoZXRoZXIgZHluYW1pYy9zdGF0aWMgaXMgd2hh dCdzIG5lZWRlZCwgd2UgbmVlZCB0byBkZWNpZGUgdGhhdCBmb3IgZWFjaAo+IGF0dGFjaG1lbnQs IHRha2luZyBib3RoIGV4cG9ydGVyIGFuZCBpbXBvcnRlciBjYXBhYmlsaXRpZXMgaW50byBhY2Nv dW50LgoKV2VsbCB0aGF0J3Mgd2hhdCB0aGUgcGluL3VucGluIGNhbGxiYWNrcyBhcmUgZ29vZCBm b3IgOikKCkVzc2VudGlhbGx5IHdlIGhhdmUgdG8gaGFuZGxlIHRoZSBmb2xsb3dpbmcgY2FzZXM6 CmEpIGR5bmFtaWMgZXhwb3J0ZXIgYW5kIGR5bmFtaWMgaW1wb3J0ZXIKIMKgwqDCoCDCoMKgwqAg Tm90aGluZyBzcGVjaWFsIGhlcmUgYW5kIHdlIGRvbid0IG5lZWQgdGhlIHNndCBjYWNoaW5nIG5v ciBwaW5uaW5nLgoKYikgZHluYW1pYyBleHBvcnRlciBhbmQgc3RhdGljIGltcG9ydGVyCiDCoMKg wqAgwqDCoMKgIFRoZSBwaW4vdW5waW4gY2FsbGJhY2tzIGFyZSB1c2VkIHRvIGluZm9ybSB0aGUg ZXhwb3J0ZXIgdGhhdCBpdCAKbmVlZHMgdG8ga2VlcCB0aGUgYnVmZmVyIGluIHRoZSBjdXJyZW50 IHBsYWNlLgoKYykgc3RhdGljIGV4cG9ydGVyIGFuZCBkeW5hbWljIGltcG9ydGVyCiDCoMKgwqAg wqDCoMKgIFdlIHVzZSB0aGUgc2d0IGNhY2hpbmcgdG8gYXZvaWQgY2FsbGluZyB0aGUgZXhwb3J0 ZXIgd2l0aCB0aGUgCmNvbW1vbiBsb2NrIGhlbGQuCgpkKSBzdGF0aWMgZXhwb3J0ZXIgYW5kIHN0 YXRpYyBpbXBvcnRlcgogwqDCoMKgIMKgwqDCoCBXZSB1c2UgdGhlIHNndCBjYWNoaW5nLCBidXQg dGhhdCBpcyBhY3R1YWxseSBvbmx5IG9wdGlvbmFsLgoKPiBJIHRoaW5rIGlmIHdlIGRvIHRoYXQs IHRoZW4gaXQgc2hvdWxkIHdvcmsgb3V0LiBJIHJlcGxpZWQgb24gdGhlIHBpbi91bnBpbgo+IGlu dGVyZmFjZSBwYXRjaCB3aXRoIHNvbWUgbW9yZSBjb25jcmV0ZSB0aG91Z2h0cy4gTWF5YmUgYmVz dCB0byBjb250aW51ZQo+IHRoYXQgZGlzY3Vzc2lvbiB0aGVyZSwgd2l0aCBtb3JlIGNvbnRleHQu CgpZZWFoLCB0aGF0IGlzIHByb2JhYmx5IGEgZ29vZCBpZGVhLgoKUmVnYXJkcywKQ2hyaXN0aWFu LgoKCj4gLURhbmllbAo+Cj4+PiBOb3Qgc3VyZSB0aGF0J3MgYSBzb2x1dGlvbiB0aGF0IHJlYWxs eSB3b3JrcywganVzdCBoaWRlcyB0aGF0Cj4+PiBmdW5kYW1lbnRhbGx5IHdlIHN0aWxsIGhhdmUg dGhhdCBpc3N1ZSBvZiBpbmNvbXBhdGlibGUgbG9ja2luZyBjaGFpbnMKPj4+IGJldHdlZW4gZGlm ZmVyZW50IGRyaXZlcnMuCj4+IFdlIGNhbiBub3cgbWFrZSBhIHNsb3cgdHJhbnNpdGlvbiBiZXR3 ZWVuIHN0YXRpYyBhbmQgZHluYW1pYyBETUEtYnVmCj4+IGhhbmRsaW5nLCBzbyBvbmx5IGRyaXZl ciB3aG8gY2FuIGRvIHRoZSBsb2NraW5nIHdpbGwgYmUgYWZmZWN0ZWQuCj4+Cj4+IENocmlzdGlh bi4KPj4KPj4+IC1EYW5pZWwKPj4+Cj4+Pj4gLS0tCj4+Pj4gICAgZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYuYyAgICAgICAgICAgICAgICAgICAgIHwgMjQgKysrKysrKysrKy0tLS0tLS0tLQo+Pj4+ ICAgIGRyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5jICAgICAgICAgICB8ICA2ICsr KystCj4+Pj4gICAgZHJpdmVycy9ncHUvZHJtL2RybV9wcmltZS5jICAgICAgICAgICAgICAgICAg IHwgIDYgKysrKy0KPj4+PiAgICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYu YyAgICAgICAgfCAgNiArKysrLQo+Pj4+ICAgIGRyaXZlcnMvZ3B1L2RybS90ZWdyYS9nZW0uYyAg ICAgICAgICAgICAgICAgICB8ICA2ICsrKystCj4+Pj4gICAgZHJpdmVycy9ncHUvZHJtL3VkbC91 ZGxfZG1hYnVmLmMgICAgICAgICAgICAgIHwgIDYgKysrKy0KPj4+PiAgICAuLi4vY29tbW9uL3Zp ZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jICAgfCAgNiArKysrLQo+Pj4+ICAgIC4uLi9t ZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYyB8ICA2ICsrKystCj4+Pj4g ICAgZHJpdmVycy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdyYS12ZGUuYyAgIHwgIDYgKysr Ky0KPj4+PiAgICBpbmNsdWRlL2xpbnV4L2RtYS1idWYuaCAgICAgICAgICAgICAgICAgICAgICAg fCAyMyArKysrKysrKysrKysrKysrLS0KPj4+PiAgICAxMCBmaWxlcyBjaGFuZ2VkLCA3NCBpbnNl cnRpb25zKCspLCAyMSBkZWxldGlvbnMoLSkKPj4+Pgo+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2RtYS1idWYvZG1hLWJ1Zi5jIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwo+Pj4+IGluZGV4 IGVmNDgwZTVmYjIzOS4uODNjOTJiZmQ5NjRjIDEwMDY0NAo+Pj4+IC0tLSBhL2RyaXZlcnMvZG1h LWJ1Zi9kbWEtYnVmLmMKPj4+PiArKysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4+Pj4g QEAgLTUzMiw4ICs1MzIsOSBAQCBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX3B1dCk7Cj4+Pj4g ICAgLyoqCj4+Pj4gICAgICogZG1hX2J1Zl9hdHRhY2ggLSBBZGQgdGhlIGRldmljZSB0byBkbWFf YnVmJ3MgYXR0YWNobWVudHMgbGlzdDsgb3B0aW9uYWxseSwKPj4+PiAgICAgKiBjYWxscyBhdHRh Y2goKSBvZiBkbWFfYnVmX29wcyB0byBhbGxvdyBkZXZpY2Utc3BlY2lmaWMgYXR0YWNoIGZ1bmN0 aW9uYWxpdHkKPj4+PiAtICogQGRtYWJ1ZjoJW2luXQlidWZmZXIgdG8gYXR0YWNoIGRldmljZSB0 by4KPj4+PiAtICogQGRldjoJW2luXQlkZXZpY2UgdG8gYmUgYXR0YWNoZWQuCj4+Pj4gKyAqIEBp bmZvOglbaW5dCWhvbGRzIGFsbCB0aGUgYXR0YWNoIHJlbGF0ZWQgaW5mb3JtYXRpb24gcHJvdmlk ZWQKPj4+PiArICoJCQlieSB0aGUgaW1wb3J0ZXIuIHNlZSAmc3RydWN0IGRtYV9idWZfYXR0YWNo X2luZm8KPj4+PiArICoJCQlmb3IgZnVydGhlciBkZXRhaWxzLgo+Pj4+ICAgICAqCj4+Pj4gICAg ICogUmV0dXJucyBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IHBvaW50ZXIgZm9yIHRoaXMgYXR0 YWNobWVudC4gQXR0YWNobWVudHMKPj4+PiAgICAgKiBtdXN0IGJlIGNsZWFuZWQgdXAgYnkgY2Fs bGluZyBkbWFfYnVmX2RldGFjaCgpLgo+Pj4+IEBAIC01NDcsMjAgKzU0OCwyMCBAQCBFWFBPUlRf U1lNQk9MX0dQTChkbWFfYnVmX3B1dCk7Cj4+Pj4gICAgICogYWNjZXNzaWJsZSB0byBAZGV2LCBh bmQgY2Fubm90IGJlIG1vdmVkIHRvIGEgbW9yZSBzdWl0YWJsZSBwbGFjZS4gVGhpcyBpcwo+Pj4+ ICAgICAqIGluZGljYXRlZCB3aXRoIHRoZSBlcnJvciBjb2RlIC1FQlVTWS4KPj4+PiAgICAgKi8K Pj4+PiAtc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1hX2J1Zl9hdHRhY2goc3RydWN0IGRt YV9idWYgKmRtYWJ1ZiwKPj4+PiAtCQkJCQkgIHN0cnVjdCBkZXZpY2UgKmRldikKPj4+PiArc3Ry dWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1hX2J1Zl9hdHRhY2goY29uc3Qgc3RydWN0IGRtYV9i dWZfYXR0YWNoX2luZm8gKmluZm8pCj4+Pj4gICAgewo+Pj4+ICsJc3RydWN0IGRtYV9idWYgKmRt YWJ1ZiA9IGluZm8tPmRtYWJ1ZjsKPj4+PiAgICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAq YXR0YWNoOwo+Pj4+ICAgIAlpbnQgcmV0Owo+Pj4+IC0JaWYgKFdBUk5fT04oIWRtYWJ1ZiB8fCAh ZGV2KSkKPj4+PiArCWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWluZm8tPmRldikpCj4+Pj4gICAg CQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKPj4+PiAgICAJYXR0YWNoID0ga3phbGxvYyhzaXpl b2YoKmF0dGFjaCksIEdGUF9LRVJORUwpOwo+Pj4+ICAgIAlpZiAoIWF0dGFjaCkKPj4+PiAgICAJ CXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwo+Pj4+IC0JYXR0YWNoLT5kZXYgPSBkZXY7Cj4+Pj4g KwlhdHRhY2gtPmRldiA9IGluZm8tPmRldjsKPj4+PiAgICAJYXR0YWNoLT5kbWFidWYgPSBkbWFi dWY7Cj4+Pj4gICAgCW11dGV4X2xvY2soJmRtYWJ1Zi0+bG9jayk7Cj4+Pj4gQEAgLTY4OCw5ICs2 ODksOSBAQCBzdHJ1Y3Qgc2dfdGFibGUgKmRtYV9idWZfbWFwX2F0dGFjaG1lbnQoc3RydWN0IGRt YV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+Pj4+ICAgIAlpZiAoYXR0YWNoLT5zZ3QpCj4+Pj4g ICAgCQlyZXR1cm4gYXR0YWNoLT5zZ3Q7Cj4+Pj4gLQlzZ190YWJsZSA9IGF0dGFjaC0+ZG1hYnVm LT5vcHMtPm1hcF9kbWFfYnVmKGF0dGFjaCwgZGlyZWN0aW9uKTsKPj4+PiAtCWlmICghc2dfdGFi bGUpCj4+Pj4gLQkJc2dfdGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOwo+Pj4+ICsJcmVzZXJ2YXRp b25fb2JqZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOwo+Pj4+ICsJc2dfdGFi bGUgPSBkbWFfYnVmX21hcF9hdHRhY2htZW50X2xvY2tlZChhdHRhY2gsIGRpcmVjdGlvbik7Cj4+ Pj4gKwlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKPj4+ PiAgICAJcmV0dXJuIHNnX3RhYmxlOwo+Pj4+ICAgIH0KPj4+PiBAQCAtNzQ0LDggKzc0NSw5IEBA IHZvaWQgZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQg KmF0dGFjaCwKPj4+PiAgICAJaWYgKGF0dGFjaC0+c2d0ID09IHNnX3RhYmxlKQo+Pj4+ICAgIAkJ cmV0dXJuOwo+Pj4+IC0JYXR0YWNoLT5kbWFidWYtPm9wcy0+dW5tYXBfZG1hX2J1ZihhdHRhY2gs IHNnX3RhYmxlLAo+Pj4+IC0JCQkJCQlkaXJlY3Rpb24pOwo+Pj4+ICsJcmVzZXJ2YXRpb25fb2Jq ZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOwo+Pj4+ICsJZG1hX2J1Zl91bm1h cF9hdHRhY2htZW50X2xvY2tlZChhdHRhY2gsIHNnX3RhYmxlLCBkaXJlY3Rpb24pOwo+Pj4+ICsJ cmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhhdHRhY2gtPmRtYWJ1Zi0+cmVzdik7Cj4+Pj4gICAg fQo+Pj4+ICAgIEVYUE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfdW5tYXBfYXR0YWNobWVudCk7Cj4+ Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5jIGIvZHJp dmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKPj4+PiBpbmRleCA2NDJkMGU3MGQwZjgu LjE5YzQ3ODIxMDMyZiAxMDA2NDQKPj4+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYXJtYWRhL2Fy bWFkYV9nZW0uYwo+Pj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5j Cj4+Pj4gQEAgLTUwMSw2ICs1MDEsMTAgQEAgYXJtYWRhX2dlbV9wcmltZV9leHBvcnQoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmosCj4+Pj4gICAgc3Ry dWN0IGRybV9nZW1fb2JqZWN0ICoKPj4+PiAgICBhcm1hZGFfZ2VtX3ByaW1lX2ltcG9ydChzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZG1hX2J1ZiAqYnVmKQo+Pj4+ICAgIHsKPj4+PiAr CXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0gewo+Pj4+ICsJCS5kZXYg PSBkZXYtPmRldiwKPj4+PiArCQkuZG1hYnVmID0gYnVmCj4+Pj4gKwl9Owo+Pj4+ICAgIAlzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7Cj4+Pj4gICAgCXN0cnVjdCBhcm1hZGFfZ2Vt X29iamVjdCAqZG9iajsKPj4+PiBAQCAtNTE2LDcgKzUyMCw3IEBAIGFybWFkYV9nZW1fcHJpbWVf aW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpidWYpCj4+Pj4g ICAgCQl9Cj4+Pj4gICAgCX0KPj4+PiAtCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKGJ1ZiwgZGV2 LT5kZXYpOwo+Pj4+ICsJYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKPj4+ PiAgICAJaWYgKElTX0VSUihhdHRhY2gpKQo+Pj4+ICAgIAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFj aCk7Cj4+Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+Pj4+IGluZGV4IDIzMWUzZjZkNWY0MS4uMWZhZGY1ZDVl ZDMzIDEwMDY0NAo+Pj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+Pj4+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwo+Pj4+IEBAIC03MDksNiArNzA5LDEwIEBA IHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZHJtX2dlbV9wcmltZV9pbXBvcnRfZGV2KHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsCj4+Pj4gICAgCQkJCQkgICAgc3RydWN0IGRtYV9idWYgKmRtYV9idWYs Cj4+Pj4gICAgCQkJCQkgICAgc3RydWN0IGRldmljZSAqYXR0YWNoX2RldikKPj4+PiAgICB7Cj4+ Pj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPj4+PiArCQku ZGV2ID0gYXR0YWNoX2RldiwKPj4+PiArCQkuZG1hYnVmID0gZG1hX2J1Zgo+Pj4+ICsJfTsKPj4+ PiAgICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwo+Pj4+ICAgIAlzdHJ1Y3Qg c2dfdGFibGUgKnNndDsKPj4+PiAgICAJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmo7Cj4+Pj4g QEAgLTcyOSw3ICs3MzMsNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmRybV9nZW1fcHJpbWVf aW1wb3J0X2RldihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+Pj4+ICAgIAlpZiAoIWRldi0+ZHJp dmVyLT5nZW1fcHJpbWVfaW1wb3J0X3NnX3RhYmxlKQo+Pj4+ICAgIAkJcmV0dXJuIEVSUl9QVFIo LUVJTlZBTCk7Cj4+Pj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBhdHRhY2hf ZGV2KTsKPj4+PiArCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4+Pj4g ICAgCWlmIChJU19FUlIoYXR0YWNoKSkKPj4+PiAgICAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gp Owo+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYu YyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2RtYWJ1Zi5jCj4+Pj4gaW5kZXggODJl MmNhMTdhNDQxLi5hYTdmNjg1YmQ2Y2EgMTAwNjQ0Cj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9nZW1fZG1hYnVmLmMKPj4+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dlbV9kbWFidWYuYwo+Pj4+IEBAIC0yNzcsNiArMjc3LDEwIEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaTkxNV9nZW1fb2JqZWN0X2RtYWJ1Zl9vcHMg PSB7Cj4+Pj4gICAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICppOTE1X2dlbV9wcmltZV9pbXBvcnQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwKPj4+PiAgICAJCQkJCSAgICAgc3RydWN0IGRtYV9idWYg KmRtYV9idWYpCj4+Pj4gICAgewo+Pj4+ICsJc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8gYXR0 YWNoX2luZm8gPSB7Cj4+Pj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+Pj4+ICsJCS5kbWFidWYgPSBk bWFfYnVmCj4+Pj4gKwl9Owo+Pj4+ICAgIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2g7Cj4+Pj4gICAgCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7Cj4+Pj4gICAgCWlu dCByZXQ7Cj4+Pj4gQEAgLTI5NSw3ICsyOTksNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmk5 MTVfZ2VtX3ByaW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+Pj4+ICAgIAl9Cj4+ Pj4gICAgCS8qIG5lZWQgdG8gYXR0YWNoICovCj4+Pj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFj aChkbWFfYnVmLCBkZXYtPmRldik7Cj4+Pj4gKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaCgmYXR0 YWNoX2luZm8pOwo+Pj4+ICAgIAlpZiAoSVNfRVJSKGF0dGFjaCkpCj4+Pj4gICAgCQlyZXR1cm4g RVJSX0NBU1QoYXR0YWNoKTsKPj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3RlZ3Jh L2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCj4+Pj4gaW5kZXggNGY4MDEwMGZm NWYzLi44ZTZiNmM4NzlhZGQgMTAwNjQ0Cj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3RlZ3Jh L2dlbS5jCj4+Pj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCj4+Pj4gQEAgLTMz Miw2ICszMzIsMTAgQEAgc3RydWN0IHRlZ3JhX2JvICp0ZWdyYV9ib19jcmVhdGVfd2l0aF9oYW5k bGUoc3RydWN0IGRybV9maWxlICpmaWxlLAo+Pj4+ICAgIHN0YXRpYyBzdHJ1Y3QgdGVncmFfYm8g KnRlZ3JhX2JvX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLAo+Pj4+ICAgIAkJCQkJc3Ry dWN0IGRtYV9idWYgKmJ1ZikKPj4+PiAgICB7Cj4+Pj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hf aW5mbyBhdHRhY2hfaW5mbyA9IHsKPj4+PiArCQkuZGV2ID0gZHJtLT5kZXYsCj4+Pj4gKwkJLmRt YWJ1ZiA9IGJ1Zgo+Pj4+ICsJfTsKPj4+PiAgICAJc3RydWN0IHRlZ3JhX2RybSAqdGVncmEgPSBk cm0tPmRldl9wcml2YXRlOwo+Pj4+ICAgIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2g7Cj4+Pj4gICAgCXN0cnVjdCB0ZWdyYV9ibyAqYm87Cj4+Pj4gQEAgLTM0MSw3ICszNDUsNyBA QCBzdGF0aWMgc3RydWN0IHRlZ3JhX2JvICp0ZWdyYV9ib19pbXBvcnQoc3RydWN0IGRybV9kZXZp Y2UgKmRybSwKPj4+PiAgICAJaWYgKElTX0VSUihibykpCj4+Pj4gICAgCQlyZXR1cm4gYm87Cj4+ Pj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChidWYsIGRybS0+ZGV2KTsKPj4+PiArCWF0dGFj aCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7Cj4+Pj4gICAgCWlmIChJU19FUlIoYXR0 YWNoKSkgewo+Pj4+ICAgIAkJZXJyID0gUFRSX0VSUihhdHRhY2gpOwo+Pj4+ICAgIAkJZ290byBm cmVlOwo+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYyBi L2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jCj4+Pj4gaW5kZXggNTU2ZjYyNjYyYWE5 Li44NmI5MjhmOTc0MmYgMTAwNjQ0Cj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxf ZG1hYnVmLmMKPj4+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYwo+Pj4+ IEBAIC0yMjYsNiArMjI2LDEwIEBAIHN0YXRpYyBpbnQgdWRsX3ByaW1lX2NyZWF0ZShzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2LAo+Pj4+ICAgIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdWRsX2dlbV9w cmltZV9pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPj4+PiAgICAJCQkJc3RydWN0IGRt YV9idWYgKmRtYV9idWYpCj4+Pj4gICAgewo+Pj4+ICsJc3RydWN0IGRtYV9idWZfYXR0YWNoX2lu Zm8gYXR0YWNoX2luZm8gPSB7Cj4+Pj4gKwkJLmRldiA9IGRldi0+ZGV2LAo+Pj4+ICsJCS5kbWFi dWYgPSBkbWFfYnVmCj4+Pj4gKwl9Owo+Pj4+ICAgIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50 ICphdHRhY2g7Cj4+Pj4gICAgCXN0cnVjdCBzZ190YWJsZSAqc2c7Cj4+Pj4gICAgCXN0cnVjdCB1 ZGxfZ2VtX29iamVjdCAqdW9iajsKPj4+PiBAQCAtMjMzLDcgKzIzNyw3IEBAIHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqdWRsX2dlbV9wcmltZV9pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwK Pj4+PiAgICAJLyogbmVlZCB0byBhdHRhY2ggKi8KPj4+PiAgICAJZ2V0X2RldmljZShkZXYtPmRl dik7Cj4+Pj4gLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBkZXYtPmRldik7Cj4+ Pj4gKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwo+Pj4+ICAgIAlpZiAo SVNfRVJSKGF0dGFjaCkpIHsKPj4+PiAgICAJCXB1dF9kZXZpY2UoZGV2LT5kZXYpOwo+Pj4+ICAg IAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7Cj4+Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVk aWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jIGIvZHJpdmVycy9tZWRp YS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMKPj4+PiBpbmRleCBhZmYw YWI3YmY4M2QuLjFmMjY4N2I1ZWIwZSAxMDA2NDQKPj4+PiAtLS0gYS9kcml2ZXJzL21lZGlhL2Nv bW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1jb250aWcuYwo+Pj4+ICsrKyBiL2RyaXZlcnMv bWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jCj4+Pj4gQEAgLTY3 Niw2ICs2NzYsMTAgQEAgc3RhdGljIHZvaWQgdmIyX2RjX2RldGFjaF9kbWFidWYodm9pZCAqbWVt X3ByaXYpCj4+Pj4gICAgc3RhdGljIHZvaWQgKnZiMl9kY19hdHRhY2hfZG1hYnVmKHN0cnVjdCBk ZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRidWYsCj4+Pj4gICAgCXVuc2lnbmVkIGxvbmcg c2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZG1hX2RpcikKPj4+PiAgICB7Cj4+Pj4gKwlz dHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPj4+PiArCQkuZGV2ID0g ZGV2LAo+Pj4+ICsJCS5kbWFidWYgPSBkYnVmCj4+Pj4gKwl9Owo+Pj4+ICAgIAlzdHJ1Y3QgdmIy X2RjX2J1ZiAqYnVmOwo+Pj4+ICAgIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkYmE7Cj4+ Pj4gQEAgLTY5MSw3ICs2OTUsNyBAQCBzdGF0aWMgdm9pZCAqdmIyX2RjX2F0dGFjaF9kbWFidWYo c3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZG1hX2J1ZiAqZGJ1ZiwKPj4+PiAgICAJYnVmLT5k ZXYgPSBkZXY7Cj4+Pj4gICAgCS8qIGNyZWF0ZSBhdHRhY2htZW50IGZvciB0aGUgZG1hYnVmIHdp dGggdGhlIHVzZXIgZGV2aWNlICovCj4+Pj4gLQlkYmEgPSBkbWFfYnVmX2F0dGFjaChkYnVmLCBi dWYtPmRldik7Cj4+Pj4gKwlkYmEgPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwo+Pj4+ ICAgIAlpZiAoSVNfRVJSKGRiYSkpIHsKPj4+PiAgICAJCXByX2VycigiZmFpbGVkIHRvIGF0dGFj aCBkbWFidWZcbiIpOwo+Pj4+ICAgIAkJa2ZyZWUoYnVmKTsKPj4+PiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYyBiL2RyaXZlcnMv bWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLXNnLmMKPj4+PiBpbmRleCAwMTVl NzM3MDk1Y2QuLmNiZDYyNmQyMzkzYSAxMDA2NDQKPj4+PiAtLS0gYS9kcml2ZXJzL21lZGlhL2Nv bW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1zZy5jCj4+Pj4gKysrIGIvZHJpdmVycy9tZWRp YS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYwo+Pj4+IEBAIC02MDgsNiArNjA4 LDEwIEBAIHN0YXRpYyB2b2lkIHZiMl9kbWFfc2dfZGV0YWNoX2RtYWJ1Zih2b2lkICptZW1fcHJp dikKPj4+PiAgICBzdGF0aWMgdm9pZCAqdmIyX2RtYV9zZ19hdHRhY2hfZG1hYnVmKHN0cnVjdCBk ZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRidWYsCj4+Pj4gICAgCXVuc2lnbmVkIGxvbmcg c2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZG1hX2RpcikKPj4+PiAgICB7Cj4+Pj4gKwlz dHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKPj4+PiArCQkuZGV2ID0g ZGV2LAo+Pj4+ICsJCS5kbWFidWYgPSBkYnVmCj4+Pj4gKwl9Owo+Pj4+ICAgIAlzdHJ1Y3QgdmIy X2RtYV9zZ19idWYgKmJ1ZjsKPj4+PiAgICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZGJh Owo+Pj4+IEBAIC02MjMsNyArNjI3LDcgQEAgc3RhdGljIHZvaWQgKnZiMl9kbWFfc2dfYXR0YWNo X2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpkYnVmLAo+Pj4+ICAg IAlidWYtPmRldiA9IGRldjsKPj4+PiAgICAJLyogY3JlYXRlIGF0dGFjaG1lbnQgZm9yIHRoZSBk bWFidWYgd2l0aCB0aGUgdXNlciBkZXZpY2UgKi8KPj4+PiAtCWRiYSA9IGRtYV9idWZfYXR0YWNo KGRidWYsIGJ1Zi0+ZGV2KTsKPj4+PiArCWRiYSA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5m byk7Cj4+Pj4gICAgCWlmIChJU19FUlIoZGJhKSkgewo+Pj4+ICAgIAkJcHJfZXJyKCJmYWlsZWQg dG8gYXR0YWNoIGRtYWJ1ZlxuIik7Cj4+Pj4gICAgCQlrZnJlZShidWYpOwo+Pj4+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRlL3RlZ3JhLXZkZS5jIGIvZHJpdmVy cy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdyYS12ZGUuYwo+Pj4+IGluZGV4IGFhNmM2YmJh OTYxZS4uNWExMGMxZmFjYzI3IDEwMDY0NAo+Pj4+IC0tLSBhL2RyaXZlcnMvc3RhZ2luZy9tZWRp YS90ZWdyYS12ZGUvdGVncmEtdmRlLmMKPj4+PiArKysgYi9kcml2ZXJzL3N0YWdpbmcvbWVkaWEv dGVncmEtdmRlL3RlZ3JhLXZkZS5jCj4+Pj4gQEAgLTU2OCw2ICs1NjgsMTAgQEAgc3RhdGljIGlu dCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4+Pj4gICAgCQkJ CSAgIHNpemVfdCAqc2l6ZSwKPj4+PiAgICAJCQkJICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24g ZG1hX2RpcikKPj4+PiAgICB7Cj4+Pj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRh Y2hfaW5mbyA9IHsKPj4+PiArCQkuZGV2ID0gZGV2LAo+Pj4+ICsJCS5kbWFidWYgPSBkbWFidWYK Pj4+PiArCX07Cj4+Pj4gICAgCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaG1lbnQ7 Cj4+Pj4gICAgCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Cj4+Pj4gICAgCXN0cnVjdCBzZ190YWJs ZSAqc2d0Owo+Pj4+IEBAIC01OTEsNyArNTk1LDcgQEAgc3RhdGljIGludCB0ZWdyYV92ZGVfYXR0 YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4+Pj4gICAgCQlyZXR1cm4gLUVJTlZBTDsK Pj4+PiAgICAJfQo+Pj4+IC0JYXR0YWNobWVudCA9IGRtYV9idWZfYXR0YWNoKGRtYWJ1ZiwgZGV2 KTsKPj4+PiArCWF0dGFjaG1lbnQgPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwo+Pj4+ ICAgIAlpZiAoSVNfRVJSKGF0dGFjaG1lbnQpKSB7Cj4+Pj4gICAgCQlkZXZfZXJyKGRldiwgIkZh aWxlZCB0byBhdHRhY2ggZG1hYnVmXG4iKTsKPj4+PiAgICAJCWVyciA9IFBUUl9FUlIoYXR0YWNo bWVudCk7Cj4+Pj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVk ZS9saW51eC9kbWEtYnVmLmgKPj4+PiBpbmRleCAxOGE3OGJlNTM1NDEuLjdlMjM3NThkYjNhNCAx MDA2NDQKPj4+PiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAo+Pj4+ICsrKyBiL2luY2x1 ZGUvbGludXgvZG1hLWJ1Zi5oCj4+Pj4gQEAgLTEyOCw2ICsxMjgsOSBAQCBzdHJ1Y3QgZG1hX2J1 Zl9vcHMgewo+Pj4+ICAgIAkgKiBhbnkgb3RoZXIga2luZCBvZiBzaGFyaW5nIHRoYXQgdGhlIGV4 cG9ydGVyIG1pZ2h0IHdpc2ggdG8gbWFrZQo+Pj4+ICAgIAkgKiBhdmFpbGFibGUgdG8gYnVmZmVy LXVzZXJzLgo+Pj4+ICAgIAkgKgo+Pj4+ICsJICogVGhpcyBpcyBhbHdheXMgY2FsbGVkIHdpdGgg dGhlIGRtYWJ1Zi0+cmVzdiBvYmplY3QgbG9ja2VkIHdoZW4KPj4+PiArCSAqIG5vX3NndF9jYWNo ZSBpcyB0cnVlLgo+Pj4+ICsJICoKPj4+PiAgICAJICogUmV0dXJuczoKPj4+PiAgICAJICoKPj4+ PiAgICAJICogQSAmc2dfdGFibGUgc2NhdHRlciBsaXN0IG9mIG9yIHRoZSBiYWNraW5nIHN0b3Jh Z2Ugb2YgdGhlIERNQSBidWZmZXIsCj4+Pj4gQEAgLTE0OCw2ICsxNTEsOSBAQCBzdHJ1Y3QgZG1h X2J1Zl9vcHMgewo+Pj4+ICAgIAkgKiBJdCBzaG91bGQgYWxzbyB1bnBpbiB0aGUgYmFja2luZyBz dG9yYWdlIGlmIHRoaXMgaXMgdGhlIGxhc3QgbWFwcGluZwo+Pj4+ICAgIAkgKiBvZiB0aGUgRE1B IGJ1ZmZlciwgaXQgdGhlIGV4cG9ydGVyIHN1cHBvcnRzIGJhY2tpbmcgc3RvcmFnZQo+Pj4+ICAg IAkgKiBtaWdyYXRpb24uCj4+Pj4gKwkgKgo+Pj4+ICsJICogVGhpcyBpcyBhbHdheXMgY2FsbGVk IHdpdGggdGhlIGRtYWJ1Zi0+cmVzdiBvYmplY3QgbG9ja2VkIHdoZW4KPj4+PiArCSAqIG5vX3Nn dF9jYWNoZSBpcyB0cnVlLgo+Pj4+ICAgIAkgKi8KPj4+PiAgICAJdm9pZCAoKnVubWFwX2RtYV9i dWYpKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKiwKPj4+PiAgICAJCQkgICAgICBzdHJ1Y3Qg c2dfdGFibGUgKiwKPj4+PiBAQCAtMzcwLDYgKzM3NiwxOSBAQCBzdHJ1Y3QgZG1hX2J1Zl9leHBv cnRfaW5mbyB7Cj4+Pj4gICAgCXN0cnVjdCBkbWFfYnVmX2V4cG9ydF9pbmZvIG5hbWUgPSB7IC5l eHBfbmFtZSA9IEtCVUlMRF9NT0ROQU1FLCBcCj4+Pj4gICAgCQkJCQkgLm93bmVyID0gVEhJU19N T0RVTEUgfQo+Pj4+ICsvKioKPj4+PiArICogc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8gLSBo b2xkcyBpbmZvcm1hdGlvbiBuZWVkZWQgdG8gYXR0YWNoIHRvIGEgZG1hX2J1Zgo+Pj4+ICsgKiBA ZG1hYnVmOgl0aGUgZXhwb3J0ZWQgZG1hX2J1Zgo+Pj4+ICsgKiBAZGV2Ogl0aGUgZGV2aWNlIHdo aWNoIHdhbnRzIHRvIGltcG9ydCB0aGUgYXR0YWNobWVudAo+Pj4+ICsgKgo+Pj4+ICsgKiBUaGlz IHN0cnVjdHVyZSBob2xkcyB0aGUgaW5mb3JtYXRpb24gcmVxdWlyZWQgdG8gYXR0YWNoIHRvIGEg YnVmZmVyLiBVc2VkCj4+Pj4gKyAqIHdpdGggZG1hX2J1Zl9hdHRhY2goKSBvbmx5Lgo+Pj4+ICsg Ki8KPj4+PiArc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8gewo+Pj4+ICsJc3RydWN0IGRtYV9i dWYgKmRtYWJ1ZjsKPj4+PiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPj4+PiArfTsKPj4+PiArCj4+ Pj4gICAgLyoqCj4+Pj4gICAgICogZ2V0X2RtYV9idWYgLSBjb252ZW5pZW5jZSB3cmFwcGVyIGZv ciBnZXRfZmlsZS4KPj4+PiAgICAgKiBAZG1hYnVmOglbaW5dCXBvaW50ZXIgdG8gZG1hX2J1Zgo+ Pj4+IEBAIC0zODQsOCArNDAzLDggQEAgc3RhdGljIGlubGluZSB2b2lkIGdldF9kbWFfYnVmKHN0 cnVjdCBkbWFfYnVmICpkbWFidWYpCj4+Pj4gICAgCWdldF9maWxlKGRtYWJ1Zi0+ZmlsZSk7Cj4+ Pj4gICAgfQo+Pj4+IC1zdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0dGFjaChz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+Pj4+IC0JCQkJCQkJc3RydWN0IGRldmljZSAqZGV2KTsK Pj4+PiArc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqCj4+Pj4gK2RtYV9idWZfYXR0YWNoKGNv bnN0IHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvICppbmZvKTsKPj4+PiAgICB2b2lkIGRtYV9i dWZfZGV0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCj4+Pj4gICAgCQkJCXN0cnVjdCBkbWFf YnVmX2F0dGFjaG1lbnQgKmRtYWJ1Zl9hdHRhY2gpOwo+Pj4+IC0tIAo+Pj4+IDIuMTcuMQo+Pj4+ Cj4+Pj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPj4+ PiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0Cj4+Pj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwo+Pj4+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCj4+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCj4+IGRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKPj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwo+PiBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2RyaS1kZXZlbAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KYW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0 cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbWQtZ2Z4 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=-6.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED 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 6BF73C282DA for ; Wed, 17 Apr 2019 17:10:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1AF8420675 for ; Wed, 17 Apr 2019 17:10:54 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KXrQbgNy" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732749AbfDQRKs (ORCPT ); Wed, 17 Apr 2019 13:10:48 -0400 Received: from mail-wr1-f66.google.com ([209.85.221.66]:40280 "EHLO mail-wr1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729395AbfDQRKs (ORCPT ); Wed, 17 Apr 2019 13:10:48 -0400 Received: by mail-wr1-f66.google.com with SMTP id h4so32947940wre.7; Wed, 17 Apr 2019 10:10:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=reply-to:subject:to:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=9CP27iTYtmXmc5G/CNCdvzzhtigy7vNfiFxnXbukxQ8=; b=KXrQbgNyW1JvUAnTsPR5rIZAFFQjOiQa2muqRgY+nG57oqR9cckRWwE3vP6YidjFQX RU4hbMNXYISYuleZUq0iXiDcJTHxJhXzoYrw4EBlS4D3v5TrLhgMhUwzpP9n/IbX+CIJ wvoPmXaO7n/xLOfGpViioLSvn62qqaT9FNd8A0LC97TNLZj3ucMVgAJbVWEyW/FRCMhG npSi7Tx9Kru0A39FaDf/tAY0sgmG6NtvJPVLLile0tfLisX+gB+Ffvtr9EHWJSyU7ewS R6tnhvOgtu9WDOP84o6IRPUpo9wjdPZ/uFtESyzSKBEDAfSp4mf9hU3SF6crNDA+J/i9 zKQg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:reply-to:subject:to:references:from:message-id :date:user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=9CP27iTYtmXmc5G/CNCdvzzhtigy7vNfiFxnXbukxQ8=; b=t74pzgBPVuTeAFv4q7tjjlBIntkm4SoRjAxtP/tffjS8MFXZbLSY38utudtH7PpSM9 f6tJvazoNzKrOgFGuzogkMQkejXR9kUnXi3BbXAOFZZUfKHou/z1/iWl6L8rUVk38HnI UJHMA0dQTs7wdmAvaBJiIBK3bT7+nvnpjtXt2xvEP508+IJxdiOQbHAWyi2z0i9218DX Nq/qtS7C4qUdZxNVWZMmqN5NHlcyPfR4AQAjWcELEIk1uaz8NESwMR+SVtuagdJ4MjdK JS1turK6Rfc/WHOgWswG5vQ1uRX1gYa6nnsRZYyHX0HJy73nw4MvVsMXQYxh+WGcEgN0 8ULQ== X-Gm-Message-State: APjAAAUXsGsCTWRewpyxy/JkvpFgGByYxl+p6FcmTzZ1Fj/jt9YxfWCf LV6uvTZRA6t0uUOrFwnSrHM= X-Google-Smtp-Source: APXvYqzalf7zd58XIsl63rUXoD8nT5N1aTNHkuOWDB58M9nhPzA/IF+G8/MNjWVVvz+Xu32FIDwZ+A== X-Received: by 2002:adf:ec0a:: with SMTP id x10mr57526334wrn.193.1555521044433; Wed, 17 Apr 2019 10:10:44 -0700 (PDT) Received: from ?IPv6:2a02:908:1252:fb60:be8a:bd56:1f94:86e7? ([2a02:908:1252:fb60:be8a:bd56:1f94:86e7]) by smtp.gmail.com with ESMTPSA id s1sm45717105wrt.43.2019.04.17.10.10.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 17 Apr 2019 10:10:43 -0700 (PDT) Reply-To: christian.koenig@amd.com Subject: Re: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 To: christian.koenig@amd.com, 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> <20190417140804.GD13337@phenom.ffwll.local> <20190417142632.GF13337@phenom.ffwll.local> From: =?UTF-8?Q?Christian_K=c3=b6nig?= Message-ID: Date: Wed, 17 Apr 2019 19:10:42 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.6.1 MIME-Version: 1.0 In-Reply-To: <20190417142632.GF13337@phenom.ffwll.local> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Am 17.04.19 um 16:26 schrieb Daniel Vetter: > On Wed, Apr 17, 2019 at 04:14:32PM +0200, Christian König wrote: >> Am 17.04.19 um 16:08 schrieb Daniel Vetter: >>> 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 >> Ah, crap thought I've got all of those. Going to fix that. >> >>> 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. >> I actually found a solution for that :) >> >> The idea is now that we always cache the sgt in the attachment unless the >> dynamic flag (previously no_sgt_cache flag) is set. And this cached sgt is >> created without holding the lock. > Yeah I think that idea works. > >> We either need to document that really well or maybe split the mapping >> callbacks into map/unmap and map_lock/unmap_locked. Opinions? > I think the implementation doesn't. Exporter can't decide on its own > whether dynamic/static is what's needed, we need to decide that for each > attachment, taking both exporter and importer capabilities into account. Well that's what the pin/unpin callbacks are good for :) Essentially we have to handle the following cases: a) dynamic exporter and dynamic importer         Nothing special here and we don't need the sgt caching nor pinning. b) dynamic exporter and static importer         The pin/unpin callbacks are used to inform the exporter that it needs to keep the buffer in the current place. c) static exporter and dynamic importer         We use the sgt caching to avoid calling the exporter with the common lock held. d) static exporter and static importer         We use the sgt caching, but that is actually only optional. > I think if we do that, then it should work out. I replied on the pin/unpin > interface patch with some more concrete thoughts. Maybe best to continue > that discussion there, with more context. Yeah, that is probably a good idea. Regards, Christian. > -Daniel > >>> 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. >> We can now make a slow transition between static and dynamic DMA-buf >> handling, so only driver who can do the locking will be affected. >> >> Christian. >> >>> -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 >> _______________________________________________ >> dri-devel mailing list >> dri-devel@lists.freedesktop.org >> https://lists.freedesktop.org/mailman/listinfo/dri-devel