[pve-manager.git] / bin / pvestatd

#!/usr/bin/perl -w

use strict;
use PVE::SafeSyslog;
use POSIX ":sys_wait_h";
use Fcntl ':flock';
use Getopt::Long;
use Time::HiRes qw (gettimeofday);
use PVE::Tools qw(dir_glob_foreach file_read_firstline);
use PVE::ProcFSTools;
use Filesys::Df;
use PVE::INotify;
use PVE::Cluster qw(cfs_read_file);
use PVE::Storage;
use PVE::QemuServer;
use PVE::OpenVZ;
use PVE::RPCEnvironment;
use PVE::API2::Subscription;

$SIG{'__WARN__'} = sub {
    my $err = $@;
    my $t = $_[0];
    chomp $t;
    syslog('warning', "WARNING: %s", $t);
    $@ = $err;
};

initlog('pvestatd');

$ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';

die "please run as root\n" if $> != 0;

my $nodename = PVE::INotify::nodename();

my $opt_debug;

if (!GetOptions ('debug' => \$opt_debug)) {
    die "USAGE: $0 [--debug]\n";
}

my $opt_pidfile = "/var/run/pvestatd.pid";

sub lockpidfile {
    my $pidfile = shift;
    my $lkfn = "$pidfile.lock";

    if (!open (FLCK, ">>$lkfn")) {
	my $msg = "can't aquire lock on file '$lkfn' - $!";
	syslog ('err', $msg);
	die "ERROR: $msg\n";
    }

    if (!flock (FLCK, LOCK_EX|LOCK_NB)) {
	close (FLCK);
        my $msg = "can't aquire lock '$lkfn' - $!";
	syslog ('err', $msg);
	die "ERROR: $msg\n";
    }
}

sub writepidfile {
    my $pidfile = shift;

    if (!open (PIDFH, ">$pidfile")) {
	my $msg = "can't open pid file '$pidfile' - $!";
	syslog ('err', $msg);
	die "ERROR: $msg\n";
    } 
    print PIDFH "$$\n";
    close (PIDFH);
}

# try to get the lock
lockpidfile($opt_pidfile);

# run in background
my $spid;

my $restart = $ENV{RESTART_PVESTATD};

if (!$opt_debug) {
    open STDIN,  '</dev/null' || die "can't read /dev/null";
    open STDOUT, '>/dev/null' || die "can't write /dev/null";
}

if (!$restart && !$opt_debug) {
    $spid = fork();
    if (!defined ($spid)) {
	my $msg =  "can't put server into background - fork failed";
	syslog('err', $msg);
	die "ERROR: $msg\n";
    } elsif ($spid) { #parent
	exit (0);
    }
}

writepidfile($opt_pidfile);

open STDERR, '>&STDOUT' || die "can't close STDERR\n";

sub cleanup {
    unlink "$opt_pidfile.lock";
    unlink "$opt_pidfile";
}
 
$SIG{INT} = $SIG{TERM} = $SIG{QUIT} = sub { 
    syslog('info' , "server closing");

    $SIG{INT} = 'DEFAULT';

    # wait for children
    1 while (waitpid(-1, POSIX::WNOHANG()) > 0);

    cleanup();

    exit (0);
};

PVE::INotify::inotify_init();

my $reload_config;

if ($restart) {
    syslog('info' , "restarting server");
} else {
    syslog('info' , "starting server");
}

$SIG{HUP} = sub { 
    $reload_config = 1;
};

sub update_node_status {

    my ($avg1, $avg5, $avg15) = PVE::ProcFSTools::read_loadavg();

    my $stat = PVE::ProcFSTools::read_proc_stat();

    my $netdev = PVE::ProcFSTools::read_proc_net_dev();

    my ($uptime) = PVE::ProcFSTools::read_proc_uptime();

    my $cpuinfo = PVE::ProcFSTools::read_cpuinfo();

    my $maxcpu = $cpuinfo->{cpus}; 

    my $subinfo = PVE::INotify::read_file('subscription');
    my $sublevel = $subinfo->{level} || '';

    # traffic from/to physical interface cards
    my $netin = 0;
    my $netout = 0;
    foreach my $dev (keys %$netdev) {
	next if $dev !~ m/^eth\d+$/;
	$netin += $netdev->{$dev}->{receive};
	$netout += $netdev->{$dev}->{transmit};
    }
 
    my $meminfo = PVE::ProcFSTools::read_meminfo();

    my $dinfo = df('/', 1);     # output is bytes

    my $ctime = time();

    # everything not free is considered to be used
    my $dused = $dinfo->{blocks} - $dinfo->{bfree};

    my $data = "$uptime:$sublevel:$ctime:$avg1:$maxcpu:$stat->{cpu}:$stat->{wait}:" .
	"$meminfo->{memtotal}:$meminfo->{memused}:" .
	"$meminfo->{swaptotal}:$meminfo->{swapused}:" .
	"$dinfo->{blocks}:$dused:$netin:$netout";

    PVE::Cluster::broadcast_rrd("pve2-node/$nodename", $data);
}

sub update_qemu_status {

    my $ctime = time();

    my $vmstatus = PVE::QemuServer::vmstatus(undef, 1);

    foreach my $vmid (keys %$vmstatus) {
	my $d = $vmstatus->{$vmid};
	my $data;
	if ($d->{pid}) { # running
	    $data = "$d->{uptime}:$d->{name}:$ctime:$d->{cpus}:$d->{cpu}:" .
		"$d->{maxmem}:$d->{mem}:" .
		"$d->{maxdisk}:$d->{disk}:" .
		"$d->{netin}:$d->{netout}:" .
		"$d->{diskread}:$d->{diskwrite}";
	} else {
	    $data = "0:$d->{name}:$ctime:$d->{cpus}::" .
		"$d->{maxmem}::" .
		"$d->{maxdisk}:$d->{disk}:" .
		":::";
	}
	PVE::Cluster::broadcast_rrd("pve2-vm/$vmid", $data);
    }
}

sub find_vzctl_console_pids {

    my $res = {};

    dir_glob_foreach('/proc', '\d+', sub {
	my ($pid) = @_;

	my $cmdline = file_read_firstline("/proc/$pid/cmdline");
	return if !$cmdline;

	my @args = split(/\0/, $cmdline);

	# serach for vzctl console <vmid>
	return if scalar(@args) != 3; 
	return if $args[1] ne 'console';
	return if $args[2] !~ m/^\d+$/;
	return if $args[0] !~ m|^(/usr/sbin/)?vzctl$|;
	
	my $vmid = $args[2];
	
	push @{$res->{$vmid}}, $pid;
    });

    return $res;
}
sub remove_stale_openvz_consoles {

    my $vmstatus = PVE::OpenVZ::vmstatus();
    my $pidhash = find_vzctl_console_pids();

    foreach my $vmid (keys %$pidhash) {
	next if defined($vmstatus->{$vmid});
	syslog('info', "remove stale vzctl console for CT $vmid");
	foreach my $pid (@{$pidhash->{$vmid}}) {
	    kill(9, $pid);
	}
    }
}

sub update_openvz_status {

    my $ctime = time();

    my $vmstatus = PVE::OpenVZ::vmstatus();

    foreach my $vmid (keys %$vmstatus) {
	my $d = $vmstatus->{$vmid};
	my $data;
	if ($d->{status} eq 'running') { # running
	    $data = "$d->{uptime}:$d->{name}:$ctime:$d->{cpus}:$d->{cpu}:" .
		"$d->{maxmem}:$d->{mem}:" .
		"$d->{maxdisk}:$d->{disk}:" .
		"$d->{netin}:$d->{netout}:" .
		"$d->{diskread}:$d->{diskwrite}";
	} else {
	    $data = "0:$d->{name}:$ctime:$d->{cpus}::" .
		"$d->{maxmem}::" .
		"$d->{maxdisk}:$d->{disk}:" .
		":::";
	}
	PVE::Cluster::broadcast_rrd("pve2-vm/$vmid", $data);
    }
}

sub update_storage_status {

    my $cfg = cfs_read_file("storage.cfg");

    my $ctime = time();

    my $info = PVE::Storage::storage_info($cfg);

    foreach my $storeid (keys %$info) {
	my $d = $info->{$storeid};
	next if !$d->{active};

	# everything not free is considered to be used
	my $realused = $d->{total} - $d->{avail};

	my $data = "$ctime:$d->{total}:$realused";

	my $key = "pve2-storage/${nodename}/$storeid";
	PVE::Cluster::broadcast_rrd($key, $data);
    }
}

sub update_status {

    # update worker list. This is not really required and
    # we just call this to make sure that we have a correct
    # list in case of an unexpected crash.
    eval {
	my $tlist = PVE::RPCEnvironment::active_workers();
	PVE::Cluster::broadcast_tasklist($tlist);
    };
    my $err = $@;
    syslog('err', $err) if $err;

    eval {
	update_node_status();
    };
    $err = $@;
    syslog('err', "node status update error: $err") if $err;

    eval {
	update_qemu_status();
    };
    $err = $@;
    syslog('err', "qemu status update error: $err") if $err;

    eval {
	update_openvz_status();
    };
    $err = $@;
    syslog('err', "openvz status update error: $err") if $err;

    eval {
	update_storage_status();
    };
    $err = $@;
    syslog('err', "storage status update error: $err") if $err;

    eval {
	remove_stale_openvz_consoles();
    };
    $err = $@;
    syslog('err', "openvz console cleanup error: $err") if $err;
}

my $next_update = 0;

# do not update directly after startup, because install scripts
# have a problem with that
my $cycle = 0; 
my $updatetime = 10;

my $commandline = [$0, @ARGV];

$0 = "pvestatd";

sub restart_server {
    my $waittime = shift;

    syslog('info', "server shutdown (restart)");

    $ENV{RESTART_PVESTATD} = 1;

    sleep($waittime) if $waittime; # avoid high server load due to restarts

    exec (@$commandline);
    exit (-1); # never reached?
}

my $initial_memory_usage;

for (;;) { # forever

    eval {
	$next_update = time() + $updatetime;

	if ($cycle) {
	    my ($ccsec, $cusec) = gettimeofday ();
	    eval {
		$reload_config = 0;
		# syslog('info', "start status update");
		PVE::Cluster::cfs_update();
		update_status();
	    };
	    my $err = $@;

	    if ($err) {
		syslog('err', "status update error: $err");
	    }

	    my ($ccsec_end, $cusec_end) = gettimeofday ();
	    my $cptime = ($ccsec_end-$ccsec) + ($cusec_end - $cusec)/1000000;

	    syslog('info', sprintf("status update time (%.3f seconds)", $cptime))
		if ($cptime > 5);
	}

	$cycle++;

	my $mem = PVE::ProcFSTools::read_memory_usage();

	if (!defined($initial_memory_usage) || ($cycle < 10)) {
	    $initial_memory_usage = $mem->{resident};
	} else {
	    my $diff = $mem->{resident} - $initial_memory_usage;
	    if ($diff > 5*1024*1024) {
		syslog ('info', "restarting server after $cycle cycles to " .
			"reduce memory usage (free $mem->{resident} ($diff) bytes)");
		restart_server ();
	    }
	}

	my $wcount = 0;
	while ((time() < $next_update) && 
	       ($wcount < $updatetime) && # protect against time wrap
	       !$reload_config) { $wcount++; sleep (1); };
    };

    my $err = $@;
    
    if ($err) {
	syslog ('err', "ERROR: $err");
	restart_server(5);
	exit (0);
    }
}

exit (0);

__END__

=head1 NAME
                                          
pvestatd - PVE Status Daemon

=head1 SYNOPSIS

pvestatd

=head1 DESCRIPTION

Documentation is available at www.proxmox.com
Commit	Line	Data
aff192e6 DM	1	#!/usr/bin/perl -w
	2
	3	use strict;
	4	use PVE::SafeSyslog;
	5	use POSIX ":sys_wait_h";
	6	use Fcntl ':flock';
	7	use Getopt::Long;
	8	use Time::HiRes qw (gettimeofday);
f9d4fc64	9	use PVE::Tools qw(dir_glob_foreach file_read_firstline);
aff192e6 DM	10	use PVE::ProcFSTools;
	11	use Filesys::Df;
	12	use PVE::INotify;
	13	use PVE::Cluster qw(cfs_read_file);
	14	use PVE::Storage;
	15	use PVE::QemuServer;
b3409356	16	use PVE::OpenVZ;
aff192e6	17	use PVE::RPCEnvironment;
16b69b6c	18	use PVE::API2::Subscription;
aff192e6 DM	19
	20	$SIG{'__WARN__'} = sub {
	21	my $err = $@;
	22	my $t = $_[0];
	23	chomp $t;
	24	syslog('warning', "WARNING: %s", $t);
	25	$@ = $err;
	26	};
	27
	28	initlog('pvestatd');
	29
	30	$ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
	31
	32	die "please run as root\n" if $> != 0;
	33
	34	my $nodename = PVE::INotify::nodename();
	35
	36	my $opt_debug;
	37
	38	if (!GetOptions ('debug' => \$opt_debug)) {
	39	die "USAGE: $0 [--debug]\n";
	40	}
	41
	42	my $opt_pidfile = "/var/run/pvestatd.pid";
	43
	44	sub lockpidfile {
	45	my $pidfile = shift;
	46	my $lkfn = "$pidfile.lock";
	47
	48	if (!open (FLCK, ">>$lkfn")) {
	49	my $msg = "can't aquire lock on file '$lkfn' - $!";
	50	syslog ('err', $msg);
	51	die "ERROR: $msg\n";
	52	}
	53
	54	if (!flock (FLCK, LOCK_EX\|LOCK_NB)) {
	55	close (FLCK);
	56	my $msg = "can't aquire lock '$lkfn' - $!";
	57	syslog ('err', $msg);
	58	die "ERROR: $msg\n";
	59	}
	60	}
	61
	62	sub writepidfile {
	63	my $pidfile = shift;
	64
	65	if (!open (PIDFH, ">$pidfile")) {
	66	my $msg = "can't open pid file '$pidfile' - $!";
	67	syslog ('err', $msg);
	68	die "ERROR: $msg\n";
	69	}
	70	print PIDFH "$$\n";
	71	close (PIDFH);
	72	}
	73
	74	# try to get the lock
	75	lockpidfile($opt_pidfile);
	76
	77	# run in background
	78	my $spid;
	79
	80	my $restart = $ENV{RESTART_PVESTATD};
	81
	82	if (!$opt_debug) {
83	open STDIN, '</dev/null' \|\| die "can't read /dev/null";
84	open STDOUT, '>/dev/null' \|\| die "can't write /dev/null";
85	}
86
87	if (!$restart && !$opt_debug) {
88	$spid = fork();
89	if (!defined ($spid)) {
90	my $msg = "can't put server into background - fork failed";
91	syslog('err', $msg);
92	die "ERROR: $msg\n";
93	} elsif ($spid) { #parent
94	exit (0);
95	}
96	}
97
98	writepidfile($opt_pidfile);
99
100	open STDERR, '>&STDOUT' \|\| die "can't close STDERR\n";
101
102	sub cleanup {
103	unlink "$opt_pidfile.lock";
104	unlink "$opt_pidfile";
105	}
106
107	$SIG{INT} = $SIG{TERM} = $SIG{QUIT} = sub {
108	syslog('info' , "server closing");
109
110	$SIG{INT} = 'DEFAULT';
111
112	# wait for children
113	1 while (waitpid(-1, POSIX::WNOHANG()) > 0);
114
115	cleanup();
116
117	exit (0);
118	};
119
120	PVE::INotify::inotify_init();
121
122	my $reload_config;
123
124	if ($restart) {
125	syslog('info' , "restarting server");
126	} else {
127	syslog('info' , "starting server");
128	}
129
130	$SIG{HUP} = sub {
131	$reload_config = 1;
132	};
133
134	sub update_node_status {
135
136	my ($avg1, $avg5, $avg15) = PVE::ProcFSTools::read_loadavg();
137
138	my $stat = PVE::ProcFSTools::read_proc_stat();
139
140	my $netdev = PVE::ProcFSTools::read_proc_net_dev();
141
142	my ($uptime) = PVE::ProcFSTools::read_proc_uptime();
143
144	my $cpuinfo = PVE::ProcFSTools::read_cpuinfo();
145
146	my $maxcpu = $cpuinfo->{cpus};
147
16b69b6c DM	148	my $subinfo = PVE::INotify::read_file('subscription');
	149	my $sublevel = $subinfo->{level} \|\| '';
	150
aff192e6 DM	151	# traffic from/to physical interface cards
	152	my $netin = 0;
	153	my $netout = 0;
	154	foreach my $dev (keys %$netdev) {
	155	next if $dev !~ m/^eth\d+$/;
	156	$netin += $netdev->{$dev}->{receive};
	157	$netout += $netdev->{$dev}->{transmit};
	158	}
	159
	160	my $meminfo = PVE::ProcFSTools::read_meminfo();
	161
	162	my $dinfo = df('/', 1); # output is bytes
	163
	164	my $ctime = time();
	165
	166	# everything not free is considered to be used
	167	my $dused = $dinfo->{blocks} - $dinfo->{bfree};
	168
16b69b6c	169	my $data = "$uptime:$sublevel:$ctime:$avg1:$maxcpu:$stat->{cpu}:$stat->{wait}:" .
aff192e6 DM	170	"$meminfo->{memtotal}:$meminfo->{memused}:" .
	171	"$meminfo->{swaptotal}:$meminfo->{swapused}:" .
	172	"$dinfo->{blocks}:$dused:$netin:$netout";
	173
	174	PVE::Cluster::broadcast_rrd("pve2-node/$nodename", $data);
	175	}
	176
	177	sub update_qemu_status {
	178
	179	my $ctime = time();
	180
cbb20c6e	181	my $vmstatus = PVE::QemuServer::vmstatus(undef, 1);
aff192e6 DM	182
	183	foreach my $vmid (keys %$vmstatus) {
	184	my $d = $vmstatus->{$vmid};
	185	my $data;
	186	if ($d->{pid}) { # running
	187	$data = "$d->{uptime}:$d->{name}:$ctime:$d->{cpus}:$d->{cpu}:" .
	188	"$d->{maxmem}:$d->{mem}:" .
	189	"$d->{maxdisk}:$d->{disk}:" .
	190	"$d->{netin}:$d->{netout}:" .
	191	"$d->{diskread}:$d->{diskwrite}";
	192	} else {
	193	$data = "0:$d->{name}:$ctime:$d->{cpus}::" .
	194	"$d->{maxmem}::" .
	195	"$d->{maxdisk}:$d->{disk}:" .
	196	":::";
	197	}
	198	PVE::Cluster::broadcast_rrd("pve2-vm/$vmid", $data);
	199	}
	200	}
	201
f9d4fc64 DM	202	sub find_vzctl_console_pids {
	203
	204	my $res = {};
	205
	206	dir_glob_foreach('/proc', '\d+', sub {
	207	my ($pid) = @_;
	208
	209	my $cmdline = file_read_firstline("/proc/$pid/cmdline");
	210	return if !$cmdline;
	211
	212	my @args = split(/\0/, $cmdline);
	213
	214	# serach for vzctl console <vmid>
	215	return if scalar(@args) != 3;
	216	return if $args[1] ne 'console';
	217	return if $args[2] !~ m/^\d+$/;
	218	return if $args[0] !~ m\|^(/usr/sbin/)?vzctl$\|;
	219
	220	my $vmid = $args[2];
	221
	222	push @{$res->{$vmid}}, $pid;
	223	});
	224
	225	return $res;
	226	}
	227	sub remove_stale_openvz_consoles {
	228
	229	my $vmstatus = PVE::OpenVZ::vmstatus();
	230	my $pidhash = find_vzctl_console_pids();
	231
	232	foreach my $vmid (keys %$pidhash) {
	233	next if defined($vmstatus->{$vmid});
	234	syslog('info', "remove stale vzctl console for CT $vmid");
	235	foreach my $pid (@{$pidhash->{$vmid}}) {
	236	kill(9, $pid);
	237	}
	238	}
	239	}
	240
b3409356 DM	241	sub update_openvz_status {
	242
	243	my $ctime = time();
	244
	245	my $vmstatus = PVE::OpenVZ::vmstatus();
	246
	247	foreach my $vmid (keys %$vmstatus) {
	248	my $d = $vmstatus->{$vmid};
	249	my $data;
	250	if ($d->{status} eq 'running') { # running
	251	$data = "$d->{uptime}:$d->{name}:$ctime:$d->{cpus}:$d->{cpu}:" .
	252	"$d->{maxmem}:$d->{mem}:" .
	253	"$d->{maxdisk}:$d->{disk}:" .
	254	"$d->{netin}:$d->{netout}:" .
	255	"$d->{diskread}:$d->{diskwrite}";
	256	} else {
	257	$data = "0:$d->{name}:$ctime:$d->{cpus}::" .
	258	"$d->{maxmem}::" .
	259	"$d->{maxdisk}:$d->{disk}:" .
	260	":::";
	261	}
	262	PVE::Cluster::broadcast_rrd("pve2-vm/$vmid", $data);
	263	}
	264	}
	265
aff192e6 DM	266	sub update_storage_status {
	267
	268	my $cfg = cfs_read_file("storage.cfg");
	269
	270	my $ctime = time();
	271
	272	my $info = PVE::Storage::storage_info($cfg);
	273
	274	foreach my $storeid (keys %$info) {
	275	my $d = $info->{$storeid};
	276	next if !$d->{active};
	277
	278	# everything not free is considered to be used
	279	my $realused = $d->{total} - $d->{avail};
	280
	281	my $data = "$ctime:$d->{total}:$realused";
	282
	283	my $key = "pve2-storage/${nodename}/$storeid";
	284	PVE::Cluster::broadcast_rrd($key, $data);
	285	}
	286	}
	287
	288	sub update_status {
	289
	290	# update worker list. This is not really required and
	291	# we just call this to make sure that we have a correct
	292	# list in case of an unexpected crash.
	293	eval {
	294	my $tlist = PVE::RPCEnvironment::active_workers();
	295	PVE::Cluster::broadcast_tasklist($tlist);
	296	};
	297	my $err = $@;
	298	syslog('err', $err) if $err;
	299
	300	eval {
	301	update_node_status();
	302	};
	303	$err = $@;
	304	syslog('err', "node status update error: $err") if $err;
	305
	306	eval {
	307	update_qemu_status();
	308	};
	309	$err = $@;
	310	syslog('err', "qemu status update error: $err") if $err;
	311
b3409356 DM	312	eval {
	313	update_openvz_status();
	314	};
	315	$err = $@;
	316	syslog('err', "openvz status update error: $err") if $err;
	317
aff192e6 DM	318	eval {
	319	update_storage_status();
	320	};
	321	$err = $@;
	322	syslog('err', "storage status update error: $err") if $err;
f9d4fc64 DM	323
	324	eval {
	325	remove_stale_openvz_consoles();
	326	};
	327	$err = $@;
	328	syslog('err', "openvz console cleanup error: $err") if $err;
aff192e6 DM	329	}
	330
	331	my $next_update = 0;
	332
	333	# do not update directly after startup, because install scripts
	334	# have a problem with that
	335	my $cycle = 0;
	336	my $updatetime = 10;
	337
	338	my $commandline = [$0, @ARGV];
	339
	340	$0 = "pvestatd";
	341
	342	sub restart_server {
	343	my $waittime = shift;
	344
	345	syslog('info', "server shutdown (restart)");
	346
	347	$ENV{RESTART_PVESTATD} = 1;
	348
	349	sleep($waittime) if $waittime; # avoid high server load due to restarts
	350
	351	exec (@$commandline);
	352	exit (-1); # never reached?
	353	}
	354
350b3b46 DM	355	my $initial_memory_usage;
350b3b46 DM	356
aff192e6 DM	357	for (;;) { # forever
	358
	359	eval {
	360	$next_update = time() + $updatetime;
	361
	362	if ($cycle) {
	363	my ($ccsec, $cusec) = gettimeofday ();
	364	eval {
	365	$reload_config = 0;
9b0aba10	366	# syslog('info', "start status update");
aff192e6 DM	367	PVE::Cluster::cfs_update();
	368	update_status();
	369	};
	370	my $err = $@;
	371
	372	if ($err) {
	373	syslog('err', "status update error: $err");
	374	}
	375
	376	my ($ccsec_end, $cusec_end) = gettimeofday ();
	377	my $cptime = ($ccsec_end-$ccsec) + ($cusec_end - $cusec)/1000000;
	378
9b0aba10 DM	379	syslog('info', sprintf("status update time (%.3f seconds)", $cptime))
9b0aba10 DM	380	if ($cptime > 5);
aff192e6 DM	381	}
	382
	383	$cycle++;
	384
	385	my $mem = PVE::ProcFSTools::read_memory_usage();
	386
9dbdda49	387	if (!defined($initial_memory_usage) \|\| ($cycle < 10)) {
350b3b46 DM	388	$initial_memory_usage = $mem->{resident};
	389	} else {
	390	my $diff = $mem->{resident} - $initial_memory_usage;
	391	if ($diff > 510241024) {
	392	syslog ('info', "restarting server after $cycle cycles to " .
	393	"reduce memory usage (free $mem->{resident} ($diff) bytes)");
	394	restart_server ();
	395	}
aff192e6 DM	396	}
	397
	398	my $wcount = 0;
	399	while ((time() < $next_update) &&
	400	($wcount < $updatetime) && # protect against time wrap
	401	!$reload_config) { $wcount++; sleep (1); };
	402	};
	403
	404	my $err = $@;
	405
	406	if ($err) {
	407	syslog ('err', "ERROR: $err");
	408	restart_server(5);
	409	exit (0);
	410	}
	411	}
	412
	413	exit (0);
	414
	415	__END__
	416
	417	=head1 NAME
	418
	419	pvestatd - PVE Status Daemon
	420
	421	=head1 SYNOPSIS
	422
	423	pvestatd
	424
	425	=head1 DESCRIPTION
	426
	427	Documentation is available at www.proxmox.com
	428
	429
	430
	431
	432