[LTP] [PATCH 4/5] fzsync: Simplify API with start/end race calls and limit exec time
Richard Palethorpe
rpalethorpe@suse.com
Tue Aug 28 11:30:01 CEST 2018
Make it so the test writer simply has to mark the beginning and end of a race
in each thread. Previously they must choose where to call a delay and where to
call a timestamp function which is used to calculate the delay as well as the
update function.
Along with the new API a randomised delay has been introduced which helps hit
some race conditions (see doc comments).
Also use the tst_timer library to check how long the main test loop has been
running for and break the loop if it exceeds (60 * LTP_TIMEOUT_MUL)
seconds. This prevents an overall test timeout which is reported as a failure.
Signed-off-by: Richard Palethorpe <rpalethorpe@suse.com>
---
include/tst_fuzzy_sync.h | 634 +++++++++++++++++++++++++++++----------
1 file changed, 468 insertions(+), 166 deletions(-)
diff --git a/include/tst_fuzzy_sync.h b/include/tst_fuzzy_sync.h
index bcc625e24..6ed509154 100644
--- a/include/tst_fuzzy_sync.h
+++ b/include/tst_fuzzy_sync.h
@@ -14,159 +14,302 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-/*
+/**
+ * @file tst_fuzzy_sync.h
* Fuzzy Synchronisation - abreviated to fzsync
*
- * This library is intended to help reproduce race conditions by providing two
- * thread synchronisation mechanisms. The first is a 'checkpoint' system where
- * each thread will wait indefinitely for the other to enter a checkpoint
- * before continuing. This is acheived by calling tst_fzsync_wait() and/or
- * tst_fzsync_wait_update() at the points you want to synchronise in each
- * thread. This is functionally very similar to using pthread_barrier_wait()
- * with two threads. However tst_fzsync_wait() can be inlined and is
- * guaranteed not to call sleep or futex.
- *
- * The second takes the form a of a delay which is calculated by measuring the
- * time difference between two points in each thread and comparing it to the
- * desired difference (default is zero). Using a delay allows you to
- * synchronise the threads at a point outside of your direct control
- * (e.g. inside the kernel) or just increase the accuracy for the first
- * mechanism. It is acheived using tst_fzsync_delay_{a,b}(),
- * tst_fzsync_time_{a,b}() and tst_fzsync[_wait_]update().
+ * This library is intended to help reproduce race conditions by synchronising
+ * two threads at a given place by marking the range a race may occur
+ * in. Because the exact place where any race occurs is whithin the kernel,
+ * and therefor impossible to mark accurately, the library may add randomised
+ * delays to either thread in order to help find the exact race timing.
+ *
+ * Currently only two way races are explicitly supported, that is races
+ * involving two threads or processes. We refer to the main test thread as
+ * thread A and the child thread as thread B.
+ *
+ * In each thread you need a simple while or for loop which you call the
+ * tst_fzsync_* functions in. In the simplest case thread A will look
+ * something like:
+ *
+ * tst_fzsync_pair_reset(&pair, run_thread_b);
+ * for (;;) {
+ * // Perform some setup which must happen before the race
+ * if (!tst_fzsync_start_race_a(&pair))
+ * break;
+ * // Do some dodgy syscall
+ * tst_fzsync_end_race_a(&pair);
+ * }
+ *
+ * Then in thread B (run_thread_b):
+ *
+ * while (tst_fzsync_start_race_b(&pair)) {
+ * // Do something which can race with the dodgy syscall in A
+ * if (!tst_fzsync_end_race_b(&pair))
+ * break;
+ * }
+ *
+ * The calls to tst_fzsync_start/end_race act as barriers which niether thread
+ * will cross until the other has reached it. You can add more barriers by
+ * using tst_fzsync_wait_a() and tst_fzsync_wait_b() in each thread.
+ *
+ * You may limit the loop in thread A to a certain number of loops or just
+ * allow fzsync to timeout. This is 60 seconds by default, but you can change
+ * it by setting tst_fzsync_pair::execution_time before calling
+ * tst_fzsync_pair_reset().
+ *
+ * Generally speaking whatever loop or time limit you choose it will be wrong
+ * on some subset of systems supported by Linux, but a best guess, based on
+ * whatever systems you have access to, should suffice.
+ *
+ * It is possible to use the library just for tst_fzsync_pair_wait() to get a
+ * basic spin wait. However if you are actually testing a race condition then
+ * it is recommended to use tst_fzsync_start_race_a/b even if the
+ * randomisation is not needed. It provides some semantic information which
+ * may be useful in the future.
*
* For a usage example see testcases/cve/cve-2016-7117.c or just run
* 'git grep tst_fuzzy_sync.h'
+ *
+ * @sa tst_fzsync_pair
*/
#include <sys/time.h>
#include <time.h>
#include <math.h>
+#include <stdlib.h>
#include "tst_atomic.h"
+#include "tst_timer.h"
+#include "tst_safe_pthread.h"
-#ifndef CLOCK_MONOTONIC_RAW
-# define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC
-#endif
+/** Some statistics for a variable */
+struct tst_fzsync_stat {
+ float avg;
+ float avg_dev;
+ float dev_ratio;
+};
/**
- * struct tst_fzsync_pair - the state of a two way synchronisation
- * @avg_diff: Internal; the average time difference over multiple iterations.
- * @avg_diff_trgt: The desired average time difference, defaults to 0.
- * @avg_alpha: The rate at which old diff samples are forgotten,
- * defaults to 0.25.
- * @avg_dev: Internal; Absolute average deviation.
- * @a: Internal; The time at which call site A was last passed.
- * @b: Internal; The time at which call site B was last passed.
- * @delay: Internal; The size of the delay, positive to delay A,
- * negative to delay B.
- * @delay_inc: The step size of a delay increment, defaults to 1.
- * @update_gap: The number of iterations between recalculating the delay.
- * Defaults to 0xF and must be of the form $2^n - 1$
- * @info_gap: The number of iterations between printing some statistics.
- * Defaults to 0x7FFFF and must also be one less than a power of 2.
- * @a_cntr: Internal; Atomic counter used by fzsync_pair_wait()
- * @b_cntr: Internal; Atomic counter used by fzsync_pair_wait()
- * @exit: Internal; Used by tst_fzsync_pair_exit() and fzsync_pair_wait()
- *
- * This contains all the necessary state for synchronising two points A and
- * B. Where A is the time of an event in one process and B is the time of an
- * event in another process.
+ * The state of a two way synchronisation or race.
+ *
+ * This contains all the necessary state for approximately synchronising two
+ * sections of code in different threads.
*
* Internal fields should only be accessed by library functions.
*/
struct tst_fzsync_pair {
- float avg_diff;
- float avg_diff_trgt;
+ /**
+ * The rate at which old diff samples are forgotten
+ *
+ * Defaults to 0.25.
+ */
float avg_alpha;
- float avg_dev;
- struct timespec a;
- struct timespec b;
- long delay;
- long delay_inc;
- int update_gap;
- int info_gap;
+ /** Internal; Thread A start time */
+ struct timespec a_start;
+ /** Internal; Thread B start time */
+ struct timespec b_start;
+ /** Internal; Thread A end time */
+ struct timespec a_end;
+ /** Internal; Thread B end time */
+ struct timespec b_end;
+ /** Internal; Avg. difference between a_start and b_start */
+ struct tst_fzsync_stat diff_ss;
+ /** Internal; Avg. difference between a_start and a_end */
+ struct tst_fzsync_stat diff_sa;
+ /** Internal; Avg. difference between b_start and b_end */
+ struct tst_fzsync_stat diff_sb;
+ /** Internal; Avg. difference between a_end and b_end */
+ struct tst_fzsync_stat diff_ab;
+ /** Internal; Number of spins while waiting for the slower thread */
+ int spins;
+ struct tst_fzsync_stat spins_avg;
+ /**
+ * Internal; Number of spins to use in the delay.
+ *
+ * A negative value delays thread A and a positive delays thread B.
+ */
+ int delay;
+ /**
+ * Internal; The number of samples left or the sampling state.
+ *
+ * A positive value is the number of remaining mandatory
+ * samples. Zero or a negative indicate ssome other state.
+ */
+ int sampling;
+ /**
+ * The Minimum number of statistical samples which must be collected.
+ *
+ * The minimum number of iterations which must be performed before a
+ * random delay can be calculated. Defaults to 1024.
+ */
+ int min_samples;
+ /**
+ * The maximum allowed proportional average deviation.
+ *
+ * A value in the range (0, 1) which gives the maximum average
+ * deviation which must be attained before random delays can be
+ * calculated.
+ *
+ * It is a ratio of (average_deviation / total_time). The default is
+ * 0.1, so this allows an average deviation of at most 10%.
+ */
+ float max_dev_ratio;
+ /** Internal; Atomic counter used by fzsync_pair_wait() */
int a_cntr;
+ /** Internal; Atomic counter used by fzsync_pair_wait() */
int b_cntr;
+ /** Internal; Used by tst_fzsync_pair_exit() and fzsync_pair_wait() */
int exit;
+ /** Internal; Used to limit the execution time. */
+ struct tst_timer timer;
+ /**
+ * The maximum time, in seconds, the test loop should be run.
+ *
+ * If the test runs for this amount of time without crashing or
+ * reaching some iteration limit, the wait and race functions will
+ * return zero signalling that the test loop should end.
+ *
+ * Note that this value is multiplied by LTP_TIMEOUT_MUL.
+ *
+ * Defaults to 60 seconds.
+ */
+ int execution_time;
+ /** Internal; The second thread or NULL */
+ pthread_t thread_b;
};
/**
- * TST_FZSYNC_PAIR_INIT - Default values for struct tst_fzysnc_pair
+ * Default static values for struct tst_fzysnc_pair
*/
#define TST_FZSYNC_PAIR_INIT { \
.avg_alpha = 0.25, \
- .delay_inc = 1, \
- .update_gap = 0xF, \
- .info_gap = 0x7FFFF \
+ .min_samples = 1024, \
+ .max_dev_ratio = 0.1, \
+ .execution_time = 60 \
}
/**
- * tst_fzsync_pair_info - Print some synchronisation statistics
+ * Indicate that all threads should exit
+ *
+ * @relates tst_fzsync_pair
+ *
+ * Causes tst_fzsync_pair_wait(), and any functions which use it, to return 0.
*/
-static void tst_fzsync_pair_info(struct tst_fzsync_pair *pair)
+static inline void tst_fzsync_pair_exit(struct tst_fzsync_pair *pair)
{
- tst_res(TINFO,
- "avg_diff = %.0fns, avg_dev = %.0fns, delay = %05ld loops",
- pair->avg_diff, pair->avg_dev, pair->delay);
+ tst_atomic_store(1, &pair->exit);
}
/**
- * tst_fzsync_delay_a - Perform spin delay for A, if needed
+ * Exit and join thread B if necessary.
+ *
+ * @relates tst_fzsync_pair
*
- * Usually called just before the point you want to synchronise.
+ * Call this from your cleanup function.
*/
-static inline void tst_fzsync_delay_a(struct tst_fzsync_pair *pair)
+static void tst_fzsync_pair_cleanup(struct tst_fzsync_pair *pair)
{
- volatile long spin_delay = pair->delay;
-
- while (spin_delay > 0)
- spin_delay--;
+ if (pair->thread_b) {
+ tst_fzsync_pair_exit(pair);
+ SAFE_PTHREAD_JOIN(pair->thread_b, 0);
+ pair->thread_b = 0;
+ }
}
/**
- * tst_fzsync_delay_b - Perform spin delay for B, if needed
+ * Zero some stat fields
*
- * Usually called just before the point you want to synchronise.
+ * @relates tst_fzsync_stat
*/
-static inline void tst_fzsync_delay_b(struct tst_fzsync_pair *pair)
+static void tst_init_stat(struct tst_fzsync_stat *s)
{
- volatile long spin_delay = pair->delay;
-
- while (spin_delay < 0)
- spin_delay++;
+ s->avg = 0;
+ s->avg_dev = 0;
}
-static inline void tst_fzsync_time(struct timespec *t)
+/**
+ * Reset or initialise fzsync.
+ *
+ * @relates tst_fzsync_pair
+ * @param pair The state structure initialised with TST_FZSYNC_PAIR_INIT.
+ * @param run_b The function defining thread B or NULL.
+ *
+ * Call this from your main test function (thread A), just before entering the
+ * main loop. It will setup any values needed by fzsync and (re)start thread B
+ * using the function provided.
+ *
+ * If you need to use fork or clone to start the second thread/process then
+ * you can pass NULL to run_b and handle starting and stopping thread B
+ * yourself. You may need to place tst_fzsync_pair in some shared memory as
+ * well.
+ */
+static void tst_fzsync_pair_reset(struct tst_fzsync_pair *pair,
+ void *(*run_b)(void *))
{
- clock_gettime(CLOCK_MONOTONIC_RAW, t);
+ tst_fzsync_pair_cleanup(pair);
+
+ tst_init_stat(&pair->diff_ss);
+ tst_init_stat(&pair->diff_sa);
+ tst_init_stat(&pair->diff_sb);
+ tst_init_stat(&pair->diff_ab);
+ tst_init_stat(&pair->spins_avg);
+ pair->delay = 0;
+ pair->sampling = pair->min_samples;
+
+ pair->timer.limit =
+ tst_sec_to_timespec(pair->execution_time * tst_timeout_mul());
+
+ pair->a_cntr = 0;
+ pair->b_cntr = 0;
+ tst_atomic_store(0, &pair->exit);
+ if (run_b)
+ SAFE_PTHREAD_CREATE(&pair->thread_b, 0, run_b, 0);
+
+ tst_timer_start_st(&pair->timer);
}
/**
- * tst_fzsync_time_a - Set A's time to now.
+ * Print stat
*
- * Called at the point you want to synchronise.
+ * @relates tst_fzsync_stat
*/
-static inline void tst_fzsync_time_a(struct tst_fzsync_pair *pair)
+static inline void tst_fzsync_stat_info(struct tst_fzsync_stat stat,
+ char *unit, char *name)
{
- tst_fzsync_time(&pair->a);
+ tst_res(TINFO,
+ "%1$-17s: { avg = %3$5.0f%2$s, avg_dev = %4$5.0f%2$s, dev_ratio = %5$.2f }",
+ name, unit, stat.avg, stat.avg_dev, stat.dev_ratio);
}
/**
- * tst_fzsync_time_b - Set B's call time to now.
+ * Print some synchronisation statistics
*
- * Called at the point you want to synchronise.
+ * @relates tst_fzsync_pair
*/
-static inline void tst_fzsync_time_b(struct tst_fzsync_pair *pair)
+static void tst_fzsync_pair_info(struct tst_fzsync_pair *pair, int loop_index)
{
- tst_fzsync_time(&pair->b);
+ tst_res(TINFO, "loop = %d", loop_index);
+ tst_fzsync_stat_info(pair->diff_ss, "ns", "start_a - start_b");
+ tst_fzsync_stat_info(pair->diff_sa, "ns", "end_a - start_a");
+ tst_fzsync_stat_info(pair->diff_sb, "ns", "end_b - start_b");
+ tst_fzsync_stat_info(pair->diff_ab, "ns", "end_a - end_b");
+ tst_fzsync_stat_info(pair->spins_avg, " ", "spins");
+}
+
+/** Wraps clock_gettime */
+static inline void tst_fzsync_time(struct timespec *t)
+{
+ clock_gettime(CLOCK_MONOTONIC_RAW, t);
}
/**
- * tst_exp_moving_avg - Exponential moving average
- * @alpha: The preference for recent samples over old ones.
- * @sample: The current sample
- * @prev_avg: The average of the all the previous samples
+ * Exponential moving average
+ *
+ * @param alpha The preference for recent samples over old ones.
+ * @param sample The current sample
+ * @param prev_avg The average of the all the previous samples
*
- * Returns average including the current sample.
+ * @return The average including the current sample.
*/
static inline float tst_exp_moving_avg(float alpha,
float sample,
@@ -176,63 +319,160 @@ static inline float tst_exp_moving_avg(float alpha,
}
/**
- * tst_fzsync_pair_update - Recalculate the delay
- * @loop_index: The i in "for(i = 0;..." or zero to ignore update_gap
- * @pair: The state necessary for calculating the delay
- *
- * This should be called at the end of each loop to update the average
- * measured time difference (between A and B) and update the delay. It is
- * assumed that A and B are less than a second apart.
- *
- * The values of update_gap, avg_alpha and delay_inc decide the speed at which
- * the algorithm approaches the optimum delay value and whether it is
- * stable. If your test is behaving strangely, it could be because this
- * algorithm is behaving chaotically and flip-flopping between large positve
- * and negative delay values. You can call tst_fzysync_pair_info every few
- * loops to check whether the average difference and delay values are stable.
+ * Update a stat with a new sample
+ *
+ * @relates tst_fzsync_stat
+ */
+static inline void tst_upd_stat(struct tst_fzsync_stat *s,
+ float alpha,
+ float sample)
+{
+ s->avg = tst_exp_moving_avg(alpha, sample, s->avg);
+ s->avg_dev = tst_exp_moving_avg(alpha, fabs(s->avg - sample), s->avg_dev);
+ s->dev_ratio = fabs(s->avg ? s->avg_dev / s->avg : 0);
+}
+
+/**
+ * Update a stat with a new diff sample
+ *
+ * @relates tst_fzsync_stat
+ */
+static inline void tst_upd_diff_stat(struct tst_fzsync_stat *s,
+ float alpha,
+ struct timespec t1,
+ struct timespec t2)
+{
+ tst_upd_stat(s, alpha, tst_timespec_diff_ns(t1, t2));
+}
+
+/**
+ * Calculate various statistics and the delay
+ *
+ * This function helps create the fuzz in fuzzy sync. Imagine we have the
+ * following timelines in threads A and B:
+ *
+ * start_race_a
+ * ^ end_race_a (a)
+ * | ^
+ * | |
+ * - --+------------------------+-- - -
+ * | Syscall A | Thread A
+ * - --+------------------------+-- - -
+ * - --+----------------+-------+-- - -
+ * | Syscall B | spin | Thread B
+ * - --+----------------+-------+-- - -
+ * | |
+ * ^ ^
+ * start_race_b end_race_b
+ *
+ * Here we have synchronised the calls to syscall A and B with start_race_{a,
+ * b} so that they happen at approximately the same time in threads A and
+ * B. If the race condition occurs during the entry code for these two
+ * functions then we will quickly hit it. If it occurs during the exit code of
+ * B and mid way through A, then we will quickly hit it.
+ *
+ * However if the exit paths of A and B need to be aligned and (end_race_a -
+ * end_race_b) is large relative to the variation in call times, the
+ * probability of hitting the race condition is close to zero. To solve this
+ * scenario (and others) a randomised delay is introduced before the syscalls
+ * in A and B. Given enough time the following should happen where the exit
+ * paths are now synchronised:
+ *
+ * start_race_a
+ * ^ end_race_a (a)
+ * | ^
+ * | |
+ * - --+------------------------+-- - -
+ * | Syscall A | Thread A
+ * - --+------------------------+-- - -
+ * - --+-------+----------------+-- - -
+ * | delay | Syscall B | Thread B
+ * - --+-------+----------------+-- - -
+ * | |
+ * ^ ^
+ * start_race_b end_race_b
+ *
+ * The delay is not introduced immediately and the delay range is only
+ * calculated once the average relative deviation has dropped below some
+ * percentage of the total time.
+ *
+ * The delay range is choosen so that any point in Syscall A could be
+ * synchronised with any point in Syscall B using a value from the
+ * range. Because the delay range may be too large for a linear search, we use
+ * an evenly distributed random function to pick a value from it.
+ *
+ * @relates tst_fzsync_pair
*/
static void tst_fzsync_pair_update(int loop_index, struct tst_fzsync_pair *pair)
{
- long diff;
- long inc = pair->delay_inc;
- float target = pair->avg_diff_trgt;
- float avg = pair->avg_diff;
-
- diff = pair->a.tv_nsec - pair->b.tv_nsec
- + 1000000000 * (pair->a.tv_sec - pair->b.tv_sec);
- avg = tst_exp_moving_avg(pair->avg_alpha, diff, avg);
- pair->avg_dev = tst_exp_moving_avg(pair->avg_alpha,
- fabs(diff - avg),
- pair->avg_dev);
-
- if (!(loop_index & pair->update_gap)) {
- if (avg > target)
- pair->delay -= inc;
- else if (avg < target)
- pair->delay += inc;
- }
+ float alpha = pair->avg_alpha;
+ float per_spin_time, time_delay, dev_ratio;
+
+ dev_ratio = (pair->diff_sa.dev_ratio
+ + pair->diff_sb.dev_ratio
+ + pair->diff_ab.dev_ratio
+ + pair->spins_avg.dev_ratio) / 4;
+
+ if (pair->sampling > 0 || dev_ratio > pair->max_dev_ratio) {
+ tst_upd_diff_stat(&pair->diff_ss, alpha,
+ pair->a_start, pair->b_start);
+ tst_upd_diff_stat(&pair->diff_sa, alpha,
+ pair->a_end, pair->a_start);
+ tst_upd_diff_stat(&pair->diff_sb, alpha,
+ pair->b_end, pair->b_start);
+ tst_upd_diff_stat(&pair->diff_ab, alpha,
+ pair->a_end, pair->b_end);
+ tst_upd_stat(&pair->spins_avg, alpha, pair->spins);
+ if (pair->sampling > 0 && --pair->sampling == 0) {
+ tst_res(TINFO,
+ "Minimum sampling period ended, deviation ratio = %.2f",
+ dev_ratio);
+ tst_fzsync_pair_info(pair, loop_index);
+ }
+ } else if (pair->diff_ab.avg >= 1 && pair->spins_avg.avg >= 1) {
+ per_spin_time = fabs(pair->diff_ab.avg) / pair->spins_avg.avg;
+ time_delay = drand48() * (pair->diff_sa.avg + pair->diff_sb.avg)
+ - pair->diff_sb.avg;
+ pair->delay = (int)(time_delay / per_spin_time);
- if (!(loop_index & pair->info_gap))
- tst_fzsync_pair_info(pair);
+ if (!pair->sampling) {
+ tst_res(TINFO,
+ "Reached deviation ratio %.2f (max %.2f), introducing randomness",
+ dev_ratio, pair->max_dev_ratio);
+ tst_res(TINFO, "Delay range is [-%d, %d]",
+ (int)(pair->diff_sb.avg / per_spin_time),
+ (int)(pair->diff_sa.avg / per_spin_time));
+ tst_fzsync_pair_info(pair, loop_index);
+ pair->sampling = -1;
+ }
+ } else if (!pair->sampling) {
+ tst_res(TWARN, "Can't calculate random delay");
+ pair->sampling = -1;
+ }
- pair->avg_diff = avg;
+ pair->spins = 0;
}
/**
- * tst_fzsync_pair_wait - Wait for the other thread
- * @our_cntr: The counter for the thread we are on
- * @other_cntr: The counter for the thread we are synchronising with
+ * Wait for the other thread
+ *
+ * @relates tst_fzsync_pair
+ * @param our_cntr The counter for the thread we are on
+ * @param other_cntr The counter for the thread we are synchronising with
+ * @param spins A pointer to the spin counter or NULL
*
- * Use this (through tst_fzsync_pair_wait_a() and tst_fzsync_pair_wait_b()) if
- * you need an additional synchronisation point in a thread or you do not want
- * to use the delay facility (not recommended). See
- * tst_fzsync_pair_wait_update().
+ * Used by tst_fzsync_pair_wait_a(), tst_fzsync_pair_wait_b(),
+ * tst_fzsync_start_race_a(), etc. If the calling thread is ahead of the other
+ * thread, then it will spin wait. Unlike pthread_barrier_wait it will never
+ * use futex and can count the number of spins spent waiting.
*
- * Returns a non-zero value if the thread should continue otherwise the
+ * @return A non-zero value if the thread should continue otherwise the
* calling thread should exit.
*/
static inline int tst_fzsync_pair_wait(struct tst_fzsync_pair *pair,
- int *our_cntr, int *other_cntr)
+ int *our_cntr,
+ int *other_cntr,
+ int *spins)
{
if (tst_atomic_inc(other_cntr) == INT_MAX) {
/*
@@ -244,8 +484,10 @@ static inline int tst_fzsync_pair_wait(struct tst_fzsync_pair *pair,
*/
while (tst_atomic_load(our_cntr) > 0
&& tst_atomic_load(our_cntr) < INT_MAX
- && !tst_atomic_load(&pair->exit))
- ;
+ && !tst_atomic_load(&pair->exit)) {
+ if (spins)
+ (*spins)++;
+ }
tst_atomic_store(0, other_cntr);
/*
@@ -261,66 +503,126 @@ static inline int tst_fzsync_pair_wait(struct tst_fzsync_pair *pair,
* of it and need to wait.
*/
while (tst_atomic_load(our_cntr) < tst_atomic_load(other_cntr)
- && !tst_atomic_load(&pair->exit))
- ;
+ && !tst_atomic_load(&pair->exit)) {
+ if (spins)
+ (*spins)++;
+ }
}
- /* Only exit if we have done the same amount of work as the other thread */
- return !tst_atomic_load(&pair->exit) ||
- tst_atomic_load(other_cntr) <= tst_atomic_load(our_cntr);
+ return !tst_atomic_load(&pair->exit);
}
+/**
+ * Wait in thread A
+ *
+ * @relates tst_fzsync_pair
+ * @sa tst_fzsync_pair_wait
+ */
static inline int tst_fzsync_wait_a(struct tst_fzsync_pair *pair)
{
- return tst_fzsync_pair_wait(pair, &pair->a_cntr, &pair->b_cntr);
+ return tst_fzsync_pair_wait(pair, &pair->a_cntr, &pair->b_cntr, NULL);
}
+/**
+ * Wait in thread B
+ *
+ * @relates tst_fzsync_pair
+ * @sa tst_fzsync_pair_wait
+ */
static inline int tst_fzsync_wait_b(struct tst_fzsync_pair *pair)
{
- return tst_fzsync_pair_wait(pair, &pair->b_cntr, &pair->a_cntr);
+ return tst_fzsync_pair_wait(pair, &pair->b_cntr, &pair->a_cntr, NULL);
}
/**
- * tst_fzsync_pair_wait_update_{a,b} - Wait and then recalculate
+ * Marks the start of a race region in thread A
+ *
+ * @relates tst_fzsync_pair
*
- * This allows you to have two long running threads which wait for each other
- * every iteration. So each thread will exit this function at approximately
- * the same time. It also updates the delay values in a thread safe manner.
+ * This should be placed just before performing whatever action can cause a
+ * race condition. Usually it is placed just before a syscall and
+ * tst_fzsync_end_race_a() is placed just afterward.
*
- * You must call this function in both threads the same number of times each
- * iteration. So a call in one thread must match with a call in the
- * other. Make sure that calls to tst_fzsync_pair_wait() and
- * tst_fzsync_pair_wait_update() happen in the same order in each thread. That
- * is, make sure that a call to tst_fzsync_pair_wait_update_a() in one thread
- * corresponds to a call to tst_fzsync_pair_wait_update_b() in the other.
+ * A corrosponding call to tst_fzsync_start_race_b() should be made in thread
+ * B.
*
- * Returns a non-zero value if the calling thread should continue to loop. If
+ * @return A non-zero value if the calling thread should continue to loop. If
* it returns zero then tst_fzsync_exit() has been called and you must exit
* the thread.
+ *
+ * @sa tst_fzsync_pair_update
*/
-static inline int tst_fzsync_wait_update_a(struct tst_fzsync_pair *pair)
+static inline int tst_fzsync_start_race_a(struct tst_fzsync_pair *pair)
{
static int loop_index;
+ volatile int delay;
+ int ret;
+
+ tst_fzsync_wait_a(pair);
- tst_fzsync_pair_wait(pair, &pair->a_cntr, &pair->b_cntr);
- loop_index++;
- tst_fzsync_pair_update(loop_index, pair);
- return tst_fzsync_pair_wait(pair, &pair->a_cntr, &pair->b_cntr);
+ if (tst_timer_expired_st(&pair->timer)) {
+ tst_res(TINFO,
+ "Exceeded fuzzy sync time limit, requesting exit");
+ tst_fzsync_pair_exit(pair);
+ } else {
+ loop_index++;
+ tst_fzsync_pair_update(loop_index, pair);
+ }
+
+ ret = tst_fzsync_wait_a(pair);
+ tst_fzsync_time(&pair->a_start);
+
+ delay = pair->delay;
+ while (delay < 0)
+ delay++;
+
+ return ret;
}
-static inline int tst_fzsync_wait_update_b(struct tst_fzsync_pair *pair)
+/**
+ * Marks the end of a race region in thread A
+ *
+ * @relates tst_fzsync_pair
+ * @sa tst_fzsync_start_race_a
+ */
+static inline int tst_fzsync_end_race_a(struct tst_fzsync_pair *pair)
{
- tst_fzsync_pair_wait(pair, &pair->b_cntr, &pair->a_cntr);
- return tst_fzsync_pair_wait(pair, &pair->b_cntr, &pair->a_cntr);
+ tst_fzsync_time(&pair->a_end);
+ return tst_fzsync_pair_wait(pair, &pair->a_cntr, &pair->b_cntr,
+ &pair->spins);
}
/**
- * tst_fzsync_pair_exit - Signal that the other thread should exit
+ * Marks the start of a race region in thread B
*
- * Causes tst_fzsync_pair_wait() and tst_fzsync_pair_wait_update() to return
- * 0.
+ * @relates tst_fzsync_pair
+ * @sa tst_fzsync_start_race_a
*/
-static inline void tst_fzsync_pair_exit(struct tst_fzsync_pair *pair)
+static inline int tst_fzsync_start_race_b(struct tst_fzsync_pair *pair)
{
- tst_atomic_store(1, &pair->exit);
+ int ret;
+ volatile int delay;
+
+ tst_fzsync_wait_b(pair);
+ ret = tst_fzsync_wait_b(pair);
+ tst_fzsync_time(&pair->b_start);
+
+ delay = pair->delay;
+ while (delay > 0)
+ delay--;
+
+ return ret;
+}
+
+/**
+ * Marks the end of a race region in thread B
+ *
+ * @relates tst_fzsync_pair
+ * @sa tst_fzsync_start_race_a
+ */
+static inline int tst_fzsync_end_race_b(struct tst_fzsync_pair *pair)
+{
+ tst_fzsync_time(&pair->b_end);
+ return tst_fzsync_pair_wait(pair, &pair->b_cntr, &pair->a_cntr,
+ &pair->spins);
}
--
2.18.0
More information about the ltp
mailing list