__this_cpu_write

#define BH_LRU_SIZE    16

struct bh_lru {
    struct buffer_head *bhs[BH_LRU_SIZE];
};

static DEFINE_PER_CPU(struct bh_lru, bh_lrus) = {{ NULL }};

__this_cpu_write(bh_lrus.bhs[0], bh);

#define __this_cpu_write(pcp, val)                    \
({                                    \
    __this_cpu_preempt_check("write");                \
    raw_cpu_write(pcp, val);                    \
})

#define raw_cpu_write(pcp, val)        __pcpu_size_call(raw_cpu_write_, pcp, val)

#define __pcpu_size_call(stem, variable, ...)                \
do {                                    \
    __verify_pcpu_ptr(&(variable));                    \
    switch(sizeof(variable)) {                    \
        case 1: stem##1(variable, __VA_ARGS__);break;        \
        case 2: stem##2(variable, __VA_ARGS__);break;        \
        case 4: stem##4(variable, __VA_ARGS__);break;        \
        case 8: stem##8(variable, __VA_ARGS__);break;        \
        default:                         \
            __bad_size_call_parameter();break;        \
    }                                \
} while (0)

raw_cpu_write_2

#define raw_cpu_write_2(pcp, val)    raw_cpu_generic_to_op(pcp, val, =)

#define raw_cpu_generic_to_op(pcp, val, op)                \
do {                                    \
    *raw_cpu_ptr(&(pcp)) op val;                    \
} while (0)

*raw_cpu_ptr(&(bh_lrus.bhs[0])) = bh;  

#define raw_cpu_ptr(ptr)    per_cpu_ptr(ptr, 0)

*per_cpu_ptr(&(bh_lrus.bhs[0]), 0) = bh;  

#define per_cpu_ptr(ptr, cpu)    ({ (void)(cpu); VERIFY_PERCPU_PTR(ptr); })

#define VERIFY_PERCPU_PTR(__p)                        \
({                                    \
    __verify_pcpu_ptr(__p);                        \
    (typeof(*(__p)) __kernel __force *)(__p);            \
})

#define __verify_pcpu_ptr(ptr)                        \
do {                                    \
    const void __percpu *__vpp_verify = (typeof((ptr) + 0))NULL;    \
    (void)__vpp_verify;                        \
} while (0)