From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [RFC simple allocator v2 1/2] Create Simple Allocator module Date: Tue, 14 Feb 2017 21:39:49 +0200 Message-ID: <1967325.JRFDDRuil3@avalon> References: <1486997106-23277-1-git-send-email-benjamin.gaignard@linaro.org> <1486997106-23277-2-git-send-email-benjamin.gaignard@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [IPv6:2001:4b98:dc2:45:216:3eff:febb:480d]) by gabe.freedesktop.org (Postfix) with ESMTPS id C63C26E7E6 for ; Tue, 14 Feb 2017 19:39:21 +0000 (UTC) In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter Cc: Linaro Kernel Mailman List , Arnd Bergmann , Linux Kernel Mailing List , dri-devel , Hans Verkuil , Mark Brown , Andrew Morton , "linux-media@vger.kernel.org" List-Id: dri-devel@lists.freedesktop.org SGkgRGFuaWVsLAoKT24gVHVlc2RheSAxNCBGZWIgMjAxNyAyMDozMzo1OCBEYW5pZWwgVmV0dGVy IHdyb3RlOgo+IE9uIE1vbiwgRmViIDEzLCAyMDE3IGF0IDM6NDUgUE0sIEJlbmphbWluIEdhaWdu YXJkIHdyb3RlOgo+ID4gVGhpcyBpcyB0aGUgY29yZSBvZiBzaW1wbGUgYWxsb2NhdG9yIG1vZHVs ZS4KPiA+IEl0IGFpbSB0byBvZmZlcnQgb25lIGNvbW1vbiBpb2N0bCB0byBhbGxvY2F0ZSBzcGVj aWZpYyBtZW1vcnkuCj4gPiAKPiA+IHZlcnNpb24gMjoKPiA+IC0gcmViYXNlZCBvbiA0LjEwLXJj Nwo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBCZW5qYW1pbiBHYWlnbmFyZCA8YmVuamFtaW4uZ2Fp Z25hcmRAbGluYXJvLm9yZz4KPiAKPiBXaHkgbm90IElPTj8gSXQncyBhIGJpdCBhIGJyb2tlbiBy ZWNvcmQgcXVlc3Rpb24sIGJ1dCBpZiB0aGVyZSBpcyBhCj4gY2xlYXIgYW5zd2VyIGl0IHNob3Vs ZCBiZSBpbiB0aGUgcGF0Y2gmZG9jcyAuLi4KClRoZXJlJ3MgYSBiaXQgb2YgbG92ZSAmIGhhdGUg cmVsYXRpb25zaGlwIGJldHdlZW4gTGludXggZGV2ZWxvcGVycyBhbmQgSU9OLiAKVGhlIEFQSSBo YXMgc2hvcnRjb21pbmdzLCBhbmQgYXR0ZW1wdHMgdG8gZml4IHRoZSBpc3N1ZXMgd2VudCBub3do ZXJlLiBBcyAKTGF1cmEgZXhwbGFpbmVkLCBzdGFydGluZyBmcm9tIGEgYmxhbmsgc2xhdGUgKG9i dmlvdXNseSBrZWVwaW5nIGluIG1pbmQgdGhlIApsZXNzb25zIGxlYXJudCBzbyBmYXIgd2l0aCBJ T04gYW5kIG90aGVyIHNpbWlsYXIgQVBJcykgYW5kIHRoZW4gYWRkaW5nIGEgCndyYXBwZXIgdG8g ZXhwb3NlIElPTiBvbiBBbmRyb2lkIHN5c3RlbXMgKGF0IGxlYXN0IGFzIGFuIGludGVyaW0gbWVh c3VyZSkgd2FzIAp0aG91Z2h0IHRvIGJlIGEgYmV0dGVyIG9wdGlvbi4gSSBzdGlsbCBiZWxpZXZl IGl0IGlzLCBidXQgd2Ugc2VlbSB0byBsYWNrIAp0cmFjdGlvbi4gVGhlIHByb2JsZW0gaGFzIGJl ZW4gYXJvdW5kIGZvciBzbyBsb25nIHRoYXQgSSBmZWVsIGV2ZXJ5Ym9keSBoYXMgCmxvc3QgaG9w ZS4KCkkgZG9uJ3QgdGhpbmsgdGhpcyBpcyB1bnNvbHZhYmxlLCBidXQgd2UgbmVlZCB0byByZWdh aW4gbW90aXZhdGlvbi4gSW4gbXkgCm9waW5pb24gdGhlIGZpcnN0IHN0ZXAgd291bGQgYmUgdG8g ZGVmaW5lIHRoZSBwcmVjaXNlIGV4dGVudCBvZiB0aGUgcHJvYmxlbSB3ZSAKd2FudCB0byBzb2x2 ZS4KCj4gPiAtLS0KPiA+IAo+ID4gIERvY3VtZW50YXRpb24vc2ltcGxlLWFsbG9jYXRvci50eHQg ICAgICAgICAgICAgIHwgIDgxICsrKysrKysrKysrCj4gPiAgZHJpdmVycy9LY29uZmlnICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKwo+ID4gIGRyaXZlcnMvTWFrZWZpbGUg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKPiA+ICBkcml2ZXJzL3NpbXBs ZWFsbG9jYXRvci9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAxMCArKwo+ID4gIGRyaXZlcnMv c2ltcGxlYWxsb2NhdG9yL01ha2VmaWxlICAgICAgICAgICAgICAgIHwgICAxICsKPiA+ICBkcml2 ZXJzL3NpbXBsZWFsbG9jYXRvci9zaW1wbGUtYWxsb2NhdG9yLXByaXYuaCB8ICAzMyArKysrKwo+ ID4gIGRyaXZlcnMvc2ltcGxlYWxsb2NhdG9yL3NpbXBsZS1hbGxvY2F0b3IuYyAgICAgIHwgMTgw ICsrKysrKysrKysrKysrKysrKysKPiA+ICBpbmNsdWRlL3VhcGkvbGludXgvc2ltcGxlLWFsbG9j YXRvci5oICAgICAgICAgICB8ICAzNSArKysrKwo+ID4gIDggZmlsZXMgY2hhbmdlZCwgMzQzIGlu c2VydGlvbnMoKykKPiA+ICBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9zaW1wbGUt YWxsb2NhdG9yLnR4dAo+ID4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3NpbXBsZWFsbG9j YXRvci9LY29uZmlnCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc2ltcGxlYWxsb2Nh dG9yL01ha2VmaWxlCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc2ltcGxlYWxsb2Nh dG9yL3NpbXBsZS1hbGxvY2F0b3ItcHJpdi5oCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvc2ltcGxlYWxsb2NhdG9yL3NpbXBsZS1hbGxvY2F0b3IuYwo+ID4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBpbmNsdWRlL3VhcGkvbGludXgvc2ltcGxlLWFsbG9jYXRvci5oCj4gPiAKPiA+IGRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL3NpbXBsZS1hbGxvY2F0b3IudHh0Cj4gPiBiL0RvY3VtZW50 YXRpb24vc2ltcGxlLWFsbG9jYXRvci50eHQgbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4 IDAwMDAwMDAuLjg5YmE4ODMKPiA+IC0tLSAvZGV2L251bGwKPiA+ICsrKyBiL0RvY3VtZW50YXRp b24vc2ltcGxlLWFsbG9jYXRvci50eHQKPiA+IEBAIC0wLDAgKzEsODEgQEAKPiA+ICtTaW1wbGUg QWxsb2NhdG9yIEZyYW1ld29yawo+ID4gKwo+ID4gK1NpbXBsZSBBbGxvY2F0b3Igb2ZmZXIgYSBz aW5nbGUgaW9jdGwgU0FfSU9DX0FMTE9DIHRvIGFsbG9jYXRlIGJ1ZmZlcnMKPiA+ICtvbiBkZWRp Y2F0ZWQgbWVtb3J5IHJlZ2lvbnMgYW5kIGV4cG9ydCB0aGVtIGFzIGEgZG1hYnVmIGZpbGUgZGVz Y3JpcHRvci4KPiA+ICtVc2luZyBkbWFidWYgZmlsZSBkZXNjcmlwdG9yIGFsbG93IHRvIHNoYXJl IHRoaXMgbWVtb3J5IGJldHdlZW4gcHJvY2Vzc2VzCj4gPiArYW5kL29yIGltcG9ydCBpdCBpbnRv IG90aGVyIGZyYW1ld29ya3MgbGlrZSB2NGwyIG9yIGRybS9rbXMgKHByaW1lKS4KPiA+ICtXaGVu IHVzZXJsYW5kIHdhbnRzIHRvIGZyZWUgdGhlIG1lbW9yeSBvbmx5IGEgY2FsbCB0byBjbG9zZSgp IGluIG5lZWRlZAo+ID4gK3NvIGl0IGNvdWxkIGRvbmUgZXZlbiB3aXRob3V0IGtub3dpbmcgdGhh dCBidWZmZXIgaGFzIGJlZW4gYWxsb2NhdGVkIGJ5Cj4gPiArc2ltcGxlIGFsbG9jYXRvciBpb2N0 bC4KPiA+ICsKPiA+ICtFYWNoIG1lbW9yeSByZWdpb25zIHdpbGwgYmUgc2VlbiBhcyBhIGZpbGVp biAvZGV2Ly4KPiA+ICtGb3IgZXhhbXBsZSBDTUEgcmVnaW9ucyB3aWxsIGV4cG9zZWQgaGFzIC9k ZXYvY21hWC4KPiA+ICsKPiA+ICtJbXBsZW1lbnRpbmcgYSBzaW1wbGUgYWxsb2NhdG9yCj4gPiAr LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKwo+ID4gK1NpbXBsZSBBbGxvY2F0 b3IgcHJvdmlkZSBoZWxwZXJzIGZ1bmN0aW9ucyB0byByZWdpc3Rlci91bnJlZ2lzdGVyIGFuCj4g PiArYWxsb2NhdG9yOgo+ID4gKy0gc2ltcGxlX2FsbG9jYXRvcl9yZWdpc3RlcihzdHJ1Y3Qgc2Ff ZGV2aWNlICpzYWRldikKPiA+ICsgIFJlZ2lzdGVyIHNpbXBsZV9hbGxvY2F0b3JfZGV2aWNlIHVz aW5nIHNhX2RldmljZSBzdHJ1Y3R1cmUgd2hlcmUgbmFtZSwKPiA+ICsgIG93bmVyIGFuZCBhbGxv Y2F0ZSBmaWVsZHMgbXVzdCBiZSBzZXQuCj4gPiArCj4gPiArLSBzaW1wbGVfYWxsb2NhdG9yX3Vu cmVnaXN0ZXIoc3RydWN0IHNhX2RldmljZSAqc2FkZXYpCj4gPiArICBVbnJlZ2lzdGVyIGEgc2lt cGxlIGFsbG9jYXRvciBkZXZpY2UuCj4gPiArCj4gPiArVXNpbmcgU2ltcGxlIEFsbG9jYXRvciAv ZGV2IGludGVyZmFjZSBleGFtcGxlCj4gPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCj4gPiArCj4gPiArVGhpcyBleGFtcGxlIG9mIGNvZGUgYWxsb2NhdGUg YSBidWZmZXIgb24gdGhlIGZpcnN0IENNQSByZWdpb24KPiA+ICgvZGV2L2NtYTApCj4gPiArYmVm b3JlIG1tYXAgYW5kIGNsb3NlIGl0Lgo+ID4gKwo+ID4gKyNpbmNsdWRlIDxlcnJuby5oPgo+ID4g KyNpbmNsdWRlIDxmY250bC5oPgo+ID4gKyNpbmNsdWRlIDxzdGRpby5oPgo+ID4gKyNpbmNsdWRl IDxzdGRsaWIuaD4KPiA+ICsjaW5jbHVkZSA8c3RyaW5nLmg+Cj4gPiArI2luY2x1ZGUgPHVuaXN0 ZC5oPgo+ID4gKyNpbmNsdWRlIDxzeXMvaW9jdGwuaD4KPiA+ICsjaW5jbHVkZSA8c3lzL21tYW4u aD4KPiA+ICsjaW5jbHVkZSA8c3lzL3N0YXQuaD4KPiA+ICsjaW5jbHVkZSA8c3lzL3R5cGVzLmg+ Cj4gPiArCj4gPiArI2luY2x1ZGUgInNpbXBsZS1hbGxvY2F0b3IuaCIKPiA+ICsKPiA+ICsjZGVm aW5lIExFTkdUSCAxMDI0KjE2Cj4gPiArCj4gPiArdm9pZCBtYWluICh2b2lkKQo+ID4gK3sKPiA+ ICsgICAgICAgc3RydWN0IHNpbXBsZV9hbGxvY2F0ZV9kYXRhIGRhdGE7Cj4gPiArICAgICAgIGlu dCBmZCA9IG9wZW4oIi9kZXYvY21hMCIsIE9fUkRXUiwgMCk7Cj4gPiArICAgICAgIGludCByZXQ7 Cj4gPiArICAgICAgIHZvaWQgKm1lbTsKPiA+ICsKPiA+ICsgICAgICAgaWYgKGZkIDwgMCkgewo+ ID4gKyAgICAgICAgICAgICAgIHByaW50ZigiQ2FuJ3Qgb3BlbiAvZGV2L2NtYTBcbiIpOwo+ID4g KyAgICAgICAgICAgICAgIHJldHVybjsKPiA+ICsgICAgICAgfQo+ID4gKwo+ID4gKyAgICAgICBt ZW1zZXQoJmRhdGEsIDAsIHNpemVvZihkYXRhKSk7Cj4gPiArCj4gPiArICAgICAgIGRhdGEubGVu Z3RoID0gTEVOR1RIOwo+ID4gKyAgICAgICBkYXRhLmZsYWdzID0gT19SRFdSIHwgT19DTE9FWEVD Owo+ID4gKwo+ID4gKyAgICAgICByZXQgPSBpb2N0bChmZCwgU0FfSU9DX0FMTE9DLCAmZGF0YSk7 Cj4gPiArICAgICAgIGlmIChyZXQpIHsKPiA+ICsgICAgICAgICAgICAgICBwcmludGYoIkJ1ZmZl ciBhbGxvY2F0aW9uIGZhaWxlZFxuIik7Cj4gPiArICAgICAgICAgICAgICAgZ290byBlbmQ7Cj4g PiArICAgICAgIH0KPiA+ICsKPiA+ICsgICAgICAgbWVtID0gbW1hcCgwLCBMRU5HVEgsIFBST1Rf UkVBRCB8IFBST1RfV1JJVEUsIE1BUF9TSEFSRUQsIGRhdGEuZmQsCj4gPiAwKTsgKyAgICAgICBp ZiAobWVtID09IE1BUF9GQUlMRUQpIHsKPiA+ICsgICAgICAgICAgICAgICBwcmludGYoIm1tYXAg ZmFpbGVkXG4iKTsKPiA+ICsgICAgICAgfQo+ID4gKwo+ID4gKyAgICAgICBtZW1zZXQobWVtLCAw eEZGLCBMRU5HVEgpOwo+ID4gKyAgICAgICBtdW5tYXAobWVtLCBMRU5HVEgpOwo+ID4gKwo+ID4g KyAgICAgICBwcmludGYoInRlc3Qgc2ltcGxlIGFsbG9jYXRvciBDTUEgT0tcbiIpOwo+ID4gK2Vu ZDoKPiA+ICsgICAgICAgY2xvc2UoZmQpOwo+ID4gK30KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJz L0tjb25maWcgYi9kcml2ZXJzL0tjb25maWcKPiA+IGluZGV4IGUxZTIwNjYuLmE2ZDg4MjggMTAw NjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL0tjb25maWcKPiA+ICsrKyBiL2RyaXZlcnMvS2NvbmZpZwo+ ID4gQEAgLTIwMiw0ICsyMDIsNiBAQCBzb3VyY2UgImRyaXZlcnMvaHd0cmFjaW5nL2ludGVsX3Ro L0tjb25maWciCj4gPiAKPiA+ICBzb3VyY2UgImRyaXZlcnMvZnBnYS9LY29uZmlnIgo+ID4gCj4g PiArc291cmNlICJkcml2ZXJzL3NpbXBsZWFsbG9jYXRvci9LY29uZmlnIgo+ID4gKwo+ID4gCj4g PiAgZW5kbWVudQo+ID4gCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9NYWtlZmlsZSBiL2RyaXZl cnMvTWFrZWZpbGUKPiA+IGluZGV4IDA2MDAyNmEuLjUwODFlYjggMTAwNjQ0Cj4gPiAtLS0gYS9k cml2ZXJzL01ha2VmaWxlCj4gPiArKysgYi9kcml2ZXJzL01ha2VmaWxlCj4gPiBAQCAtMTczLDMg KzE3Myw0IEBAIG9iai0kKENPTkZJR19TVE0pICAgICAgICAgICArPSBod3RyYWNpbmcvc3RtLwo+ ID4gCj4gPiAgb2JqLSQoQ09ORklHX0FORFJPSUQpICAgICAgICAgICs9IGFuZHJvaWQvCj4gPiAg b2JqLSQoQ09ORklHX05WTUVNKSAgICAgICAgICAgICs9IG52bWVtLwo+ID4gIG9iai0kKENPTkZJ R19GUEdBKSAgICAgICAgICAgICArPSBmcGdhLwo+ID4gCj4gPiArb2JqLSQoQ09ORklHX1NJTVBM RV9BTExPQ0FUT1IpICAgICAgICAgKz0gc2ltcGxlYWxsb2NhdG9yLwo+ID4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvc2ltcGxlYWxsb2NhdG9yL0tjb25maWcKPiA+IGIvZHJpdmVycy9zaW1wbGVhbGxv Y2F0b3IvS2NvbmZpZyBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggMDAwMDAwMC4uYzZm YzJlMwo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVycy9zaW1wbGVhbGxvY2F0b3Iv S2NvbmZpZwo+ID4gQEAgLTAsMCArMSwxMCBAQAo+ID4gK21lbnUgIlNpbXBsZSBBbGxvY2F0b3Ii Cj4gPiArCj4gPiArY29uZmlnIFNJTVBMRV9BTExPQ0FUT1IKPiA+ICsgICAgICAgdHJpc3RhdGUg IlNpbXBsZSBBbGxsb2NhdG9yIEZyYW1ld29yayIKPiA+ICsgICAgICAgc2VsZWN0IERNQV9TSEFS RURfQlVGRkVSCj4gPiArICAgICAgIC0tLWhlbHAtLS0KPiA+ICsgICAgICAgICAgVGhlIFNpbXBs ZSBBbGxvY2F0b3IgRnJhbWV3b3JrIGFkZHMgYW4gQVBJIHRvIGFsbG9jYXRlIGFuZAo+ID4gc2hh cmUKPiA+ICsgICAgICAgICAgbWVtb3J5IGluIHVzZXJsYW5kLgo+ID4gKwo+ID4gK2VuZG1lbnUK PiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3NpbXBsZWFsbG9jYXRvci9NYWtlZmlsZQo+ID4gYi9k cml2ZXJzL3NpbXBsZWFsbG9jYXRvci9NYWtlZmlsZSBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ID4g aW5kZXggMDAwMDAwMC4uZTI3YzZhZAo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVy cy9zaW1wbGVhbGxvY2F0b3IvTWFrZWZpbGUKPiA+IEBAIC0wLDAgKzEgQEAKPiA+ICtvYmotJChD T05GSUdfU0lNUExFX0FMTE9DQVRPUikgKz0gc2ltcGxlLWFsbG9jYXRvci5vCj4gPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9zaW1wbGVhbGxvY2F0b3Ivc2ltcGxlLWFsbG9jYXRvci1wcml2LmgKPiA+ IGIvZHJpdmVycy9zaW1wbGVhbGxvY2F0b3Ivc2ltcGxlLWFsbG9jYXRvci1wcml2LmggbmV3IGZp bGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAuLjMzZjVhMzMKPiA+IC0tLSAvZGV2L251 bGwKPiA+ICsrKyBiL2RyaXZlcnMvc2ltcGxlYWxsb2NhdG9yL3NpbXBsZS1hbGxvY2F0b3ItcHJp di5oCj4gPiBAQCAtMCwwICsxLDMzIEBACj4gPiArLyoKPiA+ICsgKiBDb3B5cmlnaHQgKEMpIExp bmFybyAyMDE2Cj4gPiArICoKPiA+ICsgKiBBdXRob3I6IEJlbmphbWluIEdhaWduYXJkIDxiZW5q YW1pbi5nYWlnbmFyZEBsaW5hcm8ub3JnPgo+ID4gKyAqCj4gPiArICogTGljZW5zZSB0ZXJtczog IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpCj4gPiArICovCj4gPiArCj4gPiArI2lm bmRlZiBfU0lNUExFX0FMTE9DQVRPUl9QUklWX0hfCj4gPiArI2RlZmluZSBfU0lNUExFX0FMTE9D QVRPUl9QUklWX0hfCj4gPiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KPiA+ICsjaW5j bHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KPiA+ ICsKPiA+ICsvKioKPiA+ICsgKiBzdHJ1Y3Qgc2FfZGV2aWNlIC0gc2ltcGxlIGFsbG9jYXRvciBk ZXZpY2UKPiA+ICsgKiBAb3duZXI6IG1vZHVsZSBvd25lciwgbXVzdCBiZSBzZXQgdG8gVEhJU19N T0RVTEUKPiA+ICsgKiBAbmFtZTogbmFtZSBvZiB0aGUgYWxsb2NhdG9yCj4gPiArICogQGFsbG9j YXRlOiBjYWxsYWJjayBmb3IgbWVtb3J5IGFsbG9jYXRpb24KPiA+ICsgKi8KPiA+ICtzdHJ1Y3Qg c2FfZGV2aWNlIHsKPiA+ICsgICAgICAgc3RydWN0IGRldmljZSAgIGRldjsKPiA+ICsgICAgICAg c3RydWN0IGNkZXYgICAgIGNocmRldjsKPiA+ICsgICAgICAgc3RydWN0IG1vZHVsZSAgICpvd25l cjsKPiA+ICsgICAgICAgY29uc3QgY2hhciAgICAgICpuYW1lOwo+ID4gKyAgICAgICBzdHJ1Y3Qg ZG1hX2J1ZiAqKCphbGxvY2F0ZSkoc3RydWN0IHNhX2RldmljZSAqLCB1NjQgbGVuZ3RoLCB1MzIK PiA+IGZsYWdzKTsgK307Cj4gPiArCj4gPiAraW50IHNpbXBsZV9hbGxvY2F0b3JfcmVnaXN0ZXIo c3RydWN0IHNhX2RldmljZSAqc2FkZXYpOwo+ID4gK3ZvaWQgc2ltcGxlX2FsbG9jYXRvcl91bnJl Z2lzdGVyKHN0cnVjdCBzYV9kZXZpY2UgKnNhZGV2KTsKPiA+ICsKPiA+ICsjZW5kaWYKPiA+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL3NpbXBsZWFsbG9jYXRvci9zaW1wbGUtYWxsb2NhdG9yLmMKPiA+ IGIvZHJpdmVycy9zaW1wbGVhbGxvY2F0b3Ivc2ltcGxlLWFsbG9jYXRvci5jIG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwLi5kODljY2JmCj4gPiAtLS0gL2Rldi9udWxsCj4g PiArKysgYi9kcml2ZXJzL3NpbXBsZWFsbG9jYXRvci9zaW1wbGUtYWxsb2NhdG9yLmMKPiA+IEBA IC0wLDAgKzEsMTgwIEBACj4gPiArLyoKPiA+ICsgKiBDb3B5cmlnaHQgKEMpIExpbmFybyAyMDE2 Cj4gPiArICoKPiA+ICsgKiBBdXRob3I6IEJlbmphbWluIEdhaWduYXJkIDxiZW5qYW1pbi5nYWln bmFyZEBsaW5hcm8ub3JnPgo+ID4gKyAqCj4gPiArICogTGljZW5zZSB0ZXJtczogIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpCj4gPiArICovCj4gPiArCj4gPiArI2luY2x1ZGUgPGxp bnV4L21vZHVsZS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9zaW1wbGUtYWxsb2NhdG9yLmg+Cj4g PiArI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KPiA+ICsKPiA+ICsjaW5jbHVkZSAic2ltcGxl LWFsbG9jYXRvci1wcml2LmgiCj4gPiArCj4gPiArI2RlZmluZSBTQV9NQUpPUiAgICAgICAyMjIK PiA+ICsjZGVmaW5lIFNBX05VTV9ERVZJQ0VTIDI1Ngo+ID4gKyNkZWZpbmUgU0FfTkFNRSAgICAg ICAgICAgICAgICAic2ltcGxlX2FsbG9jYXRvciIKPiA+ICsKPiA+ICtzdGF0aWMgaW50IHNhX21p bm9yOwo+ID4gKwo+ID4gK3N0YXRpYyBzdHJ1Y3QgY2xhc3Mgc2FfY2xhc3MgPSB7Cj4gPiArICAg ICAgIC5uYW1lID0gU0FfTkFNRSwKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBsb25nIHNhX2lv Y3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nCj4g PiBhcmcpICt7Cj4gPiArICAgICAgIHN0cnVjdCBzYV9kZXZpY2UgKnNhZGV2ID0gZmlscC0+cHJp dmF0ZV9kYXRhOwo+ID4gKyAgICAgICBpbnQgcmV0ID0gLUVOT0RFVjsKPiA+ICsKPiA+ICsgICAg ICAgc3dpdGNoIChjbWQpIHsKPiA+ICsgICAgICAgY2FzZSBTQV9JT0NfQUxMT0M6Cj4gPiArICAg ICAgIHsKPiA+ICsgICAgICAgICAgICAgICBzdHJ1Y3Qgc2ltcGxlX2FsbG9jYXRlX2RhdGEgZGF0 YTsKPiA+ICsgICAgICAgICAgICAgICBzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmOwo+ID4gKwo+ID4g KyAgICAgICAgICAgICAgIGlmIChjb3B5X2Zyb21fdXNlcigmZGF0YSwgKHZvaWQgX191c2VyICop YXJnLAo+ID4gX0lPQ19TSVpFKGNtZCkpKSArICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g LUVGQVVMVDsKPiA+ICsKPiA+ICsgICAgICAgICAgICAgICBpZiAoZGF0YS52ZXJzaW9uICE9IDAp Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICsg ICAgICAgICAgICAgICBkbWFidWYgPSBzYWRldi0+YWxsb2NhdGUoc2FkZXYsIGRhdGEubGVuZ3Ro LCBkYXRhLmZsYWdzKTsKPiA+ICsgICAgICAgICAgICAgICBpZiAoIWRtYWJ1ZikKPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4gKyAgICAgICAgICAg ICAgIGRhdGEuZmQgPSBkbWFfYnVmX2ZkKGRtYWJ1ZiwgZGF0YS5mbGFncyk7Cj4gPiArICAgICAg ICAgICAgICAgaWYgKGRhdGEuZmQgPCAwKSB7Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICBk bWFfYnVmX3B1dChkbWFidWYpOwo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC1F SU5WQUw7Cj4gPiArICAgICAgICAgICAgICAgfQo+ID4gKwo+ID4gKyAgICAgICAgICAgICAgIGRh dGEubGVuZ3RoID0gZG1hYnVmLT5zaXplOwo+ID4gKwo+ID4gKyAgICAgICAgICAgICAgIGlmIChj b3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopYXJnLCAmZGF0YSwKPiA+IF9JT0NfU0laRShjbWQp KSkgeyArICAgICAgICAgICAgICAgICAgICAgICBkbWFfYnVmX3B1dChkbWFidWYpOwo+ID4gKyAg ICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC1FRkFVTFQ7Cj4gPiArICAgICAgICAgICAgICAg fQo+ID4gKwo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiAwOwo+ID4gKyAgICAgICB9Cj4gPiAr ICAgICAgIH0KPiA+ICsgICAgICAgcmV0dXJuIHJldDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGlj IGludCBzYV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQo+ID4g K3sKPiA+ICsgICAgICAgc3RydWN0IHNhX2RldmljZSAqc2FkZXYgPSBjb250YWluZXJfb2YoaW5v ZGUtPmlfY2RldiwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgc3RydWN0IHNhX2RldmljZSwgY2hyZGV2KTsKPiA+ICsKPiA+ICsgICAgICAgaWYgKCFz YWRldikKPiA+ICsgICAgICAgICAgICAgICByZXR1cm4gLUVOT0RFVjsKPiA+ICsKPiA+ICsgICAg ICAgZ2V0X2RldmljZSgmc2FkZXYtPmRldik7Cj4gPiArICAgICAgIGZpbHAtPnByaXZhdGVfZGF0 YSA9IHNhZGV2Owo+ID4gKyAgICAgICByZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGlj IGludCBzYV9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQo+ ID4gK3sKPiA+ICsgICAgICAgc3RydWN0IHNhX2RldmljZSAqc2FkZXYgPSBjb250YWluZXJfb2Yo aW5vZGUtPmlfY2RldiwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc3RydWN0IHNhX2RldmljZSwgY2hyZGV2KTsKPiA+ICsKPiA+ICsgICAgICAgaWYg KCFzYWRldikKPiA+ICsgICAgICAgICAgICAgICByZXR1cm4gLUVOT0RFVjsKPiA+ICsKPiA+ICsg ICAgICAgcHV0X2RldmljZSgmc2FkZXYtPmRldik7Cj4gPiArICAgICAgIHJldHVybiAwOwo+ID4g K30KPiA+ICsKPiA+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzYV9mb3Bz ID0gewo+ID4gKyAgICAgICAub3duZXIgPSBUSElTX01PRFVMRSwKPiA+ICsgICAgICAgLm9wZW4g PSBzYV9vcGVuLAo+ID4gKyAgICAgICAucmVsZWFzZSA9IHNhX3JlbGVhc2UsCj4gPiArICAgICAg IC51bmxvY2tlZF9pb2N0bCA9IHNhX2lvY3RsLAo+ID4gK307Cj4gPiArCj4gPiArLyoqCj4gPiAr ICogc2ltcGxlX2FsbG9jYXRvcl9yZWdpc3RlciAtIHJlZ2lzdGVyIGEgc2ltcGxlIGFsbG9jYXRv cgo+ID4gKyAqIEBzYWRldjogc2ltcGxlIGFsbG9jYXRvciBzdHJ1Y3R1cmUgdG8gYmUgcmVnaXN0 ZXJlZAo+ID4gKyAqCj4gPiArICogUmV0dXJuIDAgaWYgYWxsb2NhdG9yIGhhcyBiZWVuIHJlZ3Np dGVyZWQsIGVpdGhlciBhIG5lZ2F0aXZlIHZhbHVlLgo+ID4gKyAqLwo+ID4gK2ludCBzaW1wbGVf YWxsb2NhdG9yX3JlZ2lzdGVyKHN0cnVjdCBzYV9kZXZpY2UgKnNhZGV2KQo+ID4gK3sKPiA+ICsg ICAgICAgaW50IHJldDsKPiA+ICsKPiA+ICsgICAgICAgaWYgKCFzYWRldi0+bmFtZSB8fCAhc2Fk ZXYtPmFsbG9jYXRlKQo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwo+ID4gKwo+ ID4gKyAgICAgICBjZGV2X2luaXQoJnNhZGV2LT5jaHJkZXYsICZzYV9mb3BzKTsKPiA+ICsgICAg ICAgc2FkZXYtPmNocmRldi5vd25lciA9IHNhZGV2LT5vd25lcjsKPiA+ICsKPiA+ICsgICAgICAg cmV0ID0gY2Rldl9hZGQoJnNhZGV2LT5jaHJkZXYsIE1LREVWKFNBX01BSk9SLCBzYV9taW5vciks IDEpOwo+ID4gKyAgICAgICBpZiAocmV0IDwgMCkKPiA+ICsgICAgICAgICAgICAgICByZXR1cm4g cmV0Owo+ID4gKwo+ID4gKyAgICAgICBzYWRldi0+ZGV2LmNsYXNzID0gJnNhX2NsYXNzOwo+ID4g KyAgICAgICBzYWRldi0+ZGV2LmRldnQgPSBNS0RFVihTQV9NQUpPUiwgc2FfbWlub3IpOwo+ID4g KyAgICAgICBkZXZfc2V0X25hbWUoJnNhZGV2LT5kZXYsICIlcyVkIiwgc2FkZXYtPm5hbWUsIHNh X21pbm9yKTsKPiA+ICsgICAgICAgcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKCZzYWRldi0+ZGV2KTsK PiA+ICsgICAgICAgaWYgKHJldCA8IDApCj4gPiArICAgICAgICAgICAgICAgZ290byBjbGVhbnVw Owo+ID4gKwo+ID4gKyAgICAgICBzYV9taW5vcisrOwo+ID4gKyAgICAgICByZXR1cm4gMDsKPiA+ ICsKPiA+ICtjbGVhbnVwOgo+ID4gKyAgICAgICBjZGV2X2RlbCgmc2FkZXYtPmNocmRldik7Cj4g PiArICAgICAgIHJldHVybiByZXQ7Cj4gPiArfQo+ID4gK0VYUE9SVF9TWU1CT0xfR1BMKHNpbXBs ZV9hbGxvY2F0b3JfcmVnaXN0ZXIpOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIHNpbXBsZV9hbGxv Y2F0b3JfdW5yZWdpc3RlciAtIHVucmVnaXN0ZXIgYSBzaW1wbGUgYWxsb2NhdG9yCj4gPiArICog QHNhZGV2OiBzaW1wbGUgYWxsb2NhdG9yIGRldmljZSB0byBiZSB1bnJlZ2lzdGVyZWQKPiA+ICsg Ki8KPiA+ICt2b2lkIHNpbXBsZV9hbGxvY2F0b3JfdW5yZWdpc3RlcihzdHJ1Y3Qgc2FfZGV2aWNl ICpzYWRldikKPiA+ICt7Cj4gPiArICAgICAgIGlmICghc2FkZXYpCj4gPiArICAgICAgICAgICAg ICAgcmV0dXJuOwo+ID4gKwo+ID4gKyAgICAgICBjZGV2X2RlbCgmc2FkZXYtPmNocmRldik7Cj4g PiArICAgICAgIGRldmljZV9kZWwoJnNhZGV2LT5kZXYpOwo+ID4gKyAgICAgICBwdXRfZGV2aWNl KCZzYWRldi0+ZGV2KTsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZTUJPTF9HUEwoc2ltcGxlX2FsbG9j YXRvcl91bnJlZ2lzdGVyKTsKPiA+ICsKPiA+ICtzdGF0aWMgaW50IF9faW5pdCBzYV9pbml0KHZv aWQpCj4gPiArewo+ID4gKyAgICAgICBkZXZfdCBkZXYgPSBNS0RFVihTQV9NQUpPUiwgMCk7Cj4g PiArICAgICAgIGludCByZXQ7Cj4gPiArCj4gPiArICAgICAgIHJldCA9IHJlZ2lzdGVyX2NocmRl dl9yZWdpb24oZGV2LCBTQV9OVU1fREVWSUNFUywgU0FfTkFNRSk7Cj4gPiArICAgICAgIGlmIChy ZXQgPCAwKQo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiByZXQ7Cj4gPiArCj4gPiArICAgICAg IHJldCA9IGNsYXNzX3JlZ2lzdGVyKCZzYV9jbGFzcyk7Cj4gPiArICAgICAgIGlmIChyZXQgPCAw KSB7Cj4gPiArICAgICAgICAgICAgICAgdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKGRldiwgU0Ff TlVNX0RFVklDRVMpOwo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiAtRUlPOwo+ID4gKyAgICAg ICB9Cj4gPiArCj4gPiArICAgICAgIHJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMg dm9pZCBfX2V4aXQgc2FfZXhpdCh2b2lkKQo+ID4gK3sKPiA+ICsgICAgICAgZGV2X3QgZGV2ID0g TUtERVYoU0FfTUFKT1IsIDApOwo+ID4gKwo+ID4gKyAgICAgICBjbGFzc191bnJlZ2lzdGVyKCZz YV9jbGFzcyk7Cj4gPiArICAgICAgIHVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihkZXYsIFNBX05V TV9ERVZJQ0VTKTsKPiA+ICt9Cj4gPiArCj4gPiArc3Vic3lzX2luaXRjYWxsKHNhX2luaXQpOwo+ ID4gK21vZHVsZV9leGl0KHNhX2V4aXQpOwo+ID4gKwo+ID4gK01PRFVMRV9BVVRIT1IoIkJlbmph bWluIEdhaWduYXJkIDxiZW5qYW1pbi5nYWlnbmFyZEBsaW5hcm8ub3JnPiIpOwo+ID4gK01PRFVM RV9ERVNDUklQVElPTigiU2ltcGxlIGFsbG9jYXRvciIpOwo+ID4gK01PRFVMRV9MSUNFTlNFKCJH UEwiKTsKPiA+ICtNT0RVTEVfQUxJQVNfQ0hBUkRFVl9NQUpPUihTQV9NQUpPUik7Cj4gPiBkaWZm IC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3NpbXBsZS1hbGxvY2F0b3IuaAo+ID4gYi9pbmNs dWRlL3VhcGkvbGludXgvc2ltcGxlLWFsbG9jYXRvci5oIG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4g PiBpbmRleCAwMDAwMDAwLi41NTIwYTg1Cj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9pbmNs dWRlL3VhcGkvbGludXgvc2ltcGxlLWFsbG9jYXRvci5oCj4gPiBAQCAtMCwwICsxLDM1IEBACj4g PiArLyoKPiA+ICsgKiBDb3B5cmlnaHQgKEMpIExpbmFybyAyMDE2Cj4gPiArICoKPiA+ICsgKiBB dXRob3I6IEJlbmphbWluIEdhaWduYXJkIDxiZW5qYW1pbi5nYWlnbmFyZEBsaW5hcm8ub3JnPgo+ ID4gKyAqCj4gPiArICogTGljZW5zZSB0ZXJtczogIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IChHUEwpLCB2ZXJzaW9uIDIKPiA+ICsgKi8KPiA+ICsKPiA+ICsjaWZuZGVmIF9TSU1QTEVfQUxM T0NBVE9SX0hfCj4gPiArI2RlZmluZSBfU0lNUExFX0FMTE9DQVRPUl9IXwo+ID4gKwo+ID4gKyNp bmNsdWRlIDxsaW51eC9pb2N0bC5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgo+ID4g Kwo+ID4gKy8qKgo+ID4gKyAqIHN0cnVjdCBzaW1wbGVfYWxsb2NhdGVfZGF0YSAtIGFsbG9jYXRp b24gcGFyYW1ldGVycwo+ID4gKyAqIEB2ZXJzaW9uOiAgIHN0cnVjdHVyZSB2ZXJzaW9uIChtdXN0 IGJlIHNldCB0byAwKQo+ID4gKyAqIEBsZW5ndGg6ICAgIHNpemUgb2YgdGhlIHJlcXVlc3RlZCBi dWZmZXIKPiA+ICsgKiBAZmxhZ3M6ICAgICBtb2RlIGZsYWdzIGZvciB0aGUgZmlsZSBsaWtlIE9f UkRXUiBvciBPX0NMT0VYRUMKPiA+ICsgKiBAZmQ6ICAgICAgICAgICAgICAgIHJldHVybmVkIGZp bGUgZGVzY3JpcHRvcgo+ID4gKyAqLwo+ID4gK3N0cnVjdCBzaW1wbGVfYWxsb2NhdGVfZGF0YSB7 Cj4gPiArICAgICAgIF9fdTY0IHZlcnNpb247Cj4gPiArICAgICAgIF9fdTY0IGxlbmd0aDsKPiA+ ICsgICAgICAgX191MzIgZmxhZ3M7Cj4gPiArICAgICAgIF9fdTMyIHJlc2VydmVkMTsKPiA+ICsg ICAgICAgX19zMzIgZmQ7Cj4gPiArICAgICAgIF9fdTMyIHJlc2VydmVkMjsKPiA+ICt9Owo+ID4g Kwo+ID4gKyNkZWZpbmUgU0FfSU9DX01BR0lDICdTJwo+ID4gKwo+ID4gKyNkZWZpbmUgU0FfSU9D X0FMTE9DIF9JT1dSKFNBX0lPQ19NQUdJQywgMCwgc3RydWN0IHNpbXBsZV9hbGxvY2F0ZV9kYXRh KQo+ID4gKwo+ID4gKyNlbmRpZgo+ID4gLS0KPiA+IDEuOS4xCgotLSAKUmVnYXJkcywKCkxhdXJl bnQgUGluY2hhcnQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZl bAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from galahad.ideasonboard.com ([185.26.127.97]:58324 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752814AbdBNTj1 (ORCPT ); Tue, 14 Feb 2017 14:39:27 -0500 From: Laurent Pinchart To: Daniel Vetter Cc: Benjamin Gaignard , Linaro Kernel Mailman List , Arnd Bergmann , Laura Abbott , dri-devel , Linux Kernel Mailing List , "linux-media@vger.kernel.org" , "Clark, Rob" , Andrew Morton , Hans Verkuil , Mark Brown Subject: Re: [RFC simple allocator v2 1/2] Create Simple Allocator module Date: Tue, 14 Feb 2017 21:39:49 +0200 Message-ID: <1967325.JRFDDRuil3@avalon> In-Reply-To: References: <1486997106-23277-1-git-send-email-benjamin.gaignard@linaro.org> <1486997106-23277-2-git-send-email-benjamin.gaignard@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-media-owner@vger.kernel.org List-ID: Hi Daniel, On Tuesday 14 Feb 2017 20:33:58 Daniel Vetter wrote: > On Mon, Feb 13, 2017 at 3:45 PM, Benjamin Gaignard wrote: > > This is the core of simple allocator module. > > It aim to offert one common ioctl to allocate specific memory. > > > > version 2: > > - rebased on 4.10-rc7 > > > > Signed-off-by: Benjamin Gaignard > > Why not ION? It's a bit a broken record question, but if there is a > clear answer it should be in the patch&docs ... There's a bit of love & hate relationship between Linux developers and ION. The API has shortcomings, and attempts to fix the issues went nowhere. As Laura explained, starting from a blank slate (obviously keeping in mind the lessons learnt so far with ION and other similar APIs) and then adding a wrapper to expose ION on Android systems (at least as an interim measure) was thought to be a better option. I still believe it is, but we seem to lack traction. The problem has been around for so long that I feel everybody has lost hope. I don't think this is unsolvable, but we need to regain motivation. In my opinion the first step would be to define the precise extent of the problem we want to solve. > > --- > > > > Documentation/simple-allocator.txt | 81 +++++++++++ > > drivers/Kconfig | 2 + > > drivers/Makefile | 1 + > > drivers/simpleallocator/Kconfig | 10 ++ > > drivers/simpleallocator/Makefile | 1 + > > drivers/simpleallocator/simple-allocator-priv.h | 33 +++++ > > drivers/simpleallocator/simple-allocator.c | 180 +++++++++++++++++++ > > include/uapi/linux/simple-allocator.h | 35 +++++ > > 8 files changed, 343 insertions(+) > > create mode 100644 Documentation/simple-allocator.txt > > create mode 100644 drivers/simpleallocator/Kconfig > > create mode 100644 drivers/simpleallocator/Makefile > > create mode 100644 drivers/simpleallocator/simple-allocator-priv.h > > create mode 100644 drivers/simpleallocator/simple-allocator.c > > create mode 100644 include/uapi/linux/simple-allocator.h > > > > diff --git a/Documentation/simple-allocator.txt > > b/Documentation/simple-allocator.txt new file mode 100644 > > index 0000000..89ba883 > > --- /dev/null > > +++ b/Documentation/simple-allocator.txt > > @@ -0,0 +1,81 @@ > > +Simple Allocator Framework > > + > > +Simple Allocator offer a single ioctl SA_IOC_ALLOC to allocate buffers > > +on dedicated memory regions and export them as a dmabuf file descriptor. > > +Using dmabuf file descriptor allow to share this memory between processes > > +and/or import it into other frameworks like v4l2 or drm/kms (prime). > > +When userland wants to free the memory only a call to close() in needed > > +so it could done even without knowing that buffer has been allocated by > > +simple allocator ioctl. > > + > > +Each memory regions will be seen as a filein /dev/. > > +For example CMA regions will exposed has /dev/cmaX. > > + > > +Implementing a simple allocator > > +------------------------------- > > + > > +Simple Allocator provide helpers functions to register/unregister an > > +allocator: > > +- simple_allocator_register(struct sa_device *sadev) > > + Register simple_allocator_device using sa_device structure where name, > > + owner and allocate fields must be set. > > + > > +- simple_allocator_unregister(struct sa_device *sadev) > > + Unregister a simple allocator device. > > + > > +Using Simple Allocator /dev interface example > > +--------------------------------------------- > > + > > +This example of code allocate a buffer on the first CMA region > > (/dev/cma0) > > +before mmap and close it. > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include "simple-allocator.h" > > + > > +#define LENGTH 1024*16 > > + > > +void main (void) > > +{ > > + struct simple_allocate_data data; > > + int fd = open("/dev/cma0", O_RDWR, 0); > > + int ret; > > + void *mem; > > + > > + if (fd < 0) { > > + printf("Can't open /dev/cma0\n"); > > + return; > > + } > > + > > + memset(&data, 0, sizeof(data)); > > + > > + data.length = LENGTH; > > + data.flags = O_RDWR | O_CLOEXEC; > > + > > + ret = ioctl(fd, SA_IOC_ALLOC, &data); > > + if (ret) { > > + printf("Buffer allocation failed\n"); > > + goto end; > > + } > > + > > + mem = mmap(0, LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, data.fd, > > 0); + if (mem == MAP_FAILED) { > > + printf("mmap failed\n"); > > + } > > + > > + memset(mem, 0xFF, LENGTH); > > + munmap(mem, LENGTH); > > + > > + printf("test simple allocator CMA OK\n"); > > +end: > > + close(fd); > > +} > > diff --git a/drivers/Kconfig b/drivers/Kconfig > > index e1e2066..a6d8828 100644 > > --- a/drivers/Kconfig > > +++ b/drivers/Kconfig > > @@ -202,4 +202,6 @@ source "drivers/hwtracing/intel_th/Kconfig" > > > > source "drivers/fpga/Kconfig" > > > > +source "drivers/simpleallocator/Kconfig" > > + > > > > endmenu > > > > diff --git a/drivers/Makefile b/drivers/Makefile > > index 060026a..5081eb8 100644 > > --- a/drivers/Makefile > > +++ b/drivers/Makefile > > @@ -173,3 +173,4 @@ obj-$(CONFIG_STM) += hwtracing/stm/ > > > > obj-$(CONFIG_ANDROID) += android/ > > obj-$(CONFIG_NVMEM) += nvmem/ > > obj-$(CONFIG_FPGA) += fpga/ > > > > +obj-$(CONFIG_SIMPLE_ALLOCATOR) += simpleallocator/ > > diff --git a/drivers/simpleallocator/Kconfig > > b/drivers/simpleallocator/Kconfig new file mode 100644 > > index 0000000..c6fc2e3 > > --- /dev/null > > +++ b/drivers/simpleallocator/Kconfig > > @@ -0,0 +1,10 @@ > > +menu "Simple Allocator" > > + > > +config SIMPLE_ALLOCATOR > > + tristate "Simple Alllocator Framework" > > + select DMA_SHARED_BUFFER > > + ---help--- > > + The Simple Allocator Framework adds an API to allocate and > > share > > + memory in userland. > > + > > +endmenu > > diff --git a/drivers/simpleallocator/Makefile > > b/drivers/simpleallocator/Makefile new file mode 100644 > > index 0000000..e27c6ad > > --- /dev/null > > +++ b/drivers/simpleallocator/Makefile > > @@ -0,0 +1 @@ > > +obj-$(CONFIG_SIMPLE_ALLOCATOR) += simple-allocator.o > > diff --git a/drivers/simpleallocator/simple-allocator-priv.h > > b/drivers/simpleallocator/simple-allocator-priv.h new file mode 100644 > > index 0000000..33f5a33 > > --- /dev/null > > +++ b/drivers/simpleallocator/simple-allocator-priv.h > > @@ -0,0 +1,33 @@ > > +/* > > + * Copyright (C) Linaro 2016 > > + * > > + * Author: Benjamin Gaignard > > + * > > + * License terms: GNU General Public License (GPL) > > + */ > > + > > +#ifndef _SIMPLE_ALLOCATOR_PRIV_H_ > > +#define _SIMPLE_ALLOCATOR_PRIV_H_ > > + > > +#include > > +#include > > +#include > > + > > +/** > > + * struct sa_device - simple allocator device > > + * @owner: module owner, must be set to THIS_MODULE > > + * @name: name of the allocator > > + * @allocate: callabck for memory allocation > > + */ > > +struct sa_device { > > + struct device dev; > > + struct cdev chrdev; > > + struct module *owner; > > + const char *name; > > + struct dma_buf *(*allocate)(struct sa_device *, u64 length, u32 > > flags); +}; > > + > > +int simple_allocator_register(struct sa_device *sadev); > > +void simple_allocator_unregister(struct sa_device *sadev); > > + > > +#endif > > diff --git a/drivers/simpleallocator/simple-allocator.c > > b/drivers/simpleallocator/simple-allocator.c new file mode 100644 > > index 0000000..d89ccbf > > --- /dev/null > > +++ b/drivers/simpleallocator/simple-allocator.c > > @@ -0,0 +1,180 @@ > > +/* > > + * Copyright (C) Linaro 2016 > > + * > > + * Author: Benjamin Gaignard > > + * > > + * License terms: GNU General Public License (GPL) > > + */ > > + > > +#include > > +#include > > +#include > > + > > +#include "simple-allocator-priv.h" > > + > > +#define SA_MAJOR 222 > > +#define SA_NUM_DEVICES 256 > > +#define SA_NAME "simple_allocator" > > + > > +static int sa_minor; > > + > > +static struct class sa_class = { > > + .name = SA_NAME, > > +}; > > + > > +static long sa_ioctl(struct file *filp, unsigned int cmd, unsigned long > > arg) +{ > > + struct sa_device *sadev = filp->private_data; > > + int ret = -ENODEV; > > + > > + switch (cmd) { > > + case SA_IOC_ALLOC: > > + { > > + struct simple_allocate_data data; > > + struct dma_buf *dmabuf; > > + > > + if (copy_from_user(&data, (void __user *)arg, > > _IOC_SIZE(cmd))) + return -EFAULT; > > + > > + if (data.version != 0) > > + return -EINVAL; > > + > > + dmabuf = sadev->allocate(sadev, data.length, data.flags); > > + if (!dmabuf) > > + return -EINVAL; > > + > > + data.fd = dma_buf_fd(dmabuf, data.flags); > > + if (data.fd < 0) { > > + dma_buf_put(dmabuf); > > + return -EINVAL; > > + } > > + > > + data.length = dmabuf->size; > > + > > + if (copy_to_user((void __user *)arg, &data, > > _IOC_SIZE(cmd))) { + dma_buf_put(dmabuf); > > + return -EFAULT; > > + } > > + > > + return 0; > > + } > > + } > > + return ret; > > +} > > + > > +static int sa_open(struct inode *inode, struct file *filp) > > +{ > > + struct sa_device *sadev = container_of(inode->i_cdev, > > + struct sa_device, chrdev); > > + > > + if (!sadev) > > + return -ENODEV; > > + > > + get_device(&sadev->dev); > > + filp->private_data = sadev; > > + return 0; > > +} > > + > > +static int sa_release(struct inode *inode, struct file *filp) > > +{ > > + struct sa_device *sadev = container_of(inode->i_cdev, > > + struct sa_device, chrdev); > > + > > + if (!sadev) > > + return -ENODEV; > > + > > + put_device(&sadev->dev); > > + return 0; > > +} > > + > > +static const struct file_operations sa_fops = { > > + .owner = THIS_MODULE, > > + .open = sa_open, > > + .release = sa_release, > > + .unlocked_ioctl = sa_ioctl, > > +}; > > + > > +/** > > + * simple_allocator_register - register a simple allocator > > + * @sadev: simple allocator structure to be registered > > + * > > + * Return 0 if allocator has been regsitered, either a negative value. > > + */ > > +int simple_allocator_register(struct sa_device *sadev) > > +{ > > + int ret; > > + > > + if (!sadev->name || !sadev->allocate) > > + return -EINVAL; > > + > > + cdev_init(&sadev->chrdev, &sa_fops); > > + sadev->chrdev.owner = sadev->owner; > > + > > + ret = cdev_add(&sadev->chrdev, MKDEV(SA_MAJOR, sa_minor), 1); > > + if (ret < 0) > > + return ret; > > + > > + sadev->dev.class = &sa_class; > > + sadev->dev.devt = MKDEV(SA_MAJOR, sa_minor); > > + dev_set_name(&sadev->dev, "%s%d", sadev->name, sa_minor); > > + ret = device_register(&sadev->dev); > > + if (ret < 0) > > + goto cleanup; > > + > > + sa_minor++; > > + return 0; > > + > > +cleanup: > > + cdev_del(&sadev->chrdev); > > + return ret; > > +} > > +EXPORT_SYMBOL_GPL(simple_allocator_register); > > + > > +/** > > + * simple_allocator_unregister - unregister a simple allocator > > + * @sadev: simple allocator device to be unregistered > > + */ > > +void simple_allocator_unregister(struct sa_device *sadev) > > +{ > > + if (!sadev) > > + return; > > + > > + cdev_del(&sadev->chrdev); > > + device_del(&sadev->dev); > > + put_device(&sadev->dev); > > +} > > +EXPORT_SYMBOL_GPL(simple_allocator_unregister); > > + > > +static int __init sa_init(void) > > +{ > > + dev_t dev = MKDEV(SA_MAJOR, 0); > > + int ret; > > + > > + ret = register_chrdev_region(dev, SA_NUM_DEVICES, SA_NAME); > > + if (ret < 0) > > + return ret; > > + > > + ret = class_register(&sa_class); > > + if (ret < 0) { > > + unregister_chrdev_region(dev, SA_NUM_DEVICES); > > + return -EIO; > > + } > > + > > + return 0; > > +} > > + > > +static void __exit sa_exit(void) > > +{ > > + dev_t dev = MKDEV(SA_MAJOR, 0); > > + > > + class_unregister(&sa_class); > > + unregister_chrdev_region(dev, SA_NUM_DEVICES); > > +} > > + > > +subsys_initcall(sa_init); > > +module_exit(sa_exit); > > + > > +MODULE_AUTHOR("Benjamin Gaignard "); > > +MODULE_DESCRIPTION("Simple allocator"); > > +MODULE_LICENSE("GPL"); > > +MODULE_ALIAS_CHARDEV_MAJOR(SA_MAJOR); > > diff --git a/include/uapi/linux/simple-allocator.h > > b/include/uapi/linux/simple-allocator.h new file mode 100644 > > index 0000000..5520a85 > > --- /dev/null > > +++ b/include/uapi/linux/simple-allocator.h > > @@ -0,0 +1,35 @@ > > +/* > > + * Copyright (C) Linaro 2016 > > + * > > + * Author: Benjamin Gaignard > > + * > > + * License terms: GNU General Public License (GPL), version 2 > > + */ > > + > > +#ifndef _SIMPLE_ALLOCATOR_H_ > > +#define _SIMPLE_ALLOCATOR_H_ > > + > > +#include > > +#include > > + > > +/** > > + * struct simple_allocate_data - allocation parameters > > + * @version: structure version (must be set to 0) > > + * @length: size of the requested buffer > > + * @flags: mode flags for the file like O_RDWR or O_CLOEXEC > > + * @fd: returned file descriptor > > + */ > > +struct simple_allocate_data { > > + __u64 version; > > + __u64 length; > > + __u32 flags; > > + __u32 reserved1; > > + __s32 fd; > > + __u32 reserved2; > > +}; > > + > > +#define SA_IOC_MAGIC 'S' > > + > > +#define SA_IOC_ALLOC _IOWR(SA_IOC_MAGIC, 0, struct simple_allocate_data) > > + > > +#endif > > -- > > 1.9.1 -- Regards, Laurent Pinchart