src/s_stats.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  s_stats.c: Statistics related functions
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  *
  24  *  $Id: s_stats.c 26 2006-09-20 18:02:06Z spb $
  25  */
  26
  27 #include "stdinc.h"
  28 #include "s_stats.h"
  29 #include "client.h"
  30 #include "irc_string.h"
  31 #include "ircd.h"
  32 #include "numeric.h"
  33 #include "commio.h"
  34 #include "send.h"
  35 #include "memory.h"
  36 #include "s_conf.h"
  37 #include "s_newconf.h"
  38 #include "whowas.h"
  39 #include "hash.h"
  40 #include "scache.h"
  41 #include "reject.h"
  42
  43 /*
  44  * stats stuff
  45  */
  46 static struct ServerStatistics ircst;
  47 struct ServerStatistics *ServerStats = &ircst;
  48
  49 void
  50 init_stats()
  51 {
  52         memset(&ircst, 0, sizeof(ircst));
  53 }
  54
  55 /*
  56  * tstats
  57  *
  58  * inputs       - client to report to
  59  * output       - NONE
  60  * side effects -
  61  */
  62 void
  63 tstats(struct Client *source_p)
  64 {
  65         struct Client *target_p;
  66         struct ServerStatistics *sp;
  67         struct ServerStatistics tmp;
  68         dlink_node *ptr;
  69
  70         sp = &tmp;
  71         memcpy(sp, ServerStats, sizeof(struct ServerStatistics));
  72
  73         DLINK_FOREACH(ptr, serv_list.head)
  74         {
  75                 target_p = ptr->data;
  76
  77                 sp->is_sbs += target_p->localClient->sendB;
  78                 sp->is_sbr += target_p->localClient->receiveB;
  79                 sp->is_sks += target_p->localClient->sendK;
  80                 sp->is_skr += target_p->localClient->receiveK;
  81                 sp->is_sti += CurrentTime - target_p->localClient->firsttime;
  82                 sp->is_sv++;
  83                 if(sp->is_sbs > 1023)
  84                 {
  85                         sp->is_sks += (sp->is_sbs >> 10);
  86                         sp->is_sbs &= 0x3ff;
  87                 }
  88                 if(sp->is_sbr > 1023)
  89                 {
  90                         sp->is_skr += (sp->is_sbr >> 10);
  91                         sp->is_sbr &= 0x3ff;
  92                 }
  93         }
  94
  95         DLINK_FOREACH(ptr, lclient_list.head)
  96         {
  97                 target_p = ptr->data;
  98
  99                 sp->is_cbs += target_p->localClient->sendB;
 100                 sp->is_cbr += target_p->localClient->receiveB;
 101                 sp->is_cks += target_p->localClient->sendK;
 102                 sp->is_ckr += target_p->localClient->receiveK;
 103                 sp->is_cti += CurrentTime - target_p->localClient->firsttime;
 104                 sp->is_cl++;
 105                 if(sp->is_cbs > 1023)
 106                 {
 107                         sp->is_cks += (sp->is_cbs >> 10);
 108                         sp->is_cbs &= 0x3ff;
 109                 }
 110                 if(sp->is_cbr > 1023)
 111                 {
 112                         sp->is_ckr += (sp->is_cbr >> 10);
 113                         sp->is_cbr &= 0x3ff;
 114                 }
 115
 116         }
 117
 118         DLINK_FOREACH(ptr, unknown_list.head)
 119         {
 120                 sp->is_ni++;
 121         }
 122
 123         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 124                            "T :accepts %u refused %u", sp->is_ac, sp->is_ref);
 125         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 126                         "T :rejected %u delaying %lu",
 127                         sp->is_rej, dlink_list_length(&delay_exit));
 128         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 129                         "T :nicks being delayed %lu",
 130                         get_nd_count());
 131         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 132                            "T :unknown commands %u prefixes %u",
 133                            sp->is_unco, sp->is_unpf);
 134         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 135                            "T :nick collisions %u saves %u unknown closes %u",
 136                            sp->is_kill, sp->is_save, sp->is_ni);
 137         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 138                            "T :wrong direction %u empty %u",
 139                            sp->is_wrdi, sp->is_empt);
 140         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 141                            "T :numerics seen %u", sp->is_num);
 142         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 143                            "T :auth successes %u fails %u",
 144                            sp->is_asuc, sp->is_abad);
 145         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 146                            "T :sasl successes %u fails %u",
 147                            sp->is_ssuc, sp->is_sbad);
 148         sendto_one_numeric(source_p, RPL_STATSDEBUG, "T :Client Server");
 149         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 150                            "T :connected %u %u", sp->is_cl, sp->is_sv);
 151         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 152                            "T :bytes sent %d.%uK %d.%uK",
 153                            (int) sp->is_cks, sp->is_cbs,
 154                            (int) sp->is_sks, sp->is_sbs);
 155         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 156                            "T :bytes recv %d.%uK %d.%uK",
 157                            (int) sp->is_ckr, sp->is_cbr,
 158                            (int) sp->is_skr, sp->is_sbr);
 159         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 160                            "T :time connected %d %d",
 161                            (int) sp->is_cti, (int) sp->is_sti);
 162 }
 163
 164 void
 165 count_memory(struct Client *source_p)
 166 {
 167         struct Client *target_p;
 168         struct Channel *chptr;
 169         struct Ban *actualBan;
 170         dlink_node *dlink;
 171         dlink_node *ptr;
 172         int channel_count = 0;
 173         int local_client_conf_count = 0;        /* local client conf links */
 174         int users_counted = 0;  /* user structs */
 175
 176         int channel_users = 0;
 177         int channel_invites = 0;
 178         int channel_bans = 0;
 179         int channel_except = 0;
 180         int channel_invex = 0;
 181         int channel_quiets = 0;
 182
 183         size_t wwu = 0;         /* whowas users */
 184         int class_count = 0;    /* classes */
 185         int conf_count = 0;     /* conf lines */
 186         int users_invited_count = 0;    /* users invited */
 187         int user_channels = 0;  /* users in channels */
 188         int aways_counted = 0;
 189         size_t number_servers_cached;   /* number of servers cached by scache */
 190
 191         size_t channel_memory = 0;
 192         size_t channel_ban_memory = 0;
 193         size_t channel_except_memory = 0;
 194         size_t channel_invex_memory = 0;
 195         size_t channel_quiet_memory = 0;
 196
 197         size_t away_memory = 0; /* memory used by aways */
 198         size_t wwm = 0;         /* whowas array memory used */
 199         size_t conf_memory = 0; /* memory used by conf lines */
 200         size_t mem_servers_cached;      /* memory used by scache */
 201
 202         size_t linebuf_count = 0;
 203         size_t linebuf_memory_used = 0;
 204
 205         size_t total_channel_memory = 0;
 206         size_t totww = 0;
 207
 208         size_t local_client_count = 0;
 209         size_t local_client_memory_used = 0;
 210
 211         size_t remote_client_count = 0;
 212         size_t remote_client_memory_used = 0;
 213
 214         size_t total_memory = 0;
 215
 216         count_whowas_memory(&wwu, &wwm);
 217
 218         DLINK_FOREACH(ptr, global_client_list.head)
 219         {
 220                 target_p = ptr->data;
 221                 if(MyConnect(target_p))
 222                 {
 223                         local_client_conf_count++;
 224                 }
 225
 226                 if(target_p->user)
 227                 {
 228                         users_counted++;
 229                         users_invited_count += dlink_list_length(&target_p->user->invited);
 230                         user_channels += dlink_list_length(&target_p->user->channel);
 231                         if(target_p->user->away)
 232                         {
 233                                 aways_counted++;
 234                                 away_memory += (strlen(target_p->user->away) + 1);
 235                         }
 236                 }
 237         }
 238
 239         /* Count up all channels, ban lists, except lists, Invex lists */
 240         DLINK_FOREACH(ptr, global_channel_list.head)
 241         {
 242                 chptr = ptr->data;
 243                 channel_count++;
 244                 channel_memory += (strlen(chptr->chname) + sizeof(struct Channel));
 245
 246                 channel_users += dlink_list_length(&chptr->members);
 247                 channel_invites += dlink_list_length(&chptr->invites);
 248
 249                 DLINK_FOREACH(dlink, chptr->banlist.head)
 250                 {
 251                         actualBan = dlink->data;
 252                         channel_bans++;
 253
 254                         channel_ban_memory += sizeof(dlink_node) + sizeof(struct Ban);
 255                 }
 256
 257                 DLINK_FOREACH(dlink, chptr->exceptlist.head)
 258                 {
 259                         actualBan = dlink->data;
 260                         channel_except++;
 261
 262                         channel_except_memory += (sizeof(dlink_node) + sizeof(struct Ban));
 263                 }
 264
 265                 DLINK_FOREACH(dlink, chptr->invexlist.head)
 266                 {
 267                         actualBan = dlink->data;
 268                         channel_invex++;
 269
 270                         channel_invex_memory += (sizeof(dlink_node) + sizeof(struct Ban));
 271                 }
 272
 273                 DLINK_FOREACH(dlink, chptr->quietlist.head)
 274                 {
 275                         actualBan = dlink->data;
 276                         channel_quiets++;
 277
 278                         channel_quiet_memory += (sizeof(dlink_node) + sizeof(struct Ban));
 279                 }
 280         }
 281
 282         /* count up all classes */
 283
 284         class_count = dlink_list_length(&class_list) + 1;
 285
 286         count_linebuf_memory(&linebuf_count, &linebuf_memory_used);
 287
 288         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 289                            "z :Users %u(%lu) Invites %u(%lu)",
 290                            users_counted,
 291                            (unsigned long) users_counted * sizeof(struct User),
 292                            users_invited_count,
 293                            (unsigned long) users_invited_count * sizeof(dlink_node));
 294
 295         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 296                            "z :User channels %u(%lu) Aways %u(%d)",
 297                            user_channels,
 298                            (unsigned long) user_channels * sizeof(dlink_node),
 299                            aways_counted, (int) away_memory);
 300
 301         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 302                            "z :Attached confs %u(%lu)",
 303                            local_client_conf_count,
 304                            (unsigned long) local_client_conf_count * sizeof(dlink_node));
 305
 306         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 307                            "z :Conflines %u(%d)", conf_count, (int) conf_memory);
 308
 309         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 310                            "z :Classes %u(%lu)",
 311                            class_count,
 312                            (unsigned long) class_count * sizeof(struct Class));
 313
 314         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 315                            "z :Channels %u(%d)",
 316                            channel_count, (int) channel_memory);
 317
 318         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 319                            "z :Bans %u(%d) Exceptions %u(%d) Invex %u(%d) Quiets %u(%d)",
 320                            channel_bans, (int) channel_ban_memory,
 321                            channel_except, (int) channel_except_memory,
 322                            channel_invex, (int) channel_invex_memory,
 323                            channel_quiets, (int) channel_quiet_memory);
 324
 325         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 326                            "z :Channel members %u(%lu) invite %u(%lu)",
 327                            channel_users,
 328                            (unsigned long) channel_users * sizeof(dlink_node),
 329                            channel_invites,
 330                            (unsigned long) channel_invites * sizeof(dlink_node));
 331
 332         total_channel_memory = channel_memory +
 333                 channel_ban_memory +
 334                 channel_users * sizeof(dlink_node) + channel_invites * sizeof(dlink_node);
 335
 336         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 337                            "z :Whowas users %ld(%ld)",
 338                            (long)wwu, (long) (wwu * sizeof(struct User)));
 339
 340         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 341                            "z :Whowas array %u(%d)",
 342                            NICKNAMEHISTORYLENGTH, (int) wwm);
 343
 344         totww = wwu * sizeof(struct User) + wwm;
 345
 346         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 347                            "z :Hash: client %u(%ld) chan %u(%ld)",
 348                            U_MAX, (long)(U_MAX * sizeof(dlink_list)),
 349                            CH_MAX, (long)(CH_MAX * sizeof(dlink_list)));
 350
 351         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 352                            "z :linebuf %ld(%ld)",
 353                            (long)linebuf_count, (long)linebuf_memory_used);
 354
 355         count_scache(&number_servers_cached, &mem_servers_cached);
 356
 357         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 358                            "z :scache %ld(%ld)",
 359                            (long)number_servers_cached, (long)mem_servers_cached);
 360
 361         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 362                            "z :hostname hash %d(%ld)",
 363                            HOST_MAX, (long)HOST_MAX * sizeof(dlink_list));
 364
 365         total_memory = totww + total_channel_memory + conf_memory +
 366                 class_count * sizeof(struct Class);
 367
 368         total_memory += mem_servers_cached;
 369         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 370                            "z :Total: whowas %d channel %d conf %d",
 371                            (int) totww, (int) total_channel_memory,
 372                            (int) conf_memory);
 373
 374         count_local_client_memory(&local_client_count, &local_client_memory_used);
 375         total_memory += local_client_memory_used;
 376
 377         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 378                            "z :Local client Memory in use: %ld(%ld)",
 379                            (long)local_client_count, (long)local_client_memory_used);
 380
 381
 382         count_remote_client_memory(&remote_client_count, &remote_client_memory_used);
 383         total_memory += remote_client_memory_used;
 384
 385         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 386                            "z :Remote client Memory in use: %ld(%ld)",
 387                            (long)remote_client_count,
 388                            (long)remote_client_memory_used);
 389
 390         sendto_one_numeric(source_p, RPL_STATSDEBUG,
 391                            "z :TOTAL: %d Available:  Current max RSS: %lu",
 392                            (int) total_memory, get_maxrss());
 393 }