From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sumit Semwal Subject: [PATCH v2] dma-buf: cleanup dma_buf_export() to make it easily extensible Date: Wed, 28 Jan 2015 11:30:45 +0530 Message-ID: <1422424845-14906-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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: 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 List-Id: linux-tegra@vger.kernel.org QXQgcHJlc2VudCwgZG1hX2J1Zl9leHBvcnQoKSB0YWtlcyBhIHNlcmllcyBvZiBwYXJhbWV0ZXJz LCB3aGljaAptYWtlcyBpdCBkaWZmaWN1bHQgdG8gYWRkIGFueSBuZXcgcGFyYW1ldGVycyBmb3Ig ZXhwb3J0ZXJzLCBpZiByZXF1aXJlZC4KCk1ha2UgaXQgc2ltcGxlciBieSBtb3ZpbmcgYWxsIHRo ZXNlIHBhcmFtZXRlcnMgaW50byBhIHN0cnVjdCwgYW5kIHBhc3MKdGhlIHN0cnVjdCAqIGFzIHBh cmFtZXRlciB0byBkbWFfYnVmX2V4cG9ydCgpLgoKV2hpbGUgYXQgaXQsIHVuaXRlIGRtYV9idWZf ZXhwb3J0X25hbWVkKCkgd2l0aCBkbWFfYnVmX2V4cG9ydCgpLCBhbmQKY2hhbmdlIGFsbCBjYWxs ZXJzIGFjY29yZGluZ2x5LgoKU2lnbmVkLW9mZi1ieTogU3VtaXQgU2Vtd2FsIDxzdW1pdC5zZW13 YWxAbGluYXJvLm9yZz4KLS0tCnYyOiBhZGQgbWFjcm8gdG8gemVybyBvdXQgbG9jYWwgc3RydWN0 LCBhbmQgZmlsbCBLQlVJTERfTU9ETkFNRSBieSBkZWZhdWx0CgogZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYuYyAgICAgICAgICAgICAgICAgICAgICB8IDQ3ICsrKysrKysrKysrKystLS0tLS0tLS0t LS0tCiBkcml2ZXJzL2dwdS9kcm0vYXJtYWRhL2FybWFkYV9nZW0uYyAgICAgICAgICAgIHwgMTAg KysrKy0tCiBkcml2ZXJzL2dwdS9kcm0vZHJtX3ByaW1lLmMgICAgICAgICAgICAgICAgICAgIHwg MTIgKysrKy0tLQogZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfZHJtX2RtYWJ1Zi5jICAg ICB8ICA5ICsrKy0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYyAgICAg ICAgIHwgMTAgKysrKy0tCiBkcml2ZXJzL2dwdS9kcm0vb21hcGRybS9vbWFwX2dlbV9kbWFidWYu YyAgICAgIHwgIDkgKysrKy0KIGRyaXZlcnMvZ3B1L2RybS90ZWdyYS9nZW0uYyAgICAgICAgICAg ICAgICAgICAgfCAxMCArKysrLS0KIGRyaXZlcnMvZ3B1L2RybS90dG0vdHRtX29iamVjdC5jICAg ICAgICAgICAgICAgfCAgOSArKystLQogZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZG1hYnVmLmMg ICAgICAgICAgICAgICB8ICA5ICsrKystCiBkcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1 ZjItZG1hLWNvbnRpZy5jIHwgIDggKysrKy0KIGRyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVv YnVmMi1kbWEtc2cuYyAgICAgfCAgOCArKysrLQogZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlk ZW9idWYyLXZtYWxsb2MuYyAgICB8ICA4ICsrKystCiBkcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9p b24vaW9uLmMgICAgICAgICAgICAgIHwgIDkgKysrLS0KIGluY2x1ZGUvbGludXgvZG1hLWJ1Zi5o ICAgICAgICAgICAgICAgICAgICAgICAgfCAzNSArKysrKysrKysrKysrKystLS0tCiAxNCBmaWxl cyBjaGFuZ2VkLCAxNDMgaW5zZXJ0aW9ucygrKSwgNTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMK aW5kZXggNWJlMjI1YzJiYTk4Li42ZDNkZjNkZDkzMTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1h LWJ1Zi9kbWEtYnVmLmMKKysrIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwpAQCAtMjY1LDcg KzI2NSw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IGlzX2RtYV9idWZfZmlsZShzdHJ1Y3QgZmlsZSAq ZmlsZSkKIH0KIAogLyoqCi0gKiBkbWFfYnVmX2V4cG9ydF9uYW1lZCAtIENyZWF0ZXMgYSBuZXcg ZG1hX2J1ZiwgYW5kIGFzc29jaWF0ZXMgYW4gYW5vbiBmaWxlCisgKiBkbWFfYnVmX2V4cG9ydCAt IENyZWF0ZXMgYSBuZXcgZG1hX2J1ZiwgYW5kIGFzc29jaWF0ZXMgYW4gYW5vbiBmaWxlCiAgKiB3 aXRoIHRoaXMgYnVmZmVyLCBzbyBpdCBjYW4gYmUgZXhwb3J0ZWQuCiAgKiBBbHNvIGNvbm5lY3Qg dGhlIGFsbG9jYXRvciBzcGVjaWZpYyBkYXRhIGFuZCBvcHMgdG8gdGhlIGJ1ZmZlci4KICAqIEFk ZGl0aW9uYWxseSwgcHJvdmlkZSBhIG5hbWUgc3RyaW5nIGZvciBleHBvcnRlcjsgdXNlZnVsIGlu IGRlYnVnZ2luZy4KQEAgLTI3NywzMSArMjc3LDMyIEBAIHN0YXRpYyBpbmxpbmUgaW50IGlzX2Rt YV9idWZfZmlsZShzdHJ1Y3QgZmlsZSAqZmlsZSkKICAqIEBleHBfbmFtZToJW2luXQluYW1lIG9m IHRoZSBleHBvcnRpbmcgbW9kdWxlIC0gdXNlZnVsIGZvciBkZWJ1Z2dpbmcuCiAgKiBAcmVzdjoJ W2luXQlyZXNlcnZhdGlvbi1vYmplY3QsIE5VTEwgdG8gYWxsb2NhdGUgZGVmYXVsdCBvbmUuCiAg KgorICogQWxsIHRoZSBhYm92ZSBpbmZvIGNvbWVzIGZyb20gc3RydWN0IGRtYV9idWZfZXhwb3J0 X2luZm8uCisgKgogICogUmV0dXJucywgb24gc3VjY2VzcywgYSBuZXdseSBjcmVhdGVkIGRtYV9i dWYgb2JqZWN0LCB3aGljaCB3cmFwcyB0aGUKICAqIHN1cHBsaWVkIHByaXZhdGUgZGF0YSBhbmQg b3BlcmF0aW9ucyBmb3IgZG1hX2J1Zl9vcHMuIE9uIGVpdGhlciBtaXNzaW5nCiAgKiBvcHMsIG9y IGVycm9yIGluIGFsbG9jYXRpbmcgc3RydWN0IGRtYV9idWYsIHdpbGwgcmV0dXJuIG5lZ2F0aXZl IGVycm9yLgogICoKICAqLwotc3RydWN0IGRtYV9idWYgKmRtYV9idWZfZXhwb3J0X25hbWVkKHZv aWQgKnByaXYsIGNvbnN0IHN0cnVjdCBkbWFfYnVmX29wcyAqb3BzLAotCQkJCXNpemVfdCBzaXpl LCBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIgKmV4cF9uYW1lLAotCQkJCXN0cnVjdCByZXNlcnZhdGlv bl9vYmplY3QgKnJlc3YpCitzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnQoc3RydWN0IGRt YV9idWZfZXhwb3J0X2luZm8gKmV4cF9pbmZvKQogewogCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7 CiAJc3RydWN0IGZpbGUgKmZpbGU7CiAJc2l6ZV90IGFsbG9jX3NpemUgPSBzaXplb2Yoc3RydWN0 IGRtYV9idWYpOwotCWlmICghcmVzdikKKwlpZiAoIWV4cF9pbmZvLT5yZXN2KQogCQlhbGxvY19z aXplICs9IHNpemVvZihzdHJ1Y3QgcmVzZXJ2YXRpb25fb2JqZWN0KTsKIAllbHNlCiAJCS8qIHBy ZXZlbnQgJmRtYV9idWZbMV0gPT0gZG1hX2J1Zi0+cmVzdiAqLwogCQlhbGxvY19zaXplICs9IDE7 CiAKLQlpZiAoV0FSTl9PTighcHJpdiB8fCAhb3BzCi0JCQkgIHx8ICFvcHMtPm1hcF9kbWFfYnVm Ci0JCQkgIHx8ICFvcHMtPnVubWFwX2RtYV9idWYKLQkJCSAgfHwgIW9wcy0+cmVsZWFzZQotCQkJ ICB8fCAhb3BzLT5rbWFwX2F0b21pYwotCQkJICB8fCAhb3BzLT5rbWFwCi0JCQkgIHx8ICFvcHMt Pm1tYXApKSB7CisJaWYgKFdBUk5fT04oIWV4cF9pbmZvLT5wcml2CisJCQkgIHx8ICFleHBfaW5m by0+b3BzCisJCQkgIHx8ICFleHBfaW5mby0+b3BzLT5tYXBfZG1hX2J1ZgorCQkJICB8fCAhZXhw X2luZm8tPm9wcy0+dW5tYXBfZG1hX2J1ZgorCQkJICB8fCAhZXhwX2luZm8tPm9wcy0+cmVsZWFz ZQorCQkJICB8fCAhZXhwX2luZm8tPm9wcy0+a21hcF9hdG9taWMKKwkJCSAgfHwgIWV4cF9pbmZv LT5vcHMtPmttYXAKKwkJCSAgfHwgIWV4cF9pbmZvLT5vcHMtPm1tYXApKSB7CiAJCXJldHVybiBF UlJfUFRSKC1FSU5WQUwpOwogCX0KIApAQCAtMzA5LDIxICszMTAsMjIgQEAgc3RydWN0IGRtYV9i dWYgKmRtYV9idWZfZXhwb3J0X25hbWVkKHZvaWQgKnByaXYsIGNvbnN0IHN0cnVjdCBkbWFfYnVm X29wcyAqb3BzLAogCWlmIChkbWFidWYgPT0gTlVMTCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01F TSk7CiAKLQlkbWFidWYtPnByaXYgPSBwcml2OwotCWRtYWJ1Zi0+b3BzID0gb3BzOwotCWRtYWJ1 Zi0+c2l6ZSA9IHNpemU7Ci0JZG1hYnVmLT5leHBfbmFtZSA9IGV4cF9uYW1lOworCWRtYWJ1Zi0+ cHJpdiA9IGV4cF9pbmZvLT5wcml2OworCWRtYWJ1Zi0+b3BzID0gZXhwX2luZm8tPm9wczsKKwlk bWFidWYtPnNpemUgPSBleHBfaW5mby0+c2l6ZTsKKwlkbWFidWYtPmV4cF9uYW1lID0gZXhwX2lu Zm8tPmV4cF9uYW1lOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmRtYWJ1Zi0+cG9sbCk7CiAJZG1h YnVmLT5jYl9leGNsLnBvbGwgPSBkbWFidWYtPmNiX3NoYXJlZC5wb2xsID0gJmRtYWJ1Zi0+cG9s bDsKIAlkbWFidWYtPmNiX2V4Y2wuYWN0aXZlID0gZG1hYnVmLT5jYl9zaGFyZWQuYWN0aXZlID0g MDsKIAotCWlmICghcmVzdikgewotCQlyZXN2ID0gKHN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3Qg KikmZG1hYnVmWzFdOwotCQlyZXNlcnZhdGlvbl9vYmplY3RfaW5pdChyZXN2KTsKKwlpZiAoIWV4 cF9pbmZvLT5yZXN2KSB7CisJCWV4cF9pbmZvLT5yZXN2ID0gKHN0cnVjdCByZXNlcnZhdGlvbl9v YmplY3QgKikmZG1hYnVmWzFdOworCQlyZXNlcnZhdGlvbl9vYmplY3RfaW5pdChleHBfaW5mby0+ cmVzdik7CiAJfQotCWRtYWJ1Zi0+cmVzdiA9IHJlc3Y7CisJZG1hYnVmLT5yZXN2ID0gZXhwX2lu Zm8tPnJlc3Y7CiAKLQlmaWxlID0gYW5vbl9pbm9kZV9nZXRmaWxlKCJkbWFidWYiLCAmZG1hX2J1 Zl9mb3BzLCBkbWFidWYsIGZsYWdzKTsKKwlmaWxlID0gYW5vbl9pbm9kZV9nZXRmaWxlKCJkbWFi dWYiLCAmZG1hX2J1Zl9mb3BzLCBkbWFidWYsCisJCQkJCWV4cF9pbmZvLT5mbGFncyk7CiAJaWYg KElTX0VSUihmaWxlKSkgewogCQlrZnJlZShkbWFidWYpOwogCQlyZXR1cm4gRVJSX0NBU1QoZmls ZSk7CkBAIC0zNDEsOCArMzQzLDcgQEAgc3RydWN0IGRtYV9idWYgKmRtYV9idWZfZXhwb3J0X25h bWVkKHZvaWQgKnByaXYsIGNvbnN0IHN0cnVjdCBkbWFfYnVmX29wcyAqb3BzLAogCiAJcmV0dXJu IGRtYWJ1ZjsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfZXhwb3J0X25hbWVkKTsKLQor RVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1Zl9leHBvcnQpOwogCiAvKioKICAqIGRtYV9idWZfZmQg LSByZXR1cm5zIGEgZmlsZSBkZXNjcmlwdG9yIGZvciB0aGUgZ2l2ZW4gZG1hX2J1ZgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMgYi9kcml2ZXJzL2dwdS9k cm0vYXJtYWRhL2FybWFkYV9nZW0uYwppbmRleCBlZjVmZWVlY2VjODQuLjU4MGUxMGFjYWEzYSAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKKysrIGIvZHJp dmVycy9ncHUvZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMKQEAgLTUzOCw4ICs1MzgsMTQgQEAgc3Ry dWN0IGRtYV9idWYgKgogYXJtYWRhX2dlbV9wcmltZV9leHBvcnQoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmosCiAJaW50IGZsYWdzKQogewotCXJldHVy biBkbWFfYnVmX2V4cG9ydChvYmosICZhcm1hZGFfZ2VtX3ByaW1lX2RtYWJ1Zl9vcHMsIG9iai0+ c2l6ZSwKLQkJCSAgICAgIE9fUkRXUiwgTlVMTCk7CisJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lO Rk8oZXhwX2luZm8pOworCisJZXhwX2luZm8ub3BzID0gJmFybWFkYV9nZW1fcHJpbWVfZG1hYnVm X29wczsKKwlleHBfaW5mby5zaXplID0gb2JqLT5zaXplOworCWV4cF9pbmZvLmZsYWdzID0gT19S RFdSOworCWV4cF9pbmZvLnByaXYgPSBvYmo7CisKKwlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4 cF9pbmZvKTsKIH0KIAogc3RydWN0IGRybV9nZW1fb2JqZWN0ICoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9kcm1fcHJpbWUuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwppbmRl eCA3NDgyYjA2Y2QwOGYuLjdmZWMxOTFiNDVmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9wcmltZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwpAQCAtMzM5LDEz ICszMzksMTcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfYnVmX29wcyBkcm1fZ2VtX3ByaW1l X2RtYWJ1Zl9vcHMgPSAgewogc3RydWN0IGRtYV9idWYgKmRybV9nZW1fcHJpbWVfZXhwb3J0KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCQkJICAgICBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9i aiwgaW50IGZsYWdzKQogewotCXN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3QgKnJvYmogPSBOVUxM OworCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZvKTsKKworCWV4cF9pbmZvLm9w cyA9ICZkcm1fZ2VtX3ByaW1lX2RtYWJ1Zl9vcHM7CisJZXhwX2luZm8uc2l6ZSA9IG9iai0+c2l6 ZTsKKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOworCWV4cF9pbmZvLnByaXYgPSBvYmo7CiAKIAlp ZiAoZGV2LT5kcml2ZXItPmdlbV9wcmltZV9yZXNfb2JqKQotCQlyb2JqID0gZGV2LT5kcml2ZXIt PmdlbV9wcmltZV9yZXNfb2JqKG9iaik7CisJCWV4cF9pbmZvLnJlc3YgPSBkZXYtPmRyaXZlci0+ Z2VtX3ByaW1lX3Jlc19vYmoob2JqKTsKIAotCXJldHVybiBkbWFfYnVmX2V4cG9ydChvYmosICZk cm1fZ2VtX3ByaW1lX2RtYWJ1Zl9vcHMsIG9iai0+c2l6ZSwKLQkJCSAgICAgIGZsYWdzLCByb2Jq KTsKKwlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKIH0KIEVYUE9SVF9TWU1CT0wo ZHJtX2dlbV9wcmltZV9leHBvcnQpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZXh5 bm9zL2V4eW5vc19kcm1fZG1hYnVmLmMgYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19k cm1fZG1hYnVmLmMKaW5kZXggNjAxOTJlZDU0NGYwLi5mYzI5M2ExNzlmMzYgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RybV9kbWFidWYuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZG1hYnVmLmMKQEAgLTE4NSw5ICsxODUsMTQgQEAg c3RydWN0IGRtYV9idWYgKmV4eW5vc19kbWFidWZfcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1fZGV2 aWNlICpkcm1fZGV2LAogCQkJCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqLCBpbnQgZmxhZ3Mp CiB7CiAJc3RydWN0IGV4eW5vc19kcm1fZ2VtX29iaiAqZXh5bm9zX2dlbV9vYmogPSB0b19leHlu b3NfZ2VtX29iaihvYmopOworCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZvKTsK IAotCXJldHVybiBkbWFfYnVmX2V4cG9ydChvYmosICZleHlub3NfZG1hYnVmX29wcywKLQkJCQll eHlub3NfZ2VtX29iai0+YmFzZS5zaXplLCBmbGFncywgTlVMTCk7CisJZXhwX2luZm8ub3BzID0g JmV4eW5vc19kbWFidWZfb3BzOworCWV4cF9pbmZvLnNpemUgPSBleHlub3NfZ2VtX29iai0+YmFz ZS5zaXplOworCWV4cF9pbmZvLmZsYWdzID0gZmxhZ3M7CisJZXhwX2luZm8ucHJpdiA9IG9iajsK KworCXJldHVybiBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8pOwogfQogCiBzdHJ1Y3QgZHJtX2dl bV9vYmplY3QgKmV4eW5vc19kbWFidWZfcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpk cm1fZGV2LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZG1hYnVm LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYwppbmRleCA4MmExZjRi NTc3NzguLjc5OThkYTI3YzUwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9nZW1fZG1hYnVmLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZG1hYnVm LmMKQEAgLTIzMCw2ICsyMzAsMTMgQEAgc3RydWN0IGRtYV9idWYgKmk5MTVfZ2VtX3ByaW1lX2V4 cG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQkJCSAgICAgIHN0cnVjdCBkcm1fZ2VtX29i amVjdCAqZ2VtX29iaiwgaW50IGZsYWdzKQogewogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 ICpvYmogPSB0b19pbnRlbF9ibyhnZW1fb2JqKTsKKwlERUZJTkVfRE1BX0JVRl9FWFBPUlRfSU5G TyhleHBfaW5mbyk7CisKKwlleHBfaW5mby5vcHMgPSAmaTkxNV9kbWFidWZfb3BzOworCWV4cF9p bmZvLnNpemUgPSBnZW1fb2JqLT5zaXplOworCWV4cF9pbmZvLmZsYWdzID0gZmxhZ3M7CisJZXhw X2luZm8ucHJpdiA9IGdlbV9vYmo7CisKIAogCWlmIChvYmotPm9wcy0+ZG1hYnVmX2V4cG9ydCkg ewogCQlpbnQgcmV0ID0gb2JqLT5vcHMtPmRtYWJ1Zl9leHBvcnQob2JqKTsKQEAgLTIzNyw4ICsy NDQsNyBAQCBzdHJ1Y3QgZG1hX2J1ZiAqaTkxNV9nZW1fcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsCiAJCQlyZXR1cm4gRVJSX1BUUihyZXQpOwogCX0KIAotCXJldHVybiBkbWFf YnVmX2V4cG9ydChnZW1fb2JqLCAmaTkxNV9kbWFidWZfb3BzLCBnZW1fb2JqLT5zaXplLCBmbGFn cywKLQkJCSAgICAgIE5VTEwpOworCXJldHVybiBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8pOwog fQogCiBzdGF0aWMgaW50IGk5MTVfZ2VtX29iamVjdF9nZXRfcGFnZXNfZG1hYnVmKHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vb21h cGRybS9vbWFwX2dlbV9kbWFidWYuYyBiL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZ2Vt X2RtYWJ1Zi5jCmluZGV4IGEyZGJmYjE3MzdiNC4uNTg3NGM1OGU3MmMxIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vb21hcGRybS9vbWFwX2dlbV9kbWFidWYuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vb21hcGRybS9vbWFwX2dlbV9kbWFidWYuYwpAQCAtMTcxLDcgKzE3MSwxNCBAQCBzdGF0 aWMgc3RydWN0IGRtYV9idWZfb3BzIG9tYXBfZG1hYnVmX29wcyA9IHsKIHN0cnVjdCBkbWFfYnVm ICpvbWFwX2dlbV9wcmltZV9leHBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJc3RydWN0 IGRybV9nZW1fb2JqZWN0ICpvYmosIGludCBmbGFncykKIHsKLQlyZXR1cm4gZG1hX2J1Zl9leHBv cnQob2JqLCAmb21hcF9kbWFidWZfb3BzLCBvYmotPnNpemUsIGZsYWdzLCBOVUxMKTsKKwlERUZJ TkVfRE1BX0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7CisKKwlleHBfaW5mby5vcHMgPSAmb21h cF9kbWFidWZfb3BzOworCWV4cF9pbmZvLnNpemUgPSBvYmotPnNpemU7CisJZXhwX2luZm8uZmxh Z3MgPSBmbGFnczsKKwlleHBfaW5mby5wcml2ID0gb2JqOworCisJcmV0dXJuIGRtYV9idWZfZXhw b3J0KCZleHBfaW5mbyk7CiB9CiAKIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb21hcF9nZW1fcHJp bWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vdGVncmEvZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKaW5kZXggODc3 N2I3Zjc1NzkxLi4xZjg5NWI5NTNmOGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS90ZWdy YS9nZW0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZ2VtLmMKQEAgLTY1OCw4ICs2NTgs MTQgQEAgc3RydWN0IGRtYV9idWYgKnRlZ3JhX2dlbV9wcmltZV9leHBvcnQoc3RydWN0IGRybV9k ZXZpY2UgKmRybSwKIAkJCQkgICAgICAgc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW0sCiAJCQkJ ICAgICAgIGludCBmbGFncykKIHsKLQlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoZ2VtLCAmdGVncmFf Z2VtX3ByaW1lX2RtYWJ1Zl9vcHMsIGdlbS0+c2l6ZSwKLQkJCSAgICAgIGZsYWdzLCBOVUxMKTsK KwlERUZJTkVfRE1BX0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7CisKKwlleHBfaW5mby5vcHMg PSAmdGVncmFfZ2VtX3ByaW1lX2RtYWJ1Zl9vcHM7CisJZXhwX2luZm8uc2l6ZSA9IGdlbS0+c2l6 ZTsKKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOworCWV4cF9pbmZvLnByaXYgPSBnZW07CisKKwly ZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKIH0KIAogc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICp0ZWdyYV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9vYmplY3QuYyBiL2RyaXZlcnMvZ3B1L2Ry bS90dG0vdHRtX29iamVjdC5jCmluZGV4IDEyYzg3MTEwZGIzYS4uNGY1ZmE4ZDY1ZmU5IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9vYmplY3QuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vdHRtL3R0bV9vYmplY3QuYwpAQCAtNjgzLDYgKzY4MywxMiBAQCBpbnQgdHRtX3ByaW1l X2hhbmRsZV90b19mZChzdHJ1Y3QgdHRtX29iamVjdF9maWxlICp0ZmlsZSwKIAogCWRtYV9idWYg PSBwcmltZS0+ZG1hX2J1ZjsKIAlpZiAoIWRtYV9idWYgfHwgIWdldF9kbWFfYnVmX3VubGVzc19k b29tZWQoZG1hX2J1ZikpIHsKKwkJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8p OworCisJCWV4cF9pbmZvLm9wcyA9ICZ0ZGV2LT5vcHM7CisJCWV4cF9pbmZvLnNpemUgPSBwcmlt ZS0+c2l6ZTsKKwkJZXhwX2luZm8uZmxhZ3MgPSBmbGFnczsKKwkJZXhwX2luZm8ucHJpdiA9IHBy aW1lOwogCiAJCS8qCiAJCSAqIE5lZWQgdG8gY3JlYXRlIGEgbmV3IGRtYV9idWYsIHdpdGggbWVt b3J5IGFjY291bnRpbmcuCkBAIC02OTQsOCArNzAwLDcgQEAgaW50IHR0bV9wcmltZV9oYW5kbGVf dG9fZmQoc3RydWN0IHR0bV9vYmplY3RfZmlsZSAqdGZpbGUsCiAJCQlnb3RvIG91dF91bnJlZjsK IAkJfQogCi0JCWRtYV9idWYgPSBkbWFfYnVmX2V4cG9ydChwcmltZSwgJnRkZXYtPm9wcywKLQkJ CQkJIHByaW1lLT5zaXplLCBmbGFncywgTlVMTCk7CisJCWRtYV9idWYgPSBkbWFfYnVmX2V4cG9y dCgmZXhwX2luZm8pOwogCQlpZiAoSVNfRVJSKGRtYV9idWYpKSB7CiAJCQlyZXQgPSBQVFJfRVJS KGRtYV9idWYpOwogCQkJdHRtX21lbV9nbG9iYWxfZnJlZSh0ZGV2LT5tZW1fZ2xvYiwKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jIGIvZHJpdmVycy9ncHUvZHJt L3VkbC91ZGxfZG1hYnVmLmMKaW5kZXggYWM4YTY2YjRkZmMyLi5lMjI0M2VkZDFjZTMgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS91ZGwvdWRsX2RtYWJ1Zi5jCkBAIC0yMDIsNyArMjAyLDE0IEBAIHN0YXRpYyBzdHJ1Y3Qg ZG1hX2J1Zl9vcHMgdWRsX2RtYWJ1Zl9vcHMgPSB7CiBzdHJ1Y3QgZG1hX2J1ZiAqdWRsX2dlbV9w cmltZV9leHBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJCQkgICAgIHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqb2JqLCBpbnQgZmxhZ3MpCiB7Ci0JcmV0dXJuIGRtYV9idWZfZXhwb3J0KG9i aiwgJnVkbF9kbWFidWZfb3BzLCBvYmotPnNpemUsIGZsYWdzLCBOVUxMKTsKKwlERUZJTkVfRE1B X0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7CisKKwlleHBfaW5mby5vcHMgPSAmdWRsX2RtYWJ1 Zl9vcHM7CisJZXhwX2luZm8uc2l6ZSA9IG9iai0+c2l6ZTsKKwlleHBfaW5mby5mbGFncyA9IGZs YWdzOworCWV4cF9pbmZvLnByaXYgPSBvYmo7CisKKwlyZXR1cm4gZG1hX2J1Zl9leHBvcnQoJmV4 cF9pbmZvKTsKIH0KIAogc3RhdGljIGludCB1ZGxfcHJpbWVfY3JlYXRlKHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjIt ZG1hLWNvbnRpZy5jIGIvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLWRtYS1jb250 aWcuYwppbmRleCBiNDgxZDIwYzgzNzIuLjRhZDkyYTE0NzkxOSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLWRtYS1jb250aWcuYworKysgYi9kcml2ZXJzL21l ZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItZG1hLWNvbnRpZy5jCkBAIC00MDIsNiArNDAyLDEyIEBA IHN0YXRpYyBzdHJ1Y3QgZG1hX2J1ZiAqdmIyX2RjX2dldF9kbWFidWYodm9pZCAqYnVmX3ByaXYs IHVuc2lnbmVkIGxvbmcgZmxhZ3MpCiB7CiAJc3RydWN0IHZiMl9kY19idWYgKmJ1ZiA9IGJ1Zl9w cml2OwogCXN0cnVjdCBkbWFfYnVmICpkYnVmOworCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZP KGV4cF9pbmZvKTsKKworCWV4cF9pbmZvLm9wcyA9ICZ2YjJfZGNfZG1hYnVmX29wczsKKwlleHBf aW5mby5zaXplID0gYnVmLT5zaXplOworCWV4cF9pbmZvLmZsYWdzID0gZmxhZ3M7CisJZXhwX2lu Zm8ucHJpdiA9IGJ1ZjsKIAogCWlmICghYnVmLT5zZ3RfYmFzZSkKIAkJYnVmLT5zZ3RfYmFzZSA9 IHZiMl9kY19nZXRfYmFzZV9zZ3QoYnVmKTsKQEAgLTQwOSw3ICs0MTUsNyBAQCBzdGF0aWMgc3Ry dWN0IGRtYV9idWYgKnZiMl9kY19nZXRfZG1hYnVmKHZvaWQgKmJ1Zl9wcml2LCB1bnNpZ25lZCBs b25nIGZsYWdzKQogCWlmIChXQVJOX09OKCFidWYtPnNndF9iYXNlKSkKIAkJcmV0dXJuIE5VTEw7 CiAKLQlkYnVmID0gZG1hX2J1Zl9leHBvcnQoYnVmLCAmdmIyX2RjX2RtYWJ1Zl9vcHMsIGJ1Zi0+ c2l6ZSwgZmxhZ3MsIE5VTEwpOworCWRidWYgPSBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8pOwog CWlmIChJU19FUlIoZGJ1ZikpCiAJCXJldHVybiBOVUxMOwogCmRpZmYgLS1naXQgYS9kcml2ZXJz L21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItZG1hLXNnLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDIt Y29yZS92aWRlb2J1ZjItZG1hLXNnLmMKaW5kZXggYjE4MzhhYmI2ZDAwLi40NWM3MDhlNDYzYjkg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1kbWEtc2cuYwor KysgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItZG1hLXNnLmMKQEAgLTU4Mywx MSArNTgzLDE3IEBAIHN0YXRpYyBzdHJ1Y3QgZG1hX2J1ZiAqdmIyX2RtYV9zZ19nZXRfZG1hYnVm KHZvaWQgKmJ1Zl9wcml2LCB1bnNpZ25lZCBsb25nIGZsYWdzCiB7CiAJc3RydWN0IHZiMl9kbWFf c2dfYnVmICpidWYgPSBidWZfcHJpdjsKIAlzdHJ1Y3QgZG1hX2J1ZiAqZGJ1ZjsKKwlERUZJTkVf RE1BX0JVRl9FWFBPUlRfSU5GTyhleHBfaW5mbyk7CisKKwlleHBfaW5mby5vcHMgPSAmdmIyX2Rt YV9zZ19kbWFidWZfb3BzOworCWV4cF9pbmZvLnNpemUgPSBidWYtPnNpemU7CisJZXhwX2luZm8u ZmxhZ3MgPSBmbGFnczsKKwlleHBfaW5mby5wcml2ID0gYnVmOwogCiAJaWYgKFdBUk5fT04oIWJ1 Zi0+ZG1hX3NndCkpCiAJCXJldHVybiBOVUxMOwogCi0JZGJ1ZiA9IGRtYV9idWZfZXhwb3J0KGJ1 ZiwgJnZiMl9kbWFfc2dfZG1hYnVmX29wcywgYnVmLT5zaXplLCBmbGFncywgTlVMTCk7CisJZGJ1 ZiA9IGRtYV9idWZfZXhwb3J0KCZleHBfaW5mbyk7CiAJaWYgKElTX0VSUihkYnVmKSkKIAkJcmV0 dXJuIE5VTEw7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVm Mi12bWFsbG9jLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItdm1hbGxvYy5j CmluZGV4IGZiYTk0NGU1MDIyNy4uOTkyYjFiNTk0MDljIDEwMDY0NAotLS0gYS9kcml2ZXJzL21l ZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItdm1hbGxvYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdjRs Mi1jb3JlL3ZpZGVvYnVmMi12bWFsbG9jLmMKQEAgLTM2NywxMSArMzY3LDE3IEBAIHN0YXRpYyBz dHJ1Y3QgZG1hX2J1ZiAqdmIyX3ZtYWxsb2NfZ2V0X2RtYWJ1Zih2b2lkICpidWZfcHJpdiwgdW5z aWduZWQgbG9uZyBmbGFnCiB7CiAJc3RydWN0IHZiMl92bWFsbG9jX2J1ZiAqYnVmID0gYnVmX3By aXY7CiAJc3RydWN0IGRtYV9idWYgKmRidWY7CisJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8o ZXhwX2luZm8pOworCisJZXhwX2luZm8ub3BzID0gJnZiMl92bWFsbG9jX2RtYWJ1Zl9vcHM7CisJ ZXhwX2luZm8uc2l6ZSA9IGJ1Zi0+c2l6ZTsKKwlleHBfaW5mby5mbGFncyA9IGZsYWdzOworCWV4 cF9pbmZvLnByaXYgPSBidWY7CiAKIAlpZiAoV0FSTl9PTighYnVmLT52YWRkcikpCiAJCXJldHVy biBOVUxMOwogCi0JZGJ1ZiA9IGRtYV9idWZfZXhwb3J0KGJ1ZiwgJnZiMl92bWFsbG9jX2RtYWJ1 Zl9vcHMsIGJ1Zi0+c2l6ZSwgZmxhZ3MsIE5VTEwpOworCWRidWYgPSBkbWFfYnVmX2V4cG9ydCgm ZXhwX2luZm8pOwogCWlmIChJU19FUlIoZGJ1ZikpCiAJCXJldHVybiBOVUxMOwogCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9pb24vaW9uLmMgYi9kcml2ZXJzL3N0YWdpbmcv YW5kcm9pZC9pb24vaW9uLmMKaW5kZXggMjk2ZDM0NzY2MGZjLi5hNDI5N2JlOGYxMmYgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYworKysgYi9kcml2ZXJzL3N0 YWdpbmcvYW5kcm9pZC9pb24vaW9uLmMKQEAgLTExMDYsNiArMTEwNiwxMiBAQCBzdHJ1Y3QgZG1h X2J1ZiAqaW9uX3NoYXJlX2RtYV9idWYoc3RydWN0IGlvbl9jbGllbnQgKmNsaWVudCwKIAlzdHJ1 Y3QgaW9uX2J1ZmZlciAqYnVmZmVyOwogCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7CiAJYm9vbCB2 YWxpZF9oYW5kbGU7CisJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOworCisJ ZXhwX2luZm8ub3BzID0gJmRtYV9idWZfb3BzOworCWV4cF9pbmZvLnNpemUgPSBidWZmZXItPnNp emU7CisJZXhwX2luZm8uZmxhZ3MgPSBPX1JEV1I7CisJZXhwX2luZm8ucHJpdiA9IGJ1ZmZlcjsK IAogCW11dGV4X2xvY2soJmNsaWVudC0+bG9jayk7CiAJdmFsaWRfaGFuZGxlID0gaW9uX2hhbmRs ZV92YWxpZGF0ZShjbGllbnQsIGhhbmRsZSk7CkBAIC0xMTE4LDggKzExMjQsNyBAQCBzdHJ1Y3Qg ZG1hX2J1ZiAqaW9uX3NoYXJlX2RtYV9idWYoc3RydWN0IGlvbl9jbGllbnQgKmNsaWVudCwKIAlp b25fYnVmZmVyX2dldChidWZmZXIpOwogCW11dGV4X3VubG9jaygmY2xpZW50LT5sb2NrKTsKIAot CWRtYWJ1ZiA9IGRtYV9idWZfZXhwb3J0KGJ1ZmZlciwgJmRtYV9idWZfb3BzLCBidWZmZXItPnNp emUsIE9fUkRXUiwKLQkJCQlOVUxMKTsKKwlkbWFidWYgPSBkbWFfYnVmX2V4cG9ydCgmZXhwX2lu Zm8pOwogCWlmIChJU19FUlIoZG1hYnVmKSkgewogCQlpb25fYnVmZmVyX3B1dChidWZmZXIpOwog CQlyZXR1cm4gZG1hYnVmOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmggYi9p bmNsdWRlL2xpbnV4L2RtYS1idWYuaAppbmRleCA2OTRlMWZlMWM0YjQuLjIyYzIxYTIyNGUzMiAx MDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKKysrIGIvaW5jbHVkZS9saW51eC9k bWEtYnVmLmgKQEAgLTE2Myw2ICsxNjMsMzQgQEAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCB7 CiB9OwogCiAvKioKKyAqIHN0cnVjdCBkbWFfYnVmX2V4cG9ydF9pbmZvIC0gaG9sZHMgaW5mb3Jt YXRpb24gbmVlZGVkIHRvIGV4cG9ydCBhIGRtYV9idWYKKyAqIEBleHBfbmFtZToJbmFtZSBvZiB0 aGUgZXhwb3J0aW5nIG1vZHVsZSAtIHVzZWZ1bCBmb3IgZGVidWdnaW5nLgorICogQG9wczoJQXR0 YWNoIGFsbG9jYXRvci1kZWZpbmVkIGRtYSBidWYgb3BzIHRvIHRoZSBuZXcgYnVmZmVyCisgKiBA c2l6ZToJU2l6ZSBvZiB0aGUgYnVmZmVyCisgKiBAZmxhZ3M6CW1vZGUgZmxhZ3MgZm9yIHRoZSBm aWxlCisgKiBAcmVzdjoJcmVzZXJ2YXRpb24tb2JqZWN0LCBOVUxMIHRvIGFsbG9jYXRlIGRlZmF1 bHQgb25lCisgKiBAcHJpdjoJQXR0YWNoIHByaXZhdGUgZGF0YSBvZiBhbGxvY2F0b3IgdG8gdGhp cyBidWZmZXIKKyAqCisgKiBUaGlzIHN0cnVjdHVyZSBob2xkcyB0aGUgaW5mb3JtYXRpb24gcmVx dWlyZWQgdG8gZXhwb3J0IHRoZSBidWZmZXIuIFVzZWQKKyAqIHdpdGggZG1hX2J1Zl9leHBvcnQo KSBvbmx5LgorICovCitzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyB7CisJY29uc3QgY2hhciAq ZXhwX25hbWU7CisJY29uc3Qgc3RydWN0IGRtYV9idWZfb3BzICpvcHM7CisJc2l6ZV90IHNpemU7 CisJaW50IGZsYWdzOworCXN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3QgKnJlc3Y7CisJdm9pZCAq cHJpdjsKK307CisKKy8qKgorICogaGVscGVyIG1hY3JvIGZvciBleHBvcnRlcnM7IHplcm9zIGFu ZCBmaWxscyBpbiBtb3N0IGNvbW1vbiB2YWx1ZXMKKyAqLworI2RlZmluZSBERUZJTkVfRE1BX0JV Rl9FWFBPUlRfSU5GTyhhKQkJCVwKKwlzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyBhID0gezB9 OwkJXAorCWV4cF9pbmZvLmV4cF9uYW1lID0gS0JVSUxEX01PRE5BTUUKKworLyoqCiAgKiBnZXRf ZG1hX2J1ZiAtIGNvbnZlbmllbmNlIHdyYXBwZXIgZm9yIGdldF9maWxlLgogICogQGRtYWJ1ZjoJ W2luXQlwb2ludGVyIHRvIGRtYV9idWYKICAqCkBAIC0xODEsMTIgKzIwOSw3IEBAIHN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYs CiB2b2lkIGRtYV9idWZfZGV0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCiAJCQkJc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCAqZG1hYnVmX2F0dGFjaCk7CiAKLXN0cnVjdCBkbWFfYnVmICpk bWFfYnVmX2V4cG9ydF9uYW1lZCh2b2lkICpwcml2LCBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9vcHMg Km9wcywKLQkJCSAgICAgICBzaXplX3Qgc2l6ZSwgaW50IGZsYWdzLCBjb25zdCBjaGFyICosCi0J CQkgICAgICAgc3RydWN0IHJlc2VydmF0aW9uX29iamVjdCAqKTsKLQotI2RlZmluZSBkbWFfYnVm X2V4cG9ydChwcml2LCBvcHMsIHNpemUsIGZsYWdzLCByZXN2KQlcCi0JZG1hX2J1Zl9leHBvcnRf bmFtZWQocHJpdiwgb3BzLCBzaXplLCBmbGFncywgS0JVSUxEX01PRE5BTUUsIHJlc3YpCitzdHJ1 Y3QgZG1hX2J1ZiAqZG1hX2J1Zl9leHBvcnQoc3RydWN0IGRtYV9idWZfZXhwb3J0X2luZm8gKmV4 cF9pbmZvKTsKIAogaW50IGRtYV9idWZfZmQoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwgaW50IGZs YWdzKTsKIHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmX2dldChpbnQgZmQpOwotLSAKMS45LjEKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBt YWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1761537AbbA1GBI (ORCPT ); Wed, 28 Jan 2015 01:01:08 -0500 Received: from mail-pd0-f179.google.com ([209.85.192.179]:46478 "EHLO mail-pd0-f179.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1761421AbbA1GBG (ORCPT ); Wed, 28 Jan 2015 01:01:06 -0500 From: Sumit Semwal To: 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, robdclark@gmail.com, daniel@ffwll.ch, intel-gfx@lists.freedesktop.org, linux-tegra@vger.kernel.org, inki.dae@samsung.com, Sumit Semwal Subject: [PATCH v2] dma-buf: cleanup dma_buf_export() to make it easily extensible Date: Wed, 28 Jan 2015 11:30:45 +0530 Message-Id: <1422424845-14906-1-git-send-email-sumit.semwal@linaro.org> X-Mailer: git-send-email 1.9.1 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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 --- 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 | 35 +++++++++++++++---- 14 files changed, 143 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) { 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..22c21a224e32 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -163,6 +163,34 @@ 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 = {0}; \ + exp_info.exp_name = KBUILD_MODNAME + +/** * get_dma_buf - convenience wrapper for get_file. * @dmabuf: [in] pointer to dma_buf * @@ -181,12 +209,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); -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: sumit.semwal@linaro.org (Sumit Semwal) Date: Wed, 28 Jan 2015 11:30:45 +0530 Subject: [PATCH v2] dma-buf: cleanup dma_buf_export() to make it easily extensible Message-ID: <1422424845-14906-1-git-send-email-sumit.semwal@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org 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 --- 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 | 35 +++++++++++++++---- 14 files changed, 143 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) { 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..22c21a224e32 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -163,6 +163,34 @@ 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 = {0}; \ + exp_info.exp_name = KBUILD_MODNAME + +/** * get_dma_buf - convenience wrapper for get_file. * @dmabuf: [in] pointer to dma_buf * @@ -181,12 +209,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); -- 1.9.1