src/exim_monitor/em_strip.c

   1 /*************************************************
   2 *                   Exim Monitor                 *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7 /* SPDX-License-Identifier: GPL-2.0-or-later */
   8
   9
  10 #include "em_hdr.h"
  11
  12 /* This module contains functions for handling stripcharts */
  13
  14
  15 /*************************************************
  16 *               Static variables                 *
  17 *************************************************/
  18
  19 static int     queue_first_time = 1;         /* flag for resetting time */
  20 static int     size_first_time = 1;          /* and another */
  21
  22 static int     stripchart_count = 0;         /* count stripcharts created */
  23 static int    *stripchart_delay;             /* vector of delay counts */
  24 static Widget *stripchart_label;             /* vector of label widgets */
  25 static int    *stripchart_last_total;        /* vector of previous values */
  26 static int    *stripchart_max;               /* vector of maxima */
  27 static int    *stripchart_middelay;          /* vector of */
  28 static int    *stripchart_midmax;            /* vector of */
  29 static uschar  **stripchart_name;              /* vector of name strings */
  30 static Widget  stripchart_prev_chart = NULL; /* previously created chart */
  31 static Widget  stripchart_prev_label = NULL; /* previously created label */
  32
  33
  34
  35 /*************************************************
  36 *               Initialize                       *
  37 *************************************************/
  38
  39 void stripchart_init(void)
  40 {
  41 stripchart_delay =      (int *)store_malloc(stripchart_number * sizeof(int));
  42 stripchart_label =   (Widget *)store_malloc(stripchart_number * sizeof(Widget));
  43 stripchart_last_total = (int *)store_malloc(stripchart_number * sizeof(int));
  44 stripchart_max =        (int *)store_malloc(stripchart_number * sizeof(int));
  45 stripchart_middelay =   (int *)store_malloc(stripchart_number * sizeof(int));
  46 stripchart_midmax =     (int *)store_malloc(stripchart_number * sizeof(int));
  47 stripchart_name =     (uschar **)store_malloc(stripchart_number * sizeof(uschar *));
  48 stripchart_total =      (int *)store_malloc(stripchart_number * sizeof(int));
  49 }
  50
  51
  52
  53 /*************************************************
  54 *           Stripchart callback function         *
  55 *************************************************/
  56
  57 /* The client data is the index of the stripchart. We have to play
  58 a little game in order to ensure that the double value is correctly
  59 passed back via the value pointer without the compiler doing an
  60 unwanted cast. */
  61
  62 static void
  63 stripchartAction(Widget w, XtPointer client_data, XtPointer value)
  64 {
  65 double * ptr = (double *)value;
  66 static int thresholds[] =
  67   {10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 0};
  68 int num = (long)client_data;
  69 int oldmax = 0;
  70 int newmax = 0;
  71 int newvalue = 0;
  72 int i = 0;
  73
  74 /* For the queue stripchart, the value is the current vector value.
  75 We reset the initial delay of 1 second to the normal value. */
  76
  77 if (num == 0)
  78   {
  79   newvalue = stripchart_total[0];
  80   if (queue_first_time)
  81     {
  82     xs_SetValues(w, 1, "update", stripchart_update);
  83     queue_first_time = 0;
  84     }
  85   }
  86
  87 /* For the size monitoring stripchart, the value is the percentage
  88 fullness of the partition. A similar fudge to the above is implemented
  89 for the first time. Not all OS have statvfs(); for those that don't this
  90 code is omitted. In fact it should never be obeyed, as we don't allow
  91 size_stripchart to get set in that case. For some OS the old function
  92 and struct name statfs is used; that is handled by a macro. */
  93
  94 else if (size_stripchart != NULL && num == 1)
  95   {
  96 #ifdef HAVE_STATFS
  97   struct statvfs statbuf;
  98   if (statvfs(CS size_stripchart, &statbuf) == 0)
  99     {
 100     int used = statbuf.f_blocks - statbuf.f_bfree;
 101     int max = used + statbuf.f_bavail;
 102     double fraction = ((double)used) / ((double)max);
 103     newvalue = (int)((fraction + 0.005) * 100.0);
 104     }
 105 #endif
 106   if (size_first_time)
 107     {
 108     xs_SetValues(w, 1, "update", stripchart_update);
 109     size_first_time = 0;
 110     }
 111   }
 112
 113 /* For the configured stripcharts, the value to be set is
 114 the difference from last time; save the current total for
 115 next time. */
 116
 117 else
 118   {
 119   newvalue = stripchart_total[num] - stripchart_last_total[num];
 120   stripchart_last_total[num] = stripchart_total[num];
 121   }
 122
 123 /* Adjust the scale of the stripchart according to the value;
 124 we delay enlarging the scale for a while after the values
 125 reduce. Keep the maximum value while delaying, and reset
 126 down to that. For the size stripchart, the threshold is always
 127 forced to be at least 100. */
 128
 129 while (thresholds[i] > 0)
 130   {
 131   int thresh = (size_stripchart != NULL && num == 1)? 100 : thresholds[i++];
 132   if (newvalue < (double)thresh)
 133     {
 134     /* If the current maximum is less than required, or if it is
 135     greater and we have delayed long enough, adjust the scale. */
 136
 137     if (stripchart_max[num] < thresh ||
 138        (stripchart_max[num] > thresh && stripchart_delay[num]++ > 20))
 139       {
 140       uschar buffer[128];
 141       newmax = (thresh > stripchart_midmax[num])?
 142         thresh : stripchart_midmax[num];
 143       if (newmax == 10) sprintf(CS buffer, "%s", stripchart_name[num]);
 144         else sprintf(CS buffer, "%s x%d", stripchart_name[num], newmax/10);
 145       if (size_stripchart != NULL && num == 1) Ustrcat(buffer, US"%");
 146       xs_SetValues(stripchart_label[num], 1, "label", buffer);
 147       oldmax = stripchart_max[num];
 148       stripchart_max[num] = newmax;
 149       stripchart_midmax[num] = 0;
 150       stripchart_delay[num] -= stripchart_middelay[num];
 151       }
 152
 153     /* Otherwise, if the current maximum is greater than required,
 154     keep the highest value encountered during the delay, and its
 155     position so we can adjust the delay when re-scaling. */
 156
 157     else if (stripchart_max[num] > thresh)
 158       {
 159       if (thresh > stripchart_midmax[num])
 160         {
 161         stripchart_midmax[num] = thresh;
 162         stripchart_middelay[num] = stripchart_delay[num];
 163         }
 164       }
 165
 166     /* If the maximum is exactly what we need, reset the delay. */
 167
 168     if (stripchart_max[num] == thresh) stripchart_delay[num] = 0;
 169     break;
 170     }
 171   }
 172
 173 /* The vanilla Athena stripchart widget does not support change of
 174 scale - it just draws scale lines closer and closer together, which
 175 doesn't work when the number gets very large. However, we can cause
 176 it to change scale quite simply by recomputing all the values and
 177 then calling its repaint routine. I had to nobble the repaint routine
 178 too, to stop it changing scale to anything other than 10. There's
 179 probably a better way to do this, like adding some new resource, but
 180 I'm not a widget programmer and want to get on with the rest of
 181 eximon... */
 182
 183 if (oldmax > 0)
 184   {
 185   int i;
 186   StripChartWidget ww = (StripChartWidget)w;
 187   ww->strip_chart.max_value = 0;
 188   for (i = 0; i < (int)ww->strip_chart.interval; i++)
 189     {
 190     ww->strip_chart.valuedata[i] =
 191       (ww->strip_chart.valuedata[i] * oldmax)/newmax;
 192     if (ww->strip_chart.valuedata[i] > ww->strip_chart.max_value)
 193       ww->strip_chart.max_value = ww->strip_chart.valuedata[i];
 194     }
 195   XClearWindow( XtDisplay(w), XtWindow(w));
 196   ww->strip_chart.interval = repaint_window(ww, 0, (int)w->core.width);
 197   }
 198
 199 /* Pass back the new value at the new scale */
 200
 201 *ptr = ((double)newvalue * 10.0)/(double)(stripchart_max[num]);
 202 }
 203
 204
 205
 206 /*************************************************
 207 *            Create one stripchart               *
 208 *************************************************/
 209
 210 /* This function creates two widgets, one being the title and the other being
 211 the stripchart. The client_data values for each stripchart are index into the
 212 stripchart_values vector; each new stripchart just gets the next number. There
 213 is a fudge for the very first stripchart, which is the queue length display,
 214 and for the second if it is a partition size display; its update time is
 215 initially set to 1 second so that it gives an immediate display of the queue.
 216 The first time its callback function is obeyed, the update time gets reset. */
 217
 218 void
 219 create_stripchart(Widget parent, uschar *title)
 220 {
 221 Widget chart;
 222
 223 Widget label = XtCreateManagedWidget("label",
 224   labelWidgetClass, parent, NULL, 0);
 225
 226 xs_SetValues(label, 10,
 227   "label",          title,
 228   "width",          stripchart_width + 2,
 229   "borderWidth",    0,
 230   "internalHeight", 0,
 231   "internalWidth",  0,
 232   "left",           XawChainLeft,
 233   "right",          XawChainLeft,
 234   "top",            XawChainTop,
 235   "bottom",         XawChainTop,
 236   XtNfromHoriz,     stripchart_prev_label);
 237
 238 chart = XtCreateManagedWidget("stripchart",
 239   mystripChartWidgetClass, parent, NULL, 0);
 240
 241 xs_SetValues(chart, 11,
 242   "jumpScroll", 1,
 243   "update",     (stripchart_count < stripchart_varstart)? 1:stripchart_update,
 244   "minScale",   10,
 245   "width",      stripchart_width,
 246   "height",     stripchart_height,
 247   "left",       XawChainLeft,
 248   "right",      XawChainLeft,
 249   "top",        XawChainTop,
 250   "bottom",     XawChainTop,
 251   XtNfromHoriz, stripchart_prev_chart,
 252   XtNfromVert,  label);
 253
 254 XtAddCallback(chart, "getValue", stripchartAction,
 255   (XtPointer)(long)stripchart_count);
 256
 257 stripchart_last_total[stripchart_count] = 0;
 258 stripchart_max[stripchart_count] = 10;
 259 stripchart_midmax[stripchart_count] = 0;
 260 stripchart_name[stripchart_count] = title;
 261 stripchart_prev_label = stripchart_label[stripchart_count] = label;
 262 stripchart_prev_chart = chart;
 263 stripchart_total[stripchart_count] = 0;
 264 stripchart_count++;
 265 }
 266
 267 /* End of em_strip.c */