are zero, rcutorture acts as if is interpreted

they are all non-zero.

rcutorture.irqreader= [KNL]

Run RCU readers from irq handlers, or, more

accurately, from a timer handler. Not all RCU

/* Low-order bit definition for polled grace-period APIs. */

#define RCU_GET_STATE_COMPLETED 0x1

extern int sysctl_sched_rt_runtime;

/*

* Given a snapshot from rcu_seq_snap(), determine whether or not a

* full update-side operation has occurred, but do not allow the

* (ULONG_MAX / 2) safety-factor/guard-band.

*/

static inline bool rcu_seq_done_exact(unsigned long *sp, unsigned long s)

{

unsigned long cur_s = READ_ONCE(*sp);

}

/*

unsigned long c_old,

unsigned long c);

void rcu_gp_set_torture_wait(int duration);

#else

static inline void rcutorture_get_gp_data(int *flags, unsigned long *gp_seq)

{

do { } while (0)

#endif

static inline void rcu_gp_set_torture_wait(int duration) { }

#endif

unsigned long long rcutorture_gather_gp_seqs(void);

void rcutorture_format_gp_seqs(unsigned long long seqs, char *cp, size_t len);

torture_param(int, object_debug, 0, "Enable debug-object double call_rcu() testing");

torture_param(int, onoff_holdoff, 0, "Time after boot before CPU hotplugs (s)");

torture_param(int, onoff_interval, 0, "Time between CPU hotplugs (jiffies), 0=disable");

torture_param(int, nocbs_nthreads, 0, "Number of NOCB toggle threads, 0 to disable");

torture_param(int, nocbs_toggle, 1000, "Time between toggling nocb state (ms)");

torture_param(int, preempt_duration, 0, "Preemption duration (ms), zero to disable");

bool (*reader_blocked)(void);

unsigned long long (*gather_gp_seqs)(void);

void (*format_gp_seqs)(unsigned long long seqs, char *cp, size_t len);

long cbflood_max;

int irq_capable;

int can_boost;

: NULL,

.gather_gp_seqs = rcutorture_gather_gp_seqs,

.format_gp_seqs = rcutorture_format_gp_seqs,

.irq_capable = 1,

.can_boost = IS_ENABLED(CONFIG_RCU_BOOST),

.extendables = RCUTORTURE_MAX_EXTEND,

return &rtrsp[j];

}

unsigned long cookie;

struct rcu_gp_oldstate cookie_full;

unsigned long started;

struct rcu_torture *p;

unsigned long long ts;

if (cur_ops->get_gp_state && cur_ops->poll_gp_state)

if (cur_ops->get_gp_state_full && cur_ops->poll_gp_state_full)

}

!cur_ops->readlock_held || cur_ops->readlock_held());

/* Wait for rcu_torture_writer to get underway */

return false;

}

atomic_inc(&n_rcu_torture_mberror);

preempt_disable();

if (pipe_count > RCU_TORTURE_PIPE_LEN) {

// Should not happen in a correct RCU implementation,

// happens quite often for torture_type=busted.

}

completed = cur_ops->get_gp_seq();

if (pipe_count > 1) {

rcu_ftrace_dump(DUMP_ALL);

}

__this_cpu_inc(rcu_torture_count[pipe_count]);

if (completed > RCU_TORTURE_PIPE_LEN) {

/* Should not happen, but... */

completed = RCU_TORTURE_PIPE_LEN;

}

__this_cpu_inc(rcu_torture_batch[completed]);

preempt_enable();

if (cur_ops->get_gp_state && cur_ops->poll_gp_state)

"%s: Cookie check 2 failed %s(%d) %lu->%lu\n",

__func__,

rcu_torture_writer_state_getname(),

rcu_torture_writer_state,

if (cur_ops->get_gp_state_full && cur_ops->poll_gp_state_full)

"%s: Cookie check 6 failed %s(%d) online %*pbl\n",

__func__,

rcu_torture_writer_state_getname(),

}

if (cur_ops->reader_blocked)

preempted = cur_ops->reader_blocked();

// This next splat is expected behavior if leakpointer, especially

// for CONFIG_RCU_STRICT_GRACE_PERIOD=y kernels.

/* If error or close call, record the sequence of reader protections. */

if ((pipe_count > 1 || completed > 1) && !xchg(&err_segs_recorded, 1)) {

i = 0;

err_segs[i++] = *rtrsp1;

rt_read_nsegs = i;

rt_read_preempted = preempted;

}

return true;

}

set_user_nice(current, MAX_NICE);

if (irqreader && cur_ops->irq_capable)

timer_setup_on_stack(&t, rcu_torture_timer, 0);

do {

if (irqreader && cur_ops->irq_capable) {

if (!timer_pending(&t))

int i;

long pipesummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };

long batchsummary[RCU_TORTURE_PIPE_LEN + 1] = { 0 };

struct rcu_torture *rtcp;

static unsigned long rtcv_snap = ULONG_MAX;

static bool splatted;

pipesummary[i] += READ_ONCE(per_cpu(rcu_torture_count, cpu)[i]);

batchsummary[i] += READ_ONCE(per_cpu(rcu_torture_batch, cpu)[i]);

}

}

for (i = RCU_TORTURE_PIPE_LEN; i >= 0; i--) {

if (pipesummary[i] != 0)

data_race(n_barrier_attempts),

data_race(n_rcu_torture_barrier_error));

pr_cont("read-exits: %ld ", data_race(n_read_exits)); // Statistic.

atomic_long_read(&n_nocb_offload), atomic_long_read(&n_nocb_deoffload));

pr_alert("%s%s ", torture_type, TORTURE_FLAG);

if (atomic_read(&n_rcu_torture_mberror) ||

cver = READ_ONCE(rcu_torture_current_version);

gps = cur_ops->get_gp_seq();

rfp->rcu_launder_gp_seq_start = gps;

while (time_before(jiffies, stopat) &&

!shutdown_time_arrived() &&

!READ_ONCE(rcu_fwd_emergency_stop) && !torture_must_stop()) {

static enum cpuhp_state rcutor_hp;

static void

rcu_torture_cleanup(void)

{

torture_cleanup_end();

if (cur_ops->gp_slow_unregister)

cur_ops->gp_slow_unregister(NULL);

}

static void rcu_torture_leak_cb(struct rcu_head *rhp)

}

if (object_debug)

rcu_test_debug_objects();

if (cur_ops->gp_slow_register && !WARN_ON_ONCE(!cur_ops->gp_slow_unregister))

cur_ops->gp_slow_register(&rcu_fwd_cb_nodelay);

return 0;

unwind:

bool poll_state_synchronize_srcu(struct srcu_struct *ssp, unsigned long cookie)

{

if (cookie != SRCU_GET_STATE_COMPLETED &&

return false;

// Ensure that the end of the SRCU grace period happens before

// any subsequent code that the caller might execute.

static DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_data, rcu_data) = {

.gpwrap = true,

};

static struct rcu_state rcu_state = {

.level = { &rcu_state.node[0] },

.gp_state = RCU_GP_IDLE,

smp_store_release(per_cpu_ptr(&rcu_data.rcu_urgent_qs, cpu), true);

}

/*

* When trying to report a quiescent state on behalf of some other CPU,

* it is our responsibility to check for and handle potential overflow

static void rcu_gpnum_ovf(struct rcu_node *rnp, struct rcu_data *rdp)

{

raw_lockdep_assert_held_rcu_node(rnp);

WRITE_ONCE(rdp->gpwrap, true);

if (ULONG_CMP_LT(rdp->rcu_iw_gp_seq + ULONG_MAX / 4, rnp->gp_seq))

rdp->rcu_iw_gp_seq = rnp->gp_seq + ULONG_MAX / 4;

}

struct rcu_data *rdp;

struct rcu_node *rnp = rcu_get_root();

bool start_new_poll;

WRITE_ONCE(rcu_state.gp_activity, jiffies);

raw_spin_lock_irq_rcu_node(rnp);

*/

start_new_poll = rcu_sr_normal_gp_init();

/* Record GP times before starting GP, hence rcu_seq_start(). */

rcu_seq_start(&rcu_state.gp_seq);

ASSERT_EXCLUSIVE_WRITER(rcu_state.gp_seq);

trace_rcu_grace_period(rcu_state.name, rcu_state.gp_seq, TPS("start"));

rcu_poll_gp_seq_start(&rcu_state.gp_seq_polled_snap);

bool core_needs_qs; /* Core waits for quiescent state. */

bool beenonline; /* CPU online at least once. */

bool gpwrap; /* Possible ->gp_seq wrap. */

bool cpu_started; /* RCU watching this onlining CPU. */

struct rcu_node *mynode; /* This CPU's leaf of hierarchy */

unsigned long grpmask; /* Mask to apply to leaf qsmask. */

"kunmap" => "kunmap_local",

"kmap_atomic" => "kmap_local_page",

"kunmap_atomic" => "kunmap_local",

);

#Create a search pattern for all these strings to speed up a loop below

#

# Authors: Paul E. McKenney <paulmck@kernel.org>

grep -v 'ODEBUG: ' |

grep -v 'This means that this is a DEBUG kernel and it is' |

grep -v 'Warning: unable to open an initial console' |

cp $T/KcList $resdir/ConfigFragment

base_resdir=`echo $resdir | sed -e 's/\.[0-9]\+$//'`

then

# Rerunning previous test, so use that test's kernel.

QEMU="`identify_qemu $base_resdir/vmlinux`"

summary="$summary KCSAN: $n_kcsan"

fi

fi

if test "$n_calltrace" -ne 0

then

summary="$summary Call Traces: $n_calltrace"

shift

done

nerrs=0

for d in 0 1

do

for t in 0 1 2

tools/testing/selftests/rcutorture/bin/kvm.sh --allcpus --duration 5s --configs "SRCU-P" --kconfig "CONFIG_FORCE_NEED_SRCU_NMI_SAFE=y" --bootargs "rcutorture.test_srcu_lockdep=$val rcutorture.reader_flavor=0x2" --trust-make --datestamp "$ds/$val" > "$T/kvm.sh.out" 2>&1

ret=$?

mv "$T/kvm.sh.out" "$RCUTORTURE/res/$ds/$val"

if test "$d" -ne 0 && test "$ret" -eq 0

then

err=1

done

done

done

if test "$nerrs" -ne 0

then

exit 1

do_rcuscale=yes

do_refscale=yes

do_kvfree=yes

do_kasan=yes

do_kcsan=no

do_clocksourcewd=yes

do_rt=yes

do_rcutasksflavors=yes

do_srcu_lockdep=yes

# doyesno - Helper function for yes/no arguments

function doyesno () {

echo " --do-rcutorture / --do-no-rcutorture / --no-rcutorture"

echo " --do-refscale / --do-no-refscale / --no-refscale"

echo " --do-rt / --do-no-rt / --no-rt"

echo " --do-scftorture / --do-no-scftorture / --no-scftorture"

echo " --do-srcu-lockdep / --do-no-srcu-lockdep / --no-srcu-lockdep"

echo " --duration [ <minutes> | <hours>h | <days>d ]"

do_refscale=yes

do_rt=yes

do_kvfree=yes

do_kasan=yes

do_kcsan=yes

do_clocksourcewd=yes

do_refscale=no

do_rt=no

do_kvfree=no

do_kasan=no

do_kcsan=no

do_clocksourcewd=no

do_srcu_lockdep=no

;;

--do-rcuscale|--do-no-rcuscale|--no-rcuscale)

do_rcuscale=`doyesno "$1" --do-rcuscale`

;;

--do-rt|--do-no-rt|--no-rt)

do_rt=`doyesno "$1" --do-rt`

;;

--do-scftorture|--do-no-scftorture|--no-scftorture)

do_scftorture=`doyesno "$1" --do-scftorture`

;;

echo " --- " $scriptname $args | tee -a $T/log

echo " --- Results directory: " $ds | tee -a $T/log

# Calculate rcutorture defaults and apportion time

if test -z "$configs_rcutorture"

then

local kcsan_kmake_tag=

local flavor=$1

shift

if test "$do_kasan" = "yes"

then

curflavor=${flavor}-kasan

if test "$do_rt" = "yes"

then

# With all post-boot grace periods forced to expedited.

fi

if test "$do_srcu_lockdep" = "yes"

CONFIG_NO_HZ_FULL=n

CONFIG_RCU_TRACE=y

CONFIG_HOTPLUG_CPU=y

CONFIG_RCU_NOCB_CPU=y

CONFIG_DEBUG_LOCK_ALLOC=n

CONFIG_RCU_BOOST=n

rcutree.gp_preinit_delay=3

rcutree.gp_init_delay=3

rcutree.gp_cleanup_delay=3