AFS-Monitor
view release on metacpan or search on metacpan
LICENSES/COPYING view on Meta::CPAN
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Unpack the archive to create an AFS-Monitor installation directory:
tar zxvf AFS-Monitor-0.3.3.tar.gz
'cd' into that directory, make, test and install the modules. You
have to specify the location of the AFS system libraries. While
running the 'perl Makefile.PL' step you will be prompted for the
location of the AFS system libraries. If you want to avoid that
query, you should specify the environment variable 'AFSPATH'
before you start[1]. If your AFS system type is not yet known by
the make file, please follow the printed message.
This is the sequence of commands to build the modules:
cd AFS-Monitor-0.3.2
[1] this step is optional
setenv AFSPATH 'path_to_the_AFS_system_libraries' # tcsh-shell
export AFSPATH='path_to_the_AFS_system_libraries' # sh-shell
perl Makefile.PL
examples/Meltdown.pl view on Meta::CPAN
# Meltdown.pl -s point -p 7000 -t 300
#
# Check the server 'point' on port '7000' with 5 minutes between
# rxdebug commands.
#
use blib;
use AFS::Monitor;
sub Usage {
print STDERR "\n\n$progName: collect rxdebug stats on AFS process.\n";
print STDERR "usage: $progName [options]\n";
print STDERR "options:\n";
print STDERR " -s <server> (required parameter, no default).\n";
print STDERR " -p <port> (default: 7000).\n";
print STDERR " -t <interval> (default: 1200 seconds).\n";
print STDERR " -C \n";
print STDERR " -h (help: show this help message).\n\n";
print STDERR "Example: $progName -s point -p 7000\n";
print STDERR "Collect statistics on server point for port 7000\n";
print STDERR "Refresh interval will default to 20 minutes (1200 seconds)\n\n";
exit 0;
} # Usage
sub Check_data {
#
# If a value is going to overflow the field length,
# then bump the field length to match the value.
# It won't be pretty but we'll have valid data.
#
(length $wproc > $Ln[0]) ? ($Ln[0] = length $wproc) : "";
examples/Meltdown.pl view on Meta::CPAN
(length $fpack > $Ln[3]) ? ($Ln[3] = length $fpack) : "";
(length $calls > $Ln[4]) ? ($Ln[4] = length $calls) : "";
(length $delta > $Ln[5]) ? ($Ln[5] = length $delta) : "";
(length $data > $Ln[6]) ? ($Ln[6] = length $data) : "";
(length $resend > $Ln[7]) ? ($Ln[7] = length $resend) : "";
(length $idle > $Ln[8]) ? ($Ln[8] = length $idle) : "";
} # Check_data
sub Header {
if ($csvmode != 1) {
print "\nhh:mm:ss wproc nobufs wpack fpack calls delta data resends idle\n";
} else { # assume CSV mode...
print "\nhh:mm:ss,wproc,nobufs,wpack,fpack,calls,delta,data,resends,idle\n";
}
} # Header
#
# don't buffer the output
#
$| = 1;
#
# snag program name (drop the full pathname) :
examples/Meltdown.pl view on Meta::CPAN
}
}
#
# if they didn't give us a server name, we can't run
#
if ($server eq "") {
&Usage();
}
else {
print "\nServer: $server, Port: $port, Interval $delay seconds\n";
system date;
}
#
# clear the counters for the first run
#
$wproc = 0;
$wpack = 0;
$fpack = 0;
$calls = 0;
examples/Meltdown.pl view on Meta::CPAN
#
# verify and fix field format lengths
#
Check_data;
if ($csvmode != 1) {
#
# output the timestamp and current results
#
printf "%2.2d:%2.2d:%2.2d ", $hour,$min,$sec;
printf "%-$Ln[0].0f %-$Ln[1].0f %-$Ln[2].0f %-$Ln[3].0f ",
$wproc,$nobuf,$wpack,$fpack;
printf "%-$Ln[4].0f %-$Ln[5].0f %-$Ln[6].0f %-$Ln[7].0f %-$Ln[8].0f\n",
$calls,$delta,$data,$resend,$idle;
} else { # must be csv mode then...
printf "%2.2d:%2.2d:%2.2d,", $hour,$min,$sec;
printf "$wproc,$nobuf,$wpack,$fpack";
printf "$calls,$delta,$data,$resend,$idle\n";
}
#
# delay for the required interval
#
sleep($delay);
}
exit();
examples/afsmonitor view on Meta::CPAN
$tests[7] = 0; # test of no flags
$tests[8] = 0; # test of cmhosts and fshosts and config flags all at once
$tests[9] = 0; # test of cmhosts and fshosts
$tests[10] = 0; # test of config file
$tests[11] = 0; # test of invalid config file
$tests[12] = 0; # test of config file with output file
$tests[13] = 0; # test of show and threshold parameters
my $all = 1; # show all tests
my $showdump = 0; # print entire contents of hash for each test
my $readable = 1; # print readable formatted output (and execute
# threshold handler functions if they exist)
my $shortoutput = 0; # print shorter, harder to read output (don't
# execute handlers)
# available options:
#
# afsmonitor(
# cmhosts => \@cmhosts,
# fshosts => \@fshosts,
# config => $configfilename,
# detailed => 1,
# output => $outputfilename,
# );
#
# You must give cmhosts and/or fshosts, or a config file which specifies
# the cm and fs hosts.
print "# Starting now... #\n";
my ($fsinfo, $cminfo);
if ($all || $tests[1]) {
print "\n******** TEST 1a: ********\n";
print "\nafsmonitor -fshosts ", $fshosts[0], "\n\n";
($fsinfo, $cminfo) = afsmonitor(fshosts => $fshosts[0]);
parse_results($fsinfo, $cminfo);
print "\n******** TEST 1b: ********\n";
print "\nafsmonitor -fshosts ", join(" ", @fshosts),
" -output $outputfilename -detailed\n\n";
($fsinfo, $cminfo) = afsmonitor(detailed => 1,
fshosts => \@fshosts,
output => $outputfilename
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[2]) {
print "\n******** TEST 2a: ********\n";
print "\nafsmonitor -cmhosts ", $cmhosts[0], "\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => $cmhosts[0]);
parse_results($fsinfo, $cminfo);
print "\n******** TEST 2b: ********\n";
print "\nafsmonitor -cmhosts ", join(" ", @cmhosts), "\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => \@cmhosts);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\nafsmonitor -cmhosts ", join(" ", @cmhosts), " -output /\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => \@cmhosts,
output => '/'
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[4]) {
print "\n******** TEST 4: ********\n";
print "\nafsmonitor -cmhosts ", join(" ", @cmhosts), " -detailed\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => \@cmhosts,
detailed => 1
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[5]) {
print "\n******** TEST 5: ********\n";
print "\nafsmonitor -fshosts \"something that won't work\"\n\n";
($fsinfo, $cminfo) = afsmonitor(fshosts => [ "something that won't work" ]);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[6]) {
print "\n******** TEST 6: ********\n";
print "\nafsmonitor -cmhosts notreal fake\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => [ 'notreal', 'fake' ]);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[7]) {
print "\n******** TEST 7: ********\n";
print "\nafsmonitor\n\n";
($fsinfo, $cminfo) = afsmonitor();
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[8]) {
print "\n******** TEST 8: ********\n";
print "\nafsmonitor -cmhosts ", join(" ", @cmhosts),
" -fshosts ", join(" ", @fshosts),
" -config $configfilename\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => \@cmhosts,
fshosts => \@fshosts,
config => $configfilename
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[9]) {
print "\n******** TEST 9: ********\n";
print "\nafsmonitor -cmhosts ", join(" ", @cmhosts),
" -fshosts ", join(" ", @fshosts), "\n\n";
($fsinfo, $cminfo) = afsmonitor(cmhosts => \@cmhosts,
fshosts => \@fshosts
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[10]) {
print "\n******** TEST 10: ********\n";
print "\nafsmonitor -config $configfilename\n\n";
($fsinfo, $cminfo) = afsmonitor(config => $configfilename);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[11]) {
print "\n******** TEST 11: ********\n";
print "\nafsmonitor -config $badconfigfile\n\n";
($fsinfo, $cminfo) = afsmonitor(config => $badconfigfile);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[12]) {
print "\n******** TEST 12: ********\n";
print "\nafsmonitor -config $configfilename -output $outputfilename\n\n";
($fsinfo, $cminfo) = afsmonitor(config => $configfilename,
output => $outputfilename
);
parse_results($fsinfo, $cminfo);
}
if ($all || $tests[13]) {
print "\n******** TEST 13: ********\n";
($fsinfo, $cminfo) =
afsmonitor(
cmhosts => \@cmhosts,
fshosts => \@fshosts,
# show statments
cmshow => ["PerfStats_section", "fs_oc_downDst_more_50"],
fsshow => ["VnodeCache_group", "FetchData_sqr"],
# thresholds
fsthresh => [
examples/afsmonitor view on Meta::CPAN
],
);
parse_results($fsinfo, $cminfo);
}
sub parse_results {
if ($AFS::CODE) {
print "Error case: ", ref($fsinfo), "\n" if (defined($fsinfo));
print "Error case: ", ref($cminfo), "\n" if (defined($cminfo));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Maxdepth = 2;
local $Data::Dumper::Varname = "File Servers ";
print Dumper($fsinfo);
local $Data::Dumper::Varname = "Cache Managers ";
print Dumper($cminfo);
}
if ($readable) {
print "\nFile Servers:\n";
foreach my $host (@$fsinfo) {
print "\nFS HOSTNAME: $host->{hostName}\n";
if ($host->{probeOK}) {
print " probe successful\n";
foreach my $section (sort keys %$host) {
if (ref $host->{$section}) {
print "\n $section:\n";
foreach my $group (sort keys %{$host->{$section}}) {
print "\n $group\n";
foreach my $item (sort keys %{$host->{$section}->{$group}}) {
print " $item";
for (my $i = 0; $i <= 30 - length($item); $i++) {
print " ";
}
print "$host->{$section}->{$group}->{$item}->{value}";
if ($host->{$section}->{$group}->{$item}->{overflow}) {
print " (overflow)\n";
print " threshold: $host->{$section}->{$group}->{$item}->{threshold}\n";
if ($host->{$section}->{$group}->{$item}->{overflow} ne 1) {
print "\n";
system($host->{$section}->{$group}->{$item}->{overflow});
}
}
print "\n";
}
}
}
}
}
else {
print "\n probe failed";
}
print "\n";
}
print "\nCache Managers:\n";
foreach my $host (@$cminfo) {
print "\nCM HOSTNAME: $host->{hostName}\n";
if ($host->{probeOK}) {
print " probe successful\n";
foreach my $section (sort keys %$host) {
if (ref $host->{$section}) {
print "\n $section:\n";
foreach my $group (sort keys %{$host->{$section}}) {
print "\n $group\n";
foreach my $item (sort keys %{$host->{$section}->{$group}}) {
print " $item";
for (my $i = 0; $i <= 30 - length($item); $i++) {
print " ";
}
print "$host->{$section}->{$group}->{$item}->{value}";
if ($host->{$section}->{$group}->{$item}->{overflow}) {
print " (overflow)\n";
print " threshold: $host->{$section}->{$group}->{$item}->{threshold}\n";
if ($host->{$section}->{$group}->{$item}->{overflow} ne 1) {
print "\n";
system($host->{$section}->{$group}->{$item}->{overflow});
}
}
print "\n";
}
}
}
}
}
else {
print "\n probe failed";
}
print "\n";
}
}
if ($shortoutput) {
print "\nFile Servers:\n";
foreach my $host (@$fsinfo) {
print "\nHOST: $host->{hostName}";
if ($host->{probeOK}) {
foreach my $section (sort keys %$host) {
if (ref $host->{$section}) {
print "\n******* $section *******";
foreach my $group (sort keys %{$host->{$section}}) {
print "\n [[$group]] ";
foreach my $item (sort keys %{$host->{$section}->{$group}}) {
print "$item $host->{$section}->{$group}->{$item}->{value}";
if ($host->{$section}->{$group}->{$item}->{overflow}) {
print " (";
print "thresh: $host->{$section}->{$group}->{$item}->{threshold}";
if ($host->{$section}->{$group}->{$item}->{overflow} ne 1) {
print ", handler";
}
print ")";
}
print " | ";
}
}
}
}
}
else {
print "probe failed\n";
}
print "\n";
}
print "\nCache Managers:\n";
foreach my $host (@$cminfo) {
print "\nHOST: $host->{hostName}";
if ($host->{probeOK}) {
foreach my $section (sort keys %$host) {
if (ref $host->{$section}) {
print "\n******* $section *******";
foreach my $group (sort keys %{$host->{$section}}) {
print "\n [[$group]] ";
foreach my $item (sort keys %{$host->{$section}->{$group}}) {
print "$item $host->{$section}->{$group}->{$item}->{value}";
if ($host->{$section}->{$group}->{$item}->{overflow}) {
print " (";
print "thresh: $host->{$section}->{$group}->{$item}->{threshold}";
if ($host->{$section}->{$group}->{$item}->{overflow} ne 1) {
print ", handler";
}
print ")";
}
print " | ";
}
}
}
}
}
else {
print "probe failed\n";
}
print "\n";
}
}
}
print "\n# ...Done #\n";
examples/cmdebug view on Meta::CPAN
my @tests; # choose which tests to run
$tests[1] = 1; # test of server $server, port $port, long output
$tests[2] = 0; # test of server $server, no port
$tests[3] = 0; # test of nonexistant server
$tests[4] = 0; # test of server $server, bad port
$tests[5] = 0; # test of server $server, port $port
my $all = 0;
my $showdump = 1; # print entire contents of hash for each test
my $formatted = 1; # print output formatted like the c cmdebug program
print "# Starting now... #\n";
my $locks;
my $cache_entries;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\ncmdebug -server $server -port $port -long\n\n";
($locks, $cache_entries) = cmdebug(server => $server,
port => $port,
long => 1
);
parse_result($locks, $cache_entries);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\ncmdebug -server $server\n\n";
($locks, $cache_entries) = cmdebug(server => $server);
parse_result($locks, $cache_entries);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\ncmdebug -server nonexistant\n\n";
($locks, $cache_entries) = cmdebug(server => "nonexistant");
parse_result($locks, $cache_entries);
}
if ($all || $tests[4]) {
print "\n******** TEST 4: ********\n";
print "\ncmdebug -server $server -port 7001\n\n";
($locks, $cache_entries) = cmdebug(server => $server,
port => 7001
);
parse_result($locks, $cache_entries);
}
if ($all || $tests[5]) {
print "\n******** TEST 5: ********\n";
print "\ncmdebug -server $server -port $port\n\n";
($locks, $cache_entries) = cmdebug(server => $server,
port => $port
);
parse_result($locks, $cache_entries);
}
sub parse_result {
my $l = shift;
my $c = shift;
if ($AFS::CODE) {
print "Error case: ", ref($l), "\n" if (defined($l));
print "Error case: ", ref($c), "\n" if (defined($c));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Varname = "Locks";
local $Data::Dumper::Maxdepth = 3;
local $Data::Dumper::Indent = 1;
print Dumper($l);
local $Data::Dumper::Maxdepth = 1;
local $Data::Dumper::Indent = 0;
local $Data::Dumper::Varname = "Cache Entries";
print Dumper($c);
}
if ($formatted) {
foreach my $lock (@$l) {
printf("Lock %s status: ", $lock->{name});
print_lock($lock->{lock});
print "\n";
}
foreach my $centry (@$c) {
if($centry->{addr} == 0) {
printf("Proc %4d sleeping at %08x, pri %3d\n",
$centry->{netFid}->{Vnode},
$centry->{netFid}->{Volume},
$centry->{netFid}->{Unique} - 25);
next;
}
printf("** Cache entry @ 0x%08x for %d.%d.%d.%d",
$centry->{addr},
$centry->{cell}, $centry->{netFid}->{Volume},
$centry->{netFid}->{Vnode},
$centry->{netFid}->{Unique});
if ((exists $centry->{cellname}) && ($centry->{cellname})) {
printf " [%s]\n", $centry->{cellname};
}
else {
print "\n";
}
if (exists $centry->{lock}) {
print " locks: ";
print_lock($centry->{lock});
print "\n";
}
printf(" %d bytes\tDV %d refcnt %d\n",
$centry->{Length},
$centry->{DataVersion},
$centry->{refCount});
printf(" callback %08x\texpires %u\n",
$centry->{callback},
$centry->{cbExpires});
printf(" %d opens\t%d writers\n",
$centry->{opens},
$centry->{writers});
print " ";
if ($centry->{mvstat} == 0) {
print "normal file";
}
elsif ($centry->{mvstat} == 1) {
print "mount point";
}
elsif ($centry->{mvstat} == 2) {
print "volume root";
}
elsif ($centry->{mvstat} == 3) {
print "directory";
}
elsif ($centry->{mvstat} == 4) {
print "symlink";
}
elsif ($centry->{mvstat} == 5) {
print "microsoft dfs link";
}
elsif ($centry->{mvstat} == 6) {
print "invalid link";
}
else {
printf("bogus mvstat %d", $centry->{mvstat});
}
printf("\n states (0x%x)", $centry->{states});
if ($centry->{states} & 1) {
print ", stat'd";
}
if ($centry->{states} & 2) {
print ", backup";
}
if ($centry->{states} & 4) {
print ", read-only";
}
if ($centry->{states} & 8) {
print ", mt pt valid";
}
if ($centry->{states} & 0x10) {
print ", pending core";
}
if ($centry->{states} & 0x40) {
print ", wait-for-store";
}
if ($centry->{states} & 0x80) {
print ", mapped";
}
print "\n";
}
}
}
sub print_lock {
my $lock = shift;
print "(";
if ($lock->{waitStates}) {
if($lock->{waitStates} & constant("READ_LOCK")) {
print "reader_waiting";
}
if($lock->{waitStates} & constant("WRITE_LOCK")) {
print "writer_waiting";
}
if($lock->{waitStates} & constant("SHARED_LOCK")) {
print "upgrade_waiting";
}
}
else {
print "none_waiting";
}
if ($lock->{exclLocked}) {
if ($lock->{exclLocked} & constant("WRITE_LOCK")) {
print ", write_locked";
}
if ($lock->{exclLocked} & constant("SHARED_LOCK")) {
print ", upgrade_locked";
}
printf("(pid:%d at:%d)",
$lock->{pid_writer}, $lock->{src_indicator});
}
if ($lock->{readersReading}) {
printf(", %d read_locks(pid:%d)",
$lock->{readersReading}, $lock->{pid_last_reader});
}
if ($lock->{numWaiting}) {
printf(", %d waiters", $lock->{numWaiting});
}
print ")";
}
examples/rxdebug view on Meta::CPAN
use AFS::Monitor qw(rxdebug constant);
use Data::Dumper;
my $servers = 'virtue.openafs.org'; # machine to run this on
my $port = 7001; # port to run this on
my $onlyhost = 'andrew.e.kth.se'; # some of the tests will show only connections from this host
my $onlyport = 7000; # some of the tests will show only connections on this port
my $onlyauth = 'auth'; # some of the tests will show only connections with this auth level
my @tests; # choose which tests to run
$tests[1] = 1; # prints version
$tests[2] = 0; # prints all peers and all non-dallying connections.
# (can be long)
$tests[3] = 0; # nonexistant host
$tests[4] = 0; # nonexistant port
$tests[5] = 0; # bad port; getstats fails. (can be slow)
$tests[6] = 0; # prints long version of all peers. (can be long)
$tests[7] = 0; # server $servers port $port. prints default info.
$tests[8] = 0; # prints rxstats, no connections.
$tests[9] = 0; # prints only auth $onlyauth
$tests[10] = 0; # shows all connections. (can be long)
$tests[11] = 0; # shows all server connections. (can be long)
$tests[12] = 0; # shows all client connections on port $port from host $onlyhost
$tests[13] = 0; # doesn't give port, tries default (7000).
$tests[14] = 0; # no arguments, runs on current machine with default port.
$tests[15] = 0; # port $port, runs on current machine.
$tests[16] = 0; # prints rxstats, all connections, long version of all peers.
# (can be very long)
my $all = 1; # show all tests
my $showdump = 0; # dump contents of hash to the screen for each test instead of printing rxdebug formatted output
# all available options:
# rxdebug(nodally => 1,
# allconnections => 1,
# rxstats => 1,
# onlyserver => 1,
# onlyclient => 1,
# onlyport => $onlyport,
# version => 1,
# noconns => 1,
# peers => 1,
# long => 1,
# servers => $servers, # required
# port => $port,
# onlyhost => $onlyhost,
# onlyauth => $onlyauth,
# );
print "***** Starting now... *****\n";
my $rxdeb;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\nrxdebug -version -servers $servers -port $port\n\n";
$rxdeb = rxdebug(version => 1,
servers => $servers, # required
port => $port
);
parse_results($rxdeb);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\nrxdebug -nodally -allconnections -peers -servers $servers -port $port\n\n";
$rxdeb = rxdebug(nodally => 1,
allconnections => 1,
peers => 1,
servers => $servers,
port => $port
);
parse_results($rxdeb);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\nrxdebug -servers speedy1 -port $port\n\n";
$rxdeb = rxdebug(servers => 'speedy1',
port => $port
);
parse_results($rxdeb);
}
if ($all || $tests[4]) {
print "\n******** TEST 4 ********\n";
print "\nrxdebug -servers $servers -port no\n\n";
$rxdeb = rxdebug(servers => $servers,
port => 'no'
);
parse_results($rxdeb);
}
if ($all || $tests[5]) {
print "\n******** TEST 5 ********\n";
print "\nrxdebug -servers $servers -port 643543\n(may take a while..)\n\n";
$rxdeb = rxdebug(servers => $servers,
port => 643543
);
parse_results($rxdeb);
}
if ($all || $tests[6]) {
print "\n******** TEST 6 ********\n";
print "\nrxdebug -servers $servers -port $port -noconns -peers -long\n\n";
$rxdeb = rxdebug(servers => $servers,
port => $port,
noconns => 1,
peers => 1,
long => 1
);
parse_results($rxdeb);
}
if ($all || $tests[7]) {
print "\n******** TEST 7 ********\n";
print "\nrxdebug -servers $servers -port $port\n\n";
$rxdeb = rxdebug(servers => $servers,
port => $port
);
parse_results($rxdeb);
}
if ($all || $tests[8]) {
print "\n******** TEST 8 ********\n";
print "\nrxdebug -noconns -servers $servers -port $port -rxstats\n\n";
$rxdeb = rxdebug(noconns => 1,
servers => $servers,
port => $port,
rxstats => 1
);
parse_results($rxdeb);
}
if ($all || $tests[9]) {
print "\n******** TEST 9 ********\n";
print "\nrxdebug -servers $servers -port $port -onlyauth $onlyauth\n\n";
$rxdeb = rxdebug(servers => $servers,
port => $port,
onlyauth => $onlyauth
);
parse_results($rxdeb);
}
if ($all || $tests[10]) {
print "\n******** TEST 10 ********\n";
print "\nrxdebug -servers $servers -port $port -allconnections\n\n";
$rxdeb = rxdebug(servers => $servers,
port => $port,
allconnections => 1
);
parse_results($rxdeb);
}
if ($all || $tests[11]) {
print "\n******** TEST 11 ********\n";
print "\nrxdebug -servers $servers -port $port -allconnections -onlyserver\n\n";
$rxdeb = rxdebug(allconnections => 1,
onlyserver => 1,
servers => $servers,
port => $port
);
parse_results($rxdeb);
}
if ($all || $tests[12]) {
print "\n******** TEST 12 ********\n";
print "\nrxdebug -servers $servers -port $port -allconnections -onlyclient -onlyport $onlyport -onlyhost $onlyhost\n\n";
$rxdeb = rxdebug(allconnections => 1,
onlyclient => 1,
onlyport => $onlyport,
servers => $servers,
port => $port,
onlyhost => $onlyhost
);
parse_results ($rxdeb);
}
if ($all || $tests[13]) {
print "\n******** TEST 13 ********\n";
print "\nrxdebug -servers $servers\n\n";
$rxdeb = rxdebug(servers => $servers);
parse_results ($rxdeb);
}
if ($all || $tests[14]) {
print "\n******** TEST 14 ********\n";
print "\nrxdebug 0\n\n";
$rxdeb = rxdebug();
parse_results ($rxdeb);
}
if ($all || $tests[15]) {
print "\n******** TEST 15 ********\n";
print "\nrxdebug 0 -port $port\n\n";
$rxdeb = rxdebug(port => $port);
parse_results ($rxdeb);
}
if ($all || $tests[16]) {
print "\n******** TEST 16 ********\n";
print "\nrxdebug -servers $servers -port $port -allconnections -peers -long -rxstats\n\n";
$rxdeb = rxdebug(allconnections => 1,
rxstats => 1,
peers => 1,
long => 1,
servers => $servers,
port => $port
);
parse_results($rxdeb);
}
sub parse_results {
my $val = shift;
# if there was an error, print it and then return.
if ($AFS::CODE) {
print "Error case: ", ref($val), "\n" if (defined($val));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
# print entire hash to screen
if ($showdump) {
print Dumper($val);
return;
}
# print ip address and port
print "For ", $val->{address}, " (port ", $val->{port}, ") ...\n";
# prints everything as the rxdebug function would
# print version if it was returned
if (exists $val->{version}) {
print "AFS version: ", $val->{version}, "\n";
}
# print tstats if they were returned
if (exists $val->{tstats}) {
print "Free packets: $val->{tstats}->{nFreePackets}, ";
print "packet reclaims: $val->{tstats}->{packetReclaims}, ";
print "calls: $val->{tstats}->{callsExecuted}, ";
print "used FDs: $val->{tstats}->{usedFDs}\n";
if (!$val->{tstats}->{waitingForPackets}) {
print "not ";
}
print "waiting for packets.\n";
if (exists $val->{tstats}->{nWaiting}) {
print "$val->{tstats}->{nWaiting} calls waiting for a thread\n";
}
if (exists $val->{tstats}->{idleThreads}) {
print "$val->{tstats}->{idleThreads} threads are idle\n";
}
}
# print rxstats if they were returned
if (exists $val->{rxstats}) {
print "rx stats: free packets ", $val->{tstats}->{nFreePackets},
", allocs ", $val->{rxstats}->{packetRequests}, ", ";
if ($val->{tstats}->{version} >=
constant("RX_DEBUGI_VERSION_W_NEWPACKETTYPES")) {
print "alloc-failures(rcv ", $val->{rxstats}->{receivePktAllocFailures},
"/", $val->{rxstats}->{receiveCbufPktAllocFailures},
",send ", $val->{rxstats}->{sendPktAllocFailures},
"/", $val->{rxstats}->{sendCbufPktAllocFailures},
",ack ", $val->{rxstats}->{specialPktAllocFailures}, ")\n";
} else {
print "alloc-failures(rcv ", $val->{rxstats}->{receivePktAllocFailures},
",send ", $val->{rxstats}->{sendPktAllocFailures},
",ack ", $val->{rxstats}->{specialPktAllocFailures}, ")\n";
}
print " greedy ", $val->{rxstats}->{socketGreedy},
", bogusReads ", $val->{rxstats}->{bogusPacketOnRead},
" (last from host ", $val->{rxstats}->{bogusHost},
"), noPackets ", $val->{rxstats}->{noPacketOnRead},
", noBuffers ", $val->{rxstats}->{noPacketBuffersOnRead},
", selects ", $val->{rxstats}->{selects},
", sendSelects ", $val->{rxstats}->{sendSelects}, "\n";
print " packets read: ";
foreach my $key (sort keys %{$val->{rxstats}->{packets}}) {
print $key, " ", $val->{rxstats}->{packets}->{$key}->{packetsRead}, " ";
}
print "\n";
print " other read counters: data ", $val->{rxstats}->{dataPacketsRead},
", ack ", $val->{rxstats}->{ackPacketsRead},
", dup ", $val->{rxstats}->{dupPacketsRead},
" spurious ", $val->{rxstats}->{spuriousPacketsRead},
" dally ", $val->{rxstats}->{ignorePacketDally}, "\n";
print " packets sent: ";
foreach my $key (sort keys %{$val->{rxstats}->{packets}}) {
print $key, " ", $val->{rxstats}->{packets}->{$key}->{packetsSent}, " ";
}
print "\n";
print " other send counters: ack ", $val->{rxstats}->{ackPacketsSent},
", data ", $val->{rxstats}->{dataPacketsSent},
" (not resends), resends ", $val->{rxstats}->{dataPacketsReSent},
", pushed ", $val->{rxstats}->{dataPacketsPushed},
", acked&ignored ", $val->{rxstats}->{ignoreAckedPacket}, "\n";
print " \t(these should be small) ",
"sendFailed ", $val->{rxstats}->{netSendFailures},
", fatalErrors ", $val->{rxstats}->{fatalErrors}, "\n";
if ($val->{rxstats}->{nRttSamples}) {
my $avrtt = $val->{rxstats}->{totalRtt}->{usec} / 1000000.00;
$avrtt = $avrtt + $val->{rxstats}->{totalRtt}->{sec};
$avrtt = $avrtt / $val->{rxstats}->{nRttSamples};
printf(" Average rtt is %0.3f, with %d samples\n",
$avrtt,
$val->{rxstats}->{nRttSamples});
my $minrtt = $val->{rxstats}->{minRtt}->{usec} / 1000000.00;
$minrtt = $minrtt + $val->{rxstats}->{minRtt}->{sec};
my $maxrtt = $val->{rxstats}->{maxRtt}->{usec} / 1000000.00;
$maxrtt = $maxrtt + $val->{rxstats}->{maxRtt}->{sec};
printf(" Minimum rtt is %0.3f, maximum is %0.3f\n",
$minrtt,
$maxrtt);
}
print " ", $val->{rxstats}->{nServerConns}, " server connections, ",
$val->{rxstats}->{nClientConns}, " client connections, ",
$val->{rxstats}->{nPeerStructs}, " peer structs, ",
$val->{rxstats}->{nCallStructs}, " call structs, ",
$val->{rxstats}->{nFreeCallStructs}, " free call structs\n";
if (exists $val->{rxstats}->{clock_nUpdates}) {
print " ", $val->{rxstats}->{clock_nUpdates}, " clock updates\n";
}
}
# print connections if they were returned
if (exists $val->{connections}) {
for (my $i = 0; $i <= $#{$val->{connections}}; $i++) { # print each connection
print "Connection from host ", $val->{connections}->[$i]->{host},
", port ", $val->{connections}->[$i]->{port},", ";
if ($val->{connections}->[$i]->{epoch}) {
printf "Cuid %x/%x", $val->{connections}->[$i]->{epoch}, $val->{connections}->[$i]->{cid};
} else {
printf "cid %x", $val->{connections}->[$i]->{cid};
}
if ($val->{connections}->[$i]->{error}) {
print ", error ", $val->{connections}->[$i]->{error};
}
print "\n serial $val->{connections}->[$i]->{serial}, ";
print " natMTU $val->{connections}->[$i]->{natMTU}, ";
if ($val->{connections}->[$i]->{flags}) {
print "flags";
if ($val->{connections}->[$i]->{flags} & constant("RX_CONN_MAKECALL_WAITING")) {
print " MAKECALL_WAITING";
}
if ($val->{connections}->[$i]->{flags} & constant("RX_CONN_DESTROY_ME")) {
print " DESTROYED";
}
if ($val->{connections}->[$i]->{flags} & constant("RX_CONN_USING_PACKET_CKSUM")) {
print " pktCksum";
}
print ", ";
}
print "security index $val->{connections}->[$i]->{securityIndex}, ";
if ($val->{connections}->[$i]->{type} == constant("RX_CLIENT_CONNECTION")) {
print "client conn\n";
} else {
print "server conn\n";
}
# print secStats if this connection has them
if (exists $val->{connections}->[$i]->{secStats}) {
my $secStatsType = $val->{connections}->[$i]->{secStats}->{type};
if ($secStatsType == 0) {
if ($val->{connections}->[$i]->{securityIndex} == 2) {
print " no GetStats procedure for security object\n";
}
} elsif ($secStatsType == 1) {
print " rxnull level=", $val->{connections}->[$i]->{secStats}->{level};
print ", flags=", $val->{connections}->[$i]->{secStats}->{flags},"\n";
} elsif ($secStatsType == 2) {
print " rxvab level=", $val->{connections}->[$i]->{secStats}->{level};
print ", flags=", $val->{connections}->[$i]->{secStats}->{flags},"\n";
} elsif ($secStatsType == 3) {
my $secStatsLevel;
my $secStatsFlags = $val->{connections}->[$i]->{secStats}->{flags};
if ($val->{connections}->[$i]->{secStats}->{level} == 0) {
$secStatsLevel = "clear";
} elsif ($val->{connections}->[$i]->{secStats}->{level} == 1) {
$secStatsLevel = "auth";
} elsif ($val->{connections}->[$i]->{secStats}->{level} == 2) {
$secStatsLevel = "crypt";
} else {
$secStatsLevel = "unknown";
}
print " rxkad: level ", $secStatsLevel;
if ($secStatsFlags) {
print ", flags";
}
if ($secStatsFlags & 1) {
print " unalloc";
}
if ($secStatsFlags & 2) {
print " authenticated";
}
if ($secStatsFlags & 4) {
print " expired";
}
if ($secStatsFlags & 8) {
print " pktCksum";
}
if ($val->{connections}->[$i]->{secStats}->{expires}) {
my $secStatsExpires = $val->{connections}->[$i]->{secStats}->{expires} - time();
$secStatsExpires = $secStatsExpires / 3600.0;
printf(", expires in %.1f hours", $secStatsExpires);
}
if (!($secStatsFlags & 1)) {
print "\n Received ", $val->{connections}->[$i]->{secStats}->{bytesReceived},
" bytes in ", $val->{connections}->[$i]->{secStats}->{packetsReceived}," packets\n";
print " Sent ", $val->{connections}->[$i]->{secStats}->{bytesSent},
" bytes in ", $val->{connections}->[$i]->{secStats}->{packetsSent}, " packets\n";
} else {
print "\n";
}
} else {
print " unknown\n";
}
} # done printing secStats
# print calls for this connection
for (my $j = 0; $j < constant("RX_MAXCALLS"); $j++) {
print " call ", $j, ": # ", $val->{connections}->[$i]->{callNumber}->[$j], ", state ";
# print call state
if ($val->{connections}->[$i]->{callState}->[$j] == constant("RX_STATE_NOTINIT")) {
print "not initialized\n";
next;
} elsif ($val->{connections}->[$i]->{callState}->[$j] == constant("RX_STATE_PRECALL")) {
print "precall, ";
} elsif ($val->{connections}->[$i]->{callState}->[$j] == constant("RX_STATE_ACTIVE")) {
print "active, ";
} elsif ($val->{connections}->[$i]->{callState}->[$j] == constant("RX_STATE_DALLY")) {
print "dally, ";
} elsif ($val->{connections}->[$i]->{callState}->[$j] == constant("RX_STATE_HOLD")) {
print "hold, ";
}
# print call mode
print "mode: ";
if ($val->{connections}->[$i]->{callMode}->[$j] == constant("RX_MODE_SENDING")) {
print "sending";
} elsif ($val->{connections}->[$i]->{callMode}->[$j] == constant("RX_MODE_RECEIVING")) {
print "receiving";
} elsif ($val->{connections}->[$i]->{callMode}->[$j] == constant("RX_MODE_ERROR")) {
print "error";
} elsif ($val->{connections}->[$i]->{callMode}->[$j] == constant("RX_MODE_EOF")) {
print "eof";
} else {
print "unknown";
}
# print flags for this call
if ($val->{connections}->[$i]->{callFlags}->[$j]) {
printf(", flags:");
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_READER_WAIT")) {
print " reader_wait";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_WAIT_WINDOW_ALLOC")) {
print " window_alloc";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_WAIT_WINDOW_SEND")) {
print " window_send";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_WAIT_PACKETS")) {
print " wait_packets";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_WAIT_PROC")) {
print " waiting_for_process";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_RECEIVE_DONE")) {
print " receive_done";
}
if ($val->{connections}->[$i]->{callFlags}->[$j] & constant("RX_CALL_CLEARED")) {
print " call_cleared";
}
}
if ($val->{connections}->[$i]->{callOther}->[$j] & constant("RX_OTHER_IN")) {
print ", has_input_packets";
}
if ($val->{connections}->[$i]->{callOther}->[$j] & constant("RX_OTHER_OUT")) {
print ", has_output_packets";
}
print "\n";
}
}
# if -nodally flag was set, print number of dallying connections skipped
if (exists $val->{dallyCounter}) {
print "Skipped ", $val->{dallyCounter}, " dallying connections.\n";
}
} # done printing connections
# print peers if they were returned
if (exists $val->{peers}) {
for (my $i = 0; $i <= $#{$val->{peers}}; $i++) {
print "Peer at host ", $val->{peers}->[$i]->{host},
", port ", $val->{peers}->[$i]->{port}, "\n";
printf("\tifMTU %hu\tnatMTU %hu\tmaxMTU %hu\n",
$val->{peers}->[$i]->{ifMTU},
$val->{peers}->[$i]->{natMTU},
$val->{peers}->[$i]->{maxMTU});
printf("\tpackets sent %d\tpacket resends %d\n",
$val->{peers}->[$i]->{nSent},
$val->{peers}->[$i]->{reSends});
printf("\tbytes sent high %d low %d\n",
$val->{peers}->[$i]->{bytesSent}->{high},
$val->{peers}->[$i]->{bytesSent}->{low});
printf("\tbytes received high %d low %d\n",
$val->{peers}->[$i]->{bytesReceived}->{high},
$val->{peers}->[$i]->{bytesReceived}->{low});
my $tpeer_rtt = $val->{peers}->[$i]->{rtt} >> 3;
my $tpeer_rtt_dev = $val->{peers}->[$i]->{rtt_dev} >> 2;
printf("\trtt %d msec, rtt_dev %d msec\n",
$tpeer_rtt, $tpeer_rtt_dev);
my $timeoutusec = $val->{peers}->[$i]->{timeout}->{usec};
$timeoutusec = $timeoutusec / 1000;
printf("\ttimeout %d.%03d sec\n",
$val->{peers}->[$i]->{timeout}->{sec}, $timeoutusec);
# prints extra information if -long flag was set
if (exists $val->{peers}->[$i]->{inPacketSkew}) {
printf("\tin/out packet skew: %d/%d\n",
$val->{peers}->[$i]->{inPacketSkew},
$val->{peers}->[$i]->{outPacketSkew});
printf("\tcongestion window %d, MTU %d\n",
$val->{peers}->[$i]->{cwind},
$val->{peers}->[$i]->{MTU});
printf("\tcurrent/if/max jumbogram size: %d/%d/%d\n",
$val->{peers}->[$i]->{nDgramPackets},
$val->{peers}->[$i]->{ifDgramPackets},
$val->{peers}->[$i]->{maxDgramPackets});
}
}
}
}
print "...Done\n";
examples/scout view on Meta::CPAN
my @servers = ("virtue");
my $debugfile = "debug_out/debug";
my $basename = "openafs.org";
my @tests; # choose which tests to run
$tests[1] = 1; # blank
$tests[2] = 1; # blank
my $all = 0;
my $showdump = 1; # print entire contents of hash for each test
my $formatted = 0; # print formatted, easy to read output
my $scout = 1; # print only the information displayed by the original (c) scout program
print "# Starting now... #\n";
my $result;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\nscout -server ", join(" ", @servers),
" -debug $debugfile -basename $basename\n\n";
$result = scout(server => \@servers,
debug => $debugfile,
basename => $basename);
parse_result($result);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\nscout -server virtue.openafs.org\n\n";
$result = scout(server => "virtue.openafs.org");
parse_result($result);
}
sub parse_result {
my $info = shift;
if ($AFS::CODE) {
print "Error case: ", ref($info), "\n" if (defined($info));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Varname = "scout";
print Dumper($info);
}
if ($formatted) {
foreach my $connection (@$info) {
print $connection->{hostName}, "\n";
if ($connection->{probeOK}) {
print " Results:\n";
foreach my $stat (sort keys %{$connection->{stats}}) {
print " $stat $connection->{stats}->{$stat}\n";
}
} else {
print " Probe Failed.\n";
}
}
}
if ($scout) {
foreach my $connection (@$info) {
print $connection->{hostName}, "\n";
if ($connection->{probeOK}) {
print " Conn: $connection->{stats}->{CurrentConnections}\n";
print " Fetch: $connection->{stats}->{TotalFetchs}\n";
print " Store: $connection->{stats}->{TotalStores}\n";
print " Ws: $connection->{stats}->{WorkStations}\n";
print " Disk attn:\n";
foreach my $disk (@{$connection->{stats}->{Disk}}) {
print " $disk->{Name}:$disk->{BlocksAvailable} (";
printf "%0.2f%%)\n", ($disk->{TotalBlock} - $disk->{BlocksAvailable}) * 100 / $disk->{TotalBlock};
}
} else {
print " Probe Failed.\n";
}
}
}
}
examples/scripts/HandlerScript view on Meta::CPAN
#!/usr/bin/perl -w
#
# Copyright © 2004 Alf Wachsmann <alfw@slac.stanford.edu> and
# Elizabeth Cassell <e_a_c@mailsnare.net>
#
# $Revision: 1.1 $ $Date: 2004/08/05 20:52:03 $ $Author: alfw $
#
print "*** Handler Script called for an overflow! ***\n";
print "*** Host name: ", shift, " type: ", shift, " ***\n";
print "*** Overflow in field ", shift,
" (threshold ", shift, ",
actual ", shift, ") ***\n";
my $otherargs = shift;
if ($otherargs) {
print "*** Other arguments: ", $otherargs;
while ($otherargs = shift) {
print " ", $otherargs;
}
print " ***\n";
}
examples/udebug view on Meta::CPAN
$tests[1] = 0; # test of server $server, port $port, long output
$tests[2] = 0; # test of server $non_sync_server, port $port, short output
$tests[3] = 0; # test of server $non_sync_server, port $port, long output
$tests[4] = 0; # test of server $server, no port
$tests[5] = 1; # test of nonexistant server
$tests[6] = 1; # test of server $server, bad port
$tests[7] = 0; # test of server $server, port $port
my $all = 0;
my $showdump = 0; # print entire contents of hash for each test
my $formatted = 1; # print output formatted like the C udebug program
print "# Starting now... #\n";
my $result;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\nudebug -server $server -port $port -long\n\n";
$result = udebug(server => $server,
port => $port
);
parse_result($result);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\nudebug -server $non_sync_server -port $port\n\n";
$result = udebug(server => $non_sync_server,
port => $port
);
parse_result($result);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\nudebug -server $non_sync_server -port $port -long\n\n";
$result = udebug(server => $non_sync_server,
port => $port,
long => 1
);
parse_result($result);
}
if ($all || $tests[4]) {
print "\n******** TEST 4: ********\n";
print "\nudebug -server $server\n\n";
$result =udebug(server => $server);
parse_result($result);
}
if ($all || $tests[5]) {
print "\n******** TEST 5: ********\n";
print "\nudebug -server nonexistant\n\n";
$result = udebug(server => "nonexistant");
parse_result($result);
}
if ($all || $tests[6]) {
print "\n******** TEST 6: ********\n";
print "\nudebug -server $server -port 7001\n\n";
$result = udebug(server => $server,
port => 7001
);
parse_result($result);
}
if ($all || $tests[7]) {
print "\n******** TEST 7: ********\n";
print "\nudebug -server $server -port $port\n\n";
$result = udebug(server => $server,
port => $port
);
parse_result($result);
}
sub parse_result {
my $info = shift;
if ($AFS::CODE) {
print "Error case: ", ref($info), "\n" if (defined($info));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Sortkeys = 1;
print Dumper($info);
}
if ($formatted) {
my $diff;
if (exists $info->{interfaceAddr}) {
print "Host's addresses are: ", join(" ", @{$info->{interfaceAddr}}),
"\n";
}
printf("Host's %s time is %s\n",
$info->{host},
scalar localtime($info->{now}));
$diff = time - $info->{now};
printf("Local time is %s (time differential %d secs)\n",
scalar localtime(time),
$diff);
if (abs($diff) >= constant("MAXSKEW")) {
print "****clock may be bad\n";
}
if (exists $info->{lastYesHost}) {
$diff = $info->{now} - $info->{lastYesTime};
printf("Last yes vote for %s was %d secs ago (%ssync site); \n",
$info->{lastYesHost}, $diff, $info->{lastYesState} ? "" : "not ");
$diff = $info->{now} - $info->{lastYesClaim};
printf("Last vote started %d secs ago (at %s)\n",
$diff,
scalar localtime(time - $diff));
} else {
print "Last yes vote not cast yet \n";
}
printf "Local db version is %d.%d\n",
$info->{localVersion}->{epoch},
$info->{localVersion}->{counter};
if ($info->{amSyncSite}) {
if ($info->{syncSiteUntil} == 0x7fffffff) {
printf("I am sync site forever (%d server%s)\n",
$info->{nServers},
$info->{nServers} > 1 ? "s" : "");
} else {
$diff = $info->{syncSiteUntil} - $info->{now};
printf("I am sync site until %d secs from now (at %s) (%d server%s)\n",
$diff,
scalar localtime(time + $diff),
$info->{nServers},
$info->{nServers} > 1 ? "s" : "");
}
printf("Recovery state %x\n", $info->{recoveryState});
if ($info->{activeWrite}) {
printf("I am currently managing write trans %d.%d\n",
$info->{epochTime},
$info->{tidCounter});
}
} else {
if ($info->{isClone}) {
print "I am a clone and never can become sync site\n";
} else {
print "I am not sync site\n";
}
$diff = $info->{now} - $info->{lowestTime};
printf("Lowest host %s was set %d secs ago\n",
$info->{lowestHost}, $diff);
$diff = $info->{now} - $info->{syncTime};
printf("Sync host %s was set %d secs ago\n",
$info->{syncHost}, $diff);
}
printf("Sync site's db version is %d.%d\n",
$info->{syncVersion}->{epoch},
$info->{syncVersion}->{counter});
printf("%d locked pages, %d of them for write\n",
$info->{lockedPages},
$info->{writeLockedPages});
if ($info->{anyReadLocks}) {
print "There are read locks held\n";
}
if ($info->{anyWriteLocks}) {
print "There are write locks held\n";
}
if ($info->{currentTrans}) {
if ($info->{writeTrans}) {
print "There is an active write transaction\n";
} else {
print "There is at least one active read transaction\n";
}
printf("Transaction tid is %d.%d\n",
$info->{syncTid}->{epoch},
$info->{syncTid}->{counter});
}
if ($info->{epochTime}) {
$diff = $info->{now} - $info->{epochTime};
printf("Last time a new db version was labelled was:\n\t %d secs ago (at %s)\n",
$diff, scalar localtime(time - $diff));
}
if (exists $info->{servers}) {
foreach my $current (@{$info->{servers}}) {
printf("\nServer (%s", $current->{addr});
if (exists $current->{altAddr}) {
print " ", join(" ", @{$current->{altAddr}});
}
printf("): (db %d.%d)",
$current->{remoteVersion}->{epoch},
$current->{remoteVersion}->{counter});
if ($current->{isClone}) {
print " is only a clone!";
}
print "\n";
if ($current->{lastVoteTime} == 0) {
print " last vote never rcvd \n";
} else {
$diff = $info->{now} - $current->{lastVoteTime};
printf(" last vote rcvd %d secs ago (at %s),\n",
$diff, scalar localtime(time - $diff));
}
if ($current->{lastBeaconSent} == 0) {
print " last beacon never sent \n";
} else {
$diff = $info->{now} - $current->{lastBeaconSent};
printf(" last beacon sent %d secs ago (at %s), last vote was %s\n",
$diff,
scalar localtime(time - $diff),
$current->{lastVote} ? "yes" : "no");
}
printf(" dbcurrent=%d, up=%d beaconSince=%d\n",
$current->{currentDB},
$current->{up},
$current->{beaconSinceDown});
}
}
}
}
examples/xstat_cm_test view on Meta::CPAN
my @collID = (0, 1, 2);
my @tests; # choose which tests to run
$tests[1] = 1; # test of cmname @cmname and collIDs @collID
$tests[2] = 0; # test of cmname but no collID
$tests[3] = 0; # test of single cmname with collID
$tests[4] = 0; # test of single cmname but no single collID
my $all = 1;
my $showdump = 0; # print entire contents of hash for each test
my $formatted = 1; # print formatted like original xstat_cm_test program
print "# Starting now... #\n";
my $result;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\nxstat_cm_test -cmname ", join(" ", @cmname),
" -collID ", join(" ", @collID), "\n\n";
$result = xstat_cm_test(cmname => \@cmname,
collID => \@collID);
parse_result($result);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\nxstat_cm_test -cmname ", join(" ", @cmname), "\n\n";
$result = xstat_cm_test(cmname => \@cmname);
parse_result($result);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\nxstat_cm_test -cmname ", $cmname[0],
" -collID 2\n\n";
$result = xstat_cm_test(cmname => $cmname[0],
collID => 2);
parse_result($result);
}
if ($all || $tests[4]) {
print "\n******** TEST 4: ********\n";
print "\nxstat_cm_test -cmname ", $cmname[0], "\n\n";
$result = xstat_cm_test(cmname => $cmname[0]);
parse_result($result);
}
sub parse_result {
my $info = shift;
if ($AFS::CODE) {
print "Error case: ", ref($info), "\n" if (defined($info));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Maxdepth = 2;
local $Data::Dumper::Varname = "xstat_cm_test";
print Dumper($info);
}
if ($formatted) {
foreach my $host (@$info) {
if ($host->{probeOK} == 0) {
printf("CM_Handler: Probe 1, collection %d to CM on '%s' failed\n",
$host->{collectionNumber},
$host->{hostName});
return;
}
if ($host->{collectionNumber} == constant("AFSCB_XSTATSCOLL_CALL_INFO")) {
PrintCallInfo($host);
} elsif ($host->{collectionNumber} == constant("AFSCB_XSTATSCOLL_PERF_INFO")) {
PrintPerfInfo($host);
} elsif ($host->{collectionNumber} == constant("AFSCB_XSTATSCOLL_FULL_PERF_INFO")) {
PrintFullPerfInfo($host);
} else {
printf "** Unknown collection: %d\n", $host->{collectionNumber};
}
}
}
}
sub PrintPerfInfo {
my $host = shift;
printf("AFSCB_XSTATSCOLL_PERF_INFO (coll %d) for CM %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime $host->{probeTime});
PrintOverallPerfInfo($host->{data});
}
sub PrintFullPerfInfo {
my $host = shift;
printf("AFSCB_XSTATSCOLL_FULL_PERF_INFO (coll %d) for CM %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime $host->{probeTime});
print "Overall Performance Info:\n-------------------------\n";
PrintOverallPerfInfo($host->{data}->{perf});
print "\n";
PrintRPCPerfInfo($host->{data}->{rpc});
my $authentP = $host->{data}->{authent};
print "\nAuthentication info:\n--------------------\n";
printf("\t%d PAGS, %d records (%d auth, %d unauth), %d max in PAG, chain max: %d\n",
$authentP->{curr_PAGs},
$authentP->{curr_Records},
$authentP->{curr_AuthRecords},
$authentP->{curr_UnauthRecords},
$authentP->{curr_MaxRecordsInPAG},
$authentP->{curr_LongestChain});
printf("\t%d PAG creations, %d tkt updates\n",
$authentP->{PAGCreations},
$authentP->{TicketUpdates});
printf("\t[HWMs: %d PAGS, %d records, %d max in PAG, chain max: %d]\n",
$authentP->{HWM_PAGs},
$authentP->{HWM_Records},
$authentP->{HWM_MaxRecordsInPAG},
$authentP->{HWM_LongestChain});
my $accessinfP = $host->{data}->{accessinf};
print "\n[Un]replicated accesses:\n------------------------\n";
printf("\t%d unrep, %d rep, %d reps accessed, %d max reps/ref, %d first OK\n\n",
$accessinfP->{unreplicatedRefs},
$accessinfP->{replicatedRefs},
$accessinfP->{numReplicasAccessed},
$accessinfP->{maxReplicasPerRef},
$accessinfP->{refFirstReplicaOK});
}
sub PrintOverallPerfInfo {
my $perf = shift;
printf "\t%10d numPerfCalls\n", $perf->{numPerfCalls};
printf "\t%10d epoch\n", $perf->{epoch};
printf "\t%10d numCellsVisible\n", $perf->{numCellsVisible};
printf "\t%10d numCellsContacted\n", $perf->{numCellsContacted};
printf "\t%10d dlocalAccesses\n", $perf->{dlocalAccesses};
printf "\t%10d vlocalAccesses\n", $perf->{vlocalAccesses};
printf "\t%10d dremoteAccesses\n", $perf->{dremoteAccesses};
printf "\t%10d vremoteAccesses\n", $perf->{vremoteAccesses};
printf "\t%10d cacheNumEntries\n", $perf->{cacheNumEntries};
printf "\t%10d cacheBlocksTotal\n", $perf->{cacheBlocksTotal};
printf "\t%10d cacheBlocksInUse\n", $perf->{cacheBlocksInUse};
printf "\t%10d cacheBlocksOrig\n", $perf->{cacheBlocksOrig};
printf "\t%10d cacheMaxDirtyChunks\n", $perf->{cacheMaxDirtyChunks};
printf "\t%10d cacheCurrDirtyChunks\n", $perf->{cacheCurrDirtyChunks};
printf "\t%10d dcacheHits\n", $perf->{dcacheHits};
printf "\t%10d vcacheHits\n", $perf->{vcacheHits};
printf "\t%10d dcacheMisses\n", $perf->{dcacheMisses};
printf "\t%10d vcacheMisses\n", $perf->{vcacheMisses};
printf "\t%10d cacheFilesReused\n", $perf->{cacheFilesReused};
printf "\t%10d vcacheXAllocs\n", $perf->{vcacheXAllocs};
printf "\t%10d dcacheXAllocs\n", $perf->{dcacheXAllocs};
printf "\t%10d bufAlloced\n", $perf->{bufAlloced};
printf "\t%10d bufHits\n", $perf->{bufHits};
printf "\t%10d bufMisses\n", $perf->{bufMisses};
printf "\t%10d bufFlushDirty\n", $perf->{bufFlushDirty};
printf "\t%10d LargeBlocksActive\n", $perf->{LargeBlocksActive};
printf "\t%10d LargeBlocksAlloced\n", $perf->{LargeBlocksAlloced};
printf "\t%10d SmallBlocksActive\n", $perf->{SmallBlocksActive};
printf "\t%10d SmallBlocksAlloced\n", $perf->{SmallBlocksAlloced};
printf "\t%10d OutStandingMemUsage\n", $perf->{OutStandingMemUsage};
printf "\t%10d OutStandingAllocs\n", $perf->{OutStandingAllocs};
printf "\t%10d CallBackAlloced\n", $perf->{CallBackAlloced};
printf "\t%10d CallBackFlushes\n", $perf->{CallBackFlushes};
printf "\t%10d CallBackLoops\n", $perf->{cbloops};
printf "\t%10d srvRecords\n", $perf->{srvRecords};
printf "\t%10d srvNumBuckets\n", $perf->{srvNumBuckets};
printf "\t%10d srvMaxChainLength\n", $perf->{srvMaxChainLength};
printf "\t%10d srvMaxChainLengthHWM\n", $perf->{srvMaxChainLengthHWM};
printf "\t%10d srvRecordsHWM\n", $perf->{srvRecordsHWM};
printf "\t%10d sysName_ID\n", $perf->{sysName_ID};
print "\tFile Server up/downtimes, same cell:\n";
PrintUpDownStats($perf->{fs_UpDown}->[0]);
print "\tFile Server up/downtimes, diff cell:\n";
PrintUpDownStats($perf->{fs_UpDown}->[1]);
print "\tVL Server up/downtimes, same cell:\n";
PrintUpDownStats($perf->{vl_UpDown}->[0]);
print "\tVL Server up/downtimes, diff cell:\n";
PrintUpDownStats($perf->{vl_UpDown}->[1]);
}
sub PrintUpDownStats {
my $updown = shift;
printf "\t\t%10d numTtlRecords\n", $updown->{numTtlRecords};
printf "\t\t%10d numUpRecords\n", $updown->{numUpRecords};
printf "\t\t%10d numDownRecords\n", $updown->{numDownRecords};
printf "\t\t%10d sumOfRecordAges\n",$updown->{sumOfRecordAges};
printf "\t\t%10d ageOfYoungestRecord\n",$updown->{ageOfYoungestRecord};
printf "\t\t%10d ageOfOldestRecord\n",$updown->{ageOfOldestRecord};
printf "\t\t%10d numDowntimeIncidents\n",$updown->{numDowntimeIncidents};
printf "\t\t%10d numRecordsNeverDown\n",$updown->{numRecordsNeverDown};
printf "\t\t%10d maxDowntimesInARecord\n",$updown->{maxDowntimesInARecord};
printf "\t\t%10d sumOfDowntimes\n", $updown->{sumOfDowntimes};
printf "\t\t%10d shortestDowntime\n",$updown->{shortestDowntime};
printf "\t\t%10d longestDowntime\n",$updown->{longestDowntime};
printf "\t\tDowntime duration distribution:\n";
printf "\t\t\t%8d: 0 min .. 10 min\n", $updown->{downDurations}->[0];
printf "\t\t\t%8d: 10 min .. 30 min\n", $updown->{downDurations}->[1];
printf "\t\t\t%8d: 30 min .. 1 hr\n", $updown->{downDurations}->[2];
printf "\t\t\t%8d: 1 hr .. 2 hr\n", $updown->{downDurations}->[3];
printf "\t\t\t%8d: 2 hr .. 4 hr\n", $updown->{downDurations}->[4];
printf "\t\t\t%8d: 4 hr .. 8 hr\n", $updown->{downDurations}->[5];
printf "\t\t\t%8d: > 8 hr\n", $updown->{downDurations}->[6];
printf "\t\tDowntime incident distribution:\n";
printf "\t\t\t%8d: 0 times\n", $updown->{downIncidents}->[0];
printf "\t\t\t%8d: 1 time\n", $updown->{downIncidents}->[1];
printf "\t\t\t%8d: 2 .. 5 times\n", $updown->{downIncidents}->[2];
printf "\t\t\t%8d: 6 .. 10 times\n", $updown->{downIncidents}->[3];
printf "\t\t\t%8d: 10 .. 50 times\n", $updown->{downIncidents}->[4];
printf "\t\t\t%8d: > 50 times\n", $updown->{downIncidents}->[5];
}
sub PrintRPCPerfInfo {
my $rpc = shift;
print "FS Operation Timings:\n---------------------\n";
foreach (sort keys %{$rpc->{fsRPCTimes}}) {
printf "%15s: %d ops (%d OK); sum=%f, sqr=%f, min=%f, max=%f\n",
$_,
$rpc->{fsRPCTimes}->{$_}->{numOps}, $rpc->{fsRPCTimes}->{$_}->{numSuccesses},
$rpc->{fsRPCTimes}->{$_}->{sumTime}, $rpc->{fsRPCTimes}->{$_}->{sqrTime},
$rpc->{fsRPCTimes}->{$_}->{minTime}, $rpc->{fsRPCTimes}->{$_}->{maxTime};
}
print "\nError Info:\n-----------\n";
foreach (sort keys %{$rpc->{fsRPCErrors}}) {
printf "%15s: %d server, %d network, %d prot, %d vol, %d busies, %d other\n",
$_,
$rpc->{fsRPCErrors}->{$_}->{err_Server},
$rpc->{fsRPCErrors}->{$_}->{err_Network},
$rpc->{fsRPCErrors}->{$_}->{err_Protection},
$rpc->{fsRPCErrors}->{$_}->{err_Volume},
$rpc->{fsRPCErrors}->{$_}->{err_VolumeBusies},
$rpc->{fsRPCErrors}->{$_}->{err_Other};
}
print "\nTransfer timings:\n-----------------\n";
foreach (sort keys %{$rpc->{fsXferTimes}}) {
printf "%s: %d xfers (%d OK), time sum=%f, sqr=%f, min=%f, max=%f\n",
$_,
$rpc->{fsXferTimes}->{$_}->{numXfers}, $rpc->{fsXferTimes}->{$_}->{numSuccesses},
$rpc->{fsXferTimes}->{$_}->{sumTime},
$rpc->{fsXferTimes}->{$_}->{sqrTime},
$rpc->{fsXferTimes}->{$_}->{minTime},
$rpc->{fsXferTimes}->{$_}->{maxTime};
printf "\t[bytes: sum=%d, min=%d, max=%d]\n",
$rpc->{fsXferTimes}->{$_}->{sumBytes},
$rpc->{fsXferTimes}->{$_}->{minBytes},
$rpc->{fsXferTimes}->{$_}->{maxBytes};
printf "\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d, 6: %d, 7: %d, 8: %d]\n",
$rpc->{fsXferTimes}->{$_}->{count}->[0],
$rpc->{fsXferTimes}->{$_}->{count}->[1],
$rpc->{fsXferTimes}->{$_}->{count}->[2],
$rpc->{fsXferTimes}->{$_}->{count}->[3],
$rpc->{fsXferTimes}->{$_}->{count}->[4],
$rpc->{fsXferTimes}->{$_}->{count}->[5],
$rpc->{fsXferTimes}->{$_}->{count}->[6],
$rpc->{fsXferTimes}->{$_}->{count}->[7],
$rpc->{fsXferTimes}->{$_}->{count}->[8];
}
print "\nCM Operation Timings:\n---------------------\n";
foreach (sort keys %{$rpc->{cmRPCTimes}}) {
printf "%15s: %d ops (%d OK); sum=%f, sqr=%f, min=%f, max=%f\n",
$_,
$rpc->{cmRPCTimes}->{$_}->{numOps}, $rpc->{cmRPCTimes}->{$_}->{numSuccesses},
$rpc->{cmRPCTimes}->{$_}->{sumTime}, $rpc->{cmRPCTimes}->{$_}->{sqrTime},
$rpc->{cmRPCTimes}->{$_}->{minTime}, $rpc->{cmRPCTimes}->{$_}->{maxTime};
}
}
sub PrintCallInfo {
my $host = shift;
printf "AFSCB_XSTATSCOLL_CALL_INFO (coll %d) for CM %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime $host->{probeTime};
my $data = $host->{data};
printf "\t%10d afs_init\n", $data->{afs_init};
printf "\t%10d gop_rdwr\n", $data->{gop_rdwr};
printf "\t%10d aix_gnode_rele\n", $data->{aix_gnode_rele};
printf "\t%10d gettimeofday\n", $data->{gettimeofday};
printf "\t%10d m_cpytoc\n", $data->{m_cpytoc};
printf "\t%10d aix_vattr_null\n", $data->{aix_vattr_null};
printf "\t%10d afs_gn_frunc\n", $data->{afs_gn_ftrunc};
printf "\t%10d afs_gn_rdwr\n", $data->{afs_gn_rdwr};
printf "\t%10d afs_gn_ioctl\n", $data->{afs_gn_ioctl};
printf "\t%10d afs_gn_locktl\n", $data->{afs_gn_lockctl};
printf "\t%10d afs_gn_readlink\n", $data->{afs_gn_readlink};
printf "\t%10d afs_gn_readdir\n", $data->{afs_gn_readdir};
printf "\t%10d afs_gn_select\n", $data->{afs_gn_select};
printf "\t%10d afs_gn_strategy\n", $data->{afs_gn_strategy};
printf "\t%10d afs_gn_symlink\n", $data->{afs_gn_symlink};
printf "\t%10d afs_gn_revoke\n", $data->{afs_gn_revoke};
printf "\t%10d afs_gn_link\n", $data->{afs_gn_link};
printf "\t%10d afs_gn_mkdir\n", $data->{afs_gn_mkdir};
printf "\t%10d afs_gn_mknod\n", $data->{afs_gn_mknod};
printf "\t%10d afs_gn_remove\n", $data->{afs_gn_remove};
printf "\t%10d afs_gn_rename\n", $data->{afs_gn_rename};
printf "\t%10d afs_gn_rmdir\n", $data->{afs_gn_rmdir};
printf "\t%10d afs_gn_fid\n", $data->{afs_gn_fid};
printf "\t%10d afs_gn_lookup\n", $data->{afs_gn_lookup};
printf "\t%10d afs_gn_open\n", $data->{afs_gn_open};
printf "\t%10d afs_gn_create\n", $data->{afs_gn_create};
printf "\t%10d afs_gn_hold\n", $data->{afs_gn_hold};
printf "\t%10d afs_gn_rele\n", $data->{afs_gn_rele};
printf "\t%10d afs_gn_unmap\n", $data->{afs_gn_unmap};
printf "\t%10d afs_gn_access\n", $data->{afs_gn_access};
printf "\t%10d afs_gn_getattr\n", $data->{afs_gn_getattr};
printf "\t%10d afs_gn_setattr\n", $data->{afs_gn_setattr};
printf "\t%10d afs_gn_fclear\n", $data->{afs_gn_fclear};
printf "\t%10d afs_gn_fsync\n", $data->{afs_gn_fsync};
printf "\t%10d phash\n", $data->{pHash};
printf "\t%10d DInit\n", $data->{DInit};
printf "\t%10d DRead\n", $data->{DRead};
printf "\t%10d FixupBucket\n", $data->{FixupBucket};
printf "\t%10d afs_newslot\n", $data->{afs_newslot};
printf "\t%10d DRelease\n", $data->{DRelease};
printf "\t%10d DFlush\n", $data->{DFlush};
printf "\t%10d DFlushEntry\n", $data->{DFlushEntry};
printf "\t%10d DVOffset\n", $data->{DVOffset};
printf "\t%10d DZap\n", $data->{DZap};
printf "\t%10d DNew\n", $data->{DNew};
printf "\t%10d afs_RemoveVCB\n", $data->{afs_RemoveVCB};
printf "\t%10d afs_NewVCache\n", $data->{afs_NewVCache};
printf "\t%10d afs_FlushActiveVcaches\n", $data->{afs_FlushActiveVcaches};
printf "\t%10d afs_VerifyVCache\n", $data->{afs_VerifyVCache};
printf "\t%10d afs_WriteVCache\n", $data->{afs_WriteVCache};
printf "\t%10d afs_GetVCache\n", $data->{afs_GetVCache};
printf "\t%10d afs_StuffVcache\n", $data->{afs_StuffVcache};
printf "\t%10d afs_FindVCache\n", $data->{afs_FindVCache};
printf "\t%10d afs_PutDCache\n", $data->{afs_PutDCache};
printf "\t%10d afs_PutVCache\n", $data->{afs_PutVCache};
printf "\t%10d CacheStoreProc\n", $data->{CacheStoreProc};
printf "\t%10d afs_FindDcache\n", $data->{afs_FindDCache};
printf "\t%10d afs_TryToSmush\n", $data->{afs_TryToSmush};
printf "\t%10d afs_AdjustSize\n", $data->{afs_AdjustSize};
printf "\t%10d afs_CheckSize\n", $data->{afs_CheckSize};
printf "\t%10d afs_StoreWarn\n", $data->{afs_StoreWarn};
printf "\t%10d CacheFetchProc\n", $data->{CacheFetchProc};
printf "\t%10d UFS_CacheStoreProc\n", $data->{UFS_CacheStoreProc};
printf "\t%10d UFS_CacheFetchProc\n", $data->{UFS_CacheFetchProc};
printf "\t%10d afs_GetDCache\n", $data->{afs_GetDCache};
printf "\t%10d afs_SimpleVStat\n", $data->{afs_SimpleVStat};
printf "\t%10d afs_ProcessFS\n", $data->{afs_ProcessFS};
printf "\t%10d afs_InitCacheInfo\n", $data->{afs_InitCacheInfo};
printf "\t%10d afs_InitVolumeInfo\n", $data->{afs_InitVolumeInfo};
printf "\t%10d afs_InitCacheFile\n", $data->{afs_InitCacheFile};
printf "\t%10d afs_CacheInit\n", $data->{afs_CacheInit};
printf "\t%10d afs_GetDSlot\n", $data->{afs_GetDSlot};
printf "\t%10d afs_WriteThroughDSlots\n", $data->{afs_WriteThroughDSlots};
printf "\t%10d afs_MemGetDSlot\n", $data->{afs_MemGetDSlot};
printf "\t%10d afs_UFSGetDSlot\n", $data->{afs_UFSGetDSlot};
printf "\t%10d afs_StoreDCache\n", $data->{afs_StoreDCache};
printf "\t%10d afs_StoreMini\n", $data->{afs_StoreMini};
printf "\t%10d afs_StoreAllSegments\n", $data->{afs_StoreAllSegments};
printf "\t%10d afs_InvalidateAllSegments\n", $data->{afs_InvalidateAllSegments};
printf "\t%10d afs_TruncateAllSegments\n", $data->{afs_TruncateAllSegments};
printf "\t%10d afs_CheckVolSync\n", $data->{afs_CheckVolSync};
printf "\t%10d afs_wakeup\n", $data->{afs_wakeup};
printf "\t%10d afs_CFileOpen\n", $data->{afs_CFileOpen};
printf "\t%10d afs_CFileTruncate\n", $data->{afs_CFileTruncate};
printf "\t%10d afs_GetDownD\n", $data->{afs_GetDownD};
printf "\t%10d afs_WriteDCache\n", $data->{afs_WriteDCache};
printf "\t%10d afs_FlushDCache\n", $data->{afs_FlushDCache};
printf "\t%10d afs_GetDownDSlot\n", $data->{afs_GetDownDSlot};
printf "\t%10d afs_FlushVCache\n", $data->{afs_FlushVCache};
printf "\t%10d afs_GetDownV\n", $data->{afs_GetDownV};
printf "\t%10d afs_QueueVCB\n", $data->{afs_QueueVCB};
printf "\t%10d afs_call\n", $data->{afs_call};
printf "\t%10d afs_syscall_call\n", $data->{afs_syscall_call};
printf "\t%10d afs_syscall_icreate\n", $data->{afs_syscall_icreate};
printf "\t%10d afs_syscall_iopen\n", $data->{afs_syscall_iopen};
printf "\t%10d afs_syscall_iincdec\n", $data->{afs_syscall_iincdec};
printf "\t%10d afs_syscall_ireadwrite\n", $data->{afs_syscall_ireadwrite};
printf "\t%10d afs_syscall\n", $data->{afs_syscall};
printf "\t%10d lpioctl\n", $data->{lpioctl};
printf "\t%10d lsetpag\n", $data->{lsetpag};
printf "\t%10d afs_CheckInit\n", $data->{afs_CheckInit};
printf "\t%10d ClearCallback\n", $data->{ClearCallBack};
printf "\t%10d SRXAFSCB_GetCE\n", $data->{SRXAFSCB_GetCE};
printf "\t%10d SRXAFSCB_GetLock\n", $data->{SRXAFSCB_GetLock};
printf "\t%10d SRXAFSCB_CallBack\n", $data->{SRXAFSCB_CallBack};
printf "\t%10d SRXAFSCB_InitCallBackState\n", $data->{SRXAFSCB_InitCallBackState};
printf "\t%10d SRXAFSCB_Probe\n", $data->{SRXAFSCB_Probe};
printf "\t%10d afs_Chunk\n", $data->{afs_Chunk};
printf "\t%10d afs_ChunkBase\n", $data->{afs_ChunkBase};
printf "\t%10d afs_ChunkOffset\n", $data->{afs_ChunkOffset};
printf "\t%10d afs_ChunkSize\n", $data->{afs_ChunkSize};
printf "\t%10d afs_ChunkToBase\n", $data->{afs_ChunkToBase};
printf "\t%10d afs_ChunkToSize\n", $data->{afs_ChunkToSize};
printf "\t%10d afs_SetChunkSize\n", $data->{afs_SetChunkSize};
printf "\t%10d afs_config\n", $data->{afs_config};
printf "\t%10d mem_freebytes\n", $data->{mem_freebytes};
printf "\t%10d mem_getbytes\n", $data->{mem_getbytes};
printf "\t%10d afs_Daemon\n", $data->{afs_Daemon};
printf "\t%10d afs_CheckRootVolume\n", $data->{afs_CheckRootVolume};
printf "\t%10d BPath\n", $data->{BPath};
printf "\t%10d BPrefetch\n", $data->{BPrefetch};
printf "\t%10d BStore\n", $data->{BStore};
printf "\t%10d afs_BBusy\n", $data->{afs_BBusy};
printf "\t%10d afs_BQueue\n", $data->{afs_BQueue};
printf "\t%10d afs_BRelease\n", $data->{afs_BRelease};
printf "\t%10d afs_BackgroundDaemon\n", $data->{afs_BackgroundDaemon};
printf "\t%10d exporter_add\n", $data->{exporter_add};
printf "\t%10d exporter_find\n", $data->{exporter_find};
printf "\t%10d afs_gfs_kalloc\n", $data->{afs_gfs_kalloc};
printf "\t%10d afs_gfs_kfree\n", $data->{afs_gfs_kfree};
printf "\t%10d gop_lookupname\n", $data->{gop_lookupname};
printf "\t%10d afs_uniqtime\n", $data->{afs_uniqtime};
printf "\t%10d gfs_vattr_null\n", $data->{gfs_vattr_null};
printf "\t%10d afs_lock\n", $data->{afs_lock};
printf "\t%10d afs_unlock\n", $data->{afs_unlock};
printf "\t%10d afs_update\n", $data->{afs_update};
printf "\t%10d afs_gclose\n", $data->{afs_gclose};
printf "\t%10d afs_gopen\n", $data->{afs_gopen};
printf "\t%10d afs_greadlink\n", $data->{afs_greadlink};
printf "\t%10d afs_select\n", $data->{afs_select};
printf "\t%10d afs_gbmap\n", $data->{afs_gbmap};
printf "\t%10d afs_getfsdata\n", $data->{afs_getfsdata};
printf "\t%10d afs_gsymlink\n", $data->{afs_gsymlink};
printf "\t%10d afs_namei\n", $data->{afs_namei};
printf "\t%10d afs_gmount\n", $data->{afs_gmount};
printf "\t%10d afs_gget\n", $data->{afs_gget};
printf "\t%10d afs_glink\n", $data->{afs_glink};
printf "\t%10d afs_gmkdir\n", $data->{afs_gmkdir};
printf "\t%10d afs_unlink\n", $data->{afs_unlink};
printf "\t%10d afs_grmdir\n", $data->{afs_grmdir};
printf "\t%10d afs_makenode\n", $data->{afs_makenode};
printf "\t%10d afs_grename\n", $data->{afs_grename};
printf "\t%10d afs_rele\n", $data->{afs_rele};
printf "\t%10d afs_syncgp\n", $data->{afs_syncgp};
printf "\t%10d afs_getval\n", $data->{afs_getval};
printf "\t%10d afs_trunc\n", $data->{afs_trunc};
printf "\t%10d afs_rwgp\n", $data->{afs_rwgp};
printf "\t%10d afs_stat\n", $data->{afs_stat};
printf "\t%10d afsc_link\n", $data->{afsc_link};
printf "\t%10d afs_vfs_mount\n", $data->{afs_vfs_mount};
printf "\t%10d afs_uniqtime\n", $data->{afs_uniqtime};
printf "\t%10d iopen\n", $data->{iopen};
printf "\t%10d idec\n", $data->{idec};
printf "\t%10d iinc\n", $data->{iinc};
printf "\t%10d ireadwrite\n", $data->{ireadwrite};
printf "\t%10d iread\n", $data->{iread};
printf "\t%10d iwrite\n", $data->{iwrite};
printf "\t%10d iforget\n", $data->{iforget};
printf "\t%10d icreate\n", $data->{icreate};
printf "\t%10d igetinode\n", $data->{igetinode};
printf "\t%10d osi_SleepR\n", $data->{osi_SleepR};
printf "\t%10d osi_SleepS\n", $data->{osi_SleepS};
printf "\t%10d osi_SleepW\n", $data->{osi_SleepW};
printf "\t%10d osi_Sleep\n", $data->{osi_Sleep};
printf "\t%10d afs_LookupMCE\n", $data->{afs_LookupMCE};
printf "\t%10d afs_MemReadBlk\n", $data->{afs_MemReadBlk};
printf "\t%10d afs_MemReadUIO\n", $data->{afs_MemReadUIO};
printf "\t%10d afs_MemWriteBlk\n", $data->{afs_MemWriteBlk};
printf "\t%10d afs_MemWriteUIO\n", $data->{afs_MemWriteUIO};
printf "\t%10d afs_MemCacheStoreProc\n", $data->{afs_MemCacheStoreProc};
printf "\t%10d afs_MemCacheFetchProc\n", $data->{afs_MemCacheFetchProc};
printf "\t%10d afs_MemCacheTruncate\n", $data->{afs_MemCacheTruncate};
printf "\t%10d afs_MemCacheStoreProc\n", $data->{afs_MemCacheStoreProc};
printf "\t%10d afs_GetNfsClientPag\n", $data->{afs_GetNfsClientPag};
printf "\t%10d afs_FindNfsClientPag\n", $data->{afs_FindNfsClientPag};
printf "\t%10d afs_PutNfsClientPag\n", $data->{afs_PutNfsClientPag};
printf "\t%10d afs_nfsclient_reqhandler\n", $data->{afs_nfsclient_reqhandler};
printf "\t%10d afs_nfsclient_GC\n", $data->{afs_nfsclient_GC};
printf "\t%10d afs_nfsclient_hold\n", $data->{afs_nfsclient_hold};
printf "\t%10d afs_nfsclient_stats\n", $data->{afs_nfsclient_stats};
printf "\t%10d afs_nfsclient_sysname\n", $data->{afs_nfsclient_sysname};
printf "\t%10d afs_rfs_dispatch\n", $data->{afs_rfs_dispatch};
printf "\t%10d afs_nfs2afscall\n", $data->{Nfs2AfsCall};
printf "\t%10d afs_sun_xuntext\n", $data->{afs_sun_xuntext};
printf "\t%10d osi_Active\n", $data->{osi_Active};
printf "\t%10d osi_FlushPages\n", $data->{osi_FlushPages};
printf "\t%10d osi_FlushText\n", $data->{osi_FlushText};
printf "\t%10d osi_CallProc\n", $data->{osi_CallProc};
printf "\t%10d osi_CancelProc\n", $data->{osi_CancelProc};
printf "\t%10d osi_Invisible\n", $data->{osi_Invisible};
printf "\t%10d osi_Time\n", $data->{osi_Time};
printf "\t%10d osi_Alloc\n", $data->{osi_Alloc};
printf "\t%10d osi_SetTime\n", $data->{osi_SetTime};
printf "\t%10d osi_Dump\n", $data->{osi_Dump};
printf "\t%10d osi_Free\n", $data->{osi_Free};
printf "\t%10d osi_UFSOpen\n", $data->{osi_UFSOpen};
printf "\t%10d osi_Close\n", $data->{osi_Close};
printf "\t%10d osi_Stat\n", $data->{osi_Stat};
printf "\t%10d osi_Truncate\n", $data->{osi_Truncate};
printf "\t%10d osi_Read\n", $data->{osi_Read};
printf "\t%10d osi_Write\n", $data->{osi_Write};
printf "\t%10d osi_MapStrategy\n", $data->{osi_MapStrategy};
printf "\t%10d osi_AllocLargeSpace\n", $data->{osi_AllocLargeSpace};
printf "\t%10d osi_FreeLargeSpace\n", $data->{osi_FreeLargeSpace};
printf "\t%10d osi_AllocSmallSpace\n", $data->{osi_AllocSmallSpace};
printf "\t%10d osi_FreeSmallSpace\n", $data->{osi_FreeSmallSpace};
printf "\t%10d osi_CloseToTheEdge\n", $data->{osi_CloseToTheEdge};
printf "\t%10d osi_xgreedy\n", $data->{osi_xgreedy};
printf "\t%10d osi_FreeSocket\n", $data->{osi_FreeSocket};
printf "\t%10d osi_NewSocket\n", $data->{osi_NewSocket};
printf "\t%10d osi_NetSend\n", $data->{osi_NetSend};
printf "\t%10d WaitHack\n", $data->{WaitHack};
printf "\t%10d osi_CancelWait\n", $data->{osi_CancelWait};
printf "\t%10d osi_Wakeup\n", $data->{osi_Wakeup};
printf "\t%10d osi_Wait\n", $data->{osi_Wait};
printf "\t%10d dirp_Read\n", $data->{dirp_Read};
printf "\t%10d dirp_Cpy\n", $data->{dirp_Cpy};
printf "\t%10d dirp_Eq\n", $data->{dirp_Eq};
printf "\t%10d dirp_Write\n", $data->{dirp_Write};
printf "\t%10d dirp_Zap\n", $data->{dirp_Zap};
printf "\t%10d afs_ioctl\n", $data->{afs_ioctl};
printf "\t%10d handleIoctl\n", $data->{HandleIoctl};
printf "\t%10d afs_xioctl\n", $data->{afs_xioctl};
printf "\t%10d afs_pioctl\n", $data->{afs_pioctl};
printf "\t%10d HandlePioctl\n", $data->{HandlePioctl};
printf "\t%10d PGetVolumeStatus\n", $data->{PGetVolumeStatus};
printf "\t%10d PSetVolumeStatus\n", $data->{PSetVolumeStatus};
printf "\t%10d PFlush\n", $data->{PFlush};
printf "\t%10d PFlushVolumeData\n", $data->{PFlushVolumeData};
printf "\t%10d PNewStatMount\n", $data->{PNewStatMount};
printf "\t%10d PGetTokens\n", $data->{PGetTokens};
printf "\t%10d PSetTokens\n", $data->{PSetTokens};
printf "\t%10d PUnlog\n", $data->{PUnlog};
printf "\t%10d PCheckServers\n", $data->{PCheckServers};
printf "\t%10d PCheckAuth\n", $data->{PCheckAuth};
printf "\t%10d PCheckVolNames\n", $data->{PCheckVolNames};
printf "\t%10d PFindVolume\n", $data->{PFindVolume};
printf "\t%10d Prefetch\n", $data->{Prefetch};
printf "\t%10d PGetCacheSize\n", $data->{PGetCacheSize};
printf "\t%10d PSetCacheSize\n", $data->{PSetCacheSize};
printf "\t%10d PSetSysName\n", $data->{PSetSysName};
printf "\t%10d PExportAfs\n", $data->{PExportAfs};
printf "\t%10d HandleClientContext\n", $data->{HandleClientContext};
printf "\t%10d PViceAccess\n", $data->{PViceAccess};
printf "\t%10d PRemoveCallBack\n", $data->{PRemoveCallBack};
printf "\t%10d PRemoveMount\n", $data->{PRemoveMount};
printf "\t%10d PSetVolumeStatus\n", $data->{PSetVolumeStatus};
printf "\t%10d PListCells\n", $data->{PListCells};
printf "\t%10d PNewCell\n", $data->{PNewCell};
printf "\t%10d PGetUserCell\n", $data->{PGetUserCell};
printf "\t%10d PGetCellStatus\n", $data->{PGetCellStatus};
printf "\t%10d PSetCellStatus\n", $data->{PSetCellStatus};
printf "\t%10d PVenusLogging\n", $data->{PVenusLogging};
printf "\t%10d PGetAcl\n", $data->{PGetAcl};
printf "\t%10d PGetFID\n", $data->{PGetFID};
printf "\t%10d PSetAcl\n", $data->{PSetAcl};
printf "\t%10d PGetFileCell\n", $data->{PGetFileCell};
printf "\t%10d PGetWSCell\n", $data->{PGetWSCell};
printf "\t%10d PGetSPrefs\n", $data->{PGetSPrefs};
printf "\t%10d PSetSPrefs\n", $data->{PSetSPrefs};
printf "\t%10d afs_ResetAccessCache\n", $data->{afs_ResetAccessCache};
printf "\t%10d afs_FindUser\n", $data->{afs_FindUser};
printf "\t%10d afs_GetUser\n", $data->{afs_GetUser};
printf "\t%10d afs_GCUserData\n", $data->{afs_GCUserData};
printf "\t%10d afs_PutUser\n", $data->{afs_PutUser};
printf "\t%10d afs_SetPrimary\n", $data->{afs_SetPrimary};
printf "\t%10d afs_ResetUserConns\n", $data->{afs_ResetUserConns};
printf "\t%10d afs_RemoveUserConns\n", $data->{RemoveUserConns};
printf "\t%10d afs_ResourceInit\n", $data->{afs_ResourceInit};
printf "\t%10d afs_GetCell\n", $data->{afs_GetCell};
printf "\t%10d afs_GetCellByIndex\n", $data->{afs_GetCellByIndex};
printf "\t%10d afs_GetCellByName\n", $data->{afs_GetCellByName};
if (exists $data->{afs_GetRealCellByIndex}) {
printf "\t%10d afs_GetRealCellByIndex\n", $data->{afs_GetRealCellByIndex};
}
printf "\t%10d afs_NewCell\n", $data->{afs_NewCell};
printf "\t%10d CheckVLDB\n", $data->{CheckVLDB};
printf "\t%10d afs_GetVolume\n", $data->{afs_GetVolume};
printf "\t%10d afs_PutVolume\n", $data->{afs_PutVolume};
printf "\t%10d afs_GetVolumeByName\n", $data->{afs_GetVolumeByName};
printf "\t%10d afs_random\n", $data->{afs_random};
printf "\t%10d InstallVolumeEntry\n", $data->{InstallVolumeEntry};
printf "\t%10d InstallVolumeInfo\n", $data->{InstallVolumeInfo};
printf "\t%10d afs_ResetVolumeInfo\n", $data->{afs_ResetVolumeInfo};
printf "\t%10d afs_FindServer\n", $data->{afs_FindServer};
printf "\t%10d afs_GetServer\n", $data->{afs_GetServer};
printf "\t%10d afs_SortServers\n", $data->{afs_SortServers};
printf "\t%10d afs_CheckServers\n", $data->{afs_CheckServers};
printf "\t%10d ServerDown\n", $data->{ServerDown};
printf "\t%10d afs_Conn\n", $data->{afs_Conn};
printf "\t%10d afs_PutConn\n", $data->{afs_PutConn};
printf "\t%10d afs_ConnByHost\n", $data->{afs_ConnByHost};
printf "\t%10d afs_ConnByMHosts\n", $data->{afs_ConnByMHosts};
printf "\t%10d afs_Analyze\n", $data->{afs_Analyze};
printf "\t%10d afs_CheckLocks\n", $data->{afs_CheckLocks};
printf "\t%10d CheckVLServer\n", $data->{CheckVLServer};
printf "\t%10d afs_CheckCacheResets\n", $data->{afs_CheckCacheResets};
printf "\t%10d afs_CheckVolumeNames\n", $data->{afs_CheckVolumeNames};
printf "\t%10d afs_CheckCode\n", $data->{afs_CheckCode};
printf "\t%10d afs_CopyError\n", $data->{afs_CopyError};
printf "\t%10d afs_FinalizeReq\n", $data->{afs_FinalizeReq};
printf "\t%10d afs_GetVolCache\n", $data->{afs_GetVolCache};
printf "\t%10d afs_GetVolSlot\n", $data->{afs_GetVolSlot};
printf "\t%10d afs_UFSGetVolSlot\n", $data->{afs_UFSGetVolSlot};
printf "\t%10d afs_MemGetVolSlot\n", $data->{afs_MemGetVolSlot};
printf "\t%10d afs_WriteVolCache\n", $data->{afs_WriteVolCache};
printf "\t%10d haveCallbacksfrom\n", $data->{HaveCallBacksFrom};
printf "\t%10d afs_getpage\n", $data->{afs_getpage};
printf "\t%10d afs_putpage\n", $data->{afs_putpage};
printf "\t%10d afs_nfsrdwr\n", $data->{afs_nfsrdwr};
printf "\t%10d afs_map\n", $data->{afs_map};
printf "\t%10d afs_cmp\n", $data->{afs_cmp};
printf "\t%10d afs_PageLeft\n", $data->{afs_PageLeft};
printf "\t%10d afs_mount\n", $data->{afs_mount};
printf "\t%10d afs_unmount\n", $data->{afs_unmount};
printf "\t%10d afs_root\n", $data->{afs_root};
printf "\t%10d afs_statfs\n", $data->{afs_statfs};
printf "\t%10d afs_sync\n", $data->{afs_sync};
printf "\t%10d afs_vget\n", $data->{afs_vget};
printf "\t%10d afs_index\n", $data->{afs_index};
printf "\t%10d afs_setpag\n", $data->{afs_setpag};
printf "\t%10d genpag\n", $data->{genpag};
printf "\t%10d getpag\n", $data->{getpag};
printf "\t%10d afs_GetMariner\n", $data->{afs_GetMariner};
printf "\t%10d afs_AddMarinerName\n", $data->{afs_AddMarinerName};
printf "\t%10d afs_open\n", $data->{afs_open};
printf "\t%10d afs_close\n", $data->{afs_close};
printf "\t%10d afs_closex\n", $data->{afs_closex};
printf "\t%10d afs_write\n", $data->{afs_write};
printf "\t%10d afs_UFSwrite\n", $data->{afs_UFSWrite};
printf "\t%10d afs_Memwrite\n", $data->{afs_MemWrite};
printf "\t%10d afs_rdwr\n", $data->{afs_rdwr};
printf "\t%10d afs_read\n", $data->{afs_read};
printf "\t%10d afs_UFSread\n", $data->{afs_UFSRead};
printf "\t%10d afs_Memread\n", $data->{afs_MemRead};
printf "\t%10d afs_CopyOutAttrs\n", $data->{afs_CopyOutAttrs};
printf "\t%10d afs_access\n", $data->{afs_access};
printf "\t%10d afs_getattr\n", $data->{afs_getattr};
printf "\t%10d afs_setattr\n", $data->{afs_setattr};
printf "\t%10d afs_VAttrToAS\n", $data->{afs_VAttrToAS};
printf "\t%10d EvalMountPoint\n", $data->{EvalMountPoint};
printf "\t%10d afs_lookup\n", $data->{afs_lookup};
printf "\t%10d afs_create\n", $data->{afs_create};
printf "\t%10d afs_LocalHero\n", $data->{afs_LocalHero};
printf "\t%10d afs_remove\n", $data->{afs_remove};
printf "\t%10d afs_link\n", $data->{afs_link};
printf "\t%10d afs_rename\n", $data->{afs_rename};
printf "\t%10d afs_InitReq\n", $data->{afs_InitReq};
printf "\t%10d afs_mkdir\n", $data->{afs_mkdir};
printf "\t%10d afs_rmdir\n", $data->{afs_rmdir};
printf "\t%10d afs_readdir\n", $data->{afs_readdir};
printf "\t%10d afs_read1dir\n", $data->{afs_read1dir};
printf "\t%10d afs_readdir_move\n", $data->{afs_readdir_move};
printf "\t%10d afs_readdir_iter\n", $data->{afs_readdir_iter};
printf "\t%10d afs_symlink\n", $data->{afs_symlink};
printf "\t%10d afs_HandleLink\n", $data->{afs_HandleLink};
printf "\t%10d afs_MemHandleLink\n", $data->{afs_MemHandleLink};
printf "\t%10d afs_UFSHandleLink\n", $data->{afs_UFSHandleLink};
printf "\t%10d HandleFlock\n", $data->{HandleFlock};
printf "\t%10d afs_readlink\n", $data->{afs_readlink};
printf "\t%10d afs_fsync\n", $data->{afs_fsync};
printf "\t%10d afs_inactive\n", $data->{afs_inactive};
printf "\t%10d afs_ustrategy\n", $data->{afs_ustrategy};
printf "\t%10d afs_strategy\n", $data->{afs_strategy};
printf "\t%10d afs_bread\n", $data->{afs_bread};
printf "\t%10d afs_brelse\n", $data->{afs_brelse};
printf "\t%10d afs_bmap\n", $data->{afs_bmap};
printf "\t%10d afs_fid\n", $data->{afs_fid};
printf "\t%10d afs_FakeOpen\n", $data->{afs_FakeOpen};
printf "\t%10d afs_FakeClose\n", $data->{afs_FakeClose};
printf "\t%10d afs_StoreOnLastReference\n", $data->{afs_StoreOnLastReference};
printf "\t%10d afs_AccessOK\n", $data->{afs_AccessOK};
printf "\t%10d afs_GetAccessBits\n", $data->{afs_GetAccessBits};
printf "\t%10d afsio_copy\n", $data->{afsio_copy};
printf "\t%10d afsio_trim\n", $data->{afsio_trim};
printf "\t%10d afsio_skip\n", $data->{afsio_skip};
printf "\t%10d afs_page_read\n", $data->{afs_page_read};
printf "\t%10d afs_page_write\n", $data->{afs_page_write};
printf "\t%10d afs_page_read\n", $data->{afs_page_read};
printf "\t%10d afs_get_groups_from_pag\n", $data->{afs_get_groups_from_pag};
printf "\t%10d afs_get_pag_from_groups\n", $data->{afs_get_pag_from_groups};
printf "\t%10d AddPag\n", $data->{AddPag};
printf "\t%10d PagInCred\n", $data->{PagInCred};
printf "\t%10d afs_getgroups\n", $data->{afs_getgroups};
printf "\t%10d afs_page_in\n", $data->{afs_page_in};
printf "\t%10d afs_page_out\n", $data->{afs_page_out};
printf "\t%10d afs_AdvanceFD\n", $data->{afs_AdvanceFD};
printf "\t%10d afs_lockf\n", $data->{afs_lockf};
printf "\t%10d afs_xsetgroups\n", $data->{afs_xsetgroups};
printf "\t%10d afs_nlinks\n", $data->{afs_nlinks};
printf "\t%10d afs_lockctl\n", $data->{afs_lockctl};
printf "\t%10d afs_xflock\n", $data->{afs_xflock};
printf "\t%10d PGetCPrefs\n", $data->{PGetCPrefs};
printf "\t%10d PSetCPrefs\n", $data->{PSetCPrefs};
if (exists $host->{afs_pagein}) {
printf "\t%10d afs_pagein\n", $data->{afs_pagein};
printf "\t%10d afs_pageout\n", $data->{afs_pageout};
printf "\t%10d afs_hp_strategy\n", $data->{afs_hp_strategy};
}
printf "\t%10d PFlushMount\n", $data->{PFlushMount};
}
examples/xstat_fs_test view on Meta::CPAN
$tests[1] = 0; # test of fsname @fsname and collIDs @collID
$tests[2] = 0; # test of fsname but no collID
$tests[3] = 1; # test of single fsname with collID 0
$tests[4] = 1; # test of single fsname with collID 1
$tests[5] = 0; # test of single fsname with collID 2
$tests[6] = 1; # test of single fsname with collID 3
$tests[7] = 0; # test of single fsname but no single collID
my $all = 0;
my $showdump = 0; # print entire contents of hash for each test
my $formatted = 1; # print formatted like original xstat_fs_test program
print "# Starting now... #\n";
my $result;
if ($all || $tests[1]) {
print "\n******** TEST 1: ********\n";
print "\nxstat_fs_test -fsname ", join(" ", @fsname),
" -collID ", join(" ", @collID), "\n\n";
$result = xstat_fs_test(fsname => \@fsname,
collID => \@collID);
parse_result($result);
}
if ($all || $tests[2]) {
print "\n******** TEST 2: ********\n";
print "\nxstat_fs_test -fsname ", join(" ", @fsname), "\n\n";
$result = xstat_fs_test(fsname => \@fsname);
parse_result($result);
}
if ($all || $tests[3]) {
print "\n******** TEST 3: ********\n";
print "\nxstat_fs_test -fsname ", $fsname[0],
" -collID 0\n\n";
$result = xstat_fs_test(fsname => $fsname[0],
collID => 0);
parse_result($result);
}
if ($all || $tests[4]) {
print "\n******** TEST 4: ********\n";
print "\nxstat_fs_test -fsname ", $fsname[0],
" -collID 1\n\n";
$result = xstat_fs_test(fsname => $fsname[0],
collID => 1);
parse_result($result);
}
if ($all || $tests[5]) {
print "\n******** TEST 5: ********\n";
print "\nxstat_fs_test -fsname ", $fsname[0],
" -collID 2\n\n";
$result = xstat_fs_test(fsname => $fsname[0],
collID => 2);
parse_result($result);
}
if ($all || $tests[6]) {
print "\n******** TEST 6: ********\n";
print "\nxstat_fs_test -fsname ", $fsname[0],
" -collID 3\n\n";
$result = xstat_fs_test(fsname => $fsname[0],
collID => 3);
parse_result($result);
}
if ($all || $tests[7]) {
print "\n******** TEST 7: ********\n";
print "\nxstat_fs_test -fsname ", $fsname[0], "\n\n";
$result = xstat_fs_test(fsname => $fsname[0]);
parse_result($result);
}
sub parse_result {
my $info = shift;
if ($AFS::CODE) {
print "Error case: ", ref($info), "\n" if (defined($info));
# die("Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n");
print "Error: AFS::CODE = $AFS::CODE (", ($AFS::CODE+0), ")\n";
return;
}
if ($showdump) {
local $Data::Dumper::Quotekeys = 0;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Varname = "xstat_fs_test";
local $Data::Dumper::Maxdepth = 2;
print Dumper($info);
}
if ($formatted) {
foreach my $host (@$info) {
print "\n------------------------------------------------------------\n";
if ($host->{probeOK} == 0) {
printf "FS_Handler: Probe 1 to File Server '$host->{hostName}' failed\n",
} elsif($host->{collectionNumber} == constant("AFS_XSTATSCOLL_CALL_INFO")) {
parse_CallInfo($host);
} elsif($host->{collectionNumber} == constant("AFS_XSTATSCOLL_PERF_INFO")) {
parse_PerfInfo($host);
} elsif($host->{collectionNumber} == constant("AFS_XSTATSCOLL_FULL_PERF_INFO")) {
parse_FullPerfInfo($host);
} elsif($host->{collectionNumber} == constant("AFS_XSTATSCOLL_CBSTATS")) {
parse_CbCounters($host);
} else {
print "Unknown collection: $host->{collectionNumber}\n";
}
}
}
}
sub parse_CallInfo {
my $host = shift;
printf("AFS_XSTATSCOLL_CALL_INFO (coll %d) for FS %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime $host->{probeTime});
for (my $i = 0; $i < $host->{data}->{AFS_CollData_len}; $i++) {
print $host->{i}, " ";
}
print "\n";
}
sub parse_PerfInfo {
my $host = shift;
printf("AFS_XSTATSCOLL_PERF_INFO (coll %d) for FS %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime($host->{probeTime}));
parse_OverallPerfInfo($host->{data});
}
sub parse_FullPerfInfo {
my $host = shift;
printf("AFS_XSTATSCOLL_FULL_PERF_INFO (coll %d) for FS %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime($host->{probeTime}));
parse_OverallPerfInfo($host->{data});
parse_DetailedPerfInfo($host->{data});
}
sub parse_OverallPerfInfo {
my $data = shift;
printf "\t%10d numPerfCalls\n\n", $data->{numPerfCalls};
printf "\t%10d vcache_L_Entries\n", $data->{vcache_L_Entries};
printf "\t%10d vcache_L_Allocs\n", $data->{vcache_L_Allocs};
printf "\t%10d vcache_L_Gets\n", $data->{vcache_L_Gets};
printf "\t%10d vcache_L_Reads\n", $data->{vcache_L_Reads};
printf "\t%10d vcache_L_Writes\n\n", $data->{vcache_L_Writes};
printf "\t%10d vcache_S_Entries\n", $data->{vcache_S_Entries};
printf "\t%10d vcache_S_Allocs\n", $data->{vcache_S_Allocs};
printf "\t%10d vcache_S_Gets\n", $data->{vcache_S_Gets};
printf "\t%10d vcache_S_Reads\n", $data->{vcache_S_Reads};
printf "\t%10d vcache_S_Writes\n\n", $data->{vcache_S_Writes};
printf "\t%10d vcache_H_Entries\n", $data->{vcache_H_Entries};
printf "\t%10d vcache_H_Gets\n", $data->{vcache_H_Gets};
printf "\t%10d vcache_H_Replacements\n\n", $data->{vcache_H_Replacements};
printf "\t%10d dir_Buffers\n", $data->{dir_Buffers};
printf "\t%10d dir_Calls\n", $data->{dir_Calls};
printf "\t%10d dir_IOs\n\n", $data->{dir_IOs};
printf "\t%10d rx_packetRequests\n", $data->{rx_packetRequests};
printf "\t%10d rx_noPackets_RcvClass\n", $data->{rx_noPackets_RcvClass};
printf "\t%10d rx_noPackets_SendClass\n", $data->{rx_noPackets_SendClass};
printf "\t%10d rx_noPackets_SpecialClass\n", $data->{rx_noPackets_SpecialClass};
printf "\t%10d rx_socketGreedy\n", $data->{rx_socketGreedy};
printf "\t%10d rx_bogusPacketOnRead\n", $data->{rx_bogusPacketOnRead};
printf "\t%10d rx_bogusHost\n", $data->{rx_bogusHost};
printf "\t%10d rx_noPacketOnRead\n", $data->{rx_noPacketOnRead};
printf "\t%10d rx_noPacketBuffersOnRead\n", $data->{rx_noPacketBuffersOnRead};
printf "\t%10d rx_selects\n", $data->{rx_selects};
printf "\t%10d rx_sendSelects\n", $data->{rx_sendSelects};
printf "\t%10d rx_packetsRead_RcvClass\n", $data->{rx_packetsRead_RcvClass};
printf "\t%10d rx_packetsRead_SendClass\n", $data->{rx_packetsRead_SendClass};
printf "\t%10d rx_packetsRead_SpecialClass\n", $data->{rx_packetsRead_SpecialClass};
printf "\t%10d rx_dataPacketsRead\n", $data->{rx_dataPacketsRead};
printf "\t%10d rx_ackPacketsRead\n", $data->{rx_ackPacketsRead};
printf "\t%10d rx_dupPacketsRead\n", $data->{rx_dupPacketsRead};
printf "\t%10d rx_spuriousPacketsRead\n", $data->{rx_spuriousPacketsRead};
printf "\t%10d rx_packetsSent_RcvClass\n", $data->{rx_packetsSent_RcvClass};
printf "\t%10d rx_packetsSent_SendClass\n", $data->{rx_packetsSent_SendClass};
printf "\t%10d rx_packetsSent_SpecialClass\n", $data->{rx_packetsSent_SpecialClass};
printf "\t%10d rx_ackPacketsSent\n", $data->{rx_ackPacketsSent};
printf "\t%10d rx_pingPacketsSent\n", $data->{rx_pingPacketsSent};
printf "\t%10d rx_abortPacketsSent\n", $data->{rx_abortPacketsSent};
printf "\t%10d rx_busyPacketsSent\n", $data->{rx_busyPacketsSent};
printf "\t%10d rx_dataPacketsSent\n", $data->{rx_dataPacketsSent};
printf "\t%10d rx_dataPacketsReSent\n", $data->{rx_dataPacketsReSent};
printf "\t%10d rx_dataPacketsPushed\n", $data->{rx_dataPacketsPushed};
printf "\t%10d rx_ignoreAckedPacket\n", $data->{rx_ignoreAckedPacket};
printf "\t%10d rx_totalRtt_Sec\n", $data->{rx_totalRtt_Sec};
printf "\t%10d rx_totalRtt_Usec\n", $data->{rx_totalRtt_Usec};
printf "\t%10d rx_minRtt_Sec\n", $data->{rx_minRtt_Sec};
printf "\t%10d rx_minRtt_Usec\n", $data->{rx_minRtt_Usec};
printf "\t%10d rx_maxRtt_Sec\n", $data->{rx_maxRtt_Sec};
printf "\t%10d rx_maxRtt_Usec\n", $data->{rx_maxRtt_Usec};
printf "\t%10d rx_nRttSamples\n", $data->{rx_nRttSamples};
printf "\t%10d rx_nServerConns\n", $data->{rx_nServerConns};
printf "\t%10d rx_nClientConns\n", $data->{rx_nClientConns};
printf "\t%10d rx_nPeerStructs\n", $data->{rx_nPeerStructs};
printf "\t%10d rx_nCallStructs\n", $data->{rx_nCallStructs};
printf "\t%10d rx_nFreeCallStructs\n", $data->{rx_nFreeCallStructs};
if (defined($data->{rx_nBusies})) { # only on OpenAFS-1.4.1
printf "\t%10d rx_nBusies\n\n", $data->{rx_nBusies};
printf "\t%10d fs_nBusies\n", $data->{fs_nBusies};
printf "\t%10d fs_GetCapabilities\n\n", $data->{fs_GetCapabilities};
}
printf "\t%10d host_NumHostEntries\n", $data->{host_NumHostEntries};
printf "\t%10d host_HostBlocks\n", $data->{host_HostBlocks};
printf "\t%10d host_NonDeletedHosts\n", $data->{host_NonDeletedHosts};
printf "\t%10d host_HostsInSameNetOrSubnet\n", $data->{host_HostsInSameNetOrSubnet};
printf "\t%10d host_HostsInDiffSubnet\n", $data->{host_HostsInDiffSubnet};
printf "\t%10d host_HostsInDiffNetwork\n", $data->{host_HostsInDiffNetwork};
printf "\t%10d host_NumClients\n", $data->{host_NumClients};
printf "\t%10d host_ClientBlocks\n\n", $data->{host_ClientBlocks};
printf "\t%10d sysname_ID\n", $data->{sysname_ID};
}
sub parse_DetailedPerfInfo {
my $data = shift;
printf "\t%10d epoch\n", $data->{epoch};
my $rpcop = $data->{rpcOpTimes};
parse_OpTiming("FetchData", $rpcop);
parse_OpTiming("FetchACL", $rpcop);
parse_OpTiming("FetchStatus", $rpcop);
parse_OpTiming("StoreData", $rpcop);
parse_OpTiming("StoreACL", $rpcop);
parse_OpTiming("StoreStatus", $rpcop);
parse_OpTiming("RemoveFile", $rpcop);
examples/xstat_fs_test view on Meta::CPAN
my $xferop = $data->{xferOpTimes};
parse_XferTiming("FetchData", $xferop);
parse_XferTiming("StoreData", $xferop);
}
sub parse_CbCounters {
my $host = shift;
printf("AFS_XSTATSCOLL_CBSTATS (coll %d) for FS %s\n[Probe 1, %s]\n\n",
$host->{collectionNumber},
$host->{hostName},
scalar localtime($host->{probeTime}));
printf "\t%10d DeleteFiles\n", $host->{CbCounters}->{DeleteFiles};
printf "\t%10d DeleteCallBacks\n", $host->{CbCounters}->{DeleteCallBacks};
printf "\t%10d BreakCallBacks\n", $host->{CbCounters}->{BreakCallBacks};
printf "\t%10d AddCallBack\n", $host->{CbCounters}->{AddCallBack};
printf "\t%10d GotSomeSpaces\n", $host->{CbCounters}->{GotSomeSpaces};
printf "\t%10d DeleteAllCallBacks\n", $host->{CbCounters}->{DeleteAllCallBacks};
printf "\t%10d nFEs\n", $host->{CbCounters}->{nFEs};
printf "\t%10d nCBs\n", $host->{CbCounters}->{nCBs};
printf "\t%10d nblks\n", $host->{CbCounters}->{nblks};
printf "\t%10d CBsTimedOut\n", $host->{CbCounters}->{CBsTimedOut};
printf "\t%10d nbreakers\n", $host->{CbCounters}->{nbreakers};
printf "\t%10d GSS1\n", $host->{CbCounters}->{GSS1};
printf "\t%10d GSS2\n", $host->{CbCounters}->{GSS2};
printf "\t%10d GSS3\n", $host->{CbCounters}->{GSS3};
printf "\t%10d GSS4\n", $host->{CbCounters}->{GSS4};
printf "\t%10d GSS5\n", $host->{CbCounters}->{GSS5};
}
sub parse_OpTiming {
my ($name, $rpcop) = @_;
printf("%15s: %d ops (%d OK); sum=%f, sqr=%f, min=%f, max=%f\n",
$name, $rpcop->{$name}->{numOps}, $rpcop->{$name}->{numSuccesses},
$rpcop->{$name}->{sumTime}, $rpcop->{$name}->{sqrTime},
$rpcop->{$name}->{minTime}, $rpcop->{$name}->{maxTime});
}
sub parse_XferTiming {
my ($name, $xferop) = @_;
printf("%s: %d xfers (%d OK), time sum=%f, sqr=%f, min=%f, max=%f\n",
$name, $xferop->{$name}->{numXfers}, $xferop->{$name}->{numSuccesses},
$xferop->{$name}->{sumTime}, $xferop->{$name}->{sqrTime},
$xferop->{$name}->{minTime}, $xferop->{$name}->{maxTime});
printf("\t[bytes: sum=%lu, min=%d, max=%d]\n",
$xferop->{$name}->{sumBytes},
$xferop->{$name}->{minBytes},
$xferop->{$name}->{maxBytes});
printf("\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d, 6: %d, 7: %d, 8: %d]\n",
$xferop->{$name}->{count}->[0],
$xferop->{$name}->{count}->[1],
$xferop->{$name}->{count}->[2],
$xferop->{$name}->{count}->[3],
$xferop->{$name}->{count}->[4],
$xferop->{$name}->{count}->[5],
$xferop->{$name}->{count}->[6],
$xferop->{$name}->{count}->[7],
$xferop->{$name}->{count}->[8]);
}
pod/afsmonitor.pod view on Meta::CPAN
fshosts => ["hostName3", "hostName4"],
);
($fs, $cm) = afsmonitor(
config => "configfilename",
output => "outputfilename",
detailed => 1,
);
foreach $host (@$fs) {
print "FS Host: $host->{hostName}\n";
if($host->{probeOK}) {
print "probe successful\n";
}
else {
print "probe failed\n";
}
}
($fs, $cm) =
afsmonitor(
cmhosts => ["hostName1", "hostName2"],
fshosts => ["hostName3", "hostName4", "hostName5"],
cmshow => ["PerfStats_section", "fs_oc_downDst_more_50"],
fsshow => ["VnodeCache_group", "FetchData_sqr"],
fsthresh => [
pod/afsmonitor.pod view on Meta::CPAN
=back
If a config file with "show" directives was given, then only the statistics specified
in the config file will be included, and any groups or sections that were not specified
by a "show" statement and in which no individual statistics were specified by a "show"
statement will not be included.
=back
For examples of accessing the information in the returned data structures
and printing it in a readable format, refer to the B<afsmonitor> script
in the B<examples> directory.
=head1 WRITING TO AN OUTPUT FILE
Include the B<output> argument to name the file into which the
B<afsmonitor> function writes all of the statistics it collects.
The output file is in ASCII format and records the same
information as is returned in the File Server and Cache Manager
data structures. The output file has the following format:
pod/rxdebug.pod view on Meta::CPAN
B<rxdebug> - Provides debugging trace of Rx activity
=head1 SYNOPSIS
use AFS::Monitor qw(rxdebug);
my $rxd = rxdebug(version => 1,
servers => 'hostname',
);
print "AFS build level of $rxd->{address} port $rxd->{port} is:";
print $rxd->{version};
$rxd = rxdebug(rxstats => 1,
noconns => 1,
servers => 'hostname',
port => 7001,
);
$rxd = rxdebug(noconns => 1,
peers => 1,
long => 1,
pod/rxdebug.pod view on Meta::CPAN
C<peers>: a reference to an array of hash references containing information about each peer.
=back
The simplest case would be if the version flag was set.
The hash table would have only three keys in it:
C<address>, C<port>, and C<version>.
For more details about the contents of the returned hash reference,
and an example of printing its entire contents in a readable format,
refer to the B<rxdebug> script in the B<examples> directory.
=head1 AUTHORS
The code and documentation for this class were contributed by Stanford
Linear Accelerator Center, a department of Stanford University. This
documentation was written by
=over
pod/udebug.pod view on Meta::CPAN
argument names a secondary site, but in that case only the ip address is
guaranteed to be accurate. For example, the value in the B<remoteVersion> field
is usually 0.0, because secondary sites do not poll their peers for this
information. The values in the B<lastVoteTime> and B<lastBeaconSent> fields
indicate when this site last received or requested a vote as coordinator; they
generally indicate the time of the last coordinator election.
=back
For further details of interpreting the contents of the returned hash
reference, and an example of printing its entire contents in a readable
format, refer to the B<udebug> script in the B<examples> directory.
=head1 AUTHORS
The code and documentation for this class were contributed by Stanford
Linear Accelerator Center, a department of Stanford University. This
documentation was written by
=over
pod/xstat_cm_test.pod view on Meta::CPAN
=head1 SYNOPSIS
use AFS::Monitor qw(xstat_cm_test);
my $result = xstat_cm_test(
cmname => ["hostName1", "hostName2"],
collID => [0, 1, 2],
);
foreach my $probe (@$result) {
print "For host: $probe->{hostName}, ";
print "Collection $probe->{collectionNumber}\n";
if ($probe->{probeOK}) {
print "probe successful\n";
} else {
print "probe failed\n";
}
}
=head1 DESCRIPTION
The B<xstat_cm_test> function returns the data collections from B<libxstat_cm.a>
associated with the Cache Manager.
=head1 OPTIONS
pod/xstat_cm_test.pod view on Meta::CPAN
(00:00:00 UTC, January 1, 1970).
=item B<probeOK>
1 if the probe was successful, 0 if the probe failed.
=item B<data>
If the probe was not successful, this key will not exist. Otherwise, this
entry will contain a reference to a hash containing all of the data collected.
For details on the contents of this hash, and an example of printing it in a
readable format, refer to the B<xstat_cm_test> script in the B<examples>
directory.
=back
=head1 AUTHORS
The code and documentation for this class were contributed by Stanford
Linear Accelerator Center, a department of Stanford University. This
documentation was written by
pod/xstat_fs_test.pod view on Meta::CPAN
=head1 SYNOPSIS
use AFS::Monitor qw(xstat_fs_test);
my $result = xstat_fs_test(
fsname => ["hostName1", "hostName2"],
collID => [0, 1, 2],
);
foreach my $probe (@$result) {
print "For host: $probe->{hostName}, ";
print "Collection $probe->{collectionNumber}\n";
if ($probe->{probeOK}) {
print "probe successful\n";
} else {
print "probe failed\n";
}
}
=head1 DESCRIPTION
The B<xstat_fs_test> function tests the routines in the B<libxstat_fs.a>
library and returns the data collections associated with the File Server (the
fs process).
=head1 OPTIONS
pod/xstat_fs_test.pod view on Meta::CPAN
(00:00:00 UTC, January 1, 1970).
=item B<probeOK>
1 if the probe was successful, 0 if the probe failed.
=item B<data>
If the probe was not successful, this key will not exist. Otherwise, this
entry will contain a reference to a hash containing all of the data collected.
For details on the contents of this hash, and an example of printing it in a
readable format, refer to the B<xstat_fs_test> script in the B<examples>
directory.
=back
=head1 AUTHORS
The code and documentation for this class were contributed by Stanford
Linear Accelerator Center, a department of Stanford University. This
documentation was written by
src/Makefile.PL view on Meta::CPAN
} else {
my $mess = "\nPath to the AFS installation (libraries, binaries, \n"
. "header files) to be used for this installation? \t$AFSPath] ";
$AFSPath = prompt($mess, $guess_path);
}
$AFSPath =~ s\/$\\;
# find out the AFS version of the AFS system libraries
open FILE, ">fotav.c";
print FILE <<'EOF';
#include <stdio.h>
int main(void) {
extern char *AFSVersion;
printf(">%s<\n",AFSVersion);
}
EOF
close FILE;
system("$Config::Config{cc} fotav.c -L$AFSPath/lib -lubik");
if ($CHILD_ERROR) {
unlink 'fotav.c';
die "\nCould not compile test code to retrieve the version of AFS system libraries...\n";
}
my $version = `./a.out` || die "\nCould not run test code to retrieve the version of AFS system libraries...\n";
unlink 'a.out', 'fotav.c';
print "AFS Version = $version \n";
if ($version =~ /3.[4,5]/) {
die("This release does not support AFS 3.4/3.5 system libraries ...\n");
}
# set the compiler flag "-D$version" according to the AFS version
my ($d_flag, $a_flag) = ('', '');
if ($version =~ /3.4/) { $d_flag = 'AFS 3.4'; }
elsif ($version =~ /3.5/) { $d_flag = 'AFS 3.5'; }
elsif ($version =~ /3.6/) { $d_flag = 'AFS 3.6'; }
src/Makefile.PL view on Meta::CPAN
$d_flag = '-D' . $d_flag;
$d_flag .= ' -DRXDEBUG';
# determine the alpha_sys value
my $alpha_sys = `$AFSPath/bin/fs sysname 2>&1` || 'unknown';
if ($alpha_sys =~ s/Current sysname (list|) is? //) {
$alpha_sys =~ /(\w+)/;
$alpha_sys = $1;
}
# print out a summary of determined data
print "Your AFS system library is located at: $AFSPath \n";
print " and it is major version: $version \n";
print "Your AFS system type seems to be: $alpha_sys \n\n";
# set the Makefile values
my %MakefileArgs = (
'NAME' => 'AFS::Monitor',
'VERSION' => "$VERSION",
'DEFINE' => "$d_flag $a_flag",
'INC' => "-I$AFSPath/include",
'LIBS' => [
"-L$AFSPath/lib -L$AFSPath/lib/afs "
. join (
src/Monitor.xs view on Meta::CPAN
const char *msg;
{
SV *sv = perl_get_sv("AFS::CODE", TRUE);
sv_setiv(sv, (IV) code);
if (code == 0) {
sv_setpv(sv, "");
}
else {
if (raise_exception) {
char buffer[1024];
sprintf(buffer, "AFS exception: %s (%d)", msg, code);
croak(buffer);
}
sv_setpv(sv, (char *)msg);
}
SvIOK_on(sv);
}
static void
set_code(code)
int32 code;
{
SV *sv = perl_get_sv("AFS::CODE", TRUE);
sv_setiv(sv, (IV) code);
if (code == 0) {
sv_setpv(sv, "");
}
else {
if (raise_exception) {
char buffer[1024];
sprintf(buffer, "AFS exception: %s (%d)", error_message(code), code);
croak(buffer);
}
sv_setpv(sv, (char *)error_message(code));
}
SvIOK_on(sv);
}
/* end of error handling macros */
src/Monitor.xs view on Meta::CPAN
register struct servent *ts;
ts = getservbyname(aname, (char *) NULL);
if (!ts)
return -1;
return ts->s_port; /* returns it in network byte order */
}
/*
* replaces rx_PrintTheseStats() in original c code.
* places stats in RXSTATS instead of printing them
* from src/rx/rx.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
static void
myPrintTheseStats(HV *RXSTATS, struct rx_statistics *rxstats)
{
HV *PACKETS;
HV *TYPE;
HV *TOTALRTT;
src/Monitor.xs view on Meta::CPAN
for (i = 0; i < RX_N_PACKET_TYPES; i++) {
char *packet_type = rx_packetTypes[i];
TYPE = newHV();
hv_store(TYPE, "packetsRead", 11, newSViv(rxstats->packetsRead[i]), 0);
hv_store(TYPE, "packetsSent", 11, newSViv(rxstats->packetsSent[i]), 0);
if (packet_type == "unused") {
/* rename "unused" types */
/* can't have several entries in a hash with same name */
char packet_type_unused[7];
sprintf(packet_type_unused, "unused%d", num_unused);
packet_type = packet_type_unused;
num_unused++;
}
hv_store(PACKETS, packet_type, strlen(packet_type),
newRV_inc((SV *) (TYPE)), 0);
}
hv_store(RXSTATS, "packets", 7, newRV_inc((SV *) (PACKETS)), 0);
hv_store(RXSTATS, "dataPacketsRead", 15, newSViv(rxstats->dataPacketsRead),
0);
src/Monitor.xs view on Meta::CPAN
if (isspace(*ch)) {
anotherArg = 1;
}
else if (anotherArg) {
anotherArg = 0;
sscanf(ch, "%s", fsHandler_args[argNum]);
argNum++;
}
ch++;
if (argNum >= 20) {
sprintf(buffer,
"Threshold handlers cannot have more than 20 arguments (55)");
return (55);
}
}
strcpy(args, fsHandler_args[0]);
for (i = 1; i < argNum; i++) {
strcat(args, " ");
src/Monitor.xs view on Meta::CPAN
arg1[0] = 0;
arg2[0] = 0;
arg3[0] = 0;
arg4[0] = 0;
arg5[0] = 0;
sscanf(a_line, "%s %s %s %s %s %s", opcode, arg1, arg2, arg3, arg4, arg5);
/* syntax is "thresh fs/cm variable_name threshold_value [handler] " */
if (((strlen(arg1)) == 0) || ((strlen(arg2)) == 0)
|| ((strlen(arg3)) == 0)) {
sprintf(buffer, "Incomplete line");
return (-1);
}
if (strlen(arg3) > THRESH_VAR_LEN - 2) {
sprintf(buffer, "threshold value too long");
return (-1);
}
if ((strcasecmp(arg1, "fs")) == 0) {
switch (lastHostType) {
case 0: /* its a global threshold */
(*global_fsThreshCount)++;
break;
case 1: /* inc thresh count of last file server */
last_hostEntry->numThresh++;
break;
case 2:
sprintf(buffer,
"A threshold for a File Server cannot be placed after a Cache Manager host entry in the config file");
return (-1);
default:
sprintf(buffer, "Programming error 1");
return (-1);
}
}
else if ((strcasecmp(arg1, "cm")) == 0) {
switch (lastHostType) {
case 0: /* its a global threshold */
(*global_cmThreshCount)++;
break;
case 2: /* inc thresh count of last cache manager */
last_hostEntry->numThresh++;
break;
case 1:
sprintf(buffer,
"A threshold for a Cache Manager cannot be placed after a File Server host entry in the config file");
return (-1);
default:
sprintf(buffer, "Programming error 2");
return (-1);
}
}
else {
sprintf(buffer,
"Syntax error. Second argument should be \"fs\" or \"cm\"");
return (-1);
}
return (0);
} /* my_parse_threshEntry() */
/*
src/Monitor.xs view on Meta::CPAN
extern char *fs_categories[]; /* file server data category names */
extern char *cm_categories[]; /* cache manager data category names */
opcode[0] = 0;
arg1[0] = 0;
arg2[0] = 0;
arg3[0] = 0;
sscanf(a_line, "%s %s %s %s", opcode, arg1, arg2, arg3);
if (arg3[0] != '\0') {
sprintf(buffer, "Extraneous characters at end of line");
return (-1);
}
if ((strcasecmp(arg1, "fs") != 0) && (strcasecmp(arg1, "cm") != 0)) {
sprintf(buffer,
"Second argument of \"show\" directive should be \"fs\" or \"cm\"");
return (-1);
}
/* Each entry can either be a variable name or a section/group name. Variable
* names are listed in xx_varNames[] and section/group names in xx_categories[].
* The section/group names in xx_categiries[] also give the starting/ending
* indices of the variables belonging to that section/group. These indices
* are stored in order in xx_Display_map[] and displayed to the screen in that
* order. */
src/Monitor.xs view on Meta::CPAN
while (idx < FS_NUM_DATA_CATEGORIES) {
sscanf(fs_categories[idx], "%s %d %d", catName, &fromIdx, &toIdx);
idx++;
if (strcasecmp(arg2, catName) == 0) {
found = 1;
break;
}
}
if (!found) { /* typo in section/group name */
sprintf(buffer, "Could not find section/group name %s", arg2);
return (-1);
}
}
/* if it is a group name, read its start/end indices and fill in the
* fs_Display_map[]. */
if (strcasestr(arg2, "_group") != (char *)NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_FS_STAT_ENTRIES ||
src/Monitor.xs view on Meta::CPAN
if (strcasestr(catName, "_group") != (char *) NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_FS_STAT_ENTRIES
|| toIdx > NUM_FS_STAT_ENTRIES)
return (-4);
for (j = fromIdx; j <= toIdx; j++) {
fs_showFlags[j] = 1;
}
}
else {
sprintf(buffer, "Error parsing groups for %s", arg2);
return (-6);
}
idx++;
numGroups--;
} /* for each group in section */
}
else { /* it is a variable name */
for (i = 0; i < NUM_FS_STAT_ENTRIES; i++) {
if (strcasecmp(arg2, fs_varNames[i]) == 0) {
fs_showFlags[i] = 1;
found = 1;
break;
}
}
if (!found) { /* typo in variable name */
sprintf(buffer, "Could not find variable name %s", arg2);
return (-1);
}
} /* its a variable name */
}
/* it is an fs entry */
if (strcasecmp(arg1, "cm") == 0) { /* its a Cache Manager entry */
/* mark that we have to show only what the user wants */
src/Monitor.xs view on Meta::CPAN
while (idx < CM_NUM_DATA_CATEGORIES) {
sscanf(cm_categories[idx], "%s %d %d", catName, &fromIdx, &toIdx);
idx++;
if (strcasecmp(arg2, catName) == 0) {
found = 1;
break;
}
}
if (!found) { /* typo in section/group name */
sprintf(buffer, "Could not find section/group name %s", arg2);
return (-1);
}
}
/* if it is a group name */
if (strcasestr(arg2, "_group") != (char *)NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_CM_STAT_ENTRIES
|| toIdx > NUM_CM_STAT_ENTRIES)
src/Monitor.xs view on Meta::CPAN
if (strcasestr(catName, "_group") != (char *) NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_CM_STAT_ENTRIES
|| toIdx > NUM_CM_STAT_ENTRIES)
return (-12);
for (j = fromIdx; j <= toIdx; j++) {
cm_showFlags[j] = 1;
}
}
else {
sprintf(buffer, "Error parsing groups for %s", arg2);
return (-15);
}
idx++;
numGroups--;
} /* for each group in section */
}
else { /* it is a variable name */
for (i = 0; i < NUM_CM_STAT_ENTRIES; i++) {
if (strcasecmp(arg2, cm_varNames[i]) == 0) {
cm_showFlags[i] = 1;
found = 1;
break;
}
}
if (!found) { /* typo in section/group name */
sprintf(buffer, "Could not find variable name %s", arg2);
return (-1);
}
} /* its a variable name */
} /* it is a cm entry */
return (0);
} /* my_parse_showEntry() */
src/Monitor.xs view on Meta::CPAN
char arg2[CFG_STR_LEN];
struct hostent *he = 0;
int code = 0;
opcode[0] = 0;
arg1[0] = 0;
arg2[0] = 0;
sscanf(a_line, "%s %s %s", opcode, arg1, arg2);
if ((strlen(arg2)) != 0) {
sprintf(buffer, "Extraneous characters at end of line");
return (-1);
}
he = GetHostByName(arg1);
if (he == NULL) {
sprintf(buffer, "Unable to resolve hostname %s", arg1);
return (-1);
}
if ((strcasecmp(opcode, "fs")) == 0) {
/* use the complete host name to insert in the file server names list */
code = my_insert_FS(he->h_name, FSnameList, last_hostEntry);
if (code) {
return (-1);
}
/* note that last host entry in the config file was fs */
src/Monitor.xs view on Meta::CPAN
/* resolve the threshold variable name */
found = 0;
if (a_type == FS) { /* fs threshold */
for (index = 0; index < NUM_FS_STAT_ENTRIES; index++) {
if (strcasecmp(a_varName, fs_varNames[index]) == 0) {
found = 1;
break;
}
}
if (!found) {
sprintf(buffer, "Unknown FS threshold variable name %s", a_varName);
return (-1);
}
}
else if (a_type == CM) { /* cm threshold */
for (index = 0; index < NUM_CM_STAT_ENTRIES; index++) {
if (strcasecmp(a_varName, cm_varNames[index]) == 0) {
found = 1;
break;
}
}
if (!found) {
sprintf(buffer, "Unknown CM threshold variable name %s", a_varName);
return (-1);
}
}
else
return (-1);
/* if the global thresh count is not zero, place this threshold on
* all the host entries */
if (*global_TC) {
src/Monitor.xs view on Meta::CPAN
strncpy(threshP->itemName, a_varName, THRESH_VAR_NAME_LEN);
strncpy(threshP->threshVal, a_value, THRESH_VAR_LEN);
strcpy(threshP->handler, a_handler);
threshP->index = index;
done = 1;
break;
}
threshP++;
}
if (!done) {
sprintf(buffer,
"Could not insert threshold entry for %s in thresh list of host %s",
a_varName, tmp_host->hostName);
return (-1);
}
tmp_host = tmp_host->next;
}
(*global_TC)--;
return (0);
}
/* it is not a global threshold, insert it in the thresh list of this
* host only. We overwrite the global threshold if it was already set */
if (*hostname == '\0') {
sprintf(buffer, "Programming error 3");
return (-1);
}
/* get the hostEntry that this threshold belongs to */
tmp_host = Header;
found = 0;
for (i = 0; i < srvCount; i++) {
if (strcasecmp(tmp_host->hostName, hostname) == 0) {
found = 1;
break;
}
tmp_host = tmp_host->next;
}
if (!found) {
sprintf(buffer, "Unable to find host %s in %s hostEntry list", hostname,
(a_type - 1) ? "CM" : "FS");
return (-1);
}
/* put this entry on the thresh list of this host, overwrite global value
* if needed */
threshP = tmp_host->thresh;
done = 0;
for (i = 0; i < tmp_host->numThresh; i++) {
src/Monitor.xs view on Meta::CPAN
strncpy(threshP->threshVal, a_value, THRESH_VAR_LEN);
strcpy(threshP->handler, a_handler);
threshP->index = index;
done = 1;
break;
}
threshP++;
}
if (!done) {
sprintf(buffer, "Unable to insert threshold %s for %s host %s",
a_varName, (a_type - 1) ? "CM" : "FS", tmp_host->hostName);
return (-1);
}
return (0);
} /* my_store_threshold() */
src/Monitor.xs view on Meta::CPAN
if (!found) {
threshP++;
continue;
}
if (pValue > tValue) {
hv_store(VALUE, "overflow", 8, newSViv(1), 0);
hv_store(VALUE, "threshold", 9, newSVnv(tValue), 0);
if (threshP->handler[0] != '\0') {
sprintf(strval, "%g", pValue);
code = my_execute_thresh_handler(threshP->handler,
a_hostEntry->hostName, type,
threshP->itemName,
threshP->threshVal, strval,
VALUE, buffer);
if (code) {
return (code);
}
}
src/Monitor.xs view on Meta::CPAN
int numBytes = 0;
/* int global_ThreshFlag = 1; */
int global_fsThreshCount = 0;
int global_cmThreshCount = 0;
static char last_fsHost[HOST_NAME_LEN];
static char last_cmHost[HOST_NAME_LEN];
/* open config file */
configFD = fopen(a_config_filename, "r");
if (configFD == (FILE *) NULL) {
sprintf(buff1, "Failed to open config file %s", a_config_filename);
BSETCODE(5, buff1);
return (-1);
}
/* parse config file */
/* First Pass - check syntax and count number of servers and thresholds to monitor */
*numFS = 0;
*numCM = 0;
src/Monitor.xs view on Meta::CPAN
error_in_config = 0; /* flag to note if config file has syntax errors */
while ((fgets(line, CFG_STR_LEN, configFD)) != NULL) {
opcode[0] = 0;
arg1[0] = 0;
arg2[0] = 0;
arg3[0] = 0;
arg4[0] = 0;
sscanf(line, "%s %s %s %s %s", opcode, arg1, arg2, arg3, arg4);
linenum++;
/* fprintf(STDERR, "Got line %d: \"%s %s %s %s %s\"\n",
* linenum, opcode, arg1, arg2, arg3, arg4); */
/* skip blank lines and comment lines */
if ((strlen(opcode) == 0) || line[0] == '#') {
/* fprintf(STDERR, " - skipping line %d\n", linenum); */
continue;
}
if ((strcasecmp(opcode, "fs") == 0) || (strcasecmp(opcode, "cm")) == 0) {
/* fprintf(STDERR, " - parsing host entry\n"); */
code =
my_parse_hostEntry(line, numFS, numCM, lastHostType,
last_hostEntry, FSnameList, CMnameList, buff2);
/* thresholds are not global anymore */
/* if (global_ThreshFlag) global_ThreshFlag = 0; */
}
else if ((strcasecmp(opcode, "thresh")) == 0) {
/* fprintf(STDERR, " - parsing thresh entry\n"); */
code =
my_parse_threshEntry(line, &global_fsThreshCount,
&global_cmThreshCount, *last_hostEntry,
*lastHostType, buff2);
}
else if ((strcasecmp(opcode, "show")) == 0) {
/* fprintf(STDERR, " - parsing show entry\n"); */
code =
my_parse_showEntry(line, fs_showDefault, cm_showDefault,
fs_showFlags, cm_showFlags, buff2);
}
else {
/* fprintf(STDERR, " - unknown entry\n"); */
sprintf(buff2, "Unknown opcode %s", opcode);
code = 1;
}
if (code) {
sprintf(buff1,
"Error processing config file line %d (\"%s %s %s %s %s\"). %s",
linenum, opcode, arg1, arg2, arg3, arg4, buff2);
error_in_config = 1;
BSETCODE(10, buff1);
return (-1);
}
}
/* fprintf(STDERR, "got to end of file.\n"); */
if (error_in_config) {
sprintf(buff1, "Error in config file. %s", buff2);
BSETCODE(10, buff1);
return (-1);
}
/* the threshold count of all hosts in increased by 1 for each global
* threshold. If one of the hosts has a local threshold for the same
* variable it would end up being counted twice. whats a few bytes of memory
* wasted anyway ? */
if (global_fsThreshCount) {
src/Monitor.xs view on Meta::CPAN
if (global_cmThreshCount) {
curr_host = *CMnameList;
for (i = 0; i < *numCM; i++) {
curr_host->numThresh += global_cmThreshCount;
curr_host = curr_host->next;
}
}
/* make sure we have something to monitor */
if (*numFS == 0 && *numCM == 0) {
sprintf(buff1,
"Config file must specify atleast one File Server or Cache Manager host to monitor.");
fclose(configFD);
BSETCODE(15, buff1);
return (-1);
}
/* Second Pass */
fseek(configFD, 0, 0); /* seek to the beginning */
/* allocate memory for threshold lists */
curr_host = *FSnameList;
for (i = 0; i < *numFS; i++) {
if (curr_host->hostName[0] == '\0') {
sprintf(buff1, "Programming error 4");
BSETCODE(20, buff1);
return (-1);
}
if (curr_host->numThresh) {
numBytes = curr_host->numThresh * sizeof(struct Threshold);
curr_host->thresh = (struct Threshold *)malloc(numBytes);
if (curr_host->thresh == (struct Threshold *) NULL) {
sprintf(buff1, "Memory Allocation error 1");
BSETCODE(25, buff1);
return (-1);
}
memset(curr_host->thresh, 0, numBytes);
}
curr_host = curr_host->next;
}
curr_host = *CMnameList;
for (i = 0; i < *numCM; i++) {
if (curr_host->hostName[0] == '\0') {
sprintf(buff1, "Programming error 5");
BSETCODE(30, buff1);
return (-1);
}
if (curr_host->numThresh) {
numBytes = curr_host->numThresh * sizeof(struct Threshold);
curr_host->thresh = (struct Threshold *)malloc(numBytes);
if (curr_host->thresh == (struct Threshold *) NULL) {
sprintf(buff1, "Memory Allocation error 2");
BSETCODE(35, buff1);
return (-1);
}
memset(curr_host->thresh, 0, numBytes);
}
curr_host = curr_host->next;
}
opcode[0] = 0;
arg1[0] = 0;
src/Monitor.xs view on Meta::CPAN
&global_fsThreshCount, *FSnameList,
last_fsHost, *numFS, buff2);
else if (strcasecmp(arg1, "cm") == 0)
code = my_store_threshold(2, /* 2 = cm */
arg2, arg3, handlerPtr,
&global_cmThreshCount, *CMnameList,
last_cmHost, *numCM, buff2);
else {
sprintf(buff1, "Programming error 6");
BSETCODE(40, buff1);
return (-1);
}
if (code) {
sprintf(buff1,
"Error processing config file line %d (\"%s %s %s %s %s\"): Failed to store threshold. %s",
linenum, opcode, arg1, arg2, arg3, arg4, buff2);
BSETCODE(45, buff1);
return (-1);
}
}
}
fclose(configFD);
return (0);
src/Monitor.xs view on Meta::CPAN
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_fs_OpTiming(a_opIdx, a_opTimeP, fs_outFD)
int a_opIdx;
struct fs_stats_opTimingData *a_opTimeP;
FILE *fs_outFD;
{
fprintf(fs_outFD,
"%15s: %d ops (%d OK); sum=%d.%06d, min=%d.%06d, max=%d.%06d\n",
fsOpNames[a_opIdx], a_opTimeP->numOps, a_opTimeP->numSuccesses,
a_opTimeP->sumTime.tv_sec, a_opTimeP->sumTime.tv_usec,
a_opTimeP->minTime.tv_sec, a_opTimeP->minTime.tv_usec,
a_opTimeP->maxTime.tv_sec, a_opTimeP->maxTime.tv_usec);
} /* my_Print_fs_OpTiming() */
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_fs_XferTiming(a_opIdx, a_xferP, fs_outFD)
int a_opIdx;
struct fs_stats_xferData *a_xferP;
FILE *fs_outFD;
{
fprintf(fs_outFD,
"%s: %d xfers (%d OK), time sum=%d.%06d, min=%d.%06d, max=%d.%06d\n",
xferOpNames[a_opIdx], a_xferP->numXfers, a_xferP->numSuccesses,
a_xferP->sumTime.tv_sec, a_xferP->sumTime.tv_usec,
a_xferP->minTime.tv_sec, a_xferP->minTime.tv_usec,
a_xferP->maxTime.tv_sec, a_xferP->maxTime.tv_usec);
fprintf(fs_outFD, "\t[bytes: sum=%d, min=%d, max=%d]\n",
a_xferP->sumBytes, a_xferP->minBytes, a_xferP->maxBytes);
fprintf(fs_outFD,
"\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d 6: %d, 7: %d, 8: %d]\n",
a_xferP->count[0], a_xferP->count[1], a_xferP->count[2],
a_xferP->count[3], a_xferP->count[4], a_xferP->count[5],
a_xferP->count[6], a_xferP->count[7], a_xferP->count[8]);
} /* my_Print_fs_XferTiming() */
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_fs_OverallPerfInfo(a_ovP, fs_outFD)
struct afs_PerfStats *a_ovP;
FILE *fs_outFD;
{
fprintf(fs_outFD, "\t%10d numPerfCalls\n\n", a_ovP->numPerfCalls);
/*
* Vnode cache section.
*/
fprintf(fs_outFD, "\t%10d vcache_L_Entries\n", a_ovP->vcache_L_Entries);
fprintf(fs_outFD, "\t%10d vcache_L_Allocs\n", a_ovP->vcache_L_Allocs);
fprintf(fs_outFD, "\t%10d vcache_L_Gets\n", a_ovP->vcache_L_Gets);
fprintf(fs_outFD, "\t%10d vcache_L_Reads\n", a_ovP->vcache_L_Reads);
fprintf(fs_outFD, "\t%10d vcache_L_Writes\n\n", a_ovP->vcache_L_Writes);
fprintf(fs_outFD, "\t%10d vcache_S_Entries\n", a_ovP->vcache_S_Entries);
fprintf(fs_outFD, "\t%10d vcache_S_Allocs\n", a_ovP->vcache_S_Allocs);
fprintf(fs_outFD, "\t%10d vcache_S_Gets\n", a_ovP->vcache_S_Gets);
fprintf(fs_outFD, "\t%10d vcache_S_Reads\n", a_ovP->vcache_S_Reads);
fprintf(fs_outFD, "\t%10d vcache_S_Writes\n\n", a_ovP->vcache_S_Writes);
fprintf(fs_outFD, "\t%10d vcache_H_Entries\n", a_ovP->vcache_H_Entries);
fprintf(fs_outFD, "\t%10d vcache_H_Gets\n", a_ovP->vcache_H_Gets);
fprintf(fs_outFD, "\t%10d vcache_H_Replacements\n\n",
a_ovP->vcache_H_Replacements);
/*
* Directory package section.
*/
fprintf(fs_outFD, "\t%10d dir_Buffers\n", a_ovP->dir_Buffers);
fprintf(fs_outFD, "\t%10d dir_Calls\n", a_ovP->dir_Calls);
fprintf(fs_outFD, "\t%10d dir_IOs\n\n", a_ovP->dir_IOs);
/*
* Rx section.
*/
fprintf(fs_outFD, "\t%10d rx_packetRequests\n", a_ovP->rx_packetRequests);
fprintf(fs_outFD, "\t%10d rx_noPackets_RcvClass\n",
a_ovP->rx_noPackets_RcvClass);
fprintf(fs_outFD, "\t%10d rx_noPackets_SendClass\n",
a_ovP->rx_noPackets_SendClass);
fprintf(fs_outFD, "\t%10d rx_noPackets_SpecialClass\n",
a_ovP->rx_noPackets_SpecialClass);
fprintf(fs_outFD, "\t%10d rx_socketGreedy\n", a_ovP->rx_socketGreedy);
fprintf(fs_outFD, "\t%10d rx_bogusPacketOnRead\n",
a_ovP->rx_bogusPacketOnRead);
fprintf(fs_outFD, "\t%10d rx_bogusHost\n", a_ovP->rx_bogusHost);
fprintf(fs_outFD, "\t%10d rx_noPacketOnRead\n", a_ovP->rx_noPacketOnRead);
fprintf(fs_outFD, "\t%10d rx_noPacketBuffersOnRead\n",
a_ovP->rx_noPacketBuffersOnRead);
fprintf(fs_outFD, "\t%10d rx_selects\n", a_ovP->rx_selects);
fprintf(fs_outFD, "\t%10d rx_sendSelects\n", a_ovP->rx_sendSelects);
fprintf(fs_outFD, "\t%10d rx_packetsRead_RcvClass\n",
a_ovP->rx_packetsRead_RcvClass);
fprintf(fs_outFD, "\t%10d rx_packetsRead_SendClass\n",
a_ovP->rx_packetsRead_SendClass);
fprintf(fs_outFD, "\t%10d rx_packetsRead_SpecialClass\n",
a_ovP->rx_packetsRead_SpecialClass);
fprintf(fs_outFD, "\t%10d rx_dataPacketsRead\n",
a_ovP->rx_dataPacketsRead);
fprintf(fs_outFD, "\t%10d rx_ackPacketsRead\n", a_ovP->rx_ackPacketsRead);
fprintf(fs_outFD, "\t%10d rx_dupPacketsRead\n", a_ovP->rx_dupPacketsRead);
fprintf(fs_outFD, "\t%10d rx_spuriousPacketsRead\n",
a_ovP->rx_spuriousPacketsRead);
fprintf(fs_outFD, "\t%10d rx_packetsSent_RcvClass\n",
a_ovP->rx_packetsSent_RcvClass);
fprintf(fs_outFD, "\t%10d rx_packetsSent_SendClass\n",
a_ovP->rx_packetsSent_SendClass);
fprintf(fs_outFD, "\t%10d rx_packetsSent_SpecialClass\n",
a_ovP->rx_packetsSent_SpecialClass);
fprintf(fs_outFD, "\t%10d rx_ackPacketsSent\n", a_ovP->rx_ackPacketsSent);
fprintf(fs_outFD, "\t%10d rx_pingPacketsSent\n",
a_ovP->rx_pingPacketsSent);
fprintf(fs_outFD, "\t%10d rx_abortPacketsSent\n",
a_ovP->rx_abortPacketsSent);
fprintf(fs_outFD, "\t%10d rx_busyPacketsSent\n",
a_ovP->rx_busyPacketsSent);
fprintf(fs_outFD, "\t%10d rx_dataPacketsSent\n",
a_ovP->rx_dataPacketsSent);
fprintf(fs_outFD, "\t%10d rx_dataPacketsReSent\n",
a_ovP->rx_dataPacketsReSent);
fprintf(fs_outFD, "\t%10d rx_dataPacketsPushed\n",
a_ovP->rx_dataPacketsPushed);
fprintf(fs_outFD, "\t%10d rx_ignoreAckedPacket\n",
a_ovP->rx_ignoreAckedPacket);
fprintf(fs_outFD, "\t%10d rx_totalRtt_Sec\n", a_ovP->rx_totalRtt_Sec);
fprintf(fs_outFD, "\t%10d rx_totalRtt_Usec\n", a_ovP->rx_totalRtt_Usec);
fprintf(fs_outFD, "\t%10d rx_minRtt_Sec\n", a_ovP->rx_minRtt_Sec);
fprintf(fs_outFD, "\t%10d rx_minRtt_Usec\n", a_ovP->rx_minRtt_Usec);
fprintf(fs_outFD, "\t%10d rx_maxRtt_Sec\n", a_ovP->rx_maxRtt_Sec);
fprintf(fs_outFD, "\t%10d rx_maxRtt_Usec\n", a_ovP->rx_maxRtt_Usec);
fprintf(fs_outFD, "\t%10d rx_nRttSamples\n", a_ovP->rx_nRttSamples);
fprintf(fs_outFD, "\t%10d rx_nServerConns\n", a_ovP->rx_nServerConns);
fprintf(fs_outFD, "\t%10d rx_nClientConns\n", a_ovP->rx_nClientConns);
fprintf(fs_outFD, "\t%10d rx_nPeerStructs\n", a_ovP->rx_nPeerStructs);
fprintf(fs_outFD, "\t%10d rx_nCallStructs\n", a_ovP->rx_nCallStructs);
fprintf(fs_outFD, "\t%10d rx_nFreeCallStructs\n\n",
a_ovP->rx_nFreeCallStructs);
/*
* Host module fields.
*/
fprintf(fs_outFD, "\t%10d host_NumHostEntries\n",
a_ovP->host_NumHostEntries);
fprintf(fs_outFD, "\t%10d host_HostBlocks\n", a_ovP->host_HostBlocks);
fprintf(fs_outFD, "\t%10d host_NonDeletedHosts\n",
a_ovP->host_NonDeletedHosts);
fprintf(fs_outFD, "\t%10d host_HostsInSameNetOrSubnet\n",
a_ovP->host_HostsInSameNetOrSubnet);
fprintf(fs_outFD, "\t%10d host_HostsInDiffSubnet\n",
a_ovP->host_HostsInDiffSubnet);
fprintf(fs_outFD, "\t%10d host_HostsInDiffNetwork\n",
a_ovP->host_HostsInDiffNetwork);
fprintf(fs_outFD, "\t%10d host_NumClients\n", a_ovP->host_NumClients);
fprintf(fs_outFD, "\t%10d host_ClientBlocks\n\n",
a_ovP->host_ClientBlocks);
} /* my_Print_fs_OverallPerfInfo() */
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_fs_DetailedPerfInfo(a_detP, fs_outFD)
struct fs_stats_DetailedStats *a_detP;
FILE *fs_outFD;
{
int currIdx = 0; /*Loop variable */
fprintf(fs_outFD, "\t%10d epoch\n", a_detP->epoch);
for (currIdx = 0; currIdx < FS_STATS_NUM_RPC_OPS; currIdx++)
my_Print_fs_OpTiming(currIdx, &(a_detP->rpcOpTimes[currIdx]), fs_outFD);
for (currIdx = 0; currIdx < FS_STATS_NUM_XFER_OPS; currIdx++)
my_Print_fs_XferTiming(currIdx, &(a_detP->xferOpTimes[currIdx]),
fs_outFD);
} /* my_Print_fs_DetailedPerfInfo() */
/*
* from src/afsmonitor/afsmon-output.c
src/Monitor.xs view on Meta::CPAN
void
my_Print_fs_FullPerfInfo(a_fs_Results, fs_outFD)
struct xstat_fs_ProbeResults *a_fs_Results;
FILE *fs_outFD;
{
/*Correct # longs to rcv */
static afs_int32 fullPerfLongs = (sizeof(struct fs_stats_FullPerfStats) >> 2);
afs_int32 numLongs = 0; /*# longwords received */
struct fs_stats_FullPerfStats *fullPerfP = 0; /*Ptr to full perf stats */
char *printableTime = 0; /*Ptr to printable time string */
numLongs = a_fs_Results->data.AFS_CollData_len;
if (numLongs != fullPerfLongs) {
fprintf(fs_outFD,
" ** Data size mismatch in full performance collection!\n");
fprintf(fs_outFD, " ** Expecting %d, got %d\n", fullPerfLongs,
numLongs);
return;
}
printableTime = ctime((time_t *) & (a_fs_Results->probeTime));
printableTime[strlen(printableTime) - 1] = '\0';
fullPerfP = (struct fs_stats_FullPerfStats *)
(a_fs_Results->data.AFS_CollData_val);
fprintf(fs_outFD,
"AFS_XSTATSCOLL_FULL_PERF_INFO (coll %d) for FS %s\n[Probe %d, %s]\n\n",
a_fs_Results->collectionNumber, a_fs_Results->connP->hostName,
a_fs_Results->probeNum, printableTime);
my_Print_fs_OverallPerfInfo(&(fullPerfP->overall), fs_outFD);
my_Print_fs_DetailedPerfInfo(&(fullPerfP->det), fs_outFD);
}
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_afsmon_fsOutput(a_outfile, a_detOutput, xstat_fs_Results)
char *a_outfile; /* ptr to output file name */
int a_detOutput; /* detailed output ? */
struct xstat_fs_ProbeResults xstat_fs_Results;
{
char *printTime = 0; /* ptr to time string */
char *hostname = 0; /* fileserner name */
afs_int32 numLongs = 0; /* longwords in result */
afs_int32 *currLong = 0; /* ptr to longwords in result */
int i = 0;
FILE *fs_outFD = 0;
fs_outFD = fopen(a_outfile, "a");
if (fs_outFD == (FILE *) NULL) {
warn("failed to open output file %s", a_outfile);
return;
}
/* get the probe time and strip the \n at the end */
printTime = ctime((time_t *) & (xstat_fs_Results.probeTime));
printTime[strlen(printTime) - 1] = '\0';
hostname = xstat_fs_Results.connP->hostName;
/* print "time hostname FS" */
fprintf(fs_outFD, "\n%s %s FS ", printTime, hostname);
/* if probe failed print -1 and return */
if (xstat_fs_Results.probeOK) {
fprintf(fs_outFD, "-1\n");
fclose(fs_outFD);
return;
}
/* print out the probe information as long words */
numLongs = xstat_fs_Results.data.AFS_CollData_len;
currLong = (afs_int32 *) (xstat_fs_Results.data.AFS_CollData_val);
for (i = 0; i < numLongs; i++) {
fprintf(fs_outFD, "%d ", *currLong++);
}
fprintf(fs_outFD, "\n\n");
/* print detailed information */
if (a_detOutput) {
my_Print_fs_FullPerfInfo(&xstat_fs_Results, fs_outFD);
fflush(fs_outFD);
}
fclose(fs_outFD);
} /* my_afsmon_fsOutput() */
src/Monitor.xs view on Meta::CPAN
/* there are two parts to the xstat FS statistics
* - fullPerfP->overall which give the overall performance statistics, and
* - fullPerfP->det which gives detailed info about file server operation
* execution times */
/* copy overall performance statistics */
srcbuf = (afs_int32 *) & (fullPerfP->overall);
idx = 0;
for (i = 0; i < NUM_XSTAT_FS_AFS_PERFSTATS_LONGS; i++) {
sprintf(a_fsData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/* copy epoch */
srcbuf = (afs_int32 *) & (fullPerfP->det.epoch);
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* epoch */
idx++;
/* copy fs operation timing */
srcbuf = (afs_int32 *) (fullPerfP->det.rpcOpTimes);
for (i = 0; i < FS_STATS_NUM_RPC_OPS; i++) {
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* numOps */
idx++;
srcbuf++;
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* numSuccesses */
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sum time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sqr time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* min time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* max time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
}
/* copy fs transfer timings */
srcbuf = (afs_int32 *) (fullPerfP->det.xferOpTimes);
for (i = 0; i < FS_STATS_NUM_XFER_OPS; i++) {
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* numOps */
idx++;
srcbuf++;
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* numSuccesses */
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sum time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sqr time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* min time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* max time */
sprintf(a_fsData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* sum bytes */
idx++;
srcbuf++;
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* min bytes */
idx++;
srcbuf++;
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* max bytes */
idx++;
srcbuf++;
for (j = 0; j < FS_STATS_NUM_XFER_BUCKETS; j++) {
sprintf(a_fsData->data[idx], "%d", *srcbuf); /* bucket[j] */
idx++;
srcbuf++;
}
}
return (0);
} /* my_fs_Results_ltoa() */
src/Monitor.xs view on Meta::CPAN
struct fs_Display_Data *curr_fsDataP;
struct afsmon_hostEntry *curr_host = 0;
int i = 0;
int code = 0;
int done = 0;
char buff2[256] = "";
curr_fsDataP =
(struct fs_Display_Data *)malloc(sizeof(struct fs_Display_Data));
if (curr_fsDataP == (struct fs_Display_Data *) NULL) {
sprintf(buffer, "Memory allocation failure");
return (-1);
}
memset(curr_fsDataP, 0, sizeof(struct fs_Display_Data));
hv_store(HOSTINFO, "hostName", 8, newSVpv(a_fsResults->connP->hostName, 0),
0);
/* Check the status of the probe. If it succeeded, we store its
* results in the display data structure. If it failed we only mark
* the failed status in the display data structure. */
src/Monitor.xs view on Meta::CPAN
curr_host = FSnameList;
for (i = 0; i < numFS; i++) {
if (strcasecmp(curr_host->hostName, a_fsResults->connP->hostName)
== 0) {
done = 1;
break;
}
curr_host = curr_host->next;;
}
if (!done) {
sprintf(buffer, "Error storing results for FS host %s (70)",
a_fsResults->connP->hostName);
return (70);
}
code = my_check_thresholds(curr_host, HOSTINFO, FS, buff2);
if (code) {
sprintf(buffer, "Error in checking thresholds (75) %s", buff2);
return (75);
}
} /* the probe succeeded, so we store the data in the display structure */
return (0);
} /* my_save_FS_data_forDisplay() */
src/Monitor.xs view on Meta::CPAN
*currCollIDP,
&srvVersionNumber,
&(xstat_fs_Results.probeTime),
&(xstat_fs_Results.data));
code =
ProbeHandler(xstat_fs_Results, xstat_fs_numServers, index,
buff2, argp);
index++;
if (code) {
sprintf(buffer, "Handler returned error code %d. %s",
code, buff2);
return (code);
}
} /* For each collection */
} /*Valid Rx connection */
/*
* Advance the xstat_fs connection pointer.
*/
src/Monitor.xs view on Meta::CPAN
struct xstat_fs_ConnectionInfo *curr_conn = 0, *xstat_fs_ConnInfo = 0;
struct rx_securityClass *secobj = 0; /*Client security object */
char buff2[256] = "";
int PortToUse = 0;
int code = 0;
va_list argp;
xstat_fs_ConnInfo = (struct xstat_fs_ConnectionInfo *)
malloc(xstat_fs_numServers * sizeof(struct xstat_fs_ConnectionInfo));
if (xstat_fs_ConnInfo == (struct xstat_fs_ConnectionInfo *) NULL) {
sprintf(buffer,
"Can't allocate %d connection info structs (%d bytes)",
xstat_fs_numServers,
(xstat_fs_numServers * sizeof(struct xstat_fs_ConnectionInfo)));
return (-1); /*No cleanup needs to be done yet */
}
PortToUse = XSTAT_FS_CBPORT;
do {
code = rx_Init(htons(PortToUse));
if (code) {
if (code == RX_ADDRINUSE) {
PortToUse++;
}
else {
sprintf(buffer, "Fatal error in rx_Init()");
return (-1);
}
}
} while (code);
/*
* Create a null Rx client security object, to be used by the
* probe LWP.
*/
secobj = rxnull_NewClientSecurityObject();
if (secobj == (struct rx_securityClass *) NULL) {
/*Delete already-malloc'ed areas */
my_xstat_fs_Cleanup(1, xstat_fs_numServers, xstat_fs_ConnInfo, buff2);
sprintf(buffer, "Can't create probe LWP client security object. %s",
buff2);
return (-1);
}
curr_conn = xstat_fs_ConnInfo;
conn_err = 0;
for (curr_srv = 0; curr_srv < xstat_fs_numServers; curr_srv++) {
/*
* Copy in the socket info for the current server, resolve its
* printable name if possible.
*/
memcpy(&(curr_conn->skt), a_socketArray + curr_srv,
sizeof(struct sockaddr_in));
hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == NULL) {
warn("Can't map Internet address %lu to a string name",
curr_conn->skt.sin_addr.s_addr);
curr_conn->hostName[0] = '\0';
src/Monitor.xs view on Meta::CPAN
/*
* Make an Rx connection to the current server.
*/
curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
curr_conn->skt.sin_port, /*Server port */
1, /*AFS service # */
secobj, /*Security obj */
0); /*# of above */
if (curr_conn->rxconn == (struct rx_connection *) NULL) {
sprintf(buffer,
"Can't create Rx connection to server '%s' (%lu)",
curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
my_xstat_fs_Cleanup(1, xstat_fs_numServers, xstat_fs_ConnInfo,
buff2);
return (-2);
}
/*
* Bump the current xstat_fs connection to set up.
*/
curr_conn++;
src/Monitor.xs view on Meta::CPAN
{
int code = 0; /*Return code */
int conn_idx = 0; /*Current connection index */
struct xstat_fs_ConnectionInfo *curr_conn = 0; /*Ptr to xstat_fs connection */
/*
* Take care of all Rx connections first. Check to see that the
* server count is a legal value.
*/
if (xstat_fs_numServers <= 0) {
sprintf(buffer,
"Illegal number of servers (xstat_fs_numServers = %d)",
xstat_fs_numServers);
code = -1;
}
else {
if (xstat_fs_ConnInfo != (struct xstat_fs_ConnectionInfo *) NULL) {
/*
* The xstat_fs connection structure array exists. Go through
* it and close up any Rx connections it holds.
*/
src/Monitor.xs view on Meta::CPAN
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_cm_UpDownStats(a_upDownP, cm_outFD)
struct afs_stats_SrvUpDownInfo *a_upDownP; /*Ptr to server up/down info */
FILE *cm_outFD;
{ /*Print_cm_UpDownStats */
/*
* First, print the simple values.
*/
fprintf(cm_outFD, "\t\t%10d numTtlRecords\n", a_upDownP->numTtlRecords);
fprintf(cm_outFD, "\t\t%10d numUpRecords\n", a_upDownP->numUpRecords);
fprintf(cm_outFD, "\t\t%10d numDownRecords\n", a_upDownP->numDownRecords);
fprintf(cm_outFD, "\t\t%10d sumOfRecordAges\n",
a_upDownP->sumOfRecordAges);
fprintf(cm_outFD, "\t\t%10d ageOfYoungestRecord\n",
a_upDownP->ageOfYoungestRecord);
fprintf(cm_outFD, "\t\t%10d ageOfOldestRecord\n",
a_upDownP->ageOfOldestRecord);
fprintf(cm_outFD, "\t\t%10d numDowntimeIncidents\n",
a_upDownP->numDowntimeIncidents);
fprintf(cm_outFD, "\t\t%10d numRecordsNeverDown\n",
a_upDownP->numRecordsNeverDown);
fprintf(cm_outFD, "\t\t%10d maxDowntimesInARecord\n",
a_upDownP->maxDowntimesInARecord);
fprintf(cm_outFD, "\t\t%10d sumOfDowntimes\n", a_upDownP->sumOfDowntimes);
fprintf(cm_outFD, "\t\t%10d shortestDowntime\n",
a_upDownP->shortestDowntime);
fprintf(cm_outFD, "\t\t%10d longestDowntime\n",
a_upDownP->longestDowntime);
/*
* Now, print the array values.
*/
fprintf(cm_outFD, "\t\tDowntime duration distribution:\n");
fprintf(cm_outFD, "\t\t\t%8d: 0 min .. 10 min\n",
a_upDownP->downDurations[0]);
fprintf(cm_outFD, "\t\t\t%8d: 10 min .. 30 min\n",
a_upDownP->downDurations[1]);
fprintf(cm_outFD, "\t\t\t%8d: 30 min .. 1 hr\n",
a_upDownP->downDurations[2]);
fprintf(cm_outFD, "\t\t\t%8d: 1 hr .. 2 hr\n",
a_upDownP->downDurations[3]);
fprintf(cm_outFD, "\t\t\t%8d: 2 hr .. 4 hr\n",
a_upDownP->downDurations[4]);
fprintf(cm_outFD, "\t\t\t%8d: 4 hr .. 8 hr\n",
a_upDownP->downDurations[5]);
fprintf(cm_outFD, "\t\t\t%8d: > 8 hr\n", a_upDownP->downDurations[6]);
fprintf(cm_outFD, "\t\tDowntime incident distribution:\n");
fprintf(cm_outFD, "\t\t\t%8d: 0 times\n", a_upDownP->downIncidents[0]);
fprintf(cm_outFD, "\t\t\t%8d: 1 time\n", a_upDownP->downIncidents[1]);
fprintf(cm_outFD, "\t\t\t%8d: 2 .. 5 times\n",
a_upDownP->downIncidents[2]);
fprintf(cm_outFD, "\t\t\t%8d: 6 .. 10 times\n",
a_upDownP->downIncidents[3]);
fprintf(cm_outFD, "\t\t\t%8d: 10 .. 50 times\n",
a_upDownP->downIncidents[4]);
fprintf(cm_outFD, "\t\t\t%8d: > 50 times\n", a_upDownP->downIncidents[5]);
} /* my_Print_cm_UpDownStats() */
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_cm_XferTiming(a_opIdx, a_opNames, a_xferP, cm_outFD)
int a_opIdx;
char *a_opNames[];
struct afs_stats_xferData *a_xferP;
FILE *cm_outFD;
{ /*Print_cm_XferTiming */
fprintf(cm_outFD,
"%s: %d xfers (%d OK), time sum=%d.%06d, min=%d.%06d, max=%d.%06d\n",
a_opNames[a_opIdx], a_xferP->numXfers, a_xferP->numSuccesses,
a_xferP->sumTime.tv_sec, a_xferP->sumTime.tv_usec,
a_xferP->minTime.tv_sec, a_xferP->minTime.tv_usec,
a_xferP->maxTime.tv_sec, a_xferP->maxTime.tv_usec);
fprintf(cm_outFD, "\t[bytes: sum=%d, min=%d, max=%d]\n", a_xferP->sumBytes,
a_xferP->minBytes, a_xferP->maxBytes);
fprintf(cm_outFD,
"\t[buckets: 0: %d, 1: %d, 2: %d, 3: %d, 4: %d, 5: %d 6: %d, 7: %d, 8: %d]\n",
a_xferP->count[0], a_xferP->count[1], a_xferP->count[2],
a_xferP->count[3], a_xferP->count[4], a_xferP->count[5],
a_xferP->count[6], a_xferP->count[7], a_xferP->count[8]);
} /* my_Print_cm_XferTiming() */
/*
* from src/afsmonitor/afsmon-output.c
src/Monitor.xs view on Meta::CPAN
*/
void
my_Print_cm_ErrInfo(a_opIdx, a_opNames, a_opErrP, cm_outFD)
int a_opIdx;
char *a_opNames[];
struct afs_stats_RPCErrors *a_opErrP;
FILE *cm_outFD;
{ /*Print_cm_ErrInfo */
fprintf(cm_outFD,
"%15s: %d server, %d network, %d prot, %d vol, %d busies, %d other\n",
a_opNames[a_opIdx], a_opErrP->err_Server, a_opErrP->err_Network,
a_opErrP->err_Protection, a_opErrP->err_Volume,
a_opErrP->err_VolumeBusies, a_opErrP->err_Other);
} /* my_Print_cm_ErrInfo() */
/*
src/Monitor.xs view on Meta::CPAN
*/
void
my_Print_cm_OpTiming(a_opIdx, a_opNames, a_opTimeP, cm_outFD)
int a_opIdx;
char *a_opNames[];
struct afs_stats_opTimingData *a_opTimeP;
FILE *cm_outFD;
{ /*Print_cm_OpTiming */
fprintf(cm_outFD,
"%15s: %d ops (%d OK); sum=%d.%06d, min=%d.%06d, max=%d.%06d\n",
a_opNames[a_opIdx], a_opTimeP->numOps, a_opTimeP->numSuccesses,
a_opTimeP->sumTime.tv_sec, a_opTimeP->sumTime.tv_usec,
a_opTimeP->minTime.tv_sec, a_opTimeP->minTime.tv_usec,
a_opTimeP->maxTime.tv_sec, a_opTimeP->maxTime.tv_usec);
} /* my_Print_cm_OpTiming() */
src/Monitor.xs view on Meta::CPAN
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_Print_cm_OverallPerfInfo(a_ovP, cm_outFD)
struct afs_stats_CMPerf *a_ovP;
FILE *cm_outFD;
{
fprintf(cm_outFD, "\t%10d numPerfCalls\n", a_ovP->numPerfCalls);
fprintf(cm_outFD, "\t%10d epoch\n", a_ovP->epoch);
fprintf(cm_outFD, "\t%10d numCellsVisible\n", a_ovP->numCellsVisible);
fprintf(cm_outFD, "\t%10d numCellsContacted\n", a_ovP->numCellsContacted);
fprintf(cm_outFD, "\t%10d dlocalAccesses\n", a_ovP->dlocalAccesses);
fprintf(cm_outFD, "\t%10d vlocalAccesses\n", a_ovP->vlocalAccesses);
fprintf(cm_outFD, "\t%10d dremoteAccesses\n", a_ovP->dremoteAccesses);
fprintf(cm_outFD, "\t%10d vremoteAccesses\n", a_ovP->vremoteAccesses);
fprintf(cm_outFD, "\t%10d cacheNumEntries\n", a_ovP->cacheNumEntries);
fprintf(cm_outFD, "\t%10d cacheBlocksTotal\n", a_ovP->cacheBlocksTotal);
fprintf(cm_outFD, "\t%10d cacheBlocksInUse\n", a_ovP->cacheBlocksInUse);
fprintf(cm_outFD, "\t%10d cacheBlocksOrig\n", a_ovP->cacheBlocksOrig);
fprintf(cm_outFD, "\t%10d cacheMaxDirtyChunks\n",
a_ovP->cacheMaxDirtyChunks);
fprintf(cm_outFD, "\t%10d cacheCurrDirtyChunks\n",
a_ovP->cacheCurrDirtyChunks);
fprintf(cm_outFD, "\t%10d dcacheHits\n", a_ovP->dcacheHits);
fprintf(cm_outFD, "\t%10d vcacheHits\n", a_ovP->vcacheHits);
fprintf(cm_outFD, "\t%10d dcacheMisses\n", a_ovP->dcacheMisses);
fprintf(cm_outFD, "\t%10d vcacheMisses\n", a_ovP->vcacheMisses);
fprintf(cm_outFD, "\t%10d cacheFilesReused\n", a_ovP->cacheFilesReused);
fprintf(cm_outFD, "\t%10d vcacheXAllocs\n", a_ovP->vcacheXAllocs);
fprintf(cm_outFD, "\t%10d bufAlloced\n", a_ovP->bufAlloced);
fprintf(cm_outFD, "\t%10d bufHits\n", a_ovP->bufHits);
fprintf(cm_outFD, "\t%10d bufMisses\n", a_ovP->bufMisses);
fprintf(cm_outFD, "\t%10d bufFlushDirty\n", a_ovP->bufFlushDirty);
fprintf(cm_outFD, "\t%10d LargeBlocksActive\n", a_ovP->LargeBlocksActive);
fprintf(cm_outFD, "\t%10d LargeBlocksAlloced\n",
a_ovP->LargeBlocksAlloced);
fprintf(cm_outFD, "\t%10d SmallBlocksActive\n", a_ovP->SmallBlocksActive);
fprintf(cm_outFD, "\t%10d SmallBlocksAlloced\n",
a_ovP->SmallBlocksAlloced);
fprintf(cm_outFD, "\t%10d OutStandingMemUsage\n",
a_ovP->OutStandingMemUsage);
fprintf(cm_outFD, "\t%10d OutStandingAllocs\n", a_ovP->OutStandingAllocs);
fprintf(cm_outFD, "\t%10d CallBackAlloced\n", a_ovP->CallBackAlloced);
fprintf(cm_outFD, "\t%10d CallBackFlushes\n", a_ovP->CallBackFlushes);
fprintf(cm_outFD, "\t%10d srvRecords\n", a_ovP->srvRecords);
fprintf(cm_outFD, "\t%10d srvNumBuckets\n", a_ovP->srvNumBuckets);
fprintf(cm_outFD, "\t%10d srvMaxChainLength\n", a_ovP->srvMaxChainLength);
fprintf(cm_outFD, "\t%10d srvMaxChainLengthHWM\n",
a_ovP->srvMaxChainLengthHWM);
fprintf(cm_outFD, "\t%10d srvRecordsHWM\n", a_ovP->srvRecordsHWM);
fprintf(cm_outFD, "\t%10d sysName_ID\n", a_ovP->sysName_ID);
fprintf(cm_outFD, "\tFile Server up/downtimes, same cell:\n");
my_Print_cm_UpDownStats(&(a_ovP->fs_UpDown[0]), cm_outFD);
fprintf(cm_outFD, "\tFile Server up/downtimes, diff cell:\n");
my_Print_cm_UpDownStats(&(a_ovP->fs_UpDown[1]), cm_outFD);
fprintf(cm_outFD, "\tVL Server up/downtimes, same cell:\n");
my_Print_cm_UpDownStats(&(a_ovP->vl_UpDown[0]), cm_outFD);
fprintf(cm_outFD, "\tVL Server up/downtimes, diff cell:\n");
my_Print_cm_UpDownStats(&(a_ovP->vl_UpDown[1]), cm_outFD);
} /* my_Print_cm_OverallPerfInfo() */
/*
* from src/afsmonitor/afsmon-output.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
src/Monitor.xs view on Meta::CPAN
my_Print_cm_RPCPerfInfo(a_rpcP, cm_outFD)
struct afs_stats_RPCOpInfo *a_rpcP;
FILE *cm_outFD;
{
int currIdx; /*Loop variable */
/*
* Print the contents of each of the opcode-related arrays.
*/
fprintf(cm_outFD, "FS Operation Timings:\n---------------------\n");
for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_RPC_OPS; currIdx++)
my_Print_cm_OpTiming(currIdx, fsOpNames, &(a_rpcP->fsRPCTimes[currIdx]),
cm_outFD);
fprintf(cm_outFD, "\nError Info:\n-----------\n");
for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_RPC_OPS; currIdx++)
my_Print_cm_ErrInfo(currIdx, fsOpNames, &(a_rpcP->fsRPCErrors[currIdx]),
cm_outFD);
fprintf(cm_outFD, "\nTransfer timings:\n-----------------\n");
for (currIdx = 0; currIdx < AFS_STATS_NUM_FS_XFER_OPS; currIdx++)
my_Print_cm_XferTiming(currIdx, xferOpNames,
&(a_rpcP->fsXferTimes[currIdx]), cm_outFD);
fprintf(cm_outFD, "\nCM Operation Timings:\n---------------------\n");
for (currIdx = 0; currIdx < AFS_STATS_NUM_CM_RPC_OPS; currIdx++)
my_Print_cm_OpTiming(currIdx, cmOpNames, &(a_rpcP->cmRPCTimes[currIdx]),
cm_outFD);
} /* my_Print_cm_RPCPerfInfo() */
/*
* from src/afsmonitor/afsmon-output.c
src/Monitor.xs view on Meta::CPAN
/* Ptr to authentication stats */
struct afs_stats_AuthentInfo *authentP;
/* Ptr to access stats */
struct afs_stats_AccessInfo *accessinfP;
/* Correct #longs */
static afs_int32 fullPerfLongs = (sizeof(struct afs_stats_CMFullPerf) >> 2);
/* # longs actually received */
afs_int32 numLongs;
/* Ptr to full perf info */
struct afs_stats_CMFullPerf *fullP;
/* Ptr to printable time string */
char *printableTime;
numLongs = xstat_cm_Results.data.AFSCB_CollData_len;
if (numLongs != fullPerfLongs) {
fprintf(cm_outFD,
" ** Data size mismatch in performance collection!\n");
fprintf(cm_outFD, " ** Expecting %d, got %d\n", fullPerfLongs,
numLongs);
return;
}
printableTime = ctime((time_t *) & (xstat_cm_Results.probeTime));
printableTime[strlen(printableTime) - 1] = '\0';
fullP = (struct afs_stats_CMFullPerf *)
(xstat_cm_Results.data.AFSCB_CollData_val);
fprintf(cm_outFD,
"AFSCB_XSTATSCOLL_FULL_PERF_INFO (coll %d) for CM %s\n[Probe %d, %s]\n\n",
xstat_cm_Results.collectionNumber,
xstat_cm_Results.connP->hostName, xstat_cm_Results.probeNum,
printableTime);
/*
* Print the overall numbers first, followed by all of the RPC numbers,
* then each of the other groupings.
*/
fprintf(cm_outFD,
"Overall Performance Info:\n-------------------------\n");
my_Print_cm_OverallPerfInfo(&(fullP->perf), cm_outFD);
fprintf(cm_outFD, "\n");
my_Print_cm_RPCPerfInfo(&(fullP->rpc), cm_outFD);
authentP = &(fullP->authent);
fprintf(cm_outFD, "\nAuthentication info:\n--------------------\n");
fprintf(cm_outFD,
"\t%d PAGS, %d records (%d auth, %d unauth), %d max in PAG, chain max: %d\n",
authentP->curr_PAGs, authentP->curr_Records,
authentP->curr_AuthRecords, authentP->curr_UnauthRecords,
authentP->curr_MaxRecordsInPAG, authentP->curr_LongestChain);
fprintf(cm_outFD, "\t%d PAG creations, %d tkt updates\n",
authentP->PAGCreations, authentP->TicketUpdates);
fprintf(cm_outFD,
"\t[HWMs: %d PAGS, %d records, %d max in PAG, chain max: %d]\n",
authentP->HWM_PAGs, authentP->HWM_Records,
authentP->HWM_MaxRecordsInPAG, authentP->HWM_LongestChain);
accessinfP = &(fullP->accessinf);
fprintf(cm_outFD,
"\n[Un]replicated accesses:\n------------------------\n");
fprintf(cm_outFD,
"\t%d unrep, %d rep, %d reps accessed, %d max reps/ref, %d first OK\n\n",
accessinfP->unreplicatedRefs, accessinfP->replicatedRefs,
accessinfP->numReplicasAccessed, accessinfP->maxReplicasPerRef,
accessinfP->refFirstReplicaOK);
/* There really isn't any authorship info
* authorP = &(fullP->author); */
} /* my_Print_cm_FullPerfInfo() */
src/Monitor.xs view on Meta::CPAN
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_afsmon_cmOutput(a_outfile, a_detOutput, xstat_cm_Results)
char *a_outfile; /* ptr to output file name */
int a_detOutput; /* detailed output ? */
struct xstat_cm_ProbeResults xstat_cm_Results;
{
char *printTime = 0; /* ptr to time string */
char *hostname = 0; /* fileserner name */
afs_int32 numLongs = 0; /* longwords in result */
afs_int32 *currLong = 0; /* ptr to longwords in result */
int i = 0;
FILE *cm_outFD = 0;
cm_outFD = fopen(a_outfile, "a");
if (cm_outFD == (FILE *) NULL) {
warn("failed to open output file %s", a_outfile);
return;
}
/* get the probe time and strip the \n at the end */
printTime = ctime((time_t *) & (xstat_cm_Results.probeTime));
printTime[strlen(printTime) - 1] = '\0';
hostname = xstat_cm_Results.connP->hostName;
/* print "time hostname CM" prefix */
fprintf(cm_outFD, "\n%s %s CM ", printTime, hostname);
/* if probe failed print -1 and vanish */
if (xstat_cm_Results.probeOK) {
fprintf(cm_outFD, "-1\n");
fclose(cm_outFD);
return;
}
/* print out the probe information as long words */
numLongs = xstat_cm_Results.data.AFSCB_CollData_len;
currLong = (afs_int32 *) (xstat_cm_Results.data.AFSCB_CollData_val);
for (i = 0; i < numLongs; i++) {
fprintf(cm_outFD, "%d ", *currLong++);
}
fprintf(cm_outFD, "\n\n");
/* print detailed information */
if (a_detOutput) {
my_Print_cm_FullPerfInfo(xstat_cm_Results, cm_outFD);
fflush(cm_outFD);
}
fclose(cm_outFD);
} /* my_afsmon_cmOutput() */
/*
* unchanged except for removing debugging print statements at beginning, and one
* correction (replacing xstat_cm_Results with a_cmResults)
*
* from src/afsmonitor/afsmonitor.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
int
my_cm_Results_ltoa(a_cmData, a_cmResults)
struct cm_Display_Data *a_cmData; /* target buffer */
struct xstat_cm_ProbeResults *a_cmResults; /* ptr to xstat cm Results */
src/Monitor.xs view on Meta::CPAN
srcbuf = (afs_int32 *) & (fullP->perf);
idx = 0;
/* we skip the 19 entry, ProtServAddr, so the index must account for this */
for (i = 0; i < NUM_AFS_STATS_CMPERF_LONGS + 1; i++) {
if (i == 19) {
srcbuf++;
continue; /* skip ProtServerAddr */
}
sprintf(a_cmData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* server up/down statistics */
/* copy file server up/down stats */
srcbuf = (afs_int32 *) (fullP->perf.fs_UpDown);
numLongs =
2 * (sizeof(struct afs_stats_SrvUpDownInfo) / sizeof(afs_int32));
for (i = 0; i < numLongs; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy volume location server up/down stats */
srcbuf = (afs_int32 *) (fullP->perf.vl_UpDown);
numLongs =
2 * (sizeof(struct afs_stats_SrvUpDownInfo) / sizeof(afs_int32));
for (i = 0; i < numLongs; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy CMs individual FS RPC operations info */
srcbuf = (afs_int32 *) (fullP->rpc.fsRPCTimes);
for (i = 0; i < AFS_STATS_NUM_FS_RPC_OPS; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numOps */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numSuccesses */
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sum time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sqr time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* min time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* max time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy CMs individual FS RPC errors info */
srcbuf = (afs_int32 *) (fullP->rpc.fsRPCErrors);
for (i = 0; i < AFS_STATS_NUM_FS_RPC_OPS; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* server */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* network */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* prot */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* vol */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* busies */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* other */
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy CMs individual RPC transfers info */
srcbuf = (afs_int32 *) (fullP->rpc.fsXferTimes);
for (i = 0; i < AFS_STATS_NUM_FS_XFER_OPS; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numOps */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numSuccesses */
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sum time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sqr time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* min time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* max time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* sum bytes */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* min bytes */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* max bytes */
idx++;
srcbuf++;
for (j = 0; j < AFS_STATS_NUM_XFER_BUCKETS; j++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* bucket[j] */
idx++;
srcbuf++;
}
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy CM operations timings */
srcbuf = (afs_int32 *) (fullP->rpc.cmRPCTimes);
for (i = 0; i < AFS_STATS_NUM_CM_RPC_OPS; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numOps */
idx++;
srcbuf++;
sprintf(a_cmData->data[idx], "%d", *srcbuf); /* numSuccesses */
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sum time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* sqr time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* min time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
tmpbuf = srcbuf++; /* max time */
sprintf(a_cmData->data[idx], "%d.%06d", *tmpbuf, *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy authentication info */
srcbuf = (afs_int32 *) & (fullP->authent);
numLongs = sizeof(struct afs_stats_AuthentInfo) / sizeof(afs_int32);
for (i = 0; i < numLongs; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
/* copy CM [un]replicated access info */
srcbuf = (afs_int32 *) & (fullP->accessinf);
numLongs = sizeof(struct afs_stats_AccessInfo) / sizeof(afs_int32);
for (i = 0; i < numLongs; i++) {
sprintf(a_cmData->data[idx], "%d", *srcbuf);
idx++;
srcbuf++;
}
/*printf("Ending index value = %d\n",idx-1); */
return (0);
} /* my_cm_Results_ltoa() */
/* cm_Results_to_Hash() */
void
src/Monitor.xs view on Meta::CPAN
struct cm_Display_Data *curr_cmDataP;
struct afsmon_hostEntry *curr_host = 0;
int i = 0;
int code = 0;
int done = 0;
char buff2[256] = "";
curr_cmDataP =
(struct cm_Display_Data *)malloc(sizeof(struct cm_Display_Data));
if (curr_cmDataP == (struct cm_Display_Data *) NULL) {
sprintf(buffer, "Memory allocation failure");
return (-10);
}
memset(curr_cmDataP, 0, sizeof(struct cm_Display_Data));
hv_store(HOSTINFO, "hostName", 8, newSVpv(a_cmResults->connP->hostName, 0),
0);
/* Check the status of the probe. If it succeeded, we store its
* results in the display data structure. If it failed we only mark
* the failed status in the display data structure. */
src/Monitor.xs view on Meta::CPAN
curr_host = CMnameList;
for (i = 0; i < numCM; i++) {
if (strcasecmp(curr_host->hostName, a_cmResults->connP->hostName)
== 0) {
done = 1;
break;
}
curr_host = curr_host->next;;
}
if (!done) {
sprintf(buffer, "Error storing results for CM host %s (100)",
a_cmResults->connP->hostName);
return (100);
}
code = my_check_thresholds(curr_host, HOSTINFO, CM, buff2);
if (code) {
sprintf(buffer, "Error in checking thresholds (105) %s", buff2);
return (105);
}
}
return (0);
} /* my_save_CM_data_forDisplay() */
src/Monitor.xs view on Meta::CPAN
&srvVersionNumber,
&(xstat_cm_Results.probeTime),
&(xstat_cm_Results.data));
code =
ProbeHandler(xstat_cm_Results, xstat_cm_numServers, index,
buff2, argp);
index++;
if (code) {
sprintf(buffer, "Handler routine got error code %d. %s",
code, buff2);
return (code);
}
} /* For each collection */
} /*Valid Rx connection */
/*
* Advance the xstat_fs connection pointer.
*/
src/Monitor.xs view on Meta::CPAN
char *hostNameFound = "";
struct xstat_cm_ConnectionInfo *curr_conn = 0, *xstat_cm_ConnInfo = 0;
struct rx_securityClass *secobj = 0; /*Client security object */
char buff2[256] = "";
int code = 0;
va_list argp;
xstat_cm_ConnInfo = (struct xstat_cm_ConnectionInfo *)
malloc(xstat_cm_numServers * sizeof(struct xstat_cm_ConnectionInfo));
if (xstat_cm_ConnInfo == (struct xstat_cm_ConnectionInfo *) NULL) {
sprintf(buffer,
"Can't allocate %d connection info structs (%d bytes)",
xstat_cm_numServers,
(xstat_cm_numServers * sizeof(struct xstat_cm_ConnectionInfo)));
return (-1); /*No cleanup needs to be done yet */
}
code = rx_Init(htons(0));
if (code) {
sprintf(buffer, "Fatal error in rx_Init(), error=%d", code);
return (-1);
}
/*
* Create a null Rx client security object, to be used by the
* probe LWP.
*/
secobj = rxnull_NewClientSecurityObject();
if (secobj == (struct rx_securityClass *) NULL) {
/*Delete already-malloc'ed areas */
my_xstat_cm_Cleanup(1, xstat_cm_numServers, xstat_cm_ConnInfo, buff2);
sprintf(buffer, "Can't create probe LWP client security object. %s",
buff2);
return (-1);
}
curr_conn = xstat_cm_ConnInfo;
conn_err = 0;
for (curr_srv = 0; curr_srv < xstat_cm_numServers; curr_srv++) {
/*
* Copy in the socket info for the current server, resolve its
* printable name if possible.
*/
memcpy(&(curr_conn->skt), a_socketArray + curr_srv,
sizeof(struct sockaddr_in));
hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == NULL) {
warn("Can't map Internet address %lu to a string name",
curr_conn->skt.sin_addr.s_addr);
curr_conn->hostName[0] = '\0';
src/Monitor.xs view on Meta::CPAN
/*
* Make an Rx connection to the current server.
*/
curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
curr_conn->skt.sin_port, /*Server port */
1, /*AFS service # */
secobj, /*Security obj */
0); /*# of above */
if (curr_conn->rxconn == (struct rx_connection *) NULL) {
sprintf(buffer,
"Can't create Rx connection to server '%s' (%lu)",
curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
my_xstat_cm_Cleanup(1, xstat_cm_numServers, xstat_cm_ConnInfo,
buff2);
return (-2);
}
/*
* Bump the current xstat_fs connection to set up.
*/
curr_conn++;
src/Monitor.xs view on Meta::CPAN
{
int code = 0; /*Return code */
int conn_idx = 0; /*Current connection index */
struct xstat_cm_ConnectionInfo *curr_conn = 0; /*Ptr to xstat_fs connection */
/*
* Take care of all Rx connections first. Check to see that the
* server count is a legal value.
*/
if (xstat_cm_numServers <= 0) {
sprintf(buffer,
"Illegal number of servers (xstat_cm_numServers = %d)",
xstat_cm_numServers);
code = -1;
}
else {
if (xstat_cm_ConnInfo != (struct xstat_cm_ConnectionInfo *) NULL) {
/*
* The xstat_fs connection structure array exists. Go through
* it and close up any Rx connections it holds.
*/
src/Monitor.xs view on Meta::CPAN
afs_int32 code;
HV *LOCK;
HV *LOCKDESC;
for (i = 0; i < 1000; i++) {
code = RXAFSCB_GetLock(aconn, i, &lock);
if (code) {
if (code == 1)
break;
/* otherwise we have an unrecognized error */
sprintf(buffer, "cmdebug: error checking locks: %s",
error_message(code));
return code;
}
/* here we have the lock information, so display it, perhaps */
if (aint32 || IsLocked(&lock.lock)) {
LOCK = newHV();
hv_store(LOCK, "name", 4, newSVpv(lock.name, 0), 0);
LOCKDESC = newHV();
my_PrintLock(&lock.lock, LOCKDESC);
hv_store(LOCK, "lock", 4, newRV_inc((SV *) LOCKDESC), 0);
src/Monitor.xs view on Meta::CPAN
char *cellname;
HV *NETFID;
HV *CENTRY;
HV *LOCK;
for (i = 0; i < 10000; i++) {
code = RXAFSCB_GetCE(aconn, i, ¢ry);
if (code) {
if (code == 1)
break;
sprintf(buffer, "cmdebug: failed to get cache entry %d (%s)", i,
error_message(code));
return code;
}
CENTRY = newHV();
hv_store(CENTRY, "addr", 4, newSViv(centry.addr), 0);
if (centry.addr == 0) {
/* PS output */
src/Monitor.xs view on Meta::CPAN
char *cellname;
HV *NETFID;
HV *CENTRY;
HV *LOCK;
for (i = 0; i < 10000; i++) {
code = RXAFSCB_GetCE(aconn, i, ¢ry);
if (code) {
if (code == 1)
break;
sprintf(buffer, "cmdebug: failed to get cache entry %d (%s)\n", i,
error_message(code));
return code;
}
CENTRY = newHV();
hv_store(CENTRY, "addr", 4, newSViv(centry.addr), 0);
if (centry.addr == 0) {
/* PS output */
printf("Proc %4d sleeping at %08x, pri %3d\n",
centry.netFid.Vnode, centry.netFid.Volume,
centry.netFid.Unique - 25);
continue;
}
if (((aint32 == 0) && !IsLocked(¢ry.lock)) ||
((aint32 == 2) && (centry.refCount == 0)) ||
((aint32 == 4) && (centry.callback == 0)))
continue;
/* otherwise print this entry */
hv_store(CENTRY, "cell", 4, newSViv(centry.cell), 0);
NETFID = newHV();
hv_store(NETFID, "Vnode", 5, newSViv(centry.netFid.Vnode), 0);
hv_store(NETFID, "Volume", 6, newSViv(centry.netFid.Volume), 0);
hv_store(NETFID, "Unique", 6, newSViv(centry.netFid.Unique), 0);
hv_store(CENTRY, "netFid", 6, newRV_inc((SV *) NETFID), 0);
#ifdef USE_GETCELLNAME
cellname = GetCellName(aconn, centry.cell);
if (cellname)
src/Monitor.xs view on Meta::CPAN
char *data_name;
HV *NETFID;
HV *CENTRY;
HV *LOCK;
for (i = 0; i < 10000; i++) {
code = RXAFSCB_GetCE64(aconn, i, ¢ry);
if (code) {
if (code == 1)
break;
sprintf(buffer, "cmdebug: failed to get cache entry %d (%s)\n", i,
error_message(code));
return code;
}
CENTRY = newHV();
hv_store(CENTRY, "addr", 4, newSViv(centry.addr), 0);
if (centry.addr == 0) {
/* PS output */
src/Monitor.xs view on Meta::CPAN
hv_store(CENTRY, "netFid", 6, newRV_inc((SV *) NETFID), 0);
av_store(CACHE_ENTRIES, i, newRV_inc((SV *) CENTRY));
continue;
}
if (((aint32 == 0) && !IsLocked(¢ry.lock)) ||
((aint32 == 2) && (centry.refCount == 0)) ||
((aint32 == 4) && (centry.callback == 0)))
continue;
/* otherwise print this entry */
hv_store(CENTRY, "cell", 4, newSViv(centry.cell), 0);
NETFID = newHV();
hv_store(NETFID, "Vnode", 5, newSViv(centry.netFid.Vnode), 0);
hv_store(NETFID, "Volume", 6, newSViv(centry.netFid.Volume), 0);
hv_store(NETFID, "Unique", 6, newSViv(centry.netFid.Unique), 0);
hv_store(CENTRY, "netFid", 6, newRV_inc((SV *) NETFID), 0);
#ifdef USE_GETCELLNAME
cellname = GetCellName(aconn, centry.cell);
if (cellname)
src/Monitor.xs view on Meta::CPAN
else if (centry.mvstat == 5)
data_name = "microsoft dfs link";
else if (centry.mvstat == 6)
data_name = "invalid link";
else
data_name = "bogus mvstat";
hv_store(CENTRY, "mvstat", 6, newSVpv(data_name, strlen(data_name)), 0);
data_name = "";
if (centry.states & 1)
sprintf(data_name, "%s, stat'd", data_name);
if (centry.states & 2)
sprintf(data_name, "%s, backup", data_name);
if (centry.states & 4)
sprintf(data_name, "%s, read-only", data_name);
if (centry.states & 8)
sprintf(data_name, "%s, mt pt valid", data_name);
if (centry.states & 0x10)
sprintf(data_name, "%s, pending core", data_name);
if (centry.states & 0x40)
sprintf(data_name, "%s, wait-for-store", data_name);
if (centry.states & 0x80)
sprintf(data_name, "%s, mapped", data_name);
hv_store(CENTRY, "states", 6, newSVpv(data_name, strlen(data_name)), 0);
av_store(CACHE_ENTRIES, i, newRV_inc((SV *) CENTRY));
}
return 0;
}
/*
* from src/venus/cmdebug.c
src/Monitor.xs view on Meta::CPAN
{
static char rn[] = "fsprobe_LWP"; /*Routine name */
register afs_int32 code = 0; /*Results of calls */
int conn_idx; /*Connection index */
struct fsprobe_ConnectionInfo *curr_conn; /*Current connection */
struct ProbeViceStatistics *curr_stats; /*Current stats region */
int *curr_probeOK; /*Current probeOK field */
int i;
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Called\n", rn);
fprintf(scout_debugfd,
"[%s] Collecting data from %d connected servers\n", rn,
fsprobe_numServers);
fflush(scout_debugfd);
}
curr_conn = fsprobe_ConnInfo;
curr_stats = fsprobe_Results->stats;
curr_probeOK = fsprobe_Results->probeOK;
fsprobe_Results->probeNum++;
memset(fsprobe_Results->stats, 0, fsprobe_statsBytes);
memset(fsprobe_Results->probeOK, 0, fsprobe_probeOKBytes);
for (conn_idx = 0; conn_idx < fsprobe_numServers; conn_idx++) {
/*
* Grab the statistics for the current FileServer, if the
* connection is valid.
*/
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Contacting server %s\n", rn,
curr_conn->hostName);
fflush(scout_debugfd);
}
if (curr_conn->rxconn != (struct rx_connection *) NULL) {
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Connection valid, calling RXAFS_GetStatistics\n",
rn);
fflush(scout_debugfd);
}
*curr_probeOK = RXAFS_GetStatistics(curr_conn->rxconn, (struct ViceStatistics *)curr_stats);
} /*Valid Rx connection */
/*
* Call the Volume Server too to get additional stats
*/
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Contacting volume server %s\n", rn,
curr_conn->hostName);
fflush(scout_debugfd);
}
if (curr_conn->rxVolconn != (struct rx_connection *) NULL) {
char pname[10];
struct diskPartition partition;
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Connection valid, calling RXAFS_GetStatistics\n",
rn);
fflush(scout_debugfd);
}
for (i = 0; i < curr_conn->partCnt; i++) {
if (curr_conn->partList.partFlags[i] & PARTVALID) {
MapPartIdIntoName(curr_conn->partList.partId[i], pname);
code =
AFSVolPartitionInfo(curr_conn->rxVolconn, pname,
&partition);
if (code) {
sprintf(buffer,
"Could not get information on server %s partition %s",
curr_conn->hostName, pname);
}
else {
curr_stats->Disk[i].BlocksAvailable = partition.free;
curr_stats->Disk[i].TotalBlocks = partition.minFree;
strcpy(curr_stats->Disk[i].Name, pname);
}
}
}
src/Monitor.xs view on Meta::CPAN
afs_int32 *cntp;
FILE *scout_debugfd;
{
struct pIDs partIds;
struct partEntries partEnts;
register int i, j = 0, code;
static int newvolserver = 0;
static char rn[] = "my_XListPartitions";
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Called\n", rn);
fflush(scout_debugfd);
}
*cntp = 0;
if (newvolserver == 1) {
for (i = 0; i < 26; i++)
partIds.partIds[i] = -1;
tryold:
code = AFSVolListPartitions(aconn, &partIds);
if (!code) {
src/Monitor.xs view on Meta::CPAN
FILE *scout_debugfd;
char *buffer;
{
int code = 0; /*Return code */
int conn_idx; /*Current connection index */
struct fsprobe_ConnectionInfo *curr_conn; /*Ptr to fsprobe connection */
static char rn[] = "my_fsprobe_Cleanup";
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Called\n", rn);
fflush(scout_debugfd);
}
/*
* Take care of all Rx connections first. Check to see that the
* server count is a legal value.
*/
if (fsprobe_numServers <= 0) {
sprintf(buffer,
"[%s] Illegal number of servers to clean up (fsprobe_numServers = %d)",
rn, fsprobe_numServers);
code = -1;
}
else {
if (fsprobe_ConnInfo != (struct fsprobe_ConnectionInfo *) NULL) {
/*
* The fsprobe connection structure array exists. Go through it
* and close up any Rx connections it holds.
*/
src/Monitor.xs view on Meta::CPAN
struct rx_service *rxsrv_afsserver;
char buff2[256] = "";
struct rx_call *rxcall; /*Bogus param */
AFSCBFids *Fids_Array; /*Bogus param */
AFSCBs *CallBack_Array; /*Bogus param */
struct interfaceAddr *interfaceAddr; /*Bogus param */
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Called\n", rn);
fflush(scout_debugfd);
}
if (a_numServers <= 0) {
sprintf(buffer, "[%s] Illegal number of servers: %d", rn, a_numServers);
return (-1);
}
if (a_socketArray == (struct sockaddr_in *) NULL) {
sprintf(buffer, "[%s] Null server socket array argument", rn);
return (-1);
}
memset(fsprobe_Results, 0, sizeof(struct fsprobe_ProbeResults));
rxcall = (struct rx_call *) NULL;
Fids_Array = (AFSCBFids *) NULL;
CallBack_Array = (AFSCBs *) NULL;
interfaceAddr = (struct interfaceAddr *) NULL;
SRXAFSCB_CallBack(rxcall, Fids_Array, CallBack_Array);
SRXAFSCB_InitCallBackState2(rxcall, interfaceAddr);
SRXAFSCB_Probe(rxcall);
*fsprobe_ConnInfo = (struct fsprobe_ConnectionInfo *)
malloc(a_numServers * sizeof(struct fsprobe_ConnectionInfo));
if (*fsprobe_ConnInfo == (struct fsprobe_ConnectionInfo *) NULL) {
sprintf(buffer,
"[%s] Can't allocate %d connection info structs (%d bytes)\n",
rn, a_numServers,
(a_numServers * sizeof(struct fsprobe_ConnectionInfo)));
return (-1); /*No cleanup needs to be done yet */
}
else if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] *fsprobe_ConnInfo allocated (%d bytes)\n",
rn, a_numServers * sizeof(struct fsprobe_ConnectionInfo));
fflush(scout_debugfd);
}
fsprobe_statsBytes = a_numServers * sizeof(struct ProbeViceStatistics);
fsprobe_Results->stats = (struct ProbeViceStatistics *)
malloc(fsprobe_statsBytes);
if (fsprobe_Results->stats == (struct ProbeViceStatistics *) NULL) {
/*Delete already-malloc'ed areas */
my_fsprobe_Cleanup(fsprobe_Results, *fsprobe_ConnInfo, a_numServers,
scout_debugfd, buff2);
sprintf(buffer,
"[%s] Can't allocate %d statistics structs (%d bytes). %s", rn,
a_numServers, fsprobe_statsBytes, buff2);
return (-1);
}
else if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] fsprobe_Results->stats allocated (%d bytes)\n", rn,
fsprobe_statsBytes);
fflush(scout_debugfd);
}
fsprobe_probeOKBytes = a_numServers * sizeof(int);
fsprobe_Results->probeOK = (int *)malloc(fsprobe_probeOKBytes);
if (fsprobe_Results->probeOK == (int *) NULL) {
/* Delete already-malloc'ed areas */
my_fsprobe_Cleanup(fsprobe_Results, *fsprobe_ConnInfo, a_numServers,
scout_debugfd, buff2);
sprintf(buffer,
"[%s] Can't allocate %d probeOK array entries (%d bytes). %s",
rn, a_numServers, fsprobe_probeOKBytes, buff2);
return (-1);
}
else if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] fsprobe_Results->probeOK allocated (%d bytes)\n",
rn, fsprobe_probeOKBytes);
fflush(scout_debugfd);
}
fsprobe_Results->probeNum = 0;
fsprobe_Results->probeTime = 0;
memset(fsprobe_Results->stats, 0,
(a_numServers * sizeof(struct ProbeViceStatistics)));
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Initializing Rx\n", rn);
fflush(scout_debugfd);
}
PortToUse = FSPROBE_CBPORT;
do {
code = rx_Init(htons(PortToUse));
if (code) {
if (code == RX_ADDRINUSE) {
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Callback port %d in use, advancing\n", rn,
PortToUse);
fflush(scout_debugfd);
}
PortToUse++;
}
else {
sprintf(buffer, "[%s] Fatal error in rx_Init()\n", rn);
return (-1);
}
}
} while (code);
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Rx initialized on port %d\n", rn,
PortToUse);
fflush(scout_debugfd);
}
/*
* Create a null Rx server security object, to be used by the
* Callback listener.
*/
CBsecobj = (struct rx_securityClass *)rxnull_NewServerSecurityObject();
if (CBsecobj == (struct rx_securityClass *) NULL) {
/*Delete already-malloc'ed areas */
my_fsprobe_Cleanup(fsprobe_Results, *fsprobe_ConnInfo, a_numServers,
scout_debugfd, buff2);
sprintf(buffer,
"[%s] Can't create null security object for the callback listener. %s",
rn, buff2);
return (-1);
}
if (scout_debugfd)
fprintf(scout_debugfd, "[%s] Callback server security object created\n",
rn);
/*
* Create a null Rx client security object, to be used by the
* probe LWP.
*/
secobj = (struct rx_securityClass *)rxnull_NewClientSecurityObject();
if (secobj == (struct rx_securityClass *) NULL) {
/*Delete already-malloc'ed areas */
my_fsprobe_Cleanup(fsprobe_Results, *fsprobe_ConnInfo, a_numServers,
scout_debugfd, buff2);
sprintf(buffer,
"[%s] Can't create client security object for probe LWP. %s",
rn, buff2);
return (-1);
}
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Probe LWP client security object created\n", rn);
fflush(scout_debugfd);
}
curr_conn = *fsprobe_ConnInfo;
conn_err = 0;
for (curr_srv = 0; curr_srv < a_numServers; curr_srv++) {
/*
* Copy in the socket info for the current server, resolve its
* printable name if possible.
*/
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Copying in the following socket info:\n", rn);
fprintf(scout_debugfd, "[%s] IP addr 0x%lx, port %d\n", rn,
(a_socketArray + curr_srv)->sin_addr.s_addr,
(a_socketArray + curr_srv)->sin_port);
fflush(scout_debugfd);
}
memcpy(&(curr_conn->skt), a_socketArray + curr_srv,
sizeof(struct sockaddr_in));
hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == (char *) NULL) {
warn("Can't map Internet address %lu to a string name\n",
curr_conn->skt.sin_addr.s_addr);
curr_conn->hostName[0] = '\0';
}
else {
strcpy(curr_conn->hostName, hostNameFound);
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Host name for server index %d is %s\n", rn,
curr_srv, curr_conn->hostName);
fflush(scout_debugfd);
}
}
/*
* Make an Rx connection to the current server.
*/
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Connecting to srv idx %d, IP addr 0x%lx, port %d, service 1\n",
rn, curr_srv, curr_conn->skt.sin_addr.s_addr,
curr_conn->skt.sin_port);
fflush(scout_debugfd);
}
curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
curr_conn->skt.sin_port, /*Server port */
1, /*AFS service num */
secobj, /*Security object */
0); /*Number of above */
if (curr_conn->rxconn == (struct rx_connection *) NULL) {
sprintf(buffer,
"[%s] Can't create Rx connection to server %s (%lu)",
rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
conn_err = 1;
}
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] New connection at 0x%lx\n",
rn, curr_conn->rxconn);
fflush(scout_debugfd);
}
/*
* Make an Rx connection to the current volume server.
*/
if (scout_debugfd) {
fprintf(scout_debugfd,
"[%s] Connecting to srv idx %d, IP addr 0x%lx, port %d, service 1\n",
rn, curr_srv, curr_conn->skt.sin_addr.s_addr, htons(7005));
fflush(scout_debugfd);
}
curr_conn->rxVolconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
htons(AFSCONF_VOLUMEPORT), /*Volume Server port */
VOLSERVICE_ID, /*AFS service num */
secobj, /*Security object */
0); /*Number of above */
if (curr_conn->rxVolconn == (struct rx_connection *) NULL) {
sprintf(buffer,
"[%s] Can't create Rx connection to volume server %s (%lu)\n",
rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
conn_err = 1;
}
else {
int i, cnt;
memset(&curr_conn->partList, 0, sizeof(struct partList));
curr_conn->partCnt = 0;
i = my_XListPartitions(curr_conn->rxVolconn, &curr_conn->partList,
&cnt, scout_debugfd);
if (!i) {
curr_conn->partCnt = cnt;
}
}
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] New connection at 0x%lx\n",
rn, curr_conn->rxVolconn);
fflush(scout_debugfd);
}
/*
* Bump the current fsprobe connection to set up.
*/
curr_conn++;
} /*for curr_srv */
/*
* Create the AFS callback service (listener).
*/
if (scout_debugfd)
fprintf(scout_debugfd, "[%s] Creating AFS callback listener\n", rn);
rxsrv_afsserver = rx_NewService(0, /*Use default port */
1, /*Service ID */
"afs", /*Service name */
&CBsecobj, /*Ptr to security object(s) */
1, /*Number of security objects */
RXAFSCB_ExecuteRequest); /*Dispatcher */
if (rxsrv_afsserver == (struct rx_service *) NULL) {
/*Delete already-malloc'ed areas */
my_fsprobe_Cleanup(fsprobe_Results, *fsprobe_ConnInfo, a_numServers,
scout_debugfd, buff2);
sprintf(buffer, "[%s] Can't create callback Rx service/listener. %s",
rn, buff2);
return (-1);
}
if (scout_debugfd)
fprintf(scout_debugfd, "[%s] Callback listener created\n", rn);
/*
* Start up the AFS callback service.
*/
if (scout_debugfd)
fprintf(scout_debugfd, "[%s] Starting up callback listener.\n", rn);
rx_StartServer(0 /*Don't donate yourself to LWP pool */ );
/* start probe */
code = my_fsprobe_LWP(a_numServers, *fsprobe_ConnInfo, fsprobe_Results,
fsprobe_statsBytes, fsprobe_probeOKBytes,
scout_debugfd, RETVAL, buffer);
if (code)
return (code);
if (conn_err)
src/Monitor.xs view on Meta::CPAN
ViceDisk *curr_diskstat;
int curr_disk;
int *curr_probeOK; /*Ptr to current probeOK field */
int i = 0, j = 0;
HV *RESULTS;
HV *STATS;
AV *DISKS;
HV *DISK;
if (scout_debugfd) {
fprintf(scout_debugfd, "[%s] Called\n", rn);
fflush(scout_debugfd);
}
curr_stats = fsprobe_Results.stats;
curr_probeOK = fsprobe_Results.probeOK;
curr_conn = fsprobe_ConnInfo;
for (i = 0; i < numServers; i++) {
RESULTS = newHV();
src/Monitor.xs view on Meta::CPAN
afs_int32 *currInt32;
register int i;
char temp[100];
HV *DATA = newHV();
numInt32s = xstat_fs_Results->data.AFS_CollData_len;
hv_store(DATA, "AFS_CollData_len", 16, newSViv(numInt32s), 0);
currInt32 = (afs_int32 *) (xstat_fs_Results->data.AFS_CollData_val);
for (i = 0; i < numInt32s; i++) {
sprintf(temp, "%d", i);
hv_store(DATA, temp, strlen(temp), newSViv(*currInt32++), 0);
}
hv_store(HOSTINFO, "data", 4, newRV_inc((SV *) DATA), 0);
}
/*
* from src/xstat/xstat_fs_test.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
src/Monitor.xs view on Meta::CPAN
my_fs_PrintFullPerfInfo(&xstat_fs_Results, HOSTINFO);
break;
#ifndef NOAFS_XSTATSCOLL_CBSTATS
case AFS_XSTATSCOLL_CBSTATS:
my_fs_PrintCbCounters(&xstat_fs_Results, HOSTINFO);
break;
#endif
default:
sprintf(buffer, "** Unknown collection: %d",
xstat_fs_Results.collectionNumber);
return (-1);
}
}
av_store(RETVAL, index, newRV_inc((SV *) HOSTINFO));
return (0);
}
/* end of xstat_fs_test helper functions */
src/Monitor.xs view on Meta::CPAN
/* xstat_cm_test helper functions */
/*
* from src/xstat/xstat_cm_test.c
* ("$Header: /afs/slac/g/scs/slur/Repository/AFSDebug/Debug/src/Monitor.xs,v 1.2 2006/07/05 22:25:10 alfw Exp $");
*/
void
my_print_cmCallStats(struct xstat_cm_ProbeResults *xstat_cm_Results, HV *HOSTINFO)
{
struct afs_CMStats *cmp;
HV *DATA = newHV();
char *data_name;
cmp = (struct afs_CMStats *)(xstat_cm_Results->data.AFSCB_CollData_val);
data_name = "afs_init";
hv_store(DATA, data_name, strlen(data_name),
newSViv(cmp->callInfo.C_afs_init), 0);
src/Monitor.xs view on Meta::CPAN
void
my_cm_PrintUpDownStats(struct afs_stats_SrvUpDownInfo *a_upDownP, AV *UPDOWN, int index)
{
HV *INFO = newHV();
AV *DOWNDURATIONS = newAV();
AV *DOWNINCIDENTS = newAV();
int i;
/*
* First, print the simple values.
*/
hv_store(INFO, "numTtlRecords", strlen("numTtlRecords"),
newSViv(a_upDownP->numTtlRecords), 0);
hv_store(INFO, "numUpRecords", strlen("numUpRecords"),
newSViv(a_upDownP->numUpRecords), 0);
hv_store(INFO, "numDownRecords", strlen("numDownRecords"),
newSViv(a_upDownP->numDownRecords), 0);
hv_store(INFO, "sumOfRecordAges", strlen("sumOfRecordAges"),
newSViv(a_upDownP->sumOfRecordAges), 0);
hv_store(INFO, "ageOfYoungestRecord", strlen("ageOfYoungestRecord"),
src/Monitor.xs view on Meta::CPAN
hv_store(INFO, "maxDowntimesInARecord", strlen("maxDowntimesInARecord"),
newSViv(a_upDownP->maxDowntimesInARecord), 0);
hv_store(INFO, "sumOfDowntimes", strlen("sumOfDowntimes"),
newSViv(a_upDownP->sumOfDowntimes), 0);
hv_store(INFO, "shortestDowntime", strlen("shortestDowntime"),
newSViv(a_upDownP->shortestDowntime), 0);
hv_store(INFO, "longestDowntime", strlen("longestDowntime"),
newSViv(a_upDownP->longestDowntime), 0);
/*
* Now, print the array values.
*/
for (i = 0; i <= 6; i++) {
av_store(DOWNDURATIONS, i, newSViv(a_upDownP->downDurations[i]));
}
for (i = 0; i <= 5; i++) {
av_store(DOWNINCIDENTS, i, newSViv(a_upDownP->downIncidents[i]));
}
hv_store(INFO, "downDurations", 13, newRV_inc((SV *) DOWNDURATIONS), 0);
hv_store(INFO, "downIncidents", 13, newRV_inc((SV *) DOWNINCIDENTS), 0);
av_store(UPDOWN, index, newRV_inc((SV *) INFO));
src/Monitor.xs view on Meta::CPAN
hv_store(HOSTINFO, "collectionNumber", 16,
newSViv(xstat_cm_Results.collectionNumber), 0);
hv_store(HOSTINFO, "probeTime", 9, newSViv(xstat_cm_Results.probeTime), 0);
if (xstat_cm_Results.probeOK == 0) {
switch (xstat_cm_Results.collectionNumber) {
/* Why are so many things commented out? -EC */
case AFSCB_XSTATSCOLL_CALL_INFO:
/* Why was this commented out in 3.3 ? */
/* PrintCallInfo(); */
my_print_cmCallStats(&xstat_cm_Results, HOSTINFO);
break;
case AFSCB_XSTATSCOLL_PERF_INFO:
/* we will do nothing here */
/* PrintPerfInfo(); */
my_cm_PrintPerfInfo(&xstat_cm_Results, HOSTINFO);
break;
case AFSCB_XSTATSCOLL_FULL_PERF_INFO:
my_cm_PrintFullPerfInfo(&xstat_cm_Results, HOSTINFO);
break;
default:
sprintf(buffer, "** Unknown collection: %d",
xstat_cm_Results.collectionNumber);
return (-1);
}
}
av_store(RETVAL, index, newRV_inc((SV *) HOSTINFO));
return (0);
}
src/Monitor.xs view on Meta::CPAN
else if(strncmp(key, "cmname", keylen) == 0 && keylen <= 6) {
if (SvROK(value))
host_array = (AV*) SvRV(value);
else {
host_array = av_make(1, &value);
sv_2mortal((SV *) host_array);
}
numCMs = av_len(host_array) + 1;
}
else {
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
} /* end ifs */
} /* end while */
/* done parsing arguments */
if (host_array == 0) {
sprintf(buffer, "Missing required parameter 'cmname'");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (numCMs == 0) {
sprintf(buffer, "The field 'cmname' isn't completed properly");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (coll_array == 0) {
sprintf(buffer, "Missing required parameter 'collID'");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (numCollIDs == 0) {
sprintf(buffer, "The field 'collID' isn't completed properly");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
CMSktArray = (struct sockaddr_in *)
malloc(numCMs * sizeof(struct sockaddr_in));
if (CMSktArray == (struct sockaddr_in *) NULL) {
sprintf(buffer, "Can't allocate socket array for %d Cache Managers",
numCMs);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
for (currCM = 0; currCM < numCMs; currCM++) {
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
CMSktArray[currCM].sin_family = AF_INET; /*Internet family */
#else
CMSktArray[currCM].sin_family = htons(AF_INET); /*Internet family */
#endif
CMSktArray[currCM].sin_port = htons(7001); /*Cache Manager port */
he = hostutil_GetHostByName((char *) SvPV(*av_fetch(host_array, currCM, 0), PL_na));
if (he == (struct hostent *) NULL) {
sprintf(buffer,
"Can't get host info for '%s'\n",
(char *) SvPV(*av_fetch(host_array, currCM, 0), PL_na));
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memcpy(&(CMSktArray[currCM].sin_addr.s_addr), he->h_addr, 4);
} /*Get socket info for each Cache Manager*/
collIDP = (afs_int32 *) malloc(numCollIDs * sizeof(afs_int32));
src/Monitor.xs view on Meta::CPAN
else {
host_array = av_make(1, &value);
sv_2mortal((SV *) host_array);
}
numFSs = av_len(host_array) + 1;
} else goto unrecognized;
break;
default:
unrecognized:
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
break;
} /* end switch */
} /* end while */
/* done parsing arguments */
if (host_array == 0) {
sprintf(buffer, "Missing required parameter 'fsname'");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (numFSs == 0) {
sprintf(buffer, "The field 'fsname' isn't completed properly");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (coll_array == 0) {
sprintf(buffer, "Missing required parameter 'collID'");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
else if (numCollIDs == 0) {
sprintf(buffer, "The field 'collID' isn't completed properly");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
sktbytes = numFSs * sizeof(struct sockaddr_in);
FSSktArray = (struct sockaddr_in *) malloc(sktbytes);
if (FSSktArray == (struct sockaddr_in *) NULL) {
sprintf(buffer,
"Can't malloc() %d sockaddrs (%d bytes) for the given file servers",
numFSs, sktbytes);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memset(FSSktArray, 0, sktbytes);
/*
* Fill in the socket array for each of the File Servers listed.
*/
for (currFS = 0; currFS < numFSs; currFS++) {
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
FSSktArray[currFS].sin_family = AF_INET; /*Internet family */
#else
FSSktArray[currFS].sin_family = htons(AF_INET); /*Internet family */
#endif
FSSktArray[currFS].sin_port = htons(7000); /*FileServer port*/
he = hostutil_GetHostByName((char *) SvPV(*av_fetch(host_array, currFS, 0), PL_na));
if (he == (struct hostent *) NULL) {
sprintf(buffer,
"Can't get host info for '%s'",
(char *) SvPV(*av_fetch(host_array, currFS, 0), PL_na));
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memcpy(&(FSSktArray[currFS].sin_addr.s_addr), he->h_addr, 4);
} /*Get socket info for each File Server*/
collIDP = (afs_int32 *) malloc(numCollIDs * sizeof(afs_int32));
src/Monitor.xs view on Meta::CPAN
/* parse arguments */
num_args = hv_iterinit(args);
while (num_args--) {
value = hv_iternextsv(args, &key, &keylen);
switch (*key) {
case 'b':
if(strncmp(key, "basename", keylen) == 0 && keylen <= 8) {
sprintf(basename, "%s", SvPV(value, PL_na));
} else goto unrecognized;
break;
case 'd':
if(strncmp(key, "debug", keylen) == 0 && keylen <= 5) {
debug_filename = (char *) SvPV(value, PL_na);
} else goto unrecognized;
break;
case 's':
src/Monitor.xs view on Meta::CPAN
else {
host_array = av_make(1, &value);
sv_2mortal((SV *) host_array);
}
numservers = av_len(host_array) + 1;
} else goto unrecognized;
break;
default:
unrecognized:
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
break;
} /* end switch */
} /* end while */
/* done parsing arguments */
if(numservers == 0) {
sprintf(buffer, "Missing required parameter 'server'");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
if(debug_filename) {
scout_debugfd = fopen(debug_filename, "w");
if(scout_debugfd == (FILE *) NULL) {
sprintf(buffer, "Can't open debugging file '%s'!", debug_filename);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
fprintf(scout_debugfd, "[%s] Writing to Scout debugging file '%s'\n",
rn, debug_filename);
fflush(scout_debugfd);
}
/* execute_scout */
sktbytes = numservers * sizeof(struct sockaddr_in);
FSSktArray = (struct sockaddr_in *) malloc(sktbytes);
if (FSSktArray == (struct sockaddr_in *) NULL) {
sprintf(buffer,
"Can't malloc() %d sockaddrs (%d bytes) for the given servers",
numservers, sktbytes);
BSETCODE(-1, buffer);
if (scout_debugfd != (FILE *) NULL) {
fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
fclose(scout_debugfd);
}
XSRETURN_UNDEF;
}
memset(FSSktArray, 0, sktbytes);
curr_skt = FSSktArray;
for(i=0; i<numservers; i++) {
if(*basename == '\0')
sprintf(fullsrvname, "%s", (char *) SvPV(*av_fetch(host_array, i, 0), PL_na));
else
sprintf(fullsrvname, "%s.%s", (char *) SvPV(*av_fetch(host_array, i, 0), PL_na), basename);
he = hostutil_GetHostByName(fullsrvname);
if(he == (struct hostent *) NULL) {
sprintf(buffer, "Can't get host info for '%s'", fullsrvname);
BSETCODE(-1, buffer);
if (scout_debugfd != (FILE *) NULL) {
fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
fclose(scout_debugfd);
}
XSRETURN_UNDEF;
}
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
curr_skt->sin_family = AF_INET; /*Internet family */
#else
curr_skt->sin_family = htons(AF_INET); /*Internet family */
#endif
curr_skt->sin_port = htons(7000); /* FileServer port */
curr_skt++;
}
code = my_fsprobe_Init(&fsprobe_Results, &fsprobe_ConnInfo, numservers,
FSSktArray, RETVAL, scout_debugfd, buffer);
if(code) {
if(buffer == "") {
sprintf(buffer, "Error returned by fsprobe_Init: %d", code);
}
BSETCODE(code, buffer);
if (scout_debugfd != (FILE *) NULL) {
fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
fclose(scout_debugfd);
}
XSRETURN_UNDEF;
}
code = my_FS_Handler(fsprobe_Results, numservers, fsprobe_ConnInfo,
scout_debugfd, RETVAL, buff2);
if (code) {
sprintf(buffer, "[%s] Handler routine returned error code %d. %s", rn, code, buff2);
BSETCODE(code, buffer);
if (scout_debugfd != (FILE *) NULL) {
fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
fclose(scout_debugfd);
}
XSRETURN_UNDEF;
}
if (scout_debugfd != (FILE *) NULL) {
fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
fclose(scout_debugfd);
}
ST(0) = sv_2mortal(newRV_inc((SV*)RETVAL));
SETCODE(0);
XSRETURN(1);
}
void
afs_do_udebug(args)
src/Monitor.xs view on Meta::CPAN
break;
case 's':
if(strncmp(key, "server", keylen) == 0 && keylen <= 6) {
hostName = (char *) SvPV(value, PL_na);
} else goto unrecognized;
break;
default:
unrecognized:
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
break;
} /* end switch */
} /* end while */
/* done parsing arguments */
/* lookup host */
if (hostName) {
th = hostutil_GetHostByName(hostName);
if (!th) {
sprintf(buffer, "udebug: host %s not found in host table", hostName);
BSETCODE(1, buffer);
XSRETURN_UNDEF;
}
memcpy(&hostAddr, th->h_addr, sizeof(afs_int32));
}
else hostAddr = htonl(0x7f000001); /* IP localhost */
if (!portName)
port = htons(3000); /* default */
else {
port = udebug_PortNumber(portName);
if (port < 0)
port = udebug_PortName(portName);
if (port < 0) {
sprintf(buffer, "udebug: can't resolve port name %s", portName);
BSETCODE(1, buffer);
XSRETURN_UNDEF;
}
port = htons(port);
}
rx_Init(0);
sc = rxnull_NewClientSecurityObject();
tconn = rx_NewConnection(hostAddr, port, VOTE_SERVICE_ID, sc, 0);
src/Monitor.xs view on Meta::CPAN
code = VOTE_Debug(tconn, &udebug);
#endif
if (code == RXGEN_OPCODE)
{ ubik_debug * ptr = &udebug;
oldServer = 1; /* talking to a pre 3.5 server */
memset(&udebug, 0, sizeof(udebug));
code = VOTE_DebugOld(tconn, (struct ubik_debug_old *) ptr);
}
if (code) {
sprintf(buffer, "return code %d from VOTE_Debug", code);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* now print the main info */
inhostAddr.s_addr = hostAddr;
if ( !oldServer )
{
ADDRESSES = newAV();
for ( j=0; udebug.interfaceAddr[j] && ( j<UBIK_MAX_INTERFACE_ADDR ); j++) {
av_store(ADDRESSES, j, newSVpv(afs_inet_ntoa(htonl(udebug.interfaceAddr[j])), 0));
}
hv_store(RETVAL, "interfaceAddr", 13, newRV_inc((SV*)ADDRESSES), 0);
}
src/Monitor.xs view on Meta::CPAN
code = VOTE_SDebug(tconn, i, &usdebug);
#endif
if (code > 0)
break; /* done */
if (code < 0) {
warn("error code %d from VOTE_SDebug\n", code);
break;
}
/* otherwise print the structure */
USDEBUG = newHV();
inhostAddr.s_addr = htonl(usdebug.addr);
hv_store(USDEBUG, "addr", 4, newSVpv(afs_inet_ntoa(htonl(usdebug.addr)), 0), 0);
ALTADDR = newAV();
for ( j=0;((usdebug.altAddr[j]) && (j<UBIK_MAX_INTERFACE_ADDR-1)); j++) {
av_store(ALTADDR, j, newSVpv(afs_inet_ntoa(htonl(usdebug.altAddr[j])), 0));
}
if (j) hv_store(USDEBUG, "altAddr", 7, newRV_inc((SV*)ALTADDR), 0);
src/Monitor.xs view on Meta::CPAN
break;
case 's':
if(strncmp(key, "servers", keylen) == 0 && keylen <= 7) {
hostName = (char *) SvPV(value, PL_na);
} else goto unrecognized;
break;
default:
unrecognized:
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
break;
} /* end switch */
} /* end while */
/* done parsing arguments */
rx_Init(0);
thp = hostutil_GetHostByName(hostName);
if (!thp) {
sprintf(buffer, "can't resolve address for host %s", hostName);
BSETCODE(1, buffer);
XSRETURN_UNDEF;
}
memcpy(&addr, thp->h_addr, sizeof(afs_int32));
secobj = rxnull_NewServerSecurityObject();
conn = rx_NewConnection(addr, htons(port), 1, secobj, 0);
if (!conn) {
sprintf(buffer, "failed to create connection for host %s", hostName);
BSETCODE(1, buffer);
XSRETURN_UNDEF;
}
code = my_PrintLocks(conn, aint32, LOCKS, buffer);
if(code) {
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
code = my_PrintCacheEntries(conn, aint32, CACHE_ENTRIES, buffer);
if(code) {
src/Monitor.xs view on Meta::CPAN
struct afsmon_hostEntry *CMnameList=0;
/* initialize showFlags for processing "show" directives in config file */
for(i=0; i<NUM_FS_STAT_ENTRIES; i++)
fs_showFlags[i] = 0;
for(i=0; i<NUM_CM_STAT_ENTRIES; i++)
cm_showFlags[i] = 0;
/* parse arguments */
num_args = hv_iterinit(args);
/* fprintf(STDERR, "[afsmonitor] Parsing args now: %d\n", num_args); */
while (num_args--) {
value = hv_iternextsv(args, &key, &keylen);
/* fprintf(STDERR, "got flag %s, size %d. %d remaining.\n", key, keylen, num_args); */
switch (*key) {
case 'c':
if(keylen < 2) goto unrecognized;
switch(key[1]) {
case 'o':
if(strncmp(key, "config", keylen) == 0 && keylen <= 6) {
/* fprintf(STDERR, "flag %s recognized as config; value is %s\n",
key, (char *) SvPV(value, PL_na)); */
config_filename = (char *) SvPV(value, PL_na);
} else goto unrecognized;
break;
case 'm':
if(keylen < 3) goto unrecognized;
switch(key[2]) {
case 'h':
if(strncmp(key, "cmhosts", keylen) == 0 && keylen <= 7) {
/* fprintf(STDERR, "flag %s recognized as cmhosts\n", key); */
if (SvROK(value))
host_array = (AV*) SvRV(value);
else {
host_array = av_make(1, &value);
sv_2mortal((SV *) host_array);
}
num = av_len(host_array);
/* fprintf(STDERR, "it has %d elements.\n", num+1); */
for(i=0; i<=num; i++) {
host = (char *) SvPV(*av_fetch(host_array, i, 0), PL_na);
sprintf(buffer,"cm %s",host);
code = my_parse_hostEntry(buffer, &numFS, &numCM, &lastHostType,
&last_hostEntry, &FSnameList, &CMnameList, buff2);
/* fprintf(STDERR, "got host: %s\n", host); */
if (code) {
sprintf(buffer, "Could not parse cache manager %s. %s", host, buff2);
BSETCODE(180, buffer);
/* 180 is the exit code for this error in the original afsmonitor.c */
XSRETURN_UNDEF;
}
}
} else goto unrecognized;
break;
case 's':
if(strncmp(key, "cmshow", keylen) == 0 && keylen <= 6) {
/* fprintf(STDERR, "flag %s recognized as cmshow\n", key); */
show_array = (AV*) SvRV(value);
num = av_len(show_array);
for (i=0; i<=num; i++) {
sprintf(buffer, "show cm %s", SvPV(*av_fetch(show_array, i, 0), PL_na));
code = my_parse_showEntry(buffer, &fs_showDefault, &cm_showDefault,
fs_showFlags, cm_showFlags, buff2);
if(code) {
sprintf(buffer, "Error parsing cmshow flag. %s", buff2);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
} else goto unrecognized;
break;
case 't':
if(strncmp(key, "cmthresh", keylen) == 0 && keylen <= 8) {
/* fprintf(STDERR, "flag %s recognized as cmthresh\n", key); */
cmthresh_array = (AV*) SvRV(value);
} else goto unrecognized;
break;
default:
goto unrecognized;
}
break;
default:
goto unrecognized;
}
break;
case 'd':
if(strncmp(key, "detailed", keylen) == 0 && keylen <= 8) {
/* fprintf(STDERR, "flag %s recognized as detailed; value is %d\n",
key, (int) SvIV(value)); */
detailed = (int) SvIV(value);
} else goto unrecognized;
break;
case 'f':
if(keylen < 3 || key[1] != 's') goto unrecognized;
switch(key[2]) {
case 'h':
if(strncmp(key, "fshosts", keylen) == 0 && keylen <= 7) {
/* fprintf(STDERR, "flag %s recognized as fshosts\n", key); */
if (SvROK(value))
host_array = (AV*) SvRV(value);
else {
host_array = av_make(1, &value);
sv_2mortal((SV *) host_array);
}
num = av_len(host_array);
/* fprintf(STDERR, "it has %d elements.\n", num+1); */
for(i=0; i<=num; i++) {
host = (char *) SvPV(*av_fetch(host_array, i, 0), PL_na);
sprintf(buffer,"fs %s",host);
code = my_parse_hostEntry(buffer, &numFS, &numCM, &lastHostType,
&last_hostEntry, &FSnameList, &CMnameList, buff2);
/* fprintf(STDERR, "got host: %s\n", host); */
if (code) {
sprintf(buffer, "Could not parse file server %s. %s", host, buff2);
BSETCODE(180, buffer);
XSRETURN_UNDEF;
}
}
} else goto unrecognized;
break;
case 's':
if(strncmp(key, "fsshow", keylen) == 0 && keylen <= 6) {
/* fprintf(STDERR, "flag %s recognized as fsshow\n", key); */
show_array = (AV*) SvRV(value);
num = av_len(show_array);
for (i=0; i<=num; i++) {
sprintf(buffer, "show fs %s", SvPV(*av_fetch(show_array, i, 0), PL_na));
code = my_parse_showEntry(buffer, &fs_showDefault, &cm_showDefault,
fs_showFlags, cm_showFlags, buff2);
if(code) {
sprintf(buffer, "Error parsing fsshow flag. %s", buff2);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
} else goto unrecognized;
break;
case 't':
if(strncmp(key, "fsthresh", keylen) == 0 && keylen <= 8) {
/* fprintf(STDERR, "flag %s recognized as fsthresh\n", key); */
fsthresh_array = (AV*) SvRV(value);
} else goto unrecognized;
break;
default:
goto unrecognized;
}
break;
case 'o':
if(strncmp(key, "output", keylen) == 0 && keylen <= 6) {
/* fprintf(STDERR, "flag %s recognized as output; value is %s\n",
key, (char *) SvPV(value, PL_na)); */
output_filename = (char *) SvPV(value, PL_na);
} else goto unrecognized;
break;
default:
unrecognized:
/* fprintf(STDERR,
"flag not recognized. (key: %s) (value: %s)\n",
key, (char *) SvPV(value, PL_na)); */
sprintf(buffer, "Unrecognized flag: %s", key);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
} /* end switch */
} /* end while */
/* done parsing arguments */
/* Open output file, if provided. */
if (output_filename) {
outputFD = fopen(output_filename,"a");
if (outputFD == (FILE *) NULL) {
sprintf(buffer, "Failed to open output file %s", output_filename);
BSETCODE(160, buffer);
XSRETURN_UNDEF;
}
fclose (outputFD);
}
/* cannot use 'detailed' without 'output' */
if (detailed) {
if (!output_filename) {
sprintf(buffer, "detailed switch can be used only with output switch");
BSETCODE(165, buffer);
/* 165 is the exit code for this error in the original afsmonitor.c */
XSRETURN_UNDEF;
}
}
/* The config option is mutually exclusive with the fshosts,cmhosts options */
if (config_filename) {
if (numFS || numCM) {
sprintf(buffer,"Cannot use config option with fshosts or cmhosts");
BSETCODE(170, buffer);
/* 170 is the exit code for this error in the original afsmonitor.c */
XSRETURN_UNDEF;
}
}
else {
if (!numFS && !numCM) {
sprintf(buffer,"Must specify either config or (fshosts and/or cmhosts) options");
BSETCODE(175, buffer);
/* 175 is the exit code for this error in the original afsmonitor.c */
XSRETURN_UNDEF;
}
}
if (fsthresh_array) {
if(!numFS) {
sprintf(buffer, "Cannot use fsthresh option without specifying fshosts");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
num = av_len(fsthresh_array);
for (i=0; i<=num; i++) {
thresh_host = 0;
thresh_handler = "";
thresh_entry = (HV*) SvRV(*av_fetch(fsthresh_array, i, 0));
hv_iterinit(thresh_entry);
while((value = hv_iternextsv(thresh_entry, &key, &keylen))) {
if(strcmp(key, "host")==0) {
thresh_host = (char *)SvPV(value, PL_na);
he = GetHostByName(thresh_host);
if(he == (struct hostent *) NULL) {
sprintf(buffer,
"Couldn't parse fsthresh flag; unable to resolve hostname %s\n",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
thresh_host = he->h_name;
}
else if(strcmp(key, "handler")==0) {
thresh_handler = (char *) SvPV(value, PL_na);
}
else {
thresh_name = key;
thresh_value = (char *) SvPV(value, PL_na);
}
}
sprintf(buffer, "thresh fs %s %s %s",
thresh_name, thresh_value, thresh_handler);
if(!thresh_host) {
code = my_parse_threshEntry(buffer, &global_fsThreshCount,
&global_cmThreshCount, (struct afsmon_hostEntry *) NULL, 0, buff2);
if (code) {
sprintf(buffer, "Couldn't parse fsthresh entry. %s", buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
else {
temp_host = FSnameList;
found = 0;
for (j = 0; j < numFS; j++) {
if(strcmp(thresh_host, temp_host->hostName) == 0) {
found = 1;
break;
}
temp_host = temp_host->next;
}
if(found) {
code = my_parse_threshEntry(buffer, &global_fsThreshCount,
&global_cmThreshCount, temp_host,
1, buff2);
if(code) {
sprintf(buffer, "Couldn't parse fsthresh entry. %s", buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
else {
sprintf(buffer,
"Couldn't parse fsthresh entry for host %s; host not found",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
}
if (global_fsThreshCount) {
temp_host = FSnameList;
for (i = 0; i < numFS; i++) {
temp_host->numThresh += global_fsThreshCount;
temp_host = temp_host->next;
}
}
temp_host = FSnameList;
for (i = 0; i < numFS; i++) {
if (temp_host->numThresh) {
numBytes = temp_host->numThresh * sizeof(struct Threshold);
temp_host->thresh = (struct Threshold *)malloc(numBytes);
if (temp_host->thresh == (struct Threshold *) NULL) {
sprintf(buffer, "Memory Allocation error 1.5");
BSETCODE(25, buffer);
XSRETURN_UNDEF;
}
memset(temp_host->thresh, 0, numBytes);
}
temp_host = temp_host->next;
}
num = av_len(fsthresh_array);
for (i=0; i<=num; i++) {
thresh_host = 0;
thresh_handler = "";
thresh_entry = (HV*) SvRV(*av_fetch(fsthresh_array, i, 0));
hv_iterinit(thresh_entry);
while((value = hv_iternextsv(thresh_entry, &key, &keylen))) {
if(strcmp(key, "host") == 0) {
thresh_host = (char *)SvPV(value, PL_na);
he = GetHostByName(thresh_host);
if(he == (struct hostent *) NULL) {
sprintf(buffer,
"Couldn't parse fsthresh flag; unable to resolve hostname %s\n",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
thresh_host = he->h_name;
}
else if(strcmp(key, "handler")==0) {
thresh_handler = (char *) SvPV(value, PL_na);
}
src/Monitor.xs view on Meta::CPAN
thresh_name = key;
thresh_value = (char *) SvPV(value, PL_na);
}
}
if(thresh_host) global_fsThreshCount = 0;
else global_fsThreshCount = 1;
code = my_store_threshold(1, thresh_name, thresh_value, thresh_handler,
&global_fsThreshCount, FSnameList, thresh_host,
numFS, buff2);
if(code) {
sprintf(buffer, "Unable to store threshold %s. %s", thresh_name, buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
}
if (cmthresh_array) {
if(!numCM) {
sprintf(buffer, "Cannot use cmthresh option without specifying cmhosts");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
num = av_len(cmthresh_array);
for (i=0; i<=num; i++) {
thresh_host = 0;
thresh_handler = "";
thresh_entry = (HV*) SvRV(*av_fetch(cmthresh_array, i, 0));
hv_iterinit(thresh_entry);
while((value = hv_iternextsv(thresh_entry, &key, &keylen))) {
if(strcmp(key, "host")==0) {
thresh_host = (char *)SvPV(value, PL_na);
he = GetHostByName(thresh_host);
if(he == (struct hostent *) NULL) {
sprintf(buffer,
"Couldn't parse cmthresh flag; unable to resolve hostname %s\n",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
thresh_host = he->h_name;
}
else if(strcmp(key, "handler")==0) {
thresh_handler = (char *) SvPV(value, PL_na);
}
else {
thresh_name = key;
thresh_value = (char *) SvPV(value, PL_na);
}
}
sprintf(buffer, "thresh cm %s %s %s", thresh_name, thresh_value, thresh_handler);
if(!thresh_host) {
code = my_parse_threshEntry(buffer, &global_fsThreshCount,
&global_cmThreshCount, (struct afsmon_hostEntry *) NULL, 0, buff2);
if (code) {
sprintf(buffer, "Couldn't parse cmthresh entry. %s", buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
else {
temp_host = CMnameList;
found = 0;
for (j = 0; j < numCM; j++) {
if(strcmp(thresh_host, temp_host->hostName) == 0) {
found = 1;
break;
}
temp_host = temp_host->next;
}
if(found) {
code = my_parse_threshEntry(buffer, &global_fsThreshCount,
&global_cmThreshCount, temp_host,
2, buff2);
if(code) {
sprintf(buffer, "Couldn't parse cmthresh entry. %s", buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
else {
sprintf(buffer,
"Couldn't parse cmthresh entry for host %s; host not found",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
}
if (global_cmThreshCount) {
temp_host = CMnameList;
for (i = 0; i < numCM; i++) {
temp_host->numThresh += global_cmThreshCount;
temp_host = temp_host->next;
}
}
temp_host = CMnameList;
for (i = 0; i < numCM; i++) {
if (temp_host->numThresh) {
numBytes = temp_host->numThresh * sizeof(struct Threshold);
temp_host->thresh = (struct Threshold *)malloc(numBytes);
if (temp_host->thresh == (struct Threshold *) NULL) {
sprintf(buffer, "Memory Allocation error 2.5");
BSETCODE(25, buffer);
XSRETURN_UNDEF;
}
memset(temp_host->thresh, 0, numBytes);
}
temp_host = temp_host->next;
}
num = av_len(cmthresh_array);
for (i=0; i<=num; i++) {
thresh_host = 0;
thresh_handler = "";
thresh_entry = (HV*) SvRV(*av_fetch(cmthresh_array, i, 0));
hv_iterinit(thresh_entry);
while((value = hv_iternextsv(thresh_entry, &key, &keylen))) {
if(strcmp(key, "host") == 0) {
thresh_host = (char *)SvPV(value, PL_na);
he = GetHostByName(thresh_host);
if(he == (struct hostent *) NULL) {
sprintf(buffer,
"Couldn't parse cmthresh flag; unable to resolve hostname %s\n",
thresh_host);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
thresh_host = he->h_name;
}
else if(strcmp(key, "handler")==0) {
thresh_handler = (char *) SvPV(value, PL_na);
}
src/Monitor.xs view on Meta::CPAN
thresh_name = key;
thresh_value = (char *) SvPV(value, PL_na);
}
}
if(thresh_host) global_cmThreshCount = 0;
else global_cmThreshCount = 1;
code = my_store_threshold(2, thresh_name, thresh_value, thresh_handler,
&global_cmThreshCount, CMnameList, thresh_host,
numCM, buff2);
if(code) {
sprintf(buffer, "Unable to store threshold %s. %s", thresh_name, buff2);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
}
}
/* process configuration file */
if(config_filename) {
code = my_process_config_file(config_filename, &numFS, &numCM, &lastHostType,
&last_hostEntry, &fs_showDefault, &cm_showDefault,
src/Monitor.xs view on Meta::CPAN
/* from afsmon_execute() */
/* process file server entries */
if (numFS) {
/* Allocate an array of sockets for each fileserver we monitor */
FSsktbytes = numFS * sizeof(struct sockaddr_in);
FSSktArray = (struct sockaddr_in *) malloc(FSsktbytes);
if (FSSktArray == (struct sockaddr_in *) NULL) {
sprintf(buffer,"cannot malloc %d sockaddr_ins for fileservers", numFS);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memset(FSSktArray, 0, FSsktbytes);
/* Fill in the socket information for each fileserve */
curr_skt = FSSktArray;
curr_FS = FSnameList; /* FS name list header */
while (curr_FS) {
strncpy(fullhostname,curr_FS->hostName,sizeof(fullhostname));
he = GetHostByName(fullhostname);
if (he == (struct hostent *) NULL) {
sprintf(buffer,"Cannot get host info for %s", fullhostname);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
strncpy(curr_FS->hostName,he->h_name,HOST_NAME_LEN); /* complete name*/
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
curr_skt->sin_family = AF_INET; /*Internet family */
#else
curr_skt->sin_family = htons(AF_INET); /*Internet family */
#endif
src/Monitor.xs view on Meta::CPAN
curr_skt++;
curr_FS = curr_FS->next;
}
/* initialize collection IDs. We need only one entry since we collect
all the information from xstat */
numCollIDs = 1;
collIDP = (afs_int32 *) malloc (sizeof (afs_int32));
if (collIDP == (afs_int32 *) NULL) {
sprintf(buffer,"failed to allocate a measely afs_int32 word. Argh!");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
*collIDP = 2; /* USE A macro for this */
code = my_xstat_fs_Init(my_afsmon_FS_Handler, numFS, FSSktArray, numCollIDs,
collIDP, buff2, output_filename, detailed, FILESERV,
FSnameList, fs_showFlags, fs_showDefault);
if (code) {
sprintf(buffer,"my_xstat_fs_Init() returned error. %s", buff2);
BSETCODE(125, buffer);
XSRETURN_UNDEF;
}
} /* end of process fileserver entries */
/* process cache manager entries */
if (numCM) {
/* Allocate an array of sockets for each fileserver we monitor */
CMsktbytes = numCM * sizeof(struct sockaddr_in);
CMSktArray = (struct sockaddr_in *) malloc(CMsktbytes);
if (CMSktArray == (struct sockaddr_in *) NULL) {
sprintf(buffer,"cannot malloc %d sockaddr_ins for CM entries", numCM);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memset(CMSktArray, 0, CMsktbytes);
/* Fill in the socket information for each CM */
curr_skt = CMSktArray;
curr_CM = CMnameList; /* CM name list header */
while (curr_CM) {
strncpy(fullhostname,curr_CM->hostName,sizeof(fullhostname));
he = GetHostByName(fullhostname);
if (he == (struct hostent *) NULL) {
sprintf(buffer,"Cannot get host info for %s", fullhostname);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
strncpy(curr_CM->hostName,he->h_name,HOST_NAME_LEN); /* complete name*/
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7001); /*Cache Manager port */
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
curr_skt->sin_len = sizeof(struct sockaddr_in);
#endif
src/Monitor.xs view on Meta::CPAN
curr_skt++;
curr_CM = curr_CM->next;
}
/* initialize collection IDs. We need only one entry since we collect
all the information from xstat */
numCollIDs = 1;
collIDP = (afs_int32 *) malloc (sizeof (afs_int32));
if (collIDP == (afs_int32 *) NULL) {
sprintf(buffer,"failed to allocate a measely afs_int32 word. Argh!");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
*collIDP = 2; /* USE A macro for this */
code = my_xstat_cm_Init(my_afsmon_CM_Handler, numCM, CMSktArray, numCollIDs,
collIDP, buff2, output_filename, detailed, CACHEMAN,
CMnameList, cm_showFlags, cm_showDefault);
if (code) {
sprintf(buffer,"my_xstat_cm_Init() returned error. %s", buff2);
BSETCODE(130, buffer);
XSRETURN_UNDEF;
}
} /* end of process fileserver entries */
/* end from afsmon_execute() */
SETCODE(0);
src/Monitor.xs view on Meta::CPAN
char buffer[240]; /* for error messages */
afs_uint32 supportedDebugValues = 0;
afs_uint32 supportedStatValues = 0;
afs_uint32 supportedConnValues = 0;
afs_uint32 supportedPeerValues = 0;
afs_int32 nextconn = 0;
afs_int32 nextpeer = 0;
size = hv_iterinit(args);
/* fprintf(STDERR, "Parsing args now: %d\n", size); */
while (size--) {
char *flag;
entry = hv_iternext(args);
key = hv_iterkey(entry, &keylen);
value = hv_iterval(args, entry);
flag = key;
/* fprintf(STDERR, "size = %d, format: got flag %s\n", size, key); */
switch (*flag) {
case 'a':
if (memcmp( flag, "allconnections", 14) == 0 ) {
allconns = (int) SvIV(value);
}
break;
case 'l':
if (memcmp( flag, "long", 4) == 0 ) {
src/Monitor.xs view on Meta::CPAN
case 'o':
if (memcmp( flag, "onlyserver", 10) == 0 ) {
onlyServer = (int) SvIV(value);
} else if (memcmp( flag, "onlyclient", 10) == 0 ) {
onlyClient = (int) SvIV(value);
} else if (memcmp( flag, "onlyhost", 8) == 0 ) {
char *name = (char *) SvPV(value, PL_na);
struct hostent *th;
th = hostutil_GetHostByName(name);
if (!th) {
sprintf(buffer, "rxdebug: host %s not found in host table", name);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memcpy(&onlyHost, th->h_addr, sizeof(afs_int32));
} else if (memcmp( flag, "onlyauth", 8) == 0 ) {
char *name = (char *) SvPV(value, PL_na);
if (strcmp (name, "clear") == 0) onlyAuth = 0;
else if (strcmp (name, "auth") == 0) onlyAuth = 1;
else if (strcmp (name, "crypt") == 0) onlyAuth = 2;
else if ((strcmp (name, "null") == 0) ||
(strcmp (name, "none") == 0) ||
(strncmp (name, "noauth", 6) == 0) ||
(strncmp (name, "unauth", 6) == 0)) onlyAuth = -1;
else {
sprintf (buffer, "Unknown authentication level: %s", name);
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
} else if (memcmp( flag, "onlyport", 8) == 0 ) {
char *name = (char *) SvPV(value, PL_na);
if ((onlyPort = rxdebug_PortNumber(name)) == -1)
onlyPort = rxdebug_PortName(name);
if (onlyPort == -1) {
sprintf(buffer, "rxdebug: can't resolve port name %s", name);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
break;
case 'p':
if (memcmp( flag, "port", 4) == 0 ) {
portName = (char *) SvPV(value, PL_na);
src/Monitor.xs view on Meta::CPAN
case 'v':
if (memcmp( flag, "version", 7) == 0 ) {
version_flag = (int) SvIV(value);
}
break;
default:
break;
} /* switch */
} /* while */
/* fprintf(STDERR, "Done parsing args\n\n"); */
/* lookup host */
if (hostName) {
th = hostutil_GetHostByName(hostName);
if (!th) {
sprintf(buffer, "rxdebug: host %s not found in host table", hostName);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
memcpy(&host, th->h_addr, sizeof(afs_int32));
}
else host = htonl(0x7f000001); /* IP localhost */
if (!portName)
port = htons(7000); /* default is fileserver */
else {
if ((port = rxdebug_PortNumber(portName)) == -1)
port = rxdebug_PortName(portName);
if (port == -1) {
sprintf(buffer, "rxdebug: can't resolve port name %s", portName);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
}
dallyCounter = 0;
hostAddr.s_addr = host;
/* add address and port to RETVAL hash */
hv_store(RETVAL, "address", 7, newSVpv(inet_ntoa(hostAddr), 0), 0);
hv_store(RETVAL, "port", 4, newSViv(ntohs(port)), 0);
src/Monitor.xs view on Meta::CPAN
if (code) {
perror("bind");
XSRETURN_UNDEF;
}
if (version_flag) /* add version to RETVAL and finish */
{
code = rx_GetServerVersion(s, host, port, length, version);
if (code < 0)
{
sprintf(buffer, "get version call failed with code %d, errno %d",code,errno);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
hv_store(RETVAL, "version", 7, newSVpv(version, 0), 0);
goto done;
}
code = rx_GetServerDebug(s, host, port, &tstats, &supportedDebugValues);
if (code < 0) {
sprintf(buffer, "getstats call failed with code %d", code);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
withSecStats = (supportedDebugValues & RX_SERVER_DEBUG_SEC_STATS);
withAllConn = (supportedDebugValues & RX_SERVER_DEBUG_ALL_CONN);
withRxStats = (supportedDebugValues & RX_SERVER_DEBUG_RX_STATS);
withWaiters = (supportedDebugValues & RX_SERVER_DEBUG_WAITER_CNT);
withIdleThreads = (supportedDebugValues & RX_SERVER_DEBUG_IDLE_THREADS);
withPeers = (supportedDebugValues & RX_SERVER_DEBUG_ALL_PEER);
src/Monitor.xs view on Meta::CPAN
noRxStats:
withRxStats = 0;
warn("WARNING: Server doesn't support retrieval of Rx statistics\n");
}
else {
struct rx_statistics rxstats;
/* should gracefully handle the case where rx_statistics grows */
code = rx_GetServerStats(s, host, port, &rxstats, &supportedStatValues);
if (code < 0) {
sprintf(buffer, "rxstats call failed with code %d", code);
VSETCODE(code, buffer);
XSRETURN_UNDEF;
}
if (code != sizeof(rxstats)) {
if ((((struct rx_debugIn *)(&rxstats))->type == RX_DEBUGI_BADTYPE))
goto noRxStats;
warn("WARNING: returned Rx statistics of unexpected size (got %d)\n", code);
/* handle other versions?... */
}
src/ppport.h view on Meta::CPAN
$macros{$1} = 1 if /^#\s*define\s+([a-zA-Z0-9_]+)/;
$replace = $1 if /Replace:\s+(\d+)/;
$badmacros{$2}=$1 if $replace and /^#\s*define\s+([a-zA-Z0-9_]+).*?\s+([a-zA-Z0-9_]+)/;
$badmacros{$1}=$2 if /Replace (\S+) with (\S+)/;
}
foreach $filename (map(glob($_),@ARGV)) {
unless (open(IN, "<$filename")) {
warn "Unable to read from $file: $!\n";
next;
}
print "Scanning $filename...\n";
$c = ""; while (<IN>) { $c .= $_; } close(IN);
$need_include = 0; %add_func = (); $changes = 0;
$has_include = ($c =~ /#.*include.*ppport/m);
foreach $func (keys %funcs) {
if ($c =~ /#.*define.*\bNEED_$func(_GLOBAL)?\b/m) {
if ($c !~ /\b$func\b/m) {
print "If $func isn't needed, you don't need to request it.\n" if
$changes += ($c =~ s/^.*#.*define.*\bNEED_$func\b.*\n//m);
} else {
print "Uses $func\n";
$need_include = 1;
}
} else {
if ($c =~ /\b$func\b/m) {
$add_func{$func} =1 ;
print "Uses $func\n";
$need_include = 1;
}
}
}
if (not $need_include) {
foreach $macro (keys %macros) {
if ($c =~ /\b$macro\b/m) {
print "Uses $macro\n";
$need_include = 1;
}
}
}
foreach $badmacro (keys %badmacros) {
if ($c =~ /\b$badmacro\b/m) {
$changes += ($c =~ s/\b$badmacro\b/$badmacros{$badmacro}/gm);
print "Uses $badmacros{$badmacro} (instead of $badmacro)\n";
$need_include = 1;
}
}
if (scalar(keys %add_func) or $need_include != $has_include) {
if (!$has_include) {
$inc = join('',map("#define NEED_$_\n", sort keys %add_func)).
"#include \"ppport.h\"\n";
$c = "$inc$c" unless $c =~ s/#.*include.*XSUB.*\n/$&$inc/m;
} elsif (keys %add_func) {
$inc = join('',map("#define NEED_$_\n", sort keys %add_func));
$c = "$inc$c" unless $c =~ s/^.*#.*include.*ppport.*$/$inc$&/m;
}
if (!$need_include) {
print "Doesn't seem to need ppport.h.\n";
$c =~ s/^.*#.*include.*ppport.*\n//m;
}
$changes++;
}
if ($changes) {
open(OUT,">/tmp/ppport.h.$$");
print OUT $c;
close(OUT);
open(DIFF, "diff -u $filename /tmp/ppport.h.$$|");
while (<DIFF>) { s!/tmp/ppport\.h\.$$!$filename.patched!; print STDOUT; }
close(DIFF);
unlink("/tmp/ppport.h.$$");
} else {
print "Looks OK\n";
}
}
__DATA__
*/
#ifndef PERL_REVISION
# ifndef __PATCHLEVEL_H_INCLUDED__
# include "patchlevel.h"
# endif
# ifndef PERL_REVISION
( run in 1.537 second using v1.01-cache-2.11-cpan-de7293f3b23 )