Return-Path: <linux-kernel-owner@vger.kernel.org>
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
        id S1752663AbdFQSMI (ORCPT <rfc822;w@1wt.eu>);
        Sat, 17 Jun 2017 14:12:08 -0400
Received: from mga04.intel.com ([192.55.52.120]:40913 "EHLO mga04.intel.com"
        rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP
        id S1752066AbdFQSMH (ORCPT <rfc822;linux-kernel@vger.kernel.org>);
        Sat, 17 Jun 2017 14:12:07 -0400
X-ExtLoop1: 1
X-IronPort-AV: E=Sophos;i="5.39,353,1493708400"; 
   d="gz'50?scan'50,208,50";a="114402389"
Date: Sun, 18 Jun 2017 02:11:35 +0800
From: kbuild test robot <lkp@intel.com>
To: Johannes Weiner <hannes@cmpxchg.org>
Cc: kbuild-all@01.org, Andrew Morton <akpm@linux-foundation.org>,
        Guenter Roeck <private@roeck-us.net>,
        "linux-kernel@vger.kernel.org" <linux-kernel@vger.kernel.org>
Subject: Re: mm-memcontrol-per-lruvec-stats-infrastructure-fix-4
Message-ID: <201706180238.k4W2rmoD%fengguang.wu@intel.com>
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="9jxsPFA5p3P2qPhR"
Content-Disposition: inline
In-Reply-To: <20170616201523.GA11016@cmpxchg.org>
User-Agent: Mutt/1.5.23 (2014-03-12)
X-SA-Exim-Connect-IP: <locally generated>
X-SA-Exim-Mail-From: fengguang.wu@intel.com
X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false
Sender: linux-kernel-owner@vger.kernel.org
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org
Content-Length: 61442
Lines: 982


--9jxsPFA5p3P2qPhR
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi Johannes,

[auto build test ERROR on next-20170616]
[cannot apply to linus/master linux/master v4.9-rc8 v4.9-rc7 v4.9-rc6 v4.12-rc5]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Johannes-Weiner/mm-memcontrol-per-lruvec-stats-infrastructure-fix-4/20170618-012558
config: x86_64-randconfig-i0-201725 (attached as .config)
compiler: gcc-4.9 (Debian 4.9.4-2) 4.9.4
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All error/warnings (new ones prefixed by >>):

   scripts/Makefile.kasan:25: CONFIG_KASAN: compiler does not support all options. Trying minimal configuration
   scripts/Makefile.kasan:25: CONFIG_KASAN: compiler does not support all options. Trying minimal configuration
   In file included from include/linux/mm.h:1032:0,
                    from include/linux/highmem.h:7,
                    from include/linux/bio.h:21,
                    from include/linux/writeback.h:205,
                    from include/linux/memcontrol.h:28,
                    from include/linux/swap.h:8,
                    from include/linux/suspend.h:4,
                    from arch/x86/kernel/asm-offsets.c:12:
   include/linux/vmstat.h: In function 'lruvec_page_state':
   include/linux/vmstat.h:362:2: error: implicit declaration of function 'mem_cgroup_disabled' [-Werror=implicit-function-declaration]
     if (mem_cgroup_disabled())
     ^
   In file included from arch/x86/include/asm/atomic.h:4:0,
                    from include/linux/atomic.h:4,
                    from include/linux/crypto.h:20,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/kernel.h:859:51: error: dereferencing pointer to incomplete type
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
                                                      ^
   include/linux/compiler.h:517:19: note: in definition of macro '__compiletime_assert'
      bool __cond = !(condition);    \
                      ^
   include/linux/compiler.h:537:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^
   include/linux/kernel.h:859:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
     ^
   include/linux/kernel.h:859:20: note: in expansion of macro '__same_type'
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
                       ^
   include/linux/vmstat.h:365:7: note: in expansion of macro 'container_of'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
          ^
   In file included from include/linux/compiler.h:58:0,
                    from arch/x86/include/asm/atomic.h:4,
                    from include/linux/atomic.h:4,
                    from include/linux/crypto.h:20,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/vmstat.h:365:35: error: invalid use of undefined type 'struct mem_cgroup_per_node'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
                                      ^
   include/linux/compiler-gcc.h:161:21: note: in definition of macro '__compiler_offsetof'
     __builtin_offsetof(a, b)
                        ^
   include/linux/kernel.h:862:28: note: in expansion of macro 'offsetof'
     ((type *)((char *)(ptr) - offsetof(type, member))); })
                               ^
   include/linux/vmstat.h:365:7: note: in expansion of macro 'container_of'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
          ^
   In file included from include/asm-generic/percpu.h:6:0,
                    from arch/x86/include/asm/percpu.h:542,
                    from arch/x86/include/asm/preempt.h:5,
                    from include/linux/preempt.h:80,
                    from include/linux/spinlock.h:50,
                    from include/linux/mmzone.h:7,
                    from include/linux/gfp.h:5,
                    from include/linux/slab.h:14,
                    from include/linux/crypto.h:24,
                    from arch/x86/kernel/asm-offsets.c:8:
>> include/linux/vmstat.h:367:20: error: dereferencing pointer to incomplete type
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
                       ^
   include/linux/percpu-defs.h:206:47: note: in definition of macro '__verify_pcpu_ptr'
     const void __percpu *__vpp_verify = (typeof((ptr) + 0))NULL; \
                                                  ^
   include/linux/percpu-defs.h:256:29: note: in expansion of macro 'per_cpu_ptr'
    #define per_cpu(var, cpu) (*per_cpu_ptr(&(var), cpu))
                                ^
>> include/linux/vmstat.h:367:10: note: in expansion of macro 'per_cpu'
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
             ^
   In file included from include/linux/compiler.h:58:0,
                    from arch/x86/include/asm/atomic.h:4,
                    from include/linux/atomic.h:4,
                    from include/linux/crypto.h:20,
                    from arch/x86/kernel/asm-offsets.c:8:
>> include/linux/vmstat.h:367:20: error: dereferencing pointer to incomplete type
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
                       ^
   include/linux/compiler-gcc.h:52:34: note: in definition of macro 'RELOC_HIDE'
     __asm__ ("" : "=r"(__ptr) : "0"(ptr));    \
                                     ^
   include/linux/percpu-defs.h:223:2: note: in expansion of macro 'SHIFT_PERCPU_PTR'
     SHIFT_PERCPU_PTR((ptr), per_cpu_offset((cpu)));   \
     ^
   include/linux/percpu-defs.h:256:29: note: in expansion of macro 'per_cpu_ptr'
    #define per_cpu(var, cpu) (*per_cpu_ptr(&(var), cpu))
                                ^
>> include/linux/vmstat.h:367:10: note: in expansion of macro 'per_cpu'
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
             ^
>> include/linux/vmstat.h:367:20: error: dereferencing pointer to incomplete type
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
                       ^
   include/linux/compiler-gcc.h:52:34: note: in definition of macro 'RELOC_HIDE'
     __asm__ ("" : "=r"(__ptr) : "0"(ptr));    \
                                     ^
   include/linux/percpu-defs.h:223:2: note: in expansion of macro 'SHIFT_PERCPU_PTR'
     SHIFT_PERCPU_PTR((ptr), per_cpu_offset((cpu)));   \
     ^
   include/linux/percpu-defs.h:256:29: note: in expansion of macro 'per_cpu_ptr'
    #define per_cpu(var, cpu) (*per_cpu_ptr(&(var), cpu))
                                ^
>> include/linux/vmstat.h:367:10: note: in expansion of macro 'per_cpu'
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
             ^
>> include/linux/vmstat.h:367:20: error: dereferencing pointer to incomplete type
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
                       ^
   include/linux/compiler-gcc.h:53:10: note: in definition of macro 'RELOC_HIDE'
     (typeof(ptr)) (__ptr + (off));     \
             ^
   include/linux/percpu-defs.h:223:2: note: in expansion of macro 'SHIFT_PERCPU_PTR'
     SHIFT_PERCPU_PTR((ptr), per_cpu_offset((cpu)));   \
     ^
   include/linux/percpu-defs.h:256:29: note: in expansion of macro 'per_cpu_ptr'
    #define per_cpu(var, cpu) (*per_cpu_ptr(&(var), cpu))
                                ^
>> include/linux/vmstat.h:367:10: note: in expansion of macro 'per_cpu'
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
             ^
>> include/linux/vmstat.h:367:20: error: dereferencing pointer to incomplete type
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
                       ^
   include/linux/compiler-gcc.h:53:10: note: in definition of macro 'RELOC_HIDE'
     (typeof(ptr)) (__ptr + (off));     \
             ^
   include/linux/percpu-defs.h:223:2: note: in expansion of macro 'SHIFT_PERCPU_PTR'
     SHIFT_PERCPU_PTR((ptr), per_cpu_offset((cpu)));   \
     ^
   include/linux/percpu-defs.h:256:29: note: in expansion of macro 'per_cpu_ptr'
    #define per_cpu(var, cpu) (*per_cpu_ptr(&(var), cpu))
                                ^
>> include/linux/vmstat.h:367:10: note: in expansion of macro 'per_cpu'
      val += per_cpu(pn->lruvec_stat->count[idx], cpu);
             ^
   In file included from arch/x86/include/asm/atomic.h:4:0,
                    from include/linux/atomic.h:4,
                    from include/linux/crypto.h:20,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/vmstat.h: In function '__mod_lruvec_state':
   include/linux/kernel.h:859:51: error: dereferencing pointer to incomplete type
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
                                                      ^
   include/linux/compiler.h:517:19: note: in definition of macro '__compiletime_assert'
      bool __cond = !(condition);    \
                      ^
   include/linux/compiler.h:537:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^
   include/linux/kernel.h:859:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
     ^
   include/linux/kernel.h:859:20: note: in expansion of macro '__same_type'
     BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
                       ^
   include/linux/vmstat.h:383:7: note: in expansion of macro 'container_of'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
          ^
   In file included from include/linux/compiler.h:58:0,
                    from arch/x86/include/asm/atomic.h:4,
                    from include/linux/atomic.h:4,
                    from include/linux/crypto.h:20,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/vmstat.h:383:35: error: invalid use of undefined type 'struct mem_cgroup_per_node'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
                                      ^
   include/linux/compiler-gcc.h:161:21: note: in definition of macro '__compiler_offsetof'
     __builtin_offsetof(a, b)
                        ^
   include/linux/kernel.h:862:28: note: in expansion of macro 'offsetof'
     ((type *)((char *)(ptr) - offsetof(type, member))); })
                               ^
   include/linux/vmstat.h:383:7: note: in expansion of macro 'container_of'
     pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
          ^
   In file included from include/linux/mm.h:1032:0,
                    from include/linux/highmem.h:7,
                    from include/linux/bio.h:21,
                    from include/linux/writeback.h:205,
                    from include/linux/memcontrol.h:28,
                    from include/linux/swap.h:8,
                    from include/linux/suspend.h:4,
                    from arch/x86/kernel/asm-offsets.c:12:
   include/linux/vmstat.h:384:2: error: implicit declaration of function '__mod_memcg_state' [-Werror=implicit-function-declaration]
     __mod_memcg_state(pn->memcg, idx, val);
     ^
   include/linux/vmstat.h:384:22: error: dereferencing pointer to incomplete type
     __mod_memcg_state(pn->memcg, idx, val);
                         ^
   In file included from include/asm-generic/percpu.h:6:0,
                    from arch/x86/include/asm/percpu.h:542,
                    from arch/x86/include/asm/preempt.h:5,
                    from include/linux/preempt.h:80,
                    from include/linux/spinlock.h:50,
                    from include/linux/mmzone.h:7,
                    from include/linux/gfp.h:5,
                    from include/linux/slab.h:14,
                    from include/linux/crypto.h:24,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   include/linux/percpu-defs.h:206:47: note: in definition of macro '__verify_pcpu_ptr'
     const void __percpu *__vpp_verify = (typeof((ptr) + 0))NULL; \
                                                  ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   include/linux/percpu-defs.h:363:16: note: in definition of macro '__pcpu_size_call'
     switch(sizeof(variable)) {     \
                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   In file included from arch/x86/include/asm/preempt.h:5:0,
                    from include/linux/preempt.h:80,
                    from include/linux/spinlock.h:50,
                    from include/linux/mmzone.h:7,
                    from include/linux/gfp.h:5,
                    from include/linux/slab.h:14,
                    from include/linux/crypto.h:24,
                    from arch/x86/kernel/asm-offsets.c:8:
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:128:17: note: in definition of macro 'percpu_add_op'
     typedef typeof(var) pao_T__;     \
                    ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:137:17: note: in definition of macro 'percpu_add_op'
     switch (sizeof(var)) {      \
                    ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:140:39: note: in definition of macro 'percpu_add_op'
       asm("incb "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:142:39: note: in definition of macro 'percpu_add_op'
       asm("decb "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:145:16: note: in definition of macro 'percpu_add_op'
           : "+m" (var)    \
                   ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:150:39: note: in definition of macro 'percpu_add_op'
       asm("incw "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:152:39: note: in definition of macro 'percpu_add_op'
       asm("decw "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:155:16: note: in definition of macro 'percpu_add_op'
           : "+m" (var)    \
                   ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:160:39: note: in definition of macro 'percpu_add_op'
       asm("incl "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:162:39: note: in definition of macro 'percpu_add_op'
       asm("decl "__percpu_arg(0) : "+m" (var)); \
                                          ^
>> include/linux/percpu-defs.h:364:11: note: in expansion of macro 'raw_cpu_add_1'
      case 1: stem##1(variable, __VA_ARGS__);break;  \
              ^
   include/linux/percpu-defs.h:409:32: note: in expansion of macro '__pcpu_size_call'
    #define raw_cpu_add(pcp, val)  __pcpu_size_call(raw_cpu_add_, pcp, val)
                                   ^
   include/linux/percpu-defs.h:445:2: note: in expansion of macro 'raw_cpu_add'
     raw_cpu_add(pcp, val);      \
     ^
   include/linux/vmstat.h:385:2: note: in expansion of macro '__this_cpu_add'
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
     ^
   include/linux/vmstat.h:385:19: error: dereferencing pointer to incomplete type
     __this_cpu_add(pn->lruvec_stat->count[idx], val);
                      ^
   arch/x86/include/asm/percpu.h:165:16: note: in definition of macro 'percpu_add_op'
           : "+m" (var)    \
                   ^

vim +367 include/linux/vmstat.h

   361	
   362		if (mem_cgroup_disabled())
   363			return node_page_state(lruvec_pgdat(lruvec), idx);
   364	
   365		pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
   366		for_each_possible_cpu(cpu)
 > 367			val += per_cpu(pn->lruvec_stat->count[idx], cpu);
   368	
   369		if (val < 0)
   370			val = 0;

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

--9jxsPFA5p3P2qPhR
Content-Type: application/gzip
Content-Disposition: attachment; filename=".config.gz"
Content-Transfer-Encoding: base64
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--9jxsPFA5p3P2qPhR--