sysutils/bbsload/patches/patch-aa

   1 $NetBSD$
   2
   3 --- bbsload.cc.orig     2000-05-22 18:53:37.000000000 +0000
   4 +++ bbsload.cc
   5 @@ -21,6 +21,20 @@
   6
   7  #include "bbsload.hh"
   8
   9 +#ifdef __NetBSD__
  10 +#include <sys/param.h>
  11 +#include <sys/sysctl.h>
  12 +#include <uvm/uvm_param.h>
  13 +#elif defined(__DragonFly__)
  14 +#include <sys/param.h>
  15 +#include <sys/sysctl.h>
  16 +#include <sys/vmmeter.h>
  17 +#define template
  18 +#include <sys/user.h>
  19 +#undef template
  20 +#include <kinfo.h>
  21 +#endif
  22 +
  23  CheckLoad::CheckLoad(ToolWindow *toolwindow) {
  24    bbtool=toolwindow;
  25    timer=new BTimer(bbtool->getCurrentScreenInfo()->getBaseDisplay(),this) ;
  26 @@ -40,97 +54,106 @@ void CheckLoad::Reconfigure() {
  27
  28  void CheckLoad::timeout()
  29  {
  30 -    FILE *fp;
  31 -
  32 -    char loadstr[28];
  33 -    char buffer[128];
  34 -    bool redraw=False;
  35 -    struct stat file_status;
  36 -    static time_t last_mtime;
  37 -    static unsigned long old_user=0;
  38 -    static unsigned long old_nice=0;
  39 -    static unsigned long old_system=0;
  40 -    static unsigned long old_idle=0;
  41 -    broken=False;
  42 +    static u_int64_t old_user=0, old_nice=0, old_system=0,
  43 +           old_idle=0;
  44 +    u_int64_t user,nice,system,idle,total;
  45 +#if defined(__DragonFly__)
  46 +    struct kinfo_cputime cpu_time;
  47 +#else
  48 +    u_int64_t cputimes[5];
  49 +#endif
  50 +    double lavg[3];
  51 +#if defined(__DragonFly__)
  52 +    size_t vm_stat_size = sizeof(struct vmstats);
  53 +    struct vmstats vm_stat;
  54 +#else
  55 +    struct uvmexp uvm_stat;
  56 +#endif
  57 +    int    ctl_name[3];
  58 +    size_t ctllen;
  59
  60 -    if (!(fp = fopen("/proc/loadavg", "r")))
  61 -        broken=True;
  62 -    else
  63 -    {
  64 -        fstat(fileno(fp),&file_status);
  65 -        if  (file_status.st_mtime != last_mtime)
  66 -        {
  67 -            fgets(loadstr, 28, fp);
  68 -            sscanf(loadstr,"%e %e %e %d/%d",&load.average1m,
  69 -                    &load.average5m,&load.average15m,&task.running,
  70 -                    &task.total);
  71 -            redraw=true;
  72 -        }
  73 -    }
  74 -    fclose(fp);
  75 -     if (!(fp = fopen("/proc/meminfo", "r")))
  76 -        broken=True;
  77 -    else
  78 -    {
  79 -        fstat(fileno(fp),&file_status);
  80 -        if  (file_status.st_mtime != last_mtime)
  81 -        {
  82 -            /* should work for now */
  83 -            fgets(buffer,128,fp);
  84 -            fgets(buffer,128,fp);
  85 -            sscanf(buffer,"Mem:  %lu %lu %lu %lu %lu %lu",&mem.total,
  86 -                     &mem.used,&mem.free,&mem.shared,&mem.buffers,
  87 -                     &mem.cached);
  88 -            fgets(buffer,128,fp);
  89 -            sscanf(buffer,"Swap: %lu %lu %lu",
  90 -                   &swap.total,&swap.used,&swap.free);
  91 -
  92 -            norm.total_used=(double)(mem.used+swap.used)/
  93 -                            (double)(mem.total+swap.total);
  94 -            norm.mem_used=(double)mem.used/(double)mem.total;
  95 -            if (swap.total!=0)
  96 -              norm.swap_used=(double)swap.used/(double)swap.total;
  97 -
  98 -            redraw=true;
  99 -        }
 100 -    }
 101 -    fclose(fp);
 102 +    int i;
 103
 104 -    if (!(fp = fopen("/proc/stat", "r")))
 105 -        broken=True;
 106 -    else
 107 -    {
 108 -        fstat(fileno(fp),&file_status);
 109 -        if  (file_status.st_mtime != last_mtime)
 110 -        {
 111 -           unsigned long user,nice,system,idle,total;
 112 -            /* should work for now */
 113 -            fgets(buffer,128,fp);
 114 -            sscanf(buffer,"cpu  %lu %lu %lu %lu",&user,
 115 -                     &nice,&system,&idle);
 116 -            total=(user-old_user)+(nice-old_nice)+
 117 -                  (system-old_system)+(idle-old_idle);
 118 +    broken=False;
 119
 120 -            if ((total!=0)&(old_user!=0))
 121 -            {
 122 -              cpu.user=(user-old_user)/(double)total;
 123 -              cpu.nice=(nice-old_nice)/(double)user;
 124 -              cpu.system=(system-old_system)/(double)total;
 125 -              cpu.idle=(idle-old_idle)/(double)total;
 126 -            }
 127 -            else
 128 -              cpu.user=cpu.nice=cpu.system=cpu.idle=0;
 129 +    /* Get system load */
 130
 131 -            old_user=user;
 132 -            old_nice=nice;
 133 -            old_system=system;
 134 -            old_idle=idle;
 135 -            redraw=true;
 136 -        }
 137 -    }
 138 -    fclose(fp);
 139 -    if (redraw)
 140 -      bbtool->Redraw();
 141 +    getloadavg(lavg,3);
 142 +    load.average1m=lavg[0];
 143 +    load.average5m=lavg[1];
 144 +    load.average15m=lavg[2];
 145 +
 146 +    /* Get total amount of processes */
 147 +
 148 +    ctl_name[0]=CTL_KERN;
 149 +    ctl_name[1]=KERN_PROC;
 150 +    ctl_name[2]=KERN_PROC_ALL;
 151 +    sysctl(ctl_name, 3, NULL, &ctllen,NULL,0); /* get size of proc table */
 152 +    task.total=ctllen/sizeof(struct kinfo_proc); /* Anybody have an
 153 +               alternative ? */
 154 +
 155 +#if defined(__DragonFly__)
 156 +    sysctlbyname("vm.vmstats", &vm_stat, &vm_stat_size, NULL, 0);
 157 +    mem.total = vm_stat.v_page_count;
 158 +    mem.used = mem.total - vm_stat.v_free_count;
 159 +    swap.total = 0; /* XXX fill me in, expensive! */
 160 +    swap.used = 0;
 161 +#else
 162 +    /* task.running is missing */
 163 +    /* get memory statistics */
 164 +    ctllen=sizeof(uvm_stat);
 165 +    ctl_name[0]=CTL_VM;
 166 +    ctl_name[1]=VM_UVMEXP;
 167 +    sysctl(ctl_name,2,&uvm_stat,&ctllen,NULL,0);
 168 +
 169 +    mem.total=uvm_stat.npages;
 170 +    mem.used=uvm_stat.npages-uvm_stat.free;
 171 +
 172 +    swap.total=uvm_stat.swpages;
 173 +    swap.used=uvm_stat.swpgonly; /* Only count pages in swap which are
 174 +                       not also present in memory */
 175 +#endif
 176 +
 177 +    norm.total_used=(double)(mem.used+swap.used)/
 178 +                    (double)(mem.total+swap.total);
 179 +    norm.mem_used=(double)mem.used/(double)mem.total;
 180 +    if (swap.total!=0)
 181 +        norm.swap_used=(double)swap.used/(double)swap.total;
 182 +
 183 +#if defined(__DragonFly__)
 184 +    kinfo_get_sched_cputime(&cpu_time);
 185 +    user = cpu_time.cp_user;
 186 +    nice = cpu_time.cp_nice;
 187 +    system = cpu_time.cp_sys + cpu_time.cp_intr;
 188 +    idle = cpu_time.cp_idle;
 189 +#else
 190 +    ctl_name[0]=CTL_KERN;
 191 +    ctl_name[1]=KERN_CP_TIME;
 192 +    ctllen=sizeof(cputimes);
 193 +    if(sysctl(ctl_name,2,cputimes,&ctllen,NULL,0))
 194 +       perror("sysctl");
 195 +    user=cputimes[0];
 196 +    nice=cputimes[1];
 197 +    system=cputimes[2] /*sys*/
 198 +         +cputimes[3]/*intr*/;
 199 +    idle=cputimes[4];
 200 +#endif
 201 +    total=(user-old_user)+(nice-old_nice)+
 202 +    (system-old_system)+(idle-old_idle);
 203 +    if ((total!=0)&(old_user!=0))
 204 +    {
 205 +        cpu.user=(double)(user-old_user)/(double)total;
 206 +        cpu.nice=(double)(nice-old_nice)/(double)total;
 207 +        cpu.system=(double)(system-old_system)/(double)total;
 208 +        cpu.idle=(double)(idle-old_idle)/(double)total;
 209 +    }
 210 +    else
 211 +        cpu.user=cpu.nice=cpu.system=cpu.idle=0;
 212 +    old_user=user;
 213 +    old_nice=nice;
 214 +    old_system=system;
 215 +    old_idle=idle;
 216 +    bbtool->Redraw();
 217  }
 218
 219
 220 @@ -233,15 +256,15 @@ void ToolWindow::MakeWindow(bool reconfi
 221        label_counter++;
 222      }
 223      if (resource->show.label_totalused) {
 224 -      label.width[6] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 225 +      label.width[8] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 226        label_counter++;
 227      }
 228      if (resource->show.label_memused) {
 229 -      label.width[7] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 230 +      label.width[6] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 231        label_counter++;
 232      }
 233      if (resource->show.label_swapused) {
 234 -      label.width[8] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 235 +      label.width[7] =  XTextWidth(resource->label.font,"0.00",strlen("0.00"));
 236        label_counter++;
 237      }
 238      if (resource->show.label_usercpu) {
 239 @@ -545,7 +568,7 @@ void ToolWindow::RedrawGauge(double leve
 240    }
 241  }
 242
 243 -void ToolWindow::RedrawLabel(double level,int labelnr)
 244 +void ToolWindow::RedrawLabel(double level,int labelnr,int idx, BColor colour)
 245  {
 246    char t[6];
 247
 248 @@ -561,15 +584,14 @@ void ToolWindow::RedrawLabel(double leve
 249      xposition+=label.seperator_width;
 250    }
 251
 252 -  XSetForeground(getXDisplay(),frameGC,
 253 -                 resource->label.load1m_textColor.getPixel());
 254 +  XSetForeground(getXDisplay(),frameGC, colour.getPixel());
 255    labelnr++;
 256    sprintf(t,"%1.2f",level);
 257    XDrawString(getXDisplay(), labelwin, frameGC, xposition,
 258               (label.height+resource->label.font->ascent-
 259               resource->label.font->descent) / 2,
 260               t, strlen(t));
 261 -  xposition+=label.width[2];
 262 +  xposition+=label.width[idx];
 263  }
 264
 265  void ToolWindow::Redraw()
 266 @@ -577,12 +599,12 @@ void ToolWindow::Redraw()
 267      int offset=0;
 268      if (resource->show.load1m)
 269      {
 270 -        RedrawGauge(check_load->getLoad().average1m,offset);
 271 +        RedrawGauge(check_load->getLoad().average1m,offset);
 272          offset++;
 273      }
 274      if (resource->show.load5m)
 275      {
 276 -      RedrawGauge(check_load->getLoad().average5m,offset);
 277 +      RedrawGauge(check_load->getLoad().average5m,offset);
 278        offset++;
 279      }
 280      if (resource->show.load15m)
 281 @@ -678,53 +700,63 @@ void ToolWindow::Redraw()
 282
 283          if (resource->show.label_load1m)
 284          {
 285 -          RedrawLabel(check_load->getLoad().average1m,labelnr);
 286 -          labelnr++;
 287 +            RedrawLabel(check_load->getLoad().average1m,offset,2,
 288 +               resource->label.load1m_textColor);
 289 +            offset++;
 290          }
 291          if (resource->show.label_load5m)
 292          {
 293 -          RedrawLabel(check_load->getLoad().average5m,labelnr);
 294 -          labelnr++;
 295 +          RedrawLabel(check_load->getLoad().average5m,offset,3,
 296 +               resource->label.load5m_textColor);
 297 +          offset++;
 298          }
 299          if (resource->show.label_load15m)
 300          {
 301 -          RedrawLabel(check_load->getLoad().average15m,labelnr);
 302 -          labelnr++;
 303 +          RedrawLabel(check_load->getLoad().average15m,offset,4,
 304 +               resource->label.load15m_textColor);
 305 +          offset++;
 306          }
 307          if (resource->show.label_memused)
 308          {
 309 -          RedrawLabel(check_load->getNorm().mem_used,labelnr);
 310 -          labelnr++;
 311 +          RedrawLabel(check_load->getNorm().mem_used,offset,6,
 312 +               resource->label.memUsed_textColor);
 313 +          offset++;
 314          }
 315          if (resource->show.label_swapused)
 316          {
 317 -          RedrawLabel(check_load->getNorm().swap_used,labelnr);
 318 -          labelnr++;
 319 +          RedrawLabel(check_load->getNorm().swap_used,offset,7,
 320 +               resource->label.swapUsed_textColor);
 321 +          offset++;
 322          }
 323          if (resource->show.label_totalused)
 324          {
 325 -          RedrawLabel(check_load->getNorm().total_used,labelnr);
 326 -          labelnr++;
 327 +          RedrawLabel(check_load->getNorm().total_used,offset,8,
 328 +               resource->label.totalUsed_textColor);
 329 +          offset++;
 330          }
 331          if (resource->show.label_usercpu)
 332          {
 333 -          RedrawLabel(check_load->getCpu().user,labelnr);
 334 -          labelnr++;
 335 +           RedrawLabel(check_load->getCpu().user,offset,9,
 336 +               resource->label.seperator_textColor);
 337 +           offset++;
 338          }
 339          if (resource->show.label_nicecpu)
 340          {
 341 -          RedrawLabel(check_load->getCpu().nice,labelnr);
 342 -          labelnr++;
 343 +           RedrawLabel(check_load->getCpu().nice,offset,10,
 344 +               resource->label.seperator_textColor);
 345 +           offset++;
 346          }
 347          if (resource->show.label_systemcpu)
 348          {
 349 -          RedrawLabel(check_load->getCpu().system,labelnr);
 350 -          labelnr++;
 351 +           RedrawLabel(check_load->getCpu().system,offset,11,
 352 +               resource->label.seperator_textColor);
 353 +           offset++;
 354          }
 355          if (resource->show.label_idlecpu)
 356          {
 357 -          RedrawLabel(check_load->getCpu().idle,labelnr);
 358 -          labelnr++;
 359 +           RedrawLabel(check_load->getCpu().idle,offset,12,
 360 +               resource->label.seperator_textColor);
 361 +           offset++;
 362          }
 363      }
 364