From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: Re: [RFC 1/8] dma-buf/fence: add fence_collection fences Date: Fri, 15 Apr 2016 11:27:50 -0700 Message-ID: <20160415182750.GA23954@joana> References: <1460683781-22535-1-git-send-email-gustavo@padovan.org> <1460683781-22535-2-git-send-email-gustavo@padovan.org> <20160415080254.GQ2510@phenom.ffwll.local> <5710AE61.9040308@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-pa0-f53.google.com (mail-pa0-f53.google.com [209.85.220.53]) by gabe.freedesktop.org (Postfix) with ESMTPS id B266C6ECE9 for ; Fri, 15 Apr 2016 18:27:52 +0000 (UTC) Received: by mail-pa0-f53.google.com with SMTP id zm5so57642454pac.0 for ; Fri, 15 Apr 2016 11:27:52 -0700 (PDT) Content-Disposition: inline In-Reply-To: <5710AE61.9040308@amd.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Christian =?iso-8859-1?Q?K=F6nig?= Cc: marcheu@google.com, Daniel Stone , seanpaul@google.com, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Riley Andrews , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , m.chehab@samsung.com, Gustavo Padovan , John Harrison , laurent.pinchart@ideasonboard.com List-Id: dri-devel@lists.freedesktop.org MjAxNi0wNC0xNSBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+OgoK PiBBbSAxNS4wNC4yMDE2IHVtIDEwOjAyIHNjaHJpZWIgRGFuaWVsIFZldHRlcjoKPiA+T24gVGh1 LCBBcHIgMTQsIDIwMTYgYXQgMDY6Mjk6MzRQTSAtMDcwMCwgR3VzdGF2byBQYWRvdmFuIHdyb3Rl Ogo+ID4+RnJvbTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNv LnVrPgo+ID4+Cj4gPj5zdHJ1Y3QgZmVuY2VfY29sbGVjdGlvbiBpbmhlcml0cyBmcm9tIHN0cnVj dCBmZW5jZSBhbmQgY2FycmllcyBhCj4gPj5jb2xsZWN0aW9uIG9mIGZlbmNlcyB0aGF0IG5lZWRz IHRvIGJlIHdhaXRlZCB0b2dldGhlci4KPiA+Pgo+ID4+SXQgaXMgdXNlZnVsIHRvIHRyYW5zbGF0 ZSBhIHN5bmNfZmlsZSB0byBhIGZlbmNlIHRvIHJlbW92ZSB0aGUgY29tcGxleGl0eQo+ID4+b2Yg ZGVhbGluZyB3aXRoIHN5bmNfZmlsZXMgZnJvbSBEUk0gZHJpdmVycy4gU28gZXZlbiBpZiB0aGVy ZSBhcmUgbWFueQo+ID4+ZmVuY2VzIGluIHRoZSBzeW5jX2ZpbGUgdGhhdCBuZWVkcyB0byB3YWl0 ZWQgZm9yIGEgY29tbWl0IHRvIGhhcHBlbgo+ID4+ZHJpdmVycyB3b3VsZCBvbmx5IHdvcnJ5IGFi b3V0IGEgc3RhbmRhcmQgc3RydWN0IGZlbmNlLlRoYXQgbWVhbnMgdGhhdCBubwo+ID4+Y2hhbmdl cyBuZWVkZWQgdG8gYW55IGRyaXZlciBiZXNpZGVzIHN1cHBvcnRpbmcgZmVuY2VzLgo+ID4+Cj4g Pj5mZW5jZV9jb2xsZWN0aW9uJ3MgZmVuY2UgZG9lc24ndCBiZWxvbmcgdG8gYW55IHRpbWVsaW5l IGNvbnRleHQuCj4gPj4KPiA+PlNpZ25lZC1vZmYtYnk6IEd1c3Rhdm8gUGFkb3ZhbiA8Z3VzdGF2 by5wYWRvdmFuQGNvbGxhYm9yYS5jby51az4KPiA+Pi0tLQo+ID4+ICBkcml2ZXJzL2RtYS1idWYv TWFrZWZpbGUgICAgICAgICAgIHwgICAyICstCj4gPj4gIGRyaXZlcnMvZG1hLWJ1Zi9mZW5jZS1j b2xsZWN0aW9uLmMgfCAxMzggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ID4+ICBkcml2ZXJzL2RtYS1idWYvZmVuY2UuYyAgICAgICAgICAgIHwgICAyICstCj4gPj4gIGlu Y2x1ZGUvbGludXgvZmVuY2UtY29sbGVjdGlvbi5oICAgfCAgNTYgKysrKysrKysrKysrKysrCj4g Pj4gIGluY2x1ZGUvbGludXgvZmVuY2UuaCAgICAgICAgICAgICAgfCAgIDIgKwo+ID4+ICA1IGZp bGVzIGNoYW5nZWQsIDE5OCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+ID4+ICBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2ZlbmNlLWNvbGxlY3Rpb24uYwo+ID4+ICBj cmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9mZW5jZS1jb2xsZWN0aW9uLmgKPiA+Pgo+ ID4+ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZSBiL2RyaXZlcnMvZG1hLWJ1 Zi9NYWtlZmlsZQo+ID4+aW5kZXggNDMzMjVhMS4uMzBiODQ2NCAxMDA2NDQKPiA+Pi0tLSBhL2Ry aXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZQo+ID4+KysrIGIvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxl Cj4gPj5AQCAtMSwzICsxLDMgQEAKPiA+Pi1vYmoteSA6PSBkbWEtYnVmLm8gZmVuY2UubyByZXNl cnZhdGlvbi5vIHNlcW5vLWZlbmNlLm8KPiA+PitvYmoteSA6PSBkbWEtYnVmLm8gZmVuY2UubyBy ZXNlcnZhdGlvbi5vIHNlcW5vLWZlbmNlLm8gZmVuY2UtY29sbGVjdGlvbi5vCj4gPj4gIG9iai0k KENPTkZJR19TWU5DX0ZJTEUpCQkrPSBzeW5jX2ZpbGUubyBzeW5jX3RpbWVsaW5lLm8gc3luY19k ZWJ1Zy5vCj4gPj4gIG9iai0kKENPTkZJR19TV19TWU5DKQkJKz0gc3dfc3luYy5vCj4gPj5kaWZm IC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2ZlbmNlLWNvbGxlY3Rpb24uYyBiL2RyaXZlcnMvZG1h LWJ1Zi9mZW5jZS1jb2xsZWN0aW9uLmMKPiA+Pm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPj5pbmRl eCAwMDAwMDAwLi44YTRlY2IwCj4gPj4tLS0gL2Rldi9udWxsCj4gPj4rKysgYi9kcml2ZXJzL2Rt YS1idWYvZmVuY2UtY29sbGVjdGlvbi5jCj4gPj5AQCAtMCwwICsxLDEzOCBAQAo+ID4+Ky8qCj4g Pj4rICogZmVuY2UtY29sbGVjdGlvbjogYWdncmVnYXRlIGZlbmNlcyB0byBiZSB3YWl0ZWQgdG9n ZXRoZXIKPiA+PisgKgo+ID4+KyAqIENvcHlyaWdodCAoQykgMjAxNiBDb2xsYWJvcmEgTHRkCj4g Pj4rICogQXV0aG9yczoKPiA+PisgKglHdXN0YXZvIFBhZG92YW4gPGd1c3Rhdm9AcGFkb3Zhbi5v cmc+Cj4gPj4rICoKPiA+PisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAo+ID4+KyAqIHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hl ZCBieQo+ID4+KyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4gPj4rICoKPiA+Pisg KiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwgYnV0IFdJVEhPVVQKPiA+PisgKiBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IKPiA+PisgKiBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yCj4gPj4rICogbW9yZSBkZXRhaWxzLgo+ID4+KyAqLwo+ID4+Kwo+ID4+KyNpbmNs dWRlIDxsaW51eC9leHBvcnQuaD4KPiA+PisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ID4+KyNp bmNsdWRlIDxsaW51eC9mZW5jZS1jb2xsZWN0aW9uLmg+Cj4gPj4rCj4gPj4rc3RhdGljIGNvbnN0 IGNoYXIgKmZlbmNlX2NvbGxlY3Rpb25fZ2V0X2RyaXZlcl9uYW1lKHN0cnVjdCBmZW5jZSAqZmVu Y2UpCj4gPj4rewo+ID4+KwlzdHJ1Y3QgZmVuY2VfY29sbGVjdGlvbiAqY29sbGVjdGlvbiA9IHRv X2ZlbmNlX2NvbGxlY3Rpb24oZmVuY2UpOwo+ID4+KwlzdHJ1Y3QgZmVuY2UgKmYgPSBjb2xsZWN0 aW9uLT5mZW5jZXNbMF0uZmVuY2U7Cj4gPj4rCj4gPj4rCXJldHVybiBmLT5vcHMtPmdldF9kcml2 ZXJfbmFtZShmZW5jZSk7Cj4gPj4rfQo+IAo+IEkgd291bGQgcmF0aGVyIHJldHVybiBzb21lIGNv bnN0YW50IG5hbWUgaGVyZSBpbnN0ZWFkIG9mIHJlbHlpbmcgdGhhdCB0aGUKPiBjb2xsZWN0aW9u IGFscmVhZHkgaGFzIGEgZmVuY2UgYWRkZWQgYW5kIHRoYXQgYWxsIGZlbmNlcyBhcmUgZnJvbSB0 aGUgc2FtZQo+IGRyaXZlci4KCklmIHdlIG1lcmdlIF9pbml0IGFuZCBfYWRkIHRoaXMgd2lsbCBu b3QgYmUgYSBwcm9ibGVtIGFueW1vcmUgYW5kIHdlIGNhbgpyZXR1cm4gdGhlIGFjdHVhbCBkcml2 ZXIgbmFtZS4KCj4gCj4gPj4rCj4gPj4rc3RhdGljIGNvbnN0IGNoYXIgKmZlbmNlX2NvbGxlY3Rp b25fZ2V0X3RpbWVsaW5lX25hbWUoc3RydWN0IGZlbmNlICpmZW5jZSkKPiA+Pit7Cj4gPj4rCXJl dHVybiAibm8gY29udGV4dCI7Cj4gPj4rfQo+ID4+Kwo+ID4+K3N0YXRpYyBib29sIGZlbmNlX2Nv bGxlY3Rpb25fZW5hYmxlX3NpZ25hbGluZyhzdHJ1Y3QgZmVuY2UgKmZlbmNlKQo+ID4+K3sKPiA+ PisJc3RydWN0IGZlbmNlX2NvbGxlY3Rpb24gKmNvbGxlY3Rpb24gPSB0b19mZW5jZV9jb2xsZWN0 aW9uKGZlbmNlKTsKPiA+PisKPiA+PisJcmV0dXJuIGF0b21pY19yZWFkKCZjb2xsZWN0aW9uLT5u dW1fcGVuZGluZ19mZW5jZXMpOwo+ID4+K30KPiA+PisKPiA+PitzdGF0aWMgYm9vbCBmZW5jZV9j b2xsZWN0aW9uX3NpZ25hbGVkKHN0cnVjdCBmZW5jZSAqZmVuY2UpCj4gPj4rewo+ID4+KwlzdHJ1 Y3QgZmVuY2VfY29sbGVjdGlvbiAqY29sbGVjdGlvbiA9IHRvX2ZlbmNlX2NvbGxlY3Rpb24oZmVu Y2UpOwo+ID4+Kwo+ID4+KwlyZXR1cm4gKGF0b21pY19yZWFkKCZjb2xsZWN0aW9uLT5udW1fcGVu ZGluZ19mZW5jZXMpID09IDApOwo+ID4+K30KPiA+PisKPiA+PitzdGF0aWMgdm9pZCBmZW5jZV9j b2xsZWN0aW9uX3JlbGVhc2Uoc3RydWN0IGZlbmNlICpmZW5jZSkKPiA+Pit7Cj4gPj4rCXN0cnVj dCBmZW5jZV9jb2xsZWN0aW9uICpjb2xsZWN0aW9uID0gdG9fZmVuY2VfY29sbGVjdGlvbihmZW5j ZSk7Cj4gPj4rCWludCBpOwo+ID4+Kwo+ID4+Kwlmb3IgKGkgPSAwIDsgaSA8IGNvbGxlY3Rpb24t Pm51bV9mZW5jZXMgOyBpKyspIHsKPiA+PisJCWZlbmNlX3JlbW92ZV9jYWxsYmFjayhjb2xsZWN0 aW9uLT5mZW5jZXNbaV0uZmVuY2UsCj4gPj4rCQkJCSAgICAgICZjb2xsZWN0aW9uLT5mZW5jZXNb aV0uY2IpOwo+ID4+KwkJZmVuY2VfcHV0KGNvbGxlY3Rpb24tPmZlbmNlc1tpXS5mZW5jZSk7Cj4g Pj4rCX0KPiA+PisKPiA+PisJZmVuY2VfZnJlZShmZW5jZSk7Cj4gPj4rfQo+ID4+Kwo+ID4+K3N0 YXRpYyBzaWduZWQgbG9uZyBmZW5jZV9jb2xsZWN0aW9uX3dhaXQoc3RydWN0IGZlbmNlICpmZW5j ZSwgYm9vbCBpbnRyLAo+ID4+KwkJCQkJIHNpZ25lZCBsb25nIHRpbWVvdXQpCj4gPj4rewo+ID4+ KwlzdHJ1Y3QgZmVuY2VfY29sbGVjdGlvbiAqY29sbGVjdGlvbiA9IHRvX2ZlbmNlX2NvbGxlY3Rp b24oZmVuY2UpOwo+ID4+KwlpbnQgaTsKPiA+PisKPiA+PisJZm9yIChpID0gMCA7IGkgPCBjb2xs ZWN0aW9uLT5udW1fZmVuY2VzIDsgaSsrKSB7Cj4gPj4rCQl0aW1lb3V0ID0gZmVuY2Vfd2FpdChj b2xsZWN0aW9uLT5mZW5jZXNbaV0uZmVuY2UsIGludHIpOwo+ID4+KwkJaWYgKHRpbWVvdXQgPCAw KQo+ID4+KwkJCXJldHVybiB0aW1lb3V0Owo+ID4+Kwl9Cj4gPj4rCj4gPj4rCXJldHVybiB0aW1l b3V0Owo+ID4+K30KPiA+PisKPiA+PitzdGF0aWMgY29uc3Qgc3RydWN0IGZlbmNlX29wcyBmZW5j ZV9jb2xsZWN0aW9uX29wcyA9IHsKPiA+PisJLmdldF9kcml2ZXJfbmFtZSA9IGZlbmNlX2NvbGxl Y3Rpb25fZ2V0X2RyaXZlcl9uYW1lLAo+ID4+KwkuZ2V0X3RpbWVsaW5lX25hbWUgPSBmZW5jZV9j b2xsZWN0aW9uX2dldF90aW1lbGluZV9uYW1lLAo+ID4+KwkuZW5hYmxlX3NpZ25hbGluZyA9IGZl bmNlX2NvbGxlY3Rpb25fZW5hYmxlX3NpZ25hbGluZywKPiA+PisJLnNpZ25hbGVkID0gZmVuY2Vf Y29sbGVjdGlvbl9zaWduYWxlZCwKPiA+PisJLndhaXQgPSBmZW5jZV9jb2xsZWN0aW9uX3dhaXQs Cj4gPj4rCS5yZWxlYXNlID0gZmVuY2VfY29sbGVjdGlvbl9yZWxlYXNlLAo+ID4+K307Cj4gPj4r Cj4gPj4rc3RhdGljIHZvaWQgY29sbGVjdGlvbl9jaGVja19jYl9mdW5jKHN0cnVjdCBmZW5jZSAq ZmVuY2UsIHN0cnVjdCBmZW5jZV9jYiAqY2IpCj4gPj4rewo+ID4+KwlzdHJ1Y3QgZmVuY2VfY29s bGVjdGlvbl9jYiAqZl9jYjsKPiA+PisJc3RydWN0IGZlbmNlX2NvbGxlY3Rpb24gKmNvbGxlY3Rp b247Cj4gPj4rCj4gPj4rCWZfY2IgPSBjb250YWluZXJfb2YoY2IsIHN0cnVjdCBmZW5jZV9jb2xs ZWN0aW9uX2NiLCBjYik7Cj4gPj4rCWNvbGxlY3Rpb24gPSBmX2NiLT5jb2xsZWN0aW9uOwo+ID4+ Kwo+ID4+KwlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmY29sbGVjdGlvbi0+bnVtX3BlbmRpbmdf ZmVuY2VzKSkKPiA+PisJCWZlbmNlX3NpZ25hbCgmY29sbGVjdGlvbi0+YmFzZSk7Cj4gPj4rfQo+ ID4+Kwo+ID4+K3ZvaWQgZmVuY2VfY29sbGVjdGlvbl9hZGQoc3RydWN0IGZlbmNlX2NvbGxlY3Rp b24gKmNvbGxlY3Rpb24sCj4gPj4rCQkJICBzdHJ1Y3QgZmVuY2UgKmZlbmNlKQo+ID4+K3sKPiA+ PisJaW50IG4gPSBjb2xsZWN0aW9uLT5udW1fZmVuY2VzOwo+ID4+Kwo+ID4+Kwljb2xsZWN0aW9u LT5mZW5jZXNbbl0uY29sbGVjdGlvbiA9IGNvbGxlY3Rpb247Cj4gPj4rCWNvbGxlY3Rpb24tPmZl bmNlc1tuXS5mZW5jZSA9IGZlbmNlOwo+ID4+Kwo+ID4+KwlpZiAoZmVuY2VfYWRkX2NhbGxiYWNr KGZlbmNlLCAmY29sbGVjdGlvbi0+ZmVuY2VzW25dLmNiLAo+ID4+KwkJCQkgY29sbGVjdGlvbl9j aGVja19jYl9mdW5jKSkKPiA+PisJCXJldHVybjsKPiA+PisKPiA+PisJZmVuY2VfZ2V0KGZlbmNl KTsKPiA+PisKPiA+PisJY29sbGVjdGlvbi0+bnVtX2ZlbmNlcysrOwo+ID4+KwlhdG9taWNfaW5j KCZjb2xsZWN0aW9uLT5udW1fcGVuZGluZ19mZW5jZXMpOwo+ID4+K30KPiA+Rm9yIHRoZSBpbnRl cmZhY2UgSSB0aGluayB3ZSBzaG91bGQgbm90IHNwbGl0IGl0IGludG8gX2luaXQgYW5kIF9hZGQg LSBpdAo+ID5zaG91bGRuJ3QgYmUgYWxsb3dlZCB0byBjaGFuZ2UgYSBjb2xsZWN0aW9uIG9uY2Ug aXQncyBjcmVhdGVkLiBTbyBwcm9iYWJseQo+ID5jbGVhbmVyIGlmIHdlIGFkZCBhbiBhcnJheSBv ZiBmZW5jZSBwb2ludGVycyB0byBfaW5pdC4KPiAKPiBBbWRncHUgYWxzbyBoYXMgYW4gaW1wbGVt ZW50YXRpb24gZm9yIGEgZmVuY2UgY29sbGVjdGlvbiB3aGljaCB1c2VzIGEgYQo+IGhhc2h0YWJs ZSB0byBrZWVwIHRoZSBmZW5jZXMgZ3JvdXBlZCBieSBjb250ZXh0IChlLmcuIG9ubHkgdGhlIGxh dGVzdCBmZW5jZQo+IGlzIGtlZXB0IGZvciBlYWNoIGNvbnRleHQpLiBTZWUgYW1kZ3B1X3N5bmMu YyBmb3IgcmVmZXJlbmNlLgo+IAo+IFdlIHNob3VsZCBlaXRoZXIgbWFrZSB0aGUgY29sbGVjdGlv biBzaW1pbGFyIGluIGEgd2F5IHRoYXQgeW91IGNhbiBhZGQgYXMKPiBtYW55IGZlbmNlcyBhcyB5 b3Ugd2FudCAobGlrZSB0aGUgYW1kZ3B1IGltcGxlbWVudGF0aW9uKSBvciBtYWtlIGl0IHN0YXRp Ywo+IGFuZCBvbmx5IGFkZCBhIGZpeGVkIG51bWJlciBvZiBmZW5jZXMgcmlnaHQgZnJvbSB0aGUg YmVnaW5uaW5nLgo+IAo+IEkgY2FuIGNlcnRhaW5seSBzZWUgdXNlIGNhc2VzIGZvciBib3RoLCBi dXQgaWYgeW91IHdhbnQgdG8gc3RpY2sgd2l0aCBhCj4gc3RhdGljIGFwcHJvYWNoIHlvdSBzaG91 bGQgcHJvYmFibHkgY2FsbCB0aGUgbmV3IG9iamVjdCBmZW5jZV9hcnJheSBpbnN0ZWFkCj4gb2Yg ZmVuY2VfY29sbGVjdGlvbiBhbmQgZG8gYXMgRGFuaWVsIHN1Z2dlc3RlZC4KCk1heWJlIHdlIGNh biBnbyBmb3Igc29tZXRoaW5nIGluIGJldHdlZW4uIEhhdmUgZmVuY2VfY29sbGVjdGlvbl9pbml0 KCkKbmVlZCBhdCBsZWFzdCB0d28gZmVuY2VzIHRvIGNyZWF0ZSB0aGUgZmVuY2VfY29sbGVjdGlv bi4gVGhlbgpmZW5jZV9jb2xsZWN0aW9uX2FkZCgpIHdvdWxkIGFkZCBtb3JlIGRpbmFtaWNhbGx5 LgoKPiAKPiA+T3RoZXIgbml0cGljazogQWRkaW5nIHRoZSBjYWxsYmFjayBzaG91bGQgKEkgdGhp bmspIG9ubHkgYmUgZG9uZSBpbgo+ID4tPmVuYWJsZV9zaWduYWxsaW5nLgo+IAo+IFllYWgsIEkg d2FzIGFib3V0IHRvIGNvbXBsYWluIG9uIHRoYXQgYXMgd2VsbC4KPiAKPiBFbmFibGluZyBzaWdu YWxpbmcgY2FuIGhhdmUgYSBodWdlIG92ZXJoZWFkIGZvciBzb21lIGZlbmNlIGltcGxlbWVudGF0 aW9ucy4KPiBTbyBpdCBzaG91bGQgb25seSBiZSB1c2VkIHdoZW4gbmVlZGVkCgpSaWdodCwgdGhh dCBtYWtlcyBzZW5zZS4KCj4gCj4gPgo+ID5GaW5hbGx5OiBIYXZlIHlvdSBsb29rZWQgaW50byBz dGl0Y2hpbmcgdG9nZXRoZXIgYSBmZXcgdW5pdCB0ZXN0cyBmb3IKPiA+ZmVuY2VfY29sbGVjdGlv bj8KCk5vdCB5ZXQuIEl0IGlzIHNvbWV0aGluZyBJIHBsYW4gdG8gd29yayBzb29uLgoKPiA+Cj4g PkZlbmNlIGNvbGxlY3Rpb25zIGFsc28gYnJlYWsgdGhlIGFzc3VtcHRpb24gdGhhdCBldmVyeSBm ZW5jZSBpcyBvbiBhCj4gPnRpbWVsaW5lLiBmZW5jZV9sYXRlciBhbmQgZmVuY2VfaXNfbGF0ZXIg bmVlZCB0byBiZSBhZGp1c3RlZC4gV2UgYWxzbyBuZWVkCj4gPmEgc3BlY2lhbCBjb2xsZWN0aW9u IGNvbnRleHQgdG8gZmlsdGVyIHRoZXNlIG91dC4gVGhpcyBtZWFucwo+ID5mZW5jZV9jb2xsZWN0 aW9uIGlzbid0IHBlcmZlY3RseSBvcGFxdWUgYWJzdHJhY3Rpb24uCgpJJ2xsIGZpeCB0aGlzLgoK PiA+PisKPiA+PitzdHJ1Y3QgZmVuY2VfY29sbGVjdGlvbiAqZmVuY2VfY29sbGVjdGlvbl9pbml0 KGludCBudW1fZmVuY2VzKQo+ID4+K3sKPiA+PisJc3RydWN0IGZlbmNlX2NvbGxlY3Rpb24gKmNv bGxlY3Rpb247Cj4gPj4rCj4gPj4rCWNvbGxlY3Rpb24gPSBremFsbG9jKG9mZnNldG9mKHN0cnVj dCBmZW5jZV9jb2xsZWN0aW9uLAo+ID4+KwkJCQkgICAgICBmZW5jZXNbbnVtX2ZlbmNlc10pLCBH RlBfS0VSTkVMKTsKPiA+PisJaWYgKCFjb2xsZWN0aW9uKQo+ID4+KwkJcmV0dXJuIE5VTEw7Cj4g Pj4rCj4gPj4rCXNwaW5fbG9ja19pbml0KCZjb2xsZWN0aW9uLT5sb2NrKTsKPiA+PisJZmVuY2Vf aW5pdCgmY29sbGVjdGlvbi0+YmFzZSwgJmZlbmNlX2NvbGxlY3Rpb25fb3BzLCAmY29sbGVjdGlv bi0+bG9jaywKPiA+PisJCSAgIEZFTkNFX05PX0NPTlRFWFQsIDApOwo+ID4+Kwo+ID4+KwlyZXR1 cm4gY29sbGVjdGlvbjsKPiA+Pit9Cj4gPj4rRVhQT1JUX1NZTUJPTChmZW5jZV9jb2xsZWN0aW9u X2luaXQpOwo+ID4+Kwo+ID4+K3ZvaWQgZmVuY2VfY29sbGVjdGlvbl9wdXQoc3RydWN0IGZlbmNl X2NvbGxlY3Rpb24gKmNvbGxlY3Rpb24pCj4gPj4rewo+ID4+KwlmZW5jZV9wdXQoJmNvbGxlY3Rp b24tPmJhc2UpOwo+ID5Ob3Qgc3VyZSBhIHNwZWNpYWxpemVkIF9wdXQgZnVuY3Rpb24gaXMgdXNl ZnVsLCBJJ2QgbGVhdmUgaXQgb3V0LgoKSSd2ZSBhZGRlZCB0aGlzIHRvIGxldCB0aGUgdXNlciBv bmx5IGRlYWwgd2l0aCBmZW5jZV9jb2xsZWN0aW9uLCBidXQgCkknbSBmaW5lIGxlYXZpbmcgaXQg b3V0IHRvby4KCglHdXN0YXZvCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752251AbcDOS2Q (ORCPT ); Fri, 15 Apr 2016 14:28:16 -0400 Received: from mail-pa0-f45.google.com ([209.85.220.45]:33150 "EHLO mail-pa0-f45.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750873AbcDOS1x convert rfc822-to-8bit (ORCPT ); Fri, 15 Apr 2016 14:27:53 -0400 Date: Fri, 15 Apr 2016 11:27:50 -0700 From: Gustavo Padovan To: Christian =?iso-8859-1?Q?K=F6nig?= Cc: dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Rob Clark , Greg Hackmann , John Harrison , laurent.pinchart@ideasonboard.com, seanpaul@google.com, marcheu@google.com, m.chehab@samsung.com, Maarten Lankhorst , Gustavo Padovan Subject: Re: [RFC 1/8] dma-buf/fence: add fence_collection fences Message-ID: <20160415182750.GA23954@joana> Mail-Followup-To: Gustavo Padovan , Christian =?iso-8859-1?Q?K=F6nig?= , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Rob Clark , Greg Hackmann , John Harrison , laurent.pinchart@ideasonboard.com, seanpaul@google.com, marcheu@google.com, m.chehab@samsung.com, Maarten Lankhorst , Gustavo Padovan References: <1460683781-22535-1-git-send-email-gustavo@padovan.org> <1460683781-22535-2-git-send-email-gustavo@padovan.org> <20160415080254.GQ2510@phenom.ffwll.local> <5710AE61.9040308@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8BIT In-Reply-To: <5710AE61.9040308@amd.com> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 2016-04-15 Christian König : > Am 15.04.2016 um 10:02 schrieb Daniel Vetter: > >On Thu, Apr 14, 2016 at 06:29:34PM -0700, Gustavo Padovan wrote: > >>From: Gustavo Padovan > >> > >>struct fence_collection inherits from struct fence and carries a > >>collection of fences that needs to be waited together. > >> > >>It is useful to translate a sync_file to a fence to remove the complexity > >>of dealing with sync_files from DRM drivers. So even if there are many > >>fences in the sync_file that needs to waited for a commit to happen > >>drivers would only worry about a standard struct fence.That means that no > >>changes needed to any driver besides supporting fences. > >> > >>fence_collection's fence doesn't belong to any timeline context. > >> > >>Signed-off-by: Gustavo Padovan > >>--- > >> drivers/dma-buf/Makefile | 2 +- > >> drivers/dma-buf/fence-collection.c | 138 +++++++++++++++++++++++++++++++++++++ > >> drivers/dma-buf/fence.c | 2 +- > >> include/linux/fence-collection.h | 56 +++++++++++++++ > >> include/linux/fence.h | 2 + > >> 5 files changed, 198 insertions(+), 2 deletions(-) > >> create mode 100644 drivers/dma-buf/fence-collection.c > >> create mode 100644 include/linux/fence-collection.h > >> > >>diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile > >>index 43325a1..30b8464 100644 > >>--- a/drivers/dma-buf/Makefile > >>+++ b/drivers/dma-buf/Makefile > >>@@ -1,3 +1,3 @@ > >>-obj-y := dma-buf.o fence.o reservation.o seqno-fence.o > >>+obj-y := dma-buf.o fence.o reservation.o seqno-fence.o fence-collection.o > >> obj-$(CONFIG_SYNC_FILE) += sync_file.o sync_timeline.o sync_debug.o > >> obj-$(CONFIG_SW_SYNC) += sw_sync.o > >>diff --git a/drivers/dma-buf/fence-collection.c b/drivers/dma-buf/fence-collection.c > >>new file mode 100644 > >>index 0000000..8a4ecb0 > >>--- /dev/null > >>+++ b/drivers/dma-buf/fence-collection.c > >>@@ -0,0 +1,138 @@ > >>+/* > >>+ * fence-collection: aggregate fences to be waited together > >>+ * > >>+ * Copyright (C) 2016 Collabora Ltd > >>+ * Authors: > >>+ * Gustavo Padovan > >>+ * > >>+ * This program is free software; you can redistribute it and/or modify it > >>+ * under the terms of the GNU General Public License version 2 as published by > >>+ * the Free Software Foundation. > >>+ * > >>+ * This program is distributed in the hope that it will be useful, but WITHOUT > >>+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > >>+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > >>+ * more details. > >>+ */ > >>+ > >>+#include > >>+#include > >>+#include > >>+ > >>+static const char *fence_collection_get_driver_name(struct fence *fence) > >>+{ > >>+ struct fence_collection *collection = to_fence_collection(fence); > >>+ struct fence *f = collection->fences[0].fence; > >>+ > >>+ return f->ops->get_driver_name(fence); > >>+} > > I would rather return some constant name here instead of relying that the > collection already has a fence added and that all fences are from the same > driver. If we merge _init and _add this will not be a problem anymore and we can return the actual driver name. > > >>+ > >>+static const char *fence_collection_get_timeline_name(struct fence *fence) > >>+{ > >>+ return "no context"; > >>+} > >>+ > >>+static bool fence_collection_enable_signaling(struct fence *fence) > >>+{ > >>+ struct fence_collection *collection = to_fence_collection(fence); > >>+ > >>+ return atomic_read(&collection->num_pending_fences); > >>+} > >>+ > >>+static bool fence_collection_signaled(struct fence *fence) > >>+{ > >>+ struct fence_collection *collection = to_fence_collection(fence); > >>+ > >>+ return (atomic_read(&collection->num_pending_fences) == 0); > >>+} > >>+ > >>+static void fence_collection_release(struct fence *fence) > >>+{ > >>+ struct fence_collection *collection = to_fence_collection(fence); > >>+ int i; > >>+ > >>+ for (i = 0 ; i < collection->num_fences ; i++) { > >>+ fence_remove_callback(collection->fences[i].fence, > >>+ &collection->fences[i].cb); > >>+ fence_put(collection->fences[i].fence); > >>+ } > >>+ > >>+ fence_free(fence); > >>+} > >>+ > >>+static signed long fence_collection_wait(struct fence *fence, bool intr, > >>+ signed long timeout) > >>+{ > >>+ struct fence_collection *collection = to_fence_collection(fence); > >>+ int i; > >>+ > >>+ for (i = 0 ; i < collection->num_fences ; i++) { > >>+ timeout = fence_wait(collection->fences[i].fence, intr); > >>+ if (timeout < 0) > >>+ return timeout; > >>+ } > >>+ > >>+ return timeout; > >>+} > >>+ > >>+static const struct fence_ops fence_collection_ops = { > >>+ .get_driver_name = fence_collection_get_driver_name, > >>+ .get_timeline_name = fence_collection_get_timeline_name, > >>+ .enable_signaling = fence_collection_enable_signaling, > >>+ .signaled = fence_collection_signaled, > >>+ .wait = fence_collection_wait, > >>+ .release = fence_collection_release, > >>+}; > >>+ > >>+static void collection_check_cb_func(struct fence *fence, struct fence_cb *cb) > >>+{ > >>+ struct fence_collection_cb *f_cb; > >>+ struct fence_collection *collection; > >>+ > >>+ f_cb = container_of(cb, struct fence_collection_cb, cb); > >>+ collection = f_cb->collection; > >>+ > >>+ if (atomic_dec_and_test(&collection->num_pending_fences)) > >>+ fence_signal(&collection->base); > >>+} > >>+ > >>+void fence_collection_add(struct fence_collection *collection, > >>+ struct fence *fence) > >>+{ > >>+ int n = collection->num_fences; > >>+ > >>+ collection->fences[n].collection = collection; > >>+ collection->fences[n].fence = fence; > >>+ > >>+ if (fence_add_callback(fence, &collection->fences[n].cb, > >>+ collection_check_cb_func)) > >>+ return; > >>+ > >>+ fence_get(fence); > >>+ > >>+ collection->num_fences++; > >>+ atomic_inc(&collection->num_pending_fences); > >>+} > >For the interface I think we should not split it into _init and _add - it > >shouldn't be allowed to change a collection once it's created. So probably > >cleaner if we add an array of fence pointers to _init. > > Amdgpu also has an implementation for a fence collection which uses a a > hashtable to keep the fences grouped by context (e.g. only the latest fence > is keept for each context). See amdgpu_sync.c for reference. > > We should either make the collection similar in a way that you can add as > many fences as you want (like the amdgpu implementation) or make it static > and only add a fixed number of fences right from the beginning. > > I can certainly see use cases for both, but if you want to stick with a > static approach you should probably call the new object fence_array instead > of fence_collection and do as Daniel suggested. Maybe we can go for something in between. Have fence_collection_init() need at least two fences to create the fence_collection. Then fence_collection_add() would add more dinamically. > > >Other nitpick: Adding the callback should (I think) only be done in > >->enable_signalling. > > Yeah, I was about to complain on that as well. > > Enabling signaling can have a huge overhead for some fence implementations. > So it should only be used when needed Right, that makes sense. > > > > >Finally: Have you looked into stitching together a few unit tests for > >fence_collection? Not yet. It is something I plan to work soon. > > > >Fence collections also break the assumption that every fence is on a > >timeline. fence_later and fence_is_later need to be adjusted. We also need > >a special collection context to filter these out. This means > >fence_collection isn't perfectly opaque abstraction. I'll fix this. > >>+ > >>+struct fence_collection *fence_collection_init(int num_fences) > >>+{ > >>+ struct fence_collection *collection; > >>+ > >>+ collection = kzalloc(offsetof(struct fence_collection, > >>+ fences[num_fences]), GFP_KERNEL); > >>+ if (!collection) > >>+ return NULL; > >>+ > >>+ spin_lock_init(&collection->lock); > >>+ fence_init(&collection->base, &fence_collection_ops, &collection->lock, > >>+ FENCE_NO_CONTEXT, 0); > >>+ > >>+ return collection; > >>+} > >>+EXPORT_SYMBOL(fence_collection_init); > >>+ > >>+void fence_collection_put(struct fence_collection *collection) > >>+{ > >>+ fence_put(&collection->base); > >Not sure a specialized _put function is useful, I'd leave it out. I've added this to let the user only deal with fence_collection, but I'm fine leaving it out too. Gustavo