static void aio_linux_housekeeping(struct tevent_context *event_ctx,
struct tevent_timer *te,
struct timeval now,
void *private_data)
{
/* Remove this timed event handler. */
TALLOC_FREE(te);
if ((num_busy != 0) || used) {
used = false;
/* Still busy. Look again in 30 seconds. */
(void)tevent_add_timer(event_ctx,
NULL,
timeval_current_ofs(30, 0),
aio_linux_housekeeping,
NULL);
return;
}
/* No activity for 30 seconds. Close out kernel resources. */
io_queue_release(io_ctx);
memset(&io_ctx, '\0', sizeof(io_ctx));
if (event_fd != -1) {
close(event_fd);
event_fd = -1;
}
TALLOC_FREE(aio_read_event);
}
void switch_sigint_enabled(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval t,
void *private_data)
{
struct timeval tv;
struct tevent_timer *event_timer = NULL;
struct main_context *main_ctx = talloc_get_type(private_data,
struct main_context);
if (main_ctx->is_sigint_enabled) {
main_ctx->is_sigint_enabled = 0;
DEBUG("SIGINT disabled");
} else {
main_ctx->is_sigint_enabled = 1;
DEBUG("SIGINT enabled");
}
tv = tevent_timeval_current_ofs(SIGINT_SWITCH_TIMEOUT, 0);
event_timer = tevent_add_timer(main_ctx->event_ctx, main_ctx->event_ctx, tv,
switch_sigint_enabled, main_ctx);
if (event_timer == NULL) {
DEBUG("tevent_add_signal() failed");
}
}
static void ctdb_mutex_rados_timer_cb(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data)
{
struct ctdb_mutex_rados_state *cmr_state = private_data;
int ret;
if (!cmr_state->holding_mutex) {
fprintf(stderr, "Timer callback invoked without mutex!\n");
ret = -EINVAL;
goto err_ctx_cleanup;
}
if ((kill(cmr_state->ppid, 0) == 0) || (errno != ESRCH)) {
/* parent still around, keep waiting */
cmr_state->timer_ev = tevent_add_timer(cmr_state->ev, cmr_state,
tevent_timeval_current_ofs(5, 0),
ctdb_mutex_rados_timer_cb,
cmr_state);
if (cmr_state->timer_ev == NULL) {
fprintf(stderr, "Failed to create timer event\n");
/* rely on signal cb */
}
return;
}
/* parent ended, drop lock and exit */
ret = ctdb_mutex_rados_unlock(cmr_state->ioctx, cmr_state->object);
err_ctx_cleanup:
ctdb_mutex_rados_ctx_destroy(cmr_state->ceph_cluster,
cmr_state->ioctx);
talloc_free(cmr_state);
exit(ret ? 1 : 0);
}
static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args)
{
TeventTimer_Object *ret;
struct timeval next_event;
struct tevent_timer *timer;
PyObject *handler;
if (!PyArg_ParseTuple(args, "lO", &next_event, &handler))
return NULL;
timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,
handler);
if (timer == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(timer);
return NULL;
}
ret->timer = timer;
return (PyObject *)ret;
}
static void add_oplock_timeout_handler(files_struct *fsp)
{
struct smbd_server_connection *sconn = fsp->conn->sconn;
struct kernel_oplocks *koplocks = sconn->oplocks.kernel_ops;
/*
* If kernel oplocks already notifies smbds when an oplock break times
* out, just return.
*/
if (koplocks &&
(koplocks->flags & KOPLOCKS_TIMEOUT_NOTIFICATION)) {
return;
}
if (fsp->oplock_timeout != NULL) {
DEBUG(0, ("Logic problem -- have an oplock event hanging "
"around\n"));
}
fsp->oplock_timeout =
tevent_add_timer(fsp->conn->sconn->ev_ctx, fsp,
timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0),
oplock_timeout_handler, fsp);
if (fsp->oplock_timeout == NULL) {
DEBUG(0, ("Could not add oplock timeout handler\n"));
}
}
static void wait_replies(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
bool multiple_replies)
{
struct tevent_timer *te;
bool timed_out = False;
te = tevent_add_timer(ev_ctx, NULL,
timeval_current_ofs(timeout, 0),
smbcontrol_timeout, (void *)&timed_out);
if (te == NULL) {
DEBUG(0, ("tevent_add_timer failed\n"));
return;
}
while (!timed_out) {
int ret;
if (num_replies > 0 && !multiple_replies)
break;
ret = tevent_loop_once(ev_ctx);
if (ret != 0) {
break;
}
}
}
static void remove_child_pid(struct smbd_parent_context *parent,
pid_t pid,
bool unclean_shutdown)
{
struct smbd_child_pid *child;
struct server_id child_id;
int ret;
child_id = pid_to_procid(pid);
ret = messaging_cleanup(parent->msg_ctx, pid);
if ((ret != 0) && (ret != ENOENT)) {
DEBUG(10, ("%s: messaging_cleanup returned %s\n",
__func__, strerror(ret)));
}
smbprofile_cleanup(pid);
for (child = parent->children; child != NULL; child = child->next) {
if (child->pid == pid) {
struct smbd_child_pid *tmp = child;
DLIST_REMOVE(parent->children, child);
TALLOC_FREE(tmp);
parent->num_children -= 1;
break;
}
}
if (child == NULL) {
/* not all forked child processes are added to the children list */
DEBUG(2, ("Could not find child %d -- ignoring\n", (int)pid));
return;
}
if (unclean_shutdown) {
/* a child terminated uncleanly so tickle all
processes to see if they can grab any of the
pending locks
*/
DEBUG(3,(__location__ " Unclean shutdown of pid %u\n",
(unsigned int)pid));
if (parent->cleanup_te == NULL) {
/* call the cleanup timer, but not too often */
int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
parent->cleanup_te = tevent_add_timer(parent->ev_ctx,
parent,
timeval_current_ofs(cleanup_time, 0),
cleanup_timeout_fn,
parent);
DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
}
}
if (!serverid_deregister(child_id)) {
DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
(int)pid));
}
}
static void ldap_id_enumerate_timer(struct tevent_context *ev,
struct tevent_timer *tt,
struct timeval tv, void *pvt)
{
struct sdap_id_ctx *ctx = talloc_get_type(pvt, struct sdap_id_ctx);
struct tevent_timer *timeout;
struct tevent_req *req;
int delay;
errno_t ret;
if (be_is_offline(ctx->be)) {
DEBUG(4, ("Backend is marked offline, retry later!\n"));
/* schedule starting from now, not the last run */
delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);
tv = tevent_timeval_current_ofs(delay, 0);
ldap_id_enumerate_set_timer(ctx, tv);
return;
}
req = ldap_id_enumerate_send(ev, ctx);
if (!req) {
DEBUG(1, ("Failed to schedule enumeration, retrying later!\n"));
/* schedule starting from now, not the last run */
delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);
tv = tevent_timeval_current_ofs(delay, 0);
ret = ldap_id_enumerate_set_timer(ctx, tv);
if (ret != EOK) {
DEBUG(1, ("Error setting up enumerate timer\n"));
}
return;
}
tevent_req_set_callback(req, ldap_id_enumerate_reschedule, ctx);
/* if enumeration takes so long, either we try to enumerate too
* frequently, or something went seriously wrong */
delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);
tv = tevent_timeval_current_ofs(delay, 0);
timeout = tevent_add_timer(ctx->be->ev, req, tv,
ldap_id_enumerate_timeout, req);
if (timeout == NULL) {
/* If we can't guarantee a timeout, we
* need to cancel the request, to avoid
* the possibility of starting another
* concurrently
*/
talloc_zfree(req);
DEBUG(1, ("Failed to schedule enumeration, retrying later!\n"));
/* schedule starting from now, not the last run */
delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);
tv = tevent_timeval_current_ofs(delay, 0);
ret = ldap_id_enumerate_set_timer(ctx, tv);
if (ret != EOK) {
DEBUG(1, ("Error setting up enumerate timer\n"));
}
return;
}
return;
}
/*
setup a timer to destroy a open search after a inactivity period
*/
static void pvfs_search_setup_timer(struct pvfs_search_state *search)
{
struct tevent_context *ev = search->pvfs->ntvfs->ctx->event_ctx;
if (search->handle == INVALID_SEARCH_HANDLE) return;
talloc_free(search->te);
search->te = tevent_add_timer(ev, search,
timeval_current_ofs(search->pvfs->search.inactivity_time, 0),
pvfs_search_timer, search);
}
static bool init_aio_linux(struct vfs_handle_struct *handle)
{
struct tevent_timer *te = NULL;
if (event_fd != -1) {
/* Already initialized. */
return true;
}
/* Schedule a shutdown event for 30 seconds from now. */
te = tevent_add_timer(handle->conn->sconn->ev_ctx,
NULL,
timeval_current_ofs(30, 0),
aio_linux_housekeeping,
NULL);
if (te == NULL) {
goto fail;
}
event_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
if (event_fd == -1) {
goto fail;
}
aio_read_event = tevent_add_fd(server_event_context(),
NULL,
event_fd,
TEVENT_FD_READ,
aio_linux_done,
NULL);
if (aio_read_event == NULL) {
goto fail;
}
if (io_queue_init(lp_aio_max_threads(), &io_ctx)) {
goto fail;
}
DEBUG(10,("init_aio_linux: initialized with up to %d events\n",
(int)lp_aio_max_threads()));
return true;
fail:
DEBUG(10,("init_aio_linux: initialization failed\n"));
TALLOC_FREE(te);
TALLOC_FREE(aio_read_event);
if (event_fd != -1) {
close(event_fd);
event_fd = -1;
}
memset(&io_ctx, '\0', sizeof(io_ctx));
return false;
}
/*
see if any nodes are dead
*/
static void ctdb_check_for_dead_nodes(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval t, void *private_data)
{
struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
int i;
/* send a keepalive to all other nodes, unless */
for (i=0;i<ctdb->num_nodes;i++) {
struct ctdb_node *node = ctdb->nodes[i];
if (node->flags & NODE_FLAGS_DELETED) {
continue;
}
if (node->pnn == ctdb->pnn) {
continue;
}
if (node->flags & NODE_FLAGS_DISCONNECTED) {
/* it might have come alive again */
if (node->rx_cnt != 0) {
ctdb_node_connected(node);
}
continue;
}
if (node->rx_cnt == 0) {
node->dead_count++;
} else {
node->dead_count = 0;
}
node->rx_cnt = 0;
if (node->dead_count >= ctdb->tunable.keepalive_limit) {
DEBUG(DEBUG_NOTICE,("dead count reached for node %u\n", node->pnn));
ctdb_node_dead(node);
ctdb_send_keepalive(ctdb, node->pnn);
/* maybe tell the transport layer to kill the
sockets as well?
*/
continue;
}
DEBUG(DEBUG_DEBUG,("sending keepalive to %u\n", node->pnn));
ctdb_send_keepalive(ctdb, node->pnn);
node->tx_cnt = 0;
}
tevent_add_timer(ctdb->ev, ctdb->keepalive_ctx,
timeval_current_ofs(ctdb->tunable.keepalive_interval, 0),
ctdb_check_for_dead_nodes, ctdb);
}
bool fsp_lease_update(struct share_mode_lock *lck,
const struct GUID *client_guid,
struct fsp_lease *lease)
{
struct share_mode_data *d = lck->data;
int idx;
struct share_mode_lease *l = NULL;
idx = find_share_mode_lease(d, client_guid, &lease->lease.lease_key);
if (idx != -1) {
l = &d->leases[idx];
}
if (l == NULL) {
DEBUG(1, ("%s: Could not find lease entry\n", __func__));
TALLOC_FREE(lease->timeout);
lease->lease.lease_state = SMB2_LEASE_NONE;
lease->lease.lease_epoch += 1;
lease->lease.lease_flags = 0;
return false;
}
DEBUG(10,("%s: refresh lease state\n", __func__));
/* Ensure we're in sync with current lease state. */
if (lease->lease.lease_epoch != l->epoch) {
DEBUG(10,("%s: cancel outdated timeout\n", __func__));
TALLOC_FREE(lease->timeout);
}
lease->lease.lease_epoch = l->epoch;
lease->lease.lease_state = l->current_state;
if (l->breaking) {
lease->lease.lease_flags |= SMB2_LEASE_FLAG_BREAK_IN_PROGRESS;
if (lease->timeout == NULL) {
struct timeval t = timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0);
DEBUG(10,("%s: setup timeout handler\n", __func__));
lease->timeout = tevent_add_timer(lease->sconn->ev_ctx,
lease, t,
lease_timeout_handler,
lease);
if (lease->timeout == NULL) {
DEBUG(0, ("%s: Could not add lease timeout handler\n",
__func__));
}
}
} else {
lease->lease.lease_flags &= ~SMB2_LEASE_FLAG_BREAK_IN_PROGRESS;
TALLOC_FREE(lease->timeout);
}
return true;
}
static void add_krb5_ticket_gain_handler_event(struct WINBINDD_CCACHE_ENTRY *entry,
struct timeval t)
{
entry->refresh_time = 0;
entry->event = tevent_add_timer(winbind_event_context(),
entry,
t,
krb5_ticket_gain_handler,
entry);
}
_PUBLIC_ void composite_done(struct composite_context *ctx)
{
if (!ctx->used_wait && !ctx->async.fn) {
tevent_add_timer(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
}
ctx->state = COMPOSITE_STATE_DONE;
if (ctx->async.fn != NULL) {
ctx->async.fn(ctx);
}
}
/*
* Callback routine when required locks are not obtained within timeout
* Called from parent context
*/
static void ctdb_lock_timeout_handler(struct tevent_context *ev,
struct tevent_timer *ttimer,
struct timeval current_time,
void *private_data)
{
static const char * debug_locks = NULL;
struct lock_context *lock_ctx;
struct ctdb_context *ctdb;
pid_t pid;
lock_ctx = talloc_get_type_abort(private_data, struct lock_context);
ctdb = lock_ctx->ctdb;
if (lock_ctx->type == LOCK_RECORD || lock_ctx->type == LOCK_DB) {
DEBUG(DEBUG_WARNING,
("Unable to get %s lock on database %s for %.0lf seconds\n",
(lock_ctx->type == LOCK_RECORD ? "RECORD" : "DB"),
lock_ctx->ctdb_db->db_name,
timeval_elapsed(&lock_ctx->start_time)));
} else {
DEBUG(DEBUG_WARNING,
("Unable to get ALLDB locks for %.0lf seconds\n",
timeval_elapsed(&lock_ctx->start_time)));
}
/* Fire a child process to find the blocking process. */
if (debug_locks == NULL) {
debug_locks = getenv("CTDB_DEBUG_LOCKS");
if (debug_locks == NULL) {
debug_locks = talloc_asprintf(ctdb,
"%s/debug_locks.sh",
getenv("CTDB_BASE"));
}
}
if (debug_locks != NULL) {
pid = vfork();
if (pid == 0) {
execl(debug_locks, debug_locks, NULL);
_exit(0);
}
ctdb_track_child(ctdb, pid);
} else {
DEBUG(DEBUG_WARNING,
(__location__
" Unable to setup lock debugging - no memory?\n"));
}
/* reset the timeout timer */
// talloc_free(lock_ctx->ttimer);
lock_ctx->ttimer = tevent_add_timer(ctdb->ev,
lock_ctx,
timeval_current_ofs(10, 0),
ctdb_lock_timeout_handler,
(void *)lock_ctx);
}
static void each_second(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval t,
void *private_data)
{
struct db_context *db = talloc_get_type(private_data, struct db_context);
print_counters();
tevent_add_timer(ev, db, timeval_current_ofs(1, 0), each_second, db);
}
/*
re-enable receiving
*/
_PUBLIC_ void packet_recv_enable(struct packet_context *pc)
{
if (pc->recv_need_enable) {
pc->recv_need_enable = false;
TEVENT_FD_READABLE(pc->fde);
}
pc->recv_disable = false;
if (pc->num_read != 0 && pc->packet_size >= pc->num_read) {
tevent_add_timer(pc->ev, pc, timeval_zero(), packet_next_event, pc);
}
}
/*
start a timer to refresh this name
*/
static void nbtd_wins_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
tevent_add_timer(iname->iface->nbtsrv->task->event_ctx,
iname,
timeval_add(&iname->registration_time, refresh_time, 0),
nbtd_wins_refresh, iname);
}
static bool test_event_context_threaded(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev;
struct tevent_timer *te;
struct tevent_fd *fde;
pthread_t poll_thread;
int fds[2];
int ret;
char c = 0;
ev = tevent_context_init_byname(test, "poll_mt");
torture_assert(test, ev != NULL, "poll_mt not supported");
tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
test_event_threaded_timer, NULL);
torture_assert(test, te != NULL, "Could not add timer");
ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
torture_assert(test, ret == 0, "Could not create poll thread");
ret = pipe(fds);
torture_assert(test, ret == 0, "Could not create pipe");
poll(NULL, 0, 100);
test_event_threaded_lock();
fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
test_event_threaded_read_handler, &fds[0]);
torture_assert(test, fde != NULL, "Could not add fd event");
test_event_threaded_unlock();
poll(NULL, 0, 100);
write(fds[1], &c, 1);
poll(NULL, 0, 100);
test_event_threaded_lock();
do_shutdown = true;
test_event_threaded_unlock();
write(fds[1], &c, 1);
ret = pthread_join(poll_thread, NULL);
torture_assert(test, ret == 0, "pthread_join failed");
return true;
}
/*
called when the startup event script finishes
*/
static void ctdb_startup_callback(struct ctdb_context *ctdb, int status, void *p)
{
if (status != 0) {
DEBUG(DEBUG_ERR,("startup event failed\n"));
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(5, 0),
ctdb_run_startup, ctdb);
return;
}
DEBUG(DEBUG_NOTICE,("startup event OK - enabling monitoring\n"));
ctdb_set_runstate(ctdb, CTDB_RUNSTATE_RUNNING);
ctdb->monitor->next_interval = 2;
ctdb_run_notification_script(ctdb, "startup");
ctdb->monitor->monitoring_mode = CTDB_MONITORING_ACTIVE;
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(ctdb->monitor->next_interval, 0),
ctdb_check_health, ctdb);
}
/*
shutdown and try to restart a connection to a node after it has been
disconnected
*/
static void ctdb_tcp_restart(struct ctdb_node *node)
{
struct ctdb_tcp_node *tnode = talloc_get_type(
node->private_data, struct ctdb_tcp_node);
DEBUG(DEBUG_NOTICE,("Tearing down connection to dead node :%d\n", node->pnn));
ctdb_tcp_stop_connection(node);
tnode->connect_te = tevent_add_timer(node->ctdb->ev, tnode,
timeval_zero(),
ctdb_tcp_node_connect, node);
}
/*
see if the event scripts think we are healthy
*/
static void ctdb_check_health(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval t, void *private_data)
{
struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
bool skip_monitoring = false;
int ret = 0;
if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL ||
ctdb->monitor->monitoring_mode == CTDB_MONITORING_DISABLED) {
skip_monitoring = true;
} else {
if (ctdb_db_all_frozen(ctdb)) {
DEBUG(DEBUG_ERR,
("Skip monitoring since databases are frozen\n"));
skip_monitoring = true;
}
}
if (skip_monitoring) {
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(ctdb->monitor->next_interval, 0),
ctdb_check_health, ctdb);
return;
}
ret = ctdb_event_script_callback(ctdb,
ctdb->monitor->monitor_context,
ctdb_health_callback,
ctdb, CTDB_EVENT_MONITOR, "%s", "");
if (ret != 0) {
DEBUG(DEBUG_ERR,("Unable to launch monitor event script\n"));
ctdb->monitor->next_interval = 5;
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(5, 0),
ctdb_check_health, ctdb);
}
}
static void ctdb_run_startup(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval t, void *private_data)
{
struct ctdb_context *ctdb = talloc_get_type(private_data,
struct ctdb_context);
int ret;
/* This is necessary to avoid the "startup" event colliding
* with the "ipreallocated" event from the takeover run
* following the first recovery. We might as well serialise
* these things if we can.
*/
if (ctdb->runstate < CTDB_RUNSTATE_STARTUP) {
DEBUG(DEBUG_NOTICE,
("Not yet in startup runstate. Wait one more second\n"));
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(1, 0),
ctdb_run_startup, ctdb);
return;
}
/* release any IPs we hold from previous runs of the daemon */
ctdb_release_all_ips(ctdb);
DEBUG(DEBUG_NOTICE,("Running the \"startup\" event.\n"));
ret = ctdb_event_script_callback(ctdb,
ctdb->monitor->monitor_context,
ctdb_startup_callback,
ctdb, CTDB_EVENT_STARTUP, "%s", "");
if (ret != 0) {
DEBUG(DEBUG_ERR,("Unable to launch startup event script\n"));
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(5, 0),
ctdb_run_startup, ctdb);
}
}
void ctdb_start_keepalive(struct ctdb_context *ctdb)
{
struct tevent_timer *te;
ctdb->keepalive_ctx = talloc_new(ctdb);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->keepalive_ctx);
te = tevent_add_timer(ctdb->ev, ctdb->keepalive_ctx,
timeval_current_ofs(ctdb->tunable.keepalive_interval, 0),
ctdb_check_for_dead_nodes, ctdb);
CTDB_NO_MEMORY_FATAL(ctdb, te);
DEBUG(DEBUG_NOTICE,("Keepalive monitoring has been started\n"));
}
void smbprofile_dump_schedule_timer(void)
{
struct timeval tv;
GetTimeOfDay(&tv);
tv.tv_sec += 1;
smbprofile_state.internal.te = tevent_add_timer(
smbprofile_state.internal.ev,
smbprofile_state.internal.ev,
tv,
smbprofile_dump_timer,
NULL);
}
/*
start watching for nodes that might be dead
*/
void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb)
{
ctdb_set_runstate(ctdb, CTDB_RUNSTATE_FIRST_RECOVERY);
ctdb->monitor = talloc(ctdb, struct ctdb_monitor_state);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor);
ctdb->monitor->monitor_context = talloc_new(ctdb->monitor);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor->monitor_context);
tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(1, 0),
ctdb_wait_until_recovered, ctdb);
}
/*
called when a complete packet has come in - should not happen on this socket
unless the other side closes the connection with RST or FIN
*/
void ctdb_tcp_tnode_cb(uint8_t *data, size_t cnt, void *private_data)
{
struct ctdb_node *node = talloc_get_type(private_data, struct ctdb_node);
struct ctdb_tcp_node *tnode = talloc_get_type(
node->private_data, struct ctdb_tcp_node);
if (data == NULL) {
node->ctdb->upcalls->node_dead(node);
}
ctdb_tcp_stop_connection(node);
tnode->connect_te = tevent_add_timer(node->ctdb->ev, tnode,
timeval_current_ofs(3, 0),
ctdb_tcp_node_connect, node);
}
int ctdb_statistics_init(struct ctdb_context *ctdb)
{
bzero(&ctdb->statistics, sizeof(struct ctdb_statistics));
ctdb->statistics.statistics_start_time = timeval_current();
bzero(&ctdb->statistics_current, sizeof(struct ctdb_statistics));
ctdb->statistics_current.statistics_start_time = timeval_current();
bzero(ctdb->statistics_history, sizeof(ctdb->statistics_history));
tevent_add_timer(ctdb->ev, ctdb,
timeval_current_ofs(ctdb->tunable.stat_history_interval, 0),
ctdb_statistics_update, ctdb);
return 0;
}
bool tevent_req_set_endtime(struct tevent_req *req,
struct tevent_context *ev,
struct timeval endtime)
{
TALLOC_FREE(req->internal.timer);
req->internal.timer = tevent_add_timer(ev, req, endtime,
tevent_req_timedout,
req);
if (tevent_req_nomem(req->internal.timer, req)) {
return false;
}
return true;
}
void ccache_regain_all_now(void)
{
struct WINBINDD_CCACHE_ENTRY *cur;
struct timeval t = timeval_current();
for (cur = ccache_list; cur; cur = cur->next) {
struct tevent_timer *new_event;
/*
* if refresh_time is 0, we know that the
* the event has the krb5_ticket_gain_handler
*/
if (cur->refresh_time == 0) {
new_event = tevent_add_timer(winbind_event_context(),
cur,
t,
krb5_ticket_gain_handler,
cur);
} else {
new_event = tevent_add_timer(winbind_event_context(),
cur,
t,
krb5_ticket_refresh_handler,
cur);
}
if (!new_event) {
continue;
}
TALLOC_FREE(cur->event);
cur->event = new_event;
}
return;
}
