src/timer.c File Reference

#include "copyright.h"
#include "config.h"
#include <signal.h>
#include "mudconf.h"
#include "db.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "command.h"
#include "attrs.h"
#include "powers.h"

Include dependency graph for timer.c:

Go to the source code of this file.

Defines
#define	DPSET(n)
Functions
void	pool_reset (void)
void	do_second (void)
void	fork_and_dump (int key)
unsigned int	alarm (unsigned int seconds)
void	pcache_trim (void)
void	check_events (void)
void	timer_callback (int fd, short event, void *arg)
void	init_timer ()
void	check_idle (void)
void	dispatch ()
void	do_timewarp (dbref player, dbref cause, int key, char *arg)
Variables
static struct timeval	tv = { 0, 100000 }
static struct event	timer_event

---

Define Documentation

#define DPSET

(

n

)

Definition at line 53 of file timer.c.

Referenced by dispatch().

---

Function Documentation

unsigned int alarm

(

unsigned int

seconds

)

void check_events

(

void

)

Definition at line 83 of file timer.c.

References A_DAILY, A_HOURLY, did_it(), DO_WHOLE_DB, ET_DAILY, confdata::events_daily_hour, statedata::events_flag, statedata::events_lasthour, Flags2, Going, HAS_DAILY, HAS_HOURLY, ITER_PARENTS, mudconf, mudstate, statedata::now, and Owner.

Referenced by dispatch().

{
    struct tm *ltime;
    dbref thing, parent;
    int lev;
    
    ltime = localtime(&mudstate.now);
    if((ltime->tm_hour == mudconf.events_daily_hour)
       && !(mudstate.events_flag & ET_DAILY)) {
        mudstate.events_flag = mudstate.events_flag | ET_DAILY;
        DO_WHOLE_DB(thing) { 
            if(Going(thing))
                continue;
                
            ITER_PARENTS(thing, parent, lev) {
                if(Flags2(thing) & HAS_DAILY) {
                    did_it(Owner(thing), thing, 0, NULL, 0, NULL, A_DAILY,
                           (char **) NULL, 0);
                           
                    break;
                }   
            }   
        }   
    }   
    if(ltime->tm_hour != mudstate.events_lasthour) {
        if(mudstate.events_lasthour >= 0) {
            /* Run hourly maintenance */
            DO_WHOLE_DB(thing) {
                if(Going(thing))
                    continue;
                    
                ITER_PARENTS(thing, parent, lev) {
                    if(Flags2(thing) & HAS_HOURLY) {
                        did_it(Owner(thing), thing, 0, NULL, 0, NULL,
                               A_HOURLY, (char **) NULL, 0); 
                               
                        break;
                    }   
                }   
            }   
            
        }
        mudstate.events_lasthour = ltime->tm_hour;
    }
    if(ltime->tm_hour == 23) {  /*
                                 * Nightly resetting 
                                 */
        mudstate.events_flag = 0;
    }
}

void check_idle

(

void

)

Definition at line 56 of file timer.c.

References Can_Idle, confdata::conn_timeout, descriptor_data::connected_at, DARK, Dark, DESC_SAFEITER_ALL, DS_AUTODARK, DS_CONNECTED, Flags, descriptor_data::flags, confdata::idle_timeout, confdata::idle_wiz_dark, descriptor_data::last_time, mudconf, mudstate, statedata::now, descriptor_data::player, queue_string(), R_TIMEOUT, s_Flags, shutdownsock(), and descriptor_data::timeout.

Referenced by dispatch().

{
    DESC *d, *dnext;
    time_t idletime;
    
    DESC_SAFEITER_ALL(d, dnext) {
        if(d->flags & DS_CONNECTED) {
            idletime = mudstate.now - d->last_time;
            if((idletime > d->timeout) && !Can_Idle(d->player)) {
                queue_string(d, "*** Inactivity Timeout ***\r\n");
                shutdownsock(d, R_TIMEOUT);
            } else if(mudconf.idle_wiz_dark &&
                      (idletime > mudconf.idle_timeout) && Can_Idle(d->player)
                      && !Dark(d->player)) {
                s_Flags(d->player, Flags(d->player) | DARK);
                d->flags |= DS_AUTODARK;
            }   
        } else {
            idletime = mudstate.now - d->connected_at;
            if(idletime > mudconf.conn_timeout) {
                queue_string(d, "*** Login Timeout ***\r\n");
                shutdownsock(d, R_TIMEOUT);
            }   
        }   
    }   
}   

void dispatch

(

)

Definition at line 135 of file timer.c.

References statedata::alarm_triggered, CF_CHECKPOINT, CF_DBCHECK, CF_EVENTCHECK, CF_IDLECHECK, statedata::check_counter, check_events(), check_idle(), confdata::check_interval, confdata::control_flags, statedata::debug_cmd, do_dbck(), do_second(), DPSET, statedata::dump_counter, confdata::dump_interval, statedata::events_counter, fork_and_dump(), confdata::have_specials, statedata::idle_counter, confdata::idle_interval, statedata::mstat_curr, statedata::mstat_idrss, statedata::mstat_isrss, statedata::mstat_ixrss, statedata::mstat_secs, statedata::mstats_counter, mudconf, mudstate, NOTHING, statedata::now, pcache_trim(), time(), and UpdateSpecialObjects().

Referenced by timer_callback().

{
        char *cmdsave;

#ifdef USE_PYTHON
        mudstate.debug_cmd = "< Python >";
        updatePython();
#endif

        cmdsave = mudstate.debug_cmd;
        DPSET("< dispatch >");
        /*
         * this routine can be used to poll from interface.c 
         */

        if(!mudstate.alarm_triggered)
                return;
        mudstate.alarm_triggered = 0;
        mudstate.now = time(NULL);

        do_second();

        /*
         * Free list reconstruction 
         */

        if((mudconf.control_flags & CF_DBCHECK) &&
           (mudstate.check_counter <= mudstate.now)) {
                mudstate.check_counter = mudconf.check_interval + mudstate.now;
                DPSET("< dbck >");
                do_dbck(NOTHING, NOTHING, 0);
                pcache_trim();
        }
        /*
         * Database dump routines 
         */

        if((mudconf.control_flags & CF_CHECKPOINT) &&
           (mudstate.dump_counter <= mudstate.now)) {
                mudstate.dump_counter = mudconf.dump_interval + mudstate.now;
                DPSET("< dump >");
                fork_and_dump(0);
        }
        /*
           Mech stuff ; hopefully it means once ~per sec, although you
           can never be sure - therefore, the code does 'timejumps' as
           needed (see UpdateSpecialObjects for details)
         */

        if(mudconf.have_specials)
                UpdateSpecialObjects();

        /*
         * Idle user check 
         */

        if((mudconf.control_flags & CF_IDLECHECK) &&
           (mudstate.idle_counter <= mudstate.now)) {
                mudstate.idle_counter = mudconf.idle_interval + mudstate.now;
                DPSET("< idlecheck >");
                check_idle();

        }
        /*
         * Check for execution of attribute events 
         */

        if((mudconf.control_flags & CF_EVENTCHECK) &&
           (mudstate.events_counter <= mudstate.now)) {
                mudstate.events_counter = 900 + mudstate.now;
                DPSET("< eventcheck >");
                check_events();
        }
#ifdef HAVE_GETRUSAGE
        /*
         * Memory use stats 
         */

        if(mudstate.mstats_counter <= mudstate.now) {

                int curr;

                mudstate.mstats_counter = 15 + mudstate.now;
                curr = mudstate.mstat_curr;
                if(mudstate.now > mudstate.mstat_secs[curr]) {

                        struct rusage usage;

                        curr = 1 - curr;
                        getrusage(RUSAGE_SELF, &usage);
                        mudstate.mstat_ixrss[curr] = usage.ru_ixrss;
                        mudstate.mstat_idrss[curr] = usage.ru_idrss;
                        mudstate.mstat_isrss[curr] = usage.ru_isrss;
                        mudstate.mstat_secs[curr] = mudstate.now;
                        mudstate.mstat_curr = curr;
                }
        }
#endif

        mudstate.debug_cmd = cmdsave;
}

void do_second

(

void

)

Definition at line 862 of file cque.c.

References add_to(), bque::attr, CF_DEQUEUE, bque::comm, confdata::control_flags, cque_enqueue(), statedata::debug_cmd, mudconf, mudstate, bque::next, NOTHING, statedata::now, bque::player, printk, statedata::qsemfirst, statedata::qsemlast, bque::sem, and bque::waittime.

Referenced by dispatch(), do_queue(), and process_preload().

{
        BQUE *trail, *point, *next;
        char *cmdsave;

        /*
         * move contents of low priority queue onto end of normal one this
         * helps to keep objects from getting out of control since
         * its affects on other objects happen only after one
         * second  this should allow @halt to be type before
         * getting blown away  by scrolling text 
         */

        if((mudconf.control_flags & CF_DEQUEUE) == 0)
                return;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_second >";

        /*
         * Note: the point->waittime test would be 0 except the command is
         * being put in the low priority queue to be done in one
         * second anyways 
         */

        /*
         * Check the semaphore queue for expired timed-waits 
         */

        for(point = mudstate.qsemfirst, trail = NULL; point; point = next) {
                if(point->waittime == 0) {
                        next = (trail = point)->next;
                        continue;                       /*
                                                                 * Skip if not timed-wait 
                                                                 */
                }
                if(point->waittime <= mudstate.now) {
                        if(trail != NULL)
                                trail->next = next = point->next;
                        else
                                mudstate.qsemfirst = next = point->next;
                        if(point == mudstate.qsemlast)
                                mudstate.qsemlast = trail;
                        add_to(point->sem, -1, point->attr);
                        point->sem = NOTHING;
            point->waittime = 0;
                        printk("promoting, %d/%s", point->player, point->comm);
                        cque_enqueue(point->player, point);
                } else
                        next = (trail = point)->next;
        }
        mudstate.debug_cmd = cmdsave;
        return;
}

void do_timewarp	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg
	)

Adjust various internal timers.

Definition at line 247 of file timer.c.

References statedata::check_counter, do_queue(), statedata::dump_counter, statedata::events_counter, statedata::idle_counter, mudstate, QUEUE_WARP, TWARP_CLEAN, TWARP_DUMP, TWARP_EVENTS, TWARP_IDLE, and TWARP_QUEUE.

{
        int secs;

        secs = atoi(arg);

        if((key == 0) || (key & TWARP_QUEUE))   /*
                                                                                         * Sem/Wait queues 
                                                                                         */
                do_queue(player, cause, QUEUE_WARP, arg);
        if(key & TWARP_DUMP)
                mudstate.dump_counter -= secs;
        if(key & TWARP_CLEAN)
                mudstate.check_counter -= secs;
        if(key & TWARP_IDLE)
                mudstate.idle_counter -= secs;
        if(key & TWARP_EVENTS)
                mudstate.events_counter -= secs;
}

void fork_and_dump

(

int

key

)

void init_timer

(

void

)

Definition at line 32 of file timer.c.

References statedata::check_counter, confdata::check_interval, confdata::check_offset, statedata::dump_counter, confdata::dump_interval, confdata::dump_offset, statedata::events_counter, statedata::idle_counter, confdata::idle_interval, statedata::mstats_counter, mudconf, mudstate, statedata::now, time(), timer_callback(), timer_event, and tv.

Referenced by main().

{
        mudstate.now = time(NULL);
        mudstate.dump_counter =
                ((mudconf.dump_offset ==
                  0) ? mudconf.dump_interval : mudconf.dump_offset) + mudstate.now;
        mudstate.check_counter =
                ((mudconf.check_offset ==
                  0) ? mudconf.check_interval : mudconf.check_offset) + mudstate.now;
        mudstate.idle_counter = mudconf.idle_interval + mudstate.now;
        mudstate.mstats_counter = 15 + mudstate.now;
        mudstate.events_counter = 900 + mudstate.now;
        evtimer_set(&timer_event, timer_callback, NULL);
        evtimer_add(&timer_event, &tv);
}

void pcache_trim

(

void

)

Definition at line 97 of file player_c.c.

References player_cache::cflags, player_cache::next, pcache_head, pcache_save(), pcache_tree, PF_DEAD, PF_REF, player_cache::queue, and rb_delete().

Referenced by dispatch().

{
        PCACHE *pp, *pplast, *ppnext;
        return;

        pp = pcache_head;
        pplast = NULL;
        while (pp) {
                if(!(pp->cflags & PF_DEAD) && (pp->queue || (pp->cflags & PF_REF))) {
                        pp->cflags &= ~PF_REF;
                        pplast = pp;
                        pp = pp->next;
                } else {
                        ppnext = pp->next;
                        if(pplast)
                                pplast->next = ppnext;
                        else
                                pcache_head = ppnext;
                        if(!(pp->cflags & PF_DEAD)) {
                                pcache_save(pp);
                                rb_delete(pcache_tree, (void *)pp->player);
                        }
                        free(pp);
                        pp = ppnext;
                }
        }
}

void pool_reset

(

void

)

void timer_callback	(	int	fd,
		short	event,
		void *	arg
	)

Definition at line 237 of file timer.c.

References statedata::alarm_triggered, dispatch(), mudstate, timer_event, and tv.

Referenced by init_timer().

{
        mudstate.alarm_triggered = 1;
        evtimer_add(&timer_event, &tv);
        dispatch();
}

---

Variable Documentation

struct event timer_event [static]

Definition at line 30 of file timer.c.

Referenced by init_timer(), and timer_callback().

struct timeval tv = { 0, 100000 } [static]

Definition at line 29 of file timer.c.

Referenced by init_timer(), and timer_callback().

---