workspace/ksysguard/ksysguardd/FreeBSD/Memory.c

   1 /*
   2     KSysGuard, the KDE System Guard
   3
   4         Copyright (c) 1999-2000 Hans Petter Bieker <bieker@kde.org>
   5         Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20
  21 */
  22
  23 #include <sys/types.h>
  24 #include <sys/param.h>
  25 #include <sys/sysctl.h>
  26 #include <sys/vmmeter.h>
  27
  28 #include <vm/vm_param.h>
  29
  30 #include <fcntl.h>
  31 #include <kvm.h>
  32 #include <limits.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37
  38 #include "Command.h"
  39 #include "Memory.h"
  40 #include "ksysguardd.h"
  41
  42 static size_t Total = 0;
  43 static size_t MFree = 0;
  44 static size_t Used = 0;
  45 static size_t Buffers = 0;
  46 static size_t Cached = 0;
  47 static size_t Application = 0;
  48 static size_t STotal = 0;
  49 static size_t SFree = 0;
  50 static size_t SUsed = 0;
  51 static kvm_t *kd;
  52
  53 void
  54 initMemory(struct SensorModul* sm)
  55 {
  56         char *nlistf = NULL;
  57         char *memf = NULL;
  58         char buf[_POSIX2_LINE_MAX];
  59
  60         if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == NULL) {
  61                 log_error("kvm_openfiles()");
  62                 return;
  63         }
  64
  65         registerMonitor("mem/physical/free", "integer", printMFree, printMFreeInfo, sm);
  66         registerMonitor("mem/physical/used", "integer", printUsed, printUsedInfo, sm);
  67         registerMonitor("mem/physical/buf", "integer", printBuffers, printBuffersInfo, sm);
  68         registerMonitor("mem/physical/cached", "integer", printCached, printCachedInfo, sm);
  69         registerMonitor("mem/physical/application", "integer", printApplication, printApplicationInfo, sm);
  70         registerMonitor("mem/swap/free", "integer", printSwapFree, printSwapFreeInfo, sm);
  71         registerMonitor("mem/swap/used", "integer", printSwapUsed, printSwapUsedInfo, sm);
  72 }
  73
  74 void
  75 exitMemory(void)
  76 {
  77         kvm_close(kd);
  78 }
  79
  80 int
  81 updateMemory(void)
  82 {
  83         size_t len;
  84         FILE *file;
  85         char buf[256];
  86         struct kvm_swap kswap[16];
  87         int i, swap_count, hlen, pagesize = getpagesize();
  88         long blocksize;
  89
  90         len = sizeof (Total);
  91         sysctlbyname("hw.physmem", &Total, &len, NULL, 0);
  92         Total /= 1024;
  93
  94         /* Borrowed from pstat */
  95         swap_count = kvm_getswapinfo(kd, kswap, 16, SWIF_DEV_PREFIX);
  96         getbsize(&hlen, &blocksize);
  97
  98 #define CONVERT(v) ((int)((quad_t)(v) * pagesize / blocksize))
  99
 100         if (swap_count > 0) {
 101                 STotal = CONVERT(kswap[0].ksw_total);
 102                 SUsed = CONVERT(kswap[0].ksw_used);
 103                 SFree = CONVERT(kswap[0].ksw_total - kswap[0].ksw_used);
 104         }
 105
 106         len = sizeof (Buffers);
 107         if ((sysctlbyname("vfs.bufspace", &Buffers, &len, NULL, 0) == -1) || !len)
 108                 Buffers = 0; /* Doesn't work under FreeBSD v2.2.x */
 109         Buffers /= 1024;
 110
 111         len = sizeof (Cached);
 112         if ((sysctlbyname("vm.stats.vm.v_cache_count", &Cached, &len, NULL, 0) == -1) || !len)
 113                 Cached = 0; /* Doesn't work under FreeBSD v2.2.x */
 114         Cached *= pagesize / 1024;
 115
 116         len = sizeof (MFree);
 117         if ((sysctlbyname("vm.stats.vm.v_free_count", &MFree, &len, NULL, 0) == -1) || !len)
 118                 MFree = 0; /* Doesn't work under FreeBSD v2.2.x */
 119         MFree *= pagesize / 1024;
 120
 121         Used = Total - MFree;
 122         Application = Used - Buffers - Cached;
 123
 124         return 0;
 125 }
 126
 127 void
 128 printMFree(const char* cmd)
 129 {
 130         fprintf(CurrentClient, "%d\n", MFree);
 131 }
 132
 133 void
 134 printMFreeInfo(const char* cmd)
 135 {
 136         fprintf(CurrentClient, "Free Memory\t0\t%d\tKB\n", Total);
 137 }
 138
 139 void
 140 printUsed(const char* cmd)
 141 {
 142         fprintf(CurrentClient, "%d\n", Used);
 143 }
 144
 145 void
 146 printUsedInfo(const char* cmd)
 147 {
 148         fprintf(CurrentClient, "Used Memory\t0\t%d\tKB\n", Total);
 149 }
 150
 151 void
 152 printBuffers(const char* cmd)
 153 {
 154         fprintf(CurrentClient, "%d\n", Buffers);
 155 }
 156
 157 void
 158 printBuffersInfo(const char* cmd)
 159 {
 160         fprintf(CurrentClient, "Buffer Memory\t0\t%d\tKB\n", Total);
 161 }
 162
 163 void
 164 printCached(const char* cmd)
 165 {
 166         fprintf(CurrentClient, "%d\n", Cached);
 167 }
 168
 169 void
 170 printCachedInfo(const char* cmd)
 171 {
 172         fprintf(CurrentClient, "Cached Memory\t0\t%d\tKB\n", Total);
 173 }
 174
 175 void
 176 printApplication(const char* cmd)
 177 {
 178         fprintf(CurrentClient, "%d\n", Application);
 179 }
 180
 181 void
 182 printApplicationInfo(const char* cmd)
 183 {
 184         fprintf(CurrentClient, "Application Memory\t0\t%ld\tKB\n", Total);
 185 }
 186
 187 void
 188 printSwapUsed(const char* cmd)
 189 {
 190         fprintf(CurrentClient, "%d\n", SUsed);
 191 }
 192
 193 void
 194 printSwapUsedInfo(const char* cmd)
 195 {
 196         fprintf(CurrentClient, "Used Swap Memory\t0\t%d\tKB\n", STotal);
 197 }
 198
 199 void
 200 printSwapFree(const char* cmd)
 201 {
 202         fprintf(CurrentClient, "%d\n", SFree);
 203 }
 204
 205 void
 206 printSwapFreeInfo(const char* cmd)
 207 {
 208         fprintf(CurrentClient, "Free Swap Memory\t0\t%d\tKB\n", STotal);
 209 }