kernel/os/damap.c

   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 /*
  23  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <sys/note.h>
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/buf.h>
  31 #include <sys/kmem.h>
  32 #include <sys/cmn_err.h>
  33 #include <sys/debug.h>
  34 #include <sys/sunndi.h>
  35 #include <sys/kstat.h>
  36 #include <sys/conf.h>
  37 #include <sys/ddi_periodic.h>
  38 #include <sys/devctl.h>
  39 #include <sys/callb.h>
  40 #include <sys/sysevent.h>
  41 #include <sys/taskq.h>
  42 #include <sys/ddi.h>
  43 #include <sys/bitset.h>
  44 #include <sys/damap.h>
  45 #include <sys/damap_impl.h>
  46
  47 #ifdef DEBUG
  48 static int damap_debug = 0;
  49 #endif /* DEBUG */
  50
  51 extern taskq_t *system_taskq;
  52
  53 static void dam_addrset_activate(dam_t *, bitset_t *);
  54 static void dam_addrset_deactivate(dam_t *, bitset_t *);
  55 static void dam_stabilize_map(void *);
  56 static void dam_addr_stable_cb(void *);
  57 static void dam_addrset_stable_cb(void *);
  58 static void dam_sched_timeout(void (*timeout_cb)(), dam_t *, clock_t);
  59 static void dam_addr_report(dam_t *, dam_da_t *, id_t, int);
  60 static void dam_addr_release(dam_t *, id_t);
  61 static void dam_addr_report_release(dam_t *, id_t);
  62 static void dam_addr_deactivate(dam_t *, id_t);
  63 static void dam_deact_cleanup(dam_t *, id_t, char *, damap_deact_rsn_t);
  64 static id_t dam_get_addrid(dam_t *, char *);
  65 static int dam_kstat_create(dam_t *);
  66 static int dam_map_alloc(dam_t *);
  67
  68 #define DAM_INCR_STAT(mapp, stat)                               \
  69         if ((mapp)->dam_kstatsp) {                              \
  70                 struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;  \
  71                 stp->stat.value.ui32++;                         \
  72         }
  73
  74 #define DAM_SET_STAT(mapp, stat, val)                           \
  75         if ((mapp)->dam_kstatsp) {                              \
  76                 struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;  \
  77                 stp->stat.value.ui32 = (val);                   \
  78         }
  79
  80
  81 /*
  82  * increase damap size by 64 entries at a time
  83  */
  84 #define DAM_SIZE_BUMP   64
  85
  86 int     damap_taskq_dispatch_retry_usec = 1000;
  87
  88 /*
  89  * config/unconfig taskq data
  90  */
  91 typedef struct {
  92         dam_t *tqd_mapp;
  93         id_t tqd_id;
  94 } cfg_tqd_t;
  95
  96 extern pri_t maxclsyspri;
  97
  98 /*
  99  * Create new device address map
 100  *
 101  * name:                map name (kstat unique)
 102  * size:                max # of map entries
 103  * mode:                style of address reports: per-address or fullset
 104  * stable_usec:         # of quiescent microseconds before report/map is stable
 105  *
 106  * activate_arg:        address provider activation-callout private
 107  * activate_cb:         address provider activation callback handler
 108  * deactivate_cb:       address provider deactivation callback handler
 109  *
 110  * config_arg:          configuration-callout private
 111  * config_cb:           class configuration callout
 112  * unconfig_cb:         class unconfiguration callout
 113  *
 114  * damapp:              pointer to map handle (return)
 115  *
 116  * Returns:     DAM_SUCCESS
 117  *              DAM_EINVAL      Invalid argument(s)
 118  *              DAM_FAILURE     General failure
 119  */
 120 int
 121 damap_create(char *name, damap_rptmode_t mode, int map_opts,
 122     int stable_usec, void *activate_arg, damap_activate_cb_t activate_cb,
 123     damap_deactivate_cb_t deactivate_cb,
 124     void *config_arg, damap_configure_cb_t configure_cb,
 125     damap_unconfig_cb_t unconfig_cb,
 126     damap_t **damapp)
 127 {
 128         dam_t *mapp;
 129
 130         if (configure_cb == NULL || unconfig_cb == NULL || name == NULL)
 131                 return (DAM_EINVAL);
 132
 133         mapp = kmem_zalloc(sizeof (*mapp), KM_SLEEP);
 134         mapp->dam_options = map_opts;
 135         mapp->dam_stable_ticks = drv_usectohz(stable_usec);
 136         mapp->dam_size = 0;
 137         mapp->dam_rptmode = mode;
 138         mapp->dam_activate_arg = activate_arg;
 139         mapp->dam_activate_cb = (activate_cb_t)activate_cb;
 140         mapp->dam_deactivate_cb = (deactivate_cb_t)deactivate_cb;
 141         mapp->dam_config_arg = config_arg;
 142         mapp->dam_configure_cb = (configure_cb_t)configure_cb;
 143         mapp->dam_unconfig_cb = (unconfig_cb_t)unconfig_cb;
 144         mapp->dam_name = i_ddi_strdup(name, KM_SLEEP);
 145         mutex_init(&mapp->dam_lock, NULL, MUTEX_DRIVER, NULL);
 146         cv_init(&mapp->dam_sync_cv, NULL, CV_DRIVER, NULL);
 147         bitset_init(&mapp->dam_active_set);
 148         bitset_init(&mapp->dam_stable_set);
 149         bitset_init(&mapp->dam_report_set);
 150         *damapp = (damap_t *)mapp;
 151
 152         DTRACE_PROBE5(damap__create,
 153             char *, mapp->dam_name, damap_t *, mapp,
 154             damap_rptmode_t, mode, int, map_opts, int, stable_usec);
 155
 156         return (DAM_SUCCESS);
 157 }
 158
 159 /*
 160  * Allocate backing resources
 161  *
 162  * DAMs are lightly backed on create - major allocations occur
 163  * at the time a report is made to the map, and are extended on
 164  * a demand basis.
 165  */
 166 static int
 167 dam_map_alloc(dam_t *mapp)
 168 {
 169         void *softstate_p;
 170
 171         ASSERT(mutex_owned(&mapp->dam_lock));
 172         if (mapp->dam_flags & DAM_DESTROYPEND)
 173                 return (DAM_FAILURE);
 174
 175         /*
 176          * dam_high > 0 signals map allocation complete
 177          */
 178         if (mapp->dam_high)
 179                 return (DAM_SUCCESS);
 180
 181         mapp->dam_size = DAM_SIZE_BUMP;
 182         if (ddi_soft_state_init(&softstate_p, sizeof (dam_da_t),
 183             mapp->dam_size) != DDI_SUCCESS)
 184                 return (DAM_FAILURE);
 185
 186         if (ddi_strid_init(&mapp->dam_addr_hash, mapp->dam_size) !=
 187             DDI_SUCCESS) {
 188                 ddi_soft_state_fini(softstate_p);
 189                 return (DAM_FAILURE);
 190         }
 191         if (dam_kstat_create(mapp) != DDI_SUCCESS) {
 192                 ddi_soft_state_fini(softstate_p);
 193                 ddi_strid_fini(&mapp->dam_addr_hash);
 194                 return (DAM_FAILURE);
 195         }
 196         mapp->dam_da = softstate_p;
 197         mapp->dam_high = 1;
 198         bitset_resize(&mapp->dam_active_set, mapp->dam_size);
 199         bitset_resize(&mapp->dam_stable_set, mapp->dam_size);
 200         bitset_resize(&mapp->dam_report_set, mapp->dam_size);
 201         return (DAM_SUCCESS);
 202 }
 203
 204 /*
 205  * Destroy address map
 206  *
 207  * damapp:      address map
 208  *
 209  * Returns:     DAM_SUCCESS
 210  *              DAM_EINVAL      Invalid argument(s)
 211  *              DAM_FAILURE     General failure
 212  */
 213 void
 214 damap_destroy(damap_t *damapp)
 215 {
 216         int i;
 217         dam_t *mapp = (dam_t *)damapp;
 218
 219         ASSERT(mapp);
 220
 221         DTRACE_PROBE2(damap__destroy,
 222             char *, mapp->dam_name, damap_t *, mapp);
 223
 224         mutex_enter(&mapp->dam_lock);
 225
 226         /*
 227          * prevent new reports from being added to the map
 228          */
 229         mapp->dam_flags |= DAM_DESTROYPEND;
 230
 231         if (mapp->dam_high) {
 232                 mutex_exit(&mapp->dam_lock);
 233                 /*
 234                  * wait for outstanding reports to stabilize and cancel
 235                  * the timer for this map
 236                  */
 237                 (void) damap_sync(damapp, 0);
 238                 mutex_enter(&mapp->dam_lock);
 239                 dam_sched_timeout(NULL, mapp, 0);
 240
 241                 /*
 242                  * map is at full stop
 243                  * release the contents of the map, invoking the
 244                  * detactivation protocol as addresses are released
 245                  */
 246                 mutex_exit(&mapp->dam_lock);
 247                 for (i = 1; i < mapp->dam_high; i++) {
 248                         if (ddi_get_soft_state(mapp->dam_da, i) == NULL)
 249                                 continue;
 250
 251                         ASSERT(DAM_IN_REPORT(mapp, i) == 0);
 252
 253                         if (DAM_IS_STABLE(mapp, i)) {
 254                                 dam_addr_deactivate(mapp, i);
 255                         } else {
 256                                 ddi_strid_free(mapp->dam_addr_hash, i);
 257                                 ddi_soft_state_free(mapp->dam_da, i);
 258                         }
 259                 }
 260                 ddi_strid_fini(&mapp->dam_addr_hash);
 261                 ddi_soft_state_fini(&mapp->dam_da);
 262                 kstat_delete(mapp->dam_kstatsp);
 263         } else
 264                 mutex_exit(&mapp->dam_lock);
 265
 266         bitset_fini(&mapp->dam_active_set);
 267         bitset_fini(&mapp->dam_stable_set);
 268         bitset_fini(&mapp->dam_report_set);
 269         mutex_destroy(&mapp->dam_lock);
 270         cv_destroy(&mapp->dam_sync_cv);
 271         if (mapp->dam_name)
 272                 kmem_free(mapp->dam_name, strlen(mapp->dam_name) + 1);
 273         kmem_free(mapp, sizeof (*mapp));
 274 }
 275
 276 /*
 277  * Wait for map stability.  If sync was successfull then return 1.
 278  * If called with a non-zero sync_usec, then a return value of 0 means a
 279  * timeout occurred prior to sync completion. NOTE: if sync_usec is
 280  * non-zero, it should be much longer than dam_stable_ticks.
 281  *
 282  * damapp:      address map
 283  * sync_usec:   micorseconds until we give up on sync completion.
 284  */
 285 #define WAITFOR_FLAGS (DAM_SETADD | DAM_SPEND)
 286 int
 287 damap_sync(damap_t *damapp, int sync_usec)
 288 {
 289         dam_t   *mapp = (dam_t *)damapp;
 290         int     rv;
 291
 292         ASSERT(mapp);
 293         DTRACE_PROBE3(damap__map__sync__start,
 294             char *, mapp->dam_name, dam_t *, mapp,
 295             int, sync_usec);
 296
 297         /*
 298          * Block when waiting for
 299          *      a) stabilization pending or a fullset update pending
 300          *      b) the report set to finalize (bitset is null)
 301          *      c) any scheduled timeouts to fire
 302          */
 303         rv = 1;                                 /* return synced */
 304         mutex_enter(&mapp->dam_lock);
 305 again:  while ((mapp->dam_flags & WAITFOR_FLAGS) ||
 306             (!bitset_is_null(&mapp->dam_report_set)) ||
 307             (mapp->dam_tid != 0)) {
 308                 DTRACE_PROBE2(damap__map__sync__waiting,
 309                     char *, mapp->dam_name, dam_t *, mapp);
 310
 311                 /* Wait for condition relayed via timeout */
 312                 if (sync_usec) {
 313                         if (cv_reltimedwait(&mapp->dam_sync_cv, &mapp->dam_lock,
 314                             drv_usectohz(sync_usec), TR_MICROSEC) == -1) {
 315                                 mapp->dam_sync_to_cnt++;
 316                                 rv = 0;         /* return timeout */
 317                                 break;
 318                         }
 319                 } else
 320                         cv_wait(&mapp->dam_sync_cv, &mapp->dam_lock);
 321         }
 322
 323         if (rv) {
 324                 /*
 325                  * Delay one stabilization time after the apparent sync above
 326                  * and verify accuracy - resync if not accurate.
 327                  */
 328                 (void) cv_reltimedwait(&mapp->dam_sync_cv, &mapp->dam_lock,
 329                     mapp->dam_stable_ticks, TR_MICROSEC);
 330                 if (rv && ((mapp->dam_flags & WAITFOR_FLAGS) ||
 331                     (!bitset_is_null(&mapp->dam_report_set)) ||
 332                     (mapp->dam_tid != 0)))
 333                         goto again;
 334         }
 335         mutex_exit(&mapp->dam_lock);
 336
 337         DTRACE_PROBE3(damap__map__sync__end,
 338             char *, mapp->dam_name, dam_t *, mapp,
 339             int, rv);
 340         return (rv);
 341 }
 342
 343 /*
 344  * Return 1 if active set is empty
 345  */
 346 int
 347 damap_is_empty(damap_t *damapp)
 348 {
 349         dam_t   *mapp = (dam_t *)damapp;
 350         int     rv;
 351
 352         mutex_enter(&mapp->dam_lock);
 353         rv = bitset_is_null(&mapp->dam_active_set);
 354         mutex_exit(&mapp->dam_lock);
 355         return (rv);
 356 }
 357
 358 /*
 359  * Get the name of a device address map
 360  *
 361  * damapp:      address map
 362  *
 363  * Returns:     name
 364  */
 365 char *
 366 damap_name(damap_t *damapp)
 367 {
 368         dam_t *mapp = (dam_t *)damapp;
 369
 370         return (mapp ? mapp->dam_name : "UNKNOWN_damap");
 371 }
 372
 373 /*
 374  * Get the current size of the device address map
 375  *
 376  * damapp:      address map
 377  *
 378  * Returns:     size
 379  */
 380 int
 381 damap_size(damap_t *damapp)
 382 {
 383         dam_t *mapp = (dam_t *)damapp;
 384
 385         return (mapp->dam_size);
 386 }
 387
 388 /*
 389  * Report an address to per-address report
 390  *
 391  * damapp:      address map handle
 392  * address:     address in ascii string representation
 393  * addridp:     address ID
 394  * nvl:         optional nvlist of configuration-private data
 395  * addr_priv:   optional provider-private (passed to activate/deactivate cb)
 396  *
 397  * Returns:     DAM_SUCCESS
 398  *              DAM_EINVAL      Invalid argument(s)
 399  *              DAM_MAPFULL     address map exhausted
 400  */
 401 int
 402 damap_addr_add(damap_t *damapp, char *address, damap_id_t *addridp,
 403     nvlist_t *nvl, void *addr_priv)
 404 {
 405         dam_t *mapp = (dam_t *)damapp;
 406         id_t addrid;
 407         dam_da_t *passp;
 408
 409         if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR))
 410                 return (DAM_EINVAL);
 411
 412         DTRACE_PROBE3(damap__addr__add,
 413             char *, mapp->dam_name, dam_t *, mapp,
 414             char *, address);
 415
 416         mutex_enter(&mapp->dam_lock);
 417         if ((dam_map_alloc(mapp) != DAM_SUCCESS) ||
 418             ((addrid = dam_get_addrid(mapp, address)) == 0)) {
 419                 mutex_exit(&mapp->dam_lock);
 420                 return (DAM_MAPFULL);
 421         }
 422
 423         passp = ddi_get_soft_state(mapp->dam_da, addrid);
 424         ASSERT(passp != NULL);
 425
 426         /*
 427          * If re-reporting the same address (add or remove) clear
 428          * the existing report
 429          */
 430         if (DAM_IN_REPORT(mapp, addrid)) {
 431                 DTRACE_PROBE3(damap__addr__add__jitter,
 432                     char *, mapp->dam_name, dam_t *, mapp,
 433                     char *, address);
 434                 DAM_INCR_STAT(mapp, dam_jitter);
 435                 dam_addr_report_release(mapp, addrid);
 436                 passp->da_jitter++;
 437         }
 438         passp->da_ppriv_rpt = addr_priv;
 439         if (nvl)
 440                 (void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);
 441
 442         dam_addr_report(mapp, passp, addrid, RPT_ADDR_ADD);
 443         if (addridp != NULL)
 444                 *addridp = (damap_id_t)addrid;
 445         mutex_exit(&mapp->dam_lock);
 446         return (DAM_SUCCESS);
 447 }
 448
 449 /*
 450  * Report removal of address from per-address report
 451  *
 452  * damapp:      address map
 453  * address:     address in ascii string representation
 454  *
 455  * Returns:     DAM_SUCCESS
 456  *              DAM_EINVAL      Invalid argument(s)
 457  *              DAM_FAILURE     General failure
 458  */
 459 int
 460 damap_addr_del(damap_t *damapp, char *address)
 461 {
 462         dam_t *mapp = (dam_t *)damapp;
 463         id_t addrid;
 464         dam_da_t *passp;
 465
 466         if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR))
 467                 return (DAM_EINVAL);
 468
 469         DTRACE_PROBE3(damap__addr__del,
 470             char *, mapp->dam_name, dam_t *, mapp,
 471             char *, address);
 472         mutex_enter(&mapp->dam_lock);
 473         if (dam_map_alloc(mapp) != DAM_SUCCESS) {
 474                 mutex_exit(&mapp->dam_lock);
 475                 return (DAM_MAPFULL);
 476         }
 477
 478         /*
 479          * if reporting the removal of an address which is not in the map
 480          * return success
 481          */
 482         if (!(addrid = ddi_strid_str2id(mapp->dam_addr_hash, address))) {
 483                 mutex_exit(&mapp->dam_lock);
 484                 return (DAM_SUCCESS);
 485         }
 486         passp = ddi_get_soft_state(mapp->dam_da, addrid);
 487         ASSERT(passp);
 488         if (DAM_IN_REPORT(mapp, addrid)) {
 489                 DTRACE_PROBE3(damap__addr__del__jitter,
 490                     char *, mapp->dam_name, dam_t *, mapp,
 491                     char *, address);
 492                 DAM_INCR_STAT(mapp, dam_jitter);
 493                 dam_addr_report_release(mapp, addrid);
 494                 passp->da_jitter++;
 495         }
 496         dam_addr_report(mapp, passp, addrid, RPT_ADDR_DEL);
 497         mutex_exit(&mapp->dam_lock);
 498         return (DAM_SUCCESS);
 499 }
 500
 501 static int
 502 damap_addrset_flush_locked(damap_t *damapp)
 503 {
 504         dam_t   *mapp = (dam_t *)damapp;
 505         int     idx;
 506
 507         ASSERT(mapp);
 508         ASSERT(mutex_owned(&mapp->dam_lock));
 509         if (mapp->dam_rptmode != DAMAP_REPORT_FULLSET) {
 510                 return (DAM_EINVAL);
 511         }
 512
 513         DTRACE_PROBE2(damap__addrset__flush__locked__enter,
 514             char *, mapp->dam_name, dam_t *, mapp);
 515         if (mapp->dam_flags & DAM_SETADD) {
 516                 DTRACE_PROBE2(damap__addrset__flush__locked__reset,
 517                     char *, mapp->dam_name, dam_t *, mapp);
 518
 519                 /*
 520                  * cancel stabilization timeout
 521                  */
 522                 dam_sched_timeout(NULL, mapp, 0);
 523                 DAM_INCR_STAT(mapp, dam_jitter);
 524
 525                 /*
 526                  * clear pending reports
 527                  */
 528                 for (idx = 1; idx < mapp->dam_high; idx++) {
 529                         if (DAM_IN_REPORT(mapp, idx)) {
 530                                 dam_addr_report_release(mapp, idx);
 531                         }
 532                 }
 533
 534                 bitset_zero(&mapp->dam_report_set);
 535                 mapp->dam_flags &= ~DAM_SETADD;
 536                 cv_signal(&mapp->dam_sync_cv);
 537         }
 538
 539         return (DAM_SUCCESS);
 540 }
 541
 542 /*
 543  * Initiate full-set report
 544  *
 545  * damapp:      address map
 546  *
 547  * Returns:     DAM_SUCCESS
 548  *              DAM_EINVAL      Invalid argument(s)
 549  */
 550 int
 551 damap_addrset_begin(damap_t *damapp)
 552 {
 553         dam_t   *mapp = (dam_t *)damapp;
 554         int     rv;
 555
 556         if (mapp == NULL) {
 557                 return (DAM_EINVAL);
 558         }
 559
 560         DTRACE_PROBE2(damap__addrset__begin,
 561             char *, mapp->dam_name, dam_t *, mapp);
 562
 563         mutex_enter(&mapp->dam_lock);
 564         if (dam_map_alloc(mapp) != DAM_SUCCESS) {
 565                 mutex_exit(&mapp->dam_lock);
 566
 567                 return (DAM_MAPFULL);
 568         }
 569
 570         rv = damap_addrset_flush_locked(damapp);
 571         if (rv == DAM_SUCCESS) {
 572                 mapp->dam_flags |= DAM_SETADD;
 573         }
 574         mutex_exit(&mapp->dam_lock);
 575
 576         return (rv);
 577 }
 578
 579 /*
 580  * Cancel full-set report
 581  *
 582  * damapp:      address map
 583  *
 584  * Returns:     DAM_SUCCESS
 585  *              DAM_EINVAL      Invalid argument(s)
 586  */
 587 int
 588 damap_addrset_flush(damap_t *damapp)
 589 {
 590         int     rv;
 591         dam_t   *mapp = (dam_t *)damapp;
 592
 593         if (mapp == NULL) {
 594                 return (DAM_EINVAL);
 595         }
 596
 597         DTRACE_PROBE2(damap__addrset__flush,
 598             char *, mapp->dam_name, dam_t *, mapp);
 599
 600         mutex_enter(&mapp->dam_lock);
 601         rv = damap_addrset_flush_locked(damapp);
 602         mutex_exit(&mapp->dam_lock);
 603
 604         return (rv);
 605 }
 606
 607 /*
 608  * Report address to full-set report
 609  *
 610  * damapp:      address map handle
 611  * address:     address in ascii string representation
 612  * rindx:       index if address stabilizes
 613  * nvl:         optional nvlist of configuration-private data
 614  * addr_priv:   optional provider-private data (passed to activate/release cb)
 615  *
 616  * Returns:     DAM_SUCCESS
 617  *              DAM_EINVAL      Invalid argument(s)
 618  *              DAM_MAPFULL     address map exhausted
 619  *              DAM_FAILURE     General failure
 620  */
 621 int
 622 damap_addrset_add(damap_t *damapp, char *address, damap_id_t *ridx,
 623     nvlist_t *nvl, void *addr_priv)
 624 {
 625         dam_t *mapp = (dam_t *)damapp;
 626         id_t addrid;
 627         dam_da_t *passp;
 628
 629         if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET))
 630                 return (DAM_EINVAL);
 631
 632         DTRACE_PROBE3(damap__addrset__add,
 633             char *, mapp->dam_name, dam_t *, mapp, char *, address);
 634
 635         mutex_enter(&mapp->dam_lock);
 636         if (!(mapp->dam_flags & DAM_SETADD)) {
 637                 mutex_exit(&mapp->dam_lock);
 638                 return (DAM_FAILURE);
 639         }
 640
 641         if ((addrid = dam_get_addrid(mapp, address)) == 0) {
 642                 mutex_exit(&mapp->dam_lock);
 643                 return (DAM_MAPFULL);
 644         }
 645
 646         passp = ddi_get_soft_state(mapp->dam_da, addrid);
 647         ASSERT(passp);
 648         if (DAM_IN_REPORT(mapp, addrid)) {
 649                 DTRACE_PROBE3(damap__addrset__add__jitter,
 650                     char *, mapp->dam_name, dam_t *, mapp,
 651                     char *, address);
 652                 dam_addr_report_release(mapp, addrid);
 653                 passp->da_jitter++;
 654         }
 655         passp->da_ppriv_rpt = addr_priv;
 656         if (nvl)
 657                 (void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);
 658         bitset_add(&mapp->dam_report_set, addrid);
 659         if (ridx)
 660                 *ridx = (damap_id_t)addrid;
 661         mutex_exit(&mapp->dam_lock);
 662         return (DAM_SUCCESS);
 663 }
 664
 665 /*
 666  * Commit full-set report for stabilization
 667  *
 668  * damapp:      address map handle
 669  * flags:       (currently 0)
 670  *
 671  * Returns:     DAM_SUCCESS
 672  *              DAM_EINVAL      Invalid argument(s)
 673  *              DAM_FAILURE     General failure
 674  */
 675 int
 676 damap_addrset_end(damap_t *damapp, int flags)
 677 {
 678         dam_t *mapp = (dam_t *)damapp;
 679         int i;
 680
 681         if (!mapp || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET))
 682                 return (DAM_EINVAL);
 683
 684         DTRACE_PROBE2(damap__addrset__end,
 685             char *, mapp->dam_name, dam_t *, mapp);
 686
 687         mutex_enter(&mapp->dam_lock);
 688         if (!(mapp->dam_flags & DAM_SETADD)) {
 689                 mutex_exit(&mapp->dam_lock);
 690                 return (DAM_FAILURE);
 691         }
 692
 693         if (flags & DAMAP_END_RESET) {
 694                 DTRACE_PROBE2(damap__addrset__end__reset,
 695                     char *, mapp->dam_name, dam_t *, mapp);
 696                 dam_sched_timeout(NULL, mapp, 0);
 697                 for (i = 1; i < mapp->dam_high; i++)
 698                         if (DAM_IN_REPORT(mapp, i))
 699                                 dam_addr_report_release(mapp, i);
 700         } else {
 701                 mapp->dam_last_update = gethrtime();
 702                 dam_sched_timeout(dam_addrset_stable_cb, mapp,
 703                     mapp->dam_stable_ticks);
 704         }
 705         mutex_exit(&mapp->dam_lock);
 706         return (DAM_SUCCESS);
 707 }
 708
 709 /*
 710  * Return nvlist registered with reported address
 711  *
 712  * damapp:      address map handle
 713  * addrid:      address ID
 714  *
 715  * Returns:     nvlist_t *      provider supplied via damap_addr{set}_add())
 716  *              NULL
 717  */
 718 nvlist_t *
 719 damap_id2nvlist(damap_t *damapp, damap_id_t addrid)
 720 {
 721         dam_t *mapp = (dam_t *)damapp;
 722         dam_da_t *pass;
 723
 724         if (mapp->dam_high && ddi_strid_id2str(mapp->dam_addr_hash, addrid)) {
 725                 if (pass = ddi_get_soft_state(mapp->dam_da, addrid))
 726                         return (pass->da_nvl);
 727         }
 728         return (NULL);
 729 }
 730
 731 /*
 732  * Return address string
 733  *
 734  * damapp:      address map handle
 735  * addrid:      address ID
 736  *
 737  * Returns:     char *          Address string
 738  *              NULL
 739  */
 740 char *
 741 damap_id2addr(damap_t *damapp, damap_id_t addrid)
 742 {
 743         dam_t *mapp = (dam_t *)damapp;
 744
 745         if (mapp->dam_high)
 746                 return (ddi_strid_id2str(mapp->dam_addr_hash, addrid));
 747         else
 748                 return (NULL);
 749 }
 750
 751 /*
 752  * Release address reference in map
 753  *
 754  * damapp:      address map handle
 755  * addrid:      address ID
 756  */
 757 void
 758 damap_id_rele(damap_t *damapp, damap_id_t addrid)
 759 {
 760         dam_t *mapp = (dam_t *)damapp;
 761         dam_da_t *passp;
 762         char *addr;
 763
 764         passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
 765         ASSERT(passp);
 766
 767         addr = damap_id2addr(damapp, addrid);
 768         DTRACE_PROBE4(damap__id__rele,
 769             char *, mapp->dam_name, dam_t *, mapp,
 770             char *, addr, int, passp->da_ref);
 771
 772         mutex_enter(&mapp->dam_lock);
 773
 774         /*
 775          * teardown address if last outstanding reference
 776          */
 777         if (--passp->da_ref == 0)
 778                 dam_addr_release(mapp, (id_t)addrid);
 779
 780         mutex_exit(&mapp->dam_lock);
 781 }
 782
 783 /*
 784  * Return current reference count on address reference in map
 785  *
 786  * damapp:      address map handle
 787  * addrid:      address ID
 788  *
 789  * Returns:     DAM_SUCCESS
 790  *              DAM_FAILURE
 791  */
 792 int
 793 damap_id_ref(damap_t *damapp, damap_id_t addrid)
 794 {
 795         dam_t *mapp = (dam_t *)damapp;
 796         dam_da_t *passp;
 797         int ref = -1;
 798
 799         passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
 800         if (passp)
 801                 ref = passp->da_ref;
 802
 803         return (ref);
 804 }
 805
 806 /*
 807  * Return next address ID in list
 808  *
 809  * damapp:      address map handle
 810  * damap_list:  address ID list passed to config|unconfig
 811  *              returned by look by lookup_all
 812  * last:        last ID returned, 0 is start of list
 813  *
 814  * Returns:     addrid          Next ID from the list
 815  *              0               End of the list
 816  */
 817 damap_id_t
 818 damap_id_next(damap_t *damapp, damap_id_list_t damap_list, damap_id_t last)
 819 {
 820         int i, start;
 821         dam_t *mapp = (dam_t *)damapp;
 822         bitset_t *dam_list = (bitset_t *)damap_list;
 823
 824         if (!mapp || !dam_list)
 825                 return ((damap_id_t)0);
 826
 827         start = (int)last + 1;
 828         for (i = start; i < mapp->dam_high; i++) {
 829                 if (bitset_in_set(dam_list, i)) {
 830                         return ((damap_id_t)i);
 831                 }
 832         }
 833         return ((damap_id_t)0);
 834 }
 835
 836 /*
 837  * Set config private data
 838  *
 839  * damapp:      address map handle
 840  * addrid:      address ID
 841  * cfg_priv:    configuration private data
 842  *
 843  */
 844 void
 845 damap_id_priv_set(damap_t *damapp, damap_id_t addrid, void *cfg_priv)
 846 {
 847         dam_t *mapp = (dam_t *)damapp;
 848         dam_da_t *passp;
 849
 850         mutex_enter(&mapp->dam_lock);
 851         passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
 852         if (!passp) {
 853                 mutex_exit(&mapp->dam_lock);
 854                 return;
 855         }
 856         passp->da_cfg_priv = cfg_priv;
 857         mutex_exit(&mapp->dam_lock);
 858 }
 859
 860 /*
 861  * Get config private data
 862  *
 863  * damapp:      address map handle
 864  * addrid:      address ID
 865  *
 866  * Returns:     configuration private data
 867  */
 868 void *
 869 damap_id_priv_get(damap_t *damapp, damap_id_t addrid)
 870 {
 871         dam_t *mapp = (dam_t *)damapp;
 872         dam_da_t *passp;
 873         void *rv;
 874
 875         mutex_enter(&mapp->dam_lock);
 876         passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
 877         if (!passp) {
 878                 mutex_exit(&mapp->dam_lock);
 879                 return (NULL);
 880         }
 881         rv = passp->da_cfg_priv;
 882         mutex_exit(&mapp->dam_lock);
 883         return (rv);
 884 }
 885
 886 /*
 887  * Lookup a single address in the active address map
 888  *
 889  * damapp:      address map handle
 890  * address:     address string
 891  *
 892  * Returns:     ID of active/stable address
 893  *              0       Address not in stable set
 894  *
 895  * Future: Allow the caller to wait for stabilize before returning not found.
 896  */
 897 damap_id_t
 898 damap_lookup(damap_t *damapp, char *address)
 899 {
 900         dam_t *mapp = (dam_t *)damapp;
 901         id_t addrid = 0;
 902         dam_da_t *passp = NULL;
 903
 904         DTRACE_PROBE3(damap__lookup,
 905             char *, mapp->dam_name, dam_t *, mapp,
 906             char *, address);
 907         mutex_enter(&mapp->dam_lock);
 908         if (!mapp->dam_high)
 909                 addrid = 0;
 910         else
 911                 addrid = ddi_strid_str2id(mapp->dam_addr_hash, address);
 912         if (addrid) {
 913                 if (DAM_IS_STABLE(mapp, addrid)) {
 914                         passp = ddi_get_soft_state(mapp->dam_da, addrid);
 915                         ASSERT(passp);
 916                         if (passp) {
 917                                 passp->da_ref++;
 918                         } else {
 919                                 addrid = 0;
 920                         }
 921                 } else {
 922                         addrid = 0;
 923                 }
 924         }
 925         mutex_exit(&mapp->dam_lock);
 926         DTRACE_PROBE4(damap__lookup__return,
 927             char *, mapp->dam_name, dam_t *, mapp,
 928             char *, address, int, addrid);
 929         return ((damap_id_t)addrid);
 930 }
 931
 932
 933 /*
 934  * Return the list of stable addresses in the map
 935  *
 936  * damapp:      address map handle
 937  * id_listp:    pointer to list of address IDs in stable map (returned)
 938  *
 939  * Returns:     # of entries returned in alist
 940  */
 941 int
 942 damap_lookup_all(damap_t *damapp, damap_id_list_t *id_listp)
 943 {
 944         dam_t *mapp = (dam_t *)damapp;
 945         int mapsz = mapp->dam_size;
 946         int n_ids, i;
 947         bitset_t *bsp;
 948         char     *addrp;
 949         dam_da_t *passp;
 950
 951         DTRACE_PROBE2(damap__lookup__all,
 952             char *, mapp->dam_name, dam_t *, mapp);
 953         mutex_enter(&mapp->dam_lock);
 954         if (!mapp->dam_high) {
 955                 *id_listp = (damap_id_list_t)NULL;
 956                 mutex_exit(&mapp->dam_lock);
 957                 DTRACE_PROBE2(damap__lookup__all__nomap,
 958                     char *, mapp->dam_name, dam_t *, mapp);
 959                 return (0);
 960         }
 961         bsp = kmem_alloc(sizeof (*bsp), KM_SLEEP);
 962         bitset_init(bsp);
 963         bitset_resize(bsp, mapsz);
 964         bitset_copy(&mapp->dam_active_set, bsp);
 965         for (n_ids = 0, i = 1; i < mapsz; i++) {
 966                 if (bitset_in_set(bsp, i)) {
 967                         passp = ddi_get_soft_state(mapp->dam_da, i);
 968                         ASSERT(passp);
 969                         if (passp) {
 970                                 addrp = damap_id2addr(damapp, i);
 971                                 DTRACE_PROBE3(damap__lookup__all__item,
 972                                     char *, mapp->dam_name, dam_t *, mapp,
 973                                     char *, addrp);
 974                                 passp->da_ref++;
 975                                 n_ids++;
 976                         }
 977                 }
 978         }
 979         if (n_ids) {
 980                 *id_listp = (damap_id_list_t)bsp;
 981                 mutex_exit(&mapp->dam_lock);
 982                 return (n_ids);
 983         } else {
 984                 *id_listp = (damap_id_list_t)NULL;
 985                 bitset_fini(bsp);
 986                 kmem_free(bsp, sizeof (*bsp));
 987                 mutex_exit(&mapp->dam_lock);
 988                 return (0);
 989         }
 990 }
 991
 992 /*
 993  * Release the address list returned by damap_lookup_all()
 994  *
 995  * mapp:        address map handle
 996  * id_list:     list of address IDs returned in damap_lookup_all()
 997  */
 998 void
 999 damap_id_list_rele(damap_t *damapp, damap_id_list_t id_list)
1000 {
1001         dam_t *mapp = (dam_t *)damapp;
1002         int i;
1003
1004         if (id_list == NULL)
1005                 return;
1006
1007         mutex_enter(&mapp->dam_lock);
1008         for (i = 1; i < mapp->dam_high; i++) {
1009                 if (bitset_in_set((bitset_t *)id_list, i))
1010                         (void) dam_addr_release(mapp, i);
1011         }
1012         mutex_exit(&mapp->dam_lock);
1013         bitset_fini((bitset_t *)id_list);
1014         kmem_free((void *)id_list, sizeof (bitset_t));
1015 }
1016
1017 /*
1018  * activate an address that has passed the stabilization interval
1019  */
1020 static void
1021 dam_addr_activate(dam_t *mapp, id_t addrid)
1022 {
1023         dam_da_t *passp;
1024         int config_rv;
1025         char *addrstr;
1026
1027         mutex_enter(&mapp->dam_lock);
1028         bitset_add(&mapp->dam_active_set, addrid);
1029         passp = ddi_get_soft_state(mapp->dam_da, addrid);
1030         ASSERT(passp);
1031
1032         /*
1033          * copy the reported nvlist and provider private data
1034          */
1035         addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1036         DTRACE_PROBE3(damap__addr__activate__start,
1037             char *, mapp->dam_name, dam_t *, mapp,
1038             char *, addrstr);
1039         passp->da_nvl = passp->da_nvl_rpt;
1040         passp->da_ppriv = passp->da_ppriv_rpt;
1041         passp->da_ppriv_rpt = NULL;
1042         passp->da_nvl_rpt = NULL;
1043         passp->da_last_stable = gethrtime();
1044         passp->da_stable_cnt++;
1045         mutex_exit(&mapp->dam_lock);
1046         if (mapp->dam_activate_cb) {
1047                 (*mapp->dam_activate_cb)(mapp->dam_activate_arg, addrstr,
1048                     addrid, &passp->da_ppriv_rpt);
1049         }
1050
1051         /*
1052          * call the address-specific configuration action as part of
1053          * activation.
1054          */
1055         config_rv = (*mapp->dam_configure_cb)(mapp->dam_config_arg, mapp,
1056             addrid);
1057         if (config_rv != DAM_SUCCESS) {
1058                 mutex_enter(&mapp->dam_lock);
1059                 passp->da_flags |= DA_FAILED_CONFIG;
1060                 mutex_exit(&mapp->dam_lock);
1061                 DTRACE_PROBE3(damap__addr__activate__config__failure,
1062                     char *, mapp->dam_name, dam_t *, mapp,
1063                     char *, addrstr);
1064                 dam_deact_cleanup(mapp, addrid, addrstr,
1065                     DAMAP_DEACT_RSN_CFG_FAIL);
1066         } else {
1067                 DTRACE_PROBE3(damap__addr__activate__end,
1068                     char *, mapp->dam_name, dam_t *, mapp,
1069                     char *, addrstr);
1070         }
1071 }
1072
1073 /*
1074  * deactivate a previously stable address
1075  */
1076 static void
1077 dam_addr_deactivate(dam_t *mapp, id_t addrid)
1078 {
1079         char *addrstr;
1080
1081         addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1082         DTRACE_PROBE3(damap__addr__deactivate__start,
1083             char *, mapp->dam_name, dam_t *, mapp,
1084             char *, addrstr);
1085
1086         /*
1087          * call the unconfiguration callback
1088          */
1089         (*mapp->dam_unconfig_cb)(mapp->dam_config_arg, mapp, addrid);
1090         dam_deact_cleanup(mapp, addrid, addrstr, DAMAP_DEACT_RSN_GONE);
1091 }
1092
1093 static void
1094 dam_deact_cleanup(dam_t *mapp, id_t addrid, char *addrstr,
1095     damap_deact_rsn_t deact_rsn)
1096 {
1097         dam_da_t *passp;
1098
1099         passp = ddi_get_soft_state(mapp->dam_da, addrid);
1100         ASSERT(passp);
1101         if (mapp->dam_deactivate_cb)
1102                 (*mapp->dam_deactivate_cb)(mapp->dam_activate_arg,
1103                     ddi_strid_id2str(mapp->dam_addr_hash, addrid),
1104                     addrid, passp->da_ppriv, deact_rsn);
1105
1106         /*
1107          * clear the active bit and free the backing info for
1108          * this address
1109          */
1110         mutex_enter(&mapp->dam_lock);
1111         bitset_del(&mapp->dam_active_set, addrid);
1112         passp->da_ppriv = NULL;
1113         nvlist_free(passp->da_nvl);
1114         passp->da_nvl = NULL;
1115         passp->da_ppriv_rpt = NULL;
1116         nvlist_free(passp->da_nvl_rpt);
1117         passp->da_nvl_rpt = NULL;
1118
1119         DTRACE_PROBE3(damap__addr__deactivate__end,
1120             char *, mapp->dam_name, dam_t *, mapp,
1121             char *, addrstr);
1122
1123         (void) dam_addr_release(mapp, addrid);
1124         mutex_exit(&mapp->dam_lock);
1125 }
1126
1127 /*
1128  * taskq callback for multi-thread activation
1129  */
1130 static void
1131 dam_tq_config(void *arg)
1132 {
1133         cfg_tqd_t *tqd = (cfg_tqd_t *)arg;
1134
1135         dam_addr_activate(tqd->tqd_mapp, tqd->tqd_id);
1136         kmem_free(tqd, sizeof (*tqd));
1137 }
1138
1139 /*
1140  * taskq callback for multi-thread deactivation
1141  */
1142 static void
1143 dam_tq_unconfig(void *arg)
1144 {
1145         cfg_tqd_t *tqd = (cfg_tqd_t *)arg;
1146
1147         dam_addr_deactivate(tqd->tqd_mapp, tqd->tqd_id);
1148         kmem_free(tqd, sizeof (*tqd));
1149 }
1150
1151 /*
1152  * Activate a set of stabilized addresses
1153  */
1154 static void
1155 dam_addrset_activate(dam_t *mapp, bitset_t *activate)
1156 {
1157
1158         int i, nset;
1159         taskq_t *tqp = NULL;
1160         cfg_tqd_t *tqd = NULL;
1161         char tqn[TASKQ_NAMELEN];
1162         extern pri_t maxclsyspri;
1163
1164         if (mapp->dam_options & DAMAP_MTCONFIG) {
1165                 /*
1166                  * calculate the # of taskq threads to create
1167                  */
1168                 for (i = 1, nset = 0; i < mapp->dam_high; i++)
1169                         if (bitset_in_set(activate, i))
1170                                 nset++;
1171                 ASSERT(nset);
1172                 (void) snprintf(tqn, sizeof (tqn), "actv-%s", mapp->dam_name);
1173                 tqp = taskq_create(tqn, nset, maxclsyspri, 1,
1174                     INT_MAX, TASKQ_PREPOPULATE);
1175         }
1176         for (i = 1; i < mapp->dam_high; i++) {
1177                 if (bitset_in_set(activate, i)) {
1178                         if (!tqp)
1179                                 dam_addr_activate(mapp, i);
1180                         else {
1181                                 /*
1182                                  * multi-threaded activation
1183                                  */
1184                                 tqd = kmem_alloc(sizeof (*tqd), KM_SLEEP);
1185                                 tqd->tqd_mapp = mapp;
1186                                 tqd->tqd_id = i;
1187                                 (void) taskq_dispatch(tqp, dam_tq_config,
1188                                     tqd, TQ_SLEEP);
1189                         }
1190                 }
1191         }
1192         if (tqp) {
1193                 taskq_wait(tqp);
1194                 taskq_destroy(tqp);
1195         }
1196 }
1197
1198 /*
1199  * Deactivate a set of stabilized addresses
1200  */
1201 static void
1202 dam_addrset_deactivate(dam_t *mapp, bitset_t *deactivate)
1203 {
1204         int i, nset;
1205         taskq_t *tqp = NULL;
1206         cfg_tqd_t *tqd = NULL;
1207         char tqn[TASKQ_NAMELEN];
1208
1209         DTRACE_PROBE2(damap__addrset__deactivate,
1210             char *, mapp->dam_name, dam_t *, mapp);
1211
1212         if (mapp->dam_options & DAMAP_MTCONFIG) {
1213                 /*
1214                  * compute the # of taskq threads to dispatch
1215                  */
1216                 for (i = 1, nset = 0; i < mapp->dam_high; i++)
1217                         if (bitset_in_set(deactivate, i))
1218                                 nset++;
1219                 (void) snprintf(tqn, sizeof (tqn), "deactv-%s",
1220                     mapp->dam_name);
1221                 tqp = taskq_create(tqn, nset, maxclsyspri, 1,
1222                     INT_MAX, TASKQ_PREPOPULATE);
1223         }
1224         for (i = 1; i < mapp->dam_high; i++) {
1225                 if (bitset_in_set(deactivate, i)) {
1226                         if (!tqp) {
1227                                 dam_addr_deactivate(mapp, i);
1228                         } else {
1229                                 tqd = kmem_alloc(sizeof (*tqd), KM_SLEEP);
1230                                 tqd->tqd_mapp = mapp;
1231                                 tqd->tqd_id = i;
1232                                 (void) taskq_dispatch(tqp,
1233                                     dam_tq_unconfig, tqd, TQ_SLEEP);
1234                         }
1235                 }
1236         }
1237
1238         if (tqp) {
1239                 taskq_wait(tqp);
1240                 taskq_destroy(tqp);
1241         }
1242 }
1243
1244 /*
1245  * Release a previously activated address
1246  */
1247 static void
1248 dam_addr_release(dam_t *mapp, id_t addrid)
1249 {
1250         dam_da_t *passp;
1251         char     *addrstr;
1252
1253
1254         ASSERT(mutex_owned(&mapp->dam_lock));
1255         passp = ddi_get_soft_state(mapp->dam_da, addrid);
1256         ASSERT(passp);
1257
1258         addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1259         DTRACE_PROBE3(damap__addr__release,
1260             char *, mapp->dam_name, dam_t *, mapp,
1261             char *, addrstr);
1262
1263         /*
1264          * defer releasing the address until outstanding references
1265          * are released
1266          */
1267         if (passp->da_ref > 1) {
1268                 DTRACE_PROBE4(damap__addr__release__outstanding__refs,
1269                     char *, mapp->dam_name, dam_t *, mapp,
1270                     char *, addrstr, int, passp->da_ref);
1271                 return;
1272         }
1273
1274         /*
1275          * allow pending reports to stabilize
1276          */
1277         if (DAM_IN_REPORT(mapp, addrid)) {
1278                 DTRACE_PROBE3(damap__addr__release__report__pending,
1279                     char *, mapp->dam_name, dam_t *, mapp,
1280                     char *, addrstr);
1281                 return;
1282         }
1283
1284         ddi_strid_free(mapp->dam_addr_hash, addrid);
1285         ddi_soft_state_free(mapp->dam_da, addrid);
1286 }
1287
1288 /*
1289  * process stabilized address reports
1290  */
1291 static void
1292 dam_stabilize_map(void *arg)
1293 {
1294         dam_t *mapp = (dam_t *)arg;
1295         bitset_t delta;
1296         bitset_t cfg;
1297         bitset_t uncfg;
1298         int has_cfg, has_uncfg;
1299         uint32_t i, n_active;
1300
1301         DTRACE_PROBE2(damap__stabilize__map,
1302             char *, mapp->dam_name, dam_t *, mapp);
1303
1304         bitset_init(&delta);
1305         bitset_resize(&delta, mapp->dam_size);
1306         bitset_init(&cfg);
1307         bitset_resize(&cfg, mapp->dam_size);
1308         bitset_init(&uncfg);
1309         bitset_resize(&uncfg, mapp->dam_size);
1310
1311         /*
1312          * determine which addresses have changed during
1313          * this stabilization cycle
1314          */
1315         mutex_enter(&mapp->dam_lock);
1316         ASSERT(mapp->dam_flags & DAM_SPEND);
1317         if (!bitset_xor(&mapp->dam_active_set, &mapp->dam_stable_set,
1318             &delta)) {
1319                 /*
1320                  * no difference
1321                  */
1322                 bitset_zero(&mapp->dam_stable_set);
1323                 mapp->dam_flags &= ~DAM_SPEND;
1324                 cv_signal(&mapp->dam_sync_cv);
1325                 mutex_exit(&mapp->dam_lock);
1326
1327                 bitset_fini(&uncfg);
1328                 bitset_fini(&cfg);
1329                 bitset_fini(&delta);
1330                 DTRACE_PROBE2(damap__stabilize__map__nochange,
1331                     char *, mapp->dam_name, dam_t *, mapp);
1332                 return;
1333         }
1334
1335         /*
1336          * compute the sets of addresses to be activated and deactivated
1337          */
1338         has_cfg = bitset_and(&delta, &mapp->dam_stable_set, &cfg);
1339         has_uncfg = bitset_and(&delta, &mapp->dam_active_set, &uncfg);
1340
1341         /*
1342          * drop map lock while invoking callouts
1343          */
1344         mutex_exit(&mapp->dam_lock);
1345
1346         /*
1347          * activate all newly stable addresss
1348          */
1349         if (has_cfg)
1350                 dam_addrset_activate(mapp, &cfg);
1351
1352         /*
1353          * deactivate addresss which are no longer in the map
1354          */
1355         if (has_uncfg)
1356                 dam_addrset_deactivate(mapp, &uncfg);
1357
1358
1359         /*
1360          * timestamp the last stable time and increment the kstat keeping
1361          * the # of of stable cycles for the map
1362          */
1363         mutex_enter(&mapp->dam_lock);
1364         bitset_zero(&mapp->dam_stable_set);
1365         mapp->dam_last_stable = gethrtime();
1366         mapp->dam_stable_cnt++;
1367         DAM_INCR_STAT(mapp, dam_cycles);
1368
1369         /*
1370          * determine the number of stable addresses
1371          * and update the n_active kstat for this map
1372          */
1373         for (i = 1, n_active = 0; i < mapp->dam_high; i++)
1374                 if (bitset_in_set(&mapp->dam_active_set, i))
1375                         n_active++;
1376         DAM_SET_STAT(mapp, dam_active, n_active);
1377
1378         DTRACE_PROBE3(damap__map__stable__end,
1379             char *, mapp->dam_name, dam_t *, mapp,
1380             int, n_active);
1381
1382         mapp->dam_flags &= ~DAM_SPEND;
1383         cv_signal(&mapp->dam_sync_cv);
1384         mutex_exit(&mapp->dam_lock);
1385
1386         bitset_fini(&uncfg);
1387         bitset_fini(&cfg);
1388         bitset_fini(&delta);
1389 }
1390
1391 /*
1392  * per-address stabilization timeout
1393  */
1394 static void
1395 dam_addr_stable_cb(void *arg)
1396 {
1397         dam_t *mapp = (dam_t *)arg;
1398         int i;
1399         dam_da_t *passp;
1400         int spend = 0;
1401         int tpend = 0;
1402         int64_t ts, next_ticks, delta_ticks;
1403
1404         mutex_enter(&mapp->dam_lock);
1405         if (mapp->dam_tid == 0) {
1406                 DTRACE_PROBE2(damap__map__addr__stable__cancelled,
1407                     char *, mapp->dam_name, dam_t *, mapp);
1408                 mutex_exit(&mapp->dam_lock);
1409                 return;
1410         }
1411         mapp->dam_tid = 0;
1412
1413         /*
1414          * If still under stabilization, reschedule timeout,
1415          * otherwise dispatch the task to activate and deactivate the
1416          * new stable address
1417          */
1418         if (mapp->dam_flags & DAM_SPEND) {
1419                 DAM_INCR_STAT(mapp, dam_overrun);
1420                 mapp->dam_stable_overrun++;
1421                 DTRACE_PROBE2(damap__map__addr__stable__overrun,
1422                     char *, mapp->dam_name, dam_t *, mapp);
1423                 dam_sched_timeout(dam_addr_stable_cb, mapp,
1424                     mapp->dam_stable_ticks);
1425                 mutex_exit(&mapp->dam_lock);
1426                 return;
1427         }
1428
1429         DAM_SET_STAT(mapp, dam_overrun, 0);
1430         mapp->dam_stable_overrun = 0;
1431
1432         /* See if any reports stabalized and compute next timeout. */
1433         ts = ddi_get_lbolt64();
1434         next_ticks = mapp->dam_stable_ticks;
1435         for (i = 1; i < mapp->dam_high; i++) {
1436                 if (bitset_in_set(&mapp->dam_report_set, i)) {
1437                         passp = ddi_get_soft_state(mapp->dam_da, i);
1438                         ASSERT(passp);
1439
1440                         if (passp->da_deadline <= ts)
1441                                 spend++;        /* report has stabilized */
1442                         else {
1443                                 /* not stabilized, determine next map timeout */
1444                                 tpend++;
1445                                 delta_ticks = passp->da_deadline - ts;
1446                                 if (delta_ticks < next_ticks)
1447                                         next_ticks = delta_ticks;
1448                         }
1449                 }
1450         }
1451
1452         /*
1453          * schedule system_taskq activation of stabilized reports
1454          */
1455         if (spend) {
1456                 if (taskq_dispatch(system_taskq, dam_stabilize_map,
1457                     mapp, TQ_NOSLEEP | TQ_NOQUEUE)) {
1458                         DTRACE_PROBE2(damap__map__addr__stable__start,
1459                             char *, mapp->dam_name, dam_t *, mapp);
1460
1461                         /*
1462                          * The stable_set we compute below stays pending until
1463                          * processed by dam_stabilize_map. We can't set
1464                          * DAM_SPEND (or bitset_del things from the
1465                          * report_set) until we *know* that we can handoff the
1466                          * result to dam_stabilize_map. If dam_stabilize_map
1467                          * starts executing before we are complete, it will
1468                          * block on the dam_lock mutex until we are ready.
1469                          */
1470                         mapp->dam_flags |= DAM_SPEND;
1471
1472                         /*
1473                          * Copy the current active_set to the stable_set, then
1474                          * add or remove stabilized report_set address from
1475                          * the stable set (and delete them from the report_set).
1476                          */
1477                         bitset_copy(&mapp->dam_active_set,
1478                             &mapp->dam_stable_set);
1479                         for (i = 1; i < mapp->dam_high; i++) {
1480                                 if (!bitset_in_set(&mapp->dam_report_set, i))
1481                                         continue;
1482
1483                                 passp = ddi_get_soft_state(mapp->dam_da, i);
1484                                 if (passp->da_deadline > ts)
1485                                         continue; /* report not stabilized */
1486
1487                                 /* report has stabilized */
1488                                 if (passp->da_flags & DA_RELE)
1489                                         bitset_del(&mapp->dam_stable_set, i);
1490                                 else
1491                                         bitset_add(&mapp->dam_stable_set, i);
1492
1493                                 bitset_del(&mapp->dam_report_set, i);
1494                         }
1495                 } else {
1496                         DTRACE_PROBE2(damap__map__addr__stable__spendfail,
1497                             char *, mapp->dam_name, dam_t *, mapp);
1498
1499                         /*
1500                          * Avoid waiting the entire stabalization
1501                          * time again if taskq_diskpatch fails.
1502                          */
1503                         tpend++;
1504                         delta_ticks = drv_usectohz(
1505                             damap_taskq_dispatch_retry_usec);
1506                         if (delta_ticks < next_ticks)
1507                                 next_ticks = delta_ticks;
1508                 }
1509         }
1510
1511         /*
1512          * reschedule the stabilization timer if there are reports
1513          * still pending
1514          */
1515         if (tpend) {
1516                 DTRACE_PROBE2(damap__map__addr__stable__tpend, char *,
1517                     mapp->dam_name, dam_t *, mapp);
1518                 dam_sched_timeout(dam_addr_stable_cb, mapp,
1519                     (clock_t)next_ticks);
1520         }
1521
1522         mutex_exit(&mapp->dam_lock);
1523 }
1524
1525 /*
1526  * fullset stabilization timeout callback
1527  */
1528 static void
1529 dam_addrset_stable_cb(void *arg)
1530 {
1531         dam_t *mapp = (dam_t *)arg;
1532
1533         mutex_enter(&mapp->dam_lock);
1534         if (mapp->dam_tid == 0) {
1535                 mutex_exit(&mapp->dam_lock);
1536                 DTRACE_PROBE2(damap__map__addrset__stable__cancelled,
1537                     char *, mapp->dam_name, dam_t *, mapp);
1538                 return;
1539         }
1540         mapp->dam_tid = 0;
1541
1542         /*
1543          * If map still underoing stabilization reschedule timeout,
1544          * else dispatch the task to configure the new stable set of
1545          * addresses.
1546          */
1547         if ((mapp->dam_flags & DAM_SPEND) ||
1548             (taskq_dispatch(system_taskq, dam_stabilize_map, mapp,
1549             TQ_NOSLEEP | TQ_NOQUEUE) == 0)) {
1550                 DAM_INCR_STAT(mapp, dam_overrun);
1551                 mapp->dam_stable_overrun++;
1552                 dam_sched_timeout(dam_addrset_stable_cb, mapp,
1553                     drv_usectohz(damap_taskq_dispatch_retry_usec));
1554
1555                 DTRACE_PROBE2(damap__map__addrset__stable__overrun,
1556                     char *, mapp->dam_name, dam_t *, mapp);
1557                 mutex_exit(&mapp->dam_lock);
1558                 return;
1559         }
1560
1561         DAM_SET_STAT(mapp, dam_overrun, 0);
1562         mapp->dam_stable_overrun = 0;
1563         bitset_copy(&mapp->dam_report_set, &mapp->dam_stable_set);
1564         bitset_zero(&mapp->dam_report_set);
1565         mapp->dam_flags |= DAM_SPEND;
1566         mapp->dam_flags &= ~DAM_SETADD;
1567         /* NOTE: don't need cv_signal since DAM_SPEND is still set */
1568
1569         DTRACE_PROBE2(damap__map__addrset__stable__start,
1570             char *, mapp->dam_name, dam_t *, mapp);
1571         mutex_exit(&mapp->dam_lock);
1572 }
1573
1574 /*
1575  * schedule map timeout in 'ticks' ticks
1576  * if map timer is currently running, cancel if ticks == 0
1577  */
1578 static void
1579 dam_sched_timeout(void (*timeout_cb)(), dam_t *mapp, clock_t ticks)
1580 {
1581         timeout_id_t tid;
1582
1583         DTRACE_PROBE4(damap__sched__timeout,
1584             char *, mapp->dam_name, dam_t *, mapp,
1585             int, ticks, timeout_id_t, mapp->dam_tid);
1586
1587         ASSERT(mutex_owned(&mapp->dam_lock));
1588         if ((tid = mapp->dam_tid) != 0) {
1589                 if (ticks == 0) {
1590                         mapp->dam_tid = 0;
1591                         mutex_exit(&mapp->dam_lock);
1592                         (void) untimeout(tid);
1593                         mutex_enter(&mapp->dam_lock);
1594                 }
1595         } else {
1596                 if (timeout_cb && (ticks != 0))
1597                         mapp->dam_tid = timeout(timeout_cb, mapp, ticks);
1598         }
1599 }
1600
1601 /*
1602  * report addition or removal of an address
1603  */
1604 static void
1605 dam_addr_report(dam_t *mapp, dam_da_t *passp, id_t addrid, int rpt_type)
1606 {
1607         char *addrstr = damap_id2addr((damap_t *)mapp, addrid);
1608
1609         DTRACE_PROBE4(damap__addr__report,
1610             char *, mapp->dam_name, dam_t *, mapp,
1611             char *, addrstr, int, rpt_type);
1612
1613         ASSERT(mutex_owned(&mapp->dam_lock));
1614         ASSERT(!DAM_IN_REPORT(mapp, addrid));
1615         passp->da_last_report = gethrtime();
1616         mapp->dam_last_update = gethrtime();
1617         passp->da_report_cnt++;
1618         passp->da_deadline = ddi_get_lbolt64() + mapp->dam_stable_ticks;
1619         if (rpt_type == RPT_ADDR_DEL)
1620                 passp->da_flags |= DA_RELE;
1621         else if (rpt_type == RPT_ADDR_ADD)
1622                 passp->da_flags &= ~DA_RELE;
1623         bitset_add(&mapp->dam_report_set, addrid);
1624         dam_sched_timeout(dam_addr_stable_cb, mapp, mapp->dam_stable_ticks);
1625 }
1626
1627 /*
1628  * release an address report
1629  */
1630 static void
1631 dam_addr_report_release(dam_t *mapp, id_t addrid)
1632 {
1633         dam_da_t *passp;
1634         char *addrstr = damap_id2addr((damap_t *)mapp, addrid);
1635
1636         DTRACE_PROBE3(damap__addr__report__release,
1637             char *, mapp->dam_name, dam_t *, mapp,
1638             char *, addrstr);
1639
1640         ASSERT(mutex_owned(&mapp->dam_lock));
1641         passp = ddi_get_soft_state(mapp->dam_da, addrid);
1642         ASSERT(passp);
1643         /*
1644          * clear the report bit
1645          * if the address has a registered deactivation handler and
1646          * we are holding a private data pointer and the address has not
1647          * stabilized, deactivate the address (private data).
1648          */
1649         bitset_del(&mapp->dam_report_set, addrid);
1650         if (!DAM_IS_STABLE(mapp, addrid) && mapp->dam_deactivate_cb &&
1651             passp->da_ppriv_rpt) {
1652                 mutex_exit(&mapp->dam_lock);
1653                 (*mapp->dam_deactivate_cb)(mapp->dam_activate_arg,
1654                     ddi_strid_id2str(mapp->dam_addr_hash, addrid),
1655                     addrid, passp->da_ppriv_rpt, DAMAP_DEACT_RSN_UNSTBL);
1656                 mutex_enter(&mapp->dam_lock);
1657         }
1658         passp->da_ppriv_rpt = NULL;
1659         nvlist_free(passp->da_nvl_rpt);
1660 }
1661
1662 /*
1663  * return the map ID of an address
1664  */
1665 static id_t
1666 dam_get_addrid(dam_t *mapp, char *address)
1667 {
1668         damap_id_t addrid;
1669         dam_da_t *passp;
1670
1671         ASSERT(mutex_owned(&mapp->dam_lock));
1672         if ((addrid = ddi_strid_str2id(mapp->dam_addr_hash, address)) == 0) {
1673                 if ((addrid = ddi_strid_alloc(mapp->dam_addr_hash,
1674                     address)) == (damap_id_t)0) {
1675                         return (0);
1676                 }
1677                 if (ddi_soft_state_zalloc(mapp->dam_da, addrid) !=
1678                     DDI_SUCCESS) {
1679                         ddi_strid_free(mapp->dam_addr_hash, addrid);
1680                         return (0);
1681                 }
1682
1683                 if (addrid >= mapp->dam_high)
1684                         mapp->dam_high = addrid + 1;
1685
1686                 /*
1687                  * expand bitmaps if ID has outgrown old map size
1688                  */
1689                 if (mapp->dam_high > mapp->dam_size) {
1690                         mapp->dam_size = mapp->dam_size + DAM_SIZE_BUMP;
1691                         bitset_resize(&mapp->dam_active_set, mapp->dam_size);
1692                         bitset_resize(&mapp->dam_stable_set, mapp->dam_size);
1693                         bitset_resize(&mapp->dam_report_set, mapp->dam_size);
1694                 }
1695
1696                 passp = ddi_get_soft_state(mapp->dam_da, addrid);
1697                 passp->da_ref = 1;
1698                 passp->da_addr = ddi_strid_id2str(mapp->dam_addr_hash,
1699                     addrid); /* for mdb */
1700         }
1701         return (addrid);
1702 }
1703
1704 /*
1705  * create and install map statistics
1706  */
1707 static int
1708 dam_kstat_create(dam_t *mapp)
1709 {
1710         kstat_t                 *mapsp;
1711         struct dam_kstats       *statsp;
1712
1713         mapsp = kstat_create("dam", 0, mapp->dam_name, "damap",
1714             KSTAT_TYPE_NAMED,
1715             sizeof (struct dam_kstats) / sizeof (kstat_named_t), 0);
1716
1717         if (mapsp == NULL)
1718                 return (DDI_FAILURE);
1719
1720         statsp = (struct dam_kstats *)mapsp->ks_data;
1721         kstat_named_init(&statsp->dam_cycles, "cycles", KSTAT_DATA_UINT32);
1722         kstat_named_init(&statsp->dam_overrun, "overrun", KSTAT_DATA_UINT32);
1723         kstat_named_init(&statsp->dam_jitter, "jitter", KSTAT_DATA_UINT32);
1724         kstat_named_init(&statsp->dam_active, "active", KSTAT_DATA_UINT32);
1725         kstat_install(mapsp);
1726         mapp->dam_kstatsp = mapsp;
1727         return (DDI_SUCCESS);
1728 }