1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2003 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <mdb/mdb_modapi.h> 30 #include <sys/buf.h> 31 #include <sys/var.h> 32 #include <vm/page.h> 33 34 #include "bio.h" 35 36 typedef struct buf_walk { 37 uintptr_t bw_hbufbase; /* Base address of hbuf buckets */ 38 struct hbuf *bw_hbufs; /* Snapshot of hbuf buckets */ 39 size_t bw_nhbufs; /* Number of hbuf buckets */ 40 size_t bw_hbufi; /* Current hbuf index */ 41 buf_t *bw_bufp; /* Current buffer */ 42 } buf_walk_t; 43 44 int 45 buf_walk_init(mdb_walk_state_t *wsp) 46 { 47 struct hbuf *hbufs; 48 struct var v; 49 50 uintptr_t hbuf_addr; 51 size_t nbytes; 52 53 buf_walk_t *bwp; 54 55 if (wsp->walk_addr != NULL) { 56 mdb_warn("only global buf walk supported\n"); 57 return (WALK_ERR); 58 } 59 60 if (mdb_readvar(&v, "v") == -1) { 61 mdb_warn("failed to read var struct"); 62 return (WALK_ERR); 63 } 64 65 if (mdb_readvar(&hbuf_addr, "hbuf") == -1) { 66 mdb_warn("failed to read hbuf pointer"); 67 return (WALK_ERR); 68 } 69 70 nbytes = sizeof (struct hbuf) * v.v_hbuf; 71 hbufs = mdb_alloc(nbytes, UM_SLEEP); 72 73 if (mdb_vread(hbufs, nbytes, hbuf_addr) != nbytes) { 74 mdb_warn("failed to read hbufs"); 75 mdb_free(hbufs, nbytes); 76 return (WALK_ERR); 77 } 78 79 bwp = mdb_alloc(sizeof (buf_walk_t), UM_SLEEP); 80 81 bwp->bw_hbufbase = hbuf_addr; 82 bwp->bw_hbufs = hbufs; 83 bwp->bw_nhbufs = v.v_hbuf; 84 bwp->bw_hbufi = 0; 85 bwp->bw_bufp = mdb_alloc(sizeof (buf_t), UM_SLEEP); 86 87 wsp->walk_addr = (uintptr_t)hbufs[0].b_forw; 88 wsp->walk_data = bwp; 89 90 return (WALK_NEXT); 91 } 92 93 int 94 buf_walk_step(mdb_walk_state_t *wsp) 95 { 96 buf_walk_t *bwp = wsp->walk_data; 97 uintptr_t addr; 98 99 /* 100 * If the next buf_t address we want is NULL or points back at the 101 * hbuf itself, advance to the next hash bucket. When we reach 102 * bw_nhbufs, we're done. 103 */ 104 while (wsp->walk_addr == NULL || wsp->walk_addr == (bwp->bw_hbufbase + 105 bwp->bw_hbufi * sizeof (struct hbuf))) { 106 107 if (++bwp->bw_hbufi == bwp->bw_nhbufs) 108 return (WALK_DONE); 109 110 wsp->walk_addr = (uintptr_t) 111 bwp->bw_hbufs[bwp->bw_hbufi].b_forw; 112 } 113 114 /* 115 * When we have a buf_t address, read the buffer and invoke our 116 * walk callback. We keep the next buf_t address in wsp->walk_addr. 117 */ 118 addr = wsp->walk_addr; 119 (void) mdb_vread(bwp->bw_bufp, sizeof (buf_t), addr); 120 wsp->walk_addr = (uintptr_t)bwp->bw_bufp->b_forw; 121 122 return (wsp->walk_callback(addr, bwp->bw_bufp, wsp->walk_cbdata)); 123 } 124 125 void 126 buf_walk_fini(mdb_walk_state_t *wsp) 127 { 128 buf_walk_t *bwp = wsp->walk_data; 129 130 mdb_free(bwp->bw_hbufs, sizeof (struct hbuf) * bwp->bw_nhbufs); 131 mdb_free(bwp->bw_bufp, sizeof (buf_t)); 132 mdb_free(bwp, sizeof (buf_walk_t)); 133 } 134 135 /*ARGSUSED*/ 136 int 137 bufpagefind(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 138 { 139 uintptr_t b_addr = addr; 140 uintptr_t arg; 141 142 page_t p; 143 buf_t b; 144 145 if (argc != 1) 146 return (DCMD_USAGE); 147 148 if (argv->a_type == MDB_TYPE_IMMEDIATE) 149 arg = (uintptr_t)argv->a_un.a_val; 150 else 151 arg = (uintptr_t)mdb_strtoull(argv->a_un.a_str); 152 153 if (mdb_vread(&b, sizeof (buf_t), b_addr) == -1) 154 return (DCMD_ERR); 155 156 for (addr = (uintptr_t)b.b_pages; addr != NULL; 157 addr = (uintptr_t)p.p_next) { 158 159 if (addr == arg) { 160 mdb_printf("buf %p has page %p on b_pages list\n", 161 b_addr, addr); 162 break; 163 } 164 165 if (mdb_vread(&p, sizeof (page_t), addr) == -1) 166 return (DCMD_ERR); 167 } 168 169 return (DCMD_OK); 170 } 171