From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: Re: [RFC v2 8/8] drm/fence: add out-fences support Date: Thu, 28 Apr 2016 12:23:46 -0300 Message-ID: <20160428152346.GC3496@joana> References: <1461623608-29538-1-git-send-email-gustavo@padovan.org> <1461623608-29538-9-git-send-email-gustavo@padovan.org> <20160426145305.GY8291@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-yw0-f195.google.com (mail-yw0-f195.google.com [209.85.161.195]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1C7A86ED6B for ; Thu, 28 Apr 2016 15:23:54 +0000 (UTC) Received: by mail-yw0-f195.google.com with SMTP id v81so5556582ywa.2 for ; Thu, 28 Apr 2016 08:23:54 -0700 (PDT) Content-Disposition: inline In-Reply-To: <20160426145305.GY8291@phenom.ffwll.local> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Greg Kroah-Hartman , linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, dri-devel@lists.freedesktop.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Sumit Semwal , Gustavo Padovan List-Id: dri-devel@lists.freedesktop.org MjAxNi0wNC0yNiBEYW5pZWwgVmV0dGVyIDxkYW5pZWxAZmZ3bGwuY2g+OgoKPiBPbiBNb24sIEFw ciAyNSwgMjAxNiBhdCAwNzozMzoyOFBNIC0wMzAwLCBHdXN0YXZvIFBhZG92YW4gd3JvdGU6Cj4g PiBGcm9tOiBHdXN0YXZvIFBhZG92YW4gPGd1c3Rhdm8ucGFkb3ZhbkBjb2xsYWJvcmEuY28udWs+ Cj4gPiAKPiA+IFN1cHBvcnQgRFJNIG91dC1mZW5jZXMgY3JlYXRpbmcgYSBzeW5jX2ZpbGUgd2l0 aCBhIGZlbmNlIGZvciBlYWNoIGNydGMKPiA+IHVwZGF0ZSB3aXRoIHRoZSBEUk1fTU9ERV9BVE9N SUNfT1VUX0ZFTkNFIGZsYWcuCj4gPiAKPiA+IFdlIHRoZW4gc2VuZCBhbiBzdHJ1Y3QgZHJtX291 dF9mZW5jZXMgYXJyYXkgd2l0aCB0aGUgb3V0LWZlbmNlcyBmZHMgYmFjayBpbgo+ID4gdGhlIGRy bV9hdG9taWNfaW9jdGwoKSBhcyBhbiBvdXQgYXJnIGluIHRoZSBvdXRfZmVuY2VzX3B0ciBmaWVs ZC4KPiA+IAo+ID4gc3RydWN0IGRybV9vdXRfZmVuY2VzIHsKPiA+IAlfX3UzMiAgIGNydGNfaWQ7 Cj4gPiAJX191MzIgICBmZDsKPiA+IH07Cj4gPiAKPiA+IHYyOiBDb21tZW50IGJ5IFJvYiBDbGFy azoKPiA+IAktIFNxdWFzaCBjb21taXQgdGhhdCBhZGRzIERSTV9NT0RFX0FUT01JQ19PVVRfRkVO Q0UgZmxhZyBoZXJlLgo+ID4gCj4gPiAgICAgQ29tbWVudCBieSBEYW5pZWwgVmV0dGVyOgo+ID4g CS0gQWRkIGNsZWFuIHVwIGNvZGUgZm9yIG91dF9mZW5jZXMKPiA+IAo+ID4gU2lnbmVkLW9mZi1i eTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgo+ID4g LS0tCj4gPiAgZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyB8IDE2MyArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCj4gPiAgaW5jbHVkZS9kcm0vZHJtX2NydGMu aCAgICAgICB8ICAxMCArKysKPiA+ICBpbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmggIHwgIDEx ICsrLQo+ID4gIDMgZmlsZXMgY2hhbmdlZCwgMTc5IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25z KC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jIGIv ZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+ID4gaW5kZXggNWY5ZDQzNC4uMDZjNjAwNyAx MDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKPiA+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKPiA+IEBAIC0xNTY2LDYgKzE1NjYsMTMzIEBAIHZv aWQgZHJtX2F0b21pY19jbGVhbl9vbGRfZmIoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiA+ICB9 Cj4gPiAgRVhQT1JUX1NZTUJPTChkcm1fYXRvbWljX2NsZWFuX29sZF9mYik7Cj4gPiAgCj4gPiAr c3RhdGljIHN0cnVjdCBkcm1fb3V0X2ZlbmNlX3N0YXRlICpnZXRfb3V0X2ZlbmNlKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsCj4gPiArCQkJCQkJIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0 ZSwKPiA+ICsJCQkJCQkgdWludDMyX3QgX191c2VyICpvdXRfZmVuY2VzX3B0ciwKPiA+ICsJCQkJ CQkgdWludDY0X3QgY291bnRfb3V0X2ZlbmNlcywKPiA+ICsJCQkJCQkgdWludDY0X3QgdXNlcl9k YXRhKQo+ID4gK3sKPiA+ICsJc3RydWN0IGRybV9jcnRjICpjcnRjOwo+ID4gKwlzdHJ1Y3QgZHJt X2NydGNfc3RhdGUgKmNydGNfc3RhdGU7Cj4gPiArCXN0cnVjdCBkcm1fb3V0X2ZlbmNlcyAqb3V0 X2ZlbmNlczsKPiA+ICsJc3RydWN0IGRybV9vdXRfZmVuY2Vfc3RhdGUgKmZlbmNlX3N0YXRlOwo+ ID4gKwlpbnQgbnVtX2ZlbmNlcyA9IDA7Cj4gPiArCWludCBpLCByZXQ7Cj4gPiArCj4gPiArCWlm IChjb3VudF9vdXRfZmVuY2VzID4gZGV2LT5tb2RlX2NvbmZpZy5udW1fY3J0YykKPiA+ICsJCXJl dHVybiBFUlJfUFRSKC1FSU5WQUwpOwo+ID4gKwo+ID4gKwlvdXRfZmVuY2VzID0ga2NhbGxvYyhj b3VudF9vdXRfZmVuY2VzLCBzaXplb2YoKm91dF9mZW5jZXMpLAo+ID4gKwkJCSAgICAgR0ZQX0tF Uk5FTCk7Cj4gPiArCWlmICghb3V0X2ZlbmNlcykKPiA+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9N RU0pOwo+IAo+IEEgYml0IHRyaWNreSwgYnV0IHRoZSBhYm92ZSBrY2FsbG9jIGlzIHRoZSBvbmx5 IHRoaW5nIHRoYXQgY2F0Y2hlcyBpbnRlZ2VyCj4gb3ZlcmZsb3dzIGluIGNvdW50X291dF9mZW5j ZXMuIE5lZWRzIGEgY29tbWVudCBpbW8gc2luY2UgdGhpcyBjb3VsZCBiZSBhCj4gc2VjdXJpdHkg ZXhwbG9pdCBpZiB3ZSBhY2NpZGVudGFsbHkgc2NyZXcgaXQgdXAuCgpUaGUgY2hlY2sgYWJvdmUg bWFrZXMgc3VyZSB0aGF0IGNvdW50X291dF9mZW5jZXMgaXMgbm90IGJpZ2dlciB0aGFuCm51bV9j cnRjLiBEb24ndCB0aGF0IGZpeCB0aGlzPwoKPiAKPiBBbHNvIG5lZWRzIGEgdGVzdGNhc2UgaW1v Lgo+IAo+ID4gKwo+ID4gKwlmZW5jZV9zdGF0ZSA9IGtjYWxsb2MoY291bnRfb3V0X2ZlbmNlcywg c2l6ZW9mKCpmZW5jZV9zdGF0ZSksCj4gPiArCQkJICAgICBHRlBfS0VSTkVMKTsKPiA+ICsJaWYg KCFmZW5jZV9zdGF0ZSkgewo+ID4gKwkJa2ZyZWUob3V0X2ZlbmNlcyk7Cj4gPiArCQlyZXR1cm4g RVJSX1BUUigtRU5PTUVNKTsKPiA+ICsJfQo+ID4gKwo+ID4gKwlmb3IgKGkgPSAwIDsgaSA8IGNv dW50X291dF9mZW5jZXMgOyBpKyspCj4gPiArCQlmZW5jZV9zdGF0ZVtpXS5mZCA9IC0xOwo+ID4g Kwo+ID4gKwlmb3JfZWFjaF9jcnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBjcnRjX3N0YXRlLCBp KSB7Cj4gPiArCQlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJsYW5rX2V2ZW50ICplOwo+ID4gKwkJc3Ry dWN0IGZlbmNlICpmZW5jZTsKPiA+ICsJCWNoYXIgbmFtZVszMl07Cj4gPiArCj4gPiArCQlmZW5j ZSA9IGt6YWxsb2Moc2l6ZW9mKCpmZW5jZSksIEdGUF9LRVJORUwpOwo+ID4gKwkJaWYgKCFmZW5j ZSkgewo+ID4gKwkJCXJldCA9IC1FTk9NRU07Cj4gPiArCQkJZ290byBvdXQ7Cj4gPiArCQl9Cj4g PiArCj4gPiArCQlmZW5jZV9pbml0KGZlbmNlLCAmZHJtX2NydGNfZmVuY2Vfb3BzLCAmY3J0Yy0+ ZmVuY2VfbG9jaywKPiA+ICsJCQkgICBjcnRjLT5mZW5jZV9jb250ZXh0LCBjcnRjLT5mZW5jZV9z ZXFubyk7Cj4gPiArCj4gPiArCQlzbnByaW50ZihuYW1lLCBzaXplb2YobmFtZSksICJjcnRjLSVk XyVsdSIsCj4gPiArCQkJIGRybV9jcnRjX2luZGV4KGNydGMpLCBjcnRjLT5mZW5jZV9zZXFubysr KTsKPiAKPiBIbSAuLi4gZmVuY2VfaW5pdF93aXRoX25hbWU/IEknbSBraW5kYSBjb25mdXNlZCB3 aHkgd2Ugb25seSBuYW1lIGZlbmNlcwo+IHRoYXQgYXJlIGV4cG9ydGVkIHRob3VnaCwgYW5kIHdo eSBub3QgYWxsIG9mIHRoZW0uIERlYnVnZ2luZyBmZW5jZQo+IGRlYWRsb2NrcyBpcyByZWFsIGhh cmQsIHNvIGdpdmluZyB0aGVtIGFsbCBuYW1lcyBtaWdodCBiZSBhIGdvb2QgaWRlYS4KPiAKPiBB bnl3YXksIHNlZW1zIGxpa2UgbW9yZSByb29tIGZvciBhIGJpdCBtb3JlIHN5bmNfZmlsZS9zdHJ1 Y3QgZmVuY2UKPiBtZXJnaW5nLgoKV2UganVzdCByZW1vdmVkIG5hbWUgZnJvbSBzeW5jX2ZpbGVf Y3JlYXRlKCkgc28gc25wcmludGYoKSBpcyBub3QgZXZlbgpuZWNlc3NhcnkgaGVyZSBhbnltb3Jl LgoKPiAKPiA+ICsKPiA+ICsJCWZlbmNlX3N0YXRlW2ldLmZkID0gZ2V0X3VudXNlZF9mZF9mbGFn cyhPX0NMT0VYRUMpOwo+ID4gKwkJaWYgKGZlbmNlX3N0YXRlW2ldLmZkIDwgMCkgewo+ID4gKwkJ CWZlbmNlX3B1dChmZW5jZSk7Cj4gPiArCQkJcmV0ID0gZmVuY2Vfc3RhdGVbaV0uZmQ7Cj4gPiAr CQkJZ290byBvdXQ7Cj4gPiArCQl9Cj4gPiArCj4gPiArCQlmZW5jZV9zdGF0ZVtpXS5zeW5jX2Zp bGUgPSBzeW5jX2ZpbGVfY3JlYXRlKG5hbWUsIGZlbmNlKTsKPiA+ICsJCWlmKCFmZW5jZV9zdGF0 ZVtpXS5zeW5jX2ZpbGUpIHsKPiA+ICsJCQlmZW5jZV9wdXQoZmVuY2UpOwo+ID4gKwkJCXJldCA9 IC1FTk9NRU07Cj4gPiArCQkJZ290byBvdXQ7Cj4gPiArCQl9Cj4gPiArCj4gPiArCQlpZiAoY3J0 Y19zdGF0ZS0+ZXZlbnQpIHsKPiA+ICsJCQljcnRjX3N0YXRlLT5ldmVudC0+YmFzZS5mZW5jZSA9 IGZlbmNlOwo+ID4gKwkJfSBlbHNlIHsKPiAKPiBUaGlzIGxvb2tzIGEgYml0IGZ1bm55IC0gSSdk IGNoYW5nZSB0aGUgY3JlYXRlIGV2ZW50IGxvZ2ljIHRvIGNyZWF0ZSBhbgo+IGV2ZW50IGVpdGhl ciBpZiB3ZSBoYXZlIHRoZSBlaXRoZXIgZHJtIGV2ZW50IG9yIG91dC1mZW5jZSBmbGFnIHNldC4K Ck9rLgoKPiAKPiA+ICsJCQllID0gY3JlYXRlX3ZibGFua19ldmVudChkZXYsIE5VTEwsIGZlbmNl LCB1c2VyX2RhdGEpOwo+ID4gKwkJCWlmICghZSkgewo+ID4gKwkJCQlyZXQgPSAtRU5PTUVNOwo+ ID4gKwkJCQlnb3RvIG91dDsKPiA+ICsJCQl9Cj4gPiArCj4gPiArCQkJY3J0Y19zdGF0ZS0+ZXZl bnQgPSBlOwo+ID4gKwkJfQo+ID4gKwo+ID4gKwkJb3V0X2ZlbmNlc1tudW1fZmVuY2VzXS5jcnRj X2lkID0gY3J0Yy0+YmFzZS5pZDsKPiA+ICsJCW91dF9mZW5jZXNbbnVtX2ZlbmNlc10uZmQgPSBm ZW5jZV9zdGF0ZVtpXS5mZDsKPiA+ICsJCW51bV9mZW5jZXMrKzsKPiA+ICsJfQo+ID4gKwo+ID4g KwlpZiAoY29weV90b191c2VyKG91dF9mZW5jZXNfcHRyLCBvdXRfZmVuY2VzLAo+ID4gKwkJCSBu dW1fZmVuY2VzICogc2l6ZW9mKCpvdXRfZmVuY2VzKSkpIHsKPiA+ICsJCXJldCA9IC1FRkFVTFQ7 Cj4gPiArCQlnb3RvIG91dDsKPiA+ICsJfQo+ID4gKwo+ID4gKwlrZnJlZShvdXRfZmVuY2VzKTsK PiA+ICsKPiA+ICsJcmV0dXJuIGZlbmNlX3N0YXRlOwo+ID4gKwo+ID4gK291dDoKPiA+ICsJZm9y IChpID0gMCA7IGkgPCBjb3VudF9vdXRfZmVuY2VzIDsgaSsrKSB7Cj4gPiArCQlpZiAoZmVuY2Vf c3RhdGVbaV0uc3luY19maWxlKQo+ID4gKwkJCXN5bmNfZmlsZV9wdXQoZmVuY2Vfc3RhdGVbaV0u c3luY19maWxlKTsKPiA+ICsJCWlmIChmZW5jZV9zdGF0ZVtpXS5mZCA+PSAwKQo+ID4gKwkJCXB1 dF91bnVzZWRfZmQoZmVuY2Vfc3RhdGVbaV0uZmQpOwo+ID4gKwl9Cj4gPiArCj4gPiArCWtmcmVl KGZlbmNlX3N0YXRlKTsKPiA+ICsJa2ZyZWUob3V0X2ZlbmNlcyk7Cj4gPiArCj4gPiArCXJldHVy biBFUlJfUFRSKHJldCk7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkIGluc3RhbGxfb3V0 X2ZlbmNlKHVpbnQ2NF90IGNvdW50X291dF9mZW5jZXMsCj4gPiArCQkJICAgICAgc3RydWN0IGRy bV9vdXRfZmVuY2Vfc3RhdGUgKnN0YXRlKQo+ID4gK3sKPiA+ICsJaW50IGk7Cj4gPiArCj4gPiAr CWZvciAoaSA9IDAgOyBpIDwgY291bnRfb3V0X2ZlbmNlcyA7IGkrKykgewo+ID4gKwkJaWYgKHN0 YXRlW2ldLnN5bmNfZmlsZSkKPiA+ICsJCQlzeW5jX2ZpbGVfaW5zdGFsbChzdGF0ZVtpXS5zeW5j X2ZpbGUsIHN0YXRlW2ldLmZkKTsKPiAKPiBJcyBzeW5jX2ZpbGVfaW5zdGFsbCBhbnl0aGluZyBt b3JlIHRoYW4gZmRfaW5zdGFsbD8gSW1vIGEgd3JhcHBlciBmb3IKPiBqdXN0IHRoYXQgZnVuY3Rp b24gaXMgb3ZlcmtpbGwgYW5kIGp1c3QgaGlkZXMgc3R1ZmYuIEknZCBudWtlIGl0IChhbm90aGVy Cj4gc3luY19maWxlIHBhdGNoIHRob3VnaCkuIEluIGRtYS1idWYgd2UgYWxzbyBkb24ndCB3cmFw IGl0LCB3ZSBvbmx5IGhhdmUgYQo+IGNvbnZlbmllbmNlIHdyYXBwZXIgZm9yIHVzZXJzIHdobyB3 YW50IHRvIGNvbWJpbmUgdGhlCj4gZ2V0X3VudXNlZF9mbGFncytmZF9pbnN0YWxsIGluIG9uZSBn by4gQW5kIG1heWJlIGV2ZW4gdGhhdCBpcyBzaWxseS4KPiAKPiBPaywgSSB1bmxhemllZCBhbmQg aXQncyBpbmRlZWQganVzdCBhIHNpbGx5IHdyYXBwZXIuIFBsZWFzZSBudWtlIGl0LgoKYWxyZWFk eSBmaXhlZCBpbiB0aGUgc3luYyBmaWxlIGRlLXN0YWdlIHBhdGNoZXMuCgo+IAo+ID4gKwl9Cj4g PiArfQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkIHJlbGVhc2Vfb3V0X2ZlbmNlKHVpbnQ2NF90IGNv dW50X291dF9mZW5jZXMsCj4gPiArCQkJICAgICAgc3RydWN0IGRybV9vdXRfZmVuY2Vfc3RhdGUg KnN0YXRlKQo+ID4gK3sKPiA+ICsJaW50IGk7Cj4gPiArCj4gPiArCWZvciAoaSA9IDAgOyBpIDwg Y291bnRfb3V0X2ZlbmNlcyA7IGkrKykgewo+ID4gKwkJaWYgKHN0YXRlLT5zeW5jX2ZpbGUpCj4g PiArCQkJc3luY19maWxlX3B1dChzdGF0ZS0+c3luY19maWxlKTsKPiA+ICsJCWlmIChzdGF0ZS0+ ZmQgPj0gMCkKPiA+ICsJCQlwdXRfdW51c2VkX2ZkKHN0YXRlLT5mZCk7Cj4gPiArCX0KPiA+ICt9 Cj4gPiArCj4gPiAgaW50IGRybV9tb2RlX2F0b21pY19pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LAo+ID4gIAkJCSAgdm9pZCAqZGF0YSwgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYpCj4g PiAgewo+ID4gQEAgLTE1NzQsMTIgKzE3MDEsMTQgQEAgaW50IGRybV9tb2RlX2F0b21pY19pb2N0 bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ID4gIAl1aW50MzJfdCBfX3VzZXIgKmNvdW50X3By b3BzX3B0ciA9ICh1aW50MzJfdCBfX3VzZXIgKikodW5zaWduZWQgbG9uZykoYXJnLT5jb3VudF9w cm9wc19wdHIpOwo+ID4gIAl1aW50MzJfdCBfX3VzZXIgKnByb3BzX3B0ciA9ICh1aW50MzJfdCBf X3VzZXIgKikodW5zaWduZWQgbG9uZykoYXJnLT5wcm9wc19wdHIpOwo+ID4gIAl1aW50NjRfdCBf X3VzZXIgKnByb3BfdmFsdWVzX3B0ciA9ICh1aW50NjRfdCBfX3VzZXIgKikodW5zaWduZWQgbG9u ZykoYXJnLT5wcm9wX3ZhbHVlc19wdHIpOwo+ID4gKwl1aW50MzJfdCBfX3VzZXIgKm91dF9mZW5j ZXNfcHRyID0gKHVpbnQzMl90IF9fdXNlciAqKSh1bnNpZ25lZCBsb25nKShhcmctPm91dF9mZW5j ZXNfcHRyKTsKPiA+ICAJdW5zaWduZWQgaW50IGNvcGllZF9vYmpzLCBjb3BpZWRfcHJvcHM7Cj4g PiAgCXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZTsKPiA+ICAJc3RydWN0IGRybV9tb2Rl c2V0X2FjcXVpcmVfY3R4IGN0eDsKPiA+ICAJc3RydWN0IGRybV9wbGFuZSAqcGxhbmU7Cj4gPiAg CXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKPiA+ICAJc3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRj X3N0YXRlOwo+ID4gKwlzdHJ1Y3QgZHJtX291dF9mZW5jZV9zdGF0ZSAqZmVuY2Vfc3RhdGUgPSBO VUxMOwo+ID4gIAl1bnNpZ25lZCBwbGFuZV9tYXNrOwo+ID4gIAlpbnQgcmV0ID0gMDsKPiA+ICAJ dW5zaWduZWQgaW50IGksIGo7Cj4gPiBAQCAtMTYwNSw5ICsxNzM0LDEzIEBAIGludCBkcm1fbW9k ZV9hdG9taWNfaW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiA+ICAJCQkhZGV2LT5tb2Rl X2NvbmZpZy5hc3luY19wYWdlX2ZsaXApCj4gPiAgCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICAKPiA+ ICsJaWYgKChhcmctPmZsYWdzICYgRFJNX01PREVfQVRPTUlDX09VVF9GRU5DRSkgJiYgIWFyZy0+ Y291bnRfb3V0X2ZlbmNlcykKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+IAo+IFdlIG5lZWQgdGVz dGNhc2VzIHdoaWNoIGNoZWNrIHRoYXQgYXJnLT5jb3VudF9vdXRfZmVuY2VzIGFuZAo+IGFyZy0+ b3V0X2ZlbmNlcyBhcmUgMCB3aGVuIHRoZSBPVVRfRkVOQ0UgZmxhZyBpcyBub3Qgc2V0Lgo+IAo+ IERlZmluaXRlbHkgbmVlZHMgYW4gaWd0IHRlc3RjYXNlIGZvciB0aGlzIGludmFsaWQgaW5wdXQg Y2FzZS4gT2ZjIHdlIGFsc28KPiBuZWVkIHRlc3RzIHRoYXQgZ2l2ZSB0aGUga2VybmVsIG5vbnNl bnMgaW4gY291bnRfb3V0X2ZlbmNlcyBhbmQgb3V0X2ZlbmNlcwo+IHdpdGggdGhlIGZsYWcgc2V0 Lgo+IAo+ID4gKwo+ID4gIAkvKiBjYW4ndCB0ZXN0IGFuZCBleHBlY3QgYW4gZXZlbnQgYXQgdGhl IHNhbWUgdGltZS4gKi8KPiA+ICAJaWYgKChhcmctPmZsYWdzICYgRFJNX01PREVfQVRPTUlDX1RF U1RfT05MWSkgJiYKPiA+IC0JCQkoYXJnLT5mbGFncyAmIERSTV9NT0RFX1BBR0VfRkxJUF9FVkVO VCkpCj4gPiArCQkJKGFyZy0+ZmxhZ3MgJiAoRFJNX01PREVfUEFHRV9GTElQX0VWRU5UCj4gPiAr CQkJIHwgRFJNX01PREVfQVRPTUlDX09VVF9GRU5DRSkpKQo+IAo+IElmIHlvdSBnbyB3aXRoIG15 IHN1Z2dlc3Rpb24gYWJvdmUgdG8gY3JlYXRlIHRoZSBldmVudCBpZiBlaXRoZXIgaXMgc2V0LAo+ IG1heWJlIGEgRFJNX01PREVfQVRPTUlDX0VWRU5UX01BU0sgd2l0aCBib3RoPyBXb3VsZCByZWFk IGVhc2llci4KCk9rLgoKR3VzdGF2bwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVl ZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753077AbcD1PXz (ORCPT ); Thu, 28 Apr 2016 11:23:55 -0400 Received: from mail-yw0-f196.google.com ([209.85.161.196]:34817 "EHLO mail-yw0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752755AbcD1PXx (ORCPT ); Thu, 28 Apr 2016 11:23:53 -0400 Date: Thu, 28 Apr 2016 12:23:46 -0300 From: Gustavo Padovan To: Greg Kroah-Hartman , linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, dri-devel@lists.freedesktop.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Sumit Semwal , Gustavo Padovan Subject: Re: [RFC v2 8/8] drm/fence: add out-fences support Message-ID: <20160428152346.GC3496@joana> Mail-Followup-To: Gustavo Padovan , Greg Kroah-Hartman , linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, dri-devel@lists.freedesktop.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Sumit Semwal , Gustavo Padovan References: <1461623608-29538-1-git-send-email-gustavo@padovan.org> <1461623608-29538-9-git-send-email-gustavo@padovan.org> <20160426145305.GY8291@phenom.ffwll.local> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20160426145305.GY8291@phenom.ffwll.local> 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-26 Daniel Vetter : > On Mon, Apr 25, 2016 at 07:33:28PM -0300, Gustavo Padovan wrote: > > From: Gustavo Padovan > > > > Support DRM out-fences creating a sync_file with a fence for each crtc > > update with the DRM_MODE_ATOMIC_OUT_FENCE flag. > > > > We then send an struct drm_out_fences array with the out-fences fds back in > > the drm_atomic_ioctl() as an out arg in the out_fences_ptr field. > > > > struct drm_out_fences { > > __u32 crtc_id; > > __u32 fd; > > }; > > > > v2: Comment by Rob Clark: > > - Squash commit that adds DRM_MODE_ATOMIC_OUT_FENCE flag here. > > > > Comment by Daniel Vetter: > > - Add clean up code for out_fences > > > > Signed-off-by: Gustavo Padovan > > --- > > drivers/gpu/drm/drm_atomic.c | 163 +++++++++++++++++++++++++++++++++++++++++-- > > include/drm/drm_crtc.h | 10 +++ > > include/uapi/drm/drm_mode.h | 11 ++- > > 3 files changed, 179 insertions(+), 5 deletions(-) > > > > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > > index 5f9d434..06c6007 100644 > > --- a/drivers/gpu/drm/drm_atomic.c > > +++ b/drivers/gpu/drm/drm_atomic.c > > @@ -1566,6 +1566,133 @@ void drm_atomic_clean_old_fb(struct drm_device *dev, > > } > > EXPORT_SYMBOL(drm_atomic_clean_old_fb); > > > > +static struct drm_out_fence_state *get_out_fence(struct drm_device *dev, > > + struct drm_atomic_state *state, > > + uint32_t __user *out_fences_ptr, > > + uint64_t count_out_fences, > > + uint64_t user_data) > > +{ > > + struct drm_crtc *crtc; > > + struct drm_crtc_state *crtc_state; > > + struct drm_out_fences *out_fences; > > + struct drm_out_fence_state *fence_state; > > + int num_fences = 0; > > + int i, ret; > > + > > + if (count_out_fences > dev->mode_config.num_crtc) > > + return ERR_PTR(-EINVAL); > > + > > + out_fences = kcalloc(count_out_fences, sizeof(*out_fences), > > + GFP_KERNEL); > > + if (!out_fences) > > + return ERR_PTR(-ENOMEM); > > A bit tricky, but the above kcalloc is the only thing that catches integer > overflows in count_out_fences. Needs a comment imo since this could be a > security exploit if we accidentally screw it up. The check above makes sure that count_out_fences is not bigger than num_crtc. Don't that fix this? > > Also needs a testcase imo. > > > + > > + fence_state = kcalloc(count_out_fences, sizeof(*fence_state), > > + GFP_KERNEL); > > + if (!fence_state) { > > + kfree(out_fences); > > + return ERR_PTR(-ENOMEM); > > + } > > + > > + for (i = 0 ; i < count_out_fences ; i++) > > + fence_state[i].fd = -1; > > + > > + for_each_crtc_in_state(state, crtc, crtc_state, i) { > > + struct drm_pending_vblank_event *e; > > + struct fence *fence; > > + char name[32]; > > + > > + fence = kzalloc(sizeof(*fence), GFP_KERNEL); > > + if (!fence) { > > + ret = -ENOMEM; > > + goto out; > > + } > > + > > + fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock, > > + crtc->fence_context, crtc->fence_seqno); > > + > > + snprintf(name, sizeof(name), "crtc-%d_%lu", > > + drm_crtc_index(crtc), crtc->fence_seqno++); > > Hm ... fence_init_with_name? I'm kinda confused why we only name fences > that are exported though, and why not all of them. Debugging fence > deadlocks is real hard, so giving them all names might be a good idea. > > Anyway, seems like more room for a bit more sync_file/struct fence > merging. We just removed name from sync_file_create() so snprintf() is not even necessary here anymore. > > > + > > + fence_state[i].fd = get_unused_fd_flags(O_CLOEXEC); > > + if (fence_state[i].fd < 0) { > > + fence_put(fence); > > + ret = fence_state[i].fd; > > + goto out; > > + } > > + > > + fence_state[i].sync_file = sync_file_create(name, fence); > > + if(!fence_state[i].sync_file) { > > + fence_put(fence); > > + ret = -ENOMEM; > > + goto out; > > + } > > + > > + if (crtc_state->event) { > > + crtc_state->event->base.fence = fence; > > + } else { > > This looks a bit funny - I'd change the create event logic to create an > event either if we have the either drm event or out-fence flag set. Ok. > > > + e = create_vblank_event(dev, NULL, fence, user_data); > > + if (!e) { > > + ret = -ENOMEM; > > + goto out; > > + } > > + > > + crtc_state->event = e; > > + } > > + > > + out_fences[num_fences].crtc_id = crtc->base.id; > > + out_fences[num_fences].fd = fence_state[i].fd; > > + num_fences++; > > + } > > + > > + if (copy_to_user(out_fences_ptr, out_fences, > > + num_fences * sizeof(*out_fences))) { > > + ret = -EFAULT; > > + goto out; > > + } > > + > > + kfree(out_fences); > > + > > + return fence_state; > > + > > +out: > > + for (i = 0 ; i < count_out_fences ; i++) { > > + if (fence_state[i].sync_file) > > + sync_file_put(fence_state[i].sync_file); > > + if (fence_state[i].fd >= 0) > > + put_unused_fd(fence_state[i].fd); > > + } > > + > > + kfree(fence_state); > > + kfree(out_fences); > > + > > + return ERR_PTR(ret); > > +} > > + > > +static void install_out_fence(uint64_t count_out_fences, > > + struct drm_out_fence_state *state) > > +{ > > + int i; > > + > > + for (i = 0 ; i < count_out_fences ; i++) { > > + if (state[i].sync_file) > > + sync_file_install(state[i].sync_file, state[i].fd); > > Is sync_file_install anything more than fd_install? Imo a wrapper for > just that function is overkill and just hides stuff. I'd nuke it (another > sync_file patch though). In dma-buf we also don't wrap it, we only have a > convenience wrapper for users who want to combine the > get_unused_flags+fd_install in one go. And maybe even that is silly. > > Ok, I unlazied and it's indeed just a silly wrapper. Please nuke it. already fixed in the sync file de-stage patches. > > > + } > > +} > > + > > +static void release_out_fence(uint64_t count_out_fences, > > + struct drm_out_fence_state *state) > > +{ > > + int i; > > + > > + for (i = 0 ; i < count_out_fences ; i++) { > > + if (state->sync_file) > > + sync_file_put(state->sync_file); > > + if (state->fd >= 0) > > + put_unused_fd(state->fd); > > + } > > +} > > + > > int drm_mode_atomic_ioctl(struct drm_device *dev, > > void *data, struct drm_file *file_priv) > > { > > @@ -1574,12 +1701,14 @@ int drm_mode_atomic_ioctl(struct drm_device *dev, > > uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr); > > uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr); > > uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr); > > + uint32_t __user *out_fences_ptr = (uint32_t __user *)(unsigned long)(arg->out_fences_ptr); > > unsigned int copied_objs, copied_props; > > struct drm_atomic_state *state; > > struct drm_modeset_acquire_ctx ctx; > > struct drm_plane *plane; > > struct drm_crtc *crtc; > > struct drm_crtc_state *crtc_state; > > + struct drm_out_fence_state *fence_state = NULL; > > unsigned plane_mask; > > int ret = 0; > > unsigned int i, j; > > @@ -1605,9 +1734,13 @@ int drm_mode_atomic_ioctl(struct drm_device *dev, > > !dev->mode_config.async_page_flip) > > return -EINVAL; > > > > + if ((arg->flags & DRM_MODE_ATOMIC_OUT_FENCE) && !arg->count_out_fences) > > + return -EINVAL; > > We need testcases which check that arg->count_out_fences and > arg->out_fences are 0 when the OUT_FENCE flag is not set. > > Definitely needs an igt testcase for this invalid input case. Ofc we also > need tests that give the kernel nonsens in count_out_fences and out_fences > with the flag set. > > > + > > /* can't test and expect an event at the same time. */ > > if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) && > > - (arg->flags & DRM_MODE_PAGE_FLIP_EVENT)) > > + (arg->flags & (DRM_MODE_PAGE_FLIP_EVENT > > + | DRM_MODE_ATOMIC_OUT_FENCE))) > > If you go with my suggestion above to create the event if either is set, > maybe a DRM_MODE_ATOMIC_EVENT_MASK with both? Would read easier. Ok. Gustavo