4229 mdb hangs on exit when long umem cache names exist Reviewed by: Robert Mustacchi <rm@joyent.com>
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 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 /* 27 * Copyright (c) 2013 Josef 'Jeff' Sipek <jeffpc@josefsipek.net> 28 */ 29 30 #include <mdb/mdb_debug.h> 31 #include <mdb/mdb_string.h> 32 #include <mdb/mdb_modapi.h> 33 #include <mdb/mdb_err.h> 34 #include <mdb/mdb_nv.h> 35 #include <mdb/mdb.h> 36 37 #define NV_NAME(v) \ 38 (((v)->v_flags & MDB_NV_EXTNAME) ? (v)->v_ename : (v)->v_lname) 39 40 #define NV_SIZE(v) \ 41 (((v)->v_flags & MDB_NV_EXTNAME) ? sizeof (mdb_var_t) : \ 42 sizeof (mdb_var_t) + strlen((v)->v_lname)) 43 44 #define NV_HASHSZ 211 45 46 static size_t 47 nv_hashstring(const char *key) 48 { 49 size_t g, h = 0; 50 const char *p; 51 52 ASSERT(key != NULL); 53 54 for (p = key; *p != '\0'; p++) { 55 h = (h << 4) + *p; 56 57 if ((g = (h & 0xf0000000)) != 0) { 58 h ^= (g >> 24); 59 h ^= g; 60 } 61 } 62 63 return (h); 64 } 65 66 static mdb_var_t * 67 nv_var_alloc(const char *name, const mdb_nv_disc_t *disc, 68 uintmax_t value, uint_t flags, uint_t um_flags, mdb_var_t *next) 69 { 70 size_t nbytes; 71 mdb_var_t *v; 72 73 if (flags & MDB_NV_EXTNAME) 74 nbytes = sizeof (mdb_var_t); 75 else 76 nbytes = sizeof (mdb_var_t) + strlen(name); 77 78 v = mdb_alloc(nbytes, um_flags); 79 80 if (v == NULL) 81 return (NULL); 82 83 if (flags & MDB_NV_EXTNAME) { 84 v->v_ename = name; 85 v->v_lname[0] = '\0'; 86 } else { 87 /* 88 * We don't overflow here since the mdb_var_t itself has 89 * room for the trailing \0. 90 */ 91 (void) strcpy(v->v_lname, name); 92 v->v_ename = NULL; 93 } 94 95 v->v_uvalue = value; 96 v->v_flags = flags & ~(MDB_NV_SILENT | MDB_NV_INTERPOS); 97 v->v_disc = disc; 98 v->v_next = next; 99 100 return (v); 101 } 102 103 static void 104 nv_var_free(mdb_var_t *v, uint_t um_flags) 105 { 106 if (um_flags & UM_GC) 107 return; 108 109 if (v->v_flags & MDB_NV_OVERLOAD) { 110 mdb_var_t *w, *nw; 111 112 for (w = v->v_ndef; w != NULL; w = nw) { 113 nw = w->v_ndef; 114 mdb_free(w, NV_SIZE(w)); 115 } 116 } 117 118 mdb_free(v, NV_SIZE(v)); 119 } 120 121 /* 122 * Can return NULL only if the nv's memory allocation flags include UM_NOSLEEP 123 */ 124 mdb_nv_t * 125 mdb_nv_create(mdb_nv_t *nv, uint_t um_flags) 126 { 127 nv->nv_hash = mdb_zalloc(sizeof (mdb_var_t *) * NV_HASHSZ, um_flags); 128 129 if (nv->nv_hash == NULL) 130 return (NULL); 131 132 nv->nv_hashsz = NV_HASHSZ; 133 nv->nv_nelems = 0; 134 nv->nv_iter_elt = NULL; 135 nv->nv_iter_bucket = 0; 136 nv->nv_um_flags = um_flags; 137 138 return (nv); 139 } 140 141 void 142 mdb_nv_destroy(mdb_nv_t *nv) 143 { 144 mdb_var_t *v, *w; 145 size_t i; 146 147 if (nv->nv_um_flags & UM_GC) 148 return; 149 150 for (i = 0; i < nv->nv_hashsz; i++) { 151 for (v = nv->nv_hash[i]; v != NULL; v = w) { 152 w = v->v_next; 153 nv_var_free(v, nv->nv_um_flags); 154 } 155 } 156 157 mdb_free(nv->nv_hash, sizeof (mdb_var_t *) * NV_HASHSZ); 158 } 159 160 mdb_var_t * 161 mdb_nv_lookup(mdb_nv_t *nv, const char *name) 162 { 163 size_t i = nv_hashstring(name) % nv->nv_hashsz; 164 mdb_var_t *v; 165 166 for (v = nv->nv_hash[i]; v != NULL; v = v->v_next) { 167 if (strcmp(NV_NAME(v), name) == 0) 168 return (v); 169 } 170 171 return (NULL); 172 } 173 174 /* 175 * Interpose W in place of V. We replace V with W in nv_hash, and then 176 * set W's v_ndef overload chain to point at V. 177 */ 178 static mdb_var_t * 179 nv_var_interpos(mdb_nv_t *nv, size_t i, mdb_var_t *v, mdb_var_t *w) 180 { 181 mdb_var_t **pvp = &nv->nv_hash[i]; 182 183 while (*pvp != v) { 184 mdb_var_t *vp = *pvp; 185 ASSERT(vp != NULL); 186 pvp = &vp->v_next; 187 } 188 189 *pvp = w; 190 w->v_next = v->v_next; 191 w->v_ndef = v; 192 v->v_next = NULL; 193 194 return (w); 195 } 196 197 /* 198 * Add W to the end of V's overload chain. We simply follow v_ndef to the 199 * end, and then append W. We don't expect these chains to grow very long. 200 */ 201 static mdb_var_t * 202 nv_var_overload(mdb_var_t *v, mdb_var_t *w) 203 { 204 while (v->v_ndef != NULL) 205 v = v->v_ndef; 206 207 v->v_ndef = w; 208 return (w); 209 } 210 211 /* 212 * Can return NULL only if the nv's memory allocation flags include UM_NOSLEEP 213 */ 214 mdb_var_t * 215 mdb_nv_insert(mdb_nv_t *nv, const char *name, const mdb_nv_disc_t *disc, 216 uintmax_t value, uint_t flags) 217 { 218 size_t i = nv_hashstring(name) % nv->nv_hashsz; 219 mdb_var_t *v; 220 221 ASSERT(!(flags & MDB_NV_EXTNAME) || !(flags & MDB_NV_OVERLOAD)); 222 ASSERT(!(flags & MDB_NV_RDONLY) || !(flags & MDB_NV_OVERLOAD)); 223 224 /* 225 * If the specified name is already hashed, 226 * and MDB_NV_OVERLOAD is set: insert new var into overload chain 227 * and MDB_NV_RDONLY is set: leave var unchanged, issue warning 228 * otherwise: update var with new value 229 */ 230 for (v = nv->nv_hash[i]; v != NULL; v = v->v_next) { 231 if (strcmp(NV_NAME(v), name) == 0) { 232 if (v->v_flags & MDB_NV_OVERLOAD) { 233 mdb_var_t *w = nv_var_alloc(NV_NAME(v), disc, 234 value, flags, nv->nv_um_flags, NULL); 235 236 if (w == NULL) { 237 ASSERT(nv->nv_um_flags & UM_NOSLEEP); 238 return (NULL); 239 } 240 241 if (flags & MDB_NV_INTERPOS) 242 v = nv_var_interpos(nv, i, v, w); 243 else 244 v = nv_var_overload(v, w); 245 246 } else if (v->v_flags & MDB_NV_RDONLY) { 247 if (!(flags & MDB_NV_SILENT)) { 248 warn("cannot modify read-only " 249 "variable '%s'\n", NV_NAME(v)); 250 } 251 } else 252 v->v_uvalue = value; 253 254 ASSERT(v != NULL); 255 return (v); 256 } 257 } 258 259 /* 260 * If the specified name was not found, initialize a new element 261 * and add it to the hash table at the beginning of this chain: 262 */ 263 v = nv_var_alloc(name, disc, value, flags, nv->nv_um_flags, 264 nv->nv_hash[i]); 265 266 if (v == NULL) { 267 ASSERT(nv->nv_um_flags & UM_NOSLEEP); 268 return (NULL); 269 } 270 271 nv->nv_hash[i] = v; 272 nv->nv_nelems++; 273 274 return (v); 275 } 276 277 static void 278 nv_var_defn_remove(mdb_var_t *v, mdb_var_t *corpse, uint_t um_flags) 279 { 280 mdb_var_t *w = v; 281 282 while (v->v_ndef != NULL && v->v_ndef != corpse) 283 v = v->v_ndef; 284 285 if (v == NULL) { 286 fail("var %p ('%s') not found on defn chain of %p\n", 287 (void *)corpse, NV_NAME(corpse), (void *)w); 288 } 289 290 v->v_ndef = corpse->v_ndef; 291 corpse->v_ndef = NULL; 292 nv_var_free(corpse, um_flags); 293 } 294 295 void 296 mdb_nv_remove(mdb_nv_t *nv, mdb_var_t *corpse) 297 { 298 const char *cname = NV_NAME(corpse); 299 size_t i = nv_hashstring(cname) % nv->nv_hashsz; 300 mdb_var_t *v = nv->nv_hash[i]; 301 mdb_var_t **pvp; 302 303 if (corpse->v_flags & MDB_NV_PERSIST) { 304 warn("cannot remove persistent variable '%s'\n", cname); 305 return; 306 } 307 308 if (v != corpse) { 309 do { 310 if (strcmp(NV_NAME(v), cname) == 0) { 311 if (corpse->v_flags & MDB_NV_OVERLOAD) { 312 nv_var_defn_remove(v, corpse, 313 nv->nv_um_flags); 314 return; /* No v_next changes needed */ 315 } else 316 goto notfound; 317 } 318 319 if (v->v_next == corpse) 320 break; /* Corpse is next on the chain */ 321 322 } while ((v = v->v_next) != NULL); 323 324 if (v == NULL) 325 goto notfound; 326 327 pvp = &v->v_next; 328 } else 329 pvp = &nv->nv_hash[i]; 330 331 if ((corpse->v_flags & MDB_NV_OVERLOAD) && corpse->v_ndef != NULL) { 332 corpse->v_ndef->v_next = corpse->v_next; 333 *pvp = corpse->v_ndef; 334 corpse->v_ndef = NULL; 335 } else { 336 *pvp = corpse->v_next; 337 nv->nv_nelems--; 338 } 339 340 nv_var_free(corpse, nv->nv_um_flags); 341 return; 342 343 notfound: 344 fail("var %p ('%s') not found on hash chain: nv=%p [%lu]\n", 345 (void *)corpse, cname, (void *)nv, (ulong_t)i); 346 } 347 348 void 349 mdb_nv_rewind(mdb_nv_t *nv) 350 { 351 size_t i; 352 353 for (i = 0; i < nv->nv_hashsz; i++) { 354 if (nv->nv_hash[i] != NULL) 355 break; 356 } 357 358 nv->nv_iter_elt = i < nv->nv_hashsz ? nv->nv_hash[i] : NULL; 359 nv->nv_iter_bucket = i; 360 } 361 362 mdb_var_t * 363 mdb_nv_advance(mdb_nv_t *nv) 364 { 365 mdb_var_t *v = nv->nv_iter_elt; 366 size_t i; 367 368 if (v == NULL) 369 return (NULL); 370 371 if (v->v_next != NULL) { 372 nv->nv_iter_elt = v->v_next; 373 return (v); 374 } 375 376 for (i = nv->nv_iter_bucket + 1; i < nv->nv_hashsz; i++) { 377 if (nv->nv_hash[i] != NULL) 378 break; 379 } 380 381 nv->nv_iter_elt = i < nv->nv_hashsz ? nv->nv_hash[i] : NULL; 382 nv->nv_iter_bucket = i; 383 384 return (v); 385 } 386 387 mdb_var_t * 388 mdb_nv_peek(mdb_nv_t *nv) 389 { 390 return (nv->nv_iter_elt); 391 } 392 393 size_t 394 mdb_nv_size(mdb_nv_t *nv) 395 { 396 return (nv->nv_nelems); 397 } 398 399 static int 400 nv_compare(const mdb_var_t **lp, const mdb_var_t **rp) 401 { 402 return (strcmp(mdb_nv_get_name(*lp), mdb_nv_get_name(*rp))); 403 } 404 405 void 406 mdb_nv_sort_iter(mdb_nv_t *nv, int (*func)(mdb_var_t *, void *), 407 void *private, uint_t um_flags) 408 { 409 mdb_var_t **vps = 410 mdb_alloc(nv->nv_nelems * sizeof (mdb_var_t *), um_flags); 411 412 if (nv->nv_nelems != 0 && vps != NULL) { 413 mdb_var_t *v, **vpp = vps; 414 size_t i; 415 416 for (mdb_nv_rewind(nv); (v = mdb_nv_advance(nv)) != NULL; ) 417 *vpp++ = v; 418 419 qsort(vps, nv->nv_nelems, sizeof (mdb_var_t *), 420 (int (*)(const void *, const void *))nv_compare); 421 422 for (vpp = vps, i = 0; i < nv->nv_nelems; i++) { 423 if (func(*vpp++, private) == -1) 424 break; 425 } 426 427 if (!(um_flags & UM_GC)) 428 mdb_free(vps, nv->nv_nelems * sizeof (mdb_var_t *)); 429 } 430 } 431 432 void 433 mdb_nv_defn_iter(mdb_var_t *v, int (*func)(mdb_var_t *, void *), void *private) 434 { 435 if (func(v, private) == -1 || !(v->v_flags & MDB_NV_OVERLOAD)) 436 return; 437 438 for (v = v->v_ndef; v != NULL; v = v->v_ndef) { 439 if (func(v, private) == -1) 440 break; 441 } 442 } 443 444 uintmax_t 445 mdb_nv_get_value(const mdb_var_t *v) 446 { 447 if (v->v_disc) 448 return (v->v_disc->disc_get(v)); 449 450 return (v->v_uvalue); 451 } 452 453 void 454 mdb_nv_set_value(mdb_var_t *v, uintmax_t l) 455 { 456 if (v->v_flags & MDB_NV_RDONLY) { 457 warn("cannot modify read-only variable '%s'\n", NV_NAME(v)); 458 return; 459 } 460 461 if (v->v_disc) 462 v->v_disc->disc_set(v, l); 463 else 464 v->v_uvalue = l; 465 } 466 467 void * 468 mdb_nv_get_cookie(const mdb_var_t *v) 469 { 470 if (v->v_disc) 471 return ((void *)(uintptr_t)v->v_disc->disc_get(v)); 472 473 return (MDB_NV_COOKIE(v)); 474 } 475 476 void 477 mdb_nv_set_cookie(mdb_var_t *v, void *cookie) 478 { 479 mdb_nv_set_value(v, (uintmax_t)(uintptr_t)cookie); 480 } 481 482 const char * 483 mdb_nv_get_name(const mdb_var_t *v) 484 { 485 return (NV_NAME(v)); 486 } 487 488 mdb_var_t * 489 mdb_nv_get_ndef(const mdb_var_t *v) 490 { 491 if (v->v_flags & MDB_NV_OVERLOAD) 492 return (v->v_ndef); 493 494 return (NULL); 495 } --- EOF ---