[lkml]   [2012]   [May]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
    Patch in this message
    Subject[PATCH 05/17] mm: allow PF_MEMALLOC from softirq context
    This is needed to allow network softirq packet processing to make
    use of PF_MEMALLOC.

    Currently softirq context cannot use PF_MEMALLOC due to it not being
    associated with a task, and therefore not having task flags to fiddle
    with - thus the gfp to alloc flag mapping ignores the task flags when
    in interrupts (hard or soft) context.

    Allowing softirqs to make use of PF_MEMALLOC therefore requires some
    trickery. This patch borrows the task flags from whatever process happens
    to be preempted by the softirq. It then modifies the gfp to alloc flags
    mapping to not exclude task flags in softirq context, and modify the
    softirq code to save, clear and restore the PF_MEMALLOC flag.

    The save and clear, ensures the preempted task's PF_MEMALLOC flag
    doesn't leak into the softirq. The restore ensures a softirq's
    PF_MEMALLOC flag cannot leak back into the preempted process. This
    should be safe due to the following reasons

    Softirqs can run on multiple CPUs sure but the same task should not be
    executing the same softirq code. Neither should the softirq
    handler be preempted by any other softirq handler so the flags
    should not leak to an unrelated softirq.

    Softirqs re-enable hardware interrupts in __do_softirq() so can be
    preempted by hardware interrupts so PF_MEMALLOC is inherited
    by the hard IRQ. However, this is similar to a process in
    reclaim being preempted by a hardirq. While PF_MEMALLOC is
    set, gfp_to_alloc_flags() distinguishes between hard and
    soft irqs and avoids giving a hardirq the ALLOC_NO_WATERMARKS

    If the softirq is deferred to ksoftirq then its flags may be used
    instead of a normal tasks but as the softirq cannot be preempted,
    the PF_MEMALLOC flag does not leak to other code by accident.

    [ Document why PF_MEMALLOC is safe]
    Signed-off-by: Peter Zijlstra <>
    Signed-off-by: Mel Gorman <>
    include/linux/sched.h | 7 +++++++
    kernel/softirq.c | 9 +++++++++
    mm/page_alloc.c | 6 +++++-
    3 files changed, 21 insertions(+), 1 deletion(-)

    diff --git a/include/linux/sched.h b/include/linux/sched.h
    index 81a173c..b5efaf4 100644
    --- a/include/linux/sched.h
    +++ b/include/linux/sched.h
    @@ -1913,6 +1913,13 @@ static inline void rcu_copy_process(struct task_struct *p)


    +static inline void tsk_restore_flags(struct task_struct *task,
    + unsigned long orig_flags, unsigned long flags)
    + task->flags &= ~flags;
    + task->flags |= orig_flags & flags;
    #ifdef CONFIG_SMP
    extern void do_set_cpus_allowed(struct task_struct *p,
    const struct cpumask *new_mask);
    diff --git a/kernel/softirq.c b/kernel/softirq.c
    index 671f959..b73e681 100644
    --- a/kernel/softirq.c
    +++ b/kernel/softirq.c
    @@ -210,6 +210,14 @@ asmlinkage void __do_softirq(void)
    __u32 pending;
    int max_restart = MAX_SOFTIRQ_RESTART;
    int cpu;
    + unsigned long old_flags = current->flags;
    + /*
    + * Mask out PF_MEMALLOC s current task context is borrowed for the
    + * softirq. A softirq handled such as network RX might set PF_MEMALLOC
    + * again if the socket is related to swap
    + */
    + current->flags &= ~PF_MEMALLOC;

    pending = local_softirq_pending();
    @@ -265,6 +273,7 @@ restart:

    + tsk_restore_flags(current, old_flags, PF_MEMALLOC);

    #ifndef __ARCH_HAS_DO_SOFTIRQ
    diff --git a/mm/page_alloc.c b/mm/page_alloc.c
    index 8a63620..15aebd285 100644
    --- a/mm/page_alloc.c
    +++ b/mm/page_alloc.c
    @@ -2211,7 +2211,11 @@ gfp_to_alloc_flags(gfp_t gfp_mask)
    if (likely(!(gfp_mask & __GFP_NOMEMALLOC))) {
    if (gfp_mask & __GFP_MEMALLOC)
    alloc_flags |= ALLOC_NO_WATERMARKS;
    - else if (likely(!(gfp_mask & __GFP_NOMEMALLOC)) && !in_interrupt())
    + else if (in_serving_softirq() && (current->flags & PF_MEMALLOC))
    + alloc_flags |= ALLOC_NO_WATERMARKS;
    + else if (!in_interrupt() &&
    + ((current->flags & PF_MEMALLOC) ||
    + unlikely(test_thread_flag(TIF_MEMDIE))))
    alloc_flags |= ALLOC_NO_WATERMARKS;


     \ /
      Last update: 2012-05-17 18:21    [W:0.049 / U:11.588 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site