--- deliantra/server/lib/cf.pm	2007/01/02 23:12:47	1.126
+++ deliantra/server/lib/cf.pm	2007/01/04 16:19:32	1.133
@@ -10,7 +10,7 @@
 use Safe;
 use Safe::Hole;
 
-use Coro 3.3;
+use Coro 3.3 ();
 use Coro::Event;
 use Coro::Timer;
 use Coro::Signal;
@@ -51,7 +51,6 @@
 
 our %MAP; # all maps
 our $LINK_MAP; # the special {link} map
-our $FREEZE;
 our $RANDOM_MAPS = cf::localdir . "/random";
 our %EXT_CORO;
 
@@ -73,8 +72,7 @@
 
 # a special map that is always available
 our $LINK_MAP;
-
-our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
+our $EMERGENCY_POSITION;
 
 #############################################################################
 
@@ -216,8 +214,8 @@
 for example when the coroutine gets canceled), the lock is automatically
 returned.
 
-Lock names should begin with a unique identifier (for example, find_map
-uses map_find and load_map uses map_load).
+Lock names should begin with a unique identifier (for example, cf::map::find
+uses map_find and cf::map::load uses map_load).
 
 =cut
 
@@ -247,6 +245,30 @@
    }
 }
 
+=item cf::async { BLOCK }
+
+Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
+error instead of exiting the server in case of a problem.
+
+=cut
+
+sub async(&) {
+   my ($cb) = @_;
+
+   Coro::async {
+      eval { $cb->() };
+      warn $@ if $@;
+   }
+}
+
+sub freeze_mainloop {
+   return unless $TICK_WATCHER->is_active;
+
+   my $guard = guard { $TICK_WATCHER->start };
+   $TICK_WATCHER->stop;
+   $guard
+}
+
 =item cf::sync_job { BLOCK }
 
 The design of crossfire+ requires that the main coro ($Coro::main) is
@@ -269,7 +291,7 @@
       
       # TODO: use suspend/resume instead
       # (but this is cancel-safe)
-      local $FREEZE = 1;
+      my $freeze_guard = freeze_mainloop;
 
       my $busy = 1;
       my @res;
@@ -303,12 +325,7 @@
 sub coro(&) {
    my $cb = shift;
 
-   my $coro; $coro = async {
-      eval {
-         $cb->();
-      };
-      warn $@ if $@;
-   };
+   my $coro = &cf::async ($cb);
 
    $coro->on_destroy (sub {
       delete $EXT_CORO{$coro+0};
@@ -1128,8 +1145,8 @@
 use Fcntl;
 use Coro::AIO;
 
-our $MAX_RESET     = 7200;
-our $DEFAULT_RESET = 3600;
+our $MAX_RESET     = 3600;
+our $DEFAULT_RESET = 3000;
 
 sub generate_random_map {
    my ($path, $rmp) = @_;
@@ -1177,11 +1194,11 @@
    $map
 }
 
-sub find_map;
-sub find_map {
+sub find;
+sub find {
    my ($path, $origin) = @_;
 
-   #warn "find_map<$path,$origin>\n";#d#
+   #warn "find<$path,$origin>\n";#d#
 
    $path = new cf::path $path, $origin && $origin->path;
    my $key = $path->as_string;
@@ -1195,6 +1212,8 @@
       my $map = try_load_header $path->save_path;
 
       if ($map) {
+         $map->last_access ((delete $map->{last_access})
+                            || $cf::RUNTIME); #d#
          # safety
          $map->{instantiate_time} = $cf::RUNTIME
             if $map->{instantiate_time} > $cf::RUNTIME;
@@ -1209,6 +1228,7 @@
 
          $map->{load_original} = 1;
          $map->{instantiate_time} = $cf::RUNTIME;
+         $map->last_access ($cf::RUNTIME);
          $map->instantiate;
 
          # per-player maps become, after loading, normal maps
@@ -1218,12 +1238,11 @@
       $map->path ($key);
       $map->{path} = $path;
       $map->{last_save} = $cf::RUNTIME;
-      $map->last_access ($cf::RUNTIME);
 
       if ($map->should_reset) {
          $map->reset;
          undef $guard;
-         $map = find_map $path
+         $map = find $path
             or return;
       }
 
@@ -1275,17 +1294,16 @@
    $self->in_memory (cf::MAP_IN_MEMORY);
 }
 
-sub load_map_sync {
+sub find_sync {
    my ($path, $origin) = @_;
 
-   #warn "load_map_sync<$path, $origin>\n";#d#
+   cf::sync_job { cf::map::find $path, $origin }
+}
 
-   cf::sync_job {
-      my $map = cf::map::find_map $path, $origin
-         or return;
-      $map->load;
-      $map
-   }
+sub do_load_sync {
+   my ($map) = @_;
+
+   cf::sync_job { $map->load };
 }
 
 sub save {
@@ -1302,6 +1320,8 @@
 
    return if $self->{deny_save};
 
+   local $self->{last_access} = $self->last_access;#d#
+
    if ($uniq) {
       $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
       $self->save_objects ($uniq, cf::IO_UNIQUES);
@@ -1313,11 +1333,13 @@
 sub swap_out {
    my ($self) = @_;
 
+   # save first because save cedes
+   $self->save;
+
    return if $self->players;
    return if $self->in_memory != cf::MAP_IN_MEMORY;
    return if $self->{deny_save};
 
-   $self->save;
    $self->clear;
    $self->in_memory (cf::MAP_SWAPPED);
 }
@@ -1393,14 +1415,14 @@
    my ($map, $ob) = @_;
 
    if ($map->per_player) {
-      return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
+      return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
    }
 
    $map
 }
 
 sub emergency_save {
-   local $cf::FREEZE = 1;
+   my $freeze_guard = cf::freeze_mainloop;
 
    warn "enter emergency map save\n";
 
@@ -1500,11 +1522,11 @@
    unless ($map) {
       # restore original map position
       ($map, $x, $y) = @{ $link_pos || [] };
-      $map = cf::map::find_map $map;
+      $map = cf::map::find $map;
 
       unless ($map) {
          ($map, $x, $y) = @$EMERGENCY_POSITION;
-         $map = cf::map::find_map $map
+         $map = cf::map::find $map
             or die "FATAL: cannot load emergency map\n";
       }
    }
@@ -1540,7 +1562,7 @@
       # should happen only on crashes
       if ($pl->ob->{_link_pos}) {
          $pl->ob->enter_link;
-         Coro::async {
+         cf::async {
             # we need this sleep as the login has a concurrent enter_exit running
             # and this sleep increases chances of the player not ending up in scorn
             Coro::Timer::sleep 1;
@@ -1559,10 +1581,10 @@
 
    $self->enter_link;
 
-   (Coro::async {
+   (cf::async {
       $path = new cf::path $path;
 
-      my $map = cf::map::find_map $path->as_string;
+      my $map = cf::map::find $path->as_string;
       $map = $map->customise_for ($self) if $map;
 
 #      warn "entering ", $map->path, " at ($x, $y)\n"
@@ -1631,9 +1653,9 @@
 
    $self->enter_link;
 
-   (Coro::async {
+   (cf::async {
+      $self->deactivate_recursive; # just to be sure
       unless (eval {
-
          prepare_random_map $exit
             if $exit->slaying eq "/!";
 
@@ -1705,7 +1727,8 @@
 
       # this weird shuffling is so that direct followup queries
       # get handled first
-      my $queue = delete $ns->{query_queue};
+      my $queue = delete $ns->{query_queue}
+         or return; # be conservative, not sure how that can happen, but we saw a crash here
 
       (shift @$queue)->[1]->($msg);
 
@@ -1732,12 +1755,7 @@
 sub cf::client::coro {
    my ($self, $cb) = @_;
 
-   my $coro; $coro = async {
-      eval {
-         $cb->();
-      };
-      warn $@ if $@;
-   };
+   my $coro = &cf::async ($cb);
 
    $coro->on_destroy (sub {
       delete $self->{_coro}{$coro+0};
@@ -1982,6 +2000,16 @@
 
    local $/;
    *CFG = YAML::Syck::Load <$fh>;
+
+   $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
+
+   if (exists $CFG{mlockall}) {
+      eval {
+         $CFG{mlockall} ? &mlockall : &munlockall
+            and die "WARNING: m(un)lockall failed: $!\n";
+      };
+      warn $@ if $@;
+   }
 }
 
 sub main {
@@ -2011,7 +2039,7 @@
 
    warn "reloading...";
 
-   local $FREEZE = 1;
+   my $guard = freeze_mainloop;
    cf::emergency_save;
 
    eval {
@@ -2157,11 +2185,8 @@
    at        => $NEXT_TICK || $TICK,
    data      => WF_AUTOCANCEL,
    cb        => sub {
-      unless ($FREEZE) {
-         cf::server_tick; # one server iteration
-         $RUNTIME += $TICK;
-      }
-
+      cf::server_tick; # one server iteration
+      $RUNTIME   += $TICK;
       $NEXT_TICK += $TICK;
 
       # if we are delayed by four ticks or more, skip them all