From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7B86DC4332F for ; Fri, 15 Dec 2023 04:37:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:Cc:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=9954HEFQXveozn43BRr9pdH6BqbuQ7xUuYKmvsofqlw=; b=b4Gw1awtuqYYEJ YhZKdySD9/KF2ebSdVa5sUqo21ruwrRZZ9PtNg7/lmyrz5qau8Yy+/sUStQ6aTdW3akJ3gG3+/CHl N4gaTgNZq2GGyMeZwrE6jWUOISxkCvGPncPzZ9gInw/ks05HfnBnK5kf88Gs3i5Pef658pZ8ekcki 81hBqvBA/SrsOLcNl17sNk/gzm/m9NxMuMbdHVUs+FzPGVIQ20ojPlPDAfeA7T5U2vCdYQM+ezZRV pwlFe/ioeajmQ6/h3aps+GrWxC1w460Fp646UDLuF5Ymp3aB0aHaMNoe1aJN6GIzBDClAINfjpU9h 83OQG6ONFvxXMyJYBwMA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rDzwx-001zhA-2d; Fri, 15 Dec 2023 04:37:23 +0000 Received: from out-184.mta0.migadu.com ([91.218.175.184]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rDzwt-001zcy-0m for linux-arm-kernel@lists.infradead.org; Fri, 15 Dec 2023 04:37:23 +0000 Message-ID: <50f082a8-b805-5d66-45f4-2af58e99a67f@linux.dev> DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1702615023; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=oMTQvMW92QfKnIxa39K+CCGnV2PPSQbzW7nt0Rm9e8w=; b=Z3NJrGTAWaoJyemZ+IxBaSKq/eFQeLUp5taJjgqJZ7yc9EXzkOVRSsrZHVvBiZ3a/pcWMf ANhH1k7qH2Im1NL5eovjsuWB2VlfMfNHyW5/g4baAVv8nylRMSl8JC45v+XB2RRle2nD0u 5QELYTH+1R+nT2c4QbN0QrgPCA8xxkA= Date: Fri, 15 Dec 2023 12:36:57 +0800 MIME-Version: 1.0 Subject: Re: [PATCH 2/3] arm64: mm: HVO: support BBM of vmemmap pgtable safely To: Nanyong Sun , catalin.marinas@arm.com, will@kernel.org, mike.kravetz@oracle.com, akpm@linux-foundation.org, anshuman.khandual@arm.com Cc: willy@infradead.org, wangkefeng.wang@huawei.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org References: <20231214073912.1938330-1-sunnanyong@huawei.com> <20231214073912.1938330-3-sunnanyong@huawei.com> X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. From: Muchun Song In-Reply-To: <20231214073912.1938330-3-sunnanyong@huawei.com> X-Migadu-Flow: FLOW_OUT X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231214_203719_433142_6CC0D3AC X-CRM114-Status: GOOD ( 30.53 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org CgpPbiAyMDIzLzEyLzE0IDE1OjM5LCBOYW55b25nIFN1biB3cm90ZToKPiBJbXBsZW1lbnQgdm1l bW1hcF91cGRhdGVfcG1kIGFuZCB2bWVtbWFwX3VwZGF0ZV9wdGUgb24gYXJtNjQgdG8gZG8KPiBC Qk0oYnJlYWstYmVmb3JlLW1ha2UpIGxvZ2ljIHdoZW4gY2hhbmdlIHRoZSBwYWdlIHRhYmxlIG9m IHZtZW1tYXAKPiBhZGRyZXNzLCB0aGV5IHdpbGwgdW5kZXIgdGhlIGluaXRfbW0ucGFnZV90YWJs ZV9sb2NrLgo+IElmIGEgdHJhbnNsYXRpb24gZmF1bHQgb2Ygdm1lbW1hcCBhZGRyZXNzIGNvbmN1 cnJlbnRseSBoYXBwZW5lZCBhZnRlcgo+IHB0ZS9wbWQgY2xlYXJlZCwgdm1lbW1hcCBwYWdlIGZh dWx0IGhhbmRsZXIgd2lsbCBhY3F1aXJlIHRoZQo+IGluaXRfbW0ucGFnZV90YWJsZV9sb2NrIHRv IHdhaXQgZm9yIHZtZW1tYXAgdXBkYXRlIHRvIGNvbXBsZXRlLAo+IGJ5IHRoZW4gdGhlIHZpcnR1 YWwgYWRkcmVzcyBpcyB2YWxpZCBhZ2Fpbiwgc28gUEYgY2FuIHJldHVybiBhbmQKPiBhY2Nlc3Mg Y2FuIGNvbnRpbnVlLgo+IEluIG90aGVyIGNhc2UsIGRvIHRoZSB0cmFkaXRpb25hbCBrZXJuZWwg ZmF1bHQuCgpZZXMuIEJUVywgd2UgYWxyZWFkeSB1c2UgdGhlIHNhbWUgc2NoZW1lIHRvIHN1cHBv cnQgYXJtNjQKaW4gb3VyIGludGVybmFsIHByb2R1Y3Rpb24uIFNvIHRoZSB3aG9sZSBhcHByb2Fj aCBMR1RNLgoKPiBJbXBsZW1lbnQgZmx1c2hfdGxiX3ZtZW1tYXBfYWxsIGFuZCBmbHVzaF90bGJf dm1lbW1hcF9yYW5nZSBvbiBhcm02NAo+IHdpdGggbm90aGluZyB0byBkbyBiZWNhdXNlIHRsYiBh bHJlYWR5IGZsdXNoZWQgaW4gZXZlcnkgc2luZ2xlIEJCTS4KPgo+IFNpZ25lZC1vZmYtYnk6IE5h bnlvbmcgU3VuIDxzdW5uYW55b25nQGh1YXdlaS5jb20+Cj4gLS0tCj4gICBhcmNoL2FybTY0L2lu Y2x1ZGUvYXNtL2Vzci5oIHwgIDQgKysKPiAgIGFyY2gvYXJtNjQvaW5jbHVkZS9hc20vbW11Lmgg fCAyMCArKysrKysrKwo+ICAgYXJjaC9hcm02NC9tbS9mYXVsdC5jICAgICAgICB8IDk0ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAgYXJjaC9hcm02NC9tbS9tbXUuYyAg ICAgICAgICB8IDI4ICsrKysrKysrKysrCj4gICA0IGZpbGVzIGNoYW5nZWQsIDE0NiBpbnNlcnRp b25zKCspCj4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9lc3IuaCBiL2Fy Y2gvYXJtNjQvaW5jbHVkZS9hc20vZXNyLmgKPiBpbmRleCBhZTM1OTM5ZjM5NWIuLjFjNjMyNTZl ZmQyNSAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Vzci5oCj4gKysrIGIv YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9lc3IuaAo+IEBAIC0xMTYsNiArMTE2LDEwIEBACj4gICAj ZGVmaW5lIEVTUl9FTHhfRlNDX1NFUlJPUgkoMHgxMSkKPiAgICNkZWZpbmUgRVNSX0VMeF9GU0Nf QUNDRVNTCSgweDA4KQo+ICAgI2RlZmluZSBFU1JfRUx4X0ZTQ19GQVVMVAkoMHgwNCkKPiArI2Rl ZmluZSBFU1JfRUx4X0ZTQ19GQVVMVF9MMCAgICAoMHgwNCkKPiArI2RlZmluZSBFU1JfRUx4X0ZT Q19GQVVMVF9MMSAgICAoMHgwNSkKPiArI2RlZmluZSBFU1JfRUx4X0ZTQ19GQVVMVF9MMiAgICAo MHgwNikKPiArI2RlZmluZSBFU1JfRUx4X0ZTQ19GQVVMVF9MMyAgICAoMHgwNykKPiAgICNkZWZp bmUgRVNSX0VMeF9GU0NfUEVSTQkoMHgwQykKPiAgICNkZWZpbmUgRVNSX0VMeF9GU0NfU0VBX1RU VzAJKDB4MTQpCj4gICAjZGVmaW5lIEVTUl9FTHhfRlNDX1NFQV9UVFcxCSgweDE1KQo+IGRpZmYg LS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL21tdS5oIGIvYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9tbXUuaAo+IGluZGV4IDJmY2Y1MTIzMWQ2ZS4uZmNlYzU4MjdmNTRmIDEwMDY0NAo+IC0t LSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vbW11LmgKPiArKysgYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL21tdS5oCj4gQEAgLTc2LDUgKzc2LDI1IEBAIGV4dGVybiBib29sIGthc2xyX3JlcXVp cmVzX2twdGkodm9pZCk7Cj4gICAjZGVmaW5lIElOSVRfTU1fQ09OVEVYVChuYW1lKQlcCj4gICAJ LnBnZCA9IGluaXRfcGdfZGlyLAo+ICAgCj4gKyNpZmRlZiBDT05GSUdfSFVHRVRMQl9QQUdFX09Q VElNSVpFX1ZNRU1NQVAKPiArdm9pZCB2bWVtbWFwX3VwZGF0ZV9wbWQodW5zaWduZWQgbG9uZyBz dGFydCwgcG1kX3QgKnBtZCwgcHRlX3QgKnBndGFibGUpOwo+ICsjZGVmaW5lIHZtZW1tYXBfdXBk YXRlX3BtZCB2bWVtbWFwX3VwZGF0ZV9wbWQKPiArdm9pZCB2bWVtbWFwX3VwZGF0ZV9wdGUodW5z aWduZWQgbG9uZyBhZGRyLCBwdGVfdCAqcHRlLCBwdGVfdCBlbnRyeSk7Cj4gKyNkZWZpbmUgdm1l bW1hcF91cGRhdGVfcHRlIHZtZW1tYXBfdXBkYXRlX3B0ZQo+ICsKPiArc3RhdGljIGlubGluZSB2 b2lkIGZsdXNoX3RsYl92bWVtbWFwX2FsbCh2b2lkKQo+ICt7Cj4gKwkvKiBkbyBub3RoaW5nLCBh bHJlYWR5IGZsdXNoZWQgdGxiIGluIGV2ZXJ5IHNpbmdsZSBCQk0gKi8KPiArfQo+ICsjZGVmaW5l IGZsdXNoX3RsYl92bWVtbWFwX2FsbCBmbHVzaF90bGJfdm1lbW1hcF9hbGwKPiArCj4gK3N0YXRp YyBpbmxpbmUgdm9pZCBmbHVzaF90bGJfdm1lbW1hcF9yYW5nZSh1bnNpZ25lZCBsb25nIHN0YXJ0 LAo+ICsJCQkJCSAgIHVuc2lnbmVkIGxvbmcgZW5kKQo+ICt7Cj4gKwkvKiBkbyBub3RoaW5nLCBh bHJlYWR5IGZsdXNoZWQgdGxiIGluIGV2ZXJ5IHNpbmdsZSBCQk0gKi8KPiArfQo+ICsjZGVmaW5l IGZsdXNoX3RsYl92bWVtbWFwX3JhbmdlIGZsdXNoX3RsYl92bWVtbWFwX3JhbmdlCj4gKyNlbmRp Zgo+ICsKPiAgICNlbmRpZgkvKiAhX19BU1NFTUJMWV9fICovCj4gICAjZW5kaWYKPiBkaWZmIC0t Z2l0IGEvYXJjaC9hcm02NC9tbS9mYXVsdC5jIGIvYXJjaC9hcm02NC9tbS9mYXVsdC5jCj4gaW5k ZXggNDYwZDc5OWUxMjk2Li43MDY2YTI3M2MxZTAgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02NC9t bS9mYXVsdC5jCj4gKysrIGIvYXJjaC9hcm02NC9tbS9mYXVsdC5jCj4gQEAgLTM2OCw2ICszNjgs OTcgQEAgc3RhdGljIGJvb2wgaXNfZWwxX210ZV9zeW5jX3RhZ19jaGVja19mYXVsdCh1bnNpZ25l ZCBsb25nIGVzcikKPiAgIAlyZXR1cm4gZmFsc2U7Cj4gICB9Cj4gICAKPiArI2lmZGVmIENPTkZJ R19IVUdFVExCX1BBR0VfT1BUSU1JWkVfVk1FTU1BUAo+ICtzdGF0aWMgaW5saW5lIGJvb2wgaXNf dm1lbW1hcF9hZGRyZXNzKHVuc2lnbmVkIGxvbmcgYWRkcikKPiArewo+ICsJcmV0dXJuIChhZGRy ID49IFZNRU1NQVBfU1RBUlQpICYmIChhZGRyIDwgVk1FTU1BUF9FTkQpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgaW5saW5lIGJvb2wgdm1lbW1hcF9mYXVsdF9tYXlfZml4dXAodW5zaWduZWQgbG9uZyBh ZGRyLAo+ICsJCQkJCSAgIHVuc2lnbmVkIGxvbmcgZXNyKQo+ICt7Cj4gKwlpZiAoIWlzX3ZtZW1t YXBfYWRkcmVzcyhhZGRyKSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJLyoKPiArCSAqIE9u bHkgdHJ5IHRvIGhhbmRsZSB0cmFuc2xhdGlvbiBmYXVsdCBsZXZlbCAyIG9yIGxldmVsIDMsCj4g KwkgKiBiZWNhdXNlIGh1Z2V0bGIgdm1lbW1hcCBvcHRpbWl6ZSBvbmx5IGNsZWFyIHBtZCBvciBw dGUuCj4gKwkgKi8KPiArCXN3aXRjaCAoZXNyICYgRVNSX0VMeF9GU0MpIHsKPiArCWNhc2UgRVNS X0VMeF9GU0NfRkFVTFRfTDI6Cj4gKwljYXNlIEVTUl9FTHhfRlNDX0ZBVUxUX0wzOgo+ICsJCXJl dHVybiB0cnVlOwo+ICsJZGVmYXVsdDoKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwl9Cj4gK30KPiAr Cj4gKy8qCj4gKyAqIFBNRCBtYXBwZWQgdm1lbW1hcCBzaG91bGQgaGFzIGJlZW4gc3BsaXQgYXMg UFRFIG1hcHBlZAo+ICsgKiBieSBIVk8gbm93LCBoZXJlIHdlIG9ubHkgY2hlY2sgdGhpcyBjYXNl LCBvdGhlciBjYXNlcwo+ICsgKiBzaG91bGQgZmFpbC4KPiArICogQWxzbyBzaG91bGQgY2hlY2sg dGhlIGFkZHIgaXMgaGVhbHRoeSBlbm91Z2ggdGhhdCB3aWxsIG5vdCBjYXVzZQo+ICsgKiBhIGxl dmVsMiBvciBsZXZlbDMgdHJhbnNsYXRpb24gZmF1bHQgYWdhaW4gYWZ0ZXIgcGFnZSBmYXVsdAo+ ICsgKiBoYW5kbGVkIHdpdGggc3VjY2Vzcywgc28gd2UgbmVlZCBjaGVjayBib3RoIGJpdHNbMTow XSBvZiBQTUQgYW5kCj4gKyAqIFBURSBhcyBBUk0gU3BlYyBtZW50aW9uZWQgYmVsb3c6Cj4gKyAq IEEgVHJhbnNsYXRpb24gZmF1bHQgaXMgZ2VuZXJhdGVkIGlmIGJpdHNbMTowXSBvZiBhIHRyYW5z bGF0aW9uCj4gKyAqIHRhYmxlIGRlc2NyaXB0b3IgaWRlbnRpZnkgdGhlIGRlc2NyaXB0b3IgYXMg ZWl0aGVyIGEgRmF1bHQKPiArICogZW5jb2Rpbmcgb3IgYSByZXNlcnZlZCBlbmNvZGluZy4KPiAr ICovCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCB2bWVtbWFwX2FkZHJfaGVhbHRoeSh1bnNpZ25lZCBs b25nIGFkZHIpCj4gK3sKPiArCXBnZF90ICpwZ2RwOwo+ICsJcDRkX3QgKnA0ZHA7Cj4gKwlwdWRf dCAqcHVkcCwgcHVkOwo+ICsJcG1kX3QgKnBtZHAsIHBtZDsKPiArCXB0ZV90ICpwdGVwLCBwdGU7 Cj4gKwo+ICsJcGdkcCA9IHBnZF9vZmZzZXRfayhhZGRyKTsKPiArCWlmIChwZ2Rfbm9uZShSRUFE X09OQ0UoKnBnZHApKSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJcDRkcCA9IHA0ZF9vZmZz ZXQocGdkcCwgYWRkcik7Cj4gKwlpZiAocDRkX25vbmUoUkVBRF9PTkNFKCpwNGRwKSkpCj4gKwkJ cmV0dXJuIGZhbHNlOwo+ICsKPiArCXB1ZHAgPSBwdWRfb2Zmc2V0KHA0ZHAsIGFkZHIpOwo+ICsJ cHVkID0gUkVBRF9PTkNFKCpwdWRwKTsKPiArCWlmIChwdWRfbm9uZShwdWQpKQo+ICsJCXJldHVy biBmYWxzZTsKPiArCj4gKwlwbWRwID0gcG1kX29mZnNldChwdWRwLCBhZGRyKTsKCldlIGFscmVh ZHkgbWFrZSBzdXJlIGl0IGlzIGEgdHJhbnNsYXRpb24gZmF1bHQgb2YgbGV2ZWwgMiBvciAzCmhl cmUsIHNvIHdlIGNvdWxkIHVzZSBwbWRfb2Zmc2V0X2soKSBtYWNybyB0byBzaW1wbGlmeSB0aGUg Y29kZQphIGxpdHRsZS4gUmlnaHQ/Cgo+ICsJcG1kID0gUkVBRF9PTkNFKCpwbWRwKTsKPiArCWlm ICghcG1kX3RhYmxlKHBtZCkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXB0ZXAgPSBwdGVf b2Zmc2V0X2tlcm5lbChwbWRwLCBhZGRyKTsKPiArCXB0ZSA9IFJFQURfT05DRSgqcHRlcCk7CgpQ bGVhc2UgdXNlIHB0ZXBfZ2V0ICh3aGljaCBpcyBzdXBwb3NlZCB0byBkbyB0aGlzKSB0byBhY2Nl c3MgdGhlCnJhdyBwdGUsIHNlZSBjb21taXQgYzMzYzc5NDgyOGYyMTIxNy4KCj4gKwlyZXR1cm4g KHB0ZV92YWwocHRlKSAmIFBURV9UWVBFX01BU0spID09IFBURV9UWVBFX1BBR0U7Cj4gK30KPiAr Cj4gK3N0YXRpYyBib29sIHZtZW1tYXBfaGFuZGxlX3BhZ2VfZmF1bHQodW5zaWduZWQgbG9uZyBh ZGRyLAo+ICsJCQkJICAgICAgdW5zaWduZWQgbG9uZyBlc3IpCj4gK3sKPiArCWJvb2wgcmV0ID0g ZmFsc2U7Cj4gKwo+ICsJaWYgKGxpa2VseSghdm1lbW1hcF9mYXVsdF9tYXlfZml4dXAoYWRkciwg ZXNyKSkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXNwaW5fbG9jaygmaW5pdF9tbS5wYWdl X3RhYmxlX2xvY2spOwo+ICsJaWYgKHZtZW1tYXBfYWRkcl9oZWFsdGh5KGFkZHIpKQo+ICsJCXJl dCA9IHRydWU7CgpJdCBpcyB0byBhc3NpZ24gdGhlIHJldHVybiB2YWx1ZSB0byByZXQgZGlyZWN0 bHkuIExpa2U6CgogwqDCoMKgIMKgwqDCoCByZXQgPSB2bWVtbWFwX2FkZHJfaGVhbHRoeShhZGRy KTsKClRoZSB0aGUgaW5pdGlhbGl6ZXRpb24gdG8gcmV0IGFsc28gY2FuIGJlIGRyb3BwZWQuCgo+ ICsJc3Bpbl91bmxvY2soJmluaXRfbW0ucGFnZV90YWJsZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4g cmV0Owo+ICt9Cj4gKyNlbHNlCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCB2bWVtbWFwX2hhbmRsZV9w YWdlX2ZhdWx0KHVuc2lnbmVkIGxvbmcgYWRkciwKPiArCQkJCQkgICAgIHVuc2lnbmVkIGxvbmcg ZXNyKQo+ICt7Cj4gKwlyZXR1cm4gZmFsc2U7Cj4gK30KPiArI2VuZGlmIC8qQ09ORklHX0hVR0VU TEJfUEFHRV9PUFRJTUlaRV9WTUVNTUFQICovCiDCoMKgwqDCoMKgwqDCoMKgwqAgXgpNaXNzIGEg YmxhbmsgYmV0d2VlbiAiKiIgYW5kICJDIiBoZXJlLgoKVGhhbmtzLgoKPiArCj4gICBzdGF0aWMg Ym9vbCBpc190cmFuc2xhdGlvbl9mYXVsdCh1bnNpZ25lZCBsb25nIGVzcikKPiAgIHsKPiAgIAly ZXR1cm4gKGVzciAmIEVTUl9FTHhfRlNDX1RZUEUpID09IEVTUl9FTHhfRlNDX0ZBVUxUOwo+IEBA IC00MDksNiArNTAwLDkgQEAgc3RhdGljIHZvaWQgX19kb19rZXJuZWxfZmF1bHQodW5zaWduZWQg bG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVzciwKPiAgIAkJICAgIGtmZW5jZV9oYW5kbGVfcGFn ZV9mYXVsdChhZGRyLCBlc3IgJiBFU1JfRUx4X1dOUiwgcmVncykpCj4gICAJCQlyZXR1cm47Cj4g ICAKPiArCQlpZiAodm1lbW1hcF9oYW5kbGVfcGFnZV9mYXVsdChhZGRyLCBlc3IpKQo+ICsJCQly ZXR1cm47Cj4gKwo+ICAgCQltc2cgPSAicGFnaW5nIHJlcXVlc3QiOwo+ICAgCX0KPiAgIAo+IGRp ZmYgLS1naXQgYS9hcmNoL2FybTY0L21tL21tdS5jIGIvYXJjaC9hcm02NC9tbS9tbXUuYwo+IGlu ZGV4IDE1ZjYzNDdkMjNiNi4uODFhNjAwY2NhYzdjIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQv bW0vbW11LmMKPiArKysgYi9hcmNoL2FybTY0L21tL21tdS5jCj4gQEAgLTExNDYsNiArMTE0Niwz NCBAQCBpbnQgX19tZW1pbml0IHZtZW1tYXBfY2hlY2tfcG1kKHBtZF90ICpwbWRwLCBpbnQgbm9k ZSwKPiAgIAlyZXR1cm4gMTsKPiAgIH0KPiAgIAo+ICsjaWZkZWYgQ09ORklHX0hVR0VUTEJfUEFH RV9PUFRJTUlaRV9WTUVNTUFQCj4gKy8qCj4gKyAqIEluIHRoZSB3aW5kb3cgYmV0d2VlbiB0aGUg cGFnZSB0YWJsZSBlbnRyeSBpcyBjbGVhcmVkIGFuZCBmaWxsZWQKPiArICogd2l0aCBhIG5ldyB2 YWx1ZSwgb3RoZXIgdGhyZWFkcyBoYXZlIHRoZSBvcHBvcnR1bml0eSB0byBjb25jdXJyZW50bHkK PiArICogYWNjZXNzIHRoZSB2bWVtbWFwIGFyZWEgdGhlbiBwYWdlIHRyYW5zbGF0aW9uIGZhdWx0 IG9jY3VyLgo+ICsgKiBUaGVyZWZvcmUsIHdlIG5lZWQgdG8gZW5zdXJlIHRoYXQgdGhlIGluaXRf bW0ucGFnZV90YWJsZV9sb2NrIGlzIGhlbGQKPiArICogdG8gc3luY2hyb25pemUgdGhlIHZtZW1t YXAgcGFnZSBmYXVsdCBoYW5kbGluZyB3aGljaCB3aWxsIHdhaXQgZm9yCj4gKyAqIHRoaXMgbG9j ayB0byBiZSByZWxlYXNlZCB0byBlbnN1cmUgdGhhdCB0aGUgcGFnZSB0YWJsZSBlbnRyeSBoYXMg YmVlbgo+ICsgKiByZWZyZXNoZWQgd2l0aCBhIG5ldyB2YWxpZCB2YWx1ZS4KPiArICovCj4gK3Zv aWQgdm1lbW1hcF91cGRhdGVfcG1kKHVuc2lnbmVkIGxvbmcgc3RhcnQsIHBtZF90ICpwbWQsIHB0 ZV90ICpwZ3RhYmxlKQo+ICt7Cj4gKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZpbml0X21tLnBhZ2Vf dGFibGVfbG9jayk7Cj4gKwlwbWRfY2xlYXIocG1kKTsKPiArCWZsdXNoX3RsYl9rZXJuZWxfcmFu Z2Uoc3RhcnQsIHN0YXJ0ICsgUE1EX1NJWkUpOwo+ICsJcG1kX3BvcHVsYXRlX2tlcm5lbCgmaW5p dF9tbSwgcG1kLCBwZ3RhYmxlKTsKPiArfQo+ICsKPiArdm9pZCB2bWVtbWFwX3VwZGF0ZV9wdGUo dW5zaWduZWQgbG9uZyBhZGRyLCBwdGVfdCAqcHRlLCBwdGVfdCBlbnRyeSkKPiArewo+ICsJc3Bp bl9sb2NrKCZpbml0X21tLnBhZ2VfdGFibGVfbG9jayk7Cj4gKwlwdGVfY2xlYXIoJmluaXRfbW0s IGFkZHIsIHB0ZSk7Cj4gKwlmbHVzaF90bGJfa2VybmVsX3JhbmdlKGFkZHIsIGFkZHIgKyBQQUdF X1NJWkUpOwo+ICsJc2V0X3B0ZV9hdCgmaW5pdF9tbSwgYWRkciwgcHRlLCBlbnRyeSk7Cj4gKwlz cGluX3VubG9jaygmaW5pdF9tbS5wYWdlX3RhYmxlX2xvY2spOwo+ICt9Cj4gKyNlbmRpZgo+ICsK PiAgIGludCBfX21lbWluaXQgdm1lbW1hcF9wb3B1bGF0ZSh1bnNpZ25lZCBsb25nIHN0YXJ0LCB1 bnNpZ25lZCBsb25nIGVuZCwgaW50IG5vZGUsCj4gICAJCXN0cnVjdCB2bWVtX2FsdG1hcCAqYWx0 bWFwKQo+ICAgewoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMu aW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2xpbnV4LWFybS1rZXJuZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id C16D1C4332F for ; Fri, 15 Dec 2023 04:37:08 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 269D96B0539; Thu, 14 Dec 2023 23:37:08 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 1F2A28D0103; Thu, 14 Dec 2023 23:37:08 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 0445F6B0530; Thu, 14 Dec 2023 23:37:07 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id E95136B052E for ; Thu, 14 Dec 2023 23:37:07 -0500 (EST) Received: from smtpin16.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id AB779A0352 for ; Fri, 15 Dec 2023 04:37:07 +0000 (UTC) X-FDA: 81567792894.16.4AD1E9E Received: from out-172.mta0.migadu.com (out-172.mta0.migadu.com [91.218.175.172]) by imf15.hostedemail.com (Postfix) with ESMTP id B0EE2A0003 for ; Fri, 15 Dec 2023 04:37:05 +0000 (UTC) Authentication-Results: imf15.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=Z3NJrGTA; dmarc=pass (policy=none) header.from=linux.dev; spf=pass (imf15.hostedemail.com: domain of muchun.song@linux.dev designates 91.218.175.172 as permitted sender) smtp.mailfrom=muchun.song@linux.dev ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1702615026; a=rsa-sha256; cv=none; b=SHeQ10B5lTP1rNy4RQvkcfDtDsGiDGVVP7kERs7hxaP7rfA8AjNfz9u2vxQyD7vqqAGlFp KygPJ/kTDpPIOkyjqPLergk9NdITmHba/AFhTrT1KXN6Hkd8Z3F6TJ2o6kfFZMPkbHLZlc xkR1WOZEVSVFrc4VvMX4KofVExBjHhc= ARC-Authentication-Results: i=1; imf15.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=Z3NJrGTA; dmarc=pass (policy=none) header.from=linux.dev; spf=pass (imf15.hostedemail.com: domain of muchun.song@linux.dev designates 91.218.175.172 as permitted sender) smtp.mailfrom=muchun.song@linux.dev ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1702615026; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=oMTQvMW92QfKnIxa39K+CCGnV2PPSQbzW7nt0Rm9e8w=; b=kDsxdR/Hv7IVruBr//QfQYBYTi1lCq1q+gU7hAFulZXVM3Pz726zlW715hNgq+BMxLVOTm EIlXxu5wyqnmX7hYmuWBHvEwAITNkEiAjUPp4jeh0oxLctcTRFf9Gky1AbB2FHr8RXKC7l nr6dDYrpriDvRTDrQGwWvi1BlvHNQ3Q= Message-ID: <50f082a8-b805-5d66-45f4-2af58e99a67f@linux.dev> DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1702615023; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=oMTQvMW92QfKnIxa39K+CCGnV2PPSQbzW7nt0Rm9e8w=; b=Z3NJrGTAWaoJyemZ+IxBaSKq/eFQeLUp5taJjgqJZ7yc9EXzkOVRSsrZHVvBiZ3a/pcWMf ANhH1k7qH2Im1NL5eovjsuWB2VlfMfNHyW5/g4baAVv8nylRMSl8JC45v+XB2RRle2nD0u 5QELYTH+1R+nT2c4QbN0QrgPCA8xxkA= Date: Fri, 15 Dec 2023 12:36:57 +0800 MIME-Version: 1.0 Subject: Re: [PATCH 2/3] arm64: mm: HVO: support BBM of vmemmap pgtable safely To: Nanyong Sun , catalin.marinas@arm.com, will@kernel.org, mike.kravetz@oracle.com, akpm@linux-foundation.org, anshuman.khandual@arm.com Cc: willy@infradead.org, wangkefeng.wang@huawei.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org References: <20231214073912.1938330-1-sunnanyong@huawei.com> <20231214073912.1938330-3-sunnanyong@huawei.com> X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. From: Muchun Song In-Reply-To: <20231214073912.1938330-3-sunnanyong@huawei.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT X-Rspam-User: X-Rspamd-Server: rspam06 X-Rspamd-Queue-Id: B0EE2A0003 X-Stat-Signature: 1739m3srd74ajw15z9ghmj7pyyoa36pe X-HE-Tag: 1702615025-385659 X-HE-Meta: U2FsdGVkX1/k/jMKiLT/apCmxmeQaV/7Y12D9lY9T5V6y8cAfTQ3oWHCZVGZbLEK+o7Fpn+BV1uSAswqqv32MNRJoQZE6yMYZW6WX845Q5LbWQkEdSYS5dIGfOfG7QwihpuA9/jhWBrnkpBcbt9DOdxJpFLrhRUyPkmXJtIrYfE7fZjSIuhKJ92JW/IK5PQgrFb069a7Ww8aKMHbtmifIM1++CKAmojReI+JG0YOA8PIawlcC8oE++VTQaKPmSCBYTp+ZeCe85EG/AVQFo+gN4dQW+OFrM2dHuEjmggFOHhj6CKIniDB6MW0XJ7taABpt8SAhWxIUssQlmg/741u7OL0aeB31o45AqHf96J5M8Se4Twqrdp8uygbwcIvHmbmziA7RG4foXBfveW8CUko46mhrIZaneTc3Cn/eHQ7xmTl8/pWugE7h1etO5SumvA8xvpUuPEY1AfQTSssD1GkxOe3U3KDyefp5dYsmEXwf8VUqQKUSoK4dnjidszQtrZpD/pv6s9nyPzyaXu02piFhzPDiZQzN/NUmohJmph5OmU36slkmJS92wMn91NSam61WdRfnlDv4MeG7yWlRZ4hNhNE1mDEN9oQUfwRIKB8918Ds5n8IWU8/S6sc0MFiaGxwUICtxOFEl5EG6G8fxGQWsfmZ+Vk7i9knFBUsGYjTyNjI3/QGLk9IIBaOWjqZD8yrfGfYUZfNF6YRtF9H7y6Rkh3kYnnrOmNnHbcz7JDSJiPtNX74PBTTR4ZanLrQjydR0/3aRBS5tWRjQaJJKn7uJ9An/7g2K1Ulz9kjfnw03rT1scaZvKAQMaUrCGmyTeBPlNNCQyInL7MPOCyLqXN93hAiDP+ooq17DmdGug2l2GMVvIDKKyvpiqZ8GvdF56WXBdy0TVbLo4X/duSH66DcAEykSOjRlis+bflyrFFDTYhmZV9gqv5XanoEAopJhU88v87frVtIXqr6rk3iPk l0bfgSsG c/cdFzaN7V8G32pU9GuLrX4jaudZn7JFN4A5TjOHmu1cb6U7H6GJaDqzqxcqneKcyxfJLFlCcnbb2klpC+zqqnKilhE0e40+UBkY4ltXh2QgYSYCriUUB5RHUTg== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: On 2023/12/14 15:39, Nanyong Sun wrote: > Implement vmemmap_update_pmd and vmemmap_update_pte on arm64 to do > BBM(break-before-make) logic when change the page table of vmemmap > address, they will under the init_mm.page_table_lock. > If a translation fault of vmemmap address concurrently happened after > pte/pmd cleared, vmemmap page fault handler will acquire the > init_mm.page_table_lock to wait for vmemmap update to complete, > by then the virtual address is valid again, so PF can return and > access can continue. > In other case, do the traditional kernel fault. Yes. BTW, we already use the same scheme to support arm64 in our internal production. So the whole approach LGTM. > Implement flush_tlb_vmemmap_all and flush_tlb_vmemmap_range on arm64 > with nothing to do because tlb already flushed in every single BBM. > > Signed-off-by: Nanyong Sun > --- > arch/arm64/include/asm/esr.h | 4 ++ > arch/arm64/include/asm/mmu.h | 20 ++++++++ > arch/arm64/mm/fault.c | 94 ++++++++++++++++++++++++++++++++++++ > arch/arm64/mm/mmu.c | 28 +++++++++++ > 4 files changed, 146 insertions(+) > > diff --git a/arch/arm64/include/asm/esr.h b/arch/arm64/include/asm/esr.h > index ae35939f395b..1c63256efd25 100644 > --- a/arch/arm64/include/asm/esr.h > +++ b/arch/arm64/include/asm/esr.h > @@ -116,6 +116,10 @@ > #define ESR_ELx_FSC_SERROR (0x11) > #define ESR_ELx_FSC_ACCESS (0x08) > #define ESR_ELx_FSC_FAULT (0x04) > +#define ESR_ELx_FSC_FAULT_L0 (0x04) > +#define ESR_ELx_FSC_FAULT_L1 (0x05) > +#define ESR_ELx_FSC_FAULT_L2 (0x06) > +#define ESR_ELx_FSC_FAULT_L3 (0x07) > #define ESR_ELx_FSC_PERM (0x0C) > #define ESR_ELx_FSC_SEA_TTW0 (0x14) > #define ESR_ELx_FSC_SEA_TTW1 (0x15) > diff --git a/arch/arm64/include/asm/mmu.h b/arch/arm64/include/asm/mmu.h > index 2fcf51231d6e..fcec5827f54f 100644 > --- a/arch/arm64/include/asm/mmu.h > +++ b/arch/arm64/include/asm/mmu.h > @@ -76,5 +76,25 @@ extern bool kaslr_requires_kpti(void); > #define INIT_MM_CONTEXT(name) \ > .pgd = init_pg_dir, > > +#ifdef CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP > +void vmemmap_update_pmd(unsigned long start, pmd_t *pmd, pte_t *pgtable); > +#define vmemmap_update_pmd vmemmap_update_pmd > +void vmemmap_update_pte(unsigned long addr, pte_t *pte, pte_t entry); > +#define vmemmap_update_pte vmemmap_update_pte > + > +static inline void flush_tlb_vmemmap_all(void) > +{ > + /* do nothing, already flushed tlb in every single BBM */ > +} > +#define flush_tlb_vmemmap_all flush_tlb_vmemmap_all > + > +static inline void flush_tlb_vmemmap_range(unsigned long start, > + unsigned long end) > +{ > + /* do nothing, already flushed tlb in every single BBM */ > +} > +#define flush_tlb_vmemmap_range flush_tlb_vmemmap_range > +#endif > + > #endif /* !__ASSEMBLY__ */ > #endif > diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c > index 460d799e1296..7066a273c1e0 100644 > --- a/arch/arm64/mm/fault.c > +++ b/arch/arm64/mm/fault.c > @@ -368,6 +368,97 @@ static bool is_el1_mte_sync_tag_check_fault(unsigned long esr) > return false; > } > > +#ifdef CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP > +static inline bool is_vmemmap_address(unsigned long addr) > +{ > + return (addr >= VMEMMAP_START) && (addr < VMEMMAP_END); > +} > + > +static inline bool vmemmap_fault_may_fixup(unsigned long addr, > + unsigned long esr) > +{ > + if (!is_vmemmap_address(addr)) > + return false; > + > + /* > + * Only try to handle translation fault level 2 or level 3, > + * because hugetlb vmemmap optimize only clear pmd or pte. > + */ > + switch (esr & ESR_ELx_FSC) { > + case ESR_ELx_FSC_FAULT_L2: > + case ESR_ELx_FSC_FAULT_L3: > + return true; > + default: > + return false; > + } > +} > + > +/* > + * PMD mapped vmemmap should has been split as PTE mapped > + * by HVO now, here we only check this case, other cases > + * should fail. > + * Also should check the addr is healthy enough that will not cause > + * a level2 or level3 translation fault again after page fault > + * handled with success, so we need check both bits[1:0] of PMD and > + * PTE as ARM Spec mentioned below: > + * A Translation fault is generated if bits[1:0] of a translation > + * table descriptor identify the descriptor as either a Fault > + * encoding or a reserved encoding. > + */ > +static inline bool vmemmap_addr_healthy(unsigned long addr) > +{ > + pgd_t *pgdp; > + p4d_t *p4dp; > + pud_t *pudp, pud; > + pmd_t *pmdp, pmd; > + pte_t *ptep, pte; > + > + pgdp = pgd_offset_k(addr); > + if (pgd_none(READ_ONCE(*pgdp))) > + return false; > + > + p4dp = p4d_offset(pgdp, addr); > + if (p4d_none(READ_ONCE(*p4dp))) > + return false; > + > + pudp = pud_offset(p4dp, addr); > + pud = READ_ONCE(*pudp); > + if (pud_none(pud)) > + return false; > + > + pmdp = pmd_offset(pudp, addr); We already make sure it is a translation fault of level 2 or 3 here, so we could use pmd_offset_k() macro to simplify the code a little. Right? > + pmd = READ_ONCE(*pmdp); > + if (!pmd_table(pmd)) > + return false; > + > + ptep = pte_offset_kernel(pmdp, addr); > + pte = READ_ONCE(*ptep); Please use ptep_get (which is supposed to do this) to access the raw pte, see commit c33c794828f21217. > + return (pte_val(pte) & PTE_TYPE_MASK) == PTE_TYPE_PAGE; > +} > + > +static bool vmemmap_handle_page_fault(unsigned long addr, > + unsigned long esr) > +{ > + bool ret = false; > + > + if (likely(!vmemmap_fault_may_fixup(addr, esr))) > + return false; > + > + spin_lock(&init_mm.page_table_lock); > + if (vmemmap_addr_healthy(addr)) > + ret = true; It is to assign the return value to ret directly. Like:         ret = vmemmap_addr_healthy(addr); The the initializetion to ret also can be dropped. > + spin_unlock(&init_mm.page_table_lock); > + > + return ret; > +} > +#else > +static inline bool vmemmap_handle_page_fault(unsigned long addr, > + unsigned long esr) > +{ > + return false; > +} > +#endif /*CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP */           ^ Miss a blank between "*" and "C" here. Thanks. > + > static bool is_translation_fault(unsigned long esr) > { > return (esr & ESR_ELx_FSC_TYPE) == ESR_ELx_FSC_FAULT; > @@ -409,6 +500,9 @@ static void __do_kernel_fault(unsigned long addr, unsigned long esr, > kfence_handle_page_fault(addr, esr & ESR_ELx_WNR, regs)) > return; > > + if (vmemmap_handle_page_fault(addr, esr)) > + return; > + > msg = "paging request"; > } > > diff --git a/arch/arm64/mm/mmu.c b/arch/arm64/mm/mmu.c > index 15f6347d23b6..81a600ccac7c 100644 > --- a/arch/arm64/mm/mmu.c > +++ b/arch/arm64/mm/mmu.c > @@ -1146,6 +1146,34 @@ int __meminit vmemmap_check_pmd(pmd_t *pmdp, int node, > return 1; > } > > +#ifdef CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP > +/* > + * In the window between the page table entry is cleared and filled > + * with a new value, other threads have the opportunity to concurrently > + * access the vmemmap area then page translation fault occur. > + * Therefore, we need to ensure that the init_mm.page_table_lock is held > + * to synchronize the vmemmap page fault handling which will wait for > + * this lock to be released to ensure that the page table entry has been > + * refreshed with a new valid value. > + */ > +void vmemmap_update_pmd(unsigned long start, pmd_t *pmd, pte_t *pgtable) > +{ > + lockdep_assert_held(&init_mm.page_table_lock); > + pmd_clear(pmd); > + flush_tlb_kernel_range(start, start + PMD_SIZE); > + pmd_populate_kernel(&init_mm, pmd, pgtable); > +} > + > +void vmemmap_update_pte(unsigned long addr, pte_t *pte, pte_t entry) > +{ > + spin_lock(&init_mm.page_table_lock); > + pte_clear(&init_mm, addr, pte); > + flush_tlb_kernel_range(addr, addr + PAGE_SIZE); > + set_pte_at(&init_mm, addr, pte, entry); > + spin_unlock(&init_mm.page_table_lock); > +} > +#endif > + > int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node, > struct vmem_altmap *altmap) > {