state_root Struct Reference

Collaboration diagram for state_root:

Public Member Functions
	state_root () noexcept
	~state_root ()
void	broadcast_should_exit (bool quit_watcher=false)

Static Public Member Functions
static void	deleter (struct module *m)
static void	should_exit_watcher (state_root *s)

Public Attributes
volatile int	exit_status = EXIT_SUCCESS

Private Attributes
mutex	lock
list< tuple< void(*)(void *), void * > >	should_exit_callbacks
fd_t	should_exit_pipe [2]
thread	should_exit_thread

Static Private Attributes
static constexpr char	QUIT_WATCHER_FLAG = 1

Friends
void	register_should_exit_callback (struct module *mod, void(*callback)(void *), void *udata)
void	unregister_should_exit_callback (struct module *mod, void(*callback)(void *), void *udata)

Detailed Description

Definition at line 539 of file host.cpp.

Constructor & Destructor Documentation

state_root()

state_root::state_root ( )

inlinenoexcept

Definition at line 540 of file host.cpp.

                              {
                if (platform_pipe_init(should_exit_pipe) != 0) {
                        LOG(LOG_LEVEL_FATAL) << "FATAL: Cannot create pipe!\n";
                        abort();
                }
                should_exit_thread = thread(should_exit_watcher, this);
        }

References LOG, LOG_LEVEL_FATAL, platform_pipe_init(), should_exit_pipe, should_exit_thread, and should_exit_watcher().

Here is the call graph for this function:

~state_root()

state_root::~state_root ( )

inline

Definition at line 547 of file host.cpp.

                      {
                unique_lock<mutex> lk(lock);
                should_exit_callbacks.clear();
                lk.unlock();
                broadcast_should_exit(true); // here just exit the should exit thr
                should_exit_thread.join();
                for (int i = 0; i < 2; ++i) {
                        platform_pipe_close(should_exit_pipe[0]);
                }
        }

References broadcast_should_exit(), platform_pipe_close(), should_exit_callbacks, should_exit_pipe, and should_exit_thread.

Here is the call graph for this function:

Member Function Documentation

broadcast_should_exit()

void state_root::broadcast_should_exit ( bool quit_watcher = false )

inline

Definition at line 579 of file host.cpp.

        {
                const char q = quit_watcher ? QUIT_WATCHER_FLAG : 0;
                while (PLATFORM_PIPE_WRITE(should_exit_pipe[1], &q, 1) != 1) {
                        perror("PLATFORM_PIPE_WRITE");
                }
        }

References PLATFORM_PIPE_WRITE, QUIT_WATCHER_FLAG, and should_exit_pipe.

Referenced by ~state_root(), and exit_uv().

deleter()

static void state_root::deleter ( struct module * m )

inlinestatic

Definition at line 557 of file host.cpp.

                                              {
                delete (state_root*) m->priv_data;
        }

References module::priv_data.

Referenced by init_root_module().

should_exit_watcher()

static void state_root::should_exit_watcher ( state_root * s )

inlinestatic

Definition at line 561 of file host.cpp.

                                                       {
                set_thread_name(__func__);
                char q = 0;
                bool should_exit_thread_notified = false;
                while (q != QUIT_WATCHER_FLAG) {
                        while (PLATFORM_PIPE_READ(s->should_exit_pipe[0], &q,
                                                  1) != 1) {
                                perror("PLATFORM_PIPE_READ");
                        }
                        if (!should_exit_thread_notified) {
                                unique_lock<mutex> lk(s->lock);
                                for (auto const &c : s->should_exit_callbacks) {
                                        get<0>(c)(get<1>(c));
                                }
                                should_exit_thread_notified = true;
                        }
                }
        }

References lock, PLATFORM_PIPE_READ, QUIT_WATCHER_FLAG, set_thread_name(), should_exit_callbacks, and should_exit_pipe.

Referenced by state_root().

Here is the call graph for this function:

Friends And Related Symbol Documentation

register_should_exit_callback

void register_should_exit_callback ( struct module * mod, void(* callback )(void *), void * udata )

friend

Definition at line 1144 of file host.cpp.

{
        auto              *s = (state_root *) get_root_module(mod)->priv_data;
        unique_lock<mutex> lk(s->lock);
        s->should_exit_callbacks.emplace_back(callback, udata);
}

unregister_should_exit_callback

void unregister_should_exit_callback ( struct module * mod, void(* callback )(void *), void * udata )

friend

Unregisters should_exit callback registered with register_should_exit_callback

The callback must have been registered (and not unregistered), otherwise abort is (currently) called.

Definition at line 1158 of file host.cpp.

{
        auto              *s = (state_root *) get_root_module(mod)->priv_data;
        unique_lock<mutex> lk(s->lock);
        for (auto it = s->should_exit_callbacks.begin();
             it != s->should_exit_callbacks.end(); ++it) {
                if (get<0>(*it) == callback && get<1>(*it) == udata) {
                        s->should_exit_callbacks.erase(it);
                        return;
                }
        }
        abort();
}

Member Data Documentation

exit_status

volatile int state_root::exit_status = EXIT_SUCCESS

Definition at line 587 of file host.cpp.

Referenced by exit_uv().

lock

mutex state_root::lock

private

Definition at line 590 of file host.cpp.

Referenced by should_exit_watcher().

QUIT_WATCHER_FLAG

char state_root::QUIT_WATCHER_FLAG = 1

staticconstexprprivate

Definition at line 589 of file host.cpp.

Referenced by broadcast_should_exit(), and should_exit_watcher().

should_exit_callbacks

list<tuple<void (*)(void *), void *> > state_root::should_exit_callbacks

private

Definition at line 593 of file host.cpp.

Referenced by ~state_root(), and should_exit_watcher().

should_exit_pipe

fd_t state_root::should_exit_pipe[2]

private

Definition at line 591 of file host.cpp.

Referenced by state_root(), ~state_root(), broadcast_should_exit(), and should_exit_watcher().

should_exit_thread

thread state_root::should_exit_thread

private

Definition at line 592 of file host.cpp.

Referenced by state_root(), and ~state_root().

---

The documentation for this struct was generated from the following file:

• src/host.cpp