
libfiu - Fault injection in userspace
=====================================

Introduction
------------

You, as a programmer, know many things can fail, and your software is often
expected to be able to handle those failures. But how do you test your failure
handling code, when it's not easy to make a failure appear in the first place?
One way to do it is to perform *fault injection*.

According to Wikipedia, "fault injection is a technique for improving the
coverage of a test by introducing faults in order to test code paths, in
particular error handling code paths, that might otherwise rarely be followed.
It is often used with stress testing and is widely considered to be an
important part of developing robust software".

libfiu is a library that you can use to add fault injection to your code. It
aims to be easy to use by means of a simple API, with minimal code impact and
little runtime overhead when enabled.

That means that the modifications you have to do to your code (and build
system) in order to support libfiu should be as little intrusive as possible.


Code overview
-------------

Let's take a look to a small (fictitious) code sample to see what's the
general idea behind libfiu.

Assume that you have this code that checks if there's enough free space to
store a given file::

        size_t free_space() {
                [code to find out how much free space there is]
                return space;
        }

        bool file_fits(FILE *fd) {
                if (free_space() < file_size(fd)) {
                        return false;
                }
                return true;
        }

With current disk sizes, it's very unusual to ran out of free space, which
makes the scenario where *free_space()* returns 0 hard to test. With libfiu,
you can do the following small addition::

        size_t free_space() {
                fiu_return_on("no_free_space", 0);

                [code to find out how much free space there is]
                return space;
        }

        bool file_fits(FILE *fd) {
                if (free_space() < file_size(fd)) {
                        return false;
                }
                return true;
        }

The *fiu_return_on()* annotation is the only change you need to make to your
code to create a *point of failure*, which is identified by the name
**no_free_space**. When that point of failure is enabled, the function will
return 0.

In your testing code, you can now do this::

        fiu_init();
        fiu_enable("no_free_space", 1, NULL, 0);
        assert(file_fits("tmpfile") == false);

The first line initializes the library, and the second *enables* the point of
failure. When the point of failure is enabled, *free_space()* will return 0,
so you can test how your code behaves under that condition, which was
otherwise hard to trigger.

libfiu's API has two "sides": a core API and a control API.  The core API is
used inside the code to be fault injected. The control API is used inside the
testing code, in order to control the injection of failures.

In the example above, *fiu_return_on()* is a part of the core API, and
*fiu_enable()* is a part of the control API.


Using libfiu in your project
----------------------------

To use libfiu in your project, there are three things to consider: the build
system, the fault injection code, and the testing code.


The build system
~~~~~~~~~~~~~~~~

The first thing to do is to enable your build system to use libfiu. Usually,
you do not want to make libfiu a runtime or build-time dependency, because
it's often only used for testing.

To that end, you should copy *fiu-local.h* into your source tree, and then
create an option to do a *fault injection build* that #defines the constant
*FIU_ENABLE* (usually done by adding ``-DFIU_ENABLE=1`` to your compiler
flags) and links against libfiu (usually done by adding ``-lfiu`` to your
linker flags).

That way, normal builds will not have a single trace of fault injection code,
but it will be easy to create a binary that does, for testing purposes.


The fault injection code
~~~~~~~~~~~~~~~~~~~~~~~~

Adding fault injection to your code means inserting points of failure in it,
using the core API.

First, you should ``#include "fiu-local.h"`` in the files you want to add
points of failure to. That header allows you to avoid libfiu as a build-time
dependency, as mentioned in the last section.

Then, to insert points of failure, sprinkle your code with calls like
``fiu_return_on("name", -1)``, ``fiu_exit_on("name")``, or more complex code
using ``fiu_fail("name")``. See the libfiu's manpage for the details on
the API.

It is recommended that you use meaningful names for your points of failure, to
be able to easily identify their purpose. You can also name them
hierarchically (for example, using names like *"io/write"*, *"io/read"*, and
so on), to be able to enable entire groups of points of failure (like
*"io/\*"*). To this end, any separator will do, the *'/'* is not special at
all.


The testing code
~~~~~~~~~~~~~~~~

Testing can be done in too many ways, so I won't get into specific details
here. As a general approach, usually the idea with fault injection is to write
tests similar in spirit to the one shown above: initialize the library, enable
one or more failures using the control API, and then check if the code behaves
as expected.

Initially, all points of failure are disabled, which means your code should run
as usual, with a very small performance impact.

The points of failure can be enabled using different strategies:

Unconditional (*fiu_enable()*)
  Enables the point of failure in an unconditional way, so it always fails.

Random (*fiu_enable_random()*)
  Enables the point of failure in a non-deterministic way, which will fail with
  the given probability.

External (*fiu_enable_external()*)
  Enables the point of failure using an external function, which will be called
  to determine whether the point of failure should fail or not.

You can also use an asterisk *at the end* of a name to enable all the points
of failure that begin with the given name (excluding the asterisk, of course).

Check libfiu's manpage for more details about the API.

If you prefer to avoid writing the test code in C, you can use the Python
bindings, and/or the *fiu-run* and *fiu-ctrl* utilities.


