From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v3 3/9] xen/balloon: Share common memory reservation routines Date: Tue, 12 Jun 2018 16:41:54 +0300 Message-ID: <20180612134200.17456-4-andr2000@gmail.com> References: <20180612134200.17456-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7FD3B6E4D3 for ; Tue, 12 Jun 2018 13:42:15 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id n3-v6so36086713lfe.12 for ; Tue, 12 Jun 2018 06:42:15 -0700 (PDT) In-Reply-To: <20180612134200.17456-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, daniel.vetter@intel.com, dongwon.kim@intel.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKTWVtb3J5IHtpbmNyZWFzZXxkZWNyZWFzZX1fcmVzZXJ2YXRpb24gYW5kIFZBIG1h cHBpbmdzIHVwZGF0ZS9yZXNldApjb2RlIHVzZWQgaW4gYmFsbG9vbiBkcml2ZXIgY2FuIGJlIG1h ZGUgY29tbW9uLCBzbyBvdGhlciBkcml2ZXJzIGNhbgphbHNvIHJlLXVzZSB0aGUgc2FtZSBmdW5j dGlvbmFsaXR5IHdpdGhvdXQgb3Blbi1jb2RpbmcuCkNyZWF0ZSBhIGRlZGljYXRlZCBmaWxlIGZv ciB0aGUgc2hhcmVkIGNvZGUgYW5kIGV4cG9ydCBjb3JyZXNwb25kaW5nCnN5bWJvbHMgZm9yIG90 aGVyIGtlcm5lbCBtb2R1bGVzLgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVu a28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGRyaXZlcnMveGVuL01h a2VmaWxlICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMveGVuL2JhbGxvb24uYyAgICAgICAgIHwg IDcxICsrLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy94ZW4vbWVtLXJlc2VydmF0aW9uLmMg fCAxMTIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS94ZW4vbWVt LXJlc2VydmF0aW9uLmggfCAgNjQgKysrKysrKysrKysrKysrKysrKwogNCBmaWxlcyBjaGFuZ2Vk LCAxODMgaW5zZXJ0aW9ucygrKSwgNjUgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy94ZW4vbWVtLXJlc2VydmF0aW9uLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRl L3hlbi9tZW0tcmVzZXJ2YXRpb24uaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL01ha2VmaWxl IGIvZHJpdmVycy94ZW4vTWFrZWZpbGUKaW5kZXggNDUxZTgzM2Y1OTMxLi4zYzg3YjBjM2FjYTYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL01ha2VmaWxlCisrKyBiL2RyaXZlcnMveGVuL01ha2Vm aWxlCkBAIC0yLDYgKzIsNyBAQAogb2JqLSQoQ09ORklHX0hPVFBMVUdfQ1BVKQkJKz0gY3B1X2hv dHBsdWcubwogb2JqLSQoQ09ORklHX1g4NikJCQkrPSBmYWxsYmFjay5vCiBvYmoteQkrPSBncmFu dC10YWJsZS5vIGZlYXR1cmVzLm8gYmFsbG9vbi5vIG1hbmFnZS5vIHByZWVtcHQubyB0aW1lLm8K K29iai15CSs9IG1lbS1yZXNlcnZhdGlvbi5vCiBvYmoteQkrPSBldmVudHMvCiBvYmoteQkrPSB4 ZW5idXMvCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2JhbGxvb24uYyBiL2RyaXZlcnMveGVu L2JhbGxvb24uYwppbmRleCAwNjVmMGI2MDczNzMuLmJkYmNlNDI1N2I2NSAxMDA2NDQKLS0tIGEv ZHJpdmVycy94ZW4vYmFsbG9vbi5jCisrKyBiL2RyaXZlcnMveGVuL2JhbGxvb24uYwpAQCAtNzEs NiArNzEsNyBAQAogI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CiAjaW5jbHVkZSA8eGVuL2ZlYXR1 cmVzLmg+CiAjaW5jbHVkZSA8eGVuL3BhZ2UuaD4KKyNpbmNsdWRlIDx4ZW4vbWVtLXJlc2VydmF0 aW9uLmg+CiAKIHN0YXRpYyBpbnQgeGVuX2hvdHBsdWdfdW5wb3B1bGF0ZWQ7CiAKQEAgLTE1Nywx MyArMTU4LDYgQEAgc3RhdGljIERFQ0xBUkVfREVMQVlFRF9XT1JLKGJhbGxvb25fd29ya2VyLCBi YWxsb29uX3Byb2Nlc3MpOwogI2RlZmluZSBHRlBfQkFMTE9PTiBcCiAJKEdGUF9ISUdIVVNFUiB8 IF9fR0ZQX05PV0FSTiB8IF9fR0ZQX05PUkVUUlkgfCBfX0dGUF9OT01FTUFMTE9DKQogCi1zdGF0 aWMgdm9pZCBzY3J1Yl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQotewotI2lmZGVmIENPTkZJR19Y RU5fU0NSVUJfUEFHRVMKLQljbGVhcl9oaWdocGFnZShwYWdlKTsKLSNlbmRpZgotfQotCiAvKiBi YWxsb29uX2FwcGVuZDogYWRkIHRoZSBnaXZlbiBwYWdlIHRvIHRoZSBiYWxsb29uLiAqLwogc3Rh dGljIHZvaWQgX19iYWxsb29uX2FwcGVuZChzdHJ1Y3QgcGFnZSAqcGFnZSkKIHsKQEAgLTQ2Mywx MSArNDU3LDYgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgaW5jcmVhc2VfcmVzZXJ2YXRpb24odW5z aWduZWQgbG9uZyBucl9wYWdlcykKIAlpbnQgcmM7CiAJdW5zaWduZWQgbG9uZyBpOwogCXN0cnVj dCBwYWdlICAgKnBhZ2U7Ci0Jc3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24gcmVzZXJ2YXRp b24gPSB7Ci0JCS5hZGRyZXNzX2JpdHMgPSAwLAotCQkuZXh0ZW50X29yZGVyID0gRVhURU5UX09S REVSLAotCQkuZG9taWQgICAgICAgID0gRE9NSURfU0VMRgotCX07CiAKIAlpZiAobnJfcGFnZXMg PiBBUlJBWV9TSVpFKGZyYW1lX2xpc3QpKQogCQlucl9wYWdlcyA9IEFSUkFZX1NJWkUoZnJhbWVf bGlzdCk7CkBAIC00ODYsOSArNDc1LDcgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgaW5jcmVhc2Vf cmVzZXJ2YXRpb24odW5zaWduZWQgbG9uZyBucl9wYWdlcykKIAkJcGFnZSA9IGJhbGxvb25fbmV4 dF9wYWdlKHBhZ2UpOwogCX0KIAotCXNldF94ZW5fZ3Vlc3RfaGFuZGxlKHJlc2VydmF0aW9uLmV4 dGVudF9zdGFydCwgZnJhbWVfbGlzdCk7Ci0JcmVzZXJ2YXRpb24ubnJfZXh0ZW50cyA9IG5yX3Bh Z2VzOwotCXJjID0gSFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVNX3BvcHVsYXRlX3BoeXNtYXAs ICZyZXNlcnZhdGlvbik7CisJcmMgPSB4ZW5tZW1fcmVzZXJ2YXRpb25faW5jcmVhc2UobnJfcGFn ZXMsIGZyYW1lX2xpc3QpOwogCWlmIChyYyA8PSAwKQogCQlyZXR1cm4gQlBfRUFHQUlOOwogCkBA IC00OTYsMjkgKzQ4Myw3IEBAIHN0YXRpYyBlbnVtIGJwX3N0YXRlIGluY3JlYXNlX3Jlc2VydmF0 aW9uKHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMpCiAJCXBhZ2UgPSBiYWxsb29uX3JldHJpZXZlKGZh bHNlKTsKIAkJQlVHX09OKHBhZ2UgPT0gTlVMTCk7CiAKLSNpZmRlZiBDT05GSUdfWEVOX0hBVkVf UFZNTVUKLQkJLyoKLQkJICogV2UgZG9uJ3Qgc3VwcG9ydCBQViBNTVUgd2hlbiBMaW51eCBhbmQg WGVuIGlzIHVzaW5nCi0JCSAqIGRpZmZlcmVudCBwYWdlIGdyYW51bGFyaXR5LgotCQkgKi8KLQkJ QlVJTERfQlVHX09OKFhFTl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKTsKLQotCQlpZiAoIXhlbl9m ZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSB7Ci0JCQl1bnNpZ25lZCBs b25nIHBmbiA9IHBhZ2VfdG9fcGZuKHBhZ2UpOwotCi0JCQlzZXRfcGh5c190b19tYWNoaW5lKHBm biwgZnJhbWVfbGlzdFtpXSk7Ci0KLQkJCS8qIExpbmsgYmFjayBpbnRvIHRoZSBwYWdlIHRhYmxl cyBpZiBub3QgaGlnaG1lbS4gKi8KLQkJCWlmICghUGFnZUhpZ2hNZW0ocGFnZSkpIHsKLQkJCQlp bnQgcmV0OwotCQkJCXJldCA9IEhZUEVSVklTT1JfdXBkYXRlX3ZhX21hcHBpbmcoCi0JCQkJCQko dW5zaWduZWQgbG9uZylfX3ZhKHBmbiA8PCBQQUdFX1NISUZUKSwKLQkJCQkJCW1mbl9wdGUoZnJh bWVfbGlzdFtpXSwgUEFHRV9LRVJORUwpLAotCQkJCQkJMCk7Ci0JCQkJQlVHX09OKHJldCk7Ci0J CQl9Ci0JCX0KLSNlbmRpZgorCQl4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUo MSwgJnBhZ2UsICZmcmFtZV9saXN0W2ldKTsKIAogCQkvKiBSZWxpbnF1aXNoIHRoZSBwYWdlIGJh Y2sgdG8gdGhlIGFsbG9jYXRvci4gKi8KIAkJZnJlZV9yZXNlcnZlZF9wYWdlKHBhZ2UpOwpAQCAt NTM1LDExICs1MDAsNiBAQCBzdGF0aWMgZW51bSBicF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlv bih1bnNpZ25lZCBsb25nIG5yX3BhZ2VzLCBnZnBfdCBnZnApCiAJdW5zaWduZWQgbG9uZyBpOwog CXN0cnVjdCBwYWdlICpwYWdlLCAqdG1wOwogCWludCByZXQ7Ci0Jc3RydWN0IHhlbl9tZW1vcnlf cmVzZXJ2YXRpb24gcmVzZXJ2YXRpb24gPSB7Ci0JCS5hZGRyZXNzX2JpdHMgPSAwLAotCQkuZXh0 ZW50X29yZGVyID0gRVhURU5UX09SREVSLAotCQkuZG9taWQgICAgICAgID0gRE9NSURfU0VMRgot CX07CiAJTElTVF9IRUFEKHBhZ2VzKTsKIAogCWlmIChucl9wYWdlcyA+IEFSUkFZX1NJWkUoZnJh bWVfbGlzdCkpCkBAIC01NTMsNyArNTEzLDcgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgZGVjcmVh c2VfcmVzZXJ2YXRpb24odW5zaWduZWQgbG9uZyBucl9wYWdlcywgZ2ZwX3QgZ2ZwKQogCQkJYnJl YWs7CiAJCX0KIAkJYWRqdXN0X21hbmFnZWRfcGFnZV9jb3VudChwYWdlLCAtMSk7Ci0JCXNjcnVi X3BhZ2UocGFnZSk7CisJCXhlbm1lbV9yZXNlcnZhdGlvbl9zY3J1Yl9wYWdlKHBhZ2UpOwogCQls aXN0X2FkZCgmcGFnZS0+bHJ1LCAmcGFnZXMpOwogCX0KIApAQCAtNTc1LDI1ICs1MzUsOCBAQCBz dGF0aWMgZW51bSBicF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlvbih1bnNpZ25lZCBsb25nIG5y X3BhZ2VzLCBnZnBfdCBnZnApCiAJCS8qIFhFTk1FTV9kZWNyZWFzZV9yZXNlcnZhdGlvbiByZXF1 aXJlcyBhIEdGTiAqLwogCQlmcmFtZV9saXN0W2krK10gPSB4ZW5fcGFnZV90b19nZm4ocGFnZSk7 CiAKLSNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZNTVUKLQkJLyoKLQkJICogV2UgZG9uJ3Qgc3Vw cG9ydCBQViBNTVUgd2hlbiBMaW51eCBhbmQgWGVuIGlzIHVzaW5nCi0JCSAqIGRpZmZlcmVudCBw YWdlIGdyYW51bGFyaXR5LgotCQkgKi8KLQkJQlVJTERfQlVHX09OKFhFTl9QQUdFX1NJWkUgIT0g UEFHRV9TSVpFKTsKLQotCQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVk X3BoeXNtYXApKSB7Ci0JCQl1bnNpZ25lZCBsb25nIHBmbiA9IHBhZ2VfdG9fcGZuKHBhZ2UpOwor CQl4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ19yZXNldCgxLCAmcGFnZSk7CiAKLQkJCWlm ICghUGFnZUhpZ2hNZW0ocGFnZSkpIHsKLQkJCQlyZXQgPSBIWVBFUlZJU09SX3VwZGF0ZV92YV9t YXBwaW5nKAotCQkJCQkJKHVuc2lnbmVkIGxvbmcpX192YShwZm4gPDwgUEFHRV9TSElGVCksCi0J CQkJCQlfX3B0ZV9tYSgwKSwgMCk7Ci0JCQkJQlVHX09OKHJldCk7Ci0JCQl9Ci0JCQlfX3NldF9w aHlzX3RvX21hY2hpbmUocGZuLCBJTlZBTElEX1AyTV9FTlRSWSk7Ci0JCX0KLSNlbmRpZgogCQls aXN0X2RlbCgmcGFnZS0+bHJ1KTsKIAogCQliYWxsb29uX2FwcGVuZChwYWdlKTsKQEAgLTYwMSw5 ICs1NDQsNyBAQCBzdGF0aWMgZW51bSBicF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlvbih1bnNp Z25lZCBsb25nIG5yX3BhZ2VzLCBnZnBfdCBnZnApCiAKIAlmbHVzaF90bGJfYWxsKCk7CiAKLQlz ZXRfeGVuX2d1ZXN0X2hhbmRsZShyZXNlcnZhdGlvbi5leHRlbnRfc3RhcnQsIGZyYW1lX2xpc3Qp OwotCXJlc2VydmF0aW9uLm5yX2V4dGVudHMgICA9IG5yX3BhZ2VzOwotCXJldCA9IEhZUEVSVklT T1JfbWVtb3J5X29wKFhFTk1FTV9kZWNyZWFzZV9yZXNlcnZhdGlvbiwgJnJlc2VydmF0aW9uKTsK KwlyZXQgPSB4ZW5tZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UobnJfcGFnZXMsIGZyYW1lX2xpc3Qp OwogCUJVR19PTihyZXQgIT0gbnJfcGFnZXMpOwogCiAJYmFsbG9vbl9zdGF0cy5jdXJyZW50X3Bh Z2VzIC09IG5yX3BhZ2VzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vbWVtLXJlc2VydmF0aW9u LmMgYi9kcml2ZXJzL3hlbi9tZW0tcmVzZXJ2YXRpb24uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLmFhNTUxZDU4MDAxYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZl cnMveGVuL21lbS1yZXNlcnZhdGlvbi5jCkBAIC0wLDAgKzEsMTEyIEBACisvLyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBYZW4g bWVtb3J5IHJlc2VydmF0aW9uIHV0aWxpdGllcy4KKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMs IEIgRHJhZ292aWMKKyAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA0LCBNIFdpbGxpYW1zb24sIEsg RnJhc2VyCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUgRGFuIE0uIFNtaXRoLCBJQk0gQ29ycG9yYXRp b24KKyAqIENvcHlyaWdodCAoYykgMjAxMCBEYW5pZWwgS2lwZXIKKyAqIENvcHlyaWdodCAoYykg MjAxOCBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbywgRVBBTSBTeXN0ZW1zIEluYy4KKyAqLworCisj aW5jbHVkZSA8eGVuL21lbS1yZXNlcnZhdGlvbi5oPgorCisvKgorICogVXNlIG9uZSBleHRlbnQg cGVyIFBBR0VfU0laRSB0byBhdm9pZCB0byBicmVhayBkb3duIHRoZSBwYWdlIGludG8KKyAqIG11 bHRpcGxlIGZyYW1lLgorICovCisjZGVmaW5lIEVYVEVOVF9PUkRFUiAoZmxzKFhFTl9QRk5fUEVS X1BBR0UpIC0gMSkKKworI2lmZGVmIENPTkZJR19YRU5fSEFWRV9QVk1NVQordm9pZCBfX3hlbm1l bV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3VwZGF0ZSh1bnNpZ25lZCBsb25nIGNvdW50LAorCQkJ CQkgICAgc3RydWN0IHBhZ2UgKipwYWdlcywKKwkJCQkJICAgIHhlbl9wZm5fdCAqZnJhbWVzKQor eworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKwkJc3RydWN0IHBh Z2UgKnBhZ2UgPSBwYWdlc1tpXTsKKwkJdW5zaWduZWQgbG9uZyBwZm4gPSBwYWdlX3RvX3Bmbihw YWdlKTsKKworCQlCVUdfT04ocGFnZSA9PSBOVUxMKTsKKworCQkvKgorCQkgKiBXZSBkb24ndCBz dXBwb3J0IFBWIE1NVSB3aGVuIExpbnV4IGFuZCBYZW4gaXMgdXNpbmcKKwkJICogZGlmZmVyZW50 IHBhZ2UgZ3JhbnVsYXJpdHkuCisJCSAqLworCQlCVUlMRF9CVUdfT04oWEVOX1BBR0VfU0laRSAh PSBQQUdFX1NJWkUpOworCisKKwkJc2V0X3BoeXNfdG9fbWFjaGluZShwZm4sIGZyYW1lc1tpXSk7 CisKKwkJLyogTGluayBiYWNrIGludG8gdGhlIHBhZ2UgdGFibGVzIGlmIG5vdCBoaWdobWVtLiAq LworCQlpZiAoIVBhZ2VIaWdoTWVtKHBhZ2UpKSB7CisJCQlpbnQgcmV0OworCisJCQlyZXQgPSBI WVBFUlZJU09SX3VwZGF0ZV92YV9tYXBwaW5nKAorCQkJCQkodW5zaWduZWQgbG9uZylfX3ZhKHBm biA8PCBQQUdFX1NISUZUKSwKKwkJCQkJbWZuX3B0ZShmcmFtZXNbaV0sIFBBR0VfS0VSTkVMKSwK KwkJCQkJMCk7CisJCQlCVUdfT04ocmV0KTsKKwkJfQorCX0KK30KK0VYUE9SVF9TWU1CT0xfR1BM KF9feGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfdXBkYXRlKTsKKwordm9pZCBfX3hlbm1l bV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3Jlc2V0KHVuc2lnbmVkIGxvbmcgY291bnQsCisJCQkJ CSAgIHN0cnVjdCBwYWdlICoqcGFnZXMpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwg Y291bnQ7IGkrKykgeworCQlzdHJ1Y3QgcGFnZSAqcGFnZSA9IHBhZ2VzW2ldOworCQl1bnNpZ25l ZCBsb25nIHBmbiA9IHBhZ2VfdG9fcGZuKHBhZ2UpOworCisJCS8qCisJCSAqIFdlIGRvbid0IHN1 cHBvcnQgUFYgTU1VIHdoZW4gTGludXggYW5kIFhlbiBpcyB1c2luZworCQkgKiBkaWZmZXJlbnQg cGFnZSBncmFudWxhcml0eS4KKwkJICovCisJCUJVSUxEX0JVR19PTihYRU5fUEFHRV9TSVpFICE9 IFBBR0VfU0laRSk7CisKKwkJaWYgKCFQYWdlSGlnaE1lbShwYWdlKSkgeworCQkJaW50IHJldDsK KworCQkJcmV0ID0gSFlQRVJWSVNPUl91cGRhdGVfdmFfbWFwcGluZygKKwkJCQkJKHVuc2lnbmVk IGxvbmcpX192YShwZm4gPDwgUEFHRV9TSElGVCksCisJCQkJCV9fcHRlX21hKDApLCAwKTsKKwkJ CUJVR19PTihyZXQpOworCQl9CisJCV9fc2V0X3BoeXNfdG9fbWFjaGluZShwZm4sIElOVkFMSURf UDJNX0VOVFJZKTsKKwl9Cit9CitFWFBPUlRfU1lNQk9MX0dQTChfX3hlbm1lbV9yZXNlcnZhdGlv bl92YV9tYXBwaW5nX3Jlc2V0KTsKKyNlbmRpZiAvKiBDT05GSUdfWEVOX0hBVkVfUFZNTVUgKi8K KworaW50IHhlbm1lbV9yZXNlcnZhdGlvbl9pbmNyZWFzZShpbnQgY291bnQsIHhlbl9wZm5fdCAq ZnJhbWVzKQoreworCXN0cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIHJlc2VydmF0aW9uID0g eworCQkuYWRkcmVzc19iaXRzID0gMCwKKwkJLmV4dGVudF9vcmRlciA9IEVYVEVOVF9PUkRFUiwK KwkJLmRvbWlkICAgICAgICA9IERPTUlEX1NFTEYKKwl9OworCisJc2V0X3hlbl9ndWVzdF9oYW5k bGUocmVzZXJ2YXRpb24uZXh0ZW50X3N0YXJ0LCBmcmFtZXMpOworCXJlc2VydmF0aW9uLm5yX2V4 dGVudHMgPSBjb3VudDsKKwlyZXR1cm4gSFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVNX3BvcHVs YXRlX3BoeXNtYXAsICZyZXNlcnZhdGlvbik7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh4ZW5tZW1f cmVzZXJ2YXRpb25faW5jcmVhc2UpOworCitpbnQgeGVubWVtX3Jlc2VydmF0aW9uX2RlY3JlYXNl KGludCBjb3VudCwgeGVuX3Bmbl90ICpmcmFtZXMpCit7CisJc3RydWN0IHhlbl9tZW1vcnlfcmVz ZXJ2YXRpb24gcmVzZXJ2YXRpb24gPSB7CisJCS5hZGRyZXNzX2JpdHMgPSAwLAorCQkuZXh0ZW50 X29yZGVyID0gRVhURU5UX09SREVSLAorCQkuZG9taWQgICAgICAgID0gRE9NSURfU0VMRgorCX07 CisKKwlzZXRfeGVuX2d1ZXN0X2hhbmRsZShyZXNlcnZhdGlvbi5leHRlbnRfc3RhcnQsIGZyYW1l cyk7CisJcmVzZXJ2YXRpb24ubnJfZXh0ZW50cyA9IGNvdW50OworCXJldHVybiBIWVBFUlZJU09S X21lbW9yeV9vcChYRU5NRU1fZGVjcmVhc2VfcmVzZXJ2YXRpb24sICZyZXNlcnZhdGlvbik7Cit9 CitFWFBPUlRfU1lNQk9MX0dQTCh4ZW5tZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UpOwpkaWZmIC0t Z2l0IGEvaW5jbHVkZS94ZW4vbWVtLXJlc2VydmF0aW9uLmggYi9pbmNsdWRlL3hlbi9tZW0tcmVz ZXJ2YXRpb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmUwOTM5 Mzg3Mjc4ZAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUveGVuL21lbS1yZXNlcnZhdGlvbi5o CkBAIC0wLDAgKzEsNjQgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICov CisKKy8qCisgKiBYZW4gbWVtb3J5IHJlc2VydmF0aW9uIHV0aWxpdGllcy4KKyAqCisgKiBDb3B5 cmlnaHQgKGMpIDIwMDMsIEIgRHJhZ292aWMKKyAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA0LCBN IFdpbGxpYW1zb24sIEsgRnJhc2VyCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUgRGFuIE0uIFNtaXRo LCBJQk0gQ29ycG9yYXRpb24KKyAqIENvcHlyaWdodCAoYykgMjAxMCBEYW5pZWwgS2lwZXIKKyAq IENvcHlyaWdodCAoYykgMjAxOCBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbywgRVBBTSBTeXN0ZW1z IEluYy4KKyAqLworCisjaWZuZGVmIF9YRU5NRU1fUkVTRVJWQVRJT05fSAorI2RlZmluZSBfWEVO TUVNX1JFU0VSVkFUSU9OX0gKKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KKworI2luY2x1ZGUgPGFzbS94ZW4vaHlwZXJjYWxsLmg+CisjaW5jbHVk ZSA8YXNtL3RsYi5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9tZW1vcnkuaD4KKyNpbmNs dWRlIDx4ZW4vcGFnZS5oPgorCitzdGF0aWMgaW5saW5lIHZvaWQgeGVubWVtX3Jlc2VydmF0aW9u X3NjcnViX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisjaWZkZWYgQ09ORklHX1hFTl9TQ1JV Ql9QQUdFUworCWNsZWFyX2hpZ2hwYWdlKHBhZ2UpOworI2VuZGlmCit9CisKKyNpZmRlZiBDT05G SUdfWEVOX0hBVkVfUFZNTVUKK3ZvaWQgX194ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191 cGRhdGUodW5zaWduZWQgbG9uZyBjb3VudCwKKwkJCQkJICAgIHN0cnVjdCBwYWdlICoqcGFnZXMs CisJCQkJCSAgICB4ZW5fcGZuX3QgKmZyYW1lcyk7CisKK3ZvaWQgX194ZW5tZW1fcmVzZXJ2YXRp b25fdmFfbWFwcGluZ19yZXNldCh1bnNpZ25lZCBsb25nIGNvdW50LAorCQkJCQkgICBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzKTsKKyNlbmRpZgorCitzdGF0aWMgaW5saW5lIHZvaWQgeGVubWVtX3Jlc2Vy dmF0aW9uX3ZhX21hcHBpbmdfdXBkYXRlKHVuc2lnbmVkIGxvbmcgY291bnQsCisJCQkJCQkJc3Ry dWN0IHBhZ2UgKipwYWdlcywKKwkJCQkJCQl4ZW5fcGZuX3QgKmZyYW1lcykKK3sKKyNpZmRlZiBD T05GSUdfWEVOX0hBVkVfUFZNTVUKKwlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFu c2xhdGVkX3BoeXNtYXApKQorCQlfX3hlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3VwZGF0 ZShjb3VudCwgcGFnZXMsIGZyYW1lcyk7CisjZW5kaWYKK30KKworc3RhdGljIGlubGluZSB2b2lk IHhlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3Jlc2V0KHVuc2lnbmVkIGxvbmcgY291bnQs CisJCQkJCQkgICAgICAgc3RydWN0IHBhZ2UgKipwYWdlcykKK3sKKyNpZmRlZiBDT05GSUdfWEVO X0hBVkVfUFZNTVUKKwlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3Bo eXNtYXApKQorCQlfX3hlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3Jlc2V0KGNvdW50LCBw YWdlcyk7CisjZW5kaWYKK30KKworaW50IHhlbm1lbV9yZXNlcnZhdGlvbl9pbmNyZWFzZShpbnQg Y291bnQsIHhlbl9wZm5fdCAqZnJhbWVzKTsKKworaW50IHhlbm1lbV9yZXNlcnZhdGlvbl9kZWNy ZWFzZShpbnQgY291bnQsIHhlbl9wZm5fdCAqZnJhbWVzKTsKKworI2VuZGlmCi0tIAoyLjE3LjEK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZl bCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f68.google.com ([209.85.215.68]:33470 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933733AbeFLNmP (ORCPT ); Tue, 12 Jun 2018 09:42:15 -0400 From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: daniel.vetter@intel.com, andr2000@gmail.com, dongwon.kim@intel.com, matthew.d.roper@intel.com, Oleksandr Andrushchenko Subject: [PATCH v3 3/9] xen/balloon: Share common memory reservation routines Date: Tue, 12 Jun 2018 16:41:54 +0300 Message-Id: <20180612134200.17456-4-andr2000@gmail.com> In-Reply-To: <20180612134200.17456-1-andr2000@gmail.com> References: <20180612134200.17456-1-andr2000@gmail.com> Sender: linux-media-owner@vger.kernel.org List-ID: From: Oleksandr Andrushchenko Memory {increase|decrease}_reservation and VA mappings update/reset code used in balloon driver can be made common, so other drivers can also re-use the same functionality without open-coding. Create a dedicated file for the shared code and export corresponding symbols for other kernel modules. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/Makefile | 1 + drivers/xen/balloon.c | 71 ++------------------- drivers/xen/mem-reservation.c | 112 ++++++++++++++++++++++++++++++++++ include/xen/mem-reservation.h | 64 +++++++++++++++++++ 4 files changed, 183 insertions(+), 65 deletions(-) create mode 100644 drivers/xen/mem-reservation.c create mode 100644 include/xen/mem-reservation.h diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index 451e833f5931..3c87b0c3aca6 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -2,6 +2,7 @@ obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o obj-$(CONFIG_X86) += fallback.o obj-y += grant-table.o features.o balloon.o manage.o preempt.o time.o +obj-y += mem-reservation.o obj-y += events/ obj-y += xenbus/ diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index 065f0b607373..bdbce4257b65 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -71,6 +71,7 @@ #include #include #include +#include static int xen_hotplug_unpopulated; @@ -157,13 +158,6 @@ static DECLARE_DELAYED_WORK(balloon_worker, balloon_process); #define GFP_BALLOON \ (GFP_HIGHUSER | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC) -static void scrub_page(struct page *page) -{ -#ifdef CONFIG_XEN_SCRUB_PAGES - clear_highpage(page); -#endif -} - /* balloon_append: add the given page to the balloon. */ static void __balloon_append(struct page *page) { @@ -463,11 +457,6 @@ static enum bp_state increase_reservation(unsigned long nr_pages) int rc; unsigned long i; struct page *page; - struct xen_memory_reservation reservation = { - .address_bits = 0, - .extent_order = EXTENT_ORDER, - .domid = DOMID_SELF - }; if (nr_pages > ARRAY_SIZE(frame_list)) nr_pages = ARRAY_SIZE(frame_list); @@ -486,9 +475,7 @@ static enum bp_state increase_reservation(unsigned long nr_pages) page = balloon_next_page(page); } - set_xen_guest_handle(reservation.extent_start, frame_list); - reservation.nr_extents = nr_pages; - rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); + rc = xenmem_reservation_increase(nr_pages, frame_list); if (rc <= 0) return BP_EAGAIN; @@ -496,29 +483,7 @@ static enum bp_state increase_reservation(unsigned long nr_pages) page = balloon_retrieve(false); BUG_ON(page == NULL); -#ifdef CONFIG_XEN_HAVE_PVMMU - /* - * We don't support PV MMU when Linux and Xen is using - * different page granularity. - */ - BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); - - if (!xen_feature(XENFEAT_auto_translated_physmap)) { - unsigned long pfn = page_to_pfn(page); - - set_phys_to_machine(pfn, frame_list[i]); - - /* Link back into the page tables if not highmem. */ - if (!PageHighMem(page)) { - int ret; - ret = HYPERVISOR_update_va_mapping( - (unsigned long)__va(pfn << PAGE_SHIFT), - mfn_pte(frame_list[i], PAGE_KERNEL), - 0); - BUG_ON(ret); - } - } -#endif + xenmem_reservation_va_mapping_update(1, &page, &frame_list[i]); /* Relinquish the page back to the allocator. */ free_reserved_page(page); @@ -535,11 +500,6 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) unsigned long i; struct page *page, *tmp; int ret; - struct xen_memory_reservation reservation = { - .address_bits = 0, - .extent_order = EXTENT_ORDER, - .domid = DOMID_SELF - }; LIST_HEAD(pages); if (nr_pages > ARRAY_SIZE(frame_list)) @@ -553,7 +513,7 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) break; } adjust_managed_page_count(page, -1); - scrub_page(page); + xenmem_reservation_scrub_page(page); list_add(&page->lru, &pages); } @@ -575,25 +535,8 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) /* XENMEM_decrease_reservation requires a GFN */ frame_list[i++] = xen_page_to_gfn(page); -#ifdef CONFIG_XEN_HAVE_PVMMU - /* - * We don't support PV MMU when Linux and Xen is using - * different page granularity. - */ - BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); - - if (!xen_feature(XENFEAT_auto_translated_physmap)) { - unsigned long pfn = page_to_pfn(page); + xenmem_reservation_va_mapping_reset(1, &page); - if (!PageHighMem(page)) { - ret = HYPERVISOR_update_va_mapping( - (unsigned long)__va(pfn << PAGE_SHIFT), - __pte_ma(0), 0); - BUG_ON(ret); - } - __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); - } -#endif list_del(&page->lru); balloon_append(page); @@ -601,9 +544,7 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) flush_tlb_all(); - set_xen_guest_handle(reservation.extent_start, frame_list); - reservation.nr_extents = nr_pages; - ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation); + ret = xenmem_reservation_decrease(nr_pages, frame_list); BUG_ON(ret != nr_pages); balloon_stats.current_pages -= nr_pages; diff --git a/drivers/xen/mem-reservation.c b/drivers/xen/mem-reservation.c new file mode 100644 index 000000000000..aa551d58001c --- /dev/null +++ b/drivers/xen/mem-reservation.c @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: GPL-2.0 + +/****************************************************************************** + * Xen memory reservation utilities. + * + * Copyright (c) 2003, B Dragovic + * Copyright (c) 2003-2004, M Williamson, K Fraser + * Copyright (c) 2005 Dan M. Smith, IBM Corporation + * Copyright (c) 2010 Daniel Kiper + * Copyright (c) 2018 Oleksandr Andrushchenko, EPAM Systems Inc. + */ + +#include + +/* + * Use one extent per PAGE_SIZE to avoid to break down the page into + * multiple frame. + */ +#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1) + +#ifdef CONFIG_XEN_HAVE_PVMMU +void __xenmem_reservation_va_mapping_update(unsigned long count, + struct page **pages, + xen_pfn_t *frames) +{ + int i; + + for (i = 0; i < count; i++) { + struct page *page = pages[i]; + unsigned long pfn = page_to_pfn(page); + + BUG_ON(page == NULL); + + /* + * We don't support PV MMU when Linux and Xen is using + * different page granularity. + */ + BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); + + + set_phys_to_machine(pfn, frames[i]); + + /* Link back into the page tables if not highmem. */ + if (!PageHighMem(page)) { + int ret; + + ret = HYPERVISOR_update_va_mapping( + (unsigned long)__va(pfn << PAGE_SHIFT), + mfn_pte(frames[i], PAGE_KERNEL), + 0); + BUG_ON(ret); + } + } +} +EXPORT_SYMBOL_GPL(__xenmem_reservation_va_mapping_update); + +void __xenmem_reservation_va_mapping_reset(unsigned long count, + struct page **pages) +{ + int i; + + for (i = 0; i < count; i++) { + struct page *page = pages[i]; + unsigned long pfn = page_to_pfn(page); + + /* + * We don't support PV MMU when Linux and Xen is using + * different page granularity. + */ + BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); + + if (!PageHighMem(page)) { + int ret; + + ret = HYPERVISOR_update_va_mapping( + (unsigned long)__va(pfn << PAGE_SHIFT), + __pte_ma(0), 0); + BUG_ON(ret); + } + __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); + } +} +EXPORT_SYMBOL_GPL(__xenmem_reservation_va_mapping_reset); +#endif /* CONFIG_XEN_HAVE_PVMMU */ + +int xenmem_reservation_increase(int count, xen_pfn_t *frames) +{ + struct xen_memory_reservation reservation = { + .address_bits = 0, + .extent_order = EXTENT_ORDER, + .domid = DOMID_SELF + }; + + set_xen_guest_handle(reservation.extent_start, frames); + reservation.nr_extents = count; + return HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); +} +EXPORT_SYMBOL_GPL(xenmem_reservation_increase); + +int xenmem_reservation_decrease(int count, xen_pfn_t *frames) +{ + struct xen_memory_reservation reservation = { + .address_bits = 0, + .extent_order = EXTENT_ORDER, + .domid = DOMID_SELF + }; + + set_xen_guest_handle(reservation.extent_start, frames); + reservation.nr_extents = count; + return HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation); +} +EXPORT_SYMBOL_GPL(xenmem_reservation_decrease); diff --git a/include/xen/mem-reservation.h b/include/xen/mem-reservation.h new file mode 100644 index 000000000000..e0939387278d --- /dev/null +++ b/include/xen/mem-reservation.h @@ -0,0 +1,64 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/* + * Xen memory reservation utilities. + * + * Copyright (c) 2003, B Dragovic + * Copyright (c) 2003-2004, M Williamson, K Fraser + * Copyright (c) 2005 Dan M. Smith, IBM Corporation + * Copyright (c) 2010 Daniel Kiper + * Copyright (c) 2018 Oleksandr Andrushchenko, EPAM Systems Inc. + */ + +#ifndef _XENMEM_RESERVATION_H +#define _XENMEM_RESERVATION_H + +#include +#include + +#include +#include + +#include +#include + +static inline void xenmem_reservation_scrub_page(struct page *page) +{ +#ifdef CONFIG_XEN_SCRUB_PAGES + clear_highpage(page); +#endif +} + +#ifdef CONFIG_XEN_HAVE_PVMMU +void __xenmem_reservation_va_mapping_update(unsigned long count, + struct page **pages, + xen_pfn_t *frames); + +void __xenmem_reservation_va_mapping_reset(unsigned long count, + struct page **pages); +#endif + +static inline void xenmem_reservation_va_mapping_update(unsigned long count, + struct page **pages, + xen_pfn_t *frames) +{ +#ifdef CONFIG_XEN_HAVE_PVMMU + if (!xen_feature(XENFEAT_auto_translated_physmap)) + __xenmem_reservation_va_mapping_update(count, pages, frames); +#endif +} + +static inline void xenmem_reservation_va_mapping_reset(unsigned long count, + struct page **pages) +{ +#ifdef CONFIG_XEN_HAVE_PVMMU + if (!xen_feature(XENFEAT_auto_translated_physmap)) + __xenmem_reservation_va_mapping_reset(count, pages); +#endif +} + +int xenmem_reservation_increase(int count, xen_pfn_t *frames); + +int xenmem_reservation_decrease(int count, xen_pfn_t *frames); + +#endif -- 2.17.1