From patchwork Wed Feb 12 17:47:00 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 13972259 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 75439C021A0 for ; Wed, 12 Feb 2025 17:47:17 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 0A22E6B0093; Wed, 12 Feb 2025 12:47:17 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 052DC6B0095; Wed, 12 Feb 2025 12:47:17 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E0ED76B0096; Wed, 12 Feb 2025 12:47:16 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id C03E86B0093 for ; Wed, 12 Feb 2025 12:47:16 -0500 (EST) Received: from smtpin28.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id 7562BA0379 for ; Wed, 12 Feb 2025 17:47:16 +0000 (UTC) X-FDA: 83112024072.28.301ED37 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) by imf02.hostedemail.com (Postfix) with ESMTP id 91B1D80014 for ; Wed, 12 Feb 2025 17:47:14 +0000 (UTC) Authentication-Results: imf02.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=jhrlyu03; spf=pass (imf02.hostedemail.com: domain of alexei.starovoitov@gmail.com designates 209.85.214.181 as permitted sender) smtp.mailfrom=alexei.starovoitov@gmail.com; dmarc=pass (policy=none) header.from=gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1739382434; 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-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=ZcDqEp0sdulY57w8+974+V84oF4S+MilCZmcAMnl5T8=; b=RNA/cCeYAuAIxU4bQQDRtq2IfJPYRONKUbp200jIHneH3suBiD9gb4Jdlcd3Y1Uv9fPP3s EyttOM4297cUwcfwUVTdJJmERYvydAHkLgT/zqliFtrrxn6Rkv0MFD0N1kaugahSsYMuOw SmWnszELnm5sEdT9r8jKjarj9s1HPXA= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1739382434; a=rsa-sha256; cv=none; b=TpBkffAfny5waCWK8IlTQMUPJG78GK7zvs0LY2DTe26/Nwtvy96ZUxhxtYdfz+y3al3vUa biA/ZibYBc7iu2CvaCABMsu0JRA9ZF1I3vxo9EOWop45NbeQDVjYL6JY360msfZtEScHBz efYzHuOjoUTuQCpnV+y/SfJv9kBlr6M= ARC-Authentication-Results: i=1; imf02.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=jhrlyu03; spf=pass (imf02.hostedemail.com: domain of alexei.starovoitov@gmail.com designates 209.85.214.181 as permitted sender) smtp.mailfrom=alexei.starovoitov@gmail.com; dmarc=pass (policy=none) header.from=gmail.com Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-21f2339dcfdso19706815ad.1 for ; Wed, 12 Feb 2025 09:47:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1739382433; x=1739987233; darn=kvack.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ZcDqEp0sdulY57w8+974+V84oF4S+MilCZmcAMnl5T8=; b=jhrlyu03aktzmhgB5ss/nxtedAa1oP6xu1Oh2fVzW1eFEOKBKBKulvrTKc0BIzkUua dbmRU/HOxgeACCN/vpCphbLcvPcRoVKt0ER+jWBGblMyb1M4wd+3kI0egG3khdAcvovc uIDnXfj6sDuWDRE92DPRuBfGROfyTJKQTU9qO3NHbE8ZE+tiNIUW0hZy3qqlWCZ37FEf ZQ9PmuXfwVFbpUR29rIApOCiFX6iSOYZuW/ZW+ohodHLxPQVhgWzAf3j5lBlF6lzgcSa R1NJBvecXx0QUeMzQSN5le8UeO7wnv1GTdXFi6kGPJA3/yooYDbcUdXZF5KmhC1+S2KX MD9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739382433; x=1739987233; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ZcDqEp0sdulY57w8+974+V84oF4S+MilCZmcAMnl5T8=; b=I0LZUlUYhetMcXjh9fvw2keuBoQY1uLtP+aroiKUMcEutW/N247fCujkvcRX7zFaNU 0d+TXjJtX4a6DTyqmP7hbR08nOLttjShFj4hsWVbR6qsUcI4YGxn1P9hwYH+ykYFTBD6 ojjD+PVBQeEaCHJB9QT6+yN967yy5H/VDDp6uDmUQpCue/VJViQsCshGJdjc7THJK6p/ 6Q8jeyuTHCpHMSF86ia793kD/EKJYxUNck5RkVqxqPRZpGnUI7oBLK04ngS185vHG72T NrfsrFT4XXqkgluP4NJl2BcxaEhOSXgrL1dAXtGBwlyyOg1pkm8JUcWwG5D6q7kJsD2I qz+w== X-Forwarded-Encrypted: i=1; AJvYcCV0JdD4cH45Gt+Kkb4RLkcPST1PPklnbW/h3Tolcn7ht7MIfQKN79oDATOH7vD4QG/jeQo327AnuQ==@kvack.org X-Gm-Message-State: AOJu0YzE/l21i7BUkwbwjFA2t3fudlxLmdyhS7r+m/rrDBqFQl/pMS5b RptVv4xBLAhlZrOhClFI/uEc8LFxAaER8wU/6foc+PauKMjmk6On X-Gm-Gg: ASbGncs7ruq1ZVWkY+m+dS8TEtdS2bDgS5c3R4unaEa6ZBBaNIFJmrNThIKhnhW6SJ/ yNcpkJJ9DIYtYJav6EtYHh12AQW3c0k7yiI9NzkfS31d7WBoF2Y2g0h/de1T7aeNpqBl+t3qDli giWyb8ZGZqpIgRRrgunX8s2OqpsJ46RZqXmu9Li89Yrp1Zi5BRjI8d2WMb3LtaA4EC6uaoXMm8e JVbBoCLVUHDQe6wvxOlpYsGsMMwnwp8RieTlgJ80kCNrygXWH8IEOjCljm5WrR9w9UmPaUo6JOI PxNi3M9mH0Zet+J21dV1a0uPztCUWOcKRUL+SQQbMDhO5Q== X-Google-Smtp-Source: AGHT+IGiz7lPxFiFSSCtFNzPA8nthkoVk2uvweVCB4Zudmmc+mzIhBfhSZ/Vst38614VBFH4Hr8CXg== X-Received: by 2002:a17:903:3d04:b0:21f:5e6f:a406 with SMTP id d9443c01a7336-220d2112aa1mr3048445ad.20.1739382433389; Wed, 12 Feb 2025 09:47:13 -0800 (PST) Received: from ast-mac.thefacebook.com ([2620:10d:c090:500::4:c330]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2fbf9ab0233sm1792313a91.44.2025.02.12.09.47.11 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Wed, 12 Feb 2025 09:47:12 -0800 (PST) From: Alexei Starovoitov To: bpf@vger.kernel.org Cc: andrii@kernel.org, memxor@gmail.com, akpm@linux-foundation.org, peterz@infradead.org, vbabka@suse.cz, bigeasy@linutronix.de, rostedt@goodmis.org, houtao1@huawei.com, hannes@cmpxchg.org, mhocko@suse.com, willy@infradead.org, tglx@linutronix.de, jannh@google.com, tj@kernel.org, linux-mm@kvack.org, kernel-team@fb.com Subject: [PATCH bpf-next v7 1/6] mm, bpf: Introduce try_alloc_pages() for opportunistic page allocation Date: Wed, 12 Feb 2025 09:47:00 -0800 Message-Id: <20250212174705.44492-2-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.5 (Apple Git-154) In-Reply-To: <20250212174705.44492-1-alexei.starovoitov@gmail.com> References: <20250212174705.44492-1-alexei.starovoitov@gmail.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 91B1D80014 X-Rspamd-Server: rspam07 X-Stat-Signature: hq5dcjq9sseozfiqs5cx41rk9t9m1jmp X-HE-Tag: 1739382434-356040 X-HE-Meta: U2FsdGVkX192vQYfFa7YUyRaxbgMEZzxNZMvqM+wCKeBjcR5R1RitfcyRd13afMzufTJtMvpzu0r9I/g3U5kIJ2TNLnP2yU7ZMTGBSANlPBVy1V2FzKQfaL1UZ8/ACH6xCHfTD5+V8h2rs9uS08SCVWS81Su+2e6fFnvqokKjeV3VJe0MzTCeJz6MPuiJDCxANvc7c4oCO++0IHnqiNsBs99G7fVL1nGDCg4xNV8OnssDkNuxjYkWfUZEfq3yqpBMA+Ai0Z7gr5fRWvFvIstC4t2GtXyH0XVN4lBcvkjenIdp4XCCH5NSj1LZMcLPIKJtmXZ7PAOzKVMTxbU1XFKEAT3wPbTAEqy2X/I3xyKGPZDw+RTH2ZGLwswLwTMP8BtoQtJ6+GTl9RcRbwC8vvVN8Ke4kxYAzQZvmTkIYBJUlMobs5OOBJLeg20wUa6nPYsCTZaoM2o3ZBFPO6tbhw2eBCtXKfw+2DnlOnbq6DJ3aThtEbEVpshEO63DrhI5UGdJQzmx4PKoXlvXLuhbd3Goz+eUtBvtauFgrg1ITQ9eToXqKfRe1CriMuuVvkz12mU1jVeM8O8/xuWMWnPV1VpXGCiVtZzsKXWftcLxF2l0LZpLJm+RYw2/91tQ2ZqtGcx3zXmguis0F9Vf/DyZDCeGoZhu+jF8rwDZC6JrAHUMCIjrv+Wk2xdx+k/b8Mf9YSodBRf/dI+UAFnB6W1MOCS4IPYUilIyQOpMpgzigywlRqjY9wrShfa1YEZ189GYRaDVaMoSoT5HIxo7wPq7evA+vdayvcfeNRv53VtAOoMjjVU3y41cj1BRqpo7jwXTpkr99yOztFbPCt4JbvHcNdQSIxdkjoeSzOzExJKK9CLhUwOZMvnPWgbBJocNDYrl7/7OrfSsBRRKQlUDl9VBR+rLl11nu+Pu9kNXEA4dL9DH2TrZkPIOQfZYoWy80dDetMQ0Q0lMn4dpYdiR3enwhI lrs4kAO8 2ubfqAPWVKLZGoDRzQtjetIQJ9l+owaA/Bnz3qhrt8BNheUSYm5VWIbg2QCBk4HhqLpqTc9CLMQtnvt/u0DyZKJb+g2VmW5c2bsREJgwfYp+rmdZW/mR804HKts62d5XtQ7nokPAzNu8uzOPfTm3tfPF9BWCM+10+vH2qYyQHl4JvOsFaMNk3nS7aYOILEViguPCJnj7Gwe6XyAKGu5GtzQHTEAkwSiLC4GzJJ9+hVi6E91/50LlsWHvnZ/ut88EqT605OppvucAmipWS9X2Fu178sJd9C5KrbT/jzX26VwIUkhPqtqgkICSKMR03RhpQIjEPK4S1QznfAjs7rzSswUtloMx/0Dcz27t9Mispn/dT1KXgi4ma4RDKzWKA9HFRTm851otICD6KVY8pYVEcFptQ5RpVqS2i9HaeocuWdzQ9wAOYmCCjHkoyMUhnNasEEz//bP33h0Cv5cVT0mKc1bFQl8pGzHwsYK5OF6/ApBAu7LW1aOKEUTKeTo+MeZrRqWiUnt7gtW3EANBu9WRnpJJqnd+7nR0+EqAPLi4+oRuECmilFyfyyCtcDds5m9gNv7az7dIOBYI8Lw1244W952h3y9PUyxDFfzU08T3rJFbNbEQ= 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: From: Alexei Starovoitov Tracing BPF programs execute from tracepoints and kprobes where running context is unknown, but they need to request additional memory. The prior workarounds were using pre-allocated memory and BPF specific freelists to satisfy such allocation requests. Instead, introduce gfpflags_allow_spinning() condition that signals to the allocator that running context is unknown. Then rely on percpu free list of pages to allocate a page. try_alloc_pages() -> get_page_from_freelist() -> rmqueue() -> rmqueue_pcplist() will spin_trylock to grab the page from percpu free list. If it fails (due to re-entrancy or list being empty) then rmqueue_bulk()/rmqueue_buddy() will attempt to spin_trylock zone->lock and grab the page from there. spin_trylock() is not safe in PREEMPT_RT when in NMI or in hard IRQ. Bailout early in such case. The support for gfpflags_allow_spinning() mode for free_page and memcg comes in the next patches. This is a first step towards supporting BPF requirements in SLUB and getting rid of bpf_mem_alloc. That goal was discussed at LSFMM: https://lwn.net/Articles/974138/ Acked-by: Michal Hocko Acked-by: Vlastimil Babka Acked-by: Sebastian Andrzej Siewior Reviewed-by: Shakeel Butt Signed-off-by: Alexei Starovoitov --- include/linux/gfp.h | 22 ++++++++++ lib/stackdepot.c | 5 ++- mm/internal.h | 1 + mm/page_alloc.c | 104 ++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 127 insertions(+), 5 deletions(-) diff --git a/include/linux/gfp.h b/include/linux/gfp.h index b0fe9f62d15b..82bfb65b8d15 100644 --- a/include/linux/gfp.h +++ b/include/linux/gfp.h @@ -39,6 +39,25 @@ static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags) return !!(gfp_flags & __GFP_DIRECT_RECLAIM); } +static inline bool gfpflags_allow_spinning(const gfp_t gfp_flags) +{ + /* + * !__GFP_DIRECT_RECLAIM -> direct claim is not allowed. + * !__GFP_KSWAPD_RECLAIM -> it's not safe to wake up kswapd. + * All GFP_* flags including GFP_NOWAIT use one or both flags. + * try_alloc_pages() is the only API that doesn't specify either flag. + * + * This is stronger than GFP_NOWAIT or GFP_ATOMIC because + * those are guaranteed to never block on a sleeping lock. + * Here we are enforcing that the allocation doesn't ever spin + * on any locks (i.e. only trylocks). There is no high level + * GFP_$FOO flag for this use in try_alloc_pages() as the + * regular page allocator doesn't fully support this + * allocation mode. + */ + return !(gfp_flags & __GFP_RECLAIM); +} + #ifdef CONFIG_HIGHMEM #define OPT_ZONE_HIGHMEM ZONE_HIGHMEM #else @@ -347,6 +366,9 @@ static inline struct page *alloc_page_vma_noprof(gfp_t gfp, } #define alloc_page_vma(...) alloc_hooks(alloc_page_vma_noprof(__VA_ARGS__)) +struct page *try_alloc_pages_noprof(int nid, unsigned int order); +#define try_alloc_pages(...) alloc_hooks(try_alloc_pages_noprof(__VA_ARGS__)) + extern unsigned long get_free_pages_noprof(gfp_t gfp_mask, unsigned int order); #define __get_free_pages(...) alloc_hooks(get_free_pages_noprof(__VA_ARGS__)) diff --git a/lib/stackdepot.c b/lib/stackdepot.c index 245d5b416699..377194969e61 100644 --- a/lib/stackdepot.c +++ b/lib/stackdepot.c @@ -591,7 +591,8 @@ depot_stack_handle_t stack_depot_save_flags(unsigned long *entries, depot_stack_handle_t handle = 0; struct page *page = NULL; void *prealloc = NULL; - bool can_alloc = depot_flags & STACK_DEPOT_FLAG_CAN_ALLOC; + bool allow_spin = gfpflags_allow_spinning(alloc_flags); + bool can_alloc = (depot_flags & STACK_DEPOT_FLAG_CAN_ALLOC) && allow_spin; unsigned long flags; u32 hash; @@ -630,7 +631,7 @@ depot_stack_handle_t stack_depot_save_flags(unsigned long *entries, prealloc = page_address(page); } - if (in_nmi()) { + if (in_nmi() || !allow_spin) { /* We can never allocate in NMI context. */ WARN_ON_ONCE(can_alloc); /* Best effort; bail if we fail to take the lock. */ diff --git a/mm/internal.h b/mm/internal.h index 9826f7dce607..6c3c664aa346 100644 --- a/mm/internal.h +++ b/mm/internal.h @@ -1174,6 +1174,7 @@ unsigned int reclaim_clean_pages_from_list(struct zone *zone, #define ALLOC_NOFRAGMENT 0x0 #endif #define ALLOC_HIGHATOMIC 0x200 /* Allows access to MIGRATE_HIGHATOMIC */ +#define ALLOC_TRYLOCK 0x400 /* Only use spin_trylock in allocation path */ #define ALLOC_KSWAPD 0x800 /* allow waking of kswapd, __GFP_KSWAPD_RECLAIM set */ /* Flags that allow allocations below the min watermark. */ diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 01eab25edf89..a82bc67abbdb 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -2306,7 +2306,11 @@ static int rmqueue_bulk(struct zone *zone, unsigned int order, unsigned long flags; int i; - spin_lock_irqsave(&zone->lock, flags); + if (!spin_trylock_irqsave(&zone->lock, flags)) { + if (unlikely(alloc_flags & ALLOC_TRYLOCK)) + return 0; + spin_lock_irqsave(&zone->lock, flags); + } for (i = 0; i < count; ++i) { struct page *page = __rmqueue(zone, order, migratetype, alloc_flags); @@ -2906,7 +2910,11 @@ struct page *rmqueue_buddy(struct zone *preferred_zone, struct zone *zone, do { page = NULL; - spin_lock_irqsave(&zone->lock, flags); + if (!spin_trylock_irqsave(&zone->lock, flags)) { + if (unlikely(alloc_flags & ALLOC_TRYLOCK)) + return NULL; + spin_lock_irqsave(&zone->lock, flags); + } if (alloc_flags & ALLOC_HIGHATOMIC) page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC); if (!page) { @@ -4511,7 +4519,12 @@ static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order, might_alloc(gfp_mask); - if (should_fail_alloc_page(gfp_mask, order)) + /* + * Don't invoke should_fail logic, since it may call + * get_random_u32() and printk() which need to spin_lock. + */ + if (!(*alloc_flags & ALLOC_TRYLOCK) && + should_fail_alloc_page(gfp_mask, order)) return false; *alloc_flags = gfp_to_alloc_flags_cma(gfp_mask, *alloc_flags); @@ -7028,3 +7041,88 @@ static bool __free_unaccepted(struct page *page) } #endif /* CONFIG_UNACCEPTED_MEMORY */ + +/** + * try_alloc_pages_noprof - opportunistic reentrant allocation from any context + * @nid - node to allocate from + * @order - allocation order size + * + * Allocates pages of a given order from the given node. This is safe to + * call from any context (from atomic, NMI, and also reentrant + * allocator -> tracepoint -> try_alloc_pages_noprof). + * Allocation is best effort and to be expected to fail easily so nobody should + * rely on the success. Failures are not reported via warn_alloc(). + * See always fail conditions below. + * + * Return: allocated page or NULL on failure. + */ +struct page *try_alloc_pages_noprof(int nid, unsigned int order) +{ + /* + * Do not specify __GFP_DIRECT_RECLAIM, since direct claim is not allowed. + * Do not specify __GFP_KSWAPD_RECLAIM either, since wake up of kswapd + * is not safe in arbitrary context. + * + * These two are the conditions for gfpflags_allow_spinning() being true. + * + * Specify __GFP_NOWARN since failing try_alloc_pages() is not a reason + * to warn. Also warn would trigger printk() which is unsafe from + * various contexts. We cannot use printk_deferred_enter() to mitigate, + * since the running context is unknown. + * + * Specify __GFP_ZERO to make sure that call to kmsan_alloc_page() below + * is safe in any context. Also zeroing the page is mandatory for + * BPF use cases. + * + * Though __GFP_NOMEMALLOC is not checked in the code path below, + * specify it here to highlight that try_alloc_pages() + * doesn't want to deplete reserves. + */ + gfp_t alloc_gfp = __GFP_NOWARN | __GFP_ZERO | __GFP_NOMEMALLOC; + unsigned int alloc_flags = ALLOC_TRYLOCK; + struct alloc_context ac = { }; + struct page *page; + + /* + * In PREEMPT_RT spin_trylock() will call raw_spin_lock() which is + * unsafe in NMI. If spin_trylock() is called from hard IRQ the current + * task may be waiting for one rt_spin_lock, but rt_spin_trylock() will + * mark the task as the owner of another rt_spin_lock which will + * confuse PI logic, so return immediately if called form hard IRQ or + * NMI. + * + * Note, irqs_disabled() case is ok. This function can be called + * from raw_spin_lock_irqsave region. + */ + if (IS_ENABLED(CONFIG_PREEMPT_RT) && (in_nmi() || in_hardirq())) + return NULL; + if (!pcp_allowed_order(order)) + return NULL; + +#ifdef CONFIG_UNACCEPTED_MEMORY + /* Bailout, since try_to_accept_memory_one() needs to take a lock */ + if (has_unaccepted_memory()) + return NULL; +#endif + /* Bailout, since _deferred_grow_zone() needs to take a lock */ + if (deferred_pages_enabled()) + return NULL; + + if (nid == NUMA_NO_NODE) + nid = numa_node_id(); + + prepare_alloc_pages(alloc_gfp, order, nid, NULL, &ac, + &alloc_gfp, &alloc_flags); + + /* + * Best effort allocation from percpu free list. + * If it's empty attempt to spin_trylock zone->lock. + */ + page = get_page_from_freelist(alloc_gfp, order, alloc_flags, &ac); + + /* Unlike regular alloc_pages() there is no __alloc_pages_slowpath(). */ + + trace_mm_page_alloc(page, order, alloc_gfp, ac.migratetype); + kmsan_alloc_page(page, order, alloc_gfp); + return page; +}