From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: Re: [PATCH v10 3/3] staging/android: refactor SYNC IOCTLs Date: Thu, 14 Apr 2016 11:03:44 -0700 Message-ID: <20160414180344.GC3312@joana> References: <1458307660-31986-1-git-send-email-gustavo@padovan.org> <1458307660-31986-3-git-send-email-gustavo@padovan.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-pa0-f41.google.com (mail-pa0-f41.google.com [209.85.220.41]) by gabe.freedesktop.org (Postfix) with ESMTPS id E060C6EACB for ; Thu, 14 Apr 2016 18:03:46 +0000 (UTC) Received: by mail-pa0-f41.google.com with SMTP id er2so18449073pad.3 for ; Thu, 14 Apr 2016 11:03:46 -0700 (PDT) Content-Disposition: inline In-Reply-To: <1458307660-31986-3-git-send-email-gustavo@padovan.org> 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 Cc: devel@driverdev.osuosl.org, Daniel Stone , Daniel Vetter , Riley Andrews , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Arve =?iso-8859-1?B?SGr4bm5lduVn?= , joe@perches.com, akpm@linux-foundation.org, Gustavo Padovan , John Harrison List-Id: dri-devel@lists.freedesktop.org SGkgR3JlZywKCkFueSBjb21tZW50IG9uIHRoaXM/CgpUaGFua3MsCgpHdXN0YXZvCgoyMDE2LTAz LTE4IEd1c3Rhdm8gUGFkb3ZhbiA8Z3VzdGF2b0BwYWRvdmFuLm9yZz46Cgo+IEZyb206IEd1c3Rh dm8gUGFkb3ZhbiA8Z3VzdGF2by5wYWRvdmFuQGNvbGxhYm9yYS5jby51az4KPiAKPiBDaGFuZ2Ug U1lOQ19JT0NfRklMRV9JTkZPIChmb3JtZXIgU1lOQ19JT0NfRkVOQ0VfSU5GTykgYmVoYXZpb3Vy IHRvIGF2b2lkCj4gZnV0dXJlIEFQSSBicmVha3MgYW5kIG9wdGltaXplIGJ1ZmZlciBhbGxvY2F0 aW9uLgo+IAo+IE5vdyBudW1fZmVuY2VzIGNhbiBiZSBmaWxsZWQgYnkgdGhlIGNhbGxlciB0byBp bmZvcm0gaG93IG1hbnkgZmVuY2VzIGl0Cj4gd2FudHMgdG8gcmV0cmlldmUgZnJvbSB0aGUga2Vy bmVsLiBJZiB0aGUgbnVtX2ZlbmNlcyBwYXNzZWQgaXMgZ3JlYXRlcgo+IHRoYW4gemVybyBpbmZv LT5zeW5jX2ZlbmNlX2luZm8gc2hvdWxkIHBvaW50IHRvIGEgYnVmZmVyIHdpdGggZW5vdWdoIHNw YWNlCj4gdG8gZml0IGFsbCBmZW5jZXMuCj4gCj4gSG93ZXZlciBpZiBudW1fZmVuY2VzIHBhc3Nl ZCB0byB0aGUga2VybmVsIGlzIDAsIHRoZSBrZXJuZWwgd2lsbCByZXBseQo+IHdpdGggbnVtYmVy IG9mIGZlbmNlcyBvZiB0aGUgc3luY19maWxlLgo+IAo+IFNlbmRpbmcgZmlyc3QgYW4gaW9jdGwg d2l0aCBudW1fZmVuY2VzID0gMCBjYW4gb3B0aW1pemUgYnVmZmVyIGFsbG9jYXRpb24sCj4gaW4g YSBmaXJzdCBjYWxsIHdpdGggbnVtX2ZlbmNlcyA9IDAgdXNlcnNwYWNlIHdpbGwgcmVjZWl2ZSB0 aGUgYWN0dWFsCj4gbnVtYmVyIG9mIGZlbmNlcyBpbiB0aGUgbnVtX2ZlbmNlcyBmaWxlZC4KPiAK PiBUaGVuIGl0IGNhbiBhbGxvY2F0ZSBhIGJ1ZmZlciB3aXRoIHRoZSBjb3JyZWN0IHNpemUgb24g c3luY19mZW5jZV9pbmZvIGFuZAo+IGNhbGwgU1lOQ19JT0NfRklMRV9JTkZPIGFnYWluLCBidXQg bm93IHdpdGggdGhlIGFjdHVhbCB2YWx1ZSBvZiBudW1fZmVuY2VzCj4gaW4gdGhlIHN5bmNfZmls ZS4KPiAKPiBpbmZvLT5zeW5jX2ZlbmNlX2luZm8gd2FzIGNvbnZlcnRlZCB0byBfX3U2NCBwb2lu dGVyIHRvIHByZXZlbnQgMzJiaXQKPiBjb21wYXRpYmlsaXR5IGlzc3Vlcy4gQW5kIGEgZmxhZ3Mg bWVtYmVyIHdhcyBhZGRlZC4KPiAKPiBBbiBleGFtcGxlIHVzZXJzcGFjZSBjb2RlIGZvciB0aGUg bGF0ZXIgd291bGQgYmU6Cj4gCj4gCXN0cnVjdCBzeW5jX2ZpbGVfaW5mbyAqaW5mbzsKPiAJaW50 IGVyciwgc2l6ZSwgbnVtX2ZlbmNlczsKPiAKPiAJaW5mbyA9IG1hbGxvYyhzaXplb2YoKmluZm8p KTsKPiAKPiAJaW5mby5mbGFncyA9IDA7Cj4gCWVyciA9IGlvY3RsKGZkLCBTWU5DX0lPQ19GSUxF X0lORk8sIGluZm8pOwo+IAludW1fZmVuY2VzID0gaW5mby0+bnVtX2ZlbmNlczsKPiAKPiAJaWYg KG51bV9mZW5jZXMpIHsKPiAJCWluZm8uZmxhZ3MgPSAwOwo+IAkJc2l6ZSA9IHNpemVvZihzdHJ1 Y3Qgc3luY19mZW5jZV9pbmZvKSAqIG51bV9mZW5jZXM7Cj4gCQlpbmZvLT5udW1fZmVuY2VzID0g bnVtX2ZlbmNlczsKPiAJCWluZm8tPnN5bmNfZmVuY2VfaW5mbyA9ICh1aW50NjRfdCkgY2FsbG9j KG51bV9mZW5jZXMsCj4gCQkJCQkJCSAgc2l6ZW9mKHN0cnVjdCBzeW5jX2ZlbmNlX2luZm8pKTsK PiAKPiAJCWVyciA9IGlvY3RsKGZkLCBTWU5DX0lPQ19GSUxFX0lORk8sIGluZm8pOwo+IAl9Cj4g Cj4gRmluYWxseSB0aGUgSU9DVExzIG51bWJlcnMgd2VyZSBjaGFuZ2VkIHRvIGF2b2lkIGFueSBw b3RlbnRpYWwgb2xkCj4gdXNlcnNwYWNlIHJ1bm5pbmcgdGhlIG9sZCBBUEkgdG8gZ2V0IHdlaXJk IGVycm9ycy4gQ2hhbmdpbmcgdGhlIG9wY29kZXMKPiB3aWxsIG1ha2UgdGhlbSBmYWlsIHJpZ2h0 IGF3YXkuIFRoaXMgaXMganVzdCBhIHByZWNhdXRpb24sIHRoZXJlIG5vCj4gdXBzdHJlYW0gdXNl cnMgb2YgdGhlc2UgaW50ZXJmYWNlcyB5ZXQgYW5kIHRoZSBvbmx5IHVzZXIgaXMgQW5kcm9pZCwg YnV0Cj4gd2UgZG9uJ3QgZXhwZWN0IGFueW9uZSB0cnlpbmcgdG8gcnVuIGFuZHJvaWQgdXNlcnNw YWNlIGFuZCBhbGwgaXQKPiBkZXBlbmRlbmNpZXMgb24gdG9wIG9mIHVwc3RyZWFtIGtlcm5lbHMu Cj4gCj4gU2lnbmVkLW9mZi1ieTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29s bGFib3JhLmNvLnVrPgo+IFJldmlld2VkLWJ5OiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5s YW5raG9yc3RAbGludXguaW50ZWwuY29tPgo+IEFja2VkLWJ5OiBHcmVnIEhhY2ttYW5uIDxnaGFj a21hbm5AZ29vZ2xlLmNvbT4KPiBBY2tlZC1ieTogUm9iIENsYXJrIDxyb2JkY2xhcmtAZ21haWwu Y29tPgo+IEFja2VkLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgo+ IAo+IC0tLQo+IHYyOiBmaXggZmVuY2VfaW5mbyBtZW1vcnkgbGVhawo+IAo+IHYzOiBDb21tZW50 cyBmcm9tIEVtaWwgVmVsaWtvdgo+IAktIGltcHJvdmUgY29tbWl0IG1lc3NhZ2UKPiAJLSByZW1v dmUgX191NjQgY2FzdAo+IAktIHJlbW92ZSBjaGVjayBmb3Igb3V0cHV0IGZpZWxkcyBpbiBmaWxl X2luZm8KPiAJLSBjbGVhbiB1cCBzeW5jX2ZpbGxfZmVuY2VfaW5mbygpCj4gCj4gICAgIENvbW1l bnRzIGZyb20gTWFhcnRlbiBMYW5raG9yc3QKPiAJLSByZW1vdmUgaW4ubnVtX2ZlbmNlcyAmJiAh aW4uc3luY19mZW5jZV9pbmZvIGNoZWNrCj4gCS0gcmVtb3ZlIGluZm8tPmxlbiBhbmQgdXNlIG9u bHkgbnVtX2ZlbmNlcyB0byBjYWxjdWxhdGUgc2l6ZQo+IAo+ICAgICBDb21tZW50cyBmcm9tIERh biBDYXJwZW50ZXIKPiAJLSBmaXggaW5mby0+c3luY19mZW5jZV9pbmZvIGRvY3VtZW50YXRpb24K PiAKPiB2NDogcmVtb3ZlIGFsbG9jYXRlZCBzdHJ1Y3Qgc3luY19maWxlX2luZm8gKGNvbW1lbnQg ZnJvbSBNYWFydGVuKQo+IAo+IHY1OiBtZXJnZSBhbGwgY29tbWl0cyB0aGF0IHdlcmUgY2hhbmdp bmcgdGhlIEFCSQo+IAo+IHY2OiBmaXggLVdpbnQtdG8tcG9pbnRlci1jYXN0IGVycm9yIG9uIGlu Zm8uc3luY19mZW5jZV9pbmZvCj4gLS0tCj4gIGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMu YyAgICAgIHwgNzYgKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLQo+ICBkcml2 ZXJzL3N0YWdpbmcvYW5kcm9pZC91YXBpL3N5bmMuaCB8IDM2ICsrKysrKysrKysrKystLS0tLQo+ ICAyIGZpbGVzIGNoYW5nZWQsIDY3IGluc2VydGlvbnMoKyksIDQ1IGRlbGV0aW9ucygtKQo+IAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmMgYi9kcml2ZXJzL3N0 YWdpbmcvYW5kcm9pZC9zeW5jLmMKPiBpbmRleCAzYThmMjEwLi5mOWM2MDk0IDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuYwo+ICsrKyBiL2RyaXZlcnMvc3RhZ2lu Zy9hbmRyb2lkL3N5bmMuYwo+IEBAIC00NDUsNiArNDQ1LDExIEBAIHN0YXRpYyBsb25nIHN5bmNf ZmlsZV9pb2N0bF9tZXJnZShzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGUsCj4gIAkJZ290byBl cnJfcHV0X2ZkOwo+ICAJfQo+ICAKPiArCWlmIChkYXRhLmZsYWdzIHx8IGRhdGEucGFkKSB7Cj4g KwkJZXJyID0gLUVJTlZBTDsKPiArCQlnb3RvIGVycl9wdXRfZmQ7Cj4gKwl9Cj4gKwo+ICAJZmVu Y2UyID0gc3luY19maWxlX2ZkZ2V0KGRhdGEuZmQyKTsKPiAgCWlmICghZmVuY2UyKSB7Cj4gIAkJ ZXJyID0gLUVOT0VOVDsKPiBAQCAtNDc5LDEzICs0ODQsOSBAQCBlcnJfcHV0X2ZkOgo+ICAJcmV0 dXJuIGVycjsKPiAgfQo+ICAKPiAtc3RhdGljIGludCBzeW5jX2ZpbGxfZmVuY2VfaW5mbyhzdHJ1 Y3QgZmVuY2UgKmZlbmNlLCB2b2lkICpkYXRhLCBpbnQgc2l6ZSkKPiArc3RhdGljIHZvaWQgc3lu Y19maWxsX2ZlbmNlX2luZm8oc3RydWN0IGZlbmNlICpmZW5jZSwKPiArCQkJCXN0cnVjdCBzeW5j X2ZlbmNlX2luZm8gKmluZm8pCj4gIHsKPiAtCXN0cnVjdCBzeW5jX2ZlbmNlX2luZm8gKmluZm8g PSBkYXRhOwo+IC0KPiAtCWlmIChzaXplIDwgc2l6ZW9mKCppbmZvKSkKPiAtCQlyZXR1cm4gLUVO T01FTTsKPiAtCj4gIAlzdHJsY3B5KGluZm8tPm9ial9uYW1lLCBmZW5jZS0+b3BzLT5nZXRfdGlt ZWxpbmVfbmFtZShmZW5jZSksCj4gIAkJc2l6ZW9mKGluZm8tPm9ial9uYW1lKSk7Cj4gIAlzdHJs Y3B5KGluZm8tPmRyaXZlcl9uYW1lLCBmZW5jZS0+b3BzLT5nZXRfZHJpdmVyX25hbWUoZmVuY2Up LAo+IEBAIC00OTUsNTggKzQ5Niw2MyBAQCBzdGF0aWMgaW50IHN5bmNfZmlsbF9mZW5jZV9pbmZv KHN0cnVjdCBmZW5jZSAqZmVuY2UsIHZvaWQgKmRhdGEsIGludCBzaXplKQo+ICAJZWxzZQo+ICAJ CWluZm8tPnN0YXR1cyA9IDA7Cj4gIAlpbmZvLT50aW1lc3RhbXBfbnMgPSBrdGltZV90b19ucyhm ZW5jZS0+dGltZXN0YW1wKTsKPiAtCj4gLQlyZXR1cm4gc2l6ZW9mKCppbmZvKTsKPiAgfQo+ICAK PiAgc3RhdGljIGxvbmcgc3luY19maWxlX2lvY3RsX2ZlbmNlX2luZm8oc3RydWN0IHN5bmNfZmls ZSAqc3luY19maWxlLAo+ICAJCQkJCXVuc2lnbmVkIGxvbmcgYXJnKQo+ICB7Cj4gLQlzdHJ1Y3Qg c3luY19maWxlX2luZm8gKmluZm87Cj4gKwlzdHJ1Y3Qgc3luY19maWxlX2luZm8gaW5mbzsKPiAr CXN0cnVjdCBzeW5jX2ZlbmNlX2luZm8gKmZlbmNlX2luZm8gPSBOVUxMOwo+ICAJX191MzIgc2l6 ZTsKPiAtCV9fdTMyIGxlbiA9IDA7Cj4gIAlpbnQgcmV0LCBpOwo+ICAKPiAtCWlmIChjb3B5X2Zy b21fdXNlcigmc2l6ZSwgKHZvaWQgX191c2VyICopYXJnLCBzaXplb2Yoc2l6ZSkpKQo+ICsJaWYg KGNvcHlfZnJvbV91c2VyKCZpbmZvLCAodm9pZCBfX3VzZXIgKilhcmcsIHNpemVvZihpbmZvKSkp Cj4gIAkJcmV0dXJuIC1FRkFVTFQ7Cj4gIAo+IC0JaWYgKHNpemUgPCBzaXplb2Yoc3RydWN0IHN5 bmNfZmlsZV9pbmZvKSkKPiArCWlmIChpbmZvLmZsYWdzIHx8IGluZm8ucGFkKQo+ICAJCXJldHVy biAtRUlOVkFMOwo+ICAKPiAtCWlmIChzaXplID4gNDA5NikKPiAtCQlzaXplID0gNDA5NjsKPiAt Cj4gLQlpbmZvID0ga3phbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKPiAtCWlmICghaW5mbykKPiAt CQlyZXR1cm4gLUVOT01FTTsKPiAtCj4gLQlzdHJsY3B5KGluZm8tPm5hbWUsIHN5bmNfZmlsZS0+ bmFtZSwgc2l6ZW9mKGluZm8tPm5hbWUpKTsKPiAtCWluZm8tPnN0YXR1cyA9IGF0b21pY19yZWFk KCZzeW5jX2ZpbGUtPnN0YXR1cyk7Cj4gLQlpZiAoaW5mby0+c3RhdHVzID49IDApCj4gLQkJaW5m by0+c3RhdHVzID0gIWluZm8tPnN0YXR1czsKPiAtCj4gLQlsZW4gPSBzaXplb2Yoc3RydWN0IHN5 bmNfZmlsZV9pbmZvKTsKPiArCS8qCj4gKwkgKiBQYXNzaW5nIG51bV9mZW5jZXMgPSAwIG1lYW5z IHRoYXQgdXNlcnNwYWNlIGRvZXNuJ3Qgd2FudCB0bwo+ICsJICogcmV0cmlldmUgYW55IHN5bmNf ZmVuY2VfaW5mby4gSWYgbnVtX2ZlbmNlcyA9IDAgd2Ugc2tpcCBmaWxsaW5nCj4gKwkgKiBzeW5j X2ZlbmNlX2luZm8gYW5kIHJldHVybiB0aGUgYWN0dWFsIG51bWJlciBvZiBmZW5jZXMgb24KPiAr CSAqIGluZm8tPm51bV9mZW5jZXMuCj4gKwkgKi8KPiArCWlmICghaW5mby5udW1fZmVuY2VzKQo+ ICsJCWdvdG8gbm9fZmVuY2VzOwo+ICAKPiAtCWZvciAoaSA9IDA7IGkgPCBzeW5jX2ZpbGUtPm51 bV9mZW5jZXM7ICsraSkgewo+IC0JCXN0cnVjdCBmZW5jZSAqZmVuY2UgPSBzeW5jX2ZpbGUtPmNi c1tpXS5mZW5jZTsKPiArCWlmIChpbmZvLm51bV9mZW5jZXMgPCBzeW5jX2ZpbGUtPm51bV9mZW5j ZXMpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+IC0JCXJldCA9IHN5bmNfZmlsbF9mZW5jZV9p bmZvKGZlbmNlLCAodTggKilpbmZvICsgbGVuLCBzaXplIC0gbGVuKTsKPiArCXNpemUgPSBzeW5j X2ZpbGUtPm51bV9mZW5jZXMgKiBzaXplb2YoKmZlbmNlX2luZm8pOwo+ICsJZmVuY2VfaW5mbyA9 IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWZlbmNlX2luZm8pCj4gKwkJcmV0 dXJuIC1FTk9NRU07Cj4gIAo+IC0JCWlmIChyZXQgPCAwKQo+IC0JCQlnb3RvIG91dDsKPiArCWZv ciAoaSA9IDA7IGkgPCBzeW5jX2ZpbGUtPm51bV9mZW5jZXM7ICsraSkKPiArCQlzeW5jX2ZpbGxf ZmVuY2VfaW5mbyhzeW5jX2ZpbGUtPmNic1tpXS5mZW5jZSwgJmZlbmNlX2luZm9baV0pOwo+ICAK PiAtCQlsZW4gKz0gcmV0Owo+ICsJaWYgKGNvcHlfdG9fdXNlcih1NjRfdG9fdXNlcl9wdHIoaW5m by5zeW5jX2ZlbmNlX2luZm8pLCBmZW5jZV9pbmZvLAo+ICsJCQkgc2l6ZSkpIHsKPiArCQlyZXQg PSAtRUZBVUxUOwo+ICsJCWdvdG8gb3V0Owo+ICAJfQo+ICAKPiAtCWluZm8tPmxlbiA9IGxlbjsK PiArbm9fZmVuY2VzOgo+ICsJc3RybGNweShpbmZvLm5hbWUsIHN5bmNfZmlsZS0+bmFtZSwgc2l6 ZW9mKGluZm8ubmFtZSkpOwo+ICsJaW5mby5zdGF0dXMgPSBhdG9taWNfcmVhZCgmc3luY19maWxl LT5zdGF0dXMpOwo+ICsJaWYgKGluZm8uc3RhdHVzID49IDApCj4gKwkJaW5mby5zdGF0dXMgPSAh aW5mby5zdGF0dXM7Cj4gKwo+ICsJaW5mby5udW1fZmVuY2VzID0gc3luY19maWxlLT5udW1fZmVu Y2VzOwo+ICAKPiAtCWlmIChjb3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopYXJnLCBpbmZvLCBs ZW4pKQo+ICsJaWYgKGNvcHlfdG9fdXNlcigodm9pZCBfX3VzZXIgKilhcmcsICZpbmZvLCBzaXpl b2YoaW5mbykpKQo+ICAJCXJldCA9IC1FRkFVTFQ7Cj4gIAllbHNlCj4gIAkJcmV0ID0gMDsKPiAg Cj4gIG91dDoKPiAtCWtmcmVlKGluZm8pOwo+ICsJa2ZyZWUoZmVuY2VfaW5mbyk7Cj4gIAo+ICAJ cmV0dXJuIHJldDsKPiAgfQo+IEBAIC01NjAsNyArNTY2LDcgQEAgc3RhdGljIGxvbmcgc3luY19m aWxlX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAo+ICAJY2FzZSBT WU5DX0lPQ19NRVJHRToKPiAgCQlyZXR1cm4gc3luY19maWxlX2lvY3RsX21lcmdlKHN5bmNfZmls ZSwgYXJnKTsKPiAgCj4gLQljYXNlIFNZTkNfSU9DX0ZFTkNFX0lORk86Cj4gKwljYXNlIFNZTkNf SU9DX0ZJTEVfSU5GTzoKPiAgCQlyZXR1cm4gc3luY19maWxlX2lvY3RsX2ZlbmNlX2luZm8oc3lu Y19maWxlLCBhcmcpOwo+ICAKPiAgCWRlZmF1bHQ6Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3Rh Z2luZy9hbmRyb2lkL3VhcGkvc3luYy5oIGIvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvdWFwaS9z eW5jLmgKPiBpbmRleCA0NDY3Yzc2Li5mYmFkYjhhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvc3Rh Z2luZy9hbmRyb2lkL3VhcGkvc3luYy5oCj4gKysrIGIvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQv dWFwaS9zeW5jLmgKPiBAQCAtMTYsMTQgKzE2LDE4IEBACj4gIAo+ICAvKioKPiAgICogc3RydWN0 IHN5bmNfbWVyZ2VfZGF0YSAtIGRhdGEgcGFzc2VkIHRvIG1lcmdlIGlvY3RsCj4gLSAqIEBmZDI6 CWZpbGUgZGVzY3JpcHRvciBvZiBzZWNvbmQgZmVuY2UKPiAgICogQG5hbWU6CW5hbWUgb2YgbmV3 IGZlbmNlCj4gKyAqIEBmZDI6CWZpbGUgZGVzY3JpcHRvciBvZiBzZWNvbmQgZmVuY2UKPiAgICog QGZlbmNlOglyZXR1cm5zIHRoZSBmZCBvZiB0aGUgbmV3IGZlbmNlIHRvIHVzZXJzcGFjZQo+ICsg KiBAZmxhZ3M6CW1lcmdlX2RhdGEgZmxhZ3MKPiArICogQHBhZDoJcGFkZGluZyBmb3IgNjQtYml0 IGFsaWdubWVudCwgc2hvdWxkIGFsd2F5cyBiZSB6ZXJvCj4gICAqLwo+ICBzdHJ1Y3Qgc3luY19t ZXJnZV9kYXRhIHsKPiAtCV9fczMyCWZkMjsKPiAgCWNoYXIJbmFtZVszMl07Cj4gKwlfX3MzMglm ZDI7Cj4gIAlfX3MzMglmZW5jZTsKPiArCV9fdTMyCWZsYWdzOwo+ICsJX191MzIJcGFkOwo+ICB9 Owo+ICAKPiAgLyoqCj4gQEAgLTMxLDQyICszNSw1NCBAQCBzdHJ1Y3Qgc3luY19tZXJnZV9kYXRh IHsKPiAgICogQG9ial9uYW1lOgkJbmFtZSBvZiBwYXJlbnQgc3luY190aW1lbGluZQo+ICAgKiBA ZHJpdmVyX25hbWU6CW5hbWUgb2YgZHJpdmVyIGltcGxlbWVudGluZyB0aGUgcGFyZW50Cj4gICAq IEBzdGF0dXM6CQlzdGF0dXMgb2YgdGhlIGZlbmNlIDA6YWN0aXZlIDE6c2lnbmFsZWQgPDA6ZXJy b3IKPiArICogQGZsYWdzOgkJZmVuY2VfaW5mbyBmbGFncwo+ICAgKiBAdGltZXN0YW1wX25zOgl0 aW1lc3RhbXAgb2Ygc3RhdHVzIGNoYW5nZSBpbiBuYW5vc2Vjb25kcwo+ICAgKi8KPiAgc3RydWN0 IHN5bmNfZmVuY2VfaW5mbyB7Cj4gIAljaGFyCW9ial9uYW1lWzMyXTsKPiAgCWNoYXIJZHJpdmVy X25hbWVbMzJdOwo+ICAJX19zMzIJc3RhdHVzOwo+ICsJX191MzIJZmxhZ3M7Cj4gIAlfX3U2NAl0 aW1lc3RhbXBfbnM7Cj4gIH07Cj4gIAo+ICAvKioKPiAgICogc3RydWN0IHN5bmNfZmlsZV9pbmZv IC0gZGF0YSByZXR1cm5lZCBmcm9tIGZlbmNlIGluZm8gaW9jdGwKPiAtICogQGxlbjoJaW9jdGwg Y2FsbGVyIHdyaXRlcyB0aGUgc2l6ZSBvZiB0aGUgYnVmZmVyIGl0cyBwYXNzaW5nIGluLgo+IC0g KgkJaW9jdGwgcmV0dXJucyBsZW5ndGggb2Ygc3luY19maWxlX2luZm8gcmV0dXJuZWQgdG8KPiAt ICoJCXVzZXJzcGFjZSBpbmNsdWRpbmcgcHRfaW5mby4KPiAgICogQG5hbWU6CW5hbWUgb2YgZmVu Y2UKPiAgICogQHN0YXR1czoJc3RhdHVzIG9mIGZlbmNlLiAxOiBzaWduYWxlZCAwOmFjdGl2ZSA8 MDplcnJvcgo+IC0gKiBAc3luY19mZW5jZV9pbmZvOiBhcnJheSBvZiBzeW5jX2ZlbmNlX2luZm8g Zm9yIGV2ZXJ5IGZlbmNlIGluIHRoZSBzeW5jX2ZpbGUKPiArICogQGZsYWdzOglzeW5jX2ZpbGVf aW5mbyBmbGFncwo+ICsgKiBAbnVtX2ZlbmNlcwludW1iZXIgb2YgZmVuY2VzIGluIHRoZSBzeW5j X2ZpbGUKPiArICogQHBhZDoJcGFkZGluZyBmb3IgNjQtYml0IGFsaWdubWVudCwgc2hvdWxkIGFs d2F5cyBiZSB6ZXJvCj4gKyAqIEBzeW5jX2ZlbmNlX2luZm86IHBvaW50ZXIgdG8gYXJyYXkgb2Yg c3RydWN0cyBzeW5jX2ZlbmNlX2luZm8gd2l0aCBhbGwKPiArICoJCSBmZW5jZXMgaW4gdGhlIHN5 bmNfZmlsZQo+ICAgKi8KPiAgc3RydWN0IHN5bmNfZmlsZV9pbmZvIHsKPiAtCV9fdTMyCWxlbjsK PiAgCWNoYXIJbmFtZVszMl07Cj4gIAlfX3MzMglzdGF0dXM7Cj4gKwlfX3UzMglmbGFnczsKPiAr CV9fdTMyCW51bV9mZW5jZXM7Cj4gKwlfX3UzMglwYWQ7Cj4gIAo+IC0JX191OAlzeW5jX2ZlbmNl X2luZm9bMF07Cj4gKwlfX3U2NAlzeW5jX2ZlbmNlX2luZm87Cj4gIH07Cj4gIAo+ICAjZGVmaW5l IFNZTkNfSU9DX01BR0lDCQknPicKPiAgCj4gIC8qKgo+ICsgKiBPcGNvZGVzICAwLCAxIGFuZCAy IHdlcmUgYnVybmVkIGR1cmluZyBhIEFQSSBjaGFuZ2UgdG8gYXZvaWQgdXNlcnMgb2YgdGhlCj4g KyAqIG9sZCBBUEkgdG8gZ2V0IHdlaXJkIGVycm9ycyB3aGVuIHRyeWluZyB0byBoYW5kbGluZyBz eW5jX2ZpbGVzLiBUaGUgQVBJCj4gKyAqIGNoYW5nZSBoYXBwZW5lZCBkdXJpbmcgdGhlIGRlLXN0 YWdlIG9mIHRoZSBTeW5jIEZyYW1ld29yayB3aGVuIHRoZXJlIHdhcwo+ICsgKiBubyB1cHN0cmVh bSB1c2VycyBhdmFpbGFibGUuCj4gKyAqLwo+ICsKPiArLyoqCj4gICAqIERPQzogU1lOQ19JT0Nf TUVSR0UgLSBtZXJnZSB0d28gZmVuY2VzCj4gICAqCj4gICAqIFRha2VzIGEgc3RydWN0IHN5bmNf bWVyZ2VfZGF0YS4gIENyZWF0ZXMgYSBuZXcgZmVuY2UgY29udGFpbmluZyBjb3BpZXMgb2YKPiAg ICogdGhlIHN5bmNfcHRzIGluIGJvdGggdGhlIGNhbGxpbmcgZmQgYW5kIHN5bmNfbWVyZ2VfZGF0 YS5mZDIuICBSZXR1cm5zIHRoZQo+ICAgKiBuZXcgZmVuY2UncyBmZCBpbiBzeW5jX21lcmdlX2Rh dGEuZmVuY2UKPiAgICovCj4gLSNkZWZpbmUgU1lOQ19JT0NfTUVSR0UJCV9JT1dSKFNZTkNfSU9D X01BR0lDLCAxLCBzdHJ1Y3Qgc3luY19tZXJnZV9kYXRhKQo+ICsjZGVmaW5lIFNZTkNfSU9DX01F UkdFCQlfSU9XUihTWU5DX0lPQ19NQUdJQywgMywgc3RydWN0IHN5bmNfbWVyZ2VfZGF0YSkKPiAg Cj4gIC8qKgo+ICAgKiBET0M6IFNZTkNfSU9DX0ZFTkNFX0lORk8gLSBnZXQgZGV0YWlsZWQgaW5m b3JtYXRpb24gb24gYSBmZW5jZQo+IEBAIC03OSw2ICs5NSw2IEBAIHN0cnVjdCBzeW5jX2ZpbGVf aW5mbyB7Cj4gICAqIHB0X2luZm8gaXMgYSBidWZmZXIgY29udGFpbmluZyBzeW5jX3B0X2luZm9z IGZvciBldmVyeSBzeW5jX3B0IGluIHRoZSBmZW5jZS4KPiAgICogVG8gaXRlcmF0ZSBvdmVyIHRo ZSBzeW5jX3B0X2luZm9zLCB1c2UgdGhlIHN5bmNfcHRfaW5mby5sZW4gZmllbGQuCj4gICAqLwo+ IC0jZGVmaW5lIFNZTkNfSU9DX0ZFTkNFX0lORk8JX0lPV1IoU1lOQ19JT0NfTUFHSUMsIDIsIHN0 cnVjdCBzeW5jX2ZpbGVfaW5mbykKPiArI2RlZmluZSBTWU5DX0lPQ19GSUxFX0lORk8JX0lPV1Io U1lOQ19JT0NfTUFHSUMsIDQsIHN0cnVjdCBzeW5jX2ZpbGVfaW5mbykKPiAgCj4gICNlbmRpZiAv KiBfVUFQSV9MSU5VWF9TWU5DX0ggKi8KPiAtLSAKPiAyLjUuMAo+IApfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932452AbcDNSDt (ORCPT ); Thu, 14 Apr 2016 14:03:49 -0400 Received: from mail-pa0-f54.google.com ([209.85.220.54]:35370 "EHLO mail-pa0-f54.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753116AbcDNSDr (ORCPT ); Thu, 14 Apr 2016 14:03:47 -0400 Date: Thu, 14 Apr 2016 11:03:44 -0700 From: Gustavo Padovan To: Greg Kroah-Hartman Cc: linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, dri-devel@lists.freedesktop.org, Daniel Stone , Arve =?iso-8859-1?B?SGr4bm5lduVn?= , Riley Andrews , Daniel Vetter , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Gustavo Padovan , akpm@linux-foundation.org, joe@perches.com Subject: Re: [PATCH v10 3/3] staging/android: refactor SYNC IOCTLs Message-ID: <20160414180344.GC3312@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 , Daniel Vetter , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Gustavo Padovan , akpm@linux-foundation.org, joe@perches.com References: <1458307660-31986-1-git-send-email-gustavo@padovan.org> <1458307660-31986-3-git-send-email-gustavo@padovan.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1458307660-31986-3-git-send-email-gustavo@padovan.org> 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 Hi Greg, Any comment on this? Thanks, Gustavo 2016-03-18 Gustavo Padovan : > From: Gustavo Padovan > > Change SYNC_IOC_FILE_INFO (former SYNC_IOC_FENCE_INFO) behaviour to avoid > future API breaks and optimize buffer allocation. > > Now num_fences can be filled by the caller to inform how many fences it > wants to retrieve from the kernel. If the num_fences passed is greater > than zero info->sync_fence_info should point to a buffer with enough space > to fit all fences. > > However if num_fences passed to the kernel is 0, the kernel will reply > with number of fences of the sync_file. > > Sending first an ioctl with num_fences = 0 can optimize buffer allocation, > in a first call with num_fences = 0 userspace will receive the actual > number of fences in the num_fences filed. > > Then it can allocate a buffer with the correct size on sync_fence_info and > call SYNC_IOC_FILE_INFO again, but now with the actual value of num_fences > in the sync_file. > > info->sync_fence_info was converted to __u64 pointer to prevent 32bit > compatibility issues. And a flags member was added. > > An example userspace code for the later would be: > > struct sync_file_info *info; > int err, size, num_fences; > > info = malloc(sizeof(*info)); > > info.flags = 0; > err = ioctl(fd, SYNC_IOC_FILE_INFO, info); > num_fences = info->num_fences; > > if (num_fences) { > info.flags = 0; > size = sizeof(struct sync_fence_info) * num_fences; > info->num_fences = num_fences; > info->sync_fence_info = (uint64_t) calloc(num_fences, > sizeof(struct sync_fence_info)); > > err = ioctl(fd, SYNC_IOC_FILE_INFO, info); > } > > Finally the IOCTLs numbers were changed to avoid any potential old > userspace running the old API to get weird errors. Changing the opcodes > will make them fail right away. This is just a precaution, there no > upstream users of these interfaces yet and the only user is Android, but > we don't expect anyone trying to run android userspace and all it > dependencies on top of upstream kernels. > > Signed-off-by: Gustavo Padovan > Reviewed-by: Maarten Lankhorst > Acked-by: Greg Hackmann > Acked-by: Rob Clark > Acked-by: Daniel Vetter > > --- > v2: fix fence_info memory leak > > v3: Comments from Emil Velikov > - improve commit message > - remove __u64 cast > - remove check for output fields in file_info > - clean up sync_fill_fence_info() > > Comments from Maarten Lankhorst > - remove in.num_fences && !in.sync_fence_info check > - remove info->len and use only num_fences to calculate size > > Comments from Dan Carpenter > - fix info->sync_fence_info documentation > > v4: remove allocated struct sync_file_info (comment from Maarten) > > v5: merge all commits that were changing the ABI > > v6: fix -Wint-to-pointer-cast error on info.sync_fence_info > --- > drivers/staging/android/sync.c | 76 ++++++++++++++++++++----------------- > drivers/staging/android/uapi/sync.h | 36 +++++++++++++----- > 2 files changed, 67 insertions(+), 45 deletions(-) > > diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c > index 3a8f210..f9c6094 100644 > --- a/drivers/staging/android/sync.c > +++ b/drivers/staging/android/sync.c > @@ -445,6 +445,11 @@ static long sync_file_ioctl_merge(struct sync_file *sync_file, > goto err_put_fd; > } > > + if (data.flags || data.pad) { > + err = -EINVAL; > + goto err_put_fd; > + } > + > fence2 = sync_file_fdget(data.fd2); > if (!fence2) { > err = -ENOENT; > @@ -479,13 +484,9 @@ err_put_fd: > return err; > } > > -static int sync_fill_fence_info(struct fence *fence, void *data, int size) > +static void sync_fill_fence_info(struct fence *fence, > + struct sync_fence_info *info) > { > - struct sync_fence_info *info = data; > - > - if (size < sizeof(*info)) > - return -ENOMEM; > - > strlcpy(info->obj_name, fence->ops->get_timeline_name(fence), > sizeof(info->obj_name)); > strlcpy(info->driver_name, fence->ops->get_driver_name(fence), > @@ -495,58 +496,63 @@ static int sync_fill_fence_info(struct fence *fence, void *data, int size) > else > info->status = 0; > info->timestamp_ns = ktime_to_ns(fence->timestamp); > - > - return sizeof(*info); > } > > static long sync_file_ioctl_fence_info(struct sync_file *sync_file, > unsigned long arg) > { > - struct sync_file_info *info; > + struct sync_file_info info; > + struct sync_fence_info *fence_info = NULL; > __u32 size; > - __u32 len = 0; > int ret, i; > > - if (copy_from_user(&size, (void __user *)arg, sizeof(size))) > + if (copy_from_user(&info, (void __user *)arg, sizeof(info))) > return -EFAULT; > > - if (size < sizeof(struct sync_file_info)) > + if (info.flags || info.pad) > return -EINVAL; > > - if (size > 4096) > - size = 4096; > - > - info = kzalloc(size, GFP_KERNEL); > - if (!info) > - return -ENOMEM; > - > - strlcpy(info->name, sync_file->name, sizeof(info->name)); > - info->status = atomic_read(&sync_file->status); > - if (info->status >= 0) > - info->status = !info->status; > - > - len = sizeof(struct sync_file_info); > + /* > + * Passing num_fences = 0 means that userspace doesn't want to > + * retrieve any sync_fence_info. If num_fences = 0 we skip filling > + * sync_fence_info and return the actual number of fences on > + * info->num_fences. > + */ > + if (!info.num_fences) > + goto no_fences; > > - for (i = 0; i < sync_file->num_fences; ++i) { > - struct fence *fence = sync_file->cbs[i].fence; > + if (info.num_fences < sync_file->num_fences) > + return -EINVAL; > > - ret = sync_fill_fence_info(fence, (u8 *)info + len, size - len); > + size = sync_file->num_fences * sizeof(*fence_info); > + fence_info = kzalloc(size, GFP_KERNEL); > + if (!fence_info) > + return -ENOMEM; > > - if (ret < 0) > - goto out; > + for (i = 0; i < sync_file->num_fences; ++i) > + sync_fill_fence_info(sync_file->cbs[i].fence, &fence_info[i]); > > - len += ret; > + if (copy_to_user(u64_to_user_ptr(info.sync_fence_info), fence_info, > + size)) { > + ret = -EFAULT; > + goto out; > } > > - info->len = len; > +no_fences: > + strlcpy(info.name, sync_file->name, sizeof(info.name)); > + info.status = atomic_read(&sync_file->status); > + if (info.status >= 0) > + info.status = !info.status; > + > + info.num_fences = sync_file->num_fences; > > - if (copy_to_user((void __user *)arg, info, len)) > + if (copy_to_user((void __user *)arg, &info, sizeof(info))) > ret = -EFAULT; > else > ret = 0; > > out: > - kfree(info); > + kfree(fence_info); > > return ret; > } > @@ -560,7 +566,7 @@ static long sync_file_ioctl(struct file *file, unsigned int cmd, > case SYNC_IOC_MERGE: > return sync_file_ioctl_merge(sync_file, arg); > > - case SYNC_IOC_FENCE_INFO: > + case SYNC_IOC_FILE_INFO: > return sync_file_ioctl_fence_info(sync_file, arg); > > default: > diff --git a/drivers/staging/android/uapi/sync.h b/drivers/staging/android/uapi/sync.h > index 4467c76..fbadb8a 100644 > --- a/drivers/staging/android/uapi/sync.h > +++ b/drivers/staging/android/uapi/sync.h > @@ -16,14 +16,18 @@ > > /** > * struct sync_merge_data - data passed to merge ioctl > - * @fd2: file descriptor of second fence > * @name: name of new fence > + * @fd2: file descriptor of second fence > * @fence: returns the fd of the new fence to userspace > + * @flags: merge_data flags > + * @pad: padding for 64-bit alignment, should always be zero > */ > struct sync_merge_data { > - __s32 fd2; > char name[32]; > + __s32 fd2; > __s32 fence; > + __u32 flags; > + __u32 pad; > }; > > /** > @@ -31,42 +35,54 @@ struct sync_merge_data { > * @obj_name: name of parent sync_timeline > * @driver_name: name of driver implementing the parent > * @status: status of the fence 0:active 1:signaled <0:error > + * @flags: fence_info flags > * @timestamp_ns: timestamp of status change in nanoseconds > */ > struct sync_fence_info { > char obj_name[32]; > char driver_name[32]; > __s32 status; > + __u32 flags; > __u64 timestamp_ns; > }; > > /** > * struct sync_file_info - data returned from fence info ioctl > - * @len: ioctl caller writes the size of the buffer its passing in. > - * ioctl returns length of sync_file_info returned to > - * userspace including pt_info. > * @name: name of fence > * @status: status of fence. 1: signaled 0:active <0:error > - * @sync_fence_info: array of sync_fence_info for every fence in the sync_file > + * @flags: sync_file_info flags > + * @num_fences number of fences in the sync_file > + * @pad: padding for 64-bit alignment, should always be zero > + * @sync_fence_info: pointer to array of structs sync_fence_info with all > + * fences in the sync_file > */ > struct sync_file_info { > - __u32 len; > char name[32]; > __s32 status; > + __u32 flags; > + __u32 num_fences; > + __u32 pad; > > - __u8 sync_fence_info[0]; > + __u64 sync_fence_info; > }; > > #define SYNC_IOC_MAGIC '>' > > /** > + * Opcodes 0, 1 and 2 were burned during a API change to avoid users of the > + * old API to get weird errors when trying to handling sync_files. The API > + * change happened during the de-stage of the Sync Framework when there was > + * no upstream users available. > + */ > + > +/** > * DOC: SYNC_IOC_MERGE - merge two fences > * > * Takes a struct sync_merge_data. Creates a new fence containing copies of > * the sync_pts in both the calling fd and sync_merge_data.fd2. Returns the > * new fence's fd in sync_merge_data.fence > */ > -#define SYNC_IOC_MERGE _IOWR(SYNC_IOC_MAGIC, 1, struct sync_merge_data) > +#define SYNC_IOC_MERGE _IOWR(SYNC_IOC_MAGIC, 3, struct sync_merge_data) > > /** > * DOC: SYNC_IOC_FENCE_INFO - get detailed information on a fence > @@ -79,6 +95,6 @@ struct sync_file_info { > * pt_info is a buffer containing sync_pt_infos for every sync_pt in the fence. > * To iterate over the sync_pt_infos, use the sync_pt_info.len field. > */ > -#define SYNC_IOC_FENCE_INFO _IOWR(SYNC_IOC_MAGIC, 2, struct sync_file_info) > +#define SYNC_IOC_FILE_INFO _IOWR(SYNC_IOC_MAGIC, 4, struct sync_file_info) > > #endif /* _UAPI_LINUX_SYNC_H */ > -- > 2.5.0 >