xref: /dflybsd-src/test/debug/vmobjinfo.c (revision 8835adf8d6f12ed2e2bc71c55e928e81ae0339c0)

/*
 * VMOBJINFO.C
 *
 * cc -I/usr/src/sys vmobjinfo.c -o ~/bin/vmobjinfo -lkvm
 *
 * Dump all vm_object's in the system
 *
 * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#define _KERNEL_STRUCTURES
#include <sys/param.h>
#include <sys/user.h>
#include <sys/malloc.h>
#include <sys/signalvar.h>
#include <sys/namecache.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/buf.h>

#include <vm/vm.h>
#include <vm/vm_page.h>
#include <vm/vm_kern.h>
#include <vm/vm_object.h>
#include <vm/swap_pager.h>
#include <vm/vnode_pager.h>

#include <vfs/ufs/quota.h>
#include <vfs/ufs/inode.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <kvm.h>
#include <nlist.h>
#include <getopt.h>
#include <ctype.h>

TAILQ_HEAD(object_q, vm_object);

struct nlist Nl[] = {
    { "_vm_object_lists" },
    { "_nswdev" },
    { "_dmmax" },
    { NULL }
};

int VerboseOpt;
int nswdev;
int dmmax;
int memfds = -1;
int *swapfds;
char pgbuf[PAGE_SIZE];

static void scan_vmobjs(kvm_t *kd, struct object_q *obj_list);
static void dump_swap(kvm_t *kd, struct swblock *swbp);
static void dump_memq(kvm_t *kd, struct vm_page *pgp);
static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
static off_t devoffset(long blkno, int *whichp);

int
main(int ac, char **av)
{
    struct object_q obj_list[VMOBJ_HSIZE];
    kvm_t *kd;
    int i;
    int nswap;
    int ch;
    const char *corefile = NULL;
    const char *sysfile = NULL;

    while ((ch = getopt(ac, av, "M:N:v")) != -1) {
	switch(ch) {
	case 'M':
	    corefile = optarg;
	    break;
	case 'N':
	    sysfile = optarg;
	    break;
	case 'v':
	    ++VerboseOpt;
	    break;
	default:
	    fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
	    exit(1);
	}
    }
    if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
	perror("kvm_open");
	exit(1);
    }
    if (kvm_nlist(kd, Nl) != 0) {
	perror("kvm_nlist");
	exit(1);
    }
    kkread(kd, Nl[1].n_value, &nswdev, sizeof(nswdev));
    kkread(kd, Nl[2].n_value, &dmmax, sizeof(dmmax));

    if (VerboseOpt) {
	swapfds = calloc(sizeof(int), nswdev);
	for (i = 0; i < nswdev && i < ac - optind; ++i) {
		printf("open %s\n", av[optind + i]);
		swapfds[i] = open(av[optind + i], O_RDONLY);
	}
	while (i < nswdev) {
		swapfds[i] = -1;
		++i;
	}
	memfds = open("/dev/mem", O_RDONLY);
    }

    kkread(kd, Nl[0].n_value, obj_list, sizeof(obj_list));
    for (i = 0; i < VMOBJ_HSIZE; ++i)
	    scan_vmobjs(kd, &obj_list[i]);
    return(0);
}

static void
scan_vmobjs(kvm_t *kd, struct object_q *obj_list)
{
    struct vm_object *op;
    struct vm_object obj;

    op = TAILQ_FIRST(obj_list);
    while (op) {
	kkread(kd, (long)op, &obj, sizeof(obj));

	printf("%p type=%d size=%016jx handle=%p swblocks=%d\n",
		op, obj.type, (intmax_t)obj.size, obj.handle,
		obj.swblock_count);
	printf("\t\t   ref_count=%d backing_obj=%p\n",
		obj.ref_count, obj.backing_object);

	if (VerboseOpt) {
		dump_swap(kd, obj.swblock_root.rbh_root);
		if (obj.type == OBJT_DEFAULT || obj.type == OBJT_SWAP)
			dump_memq(kd, obj.rb_memq.rbh_root);
	}

	op = TAILQ_NEXT(&obj, object_list);
    }
}

static void
dump_swap(kvm_t *kd, struct swblock *swbp)
{
	struct swblock swb;
	int which;
	int i;
	int j;
	int k;
	int fd;
	off_t off;

	if (swbp == NULL)
		return;
	kkread(kd, (long)swbp, &swb, sizeof(swb));
	dump_swap(kd, swb.swb_entry.rbe_left);

	for (i = 0; i < SWAP_META_PAGES; ++i) {
		printf("    %016lx: ", (swb.swb_index + i) * 4096L);
		if (swb.swb_pages[i] == SWAPBLK_NONE) {
			printf(" (unassigned)\n");
			continue;
		}
		printf(" %ld\n", swb.swb_pages[i]);
		off = devoffset(swb.swb_pages[i], &which);
		if (swapfds[which] >= 0) {
			lseek(swapfds[which], off, 0);
			if (read(swapfds[which], pgbuf, sizeof(pgbuf)) <= 0)
				printf("\t(read failed)\n");
			else
			for (j = 0; j < PAGE_SIZE; j += 16) {
				printf("\t%04x ", j);
				for (k = 0; k < 16; ++k) {
					printf(" %02x", (uint8_t)pgbuf[j+k]);
					if (k == 7)
						printf(" ");
				}
				printf("  ");
				for (k = 0; k < 16; ++k) {
					if (isprint((uint8_t)pgbuf[j+k]))
						printf("%c", pgbuf[j+k]);
					else
						printf(".");
				}
				printf("\n");
			}
		}
	}

	dump_swap(kd, swb.swb_entry.rbe_right);
}

static void
dump_memq(kvm_t *kd, struct vm_page *pgp)
{
	struct vm_page pg;
	int j;
	int k;

	if (pgp == NULL)
		return;
	kkread(kd, (long)pgp, &pg, sizeof(pg));
	dump_memq(kd, pg.rb_entry.rbe_left);
	printf("    %016lx: %016jx (physical)\n",
	       pg.pindex * 4096L, (intmax_t)pg.phys_addr);
	lseek(memfds, pg.phys_addr, 0);
	if (read(memfds, pgbuf, sizeof(pgbuf)) <= 0) {
		printf("\t(read failed)\n");
	} else {
		for (j = 0; j < PAGE_SIZE; j += 16) {
			printf("\t%04x ", j);
			for (k = 0; k < 16; ++k) {
				printf(" %02x", (uint8_t)pgbuf[j+k]);
				if (k == 7)
					printf(" ");
			}
			printf("  ");
			for (k = 0; k < 16; ++k) {
				if (isprint((uint8_t)pgbuf[j+k]))
					printf("%c", pgbuf[j+k]);
				else
					printf(".");
			}
			printf("\n");
		}
	}

	dump_memq(kd, pg.rb_entry.rbe_right);
}

static void
kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
{
    if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
        perror("kvm_read");
        exit(1);
    }
}

static off_t
devoffset(long blkno, int *whichp)
{
	off_t off;
	long seg;

	if (nswdev > 1) {
		off = blkno % dmmax;
		seg = blkno / dmmax;
		*whichp = seg % nswdev;
		seg /= nswdev;
		off = (off_t)(seg * dmmax + off) << PAGE_SHIFT;
	} else {
		*whichp = 0;
		off = blkno * PAGE_SIZE;
	}
}