percpu: use TYPEOF_UNQUAL() in variable declarations

Use TYPEOF_UNQUAL() to declare variables as a corresponding type without
named address space qualifier to avoid "`__seg_gs' specified for auto
variable `var'" errors.

Link: https://lkml.kernel.org/r/20250127160709.80604-4-ubizjak@gmail.com
Signed-off-by: Uros Bizjak <ubizjak@gmail.com>
Acked-by: Nadav Amit <nadav.amit@gmail.com>
Acked-by: Christoph Lameter <cl@linux.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Tejun Heo <tj@kernel.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Kent Overstreet <kent.overstreet@linux.dev>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Eric Dumazet <edumazet@google.com>
Cc: Jakub Kicinski <kuba@kernel.org>
Cc: Paolo Abeni <pabeni@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will@kernel.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/arch/x86/include/asm/percpu.h b/arch/x86/include/asm/percpu.h
index e525cd85f999fdc53d7686bcbfb54975d5f86584..666e4137b09f18806a25a93f2ba3ce6c73d0667e 100644 (file)
--- a/arch/x86/include/asm/percpu.h
+++ b/arch/x86/include/asm/percpu.h
@@ -180,7 +180,7 @@ do {                                                                        \
        __pcpu_type_##size pto_val__ = __pcpu_cast_##size(_val);        \
                                                                        \
        if (0) {                                                        \
-               typeof(_var) pto_tmp__;                                 \
+               TYPEOF_UNQUAL(_var) pto_tmp__;                          \
                pto_tmp__ = (_val);                                     \
                (void)pto_tmp__;                                        \
        }                                                               \
@@ -219,7 +219,7 @@ do {                                                                        \
        __pcpu_type_##size pto_val__ = __pcpu_cast_##size(_val);        \
                                                                        \
        if (0) {                                                        \
-               typeof(_var) pto_tmp__;                                 \
+               TYPEOF_UNQUAL(_var) pto_tmp__;                          \
                pto_tmp__ = (_val);                                     \
                (void)pto_tmp__;                                        \
        }                                                               \
@@ -240,7 +240,7 @@ do {                                                                        \
                         (val) == (typeof(val))-1)) ? (int)(val) : 0;   \
                                                                        \
        if (0) {                                                        \
-               typeof(var) pao_tmp__;                                  \
+               TYPEOF_UNQUAL(var) pao_tmp__;                           \
                pao_tmp__ = (val);                                      \
                (void)pao_tmp__;                                        \
        }                                                               \
@@ -273,7 +273,7 @@ do {                                                                        \
  */
 #define raw_percpu_xchg_op(_var, _nval)                                        \
 ({                                                                     \
-       typeof(_var) pxo_old__ = raw_cpu_read(_var);                    \
+       TYPEOF_UNQUAL(_var) pxo_old__ = raw_cpu_read(_var);             \
                                                                        \
        raw_cpu_write(_var, _nval);                                     \
                                                                        \
@@ -287,7 +287,7 @@ do {                                                                        \
  */
 #define this_percpu_xchg_op(_var, _nval)                               \
 ({                                                                     \
-       typeof(_var) pxo_old__ = this_cpu_read(_var);                   \
+       TYPEOF_UNQUAL(_var) pxo_old__ = this_cpu_read(_var);            \
                                                                        \
        do { } while (!this_cpu_try_cmpxchg(_var, &pxo_old__, _nval));  \
                                                                        \

diff --git a/fs/bcachefs/util.h b/fs/bcachefs/util.h
index e7c3541b38f3ff0df9d8fe0be372feabc383648d..5760f7dbcac219552faf5e5de5c099eade898d3a 100644 (file)
--- a/fs/bcachefs/util.h
+++ b/fs/bcachefs/util.h
@@ -609,7 +609,7 @@ do {                                                                        \
 
 #define per_cpu_sum(_p)                                                        \
 ({                                                                     \
-       typeof(*_p) _ret = 0;                                           \
+       TYPEOF_UNQUAL(*_p) _ret = 0;                                    \
                                                                        \
        int cpu;                                                        \
        for_each_possible_cpu(cpu)                                      \

diff --git a/include/asm-generic/percpu.h b/include/asm-generic/percpu.h
index 94cbd50cc870bb289c0cd238700b11b635d43d03..50597b975a49927605c3b4475d25a487c06ab718 100644 (file)
--- a/include/asm-generic/percpu.h
+++ b/include/asm-generic/percpu.h
@@ -74,7 +74,7 @@ do {                                                                  \
 
 #define raw_cpu_generic_add_return(pcp, val)                           \
 ({                                                                     \
-       typeof(pcp) *__p = raw_cpu_ptr(&(pcp));                         \
+       TYPEOF_UNQUAL(pcp) *__p = raw_cpu_ptr(&(pcp));                  \
                                                                        \
        *__p += val;                                                    \
        *__p;                                                           \
@@ -82,8 +82,8 @@ do {                                                                  \
 
 #define raw_cpu_generic_xchg(pcp, nval)                                        \
 ({                                                                     \
-       typeof(pcp) *__p = raw_cpu_ptr(&(pcp));                         \
-       typeof(pcp) __ret;                                              \
+       TYPEOF_UNQUAL(pcp) *__p = raw_cpu_ptr(&(pcp));                  \
+       TYPEOF_UNQUAL(pcp) __ret;                                       \
        __ret = *__p;                                                   \
        *__p = nval;                                                    \
        __ret;                                                          \
@@ -91,7 +91,7 @@ do {                                                                  \
 
 #define __cpu_fallback_try_cmpxchg(pcp, ovalp, nval, _cmpxchg)         \
 ({                                                                     \
-       typeof(pcp) __val, __old = *(ovalp);                            \
+       TYPEOF_UNQUAL(pcp) __val, __old = *(ovalp);                     \
        __val = _cmpxchg(pcp, __old, nval);                             \
        if (__val != __old)                                             \
                *(ovalp) = __val;                                       \
@@ -100,8 +100,8 @@ do {                                                                        \
 
 #define raw_cpu_generic_try_cmpxchg(pcp, ovalp, nval)                  \
 ({                                                                     \
-       typeof(pcp) *__p = raw_cpu_ptr(&(pcp));                         \
-       typeof(pcp) __val = *__p, ___old = *(ovalp);                    \
+       TYPEOF_UNQUAL(pcp) *__p = raw_cpu_ptr(&(pcp));                  \
+       TYPEOF_UNQUAL(pcp) __val = *__p, ___old = *(ovalp);             \
        bool __ret;                                                     \
        if (__val == ___old) {                                          \
                *__p = nval;                                            \
@@ -115,14 +115,14 @@ do {                                                                      \
 
 #define raw_cpu_generic_cmpxchg(pcp, oval, nval)                       \
 ({                                                                     \
-       typeof(pcp) __old = (oval);                                     \
+       TYPEOF_UNQUAL(pcp) __old = (oval);                              \
        raw_cpu_generic_try_cmpxchg(pcp, &__old, nval);                 \
        __old;                                                          \
 })
 
 #define __this_cpu_generic_read_nopreempt(pcp)                         \
 ({                                                                     \
-       typeof(pcp) ___ret;                                             \
+       TYPEOF_UNQUAL(pcp) ___ret;                                      \
        preempt_disable_notrace();                                      \
        ___ret = READ_ONCE(*raw_cpu_ptr(&(pcp)));                       \
        preempt_enable_notrace();                                       \
@@ -131,7 +131,7 @@ do {                                                                        \
 
 #define __this_cpu_generic_read_noirq(pcp)                             \
 ({                                                                     \
-       typeof(pcp) ___ret;                                             \
+       TYPEOF_UNQUAL(pcp) ___ret;                                      \
        unsigned long ___flags;                                         \
        raw_local_irq_save(___flags);                                   \
        ___ret = raw_cpu_generic_read(pcp);                             \
@@ -141,7 +141,7 @@ do {                                                                        \
 
 #define this_cpu_generic_read(pcp)                                     \
 ({                                                                     \
-       typeof(pcp) __ret;                                              \
+       TYPEOF_UNQUAL(pcp) __ret;                                       \
        if (__native_word(pcp))                                         \
                __ret = __this_cpu_generic_read_nopreempt(pcp);         \
        else                                                            \
@@ -160,7 +160,7 @@ do {                                                                        \
 
 #define this_cpu_generic_add_return(pcp, val)                          \
 ({                                                                     \
-       typeof(pcp) __ret;                                              \
+       TYPEOF_UNQUAL(pcp) __ret;                                       \
        unsigned long __flags;                                          \
        raw_local_irq_save(__flags);                                    \
        __ret = raw_cpu_generic_add_return(pcp, val);                   \
@@ -170,7 +170,7 @@ do {                                                                        \
 
 #define this_cpu_generic_xchg(pcp, nval)                               \
 ({                                                                     \
-       typeof(pcp) __ret;                                              \
+       TYPEOF_UNQUAL(pcp) __ret;                                       \
        unsigned long __flags;                                          \
        raw_local_irq_save(__flags);                                    \
        __ret = raw_cpu_generic_xchg(pcp, nval);                        \
@@ -190,7 +190,7 @@ do {                                                                        \
 
 #define this_cpu_generic_cmpxchg(pcp, oval, nval)                      \
 ({                                                                     \
-       typeof(pcp) __ret;                                              \
+       TYPEOF_UNQUAL(pcp) __ret;                                       \
        unsigned long __flags;                                          \
        raw_local_irq_save(__flags);                                    \
        __ret = raw_cpu_generic_cmpxchg(pcp, oval, nval);               \

diff --git a/include/linux/part_stat.h b/include/linux/part_stat.h
index ac8c44dd8237e8e855a0592dabd0d1899ec10688..c5e9cac0575ea9ace3a156fee93938bda5b1296e 100644 (file)
--- a/include/linux/part_stat.h
+++ b/include/linux/part_stat.h
@@ -33,7 +33,7 @@ struct disk_stats {
 
 #define part_stat_read(part, field)                                    \
 ({                                                                     \
-       typeof((part)->bd_stats->field) res = 0;                        \
+       TYPEOF_UNQUAL((part)->bd_stats->field) res = 0;                 \
        unsigned int _cpu;                                              \
        for_each_possible_cpu(_cpu)                                     \
                res += per_cpu_ptr((part)->bd_stats, _cpu)->field; \

diff --git a/include/linux/percpu-defs.h b/include/linux/percpu-defs.h
index 5b520fe86b6093485eb1590ca7229480a720d35a..79b9402404f1fcd14b2b3b2aee34078a8daf6fd5 100644 (file)
--- a/include/linux/percpu-defs.h
+++ b/include/linux/percpu-defs.h
@@ -317,7 +317,7 @@ static __always_inline void __this_cpu_preempt_check(const char *op) { }
 
 #define __pcpu_size_call_return(stem, variable)                                \
 ({                                                                     \
-       typeof(variable) pscr_ret__;                                    \
+       TYPEOF_UNQUAL(variable) pscr_ret__;                             \
        __verify_pcpu_ptr(&(variable));                                 \
        switch(sizeof(variable)) {                                      \
        case 1: pscr_ret__ = stem##1(variable); break;                  \
@@ -332,7 +332,7 @@ static __always_inline void __this_cpu_preempt_check(const char *op) { }
 
 #define __pcpu_size_call_return2(stem, variable, ...)                  \
 ({                                                                     \
-       typeof(variable) pscr2_ret__;                                   \
+       TYPEOF_UNQUAL(variable) pscr2_ret__;                            \
        __verify_pcpu_ptr(&(variable));                                 \
        switch(sizeof(variable)) {                                      \
        case 1: pscr2_ret__ = stem##1(variable, __VA_ARGS__); break;    \

diff --git a/include/net/snmp.h b/include/net/snmp.h
index 468a67836e2f1fcf744b845784312175fab63668..4cb4326dfebe6bbfa14cfac1d987bc6f6c21954a 100644 (file)
--- a/include/net/snmp.h
+++ b/include/net/snmp.h
@@ -159,7 +159,7 @@ struct linux_tls_mib {
 
 #define __SNMP_ADD_STATS64(mib, field, addend)                                 \
        do {                                                            \
-               __typeof__(*mib) *ptr = raw_cpu_ptr(mib);               \
+               TYPEOF_UNQUAL(*mib) *ptr = raw_cpu_ptr(mib);            \
                u64_stats_update_begin(&ptr->syncp);                    \
                ptr->mibs[field] += addend;                             \
                u64_stats_update_end(&ptr->syncp);                      \
@@ -176,8 +176,7 @@ struct linux_tls_mib {
 #define SNMP_INC_STATS64(mib, field) SNMP_ADD_STATS64(mib, field, 1)
 #define __SNMP_UPD_PO_STATS64(mib, basefield, addend)                  \
        do {                                                            \
-               __typeof__(*mib) *ptr;                          \
-               ptr = raw_cpu_ptr((mib));                               \
+               TYPEOF_UNQUAL(*mib) *ptr = raw_cpu_ptr(mib);            \
                u64_stats_update_begin(&ptr->syncp);                    \
                ptr->mibs[basefield##PKTS]++;                           \
                ptr->mibs[basefield##OCTETS] += addend;                 \

diff --git a/kernel/locking/percpu-rwsem.c b/kernel/locking/percpu-rwsem.c
index 6083883c4fe09444a5f770eb7ee0f092d1ad8d4e..d6964fc29f513997f906a07ff68118ae50520097 100644 (file)
--- a/kernel/locking/percpu-rwsem.c
+++ b/kernel/locking/percpu-rwsem.c
@@ -184,7 +184,7 @@ EXPORT_SYMBOL_GPL(__percpu_down_read);
 
 #define per_cpu_sum(var)                                               \
 ({                                                                     \
-       typeof(var) __sum = 0;                                          \
+       TYPEOF_UNQUAL(var) __sum = 0;                                   \
        int cpu;                                                        \
        compiletime_assert_atomic_type(__sum);                          \
        for_each_possible_cpu(cpu)                                      \

diff --git a/net/mpls/internal.h b/net/mpls/internal.h
index b9f492ddf93be46ca2fd590e2660b688d5eb338e..83c629529b57515267ab1adf121cb0a56913e07a 100644 (file)
--- a/net/mpls/internal.h
+++ b/net/mpls/internal.h
@@ -33,7 +33,7 @@ struct mpls_dev {
 
 #define MPLS_INC_STATS_LEN(mdev, len, pkts_field, bytes_field)         \
        do {                                                            \
-               __typeof__(*(mdev)->stats) *ptr =                       \
+               TYPEOF_UNQUAL(*(mdev)->stats) *ptr =                    \
                        raw_cpu_ptr((mdev)->stats);                     \
                local_bh_disable();                                     \
                u64_stats_update_begin(&ptr->syncp);                    \
@@ -45,7 +45,7 @@ struct mpls_dev {
 
 #define MPLS_INC_STATS(mdev, field)                                    \
        do {                                                            \
-               __typeof__(*(mdev)->stats) *ptr =                       \
+               TYPEOF_UNQUAL(*(mdev)->stats) *ptr =                    \
                        raw_cpu_ptr((mdev)->stats);                     \
                local_bh_disable();                                     \
                u64_stats_update_begin(&ptr->syncp);                    \