cregit-Linux how code gets into the kernel

Release 4.8 mm/mempolicy.c

Directory: mm
 * Simple NUMA memory policy for the Linux kernel.
 * Copyright 2003,2004 Andi Kleen, SuSE Labs.
 * (C) Copyright 2005 Christoph Lameter, Silicon Graphics, Inc.
 * Subject to the GNU Public License, version 2.
 * NUMA policy allows the user to give hints in which node(s) memory should
 * be allocated.
 * Support four policies per VMA and per process:
 * The VMA policy has priority over the process policy for a page fault.
 * interleave     Allocate memory interleaved over a set of nodes,
 *                with normal fallback if it fails.
 *                For VMA based allocations this interleaves based on the
 *                offset into the backing object or offset into the mapping
 *                for anonymous memory. For process policy an process counter
 *                is used.
 * bind           Only allocate memory on a specific set of nodes,
 *                no fallback.
 *                FIXME: memory is allocated starting with the first node
 *                to the last. It would be better if bind would truly restrict
 *                the allocation to memory nodes instead
 * preferred       Try a specific node first before normal fallback.
 *                As a special case NUMA_NO_NODE here means do the allocation
 *                on the local CPU. This is normally identical to default,
 *                but useful to set in a VMA when you have a non default
 *                process policy.
 * default        Allocate on the local node first, or when on a VMA
 *                use the process policy. This is what Linux always did
 *                in a NUMA aware kernel and still does by, ahem, default.
 * The process policy is applied for most non interrupt memory allocations
 * in that process' context. Interrupts ignore the policies and always
 * try to allocate on the local CPU. The VMA policy is only applied for memory
 * allocations for a VMA in the VM.
 * Currently there are a few corner cases in swapping where the policy
 * is not applied, but the majority should be handled. When process policy
 * is used it is not remembered over swap outs/swap ins.
 * Only the highest zone in the zone hierarchy gets policied. Allocations
 * requesting a lower zone just use default policy. This implies that
 * on systems with highmem kernel lowmem allocation don't get policied.
 * Same with GFP_DMA allocations.
 * For shmfs/tmpfs/hugetlbfs shared memory the policy is shared between
 * all users and remembered even when nobody has memory mapped.

/* Notebook:
   fix mmap readahead to honour policy and enable policy for any page cache
   statistics for bigpages
   global policy for page cache? currently it uses process policy. Requires
   first item above.
   handle mremap for shared memory (currently ignored for the policy)
   grows down?
   make bind policy root only? It can trigger oom much faster and the
   kernel is not always grateful with that.

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/mempolicy.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/hugetlb.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/nodemask.h>
#include <linux/cpuset.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/export.h>
#include <linux/nsproxy.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/compat.h>
#include <linux/swap.h>
#include <linux/seq_file.h>
#include <linux/proc_fs.h>
#include <linux/migrate.h>
#include <linux/ksm.h>
#include <linux/rmap.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/ctype.h>
#include <linux/mm_inline.h>
#include <linux/mmu_notifier.h>
#include <linux/printk.h>

#include <asm/tlbflush.h>
#include <asm/uaccess.h>

#include "internal.h"

/* Internal flags */

/* Skip checks for continuous vmas */

/* Invert check for nodemask */

static struct kmem_cache *policy_cache;

static struct kmem_cache *sn_cache;

/* Highest zone. An specific allocation for a zone below that is not
   policied. */

enum zone_type policy_zone = 0;

 * run-time system-wide default policy => local allocation

static struct mempolicy default_policy = {
	.refcnt = ATOMIC_INIT(1), /* never free it */
	.flags = MPOL_F_LOCAL,

static struct mempolicy preferred_node_policy[MAX_NUMNODES];

struct mempolicy *get_task_policy(struct task_struct *p) { struct mempolicy *pol = p->mempolicy; int node; if (pol) return pol; node = numa_node_id(); if (node != NUMA_NO_NODE) { pol = &preferred_node_policy[node]; /* preferred_node_policy is not initialised early in boot */ if (pol->mode) return pol; } return &default_policy; }


mel gormanmel gorman5075.76%125.00%
oleg nesterovoleg nesterov1319.70%125.00%
jianguo wujianguo wu23.03%125.00%
david rientjesdavid rientjes11.52%125.00%

static const struct mempolicy_operations { int (*create)(struct mempolicy *pol, const nodemask_t *nodes); /* * If read-side task has no lock to protect task->mempolicy, write-side * task will rebind the task->mempolicy by two step. The first step is * setting all the newly nodes, and the second step is cleaning all the * disallowed nodes. In this way, we can avoid finding no node to alloc * page. * If we have a lock to protect task->mempolicy in read-side, we do * rebind directly. * * step: * MPOL_REBIND_ONCE - do rebind work at once * MPOL_REBIND_STEP1 - set all the newly nodes * MPOL_REBIND_STEP2 - clean all the disallowed nodes */ void (*rebind)(struct mempolicy *pol, const nodemask_t *nodes, enum mpol_rebind_step step); } mpol_ops[MPOL_MAX];
static inline int mpol_store_user_nodemask(const struct mempolicy *pol) { return pol->flags & MPOL_MODE_FLAGS; }


david rientjesdavid rientjes1995.00%150.00%
bob liubob liu15.00%150.00%

static void mpol_relative_nodemask(nodemask_t *ret, const nodemask_t *orig, const nodemask_t *rel) { nodemask_t tmp; nodes_fold(tmp, *orig, nodes_weight(*rel)); nodes_onto(*ret, tmp, *rel); }


david rientjesdavid rientjes48100.00%1100.00%

static int mpol_new_interleave(struct mempolicy *pol, const nodemask_t *nodes) { if (nodes_empty(*nodes)) return -EINVAL; pol->v.nodes = *nodes; return 0; }


david rientjesdavid rientjes40100.00%1100.00%

static int mpol_new_preferred(struct mempolicy *pol, const nodemask_t *nodes) { if (!nodes) pol->flags |= MPOL_F_LOCAL; /* local allocation */ else if (nodes_empty(*nodes)) return -EINVAL; /* no allowed nodes */ else pol->v.preferred_node = first_node(*nodes); return 0; }


david rientjesdavid rientjes5594.83%150.00%
lee schermerhornlee schermerhorn35.17%150.00%

static int mpol_new_bind(struct mempolicy *pol, const nodemask_t *nodes) { if (nodes_empty(*nodes)) return -EINVAL; pol->v.nodes = *nodes; return 0; }


david rientjesdavid rientjes3895.00%150.00%
zhihui zhangzhihui zhang25.00%150.00%

/* * mpol_set_nodemask is called after mpol_new() to set up the nodemask, if * any, for the new policy. mpol_new() has already validated the nodes * parameter with respect to the policy mode and flags. But, we need to * handle an empty nodemask with MPOL_PREFERRED here. * * Must be called holding task's alloc_lock to protect task's mems_allowed * and mempolicy. May also be called holding the mmap_semaphore for write. */
static int mpol_set_nodemask(struct mempolicy *pol, const nodemask_t *nodes, struct nodemask_scratch *nsc) { int ret; /* if mode is MPOL_DEFAULT, pol is NULL. This is right. */ if (pol == NULL) return 0; /* Check N_MEMORY */ nodes_and(nsc->mask1, cpuset_current_mems_allowed, node_states[N_MEMORY]); VM_BUG_ON(!nodes); if (pol->mode == MPOL_PREFERRED && nodes_empty(*nodes)) nodes = NULL; /* explicit local allocation */ else { if (pol->flags & MPOL_F_RELATIVE_NODES) mpol_relative_nodemask(&nsc->mask2, nodes, &nsc->mask1); else nodes_and(nsc->mask2, *nodes, nsc->mask1); if (mpol_store_user_nodemask(pol)) pol->w.user_nodemask = *nodes; else pol->w.cpuset_mems_allowed = cpuset_current_mems_allowed; } if (nodes) ret = mpol_ops[pol->mode].create(pol, &nsc->mask2); else ret = mpol_ops[pol->mode].create(pol, NULL); return ret; }


miao xiemiao xie12869.95%133.33%
kamezawa hiroyukikamezawa hiroyuki5328.96%133.33%
lai jiangshanlai jiangshan21.09%133.33%

/* * This function just creates a new policy, does some check and simple * initialization. You must invoke mpol_set_nodemask() to set nodes. */
static struct mempolicy *mpol_new(unsigned short mode, unsigned short flags, nodemask_t *nodes) { struct mempolicy *policy; pr_debug("setting mode %d flags %d nodes[0] %lx\n", mode, flags, nodes ? nodes_addr(*nodes)[0] : NUMA_NO_NODE); if (mode == MPOL_DEFAULT) { if (nodes && !nodes_empty(*nodes)) return ERR_PTR(-EINVAL); return NULL; } VM_BUG_ON(!nodes); /* * MPOL_PREFERRED cannot be used with MPOL_F_STATIC_NODES or * MPOL_F_RELATIVE_NODES if the nodemask is empty (local allocation). * All other modes require a valid pointer to a non-empty nodemask. */ if (mode == MPOL_PREFERRED) { if (nodes_empty(*nodes)) { if (((flags & MPOL_F_STATIC_NODES) || (flags & MPOL_F_RELATIVE_NODES))) return ERR_PTR(-EINVAL); } } else if (mode == MPOL_LOCAL) { if (!nodes_empty(*nodes)) return ERR_PTR(-EINVAL); mode = MPOL_PREFERRED; } else if (nodes_empty(*nodes)) return ERR_PTR(-EINVAL); policy = kmem_cache_alloc(policy_cache, GFP_KERNEL); if (!policy) return ERR_PTR(-ENOMEM); atomic_set(&policy->refcnt, 1); policy->mode = mode; policy->flags = flags; return policy; }


david rientjesdavid rientjes11051.16%654.55%
andrew mortonandrew morton6630.70%19.09%
peter zijlstrapeter zijlstra2913.49%19.09%
andi kleenandi kleen52.33%19.09%
paul mundtpaul mundt41.86%19.09%
lee schermerhornlee schermerhorn10.47%19.09%

/* Slow path of a mpol destructor. */
void __mpol_put(struct mempolicy *p) { if (!atomic_dec_and_test(&p->refcnt)) return; kmem_cache_free(policy_cache, p); }


lee schermerhornlee schermerhorn29100.00%1100.00%

static void mpol_rebind_default(struct mempolicy *pol, const nodemask_t *nodes, enum mpol_rebind_step step) { }


david rientjesdavid rientjes736.84%225.00%
andrew mortonandrew morton421.05%112.50%
miao xiemiao xie421.05%112.50%
andi kleenandi kleen210.53%225.00%
hugh dickinshugh dickins15.26%112.50%
christoph lameterchristoph lameter15.26%112.50%

/* * step: * MPOL_REBIND_ONCE - do rebind work at once * MPOL_REBIND_STEP1 - set all the newly nodes * MPOL_REBIND_STEP2 - clean all the disallowed nodes */
static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes, enum mpol_rebind_step step) { nodemask_t tmp; if (pol->flags & MPOL_F_STATIC_NODES) nodes_and(tmp, pol->w.user_nodemask, *nodes); else if (pol->flags & MPOL_F_RELATIVE_NODES) mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes); else { /* * if step == 1, we use ->w.cpuset_mems_allowed to cache the * result */ if (step == MPOL_REBIND_ONCE || step == MPOL_REBIND_STEP1) { nodes_remap(tmp, pol->v.nodes, pol->w.cpuset_mems_allowed, *nodes); pol->w.cpuset_mems_allowed = step ? tmp : *nodes; } else if (step == MPOL_REBIND_STEP2) { tmp = pol->w.cpuset_mems_allowed; pol->w.cpuset_mems_allowed = *nodes; } else BUG(); } if (nodes_empty(tmp)) tmp = *nodes; if (step == MPOL_REBIND_STEP1) nodes_or(pol->v.nodes, pol->v.nodes, tmp); else if (step == MPOL_REBIND_ONCE || step == MPOL_REBIND_STEP2) pol->v.nodes = tmp; else BUG(); if (!node_isset(current->il_next, tmp)) { current->il_next = next_node_in(current->il_next, tmp); if (current->il_next >= MAX_NUMNODES) current->il_next = numa_node_id(); } }


david rientjesdavid rientjes12952.02%220.00%
miao xiemiao xie10140.73%110.00%
christoph lameterchristoph lameter124.84%330.00%
andrew mortonandrew morton31.21%220.00%
andi kleenandi kleen20.81%110.00%
hugh dickinshugh dickins10.40%110.00%

static void mpol_rebind_preferred(struct mempolicy *pol, const nodemask_t *nodes, enum mpol_rebind_step step) { nodemask_t tmp; if (pol->flags & MPOL_F_STATIC_NODES) { int node = first_node(pol->w.user_nodemask); if (node_isset(node, *nodes)) { pol->v.preferred_node = node; pol->flags &= ~MPOL_F_LOCAL; } else pol->flags |= MPOL_F_LOCAL; } else if (pol->flags & MPOL_F_RELATIVE_NODES) { mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes); pol->v.preferred_node = first_node(tmp); } else if (!(pol->flags & MPOL_F_LOCAL)) { pol->v.preferred_node = node_remap(pol->v.preferred_node, pol->w.cpuset_mems_allowed, *nodes); pol->w.cpuset_mems_allowed = *nodes; } }


david rientjesdavid rientjes14186.50%360.00%
lee schermerhornlee schermerhorn1811.04%120.00%
miao xiemiao xie42.45%120.00%

/* * mpol_rebind_policy - Migrate a policy to a different set of nodes * * If read-side task has no lock to protect task->mempolicy, write-side * task will rebind the task->mempolicy by two step. The first step is * setting all the newly nodes, and the second step is cleaning all the * disallowed nodes. In this way, we can avoid finding no node to alloc * page. * If we have a lock to protect task->mempolicy in read-side, we do * rebind directly. * * step: * MPOL_REBIND_ONCE - do rebind work at once * MPOL_REBIND_STEP1 - set all the newly nodes * MPOL_REBIND_STEP2 - clean all the disallowed nodes */
static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask, enum mpol_rebind_step step) { if (!pol) return; if (!mpol_store_user_nodemask(pol) && step == MPOL_REBIND_ONCE && nodes_equal(pol->w.cpuset_mems_allowed, *newmask)) return; if (step == MPOL_REBIND_STEP1 && (pol->flags & MPOL_F_REBINDING)) return; if (step == MPOL_REBIND_STEP2 && !(pol->flags & MPOL_F_REBINDING)) BUG(); if (step == MPOL_REBIND_STEP1) pol->flags |= MPOL_F_REBINDING; else if (step == MPOL_REBIND_STEP2) pol->flags &= ~MPOL_F_REBINDING; else if (step >= MPOL_REBIND_NSTEP) BUG(); mpol_ops[pol->mode].rebind(pol, newmask, step); }


miao xiemiao xie7857.35%120.00%
david rientjesdavid rientjes5641.18%240.00%
wang sheng-huiwang sheng-hui10.74%120.00%
lee schermerhornlee schermerhorn10.74%120.00%

/* * Wrapper for mpol_rebind_policy() that just requires task * pointer, and updates task mempolicy. * * Called with task's alloc_lock held. */
void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new, enum mpol_rebind_step step) { mpol_rebind_policy(tsk->mempolicy, new, step); }


david rientjesdavid rientjes2480.00%150.00%
miao xiemiao xie620.00%150.00%

/* * Rebind each vma in mm to new nodemask. * * Call holding a reference to mm. Takes mm->mmap_sem during call. */
void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new) { struct vm_area_struct *vma; down_write(&mm->mmap_sem); for (vma = mm->mmap; vma; vma = vma->vm_next) mpol_rebind_policy(vma->vm_policy, new, MPOL_REBIND_ONCE); up_write(&mm->mmap_sem); }


david rientjesdavid rientjes6096.77%150.00%
miao xiemiao xie23.23%150.00%

static const struct mempolicy_operations mpol_ops[MPOL_MAX] = { [MPOL_DEFAULT] = { .rebind = mpol_rebind_default, }, [MPOL_INTERLEAVE] = { .create = mpol_new_interleave, .rebind = mpol_rebind_nodemask, }, [MPOL_PREFERRED] = { .create = mpol_new_preferred, .rebind = mpol_rebind_preferred, }, [MPOL_BIND] = { .create = mpol_new_bind, .rebind = mpol_rebind_nodemask, }, }; static void migrate_page_add(struct page *page, struct list_head *pagelist, unsigned long flags); struct queue_pages { struct list_head *pagelist; unsigned long flags; nodemask_t *nmask; struct vm_area_struct *prev; }; /* * Scan through pages checking if pages follow certain conditions, * and move them to the pagelist if they do. */
static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end, struct mm_walk *walk) { struct vm_area_struct *vma = walk->vma; struct page *page; struct queue_pages *qp = walk->private; unsigned long flags = qp->flags; int nid, ret; pte_t *pte; spinlock_t *ptl; if (pmd_trans_huge(*pmd)) { ptl = pmd_lock(walk->mm, pmd); if (pmd_trans_huge(*pmd)) { page = pmd_page(*pmd); if (is_huge_zero_page(page)) { spin_unlock(ptl); split_huge_pmd(vma, pmd, addr); } else { get_page(page); spin_unlock(ptl); lock_page(page); ret = split_huge_page(page); unlock_page(page); put_page(page); if (ret) return 0; } } else { spin_unlock(ptl); } } if (pmd_trans_unstable(pmd)) return 0; retry: pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl); for (; addr != end; pte++, addr += PAGE_SIZE) { if (!pte_present(*pte)) continue; page = vm_normal_page(vma, addr, *pte); if (!page) continue; /* * vm_normal_page() filters out zero pages, but there might * still be PageReserved pages to skip, perhaps in a VDSO. */ if (PageReserved(page)) continue; nid = page_to_nid(page); if (node_isset(nid, *qp->nmask) == !!(flags & MPOL_MF_INVERT)) continue; if (PageTransCompound(page)) { get_page(page); pte_unmap_unlock(pte, ptl); lock_page(page); ret = split_huge_page(page); unlock_page(page); put_page(page); /* Failed to split -- skip. */ if (ret) { pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl); continue; } goto retry; } migrate_page_add(page, qp->pagelist, flags); } pte_unmap_unlock(pte - 1, ptl); cond_resched(); return 0; }


kirill a. shutemovkirill a. shutemov17244.79%323.08%
david rientjesdavid rientjes10828.12%17.69%
naoya horiguchinaoya horiguchi8722.66%323.08%
hugh dickinshugh dickins112.86%430.77%
christoph lameterchristoph lameter41.04%17.69%
andrew mortonandrew morton20.52%17.69%

static int queue_pages_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr, unsigned long end, struct mm_walk *walk) { #ifdef CONFIG_HUGETLB_PAGE struct queue_pages *qp = walk->private; unsigned long flags = qp->flags; int nid; struct page *page; spinlock_t *ptl; pte_t entry; ptl = huge_pte_lock(hstate_vma(walk->vma), walk->mm, pte); entry = huge_ptep_get(pte); if (!pte_present(entry)) goto unlock; page = pte_page(entry); nid = page_to_nid(page); if (node_isset(nid, *qp->nmask) == !!(flags & MPOL_MF_INVERT)) goto unlock; /* With MPOL_MF_MOVE, we migrate only unshared hugepage. */ if (flags & (MPOL_MF_MOVE_ALL) || (flags & MPOL_MF_MOVE && page_mapcount(page) == 1)) isolate_huge_page(page, qp->pagelist); unlock: spin_unlock(ptl); #else BUG(); #endif return 0; }


naoya horiguchinaoya horiguchi16992.35%375.00%
kirill a. shutemovkirill a. shutemov147.65%125.00%

#ifdef CONFIG_NUMA_BALANCING /* * This is used to mark a range of virtual addresses to be inaccessible. * These are later cleared by a NUMA hinting fault. Depending on these * faults, pages may be migrated for better NUMA placement. * * This is assuming that NUMA faults are handled using PROT_NONE. If * an architecture makes a different choice, it will need further * changes to the core. */
unsigned long change_prot_numa(struct vm_area_struct *vma, unsigned long addr, unsigned long end) { int nr_updated; nr_updated = change_protection(vma, addr, end, PAGE_NONE, 0, 1); if (nr_updated) count_vm_numa_events(NUMA_PTE_UPDATES, nr_updated); return nr_updated; }


hugh dickinshugh dickins1630.19%112.50%
mel gormanmel gorman1528.30%337.50%
naoya horiguchinaoya horiguchi1324.53%112.50%
andrew mortonandrew morton59.43%112.50%
lee schermerhornlee schermerhorn23.77%112.50%
nick pigginnick piggin23.77%112.50%

static unsigned long change_prot_numa(struct vm_area_struct *vma, unsigned long addr, unsigned long end) { return 0; }


lee schermerhornlee schermerhorn1773.91%133.33%
andrew mortonandrew morton313.04%133.33%
hugh dickinshugh dickins313.04%133.33%

static int queue_pages_test_walk(unsigned long start, unsigned long end, struct mm_walk *walk) { struct vm_area_struct *vma = walk->vma; struct queue_pages *qp = walk->private; unsigned long endvma = vma->vm_end; unsigned long flags = qp->flags; if (!vma_migratable(vma)) return 1; if (endvma > end) endvma = end; if (vma->vm_start > start) start = vma->vm_start; if (!(flags & MPOL_MF_DISCONTIG_OK)) { if (!vma->vm_next && vma->vm_end < end) return -EFAULT; if (qp->prev && qp->prev->vm_end < vma->vm_start) return -EFAULT; } qp->prev = vma; if (flags & MPOL_MF_LAZY) { /* Similar to task_numa_work, skip inaccessible VMAs */ if (!is_vm_hugetlb_page(vma) && (vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)) && !(vma->vm_flags & VM_MIXEDMAP)) change_prot_numa(vma, start, endvma); return 1; } /* queue pages from current vma */ if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) return 0; return 1; }


andrew mortonandrew morton5425.59%110.00%
naoya horiguchinaoya horiguchi5224.64%220.00%
lee schermerhornlee schermerhorn4018.96%110.00%
christoph lameterchristoph lameter219.95%110.00%
liang chenliang chen178.06%110.00%
mel gormanmel gorman157.11%110.00%
andi kleenandi kleen62.84%110.00%
kirill a. shutemovkirill a. shutemov52.37%110.00%
hugh dickinshugh dickins10.47%110.00%

/* * Walk through page tables and collect pages to be migrated. * * If pages found in a given range are on a set of nodes (determined by * @nodes and @flags,) it's isolated and queued to the pagelist which is * passed via @private.) */
static int queue_pages_range(struct mm_struct *mm, unsigned long start, unsigned long end, nodemask_t *nodes, unsigned long flags, struct list_head *pagelist) { struct queue_pages qp = { .pagelist = pagelist, .flags = flags, .nmask = nodes, .prev = NULL, }; struct mm_walk queue_pages_walk = { .hugetlb_entry = queue_pages_hugetlb, .pmd_entry = queue_pages_pte_range, .test_walk = queue_pages_test_walk, .mm = mm, .private = &qp, }; return walk_page_range(start, end, &queue_pages_walk); }


naoya horiguchinaoya horiguchi9291.09%125.00%
andrew mortonandrew morton76.93%125.00%
christoph lameterchristoph lameter10.99%125.00%
andi kleenandi kleen10.99%125.00%

/* * Apply policy to a single VMA * This must be called with the mmap_sem held for writing. */
static int vma_replace_policy(struct vm_area_struct *vma, struct mempolicy *pol) { int err; struct mempolicy *old; struct mempolicy *new; pr_debug("vma %lx-%lx/%lx vm_ops %p vm_file %p set_policy %p\n", vma->vm_start, vma->vm_end, vma->vm_pgoff, vma->vm_ops, vma->vm_file, vma->vm_ops ? vma->vm_ops->set_policy : NULL); new = mpol_dup(pol); if (IS_ERR(new)) return PTR_ERR(new); if (vma->vm_ops && vma->vm_ops->set_policy) { err = vma->vm_ops->set_policy(vma, new); if (err) goto err_out; } old = vma->vm_policy; vma->vm_policy = new; /* protected by mmap_sem */ mpol_put(old); return 0; err_out: mpol_put(new); return err; }


kosaki motohirokosaki motohiro151100.00%2100.00%

/* Step 2: apply policy to a range and do splits. */
static int mbind_range(struct mm_struct *mm, unsigned long start, unsigned long end, struct mempolicy *new_pol) { struct vm_area_struct *next; struct vm_area_struct *prev; struct vm_area_struct *vma; int err = 0; pgoff_t pgoff;