lib/libkvm/kvm_getswapinfo.c

   1 /*
   2  * Copyright (c) 1999 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $FreeBSD: src/lib/libkvm/kvm_getswapinfo.c,v 1.10.2.4 2003/01/12 09:23:13 dillon Exp $
  35  */
  36
  37 #define _KERNEL_STRUCTURES
  38
  39 #include <sys/param.h>
  40 #include <sys/time.h>
  41 #include <sys/ucred.h>
  42 #include <sys/stat.h>
  43 #include <sys/conf.h>
  44 #include <sys/blist.h>
  45 #include <sys/sysctl.h>
  46 #include <vm/vm_param.h>
  47
  48 #include <err.h>
  49 #include <fcntl.h>
  50 #include <nlist.h>
  51 #include <paths.h>
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #include <unistd.h>
  56 #include <limits.h>
  57
  58 #include "kvm.h"
  59 #include "kvm_private.h"
  60
  61 static struct nlist kvm_swap_nl[] = {
  62         { "_swapblist" },       /* new radix swap list          */
  63         { "_swdevt" },          /* list of swap devices and sizes */
  64         { "_nswdev" },          /* number of swap devices */
  65         { "_dmmax" },           /* maximum size of a swap block */
  66         { "" }
  67 };
  68
  69 #define NL_SWAPBLIST    0
  70 #define NL_SWDEVT       1
  71 #define NL_NSWDEV       2
  72 #define NL_DMMAX        3
  73
  74 static int kvm_swap_nl_cached = 0;
  75 static int nswdev;
  76 static int unswdev;
  77 static int dmmax;
  78
  79 static int nlist_init(kvm_t *kd);
  80 static void dump_blist(kvm_t *kd);
  81 static int kvm_getswapinfo_sysctl(kvm_t *kd, struct kvm_swap *swap_ary,
  82                               int swap_max, int flags);
  83
  84 #define SVAR(var) __STRING(var) /* to force expansion */
  85 #define KGET(idx, var)                                                  \
  86         KGET1(idx, &var, sizeof(var), SVAR(var))
  87 #define KGET1(idx, p, s, msg)                                           \
  88         KGET2(kvm_swap_nl[idx].n_value, p, s, msg)
  89 #define KGET2(addr, p, s, msg)                                          \
  90         if (kvm_read(kd, (u_long)(addr), p, s) != s)                    \
  91                 warnx("cannot read %s: %s", msg, kvm_geterr(kd))
  92 #define KGETN(idx, var)                                                 \
  93         KGET1N(idx, &var, sizeof(var), SVAR(var))
  94 #define KGET1N(idx, p, s, msg)                                          \
  95         KGET2N(kvm_swap_nl[idx].n_value, p, s, msg)
  96 #define KGET2N(addr, p, s, msg)                                         \
  97         ((kvm_read(kd, (u_long)(addr), p, s) == s) ? 1 : 0)
  98 #define KGETRET(addr, p, s, msg)                                        \
  99         if (kvm_read(kd, (u_long)(addr), p, s) != s) {                  \
 100                 warnx("cannot read %s: %s", msg, kvm_geterr(kd));       \
 101                 return (0);                                             \
 102         }
 103
 104 #define GETSWDEVNAME(dev, str, flags)                                   \
 105         if (dev == NODEV) {                                             \
 106                 strlcpy(str, "[NFS swap]", sizeof(str));                \
 107         } else {                                                        \
 108                 snprintf(                                               \
 109                     str, sizeof(str), "%s%s",                           \
 110                     ((flags & SWIF_DEV_PREFIX) ? _PATH_DEV : ""),       \
 111                     devname(dev, S_IFCHR)                               \
 112                 );                                                      \
 113         }
 114
 115 int
 116 kvm_getswapinfo(
 117         kvm_t *kd,
 118         struct kvm_swap *swap_ary,
 119         int swap_max,
 120         int flags
 121 ) {
 122         int i, ti, swi;
 123         swblk_t ttl;
 124         struct swdevt *sw;
 125         struct swdevt swinfo;
 126
 127         /*
 128          * clear cache
 129          */
 130         if (kd == NULL) {
 131                 kvm_swap_nl_cached = 0;
 132                 return(0);
 133         }
 134
 135         if (swap_max < 1)
 136                 return (-1);
 137
 138         /*
 139          * Use sysctl if possible
 140          */
 141         if (kvm_ishost(kd) && (flags & SWIF_DUMP_TREE) == 0) {
 142                 ti = kvm_getswapinfo_sysctl(kd, swap_ary, swap_max, flags);
 143                 if (ti >= 0)
 144                         return(ti);
 145         }
 146
 147         /*
 148          * namelist
 149          */
 150         if (!nlist_init(kd))
 151                 return (-1);
 152
 153         swi = unswdev;
 154         if (swi >= swap_max)
 155                 swi = swap_max - 1;
 156
 157         bzero(swap_ary, sizeof(struct kvm_swap) * (swi + 1));
 158
 159         KGET(NL_SWDEVT, sw);
 160         for (i = ti = 0; i < nswdev; ++i) {
 161                 KGET2(&sw[i], &swinfo, sizeof(swinfo), "swinfo");
 162
 163                 if (swinfo.sw_nblks == 0)
 164                         continue;
 165
 166                 /*
 167                  * The first dmmax is never allocated to avoid
 168                  * trashing the disklabels.
 169                  */
 170                 ttl = swinfo.sw_nblks - dmmax;
 171                 if (ttl == 0)
 172                         continue;
 173
 174                 swap_ary[swi].ksw_total += ttl;
 175                 swap_ary[swi].ksw_used += swinfo.sw_nused;
 176
 177                 if (ti < swi) {
 178                         swap_ary[ti].ksw_total = ttl;
 179                         swap_ary[ti].ksw_used = swinfo.sw_nused;
 180                         swap_ary[ti].ksw_flags = swinfo.sw_flags;
 181                         GETSWDEVNAME(swinfo.sw_dev, swap_ary[ti].ksw_devname,
 182                             flags);
 183                         ++ti;
 184                 }
 185         }
 186
 187         if (flags & SWIF_DUMP_TREE)
 188                 dump_blist(kd);
 189         return (swi);
 190 }
 191
 192 static int
 193 nlist_init(kvm_t *kd)
 194 {
 195         int i;
 196         struct swdevt *sw;
 197         struct swdevt swinfo;
 198
 199         if (kvm_swap_nl_cached)
 200                 return (1);
 201
 202         if (kvm_nlist(kd, kvm_swap_nl) < 0)
 203                 return (0);
 204
 205         /*
 206          * required entries
 207          */
 208         if (kvm_swap_nl[NL_SWDEVT].n_value == 0 ||
 209             kvm_swap_nl[NL_NSWDEV].n_value == 0 ||
 210             kvm_swap_nl[NL_DMMAX].n_value == 0 ||
 211             kvm_swap_nl[NL_SWAPBLIST].n_type == 0) {
 212                 return (0);
 213         }
 214
 215         /*
 216          * get globals, type of swap
 217          */
 218         KGET(NL_NSWDEV, nswdev);
 219         KGET(NL_DMMAX, dmmax);
 220
 221         /*
 222          * figure out how many actual swap devices are enabled
 223          */
 224         KGET(NL_SWDEVT, sw);
 225         for (i = unswdev = 0; i < nswdev; ++i) {
 226                 KGET2(&sw[i], &swinfo, sizeof(swinfo), "swinfo");
 227                 if (swinfo.sw_nblks)
 228                         ++unswdev;
 229
 230         }
 231
 232         kvm_swap_nl_cached = 1;
 233         return (1);
 234 }
 235
 236 /*
 237  * scanradix() - support routine for radix scanner
 238  */
 239
 240 #define TABME   tab, tab, ""
 241
 242 static int
 243 scanradix(
 244         blmeta_t *scan,
 245         blmeta_t *scan_cache,
 246         swblk_t blk,
 247         int64_t radix,
 248         swblk_t skip,
 249         swblk_t count,
 250         kvm_t *kd,
 251         int dmmaxr,
 252         int nswdevr,
 253         int64_t *availp,
 254         int tab
 255 ) {
 256         blmeta_t meta;
 257         blmeta_t scan_array[BLIST_BMAP_RADIX];
 258         int64_t avail_tmp = 0;
 259         int i, im;
 260         int next_skip;
 261
 262         if (scan_cache) {
 263                 meta = *scan_cache;
 264         } else if (skip == BLIST_META_RADIX) {
 265                 if (kvm_read(kd, (u_long)scan, scan_array, sizeof(scan_array)) != sizeof(scan_array)) {
 266                         warnx("cannot read %s: %s", "blmeta_t", kvm_geterr(kd));
 267                         bzero(scan_array, sizeof(scan_array));
 268                 }
 269                 meta = scan_array[0];
 270         } else {
 271                 KGET2(scan, &meta, sizeof(meta), "blmeta_t");
 272         }
 273
 274         /*
 275          * Terminator
 276          */
 277         if (meta.bm_bighint == (swblk_t)-1) {
 278                 printf("%*.*s(0x%06jx,%jd) Terminator\n",
 279                     TABME,
 280                     (intmax_t)blk,
 281                     (intmax_t)radix
 282                 );
 283                 return(-1);
 284         }
 285
 286         if (radix == BLIST_BMAP_RADIX) {
 287                 /*
 288                  * Leaf bitmap
 289                  */
 290                 printf("%*.*s(0x%06jx,%jd) Bitmap %016jx big=%jd\n",
 291                     TABME,
 292                     (intmax_t)blk,
 293                     (intmax_t)radix,
 294                     (intmax_t)meta.u.bmu_bitmap,
 295                     (intmax_t)meta.bm_bighint
 296                 );
 297
 298                 if (meta.u.bmu_bitmap) {
 299                         for (i = 0; i < BLIST_BMAP_RADIX; ++i) {
 300                                 if (meta.u.bmu_bitmap & (1 << i))
 301                                         ++*availp;
 302                         }
 303                 }
 304         } else if (meta.u.bmu_avail == radix) {
 305                 /*
 306                  * Meta node if all free
 307                  */
 308                 printf("%*.*s(0x%06jx,%jd) Submap ALL-FREE (big=%jd) {\n",
 309                     TABME,
 310                     (intmax_t)blk,
 311                     (intmax_t)radix,
 312                     (intmax_t)meta.bm_bighint
 313                 );
 314                 *availp += radix;
 315         } else if (meta.u.bmu_avail == 0) {
 316                 /*
 317                  * Meta node if all used
 318                  */
 319                 printf("%*.*s(0x%06jx,%jd) Submap ALL-ALLOCATED (big=%jd)\n",
 320                     TABME,
 321                     (intmax_t)blk,
 322                     (intmax_t)radix,
 323                     (intmax_t)meta.bm_bighint
 324                 );
 325         } else {
 326                 /*
 327                  * Meta node if not all free
 328                  */
 329                 printf("%*.*s(0x%06jx,%jd) Submap avail=%jd big=%jd {\n",
 330                     TABME,
 331                     (intmax_t)blk,
 332                     (intmax_t)radix,
 333                     (intmax_t)meta.u.bmu_avail,
 334                     (intmax_t)meta.bm_bighint
 335                 );
 336
 337                 radix /= BLIST_META_RADIX;
 338                 next_skip = skip / BLIST_META_RADIX;
 339
 340                 for (im = 1; im <= skip; im += next_skip) {
 341                         int r;
 342                         swblk_t vcount = (count > radix) ?
 343                                         (swblk_t)radix : count;
 344
 345                         r = scanradix(
 346                             &scan[im],
 347                             ((next_skip == 1) ? &scan_array[im] : NULL),
 348                             blk,
 349                             radix,
 350                             next_skip - 1,
 351                             vcount,
 352                             kd,
 353                             dmmaxr,
 354                             nswdevr,
 355                             &avail_tmp,
 356                             tab + 4
 357                         );
 358                         if (r < 0)
 359                                 break;
 360                         blk += (swblk_t)radix;
 361                 }
 362                 *availp += avail_tmp;
 363                 if (avail_tmp == meta.u.bmu_avail)
 364                         printf("%*.*s}\n", TABME);
 365                 else
 366                         printf("%*.*s} (AVAIL MISMATCH %jd/%jd\n",
 367                                 TABME,
 368                                 (intmax_t)avail_tmp,
 369                                 (intmax_t)meta.u.bmu_avail);
 370         }
 371         return(0);
 372 }
 373
 374 static void
 375 dump_blist(kvm_t *kd)
 376 {
 377         struct blist *swapblist = NULL;
 378         struct blist blcopy = { 0 };
 379         int64_t avail = 0;
 380
 381         KGET(NL_SWAPBLIST, swapblist);
 382
 383         if (swapblist == NULL) {
 384                 printf("radix tree: NULL - no swap in system\n");
 385                 return;
 386         }
 387
 388         KGET2(swapblist, &blcopy, sizeof(blcopy), "*swapblist");
 389
 390         printf("radix tree: %jd/%jd/%jd blocks, %jdK wired\n",
 391                 (intmax_t)blcopy.bl_free,
 392                 (intmax_t)blcopy.bl_blocks,
 393                 (intmax_t)blcopy.bl_radix,
 394                 (intmax_t)((blcopy.bl_rootblks * sizeof(blmeta_t) + 1023)/
 395                     1024)
 396         );
 397
 398         scanradix(
 399             blcopy.bl_root,
 400             NULL,
 401             0,
 402             blcopy.bl_radix,
 403             blcopy.bl_skip,
 404             blcopy.bl_rootblks,
 405             kd,
 406             dmmax,
 407             nswdev,
 408             &avail,
 409             0
 410         );
 411         printf("final availability: %jd\n", (intmax_t)avail);
 412 }
 413
 414 static
 415 int
 416 kvm_getswapinfo_sysctl(kvm_t *kd, struct kvm_swap *swap_ary,
 417                        int swap_max, int flags)
 418 {
 419         size_t bytes = 0;
 420         size_t ksize;
 421         int ti;
 422         int swi;
 423         int n;
 424         int i;
 425         char *xswbuf;
 426         struct xswdev *xsw;
 427
 428         if (sysctlbyname("vm.swap_info_array", NULL, &bytes, NULL, 0) < 0)
 429                 return(-1);
 430         if (bytes == 0)
 431                 return(-1);
 432
 433         xswbuf = malloc(bytes);
 434         if (sysctlbyname("vm.swap_info_array", xswbuf, &bytes, NULL, 0) < 0) {
 435                 free(xswbuf);
 436                 return(-1);
 437         }
 438         if (bytes == 0) {
 439                 free(xswbuf);
 440                 return(-1);
 441         }
 442
 443         /*
 444          * Calculate size of xsw entry returned by kernel (it can be larger
 445          * than the one we have if there is a version mismatch).
 446          */
 447         ksize = ((struct xswdev *)xswbuf)->xsw_size;
 448         n = (int)(bytes / ksize);
 449
 450         /*
 451          * Calculate the number of live swap devices and calculate
 452          * the swap_ary[] index used for the cumulative result (swi)
 453          */
 454         for (i = swi = 0; i < n; ++i) {
 455                 xsw = (void *)((char *)xswbuf + i * ksize);
 456                 if ((xsw->xsw_flags & SW_FREED) == 0)
 457                         continue;
 458                 ++swi;
 459         }
 460         if (swi >= swap_max)
 461                 swi = swap_max - 1;
 462
 463         bzero(swap_ary, sizeof(struct kvm_swap) * (swi + 1));
 464
 465         /*
 466          * Accumulate results.  If the provided swap_ary[] is too
 467          * small will only populate up to the available entries,
 468          * but we always populate the cumulative results entry.
 469          */
 470         for (i = ti = 0; i < n; ++i) {
 471                 xsw = (void *)((char *)xswbuf + i * ksize);
 472
 473                 if ((xsw->xsw_flags & SW_FREED) == 0)
 474                         continue;
 475
 476                 swap_ary[swi].ksw_total += xsw->xsw_nblks;
 477                 swap_ary[swi].ksw_used += xsw->xsw_used;
 478
 479                 if (ti < swi) {
 480                         swap_ary[ti].ksw_total = xsw->xsw_nblks;
 481                         swap_ary[ti].ksw_used = xsw->xsw_used;
 482                         swap_ary[ti].ksw_flags = xsw->xsw_flags;
 483                         GETSWDEVNAME(xsw->xsw_dev, swap_ary[ti].ksw_devname,
 484                             flags);
 485                         ++ti;
 486                 }
 487         }
 488
 489         free(xswbuf);
 490         return(swi);
 491 }