From mboxrd@z Thu Jan 1 00:00:00 1970 From: Maarten Lankhorst Subject: Re: [PATCH v3] dma-buf: cleanup dma_buf_export() to make it easily extensible Date: Wed, 28 Jan 2015 16:00:12 +0100 Message-ID: <54C8F97C.2040208@canonical.com> References: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Sumit Semwal , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-arm-kernel@lists.infradead.org, rmk+kernel@arm.linux.org.uk, airlied@linux.ie, kgene@kernel.org, daniel.vetter@intel.com, thierry.reding@gmail.com, pawel@osciak.com, m.szyprowski@samsung.com, mchehab@osg.samsung.com, gregkh@linuxfoundation.org Cc: linux-tegra@vger.kernel.org, intel-gfx@lists.freedesktop.org, linaro-kernel@lists.linaro.org List-Id: linux-tegra@vger.kernel.org T3AgMjgtMDEtMTUgb20gMTM6NTQgc2NocmVlZiBTdW1pdCBTZW13YWw6Cj4gQXQgcHJlc2VudCwg ZG1hX2J1Zl9leHBvcnQoKSB0YWtlcyBhIHNlcmllcyBvZiBwYXJhbWV0ZXJzLCB3aGljaAo+IG1h a2VzIGl0IGRpZmZpY3VsdCB0byBhZGQgYW55IG5ldyBwYXJhbWV0ZXJzIGZvciBleHBvcnRlcnMs IGlmIHJlcXVpcmVkLgo+Cj4gTWFrZSBpdCBzaW1wbGVyIGJ5IG1vdmluZyBhbGwgdGhlc2UgcGFy YW1ldGVycyBpbnRvIGEgc3RydWN0LCBhbmQgcGFzcwo+IHRoZSBzdHJ1Y3QgKiBhcyBwYXJhbWV0 ZXIgdG8gZG1hX2J1Zl9leHBvcnQoKS4KPgo+IFdoaWxlIGF0IGl0LCB1bml0ZSBkbWFfYnVmX2V4 cG9ydF9uYW1lZCgpIHdpdGggZG1hX2J1Zl9leHBvcnQoKSwgYW5kCj4gY2hhbmdlIGFsbCBjYWxs ZXJzIGFjY29yZGluZ2x5Lgo+Cj4gU2lnbmVkLW9mZi1ieTogU3VtaXQgU2Vtd2FsIDxzdW1pdC5z ZW13YWxAbGluYXJvLm9yZz4KPiAtLS0KPiB2MzogRGFuaWVsIFRob21wc29uIGNhdWdodCB0aGUg Qzk5IHdhcm5pbmcgaXNzdWUgdy8gdXNpbmcgezB9OyB1c2luZwo+ICAgICB7LmV4cF9uYW1lID0g eHh4fSBpbnN0ZWFkLgo+Cj4gdjI6IGFkZCBtYWNybyB0byB6ZXJvIG91dCBsb2NhbCBzdHJ1Y3Qs IGFuZCBmaWxsIEtCVUlMRF9NT0ROQU1FIGJ5IGRlZmF1bHQKPgo+ICBkcml2ZXJzL2RtYS1idWYv ZG1hLWJ1Zi5jICAgICAgICAgICAgICAgICAgICAgIHwgNDcgKysrKysrKysrKysrKy0tLS0tLS0t LS0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMgICAgICAgICAgICB8 IDEwICsrKystLQo+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX3ByaW1lLmMgICAgICAgICAgICAgICAg ICAgIHwgMTIgKysrKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZG1h YnVmLmMgICAgIHwgIDkgKysrLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZG1h YnVmLmMgICAgICAgICB8IDEwICsrKystLQo+ICBkcml2ZXJzL2dwdS9kcm0vb21hcGRybS9vbWFw X2dlbV9kbWFidWYuYyAgICAgIHwgIDkgKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dl bS5jICAgICAgICAgICAgICAgICAgICB8IDEwICsrKystLQo+ICBkcml2ZXJzL2dwdS9kcm0vdHRt L3R0bV9vYmplY3QuYyAgICAgICAgICAgICAgIHwgIDkgKysrLS0KPiAgZHJpdmVycy9ncHUvZHJt L3VkbC91ZGxfZG1hYnVmLmMgICAgICAgICAgICAgICB8ICA5ICsrKystCj4gIGRyaXZlcnMvbWVk aWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMgfCAgOCArKysrLQo+ICBkcml2ZXJz L21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItZG1hLXNnLmMgICAgIHwgIDggKysrKy0KPiAgZHJp dmVycy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLXZtYWxsb2MuYyAgICB8ICA4ICsrKystCj4g IGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYyAgICAgICAgICAgICAgfCAgOSArKyst LQo+ICBpbmNsdWRlL2xpbnV4L2RtYS1idWYuaCAgICAgICAgICAgICAgICAgICAgICAgIHwgMzQg KysrKysrKysrKysrKysrLS0tLQo+ICAxNCBmaWxlcyBjaGFuZ2VkLCAxNDIgaW5zZXJ0aW9ucygr KSwgNTAgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2RtYS1i dWYuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMKPiBpbmRleCA1YmUyMjVjMmJhOTguLjZk M2RmM2RkOTMxMCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gKysr IGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwo+IEBAIC0yNjUsNyArMjY1LDcgQEAgc3RhdGlj IGlubGluZSBpbnQgaXNfZG1hX2J1Zl9maWxlKHN0cnVjdCBmaWxlICpmaWxlKQo+ICB9Cj4gIAo+ ICAvKioKPiAtICogZG1hX2J1Zl9leHBvcnRfbmFtZWQgLSBDcmVhdGVzIGEgbmV3IGRtYV9idWYs IGFuZCBhc3NvY2lhdGVzIGFuIGFub24gZmlsZQo+ICsgKiBkbWFfYnVmX2V4cG9ydCAtIENyZWF0 ZXMgYSBuZXcgZG1hX2J1ZiwgYW5kIGFzc29jaWF0ZXMgYW4gYW5vbiBmaWxlCj4gICAqIHdpdGgg dGhpcyBidWZmZXIsIHNvIGl0IGNhbiBiZSBleHBvcnRlZC4KPiAgICogQWxzbyBjb25uZWN0IHRo ZSBhbGxvY2F0b3Igc3BlY2lmaWMgZGF0YSBhbmQgb3BzIHRvIHRoZSBidWZmZXIuCj4gICAqIEFk ZGl0aW9uYWxseSwgcHJvdmlkZSBhIG5hbWUgc3RyaW5nIGZvciBleHBvcnRlcjsgdXNlZnVsIGlu IGRlYnVnZ2luZy4KPiBAQCAtMjc3LDMxICsyNzcsMzIgQEAgc3RhdGljIGlubGluZSBpbnQgaXNf ZG1hX2J1Zl9maWxlKHN0cnVjdCBmaWxlICpmaWxlKQo+ICAgKiBAZXhwX25hbWU6CVtpbl0JbmFt ZSBvZiB0aGUgZXhwb3J0aW5nIG1vZHVsZSAtIHVzZWZ1bCBmb3IgZGVidWdnaW5nLgo+ICAgKiBA cmVzdjoJW2luXQlyZXNlcnZhdGlvbi1vYmplY3QsIE5VTEwgdG8gYWxsb2NhdGUgZGVmYXVsdCBv bmUuCj4gICAqCj4gKyAqIEFsbCB0aGUgYWJvdmUgaW5mbyBjb21lcyBmcm9tIHN0cnVjdCBkbWFf YnVmX2V4cG9ydF9pbmZvLgo+ICsgKgo+ICAgKiBSZXR1cm5zLCBvbiBzdWNjZXNzLCBhIG5ld2x5 IGNyZWF0ZWQgZG1hX2J1ZiBvYmplY3QsIHdoaWNoIHdyYXBzIHRoZQo+ICAgKiBzdXBwbGllZCBw cml2YXRlIGRhdGEgYW5kIG9wZXJhdGlvbnMgZm9yIGRtYV9idWZfb3BzLiBPbiBlaXRoZXIgbWlz c2luZwo+ICAgKiBvcHMsIG9yIGVycm9yIGluIGFsbG9jYXRpbmcgc3RydWN0IGRtYV9idWYsIHdp bGwgcmV0dXJuIG5lZ2F0aXZlIGVycm9yLgo+ICAgKgo+ICAgKi8KPiAtc3RydWN0IGRtYV9idWYg KmRtYV9idWZfZXhwb3J0X25hbWVkKHZvaWQgKnByaXYsIGNvbnN0IHN0cnVjdCBkbWFfYnVmX29w cyAqb3BzLAo+IC0JCQkJc2l6ZV90IHNpemUsIGludCBmbGFncywgY29uc3QgY2hhciAqZXhwX25h bWUsCj4gLQkJCQlzdHJ1Y3QgcmVzZXJ2YXRpb25fb2JqZWN0ICpyZXN2KQo+ICtzdHJ1Y3QgZG1h X2J1ZiAqZG1hX2J1Zl9leHBvcnQoc3RydWN0IGRtYV9idWZfZXhwb3J0X2luZm8gKmV4cF9pbmZv KQpUaGlzIGZ1bmN0aW9uIHNob3VsZCBwcm9iYWJseSB0YWtlIGEgY29uc3Qgc3RydWN0IGRtYV9i dWZfZXhwb3J0X2luZm8gaGVyZS4uCgpSZXN0IGxvb2tzIHNhbmUuCgp+TWFhcnRlbgoKCj4gIHsK PiAgCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Cj4gIAlzdHJ1Y3QgZmlsZSAqZmlsZTsKPiAgCXNp emVfdCBhbGxvY19zaXplID0gc2l6ZW9mKHN0cnVjdCBkbWFfYnVmKTsKPiAtCWlmICghcmVzdikK PiArCWlmICghZXhwX2luZm8tPnJlc3YpCj4gIAkJYWxsb2Nfc2l6ZSArPSBzaXplb2Yoc3RydWN0 IHJlc2VydmF0aW9uX29iamVjdCk7Cj4gIAllbHNlCj4gIAkJLyogcHJldmVudCAmZG1hX2J1Zlsx XSA9PSBkbWFfYnVmLT5yZXN2ICovCj4gIAkJYWxsb2Nfc2l6ZSArPSAxOwo+ICAKPiAtCWlmIChX QVJOX09OKCFwcml2IHx8ICFvcHMKPiAtCQkJICB8fCAhb3BzLT5tYXBfZG1hX2J1Zgo+IC0JCQkg IHx8ICFvcHMtPnVubWFwX2RtYV9idWYKPiAtCQkJICB8fCAhb3BzLT5yZWxlYXNlCj4gLQkJCSAg fHwgIW9wcy0+a21hcF9hdG9taWMKPiAtCQkJICB8fCAhb3BzLT5rbWFwCj4gLQkJCSAgfHwgIW9w cy0+bW1hcCkpIHsKPiArCWlmIChXQVJOX09OKCFleHBfaW5mby0+cHJpdgo+ICsJCQkgIHx8ICFl eHBfaW5mby0+b3BzCj4gKwkJCSAgfHwgIWV4cF9pbmZvLT5vcHMtPm1hcF9kbWFfYnVmCj4gKwkJ CSAgfHwgIWV4cF9pbmZvLT5vcHMtPnVubWFwX2RtYV9idWYKPiArCQkJICB8fCAhZXhwX2luZm8t Pm9wcy0+cmVsZWFzZQo+ICsJCQkgIHx8ICFleHBfaW5mby0+b3BzLT5rbWFwX2F0b21pYwo+ICsJ CQkgIHx8ICFleHBfaW5mby0+b3BzLT5rbWFwCj4gKwkJCSAgfHwgIWV4cF9pbmZvLT5vcHMtPm1t YXApKSB7Cj4gIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7Cj4gIAl9Cj4gIAo+IEBAIC0zMDks MjEgKzMxMCwyMiBAQCBzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnRfbmFtZWQodm9pZCAq cHJpdiwgY29uc3Qgc3RydWN0IGRtYV9idWZfb3BzICpvcHMsCj4gIAlpZiAoZG1hYnVmID09IE5V TEwpCj4gIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cj4gIAo+IC0JZG1hYnVmLT5wcml2ID0g cHJpdjsKPiAtCWRtYWJ1Zi0+b3BzID0gb3BzOwo+IC0JZG1hYnVmLT5zaXplID0gc2l6ZTsKPiAt CWRtYWJ1Zi0+ZXhwX25hbWUgPSBleHBfbmFtZTsKPiArCWRtYWJ1Zi0+cHJpdiA9IGV4cF9pbmZv LT5wcml2Owo+ICsJZG1hYnVmLT5vcHMgPSBleHBfaW5mby0+b3BzOwo+ICsJZG1hYnVmLT5zaXpl ID0gZXhwX2luZm8tPnNpemU7Cj4gKwlkbWFidWYtPmV4cF9uYW1lID0gZXhwX2luZm8tPmV4cF9u YW1lOwo+ICAJaW5pdF93YWl0cXVldWVfaGVhZCgmZG1hYnVmLT5wb2xsKTsKPiAgCWRtYWJ1Zi0+ Y2JfZXhjbC5wb2xsID0gZG1hYnVmLT5jYl9zaGFyZWQucG9sbCA9ICZkbWFidWYtPnBvbGw7Cj4g IAlkbWFidWYtPmNiX2V4Y2wuYWN0aXZlID0gZG1hYnVmLT5jYl9zaGFyZWQuYWN0aXZlID0gMDsK PiAgCj4gLQlpZiAoIXJlc3YpIHsKPiAtCQlyZXN2ID0gKHN0cnVjdCByZXNlcnZhdGlvbl9vYmpl Y3QgKikmZG1hYnVmWzFdOwo+IC0JCXJlc2VydmF0aW9uX29iamVjdF9pbml0KHJlc3YpOwo+ICsJ aWYgKCFleHBfaW5mby0+cmVzdikgewo+ICsJCWV4cF9pbmZvLT5yZXN2ID0gKHN0cnVjdCByZXNl cnZhdGlvbl9vYmplY3QgKikmZG1hYnVmWzFdOwo+ICsJCXJlc2VydmF0aW9uX29iamVjdF9pbml0 KGV4cF9pbmZvLT5yZXN2KTsKPiAgCX0KPiAtCWRtYWJ1Zi0+cmVzdiA9IHJlc3Y7Cj4gKwlkbWFi dWYtPnJlc3YgPSBleHBfaW5mby0+cmVzdjsKPiAgCj4gLQlmaWxlID0gYW5vbl9pbm9kZV9nZXRm aWxlKCJkbWFidWYiLCAmZG1hX2J1Zl9mb3BzLCBkbWFidWYsIGZsYWdzKTsKPiArCWZpbGUgPSBh bm9uX2lub2RlX2dldGZpbGUoImRtYWJ1ZiIsICZkbWFfYnVmX2ZvcHMsIGRtYWJ1ZiwKPiArCQkJ CQlleHBfaW5mby0+ZmxhZ3MpOwo+ICAJaWYgKElTX0VSUihmaWxlKSkgewo+ICAJCWtmcmVlKGRt YWJ1Zik7Cj4gIAkJcmV0dXJuIEVSUl9DQVNUKGZpbGUpOwo+IEBAIC0zNDEsOCArMzQzLDcgQEAg c3RydWN0IGRtYV9idWYgKmRtYV9idWZfZXhwb3J0X25hbWVkKHZvaWQgKnByaXYsIGNvbnN0IHN0 cnVjdCBkbWFfYnVmX29wcyAqb3BzLAo+ICAKPiAgCXJldHVybiBkbWFidWY7Cj4gIH0KPiAtRVhQ T1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9leHBvcnRfbmFtZWQpOwo+IC0KPiArRVhQT1JUX1NZTUJP TF9HUEwoZG1hX2J1Zl9leHBvcnQpOwo+ICAKPiAgLyoqCj4gICAqIGRtYV9idWZfZmQgLSByZXR1 cm5zIGEgZmlsZSBkZXNjcmlwdG9yIGZvciB0aGUgZ2l2ZW4gZG1hX2J1Zgo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYXJtYWRhL2FybWFkYV9nZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9h cm1hZGEvYXJtYWRhX2dlbS5jCj4gaW5kZXggZWY1ZmVlZWNlYzg0Li41ODBlMTBhY2FhM2EgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vYXJtYWRhL2FybWFkYV9nZW0uYwo+IEBAIC01MzgsOCArNTM4LDE0IEBA IHN0cnVjdCBkbWFfYnVmICoKPiAgYXJtYWRhX2dlbV9wcmltZV9leHBvcnQoc3RydWN0IGRybV9k ZXZpY2UgKmRldiwgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmosCj4gIAlpbnQgZmxhZ3MpCj4g IHsKPiAtCXJldHVybiBkbWFfYnVmX2V4cG9ydChvYmosICZhcm1hZGFfZ2VtX3ByaW1lX2RtYWJ1 Zl9vcHMsIG9iai0+c2l6ZSwKPiAtCQkJICAgICAgT19SRFdSLCBOVUxMKTsKPiArCURFRklORV9E TUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZvKTsKPiArCj4gKwlleHBfaW5mby5vcHMgPSAmYXJt YWRhX2dlbV9wcmltZV9kbWFidWZfb3BzOwo+ICsJZXhwX2luZm8uc2l6ZSA9IG9iai0+c2l6ZTsK PiArCWV4cF9pbmZvLmZsYWdzID0gT19SRFdSOwo+ICsJZXhwX2luZm8ucHJpdiA9IG9iajsKPiAr Cj4gKwlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKPiAgfQo+ICAKPiAgc3RydWN0 IGRybV9nZW1fb2JqZWN0ICoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9wcmlt ZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9wcmltZS5jCj4gaW5kZXggNzQ4MmIwNmNkMDhmLi43 ZmVjMTkxYjQ1ZjcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9wcmltZS5jCj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9wcmltZS5jCj4gQEAgLTMzOSwxMyArMzM5LDE3IEBA IHN0YXRpYyBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9vcHMgZHJtX2dlbV9wcmltZV9kbWFidWZfb3Bz ID0gIHsKPiAgc3RydWN0IGRtYV9idWYgKmRybV9nZW1fcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsCj4gIAkJCQkgICAgIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqLCBpbnQg ZmxhZ3MpCj4gIHsKPiAtCXN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3QgKnJvYmogPSBOVUxMOwo+ ICsJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOwo+ICsKPiArCWV4cF9pbmZv Lm9wcyA9ICZkcm1fZ2VtX3ByaW1lX2RtYWJ1Zl9vcHM7Cj4gKwlleHBfaW5mby5zaXplID0gb2Jq LT5zaXplOwo+ICsJZXhwX2luZm8uZmxhZ3MgPSBmbGFnczsKPiArCWV4cF9pbmZvLnByaXYgPSBv Ymo7Cj4gIAo+ICAJaWYgKGRldi0+ZHJpdmVyLT5nZW1fcHJpbWVfcmVzX29iaikKPiAtCQlyb2Jq ID0gZGV2LT5kcml2ZXItPmdlbV9wcmltZV9yZXNfb2JqKG9iaik7Cj4gKwkJZXhwX2luZm8ucmVz diA9IGRldi0+ZHJpdmVyLT5nZW1fcHJpbWVfcmVzX29iaihvYmopOwo+ICAKPiAtCXJldHVybiBk bWFfYnVmX2V4cG9ydChvYmosICZkcm1fZ2VtX3ByaW1lX2RtYWJ1Zl9vcHMsIG9iai0+c2l6ZSwK PiAtCQkJICAgICAgZmxhZ3MsIHJvYmopOwo+ICsJcmV0dXJuIGRtYV9idWZfZXhwb3J0KCZleHBf aW5mbyk7Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fZ2VtX3ByaW1lX2V4cG9ydCk7Cj4gIAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZG1hYnVmLmMg Yi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZG1hYnVmLmMKPiBpbmRleCA2MDE5 MmVkNTQ0ZjAuLmZjMjkzYTE3OWYzNiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZXh5 bm9zL2V4eW5vc19kcm1fZG1hYnVmLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4 eW5vc19kcm1fZG1hYnVmLmMKPiBAQCAtMTg1LDkgKzE4NSwxNCBAQCBzdHJ1Y3QgZG1hX2J1ZiAq ZXh5bm9zX2RtYWJ1Zl9wcmltZV9leHBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXYsCj4g IAkJCQlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaiwgaW50IGZsYWdzKQo+ICB7Cj4gIAlzdHJ1 Y3QgZXh5bm9zX2RybV9nZW1fb2JqICpleHlub3NfZ2VtX29iaiA9IHRvX2V4eW5vc19nZW1fb2Jq KG9iaik7Cj4gKwlERUZJTkVfRE1BX0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7Cj4gIAo+IC0J cmV0dXJuIGRtYV9idWZfZXhwb3J0KG9iaiwgJmV4eW5vc19kbWFidWZfb3BzLAo+IC0JCQkJZXh5 bm9zX2dlbV9vYmotPmJhc2Uuc2l6ZSwgZmxhZ3MsIE5VTEwpOwo+ICsJZXhwX2luZm8ub3BzID0g JmV4eW5vc19kbWFidWZfb3BzOwo+ICsJZXhwX2luZm8uc2l6ZSA9IGV4eW5vc19nZW1fb2JqLT5i YXNlLnNpemU7Cj4gKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOwo+ICsJZXhwX2luZm8ucHJpdiA9 IG9iajsKPiArCj4gKwlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKPiAgfQo+ICAK PiAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpleHlub3NfZG1hYnVmX3ByaW1lX2ltcG9ydChzdHJ1 Y3QgZHJtX2RldmljZSAqZHJtX2RldiwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9nZW1fZG1hYnVmLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFi dWYuYwo+IGluZGV4IDgyYTFmNGI1Nzc3OC4uNzk5OGRhMjdjNTAwIDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2RtYWJ1Zi5jCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9nZW1fZG1hYnVmLmMKPiBAQCAtMjMwLDYgKzIzMCwxMyBAQCBzdHJ1Y3Qg ZG1hX2J1ZiAqaTkxNV9nZW1fcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4g IAkJCQkgICAgICBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosIGludCBmbGFncykKPiAg ewo+ICAJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IHRvX2ludGVsX2JvKGdlbV9v YmopOwo+ICsJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOwo+ICsKPiArCWV4 cF9pbmZvLm9wcyA9ICZpOTE1X2RtYWJ1Zl9vcHM7Cj4gKwlleHBfaW5mby5zaXplID0gZ2VtX29i ai0+c2l6ZTsKPiArCWV4cF9pbmZvLmZsYWdzID0gZmxhZ3M7Cj4gKwlleHBfaW5mby5wcml2ID0g Z2VtX29iajsKPiArCj4gIAo+ICAJaWYgKG9iai0+b3BzLT5kbWFidWZfZXhwb3J0KSB7Cj4gIAkJ aW50IHJldCA9IG9iai0+b3BzLT5kbWFidWZfZXhwb3J0KG9iaik7Cj4gQEAgLTIzNyw4ICsyNDQs NyBAQCBzdHJ1Y3QgZG1hX2J1ZiAqaTkxNV9nZW1fcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsCj4gIAkJCXJldHVybiBFUlJfUFRSKHJldCk7Cj4gIAl9Cj4gIAo+IC0JcmV0dXJu IGRtYV9idWZfZXhwb3J0KGdlbV9vYmosICZpOTE1X2RtYWJ1Zl9vcHMsIGdlbV9vYmotPnNpemUs IGZsYWdzLAo+IC0JCQkgICAgICBOVUxMKTsKPiArCXJldHVybiBkbWFfYnVmX2V4cG9ydCgmZXhw X2luZm8pOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50IGk5MTVfZ2VtX29iamVjdF9nZXRfcGFnZXNf ZG1hYnVmKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZ2VtX2RtYWJ1Zi5jIGIvZHJpdmVycy9ncHUvZHJt L29tYXBkcm0vb21hcF9nZW1fZG1hYnVmLmMKPiBpbmRleCBhMmRiZmIxNzM3YjQuLjU4NzRjNThl NzJjMSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vb21hcGRybS9vbWFwX2dlbV9kbWFi dWYuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZ2VtX2RtYWJ1Zi5jCj4g QEAgLTE3MSw3ICsxNzEsMTQgQEAgc3RhdGljIHN0cnVjdCBkbWFfYnVmX29wcyBvbWFwX2RtYWJ1 Zl9vcHMgPSB7Cj4gIHN0cnVjdCBkbWFfYnVmICpvbWFwX2dlbV9wcmltZV9leHBvcnQoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKPiAgCQlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaiwgaW50IGZs YWdzKQo+ICB7Cj4gLQlyZXR1cm4gZG1hX2J1Zl9leHBvcnQob2JqLCAmb21hcF9kbWFidWZfb3Bz LCBvYmotPnNpemUsIGZsYWdzLCBOVUxMKTsKPiArCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZP KGV4cF9pbmZvKTsKPiArCj4gKwlleHBfaW5mby5vcHMgPSAmb21hcF9kbWFidWZfb3BzOwo+ICsJ ZXhwX2luZm8uc2l6ZSA9IG9iai0+c2l6ZTsKPiArCWV4cF9pbmZvLmZsYWdzID0gZmxhZ3M7Cj4g KwlleHBfaW5mby5wcml2ID0gb2JqOwo+ICsKPiArCXJldHVybiBkbWFfYnVmX2V4cG9ydCgmZXhw X2luZm8pOwo+ICB9Cj4gIAo+ICBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9tYXBfZ2VtX3ByaW1l X2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vdGVncmEvZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKPiBpbmRleCA4 Nzc3YjdmNzU3OTEuLjFmODk1Yjk1M2Y4ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v dGVncmEvZ2VtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKPiBAQCAtNjU4 LDggKzY1OCwxNCBAQCBzdHJ1Y3QgZG1hX2J1ZiAqdGVncmFfZ2VtX3ByaW1lX2V4cG9ydChzdHJ1 Y3QgZHJtX2RldmljZSAqZHJtLAo+ICAJCQkJICAgICAgIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAq Z2VtLAo+ICAJCQkJICAgICAgIGludCBmbGFncykKPiAgewo+IC0JcmV0dXJuIGRtYV9idWZfZXhw b3J0KGdlbSwgJnRlZ3JhX2dlbV9wcmltZV9kbWFidWZfb3BzLCBnZW0tPnNpemUsCj4gLQkJCSAg ICAgIGZsYWdzLCBOVUxMKTsKPiArCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZv KTsKPiArCj4gKwlleHBfaW5mby5vcHMgPSAmdGVncmFfZ2VtX3ByaW1lX2RtYWJ1Zl9vcHM7Cj4g KwlleHBfaW5mby5zaXplID0gZ2VtLT5zaXplOwo+ICsJZXhwX2luZm8uZmxhZ3MgPSBmbGFnczsK PiArCWV4cF9pbmZvLnByaXYgPSBnZW07Cj4gKwo+ICsJcmV0dXJuIGRtYV9idWZfZXhwb3J0KCZl eHBfaW5mbyk7Cj4gIH0KPiAgCj4gIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdGVncmFfZ2VtX3By aW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vdHRtL3R0bV9vYmplY3QuYyBiL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX29iamVj dC5jCj4gaW5kZXggMTJjODcxMTBkYjNhLi40ZjVmYThkNjVmZTkgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL3R0bS90dG1fb2JqZWN0LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdHRt L3R0bV9vYmplY3QuYwo+IEBAIC02ODMsNiArNjgzLDEyIEBAIGludCB0dG1fcHJpbWVfaGFuZGxl X3RvX2ZkKHN0cnVjdCB0dG1fb2JqZWN0X2ZpbGUgKnRmaWxlLAo+ICAKPiAgCWRtYV9idWYgPSBw cmltZS0+ZG1hX2J1ZjsKPiAgCWlmICghZG1hX2J1ZiB8fCAhZ2V0X2RtYV9idWZfdW5sZXNzX2Rv b21lZChkbWFfYnVmKSkgewo+ICsJCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZv KTsKPiArCj4gKwkJZXhwX2luZm8ub3BzID0gJnRkZXYtPm9wczsKPiArCQlleHBfaW5mby5zaXpl ID0gcHJpbWUtPnNpemU7Cj4gKwkJZXhwX2luZm8uZmxhZ3MgPSBmbGFnczsKPiArCQlleHBfaW5m by5wcml2ID0gcHJpbWU7Cj4gIAo+ICAJCS8qCj4gIAkJICogTmVlZCB0byBjcmVhdGUgYSBuZXcg ZG1hX2J1Ziwgd2l0aCBtZW1vcnkgYWNjb3VudGluZy4KPiBAQCAtNjk0LDggKzcwMCw3IEBAIGlu dCB0dG1fcHJpbWVfaGFuZGxlX3RvX2ZkKHN0cnVjdCB0dG1fb2JqZWN0X2ZpbGUgKnRmaWxlLAo+ ICAJCQlnb3RvIG91dF91bnJlZjsKPiAgCQl9Cj4gIAo+IC0JCWRtYV9idWYgPSBkbWFfYnVmX2V4 cG9ydChwcmltZSwgJnRkZXYtPm9wcywKPiAtCQkJCQkgcHJpbWUtPnNpemUsIGZsYWdzLCBOVUxM KTsKPiArCQlkbWFfYnVmID0gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKPiAgCQlpZiAoSVNf RVJSKGRtYV9idWYpKSB7Cj4gIAkJCXJldCA9IFBUUl9FUlIoZG1hX2J1Zik7Cj4gIAkJCXR0bV9t ZW1fZ2xvYmFsX2ZyZWUodGRldi0+bWVtX2dsb2IsCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS91ZGwvdWRsX2RtYWJ1Zi5jIGIvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZG1hYnVmLmMK PiBpbmRleCBhYzhhNjZiNGRmYzIuLmUyMjQzZWRkMWNlMyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRs X2RtYWJ1Zi5jCj4gQEAgLTIwMiw3ICsyMDIsMTQgQEAgc3RhdGljIHN0cnVjdCBkbWFfYnVmX29w cyB1ZGxfZG1hYnVmX29wcyA9IHsKPiAgc3RydWN0IGRtYV9idWYgKnVkbF9nZW1fcHJpbWVfZXhw b3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCQkgICAgIHN0cnVjdCBkcm1fZ2VtX29i amVjdCAqb2JqLCBpbnQgZmxhZ3MpCj4gIHsKPiAtCXJldHVybiBkbWFfYnVmX2V4cG9ydChvYmos ICZ1ZGxfZG1hYnVmX29wcywgb2JqLT5zaXplLCBmbGFncywgTlVMTCk7Cj4gKwlERUZJTkVfRE1B X0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7Cj4gKwo+ICsJZXhwX2luZm8ub3BzID0gJnVkbF9k bWFidWZfb3BzOwo+ICsJZXhwX2luZm8uc2l6ZSA9IG9iai0+c2l6ZTsKPiArCWV4cF9pbmZvLmZs YWdzID0gZmxhZ3M7Cj4gKwlleHBfaW5mby5wcml2ID0gb2JqOwo+ICsKPiArCXJldHVybiBkbWFf YnVmX2V4cG9ydCgmZXhwX2luZm8pOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50IHVkbF9wcmltZV9j cmVhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS92NGwyLWNvcmUvdmlkZW9idWYyLWRtYS1jb250aWcuYyBiL2RyaXZlcnMvbWVkaWEvdjRsMi1j b3JlL3ZpZGVvYnVmMi1kbWEtY29udGlnLmMKPiBpbmRleCBiNDgxZDIwYzgzNzIuLjRhZDkyYTE0 NzkxOSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItZG1h LWNvbnRpZy5jCj4gKysrIGIvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLWRtYS1j b250aWcuYwo+IEBAIC00MDIsNiArNDAyLDEyIEBAIHN0YXRpYyBzdHJ1Y3QgZG1hX2J1ZiAqdmIy X2RjX2dldF9kbWFidWYodm9pZCAqYnVmX3ByaXYsIHVuc2lnbmVkIGxvbmcgZmxhZ3MpCj4gIHsK PiAgCXN0cnVjdCB2YjJfZGNfYnVmICpidWYgPSBidWZfcHJpdjsKPiAgCXN0cnVjdCBkbWFfYnVm ICpkYnVmOwo+ICsJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOwo+ICsKPiAr CWV4cF9pbmZvLm9wcyA9ICZ2YjJfZGNfZG1hYnVmX29wczsKPiArCWV4cF9pbmZvLnNpemUgPSBi dWYtPnNpemU7Cj4gKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOwo+ICsJZXhwX2luZm8ucHJpdiA9 IGJ1ZjsKPiAgCj4gIAlpZiAoIWJ1Zi0+c2d0X2Jhc2UpCj4gIAkJYnVmLT5zZ3RfYmFzZSA9IHZi Ml9kY19nZXRfYmFzZV9zZ3QoYnVmKTsKPiBAQCAtNDA5LDcgKzQxNSw3IEBAIHN0YXRpYyBzdHJ1 Y3QgZG1hX2J1ZiAqdmIyX2RjX2dldF9kbWFidWYodm9pZCAqYnVmX3ByaXYsIHVuc2lnbmVkIGxv bmcgZmxhZ3MpCj4gIAlpZiAoV0FSTl9PTighYnVmLT5zZ3RfYmFzZSkpCj4gIAkJcmV0dXJuIE5V TEw7Cj4gIAo+IC0JZGJ1ZiA9IGRtYV9idWZfZXhwb3J0KGJ1ZiwgJnZiMl9kY19kbWFidWZfb3Bz LCBidWYtPnNpemUsIGZsYWdzLCBOVUxMKTsKPiArCWRidWYgPSBkbWFfYnVmX2V4cG9ydCgmZXhw X2luZm8pOwo+ICAJaWYgKElTX0VSUihkYnVmKSkKPiAgCQlyZXR1cm4gTlVMTDsKPiAgCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1kbWEtc2cuYyBiL2Ry aXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1kbWEtc2cuYwo+IGluZGV4IGIxODM4YWJi NmQwMC4uNDVjNzA4ZTQ2M2I5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3Jl L3ZpZGVvYnVmMi1kbWEtc2cuYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVv YnVmMi1kbWEtc2cuYwo+IEBAIC01ODMsMTEgKzU4MywxNyBAQCBzdGF0aWMgc3RydWN0IGRtYV9i dWYgKnZiMl9kbWFfc2dfZ2V0X2RtYWJ1Zih2b2lkICpidWZfcHJpdiwgdW5zaWduZWQgbG9uZyBm bGFncwo+ICB7Cj4gIAlzdHJ1Y3QgdmIyX2RtYV9zZ19idWYgKmJ1ZiA9IGJ1Zl9wcml2Owo+ICAJ c3RydWN0IGRtYV9idWYgKmRidWY7Cj4gKwlERUZJTkVfRE1BX0JVRl9FWFBPUlRfSU5GTyhleHBf aW5mbyk7Cj4gKwo+ICsJZXhwX2luZm8ub3BzID0gJnZiMl9kbWFfc2dfZG1hYnVmX29wczsKPiAr CWV4cF9pbmZvLnNpemUgPSBidWYtPnNpemU7Cj4gKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOwo+ ICsJZXhwX2luZm8ucHJpdiA9IGJ1ZjsKPiAgCj4gIAlpZiAoV0FSTl9PTighYnVmLT5kbWFfc2d0 KSkKPiAgCQlyZXR1cm4gTlVMTDsKPiAgCj4gLQlkYnVmID0gZG1hX2J1Zl9leHBvcnQoYnVmLCAm dmIyX2RtYV9zZ19kbWFidWZfb3BzLCBidWYtPnNpemUsIGZsYWdzLCBOVUxMKTsKPiArCWRidWYg PSBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8pOwo+ICAJaWYgKElTX0VSUihkYnVmKSkKPiAgCQly ZXR1cm4gTlVMTDsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3Zp ZGVvYnVmMi12bWFsbG9jLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItdm1h bGxvYy5jCj4gaW5kZXggZmJhOTQ0ZTUwMjI3Li45OTJiMWI1OTQwOWMgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLXZtYWxsb2MuYwo+ICsrKyBiL2RyaXZl cnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi12bWFsbG9jLmMKPiBAQCAtMzY3LDExICszNjcs MTcgQEAgc3RhdGljIHN0cnVjdCBkbWFfYnVmICp2YjJfdm1hbGxvY19nZXRfZG1hYnVmKHZvaWQg KmJ1Zl9wcml2LCB1bnNpZ25lZCBsb25nIGZsYWcKPiAgewo+ICAJc3RydWN0IHZiMl92bWFsbG9j X2J1ZiAqYnVmID0gYnVmX3ByaXY7Cj4gIAlzdHJ1Y3QgZG1hX2J1ZiAqZGJ1ZjsKPiArCURFRklO RV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZvKTsKPiArCj4gKwlleHBfaW5mby5vcHMgPSAm dmIyX3ZtYWxsb2NfZG1hYnVmX29wczsKPiArCWV4cF9pbmZvLnNpemUgPSBidWYtPnNpemU7Cj4g KwlleHBfaW5mby5mbGFncyA9IGZsYWdzOwo+ICsJZXhwX2luZm8ucHJpdiA9IGJ1ZjsKPiAgCj4g IAlpZiAoV0FSTl9PTighYnVmLT52YWRkcikpCj4gIAkJcmV0dXJuIE5VTEw7Cj4gIAo+IC0JZGJ1 ZiA9IGRtYV9idWZfZXhwb3J0KGJ1ZiwgJnZiMl92bWFsbG9jX2RtYWJ1Zl9vcHMsIGJ1Zi0+c2l6 ZSwgZmxhZ3MsIE5VTEwpOwo+ICsJZGJ1ZiA9IGRtYV9idWZfZXhwb3J0KCZleHBfaW5mbyk7Cj4g IAlpZiAoSVNfRVJSKGRidWYpKQo+ICAJCXJldHVybiBOVUxMOwo+ICAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvaW9uL2lvbi5jIGIvZHJpdmVycy9zdGFnaW5nL2FuZHJv aWQvaW9uL2lvbi5jCj4gaW5kZXggMjk2ZDM0NzY2MGZjLi5hNDI5N2JlOGYxMmYgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvaW9uL2lvbi5jCj4gKysrIGIvZHJpdmVycy9z dGFnaW5nL2FuZHJvaWQvaW9uL2lvbi5jCj4gQEAgLTExMDYsNiArMTEwNiwxMiBAQCBzdHJ1Y3Qg ZG1hX2J1ZiAqaW9uX3NoYXJlX2RtYV9idWYoc3RydWN0IGlvbl9jbGllbnQgKmNsaWVudCwKPiAg CXN0cnVjdCBpb25fYnVmZmVyICpidWZmZXI7Cj4gIAlzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmOwo+ ICAJYm9vbCB2YWxpZF9oYW5kbGU7Cj4gKwlERUZJTkVfRE1BX0JVRl9FWFBPUlRfSU5GTyhleHBf aW5mbyk7Cj4gKwo+ICsJZXhwX2luZm8ub3BzID0gJmRtYV9idWZfb3BzOwo+ICsJZXhwX2luZm8u c2l6ZSA9IGJ1ZmZlci0+c2l6ZTsKPiArCWV4cF9pbmZvLmZsYWdzID0gT19SRFdSOwo+ICsJZXhw X2luZm8ucHJpdiA9IGJ1ZmZlcjsKPiAgCj4gIAltdXRleF9sb2NrKCZjbGllbnQtPmxvY2spOwo+ ICAJdmFsaWRfaGFuZGxlID0gaW9uX2hhbmRsZV92YWxpZGF0ZShjbGllbnQsIGhhbmRsZSk7Cj4g QEAgLTExMTgsOCArMTEyNCw3IEBAIHN0cnVjdCBkbWFfYnVmICppb25fc2hhcmVfZG1hX2J1Zihz dHJ1Y3QgaW9uX2NsaWVudCAqY2xpZW50LAo+ICAJaW9uX2J1ZmZlcl9nZXQoYnVmZmVyKTsKPiAg CW11dGV4X3VubG9jaygmY2xpZW50LT5sb2NrKTsKPiAgCj4gLQlkbWFidWYgPSBkbWFfYnVmX2V4 cG9ydChidWZmZXIsICZkbWFfYnVmX29wcywgYnVmZmVyLT5zaXplLCBPX1JEV1IsCj4gLQkJCQlO VUxMKTsKPiArCWRtYWJ1ZiA9IGRtYV9idWZfZXhwb3J0KCZleHBfaW5mbyk7Cj4gIAlpZiAoSVNf RVJSKGRtYWJ1ZikpIHsKPiAgCQlpb25fYnVmZmVyX3B1dChidWZmZXIpOwo+ICAJCXJldHVybiBk bWFidWY7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9s aW51eC9kbWEtYnVmLmgKPiBpbmRleCA2OTRlMWZlMWM0YjQuLmE0ZTM5NWVlZmZlZiAxMDA2NDQK PiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvZG1h LWJ1Zi5oCj4gQEAgLTE2Myw2ICsxNjMsMzMgQEAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCB7 Cj4gIH07Cj4gIAo+ICAvKioKPiArICogc3RydWN0IGRtYV9idWZfZXhwb3J0X2luZm8gLSBob2xk cyBpbmZvcm1hdGlvbiBuZWVkZWQgdG8gZXhwb3J0IGEgZG1hX2J1Zgo+ICsgKiBAZXhwX25hbWU6 CW5hbWUgb2YgdGhlIGV4cG9ydGluZyBtb2R1bGUgLSB1c2VmdWwgZm9yIGRlYnVnZ2luZy4KPiAr ICogQG9wczoJQXR0YWNoIGFsbG9jYXRvci1kZWZpbmVkIGRtYSBidWYgb3BzIHRvIHRoZSBuZXcg YnVmZmVyCj4gKyAqIEBzaXplOglTaXplIG9mIHRoZSBidWZmZXIKPiArICogQGZsYWdzOgltb2Rl IGZsYWdzIGZvciB0aGUgZmlsZQo+ICsgKiBAcmVzdjoJcmVzZXJ2YXRpb24tb2JqZWN0LCBOVUxM IHRvIGFsbG9jYXRlIGRlZmF1bHQgb25lCj4gKyAqIEBwcml2OglBdHRhY2ggcHJpdmF0ZSBkYXRh IG9mIGFsbG9jYXRvciB0byB0aGlzIGJ1ZmZlcgo+ICsgKgo+ICsgKiBUaGlzIHN0cnVjdHVyZSBo b2xkcyB0aGUgaW5mb3JtYXRpb24gcmVxdWlyZWQgdG8gZXhwb3J0IHRoZSBidWZmZXIuIFVzZWQK PiArICogd2l0aCBkbWFfYnVmX2V4cG9ydCgpIG9ubHkuCj4gKyAqLwo+ICtzdHJ1Y3QgZG1hX2J1 Zl9leHBvcnRfaW5mbyB7Cj4gKwljb25zdCBjaGFyICpleHBfbmFtZTsKPiArCWNvbnN0IHN0cnVj dCBkbWFfYnVmX29wcyAqb3BzOwo+ICsJc2l6ZV90IHNpemU7Cj4gKwlpbnQgZmxhZ3M7Cj4gKwlz dHJ1Y3QgcmVzZXJ2YXRpb25fb2JqZWN0ICpyZXN2Owo+ICsJdm9pZCAqcHJpdjsKPiArfTsKPiAr Cj4gKy8qKgo+ICsgKiBoZWxwZXIgbWFjcm8gZm9yIGV4cG9ydGVyczsgemVyb3MgYW5kIGZpbGxz IGluIG1vc3QgY29tbW9uIHZhbHVlcwo+ICsgKi8KPiArI2RlZmluZSBERUZJTkVfRE1BX0JVRl9F WFBPUlRfSU5GTyhhKQlcCj4gKwlzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyBhID0geyAuZXhw X25hbWUgPSBLQlVJTERfTU9ETkFNRSB9Cj4gKwo+ICsvKioKPiAgICogZ2V0X2RtYV9idWYgLSBj b252ZW5pZW5jZSB3cmFwcGVyIGZvciBnZXRfZmlsZS4KPiAgICogQGRtYWJ1ZjoJW2luXQlwb2lu dGVyIHRvIGRtYV9idWYKPiAgICoKPiBAQCAtMTgxLDEyICsyMDgsNyBAQCBzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICB2 b2lkIGRtYV9idWZfZGV0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCj4gIAkJCQlzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFidWZfYXR0YWNoKTsKPiAgCj4gLXN0cnVjdCBkbWFfYnVm ICpkbWFfYnVmX2V4cG9ydF9uYW1lZCh2b2lkICpwcml2LCBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9v cHMgKm9wcywKPiAtCQkJICAgICAgIHNpemVfdCBzaXplLCBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIg KiwKPiAtCQkJICAgICAgIHN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3QgKik7Cj4gLQo+IC0jZGVm aW5lIGRtYV9idWZfZXhwb3J0KHByaXYsIG9wcywgc2l6ZSwgZmxhZ3MsIHJlc3YpCVwKPiAtCWRt YV9idWZfZXhwb3J0X25hbWVkKHByaXYsIG9wcywgc2l6ZSwgZmxhZ3MsIEtCVUlMRF9NT0ROQU1F LCByZXN2KQo+ICtzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnQoc3RydWN0IGRtYV9idWZf ZXhwb3J0X2luZm8gKmV4cF9pbmZvKTsKPiAgCj4gIGludCBkbWFfYnVmX2ZkKHN0cnVjdCBkbWFf YnVmICpkbWFidWYsIGludCBmbGFncyk7Cj4gIHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmX2dldChp bnQgZmQpOwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K SW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 From: maarten.lankhorst@canonical.com (Maarten Lankhorst) Date: Wed, 28 Jan 2015 16:00:12 +0100 Subject: [PATCH v3] dma-buf: cleanup dma_buf_export() to make it easily extensible In-Reply-To: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> References: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> Message-ID: <54C8F97C.2040208@canonical.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Op 28-01-15 om 13:54 schreef Sumit Semwal: > At present, dma_buf_export() takes a series of parameters, which > makes it difficult to add any new parameters for exporters, if required. > > Make it simpler by moving all these parameters into a struct, and pass > the struct * as parameter to dma_buf_export(). > > While at it, unite dma_buf_export_named() with dma_buf_export(), and > change all callers accordingly. > > Signed-off-by: Sumit Semwal > --- > v3: Daniel Thompson caught the C99 warning issue w/ using {0}; using > {.exp_name = xxx} instead. > > v2: add macro to zero out local struct, and fill KBUILD_MODNAME by default > > drivers/dma-buf/dma-buf.c | 47 +++++++++++++------------- > drivers/gpu/drm/armada/armada_gem.c | 10 ++++-- > drivers/gpu/drm/drm_prime.c | 12 ++++--- > drivers/gpu/drm/exynos/exynos_drm_dmabuf.c | 9 +++-- > drivers/gpu/drm/i915/i915_gem_dmabuf.c | 10 ++++-- > drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c | 9 ++++- > drivers/gpu/drm/tegra/gem.c | 10 ++++-- > drivers/gpu/drm/ttm/ttm_object.c | 9 +++-- > drivers/gpu/drm/udl/udl_dmabuf.c | 9 ++++- > drivers/media/v4l2-core/videobuf2-dma-contig.c | 8 ++++- > drivers/media/v4l2-core/videobuf2-dma-sg.c | 8 ++++- > drivers/media/v4l2-core/videobuf2-vmalloc.c | 8 ++++- > drivers/staging/android/ion/ion.c | 9 +++-- > include/linux/dma-buf.h | 34 +++++++++++++++---- > 14 files changed, 142 insertions(+), 50 deletions(-) > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index 5be225c2ba98..6d3df3dd9310 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -265,7 +265,7 @@ static inline int is_dma_buf_file(struct file *file) > } > > /** > - * dma_buf_export_named - Creates a new dma_buf, and associates an anon file > + * dma_buf_export - Creates a new dma_buf, and associates an anon file > * with this buffer, so it can be exported. > * Also connect the allocator specific data and ops to the buffer. > * Additionally, provide a name string for exporter; useful in debugging. > @@ -277,31 +277,32 @@ static inline int is_dma_buf_file(struct file *file) > * @exp_name: [in] name of the exporting module - useful for debugging. > * @resv: [in] reservation-object, NULL to allocate default one. > * > + * All the above info comes from struct dma_buf_export_info. > + * > * Returns, on success, a newly created dma_buf object, which wraps the > * supplied private data and operations for dma_buf_ops. On either missing > * ops, or error in allocating struct dma_buf, will return negative error. > * > */ > -struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > - size_t size, int flags, const char *exp_name, > - struct reservation_object *resv) > +struct dma_buf *dma_buf_export(struct dma_buf_export_info *exp_info) This function should probably take a const struct dma_buf_export_info here.. Rest looks sane. ~Maarten > { > struct dma_buf *dmabuf; > struct file *file; > size_t alloc_size = sizeof(struct dma_buf); > - if (!resv) > + if (!exp_info->resv) > alloc_size += sizeof(struct reservation_object); > else > /* prevent &dma_buf[1] == dma_buf->resv */ > alloc_size += 1; > > - if (WARN_ON(!priv || !ops > - || !ops->map_dma_buf > - || !ops->unmap_dma_buf > - || !ops->release > - || !ops->kmap_atomic > - || !ops->kmap > - || !ops->mmap)) { > + if (WARN_ON(!exp_info->priv > + || !exp_info->ops > + || !exp_info->ops->map_dma_buf > + || !exp_info->ops->unmap_dma_buf > + || !exp_info->ops->release > + || !exp_info->ops->kmap_atomic > + || !exp_info->ops->kmap > + || !exp_info->ops->mmap)) { > return ERR_PTR(-EINVAL); > } > > @@ -309,21 +310,22 @@ struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > if (dmabuf == NULL) > return ERR_PTR(-ENOMEM); > > - dmabuf->priv = priv; > - dmabuf->ops = ops; > - dmabuf->size = size; > - dmabuf->exp_name = exp_name; > + dmabuf->priv = exp_info->priv; > + dmabuf->ops = exp_info->ops; > + dmabuf->size = exp_info->size; > + dmabuf->exp_name = exp_info->exp_name; > init_waitqueue_head(&dmabuf->poll); > dmabuf->cb_excl.poll = dmabuf->cb_shared.poll = &dmabuf->poll; > dmabuf->cb_excl.active = dmabuf->cb_shared.active = 0; > > - if (!resv) { > - resv = (struct reservation_object *)&dmabuf[1]; > - reservation_object_init(resv); > + if (!exp_info->resv) { > + exp_info->resv = (struct reservation_object *)&dmabuf[1]; > + reservation_object_init(exp_info->resv); > } > - dmabuf->resv = resv; > + dmabuf->resv = exp_info->resv; > > - file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, flags); > + file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, > + exp_info->flags); > if (IS_ERR(file)) { > kfree(dmabuf); > return ERR_CAST(file); > @@ -341,8 +343,7 @@ struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > > return dmabuf; > } > -EXPORT_SYMBOL_GPL(dma_buf_export_named); > - > +EXPORT_SYMBOL_GPL(dma_buf_export); > > /** > * dma_buf_fd - returns a file descriptor for the given dma_buf > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index ef5feeecec84..580e10acaa3a 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -538,8 +538,14 @@ struct dma_buf * > armada_gem_prime_export(struct drm_device *dev, struct drm_gem_object *obj, > int flags) > { > - return dma_buf_export(obj, &armada_gem_prime_dmabuf_ops, obj->size, > - O_RDWR, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &armada_gem_prime_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = O_RDWR; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object * > diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c > index 7482b06cd08f..7fec191b45f7 100644 > --- a/drivers/gpu/drm/drm_prime.c > +++ b/drivers/gpu/drm/drm_prime.c > @@ -339,13 +339,17 @@ static const struct dma_buf_ops drm_gem_prime_dmabuf_ops = { > struct dma_buf *drm_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - struct reservation_object *robj = NULL; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &drm_gem_prime_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > > if (dev->driver->gem_prime_res_obj) > - robj = dev->driver->gem_prime_res_obj(obj); > + exp_info.resv = dev->driver->gem_prime_res_obj(obj); > > - return dma_buf_export(obj, &drm_gem_prime_dmabuf_ops, obj->size, > - flags, robj); > + return dma_buf_export(&exp_info); > } > EXPORT_SYMBOL(drm_gem_prime_export); > > diff --git a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > index 60192ed544f0..fc293a179f36 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > @@ -185,9 +185,14 @@ struct dma_buf *exynos_dmabuf_prime_export(struct drm_device *drm_dev, > struct drm_gem_object *obj, int flags) > { > struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > > - return dma_buf_export(obj, &exynos_dmabuf_ops, > - exynos_gem_obj->base.size, flags, NULL); > + exp_info.ops = &exynos_dmabuf_ops; > + exp_info.size = exynos_gem_obj->base.size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *exynos_dmabuf_prime_import(struct drm_device *drm_dev, > diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > index 82a1f4b57778..7998da27c500 100644 > --- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > @@ -230,6 +230,13 @@ struct dma_buf *i915_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *gem_obj, int flags) > { > struct drm_i915_gem_object *obj = to_intel_bo(gem_obj); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &i915_dmabuf_ops; > + exp_info.size = gem_obj->size; > + exp_info.flags = flags; > + exp_info.priv = gem_obj; > + > > if (obj->ops->dmabuf_export) { > int ret = obj->ops->dmabuf_export(obj); > @@ -237,8 +244,7 @@ struct dma_buf *i915_gem_prime_export(struct drm_device *dev, > return ERR_PTR(ret); > } > > - return dma_buf_export(gem_obj, &i915_dmabuf_ops, gem_obj->size, flags, > - NULL); > + return dma_buf_export(&exp_info); > } > > static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj) > diff --git a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > index a2dbfb1737b4..5874c58e72c1 100644 > --- a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > +++ b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > @@ -171,7 +171,14 @@ static struct dma_buf_ops omap_dmabuf_ops = { > struct dma_buf *omap_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - return dma_buf_export(obj, &omap_dmabuf_ops, obj->size, flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &omap_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c > index 8777b7f75791..1f895b953f8f 100644 > --- a/drivers/gpu/drm/tegra/gem.c > +++ b/drivers/gpu/drm/tegra/gem.c > @@ -658,8 +658,14 @@ struct dma_buf *tegra_gem_prime_export(struct drm_device *drm, > struct drm_gem_object *gem, > int flags) > { > - return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size, > - flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &tegra_gem_prime_dmabuf_ops; > + exp_info.size = gem->size; > + exp_info.flags = flags; > + exp_info.priv = gem; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *tegra_gem_prime_import(struct drm_device *drm, > diff --git a/drivers/gpu/drm/ttm/ttm_object.c b/drivers/gpu/drm/ttm/ttm_object.c > index 12c87110db3a..4f5fa8d65fe9 100644 > --- a/drivers/gpu/drm/ttm/ttm_object.c > +++ b/drivers/gpu/drm/ttm/ttm_object.c > @@ -683,6 +683,12 @@ int ttm_prime_handle_to_fd(struct ttm_object_file *tfile, > > dma_buf = prime->dma_buf; > if (!dma_buf || !get_dma_buf_unless_doomed(dma_buf)) { > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &tdev->ops; > + exp_info.size = prime->size; > + exp_info.flags = flags; > + exp_info.priv = prime; > > /* > * Need to create a new dma_buf, with memory accounting. > @@ -694,8 +700,7 @@ int ttm_prime_handle_to_fd(struct ttm_object_file *tfile, > goto out_unref; > } > > - dma_buf = dma_buf_export(prime, &tdev->ops, > - prime->size, flags, NULL); > + dma_buf = dma_buf_export(&exp_info); > if (IS_ERR(dma_buf)) { > ret = PTR_ERR(dma_buf); > ttm_mem_global_free(tdev->mem_glob, > diff --git a/drivers/gpu/drm/udl/udl_dmabuf.c b/drivers/gpu/drm/udl/udl_dmabuf.c > index ac8a66b4dfc2..e2243edd1ce3 100644 > --- a/drivers/gpu/drm/udl/udl_dmabuf.c > +++ b/drivers/gpu/drm/udl/udl_dmabuf.c > @@ -202,7 +202,14 @@ static struct dma_buf_ops udl_dmabuf_ops = { > struct dma_buf *udl_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - return dma_buf_export(obj, &udl_dmabuf_ops, obj->size, flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &udl_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > static int udl_prime_create(struct drm_device *dev, > diff --git a/drivers/media/v4l2-core/videobuf2-dma-contig.c b/drivers/media/v4l2-core/videobuf2-dma-contig.c > index b481d20c8372..4ad92a147919 100644 > --- a/drivers/media/v4l2-core/videobuf2-dma-contig.c > +++ b/drivers/media/v4l2-core/videobuf2-dma-contig.c > @@ -402,6 +402,12 @@ static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags) > { > struct vb2_dc_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_dc_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (!buf->sgt_base) > buf->sgt_base = vb2_dc_get_base_sgt(buf); > @@ -409,7 +415,7 @@ static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags) > if (WARN_ON(!buf->sgt_base)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_dc_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/media/v4l2-core/videobuf2-dma-sg.c b/drivers/media/v4l2-core/videobuf2-dma-sg.c > index b1838abb6d00..45c708e463b9 100644 > --- a/drivers/media/v4l2-core/videobuf2-dma-sg.c > +++ b/drivers/media/v4l2-core/videobuf2-dma-sg.c > @@ -583,11 +583,17 @@ static struct dma_buf *vb2_dma_sg_get_dmabuf(void *buf_priv, unsigned long flags > { > struct vb2_dma_sg_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_dma_sg_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (WARN_ON(!buf->dma_sgt)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_dma_sg_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/media/v4l2-core/videobuf2-vmalloc.c b/drivers/media/v4l2-core/videobuf2-vmalloc.c > index fba944e50227..992b1b59409c 100644 > --- a/drivers/media/v4l2-core/videobuf2-vmalloc.c > +++ b/drivers/media/v4l2-core/videobuf2-vmalloc.c > @@ -367,11 +367,17 @@ static struct dma_buf *vb2_vmalloc_get_dmabuf(void *buf_priv, unsigned long flag > { > struct vb2_vmalloc_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_vmalloc_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (WARN_ON(!buf->vaddr)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_vmalloc_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c > index 296d347660fc..a4297be8f12f 100644 > --- a/drivers/staging/android/ion/ion.c > +++ b/drivers/staging/android/ion/ion.c > @@ -1106,6 +1106,12 @@ struct dma_buf *ion_share_dma_buf(struct ion_client *client, > struct ion_buffer *buffer; > struct dma_buf *dmabuf; > bool valid_handle; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &dma_buf_ops; > + exp_info.size = buffer->size; > + exp_info.flags = O_RDWR; > + exp_info.priv = buffer; > > mutex_lock(&client->lock); > valid_handle = ion_handle_validate(client, handle); > @@ -1118,8 +1124,7 @@ struct dma_buf *ion_share_dma_buf(struct ion_client *client, > ion_buffer_get(buffer); > mutex_unlock(&client->lock); > > - dmabuf = dma_buf_export(buffer, &dma_buf_ops, buffer->size, O_RDWR, > - NULL); > + dmabuf = dma_buf_export(&exp_info); > if (IS_ERR(dmabuf)) { > ion_buffer_put(buffer); > return dmabuf; > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index 694e1fe1c4b4..a4e395eeffef 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -163,6 +163,33 @@ struct dma_buf_attachment { > }; > > /** > + * struct dma_buf_export_info - holds information needed to export a dma_buf > + * @exp_name: name of the exporting module - useful for debugging. > + * @ops: Attach allocator-defined dma buf ops to the new buffer > + * @size: Size of the buffer > + * @flags: mode flags for the file > + * @resv: reservation-object, NULL to allocate default one > + * @priv: Attach private data of allocator to this buffer > + * > + * This structure holds the information required to export the buffer. Used > + * with dma_buf_export() only. > + */ > +struct dma_buf_export_info { > + const char *exp_name; > + const struct dma_buf_ops *ops; > + size_t size; > + int flags; > + struct reservation_object *resv; > + void *priv; > +}; > + > +/** > + * helper macro for exporters; zeros and fills in most common values > + */ > +#define DEFINE_DMA_BUF_EXPORT_INFO(a) \ > + struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME } > + > +/** > * get_dma_buf - convenience wrapper for get_file. > * @dmabuf: [in] pointer to dma_buf > * > @@ -181,12 +208,7 @@ struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > void dma_buf_detach(struct dma_buf *dmabuf, > struct dma_buf_attachment *dmabuf_attach); > > -struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > - size_t size, int flags, const char *, > - struct reservation_object *); > - > -#define dma_buf_export(priv, ops, size, flags, resv) \ > - dma_buf_export_named(priv, ops, size, flags, KBUILD_MODNAME, resv) > +struct dma_buf *dma_buf_export(struct dma_buf_export_info *exp_info); > > int dma_buf_fd(struct dma_buf *dmabuf, int flags); > struct dma_buf *dma_buf_get(int fd); From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from youngberry.canonical.com ([91.189.89.112]:47089 "EHLO youngberry.canonical.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1760336AbbA2CoL (ORCPT ); Wed, 28 Jan 2015 21:44:11 -0500 Message-ID: <54C8F97C.2040208@canonical.com> Date: Wed, 28 Jan 2015 16:00:12 +0100 From: Maarten Lankhorst MIME-Version: 1.0 To: Sumit Semwal , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-arm-kernel@lists.infradead.org, rmk+kernel@arm.linux.org.uk, airlied@linux.ie, kgene@kernel.org, daniel.vetter@intel.com, thierry.reding@gmail.com, pawel@osciak.com, m.szyprowski@samsung.com, mchehab@osg.samsung.com, gregkh@linuxfoundation.org CC: linaro-kernel@lists.linaro.org, intel-gfx@lists.freedesktop.org, linux-tegra@vger.kernel.org Subject: Re: [PATCH v3] dma-buf: cleanup dma_buf_export() to make it easily extensible References: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> In-Reply-To: <1422449643-7829-1-git-send-email-sumit.semwal@linaro.org> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit Sender: linux-media-owner@vger.kernel.org List-ID: Op 28-01-15 om 13:54 schreef Sumit Semwal: > At present, dma_buf_export() takes a series of parameters, which > makes it difficult to add any new parameters for exporters, if required. > > Make it simpler by moving all these parameters into a struct, and pass > the struct * as parameter to dma_buf_export(). > > While at it, unite dma_buf_export_named() with dma_buf_export(), and > change all callers accordingly. > > Signed-off-by: Sumit Semwal > --- > v3: Daniel Thompson caught the C99 warning issue w/ using {0}; using > {.exp_name = xxx} instead. > > v2: add macro to zero out local struct, and fill KBUILD_MODNAME by default > > drivers/dma-buf/dma-buf.c | 47 +++++++++++++------------- > drivers/gpu/drm/armada/armada_gem.c | 10 ++++-- > drivers/gpu/drm/drm_prime.c | 12 ++++--- > drivers/gpu/drm/exynos/exynos_drm_dmabuf.c | 9 +++-- > drivers/gpu/drm/i915/i915_gem_dmabuf.c | 10 ++++-- > drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c | 9 ++++- > drivers/gpu/drm/tegra/gem.c | 10 ++++-- > drivers/gpu/drm/ttm/ttm_object.c | 9 +++-- > drivers/gpu/drm/udl/udl_dmabuf.c | 9 ++++- > drivers/media/v4l2-core/videobuf2-dma-contig.c | 8 ++++- > drivers/media/v4l2-core/videobuf2-dma-sg.c | 8 ++++- > drivers/media/v4l2-core/videobuf2-vmalloc.c | 8 ++++- > drivers/staging/android/ion/ion.c | 9 +++-- > include/linux/dma-buf.h | 34 +++++++++++++++---- > 14 files changed, 142 insertions(+), 50 deletions(-) > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index 5be225c2ba98..6d3df3dd9310 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -265,7 +265,7 @@ static inline int is_dma_buf_file(struct file *file) > } > > /** > - * dma_buf_export_named - Creates a new dma_buf, and associates an anon file > + * dma_buf_export - Creates a new dma_buf, and associates an anon file > * with this buffer, so it can be exported. > * Also connect the allocator specific data and ops to the buffer. > * Additionally, provide a name string for exporter; useful in debugging. > @@ -277,31 +277,32 @@ static inline int is_dma_buf_file(struct file *file) > * @exp_name: [in] name of the exporting module - useful for debugging. > * @resv: [in] reservation-object, NULL to allocate default one. > * > + * All the above info comes from struct dma_buf_export_info. > + * > * Returns, on success, a newly created dma_buf object, which wraps the > * supplied private data and operations for dma_buf_ops. On either missing > * ops, or error in allocating struct dma_buf, will return negative error. > * > */ > -struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > - size_t size, int flags, const char *exp_name, > - struct reservation_object *resv) > +struct dma_buf *dma_buf_export(struct dma_buf_export_info *exp_info) This function should probably take a const struct dma_buf_export_info here.. Rest looks sane. ~Maarten > { > struct dma_buf *dmabuf; > struct file *file; > size_t alloc_size = sizeof(struct dma_buf); > - if (!resv) > + if (!exp_info->resv) > alloc_size += sizeof(struct reservation_object); > else > /* prevent &dma_buf[1] == dma_buf->resv */ > alloc_size += 1; > > - if (WARN_ON(!priv || !ops > - || !ops->map_dma_buf > - || !ops->unmap_dma_buf > - || !ops->release > - || !ops->kmap_atomic > - || !ops->kmap > - || !ops->mmap)) { > + if (WARN_ON(!exp_info->priv > + || !exp_info->ops > + || !exp_info->ops->map_dma_buf > + || !exp_info->ops->unmap_dma_buf > + || !exp_info->ops->release > + || !exp_info->ops->kmap_atomic > + || !exp_info->ops->kmap > + || !exp_info->ops->mmap)) { > return ERR_PTR(-EINVAL); > } > > @@ -309,21 +310,22 @@ struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > if (dmabuf == NULL) > return ERR_PTR(-ENOMEM); > > - dmabuf->priv = priv; > - dmabuf->ops = ops; > - dmabuf->size = size; > - dmabuf->exp_name = exp_name; > + dmabuf->priv = exp_info->priv; > + dmabuf->ops = exp_info->ops; > + dmabuf->size = exp_info->size; > + dmabuf->exp_name = exp_info->exp_name; > init_waitqueue_head(&dmabuf->poll); > dmabuf->cb_excl.poll = dmabuf->cb_shared.poll = &dmabuf->poll; > dmabuf->cb_excl.active = dmabuf->cb_shared.active = 0; > > - if (!resv) { > - resv = (struct reservation_object *)&dmabuf[1]; > - reservation_object_init(resv); > + if (!exp_info->resv) { > + exp_info->resv = (struct reservation_object *)&dmabuf[1]; > + reservation_object_init(exp_info->resv); > } > - dmabuf->resv = resv; > + dmabuf->resv = exp_info->resv; > > - file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, flags); > + file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, > + exp_info->flags); > if (IS_ERR(file)) { > kfree(dmabuf); > return ERR_CAST(file); > @@ -341,8 +343,7 @@ struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > > return dmabuf; > } > -EXPORT_SYMBOL_GPL(dma_buf_export_named); > - > +EXPORT_SYMBOL_GPL(dma_buf_export); > > /** > * dma_buf_fd - returns a file descriptor for the given dma_buf > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index ef5feeecec84..580e10acaa3a 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -538,8 +538,14 @@ struct dma_buf * > armada_gem_prime_export(struct drm_device *dev, struct drm_gem_object *obj, > int flags) > { > - return dma_buf_export(obj, &armada_gem_prime_dmabuf_ops, obj->size, > - O_RDWR, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &armada_gem_prime_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = O_RDWR; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object * > diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c > index 7482b06cd08f..7fec191b45f7 100644 > --- a/drivers/gpu/drm/drm_prime.c > +++ b/drivers/gpu/drm/drm_prime.c > @@ -339,13 +339,17 @@ static const struct dma_buf_ops drm_gem_prime_dmabuf_ops = { > struct dma_buf *drm_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - struct reservation_object *robj = NULL; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &drm_gem_prime_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > > if (dev->driver->gem_prime_res_obj) > - robj = dev->driver->gem_prime_res_obj(obj); > + exp_info.resv = dev->driver->gem_prime_res_obj(obj); > > - return dma_buf_export(obj, &drm_gem_prime_dmabuf_ops, obj->size, > - flags, robj); > + return dma_buf_export(&exp_info); > } > EXPORT_SYMBOL(drm_gem_prime_export); > > diff --git a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > index 60192ed544f0..fc293a179f36 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c > @@ -185,9 +185,14 @@ struct dma_buf *exynos_dmabuf_prime_export(struct drm_device *drm_dev, > struct drm_gem_object *obj, int flags) > { > struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > > - return dma_buf_export(obj, &exynos_dmabuf_ops, > - exynos_gem_obj->base.size, flags, NULL); > + exp_info.ops = &exynos_dmabuf_ops; > + exp_info.size = exynos_gem_obj->base.size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *exynos_dmabuf_prime_import(struct drm_device *drm_dev, > diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > index 82a1f4b57778..7998da27c500 100644 > --- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c > @@ -230,6 +230,13 @@ struct dma_buf *i915_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *gem_obj, int flags) > { > struct drm_i915_gem_object *obj = to_intel_bo(gem_obj); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &i915_dmabuf_ops; > + exp_info.size = gem_obj->size; > + exp_info.flags = flags; > + exp_info.priv = gem_obj; > + > > if (obj->ops->dmabuf_export) { > int ret = obj->ops->dmabuf_export(obj); > @@ -237,8 +244,7 @@ struct dma_buf *i915_gem_prime_export(struct drm_device *dev, > return ERR_PTR(ret); > } > > - return dma_buf_export(gem_obj, &i915_dmabuf_ops, gem_obj->size, flags, > - NULL); > + return dma_buf_export(&exp_info); > } > > static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj) > diff --git a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > index a2dbfb1737b4..5874c58e72c1 100644 > --- a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > +++ b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > @@ -171,7 +171,14 @@ static struct dma_buf_ops omap_dmabuf_ops = { > struct dma_buf *omap_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - return dma_buf_export(obj, &omap_dmabuf_ops, obj->size, flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &omap_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c > index 8777b7f75791..1f895b953f8f 100644 > --- a/drivers/gpu/drm/tegra/gem.c > +++ b/drivers/gpu/drm/tegra/gem.c > @@ -658,8 +658,14 @@ struct dma_buf *tegra_gem_prime_export(struct drm_device *drm, > struct drm_gem_object *gem, > int flags) > { > - return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size, > - flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &tegra_gem_prime_dmabuf_ops; > + exp_info.size = gem->size; > + exp_info.flags = flags; > + exp_info.priv = gem; > + > + return dma_buf_export(&exp_info); > } > > struct drm_gem_object *tegra_gem_prime_import(struct drm_device *drm, > diff --git a/drivers/gpu/drm/ttm/ttm_object.c b/drivers/gpu/drm/ttm/ttm_object.c > index 12c87110db3a..4f5fa8d65fe9 100644 > --- a/drivers/gpu/drm/ttm/ttm_object.c > +++ b/drivers/gpu/drm/ttm/ttm_object.c > @@ -683,6 +683,12 @@ int ttm_prime_handle_to_fd(struct ttm_object_file *tfile, > > dma_buf = prime->dma_buf; > if (!dma_buf || !get_dma_buf_unless_doomed(dma_buf)) { > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &tdev->ops; > + exp_info.size = prime->size; > + exp_info.flags = flags; > + exp_info.priv = prime; > > /* > * Need to create a new dma_buf, with memory accounting. > @@ -694,8 +700,7 @@ int ttm_prime_handle_to_fd(struct ttm_object_file *tfile, > goto out_unref; > } > > - dma_buf = dma_buf_export(prime, &tdev->ops, > - prime->size, flags, NULL); > + dma_buf = dma_buf_export(&exp_info); > if (IS_ERR(dma_buf)) { > ret = PTR_ERR(dma_buf); > ttm_mem_global_free(tdev->mem_glob, > diff --git a/drivers/gpu/drm/udl/udl_dmabuf.c b/drivers/gpu/drm/udl/udl_dmabuf.c > index ac8a66b4dfc2..e2243edd1ce3 100644 > --- a/drivers/gpu/drm/udl/udl_dmabuf.c > +++ b/drivers/gpu/drm/udl/udl_dmabuf.c > @@ -202,7 +202,14 @@ static struct dma_buf_ops udl_dmabuf_ops = { > struct dma_buf *udl_gem_prime_export(struct drm_device *dev, > struct drm_gem_object *obj, int flags) > { > - return dma_buf_export(obj, &udl_dmabuf_ops, obj->size, flags, NULL); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &udl_dmabuf_ops; > + exp_info.size = obj->size; > + exp_info.flags = flags; > + exp_info.priv = obj; > + > + return dma_buf_export(&exp_info); > } > > static int udl_prime_create(struct drm_device *dev, > diff --git a/drivers/media/v4l2-core/videobuf2-dma-contig.c b/drivers/media/v4l2-core/videobuf2-dma-contig.c > index b481d20c8372..4ad92a147919 100644 > --- a/drivers/media/v4l2-core/videobuf2-dma-contig.c > +++ b/drivers/media/v4l2-core/videobuf2-dma-contig.c > @@ -402,6 +402,12 @@ static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags) > { > struct vb2_dc_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_dc_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (!buf->sgt_base) > buf->sgt_base = vb2_dc_get_base_sgt(buf); > @@ -409,7 +415,7 @@ static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags) > if (WARN_ON(!buf->sgt_base)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_dc_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/media/v4l2-core/videobuf2-dma-sg.c b/drivers/media/v4l2-core/videobuf2-dma-sg.c > index b1838abb6d00..45c708e463b9 100644 > --- a/drivers/media/v4l2-core/videobuf2-dma-sg.c > +++ b/drivers/media/v4l2-core/videobuf2-dma-sg.c > @@ -583,11 +583,17 @@ static struct dma_buf *vb2_dma_sg_get_dmabuf(void *buf_priv, unsigned long flags > { > struct vb2_dma_sg_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_dma_sg_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (WARN_ON(!buf->dma_sgt)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_dma_sg_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/media/v4l2-core/videobuf2-vmalloc.c b/drivers/media/v4l2-core/videobuf2-vmalloc.c > index fba944e50227..992b1b59409c 100644 > --- a/drivers/media/v4l2-core/videobuf2-vmalloc.c > +++ b/drivers/media/v4l2-core/videobuf2-vmalloc.c > @@ -367,11 +367,17 @@ static struct dma_buf *vb2_vmalloc_get_dmabuf(void *buf_priv, unsigned long flag > { > struct vb2_vmalloc_buf *buf = buf_priv; > struct dma_buf *dbuf; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &vb2_vmalloc_dmabuf_ops; > + exp_info.size = buf->size; > + exp_info.flags = flags; > + exp_info.priv = buf; > > if (WARN_ON(!buf->vaddr)) > return NULL; > > - dbuf = dma_buf_export(buf, &vb2_vmalloc_dmabuf_ops, buf->size, flags, NULL); > + dbuf = dma_buf_export(&exp_info); > if (IS_ERR(dbuf)) > return NULL; > > diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c > index 296d347660fc..a4297be8f12f 100644 > --- a/drivers/staging/android/ion/ion.c > +++ b/drivers/staging/android/ion/ion.c > @@ -1106,6 +1106,12 @@ struct dma_buf *ion_share_dma_buf(struct ion_client *client, > struct ion_buffer *buffer; > struct dma_buf *dmabuf; > bool valid_handle; > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + > + exp_info.ops = &dma_buf_ops; > + exp_info.size = buffer->size; > + exp_info.flags = O_RDWR; > + exp_info.priv = buffer; > > mutex_lock(&client->lock); > valid_handle = ion_handle_validate(client, handle); > @@ -1118,8 +1124,7 @@ struct dma_buf *ion_share_dma_buf(struct ion_client *client, > ion_buffer_get(buffer); > mutex_unlock(&client->lock); > > - dmabuf = dma_buf_export(buffer, &dma_buf_ops, buffer->size, O_RDWR, > - NULL); > + dmabuf = dma_buf_export(&exp_info); > if (IS_ERR(dmabuf)) { > ion_buffer_put(buffer); > return dmabuf; > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index 694e1fe1c4b4..a4e395eeffef 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -163,6 +163,33 @@ struct dma_buf_attachment { > }; > > /** > + * struct dma_buf_export_info - holds information needed to export a dma_buf > + * @exp_name: name of the exporting module - useful for debugging. > + * @ops: Attach allocator-defined dma buf ops to the new buffer > + * @size: Size of the buffer > + * @flags: mode flags for the file > + * @resv: reservation-object, NULL to allocate default one > + * @priv: Attach private data of allocator to this buffer > + * > + * This structure holds the information required to export the buffer. Used > + * with dma_buf_export() only. > + */ > +struct dma_buf_export_info { > + const char *exp_name; > + const struct dma_buf_ops *ops; > + size_t size; > + int flags; > + struct reservation_object *resv; > + void *priv; > +}; > + > +/** > + * helper macro for exporters; zeros and fills in most common values > + */ > +#define DEFINE_DMA_BUF_EXPORT_INFO(a) \ > + struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME } > + > +/** > * get_dma_buf - convenience wrapper for get_file. > * @dmabuf: [in] pointer to dma_buf > * > @@ -181,12 +208,7 @@ struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, > void dma_buf_detach(struct dma_buf *dmabuf, > struct dma_buf_attachment *dmabuf_attach); > > -struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops, > - size_t size, int flags, const char *, > - struct reservation_object *); > - > -#define dma_buf_export(priv, ops, size, flags, resv) \ > - dma_buf_export_named(priv, ops, size, flags, KBUILD_MODNAME, resv) > +struct dma_buf *dma_buf_export(struct dma_buf_export_info *exp_info); > > int dma_buf_fd(struct dma_buf *dmabuf, int flags); > struct dma_buf *dma_buf_get(int fd);