data.c

opensolaris下列出top进程

#include "data.h"

database *
init_database ()
{
  int i;
  database *data = malloc (sizeof (database));
  // cpu
  glibtop_cpu *cpu = malloc (sizeof (glibtop_cpu));
  glibtop_get_cpu (cpu);
  cpustorage *cpustore = malloc (sizeof (cpustorage));
  cpustore->olddata = cpu;
  // fill cpuusage (list)
  cpuusage *use = malloc (sizeof (cpuusage));
  use->total = cpu->total;
  use->user = cpu->user;
  use->nice = cpu->nice;
  use->sys = cpu->sys;
  use->idle = cpu->idle;
  use->frequency = cpu->frequency;
  use->next = NULL;
  data->Lcpu = use;
  data->Scpu = cpustore;
  cpuusage *temp = use;
  i = 0;
  while (cpu->xcpu_total[i] != 0)
    {
      cpuusage *neu = malloc (sizeof (cpuusage));
      neu->total = cpu->xcpu_total[i];
      neu->user = cpu->xcpu_user[i];
      neu->nice = cpu->xcpu_nice[i];
      neu->sys = cpu->xcpu_sys[i];
      neu->idle = cpu->xcpu_idle[i];
      neu->next = NULL;
      temp->next = neu;
      temp = neu;
      i++;
    }

  // memoryusage
  glibtop_mem *mem = malloc (sizeof (glibtop_mem));
  data->memoryusage = mem;

  // TODO: make this dynamic
  //  fill netload (list)
  netstorage *seth0 = malloc (sizeof (netload));
  netload *ueth0 = malloc (sizeof (netload));

  glibtop_netload *geth0 = malloc (sizeof (glibtop_netload));
  glibtop_get_netload (geth0, "eth0");

  seth0->olddata = geth0;
  seth0->next = NULL;
  strcpy (ueth0->device, "eth0");
  ueth0->next = NULL;

  data->Snetload = seth0;
  data->Lnetload = ueth0;

  // process list
  data->Lprocess = create_processlist ();
  find_top_processes (data->Lprocess, data->Tprocess, NUMBER_PROCESSES);

  // list of mounted filesystems
  glibtop_mountlist *mountlist = malloc (sizeof (glibtop_mountlist));
  // get a list of all fs
  glibtop_mountentry *mountentry = glibtop_get_mountlist (mountlist, 0);
  csm_fsinfo *previous;
  for (i = 0; i < mountlist->number; i++)
    {
      csm_fsinfo *neu = malloc (sizeof (csm_fsinfo));
      strcpy (neu->devname, mountentry[i].devname);
      strcpy (neu->mountdir, mountentry[i].mountdir);
      strcpy (neu->type, mountentry[i].type);
      //neu->mountentry = &mountentry[i];
      glibtop_fsusage *usage = malloc (sizeof (glibtop_fsusage));
      // get usage
      glibtop_get_fsusage (usage, mountentry[i].mountdir);
      // don't "use" filesystems with zero blocks or tmpfs
      if (usage->blocks == 0 || !strcmp (neu->type, "tmpfs"))
        continue;
      neu->fsusage = usage;
      // handle first node
      if (data->fsinfo == NULL)
        {
          data->fsinfo = neu;
          neu->prev = NULL;
          neu->next = NULL;
          previous = neu;
          continue;
        }
      neu->prev = previous;
      previous->next = neu;
      previous = neu;
      neu->next = NULL;
    }
  g_free (mountentry);
  free (mountlist);

  // XXX:  hack! (prevents division by zero in some cases)
  //       Bugs are fixed, this is for history reasons only;-)
  usleep (100000);

  return data;
}

void
free_database (database * data)
{
  g_free (data->Scpu->olddata);
  g_free (data->Scpu);
  g_free (data->memoryusage);
  //free Lcpu
  cpuusage *cputemp = data->Lcpu;
  cpuusage *cpudelinquent;
  while (cputemp != NULL)
    {
      cpudelinquent = cputemp;
      cputemp = cputemp->next;
      g_free (cpudelinquent);
    }
  g_free (cputemp);
  //free Lnetload
  netload *nettemp = data->Lnetload;
  netload *netdelinquent;
  while (nettemp != NULL)
    {
      netdelinquent = nettemp;
      nettemp = nettemp->next;
      g_free (netdelinquent);
    }
  g_free (nettemp);
  //free Snetload
  netstorage *snettemp = data->Snetload;
  netstorage *snetdelinquent;
  while (snettemp != NULL)
    {
      snetdelinquent = snettemp;
      snettemp = snettemp->next;
      g_free (snetdelinquent->olddata);
      g_free (snetdelinquent);
    }
  g_free (snettemp);
  // free processes
  process *ptemp = data->Lprocess;
  process *prev;
  while (ptemp != NULL)
    {
      prev = ptemp;
      ptemp = ptemp->next;
      free (prev);
    }
  // TODO: free filesystems
  free (ptemp);
  g_free (data);
}

/**
 * Methods which fill the data storage with the actual content
 */
void
calc_cpu (database * data)
{
  glibtop_cpu *cpu = g_malloc (sizeof (glibtop_cpu));
  glibtop_get_cpu (cpu);
  cpustorage *storage = data->Scpu;
  data->Lcpu->total = (cpu->total - storage->olddata->total);
  if (data->Lcpu->total != 0)
    {
      // if it is zero, no time has passed
      // since last invocation (and we would have division by zero)
      data->Lcpu->user =
        (cpu->user - storage->olddata->user) / data->Lcpu->total;
      data->Lcpu->nice =
        (cpu->nice - storage->olddata->nice) / data->Lcpu->total;
      data->Lcpu->sys =
        (cpu->sys - storage->olddata->sys) / data->Lcpu->total;
      data->Lcpu->idle =
        (cpu->idle - storage->olddata->idle) / data->Lcpu->total;
      data->Lcpu->frequency = cpu->frequency;
      // this is for smp systems,
      // calculate all other cpus
      cpuusage *temp = data->Lcpu->next;
      int i = 0;
      while (temp != NULL)
        {
          temp->total =
            (cpu->xcpu_total[i] - storage->olddata->xcpu_total[i]);
          temp->user =
            (cpu->xcpu_user[i] - storage->olddata->xcpu_user[i])
            / temp->total;
          temp->nice =
            (cpu->xcpu_nice[i] - storage->olddata->xcpu_nice[i])
            / temp->total;
          temp->sys =
            (cpu->xcpu_sys[i] - storage->olddata->xcpu_sys[i]) / temp->total;
          temp->idle =
            (cpu->xcpu_idle[i] - storage->olddata->xcpu_idle[i])
            / temp->total;
          temp = temp->next;
          i++;
        }
    }
  free (storage->olddata);
  storage->olddata = cpu;
}

void
calc_net (database * data)
{
  netload *current_netload = data->Lnetload;    // first netdevice
  netstorage *storage = data->Snetload;
  // walk list of interfaces
  while ((current_netload != NULL) && (storage != NULL))
    {
      glibtop_netload *new = malloc (sizeof (glibtop_netload));

      // get current info on device
      glibtop_get_netload (new, current_netload->device);
      glibtop_netload *old = storage->olddata;

      // calc netload
      current_netload->bytes_in = new->bytes_in - old->bytes_in;
      current_netload->bytes_out = new->bytes_out - old->bytes_out;
      current_netload->packets_in = new->packets_in - old->packets_in;
      current_netload->packets_out = new->packets_out - old->packets_out;
      current_netload->errors_in = new->errors_in - old->errors_in;
      current_netload->errors_out = new->errors_out - old->errors_out;
      current_netload->collisions = new->collisions - old->collisions;

      // free memory
      free (storage->olddata);
      storage->olddata = new;

      // goto next device
      current_netload = current_netload->next;
      storage = storage->next;
    }
}

void
calc_mem (database * data)
{
  glibtop_get_mem (data->memoryusage);
}

void
clean_csm_fsinfo (database * data)
{
  csm_fsinfo *temp = data->fsinfo;
  while (temp != NULL)
    {
      // this fs is no longer mounted
      if (temp->touched == 0)
        {
          csm_fsinfo *save = temp->next;
          if (temp->next != NULL)
            temp->next->prev = temp->prev;
          if (temp->prev != NULL)
            temp->prev->next = temp->next;
          // free temp
          free (temp->fsusage);
          free (temp);
          temp = save;
          continue;
        }
      temp = temp->next;
    }
}

void
clean_csm_fsinfo_touched (database * data)
{
  csm_fsinfo *temp = data->fsinfo;
  while (temp != NULL)
    {
      temp->touched = 0;
      temp = temp->next;
    }
}

void
update_csm_fsinfo (database * data)
{
  glibtop_mountlist *mountlist = malloc (sizeof (glibtop_mountlist));
  glibtop_mountentry *entries = glibtop_get_mountlist (mountlist, 0);
  int i, flag;
  for (i = 0; i < mountlist->number; i++)
    {
      flag = 0;
      csm_fsinfo *temp = data->fsinfo;
      while (temp != NULL)
        {
          // skip already found filesystems
          if (temp->touched == 1)
            {
              temp = temp->next;
              continue;
            }
          // is this mounted filesystem in our list?
          if (!strcmp (entries[i].mountdir, temp->mountdir))
            {
              temp->touched = 1;
              flag = 1;
              break;
            }
          temp = temp->next;
        }
      // filesystem is not yet in mountlist
      if (flag == 0)
        {
          // make new csm_fsinfo
          csm_fsinfo *neu = malloc (sizeof (csm_fsinfo));
          strcpy (neu->devname, entries[i].devname);
          strcpy (neu->mountdir, entries[i].mountdir);
          strcpy (neu->type, entries[i].type);
          neu->touched = 1;
          glibtop_fsusage *usage = malloc (sizeof (glibtop_fsusage));
          glibtop_get_fsusage (usage, entries[i].mountdir);
          neu->fsusage = usage;
          // don't use tmpfs and filesystems with zero blockcount
          if (usage->blocks == 0 || !strcmp (neu->type, "tmpfs"))
            {
              free (neu->fsusage);
              free (neu);
              continue;
            }
          neu->next = NULL;
          // goto last listitem
          temp = data->fsinfo;
          while (temp->next != NULL)
            {
              temp = temp->next;
            }
          temp->next = neu;
          neu->prev = temp;
        }                       // fi
    }                           // rof
  g_free (mountlist);
  g_free (entries);
  // clean list
  clean_csm_fsinfo (data);
  // reset csm_fsinfo->touched
  clean_csm_fsinfo_touched (data);
}

void
calc_disk (database * data)
{
  // update list of mounted filesystems
  update_csm_fsinfo (data);
  csm_fsinfo *temp = data->fsinfo;
  while (temp != NULL)
    {
      // update fsusage
      glibtop_get_fsusage (temp->fsusage, temp->mountdir);
      temp = temp->next;
    }
}

void
calc_top_processes (database * data)
{
  update_processlist (data->Lprocess);
  find_top_processes (data->Lprocess, data->Tprocess, NUMBER_PROCESSES);
}

/**
 * Utility functions
 */
void
init_csm ()
{
  glibtop_init ();
}