Hi Paul, On 3/2/2024 8:01 PM, Joel Fernandes wrote: >> As you noted, one thing that Ankur's series changes is that preemption >> can occur anywhere that it is not specifically disabled in kernels >> built with CONFIG_PREEMPT_NONE=y or CONFIG_PREEMPT_VOLUNTARY=y. This in >> turn changes Tasks Rude RCU's definition of a quiescent state for these >> kernels, adding all code regions where preemption is not specifically >> disabled to the list of such quiescent states. >> >> Although from what I know, this is OK, it would be good to check the >> calls to call_rcu_tasks_rude() or synchronize_rcu_tasks_rude() are set >> up so as to expect these new quiescent states. One example where it >> would definitely be OK is if there was a call to synchronize_rcu_tasks() >> right before or after that call to synchronize_rcu_tasks_rude(). >> >> Would you be willing to check the call sites to verify that they >> are OK with this change in > Yes, I will analyze and make sure those users did not unexpectedly > assume something about AUTO (i.e. preempt enabled sections using > readers). Other than RCU test code, there are just 3 call sites for RUDE right now, all in ftrace.c. (Long story short, PREEMPT_AUTO should not cause wreckage in TASKS_RCU_RUDE other than any preexisting wreckage that !PREEMPT_AUTO already had. Steve is on CC as well to CMIIW). Case 1: For !CONFIG_DYNAMIC_FTRACE update of ftrace_trace_function This config is itself expected to be slow. However seeing what it does, it is trying to make sure the global function pointer "ftrace_trace_function" is updated and any readers of that pointers would have finished reading it. I don't personally think preemption has to be disabled across the entirety of the section that calls into this function. So sensitivity to preempt disabling should not be relevant for this case IMO, but lets see if ftrace folks disagree (on CC). It has more to do with, any callers of this function pointer are no longer calling into the old function. Case 2: Trampoline structures accessing For this there is a code comment that says preemption will disabled so it should not be dependent on any of the preemptiblity modes, because preempt_disable() should disable preempt with PREEMPT_AUTO. /* * We need to do a hard force of sched synchronization. * This is because we use preempt_disable() to do RCU, but * the function tracers can be called where RCU is not watching * (like before user_exit()). We can not rely on the RCU * infrastructure to do the synchronization, thus we must do it * ourselves. */ synchronize_rcu_tasks_rude(); [...] ftrace_trampoline_free(ops); Code comment probably needs update because it says 'can not rely on RCU..' ;-) My *guess* is the preempt_disable() mentioned in this case is ftrace_ops_trampoline() where trampoline-related datas tructures are accessed for stack unwinding purposes. This is a data structure protection thing AFAICS and nothing to do with "trampoline execution" itself which needs "Tasks RCU" to allow for preemption in trampolines. Case 3: This has to do with update of function graph tracing and there is the same comment as case 2, where preempt will be disabled in readers, so it should be safe for PREEMPT_AUTO (famous last words). Though I am not yet able to locate that preempt_disable() which is not an PREEMPT_AUTO-related issue anyway. Maybe its buried in function graph tracing logic somewhere? Finally, my thought also was, if any of these thread usages/cases of Tasks RCU RUDE assume working only on a CONFIG_PREEMPT_NONE=y or CONFIG_PREEMPT_VOLUNTARY=y kernel, that could be worrying but AFAICS, they don't assume anything related to that. thanks, - Joel
