/*
* NeoIRCd: NeoStats Group. Based on Hybird7
* s_debug.c: Some assorted debug functions.
*
* Copyright (C) 2002 by the past and present ircd coders, and others.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*
* $Id: s_debug.c,v 1.5 2002/11/01 01:32:34 fishwaldo Exp $
*/
#include "stdinc.h"
#include "tools.h"
#include "s_debug.h"
#include "channel.h"
#include "class.h"
#include "client.h"
#include "common.h"
#include "fdlist.h"
#include "fileio.h"
#include "hash.h"
#include "ircd.h"
#include "list.h"
#include "numeric.h"
#include "res.h"
#include "s_conf.h"
#include "s_log.h"
#include "scache.h"
#include "send.h"
#include "whowas.h"
#include "linebuf.h"
#include "memory.h"
/*
* Option string. Must be before #ifdef DEBUGMODE.
*/
const char serveropts[] = {
' ',
'T',
'S',
#ifdef TS_CURRENT
'0' + TS_CURRENT,
#endif
/* ONLY do TS */
/* ALWAYS do TS_WARNINGS */
'o',
'w',
'\0'
};
void debug(int level, char *format, ...)
{
static char debugbuf[1024];
va_list args;
int err = errno;
#ifndef DEBUG
if ((debuglevel >= 0) && (level <= debuglevel)) {
#endif
va_start(args, format);
vsprintf(debugbuf, format, args);
va_end(args);
ilog(L_DEBUG, "%s", debugbuf);
#ifndef DEBUG
}
#endif
errno = err;
} /* debug() */
/*
* This is part of the STATS replies. There is no offical numeric for this
* since this isnt an official command, in much the same way as HASH isnt.
* It is also possible that some systems wont support this call or have
* different field names for "struct rusage".
* -avalon
*/
void send_usage(struct Client *source_p)
{
struct rusage rus;
time_t secs;
time_t rup;
#ifdef hz
# define hzz hz
#else
# ifdef HZ
# define hzz HZ
# else
int hzz = 1;
# endif
#endif
#ifdef VMS
sendto_one(source_p, ":%s NOTICE %s :getrusage not supported on this system");
return;
#else
if (getrusage(RUSAGE_SELF, &rus) == -1)
{
sendto_one(source_p,":%s NOTICE %s :Getruseage error: %s.",
me.name, source_p->name, strerror(errno));
return;
}
secs = rus.ru_utime.tv_sec + rus.ru_stime.tv_sec;
if (0 == secs)
secs = 1;
rup = (CurrentTime - me.since) * hzz;
if (0 == rup)
rup = 1;
sendto_one(source_p,
":%s %d %s :CPU Secs %d:%d User %d:%d System %d:%d",
me.name, RPL_STATSDEBUG, source_p->name, (int)(secs/60), (int)(secs%60),
(int)(rus.ru_utime.tv_sec/60), (int)(rus.ru_utime.tv_sec%60),
(int)(rus.ru_stime.tv_sec/60), (int)(rus.ru_stime.tv_sec%60));
sendto_one(source_p, ":%s %d %s :RSS %ld ShMem %ld Data %ld Stack %ld",
me.name, RPL_STATSDEBUG, source_p->name, rus.ru_maxrss,
(rus.ru_ixrss / rup), (rus.ru_idrss / rup),
(rus.ru_isrss / rup));
sendto_one(source_p, ":%s %d %s :Swaps %d Reclaims %d Faults %d",
me.name, RPL_STATSDEBUG, source_p->name, (int)rus.ru_nswap,
(int)rus.ru_minflt, (int)rus.ru_majflt);
sendto_one(source_p, ":%s %d %s :Block in %d out %d",
me.name, RPL_STATSDEBUG, source_p->name, (int)rus.ru_inblock,
(int)rus.ru_oublock);
sendto_one(source_p, ":%s %d %s :Msg Rcv %d Send %d",
me.name, RPL_STATSDEBUG, source_p->name, (int)rus.ru_msgrcv,
(int)rus.ru_msgsnd);
sendto_one(source_p, ":%s %d %s :Signals %d Context Vol. %d Invol %d",
me.name, RPL_STATSDEBUG, source_p->name, (int)rus.ru_nsignals,
(int)rus.ru_nvcsw, (int)rus.ru_nivcsw);
#endif /* VMS */
}
void count_memory(struct Client *source_p)
{
struct Client *target_p;
struct Channel *chptr;
struct ConfItem *aconf;
struct Ban *actualBan;
struct Class *cltmp;
dlink_node *dlink;
int channel_count = 0;
int local_client_conf_count = 0; /* local client conf links */
int users_counted = 0; /* user structs */
int channel_users = 0;
int channel_invites = 0;
int channel_bans = 0;
int channel_except = 0;
int channel_invex = 0;
int wwu = 0; /* whowas users */
int class_count = 0; /* classes */
int conf_count = 0; /* conf lines */
int users_invited_count = 0; /* users invited */
int user_channels = 0; /* users in channels */
int aways_counted = 0;
int number_ips_stored; /* number of ip addresses hashed */
int number_servers_cached; /* number of servers cached by scache */
u_long channel_memory = 0;
u_long channel_ban_memory = 0;
u_long channel_except_memory = 0;
u_long channel_invex_memory = 0;
u_long away_memory = 0; /* memory used by aways */
u_long wwm = 0; /* whowas array memory used */
u_long conf_memory = 0; /* memory used by conf lines */
u_long mem_servers_cached; /* memory used by scache */
u_long mem_ips_stored; /* memory used by ip address hash */
int linebuf_count =0;
u_long linebuf_memory_used = 0;
u_long client_hash_table_size = 0;
u_long channel_hash_table_size = 0;
u_long total_channel_memory = 0;
u_long totww = 0;
int local_client_count = 0;
u_long local_client_memory_used = 0;
int remote_client_count = 0;
u_long remote_client_memory_used = 0;
int user_count = 0;
u_long user_memory_used = 0;
int links_count = 0;
u_long links_memory_used = 0;
u_long total_memory = 0;
count_whowas_memory(&wwu, &wwm);
for (target_p = GlobalClientList; target_p; target_p = target_p->next)
{
if (MyConnect(target_p))
{
for (dlink = target_p->localClient->confs.head;
dlink; dlink = dlink->next)
local_client_conf_count++;
}
if (target_p->user)
{
users_counted++;
for (dlink = target_p->user->invited.head; dlink;
dlink = dlink->next)
users_invited_count++;
for (dlink = target_p->user->channel.head; dlink;
dlink = dlink->next)
user_channels++;
if (target_p->user->away)
{
aways_counted++;
away_memory += (strlen(target_p->user->away)+1);
}
}
}
/* Count up all channels, ban lists, except lists, Invex lists */
for (chptr = GlobalChannelList; chptr; chptr = chptr->nextch)
{
channel_count++;
channel_memory += (strlen(chptr->chname) + sizeof(struct Channel));
for (dlink = chptr->peons.head; dlink; dlink = dlink->next)
channel_users++;
for (dlink = chptr->chanops.head; dlink; dlink = dlink->next)
channel_users++;
for (dlink = chptr->voiced.head; dlink; dlink = dlink->next)
channel_users++;
for (dlink = chptr->halfops.head; dlink; dlink = dlink->next)
channel_users++;
for (dlink = chptr->invites.head; dlink; dlink = dlink->next)
channel_invites++;
for (dlink = chptr->banlist.head; dlink; dlink = dlink->next)
{
actualBan = dlink->data;
channel_bans++;
channel_ban_memory += sizeof(dlink_node) +
sizeof(struct Ban);
if (actualBan->banstr)
channel_ban_memory += strlen(actualBan->banstr);
if (actualBan->who)
channel_ban_memory += strlen(actualBan->who);
}
for (dlink = chptr->exceptlist.head; dlink; dlink = dlink->next)
{
actualBan = dlink->data;
channel_except++;
channel_except_memory += (sizeof(dlink_node) +
sizeof(struct Ban));
if (actualBan->banstr)
channel_except_memory += strlen(actualBan->banstr);
if (actualBan->who)
channel_except_memory += strlen(actualBan->who);
}
for (dlink = chptr->invexlist.head; dlink; dlink = dlink->next)
{
actualBan = dlink->data;
channel_invex++;
channel_invex_memory += (sizeof(dlink_node) +
sizeof(struct Ban));
if (actualBan->banstr)
channel_invex_memory += strlen(actualBan->banstr);
if (actualBan->who)
channel_invex_memory += strlen(actualBan->who);
}
}
/* count up all config items */
for (aconf = ConfigItemList; aconf; aconf = aconf->next)
{
conf_count++;
conf_memory += aconf->host ? strlen(aconf->host)+1 : 0;
conf_memory += aconf->passwd ? strlen(aconf->passwd)+1 : 0;
conf_memory += aconf->name ? strlen(aconf->name)+1 : 0;
conf_memory += sizeof(struct ConfItem);
}
/* count up all classes */
for (cltmp = ClassList; cltmp; cltmp = cltmp->next)
class_count++;
count_linebuf_memory(&linebuf_count, &linebuf_memory_used);
sendto_one(source_p, ":%s %d %s :Users %u(%lu) Invites %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name,
users_counted, (unsigned long)users_counted * sizeof(struct User),
users_invited_count, (unsigned long)users_invited_count * sizeof(dlink_node));
sendto_one(source_p, ":%s %d %s :User channels %u(%lu) Aways %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
user_channels, (unsigned long)user_channels*sizeof(dlink_node),
aways_counted, (int)away_memory);
sendto_one(source_p, ":%s %d %s :Attached confs %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name,
local_client_conf_count,
(unsigned long)local_client_conf_count * sizeof(dlink_node));
sendto_one(source_p, ":%s %d %s :Conflines %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
conf_count, (int)conf_memory);
sendto_one(source_p, ":%s %d %s :Classes %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name,
class_count, (unsigned long)class_count*sizeof(struct Class));
sendto_one(source_p, ":%s %d %s :Channels %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
channel_count, (int)channel_memory);
sendto_one(source_p, ":%s %d %s :Bans %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
channel_bans, (int)channel_ban_memory);
sendto_one(source_p, ":%s %d %s :Exceptions %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
channel_except, (int)channel_except_memory);
sendto_one(source_p, ":%s %d %s :Invex %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
channel_invex, (int)channel_invex_memory);
sendto_one(source_p, ":%s %d %s :Channel members %u(%lu) invite %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name, channel_users,
(unsigned long)channel_users*sizeof(dlink_node),
channel_invites, (unsigned long)channel_invites*sizeof(dlink_node));
total_channel_memory = channel_memory +
channel_ban_memory +
channel_users*sizeof(dlink_node) +
channel_invites*sizeof(dlink_node);
sendto_one(source_p, ":%s %d %s :Whowas users %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name,
wwu, (unsigned long)wwu*sizeof(struct User));
sendto_one(source_p, ":%s %d %s :Whowas array %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name, NICKNAMEHISTORYLENGTH, (int)wwm);
totww = wwu * sizeof(struct User) + wwm;
client_hash_table_size = hash_get_client_table_size();
channel_hash_table_size = hash_get_channel_table_size();
sendto_one(source_p, ":%s %d %s :Hash: client %u(%lu) chan %u(%lu)",
me.name, RPL_STATSDEBUG, source_p->name,
U_MAX, client_hash_table_size,
CH_MAX, channel_hash_table_size);
sendto_one(source_p, ":%s %d %s :linebuf %d(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
linebuf_count, (int)linebuf_memory_used);
count_scache(&number_servers_cached,&mem_servers_cached);
sendto_one(source_p, ":%s %d %s :scache %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
number_servers_cached,
(int)mem_servers_cached);
count_ip_hash(&number_ips_stored,&mem_ips_stored);
sendto_one(source_p, ":%s %d %s :iphash %u(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
number_ips_stored,
(int)mem_ips_stored);
total_memory = totww + total_channel_memory + conf_memory +
class_count * sizeof(struct Class);
total_memory += client_hash_table_size;
total_memory += channel_hash_table_size;
total_memory += mem_servers_cached;
sendto_one(source_p, ":%s %d %s :Total: whowas %d channel %d conf %d",
me.name, RPL_STATSDEBUG, source_p->name,
(int)totww,
(int)total_channel_memory,
(int)conf_memory);
count_local_client_memory( &local_client_count,
(int *)&local_client_memory_used );
total_memory += local_client_memory_used;
sendto_one(source_p, ":%s %d %s :Local client Memory in use: %d(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
local_client_count,
(int)local_client_memory_used);
count_remote_client_memory( &remote_client_count,
(int *)&remote_client_memory_used);
total_memory += remote_client_memory_used;
sendto_one(source_p, ":%s %d %s :Remote client Memory in use: %d(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
remote_client_count,
(int)remote_client_memory_used);
count_user_memory( &user_count, (int *)&user_memory_used );
total_memory += user_memory_used;
sendto_one(source_p, ":%s %d %s :User Memory in use: %d(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
user_count, (int)user_memory_used);
count_links_memory( &links_count, (int *)&links_memory_used );
total_memory += links_memory_used;
sendto_one(source_p, ":%s %d %s :Links Memory in use: %d(%d)",
me.name, RPL_STATSDEBUG, source_p->name,
(int)links_count,
(int)links_memory_used);
sendto_one(source_p,
":%s %d %s :TOTAL: %d Available: Current max RSS: %lu",
me.name, RPL_STATSDEBUG, source_p->name,
(int)total_memory, get_maxrss());
}
