Commit 96973767 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'ktest-v4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-ktest 

Pull ktest updates from Steven Rostedt:
 "These commits have either been sitting in my INBOX or have been in my
  local tree for some time. I need to push them upstream:

   - Separate out config-bisect.pl from ktest.pl.

     This allows users to do config bisects without full ktest setup.

   - Email on status change.

     Allow the user to be emailed on test start, finish, failure, etc.

   - Other small fixes and enhancements"

* tag 'ktest-v4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-ktest: (24 commits)
  ktest: Take submenu into account for grub2 menus
  ktest.pl: Add MAIL_COMMAND option to define how to send email
  ktest.pl: Use run_command to execute sending mail
  ktest.pl: Allow dodie be recursive
  ktest.pl: Kill test if mailer is not supported
  ktest.pl: Add MAIL_PATH option to define where to find the mailer
  ktest.pl: No need to print no mailer is specified when mailto is not
  Ktest: add email options to sample.config
  Ktest: Use dodie for critical falures
  Ktest: Add SigInt handling
  Ktest: Add email support
  ktest.pl: Detect if a config-bisect was interrupted
  ktest.pl: Make finding config-bisect.pl dynamic
  ktest.pl: Have ktest.pl pass -r to config-bisect.pl to reset bisect
  ktest.pl: Use diffconfig if available for failed config bisects
  ktest.pl: Allow for the config-bisect.pl output to display to console
  ktest: Use config-bisect.pl in ktest.pl
  ktest: Add standalone config-bisect.pl program
  ktest: Set do_not_reboot=y for CONFIG_BISECT_TYPE=build
  ktest: Set buildonly=1 for CONFIG_BISECT_TYPE=build
  ...
parents 77cb51e6 6cd110a9

tools/testing/ktest/config-bisect.pl

0 → 100755
+770 −0
Original line number Diff line number Diff line 
#!/usr/bin/perl -w

#

# Copyright 2015 - Steven Rostedt, Red Hat Inc.

# Copyright 2017 - Steven Rostedt, VMware, Inc.

#

# Licensed under the terms of the GNU GPL License version 2

#



# usage:

#  config-bisect.pl [options] good-config bad-config [good|bad]

#



# Compares a good config to a bad config, then takes half of the diffs

# and produces a config that is somewhere between the good config and

# the bad config. That is, the resulting config will start with the

# good config and will try to make half of the differences of between

# the good and bad configs match the bad config. It tries because of

# dependencies between the two configs it may not be able to change

# exactly half of the configs that are different between the two config

# files.



# Here's a normal way to use it:

#

#  $ cd /path/to/linux/kernel

#  $ config-bisect.pl /path/to/good/config /path/to/bad/config



# This will now pull in good config (blowing away .config in that directory

# so do not make that be one of the good or bad configs), and then

# build the config with "make oldconfig" to make sure it matches the

# current kernel. It will then store the configs in that result for

# the good config. It does the same for the bad config as well.

# The algorithm will run, merging half of the differences between

# the two configs and building them with "make oldconfig" to make sure

# the result changes (dependencies may reset changes the tool had made).

# It then copies the result of its good config to /path/to/good/config.tmp

# and the bad config to /path/to/bad/config.tmp (just appends ".tmp" to the

# files passed in). And the ".config" that you should test will be in

# directory



# After the first run, determine if the result is good or bad then

# run the same command appending the result



# For good results:

#  $ config-bisect.pl /path/to/good/config /path/to/bad/config good



# For bad results:

#  $ config-bisect.pl /path/to/good/config /path/to/bad/config bad



# Do not change the good-config or bad-config, config-bisect.pl will

# copy the good-config to a temp file with the same name as good-config

# but with a ".tmp" after it. It will do the same with the bad-config.



# If "good" or "bad" is not stated at the end, it will copy the good and

# bad configs to the .tmp versions. If a .tmp version already exists, it will

# warn before writing over them (-r will not warn, and just write over them).

# If the last config is labeled "good", then it will copy it to the good .tmp

# version. If the last config is labeled "bad", it will copy it to the bad

# .tmp version. It will continue this until it can not merge the two any more

# without the result being equal to either the good or bad .tmp configs.



my $start = 0;

my $val = "";



my $pwd = `pwd`;

chomp $pwd;

my $tree = $pwd;

my $build;



my $output_config;

my $reset_bisect;



sub usage {

    print << "EOF"



usage: config-bisect.pl [-l linux-tree][-b build-dir] good-config bad-config [good|bad]

  -l [optional] define location of linux-tree (default is current directory)

  -b [optional] define location to build (O=build-dir) (default is linux-tree)

  good-config the config that is considered good

  bad-config the config that does not work

  "good" add this if the last run produced a good config

  "bad" add this if the last run produced a bad config

  If "good" or "bad" is not specified, then it is the start of a new bisect



  Note, each run will create copy of good and bad configs with ".tmp" appended.



EOF

;



    exit(-1);

}



sub doprint {

    print @_;

}



sub dodie {

    doprint "CRITICAL FAILURE... ", @_, "\n";



    die @_, "\n";

}



sub expand_path {

    my ($file) = @_;



    if ($file =~ m,^/,) {

	return $file;

    }

    return "$pwd/$file";

}



sub read_prompt {

    my ($cancel, $prompt) = @_;



    my $ans;



    for (;;) {

	if ($cancel) {

	    print "$prompt [y/n/C] ";

	} else {

	    print "$prompt [y/N] ";

	}

	$ans = <STDIN>;

	chomp $ans;

	if ($ans =~ /^\s*$/) {

	    if ($cancel) {

		$ans = "c";

	    } else {

		$ans = "n";

	    }

	}

	last if ($ans =~ /^y$/i || $ans =~ /^n$/i);

	if ($cancel) {

	    last if ($ans =~ /^c$/i);

	    print "Please answer either 'y', 'n' or 'c'.\n";

	} else {

	    print "Please answer either 'y' or 'n'.\n";

	}

    }

    if ($ans =~ /^c/i) {

	exit;

    }

    if ($ans !~ /^y$/i) {

	return 0;

    }

    return 1;

}



sub read_yn {

    my ($prompt) = @_;



    return read_prompt 0, $prompt;

}



sub read_ync {

    my ($prompt) = @_;



    return read_prompt 1, $prompt;

}



sub run_command {

    my ($command, $redirect) = @_;

    my $start_time;

    my $end_time;

    my $dord = 0;

    my $pid;



    $start_time = time;



    doprint("$command ... ");



    $pid = open(CMD, "$command 2>&1 |") or

	dodie "unable to exec $command";



    if (defined($redirect)) {

	open (RD, ">$redirect") or

	    dodie "failed to write to redirect $redirect";

	$dord = 1;

    }



    while (<CMD>) {

	print RD  if ($dord);

    }



    waitpid($pid, 0);

    my $failed = $?;



    close(CMD);

    close(RD)  if ($dord);



    $end_time = time;

    my $delta = $end_time - $start_time;



    if ($delta == 1) {

	doprint "[1 second] ";

    } else {

	doprint "[$delta seconds] ";

    }



    if ($failed) {

	doprint "FAILED!\n";

    } else {

	doprint "SUCCESS\n";

    }



    return !$failed;

}



###### CONFIG BISECT ######



# config_ignore holds the configs that were set (or unset) for

# a good config and we will ignore these configs for the rest

# of a config bisect. These configs stay as they were.

my %config_ignore;



# config_set holds what all configs were set as.

my %config_set;



# config_off holds the set of configs that the bad config had disabled.

# We need to record them and set them in the .config when running

# olddefconfig, because olddefconfig keeps the defaults.

my %config_off;



# config_off_tmp holds a set of configs to turn off for now

my @config_off_tmp;



# config_list is the set of configs that are being tested

my %config_list;

my %null_config;



my %dependency;



my $make;



sub make_oldconfig {



    if (!run_command "$make olddefconfig") {

	# Perhaps olddefconfig doesn't exist in this version of the kernel

	# try oldnoconfig

	doprint "olddefconfig failed, trying make oldnoconfig\n";

	if (!run_command "$make oldnoconfig") {

	    doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";

	    # try a yes '' | oldconfig

	    run_command "yes '' | $make oldconfig" or

		dodie "failed make config oldconfig";

	}

    }

}



sub assign_configs {

    my ($hash, $config) = @_;



    doprint "Reading configs from $config\n";



    open (IN, $config)

	or dodie "Failed to read $config";



    while (<IN>) {

	chomp;

	if (/^((CONFIG\S*)=.*)/) {

	    ${$hash}{$2} = $1;

	} elsif (/^(# (CONFIG\S*) is not set)/) {

	    ${$hash}{$2} = $1;

	}

    }



    close(IN);

}



sub process_config_ignore {

    my ($config) = @_;



    assign_configs \%config_ignore, $config;

}



sub get_dependencies {

    my ($config) = @_;



    my $arr = $dependency{$config};

    if (!defined($arr)) {

	return ();

    }



    my @deps = @{$arr};



    foreach my $dep (@{$arr}) {

	print "ADD DEP $dep\n";

	@deps = (@deps, get_dependencies $dep);

    }



    return @deps;

}



sub save_config {

    my ($pc, $file) = @_;



    my %configs = %{$pc};



    doprint "Saving configs into $file\n";



    open(OUT, ">$file") or dodie "Can not write to $file";



    foreach my $config (keys %configs) {

	print OUT "$configs{$config}\n";

    }

    close(OUT);

}



sub create_config {

    my ($name, $pc) = @_;



    doprint "Creating old config from $name configs\n";



    save_config $pc, $output_config;



    make_oldconfig;

}



# compare two config hashes, and return configs with different vals.

# It returns B's config values, but you can use A to see what A was.

sub diff_config_vals {

    my ($pa, $pb) = @_;



    # crappy Perl way to pass in hashes.

    my %a = %{$pa};

    my %b = %{$pb};



    my %ret;



    foreach my $item (keys %a) {

	if (defined($b{$item}) && $b{$item} ne $a{$item}) {

	    $ret{$item} = $b{$item};

	}

    }



    return %ret;

}



# compare two config hashes and return the configs in B but not A

sub diff_configs {

    my ($pa, $pb) = @_;



    my %ret;



    # crappy Perl way to pass in hashes.

    my %a = %{$pa};

    my %b = %{$pb};



    foreach my $item (keys %b) {

	if (!defined($a{$item})) {

	    $ret{$item} = $b{$item};

	}

    }



    return %ret;

}



# return if two configs are equal or not

# 0 is equal +1 b has something a does not

# +1 if a and b have a different item.

# -1 if a has something b does not

sub compare_configs {

    my ($pa, $pb) = @_;



    my %ret;



    # crappy Perl way to pass in hashes.

    my %a = %{$pa};

    my %b = %{$pb};



    foreach my $item (keys %b) {

	if (!defined($a{$item})) {

	    return 1;

	}

	if ($a{$item} ne $b{$item}) {

	    return 1;

	}

    }



    foreach my $item (keys %a) {

	if (!defined($b{$item})) {

	    return -1;

	}

    }



    return 0;

}



sub process_failed {

    my ($config) = @_;



    doprint "\n\n***************************************\n";

    doprint "Found bad config: $config\n";

    doprint "***************************************\n\n";

}



sub process_new_config {

    my ($tc, $nc, $gc, $bc) = @_;



    my %tmp_config = %{$tc};

    my %good_configs = %{$gc};

    my %bad_configs = %{$bc};



    my %new_configs;



    my $runtest = 1;

    my $ret;



    create_config "tmp_configs", \%tmp_config;

    assign_configs \%new_configs, $output_config;



    $ret = compare_configs \%new_configs, \%bad_configs;

    if (!$ret) {

	doprint "New config equals bad config, try next test\n";

	$runtest = 0;

    }



    if ($runtest) {

	$ret = compare_configs \%new_configs, \%good_configs;

	if (!$ret) {

	    doprint "New config equals good config, try next test\n";

	    $runtest = 0;

	}

    }



    %{$nc} = %new_configs;



    return $runtest;

}



sub convert_config {

    my ($config) = @_;



    if ($config =~ /^# (.*) is not set/) {

	$config = "$1=n";

    }



    $config =~ s/^CONFIG_//;

    return $config;

}



sub print_config {

    my ($sym, $config) = @_;



    $config = convert_config $config;

    doprint "$sym$config\n";

}



sub print_config_compare {

    my ($good_config, $bad_config) = @_;



    $good_config = convert_config $good_config;

    $bad_config = convert_config $bad_config;



    my $good_value = $good_config;

    my $bad_value = $bad_config;

    $good_value =~ s/(.*)=//;

    my $config = $1;



    $bad_value =~ s/.*=//;



    doprint " $config $good_value -> $bad_value\n";

}



# Pass in:

# $phalf: half of the configs names you want to add

# $oconfigs: The orginial configs to start with

# $sconfigs: The source to update $oconfigs with (from $phalf)

# $which: The name of which half that is updating (top / bottom)

# $type: The name of the source type (good / bad)

sub make_half {

    my ($phalf, $oconfigs, $sconfigs, $which, $type) = @_;



    my @half = @{$phalf};

    my %orig_configs = %{$oconfigs};

    my %source_configs = %{$sconfigs};



    my %tmp_config = %orig_configs;



    doprint "Settings bisect with $which half of $type configs:\n";

    foreach my $item (@half) {

	doprint "Updating $item to $source_configs{$item}\n";

	$tmp_config{$item} = $source_configs{$item};

    }



    return %tmp_config;

}



sub run_config_bisect {

    my ($pgood, $pbad) = @_;



    my %good_configs = %{$pgood};

    my %bad_configs = %{$pbad};



    my %diff_configs = diff_config_vals \%good_configs, \%bad_configs;

    my %b_configs = diff_configs \%good_configs, \%bad_configs;

    my %g_configs = diff_configs \%bad_configs, \%good_configs;



    # diff_arr is what is in both good and bad but are different (y->n)

    my @diff_arr = keys %diff_configs;

    my $len_diff = $#diff_arr + 1;



    # b_arr is what is in bad but not in good (has depends)

    my @b_arr = keys %b_configs;

    my $len_b = $#b_arr + 1;



    # g_arr is what is in good but not in bad

    my @g_arr = keys %g_configs;

    my $len_g = $#g_arr + 1;



    my $runtest = 0;

    my %new_configs;

    my $ret;



    # Look at the configs that are different between good and bad.

    # This does not include those that depend on other configs

    #  (configs depending on other configs that are not set would

    #   not show up even as a "# CONFIG_FOO is not set"





    doprint "# of configs to check:             $len_diff\n";

    doprint "# of configs showing only in good: $len_g\n";

    doprint "# of configs showing only in bad:  $len_b\n";



    if ($len_diff > 0) {

	# Now test for different values



	doprint "Configs left to check:\n";

	doprint "  Good Config\t\t\tBad Config\n";

	doprint "  -----------\t\t\t----------\n";

	foreach my $item (@diff_arr) {

	    doprint "  $good_configs{$item}\t$bad_configs{$item}\n";

	}



	my $half = int($#diff_arr / 2);

	my @tophalf = @diff_arr[0 .. $half];



	doprint "Set tmp config to be good config with some bad config values\n";



	my %tmp_config = make_half \@tophalf, \%good_configs,

	    \%bad_configs, "top", "bad";



	$runtest = process_new_config \%tmp_config, \%new_configs,

			    \%good_configs, \%bad_configs;



	if (!$runtest) {

	    doprint "Set tmp config to be bad config with some good config values\n";



	    my %tmp_config = make_half \@tophalf, \%bad_configs,

		\%good_configs, "top", "good";



	    $runtest = process_new_config \%tmp_config, \%new_configs,

		\%good_configs, \%bad_configs;

	}

    }



    if (!$runtest && $len_diff > 0) {

	# do the same thing, but this time with bottom half



	my $half = int($#diff_arr / 2);

	my @bottomhalf = @diff_arr[$half+1 .. $#diff_arr];



	doprint "Set tmp config to be good config with some bad config values\n";



	my %tmp_config = make_half \@bottomhalf, \%good_configs,

	    \%bad_configs, "bottom", "bad";



	$runtest = process_new_config \%tmp_config, \%new_configs,

			    \%good_configs, \%bad_configs;



	if (!$runtest) {

	    doprint "Set tmp config to be bad config with some good config values\n";



	    my %tmp_config = make_half \@bottomhalf, \%bad_configs,

		\%good_configs, "bottom", "good";



	    $runtest = process_new_config \%tmp_config, \%new_configs,

		\%good_configs, \%bad_configs;

	}

    }



    if ($runtest) {

	make_oldconfig;

	doprint "READY TO TEST .config IN $build\n";

	return 0;

    }



    doprint "\n%%%%%%%% FAILED TO FIND SINGLE BAD CONFIG %%%%%%%%\n";

    doprint "Hmm, can't make any more changes without making good == bad?\n";

    doprint "Difference between good (+) and bad (-)\n";



    foreach my $item (keys %bad_configs) {

	if (!defined($good_configs{$item})) {

	    print_config "-", $bad_configs{$item};

	}

    }



    foreach my $item (keys %good_configs) {

	next if (!defined($bad_configs{$item}));

	if ($good_configs{$item} ne $bad_configs{$item}) {

	    print_config_compare $good_configs{$item}, $bad_configs{$item};

	}

    }



    foreach my $item (keys %good_configs) {

	if (!defined($bad_configs{$item})) {

	    print_config "+", $good_configs{$item};

	}

    }

    return -1;

}



sub config_bisect {

    my ($good_config, $bad_config) = @_;

    my $ret;



    my %good_configs;

    my %bad_configs;

    my %tmp_configs;



    doprint "Run good configs through make oldconfig\n";

    assign_configs \%tmp_configs, $good_config;

    create_config "$good_config", \%tmp_configs;

    assign_configs \%good_configs, $output_config;



    doprint "Run bad configs through make oldconfig\n";

    assign_configs \%tmp_configs, $bad_config;

    create_config "$bad_config", \%tmp_configs;

    assign_configs \%bad_configs, $output_config;



    save_config \%good_configs, $good_config;

    save_config \%bad_configs, $bad_config;



    return run_config_bisect \%good_configs, \%bad_configs;

}



while ($#ARGV >= 0) {

    if ($ARGV[0] !~ m/^-/) {

	last;

    }

    my $opt = shift @ARGV;



    if ($opt eq "-b") {

	$val = shift @ARGV;

	if (!defined($val)) {

	    die "-b requires value\n";

	}

	$build = $val;

    }



    elsif ($opt eq "-l") {

	$val = shift @ARGV;

	if (!defined($val)) {

	    die "-l requires value\n";

	}

	$tree = $val;

    }



    elsif ($opt eq "-r") {

	$reset_bisect = 1;

    }



    elsif ($opt eq "-h") {

	usage;

    }



    else {

	die "Unknow option $opt\n";

    }

}



$build = $tree if (!defined($build));



$tree = expand_path $tree;

$build = expand_path $build;



if ( ! -d $tree ) {

    die "$tree not a directory\n";

}



if ( ! -d $build ) {

    die "$build not a directory\n";

}



usage if $#ARGV < 1;



if ($#ARGV == 1) {

    $start = 1;

} elsif ($#ARGV == 2) {

    $val = $ARGV[2];

    if ($val ne "good" && $val ne "bad") {

	die "Unknown command '$val', bust be either \"good\" or \"bad\"\n";

    }

} else {

    usage;

}



my $good_start = expand_path $ARGV[0];

my $bad_start = expand_path $ARGV[1];



my $good = "$good_start.tmp";

my $bad = "$bad_start.tmp";



$make = "make";



if ($build ne $tree) {

    $make = "make O=$build"

}



$output_config = "$build/.config";



if ($start) {

    if ( ! -f $good_start ) {

	die "$good_start not found\n";

    }

    if ( ! -f $bad_start ) {

	die "$bad_start not found\n";

    }

    if ( -f $good || -f $bad ) {

	my $p = "";



	if ( -f $good ) {

	    $p = "$good exists\n";

	}



	if ( -f $bad ) {

	    $p = "$p$bad exists\n";

	}



	if (!defined($reset_bisect)) {

	    if (!read_yn "${p}Overwrite and start new bisect anyway?") {

		exit (-1);

	    }

	}

    }

    run_command "cp $good_start $good" or die "failed to copy to $good\n";

    run_command "cp $bad_start $bad" or die "faield to copy to $bad\n";

} else {

    if ( ! -f $good ) {

	die "Can not find file $good\n";

    }

    if ( ! -f $bad ) {

	die "Can not find file $bad\n";

    }

    if ($val eq "good") {

	run_command "cp $output_config $good" or die "failed to copy $config to $good\n";

    } elsif ($val eq "bad") {

	run_command "cp $output_config $bad" or die "failed to copy $config to $bad\n";

    }

}



chdir $tree || die "can't change directory to $tree";



my $ret = config_bisect $good, $bad;



if (!$ret) {

    exit(0);

}



if ($ret > 0) {

    doprint "Cleaning temp files\n";

    run_command "rm $good";

    run_command "rm $bad";

    exit(1);

} else {

    doprint "See good and bad configs for details:\n";

    doprint "good: $good\n";

    doprint "bad:  $bad\n";

    doprint "%%%%%%%% FAILED TO FIND SINGLE BAD CONFIG %%%%%%%%\n";

}

exit(2);

tools/testing/ktest/ktest.pl

+261 −272

File changed.

Preview size limit exceeded, changes collapsed.

tools/testing/ktest/sample.conf

+60 −0
Original line number Diff line number Diff line 
#

# Config file for ktest.pl

#

# Place your customized version of this, in the working directory that

# ktest.pl is run from. By default, ktest.pl will look for a file

# called "ktest.conf", but you can name it anything you like and specify

# the name of your config file as the first argument of ktest.pl.

#

# Note, all paths must be absolute

#
@@ -396,6 +401,44 @@ 


#### Optional Config Options (all have defaults) ####



# Email options for receiving notifications. Users must setup

# the specified mailer prior to using this feature.

#

# (default undefined)

#MAILTO =

#

# Supported mailers: sendmail, mail, mailx

# (default sendmail)

#MAILER = sendmail

#

# The executable to run

# (default: for sendmail "/usr/sbin/sendmail", otherwise equals ${MAILER})

#MAIL_EXEC = /usr/sbin/sendmail

#

# The command used to send mail, which uses the above options

# can be modified. By default if the mailer is "sendmail" then

#  MAIL_COMMAND = echo \'Subject: $SUBJECT\n\n$MESSAGE\' | $MAIL_PATH/$MAILER -t $MAILTO

# For mail or mailx:

#  MAIL_COMMAND = "$MAIL_PATH/$MAILER -s \'$SUBJECT\' $MAILTO <<< \'$MESSAGE\'

# ktest.pl will do the substitution for MAIL_PATH, MAILER, MAILTO at the time

#    it sends the mail if "$FOO" format is used. If "${FOO}" format is used,

#    then the substitutions will occur at the time the config file is read.

#    But note, MAIL_PATH and MAILER require being set by the config file if

#     ${MAIL_PATH} or ${MAILER} are used, but not if $MAIL_PATH or $MAILER are.

#MAIL_COMMAND = echo \'Subject: $SUBJECT\n\n$MESSAGE\' | $MAIL_PATH/$MAILER -t $MAILTO

#

# Errors are defined as those would terminate the script

# (default 1)

#EMAIL_ON_ERROR = 1

# (default 1)

#EMAIL_WHEN_FINISHED = 1

# (default 0)

#EMAIL_WHEN_STARTED = 1

#

# Users can cancel the test by Ctrl^C

# (default 0)

#EMAIL_WHEN_CANCELED = 1



# Start a test setup. If you leave this off, all options

# will be default and the test will run once.

# This is a label and not really an option (it takes no value).
@@ -725,6 +768,13 @@ 
# (default 120)

#TIMEOUT = 120



# The timeout in seconds when to test if the box can be rebooted

# or not. Before issuing the reboot command, a ssh connection

# is attempted to see if the target machine is still active.

# If the target does not connect within this timeout, a power cycle

# is issued instead of a reboot.

# CONNECT_TIMEOUT = 25



# In between tests, a reboot of the box may occur, and this

# is the time to wait for the console after it stops producing

# output. Some machines may not produce a large lag on reboot
@@ -1167,6 +1217,16 @@ 
#  Set it to "good" to test only the good config and set it

#  to "bad" to only test the bad config.

#

# CONFIG_BISECT_EXEC (optional)

#  The config bisect is a separate program that comes with ktest.pl.

#  By befault, it will look for:

#    `pwd`/config-bisect.pl # the location ktest.pl was executed from.

#  If it does not find it there, it will look for:

#    `dirname <ktest.pl>`/config-bisect.pl # The directory that holds ktest.pl

#  If it does not find it there, it will look for:

#    ${BUILD_DIR}/tools/testing/ktest/config-bisect.pl

#  Setting CONFIG_BISECT_EXEC will override where it looks.

#

# Example:

#   TEST_START

#   TEST_TYPE = config_bisect

CRA Git | Maintained and supported by SUSTech CRA and CCSE