lkml.org 
[lkml]   [2015]   [May]   [11]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 1/7] preempt: Merge preempt_mask.h into preempt.h
    Date
    preempt_mask.h defines all the preempt_count semantics and related
    symbols: preempt, softirq, hardirq, nmi, preempt active, need resched,
    etc...

    preempt.h defines the accessors and mutators of preempt_count.

    But there is a messy dependency game around those two header files:

    * preempt_mask.h includes preempt.h in order to access preempt_count()

    * preempt_mask.h defines all preempt_count semantic and symbols
    except PREEMPT_NEED_RESCHED that is needed by asm/preempt.h
    Thus we need to define it from preempt.h, right before including
    asm/preempt.h, instead of defining it to preempt_mask.h with the
    other preempt_count symbols. Therefore the preempt_count semantics
    happen to be spread out.

    * We plan to introduce preempt_active_[enter,exit]() to consolidate
    preempt_schedule*() code. But we'll need to access both preempt_count
    mutators (preempt_count_add()) and preempt_count symbols
    (PREEMPT_ACTIVE, PREEMPT_OFFSET). The usual place to define preempt
    operations is in preempt.h but then we'll need symbols in
    preempt_mask.h which already includes preempt.h. So we end up with
    a ressource circle dependency.

    Lets merge preempt_mask.h into preempt.h to solve these dependency issues.
    This way we gather semantic symbols and operation definition of
    preempt_count in a single file.

    This is a dumb copy-paste merge. Further merge re-arrangments are
    performed in a subsequent patch to ease review.

    Cc: Ingo Molnar <mingo@kernel.org>
    Cc: Peter Zijlstra <peterz@infradead.org>
    Cc: Thomas Gleixner <tglx@linutronix.de>
    Cc: Linus Torvalds <torvalds@linux-foundation.org>
    Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
    ---
    arch/m68k/include/asm/irqflags.h | 3 -
    include/linux/bottom_half.h | 1 -
    include/linux/hardirq.h | 2 +-
    include/linux/preempt.h | 111 +++++++++++++++++++++++++++++++++++++
    include/linux/preempt_mask.h | 117 ---------------------------------------
    include/linux/sched.h | 2 +-
    lib/radix-tree.c | 2 +-
    7 files changed, 114 insertions(+), 124 deletions(-)
    delete mode 100644 include/linux/preempt_mask.h

    diff --git a/arch/m68k/include/asm/irqflags.h b/arch/m68k/include/asm/irqflags.h
    index a823cd7..b594181 100644
    --- a/arch/m68k/include/asm/irqflags.h
    +++ b/arch/m68k/include/asm/irqflags.h
    @@ -2,9 +2,6 @@
    #define _M68K_IRQFLAGS_H

    #include <linux/types.h>
    -#ifdef CONFIG_MMU
    -#include <linux/preempt_mask.h>
    -#endif
    #include <linux/preempt.h>
    #include <asm/thread_info.h>
    #include <asm/entry.h>
    diff --git a/include/linux/bottom_half.h b/include/linux/bottom_half.h
    index 86c12c9..8fdcb78 100644
    --- a/include/linux/bottom_half.h
    +++ b/include/linux/bottom_half.h
    @@ -2,7 +2,6 @@
    #define _LINUX_BH_H

    #include <linux/preempt.h>
    -#include <linux/preempt_mask.h>

    #ifdef CONFIG_TRACE_IRQFLAGS
    extern void __local_bh_disable_ip(unsigned long ip, unsigned int cnt);
    diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
    index cba442e..4e971fa 100644
    --- a/include/linux/hardirq.h
    +++ b/include/linux/hardirq.h
    @@ -1,7 +1,7 @@
    #ifndef LINUX_HARDIRQ_H
    #define LINUX_HARDIRQ_H

    -#include <linux/preempt_mask.h>
    +#include <linux/preempt.h>
    #include <linux/lockdep.h>
    #include <linux/ftrace_irq.h>
    #include <linux/vtime.h>
    diff --git a/include/linux/preempt.h b/include/linux/preempt.h
    index de83b4e..8cc0338 100644
    --- a/include/linux/preempt.h
    +++ b/include/linux/preempt.h
    @@ -17,6 +17,117 @@

    #include <asm/preempt.h>

    +/*
    + * We put the hardirq and softirq counter into the preemption
    + * counter. The bitmask has the following meaning:
    + *
    + * - bits 0-7 are the preemption count (max preemption depth: 256)
    + * - bits 8-15 are the softirq count (max # of softirqs: 256)
    + *
    + * The hardirq count could in theory be the same as the number of
    + * interrupts in the system, but we run all interrupt handlers with
    + * interrupts disabled, so we cannot have nesting interrupts. Though
    + * there are a few palaeontologic drivers which reenable interrupts in
    + * the handler, so we need more than one bit here.
    + *
    + * PREEMPT_MASK: 0x000000ff
    + * SOFTIRQ_MASK: 0x0000ff00
    + * HARDIRQ_MASK: 0x000f0000
    + * NMI_MASK: 0x00100000
    + * PREEMPT_ACTIVE: 0x00200000
    + */
    +#define PREEMPT_BITS 8
    +#define SOFTIRQ_BITS 8
    +#define HARDIRQ_BITS 4
    +#define NMI_BITS 1
    +
    +#define PREEMPT_SHIFT 0
    +#define SOFTIRQ_SHIFT (PREEMPT_SHIFT + PREEMPT_BITS)
    +#define HARDIRQ_SHIFT (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
    +#define NMI_SHIFT (HARDIRQ_SHIFT + HARDIRQ_BITS)
    +
    +#define __IRQ_MASK(x) ((1UL << (x))-1)
    +
    +#define PREEMPT_MASK (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
    +#define SOFTIRQ_MASK (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
    +#define HARDIRQ_MASK (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
    +#define NMI_MASK (__IRQ_MASK(NMI_BITS) << NMI_SHIFT)
    +
    +#define PREEMPT_OFFSET (1UL << PREEMPT_SHIFT)
    +#define SOFTIRQ_OFFSET (1UL << SOFTIRQ_SHIFT)
    +#define HARDIRQ_OFFSET (1UL << HARDIRQ_SHIFT)
    +#define NMI_OFFSET (1UL << NMI_SHIFT)
    +
    +#define SOFTIRQ_DISABLE_OFFSET (2 * SOFTIRQ_OFFSET)
    +
    +#define PREEMPT_ACTIVE_BITS 1
    +#define PREEMPT_ACTIVE_SHIFT (NMI_SHIFT + NMI_BITS)
    +#define PREEMPT_ACTIVE (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
    +
    +#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
    +#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
    +#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
    + | NMI_MASK))
    +
    +/*
    + * Are we doing bottom half or hardware interrupt processing?
    + * Are we in a softirq context? Interrupt context?
    + * in_softirq - Are we currently processing softirq or have bh disabled?
    + * in_serving_softirq - Are we currently processing softirq?
    + */
    +#define in_irq() (hardirq_count())
    +#define in_softirq() (softirq_count())
    +#define in_interrupt() (irq_count())
    +#define in_serving_softirq() (softirq_count() & SOFTIRQ_OFFSET)
    +
    +/*
    + * Are we in NMI context?
    + */
    +#define in_nmi() (preempt_count() & NMI_MASK)
    +
    +#if defined(CONFIG_PREEMPT_COUNT)
    +# define PREEMPT_CHECK_OFFSET 1
    +#else
    +# define PREEMPT_CHECK_OFFSET 0
    +#endif
    +
    +/*
    + * The preempt_count offset needed for things like:
    + *
    + * spin_lock_bh()
    + *
    + * Which need to disable both preemption (CONFIG_PREEMPT_COUNT) and
    + * softirqs, such that unlock sequences of:
    + *
    + * spin_unlock();
    + * local_bh_enable();
    + *
    + * Work as expected.
    + */
    +#define SOFTIRQ_LOCK_OFFSET (SOFTIRQ_DISABLE_OFFSET + PREEMPT_CHECK_OFFSET)
    +
    +/*
    + * Are we running in atomic context? WARNING: this macro cannot
    + * always detect atomic context; in particular, it cannot know about
    + * held spinlocks in non-preemptible kernels. Thus it should not be
    + * used in the general case to determine whether sleeping is possible.
    + * Do not use in_atomic() in driver code.
    + */
    +#define in_atomic() ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
    +
    +/*
    + * Check whether we were atomic before we did preempt_disable():
    + * (used by the scheduler, *after* releasing the kernel lock)
    + */
    +#define in_atomic_preempt_off() \
    + ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
    +
    +#ifdef CONFIG_PREEMPT_COUNT
    +# define preemptible() (preempt_count() == 0 && !irqs_disabled())
    +#else
    +# define preemptible() 0
    +#endif
    +
    #if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
    extern void preempt_count_add(int val);
    extern void preempt_count_sub(int val);
    diff --git a/include/linux/preempt_mask.h b/include/linux/preempt_mask.h
    deleted file mode 100644
    index dbeec4d..0000000
    --- a/include/linux/preempt_mask.h
    +++ /dev/null
    @@ -1,117 +0,0 @@
    -#ifndef LINUX_PREEMPT_MASK_H
    -#define LINUX_PREEMPT_MASK_H
    -
    -#include <linux/preempt.h>
    -
    -/*
    - * We put the hardirq and softirq counter into the preemption
    - * counter. The bitmask has the following meaning:
    - *
    - * - bits 0-7 are the preemption count (max preemption depth: 256)
    - * - bits 8-15 are the softirq count (max # of softirqs: 256)
    - *
    - * The hardirq count could in theory be the same as the number of
    - * interrupts in the system, but we run all interrupt handlers with
    - * interrupts disabled, so we cannot have nesting interrupts. Though
    - * there are a few palaeontologic drivers which reenable interrupts in
    - * the handler, so we need more than one bit here.
    - *
    - * PREEMPT_MASK: 0x000000ff
    - * SOFTIRQ_MASK: 0x0000ff00
    - * HARDIRQ_MASK: 0x000f0000
    - * NMI_MASK: 0x00100000
    - * PREEMPT_ACTIVE: 0x00200000
    - */
    -#define PREEMPT_BITS 8
    -#define SOFTIRQ_BITS 8
    -#define HARDIRQ_BITS 4
    -#define NMI_BITS 1
    -
    -#define PREEMPT_SHIFT 0
    -#define SOFTIRQ_SHIFT (PREEMPT_SHIFT + PREEMPT_BITS)
    -#define HARDIRQ_SHIFT (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
    -#define NMI_SHIFT (HARDIRQ_SHIFT + HARDIRQ_BITS)
    -
    -#define __IRQ_MASK(x) ((1UL << (x))-1)
    -
    -#define PREEMPT_MASK (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
    -#define SOFTIRQ_MASK (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
    -#define HARDIRQ_MASK (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
    -#define NMI_MASK (__IRQ_MASK(NMI_BITS) << NMI_SHIFT)
    -
    -#define PREEMPT_OFFSET (1UL << PREEMPT_SHIFT)
    -#define SOFTIRQ_OFFSET (1UL << SOFTIRQ_SHIFT)
    -#define HARDIRQ_OFFSET (1UL << HARDIRQ_SHIFT)
    -#define NMI_OFFSET (1UL << NMI_SHIFT)
    -
    -#define SOFTIRQ_DISABLE_OFFSET (2 * SOFTIRQ_OFFSET)
    -
    -#define PREEMPT_ACTIVE_BITS 1
    -#define PREEMPT_ACTIVE_SHIFT (NMI_SHIFT + NMI_BITS)
    -#define PREEMPT_ACTIVE (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
    -
    -#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
    -#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
    -#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
    - | NMI_MASK))
    -
    -/*
    - * Are we doing bottom half or hardware interrupt processing?
    - * Are we in a softirq context? Interrupt context?
    - * in_softirq - Are we currently processing softirq or have bh disabled?
    - * in_serving_softirq - Are we currently processing softirq?
    - */
    -#define in_irq() (hardirq_count())
    -#define in_softirq() (softirq_count())
    -#define in_interrupt() (irq_count())
    -#define in_serving_softirq() (softirq_count() & SOFTIRQ_OFFSET)
    -
    -/*
    - * Are we in NMI context?
    - */
    -#define in_nmi() (preempt_count() & NMI_MASK)
    -
    -#if defined(CONFIG_PREEMPT_COUNT)
    -# define PREEMPT_CHECK_OFFSET 1
    -#else
    -# define PREEMPT_CHECK_OFFSET 0
    -#endif
    -
    -/*
    - * The preempt_count offset needed for things like:
    - *
    - * spin_lock_bh()
    - *
    - * Which need to disable both preemption (CONFIG_PREEMPT_COUNT) and
    - * softirqs, such that unlock sequences of:
    - *
    - * spin_unlock();
    - * local_bh_enable();
    - *
    - * Work as expected.
    - */
    -#define SOFTIRQ_LOCK_OFFSET (SOFTIRQ_DISABLE_OFFSET + PREEMPT_CHECK_OFFSET)
    -
    -/*
    - * Are we running in atomic context? WARNING: this macro cannot
    - * always detect atomic context; in particular, it cannot know about
    - * held spinlocks in non-preemptible kernels. Thus it should not be
    - * used in the general case to determine whether sleeping is possible.
    - * Do not use in_atomic() in driver code.
    - */
    -#define in_atomic() ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
    -
    -/*
    - * Check whether we were atomic before we did preempt_disable():
    - * (used by the scheduler, *after* releasing the kernel lock)
    - */
    -#define in_atomic_preempt_off() \
    - ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
    -
    -#ifdef CONFIG_PREEMPT_COUNT
    -# define preemptible() (preempt_count() == 0 && !irqs_disabled())
    -#else
    -# define preemptible() 0
    -#endif
    -
    -#endif /* LINUX_PREEMPT_MASK_H */
    diff --git a/include/linux/sched.h b/include/linux/sched.h
    index fdca05c..5c13be9 100644
    --- a/include/linux/sched.h
    +++ b/include/linux/sched.h
    @@ -25,7 +25,7 @@ struct sched_param {
    #include <linux/errno.h>
    #include <linux/nodemask.h>
    #include <linux/mm_types.h>
    -#include <linux/preempt_mask.h>
    +#include <linux/preempt.h>

    #include <asm/page.h>
    #include <asm/ptrace.h>
    diff --git a/lib/radix-tree.c b/lib/radix-tree.c
    index 3d2aa27..061550d 100644
    --- a/lib/radix-tree.c
    +++ b/lib/radix-tree.c
    @@ -33,7 +33,7 @@
    #include <linux/string.h>
    #include <linux/bitops.h>
    #include <linux/rcupdate.h>
    -#include <linux/preempt_mask.h> /* in_interrupt() */
    +#include <linux/preempt.h> /* in_interrupt() */


    /*
    --
    2.1.4


    \
     
     \ /
      Last update: 2015-05-11 17:41    [W:3.558 / U:0.024 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site