| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20200305032723.GY2935@paulmck-ThinkPad-P72>
Date: Wed, 4 Mar 2020 19:27:23 -0800
From: "Paul E. McKenney" <paulmck@...nel.org>
To: "Li, Philip" <philip.li@...el.com>
Cc: lkp <lkp@...el.com>,
"kbuild-all@...ts.01.org" <kbuild-all@...ts.01.org>,
"linux-kernel@...r.kernel.org" <linux-kernel@...r.kernel.org>
Subject: Re: [kbuild-all] Re: [rcu:dev.2020.02.29a 43/43]
kernel/rcu/tasks.h:369:2: error: implicit declaration of function
'call_rcu_tasks_generic'
On Thu, Mar 05, 2020 at 02:29:26AM +0000, Li, Philip wrote:
> > Subject: [kbuild-all] Re: [rcu:dev.2020.02.29a 43/43] kernel/rcu/tasks.h:369:2:
> > error: implicit declaration of function 'call_rcu_tasks_generic'
> >
> > On Thu, Mar 05, 2020 at 12:40:11AM +0800, kbuild test robot wrote:
> > > tree: https://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
> > dev.2020.02.29a
> > > head: 61f7110d6b78f4c84ea5d5480185740840889af7
> > > commit: 61f7110d6b78f4c84ea5d5480185740840889af7 [43/43] rcu-tasks: Add
> > an RCU-tasks rude variant
> > > config: mips-rm200_defconfig (attached as .config)
> > > compiler: mipsel-linux-gcc (GCC) 5.5.0
> > > reproduce:
> > > wget https://raw.githubusercontent.com/intel/lkp-
> > tests/master/sbin/make.cross -O ~/bin/make.cross
> > > chmod +x ~/bin/make.cross
> > > git checkout 61f7110d6b78f4c84ea5d5480185740840889af7
> > > # save the attached .config to linux build tree
> > > GCC_VERSION=5.5.0 make.cross ARCH=mips
> > >
> > > If you fix the issue, kindly add following tag
> > > Reported-by: kbuild test robot <lkp@...el.com>
> >
> > This is for an obsolete branch. I believe that the replacement commit
> > 8dd788e3ab55 ("rcu-tasks: Add an RCU-tasks rude variant") fixes this.
> got it, Paul.
>
> Kindly ignore later reports against this branch, that some bisections are still in progress,
> sorry for the noise.
Not a problem, just wanted you all to know. Also, just in case you
guys ever have a way of stopping work on now-obsolete branches. ;-)
Thanx, Paul
> Thanks
>
> >
> > Thanx, Paul
> >
> > > All error/warnings (new ones prefixed by >>):
> > >
> > > union { typeof(x) __val; char __c[1]; } __u; \
> > > ^
> > > kernel/rcu/tasks.h:212:7: note: in expansion of macro 'READ_ONCE'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > kernel/rcu/tasks.h:212:18: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > include/linux/compiler.h:287:22: note: in definition of macro '__READ_ONCE'
> > > __read_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:212:7: note: in expansion of macro 'READ_ONCE'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > kernel/rcu/tasks.h:212:18: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > include/linux/compiler.h:287:42: note: in definition of macro '__READ_ONCE'
> > > __read_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:212:7: note: in expansion of macro 'READ_ONCE'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > kernel/rcu/tasks.h:212:18: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > include/linux/compiler.h:289:30: note: in definition of macro '__READ_ONCE'
> > > __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:212:7: note: in expansion of macro 'READ_ONCE'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > kernel/rcu/tasks.h:212:18: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > include/linux/compiler.h:289:50: note: in definition of macro '__READ_ONCE'
> > > __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:212:7: note: in expansion of macro 'READ_ONCE'
> > > if (!READ_ONCE(t->rcu_tasks_holdout) ||
> > > ^
> > > In file included from kernel/rcu/update.c:562:0:
> > > kernel/rcu/tasks.h:213:7: error: 'struct task_struct' has no member named
> > 'rcu_tasks_nvcsw'
> > > t->rcu_tasks_nvcsw != READ_ONCE(t->nvcsw) ||
> > > ^
> > > kernel/rcu/tasks.h:216:28: error: 'struct task_struct' has no member named
> > 'rcu_tasks_idle_cpu'
> > > !is_idle_task(t) && t->rcu_tasks_idle_cpu >= 0)) {
> > > ^
> > > In file included from include/linux/kernel.h:11:0,
> > > from kernel/rcu/update.c:21:
> > > kernel/rcu/tasks.h:217:15: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, false);
> > > ^
> > > include/linux/compiler.h:310:17: note: in definition of macro 'WRITE_ONCE'
> > > union { typeof(x) __val; char __c[1]; } __u = \
> > > ^
> > > kernel/rcu/tasks.h:217:15: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, false);
> > > ^
> > > include/linux/compiler.h:311:30: note: in definition of macro 'WRITE_ONCE'
> > > { .__val = (__force typeof(x)) (val) }; \
> > > ^
> > > kernel/rcu/tasks.h:217:15: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, false);
> > > ^
> > > include/linux/compiler.h:312:22: note: in definition of macro 'WRITE_ONCE'
> > > __write_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:217:15: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, false);
> > > ^
> > > include/linux/compiler.h:312:42: note: in definition of macro 'WRITE_ONCE'
> > > __write_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > In file included from kernel/rcu/update.c:562:0:
> > > kernel/rcu/tasks.h:218:19: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout_list'
> > > list_del_init(&t->rcu_tasks_holdout_list);
> > > ^
> > > In file included from include/linux/kernel.h:15:0,
> > > from kernel/rcu/update.c:21:
> > > kernel/rcu/tasks.h:233:5: error: 'struct task_struct' has no member named
> > 'rcu_tasks_nvcsw'
> > > t->rcu_tasks_nvcsw, t->nvcsw, t->rcu_tasks_holdout,
> > > ^
> > > include/linux/printk.h:300:35: note: in definition of macro 'pr_alert'
> > > printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
> > > ^
> > > kernel/rcu/tasks.h:233:35: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > t->rcu_tasks_nvcsw, t->nvcsw, t->rcu_tasks_holdout,
> > > ^
> > > include/linux/printk.h:300:35: note: in definition of macro 'pr_alert'
> > > printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
> > > ^
> > > kernel/rcu/tasks.h:234:5: error: 'struct task_struct' has no member named
> > 'rcu_tasks_idle_cpu'
> > > t->rcu_tasks_idle_cpu, cpu);
> > > ^
> > > include/linux/printk.h:300:35: note: in definition of macro 'pr_alert'
> > > printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
> > > ^
> > > In file included from kernel/rcu/update.c:562:0:
> > > kernel/rcu/tasks.h: At top level:
> > > >> kernel/rcu/tasks.h:239:38: warning: 'struct rcu_tasks' declared inside
> > parameter list
> > > static void rcu_tasks_wait_gp(struct rcu_tasks *rtp)
> > > ^
> > > >> kernel/rcu/tasks.h:239:38: warning: its scope is only this definition or
> > declaration, which is probably not what you want
> > > kernel/rcu/tasks.h: In function 'rcu_tasks_wait_gp':
> > > kernel/rcu/tasks.h:271:5: error: 'struct task_struct' has no member named
> > 'rcu_tasks_nvcsw'
> > > t->rcu_tasks_nvcsw = READ_ONCE(t->nvcsw);
> > > ^
> > > In file included from include/linux/kernel.h:11:0,
> > > from kernel/rcu/update.c:21:
> > > kernel/rcu/tasks.h:272:16: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, true);
> > > ^
> > > include/linux/compiler.h:310:17: note: in definition of macro 'WRITE_ONCE'
> > > union { typeof(x) __val; char __c[1]; } __u = \
> > > ^
> > > kernel/rcu/tasks.h:272:16: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, true);
> > > ^
> > > include/linux/compiler.h:311:30: note: in definition of macro 'WRITE_ONCE'
> > > { .__val = (__force typeof(x)) (val) }; \
> > > ^
> > > kernel/rcu/tasks.h:272:16: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, true);
> > > ^
> > > include/linux/compiler.h:312:22: note: in definition of macro 'WRITE_ONCE'
> > > __write_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > kernel/rcu/tasks.h:272:16: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout'
> > > WRITE_ONCE(t->rcu_tasks_holdout, true);
> > > ^
> > > include/linux/compiler.h:312:42: note: in definition of macro 'WRITE_ONCE'
> > > __write_once_size(&(x), __u.__c, sizeof(x)); \
> > > ^
> > > In file included from kernel/rcu/update.c:562:0:
> > > kernel/rcu/tasks.h:273:15: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout_list'
> > > list_add(&t->rcu_tasks_holdout_list,
> > > ^
> > > kernel/rcu/tasks.h:286:20: error: 'tasks_rcu_exit_srcu' undeclared (first use in
> > this function)
> > > synchronize_srcu(&tasks_rcu_exit_srcu);
> > > ^
> > > kernel/rcu/tasks.h:286:20: note: each undeclared identifier is reported only
> > once for each function it appears in
> > > In file included from include/linux/kernel.h:11:0,
> > > from kernel/rcu/update.c:21:
> > > kernel/rcu/tasks.h:313:20: error: 'rcu_task_stall_timeout' undeclared (first use
> > in this function)
> > > rtst = READ_ONCE(rcu_task_stall_timeout);
> > > ^
> > > include/linux/compiler.h:285:17: note: in definition of macro '__READ_ONCE'
> > > union { typeof(x) __val; char __c[1]; } __u; \
> > > ^
> > > kernel/rcu/tasks.h:313:10: note: in expansion of macro 'READ_ONCE'
> > > rtst = READ_ONCE(rcu_task_stall_timeout);
> > > ^
> > > include/linux/kernel.h:987:51: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout_list'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/compiler.h:374:9: note: in definition of macro
> > '__compiletime_assert'
> > > if (!(condition)) \
> > > ^
> > > include/linux/compiler.h:394:2: note: in expansion of macro
> > '_compiletime_assert'
> > > _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
> > > ^
> > > include/linux/build_bug.h:39:37: note: in expansion of macro
> > 'compiletime_assert'
> > > #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
> > > ^
> > > include/linux/kernel.h:987:2: note: in expansion of macro
> > 'BUILD_BUG_ON_MSG'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/kernel.h:987:20: note: in expansion of macro '__same_type'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/list.h:493:2: note: in expansion of macro 'container_of'
> > > container_of(ptr, type, member)
> > > ^
> > > include/linux/list.h:504:2: note: in expansion of macro 'list_entry'
> > > list_entry((ptr)->next, type, member)
> > > ^
> > > include/linux/list.h:688:13: note: in expansion of macro 'list_first_entry'
> > > for (pos = list_first_entry(head, typeof(*pos), member), \
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > ^
> > > In file included from <command-line>:0:0:
> > > include/linux/compiler_types.h:129:35: error: 'struct task_struct' has no
> > member named 'rcu_tasks_holdout_list'
> > > #define __compiler_offsetof(a, b) __builtin_offsetof(a, b)
> > > ^
> > > include/linux/stddef.h:17:32: note: in expansion of macro '__compiler_offsetof'
> > > #define offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER)
> > > ^
> > > include/linux/kernel.h:990:21: note: in expansion of macro 'offsetof'
> > > ((type *)(__mptr - offsetof(type, member))); })
> > > ^
> > > include/linux/list.h:493:2: note: in expansion of macro 'container_of'
> > > container_of(ptr, type, member)
> > > ^
> > > include/linux/list.h:504:2: note: in expansion of macro 'list_entry'
> > > list_entry((ptr)->next, type, member)
> > > ^
> > > include/linux/list.h:688:13: note: in expansion of macro 'list_first_entry'
> > > for (pos = list_first_entry(head, typeof(*pos), member), \
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > --
> > > ^
> > > include/linux/list.h:537:2: note: in expansion of macro 'list_entry'
> > > list_entry((pos)->member.next, typeof(*(pos)), member)
> > > ^
> > > include/linux/list.h:691:20: note: in expansion of macro 'list_next_entry'
> > > pos = n, n = list_next_entry(n, member))
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > ^
> > > include/linux/kernel.h:987:51: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout_list'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/compiler.h:374:9: note: in definition of macro
> > '__compiletime_assert'
> > > if (!(condition)) \
> > > ^
> > > include/linux/compiler.h:394:2: note: in expansion of macro
> > '_compiletime_assert'
> > > _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
> > > ^
> > > include/linux/build_bug.h:39:37: note: in expansion of macro
> > 'compiletime_assert'
> > > #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
> > > ^
> > > include/linux/kernel.h:987:2: note: in expansion of macro
> > 'BUILD_BUG_ON_MSG'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/kernel.h:987:20: note: in expansion of macro '__same_type'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/list.h:493:2: note: in expansion of macro 'container_of'
> > > container_of(ptr, type, member)
> > > ^
> > > include/linux/list.h:537:2: note: in expansion of macro 'list_entry'
> > > list_entry((pos)->member.next, typeof(*(pos)), member)
> > > ^
> > > include/linux/list.h:691:20: note: in expansion of macro 'list_next_entry'
> > > pos = n, n = list_next_entry(n, member))
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > ^
> > > include/linux/list.h:537:18: error: 'struct task_struct' has no member named
> > 'rcu_tasks_holdout_list'
> > > list_entry((pos)->member.next, typeof(*(pos)), member)
> > > ^
> > > include/linux/compiler.h:374:9: note: in definition of macro
> > '__compiletime_assert'
> > > if (!(condition)) \
> > > ^
> > > include/linux/compiler.h:394:2: note: in expansion of macro
> > '_compiletime_assert'
> > > _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
> > > ^
> > > include/linux/build_bug.h:39:37: note: in expansion of macro
> > 'compiletime_assert'
> > > #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
> > > ^
> > > include/linux/kernel.h:987:2: note: in expansion of macro
> > 'BUILD_BUG_ON_MSG'
> > > BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
> > > ^
> > > include/linux/kernel.h:988:6: note: in expansion of macro '__same_type'
> > > !__same_type(*(ptr), void), \
> > > ^
> > > include/linux/list.h:493:2: note: in expansion of macro 'container_of'
> > > container_of(ptr, type, member)
> > > ^
> > > include/linux/list.h:537:2: note: in expansion of macro 'list_entry'
> > > list_entry((pos)->member.next, typeof(*(pos)), member)
> > > ^
> > > include/linux/list.h:691:20: note: in expansion of macro 'list_next_entry'
> > > pos = n, n = list_next_entry(n, member))
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > ^
> > > In file included from <command-line>:0:0:
> > > include/linux/compiler_types.h:129:35: error: 'struct task_struct' has no
> > member named 'rcu_tasks_holdout_list'
> > > #define __compiler_offsetof(a, b) __builtin_offsetof(a, b)
> > > ^
> > > include/linux/stddef.h:17:32: note: in expansion of macro '__compiler_offsetof'
> > > #define offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER)
> > > ^
> > > include/linux/kernel.h:990:21: note: in expansion of macro 'offsetof'
> > > ((type *)(__mptr - offsetof(type, member))); })
> > > ^
> > > include/linux/list.h:493:2: note: in expansion of macro 'container_of'
> > > container_of(ptr, type, member)
> > > ^
> > > include/linux/list.h:537:2: note: in expansion of macro 'list_entry'
> > > list_entry((pos)->member.next, typeof(*(pos)), member)
> > > ^
> > > include/linux/list.h:691:20: note: in expansion of macro 'list_next_entry'
> > > pos = n, n = list_next_entry(n, member))
> > > ^
> > > kernel/rcu/tasks.h:319:3: note: in expansion of macro
> > 'list_for_each_entry_safe'
> > > list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > ^
> > > In file included from kernel/rcu/update.c:562:0:
> > > kernel/rcu/tasks.h: At top level:
> > > kernel/rcu/tasks.h:347:1: warning: data definition has no type or storage class
> > > DEFINE_RCU_TASKS(rcu_tasks, rcu_tasks_wait_gp, call_rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h:347:1: error: type defaults to 'int' in declaration of
> > 'DEFINE_RCU_TASKS' [-Werror=implicit-int]
> > > kernel/rcu/tasks.h:347:1: warning: parameter names (without types) in
> > function declaration
> > > kernel/rcu/tasks.h: In function 'call_rcu':
> > > >> kernel/rcu/tasks.h:369:2: error: implicit declaration of function
> > 'call_rcu_tasks_generic' [-Werror=implicit-function-declaration]
> > > call_rcu_tasks_generic(rhp, func, &rcu_tasks);
> > > ^
> > > >> kernel/rcu/tasks.h:369:37: error: 'rcu_tasks' undeclared (first use in this
> > function)
> > > call_rcu_tasks_generic(rhp, func, &rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h: In function 'synchronize_rcu':
> > > >> kernel/rcu/tasks.h:393:2: error: implicit declaration of function
> > 'synchronize_rcu_tasks_generic' [-Werror=implicit-function-declaration]
> > > synchronize_rcu_tasks_generic(&rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h:393:33: error: 'rcu_tasks' undeclared (first use in this
> > function)
> > > synchronize_rcu_tasks_generic(&rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h: In function 'rcu_spawn_tasks_kthread':
> > > >> kernel/rcu/tasks.h:412:2: error: implicit declaration of function
> > 'rcu_spawn_tasks_kthread_generic' [-Werror=implicit-function-declaration]
> > > rcu_spawn_tasks_kthread_generic(&rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h:412:35: error: 'rcu_tasks' undeclared (first use in this
> > function)
> > > rcu_spawn_tasks_kthread_generic(&rcu_tasks);
> > > ^
> > > kernel/rcu/tasks.h: At top level:
> > > kernel/rcu/tasks.h:432:43: warning: 'struct rcu_tasks' declared inside
> > parameter list
> > > static void rcu_tasks_rude_wait_gp(struct rcu_tasks *rtp)
> > > ^
> > > kernel/rcu/tasks.h:439:1: warning: data definition has no type or storage class
> > > DEFINE_RCU_TASKS(rcu_tasks_rude, rcu_tasks_rude_wait_gp,
> > call_rcu_tasks_rude);
> > > ^
> > > kernel/rcu/tasks.h:439:1: error: type defaults to 'int' in declaration of
> > 'DEFINE_RCU_TASKS' [-Werror=implicit-int]
> > > kernel/rcu/tasks.h:439:1: warning: parameter names (without types) in
> > function declaration
> > > kernel/rcu/tasks.h: In function 'call_rcu_tasks_rude':
> > > >> kernel/rcu/tasks.h:461:37: error: 'rcu_tasks_rude' undeclared (first use in this
> > function)
> > > call_rcu_tasks_generic(rhp, func, &rcu_tasks_rude);
> > > ^
> > > kernel/rcu/tasks.h: In function 'synchronize_rcu_tasks_rude':
> > > kernel/rcu/tasks.h:485:33: error: 'rcu_tasks_rude' undeclared (first use in this
> > function)
> > > synchronize_rcu_tasks_generic(&rcu_tasks_rude);
> > > ^
> > > kernel/rcu/tasks.h: In function 'rcu_spawn_tasks_rude_kthread':
> > > kernel/rcu/tasks.h:504:35: error: 'rcu_tasks_rude' undeclared (first use in this
> > function)
> > > rcu_spawn_tasks_kthread_generic(&rcu_tasks_rude);
> > > ^
> > > kernel/rcu/update.c: At top level:
> > > kernel/rcu/tasks.h:239:13: warning: 'rcu_tasks_wait_gp' defined but not used
> > [-Wunused-function]
> > > static void rcu_tasks_wait_gp(struct rcu_tasks *rtp)
> > > ^
> > > cc1: some warnings being treated as errors
> > >
> > > vim +/call_rcu_tasks_generic +369 kernel/rcu/tasks.h
> > >
> > > 237
> > > 238 /* Wait for one RCU-tasks grace period. */
> > > > 239 static void rcu_tasks_wait_gp(struct rcu_tasks *rtp)
> > > 240 {
> > > 241 struct task_struct *g, *t;
> > > 242 unsigned long lastreport;
> > > 243 LIST_HEAD(rcu_tasks_holdouts);
> > > 244 int fract;
> > > 245
> > > 246 /*
> > > 247 * Wait for all pre-existing t->on_rq and t->nvcsw transitions
> > > 248 * to complete. Invoking synchronize_rcu() suffices because all
> > > 249 * these transitions occur with interrupts disabled. Without this
> > > 250 * synchronize_rcu(), a read-side critical section that started
> > > 251 * before the grace period might be incorrectly seen as having
> > > 252 * started after the grace period.
> > > 253 *
> > > 254 * This synchronize_rcu() also dispenses with the need for a
> > > 255 * memory barrier on the first store to t->rcu_tasks_holdout,
> > > 256 * as it forces the store to happen after the beginning of the
> > > 257 * grace period.
> > > 258 */
> > > 259 synchronize_rcu();
> > > 260
> > > 261 /*
> > > 262 * There were callbacks, so we need to wait for an RCU-tasks
> > > 263 * grace period. Start off by scanning the task list for tasks
> > > 264 * that are not already voluntarily blocked. Mark these tasks
> > > 265 * and make a list of them in rcu_tasks_holdouts.
> > > 266 */
> > > 267 rcu_read_lock();
> > > 268 for_each_process_thread(g, t) {
> > > 269 if (t != current && READ_ONCE(t->on_rq)
> > && !is_idle_task(t)) {
> > > 270 get_task_struct(t);
> > > 271 t->rcu_tasks_nvcsw = READ_ONCE(t->nvcsw);
> > > 272 WRITE_ONCE(t->rcu_tasks_holdout, true);
> > > 273 list_add(&t->rcu_tasks_holdout_list,
> > > 274 &rcu_tasks_holdouts);
> > > 275 }
> > > 276 }
> > > 277 rcu_read_unlock();
> > > 278
> > > 279 /*
> > > 280 * Wait for tasks that are in the process of exiting. This
> > > 281 * does only part of the job, ensuring that all tasks that were
> > > 282 * previously exiting reach the point where they have disabled
> > > 283 * preemption, allowing the later synchronize_rcu() to finish
> > > 284 * the job.
> > > 285 */
> > > 286 synchronize_srcu(&tasks_rcu_exit_srcu);
> > > 287
> > > 288 /*
> > > 289 * Each pass through the following loop scans the list of holdout
> > > 290 * tasks, removing any that are no longer holdouts. When the list
> > > 291 * is empty, we are done.
> > > 292 */
> > > 293 lastreport = jiffies;
> > > 294
> > > 295 /* Start off with HZ/10 wait and slowly back off to 1 HZ wait. */
> > > 296 fract = 10;
> > > 297
> > > 298 for (;;) {
> > > 299 bool firstreport;
> > > 300 bool needreport;
> > > 301 int rtst;
> > > 302 struct task_struct *t1;
> > > 303
> > > 304 if (list_empty(&rcu_tasks_holdouts))
> > > 305 break;
> > > 306
> > > 307 /* Slowly back off waiting for holdouts */
> > > 308 schedule_timeout_interruptible(HZ/fract);
> > > 309
> > > 310 if (fract > 1)
> > > 311 fract--;
> > > 312
> > > 313 rtst = READ_ONCE(rcu_task_stall_timeout);
> > > 314 needreport = rtst > 0 && time_after(jiffies, lastreport +
> > rtst);
> > > 315 if (needreport)
> > > 316 lastreport = jiffies;
> > > 317 firstreport = true;
> > > 318 WARN_ON(signal_pending(current));
> > > 319 list_for_each_entry_safe(t, t1, &rcu_tasks_holdouts,
> > > 320 rcu_tasks_holdout_list) {
> > > 321 check_holdout_task(t, needreport, &firstreport);
> > > 322 cond_resched();
> > > 323 }
> > > 324 }
> > > 325
> > > 326 /*
> > > 327 * Because ->on_rq and ->nvcsw are not guaranteed to have a full
> > > 328 * memory barriers prior to them in the schedule() path, memory
> > > 329 * reordering on other CPUs could cause their RCU-tasks read-
> > side
> > > 330 * critical sections to extend past the end of the grace period.
> > > 331 * However, because these ->nvcsw updates are carried out with
> > > 332 * interrupts disabled, we can use synchronize_rcu() to force the
> > > 333 * needed ordering on all such CPUs.
> > > 334 *
> > > 335 * This synchronize_rcu() also confines all ->rcu_tasks_holdout
> > > 336 * accesses to be within the grace period, avoiding the need for
> > > 337 * memory barriers for ->rcu_tasks_holdout accesses.
> > > 338 *
> > > 339 * In addition, this synchronize_rcu() waits for exiting tasks
> > > 340 * to complete their final preempt_disable() region of execution,
> > > 341 * cleaning up after the synchronize_srcu() above.
> > > 342 */
> > > 343 synchronize_rcu();
> > > 344 }
> > > 345
> > > 346 void call_rcu_tasks(struct rcu_head *rhp, rcu_callback_t func);
> > > 347 DEFINE_RCU_TASKS(rcu_tasks, rcu_tasks_wait_gp, call_rcu_tasks);
> > > 348
> > > 349 /**
> > > 350 * call_rcu_tasks() - Queue an RCU for invocation task-based grace
> > period
> > > 351 * @rhp: structure to be used for queueing the RCU updates.
> > > 352 * @func: actual callback function to be invoked after the grace period
> > > 353 *
> > > 354 * The callback function will be invoked some time after a full grace
> > > 355 * period elapses, in other words after all currently executing RCU
> > > 356 * read-side critical sections have completed. call_rcu_tasks() assumes
> > > 357 * that the read-side critical sections end at a voluntary context
> > > 358 * switch (not a preemption!), cond_resched_rcu_qs(), entry into idle,
> > > 359 * or transition to usermode execution. As such, there are no read-side
> > > 360 * primitives analogous to rcu_read_lock() and rcu_read_unlock() because
> > > 361 * this primitive is intended to determine that all tasks have passed
> > > 362 * through a safe state, not so much for data-strcuture synchronization.
> > > 363 *
> > > 364 * See the description of call_rcu() for more detailed information on
> > > 365 * memory ordering guarantees.
> > > 366 */
> > > 367 void call_rcu_tasks(struct rcu_head *rhp, rcu_callback_t func)
> > > 368 {
> > > > 369 call_rcu_tasks_generic(rhp, func, &rcu_tasks);
> > > 370 }
> > > 371 EXPORT_SYMBOL_GPL(call_rcu_tasks);
> > > 372
> > > 373 /**
> > > 374 * synchronize_rcu_tasks - wait until an rcu-tasks grace period has
> > elapsed.
> > > 375 *
> > > 376 * Control will return to the caller some time after a full rcu-tasks
> > > 377 * grace period has elapsed, in other words after all currently
> > > 378 * executing rcu-tasks read-side critical sections have elapsed. These
> > > 379 * read-side critical sections are delimited by calls to schedule(),
> > > 380 * cond_resched_tasks_rcu_qs(), idle execution, userspace execution,
> > calls
> > > 381 * to synchronize_rcu_tasks(), and (in theory, anyway) cond_resched().
> > > 382 *
> > > 383 * This is a very specialized primitive, intended only for a few uses in
> > > 384 * tracing and other situations requiring manipulation of function
> > > 385 * preambles and profiling hooks. The synchronize_rcu_tasks() function
> > > 386 * is not (yet) intended for heavy use from multiple CPUs.
> > > 387 *
> > > 388 * See the description of synchronize_rcu() for more detailed information
> > > 389 * on memory ordering guarantees.
> > > 390 */
> > > 391 void synchronize_rcu_tasks(void)
> > > 392 {
> > > > 393 synchronize_rcu_tasks_generic(&rcu_tasks);
> > > 394 }
> > > 395 EXPORT_SYMBOL_GPL(synchronize_rcu_tasks);
> > > 396
> > > 397 /**
> > > 398 * rcu_barrier_tasks - Wait for in-flight call_rcu_tasks() callbacks.
> > > 399 *
> > > 400 * Although the current implementation is guaranteed to wait, it is not
> > > 401 * obligated to, for example, if there are no pending callbacks.
> > > 402 */
> > > 403 void rcu_barrier_tasks(void)
> > > 404 {
> > > 405 /* There is only one callback queue, so this is easy. ;-) */
> > > 406 synchronize_rcu_tasks();
> > > 407 }
> > > 408 EXPORT_SYMBOL_GPL(rcu_barrier_tasks);
> > > 409
> > > 410 static int __init rcu_spawn_tasks_kthread(void)
> > > 411 {
> > > > 412 rcu_spawn_tasks_kthread_generic(&rcu_tasks);
> > > 413 return 0;
> > > 414 }
> > > 415 core_initcall(rcu_spawn_tasks_kthread);
> > > 416
> > > 417 ////////////////////////////////////////////////////////////////////////
> > > 418 //
> > > 419 // "Rude" variant of Tasks RCU, inspired by Steve Rostedt's trick of
> > > 420 // passing an empty function to schedule_on_each_cpu(). This approach
> > > 421 // provides an asynchronous call_rcu_rude() API and batching of
> > concurrent
> > > 422 // calls to the synchronous synchronize_rcu_rude() API. This sends IPIs
> > > 423 // far and wide and induces otherwise unnecessary context switches on all
> > > 424 // online CPUs, whether online or not.
> > > 425
> > > 426 // Empty function to allow workqueues to force a context switch.
> > > 427 static void rcu_tasks_be_rude(struct work_struct *work)
> > > 428 {
> > > 429 }
> > > 430
> > > 431 // Wait for one rude RCU-tasks grace period.
> > > 432 static void rcu_tasks_rude_wait_gp(struct rcu_tasks *rtp)
> > > 433 {
> > > 434 schedule_on_each_cpu(rcu_tasks_be_rude);
> > > 435 }
> > > 436 EXPORT_SYMBOL_GPL(rcu_tasks_rude_wait_gp);
> > > 437
> > > 438 void call_rcu_tasks_rude(struct rcu_head *rhp, rcu_callback_t func);
> > > 439 DEFINE_RCU_TASKS(rcu_tasks_rude, rcu_tasks_rude_wait_gp,
> > call_rcu_tasks_rude);
> > > 440
> > > 441 /**
> > > 442 * call_rcu_tasks_rude() - Queue a callback rude task-based grace period
> > > 443 * @rhp: structure to be used for queueing the RCU updates.
> > > 444 * @func: actual callback function to be invoked after the grace period
> > > 445 *
> > > 446 * The callback function will be invoked some time after a full grace
> > > 447 * period elapses, in other words after all currently executing RCU
> > > 448 * read-side critical sections have completed. call_rcu_tasks_rude()
> > > 449 * assumes that the read-side critical sections end at context switch,
> > > 450 * cond_resched_rcu_qs(), or transition to usermode execution. As such,
> > > 451 * there are no read-side primitives analogous to rcu_read_lock() and
> > > 452 * rcu_read_unlock() because this primitive is intended to determine
> > > 453 * that all tasks have passed through a safe state, not so much for
> > > 454 * data-strcuture synchronization.
> > > 455 *
> > > 456 * See the description of call_rcu() for more detailed information on
> > > 457 * memory ordering guarantees.
> > > 458 */
> > > 459 void call_rcu_tasks_rude(struct rcu_head *rhp, rcu_callback_t func)
> > > 460 {
> > > > 461 call_rcu_tasks_generic(rhp, func, &rcu_tasks_rude);
> > > 462 }
> > > 463 EXPORT_SYMBOL_GPL(call_rcu_tasks_rude);
> > > 464
> > >
> > > ---
> > > 0-DAY CI Kernel Test Service, Intel Corporation
> > > https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
> >
> > _______________________________________________
> > kbuild-all mailing list -- kbuild-all@...ts.01.org
> > To unsubscribe send an email to kbuild-all-leave@...ts.01.org
Powered by blists - more mailing lists