igt_fork_signal_helper ()

void
igt_fork_signal_helper (void);

Fork a child process using igt_fork_helper to interrupt the parent process with a SIGCONT signal at regular quick intervals. The corresponding dummy signal handler is installed in the parent process.

This is useful to exercise ioctl error paths, at least where those can be exercises by interrupting blocking waits, like stalling for the gpu. This helper can also be used from children spawned with igt_fork.

In tests with subtests this function can be called outside of failure catching code blocks like igt_fixture or igt_subtest.

Note that this just spews signals at the current process unconditionally and hence incurs quite a bit of overhead. For a more focused approach, with less overhead, look at the igt_while_interruptible code block macro.

igt_stop_signal_helper ()

void
igt_stop_signal_helper (void);

Stops the child process spawned with igt_fork_signal_helper() again.

In tests with subtests this function can be called outside of failure catching code blocks like igt_fixture or igt_subtest.

igt_fork_hang_detector ()

void
igt_fork_hang_detector (int fd);

igt_stop_hang_detector ()

void
igt_stop_hang_detector (void);

igt_while_interruptible()

#define             igt_while_interruptible(enable)

Provides control flow such that all drmIoctl() (strictly igt_ioctl()) within the loop are forcibly injected with signals (SIGRTMIN).

This is useful to exercise ioctl error paths, at least where those can be exercises by interrupting blocking waits, like stalling for the gpu.

The code block attached to this macro is run in a loop with doubling the interrupt timeout on each ioctl for every run, until no ioctl gets interrupted any more. The starting timeout is taken to be the signal delivery latency, measured at runtime. This way the any ioctls called from this code block should be exhaustively tested for all signal interruption paths.

Note that since this overloads the igt_ioctl(), this method is not useful for widespread signal injection, for example providing coverage of pagefaults. To interrupt everything, see igt_fork_signal_helper().

igt_until_timeout()

#define             igt_until_timeout(timeout)

Convenience macro loop to run the provided code block in a loop until the timeout has expired. Of course when an individual execution takes too long, the actual execution time could be a lot longer.

The code block will be executed at least once.

igt_for_milliseconds()

#define             igt_for_milliseconds(t)

Convenience macro loop to run the provided code block in a loop until the target interval has expired. Of course when an individual execution takes too long, the actual execution time could be a lot longer.

The code block will be executed at least once.

igt_exchange_int ()

void
igt_exchange_int (void *array,
                  unsigned  i,
                  unsigned  j);

Exchanges the two values at array indices i and j . Useful as an exchange function for igt_permute_array().

igt_permute_array ()

void
igt_permute_array (void *array,
                   unsigned  size,
                   void (*exchange_func) (void *array, unsigned i, unsigned j));

This function randomly permutes the array using random() as the PRNG source. The exchange_func function is called to exchange two elements in the array when needed.

igt_progress ()

void
igt_progress (const char *header,
              uint64_t i,
              uint64_t total);

This function draws a progress indicator, which is useful for running long-winded tests manually on the console. To avoid spamming log files in automated runs the progress indicator is suppressed when not running on a terminal.

igt_print_activity ()

void
igt_print_activity (void);

Print a '.' to indicate activity. This is printed without a newline and only if output is to a terminal.

igt_check_boolean_env_var ()

bool
igt_check_boolean_env_var (const char *env_var,
                           bool default_value);

This function should be used to parse boolean environment variable options.

igt_aub_dump_enabled ()

bool
igt_aub_dump_enabled (void);

igt_init_aperture_trashers ()

void
igt_init_aperture_trashers (drm_intel_bufmgr *bufmgr);

Initialize the aperture trasher using bufmgr , which can then be run with igt_trash_aperture().

igt_trash_aperture ()

void
igt_trash_aperture (void);

Trash the aperture by walking a set of GTT memory mapped objects.

igt_cleanup_aperture_trashers ()

void
igt_cleanup_aperture_trashers (void);

Clean up all aperture trasher state set up with igt_init_aperture_trashers().

igt_system_suspend_autoresume ()

void
igt_system_suspend_autoresume (void);

Execute a system suspend-to-mem cycle and automatically wake up again using the firmware's resume timer.

This is very handy for implementing any kind of suspend/resume test.

igt_system_hibernate_autoresume ()

void
igt_system_hibernate_autoresume (void);

Execute a system suspend-to-disk cycle and automatically wake up again using the firmware's resume timer.

This is very handy for implementing any kind of hibernate/resume test.

igt_drop_root ()

void
igt_drop_root (void);

Drop root privileges and make sure it actually worked. Useful for tests which need to check security constraints. Note that this should only be called from manually forked processes, since the lack of root privileges will wreak havoc with the automatic cleanup handlers.

igt_debug_wait_for_keypress ()

void
igt_debug_wait_for_keypress (const char *var);

Waits for a key press when run interactively and when the corresponding debug var is set in the --interactive-debug=<var> variable. Multiple keys can be specified as a comma-separated list or alternatively "all" if a wait should happen for all cases.

When not connected to a terminal interactive_debug is ignored and execution immediately continues.

This is useful for display tests where under certain situation manual inspection of the display is useful. Or when running a testcase in the background.

igt_debug_manual_check ()

void
igt_debug_manual_check (const char *var,
                        const char *expected);

Waits for a key press when run interactively and when the corresponding debug var is set in the --interactive-debug=<var> variable. Multiple vars can be specified as a comma-separated list or alternatively "all" if a wait should happen for all cases.

This is useful for display tests where under certain situation manual inspection of the display is useful. Or when running a testcase in the background.

When not connected to a terminal interactive_debug is ignored and execution immediately continues. For this reason by default this function returns true. It returns false only when N/n is pressed indicating the user isn't seeing what was expected.

Force test fail when N/n is pressed.

intel_purge_vm_caches ()

void
intel_purge_vm_caches (void);

intel_get_avail_ram_mb ()

uint64_t
intel_get_avail_ram_mb (void);

intel_get_total_ram_mb ()

uint64_t
intel_get_total_ram_mb (void);

intel_get_total_swap_mb ()

uint64_t
intel_get_total_swap_mb (void);

intel_require_memory ()

void
intel_require_memory (uint64_t count,
                      uint64_t size,
                      unsigned  mode);

Computes the total amount of memory required to allocate count surfaces, each of size bytes, and includes an estimate for kernel overhead. It then queries the kernel for the available amount of memory on the system (either RAM and/or SWAP depending upon mode ) and determines whether there is sufficient to run the test.

Most tests should check that there is enough RAM to hold their working set. The rare swap thrashing tests should check that there is enough RAM + SWAP for their tests. oom-killer tests should only run if this reports that there is not enough RAM + SWAP!

If there is not enough RAM this function calls igt_skip with an appropriate message. It only ever returns if the requirement is fulfilled. This function also causes the test to be skipped automatically on simulation under the assumption that any test that needs to check for memory requirements is a thrashing test unsuitable for slow simulated systems.

intel_require_files ()

void
intel_require_files (uint64_t count);

Does the system support enough file descriptors for the test?

min()

#define             min(a, b)

max()

#define             max(a, b)

igt_swap()

#define             igt_swap(a, b)

igt_lock_mem ()

void
igt_lock_mem (size_t size);

Allocate size MB of memory and lock it into RAM. This releases any previously locked memory.

Use igt_unlock_mem to release the currently locked memory.

igt_unlock_mem ()

void
igt_unlock_mem (void);

Release and free the RAM used by igt_lock_mem.

igt_wait()

#define             igt_wait(COND, timeout_ms, interval_ms)

Waits until COND evaluates to true or the timeout passes.

It is safe to call this macro if the signal helper is active. The only problem is that the usleep() calls will return early, making us evaluate COND too often, possibly eating valuable CPU cycles.

igt_start_siglatency ()

void
igt_start_siglatency (int sig);

igt_stop_siglatency ()

double
igt_stop_siglatency (struct igt_mean *result);

igt_set_module_param ()

void
igt_set_module_param (const char *name,
                      const char *val);

This function sets the desired value for the given i915.ko parameter. It also takes care of saving and restoring the values that were already set before the test was run.

Please consider using igt_set_module_param_int() for the integer and bool parameters.

igt_set_module_param_int ()

void
igt_set_module_param_int (const char *name,
                          int val);

This is a wrapper for igt_set_module_param() that takes an integer instead of a string. Please see igt_set_module_param().

trash_bos

extern drm_intel_bo **trash_bos;

num_trash_bos

extern int num_trash_bos;

struct _igt_sigiter

struct _igt_sigiter {
	unsigned pass;
};

CHECK_RAM

#define CHECK_RAM 0x1

CHECK_SWAP

#define CHECK_SWAP 0x2

struct igt_mean

struct igt_mean {
};

Structure to compute running statistical numbers. Needs to be initialized with igt_mean_init(). Read out data using igt_mean_get() and igt_mean_get_variance().