From nobody Sun Dec 28 03:08:01 2025 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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 04247C4167B for ; Wed, 13 Dec 2023 22:42:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1442908AbjLMWmV (ORCPT ); Wed, 13 Dec 2023 17:42:21 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:33614 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235514AbjLMWmB (ORCPT ); Wed, 13 Dec 2023 17:42:01 -0500 Received: from mail-yw1-x1141.google.com (mail-yw1-x1141.google.com [IPv6:2607:f8b0:4864:20::1141]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3AB3FD4F; Wed, 13 Dec 2023 14:41:45 -0800 (PST) Received: by mail-yw1-x1141.google.com with SMTP id 00721157ae682-5e2b8f480b3so333707b3.0; Wed, 13 Dec 2023 14:41:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1702507303; x=1703112103; darn=vger.kernel.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=dcLZQlPIPx6ZuAQyXEt76xksXRJVFm+Duc3RLeJjB9Q=; b=hxBUWXFNfy3skJ8PdCUNMJ3KLMFVFPMqYjGau3ms2G9Ic6YYv0pkfNgApjfc/8mPoN IOB48CZW/mvAseL4yUq/fxdpYjeBZ7scWcTvVK84SJjkRw5znYmELbOCwbciUjbaGBQK G7cxAzI0SZ1jf41RtFv6hA8z+PokwsuzviHGirJoNFV8fTYUxz/Zi+tVrvEvJ6Z6gpC0 KcaJjajpA6k1mNgd/dqe9kz7l1eLveNGHRKBMdh15fPzM6Ed0HstQHmyCW4f0DsCFQex rPYOWfKpbSfSDGCHQuCKvD8wPX3zTz9kMvHNI3imW5bLSFPioxTxkmuWGVQS0qe4P7Ee Nk/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1702507303; x=1703112103; 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=dcLZQlPIPx6ZuAQyXEt76xksXRJVFm+Duc3RLeJjB9Q=; b=Lm6Ortp2tQF4R7N2oBsjVyM6rIH7E0/fAIqwBf/FB9NN7S93wsLy6AcfZ1orfpOYem 9z5hk6y67aTvNzgyw/A28vM77H1JU0BxiXNJKXyMvPodpU48J/kbAYrYRFiCFq6jrU+y XxmVbVt0ZO8I0Pe1x5cKLLV4noqd6+L9wZ90kvk25JrMZyWom9BWcxJLT6oq8bFt+oF2 dLqrFHv0DcE71NtZs3tl2sy8RZdwEu+FY8VKuZuIwhCrAZO9Z8TyBK6Kdeb94jzUp/3f 5SGCCXZ1yauyFJ2Oenc64zUDi1QITsqvtMRHHpaujgBUUaIkBZK/f3N6YPn1byl9aDee XXxw== X-Gm-Message-State: AOJu0YxAl+6B5Iw6iajjihEwXo+XQmtqykwfjWTF/myOsT5w8lOirNsi zXUyQ4j0yyydL82ygtUAoA== X-Google-Smtp-Source: AGHT+IE0YJgXEg+UWPKESrg+QohqAIPQo5bH6znCqFxfa0y0nkt+0/Ay/tyeMlQaWWHJtbOPp9QKbw== X-Received: by 2002:a05:690c:3382:b0:5e0:66ef:bca5 with SMTP id fl2-20020a05690c338200b005e066efbca5mr4871579ywb.40.1702507302762; Wed, 13 Dec 2023 14:41:42 -0800 (PST) Received: from fedora.mshome.net (pool-173-79-56-208.washdc.fios.verizon.net. [173.79.56.208]) by smtp.gmail.com with ESMTPSA id v4-20020a818504000000b005d9729068f5sm5050583ywf.42.2023.12.13.14.41.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Dec 2023 14:41:42 -0800 (PST) From: Gregory Price X-Google-Original-From: Gregory Price To: linux-mm@kvack.org Cc: linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-api@vger.kernel.org, x86@kernel.org, akpm@linux-foundation.org, arnd@arndb.de, tglx@linutronix.de, luto@kernel.org, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, mhocko@kernel.org, tj@kernel.org, ying.huang@intel.com, gregory.price@memverge.com, corbet@lwn.net, rakie.kim@sk.com, hyeongtak.ji@sk.com, honggyu.kim@sk.com, vtavarespetr@micron.com, peterz@infradead.org, jgroves@micron.com, ravis.opensrc@micron.com, sthanneeru@micron.com, emirakhur@micron.com, Hasan.Maruf@amd.com, seungjun.ha@samsung.com Subject: [PATCH v3 11/11] mm/mempolicy: extend set_mempolicy2 and mbind2 to support weighted interleave Date: Wed, 13 Dec 2023 17:41:18 -0500 Message-Id: <20231213224118.1949-12-gregory.price@memverge.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20231213224118.1949-1-gregory.price@memverge.com> References: <20231213224118.1949-1-gregory.price@memverge.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Extend set_mempolicy2 and mbind2 to support weighted interleave, and demonstrate the extensibility of the mpol_args structure. To support weighted interleave we add interleave weight fields to the following structures: Kernel Internal: (include/linux/mempolicy.h) struct mempolicy { /* task-local weights to apply to weighted interleave */ unsigned char weights[MAX_NUMNODES]; } struct mempolicy_args { /* Optional: interleave weights for MPOL_WEIGHTED_INTERLEAVE */ unsigned char *il_weights; /* of size MAX_NUMNODES */ } UAPI: (/include/uapi/linux/mempolicy.h) struct mpol_args { /* Optional: interleave weights for MPOL_WEIGHTED_INTERLEAVE */ unsigned char *il_weights; /* of size pol_max_nodes */ } The task-local weights are a single, one-dimensional array of weights that apply to all possible nodes on the system. If a node is set in the mempolicy nodemask, the weight in `il_weights` must be >=3D 1, otherwise set_mempolicy2() will return -EINVAL. If a node is not set in pol_nodemask, the weight will default to `1` in the task policy. The default value of `1` is required to handle the situation where a task migrates to a set of nodes for which weights were not set (up to and including the local numa node). For example, a migrated task whose nodemask changes entirely will have all its weights defaulted back to `1`, or if the nodemask changes to include a mix of nodes that were not previously accounted for - the weighted interleave may be suboptimal. If migrations are expected, a task should prefer not to use task-local interleave weights, and instead utilize the global settings for natural re-weighting on migration. To support global vs local weighting, we add the kernel-internal flag: MPOL_F_GWEIGHT (1 << 5) /* Utilize global weights */ This flag is set when il_weights is omitted by set_mempolicy2(), or when MPOL_WEIGHTED_INTERLEAVE is set by set_mempolicy(). This internal mode_flag dictates whether global weights or task-local weights are utilized by the the various weighted interleave functions: * weighted_interleave_nodes * weighted_interleave_nid * alloc_pages_bulk_array_weighted_interleave if (pol->flags & MPOL_F_GWEIGHT) pol_weights =3D iw_table; else pol_weights =3D pol->wil.weights; To simplify creations and duplication of mempolicies, the weights are added as a structure directly within mempolicy. This allows the existing logic in __mpol_dup to copy the weights without additional allocations: if (old =3D=3D current->mempolicy) { task_lock(current); *new =3D *old; task_unlock(current); } else *new =3D *old Suggested-by: Rakie Kim Suggested-by: Hyeongtak Ji Suggested-by: Honggyu Kim Suggested-by: Vinicius Tavares Petrucci Signed-off-by: Gregory Price Co-developed-by: Rakie Kim Signed-off-by: Rakie Kim Co-developed-by: Hyeongtak Ji Signed-off-by: Hyeongtak Ji Co-developed-by: Honggyu Kim Signed-off-by: Honggyu Kim Co-developed-by: Vinicius Tavares Petrucci Signed-off-by: Vinicius Tavares Petrucci --- .../admin-guide/mm/numa_memory_policy.rst | 10 ++ include/linux/mempolicy.h | 2 + include/uapi/linux/mempolicy.h | 2 + mm/mempolicy.c | 129 +++++++++++++++++- 4 files changed, 139 insertions(+), 4 deletions(-) diff --git a/Documentation/admin-guide/mm/numa_memory_policy.rst b/Document= ation/admin-guide/mm/numa_memory_policy.rst index 99e1f732cade..0e91efe9e769 100644 --- a/Documentation/admin-guide/mm/numa_memory_policy.rst +++ b/Documentation/admin-guide/mm/numa_memory_policy.rst @@ -254,6 +254,8 @@ MPOL_WEIGHTED_INTERLEAVE This mode operates the same as MPOL_INTERLEAVE, except that interleaving behavior is executed based on weights set in /sys/kernel/mm/mempolicy/weighted_interleave/ + when configured to utilize global weights, or based on task-local + weights configured with set_mempolicy2(2) or mbind2(2). =20 Weighted interleave allocations pages on nodes according to their weight. For example if nodes [0,1] are weighted [5,2] @@ -261,6 +263,13 @@ MPOL_WEIGHTED_INTERLEAVE 2 pages allocated on node1. This can better distribute data according to bandwidth on heterogeneous memory systems. =20 + When utilizing task-local weights, weights are not rebalanced + in the event of a task migration. If a weight has not been + explicitly set for a node set in the new nodemask, the + value of that weight defaults to "1". For this reason, if + migrations are expected or possible, users should consider + utilizing global interleave weights. + NUMA memory policy supports the following optional mode flags: =20 MPOL_F_STATIC_NODES @@ -514,6 +523,7 @@ Extended Mempolicy Arguments:: __u16 mode_flags; __s32 home_node; /* mbind2: policy home node */ __aligned_u64 pol_nodes; /* nodemask pointer */ + __aligned_u64 il_weights; /* u8 buf of size pol_maxnodes */ __u64 pol_maxnodes; __s32 policy_node; /* get_mempolicy2: policy node information */ }; diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h index aeac19dfc2b6..387c5c418a66 100644 --- a/include/linux/mempolicy.h +++ b/include/linux/mempolicy.h @@ -58,6 +58,7 @@ struct mempolicy { /* Weighted interleave settings */ struct { unsigned char cur_weight; + unsigned char weights[MAX_NUMNODES]; } wil; }; =20 @@ -70,6 +71,7 @@ struct mempolicy_args { unsigned short mode_flags; /* policy mode flags */ int home_node; /* mbind: use MPOL_MF_HOME_NODE */ nodemask_t *policy_nodes; /* get/set/mbind */ + unsigned char *il_weights; /* for mode MPOL_WEIGHTED_INTERLEAVE */ int policy_node; /* get: policy node information */ }; =20 diff --git a/include/uapi/linux/mempolicy.h b/include/uapi/linux/mempolicy.h index ec1402dae35b..16fedf966166 100644 --- a/include/uapi/linux/mempolicy.h +++ b/include/uapi/linux/mempolicy.h @@ -33,6 +33,7 @@ struct mpol_args { __u16 mode_flags; __s32 home_node; /* mbind2: policy home node */ __aligned_u64 pol_nodes; + __aligned_u64 il_weights; /* size: pol_maxnodes * sizeof(char) */ __u64 pol_maxnodes; __s32 policy_node; /* get_mempolicy: policy node info */ }; @@ -75,6 +76,7 @@ struct mpol_args { #define MPOL_F_SHARED (1 << 0) /* identify shared policies */ #define MPOL_F_MOF (1 << 3) /* this policy wants migrate on fault */ #define MPOL_F_MORON (1 << 4) /* Migrate On protnone Reference On Node */ +#define MPOL_F_GWEIGHT (1 << 5) /* Utilize global weights */ =20 /* * These bit locations are exposed in the vm.zone_reclaim_mode sysctl diff --git a/mm/mempolicy.c b/mm/mempolicy.c index 68ea8e177217..15d047098429 100644 --- a/mm/mempolicy.c +++ b/mm/mempolicy.c @@ -271,6 +271,7 @@ static struct mempolicy *mpol_new(struct mempolicy_args= *args) unsigned short mode =3D args->mode; unsigned short flags =3D args->mode_flags; nodemask_t *nodes =3D args->policy_nodes; + int node; =20 if (mode =3D=3D MPOL_DEFAULT) { if (nodes && !nodes_empty(*nodes)) @@ -297,6 +298,19 @@ static struct mempolicy *mpol_new(struct mempolicy_arg= s *args) (flags & MPOL_F_STATIC_NODES) || (flags & MPOL_F_RELATIVE_NODES)) return ERR_PTR(-EINVAL); + } else if (mode =3D=3D MPOL_WEIGHTED_INTERLEAVE) { + /* weighted interleave requires a nodemask and weights > 0 */ + if (nodes_empty(*nodes)) + return ERR_PTR(-EINVAL); + if (args->il_weights) { + node =3D first_node(*nodes); + while (node !=3D MAX_NUMNODES) { + if (!args->il_weights[node]) + return ERR_PTR(-EINVAL); + node =3D next_node(node, *nodes); + } + } else if (!(args->mode_flags & MPOL_F_GWEIGHT)) + return ERR_PTR(-EINVAL); } else if (nodes_empty(*nodes)) return ERR_PTR(-EINVAL); =20 @@ -309,6 +323,17 @@ static struct mempolicy *mpol_new(struct mempolicy_arg= s *args) policy->home_node =3D args->home_node; policy->wil.cur_weight =3D 0; =20 + if (policy->mode =3D=3D MPOL_WEIGHTED_INTERLEAVE && args->il_weights) { + policy->wil.cur_weight =3D 0; + /* Minimum weight value is always 1 */ + memset(policy->wil.weights, 1, MAX_NUMNODES); + node =3D first_node(*nodes); + while (node !=3D MAX_NUMNODES) { + policy->wil.weights[node] =3D args->il_weights[node]; + node =3D next_node(node, *nodes); + } + } + return policy; } =20 @@ -937,6 +962,17 @@ static void do_get_mempolicy_nodemask(struct mempolicy= *pol, nodemask_t *nmask) } } =20 +static void do_get_mempolicy_il_weights(struct mempolicy *pol, + unsigned char weights[MAX_NUMNODES]) +{ + if (pol->mode !=3D MPOL_WEIGHTED_INTERLEAVE) + memset(weights, 0, MAX_NUMNODES); + else if (pol->flags & MPOL_F_GWEIGHT) + memcpy(weights, iw_table, MAX_NUMNODES); + else + memcpy(weights, pol->wil.weights, MAX_NUMNODES); +} + /* Retrieve NUMA policy for a VMA assocated with a given address */ static long do_get_vma_mempolicy(unsigned long addr, int *addr_node, struct mempolicy_args *args) @@ -973,6 +1009,9 @@ static long do_get_vma_mempolicy(unsigned long addr, i= nt *addr_node, if (args->policy_nodes) do_get_mempolicy_nodemask(pol, args->policy_nodes); =20 + if (args->il_weights) + do_get_mempolicy_il_weights(pol, args->il_weights); + if (pol !=3D &default_policy) { mpol_put(pol); mpol_cond_put(pol); @@ -999,6 +1038,9 @@ static long do_get_task_mempolicy(struct mempolicy_arg= s *args) if (args->policy_nodes) do_get_mempolicy_nodemask(pol, args->policy_nodes); =20 + if (args->il_weights) + do_get_mempolicy_il_weights(pol, args->il_weights); + return 0; } =20 @@ -1521,6 +1563,9 @@ static long kernel_mbind(unsigned long start, unsigne= d long len, if (err) return err; =20 + if (mode & MPOL_WEIGHTED_INTERLEAVE) + mode_flags |=3D MPOL_F_GWEIGHT; + memset(&margs, 0, sizeof(margs)); margs.mode =3D lmode; margs.mode_flags =3D mode_flags; @@ -1611,6 +1656,8 @@ SYSCALL_DEFINE5(mbind2, unsigned long, start, unsigne= d long, len, struct mempolicy_args margs; nodemask_t policy_nodes; unsigned long __user *nodes_ptr; + unsigned char weights[MAX_NUMNODES]; + unsigned char __user *weights_ptr; int err; =20 if (!start || !len) @@ -1643,6 +1690,23 @@ SYSCALL_DEFINE5(mbind2, unsigned long, start, unsign= ed long, len, return err; margs.policy_nodes =3D &policy_nodes; =20 + if (kargs.mode =3D=3D MPOL_WEIGHTED_INTERLEAVE) { + weights_ptr =3D u64_to_user_ptr(kargs.il_weights); + if (weights_ptr) { + err =3D copy_struct_from_user(weights, + sizeof(weights), + weights_ptr, + kargs.pol_maxnodes); + if (err) + return err; + margs.il_weights =3D weights; + } else { + margs.il_weights =3D NULL; + margs.mode_flags |=3D MPOL_F_GWEIGHT; + } + } else + margs.il_weights =3D NULL; + return do_mbind(untagged_addr(start), len, &margs, flags); } =20 @@ -1664,6 +1728,9 @@ static long kernel_set_mempolicy(int mode, const unsi= gned long __user *nmask, if (err) return err; =20 + if (mode & MPOL_WEIGHTED_INTERLEAVE) + mode_flags |=3D MPOL_F_GWEIGHT; + memset(&args, 0, sizeof(args)); args.mode =3D lmode; args.mode_flags =3D mode_flags; @@ -1687,6 +1754,8 @@ SYSCALL_DEFINE3(set_mempolicy2, struct mpol_args __us= er *, uargs, size_t, usize, int err; nodemask_t policy_nodemask; unsigned long __user *nodes_ptr; + unsigned char weights[MAX_NUMNODES]; + unsigned char __user *weights_ptr; =20 if (flags) return -EINVAL; @@ -1712,6 +1781,20 @@ SYSCALL_DEFINE3(set_mempolicy2, struct mpol_args __u= ser *, uargs, size_t, usize, } else margs.policy_nodes =3D NULL; =20 + if (kargs.mode =3D=3D MPOL_WEIGHTED_INTERLEAVE && kargs.il_weights) { + weights_ptr =3D u64_to_user_ptr(kargs.il_weights); + err =3D copy_struct_from_user(weights, + sizeof(weights), + weights_ptr, + kargs.pol_maxnodes); + if (err) + return err; + margs.il_weights =3D weights; + } else { + margs.il_weights =3D NULL; + margs.mode_flags |=3D MPOL_F_GWEIGHT; + } + return do_set_mempolicy(&margs); } =20 @@ -1914,17 +1997,25 @@ SYSCALL_DEFINE4(get_mempolicy2, struct mpol_args __= user *, uargs, size_t, usize, int err; nodemask_t policy_nodemask; unsigned long __user *nodes_ptr; + unsigned char __user *weights_ptr; + unsigned char weights[MAX_NUMNODES]; =20 if (flags & ~(MPOL_F_ADDR)) return -EINVAL; =20 /* initialize any memory liable to be copied to userland */ memset(&margs, 0, sizeof(margs)); + memset(weights, 0, sizeof(weights)); =20 err =3D copy_struct_from_user(&kargs, sizeof(kargs), uargs, usize); if (err) return -EINVAL; =20 + if (kargs.il_weights) + margs.il_weights =3D weights; + else + margs.il_weights =3D NULL; + margs.policy_nodes =3D kargs.pol_nodes ? &policy_nodemask : NULL; if (flags & MPOL_F_ADDR) err =3D do_get_vma_mempolicy(untagged_addr(addr), NULL, &margs); @@ -1946,6 +2037,13 @@ SYSCALL_DEFINE4(get_mempolicy2, struct mpol_args __u= ser *, uargs, size_t, usize, return err; } =20 + if (kargs.mode =3D=3D MPOL_WEIGHTED_INTERLEAVE && kargs.il_weights) { + weights_ptr =3D u64_to_user_ptr(kargs.il_weights); + err =3D copy_to_user(weights_ptr, weights, kargs.pol_maxnodes); + if (err) + return err; + } + return copy_to_user(uargs, &kargs, usize) ? -EFAULT : 0; } =20 @@ -2062,13 +2160,18 @@ static unsigned int weighted_interleave_nodes(struc= t mempolicy *policy) { unsigned int next; struct task_struct *me =3D current; + unsigned char next_weight; =20 next =3D next_node_in(me->il_prev, policy->nodes); if (next =3D=3D MAX_NUMNODES) return next; =20 - if (!policy->wil.cur_weight) - policy->wil.cur_weight =3D iw_table[next]; + if (!policy->wil.cur_weight) { + next_weight =3D (policy->flags & MPOL_F_GWEIGHT) ? + iw_table[next] : + policy->wil.weights[next]; + policy->wil.cur_weight =3D next_weight ? next_weight : 1; + } =20 policy->wil.cur_weight--; if (!policy->wil.cur_weight) @@ -2142,6 +2245,7 @@ static unsigned int weighted_interleave_nid(struct me= mpolicy *pol, pgoff_t ilx) nodemask_t nodemask =3D pol->nodes; unsigned int target, weight_total =3D 0; int nid; + unsigned char *pol_weights; unsigned char weights[MAX_NUMNODES]; unsigned char weight; =20 @@ -2153,8 +2257,13 @@ static unsigned int weighted_interleave_nid(struct m= empolicy *pol, pgoff_t ilx) return nid; =20 /* Then collect weights on stack and calculate totals */ + if (pol->flags & MPOL_F_GWEIGHT) + pol_weights =3D iw_table; + else + pol_weights =3D pol->wil.weights; + for_each_node_mask(nid, nodemask) { - weight =3D iw_table[nid]; + weight =3D pol_weights[nid]; weight_total +=3D weight; weights[nid] =3D weight; } @@ -2552,6 +2661,7 @@ static unsigned long alloc_pages_bulk_array_weighted_= interleave(gfp_t gfp, unsigned long nr_allocated; unsigned long rounds; unsigned long node_pages, delta; + unsigned char *pol_weights; unsigned char weight; unsigned char weights[MAX_NUMNODES]; unsigned int weight_total =3D 0; @@ -2565,9 +2675,14 @@ static unsigned long alloc_pages_bulk_array_weighted= _interleave(gfp_t gfp, =20 nnodes =3D nodes_weight(nodes); =20 + if (pol->flags & MPOL_F_GWEIGHT) + pol_weights =3D iw_table; + else + pol_weights =3D pol->wil.weights; + /* Collect weights and save them on stack so they don't change */ for_each_node_mask(node, nodes) { - weight =3D iw_table[node]; + weight =3D pol_weights[node]; weight_total +=3D weight; weights[node] =3D weight; } @@ -3092,6 +3207,7 @@ void mpol_shared_policy_init(struct shared_policy *sp= , struct mempolicy *mpol) { int ret; struct mempolicy_args margs; + unsigned char weights[MAX_NUMNODES]; =20 sp->root =3D RB_ROOT; /* empty tree =3D=3D default mempolicy */ rwlock_init(&sp->lock); @@ -3109,6 +3225,11 @@ void mpol_shared_policy_init(struct shared_policy *s= p, struct mempolicy *mpol) margs.mode_flags =3D mpol->flags; margs.policy_nodes =3D &mpol->w.user_nodemask; margs.home_node =3D NUMA_NO_NODE; + if (margs.mode =3D=3D MPOL_WEIGHTED_INTERLEAVE && + !(margs.mode_flags & MPOL_F_GWEIGHT)) { + memcpy(weights, mpol->wil.weights, sizeof(weights)); + margs.il_weights =3D weights; + } =20 /* contextualize the tmpfs mount point mempolicy to this file */ npol =3D mpol_new(&margs); --=20 2.39.1