From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andrzej Hajda Subject: Re: [RFC 1/2] core: Add generic object registry implementation Date: Wed, 05 Nov 2014 13:36:24 +0100 Message-ID: <545A19C8.6090508@samsung.com> References: <1415118568-18771-1-git-send-email-thierry.reding@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mailout1.w1.samsung.com (mailout1.w1.samsung.com [210.118.77.11]) by gabe.freedesktop.org (Postfix) with ESMTP id EB2336E8DC for ; Wed, 5 Nov 2014 04:36:28 -0800 (PST) Received: from eucpsbgm2.samsung.com (unknown [203.254.199.245]) by mailout1.w1.samsung.com (Oracle Communications Messaging Server 7u4-24.01(7.0.4.24.0) 64bit (built Nov 17 2011)) with ESMTP id <0NEK00AJ4GHKDZ80@mailout1.w1.samsung.com> for dri-devel@lists.freedesktop.org; Wed, 05 Nov 2014 12:39:20 +0000 (GMT) In-reply-to: <1415118568-18771-1-git-send-email-thierry.reding@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Thierry Reding , Greg Kroah-Hartman Cc: Daniel Vetter , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gMTEvMDQvMjAxNCAwNToyOSBQTSwgVGhpZXJyeSBSZWRpbmcgd3JvdGU6Cj4gRnJvbTogVGhp ZXJyeSBSZWRpbmcgPHRyZWRpbmdAbnZpZGlhLmNvbT4KPiAKPiBBZGQgYSBnZW5lcmljIGltcGxl bWVudGF0aW9uIG9mIGFuIG9iamVjdCByZWdpc3RyeS4gVGhpcyB0YXJnZXRzIGRyaXZlcnMKPiBh bmQgc3Vic3lzdGVtcyB0aGF0IHByb3ZpZGUgYXV4aWxpYXJ5IG9iamVjdHMgdGhhdCBvdGhlciBk cml2ZXJzIG5lZWQgdG8KPiBsb29rIHVwLiBUaGUgZ29hbCBpcyB0byBwdXQgdGhlIGRpZmZpY3Vs dCBwYXJ0cyAoa2VlcCBvYmplY3QgcmVmZXJlbmNlcywKPiBtb2R1bGUgdXNhZ2UgY291bnQsIC4u LikgaW50byBjb3JlIGNvZGUgc28gdGhhdCBpbmRpdmlkdWFsIHN1YnN5c3RlbXMgZG8KPiBub3Qg aGF2ZSB0byBkZWFsIHdpdGggdGhlbS4KPiAKPiBUaGUgaW50ZW50aW9uIGlzIGZvciBzdWJzeXN0 ZW1zIHRvIGluc3RhbnRpYXRlIGEgc3RydWN0IHJlZ2lzdHJ5IGFuZCB1c2UKPiBhIHN0cnVjdCBy ZWdpc3RyeV9yZWNvcmQgZW1iZWRkZWQgaW50byBhIHN1YnN5c3RlbS1zcGVjaWZpYyBzdHJ1Y3R1 cmUgdG8KPiBwcm92aWRlIGEgc3Vic3lzdGVtLXNwZWNpZmljIEFQSSBhcm91bmQgdGhhdC4KCgpB cyBJIHVuZGVyc3RhbmQgeW91IHdhbnQgdG8gdXNlIHRoaXMgcmVnaXN0cnkgZm9yIHBhbmVscyBh bmQgYnJpZGdlcy4KQ291bGQgeW91IGV4cGxhaW4gdGhlIGlkZWEgYW5kIGRlc2NyaWJlIGV4YW1w bGUgc2NlbmFyaW8gd2hlbiB0aGVzZQpyZWZjb3VudGluZ3MgYXJlIHVzZWZ1bC4gSSBndWVzcyBp dCBzaG91bGQgYmUgd2hlbiBwYW5lbCBhdHRhY2hlZCB0bwpkcm1kcnYgd2FudCB0byBkaXNhcHBl YXIuCgpSZWFsIGxpZmV0aW1lIG9mIHBhbmVsIGlzIGxpbWl0ZWQgYnkgcHJvYmUvcmVtb3ZlIGNh bGxiYWNrcyBvZiBwYW5lbApkcml2ZXIsIGRvIHlvdSB3YW50IHRvIHByb2xvbmcgaXQgYmVoaW5k IHRoZXNlIGxpbWl0cz8KRG8geW91IHdhbnQgdG8gaGF2ZSB6b21iaWUgcGFuZWxzLCB3aXRob3V0 IGhhcmR3YXJlIHRoZXkgYWJzdHJhY3Q/IEZvcgp3aGF0IHB1cnBvc2U/CldoYXQgZG8geW91IHdh bnQgdG8gZG8gd2l0aCBwYW5lbCBvcHM/IERvIHRoZXkgbmVlZCBzdXBwb3J0IGJvdGggbGlmZQpz dGF0ZXM/CgpBbnl3YXkgaW1wbGVtZW50YXRpb24gY3VycmVudGx5IHNlZW1zIHRvIGJlIGJyb2tl biwgeW91IHRyeSB0byByZWZjb3VudApvYmplY3RzIHdoaWNoIGFyZSB1c3VhbGx5IGVtYmVkZGVk IGluIGRyaXZlciBwcml2IGRhdGEsIHdoaWNoIGRpc2FwcGVhcnMKZHVyaW5nIHJlbW92ZSBjYWxs YmFjayBvZiB0aGUgZHJpdmVyLgoKUmVnYXJkcwpBbmRyemVqCgo+IAo+IFNpZ25lZC1vZmYtYnk6 IFRoaWVycnkgUmVkaW5nIDx0cmVkaW5nQG52aWRpYS5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvYmFz ZS9NYWtlZmlsZSAgICB8ICAgMiArLQo+ICBkcml2ZXJzL2Jhc2UvcmVnaXN0cnkuYyAgfCAxNDcg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVk ZS9saW51eC9yZWdpc3RyeS5oIHwgIDYyICsrKysrKysrKysrKysrKysrKysrCj4gIDMgZmlsZXMg Y2hhbmdlZCwgMjEwIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiAgY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvYmFzZS9yZWdpc3RyeS5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNs dWRlL2xpbnV4L3JlZ2lzdHJ5LmgKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL01ha2Vm aWxlIGIvZHJpdmVycy9iYXNlL01ha2VmaWxlCj4gaW5kZXggNTNjM2ZlMWFlYjI5Li4yNTAyNjJk MWFmMmMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9iYXNlL01ha2VmaWxlCj4gKysrIGIvZHJpdmVy cy9iYXNlL01ha2VmaWxlCj4gQEAgLTQsNyArNCw3IEBAIG9iai15CQkJOj0gY29tcG9uZW50Lm8g Y29yZS5vIGJ1cy5vIGRkLm8gc3lzY29yZS5vIFwKPiAgCQkJICAgZHJpdmVyLm8gY2xhc3MubyBw bGF0Zm9ybS5vIFwKPiAgCQkJICAgY3B1Lm8gZmlybXdhcmUubyBpbml0Lm8gbWFwLm8gZGV2cmVz Lm8gXAo+ICAJCQkgICBhdHRyaWJ1dGVfY29udGFpbmVyLm8gdHJhbnNwb3J0X2NsYXNzLm8gXAo+ IC0JCQkgICB0b3BvbG9neS5vIGNvbnRhaW5lci5vIHByb3BlcnR5Lm8KPiArCQkJICAgdG9wb2xv Z3kubyBjb250YWluZXIubyBwcm9wZXJ0eS5vIHJlZ2lzdHJ5Lm8KPiAgb2JqLSQoQ09ORklHX0RF VlRNUEZTKQkrPSBkZXZ0bXBmcy5vCj4gIG9iai0kKENPTkZJR19ETUFfQ01BKSArPSBkbWEtY29u dGlndW91cy5vCj4gIG9iai15CQkJKz0gcG93ZXIvCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFz ZS9yZWdpc3RyeS5jIGIvZHJpdmVycy9iYXNlL3JlZ2lzdHJ5LmMKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uOWY1MTBmNjIzN2I3Cj4gLS0tIC9kZXYvbnVsbAo+ ICsrKyBiL2RyaXZlcnMvYmFzZS9yZWdpc3RyeS5jCj4gQEAgLTAsMCArMSwxNDcgQEAKPiArLyoK PiArICogQ29weXJpZ2h0IChDKSAyMDE0LCBOVklESUEgQ29ycG9yYXRpb24uICBBbGwgcmlnaHRz IHJlc2VydmVkLgo+ICsgKgo+ICsgKiBUaGlzIGZpbGUgaXMgcmVsZWFzZWQgdW5kZXIgdGhlIEdQ TCB2Mi4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3JlZ2lzdHJ5Lmg+Cj4gKwo+ICtz dGF0aWMgaW5saW5lIHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnRvX3JlZ2lzdHJ5X3JlY29yZChz dHJ1Y3Qga3JlZiAqa3JlZikKPiArewo+ICsJcmV0dXJuIGNvbnRhaW5lcl9vZihrcmVmLCBzdHJ1 Y3QgcmVnaXN0cnlfcmVjb3JkLCBrcmVmKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgcmVnaXN0 cnlfcmVjb3JkX3JlbGVhc2Uoc3RydWN0IGtyZWYgKmtyZWYpCj4gK3sKPiArCXN0cnVjdCByZWdp c3RyeV9yZWNvcmQgKnJlY29yZCA9IHRvX3JlZ2lzdHJ5X3JlY29yZChrcmVmKTsKPiArCj4gKwly ZWNvcmQtPnJlbGVhc2UocmVjb3JkKTsKPiArfQo+ICsKPiArLyoqCj4gKyAqIHJlZ2lzdHJ5X3Jl Y29yZF9pbml0IC0gaW5pdGlhbGl6ZSBhIHJlZ2lzdHJ5IHJlY29yZAo+ICsgKiBAcmVjb3JkOiBy ZWNvcmQgdG8gaW5pdGlhbGl6ZQo+ICsgKgo+ICsgKiBTZXRzIHVwIGludGVybmFsIGZpZWxkcyBv ZiB0aGUgcmVnaXN0cnkgcmVjb3JkIHNvIHRoYXQgaXQgY2FuIHN1YnNlcXVlbnRseQo+ICsgKiBi ZSBhZGRlZCB0byBhIHJlZ2lzdHJ5Lgo+ICsgKi8KPiArdm9pZCByZWdpc3RyeV9yZWNvcmRfaW5p dChzdHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWNvcmQpCj4gK3sKPiArCUlOSVRfTElTVF9IRUFE KCZyZWNvcmQtPmxpc3QpOwo+ICsJa3JlZl9pbml0KCZyZWNvcmQtPmtyZWYpOwo+ICt9Cj4gKwo+ ICsvKioKPiArICogcmVnaXN0cnlfcmVjb3JkX3JlZiAtIHJlZmVyZW5jZSBvbiB0aGUgcmVnaXN0 cnkgcmVjb3JkCj4gKyAqIEByZWNvcmQ6IHJlY29yZCB0byByZWZlcmVuY2UKPiArICoKPiArICog SW5jcmVhc2VzIHRoZSByZWZlcmVuY2UgY291bnQgb24gdGhlIHJlY29yZCBhbmQgcmV0dXJucyBh IHBvaW50ZXIgdG8gaXQuCj4gKyAqCj4gKyAqIFJldHVybjogQSBwb2ludGVyIHRvIHRoZSByZWNv cmQgb24gc3VjY2VzcyBvciBOVUxMIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtzdHJ1Y3QgcmVnaXN0 cnlfcmVjb3JkICpyZWdpc3RyeV9yZWNvcmRfcmVmKHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnJl Y29yZCkKPiArewo+ICsJaWYgKCFyZWNvcmQpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJLyoK PiArCSAqIFJlZnVzZSB0byBnaXZlIG91dCBhbnkgbW9yZSByZWZlcmVuY2VzIGlmIHRoZSBtb2R1 bGUgb3duaW5nIHRoZQo+ICsJICogcmVjb3JkIGlzIGJlaW5nIHJlbW92ZWQuCj4gKwkgKi8KPiAr CWlmICghdHJ5X21vZHVsZV9nZXQocmVjb3JkLT5vd25lcikpCj4gKwkJcmV0dXJuIE5VTEw7Cj4g Kwo+ICsJa3JlZl9nZXQoJnJlY29yZC0+a3JlZik7Cj4gKwo+ICsJcmV0dXJuIHJlY29yZDsKPiAr fQo+ICsKPiArLyoqCj4gKyAqIHJlZ2lzdHJ5X3JlY29yZF91bnJlZiAtIGRyb3AgYSByZWZlcmVu Y2UgdG8gYSByZWdpc3RyeSByZWNvcmQKPiArICogQHJlY29yZDogcmVjb3JkIHRvIHVucmVmZXJl bmNlCj4gKyAqCj4gKyAqIERlY3JlYXNlcyB0aGUgcmVmZXJlbmNlIGNvdW50IG9uIHRoZSByZWNv cmQuIFdoZW4gdGhlIHJlZmVyZW5jZSBjb3VudAo+ICsgKiByZWFjaGVzIHplcm8gdGhlIHJlY29y ZCB3aWxsIGJlIGRlc3Ryb3llZC4KPiArICovCj4gK3ZvaWQgcmVnaXN0cnlfcmVjb3JkX3VucmVm KHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnJlY29yZCkKPiArewo+ICsJaWYgKHJlY29yZCkgewo+ ICsJCS8qCj4gKwkJICogS2VlcCBhIGNvcHkgb2YgdGhlIG1vZHVsZSBvd25lciBzaW5jZSB0aGUg cmVjb3JkIG1heQo+ICsJCSAqIGRpc2FwcGVhciBkdXJpbmcgdGhlIGtyZWZfcHV0KCkuCj4gKwkJ ICovCj4gKwkJc3RydWN0IG1vZHVsZSAqb3duZXIgPSByZWNvcmQtPm93bmVyOwo+ICsKPiArCQlr cmVmX3B1dCgmcmVjb3JkLT5rcmVmLCByZWdpc3RyeV9yZWNvcmRfcmVsZWFzZSk7Cj4gKwkJbW9k dWxlX3B1dChvd25lcik7Cj4gKwl9Cj4gK30KPiArCj4gKy8qKgo+ICsgKiByZWdpc3RyeV9hZGQg LSBhZGQgYSByZWNvcmQgdG8gYSByZWdpc3RyeQo+ICsgKiBAcmVnaXN0cnk6IHJlZ2lzdHJ5IHRv IGFkZCB0aGUgcmVjb3JkIHRvCj4gKyAqIEByZWNvcmQ6IHJlY29yZCB0byBhZGQKPiArICoKPiAr ICogVHJpZXMgdG8gaW5jcmVhc2UgdGhlIHJlZmVyZW5jZSBjb3VudCBvZiB0aGUgbW9kdWxlIG93 bmluZyB0aGUgcmVnaXN0cnkuIElmCj4gKyAqIHN1Y2Nlc3NmdWwgYWRkcyB0aGUgbmV3IHJlY29y ZCB0byB0aGUgcmVnaXN0cnkuCj4gKyAqCj4gKyAqIFJldHVybjogMCBvbiBzdWNjZXNzIG9yIGEg bmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiAraW50IHJlZ2lzdHJ5X2Fk ZChzdHJ1Y3QgcmVnaXN0cnkgKnJlZ2lzdHJ5LCBzdHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWNv cmQpCj4gK3sKPiArCWlmICghdHJ5X21vZHVsZV9nZXQocmVnaXN0cnktPm93bmVyKSkKPiArCQly ZXR1cm4gLUVOT0RFVjsKPiArCj4gKwltdXRleF9sb2NrKCZyZWdpc3RyeS0+bG9jayk7Cj4gKwls aXN0X2FkZF90YWlsKCZyZWNvcmQtPmxpc3QsICZyZWdpc3RyeS0+bGlzdCk7Cj4gKwltdXRleF91 bmxvY2soJnJlZ2lzdHJ5LT5sb2NrKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArLyoq Cj4gKyAqIHJlZ2lzdHJ5X3JlbW92ZSAtIHJlbW92ZSBhIHJlY29yZCBmcm9tIGEgcmVnaXN0cnkK PiArICogQHJlZ2lzdHJ5OiByZWdpc3RyeSB0byByZW1vdmUgdGhlIHJlY29yZCBmcm9tCj4gKyAq IEByZWNvcmQ6IHJlY29yZCB0byByZW1vdmUKPiArICoKPiArICogRGVjcmVhc2VzIHRoZSByZWZl cmVuY2UgY291bnQgb24gdGhlIG1vZHVsZSBvd25pbmcgdGhlIHJlZ2lzdHJ5Lgo+ICsgKi8KPiAr dm9pZCByZWdpc3RyeV9yZW1vdmUoc3RydWN0IHJlZ2lzdHJ5ICpyZWdpc3RyeSwKPiArCQkgICAg IHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnJlY29yZCkKPiArewo+ICsJbXV0ZXhfbG9jaygmcmVn aXN0cnktPmxvY2spOwo+ICsJbGlzdF9kZWxfaW5pdCgmcmVjb3JkLT5saXN0KTsKPiArCW11dGV4 X3VubG9jaygmcmVnaXN0cnktPmxvY2spOwo+ICsKPiArCW1vZHVsZV9wdXQocmVnaXN0cnktPm93 bmVyKTsKPiArfQo+ICsKPiArI2lmZGVmIENPTkZJR19PRgo+ICsvKioKPiArICogcmVnaXN0cnlf ZmluZF9ieV9vZl9ub2RlIC0gbG9vayB1cCBhbiBvYmplY3QgYnkgZGV2aWNlIG5vZGUgaW4gYSBy ZWdpc3RyeQo+ICsgKiBAcmVnaXN0cnk6IHJlZ2lzdHJ5IHRvIHNlYXJjaAo+ICsgKiBAbnA6IGRl dmljZSBub2RlIHRvIG1hdGNoIG9uCj4gKyAqCj4gKyAqIFJldHVybjogQSBwb2ludGVyIHRvIHRo ZSByZWNvcmQgbWF0Y2hpbmcgQG5wIG9yIE5VTEwgaWYgbm8gc3VjaCByZWNvcmQgd2FzCj4gKyAq IGZvdW5kLgo+ICsgKi8KPiArc3RydWN0IHJlZ2lzdHJ5X3JlY29yZCAqcmVnaXN0cnlfZmluZF9i eV9vZl9ub2RlKHN0cnVjdCByZWdpc3RyeSAqcmVnaXN0cnksCj4gKwkJCQkJCSBzdHJ1Y3QgZGV2 aWNlX25vZGUgKm5wKQo+ICt7Cj4gKwlzdHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWNvcmQ7Cj4g Kwo+ICsJbXV0ZXhfbG9jaygmcmVnaXN0cnktPmxvY2spOwo+ICsKPiArCWxpc3RfZm9yX2VhY2hf ZW50cnkocmVjb3JkLCAmcmVnaXN0cnktPmxpc3QsIGxpc3QpCj4gKwkJaWYgKHJlY29yZC0+ZGV2 LT5vZl9ub2RlID09IG5wKQo+ICsJCQlnb3RvIG91dDsKPiArCj4gKwlyZWNvcmQgPSBOVUxMOwo+ ICsKPiArb3V0Ogo+ICsJbXV0ZXhfdW5sb2NrKCZyZWdpc3RyeS0+bG9jayk7Cj4gKwlyZXR1cm4g cmVjb3JkOwo+ICt9Cj4gKyNlbmRpZgo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3JlZ2lz dHJ5LmggYi9pbmNsdWRlL2xpbnV4L3JlZ2lzdHJ5LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ IGluZGV4IDAwMDAwMDAwMDAwMC4uYTgwN2Y0MTI0NzM2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBi L2luY2x1ZGUvbGludXgvcmVnaXN0cnkuaAo+IEBAIC0wLDAgKzEsNjIgQEAKPiArLyoKPiArICog Q29weXJpZ2h0IChDKSAyMDE0LCBOVklESUEgQ29ycG9yYXRpb24uICBBbGwgcmlnaHRzIHJlc2Vy dmVkLgo+ICsgKgo+ICsgKiBUaGlzIGZpbGUgaXMgcmVsZWFzZWQgdW5kZXIgdGhlIEdQTCB2Mi4K PiArICovCj4gKwo+ICsjaWZuZGVmIF9fTElOVVhfUkVHSVNUUllfSAo+ICsjZGVmaW5lIF9fTElO VVhfUkVHSVNUUllfSAo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2tyZWYuaD4KPiArI2luY2x1ZGUg PGxpbnV4L2xpc3QuaD4KPiArI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKwo+ICtzdHJ1Y3Qg ZGV2aWNlOwo+ICtzdHJ1Y3QgZGV2aWNlX25vZGU7Cj4gK3N0cnVjdCBtb2R1bGU7Cj4gKwo+ICtz dHJ1Y3QgcmVnaXN0cnk7Cj4gKwo+ICsvKioKPiArICogc3RydWN0IHJlZ2lzdHJ5X3JlY29yZCAt IHJlZ2lzdHJ5IHJlY29yZCBvYmplY3QKPiArICogQGxpc3Q6IGVudHJ5IGluIHJlZ2lzdHJ5IGZv ciB0aGlzIHJlY29yZAo+ICsgKiBAb3duZXI6IG93bmVyIG1vZHVsZQo+ICsgKiBAa3JlZjogcmVm ZXJlbmNlIGNvdW50Cj4gKyAqIEBkZXY6IHBhcmVudCBkZXZpY2UKPiArICogQHJlbGVhc2U6IGNh bGxiYWNrIHRvIGRlc3Ryb3kgYSByZWNvcmQgd2hlbiBubyByZWZlcmVuY2UgYXJlIGxlZnQKPiAr ICovCj4gK3N0cnVjdCByZWdpc3RyeV9yZWNvcmQgewo+ICsJc3RydWN0IGxpc3RfaGVhZCBsaXN0 Owo+ICsJc3RydWN0IG1vZHVsZSAqb3duZXI7Cj4gKwlzdHJ1Y3Qga3JlZiBrcmVmOwo+ICsJc3Ry dWN0IGRldmljZSAqZGV2Owo+ICsKPiArCXZvaWQgKCpyZWxlYXNlKShzdHJ1Y3QgcmVnaXN0cnlf cmVjb3JkICpyZWNvcmQpOwo+ICt9Owo+ICsKPiArdm9pZCByZWdpc3RyeV9yZWNvcmRfaW5pdChz dHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWNvcmQpOwo+ICtzdHJ1Y3QgcmVnaXN0cnlfcmVjb3Jk ICpyZWdpc3RyeV9yZWNvcmRfcmVmKHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnJlY29yZCk7Cj4g K3ZvaWQgcmVnaXN0cnlfcmVjb3JkX3VucmVmKHN0cnVjdCByZWdpc3RyeV9yZWNvcmQgKnJlY29y ZCk7Cj4gKwo+ICsvKioKPiArICogc3RydWN0IHJlZ2lzdHJ5IC0gZ2VuZXJpYyBvYmplY3QgcmVn aXN0cnkKPiArICogQGxpc3Q6IGxpc3QgaGVhZCBvZiBvYmplY3RzCj4gKyAqIEBvd25lcjogb3du ZXIgbW9kdWxlCj4gKyAqIEBsb2NrOiBsb2NrIGZvciBvYmplY3QgbGlzdAo+ICsgKi8KPiArc3Ry dWN0IHJlZ2lzdHJ5IHsKPiArCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKPiArCXN0cnVjdCBtb2R1 bGUgKm93bmVyOwo+ICsJc3RydWN0IG11dGV4IGxvY2s7Cj4gK307Cj4gKwo+ICtpbnQgcmVnaXN0 cnlfYWRkKHN0cnVjdCByZWdpc3RyeSAqcmVnaXN0cnksIHN0cnVjdCByZWdpc3RyeV9yZWNvcmQg KnJlY29yZCk7Cj4gK3ZvaWQgcmVnaXN0cnlfcmVtb3ZlKHN0cnVjdCByZWdpc3RyeSAqcmVnaXN0 cnksCj4gKwkJICAgICBzdHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWNvcmQpOwo+ICsKPiArI2lm ZGVmIENPTkZJR19PRgo+ICtzdHJ1Y3QgcmVnaXN0cnlfcmVjb3JkICpyZWdpc3RyeV9maW5kX2J5 X29mX25vZGUoc3RydWN0IHJlZ2lzdHJ5ICpyZWdpc3RyeSwKPiArCQkJCQkJIHN0cnVjdCBkZXZp Y2Vfbm9kZSAqbnApOwo+ICsjZW5kaWYKPiArCj4gKyNlbmRpZgo+IAoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5v 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 S1754823AbaKEMga (ORCPT ); Wed, 5 Nov 2014 07:36:30 -0500 Received: from mailout1.w1.samsung.com ([210.118.77.11]:36554 "EHLO mailout1.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754643AbaKEMg3 (ORCPT ); Wed, 5 Nov 2014 07:36:29 -0500 X-AuditID: cbfec7f5-b7f956d000005ed7-2b-545a19ca2fb6 Message-id: <545A19C8.6090508@samsung.com> Date: Wed, 05 Nov 2014 13:36:24 +0100 From: Andrzej Hajda User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.2.0 MIME-version: 1.0 To: Thierry Reding , Greg Kroah-Hartman Cc: Daniel Vetter , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [RFC 1/2] core: Add generic object registry implementation References: <1415118568-18771-1-git-send-email-thierry.reding@gmail.com> In-reply-to: <1415118568-18771-1-git-send-email-thierry.reding@gmail.com> Content-type: text/plain; charset=utf-8 Content-transfer-encoding: 7bit X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFlrPLMWRmVeSWpSXmKPExsVy+t/xq7qnJKNCDHrbJSwWPrzLbHHl63s2 i+bF69ksLu+aw2bxc9c8FgdWj73fFrB47Jx1l91j/9w17B73u48zeXzeJBfAGsVlk5Kak1mW WqRvl8CVceryGsaCLueKts+PGBsYl5t2MXJySAiYSOx+v4URwhaTuHBvPVsXIxeHkMBSRon3 73cyQzifGCVetWwFynBw8ApoSTz9IwvSwCKgKvG1eRU7iM0moCnxd/NNNhBbVCBC4sqaOWBD eQUEJX5MvscC0ioikCDx5IgMiMkskC1xZ74dSIWwgLvEvZXXwKqFBDwkFm86ygJicwp4SnTd 3soKUa4uMWVKLkiYWUBeYvOat8wTGAVmIZk/C6FqFpKqBYzMqxhFU0uTC4qT0nON9IoTc4tL 89L1kvNzNzFCAvnrDsalx6wOMQpwMCrx8Ho0RYYIsSaWFVfmHmKU4GBWEuFlEIkKEeJNSays Si3Kjy8qzUktPsTIxMEp1cBo3zfvksHK8MkL1XRbyg4skNXeuNeLt8Jsu1zlGjPGiDt77ytO 0JpfzG+7xNTCbHqQ04HVZSuitrsnK5kZS7aGtOcq6ou9nyiia/ZF6yR7FMNRhm+Wez9tnfqW 37/rNe/SmgNB6zKZNA51sd86f+tUGZ/uVmP97Y8Sp8/Rnnxkxz6bJP/Nh7YpsRRnJBpqMRcV JwIAhfyZ90ICAAA= Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 11/04/2014 05:29 PM, Thierry Reding wrote: > From: Thierry Reding > > Add a generic implementation of an object registry. This targets drivers > and subsystems that provide auxiliary objects that other drivers need to > look up. The goal is to put the difficult parts (keep object references, > module usage count, ...) into core code so that individual subsystems do > not have to deal with them. > > The intention is for subsystems to instantiate a struct registry and use > a struct registry_record embedded into a subsystem-specific structure to > provide a subsystem-specific API around that. As I understand you want to use this registry for panels and bridges. Could you explain the idea and describe example scenario when these refcountings are useful. I guess it should be when panel attached to drmdrv want to disappear. Real lifetime of panel is limited by probe/remove callbacks of panel driver, do you want to prolong it behind these limits? Do you want to have zombie panels, without hardware they abstract? For what purpose? What do you want to do with panel ops? Do they need support both life states? Anyway implementation currently seems to be broken, you try to refcount objects which are usually embedded in driver priv data, which disappears during remove callback of the driver. Regards Andrzej > > Signed-off-by: Thierry Reding > --- > drivers/base/Makefile | 2 +- > drivers/base/registry.c | 147 +++++++++++++++++++++++++++++++++++++++++++++++ > include/linux/registry.h | 62 ++++++++++++++++++++ > 3 files changed, 210 insertions(+), 1 deletion(-) > create mode 100644 drivers/base/registry.c > create mode 100644 include/linux/registry.h > > diff --git a/drivers/base/Makefile b/drivers/base/Makefile > index 53c3fe1aeb29..250262d1af2c 100644 > --- a/drivers/base/Makefile > +++ b/drivers/base/Makefile > @@ -4,7 +4,7 @@ obj-y := component.o core.o bus.o dd.o syscore.o \ > driver.o class.o platform.o \ > cpu.o firmware.o init.o map.o devres.o \ > attribute_container.o transport_class.o \ > - topology.o container.o property.o > + topology.o container.o property.o registry.o > obj-$(CONFIG_DEVTMPFS) += devtmpfs.o > obj-$(CONFIG_DMA_CMA) += dma-contiguous.o > obj-y += power/ > diff --git a/drivers/base/registry.c b/drivers/base/registry.c > new file mode 100644 > index 000000000000..9f510f6237b7 > --- /dev/null > +++ b/drivers/base/registry.c > @@ -0,0 +1,147 @@ > +/* > + * Copyright (C) 2014, NVIDIA Corporation. All rights reserved. > + * > + * This file is released under the GPL v2. > + */ > + > +#include > +#include > +#include > + > +static inline struct registry_record *to_registry_record(struct kref *kref) > +{ > + return container_of(kref, struct registry_record, kref); > +} > + > +static void registry_record_release(struct kref *kref) > +{ > + struct registry_record *record = to_registry_record(kref); > + > + record->release(record); > +} > + > +/** > + * registry_record_init - initialize a registry record > + * @record: record to initialize > + * > + * Sets up internal fields of the registry record so that it can subsequently > + * be added to a registry. > + */ > +void registry_record_init(struct registry_record *record) > +{ > + INIT_LIST_HEAD(&record->list); > + kref_init(&record->kref); > +} > + > +/** > + * registry_record_ref - reference on the registry record > + * @record: record to reference > + * > + * Increases the reference count on the record and returns a pointer to it. > + * > + * Return: A pointer to the record on success or NULL on failure. > + */ > +struct registry_record *registry_record_ref(struct registry_record *record) > +{ > + if (!record) > + return NULL; > + > + /* > + * Refuse to give out any more references if the module owning the > + * record is being removed. > + */ > + if (!try_module_get(record->owner)) > + return NULL; > + > + kref_get(&record->kref); > + > + return record; > +} > + > +/** > + * registry_record_unref - drop a reference to a registry record > + * @record: record to unreference > + * > + * Decreases the reference count on the record. When the reference count > + * reaches zero the record will be destroyed. > + */ > +void registry_record_unref(struct registry_record *record) > +{ > + if (record) { > + /* > + * Keep a copy of the module owner since the record may > + * disappear during the kref_put(). > + */ > + struct module *owner = record->owner; > + > + kref_put(&record->kref, registry_record_release); > + module_put(owner); > + } > +} > + > +/** > + * registry_add - add a record to a registry > + * @registry: registry to add the record to > + * @record: record to add > + * > + * Tries to increase the reference count of the module owning the registry. If > + * successful adds the new record to the registry. > + * > + * Return: 0 on success or a negative error code on failure. > + */ > +int registry_add(struct registry *registry, struct registry_record *record) > +{ > + if (!try_module_get(registry->owner)) > + return -ENODEV; > + > + mutex_lock(®istry->lock); > + list_add_tail(&record->list, ®istry->list); > + mutex_unlock(®istry->lock); > + > + return 0; > +} > + > +/** > + * registry_remove - remove a record from a registry > + * @registry: registry to remove the record from > + * @record: record to remove > + * > + * Decreases the reference count on the module owning the registry. > + */ > +void registry_remove(struct registry *registry, > + struct registry_record *record) > +{ > + mutex_lock(®istry->lock); > + list_del_init(&record->list); > + mutex_unlock(®istry->lock); > + > + module_put(registry->owner); > +} > + > +#ifdef CONFIG_OF > +/** > + * registry_find_by_of_node - look up an object by device node in a registry > + * @registry: registry to search > + * @np: device node to match on > + * > + * Return: A pointer to the record matching @np or NULL if no such record was > + * found. > + */ > +struct registry_record *registry_find_by_of_node(struct registry *registry, > + struct device_node *np) > +{ > + struct registry_record *record; > + > + mutex_lock(®istry->lock); > + > + list_for_each_entry(record, ®istry->list, list) > + if (record->dev->of_node == np) > + goto out; > + > + record = NULL; > + > +out: > + mutex_unlock(®istry->lock); > + return record; > +} > +#endif > diff --git a/include/linux/registry.h b/include/linux/registry.h > new file mode 100644 > index 000000000000..a807f4124736 > --- /dev/null > +++ b/include/linux/registry.h > @@ -0,0 +1,62 @@ > +/* > + * Copyright (C) 2014, NVIDIA Corporation. All rights reserved. > + * > + * This file is released under the GPL v2. > + */ > + > +#ifndef __LINUX_REGISTRY_H > +#define __LINUX_REGISTRY_H > + > +#include > +#include > +#include > + > +struct device; > +struct device_node; > +struct module; > + > +struct registry; > + > +/** > + * struct registry_record - registry record object > + * @list: entry in registry for this record > + * @owner: owner module > + * @kref: reference count > + * @dev: parent device > + * @release: callback to destroy a record when no reference are left > + */ > +struct registry_record { > + struct list_head list; > + struct module *owner; > + struct kref kref; > + struct device *dev; > + > + void (*release)(struct registry_record *record); > +}; > + > +void registry_record_init(struct registry_record *record); > +struct registry_record *registry_record_ref(struct registry_record *record); > +void registry_record_unref(struct registry_record *record); > + > +/** > + * struct registry - generic object registry > + * @list: list head of objects > + * @owner: owner module > + * @lock: lock for object list > + */ > +struct registry { > + struct list_head list; > + struct module *owner; > + struct mutex lock; > +}; > + > +int registry_add(struct registry *registry, struct registry_record *record); > +void registry_remove(struct registry *registry, > + struct registry_record *record); > + > +#ifdef CONFIG_OF > +struct registry_record *registry_find_by_of_node(struct registry *registry, > + struct device_node *np); > +#endif > + > +#endif >