FT means Fault-Tolerance.

This is the README file of FT controller under RT-Linux.

Written by A. Lanusse <lanusse@cea.fr>, P. Vanuxeem<vanuxeem@cea.fr>
Copyright (C) [date] OCERA Consortium.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2.

Description :
-------------

The FT controller component, named ftcontroller, is a low level component
that handles abnormal situations (timing errors and/or abortion) and provides
replacement behaviour for the faulty thread.

The FT controller component treats notably the threads of the ft-tasks
(see README of ftappli for definition of a ft-task).
 
Actually, the FT controller component is in relation with the rtl_ktrace
component by using a kernel stream trace in order to get system events
related notably to application threads. After the analyse and the filter
of some particular event (PTHREAD_KILL), a decision making on the abnormal
detected thread implies a transition from the normal behavior thread to
the degraded behavior thread.

Further, other events have to be processed.
Further, in order to detect notably deadline miss, the FT controller component
may be in relation with the sheduler component.

The RT-Linux ftcontroller module, associated to the FT controller
component, is build in order to be installed and executed, necessary by
the root user, under RT-Linux.

Implementation :
----------------

The ftcontroller directory is composed of the following directories:
	- doc
	- examples
	- include
	- src

and the following files:
	- README
	- INSTALL
	- Makefile

The include directory contains the following files:
	- ft_controller.h
	- ft_api_controller.h

	The ft_controller.h file is the standart include of the
	ft_controller.c file.

	The ft_api_controller.h file defines the FT API interface between
	FT application monitor and FT controller and between the scheduler
	and the FT controller (not used actually).
	This interface has to be used by the FT application monitor file
	(ft_appli_monitor.c).
	It contains notably the prototypes of the FT API interface functions.

The src directory contains the following files:	
	- ft_controller.c

	The ft_controller.c file is the source code which implements
	the FT controller.
	It includes actually only ft_controller.h file.

The Makefile file allows to make the RT-Linux ftcontroller module, named
ftcontroller.o.

Compilation :
-------------

In order to make the compilation of the ftcontroller module, please follow
next steps:

	- Be a root user
	$ su
	Password:
	#

	- Go to the ft/ftcontroller directory:
	# cd ft/ftcontroller

	- Clean the ft/ftcontroller directory:
	# make clean
	Notably an old ftcontroller.o file is clean up.

	- Compile the ftcontroller module:
	# make all
	The ftcontroller.o module is now available under the ft/ftcontroller
	directory.

Installation :
--------------
Note that the Makefile does'nt actually allow to install and execute the
ftcontroller module.

Only the Makefile file in ftcontroller/examples directory allows actually
to install and execute all the modules, included ftcontroller module, within a
whole application context.

Then it is recommended to use the Makefile in ft/ftcontrolller/examples
directory in order to install and execute notably the ftcontroller module.

Note that the installation order between modules is important due to
the dependances between the FT components (API).
The imperative order is:
	- rtlinux start           (notably for rtl_ktrace)
	- insmod ftcontroller.o   (notably for ft_api_controller.h)
	- insmod ftappmon.o       (notably for ft_api_appli_monitor.h)
	- insmod ftappli.o