From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 3/9] xen/balloon: Share common memory reservation routines Date: Fri, 1 Jun 2018 14:41:26 +0300 Message-ID: <20180601114132.22596-4-andr2000@gmail.com> References: <20180601114132.22596-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-x242.google.com (mail-lf0-x242.google.com [IPv6:2a00:1450:4010:c07::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id E14026E662 for ; Fri, 1 Jun 2018 11:41:45 +0000 (UTC) Received: by mail-lf0-x242.google.com with SMTP id t134-v6so14377902lff.6 for ; Fri, 01 Jun 2018 04:41:45 -0700 (PDT) In-Reply-To: <20180601114132.22596-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 IDcxICsrLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9tZW0tcmVzZXJ2YXRpb24uYyB8 IDEyMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3hlbi9tZW0t cmVzZXJ2YXRpb24uaCB8ICA2NSArKysrKysrKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwg MTkyIGluc2VydGlvbnMoKyksIDY1IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMveGVuL21lbS1yZXNlcnZhdGlvbi5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS94 ZW4vbWVtLXJlc2VydmF0aW9uLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9NYWtlZmlsZSBi L2RyaXZlcnMveGVuL01ha2VmaWxlCmluZGV4IDQ1MWU4MzNmNTkzMS4uM2M4N2IwYzNhY2E2IDEw MDY0NAotLS0gYS9kcml2ZXJzL3hlbi9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3hlbi9NYWtlZmls ZQpAQCAtMiw2ICsyLDcgQEAKIG9iai0kKENPTkZJR19IT1RQTFVHX0NQVSkJCSs9IGNwdV9ob3Rw bHVnLm8KIG9iai0kKENPTkZJR19YODYpCQkJKz0gZmFsbGJhY2subwogb2JqLXkJKz0gZ3JhbnQt dGFibGUubyBmZWF0dXJlcy5vIGJhbGxvb24ubyBtYW5hZ2UubyBwcmVlbXB0Lm8gdGltZS5vCitv YmoteQkrPSBtZW0tcmVzZXJ2YXRpb24ubwogb2JqLXkJKz0gZXZlbnRzLwogb2JqLXkJKz0geGVu YnVzLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9iYWxsb29uLmMgYi9kcml2ZXJzL3hlbi9i YWxsb29uLmMKaW5kZXggMDY1ZjBiNjA3MzczLi5iZGJjZTQyNTdiNjUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL2JhbGxvb24uYworKysgYi9kcml2ZXJzL3hlbi9iYWxsb29uLmMKQEAgLTcxLDYg KzcxLDcgQEAKICNpbmNsdWRlIDx4ZW4vYmFsbG9vbi5oPgogI2luY2x1ZGUgPHhlbi9mZWF0dXJl cy5oPgogI2luY2x1ZGUgPHhlbi9wYWdlLmg+CisjaW5jbHVkZSA8eGVuL21lbS1yZXNlcnZhdGlv bi5oPgogCiBzdGF0aWMgaW50IHhlbl9ob3RwbHVnX3VucG9wdWxhdGVkOwogCkBAIC0xNTcsMTMg KzE1OCw2IEBAIHN0YXRpYyBERUNMQVJFX0RFTEFZRURfV09SSyhiYWxsb29uX3dvcmtlciwgYmFs bG9vbl9wcm9jZXNzKTsKICNkZWZpbmUgR0ZQX0JBTExPT04gXAogCShHRlBfSElHSFVTRVIgfCBf X0dGUF9OT1dBUk4gfCBfX0dGUF9OT1JFVFJZIHwgX19HRlBfTk9NRU1BTExPQykKIAotc3RhdGlj IHZvaWQgc2NydWJfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKLXsKLSNpZmRlZiBDT05GSUdfWEVO X1NDUlVCX1BBR0VTCi0JY2xlYXJfaGlnaHBhZ2UocGFnZSk7Ci0jZW5kaWYKLX0KLQogLyogYmFs bG9vbl9hcHBlbmQ6IGFkZCB0aGUgZ2l2ZW4gcGFnZSB0byB0aGUgYmFsbG9vbi4gKi8KIHN0YXRp YyB2b2lkIF9fYmFsbG9vbl9hcHBlbmQoc3RydWN0IHBhZ2UgKnBhZ2UpCiB7CkBAIC00NjMsMTEg KzQ1Nyw2IEBAIHN0YXRpYyBlbnVtIGJwX3N0YXRlIGluY3JlYXNlX3Jlc2VydmF0aW9uKHVuc2ln bmVkIGxvbmcgbnJfcGFnZXMpCiAJaW50IHJjOwogCXVuc2lnbmVkIGxvbmcgaTsKIAlzdHJ1Y3Qg cGFnZSAgICpwYWdlOwotCXN0cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIHJlc2VydmF0aW9u ID0gewotCQkuYWRkcmVzc19iaXRzID0gMCwKLQkJLmV4dGVudF9vcmRlciA9IEVYVEVOVF9PUkRF UiwKLQkJLmRvbWlkICAgICAgICA9IERPTUlEX1NFTEYKLQl9OwogCiAJaWYgKG5yX3BhZ2VzID4g QVJSQVlfU0laRShmcmFtZV9saXN0KSkKIAkJbnJfcGFnZXMgPSBBUlJBWV9TSVpFKGZyYW1lX2xp c3QpOwpAQCAtNDg2LDkgKzQ3NSw3IEBAIHN0YXRpYyBlbnVtIGJwX3N0YXRlIGluY3JlYXNlX3Jl c2VydmF0aW9uKHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMpCiAJCXBhZ2UgPSBiYWxsb29uX25leHRf cGFnZShwYWdlKTsKIAl9CiAKLQlzZXRfeGVuX2d1ZXN0X2hhbmRsZShyZXNlcnZhdGlvbi5leHRl bnRfc3RhcnQsIGZyYW1lX2xpc3QpOwotCXJlc2VydmF0aW9uLm5yX2V4dGVudHMgPSBucl9wYWdl czsKLQlyYyA9IEhZUEVSVklTT1JfbWVtb3J5X29wKFhFTk1FTV9wb3B1bGF0ZV9waHlzbWFwLCAm cmVzZXJ2YXRpb24pOworCXJjID0geGVubWVtX3Jlc2VydmF0aW9uX2luY3JlYXNlKG5yX3BhZ2Vz LCBmcmFtZV9saXN0KTsKIAlpZiAocmMgPD0gMCkKIAkJcmV0dXJuIEJQX0VBR0FJTjsKIApAQCAt NDk2LDI5ICs0ODMsNyBAQCBzdGF0aWMgZW51bSBicF9zdGF0ZSBpbmNyZWFzZV9yZXNlcnZhdGlv bih1bnNpZ25lZCBsb25nIG5yX3BhZ2VzKQogCQlwYWdlID0gYmFsbG9vbl9yZXRyaWV2ZShmYWxz ZSk7CiAJCUJVR19PTihwYWdlID09IE5VTEwpOwogCi0jaWZkZWYgQ09ORklHX1hFTl9IQVZFX1BW TU1VCi0JCS8qCi0JCSAqIFdlIGRvbid0IHN1cHBvcnQgUFYgTU1VIHdoZW4gTGludXggYW5kIFhl biBpcyB1c2luZwotCQkgKiBkaWZmZXJlbnQgcGFnZSBncmFudWxhcml0eS4KLQkJICovCi0JCUJV SUxEX0JVR19PTihYRU5fUEFHRV9TSVpFICE9IFBBR0VfU0laRSk7Ci0KLQkJaWYgKCF4ZW5fZmVh dHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkgewotCQkJdW5zaWduZWQgbG9u ZyBwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKLQotCQkJc2V0X3BoeXNfdG9fbWFjaGluZShwZm4s IGZyYW1lX2xpc3RbaV0pOwotCi0JCQkvKiBMaW5rIGJhY2sgaW50byB0aGUgcGFnZSB0YWJsZXMg aWYgbm90IGhpZ2htZW0uICovCi0JCQlpZiAoIVBhZ2VIaWdoTWVtKHBhZ2UpKSB7Ci0JCQkJaW50 IHJldDsKLQkJCQlyZXQgPSBIWVBFUlZJU09SX3VwZGF0ZV92YV9tYXBwaW5nKAotCQkJCQkJKHVu c2lnbmVkIGxvbmcpX192YShwZm4gPDwgUEFHRV9TSElGVCksCi0JCQkJCQltZm5fcHRlKGZyYW1l X2xpc3RbaV0sIFBBR0VfS0VSTkVMKSwKLQkJCQkJCTApOwotCQkJCUJVR19PTihyZXQpOwotCQkJ fQotCQl9Ci0jZW5kaWYKKwkJeGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfdXBkYXRlKDEs ICZwYWdlLCAmZnJhbWVfbGlzdFtpXSk7CiAKIAkJLyogUmVsaW5xdWlzaCB0aGUgcGFnZSBiYWNr IHRvIHRoZSBhbGxvY2F0b3IuICovCiAJCWZyZWVfcmVzZXJ2ZWRfcGFnZShwYWdlKTsKQEAgLTUz NSwxMSArNTAwLDYgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgZGVjcmVhc2VfcmVzZXJ2YXRpb24o dW5zaWduZWQgbG9uZyBucl9wYWdlcywgZ2ZwX3QgZ2ZwKQogCXVuc2lnbmVkIGxvbmcgaTsKIAlz dHJ1Y3QgcGFnZSAqcGFnZSwgKnRtcDsKIAlpbnQgcmV0OwotCXN0cnVjdCB4ZW5fbWVtb3J5X3Jl c2VydmF0aW9uIHJlc2VydmF0aW9uID0gewotCQkuYWRkcmVzc19iaXRzID0gMCwKLQkJLmV4dGVu dF9vcmRlciA9IEVYVEVOVF9PUkRFUiwKLQkJLmRvbWlkICAgICAgICA9IERPTUlEX1NFTEYKLQl9 OwogCUxJU1RfSEVBRChwYWdlcyk7CiAKIAlpZiAobnJfcGFnZXMgPiBBUlJBWV9TSVpFKGZyYW1l X2xpc3QpKQpAQCAtNTUzLDcgKzUxMyw3IEBAIHN0YXRpYyBlbnVtIGJwX3N0YXRlIGRlY3JlYXNl X3Jlc2VydmF0aW9uKHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMsIGdmcF90IGdmcCkKIAkJCWJyZWFr OwogCQl9CiAJCWFkanVzdF9tYW5hZ2VkX3BhZ2VfY291bnQocGFnZSwgLTEpOwotCQlzY3J1Yl9w YWdlKHBhZ2UpOworCQl4ZW5tZW1fcmVzZXJ2YXRpb25fc2NydWJfcGFnZShwYWdlKTsKIAkJbGlz dF9hZGQoJnBhZ2UtPmxydSwgJnBhZ2VzKTsKIAl9CiAKQEAgLTU3NSwyNSArNTM1LDggQEAgc3Rh dGljIGVudW0gYnBfc3RhdGUgZGVjcmVhc2VfcmVzZXJ2YXRpb24odW5zaWduZWQgbG9uZyBucl9w YWdlcywgZ2ZwX3QgZ2ZwKQogCQkvKiBYRU5NRU1fZGVjcmVhc2VfcmVzZXJ2YXRpb24gcmVxdWly ZXMgYSBHRk4gKi8KIAkJZnJhbWVfbGlzdFtpKytdID0geGVuX3BhZ2VfdG9fZ2ZuKHBhZ2UpOwog Ci0jaWZkZWYgQ09ORklHX1hFTl9IQVZFX1BWTU1VCi0JCS8qCi0JCSAqIFdlIGRvbid0IHN1cHBv cnQgUFYgTU1VIHdoZW4gTGludXggYW5kIFhlbiBpcyB1c2luZwotCQkgKiBkaWZmZXJlbnQgcGFn ZSBncmFudWxhcml0eS4KLQkJICovCi0JCUJVSUxEX0JVR19PTihYRU5fUEFHRV9TSVpFICE9IFBB R0VfU0laRSk7Ci0KLQkJaWYgKCF4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9w aHlzbWFwKSkgewotCQkJdW5zaWduZWQgbG9uZyBwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKKwkJ eGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfcmVzZXQoMSwgJnBhZ2UpOwogCi0JCQlpZiAo IVBhZ2VIaWdoTWVtKHBhZ2UpKSB7Ci0JCQkJcmV0ID0gSFlQRVJWSVNPUl91cGRhdGVfdmFfbWFw cGluZygKLQkJCQkJCSh1bnNpZ25lZCBsb25nKV9fdmEocGZuIDw8IFBBR0VfU0hJRlQpLAotCQkJ CQkJX19wdGVfbWEoMCksIDApOwotCQkJCUJVR19PTihyZXQpOwotCQkJfQotCQkJX19zZXRfcGh5 c190b19tYWNoaW5lKHBmbiwgSU5WQUxJRF9QMk1fRU5UUlkpOwotCQl9Ci0jZW5kaWYKIAkJbGlz dF9kZWwoJnBhZ2UtPmxydSk7CiAKIAkJYmFsbG9vbl9hcHBlbmQocGFnZSk7CkBAIC02MDEsOSAr NTQ0LDcgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgZGVjcmVhc2VfcmVzZXJ2YXRpb24odW5zaWdu ZWQgbG9uZyBucl9wYWdlcywgZ2ZwX3QgZ2ZwKQogCiAJZmx1c2hfdGxiX2FsbCgpOwogCi0Jc2V0 X3hlbl9ndWVzdF9oYW5kbGUocmVzZXJ2YXRpb24uZXh0ZW50X3N0YXJ0LCBmcmFtZV9saXN0KTsK LQlyZXNlcnZhdGlvbi5ucl9leHRlbnRzICAgPSBucl9wYWdlczsKLQlyZXQgPSBIWVBFUlZJU09S X21lbW9yeV9vcChYRU5NRU1fZGVjcmVhc2VfcmVzZXJ2YXRpb24sICZyZXNlcnZhdGlvbik7CisJ cmV0ID0geGVubWVtX3Jlc2VydmF0aW9uX2RlY3JlYXNlKG5yX3BhZ2VzLCBmcmFtZV9saXN0KTsK IAlCVUdfT04ocmV0ICE9IG5yX3BhZ2VzKTsKIAogCWJhbGxvb25fc3RhdHMuY3VycmVudF9wYWdl cyAtPSBucl9wYWdlczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL21lbS1yZXNlcnZhdGlvbi5j IGIvZHJpdmVycy94ZW4vbWVtLXJlc2VydmF0aW9uLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi41Mzg4ZGY4NTJhMjEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L3hlbi9tZW0tcmVzZXJ2YXRpb24uYwpAQCAtMCwwICsxLDEyMCBAQAorLy8gU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogWGVuIG1l bW9yeSByZXNlcnZhdGlvbiB1dGlsaXRpZXMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAzLCBC IERyYWdvdmljCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwNCwgTSBXaWxsaWFtc29uLCBLIEZy YXNlcgorICogQ29weXJpZ2h0IChjKSAyMDA1IERhbiBNLiBTbWl0aCwgSUJNIENvcnBvcmF0aW9u CisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgRGFuaWVsIEtpcGVyCisgKiBDb3B5cmlnaHQgKGMpIDIw MTggT2xla3NhbmRyIEFuZHJ1c2hjaGVua28sIEVQQU0gU3lzdGVtcyBJbmMuCisgKi8KKworI2lu Y2x1ZGUgPHhlbi9tZW0tcmVzZXJ2YXRpb24uaD4KKworLyoKKyAqIFVzZSBvbmUgZXh0ZW50IHBl ciBQQUdFX1NJWkUgdG8gYXZvaWQgdG8gYnJlYWsgZG93biB0aGUgcGFnZSBpbnRvCisgKiBtdWx0 aXBsZSBmcmFtZS4KKyAqLworI2RlZmluZSBFWFRFTlRfT1JERVIgKGZscyhYRU5fUEZOX1BFUl9Q QUdFKSAtIDEpCisKKyNpZmRlZiBDT05GSUdfWEVOX1NDUlVCX1BBR0VTCit2b2lkIHhlbm1lbV9y ZXNlcnZhdGlvbl9zY3J1Yl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQoreworCWNsZWFyX2hpZ2hw YWdlKHBhZ2UpOworfQorRVhQT1JUX1NZTUJPTF9HUEwoeGVubWVtX3Jlc2VydmF0aW9uX3NjcnVi X3BhZ2UpOworI2VuZGlmCisKKyNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZNTVUKK3ZvaWQgX194 ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUodW5zaWduZWQgbG9uZyBjb3VudCwK KwkJCQkJICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsCisJCQkJCSAgICB4ZW5fcGZuX3QgKmZyYW1l cykKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CisJCXN0cnVj dCBwYWdlICpwYWdlID0gcGFnZXNbaV07CisJCXVuc2lnbmVkIGxvbmcgcGZuID0gcGFnZV90b19w Zm4ocGFnZSk7CisKKwkJQlVHX09OKHBhZ2UgPT0gTlVMTCk7CisKKwkJLyoKKwkJICogV2UgZG9u J3Qgc3VwcG9ydCBQViBNTVUgd2hlbiBMaW51eCBhbmQgWGVuIGlzIHVzaW5nCisJCSAqIGRpZmZl cmVudCBwYWdlIGdyYW51bGFyaXR5LgorCQkgKi8KKwkJQlVJTERfQlVHX09OKFhFTl9QQUdFX1NJ WkUgIT0gUEFHRV9TSVpFKTsKKworCisJCXNldF9waHlzX3RvX21hY2hpbmUocGZuLCBmcmFtZXNb aV0pOworCisJCS8qIExpbmsgYmFjayBpbnRvIHRoZSBwYWdlIHRhYmxlcyBpZiBub3QgaGlnaG1l bS4gKi8KKwkJaWYgKCFQYWdlSGlnaE1lbShwYWdlKSkgeworCQkJaW50IHJldDsKKworCQkJcmV0 ID0gSFlQRVJWSVNPUl91cGRhdGVfdmFfbWFwcGluZygKKwkJCQkJKHVuc2lnbmVkIGxvbmcpX192 YShwZm4gPDwgUEFHRV9TSElGVCksCisJCQkJCW1mbl9wdGUoZnJhbWVzW2ldLCBQQUdFX0tFUk5F TCksCisJCQkJCTApOworCQkJQlVHX09OKHJldCk7CisJCX0KKwl9Cit9CitFWFBPUlRfU1lNQk9M X0dQTChfX3hlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3VwZGF0ZSk7CisKK3ZvaWQgX194 ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ19yZXNldCh1bnNpZ25lZCBsb25nIGNvdW50LAor CQkJCQkgICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQoreworCWludCBpOworCisJZm9yIChpID0gMDsg aSA8IGNvdW50OyBpKyspIHsKKwkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBwYWdlc1tpXTsKKwkJdW5z aWduZWQgbG9uZyBwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKKworCQkvKgorCQkgKiBXZSBkb24n dCBzdXBwb3J0IFBWIE1NVSB3aGVuIExpbnV4IGFuZCBYZW4gaXMgdXNpbmcKKwkJICogZGlmZmVy ZW50IHBhZ2UgZ3JhbnVsYXJpdHkuCisJCSAqLworCQlCVUlMRF9CVUdfT04oWEVOX1BBR0VfU0la RSAhPSBQQUdFX1NJWkUpOworCisJCWlmICghUGFnZUhpZ2hNZW0ocGFnZSkpIHsKKwkJCWludCBy ZXQ7CisKKwkJCXJldCA9IEhZUEVSVklTT1JfdXBkYXRlX3ZhX21hcHBpbmcoCisJCQkJCSh1bnNp Z25lZCBsb25nKV9fdmEocGZuIDw8IFBBR0VfU0hJRlQpLAorCQkJCQlfX3B0ZV9tYSgwKSwgMCk7 CisJCQlCVUdfT04ocmV0KTsKKwkJfQorCQlfX3NldF9waHlzX3RvX21hY2hpbmUocGZuLCBJTlZB TElEX1AyTV9FTlRSWSk7CisJfQorfQorRVhQT1JUX1NZTUJPTF9HUEwoX194ZW5tZW1fcmVzZXJ2 YXRpb25fdmFfbWFwcGluZ19yZXNldCk7CisjZW5kaWYgLyogQ09ORklHX1hFTl9IQVZFX1BWTU1V ICovCisKK2ludCB4ZW5tZW1fcmVzZXJ2YXRpb25faW5jcmVhc2UoaW50IGNvdW50LCB4ZW5fcGZu X3QgKmZyYW1lcykKK3sKKwlzdHJ1Y3QgeGVuX21lbW9yeV9yZXNlcnZhdGlvbiByZXNlcnZhdGlv biA9IHsKKwkJLmFkZHJlc3NfYml0cyA9IDAsCisJCS5leHRlbnRfb3JkZXIgPSBFWFRFTlRfT1JE RVIsCisJCS5kb21pZCAgICAgICAgPSBET01JRF9TRUxGCisJfTsKKworCXNldF94ZW5fZ3Vlc3Rf aGFuZGxlKHJlc2VydmF0aW9uLmV4dGVudF9zdGFydCwgZnJhbWVzKTsKKwlyZXNlcnZhdGlvbi5u cl9leHRlbnRzID0gY291bnQ7CisJcmV0dXJuIEhZUEVSVklTT1JfbWVtb3J5X29wKFhFTk1FTV9w b3B1bGF0ZV9waHlzbWFwLCAmcmVzZXJ2YXRpb24pOworfQorRVhQT1JUX1NZTUJPTF9HUEwoeGVu bWVtX3Jlc2VydmF0aW9uX2luY3JlYXNlKTsKKworaW50IHhlbm1lbV9yZXNlcnZhdGlvbl9kZWNy ZWFzZShpbnQgY291bnQsIHhlbl9wZm5fdCAqZnJhbWVzKQoreworCXN0cnVjdCB4ZW5fbWVtb3J5 X3Jlc2VydmF0aW9uIHJlc2VydmF0aW9uID0geworCQkuYWRkcmVzc19iaXRzID0gMCwKKwkJLmV4 dGVudF9vcmRlciA9IEVYVEVOVF9PUkRFUiwKKwkJLmRvbWlkICAgICAgICA9IERPTUlEX1NFTEYK Kwl9OworCisJc2V0X3hlbl9ndWVzdF9oYW5kbGUocmVzZXJ2YXRpb24uZXh0ZW50X3N0YXJ0LCBm cmFtZXMpOworCXJlc2VydmF0aW9uLm5yX2V4dGVudHMgPSBjb3VudDsKKwlyZXR1cm4gSFlQRVJW SVNPUl9tZW1vcnlfb3AoWEVOTUVNX2RlY3JlYXNlX3Jlc2VydmF0aW9uLCAmcmVzZXJ2YXRpb24p OworfQorRVhQT1JUX1NZTUJPTF9HUEwoeGVubWVtX3Jlc2VydmF0aW9uX2RlY3JlYXNlKTsKZGlm ZiAtLWdpdCBhL2luY2x1ZGUveGVuL21lbS1yZXNlcnZhdGlvbi5oIGIvaW5jbHVkZS94ZW4vbWVt LXJlc2VydmF0aW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5h NzI3ZDY1YTFlNjEKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3hlbi9tZW0tcmVzZXJ2YXRp b24uaApAQCAtMCwwICsxLDY1IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIu MCAqLworCisvKgorICogWGVuIG1lbW9yeSByZXNlcnZhdGlvbiB1dGlsaXRpZXMuCisgKgorICog Q29weXJpZ2h0IChjKSAyMDAzLCBCIERyYWdvdmljCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAw NCwgTSBXaWxsaWFtc29uLCBLIEZyYXNlcgorICogQ29weXJpZ2h0IChjKSAyMDA1IERhbiBNLiBT bWl0aCwgSUJNIENvcnBvcmF0aW9uCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgRGFuaWVsIEtpcGVy CisgKiBDb3B5cmlnaHQgKGMpIDIwMTggT2xla3NhbmRyIEFuZHJ1c2hjaGVua28sIEVQQU0gU3lz dGVtcyBJbmMuCisgKi8KKworI2lmbmRlZiBfWEVOTUVNX1JFU0VSVkFUSU9OX0gKKyNkZWZpbmUg X1hFTk1FTV9SRVNFUlZBVElPTl9ICisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNs dWRlIDxsaW51eC9zbGFiLmg+CisKKyNpbmNsdWRlIDxhc20veGVuL2h5cGVyY2FsbC5oPgorI2lu Y2x1ZGUgPGFzbS90bGIuaD4KKworI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvbWVtb3J5Lmg+Cisj aW5jbHVkZSA8eGVuL3BhZ2UuaD4KKworI2lmZGVmIENPTkZJR19YRU5fU0NSVUJfUEFHRVMKK3Zv aWQgeGVubWVtX3Jlc2VydmF0aW9uX3NjcnViX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpOworI2Vs c2UKK3N0YXRpYyBpbmxpbmUgdm9pZCB4ZW5tZW1fcmVzZXJ2YXRpb25fc2NydWJfcGFnZShzdHJ1 Y3QgcGFnZSAqcGFnZSkKK3sKK30KKyNlbmRpZgorCisjaWZkZWYgQ09ORklHX1hFTl9IQVZFX1BW TU1VCit2b2lkIF9feGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfdXBkYXRlKHVuc2lnbmVk IGxvbmcgY291bnQsCisJCQkJCSAgICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAorCQkJCQkgICAgeGVu X3Bmbl90ICpmcmFtZXMpOworCit2b2lkIF9feGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdf cmVzZXQodW5zaWduZWQgbG9uZyBjb3VudCwKKwkJCQkJICAgc3RydWN0IHBhZ2UgKipwYWdlcyk7 CisjZW5kaWYKKworc3RhdGljIGlubGluZSB2b2lkIHhlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBw aW5nX3VwZGF0ZSh1bnNpZ25lZCBsb25nIGNvdW50LAorCQkJCQkJCXN0cnVjdCBwYWdlICoqcGFn ZXMsCisJCQkJCQkJeGVuX3Bmbl90ICpmcmFtZXMpCit7CisjaWZkZWYgQ09ORklHX1hFTl9IQVZF X1BWTU1VCisJaWYgKCF4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFw KSkKKwkJX194ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUoY291bnQsIHBhZ2Vz LCBmcmFtZXMpOworI2VuZGlmCit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB4ZW5tZW1fcmVzZXJ2 YXRpb25fdmFfbWFwcGluZ19yZXNldCh1bnNpZ25lZCBsb25nIGNvdW50LAorCQkJCQkJICAgICAg IHN0cnVjdCBwYWdlICoqcGFnZXMpCit7CisjaWZkZWYgQ09ORklHX1hFTl9IQVZFX1BWTU1VCisJ aWYgKCF4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkKKwkJX194 ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ19yZXNldChjb3VudCwgcGFnZXMpOworI2VuZGlm Cit9CisKK2ludCB4ZW5tZW1fcmVzZXJ2YXRpb25faW5jcmVhc2UoaW50IGNvdW50LCB4ZW5fcGZu X3QgKmZyYW1lcyk7CisKK2ludCB4ZW5tZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UoaW50IGNvdW50 LCB4ZW5fcGZuX3QgKmZyYW1lcyk7CisKKyNlbmRpZgotLSAKMi4xNy4wCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0 CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3Rv cC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f68.google.com ([209.85.215.68]:37345 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751879AbeFALlq (ORCPT ); Fri, 1 Jun 2018 07:41:46 -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 v2 3/9] xen/balloon: Share common memory reservation routines Date: Fri, 1 Jun 2018 14:41:26 +0300 Message-Id: <20180601114132.22596-4-andr2000@gmail.com> In-Reply-To: <20180601114132.22596-1-andr2000@gmail.com> References: <20180601114132.22596-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 | 120 ++++++++++++++++++++++++++++++++++ include/xen/mem-reservation.h | 65 ++++++++++++++++++ 4 files changed, 192 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..5388df852a21 --- /dev/null +++ b/drivers/xen/mem-reservation.c @@ -0,0 +1,120 @@ +// 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_SCRUB_PAGES +void xenmem_reservation_scrub_page(struct page *page) +{ + clear_highpage(page); +} +EXPORT_SYMBOL_GPL(xenmem_reservation_scrub_page); +#endif + +#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..a727d65a1e61 --- /dev/null +++ b/include/xen/mem-reservation.h @@ -0,0 +1,65 @@ +/* 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 + +#ifdef CONFIG_XEN_SCRUB_PAGES +void xenmem_reservation_scrub_page(struct page *page); +#else +static inline void xenmem_reservation_scrub_page(struct page *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.0