2 * Copyright (c) 1999 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
34 * $FreeBSD: src/lib/libkvm/kvm_getswapinfo.c,v 1.10.2.4 2003/01/12 09:23:13 dillon Exp $
35 * $DragonFly: src/lib/libkvm/kvm_getswapinfo.c,v 1.5 2006/03/18 17:15:35 dillon Exp $
38 #define _KERNEL_STRUCTURES
40 #include <sys/param.h>
42 #include <sys/ucred.h>
45 #include <sys/blist.h>
57 static struct nlist kvm_swap_nl
[] = {
58 { "_swapblist" }, /* new radix swap list */
59 { "_swdevt" }, /* list of swap devices and sizes */
60 { "_nswdev" }, /* number of swap devices */
61 { "_dmmax" }, /* maximum size of a swap block */
65 #define NL_SWAPBLIST 0
70 static int kvm_swap_nl_cached
= 0;
75 static void getswapinfo_radix(kvm_t
*kd
, struct kvm_swap
*swap_ary
,
76 int swap_max
, int flags
);
78 #define SVAR(var) __STRING(var) /* to force expansion */
79 #define KGET(idx, var) \
80 KGET1(idx, &var, sizeof(var), SVAR(var))
81 #define KGET1(idx, p, s, msg) \
82 KGET2(kvm_swap_nl[idx].n_value, p, s, msg)
83 #define KGET2(addr, p, s, msg) \
84 if (kvm_read(kd, (u_long)(addr), p, s) != s) \
85 warnx("cannot read %s: %s", msg, kvm_geterr(kd))
86 #define KGETN(idx, var) \
87 KGET1N(idx, &var, sizeof(var), SVAR(var))
88 #define KGET1N(idx, p, s, msg) \
89 KGET2N(kvm_swap_nl[idx].n_value, p, s, msg)
90 #define KGET2N(addr, p, s, msg) \
91 ((kvm_read(kd, (u_long)(addr), p, s) == s) ? 1 : 0)
92 #define KGETRET(addr, p, s, msg) \
93 if (kvm_read(kd, (u_long)(addr), p, s) != s) { \
94 warnx("cannot read %s: %s", msg, kvm_geterr(kd)); \
101 struct kvm_swap
*swap_ary
,
111 kvm_swap_nl_cached
= 0;
118 if (kvm_swap_nl_cached
== 0) {
121 if (kvm_nlist(kd
, kvm_swap_nl
) < 0)
129 kvm_swap_nl
[NL_SWDEVT
].n_value
== 0 ||
130 kvm_swap_nl
[NL_NSWDEV
].n_value
== 0 ||
131 kvm_swap_nl
[NL_DMMAX
].n_value
== 0 ||
132 kvm_swap_nl
[NL_SWAPBLIST
].n_type
== 0
138 * get globals, type of swap
141 KGET(NL_NSWDEV
, nswdev
);
142 KGET(NL_DMMAX
, dmmax
);
145 * figure out how many actual swap devices are enabled
149 for (unswdev
= nswdev
- 1; unswdev
>= 0; --unswdev
) {
150 struct swdevt swinfo
;
152 KGET2(&sw
[unswdev
], &swinfo
, sizeof(swinfo
), "swinfo");
158 kvm_swap_nl_cached
= 1;
171 bzero(swap_ary
, sizeof(struct kvm_swap
) * (ti
+ 1));
174 for (i
= 0; i
< unswdev
; ++i
) {
175 struct swdevt swinfo
;
178 KGET2(&sw
[i
], &swinfo
, sizeof(swinfo
), "swinfo");
181 * old style: everything in DEV_BSIZE'd chunks,
184 * new style: swinfo in DEV_BSIZE'd chunks but dmmax
187 * The first dmmax is never allocating to avoid
188 * trashing the disklabels
191 ttl
= swinfo
.sw_nblks
- dmmax
;
197 swap_ary
[i
].ksw_total
= ttl
;
198 swap_ary
[i
].ksw_used
= ttl
;
199 swap_ary
[i
].ksw_flags
= swinfo
.sw_flags
;
200 if (swinfo
.sw_dev
== NODEV
) {
202 swap_ary
[i
].ksw_devname
,
203 sizeof(swap_ary
[i
].ksw_devname
),
209 swap_ary
[i
].ksw_devname
,
210 sizeof(swap_ary
[i
].ksw_devname
),
212 ((flags
& SWIF_DEV_PREFIX
) ? _PATH_DEV
: ""),
213 devname(swinfo
.sw_dev
, S_IFCHR
)
218 swap_ary
[ti
].ksw_total
+= ttl
;
219 swap_ary
[ti
].ksw_used
+= ttl
;
224 getswapinfo_radix(kd
, swap_ary
, swap_max
, flags
);
229 * scanradix() - support routine for radix scanner
232 #define TABME tab, tab, ""
237 blmeta_t
*scan_cache
,
245 struct kvm_swap
*swap_ary
,
251 blmeta_t scan_array
[BLIST_BMAP_RADIX
];
252 int ti
= (unswdev
>= swap_max
) ? swap_max
- 1 : unswdev
;
256 } else if (skip
== BLIST_META_RADIX
) {
257 if (kvm_read(kd
, (u_long
)scan
, scan_array
, sizeof(scan_array
)) != sizeof(scan_array
)) {
258 warnx("cannot read %s: %s", "blmeta_t", kvm_geterr(kd
));
259 bzero(scan_array
, sizeof(scan_array
));
261 meta
= scan_array
[0];
263 KGET2(scan
, &meta
, sizeof(meta
), "blmeta_t");
269 if (meta
.bm_bighint
== (swblk_t
)-1) {
270 if (flags
& SWIF_DUMP_TREE
) {
271 printf("%*.*s(0x%06x,%lld) Terminator\n",
280 if (radix
== BLIST_BMAP_RADIX
) {
286 if (flags
& SWIF_DUMP_TREE
) {
287 printf("%*.*s(0x%06x,%lld) Bitmap %08x big=%d\n",
291 (int)meta
.u
.bmu_bitmap
,
297 * If not all allocated, count.
299 if (meta
.u
.bmu_bitmap
!= 0) {
300 for (i
= 0; i
< BLIST_BMAP_RADIX
&& i
< count
; ++i
) {
302 * A 0 bit means allocated
304 if ((meta
.u
.bmu_bitmap
& (1 << i
))) {
308 t
= (blk
+ i
) / dmmax
% nswdev
;
310 --swap_ary
[t
].ksw_used
;
312 --swap_ary
[ti
].ksw_used
;
316 } else if (meta
.u
.bmu_avail
== radix
) {
318 * Meta node if all free
320 if (flags
& SWIF_DUMP_TREE
) {
321 printf("%*.*s(0x%06x,%lld) Submap ALL-FREE {\n",
328 * Note: both dmmax and radix are powers of 2. However, dmmax
329 * may be larger then radix so use a smaller increment if
339 for (t
= blk
; t
< blk
+ radix
; t
+= tinc
) {
340 int u
= (nswdev
) ? (t
/ dmmax
% nswdev
) : 0;
343 swap_ary
[u
].ksw_used
-= tinc
;
345 swap_ary
[ti
].ksw_used
-= tinc
;
348 } else if (meta
.u
.bmu_avail
== 0) {
350 * Meta node if all used
352 if (flags
& SWIF_DUMP_TREE
) {
353 printf("%*.*s(0x%06x,%lld) Submap ALL-ALLOCATED\n",
361 * Meta node if not all free
366 if (flags
& SWIF_DUMP_TREE
) {
367 printf("%*.*s(0x%06x,%lld) Submap avail=%d big=%d {\n",
371 (int)meta
.u
.bmu_avail
,
376 radix
/= BLIST_META_RADIX
;
377 next_skip
= skip
/ BLIST_META_RADIX
;
379 for (i
= 1; i
<= skip
; i
+= next_skip
) {
381 swblk_t vcount
= (count
> radix
) ?
382 (swblk_t
)radix
: count
;
386 ((next_skip
== 1) ? &scan_array
[i
] : NULL
),
401 blk
+= (swblk_t
)radix
;
403 if (flags
& SWIF_DUMP_TREE
) {
404 printf("%*.*s}\n", TABME
);
411 getswapinfo_radix(kvm_t
*kd
, struct kvm_swap
*swap_ary
, int swap_max
, int flags
)
413 struct blist
*swapblist
= NULL
;
414 struct blist blcopy
= { 0 };
416 KGET(NL_SWAPBLIST
, swapblist
);
418 if (swapblist
== NULL
) {
419 if (flags
& SWIF_DUMP_TREE
)
420 printf("radix tree: NULL - no swap in system\n");
424 KGET2(swapblist
, &blcopy
, sizeof(blcopy
), "*swapblist");
426 if (flags
& SWIF_DUMP_TREE
) {
427 printf("radix tree: %d/%d/%lld blocks, %dK wired\n",
430 (long long)blcopy
.bl_radix
,
431 (int)((blcopy
.bl_rootblks
* sizeof(blmeta_t
) + 1023)/
437 * XXX Scan the radix tree in the kernel if we have more then one
438 * swap device so we can get per-device statistics. This can
439 * get nasty because swap devices are interleaved based on the
440 * maximum of (4), so the blist winds up not using any shortcuts.
442 * Otherwise just pull the free count out of the blist header,
443 * which is a billion times faster.
445 if ((flags
& SWIF_DUMP_TREE
) || unswdev
> 1) {
462 swap_ary
[0].ksw_used
-= blcopy
.bl_free
;