Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Message-ID: <562b3cbf-19dd-0453-855c-d4bc1c599230@nutanix.com>
Date:   Mon, 27 Jun 2022 18:17:12 +0530
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
 Gecko/20100101 Thunderbird/91.10.0
Subject: Re: [RFC PATCH 07/26] hugetlb: add hugetlb_pte to track HugeTLB page
 table entries
To:     James Houghton <jthoughton@google.com>,
        Mike Kravetz <mike.kravetz@oracle.com>,
        Muchun Song <songmuchun@bytedance.com>,
        Peter Xu <peterx@redhat.com>
Cc:     David Hildenbrand <david@redhat.com>,
        David Rientjes <rientjes@google.com>,
        Axel Rasmussen <axelrasmussen@google.com>,
        Mina Almasry <almasrymina@google.com>,
        Jue Wang <juew@google.com>,
        "Dr . David Alan Gilbert" <dgilbert@redhat.com>,
        linux-mm@kvack.org, linux-kernel@vger.kernel.org
References: <20220624173656.2033256-1-jthoughton@google.com>
 <20220624173656.2033256-8-jthoughton@google.com>
From:   "manish.mishra" <manish.mishra@nutanix.com>
In-Reply-To: <20220624173656.2033256-8-jthoughton@google.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
MIME-Version: 1.0
X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1
X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?ekFoNHRvNmIrUS94UUEzelNPKzNYVTQ0eWxNUHFzbElDblpSRjZBdFY4MWh0?=
 =?utf-8?B?K3E1RXU1OWUzMlJBbjJkRWxiVkdmcWFxMzBVSmU3TEhSVExQK2xhKys2aU9z?=
 =?utf-8?B?OGlNU2w3T0RSaHVEWnF2aEloOXBtUmMzbWNLdFZ0UUIyUytIMWo0VVBSTDRN?=
 =?utf-8?B?ZWtKeXNhVnpuWm8vU1k5dEdPcnZPenllWXZRcU1LVG00bEhFakpheXJHeTRP?=
 =?utf-8?B?S0FoY0NPY2R1b3Y0TENkeGJ5Wk52a0JMSHRpNlR2Z3J2OFgyZS96TmYzV3Q0?=
 =?utf-8?B?NkpybmJhaHIxYVJ4czJaQ3dRTElFMFRLNk5oUFdUekp0TG5YckZtSkNudW8v?=
 =?utf-8?B?MHVuN1FzY3hwNDd1SlF4ZTRqZlFsMFpyTnpNYjZXUEJ0aHV3L0dQT3M3c0hS?=
 =?utf-8?B?T1hDQ2VTanNuSkdVRXlPUTVPZ3RzOXBGaUREVGd6aUdVY2xYOUREdG1qcUJF?=
 =?utf-8?B?am5ic3IvTUxmNFNubEkzbU9LY2tueWx3MUk0ckRxVnU5aGJoaW40by8wR1Zi?=
 =?utf-8?B?T0N5RDBQamNUQmtRNkxrZTkyQUVGUXdJcEZxVE5GWFdqTVZHYU1hdnhYWXJp?=
 =?utf-8?B?VUJzekFTdXpXNUNnUUhFL3Y3Vk4zOW0xRllvWHhIUDJBcXNhM2I2dWlPQTFt?=
 =?utf-8?B?WDdERkdPRUdSZFZkV3E3QlNrSkl6c1k4VUYyelJ0TVZmRUZpK0hhWUdkVlRp?=
 =?utf-8?B?RkNUV08wWS9NeEpIUmovbndRVERxZTFoTVV3ckYwakpNTlZ2eGFlTDZKdTFF?=
 =?utf-8?B?VnRWZ2ExNENJdm5Fclo0YWdwdTdwUStEQjUvci92aGhuaDZ5V2YwRTFRQ0Y4?=
 =?utf-8?B?MzBlWnUzSVlyR3oyUnhYREpheUhaaFBqMlRvanByUk9lVjRjS2NlbHBJZkU1?=
 =?utf-8?B?dzBOSHI3aHRaV1VaOFg2TVhUVmhtS3pPZFhkYnpweHRONGhoZmt5TStXZEdU?=
 =?utf-8?B?Q2tnVGoxd2swQUI5dVA1UjFhSGRhczVCSGwxNkdrQkNabndIRFIrR1NjSlRz?=
 =?utf-8?B?bzdGNGtFSFFDTU9QWklHWkNQS1V0NVdabUpXSTRyQStjK1lQY1JOcmwvME5U?=
 =?utf-8?B?aGVpYmVwYWVmZ1l2SW44c0t0QTdsTndEVDdwVWYwMmpqSVVMYnZYV3hacWNE?=
 =?utf-8?B?NkJxSFU2a0gvMCszQ0xod3M2M3d0OEUwczVVb3NyVG4wZHZzVDZiQktQSERK?=
 =?utf-8?B?Ny9VUW51S3RFekM3UjdOOFBnN2YwS2lUek1vUlZuN2QvVkZ4ajVuanltek9s?=
 =?utf-8?B?SWlXeWg5cHRpSlZtblkrOHpIWU1jc3hPMklwR1o5VHdyQWlYaFh1c1FpMEJ5?=
 =?utf-8?B?Ly83ZktuekljdFdBcVYyWVpRU2IxYktyZmVRenpoK2dkdFRuTjU4empMRmVZ?=
 =?utf-8?B?NUdiRnNkY0FnSWFwZTFOcmh0VC9ZMHNHTVk1UUZrcFhCQWNEa3lXMlIrTHh0?=
 =?utf-8?B?dVA5VmNJYWN2VkpQRnVFckU4OGUyR0VnKzFhVmJTUDIxdVNHYTVia1NNclJl?=
 =?utf-8?B?YzNBb1RxUVFvQnFUZE4ycFFUZWVEOE9sME41aExreU9ENmwwWXNDWTJZSkVr?=
 =?utf-8?B?WmxGbHo3SXZiYXZHUjFGZUZuUC91Z2s1Qmw1VVlkTitBbHM1bjFoZHBNUjhn?=
 =?utf-8?B?a1dSZzY5enA0MVFjUzRXd0RpcFk4RE5BSGtVb2p3UGs0clJjRVloVjZrenh6?=
 =?utf-8?B?anVzTklDazdlQk40eUphaGxOdHY5cjhFa3I3OGdacmlEWlBIMnBvR2hJZ2hN?=
 =?utf-8?B?RjYwTnhyTmliVllpb1psM2F6K2htdDBnL3h6QnNpU1NEWHJINHpwaTRjd0hp?=
 =?utf-8?B?WTBoeTdRUzJmWW54WEJGRk9Mc3g2K1FzZlo3TFl2NUFZQ0xwT2t2emxTR3dv?=
 =?utf-8?B?dWpaYkNkWDJMTnNqYmhqQlo1TUJsSkNBdTc0c25VTGltbjhJMHNqb0xhVjRO?=
 =?utf-8?B?ZnRNNWg1TXNBWkxFekRhcldoNllFWFV2RkhWNWhvN0RyMHpVbXlHNjBacmVk?=
 =?utf-8?B?Ynl5RXdWb01WTyszc2ZTcDBNMng4aElkQ1d1Qk1KZGtIV1lpc0NUYloyKzFU?=
 =?utf-8?B?K2JLMExBbXlycnZKTFdFMXRPbGVkN2dPcjVwam50US9wNlIreFhtMDJLdzhp?=
 =?utf-8?B?R2ZqMm9EZmZtd0R4cWdQUVhyOEMzdTRJYjIxWE96YWdyV2xOL3VsdFN3V1cr?=
 =?utf-8?B?Y1E9PQ==?=
X-OriginatorOrg: nutanix.com
X-MS-Exchange-CrossTenant-Network-Message-Id: 424f0daf-b99f-48d2-5df6-08da583b32b9
X-MS-Exchange-CrossTenant-AuthSource: PH0PR02MB7384.namprd02.prod.outlook.com
X-MS-Exchange-CrossTenant-AuthAs: Internal
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 27 Jun 2022 12:47:30.4920
 (UTC)
X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted
X-MS-Exchange-CrossTenant-Id: bb047546-786f-4de1-bd75-24e5b6f79043
X-MS-Exchange-CrossTenant-MailboxType: HOSTED
X-MS-Exchange-CrossTenant-UserPrincipalName: rz7KJR0yT+RWa/RbqW8HNslIYXa83ZLhpTkh7kEeUVFZ5EKnwslQPUoCi2/+4cWWxVZvrlbV3UgmI2rcgTTRRnjHrRKJ/loS6gY9cONJg4w=
X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR02MB5706
X-Proofpoint-GUID: ZaAxUhm3VesgTPj4NfXqjK8mA8DIx28_
X-Proofpoint-ORIG-GUID: ZaAxUhm3VesgTPj4NfXqjK8mA8DIx28_
X-Proofpoint-Virus-Version: vendor=baseguard
 engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1
 definitions=2022-06-27_06,2022-06-24_01,2022-06-22_01
X-Proofpoint-Spam-Reason: safe
X-Spam-Status: No, score=-2.5 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,
        DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,NICE_REPLY_A,
        SPF_HELO_NONE,SPF_NONE,T_SCC_BODY_TEXT_LINE autolearn=ham
        autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
        lindbergh.monkeyblade.net
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org


On 24/06/22 11:06 pm, James Houghton wrote:
> After high-granularity mapping, page table entries for HugeTLB pages can
> be of any size/type. (For example, we can have a 1G page mapped with a
> mix of PMDs and PTEs.) This struct is to help keep track of a HugeTLB
> PTE after we have done a page table walk.
>
> Without this, we'd have to pass around the "size" of the PTE everywhere.
> We effectively did this before; it could be fetched from the hstate,
> which we pass around pretty much everywhere.
>
> This commit includes definitions for some basic helper functions that
> are used later. These helper functions wrap existing PTE
> inspection/modification functions, where the correct version is picked
> depending on if the HugeTLB PTE is actually "huge" or not. (Previously,
> all HugeTLB PTEs were "huge").
>
> For example, hugetlb_ptep_get wraps huge_ptep_get and ptep_get, where
> ptep_get is used when the HugeTLB PTE is PAGE_SIZE, and huge_ptep_get is
> used in all other cases.
>
> Signed-off-by: James Houghton <jthoughton@google.com>
> ---
>   include/linux/hugetlb.h | 84 +++++++++++++++++++++++++++++++++++++++++
>   mm/hugetlb.c            | 57 ++++++++++++++++++++++++++++
>   2 files changed, 141 insertions(+)
>
> diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
> index 5fe1db46d8c9..1d4ec9dfdebf 100644
> --- a/include/linux/hugetlb.h
> +++ b/include/linux/hugetlb.h
> @@ -46,6 +46,68 @@ enum {
>   	__NR_USED_SUBPAGE,
>   };
>   
> +struct hugetlb_pte {
> +	pte_t *ptep;
> +	unsigned int shift;
> +};
> +
> +static inline
> +void hugetlb_pte_init(struct hugetlb_pte *hpte)
> +{
> +	hpte->ptep = NULL;
I agree it does not matter but still will hpte->shift = 0 too be better?
> +}
> +
> +static inline
> +void hugetlb_pte_populate(struct hugetlb_pte *hpte, pte_t *ptep,
> +			  unsigned int shift)
> +{
> +	BUG_ON(!ptep);
> +	hpte->ptep = ptep;
> +	hpte->shift = shift;
> +}
> +
> +static inline
> +unsigned long hugetlb_pte_size(const struct hugetlb_pte *hpte)
> +{
> +	BUG_ON(!hpte->ptep);
> +	return 1UL << hpte->shift;
> +}
> +
> +static inline
> +unsigned long hugetlb_pte_mask(const struct hugetlb_pte *hpte)
> +{
> +	BUG_ON(!hpte->ptep);
> +	return ~(hugetlb_pte_size(hpte) - 1);
> +}
> +
> +static inline
> +unsigned int hugetlb_pte_shift(const struct hugetlb_pte *hpte)
> +{
> +	BUG_ON(!hpte->ptep);
> +	return hpte->shift;
> +}
> +
> +static inline
> +bool hugetlb_pte_huge(const struct hugetlb_pte *hpte)
> +{
> +	return !IS_ENABLED(CONFIG_HUGETLB_HIGH_GRANULARITY_MAPPING) ||
> +		hugetlb_pte_shift(hpte) > PAGE_SHIFT;
> +}
> +
> +static inline
> +void hugetlb_pte_copy(struct hugetlb_pte *dest, const struct hugetlb_pte *src)
> +{
> +	dest->ptep = src->ptep;
> +	dest->shift = src->shift;
> +}
> +
> +bool hugetlb_pte_present_leaf(const struct hugetlb_pte *hpte);
> +bool hugetlb_pte_none(const struct hugetlb_pte *hpte);
> +bool hugetlb_pte_none_mostly(const struct hugetlb_pte *hpte);
> +pte_t hugetlb_ptep_get(const struct hugetlb_pte *hpte);
> +void hugetlb_pte_clear(struct mm_struct *mm, const struct hugetlb_pte *hpte,
> +		       unsigned long address);
> +
>   struct hugepage_subpool {
>   	spinlock_t lock;
>   	long count;
> @@ -1130,6 +1192,28 @@ static inline spinlock_t *huge_pte_lock_shift(unsigned int shift,
>   	return ptl;
>   }
>   
> +static inline
> +spinlock_t *hugetlb_pte_lockptr(struct mm_struct *mm, struct hugetlb_pte *hpte)
> +{
> +
> +	BUG_ON(!hpte->ptep);
> +	// Only use huge_pte_lockptr if we are at leaf-level. Otherwise use
> +	// the regular page table lock.
> +	if (hugetlb_pte_none(hpte) || hugetlb_pte_present_leaf(hpte))
> +		return huge_pte_lockptr(hugetlb_pte_shift(hpte),
> +				mm, hpte->ptep);
> +	return &mm->page_table_lock;
> +}
> +
> +static inline
> +spinlock_t *hugetlb_pte_lock(struct mm_struct *mm, struct hugetlb_pte *hpte)
> +{
> +	spinlock_t *ptl = hugetlb_pte_lockptr(mm, hpte);
> +
> +	spin_lock(ptl);
> +	return ptl;
> +}
> +
>   #if defined(CONFIG_HUGETLB_PAGE) && defined(CONFIG_CMA)
>   extern void __init hugetlb_cma_reserve(int order);
>   extern void __init hugetlb_cma_check(void);
> diff --git a/mm/hugetlb.c b/mm/hugetlb.c
> index d6d0d4c03def..1a1434e29740 100644
> --- a/mm/hugetlb.c
> +++ b/mm/hugetlb.c
> @@ -1120,6 +1120,63 @@ static bool vma_has_reserves(struct vm_area_struct *vma, long chg)
>   	return false;
>   }
>   
> +bool hugetlb_pte_present_leaf(const struct hugetlb_pte *hpte)
> +{
> +	pgd_t pgd;
> +	p4d_t p4d;
> +	pud_t pud;
> +	pmd_t pmd;
> +
> +	BUG_ON(!hpte->ptep);
> +	if (hugetlb_pte_size(hpte) >= PGDIR_SIZE) {
> +		pgd = *(pgd_t *)hpte->ptep;

sorry did not understand in these conditions why

hugetlb_pte_size(hpte) >= PGDIR_SIZE. I mean why >= check

and not just == check?

> +		return pgd_present(pgd) && pgd_leaf(pgd);
> +	} else if (hugetlb_pte_size(hpte) >= P4D_SIZE) {
> +		p4d = *(p4d_t *)hpte->ptep;
> +		return p4d_present(p4d) && p4d_leaf(p4d);
> +	} else if (hugetlb_pte_size(hpte) >= PUD_SIZE) {
> +		pud = *(pud_t *)hpte->ptep;
> +		return pud_present(pud) && pud_leaf(pud);
> +	} else if (hugetlb_pte_size(hpte) >= PMD_SIZE) {
> +		pmd = *(pmd_t *)hpte->ptep;
> +		return pmd_present(pmd) && pmd_leaf(pmd);
> +	} else if (hugetlb_pte_size(hpte) >= PAGE_SIZE)
> +		return pte_present(*hpte->ptep);
> +	BUG();
> +}
> +
> +bool hugetlb_pte_none(const struct hugetlb_pte *hpte)
> +{
> +	if (hugetlb_pte_huge(hpte))
> +		return huge_pte_none(huge_ptep_get(hpte->ptep));
> +	return pte_none(ptep_get(hpte->ptep));
> +}
> +
> +bool hugetlb_pte_none_mostly(const struct hugetlb_pte *hpte)
> +{
> +	if (hugetlb_pte_huge(hpte))
> +		return huge_pte_none_mostly(huge_ptep_get(hpte->ptep));
> +	return pte_none_mostly(ptep_get(hpte->ptep));
> +}
> +
> +pte_t hugetlb_ptep_get(const struct hugetlb_pte *hpte)
> +{
> +	if (hugetlb_pte_huge(hpte))
> +		return huge_ptep_get(hpte->ptep);
> +	return ptep_get(hpte->ptep);
> +}
> +
> +void hugetlb_pte_clear(struct mm_struct *mm, const struct hugetlb_pte *hpte,
> +		       unsigned long address)
> +{
> +	BUG_ON(!hpte->ptep);
> +	unsigned long sz = hugetlb_pte_size(hpte);
> +
> +	if (sz > PAGE_SIZE)
> +		return huge_pte_clear(mm, address, hpte->ptep, sz);

just for cosistency something like above?

if (hugetlb_pte_huge(hpte))
+		return huge_pte_clear
;

> +	return pte_clear(mm, address, hpte->ptep);
> +}
> +
>   static void enqueue_huge_page(struct hstate *h, struct page *page)
>   {
>   	int nid = page_to_nid(page);