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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright (c) 2013 by Delphix. All rights reserved. 27 */ 28 29 #include <sys/avl.h> 30 31 #include <mdb/mdb_modapi.h> 32 33 struct aw_info { 34 void *aw_buff; /* buffer to hold tree element */ 35 avl_tree_t aw_tree; /* copy of avl_tree_t being walked */ 36 uintptr_t aw_end; /* last node in specified range */ 37 const char *aw_elem_name; 38 int (*aw_elem_check)(void *, uintptr_t, void *); 39 void *aw_elem_check_arg; 40 }; 41 42 /* 43 * common code used to find the addr of the the leftmost child below 44 * an AVL node 45 */ 46 static uintptr_t 47 avl_leftmostchild(uintptr_t addr, void *buff, size_t offset, size_t size, 48 const char *elem_name) 49 { 50 avl_node_t *node = (avl_node_t *)((uintptr_t)buff + offset); 51 52 for (;;) { 53 addr -= offset; 54 if (mdb_vread(buff, size, addr) == -1) { 55 mdb_warn("failed to read %s at %#lx", elem_name, addr); 56 return ((uintptr_t)-1L); 57 } 58 if (node->avl_child[0] == NULL) 59 break; 60 addr = (uintptr_t)node->avl_child[0]; 61 } 62 return (addr); 63 } 64 65 /* 66 * initialize a forward walk thru an avl tree. 67 * 68 * begin and end optionally specify objects other than the first and last 69 * objects in the tree; either or both may be NULL (defaulting to first and 70 * last). 71 * 72 * avl_name and element_name specify command-specific labels other than 73 * "avl_tree_t" and "tree element" for use in error messages. 74 * 75 * element_check() returns -1, 1, or 0: abort the walk with an error, stop 76 * without an error, or allow the normal callback; arg is an optional user 77 * argument to element_check(). 78 */ 79 int 80 avl_walk_init_range(mdb_walk_state_t *wsp, uintptr_t begin, uintptr_t end, 81 const char *avl_name, const char *element_name, 82 int (*element_check)(void *, uintptr_t, void *), void *arg) 83 { 84 struct aw_info *aw; 85 avl_tree_t *tree; 86 uintptr_t addr; 87 88 if (avl_name == NULL) 89 avl_name = "avl_tree_t"; 90 if (element_name == NULL) 91 element_name = "tree element"; 92 93 /* 94 * allocate the AVL walk data 95 */ 96 wsp->walk_data = aw = mdb_zalloc(sizeof (struct aw_info), UM_SLEEP); 97 98 /* 99 * get an mdb copy of the avl_tree_t being walked 100 */ 101 tree = &aw->aw_tree; 102 if (mdb_vread(tree, sizeof (avl_tree_t), wsp->walk_addr) == -1) { 103 mdb_warn("failed to read %s at %#lx", avl_name, wsp->walk_addr); 104 goto error; 105 } 106 if (tree->avl_size < tree->avl_offset + sizeof (avl_node_t)) { 107 mdb_warn("invalid avl_tree_t at %p, avl_size:%d, avl_offset:%d", 108 wsp->walk_addr, tree->avl_size, tree->avl_offset); 109 goto error; 110 } 111 112 /* 113 * allocate a buffer to hold the mdb copy of tree's structs 114 * "node" always points at the avl_node_t field inside the struct 115 */ 116 aw->aw_buff = mdb_zalloc(tree->avl_size, UM_SLEEP); 117 aw->aw_end = (end == 0 ? 0 : end + tree->avl_offset); 118 aw->aw_elem_name = element_name; 119 aw->aw_elem_check = element_check; 120 aw->aw_elem_check_arg = arg; 121 122 /* 123 * get the first avl_node_t address, use same algorithm 124 * as avl_start() -- leftmost child in tree from root 125 */ 126 if (begin == 0) { 127 addr = (uintptr_t)tree->avl_root; 128 if (addr == 0) { 129 wsp->walk_addr = 0; 130 return (WALK_NEXT); 131 } 132 addr = avl_leftmostchild(addr, aw->aw_buff, tree->avl_offset, 133 tree->avl_size, aw->aw_elem_name); 134 if (addr == (uintptr_t)-1L) 135 goto error; 136 wsp->walk_addr = addr; 137 } else { 138 wsp->walk_addr = begin + tree->avl_offset; 139 } 140 141 return (WALK_NEXT); 142 143 error: 144 if (aw->aw_buff != NULL) 145 mdb_free(aw->aw_buff, sizeof (tree->avl_size)); 146 mdb_free(aw, sizeof (struct aw_info)); 147 return (WALK_ERR); 148 } 149 150 int 151 avl_walk_init(mdb_walk_state_t *wsp) 152 { 153 return (avl_walk_init_range(wsp, 0, 0, NULL, NULL, NULL, NULL)); 154 } 155 156 int 157 avl_walk_init_named(mdb_walk_state_t *wsp, 158 const char *avl_name, const char *element_name) 159 { 160 return (avl_walk_init_range(wsp, 0, 0, avl_name, element_name, 161 NULL, NULL)); 162 } 163 164 int 165 avl_walk_init_checked(mdb_walk_state_t *wsp, 166 const char *avl_name, const char *element_name, 167 int (*element_check)(void *, uintptr_t, void *), void *arg) 168 { 169 return (avl_walk_init_range(wsp, 0, 0, avl_name, element_name, 170 element_check, arg)); 171 } 172 173 /* 174 * At each step, visit (callback) the current node, then move to the next 175 * in the AVL tree. Uses the same algorithm as avl_walk(). 176 */ 177 int 178 avl_walk_step(mdb_walk_state_t *wsp) 179 { 180 struct aw_info *aw; 181 size_t offset; 182 size_t size; 183 uintptr_t addr; 184 avl_node_t *node; 185 int status; 186 int was_child; 187 188 /* 189 * don't walk past the end of the tree! 190 */ 191 addr = wsp->walk_addr; 192 if (addr == 0) 193 return (WALK_DONE); 194 195 aw = (struct aw_info *)wsp->walk_data; 196 197 if (aw->aw_end != 0 && wsp->walk_addr == aw->aw_end) 198 return (WALK_DONE); 199 200 size = aw->aw_tree.avl_size; 201 offset = aw->aw_tree.avl_offset; 202 node = (avl_node_t *)((uintptr_t)aw->aw_buff + offset); 203 204 /* 205 * must read the current node for the call back to use 206 */ 207 if (mdb_vread(aw->aw_buff, size, addr) == -1) { 208 mdb_warn("failed to read %s at %#lx", aw->aw_elem_name, addr); 209 return (WALK_ERR); 210 } 211 212 if (aw->aw_elem_check != NULL) { 213 int rc = aw->aw_elem_check(aw->aw_buff, addr, 214 aw->aw_elem_check_arg); 215 if (rc == -1) 216 return (WALK_ERR); 217 else if (rc == 1) 218 return (WALK_DONE); 219 } 220 221 /* 222 * do the call back 223 */ 224 status = wsp->walk_callback(addr, aw->aw_buff, wsp->walk_cbdata); 225 if (status != WALK_NEXT) 226 return (status); 227 228 /* 229 * move to the next node.... 230 * note we read in new nodes, so the pointer to the buffer is fixed 231 */ 232 233 /* 234 * if the node has a right child then go to it and then all the way 235 * thru as many left children as possible 236 */ 237 addr = (uintptr_t)node->avl_child[1]; 238 if (addr != 0) { 239 addr = avl_leftmostchild(addr, aw->aw_buff, offset, size, 240 aw->aw_elem_name); 241 if (addr == (uintptr_t)-1L) 242 return (WALK_ERR); 243 244 /* 245 * othewise return to parent nodes, stopping if we ever return from 246 * a left child 247 */ 248 } else { 249 for (;;) { 250 was_child = AVL_XCHILD(node); 251 addr = (uintptr_t)AVL_XPARENT(node); 252 if (addr == 0) 253 break; 254 addr -= offset; 255 if (was_child == 0) /* stop on return from left child */ 256 break; 257 if (mdb_vread(aw->aw_buff, size, addr) == -1) { 258 mdb_warn("failed to read %s at %#lx", 259 aw->aw_elem_name, addr); 260 return (WALK_ERR); 261 } 262 } 263 } 264 265 wsp->walk_addr = addr; 266 return (WALK_NEXT); 267 } 268 269 /* 270 * Release the memory allocated for the walk 271 */ 272 void 273 avl_walk_fini(mdb_walk_state_t *wsp) 274 { 275 struct aw_info *aw; 276 277 aw = (struct aw_info *)wsp->walk_data; 278 279 if (aw == NULL) 280 return; 281 282 if (aw->aw_buff != NULL) 283 mdb_free(aw->aw_buff, aw->aw_tree.avl_size); 284 285 mdb_free(aw, sizeof (struct aw_info)); 286 } 287 288 /* 289 * This function is named avl_walk_mdb to avoid a naming conflict with the 290 * existing avl_walk function. 291 */ 292 int 293 avl_walk_mdb(uintptr_t addr, mdb_walk_cb_t callback, void *cbdata) 294 { 295 mdb_walk_state_t ws; 296 int ret; 297 298 ws.walk_addr = addr; 299 ws.walk_callback = callback; 300 ws.walk_cbdata = cbdata; 301 302 avl_walk_init(&ws); 303 while ((ret = avl_walk_step(&ws)) == WALK_NEXT) 304 continue; 305 avl_walk_fini(&ws); 306 307 return (ret); 308 } 309