Detailed Description

Support library for TESLA instrumentation.

Classes
struct	tesla_transition
	A single allowable transition in a TESLA automaton. More...

struct	tesla_transitions
	A set of permissible state transitions for an automata instance. More...

struct	tesla_key
	A TESLA instance can be identified by a tesla_class and a tesla_key. More...

struct	tesla_instance
	A single instance of an automaton: a name (ti_key) and a state. More...

struct	tesla_event_handlers
	A vector of event handlers. More...

struct	tesla_event_metahandler
	A 'meta-handler' that wraps a number of event handling vectors. More...

struct	tesla_class

struct	tesla_store

Macros
#define	TESLA_TRANS_INIT 0x02 /* May need to initialise the class. */

#define	TESLA_TRANS_CLEANUP 0x04 /* Clean up the class now. */

#define	TESLA_KEY_SIZE 4

#define	SUBSET(x, y) ((x & y) == x)
	Is x a subset of y? More...

#define	__unused

#define	tesla_panic(...) errx(1, __VA_ARGS__)
	errx() is the userspace equivalent of panic(). More...

#define	tesla_assert(condition,...) assert(condition)
	POSIX assert() doesn't let us provide an error message. More...

#define	tesla_malloc(len) calloc(1, len)

#define	tesla_free(x) free(x)

#define	tesla_lock(l) do { __debug int err = pthread_mutex_lock(l); assert(err == 0); } while(0)

#define	tesla_unlock(l) do { __debug int err = pthread_mutex_unlock(l); assert(err == 0); } while(0)

#define	TESLA_MAX_CLASSES 128

#define	TESLA_MAX_INSTANCES 128

#define	SAFE_SPRINTF(current, end,...)
	Do a sprintf() into a buffer, checking bounds appropriately. More...

#define	print(...) printf(__VA_ARGS__)

#define	error(...) fprintf(stderr, __VA_ARGS__)

#define	__debug

#define	DEBUG(dclass,...) if (tesla_debugging(#dclass)) printf(__VA_ARGS__)
	Emit debugging information with a debug name (e.g., libtesla.event). More...

Typedefs
typedef void(*	tesla_ev_new_instance )(struct tesla_class , struct tesla_instance )
	A new tesla_instance has been created. More...

typedef void(*	tesla_ev_transition )(struct tesla_class , struct tesla_instance , const struct tesla_transition *)
	A tesla_instance has taken a transition. More...

typedef void(*	tesla_ev_clone )(struct tesla_class , struct tesla_instance orig, struct tesla_instance copy, const struct tesla_transition )
	An exisiting tesla_instance has been cloned because of an event. More...

typedef void(*	tesla_ev_no_instance )(struct tesla_class , const struct tesla_key , const struct tesla_transitions *)
	No tesla_class instance was found to match a tesla_key. More...

typedef void(*	tesla_ev_bad_transition )(struct tesla_class , struct tesla_instance , const struct tesla_transitions *)
	A tesla_instance is not in the right state to take a transition. More...

typedef void(*	tesla_ev_error )(struct tesla_class , int32_t, const char )
	Generic error handler. More...

typedef void(*	tesla_ev_accept )(struct tesla_class , struct tesla_instance )
	A tesla_instance has accepted a sequence of events. More...

typedef void(*	tesla_ev_ignored )(const struct tesla_class , const struct tesla_key , const struct tesla_transitions *)
	An event is being ignored. More...

typedef struct tesla_class	tesla_class

typedef struct tesla_instance	tesla_instance

typedef struct tesla_key	tesla_key

typedef struct tesla_store	tesla_store

typedef struct tesla_transition	tesla_transition

typedef struct tesla_transitions	tesla_transitions

Enumerations
enum	tesla_err_t { TESLA_SUCCESS, TESLA_ERROR_ENOENT, TESLA_ERROR_ENOMEM, TESLA_ERROR_EINVAL, TESLA_ERROR_UNKNOWN }
	Error values that can be returned by libtesla functions. More...

enum	tesla_context { TESLA_CONTEXT_GLOBAL, TESLA_CONTEXT_THREAD }
	A context where TESLA data is stored. More...

enum	tesla_action_t { UPDATE, FORK, JOIN, IGNORE, FAIL }
	Actions that can be taken by tesla_update_state. More...

Functions
const char *	tesla_strerror (int32_t error)
	Provide string versions of TESLA errors. More...

int32_t	tesla_store_get (enum tesla_context context, uint32_t classes, uint32_t instances, struct tesla_store **store)
	Retrieve the tesla_store for a context (e.g., a thread). More...

int32_t	tesla_class_get (struct tesla_store store, uint32_t id, struct tesla_class tclass, const char name, const char *description)
	Retrieve (or create) a tesla_class from a tesla_store. More...

void	tesla_class_put (struct tesla_class *)
	Release resources (e.g., locks) associated with a tesla_class. More...

void	tesla_update_state (enum tesla_context context, uint32_t class_id, const struct tesla_key key, const char name, const char description, const struct tesla_transitions )
	Update all automata instances that match a given key to a new state. More...

int	tesla_set_event_handler (struct tesla_event_handlers *)
	Register an event handler vector. More...

int	tesla_set_event_handlers (struct tesla_event_metahandler *)
	Register a set of event handling vectors. More...

void	tesla_die (int32_t errno, const char *event) __attribute__((noreturn))
	Call this if things go catastrophically, unrecoverably wrong. More...

int32_t	tesla_store_reset (struct tesla_store *store)
	Reset all automata in a store to the inactive state. More...

void	tesla_store_free (struct tesla_store *)
	Clean up a tesla_store. More...

void	tesla_class_reset (struct tesla_class *)
	Reset a tesla_class for re-use from a clean state. More...

void	tesla_class_destroy (struct tesla_class *)
	Clean up a tesla_class. More...

int32_t	tesla_instance_new (struct tesla_class tclass, const struct tesla_key name, uint32_t state, struct tesla_instance **out)
	Create a new tesla_instance. More...

int32_t	tesla_instance_active (const struct tesla_instance *i)
	Checks whether or not a TESLA automata instance is active (in use). More...

int32_t	tesla_instance_clone (struct tesla_class tclass, const struct tesla_instance orig, struct tesla_instance **copy)
	Clone an existing instance into a new instance. More...

void	tesla_instance_clear (struct tesla_instance *tip)
	Zero an instance for re-use. More...

int32_t	tesla_match (struct tesla_class tclass, const struct tesla_key key, struct tesla_instance *array, uint32_t size)
	Find all automata instances in a class that match a particular key. More...

int32_t	tesla_key_matches (const struct tesla_key pattern, const struct tesla_key k)
	Check to see if a key matches a pattern. More...

enum tesla_action_t	tesla_action (const struct tesla_instance , const struct tesla_key , const struct tesla_transitions , const struct tesla_transition *trigger)
	What is the correct action to perform on a given tesla_instance to satisfy a set of tesla_transitions? More...

int32_t	tesla_key_union (struct tesla_key dest, const struct tesla_key source)
	Copy new entries from source into dest. More...

int	tesla_store_init (tesla_store *, enum tesla_context context, uint32_t classes, uint32_t instances)
	Initialise tesla_store internals. More...

int	tesla_class_init (struct tesla_class *, enum tesla_context context, uint32_t instances)
	Initialize tesla_class internals. More...

int32_t	tesla_class_global_postinit (struct tesla_class *)

void	tesla_class_global_acquire (struct tesla_class *)

void	tesla_class_global_release (struct tesla_class *)

void	tesla_class_global_destroy (struct tesla_class *)

int32_t	tesla_class_perthread_postinit (struct tesla_class *)

void	tesla_class_perthread_acquire (struct tesla_class *)

void	tesla_class_perthread_release (struct tesla_class *)

void	tesla_class_perthread_destroy (struct tesla_class *)

void	ev_new_instance (struct tesla_class , struct tesla_instance )

void	ev_transition (struct tesla_class , struct tesla_instance , const struct tesla_transition *)

void	ev_clone (struct tesla_class , struct tesla_instance orig, struct tesla_instance copy, const struct tesla_transition )

void	ev_no_instance (struct tesla_class , const struct tesla_key , const struct tesla_transitions *)

void	ev_bad_transition (struct tesla_class , struct tesla_instance , const struct tesla_transitions *)

void	ev_err (struct tesla_class tcp, int errno, const char message)

void	ev_accept (struct tesla_class , struct tesla_instance )

void	ev_ignored (const struct tesla_class , const struct tesla_key , const struct tesla_transitions *)

int32_t	tesla_debugging (const char *)
	Are we in (verbose) debug mode? More...

void	assert_instanceof (struct tesla_instance i, struct tesla_class tclass)
	Assert that a tesla_instance is an instance of a tesla_class. More...

char *	key_string (char buffer, const char end, const struct tesla_key *)
	Print a key into a buffer. More...

void	print_key (const char debug_name, const struct tesla_key key)
	Print a tesla_key to stderr. More...

void	print_class (const struct tesla_class *)
	Print a tesla_class to stderr. More...

void	print_transition (const char debug, const struct tesla_transition )
	Print a human-readable version of a tesla_transition. More...

char *	sprint_transition (char buffer, const char end, const struct tesla_transition *)
	Print a human-readable version of a tesla_transition into a buffer. More...

void	print_transitions (const char debug, const struct tesla_transitions )
	Print a human-readable version of tesla_transitions. More...

char *	sprint_transitions (char buffer, const char end, const struct tesla_transitions *)
	Print a human-readable version of tesla_transitions into a buffer. More...

Class Documentation

struct tesla_transition

Collaboration diagram for tesla_transition:

Class Members
int	flags	Things we may need to do on this transition.
uint32_t	from	The state we are moving from.
uint32_t	from_mask	The mask of the state we're moving from.
uint32_t	to	The state we are moving to.
uint32_t	to_mask	A mask of the keys that the 'to' state should have set.

struct tesla_transitions

Collaboration diagram for tesla_transitions:

Class Members
uint32_t	length	The number of possible transitions in transitions.
struct tesla_transition *	transitions	Possible transitions: exactly one must be taken.

struct tesla_key

Collaboration diagram for tesla_key:

Class Members
uintptr_t	tk_keys[4]	The keys / event parameters that name this automata instance.
uint32_t	tk_mask	A bitmask of the keys that are actually set.

struct tesla_instance

Collaboration diagram for tesla_instance:

Class Members
struct tesla_key	ti_key
uint32_t	ti_state

struct tesla_event_handlers

Collaboration diagram for tesla_event_handlers:

Class Members
tesla_ev_accept	teh_accept
tesla_ev_bad_transition	teh_bad_transition
tesla_ev_clone	teh_clone
tesla_ev_error	teh_err
tesla_ev_no_instance	teh_fail_no_instance
tesla_ev_ignored	teh_ignored
tesla_ev_new_instance	teh_init
tesla_ev_transition	teh_transition

struct tesla_event_metahandler

Collaboration diagram for tesla_event_metahandler:

Class Members
struct tesla_event_handlers const	tem_handlers	The backend event handlers.
const uint32_t	tem_length	The number of event handlers wrapped by this handler.
uint32_t	tem_mask	Which backend handlers to use; may be modified dynamically.

struct tesla_class

Collaboration diagram for tesla_class:

Class Members
enum tesla_context	tc_context
const char *	tc_description
uint32_t	tc_free
struct tesla_instance *	tc_instances
uint32_t	tc_limit
pthread_mutex_t	tc_lock
const char *	tc_name

struct tesla_store

Collaboration diagram for tesla_store:

Class Members
struct tesla_class *	classes
uint32_t	length

Macro Definition Documentation

#define __debug

Definition at line 351 of file tesla_internal.h.

Referenced by pthread_key(), and tesla_store_get().

#define __unused

Definition at line 187 of file tesla_internal.h.

#define DEBUG	(	dclass,
		...
	)	if (tesla_debugging(#dclass)) printf(__VA_ARGS__)

Emit debugging information with a debug name (e.g., libtesla.event).

Definition at line 363 of file tesla_internal.h.

Referenced by tesla_class_reset(), and tesla_store_free().

#define error ( ... ) fprintf(stderr, __VA_ARGS__)

Definition at line 346 of file tesla_internal.h.

Referenced by tesla_set_event_handler(), and tesla_set_event_handlers().

#define print ( ... ) printf(__VA_ARGS__)

Definition at line 341 of file tesla_internal.h.

Referenced by print_class(), print_key(), print_transition(), and print_transitions().

#define SAFE_SPRINTF	(	current,
		end,
		...
	)

Value:

do {                            \
        int written = snprintf(current, end - current, __VA_ARGS__);    \
        if ((written > 0) && (current + written < end))                 \
                current += written;                                     \
} while (0)

Do a sprintf() into a buffer, checking bounds appropriately.

Definition at line 335 of file tesla_internal.h.

Referenced by key_string(), sprint_transition(), and sprint_transitions().

#define SUBSET	(	x,
		y
	)	((x & y) == x)

Is x a subset of y?

Definition at line 71 of file tesla_internal.h.

Referenced by tesla_action(), and tesla_key_matches().

#define tesla_assert	(	condition,
		...
	)	assert(condition)

POSIX assert() doesn't let us provide an error message.

Definition at line 215 of file tesla_internal.h.

Referenced by assert_instanceof(), and tesla_instance_new().

#define tesla_free ( x ) free(x)

Definition at line 218 of file tesla_internal.h.

Referenced by tesla_class_destroy(), and tesla_store_free().

#define TESLA_KEY_SIZE 4

Definition at line 173 of file libtesla.h.

Referenced by key_string(), tesla::KeyType(), print_key(), tesla_key_matches(), and tesla_key_union().

#define tesla_lock ( l ) do { __debug int err = pthread_mutex_lock(l); assert(err == 0); } while(0)

Definition at line 220 of file tesla_internal.h.

Referenced by tesla_class_global_acquire().

#define tesla_malloc ( len ) calloc(1, len)

Definition at line 217 of file tesla_internal.h.

Referenced by tesla_class_init(), tesla_store_get(), and tesla_store_init().

#define TESLA_MAX_CLASSES 128

Definition at line 286 of file tesla_internal.h.

Referenced by tesla_update_state().

#define TESLA_MAX_INSTANCES 128

Definition at line 287 of file tesla_internal.h.

Referenced by tesla_update_state().

#define tesla_panic ( ... ) errx(1, __VA_ARGS__)

errx() is the userspace equivalent of panic().

Definition at line 212 of file tesla_internal.h.

Referenced by tesla_die().

#define TESLA_TRANS_CLEANUP 0x04 /* Clean up the class now. */

Definition at line 158 of file libtesla.h.

Referenced by sprint_transition(), tesla_action(), and tesla_update_state().

#define TESLA_TRANS_INIT 0x02 /* May need to initialise the class. */

Definition at line 157 of file libtesla.h.

Referenced by sprint_transition(), and tesla_update_state().

#define tesla_unlock ( l ) do { __debug int err = pthread_mutex_unlock(l); assert(err == 0); } while(0)

Definition at line 223 of file tesla_internal.h.

Referenced by tesla_class_global_release().

Typedef Documentation

typedef struct tesla_class tesla_class

Definition at line 249 of file tesla_internal.h.

typedef void(* tesla_ev_accept)(struct tesla_class *, struct tesla_instance *)

A tesla_instance has accepted a sequence of events.

Definition at line 237 of file libtesla.h.

typedef void(* tesla_ev_bad_transition)(struct tesla_class *, struct tesla_instance *, const struct tesla_transitions *)

A tesla_instance is not in the right state to take a transition.

Definition at line 230 of file libtesla.h.

typedef void(* tesla_ev_clone)(struct tesla_class *, struct tesla_instance *orig, struct tesla_instance *copy, const struct tesla_transition *)

An exisiting tesla_instance has been cloned because of an event.

Definition at line 221 of file libtesla.h.

typedef void(* tesla_ev_error)(struct tesla_class *, int32_t, const char *)

Generic error handler.

Definition at line 234 of file libtesla.h.

typedef void(* tesla_ev_ignored)(const struct tesla_class *, const struct tesla_key *, const struct tesla_transitions *)

An event is being ignored.

Definition at line 241 of file libtesla.h.

typedef void(* tesla_ev_new_instance)(struct tesla_class *, struct tesla_instance *)

A new tesla_instance has been created.

Definition at line 213 of file libtesla.h.

typedef void(* tesla_ev_no_instance)(struct tesla_class *, const struct tesla_key *, const struct tesla_transitions *)

No tesla_class instance was found to match a tesla_key.

Definition at line 226 of file libtesla.h.

typedef void(* tesla_ev_transition)(struct tesla_class *, struct tesla_instance *, const struct tesla_transition *)

A tesla_instance has taken a transition.

Definition at line 217 of file libtesla.h.

typedef struct tesla_instance tesla_instance

Definition at line 250 of file tesla_internal.h.

typedef struct tesla_key tesla_key

Definition at line 251 of file tesla_internal.h.

typedef struct tesla_store tesla_store

Definition at line 252 of file tesla_internal.h.

typedef struct tesla_transition tesla_transition

Definition at line 253 of file tesla_internal.h.

typedef struct tesla_transitions tesla_transitions

Definition at line 254 of file tesla_internal.h.

Enumeration Type Documentation

enum tesla_action_t

Actions that can be taken by tesla_update_state.

Enumerator
UPDATE	The instance's state should be updated.
FORK	The instance should be copied to a new instance.
JOIN	The instance should be merged into another instance.
IGNORE	The instance is irrelevant to the given transitions.
FAIL	The instance matches, but there are no valid transitions for it.

Definition at line 152 of file tesla_internal.h.

                     {
         UPDATE,
 
         FORK,
 
         JOIN,
 
         IGNORE,
 
         FAIL
 };

enum tesla_context

A context where TESLA data is stored.

TESLA data can be stored in a number of places that imply different synchronisation requirements. For instance, thread-local storage does not require synchronisation on access, whereas global storage does. On the other hand, thread-local storage cannot be used to track events across multiple threads.

Enumerator
TESLA_CONTEXT_GLOBAL
TESLA_CONTEXT_THREAD

Definition at line 86 of file libtesla.h.

                    {
         TESLA_CONTEXT_GLOBAL,
         TESLA_CONTEXT_THREAD,
 };

enum tesla_err_t

Error values that can be returned by libtesla functions.

libtesla functions mostly return error values, and therefore return pointers, etc, via call-by-reference arguments.

Enumerator
TESLA_SUCCESS
TESLA_ERROR_ENOENT
TESLA_ERROR_ENOMEM
TESLA_ERROR_EINVAL
TESLA_ERROR_UNKNOWN

Definition at line 55 of file libtesla.h.

                  {
         TESLA_SUCCESS,          /* Success. */
         TESLA_ERROR_ENOENT,     /* Entry not found. */
         TESLA_ERROR_ENOMEM,     /* Insufficient memory. */
         TESLA_ERROR_EINVAL,     /* Invalid parameters. */
         TESLA_ERROR_UNKNOWN,    /* An unknown (e.g. platform) error. */
 };

Function Documentation

void assert_instanceof	(	struct tesla_instance *	i,
		struct tesla_class *	tclass
	)

Assert that a tesla_instance is an instance of a tesla_class.

This could be expensive (a linear walk over all tesla_instance in tclass), so it should only be called from debug code.

Parameters

i	the instance to test
tclass	the expected class of i

Definition at line 181 of file tesla_debug.c.

References tesla_class::tc_instances, tesla_class::tc_limit, tesla_class::tc_name, and tesla_assert.

 {
         assert(instance != NULL);
         assert(tclass != NULL);
 
         int32_t instance_belongs_to_class = 0;
         for (uint32_t i = 0; i < tclass->tc_limit; i++) {
                 if (instance == &tclass->tc_instances[i]) {
                         instance_belongs_to_class = 1;
                         break;
                 }
         }
 
         tesla_assert(instance_belongs_to_class,
                 ("tesla_instance %x not of class '%s'",
                  instance, tclass->tc_name)
                );
 }

void ev_accept	(	struct tesla_class *	,
		struct tesla_instance *
	)

Definition at line 161 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_accept(tcp, tip);
 }

Here is the caller graph for this function:

void ev_bad_transition	(	struct tesla_class *	,
		struct tesla_instance *	,
		const struct tesla_transitions *
	)

Definition at line 146 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_bad_transition(tcp, tip, ttp);
 }

Here is the caller graph for this function:

void ev_clone	(	struct tesla_class *	,
		struct tesla_instance *	orig,
		struct tesla_instance *	copy,
		const struct tesla_transition *
	)

Definition at line 130 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_clone(tcp, orig, copy, ttp);
 }

Here is the caller graph for this function:

void ev_err	(	struct tesla_class *	tcp,
		int	errno,
		const char *	message
	)

Definition at line 154 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_err(tcp, errno, message);
 }

Here is the caller graph for this function:

void ev_ignored	(	const struct tesla_class *	,
		const struct tesla_key *	,
		const struct tesla_transitions *
	)

Definition at line 168 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_ignored(tcp, tkp, ttp);
 }

Here is the caller graph for this function:

void ev_new_instance	(	struct tesla_class *	,
		struct tesla_instance *
	)

Definition at line 115 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_init(tcp, tip);
 }

Here is the caller graph for this function:

void ev_no_instance	(	struct tesla_class *	,
		const struct tesla_key *	,
		const struct tesla_transitions *
	)

Definition at line 138 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_fail_no_instance(tcp, tkp, ttp);
 }

Here is the caller graph for this function:

void ev_transition	(	struct tesla_class *	,
		struct tesla_instance *	,
		const struct tesla_transition *
	)

Definition at line 122 of file tesla_notification.c.

References FOREACH_ERROR_HANDLER.

Referenced by tesla_update_state().

 {
 
         FOREACH_ERROR_HANDLER()->teh_transition(tcp, tip, ttp);
 }

Here is the caller graph for this function:

char* key_string	(	char *	buffer,
		const char *	end,
		const struct tesla_key *
	)

Print a key into a buffer.

Definition at line 111 of file tesla_debug.c.

References SAFE_SPRINTF, TESLA_KEY_SIZE, tesla_key::tk_keys, and tesla_key::tk_mask.

Referenced by print_key().

 {
         char *c = buffer;
 
         SAFE_SPRINTF(c, end, "0x%tx [ ", key->tk_mask);
 
         for (int32_t i = 0; i < TESLA_KEY_SIZE; i++) {
                 if (key->tk_mask & (1 << i))
                         SAFE_SPRINTF(c, end, "%tx ", key->tk_keys[i]);
                 else
                         SAFE_SPRINTF(c, end, "X ");
         }
 
         SAFE_SPRINTF(c, end, "]");
 
         return c;
 }

Here is the caller graph for this function:

void print_class ( const struct tesla_class * )

Print a tesla_class to stderr.

Definition at line 201 of file tesla_debug.c.

References DEBUG_NAME, print, print_key(), TESLA_CONTEXT_GLOBAL, TESLA_CONTEXT_THREAD, tesla_debugging(), tesla_instance_active(), tesla_instance::ti_key, and tesla_instance::ti_state.

Referenced by tesla_update_state().

 {
         static const char *DEBUG_NAME = "libtesla.class.state";
         if (!tesla_debugging(DEBUG_NAME))
                 return;
 
         print("----\n");
         print("struct tesla_class @ 0x%tx {\n", (intptr_t) c);
         print("  name:         '%s',\n", c->tc_name);
         print("  description:  '[...]',\n");   // TL;DR
         print("  scope:        ");
         switch (c->tc_context) {
                 case TESLA_CONTEXT_THREAD:  print("thread-local\n"); break;
                 case TESLA_CONTEXT_GLOBAL:  print("global\n");       break;
                 default:
                         print("UNKNOWN (0x%x)\n", c->tc_context);
         }
         print("  limit:        %d\n", c->tc_limit);
         print("  %d/%d instances\n", c->tc_limit - c->tc_free, c->tc_limit);
         for (uint32_t i = 0; i < c->tc_limit; i++) {
                 const struct tesla_instance *inst = c->tc_instances + i;
                 if (!tesla_instance_active(inst))
                         continue;
 
                 print("    %2u: state %d, ", i, inst->ti_state);
                 print_key(DEBUG_NAME, &inst->ti_key);
                 print("\n");
         }
         print("}\n");
         print("----\n");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void print_key	(	const char *	debug_name,
		const struct tesla_key *	key
	)

Print a tesla_key to stderr.

Definition at line 234 of file tesla_debug.c.

References key_string(), print, tesla_debugging(), and TESLA_KEY_SIZE.

Referenced by print_class(), and tesla_update_state().

 {
         if (!tesla_debugging(debug_name))
                 return;
 
         static const size_t LEN = 15 * TESLA_KEY_SIZE + 10;
         char buffer[LEN];
         char *end = buffer + LEN;
 
         char *e = key_string(buffer, end, key);
         assert(e < end);
 
         print("%s", buffer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void print_transition	(	const char *	debug,
		const struct tesla_transition *
	)

Print a human-readable version of a tesla_transition.

Definition at line 44 of file tesla_debug.c.

References print, sprint_transition(), and tesla_debugging().

 {
         if (!tesla_debugging(debug))
                 return;
 
         char buffer[1024];
         char *end = buffer + sizeof(buffer);
 
         sprint_transition(buffer, end, t);
         print("%s", buffer);
 }

Here is the call graph for this function:

void print_transitions	(	const char *	debug,
		const struct tesla_transitions *
	)

Print a human-readable version of tesla_transitions.

Definition at line 82 of file tesla_debug.c.

References print, sprint_transitions(), and tesla_debugging().

Referenced by tesla_update_state().

 {
         if (!tesla_debugging(debug))
                 return;
 
         char buffer[1024];
         char *end = buffer + sizeof(buffer);
 
         sprint_transitions(buffer, end, transp);
         print("%s", buffer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

char* sprint_transition	(	char *	buffer,
		const char *	end,
		const struct tesla_transition *
	)

Print a human-readable version of a tesla_transition into a buffer.

Definition at line 57 of file tesla_debug.c.

References tesla_transition::flags, tesla_transition::from, tesla_transition::from_mask, SAFE_SPRINTF, TESLA_TRANS_CLEANUP, TESLA_TRANS_INIT, tesla_transition::to, and tesla_transition::to_mask.

Referenced by print_transition(), and sprint_transitions().

 {
         char *c = buf;
 
         /* Note: On at least one Mac, combining the following
          *       into a single snprintf() causes the wrong thing
          *       to be printed (instead of t->mask, we get an address!).
          */
         SAFE_SPRINTF(c, end, "(%d:", t->from);
         SAFE_SPRINTF(c, end, "0x%tx", t->from_mask);
         SAFE_SPRINTF(c, end, " -> %d:", t->to);
         SAFE_SPRINTF(c, end, "0x%tx", t->to_mask);
 
         if (t->flags & TESLA_TRANS_INIT)
                 SAFE_SPRINTF(c, end, " <init>");
 
         if (t->flags & TESLA_TRANS_CLEANUP)
                 SAFE_SPRINTF(c, end, " <clean>");
 
         SAFE_SPRINTF(c, end, ") ");
 
         return c;
 }

Here is the caller graph for this function:

char* sprint_transitions	(	char *	buffer,
		const char *	end,
		const struct tesla_transitions *
	)

Print a human-readable version of tesla_transitions into a buffer.

Definition at line 95 of file tesla_debug.c.

References tesla_transitions::length, SAFE_SPRINTF, sprint_transition(), and tesla_transitions::transitions.

Referenced by print_transitions().

 {
         char *c = buffer;
 
         SAFE_SPRINTF(c, end, "[ ");
 
         for (size_t i = 0; i < tp->length; i++)
                 c = sprint_transition(c, end, tp->transitions + i);
 
         SAFE_SPRINTF(c, end, "]");
 
         return c;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

enum tesla_action_t tesla_action	(	const struct tesla_instance *	,
		const struct tesla_key *	,
		const struct tesla_transitions *	,
		const struct tesla_transition **	trigger
	)

What is the correct action to perform on a given tesla_instance to satisfy a set of tesla_transitions?

Parameters

[out] trigger the tesla_transition that triggered the action

Referenced by tesla_update_state().

Here is the caller graph for this function:

void tesla_class_destroy ( struct tesla_class * )

Clean up a tesla_class.

Definition at line 77 of file tesla_class.c.

References tesla_class_global_destroy(), tesla_class_perthread_destroy(), TESLA_CONTEXT_GLOBAL, TESLA_CONTEXT_THREAD, and tesla_free.

Referenced by tesla_store_free().

 {
         tesla_free(class->tc_instances);
         switch (class->tc_context) {
         case TESLA_CONTEXT_GLOBAL:
                 tesla_class_global_destroy(class);
                 break;
 
         case TESLA_CONTEXT_THREAD:
                 tesla_class_perthread_destroy(class);
                 break;
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_class_get	(	struct tesla_store *	store,
		uint32_t	id,
		struct tesla_class **	tclass,
		const char *	name,
		const char *	description
	)

Retrieve (or create) a tesla_class from a tesla_store.

Once the caller is done with the tesla_class, tesla_class_put must be called.

Parameters

[in]	store	where the tesla_class is expected to be stored
[in]	id	a client-generated handle (a small integer, used as an index into an array)
[out]	tclass	the retrieved (or generated) tesla_class; only set if function returns TESLA_SUCCESS
[in]	name	a user-readable name (e.g. an automata filename)
[in]	description	a user-readable description (for error messages)

Returns: a TESLA error code (TESLA_SUCCESS, TESLA_ERROR_EINVAL, etc.)

Definition at line 155 of file tesla_store.c.

References tesla_store::classes, tesla_store::length, tesla_class::tc_context, tesla_class::tc_description, tesla_class::tc_instances, tesla_class::tc_name, TESLA_ERROR_EINVAL, and TESLA_SUCCESS.

Referenced by tesla_update_state().

 {
         assert(store != NULL);
         assert(tclassp != NULL);
 
         if (id >= store->length)
                 return (TESLA_ERROR_EINVAL);
 
         tesla_class *tclass = &store->classes[id];
         assert(tclass != NULL);
         assert(tclass->tc_instances != NULL);
         assert(tclass->tc_context >= 0);
 
         if (tclass->tc_name == NULL) tclass->tc_name = name;
         if (tclass->tc_description == NULL)
                 tclass->tc_description = description;
 
         tesla_class_acquire(tclass);
 
         *tclassp = tclass;
         return (TESLA_SUCCESS);
 }

Here is the caller graph for this function:

void tesla_class_global_acquire ( struct tesla_class * )

Definition at line 49 of file tesla_class_global.c.

References tesla_class::tc_context, tesla_class::tc_lock, TESLA_CONTEXT_GLOBAL, and tesla_lock.

 {
 
         assert(tsp->tc_context == TESLA_CONTEXT_GLOBAL);
         tesla_lock(&tsp->tc_lock);
 }

void tesla_class_global_destroy ( struct tesla_class * )

Definition at line 65 of file tesla_class_global.c.

Referenced by tesla_class_destroy().

 {
 
         tesla_class_global_lock_destroy(tsp);
 }

Here is the caller graph for this function:

int32_t tesla_class_global_postinit ( struct tesla_class * )

Definition at line 40 of file tesla_class_global.c.

References tesla_class::tc_context, TESLA_CONTEXT_GLOBAL, and TESLA_SUCCESS.

Referenced by tesla_class_init().

 {
 
         assert(tsp->tc_context == TESLA_CONTEXT_GLOBAL);
         tesla_class_global_lock_init(tsp);
         return (TESLA_SUCCESS);
 }

Here is the caller graph for this function:

void tesla_class_global_release ( struct tesla_class * )

Definition at line 57 of file tesla_class_global.c.

References tesla_class::tc_context, tesla_class::tc_lock, TESLA_CONTEXT_GLOBAL, and tesla_unlock.

Referenced by tesla_class_put().

 {
 
         assert(tsp->tc_context == TESLA_CONTEXT_GLOBAL);
         tesla_unlock(&tsp->tc_lock);
 }

Here is the caller graph for this function:

int tesla_class_init	(	struct tesla_class *	,
		enum tesla_context	context,
		uint32_t	instances
	)

Initialize tesla_class internals.

Locking is the responsibility of the caller.

Definition at line 46 of file tesla_class.c.

References tesla_class::tc_context, tesla_class::tc_free, tesla_class::tc_instances, tesla_class::tc_limit, tesla_class_global_postinit(), tesla_class_perthread_postinit(), TESLA_CONTEXT_GLOBAL, TESLA_CONTEXT_THREAD, TESLA_ERROR_UNKNOWN, and tesla_malloc.

Referenced by tesla_store_init().

 {
         assert(tclass != NULL);
         assert(context >= 0);
         assert(instances > 0);
         // TODO: write a TESLA assertion about locking here.
 
         tclass->tc_limit = instances;
 
         tclass->tc_context = context;
         tclass->tc_limit = instances;
         tclass->tc_free = instances;
         tclass->tc_instances =
                 tesla_malloc(instances * sizeof(tclass->tc_instances[0]));
 
         switch (context) {
         case TESLA_CONTEXT_GLOBAL:
                 return tesla_class_global_postinit(tclass);
 
         case TESLA_CONTEXT_THREAD:
                 return tesla_class_perthread_postinit(tclass);
 
         default:
                 assert(0 && "unhandled TESLA context");
                 return (TESLA_ERROR_UNKNOWN);
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void tesla_class_perthread_acquire ( struct tesla_class * )

Definition at line 101 of file tesla_class_perthread.c.

102 {

103 }

void tesla_class_perthread_destroy ( struct tesla_class * )

Definition at line 111 of file tesla_class_perthread.c.

Referenced by tesla_class_destroy().

112 {

113 }

Here is the caller graph for this function:

int32_t tesla_class_perthread_postinit ( struct tesla_class * )

Definition at line 95 of file tesla_class_perthread.c.

Referenced by tesla_class_init().

 {
         return 0;
 }

Here is the caller graph for this function:

void tesla_class_perthread_release ( struct tesla_class * )

Definition at line 106 of file tesla_class_perthread.c.

Referenced by tesla_class_put().

107 {

108 }

Here is the caller graph for this function:

void tesla_class_put ( struct tesla_class * )

Release resources (e.g., locks) associated with a tesla_class.

Definition at line 181 of file tesla_class.c.

References tesla_class::tc_context, tesla_class_global_release(), tesla_class_perthread_release(), TESLA_CONTEXT_GLOBAL, and TESLA_CONTEXT_THREAD.

Referenced by tesla_update_state().

 {
         switch (tsp->tc_context) {
         case TESLA_CONTEXT_GLOBAL:
                 return tesla_class_global_release(tsp);
 
         case TESLA_CONTEXT_THREAD:
                 return tesla_class_perthread_release(tsp);
 
         default:
                 assert(0 && "unhandled TESLA context");
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void tesla_class_reset ( struct tesla_class * )

Reset a tesla_class for re-use from a clean state.

Definition at line 196 of file tesla_class.c.

References DEBUG, tesla_class::tc_free, tesla_class::tc_instances, tesla_class::tc_limit, and tesla_class::tc_name.

Referenced by tesla_update_state().

 {
 
         DEBUG(libtesla.class.reset, "tesla_class_reset %s\n", c->tc_name);
 
         bzero(c->tc_instances, sizeof(c->tc_instances[0]) * c->tc_limit);
         c->tc_free = c->tc_limit;
 }

Here is the caller graph for this function:

int32_t tesla_debugging ( const char * )

Are we in (verbose) debug mode?

Definition at line 132 of file tesla_debug.c.

References strnlen.

Referenced by print_class(), print_key(), print_transition(), print_transitions(), and tesla_update_state().

 {
 #ifdef _KERNEL
         /*
          * In the kernel, only print 'libtesla.{event,instance}*' output.
          */
         static const char* allowed[] = {
                 "libtesla.event",
                 "libtesla.instance",
                 NULL,
         };
         const size_t len = sizeof(allowed) / sizeof(allowed[0]);
 
         for (size_t i = 0; (i < len) && (allowed[i] != NULL); i++) {
                 const char *s = allowed[i];
                 const size_t len = strlen(s);
 
                 if (strncmp(s, name, len) == 0)
                         return 1;
         }
 
         return 0;
 #else
 #ifdef HAVE_ISSETUGID
         /*
          * Debugging paths could be more vulnerable to format string problems
          * than other code; don't allow when running setuid or setgid.
          */
         if (issetugid())
                 return 0;
 #endif
 
         const char *env = getenv("TESLA_DEBUG");
 
         /* If TESLA_DEBUG is not set, we're definitely not debugging. */
         if (env == NULL)
                 return 0;
 
         /* Allow e.g. 'libtesla' to match 'libtesla.foo'. */
         size_t envlen = strnlen(env, 100);
         if ((strncmp(env, name, envlen) == 0) && (name[envlen] == '.'))
                 return 1;
 
         /* Otherwise, use fnmatch's normal star-matching. */
         return (fnmatch(env, name, 0) == 0);
 #endif
 }

Here is the caller graph for this function:

void tesla_die	(	int32_t	errno,
		const char *	event
	)

Call this if things go catastrophically, unrecoverably wrong.

Definition at line 38 of file tesla_util.c.

References tesla_panic, and tesla_strerror().

 {
 
         tesla_panic("tesla_die: fatal error in event '%s'; %s\n",
                 event, tesla_strerror(code));
 }

Here is the call graph for this function:

int32_t tesla_instance_active ( const struct tesla_instance * i )

Checks whether or not a TESLA automata instance is active (in use).

Parameters

i	pointer to a valid tesla_instance

Returns: 1 if active, 0 if inactive

Definition at line 123 of file tesla_class.c.

References tesla_instance::ti_key, tesla_instance::ti_state, and tesla_key::tk_mask.

Referenced by print_class(), tesla_action(), tesla_instance_clear(), tesla_instance_new(), tesla_match(), and tesla_update_state().

 {
         assert(i != NULL);
 
         return ((i->ti_state != 0) || (i->ti_key.tk_mask != 0));
 }

Here is the caller graph for this function:

void tesla_instance_clear ( struct tesla_instance * tip )

Zero an instance for re-use.

Definition at line 173 of file tesla_class.c.

References tesla_instance_active().

Referenced by tesla_update_state().

 {
 
         bzero(tip, sizeof(*tip));
         assert(!tesla_instance_active(tip));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_instance_clone	(	struct tesla_class *	tclass,
		const struct tesla_instance *	orig,
		struct tesla_instance **	copy
	)

Clone an existing instance into a new instance.

Definition at line 166 of file tesla_class.c.

References tesla_instance_new(), tesla_instance::ti_key, and tesla_instance::ti_state.

Referenced by tesla_update_state().

 {
         return tesla_instance_new(tclass, &orig->ti_key, orig->ti_state, copy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_instance_new	(	struct tesla_class *	tclass,
		const struct tesla_key *	name,
		uint32_t	state,
		struct tesla_instance **	out
	)

Create a new tesla_instance.

The caller is responsible for locking the class if needed.

Definition at line 132 of file tesla_class.c.

References tesla_class::tc_free, tesla_class::tc_instances, tesla_class::tc_limit, tesla_assert, TESLA_ERROR_EINVAL, TESLA_ERROR_ENOMEM, tesla_instance_active(), TESLA_SUCCESS, tesla_instance::ti_key, tesla_instance::ti_state, and tesla_key::tk_mask.

Referenced by tesla_instance_clone(), and tesla_update_state().

 {
         assert(tclass != NULL);
         assert(name != NULL);
         assert(out != NULL);
 
         // A new instance must not look inactive.
         if ((state == 0) && (name->tk_mask == 0))
                 return (TESLA_ERROR_EINVAL);
 
         if (tclass->tc_free == 0)
                 return (TESLA_ERROR_ENOMEM);
 
         for (uint32_t i = 0; i < tclass->tc_limit; i++) {
                 struct tesla_instance *inst = tclass->tc_instances + i;
                 if (tesla_instance_active(inst))
                         continue;
 
                 // Initialise the new instance.
                 inst->ti_key = *name;
                 inst->ti_state = state;
 
                 tclass->tc_free--;
                 *out = inst;
 
                 return (TESLA_SUCCESS);
         }
 
         tesla_assert(*out != NULL, ("no free instances but tc_free was > 0"));
         return (TESLA_ERROR_ENOMEM);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_key_matches	(	const struct tesla_key *	pattern,
		const struct tesla_key *	k
	)

Check to see if a key matches a pattern.

Returns: 1 if k matches pattern, 0 otherwise

Definition at line 44 of file tesla_key.c.

References SUBSET, TESLA_KEY_SIZE, tesla_key::tk_keys, and tesla_key::tk_mask.

Referenced by tesla_action(), and tesla_match().

 {
         assert(pattern != NULL);
         assert(k != NULL);
 
         // The pattern's mask must be a subset of the target's (ANY matches
         // 42 but not the other way around).
         if (!SUBSET(pattern->tk_mask, k->tk_mask))
                 return (0);
 
         for (uint32_t i = 0; i < TESLA_KEY_SIZE; i++) {
                 // Only check keys specified by the bitmasks.
                 uint32_t mask = (1 << i);
                 if ((pattern->tk_mask & mask) != mask)
                         continue;
 
                 // A non-match of any sub-key implies a non-match of the key.
                 if (pattern->tk_keys[i] != k->tk_keys[i])
                         return (0);
         }
 
         return (1);
 }

Here is the caller graph for this function:

int32_t tesla_key_union	(	struct tesla_key *	dest,
		const struct tesla_key *	source
	)

Copy new entries from source into dest.

Referenced by tesla_update_state().

Here is the caller graph for this function:

int32_t tesla_match	(	struct tesla_class *	tclass,
		const struct tesla_key *	key,
		struct tesla_instance **	array,
		uint32_t *	size
	)

Find all automata instances in a class that match a particular key.

The caller is responsible for locking the class if necessary.

Parameters

[in]	tclass	the class of automata to match
[in]	key	must remain valid as long as the iterator is in use
[out]	array	a caller-allocated array to store matches in
[in,out]	size	in: size of array. out: number of instances.

Returns: a standard TESLA error code (e.g., TESLA_ERROR_ENOMEM)

Definition at line 93 of file tesla_class.c.

References tesla_class::tc_instances, tesla_class::tc_limit, TESLA_ERROR_ENOMEM, tesla_instance_active(), tesla_key_matches(), TESLA_SUCCESS, and tesla_instance::ti_key.

 {
         assert(tclass != NULL);
         assert(pattern != NULL);
         assert(array != NULL);
         assert(size != NULL);
 
         // Assume that any and every instance could match.
         if (*size < tclass->tc_limit) {
                 *size = tclass->tc_limit;
                 return (TESLA_ERROR_ENOMEM);
         }
 
         // Copy matches into the array.
         *size = 0;
         for (uint32_t i = 0; i < tclass->tc_limit; i++) {
                 struct tesla_instance *inst = tclass->tc_instances + i;
                 if (tesla_instance_active(inst)
                     && tesla_key_matches(pattern, &inst->ti_key)) {
                         array[*size] = inst;
                         *size += 1;
                 }
         }
 
         return (TESLA_SUCCESS);
 }

Here is the call graph for this function:

int tesla_set_event_handler ( struct tesla_event_handlers * )

Register an event handler vector.

Definition at line 59 of file tesla_notification.c.

References error, tesla_event_metahandler::tem_length, and TESLA_SUCCESS.

 {
         int error = check_event_handler(tehp);
         if (error != TESLA_SUCCESS)
                 return (error);
 
         const static struct tesla_event_handlers* singleton[1];
         static struct tesla_event_metahandler singleton_handler = {
                 .tem_length = 1,
                 .tem_mask = 1,
                 .tem_handlers = singleton,
         };
 
         singleton[0] = tehp;
         event_handlers = &singleton_handler;
 
         return (TESLA_SUCCESS);
 }

int tesla_set_event_handlers ( struct tesla_event_metahandler * )

Register a set of event handling vectors.

Definition at line 79 of file tesla_notification.c.

References error, tesla_event_metahandler::tem_handlers, tesla_event_metahandler::tem_length, TESLA_ERROR_EINVAL, and TESLA_SUCCESS.

 {
         int error = TESLA_SUCCESS;
 
         if (!temp)
                 return (TESLA_ERROR_EINVAL);
 
         /*
          * It's ok to disable event handlers dynamically using the bitmask,
          * but all event handlers passed in must be valid.
          */
         for (uint32_t i = 0; i < temp->tem_length; i++) {
                 error = check_event_handler(temp->tem_handlers[i]);
                 if (error != TESLA_SUCCESS)
                         return (error);
         }
 
         event_handlers = temp;
         return (TESLA_SUCCESS);
 }

void tesla_store_free ( struct tesla_store * )

Clean up a tesla_store.

Definition at line 143 of file tesla_store.c.

References tesla_store::classes, DEBUG, tesla_store::length, tesla_class_destroy(), and tesla_free.

Referenced by tesla_pthread_destructor().

 {
         DEBUG(libtesla.store.free, "tesla_store_free %tx\n", store);
 
         for (uint32_t i = 0; i < store->length; i++)
                 tesla_class_destroy(store->classes + i);
 
         tesla_free(store);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_store_get	(	enum tesla_context	context,
		uint32_t	classes,
		uint32_t	instances,
		struct tesla_store **	store
	)

Retrieve the tesla_store for a context (e.g., a thread).

If the tesla_store does not exist yet, it will be created.

Parameters

[in]	context	TESLA_CONTEXT_THREAD or TESLA_CONTEXT_GLOBAL
[in]	classes	number of tesla_class'es to expect
[in]	instances	tesla_instance count per tesla_class
[out]	store	return parameter for tesla_store pointer

Definition at line 65 of file tesla_store.c.

References __debug, tesla_store::classes, tesla_store::length, pthread_key(), TESLA_CONTEXT_GLOBAL, TESLA_CONTEXT_THREAD, TESLA_ERROR_EINVAL, tesla_malloc, tesla_store_init(), and TESLA_SUCCESS.

Referenced by tesla_update_state().

 {
         assert(storep);
 
         tesla_store *store;
 
         switch (context) {
         case TESLA_CONTEXT_GLOBAL:
                 store = &global_store;
                 break;
 
         case TESLA_CONTEXT_THREAD: {
 #ifdef _KERNEL
                 store = curthread->td_tesla;
 #else
                 pthread_key_t key = pthread_key();
                 store = pthread_getspecific(key);
 #endif
 
                 // Create a new store if we don't already have one.
                 if (store == NULL) {
                         store = tesla_malloc(sizeof(tesla_store));
 #ifdef _KERNEL
                         curthread->td_tesla = store;
 #else
                         __debug int err = pthread_setspecific(key, store);
                         assert(err == 0);
 #endif
                 }
                 break;
         }
 
         default:
                 return (TESLA_ERROR_EINVAL);
         }
 
         if (store->length == 0) {
                 int32_t error =
                         tesla_store_init(store, context, classes, instances);
 
                 if (error != TESLA_SUCCESS) return (error);
 
                 assert(store->classes != NULL);
         }
 
         *storep = store;
         return (TESLA_SUCCESS);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int tesla_store_init	(	tesla_store *	,
		enum tesla_context	context,
		uint32_t	classes,
		uint32_t	instances
	)

Initialise tesla_store internals.

Locking is the responsibility of the caller.

Definition at line 117 of file tesla_store.c.

References tesla_store::classes, tesla_store::length, tesla_class::tc_context, tesla_class_init(), TESLA_ERROR_ENOMEM, tesla_malloc, and TESLA_SUCCESS.

Referenced by tesla_store_get().

 {
         assert(classes > 0);
         assert(instances > 0);
 
         store->length = classes;
         store->classes = tesla_malloc(classes * sizeof(tesla_class));
         if (store->classes == NULL)
                 return (TESLA_ERROR_ENOMEM);
 
         int error = TESLA_SUCCESS;
         for (uint32_t i = 0; i < classes; i++) {
                 error = tesla_class_init(store->classes + i, context, instances);
                 assert(error == TESLA_SUCCESS);
                 if (error != TESLA_SUCCESS)
                         break;
 
                 assert(store->classes[i].tc_context >= 0);
         }
 
         return (error);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t tesla_store_reset ( struct tesla_store * store )

Reset all automata in a store to the inactive state.

const char* tesla_strerror ( int32_t error )

Provide string versions of TESLA errors.

Referenced by tesla_die().

Here is the caller graph for this function:

void tesla_update_state	(	enum tesla_context	context,
		uint32_t	class_id,
		const struct tesla_key *	key,
		const char *	name,
		const char *	description,
		const struct tesla_transitions *
	)

Update all automata instances that match a given key to a new state.

Computer Laboratory

Detailed Description

Classes

Macros

Typedefs

Enumerations

Functions

Class Documentation

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation