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 X-Spam-Level: X-Spam-Status: No, score=-8.4 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 83671C2BA19 for ; Tue, 14 Apr 2020 15:38:44 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 1CB6D20678 for ; Tue, 14 Apr 2020 15:38:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=oneplus.com header.i=@oneplus.com header.b="GQAJ7/wr" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1CB6D20678 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=oneplus.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id C2B5B8E0024; Tue, 14 Apr 2020 11:38:43 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id BDC5B8E0007; Tue, 14 Apr 2020 11:38:43 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id ACBE58E0024; Tue, 14 Apr 2020 11:38:43 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0068.hostedemail.com [216.40.44.68]) by kanga.kvack.org (Postfix) with ESMTP id 8F0908E0007 for ; Tue, 14 Apr 2020 11:38:43 -0400 (EDT) Received: from smtpin08.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with ESMTP id 5A4AD21E4 for ; Tue, 14 Apr 2020 15:38:43 +0000 (UTC) X-FDA: 76706868126.08.sign76_6911784958806 X-HE-Tag: sign76_6911784958806 X-Filterd-Recvd-Size: 19031 Received: from APC01-SG2-obe.outbound.protection.outlook.com (mail-eopbgr1310103.outbound.protection.outlook.com [40.107.131.103]) by imf11.hostedemail.com (Postfix) with ESMTP for ; Tue, 14 Apr 2020 15:38:41 +0000 (UTC) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eql8YhAcWmZ1uDMFtjF1BFa2HgFiQh+gKjSvYQZPD5om0ICayv2M4FTcKkssiNFouRFbDfaZyrIOeI3B/vHI/vhEeQjdCZgwJZXaSlkcWqI5qTMXGIzt7f3bPpbJAYe/0mV2zuYDEFeStkeQFnjnyyuDx9cjF+eTXZiaNrUH66p1ENTkvuCvZqaz2KBPCJiXU2hwu6Fx+OObq0LrkIpnIsRiCF/1bPhMTr9YuvVP5s3FcRR17XWxIckyKkThwaQEnM2zeCBs348gjKyG2YALclfHKTHH3q27nzdYuwZre6qiDcUczYYvuHB5i78lAOArlu+MihcwwOOTThSwtkGgTw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=9goTfm5PpE4ZJ1da9gk0fCCejUk5/yLP14MX7jgz4jg=; b=UBxGimR3NCgEVQC973dUR0gpjxpKipEMqoDfsNk8IPCUZkxQEfKziBSpOz3Qjxw6jQFsTAfEqmgPYXKNc0mmIFP2XtLO/NOLis+9z2F4c/d2TxLAtcVNBYpOfsgwyxJQiSeawiwgB7qlwURUdAmWkbwt1GNPgqisvrQSbbNTcaGIIoCv0d6MYdHsU9gyD6cZF0s6wTdojrrI/ijje//0KKILN2HKzqUTNBz32dl1o9RvdSnkqxJxgDwrCRIXNGjtGsoffhQXCSpElkpW58n9PBribLQk4LbKSRR+AJr4Ia9w5+lspPe2x+jalgvKX968iHyNTlUckjIdOhzHgmiywA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oneplus.com; dmarc=pass action=none header.from=oneplus.com; dkim=pass header.d=oneplus.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oneplus.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=9goTfm5PpE4ZJ1da9gk0fCCejUk5/yLP14MX7jgz4jg=; b=GQAJ7/wrd+Eqafc8klzYyyu38rJuesufYhQxcwMvXzsjjU9kVlf2NWKtGRV2SRtcQ5KAHG0hx8ozoE112HBenQY2EQUSAxdVrO8vaMJuDwUD9Hl5jY1VEHxgVCcs/tgySVujytO0qlExmazw8oWb2ZNsnmaEjWp9NkLBs5s+rEc= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=prathu.baronia@oneplus.com; Received: from SG2PR04MB3093.apcprd04.prod.outlook.com (20.177.91.75) by SG2PR04MB2283.apcprd04.prod.outlook.com (20.177.1.148) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2900.26; Tue, 14 Apr 2020 15:38:38 +0000 Received: from SG2PR04MB3093.apcprd04.prod.outlook.com ([fe80::140:687e:956d:8070]) by SG2PR04MB3093.apcprd04.prod.outlook.com ([fe80::140:687e:956d:8070%6]) with mapi id 15.20.2900.026; Tue, 14 Apr 2020 15:38:37 +0000 Date: Tue, 14 Apr 2020 21:08:32 +0530 From: Prathu Baronia To: alexander.duyck@gmail.com, chintan.pandya@oneplus.com, ying.huang@intel.com, mhocko@suse.com, akpm@linux-foundation.com, linux-mm@kvack.org, gregkh@linuxfoundation.com, gthelen@google.com, jack@suse.cz, ken.lin@oneplus.com, gasine.xu@oneplus.com Subject: [PATCH v2] mm: Optimized hugepage zeroing & copying from user Message-ID: <20200414153829.GA15230@oneplus.com> Content-Type: text/plain; charset=utf-8 Content-Disposition: inline User-Agent: Mutt/1.9.4 (2018-02-28) X-ClientProxiedBy: HK0PR03CA0101.apcprd03.prod.outlook.com (2603:1096:203:b0::17) To SG2PR04MB3093.apcprd04.prod.outlook.com (2603:1096:4:6d::11) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from oneplus.com (183.83.136.195) by HK0PR03CA0101.apcprd03.prod.outlook.com (2603:1096:203:b0::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2921.25 via Frontend Transport; Tue, 14 Apr 2020 15:38:35 +0000 X-Originating-IP: [183.83.136.195] X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 31f83fa6-3a7d-404f-5b2a-08d7e089e641 X-MS-TrafficTypeDiagnostic: SG2PR04MB2283:|SG2PR04MB2283: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:3383; X-Forefront-PRVS: 0373D94D15 X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:SG2PR04MB3093.apcprd04.prod.outlook.com;PTR:;CAT:NONE;SFTY:;SFS:(10019020)(4636009)(376002)(346002)(366004)(39850400004)(396003)(136003)(66946007)(55016002)(33656002)(52116002)(86362001)(5660300002)(186003)(16526019)(6666004)(478600001)(44832011)(6636002)(1076003)(30864003)(316002)(7696005)(36756003)(2616005)(8886007)(2906002)(8936002)(66476007)(26005)(8676002)(81156014)(956004)(66556008)(921003)(1121003);DIR:OUT;SFP:1102; Received-SPF: None (protection.outlook.com: oneplus.com does not designate permitted sender hosts) X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: VbzqzK92xaMwnQLpup5vFyRnN6R6VcuLOnE1LgFlJUHzmhHfxX0x3cV3kUR4mzFYhqCEtbMxbIGK/rZkgaT9VFXi2Lrdp0yt1G84NjZ80cZeYwBYTz5ti8q2UbZaUhTgJLOYDJMUpFnxqFTAUslGKr7AzQ9x6uYI2HH9dbJK9DFJZyHpwLflgvox+xV/oA2QZCr+q5PPQ6RbaPSqalJKdKBWTPIPQq6pD7Exq8JQi6m0cIGUMSzvMydpcgiIi8Vg/rm+zqc6y92LWxTXZv4H7HnEkHnRYCYA5zkEBx8mInUhzNojXL21M2n/wQPCHwnge1xsRMRz1eb1+Cp/o93WwKviPuAR1/mwD5Kw8TmZtv6Z/QpEunBMZFlMMMtDkfoyepX0aEAj9vwQV1hGJvpNA8xkcsB4gYh/gmTBS4HS2RZFPpGxaUY4N85rGS7+X9u5FSePwhmxWZwvyPL4BDQoRBtejmhvOFkaqnIyKUJWBDIdDAqcIyohdue1YVRRHaCM X-MS-Exchange-AntiSpam-MessageData: 8cbLY6Zuc36yprTm7s6u+voOLuCUcN8iPODi3SUxatIF8pSmK916eaLS6qihYPdM2ZabGZxH24S5B4DC7NYV4GRykvdPNoqT+JPxP6xS7KGcsGk2NwOdhBZEEJVUbkhCkdQqSJA0sLwMVS23zF9Qeg== X-OriginatorOrg: oneplus.com X-MS-Exchange-CrossTenant-Network-Message-Id: 31f83fa6-3a7d-404f-5b2a-08d7e089e641 X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Apr 2020 15:38:37.6777 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 0423909d-296c-463e-ab5c-e5853a518df8 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: pRKVrys0Z7Q2efJ93ge4SgaBoLyc0HYqW/5rS6qDVUPHBRS977Bi0MNpZ9ZMWwBcsbbKpBJXPuEjL+NTmuCQQoUSDJ8s+FWsMC2AaxZ3NrA= X-MS-Exchange-Transport-CrossTenantHeadersStamped: SG2PR04MB2283 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: In !HIGHMEM cases, specially in 64-bit architectures, we don't need temp mapping of pages. Hence, k(map|unmap)_atomic() acts as nothing more than multiple barrier() calls, for example for a 2MB hugepage in clear_huge_page() these are called 512 times i.e. to map and unmap each subpage that means in total 2048 barrier calls. This called for optimization. Simply getting VADDR from page does the job for us. This also applies to the copy_user_huge_page() function. With kmap_atomic() out of the picture we can use memset and memcpy for sizes larger than 4K. Instead of a left-right approach to access the target subpage, getting the VADDR from the page and using memset directly in a simple experiment we observed a 64% improvement in time over the current approach. With this(v2) patch we observe 65.85%(under controlled conditions) improvement over the current approach. Currently process_huge_page iterates over subpages in a left-right manner targeting the subpage that was accessed to be processed at last to keep the cache hot around the faulting address. This caused a latency issue because as we observed in the case of ARM64 the reverse access is much slower than forward access and much much slower than oneshot access because of the pre-fetcher behaviour. The following simple userspace experiment to allocate 100MB(total_size) of pages and writing to it using memset(oneshot), forward order loop and a reverse order loop gave us a good insight:- -------------------------------------------------------------------------------- Test code snippet: -------------------------------------------------------------------------------- /* One shot memset */ memset (r, 0xd, total_size); /* traverse in forward order */ for (j = 0; j < total_pages; j++) { memset (q + (j * SZ_4K), 0xc, SZ_4K); } /* traverse in reverse order */ for (i = 0; i < total_pages; i++) { memset (p + total_size - (i + 1) * SZ_4K, 0xb, SZ_4K); } ---------------------------------------------------------------------- Results: ---------------------------------------------------------------------- Results for ARM64 target (SM8150 , CPU0 & 6 are online, running at max frequency) All numbers are mean of 100 iterations. Variation is ignorable. ---------------------------------------------------------------------- - Oneshot : 3389.26 us - Forward : 8876.16 us - Reverse : 18157.6 us ---------------------------------------------------------------------- ---------------------------------------------------------------------- Results for x86-64 (Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz, only CPU 0 in max frequency, DDR also running at max frequency.) All numbers are mean of 100 iterations. Variation is ignorable. ---------------------------------------------------------------------- - Oneshot : 3203.49 us - Forward : 5766.46 us - Reverse : 5187.86 us ---------------------------------------------------------------------- Hence refactor the function process_huge_page() to process the hugepage in oneshot manner using oneshot version of routines clear_huge_page() and copy_user_huge_page() for !HIGHMEM cases. These oneshot routines do zeroing using memset and copying using memcpy since we observed after extensive testing on ARM64 and some local testing on x86 memset and memcpy routines are highly optimized and with the above data points in hand it made sense to utilize them directly instead of looping over all subpages. These oneshot routines do zero and copy with a small offset(default kept as 32KB for now) to keep the cache hot around the faulting address. This offset is dependent on the cache size and hence can be kept as a tunable configuration option. The below profiles are for ARM64(SM8150, CPU0 & 6 are online, running at max frequency, DDR also running at max frequency.) ---------------------------------------------------------------------- Ftrace Results(clear_huge_page_profile()): ---------------------------------------------------------------------- All timing values are in microseconds(us) ---------------------------------------------------------------------- Base: - CPU0: - Samples: 95 - Mean: 242.099 us - Std dev: 45.0096 us - CPU6: - Samples: 61 - Mean: 258.372 us - Std dev: 22.0754 us ---------------------------------------------------------------------- v2: - CPU0: - Samples: 63 - Mean: 112.297 us - Std dev: 0.310989 us - CPU6: - Samples: 99 - Mean: 67.359 us - Std dev: 1.15997 us ---------------------------------------------------------------------- Signed-off-by: Prathu Baronia Reported-by: Chintan Pandya --- mm/Kconfig | 13 +++++ mm/memory.c | 159 +++++++++++++++++++++++----------------------------- 2 files changed, 83 insertions(+), 89 deletions(-) diff --git a/mm/Kconfig b/mm/Kconfig index ab80933be65f..31c169432276 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -739,4 +739,17 @@ config ARCH_HAS_HUGEPD config MAPPING_DIRTY_HELPERS bool +config HOT_CACHE_RANGE + int + default 8 + range 1 512 + help + This value can be tweaked to make the cache hot around the + faulting address of the hugepage, primarily to make the + clearing and copying of hugepage more cache friendly. It is + proportionate to the cache size and should be kept bigger + for bigger caches for better performance. + This value is in terms of number of 4KB pages. + Don't change it if you are not sure. + endmenu diff --git a/mm/memory.c b/mm/memory.c index e8bfdf0d9d1d..e7b16e76e794 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -4655,6 +4655,11 @@ EXPORT_SYMBOL(__might_fault); #endif #if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_HUGETLBFS) +struct copy_subpage_arg { + struct page *dst; + struct page *src; + struct vm_area_struct *vma; +}; /* * Process all subpages of the specified huge page with the specified * operation. The target subpage will be processed last to keep its @@ -4662,137 +4667,113 @@ EXPORT_SYMBOL(__might_fault); */ static inline void process_huge_page( unsigned long addr_hint, unsigned int pages_per_huge_page, - void (*process_subpage)(unsigned long addr, int idx, void *arg), + void (*process_subpage)(unsigned long offset, int size, void *arg), void *arg) { - int i, n, base, l; - unsigned long addr = addr_hint & - ~(((unsigned long)pages_per_huge_page << PAGE_SHIFT) - 1); + unsigned long clear_start_addr; + unsigned long addr_base; + unsigned long offset; + unsigned long remaining; + unsigned long huge_page_size = (unsigned long) pages_per_huge_page << PAGE_SHIFT; + struct copy_subpage_arg *general_arg = arg; + + addr_base = addr_hint & ~(huge_page_size - 1); - /* Process target subpage last to keep its cache lines hot */ - might_sleep(); - n = (addr_hint - addr) / PAGE_SIZE; - if (2 * n <= pages_per_huge_page) { - /* If target subpage in first half of huge page */ - base = 0; - l = n; - /* Process subpages at the end of huge page */ - for (i = pages_per_huge_page - 1; i >= 2 * n; i--) { - cond_resched(); - process_subpage(addr + i * PAGE_SIZE, i, arg); - } - } else { - /* If target subpage in second half of huge page */ - base = pages_per_huge_page - 2 * (pages_per_huge_page - n); - l = pages_per_huge_page - n; - /* Process subpages at the begin of huge page */ - for (i = 0; i < base; i++) { - cond_resched(); - process_subpage(addr + i * PAGE_SIZE, i, arg); - } - } /* - * Process remaining subpages in left-right-left-right pattern - * towards the target subpage + * Converting addr_hint into relative & 4KB aligned address */ - for (i = 0; i < l; i++) { - int left_idx = base + i; - int right_idx = base + 2 * l - 1 - i; + offset = (addr_hint - addr_base) & ~(PAGE_SIZE - 1); - cond_resched(); - process_subpage(addr + left_idx * PAGE_SIZE, left_idx, arg); - cond_resched(); - process_subpage(addr + right_idx * PAGE_SIZE, right_idx, arg); + /* + * First, we will attempt to process higher range of addresses + * and lastly we attempt lower range of addresses within a huge + * page. This will make [addr_hint - range, addr_hint + range] + * to be processed in the last. This will keep cache hot around + * addr_hint, which will be helpful in operations further. + */ + clear_start_addr = offset + CONFIG_HOT_CACHE_RANGE*PAGE_SIZE; + if (clear_start_addr < huge_page_size) { + process_subpage(clear_start_addr, huge_page_size - clear_start_addr, general_arg); + remaining = clear_start_addr; + } else { + remaining = huge_page_size; } + + process_subpage(0, remaining, general_arg); } -static void clear_gigantic_page(struct page *page, - unsigned long addr, - unsigned int pages_per_huge_page) +#ifdef CONFIG_HIGHMEM +static void clear_subpage(unsigned long offset, int size, void *arg) { int i; - struct page *p = page; + struct copy_subpage_arg *args = arg; + struct page *p = args->dst + (offset/PAGE_SIZE); might_sleep(); - for (i = 0; i < pages_per_huge_page; - i++, p = mem_map_next(p, page, i)) { + for (i = 0; i < size/PAGE_SIZE; + i++, p = mem_map_next(p, args->dst, i)) { cond_resched(); - clear_user_highpage(p, addr + i * PAGE_SIZE); + clear_user_highpage(p, 0); } } -static void clear_subpage(unsigned long addr, int idx, void *arg) +static void copy_subpage(unsigned long offset, int size, void *arg) { - struct page *page = arg; - - clear_user_highpage(page + idx, addr); -} + int i; + struct copy_subpage_arg *copy_args = arg; + struct page *dst = copy_args->dst + (offset/PAGE_SIZE); + struct page *src = copy_args->src + (offset/PAGE_SIZE); -void clear_huge_page(struct page *page, - unsigned long addr_hint, unsigned int pages_per_huge_page) -{ - unsigned long addr = addr_hint & - ~(((unsigned long)pages_per_huge_page << PAGE_SHIFT) - 1); + for (i = 0; i < size/PAGE_SIZE; ) { + cond_resched(); + copy_user_highpage(dst, src, 0, copy_args->vma); - if (unlikely(pages_per_huge_page > MAX_ORDER_NR_PAGES)) { - clear_gigantic_page(page, addr, pages_per_huge_page); - return; + i++; + dst = mem_map_next(dst, copy_args->dst, i); + src = mem_map_next(src, copy_args->src, i); } +} +#else +static void clear_subpage(unsigned long offset, int size, void *arg) +{ + struct copy_subpage_arg *args = arg; + unsigned long addr = (unsigned long) page_address(args->dst); - process_huge_page(addr_hint, pages_per_huge_page, clear_subpage, page); + memset((void *) addr + offset, 0x0, size); } -static void copy_user_gigantic_page(struct page *dst, struct page *src, - unsigned long addr, - struct vm_area_struct *vma, - unsigned int pages_per_huge_page) +static void copy_subpage(unsigned long offset, int size, void *arg) { - int i; - struct page *dst_base = dst; - struct page *src_base = src; + struct copy_subpage_arg *copy_args = arg; + unsigned long d_addr = (unsigned long) page_address(copy_args->dst); + unsigned long s_addr = (unsigned long) page_address(copy_args->src); - for (i = 0; i < pages_per_huge_page; ) { - cond_resched(); - copy_user_highpage(dst, src, addr + i*PAGE_SIZE, vma); - - i++; - dst = mem_map_next(dst, dst_base, i); - src = mem_map_next(src, src_base, i); - } + memcpy((void *) d_addr + offset, (void *) s_addr + offset, size); } +#endif -struct copy_subpage_arg { - struct page *dst; - struct page *src; - struct vm_area_struct *vma; -}; - -static void copy_subpage(unsigned long addr, int idx, void *arg) +void clear_huge_page(struct page *page, + unsigned long addr_hint, unsigned int pages_per_huge_page) { - struct copy_subpage_arg *copy_arg = arg; + struct copy_subpage_arg arg = { + .dst = page, + .src = NULL, + .vma = NULL, + }; - copy_user_highpage(copy_arg->dst + idx, copy_arg->src + idx, - addr, copy_arg->vma); + process_huge_page(addr_hint, pages_per_huge_page, clear_subpage, &arg); } void copy_user_huge_page(struct page *dst, struct page *src, unsigned long addr_hint, struct vm_area_struct *vma, unsigned int pages_per_huge_page) { - unsigned long addr = addr_hint & - ~(((unsigned long)pages_per_huge_page << PAGE_SHIFT) - 1); struct copy_subpage_arg arg = { .dst = dst, .src = src, .vma = vma, }; - if (unlikely(pages_per_huge_page > MAX_ORDER_NR_PAGES)) { - copy_user_gigantic_page(dst, src, addr, vma, - pages_per_huge_page); - return; - } - process_huge_page(addr_hint, pages_per_huge_page, copy_subpage, &arg); } -- 2.17.1 -- Prathu Baronia OnePlus RnD