On Fri, Sep 04, 2020 at 05:32:30PM +0200, Ahmed S. Darwish wrote:
> @@ -406,13 +443,20 @@ static inline int read_seqcount_t_retry(const 
> seqcount_t *s, unsigned start)
>       return __read_seqcount_t_retry(s, start);
>  }
>  
> +/*
> + * Enforce non-preemptibility for all seqcount_LOCKNAME_t writers. Don't
> + * do it for PREEMPT_RT, for the reasons outlined at __SEQ_LOCK().
> + */
> +#define __seq_enforce_writer_non_preemptibility(s)                   \
> +     (!IS_ENABLED(CONFIG_PREEMPT_RT) && __seqcount_lock_preemptible(s))
> +
>  /**
>   * raw_write_seqcount_begin() - start a seqcount_t write section w/o lockdep
>   * @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
>   */
>  #define raw_write_seqcount_begin(s)                                  \
>  do {                                                                 \
> -     if (__seqcount_lock_preemptible(s))                             \
> +     if (__seq_enforce_writer_non_preemptibility(s))                 \
>               preempt_disable();                                      \
>                                                                       \
>       raw_write_seqcount_t_begin(__seqcount_ptr(s));                  \
> @@ -433,7 +477,7 @@ static inline void raw_write_seqcount_t_begin(seqcount_t 
> *s)
>  do {                                                                 \
>       raw_write_seqcount_t_end(__seqcount_ptr(s));                    \
>                                                                       \
> -     if (__seqcount_lock_preemptible(s))                             \
> +     if (__seq_enforce_writer_non_preemptibility(s))                 \
>               preempt_enable();                                       \
>  } while (0)
>  
> @@ -456,7 +500,7 @@ static inline void raw_write_seqcount_t_end(seqcount_t *s)
>  do {                                                                 \
>       __seqcount_assert_lock_held(s);                                 \
>                                                                       \
> -     if (__seqcount_lock_preemptible(s))                             \
> +     if (__seq_enforce_writer_non_preemptibility(s))                 \
>               preempt_disable();                                      \
>                                                                       \
>       write_seqcount_t_begin_nested(__seqcount_ptr(s), subclass);     \
> @@ -483,7 +527,7 @@ static inline void 
> write_seqcount_t_begin_nested(seqcount_t *s, int subclass)
>  do {                                                                 \
>       __seqcount_assert_lock_held(s);                                 \
>                                                                       \
> -     if (__seqcount_lock_preemptible(s))                             \
> +     if (__seq_enforce_writer_non_preemptibility(s))                 \
>               preempt_disable();                                      \
>                                                                       \
>       write_seqcount_t_begin(__seqcount_ptr(s));                      \
> @@ -504,7 +548,7 @@ static inline void write_seqcount_t_begin(seqcount_t *s)
>  do {                                                                 \
>       write_seqcount_t_end(__seqcount_ptr(s));                        \
>                                                                       \
> -     if (__seqcount_lock_preemptible(s))                             \
> +     if (__seq_enforce_writer_non_preemptibility(s))                 \
>               preempt_enable();                                       \
>  } while (0)

I've replaced the above with the below, afaict there were no users of
__seqcount_lock_preemptible() left.

--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -228,7 +228,11 @@ __seqprop_##lockname##_sequence(const se
 static __always_inline bool                                            \
 __seqprop_##lockname##_preemptible(const seqcount_##lockname##_t *s)   \
 {                                                                      \
-       return preemptible;                                             \
+       if (!IS_ENABLED(CONFIG_PREEMPT_RT))                             \
+               return preemptible;                                     \
+                                                                       \
+       /* PREEMPT_RT relies on the above LOCK+UNLOCK */                \
+       return false;                                                   \
 }                                                                      \
                                                                        \
 static __always_inline void                                            \

Reply via email to