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 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * memory support routines for sbd. 29 */ 30 31 #include <sys/debug.h> 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <sys/param.h> 35 #include <sys/dditypes.h> 36 #include <sys/kmem.h> 37 #include <sys/conf.h> 38 #include <sys/ddi.h> 39 #include <sys/sunddi.h> 40 #include <sys/sunndi.h> 41 #include <sys/ddi_impldefs.h> 42 #include <sys/sysmacros.h> 43 #include <sys/machsystm.h> 44 #include <sys/spitregs.h> 45 #include <sys/cpuvar.h> 46 #include <sys/cpu_module.h> 47 #include <sys/promif.h> 48 #include <sys/memlist_impl.h> 49 #include <sys/mem_cage.h> 50 #include <sys/lgrp.h> 51 #include <sys/platform_module.h> 52 #include <vm/seg_kmem.h> 53 54 #include <sys/sbdpriv.h> 55 56 #define _ptob64(p) ((uint64_t)(p) << PAGESHIFT) 57 #define _b64top(b) ((pgcnt_t)((b) >> PAGESHIFT)) 58 59 static int sbd_post_detach_mem_unit(sbd_mem_unit_t *mp, 60 sbderror_t *ep); 61 static int sbd_reserve_mem_spans(memhandle_t *mhp, 62 struct memlist *mlist); 63 static int sbd_check_boundaries(struct memlist *orig_memlist, 64 sbd_mem_unit_t *s_mp, 65 sbd_mem_unit_t *t_mp); 66 static int sbd_select_mem_target(sbd_handle_t *hp, 67 sbd_mem_unit_t *mp, struct memlist *ml); 68 static void sbd_init_mem_unit_data(sbd_mem_unit_t *mp, sbderror_t 69 *ep); 70 static int memlist_canfit(struct memlist *s_mlist, 71 struct memlist *t_mlist); 72 static void sbd_mem_cleanup(sbd_mem_unit_t *s_mp, 73 sbd_mem_unit_t *t_mp, sbderror_t *ep); 74 static void sbd_flush_ecache(uint64_t a, uint64_t b); 75 76 struct memlist * 77 sbd_get_memlist(sbd_mem_unit_t *mp, sbderror_t *ep) 78 { 79 struct memlist *mlist; 80 static fn_t f = "sbd_get_memlist"; 81 sbd_board_t *sbp = (sbd_board_t *)mp->sbm_cm.sbdev_sbp; 82 sbdp_handle_t *hdp; 83 sbd_handle_t *hp = MACHBD2HD(sbp); 84 85 PR_MEM("%s...\n", f); 86 87 /* 88 * Return cached memlist, if present. 89 * This memlist will be present following an 90 * unconfigure (a.k.a: detach) of this memunit. 91 * It should only be used in the case were a configure 92 * is bringing this memunit back in without going 93 * through the disconnect and connect states. 94 */ 95 if (mp->sbm_mlist) { 96 PR_MEM("%s: found cached memlist\n", f); 97 98 mlist = memlist_dup(mp->sbm_mlist); 99 } else { 100 /* attempt to construct a memlist using phys_install */ 101 102 /* 103 * NOTE: this code block assumes only one memunit per 104 * board. This is currently safe because the function 105 * sbd_init_mem_devlist() forces this assumption to be 106 * valid. 107 */ 108 109 /* round down to slice base address */ 110 /* build mlist from the lower layer */ 111 hdp = sbd_get_sbdp_handle(sbp, hp); 112 mlist = sbdp_get_memlist(hdp, mp->sbm_cm.sbdev_dip); 113 if (mlist == NULL) { 114 SBD_GET_PERR(hdp->h_err, ep); 115 PR_MEM("sbd:%s: failed to get memlist for " 116 "dip (0x%p) ecode %d errno %d", f, 117 (void *)mp->sbm_cm.sbdev_dip, 118 ep->e_code, ep->e_errno); 119 sbd_release_sbdp_handle(hdp); 120 return (NULL); 121 } 122 sbd_release_sbdp_handle(hdp); 123 } 124 125 PR_MEM("%s: memlist for mem-unit (%d.%d), dip 0x%p:\n", 126 f, sbp->sb_num, 127 mp->sbm_cm.sbdev_unum, 128 (void *)mp->sbm_cm.sbdev_dip); 129 SBD_MEMLIST_DUMP(mlist); 130 131 return (mlist); 132 } 133 134 int 135 sbd_pre_attach_mem(sbd_handle_t *hp, sbd_devlist_t devlist[], int devnum) 136 { 137 int err_flag = 0; 138 sbderror_t *ep = SBD_HD2ERR(hp); 139 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 140 int d, i; 141 sbdp_handle_t *hdp; 142 static fn_t f = "sbd_pre_attach_mem"; 143 144 PR_MEM("%s...\n", f); 145 146 SBD_SET_ERR(ep, 0); 147 hdp = sbd_get_sbdp_handle(sbp, hp); 148 149 for (d = 0; d < devnum; d++) { 150 sbd_mem_unit_t *mp; 151 int unit; 152 dev_info_t *dip; 153 sbd_istate_t state; 154 int rv; 155 156 /* sbd_get_devlist will not devlist element w/ dip of 0 */ 157 ASSERT(devlist[d].dv_dip != NULL); 158 159 dip = devlist[d].dv_dip; 160 unit = sbdp_get_unit_num(hdp, dip); 161 if (unit == -1) { 162 if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) 163 continue; 164 else { 165 SBD_GET_PERR(hdp->h_err, ep); 166 err_flag = 1; 167 break; 168 } 169 } 170 171 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 172 173 ASSERT(mp->sbm_cm.sbdev_sbp == sbp); 174 ASSERT(unit == mp->sbm_cm.sbdev_unum); 175 176 PR_MEM("sbd: OS attach mem-unit (%d.%d)\n", 177 sbp->sb_num, 178 mp->sbm_cm.sbdev_unum); 179 180 state = mp->sbm_cm.sbdev_state; 181 switch (state) { 182 case SBD_STATE_UNCONFIGURED: 183 /* use memlist cached by sbd_post_detach_mem_unit */ 184 if (mp->sbm_mlist != NULL) { 185 PR_MEM("%s: recovering from UNCONFIG" 186 " mem-unit (%d.%d)\n", 187 f, sbp->sb_num, 188 mp->sbm_cm.sbdev_unum); 189 190 PR_MEM("%s: re-configure cached memlist:\n", f); 191 SBD_MEMLIST_DUMP(mp->sbm_mlist); 192 193 /* 194 * kphysm del handle should have been freed 195 */ 196 ASSERT((mp->sbm_flags & SBD_MFLAG_RELOWNER) 197 == 0); 198 } else { 199 if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) 200 continue; 201 else { 202 SBD_GET_PERR(hdp->h_err, ep); 203 err_flag = 1; 204 PR_MEM("%s: mem-unit (%d.%d)" 205 " unusable\n", 206 f, sbp->sb_num, 207 mp->sbm_cm.sbdev_unum); 208 break; 209 } 210 } 211 212 /*FALLTHROUGH*/ 213 214 case SBD_STATE_CONNECTED: 215 PR_MEM("%s: reprogramming mem hardware (board %d)\n", 216 f, sbp->sb_num); 217 218 for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) { 219 if (mp->sbm_dip[i] == NULL) 220 continue; 221 dip = mp->sbm_dip[i]; 222 223 PR_MEM("%s: enabling mc 0x%p on board %d\n", 224 f, (void *)dip, sbp->sb_num); 225 226 rv = sbdphw_enable_memctrl(hdp, dip); 227 if (rv < 0) { 228 SBD_GET_PERR(hdp->h_err, ep); 229 cmn_err(CE_WARN, 230 "%s: failed to program mem ctrlr %p on " 231 "board %d", f, (void *)mp->sbm_dip[i], 232 sbp->sb_num); 233 err_flag = 1; 234 } 235 } 236 break; 237 238 default: 239 cmn_err(CE_WARN, 240 "%s: unexpected state (%d) for mem-unit " 241 "(%d.%d)", f, state, sbp->sb_num, 242 mp->sbm_cm.sbdev_unum); 243 if (SBD_GET_ERR(ep) == 0) { 244 SBD_SET_ERR(ep, ESBD_STATE); 245 err_flag = 1; 246 } 247 break; 248 } 249 250 /* exit for loop if error encountered */ 251 if (err_flag) { 252 SBD_SET_ERRSTR(ep, 253 sbp->sb_mempath[mp->sbm_cm.sbdev_unum]); 254 break; 255 } 256 } 257 sbd_release_sbdp_handle(hdp); 258 259 return (err_flag ? -1 : 0); 260 } 261 262 int 263 sbd_post_attach_mem(sbd_handle_t *hp, sbd_devlist_t devlist[], int devnum) 264 { 265 int d; 266 sbdp_handle_t *hdp; 267 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 268 sbderror_t *ep = SBD_HD2ERR(hp); 269 static fn_t f = "sbd_post_attach_mem"; 270 271 PR_MEM("%s...\n", f); 272 hdp = sbd_get_sbdp_handle(sbp, hp); 273 274 for (d = 0; d < devnum; d++) { 275 sbd_mem_unit_t *mp; 276 dev_info_t *dip; 277 int unit; 278 struct memlist *mlist, *ml; 279 280 /* sbd_get_devlist will not devlist element w/ dip of 0 */ 281 ASSERT(devlist[d].dv_dip != NULL); 282 283 dip = devlist[d].dv_dip; 284 unit = sbdp_get_unit_num(hdp, dip); 285 if (unit == -1) { 286 if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) 287 continue; 288 else { 289 SBD_GET_PERR(hdp->h_err, ep); 290 break; 291 } 292 } 293 294 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 295 296 mlist = sbd_get_memlist(mp, ep); 297 if (mlist == NULL) { 298 cmn_err(CE_WARN, 299 "%s: no memlist for mem-unit (%d.%d)", 300 f, 301 sbp->sb_num, 302 mp->sbm_cm.sbdev_unum); 303 304 if (SBD_GET_ERR(ep) == 0) { 305 SBD_SET_ERR(ep, ESBD_MEMFAIL); 306 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 307 } 308 309 continue; 310 } 311 312 /* 313 * Verify the memory really did successfully attach 314 * by checking for its existence in phys_install. 315 */ 316 317 memlist_read_lock(); 318 if (memlist_intersect(phys_install, mlist) == 0) { 319 memlist_read_unlock(); 320 321 cmn_err(CE_WARN, 322 "%s: mem-unit (%d.%d) memlist not in" 323 " phys_install", f, sbp->sb_num, 324 mp->sbm_cm.sbdev_unum); 325 326 if (SBD_GET_ERR(ep) == 0) { 327 SBD_SET_ERR(ep, ESBD_INTERNAL); 328 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 329 } 330 331 memlist_delete(mlist); 332 continue; 333 } 334 memlist_read_unlock(); 335 336 for (ml = mlist; ml != NULL; ml = ml->ml_next) { 337 (void) sbdp_mem_add_span(hdp, ml->ml_address, 338 ml->ml_size); 339 } 340 341 memlist_delete(mlist); 342 343 /* 344 * Destroy cached memlist, if any. 345 * There will be a cached memlist in sbm_mlist if 346 * this board is being configured directly after 347 * an unconfigure. 348 * To support this transition, sbd_post_detach_mem 349 * left a copy of the last known memlist in sbm_mlist. 350 * This memlist could differ from any derived from 351 * hardware if while this memunit was last configured 352 * the system detected and deleted bad pages from 353 * phys_install. The location of those bad pages 354 * will be reflected in the cached memlist. 355 */ 356 if (mp->sbm_mlist) { 357 memlist_delete(mp->sbm_mlist); 358 mp->sbm_mlist = NULL; 359 } 360 sbd_init_mem_unit_data(mp, ep); 361 } 362 363 sbd_release_sbdp_handle(hdp); 364 return (0); 365 } 366 367 int 368 sbd_pre_detach_mem(sbd_handle_t *hp, sbd_devlist_t devlist[], int devnum) 369 { 370 int d; 371 int unit; 372 sbdp_handle_t *hdp; 373 sbderror_t *ep = SBD_HD2ERR(hp); 374 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 375 dev_info_t *dip; 376 377 hdp = sbd_get_sbdp_handle(sbp, hp); 378 379 for (d = 0; d < devnum; d++) { 380 sbd_mem_unit_t *mp; 381 382 /* sbd_get_devlist will not devlist element w/ dip of 0 */ 383 ASSERT(devlist[d].dv_dip != NULL); 384 385 dip = devlist[d].dv_dip; 386 unit = sbdp_get_unit_num(hdp, dip); 387 if (unit == -1) { 388 if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) 389 continue; 390 else { 391 SBD_GET_PERR(hdp->h_err, ep); 392 sbd_release_sbdp_handle(hdp); 393 return (-1); 394 } 395 } 396 397 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 398 399 /* sanity check */ 400 ASSERT(mp->sbm_cm.sbdev_sbp == sbp); 401 ASSERT(unit == mp->sbm_cm.sbdev_unum); 402 403 PR_MEM("sbd: OS detach mem-unit (%d.%d)\n", 404 sbp->sb_num, mp->sbm_cm.sbdev_unum); 405 } 406 407 sbd_release_sbdp_handle(hdp); 408 return (0); 409 } 410 411 int 412 sbd_post_detach_mem(sbd_handle_t *hp, sbd_devlist_t devlist[], int devnum) 413 { 414 int d, rv; 415 sbdp_handle_t *hdp; 416 sbd_board_t *sbp; 417 sbd_mem_unit_t *s_mp, *t_mp; 418 static fn_t f = "sbd_post_detach_mem"; 419 420 PR_MEM("%s...\n", f); 421 422 sbp = SBDH2BD(hp->h_sbd); 423 424 hdp = sbd_get_sbdp_handle(sbp, hp); 425 426 427 rv = 0; 428 for (d = 0; d < devnum; d++) { 429 sbderror_t *ep; 430 dev_info_t *dip; 431 int unit; 432 433 /* sbd_get_devlist will not devlist element w/ dip of 0 */ 434 ASSERT(devlist[d].dv_dip != NULL); 435 436 ep = &devlist[d].dv_error; 437 if ((SBD_GET_ERR(SBD_HD2ERR(hp)) != 0) || 438 (sbd_set_err_in_hdl(hp, ep) == 0)) { 439 rv = -1; 440 } 441 442 dip = devlist[d].dv_dip; 443 unit = sbdp_get_unit_num(hdp, dip); 444 if (unit == -1) { 445 if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) 446 continue; 447 else { 448 if (rv != -1) 449 SBD_GET_PERR(hdp->h_err, ep); 450 break; 451 } 452 } 453 454 s_mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 455 456 ASSERT(s_mp->sbm_cm.sbdev_sbp == sbp); 457 458 if (rv == -1) { 459 if (s_mp->sbm_flags & SBD_MFLAG_SOURCE) { 460 t_mp = s_mp->sbm_peer; 461 } else { 462 /* this is no target unit */ 463 t_mp = NULL; 464 } 465 466 sbd_mem_cleanup(s_mp, t_mp, ep); 467 } else if (sbd_post_detach_mem_unit(s_mp, ep)) 468 rv = -1; 469 } 470 471 sbd_release_sbdp_handle(hdp); 472 return (rv); 473 } 474 475 static void 476 sbd_add_memory_spans(sbd_board_t *sbp, struct memlist *ml) 477 { 478 sbdp_handle_t *hdp; 479 static fn_t f = "sbd_add_memory_spans"; 480 481 PR_MEM("%s...", f); 482 SBD_MEMLIST_DUMP(ml); 483 484 #ifdef DEBUG 485 memlist_read_lock(); 486 if (memlist_intersect(phys_install, ml)) { 487 PR_MEM("%s:WARNING: memlist intersects with phys_install\n", f); 488 } 489 memlist_read_unlock(); 490 #endif 491 hdp = sbd_get_sbdp_handle(NULL, NULL); 492 493 for (; ml; ml = ml->ml_next) { 494 update_membounds_t umb; 495 pfn_t base; 496 pgcnt_t npgs; 497 int rv; 498 499 base = _b64top(ml->ml_address); 500 npgs = _b64top(ml->ml_size); 501 502 umb.u_board = sbp->sb_num; 503 umb.u_base = (uint64_t)base << MMU_PAGESHIFT; 504 umb.u_len = (uint64_t)npgs << MMU_PAGESHIFT; 505 506 lgrp_plat_config(LGRP_CONFIG_MEM_ADD, (uintptr_t)&umb); 507 rv = kphysm_add_memory_dynamic(base, npgs); 508 509 (void) sbdp_mem_add_span(hdp, ml->ml_address, ml->ml_size); 510 511 if (rv != KPHYSM_OK) { 512 cmn_err(CE_WARN, "sbd:%s:" 513 " unexpected kphysm_add_memory_dynamic" 514 " return value %d;" 515 " basepfn=0x%lx, npages=%ld\n", 516 f, rv, base, npgs); 517 518 continue; 519 } 520 rv = kcage_range_add(base, npgs, KCAGE_DOWN); 521 if (rv != 0) 522 continue; 523 } 524 sbd_release_sbdp_handle(hdp); 525 } 526 527 /* hack for test scripts. *** remove before code finalized *** */ 528 int sbd_last_target; 529 530 static int 531 sbd_post_detach_mem_unit(sbd_mem_unit_t *s_mp, sbderror_t *ep) 532 { 533 uint64_t sz; 534 uint64_t sm; 535 uint64_t t_basepa; 536 uint64_t tmp_basepa; 537 uint64_t s_basepa; 538 sbd_board_t *sbp; 539 sbdp_handle_t *hdp; 540 uint64_t s_nbytes; 541 uint64_t s_new_basepa; 542 sbd_mem_unit_t *t_mp, *x_mp; 543 struct memlist *ml; 544 int rv; 545 static fn_t f = "sbd_post_detach_mem_unit"; 546 sbd_handle_t *hp; 547 548 PR_MEM("%s...\n", f); 549 550 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 551 hp = MACHBD2HD(sbp); 552 hdp = sbd_get_sbdp_handle(sbp, hp); 553 554 if (sbdp_get_mem_alignment(hdp, s_mp->sbm_cm.sbdev_dip, &sz)) { 555 cmn_err(CE_WARN, 556 "sbd:%s: no alignment for mem-unit (%d.%d)", 557 f, sbp->sb_num, s_mp->sbm_cm.sbdev_unum); 558 SBD_GET_PERR(hdp->h_err, ep); 559 sbd_release_sbdp_handle(hdp); 560 return (-1); 561 } 562 sm = sz - 1; 563 564 /* s_mp->sbm_del_mlist could be NULL, meaning no deleted spans */ 565 PR_MEM("%s: brd %d: deleted memlist (EMPTY maybe okay):\n", 566 f, sbp->sb_num); 567 SBD_MEMLIST_DUMP(s_mp->sbm_del_mlist); 568 569 /* sanity check */ 570 ASSERT(s_mp->sbm_del_mlist == NULL || 571 (s_mp->sbm_flags & SBD_MFLAG_RELDONE) != 0); 572 573 if (s_mp->sbm_flags & SBD_MFLAG_SOURCE) { 574 t_mp = s_mp->sbm_peer; 575 576 ASSERT(t_mp != NULL); 577 ASSERT(t_mp->sbm_flags & SBD_MFLAG_TARGET); 578 ASSERT(t_mp->sbm_peer == s_mp); 579 580 ASSERT(t_mp->sbm_flags & SBD_MFLAG_RELDONE); 581 ASSERT(t_mp->sbm_del_mlist); 582 583 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 584 PR_MEM("%s: target brd %d: deleted memlist:\n", 585 f, sbp->sb_num); 586 SBD_MEMLIST_DUMP(t_mp->sbm_del_mlist); 587 } else { 588 /* this is no target unit */ 589 t_mp = NULL; 590 } 591 592 /* 593 * Verify the memory really did successfully detach 594 * by checking for its non-existence in phys_install. 595 */ 596 rv = 0; 597 memlist_read_lock(); 598 if (s_mp->sbm_flags & SBD_MFLAG_RELDONE) { 599 x_mp = s_mp; 600 rv = memlist_intersect(phys_install, x_mp->sbm_del_mlist); 601 } 602 if (rv == 0 && t_mp && (t_mp->sbm_flags & SBD_MFLAG_RELDONE)) { 603 x_mp = t_mp; 604 rv = memlist_intersect(phys_install, x_mp->sbm_del_mlist); 605 } 606 memlist_read_unlock(); 607 608 if (rv) { 609 sbp = (sbd_board_t *)x_mp->sbm_cm.sbdev_sbp; 610 611 cmn_err(CE_WARN, 612 "%s: %smem-unit (%d.%d) memlist still in phys_install", 613 f, 614 x_mp == t_mp ? "target " : "", 615 sbp->sb_num, 616 x_mp->sbm_cm.sbdev_unum); 617 SBD_SET_ERR(ep, ESBD_INTERNAL); 618 SBD_SET_ERRSTR(ep, sbp->sb_mempath[x_mp->sbm_cm.sbdev_unum]); 619 sbd_release_sbdp_handle(hdp); 620 return (-1); 621 } 622 623 s_basepa = _ptob64(s_mp->sbm_basepfn); 624 s_nbytes = _ptob64(s_mp->sbm_npages); 625 626 if (t_mp != NULL) { 627 t_basepa = _ptob64(t_mp->sbm_basepfn); 628 s_new_basepa = (s_basepa & ~ sm) + 629 _ptob64(t_mp->sbm_slice_offset); 630 631 /* 632 * We had to swap mem-units, so update 633 * memlists accordingly with new base 634 * addresses. 635 */ 636 for (ml = t_mp->sbm_mlist; ml; ml = ml->ml_next) { 637 ml->ml_address -= t_basepa; 638 ml->ml_address += s_new_basepa; 639 } 640 641 /* 642 * There is no need to explicitly rename the target delete 643 * memlist, because sbm_del_mlist and sbm_mlist always 644 * point to the same memlist for a copy/rename operation. 645 */ 646 ASSERT(t_mp->sbm_del_mlist == t_mp->sbm_mlist); 647 648 PR_MEM("%s: renamed target memlist and delete memlist", f); 649 SBD_MEMLIST_DUMP(t_mp->sbm_mlist); 650 651 for (ml = s_mp->sbm_mlist; ml; ml = ml->ml_next) { 652 ml->ml_address -= s_basepa; 653 ml->ml_address += t_basepa; 654 } 655 656 PR_MEM("%s: renamed source memlist", f); 657 SBD_MEMLIST_DUMP(s_mp->sbm_mlist); 658 659 #ifdef DEBUG 660 ASSERT(s_mp->sbm_mlist != s_mp->sbm_del_mlist); 661 /* 662 * Renaming s_mp->sbm_del_mlist is not necessary. This 663 * list is not used beyond this point, and in fact, is 664 * disposed of at the end of this function. 665 */ 666 for (ml = s_mp->sbm_del_mlist; ml; ml = ml->ml_next) { 667 ml->ml_address -= s_basepa; 668 ml->ml_address += t_basepa; 669 } 670 671 PR_MEM("%s: renamed source delete memlist", f); 672 SBD_MEMLIST_DUMP(s_mp->sbm_del_mlist); 673 #endif 674 675 if (s_mp->sbm_flags & SBD_MFLAG_MEMUPSIZE) { 676 struct memlist *nl; 677 int mlret; 678 679 /* 680 * We had to perform a copy-rename from a 681 * small memory node to a big memory node. 682 * Need to add back the remaining memory on 683 * the big board that wasn't used by that 684 * from the small board during the copy. 685 * Subtract out the portion of the target memory 686 * node that was taken over by the source memory 687 * node. 688 */ 689 nl = memlist_dup(t_mp->sbm_mlist); 690 mlret = memlist_delete_span(s_basepa, s_nbytes, &nl); 691 PR_MEM("%s: mlret = %d\n", f, mlret); 692 693 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 694 PR_MEM("%s: adding back remaining portion" 695 " of mem-unit (%d.%d), memlist:\n", 696 f, sbp->sb_num, 697 t_mp->sbm_cm.sbdev_unum); 698 699 SBD_MEMLIST_DUMP(nl); 700 701 sbd_add_memory_spans(sbp, nl); 702 703 memlist_delete(nl); 704 } 705 } 706 707 708 if (t_mp != NULL) { 709 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 710 hdp->h_board = sbp->sb_num; 711 /* delete target's entire address space */ 712 tmp_basepa = t_basepa & ~ sm; 713 rv = sbdp_mem_del_span(hdp, tmp_basepa, sz); 714 ASSERT(rv == 0); 715 716 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 717 hdp->h_board = sbp->sb_num; 718 tmp_basepa = s_basepa & ~ sm; 719 sz = s_new_basepa & sm; 720 /* delete source board's vacant address space */ 721 rv = sbdp_mem_del_span(hdp, tmp_basepa, sz); 722 ASSERT(rv == 0); 723 } else { 724 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 725 hdp->h_board = sbp->sb_num; 726 tmp_basepa = s_basepa & ~ sm; 727 /* delete board's entire address space */ 728 rv = sbdp_mem_del_span(hdp, tmp_basepa, sz); 729 ASSERT(rv == 0); 730 } 731 732 #ifdef LINT 733 rv = rv; 734 #endif 735 736 sbd_mem_cleanup(s_mp, t_mp, ep); 737 738 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 739 PR_MEM("%s: board %d's memlist:", f, sbp->sb_num); 740 SBD_MEMLIST_DUMP(s_mp->sbm_mlist); 741 742 sbd_release_sbdp_handle(hdp); 743 return (0); 744 } 745 746 static void 747 sbd_mem_cleanup(sbd_mem_unit_t *s_mp, sbd_mem_unit_t *t_mp, sbderror_t *ep) 748 { 749 sbd_board_t *sbp; 750 751 /* clean up target mem unit */ 752 if (t_mp != NULL) { 753 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 754 755 ASSERT(t_mp->sbm_del_mlist == t_mp->sbm_mlist); 756 /* 757 * sbm_del_mlist and sbm_mlist point at the same list 758 * We only need to delete one and then set both pointers 759 * to NULL 760 */ 761 memlist_delete(t_mp->sbm_del_mlist); 762 763 t_mp->sbm_del_mlist = NULL; 764 t_mp->sbm_mlist = NULL; 765 t_mp->sbm_peer = NULL; 766 t_mp->sbm_flags = 0; 767 t_mp->sbm_cm.sbdev_busy = 0; 768 sbd_init_mem_unit_data(t_mp, ep); 769 770 /* 771 * now that copy/rename has completed, undo this 772 * work that was done in sbd_release_mem_done. 773 */ 774 /* 775 * If error don't set the target to configured 776 */ 777 if (SBD_GET_ERR(ep) == 0) { 778 SBD_DEV_CLR_UNREFERENCED(sbp, SBD_COMP_MEM, 0); 779 SBD_DEV_CLR_RELEASED(sbp, SBD_COMP_MEM, 0); 780 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, 0, 781 SBD_STATE_CONFIGURED); 782 } 783 784 /* hack for test scripts. *** remove before code finalized *** */ 785 sbd_last_target = sbp->sb_num; 786 } 787 788 /* 789 * clean up (source) board's mem unit structure. 790 * NOTE: sbm_mlist is retained. It is referred to as the 791 * cached memlist. The cached memlist is used to re-attach 792 * (configure back in) this memunit from the unconfigured 793 * state. 794 */ 795 if (s_mp != NULL) { 796 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 797 798 /* 799 * Don't want to call memlist_delete for sbm_del_mlist, 800 * since that list points to the sbm_list 801 */ 802 s_mp->sbm_del_mlist = NULL; 803 s_mp->sbm_peer = NULL; 804 s_mp->sbm_flags = 0; 805 s_mp->sbm_cm.sbdev_busy = 0; 806 sbd_init_mem_unit_data(s_mp, ep); 807 } 808 } 809 810 /* 811 * Successful return from this function will have the memory 812 * handle in sbp->sb_dev[..mem-unit...].sbm_memhandle allocated 813 * and waiting. This routine's job is to select the memory that 814 * actually has to be released (detached) which may not necessarily 815 * be the same memory node that came in in devlist[], 816 * i.e. a copy-rename is needed. 817 */ 818 int 819 sbd_pre_release_mem(sbd_handle_t *hp, sbd_devlist_t devlist[], int devnum) 820 { 821 extern int kcage_on; 822 int d; 823 int err_flag = 0; 824 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 825 sbderror_t *ep = SBD_HD2ERR(hp); 826 sbderror_t *lep; 827 static fn_t f = "sbd_pre_release_mem"; 828 829 PR_MEM("%s...\n", f); 830 831 if (kcage_on == 0) { 832 /* 833 * Can't Detach memory if Cage is OFF. 834 */ 835 cmn_err(CE_WARN, "%s: kernel cage is disabled", f); 836 SBD_SET_ERR(ep, ESBD_KCAGE_OFF); 837 return (-1); 838 } 839 840 for (d = 0; d < devnum; d++) { 841 int rv; 842 memquery_t mq; 843 sbd_mem_unit_t *mp; 844 struct memlist *ml; 845 846 /* sbd_get_devlist will not devlist element w/ dip of 0 */ 847 ASSERT(devlist[d].dv_dip != NULL); 848 849 mp = SBD_GET_BOARD_MEMUNIT(sbp, d); 850 851 /* 852 * If all the mem unit is marked as failed then don't allow the 853 * operation 854 */ 855 if (mp->sbm_cm.sbdev_cond == SBD_COND_FAILED) { 856 SBD_SET_ERR(ep, ESBD_STATE); 857 SBD_SET_ERRSTR(ep, sbp->sb_mempath[d]); 858 err_flag = -1; 859 break; 860 } 861 862 ASSERT(d == mp->sbm_cm.sbdev_unum); 863 864 /* 865 * if interleave is set to across boards fail the op 866 */ 867 if (mp->sbm_interleave) { 868 SBD_SET_ERR(ep, ESBD_MEMINTLV); 869 SBD_SET_ERRSTR(ep, sbp->sb_mempath[d]); 870 err_flag = -1; 871 break; 872 } 873 874 lep = &devlist[d].dv_error; 875 if (SBD_GET_ERR(lep) != 0) { 876 err_flag = -1; 877 (void) sbd_set_err_in_hdl(hp, lep); 878 break; 879 } 880 881 if (mp->sbm_flags & SBD_MFLAG_RESERVED) { 882 /* 883 * Board is currently involved in a delete 884 * memory operation. Can't detach this guy until 885 * that operation completes. 886 */ 887 cmn_err(CE_WARN, 888 "%s: ineligible mem-unit (%d.%d) for detach", 889 f, sbp->sb_num, 890 mp->sbm_cm.sbdev_unum); 891 892 SBD_SET_ERR(lep, ESBD_INVAL); 893 SBD_SET_ERRSTR(lep, sbp->sb_mempath[d]); 894 (void) sbd_set_err_in_hdl(hp, lep); 895 err_flag = -1; 896 break; 897 } 898 899 /* 900 * Check whether the detaching memory requires a 901 * copy-rename. 902 */ 903 ASSERT(mp->sbm_npages != 0); 904 rv = kphysm_del_span_query( 905 mp->sbm_basepfn, mp->sbm_npages, &mq); 906 if (rv != KPHYSM_OK) { 907 cmn_err(CE_WARN, 908 "%s: unexpected kphysm_del_span_query" 909 " return value %d;" 910 " basepfn 0x%lx, npages 0x%lx," 911 " mem-unit (%d.%d), dip 0x%p", 912 f, 913 rv, 914 mp->sbm_basepfn, 915 mp->sbm_npages, 916 sbp->sb_num, 917 mp->sbm_cm.sbdev_unum, 918 (void *)mp->sbm_cm.sbdev_dip); 919 920 SBD_SET_ERR(lep, ESBD_INTERNAL); 921 SBD_SET_ERRSTR(lep, sbp->sb_mempath[d]); 922 (void) sbd_set_err_in_hdl(hp, lep); 923 err_flag = -1; 924 break; 925 } 926 927 if (mq.nonrelocatable != 0) { 928 if (!(hp->h_iap->i_flags & SBD_FLAG_QUIESCE_OKAY)) { 929 /* caller wasn't prompted for a suspend */ 930 SBD_SET_ERR(lep, ESBD_QUIESCE_REQD); 931 SBD_SET_ERRSTR(lep, sbp->sb_mempath[d]); 932 (void) sbd_set_err_in_hdl(hp, lep); 933 err_flag = 1; 934 break; 935 } 936 } 937 938 /* flags should be clean at this time */ 939 ASSERT(mp->sbm_flags == 0); 940 941 ASSERT(mp->sbm_del_mlist == NULL); /* should be null */ 942 943 if (mp->sbm_mlist != NULL) { 944 memlist_delete(mp->sbm_mlist); 945 mp->sbm_mlist = NULL; 946 } 947 948 ml = sbd_get_memlist(mp, lep); 949 (void) sbd_set_err_in_hdl(hp, lep); 950 if (ml == NULL) { 951 PR_MEM("%s: no memlist found for board %d\n", 952 f, sbp->sb_num); 953 err_flag = -1; 954 break; 955 } 956 957 /* allocate a kphysm handle */ 958 rv = kphysm_del_gethandle(&mp->sbm_memhandle); 959 if (rv != KPHYSM_OK) { 960 memlist_delete(ml); 961 962 cmn_err(CE_WARN, 963 "%s: unexpected kphysm_del_gethandle" 964 " return value %d", f, rv); 965 966 SBD_SET_ERR(lep, ESBD_INTERNAL); 967 SBD_SET_ERRSTR(lep, sbp->sb_mempath[d]); 968 (void) sbd_set_err_in_hdl(hp, lep); 969 err_flag = -1; 970 break; 971 } 972 mp->sbm_flags |= SBD_MFLAG_RELOWNER; 973 974 if ((mq.nonrelocatable != 0) || 975 sbd_reserve_mem_spans(&mp->sbm_memhandle, ml)) { 976 /* 977 * Either the detaching memory node contains 978 * non-reloc memory or we failed to reserve the 979 * detaching memory node (which did _not_ have 980 * any non-reloc memory, i.e. some non-reloc mem 981 * got onboard). 982 */ 983 984 if (sbd_select_mem_target(hp, mp, ml)) { 985 int rv; 986 987 /* 988 * We had no luck locating a target 989 * memory node to be the recipient of 990 * the non-reloc memory on the node 991 * we're trying to detach. 992 * Clean up be disposing the mem handle 993 * and the mem list. 994 */ 995 rv = kphysm_del_release(mp->sbm_memhandle); 996 if (rv != KPHYSM_OK) { 997 /* 998 * can do nothing but complain 999 * and hope helpful for debug 1000 */ 1001 cmn_err(CE_WARN, "sbd:%s: unexpected" 1002 " kphysm_del_release return" 1003 " value %d", 1004 f, rv); 1005 } 1006 mp->sbm_flags &= ~SBD_MFLAG_RELOWNER; 1007 1008 memlist_delete(ml); 1009 1010 /* make sure sbm_flags is clean */ 1011 ASSERT(mp->sbm_flags == 0); 1012 1013 cmn_err(CE_WARN, 1014 "%s: no available target for " 1015 "mem-unit (%d.%d)", 1016 f, sbp->sb_num, 1017 mp->sbm_cm.sbdev_unum); 1018 1019 SBD_SET_ERR(lep, ESBD_NO_TARGET); 1020 SBD_SET_ERRSTR(lep, 1021 sbp->sb_mempath[mp->sbm_cm.sbdev_unum]); 1022 (void) sbd_set_err_in_hdl(hp, lep); 1023 1024 err_flag = -1; 1025 break; 1026 } 1027 1028 /* 1029 * ml is not memlist_deleted here because 1030 * it has been assigned to mp->sbm_mlist 1031 * by sbd_select_mem_target. 1032 */ 1033 } else { 1034 /* no target needed to detach this board */ 1035 mp->sbm_flags |= SBD_MFLAG_RESERVED; 1036 mp->sbm_peer = NULL; 1037 mp->sbm_del_mlist = ml; 1038 mp->sbm_mlist = ml; 1039 mp->sbm_cm.sbdev_busy = 1; 1040 } 1041 #ifdef DEBUG 1042 ASSERT(mp->sbm_mlist != NULL); 1043 1044 if (mp->sbm_flags & SBD_MFLAG_SOURCE) { 1045 int src, targ; 1046 1047 sbp = (sbd_board_t *) 1048 mp->sbm_peer->sbm_cm.sbdev_sbp; 1049 targ = sbp->sb_num; 1050 sbp = (sbd_board_t *)mp->sbm_cm.sbdev_sbp; 1051 src = sbp->sb_num; 1052 PR_MEM("%s: release of board %d requires copy/rename;" 1053 " selected target board %d\n", 1054 f, src, targ); 1055 } else { 1056 sbp = (sbd_board_t *)mp->sbm_cm.sbdev_sbp; 1057 PR_MEM("%s: copy/rename not required to release" 1058 " board %d\n", f, sbp->sb_num); 1059 } 1060 1061 ASSERT(mp->sbm_flags & SBD_MFLAG_RELOWNER); 1062 ASSERT(mp->sbm_flags & SBD_MFLAG_RESERVED); 1063 #endif 1064 } 1065 1066 return (err_flag); 1067 } 1068 1069 void 1070 sbd_release_mem_done(sbd_handle_t *hp, int unit) 1071 { 1072 sbd_mem_unit_t *s_mp, *t_mp, *mp; 1073 sbderror_t *ep = SBD_HD2ERR(hp); 1074 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 1075 int rv; 1076 static fn_t f = "sbd_release_mem_done"; 1077 1078 s_mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 1079 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 1080 1081 /* 1082 * This unit will be flagged with SBD_MFLAG_SOURCE, if it 1083 * has a target unit. 1084 */ 1085 if (s_mp->sbm_flags & SBD_MFLAG_SOURCE) { 1086 t_mp = s_mp->sbm_peer; 1087 ASSERT(t_mp != NULL); 1088 ASSERT(t_mp->sbm_peer == s_mp); 1089 ASSERT(t_mp->sbm_flags & SBD_MFLAG_TARGET); 1090 ASSERT(t_mp->sbm_flags & SBD_MFLAG_RESERVED); 1091 } else { 1092 /* this is no target unit */ 1093 t_mp = NULL; 1094 } 1095 1096 /* free delete handle */ 1097 ASSERT(s_mp->sbm_flags & SBD_MFLAG_RELOWNER); 1098 ASSERT(s_mp->sbm_flags & SBD_MFLAG_RESERVED); 1099 1100 rv = kphysm_del_release(s_mp->sbm_memhandle); 1101 if (rv != KPHYSM_OK) { 1102 /* 1103 * can do nothing but complain 1104 * and hope helpful for debug 1105 */ 1106 cmn_err(CE_WARN, "sbd:%s: unexpected kphysm_del_release" 1107 " return value %d", f, rv); 1108 } 1109 s_mp->sbm_flags &= ~SBD_MFLAG_RELOWNER; 1110 1111 /* 1112 * If an error was encountered during release, clean up 1113 * the source (and target, if present) unit data. 1114 */ 1115 if (SBD_GET_ERR(ep) != 0) { 1116 1117 PR_MEM("%s: unit %d.%d: error %d noted\n", 1118 f, sbp->sb_num, 1119 s_mp->sbm_cm.sbdev_unum, 1120 SBD_GET_ERR(ep)); 1121 1122 sbd_mem_cleanup(s_mp, t_mp, ep); 1123 1124 /* bail out */ 1125 return; 1126 } 1127 1128 SBD_DEV_SET_RELEASED(sbp, SBD_COMP_MEM, unit); 1129 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, unit, SBD_STATE_RELEASE); 1130 1131 if (t_mp != NULL) { 1132 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 1133 /* 1134 * the kphysm delete operation that drained the source 1135 * board also drained this target board. Since the source 1136 * board drain is now known to have succeeded, we know this 1137 * target board is drained too. 1138 */ 1139 SBD_DEV_SET_RELEASED(sbp, SBD_COMP_MEM, 1140 t_mp->sbm_cm.sbdev_unum); 1141 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, 1142 t_mp->sbm_cm.sbdev_unum, 1143 SBD_STATE_RELEASE); 1144 1145 /* 1146 * NOTE: do not transition target's board state, 1147 * even if the mem-unit was the last configure 1148 * unit of the board. When copy/rename completes 1149 * this mem-unit will transitioned back to 1150 * the configured state. In the meantime, the 1151 * board's must remain as is. 1152 */ 1153 } 1154 1155 /* if board(s) had deleted memory, verify it is gone */ 1156 rv = 0; 1157 memlist_read_lock(); 1158 if (s_mp->sbm_del_mlist != NULL) { 1159 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 1160 mp = s_mp; 1161 rv = memlist_intersect(phys_install, mp->sbm_del_mlist); 1162 } 1163 if (rv == 0 && t_mp && t_mp->sbm_del_mlist != NULL) { 1164 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 1165 mp = t_mp; 1166 rv = memlist_intersect(phys_install, mp->sbm_del_mlist); 1167 } 1168 memlist_read_unlock(); 1169 if (rv) { 1170 cmn_err(CE_WARN, "sbd:%s: %smem-unit (%d.%d): " 1171 "deleted memory still found in phys_install", 1172 f, 1173 (mp == t_mp ? "target " : ""), 1174 sbp->sb_num, 1175 mp->sbm_cm.sbdev_unum); 1176 1177 SBD_SET_ERR(ep, ESBD_INTERNAL); 1178 SBD_SET_ERRSTR(ep, sbp->sb_mempath[mp->sbm_cm.sbdev_unum]); 1179 return; 1180 } 1181 1182 s_mp->sbm_flags |= SBD_MFLAG_RELDONE; 1183 if (t_mp != NULL) { 1184 t_mp->sbm_flags &= ~SBD_MFLAG_RESERVED; 1185 t_mp->sbm_flags |= SBD_MFLAG_RELDONE; 1186 } 1187 1188 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 1189 1190 SBD_DEV_SET_UNREFERENCED(sbp, SBD_COMP_MEM, unit); 1191 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, unit, SBD_STATE_UNREFERENCED); 1192 1193 PR_MEM("%s: marking mem-unit (%d.%d) release DONE\n", 1194 f, sbp->sb_num, 1195 s_mp->sbm_cm.sbdev_unum); 1196 1197 s_mp->sbm_cm.sbdev_ostate = SBD_STAT_UNCONFIGURED; 1198 1199 if (t_mp != NULL) { 1200 sbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 1201 1202 SBD_DEV_SET_UNREFERENCED(sbp, SBD_COMP_MEM, 1203 t_mp->sbm_cm.sbdev_unum); 1204 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, 1205 t_mp->sbm_cm.sbdev_unum, 1206 SBD_STATE_UNREFERENCED); 1207 1208 sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 1209 1210 PR_MEM("%s: marking mem-unit (%d.%d) release DONE\n", 1211 f, sbp->sb_num, 1212 t_mp->sbm_cm.sbdev_unum); 1213 1214 t_mp->sbm_cm.sbdev_ostate = SBD_STAT_UNCONFIGURED; 1215 } 1216 } 1217 1218 int 1219 sbd_disconnect_mem(sbd_handle_t *hp, int unit) 1220 { 1221 static fn_t f = "sbd_disconnect_mem"; 1222 sbd_mem_unit_t *mp; 1223 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 1224 1225 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 1226 1227 ASSERT(mp->sbm_cm.sbdev_state == SBD_STATE_CONNECTED || 1228 mp->sbm_cm.sbdev_state == SBD_STATE_UNCONFIGURED); 1229 1230 PR_MEM("%s...\n", f); 1231 1232 if (mp->sbm_del_mlist && mp->sbm_del_mlist != mp->sbm_mlist) 1233 memlist_delete(mp->sbm_del_mlist); 1234 mp->sbm_del_mlist = NULL; 1235 1236 if (mp->sbm_mlist) { 1237 memlist_delete(mp->sbm_mlist); 1238 mp->sbm_mlist = NULL; 1239 } 1240 1241 return (0); 1242 } 1243 1244 int 1245 sbd_cancel_mem(sbd_handle_t *hp, int unit) 1246 { 1247 sbd_mem_unit_t *s_mp, *t_mp; 1248 sbd_istate_t state; 1249 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 1250 sbd_board_t *tsbp; 1251 static fn_t f = "sbd_cancel_mem"; 1252 sbderror_t *ep = SBD_HD2ERR(hp); 1253 1254 s_mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 1255 1256 state = s_mp->sbm_cm.sbdev_state; 1257 1258 if (s_mp->sbm_flags & SBD_MFLAG_TARGET) { 1259 /* must cancel source board, not target board */ 1260 SBD_SET_ERR(ep, ESBD_INTERNAL); 1261 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 1262 return (-1); 1263 } else if (s_mp->sbm_flags & SBD_MFLAG_SOURCE) { 1264 t_mp = s_mp->sbm_peer; 1265 tsbp = t_mp->sbm_cm.sbdev_sbp; 1266 ASSERT(t_mp != NULL); 1267 ASSERT(t_mp->sbm_peer == s_mp); 1268 1269 /* must always match the source board's state */ 1270 ASSERT(t_mp->sbm_cm.sbdev_state == state); 1271 } else { 1272 /* this is no target unit */ 1273 t_mp = NULL; 1274 } 1275 1276 switch (state) { 1277 case SBD_STATE_UNREFERENCED: /* state set by sbd_release_mem_done */ 1278 ASSERT((s_mp->sbm_flags & SBD_MFLAG_RELOWNER) == 0); 1279 1280 if (t_mp != NULL && t_mp->sbm_del_mlist != NULL) { 1281 PR_MEM("%s: undoing target board %d memory delete\n", 1282 f, tsbp->sb_num); 1283 sbd_add_memory_spans(tsbp, t_mp->sbm_del_mlist); 1284 SBD_DEV_CLR_UNREFERENCED(tsbp, SBD_COMP_MEM, 1285 t_mp->sbm_cm.sbdev_unum); 1286 } 1287 1288 if (s_mp->sbm_del_mlist != NULL) { 1289 PR_MEM("%s: undoing board %d memory delete\n", 1290 f, sbp->sb_num); 1291 sbd_add_memory_spans(sbp, s_mp->sbm_del_mlist); 1292 } 1293 1294 /*FALLTHROUGH*/ 1295 1296 case SBD_STATE_CONFIGURED: 1297 /* 1298 * we got here because of an error early in the release process 1299 * Just leave the memory as is and report the error 1300 */ 1301 1302 ASSERT((s_mp->sbm_flags & SBD_MFLAG_RELOWNER) == 0); 1303 1304 if (t_mp != NULL) { 1305 ASSERT(t_mp->sbm_del_mlist == t_mp->sbm_mlist); 1306 t_mp->sbm_del_mlist = NULL; 1307 1308 if (t_mp->sbm_mlist != NULL) { 1309 memlist_delete(t_mp->sbm_mlist); 1310 t_mp->sbm_mlist = NULL; 1311 } 1312 1313 t_mp->sbm_peer = NULL; 1314 t_mp->sbm_flags = 0; 1315 t_mp->sbm_cm.sbdev_busy = 0; 1316 sbd_init_mem_unit_data(t_mp, ep); 1317 1318 SBD_DEV_CLR_RELEASED(tsbp, SBD_COMP_MEM, 1319 t_mp->sbm_cm.sbdev_unum); 1320 1321 SBD_DEVICE_TRANSITION(tsbp, SBD_COMP_MEM, 1322 t_mp->sbm_cm.sbdev_unum, 1323 SBD_STATE_CONFIGURED); 1324 } 1325 1326 if (s_mp->sbm_del_mlist != s_mp->sbm_mlist) 1327 memlist_delete(s_mp->sbm_del_mlist); 1328 s_mp->sbm_del_mlist = NULL; 1329 1330 if (s_mp->sbm_mlist != NULL) { 1331 memlist_delete(s_mp->sbm_mlist); 1332 s_mp->sbm_mlist = NULL; 1333 } 1334 1335 s_mp->sbm_peer = NULL; 1336 s_mp->sbm_flags = 0; 1337 s_mp->sbm_cm.sbdev_busy = 0; 1338 sbd_init_mem_unit_data(s_mp, ep); 1339 1340 return (0); 1341 default: 1342 PR_MEM("%s: WARNING unexpected state (%d) for " 1343 "mem-unit %d.%d\n", 1344 f, 1345 (int)state, 1346 sbp->sb_num, 1347 s_mp->sbm_cm.sbdev_unum); 1348 1349 return (-1); 1350 } 1351 /*NOTREACHED*/ 1352 } 1353 1354 void 1355 sbd_init_mem_unit(sbd_board_t *sbp, int unit, sbderror_t *ep) 1356 { 1357 sbd_istate_t new_state; 1358 sbd_mem_unit_t *mp; 1359 dev_info_t *cur_mc_dip; 1360 int failed_mcs = 0, present_mcs = 0; 1361 sbd_cond_t mc_cond; 1362 int i; 1363 1364 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 1365 1366 if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_MEM, unit)) { 1367 new_state = SBD_STATE_CONFIGURED; 1368 } else if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, unit)) { 1369 new_state = SBD_STATE_CONNECTED; 1370 } else if (mp->sbm_cm.sbdev_dip != NULL) { 1371 new_state = SBD_STATE_OCCUPIED; 1372 } else { 1373 new_state = SBD_STATE_EMPTY; 1374 } 1375 1376 /* 1377 * Check all the possible memory nodes on the board. If all of them 1378 * have a failed status mark memory as failed. Otherwise mem is ok 1379 */ 1380 if (!sbp->sb_memaccess_ok) { 1381 mp->sbm_cm.sbdev_cond = SBD_COND_UNKNOWN; 1382 return; 1383 } 1384 1385 for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) { 1386 cur_mc_dip = mp->sbm_dip[i]; 1387 1388 if (cur_mc_dip == NULL) 1389 continue; 1390 1391 present_mcs |= (1 << i); 1392 1393 mc_cond = sbd_get_comp_cond(cur_mc_dip); 1394 if (mc_cond == SBD_COND_FAILED) { 1395 failed_mcs |= (1 << i); 1396 } 1397 } 1398 1399 if (failed_mcs == present_mcs) { 1400 /* 1401 * All mem nodes failed, therefore mark all mem 1402 * as failed 1403 */ 1404 mp->sbm_cm.sbdev_cond = SBD_COND_FAILED; 1405 } else { 1406 mp->sbm_cm.sbdev_cond = SBD_COND_OK; 1407 } 1408 1409 sbd_init_mem_unit_data(mp, ep); 1410 1411 /* 1412 * Any changes to this memory unit should be performed above 1413 * this call to ensure the unit is fully initialized 1414 * before transitioning to the new state. 1415 */ 1416 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, unit, new_state); 1417 1418 } 1419 1420 static void 1421 sbd_init_mem_unit_data(sbd_mem_unit_t *mp, sbderror_t *ep) 1422 { 1423 uint64_t basepa; 1424 uint64_t sz; 1425 sbd_board_t *sbp = mp->sbm_cm.sbdev_sbp; 1426 sbdp_handle_t *hdp; 1427 static fn_t f = "sbd_init_mem_unit_data"; 1428 sbd_handle_t *hp = MACHBD2HD(sbp); 1429 1430 PR_MEM("%s...\n", f); 1431 1432 /* a little sanity checking */ 1433 ASSERT(mp->sbm_peer == NULL); 1434 ASSERT(mp->sbm_flags == 0); 1435 1436 hdp = sbd_get_sbdp_handle(sbp, hp); 1437 1438 /* get basepfn of mem unit */ 1439 if (sbdphw_get_base_physaddr(hdp, mp->sbm_cm.sbdev_dip, &basepa)) { 1440 cmn_err(CE_WARN, "sbd:%s: failed to get physaddr" 1441 " for mem-unit (%d.%d)", 1442 f, 1443 sbp->sb_num, 1444 mp->sbm_cm.sbdev_unum); 1445 SBD_GET_PERR(hdp->h_err, ep); 1446 sbd_release_sbdp_handle(hdp); 1447 return; 1448 } 1449 mp->sbm_basepfn = _b64top(basepa); 1450 1451 /* attempt to get number of pages from PDA */ 1452 mp->sbm_npages = sbdp_get_mem_size(hdp); 1453 1454 /* if didn't work, calculate using memlist */ 1455 if (mp->sbm_npages == 0) { 1456 struct memlist *ml, *mlist; 1457 mlist = sbd_get_memlist(mp, ep); 1458 for (ml = mlist; ml; ml = ml->ml_next) 1459 mp->sbm_npages += btop(ml->ml_size); 1460 memlist_delete(mlist); 1461 } 1462 1463 1464 if (sbdp_get_mem_alignment(hdp, mp->sbm_cm.sbdev_dip, &sz)) { 1465 cmn_err(CE_WARN, 1466 "sbd:%s: no alignment for mem-unit (%d.%d)", 1467 f, sbp->sb_num, mp->sbm_cm.sbdev_unum); 1468 SBD_GET_PERR(hdp->h_err, ep); 1469 sbd_release_sbdp_handle(hdp); 1470 return; 1471 } 1472 mp->sbm_alignment_mask = _b64top(sz); 1473 1474 1475 mp->sbm_interleave = sbdp_isinterleaved(hdp, 1476 mp->sbm_cm.sbdev_dip); 1477 1478 PR_MEM("%s: board %d (basepfn = 0x%lx, npgs = 0x%lx interleave %d)\n", 1479 f, sbp->sb_num, 1480 mp->sbm_basepfn, 1481 mp->sbm_npages, 1482 mp->sbm_interleave); 1483 1484 sbd_release_sbdp_handle(hdp); 1485 } 1486 1487 static int 1488 sbd_reserve_mem_spans(memhandle_t *mhp, struct memlist *ml) 1489 { 1490 int err; 1491 pfn_t base; 1492 pgcnt_t npgs; 1493 struct memlist *mc; 1494 static fn_t f = "sbd_reserve_mem_spans"; 1495 1496 PR_MEM("%s...\n", f); 1497 1498 /* 1499 * Walk the supplied memlist scheduling each span for removal 1500 * with kphysm_del_span. It is possible that a span may intersect 1501 * an area occupied by the cage. 1502 */ 1503 for (mc = ml; mc != NULL; mc = mc->ml_next) { 1504 base = _b64top(mc->ml_address); 1505 npgs = _b64top(mc->ml_size); 1506 1507 err = kphysm_del_span(*mhp, base, npgs); 1508 if (err != KPHYSM_OK) { 1509 cmn_err(CE_WARN, "sbd:%s memory reserve failed." 1510 " unexpected kphysm_del_span return value %d;" 1511 " basepfn=0x%lx npages=%ld", 1512 f, err, base, npgs); 1513 return (-1); 1514 } 1515 } 1516 return (0); 1517 } 1518 1519 /* debug counters */ 1520 int sbd_smt_realigned; 1521 int sbd_smt_preference[4]; 1522 1523 #ifdef DEBUG 1524 uint_t sbd_ignore_board; /* if bit[bnum-1] set, board won't be candidate */ 1525 #endif 1526 1527 /* 1528 * Verify that there is no memory overlapping if copy-rename is 1529 * done with the selected target board. 1530 * 1531 * Returns 0 if OK, -1 otherwise. 1532 */ 1533 static int 1534 sbd_check_boundaries(struct memlist *orig_memlist, sbd_mem_unit_t *s_mp, 1535 sbd_mem_unit_t *t_mp) 1536 { 1537 struct memlist *new_memlist; 1538 int mlret; 1539 static fn_t f = "sbd_check_boundaries"; 1540 1541 new_memlist = memlist_dup(orig_memlist); 1542 if (new_memlist == NULL) { 1543 PR_MEM("%s: can't dup original memlist\n", f); 1544 return (-1); 1545 } 1546 1547 mlret = memlist_delete_span( 1548 _ptob64(s_mp->sbm_basepfn), 1549 _ptob64(s_mp->sbm_npages), 1550 &new_memlist); 1551 if (mlret != MEML_SPANOP_OK) { 1552 PR_MEM("%s: del s/s mlret = %d\n", f, mlret); 1553 goto check_done; 1554 } 1555 1556 mlret = memlist_delete_span( 1557 _ptob64(t_mp->sbm_basepfn), 1558 _ptob64(t_mp->sbm_npages), 1559 &new_memlist); 1560 if (mlret != MEML_SPANOP_OK) { 1561 PR_MEM("%s: del t/t mlret = %d\n", f, mlret); 1562 goto check_done; 1563 } 1564 1565 mlret = memlist_add_span( 1566 _ptob64(t_mp->sbm_basepfn), 1567 _ptob64(s_mp->sbm_npages), 1568 &new_memlist); 1569 if (mlret != MEML_SPANOP_OK) { 1570 PR_MEM("%s: add t/s mlret = %d\n", f, mlret); 1571 goto check_done; 1572 } 1573 1574 mlret = memlist_add_span( 1575 _ptob64(s_mp->sbm_basepfn), 1576 _ptob64(t_mp->sbm_npages), 1577 &new_memlist); 1578 if (mlret != MEML_SPANOP_OK) { 1579 PR_MEM("%s: add s/t mlret = %d\n", f, mlret); 1580 } 1581 1582 check_done: 1583 memlist_delete(new_memlist); 1584 1585 if (mlret == MEML_SPANOP_OK) 1586 return (0); 1587 else 1588 return (-1); 1589 } 1590 1591 /* 1592 * Find and reserve a copy/rename target board suitable for the 1593 * given source board. 1594 * All boards in the system are examined and categorized in relation to 1595 * their memory size versus the source board's memory size. Order of 1596 * preference is: 1597 * 1st: board has same memory size 1598 * 2nd: board has larger memory size 1599 * 3rd: board has smaller memory size 1600 * 4th: board has smaller memory size, available memory will be reduced. 1601 * Boards in category 3 and 4 will have their MC's reprogrammed to locate the 1602 * span to which the MC responds to address span that appropriately covers 1603 * the nonrelocatable span of the source board. 1604 */ 1605 static int 1606 sbd_select_mem_target(sbd_handle_t *hp, 1607 sbd_mem_unit_t *s_mp, struct memlist *s_ml) 1608 { 1609 uint64_t sz; 1610 pgcnt_t sm; 1611 int n_sets = 4; /* same, larger, smaller, clipped */ 1612 int preference; /* lower value is higher preference */ 1613 int n_units_per_set; 1614 int idx; 1615 sbd_mem_unit_t **sets; 1616 sbdp_handle_t *hdp; 1617 int t_bd; 1618 sbd_softstate_t *softsp; 1619 int t_unit; 1620 int max_boards; 1621 int rv; 1622 sbd_board_t *s_sbp, *t_sbp; 1623 sbd_mem_unit_t *t_mp, *c_mp; 1624 struct memlist *d_ml, *t_ml, *x_ml; 1625 memquery_t s_mq = {0}; 1626 static fn_t f = "sbd_select_mem_target"; 1627 1628 PR_MEM("%s...\n", f); 1629 1630 ASSERT(s_ml != NULL); 1631 1632 s_sbp = s_mp->sbm_cm.sbdev_sbp; 1633 1634 hdp = sbd_get_sbdp_handle(s_sbp, hp); 1635 1636 if (sbdp_get_mem_alignment(hdp, s_mp->sbm_cm.sbdev_dip, &sz)) { 1637 sbderror_t *ep = SBD_HD2ERR(hp); 1638 cmn_err(CE_WARN, 1639 "sbd:%s: no alignment for mem-unit (%d.%d)", 1640 f, s_sbp->sb_num, s_mp->sbm_cm.sbdev_unum); 1641 SBD_GET_PERR(hdp->h_err, ep); 1642 sbd_release_sbdp_handle(hdp); 1643 return (-1); 1644 } 1645 sm = sz - 1; 1646 sbd_release_sbdp_handle(hdp); 1647 1648 softsp = (sbd_softstate_t *)s_sbp->sb_softsp; 1649 1650 max_boards = softsp->max_boards; 1651 n_units_per_set = max_boards * MAX_MEM_UNITS_PER_BOARD; 1652 sets = GETSTRUCT(sbd_mem_unit_t *, n_units_per_set * n_sets); 1653 1654 /* 1655 * Make one pass through all memory units on all boards 1656 * and categorize them with respect to the source board. 1657 */ 1658 for (t_bd = 0; t_bd < max_boards; t_bd++) { 1659 /* 1660 * The board structs are a contiguous array 1661 * so we take advantage of that to find the 1662 * correct board struct pointer for a given 1663 * board number. 1664 */ 1665 t_sbp = (sbd_board_t *)softsp->sbd_boardlist; 1666 t_sbp += t_bd; 1667 1668 /* source board can not be its own target */ 1669 if (s_sbp->sb_num == t_sbp->sb_num) 1670 continue; 1671 1672 for (t_unit = 0; t_unit < MAX_MEM_UNITS_PER_BOARD; t_unit++) { 1673 1674 t_mp = SBD_GET_BOARD_MEMUNIT(t_sbp, t_unit); 1675 1676 /* this memory node must be attached */ 1677 if (!SBD_DEV_IS_ATTACHED(t_sbp, SBD_COMP_MEM, t_unit)) 1678 continue; 1679 1680 /* source unit can not be its own target */ 1681 if (s_mp == t_mp) { 1682 /* catch this in debug kernels */ 1683 ASSERT(0); 1684 continue; 1685 } 1686 1687 /* 1688 * this memory node must not already be reserved 1689 * by some other memory delete operation. 1690 */ 1691 if (t_mp->sbm_flags & SBD_MFLAG_RESERVED) 1692 continue; 1693 1694 /* 1695 * categorize the memory node 1696 * If this is a smaller memory node, create a 1697 * temporary, edited copy of the source board's 1698 * memlist containing only the span of the non- 1699 * relocatable pages. 1700 */ 1701 if (t_mp->sbm_npages == s_mp->sbm_npages) { 1702 preference = 0; 1703 t_mp->sbm_slice_offset = 0; 1704 } else if (t_mp->sbm_npages > s_mp->sbm_npages) { 1705 preference = 1; 1706 t_mp->sbm_slice_offset = 0; 1707 } else { 1708 /* 1709 * We do not allow other options right now 1710 */ 1711 continue; 1712 } 1713 1714 sbd_smt_preference[preference]++; 1715 1716 /* calculate index to start of preference set */ 1717 idx = n_units_per_set * preference; 1718 /* calculate offset to respective element */ 1719 idx += t_bd * MAX_MEM_UNITS_PER_BOARD + t_unit; 1720 1721 ASSERT(idx < n_units_per_set * n_sets); 1722 sets[idx] = t_mp; 1723 } 1724 } 1725 1726 /* 1727 * NOTE: this would be a good place to sort each candidate 1728 * set in to some desired order, e.g. memory size in ascending 1729 * order. Without an additional sorting step here, the order 1730 * within a set is ascending board number order. 1731 */ 1732 1733 c_mp = NULL; 1734 x_ml = NULL; 1735 t_ml = NULL; 1736 for (idx = 0; idx < n_units_per_set * n_sets; idx++) { 1737 memquery_t mq; 1738 1739 /* cleanup t_ml after previous pass */ 1740 if (t_ml != NULL) { 1741 memlist_delete(t_ml); 1742 t_ml = NULL; 1743 } 1744 1745 /* get candidate target board mem unit */ 1746 t_mp = sets[idx]; 1747 if (t_mp == NULL) 1748 continue; 1749 1750 t_sbp = t_mp->sbm_cm.sbdev_sbp; 1751 1752 /* get target board memlist */ 1753 t_ml = sbd_get_memlist(t_mp, SBD_HD2ERR(hp)); 1754 if (t_ml == NULL) { 1755 cmn_err(CE_WARN, "sbd:%s: no memlist for" 1756 " mem-unit %d, board %d", 1757 f, 1758 t_sbp->sb_num, 1759 t_mp->sbm_cm.sbdev_unum); 1760 1761 continue; 1762 } 1763 1764 /* get appropriate source board memlist */ 1765 if (t_mp->sbm_npages < s_mp->sbm_npages) { 1766 spgcnt_t excess; 1767 1768 /* 1769 * make a copy of the source board memlist 1770 * then edit it to remove the spans that 1771 * are outside the calculated span of 1772 * [pfn..s_mq.last_nonrelocatable]. 1773 */ 1774 if (x_ml != NULL) 1775 memlist_delete(x_ml); 1776 1777 x_ml = memlist_dup(s_ml); 1778 if (x_ml == NULL) { 1779 PR_MEM("%s: memlist_dup failed\n", f); 1780 /* TODO: should abort */ 1781 continue; 1782 } 1783 1784 /* trim off lower portion */ 1785 excess = t_mp->sbm_slice_offset; 1786 if (excess > 0) { 1787 int mlret; 1788 1789 mlret = memlist_delete_span( 1790 _ptob64(s_mp->sbm_basepfn), 1791 _ptob64(excess), 1792 &x_ml); 1793 PR_MEM("%s: mlret = %d\n", f, mlret); 1794 } 1795 1796 /* 1797 * Since this candidate target board is smaller 1798 * than the source board, s_mq must have been 1799 * initialized in previous loop while processing 1800 * this or some other candidate board. 1801 * FIXME: this is weak. 1802 */ 1803 ASSERT(s_mq.phys_pages != 0); 1804 1805 /* trim off upper portion */ 1806 excess = (s_mp->sbm_basepfn + s_mp->sbm_npages) 1807 - (s_mq.last_nonrelocatable + 1); 1808 if (excess > 0) { 1809 pfn_t p; 1810 int mlret; 1811 1812 p = s_mq.last_nonrelocatable + 1; 1813 p -= excess; 1814 1815 mlret = memlist_delete_span( 1816 _ptob64(p), 1817 _ptob64(excess), 1818 &x_ml); 1819 PR_MEM("%s: mlret = %d\n", f, mlret); 1820 } 1821 1822 PR_MEM("%s: brd %d: edited source memlist:\n", 1823 f, s_sbp->sb_num); 1824 SBD_MEMLIST_DUMP(x_ml); 1825 1826 #ifdef DEBUG 1827 /* sanity check memlist */ 1828 d_ml = x_ml; 1829 while (d_ml->ml_next != NULL) 1830 d_ml = d_ml->ml_next; 1831 ASSERT(x_ml->ml_address == _ptob64(s_mp->sbm_basepfn) + 1832 _ptob64(t_mp->sbm_slice_offset)); 1833 ASSERT(d_ml->ml_address + d_ml->ml_size == 1834 _ptob64(s_mq.last_nonrelocatable + 1)); 1835 #endif 1836 1837 /* 1838 * x_ml now describes only the portion of the 1839 * source board that will be moved during the 1840 * copy/rename operation. 1841 */ 1842 d_ml = x_ml; 1843 } else { 1844 /* use original memlist; all spans will be moved */ 1845 d_ml = s_ml; 1846 } 1847 1848 /* verify target can support source memory spans. */ 1849 if (memlist_canfit(d_ml, t_ml) == 0) { 1850 PR_MEM("%s: source memlist won't" 1851 " fit in target memlist\n", f); 1852 PR_MEM("%s: source memlist:\n", f); 1853 SBD_MEMLIST_DUMP(d_ml); 1854 PR_MEM("%s: target memlist:\n", f); 1855 SBD_MEMLIST_DUMP(t_ml); 1856 1857 continue; 1858 } 1859 1860 /* NOTE: the value of d_ml is not used beyond this point */ 1861 1862 PR_MEM("%s: checking for no-reloc on board %d, " 1863 " basepfn=0x%lx, npages=%ld\n", 1864 f, 1865 t_sbp->sb_num, 1866 t_mp->sbm_basepfn, 1867 t_mp->sbm_npages); 1868 1869 rv = kphysm_del_span_query( 1870 t_mp->sbm_basepfn, t_mp->sbm_npages, &mq); 1871 if (rv != KPHYSM_OK) { 1872 PR_MEM("%s: kphysm_del_span_query:" 1873 " unexpected return value %d\n", f, rv); 1874 1875 continue; 1876 } 1877 1878 if (mq.nonrelocatable != 0) { 1879 PR_MEM("%s: candidate board %d has" 1880 " nonrelocatable span [0x%lx..0x%lx]\n", 1881 f, 1882 t_sbp->sb_num, 1883 mq.first_nonrelocatable, 1884 mq.last_nonrelocatable); 1885 1886 continue; 1887 } 1888 1889 #ifdef DEBUG 1890 /* 1891 * This is a debug tool for excluding certain boards 1892 * from being selected as a target board candidate. 1893 * sbd_ignore_board is only tested by this driver. 1894 * It must be set with adb, obp, /etc/system or your 1895 * favorite debugger. 1896 */ 1897 if (sbd_ignore_board & 1898 (1 << (t_sbp->sb_num - 1))) { 1899 PR_MEM("%s: sbd_ignore_board flag set," 1900 " ignoring board %d as candidate\n", 1901 f, t_sbp->sb_num); 1902 continue; 1903 } 1904 #endif 1905 1906 /* 1907 * Make sure there is no memory overlap if this 1908 * target board is used for copy-rename. 1909 */ 1910 if (sbd_check_boundaries(phys_install, s_mp, t_mp) != 0) 1911 continue; 1912 1913 /* 1914 * Reserve excess source board memory, if any. 1915 * 1916 * When the number of pages on the candidate target 1917 * board is less than the number of pages on the source, 1918 * then some spans (clearly) of the source board's address 1919 * space will not be covered by physical memory after the 1920 * copy/rename completes. The following code block 1921 * schedules those spans to be deleted. 1922 */ 1923 if (t_mp->sbm_npages < s_mp->sbm_npages) { 1924 pfn_t pfn; 1925 int mlret; 1926 1927 d_ml = memlist_dup(s_ml); 1928 if (d_ml == NULL) { 1929 PR_MEM("%s: cant dup src brd memlist\n", f); 1930 /* TODO: should abort */ 1931 continue; 1932 } 1933 1934 /* calculate base pfn relative to target board */ 1935 pfn = s_mp->sbm_basepfn & ~sm; 1936 pfn += t_mp->sbm_slice_offset; 1937 1938 /* remove span that will reside on candidate board */ 1939 mlret = memlist_delete_span( 1940 _ptob64(pfn), 1941 _ptob64(t_mp->sbm_npages), 1942 &d_ml); 1943 PR_MEM("%s: mlret = %d\n", f, mlret); 1944 1945 PR_MEM("%s: brd %d: reserving src brd memlist:\n", 1946 f, s_sbp->sb_num); 1947 SBD_MEMLIST_DUMP(d_ml); 1948 1949 /* reserve excess spans */ 1950 if (sbd_reserve_mem_spans( 1951 &s_mp->sbm_memhandle, d_ml) != 0) { 1952 1953 /* likely more non-reloc pages appeared */ 1954 /* TODO: restart from top? */ 1955 continue; 1956 } 1957 } else { 1958 /* no excess source board memory */ 1959 d_ml = NULL; 1960 } 1961 1962 s_mp->sbm_flags |= SBD_MFLAG_RESERVED; 1963 1964 /* 1965 * reserve all memory on target board. 1966 * NOTE: source board's memhandle is used. 1967 * 1968 * If this succeeds (eq 0), then target selection is 1969 * complete and all unwanted memory spans, both source and 1970 * target, have been reserved. Loop is terminated. 1971 */ 1972 if (sbd_reserve_mem_spans(&s_mp->sbm_memhandle, t_ml) == 0) { 1973 PR_MEM("%s: brd %d: target board memory reserved\n", 1974 f, t_sbp->sb_num); 1975 1976 /* a candidate target board is now reserved */ 1977 t_mp->sbm_flags |= SBD_MFLAG_RESERVED; 1978 c_mp = t_mp; 1979 1980 /* *** EXITING LOOP *** */ 1981 break; 1982 } 1983 1984 /* did not successfully reserve the target board. */ 1985 PR_MEM("%s: could not reserve target board %d\n", 1986 f, t_sbp->sb_num); 1987 1988 /* 1989 * NOTE: an undo of the sbd_reserve_mem_span work 1990 * will happen automatically when the memhandle 1991 * (s_mp->sbm_memhandle) is kphysm_del_release'd. 1992 */ 1993 1994 s_mp->sbm_flags &= ~SBD_MFLAG_RESERVED; 1995 } 1996 1997 /* clean up after memlist editing logic */ 1998 if (x_ml != NULL) 1999 memlist_delete(x_ml); 2000 2001 FREESTRUCT(sets, sbd_mem_unit_t *, n_units_per_set * n_sets); 2002 2003 /* 2004 * c_mp will be NULL when the entire sets[] array 2005 * has been searched without reserving a target board. 2006 */ 2007 if (c_mp == NULL) { 2008 PR_MEM("%s: brd %d: target selection failed.\n", 2009 f, s_sbp->sb_num); 2010 2011 if (t_ml != NULL) 2012 memlist_delete(t_ml); 2013 2014 return (-1); 2015 } 2016 2017 PR_MEM("%s: found target board %d for source board %d\n", 2018 f, 2019 t_sbp->sb_num, 2020 s_sbp->sb_num); 2021 2022 s_mp->sbm_peer = c_mp; 2023 s_mp->sbm_flags |= SBD_MFLAG_SOURCE; 2024 s_mp->sbm_del_mlist = d_ml; /* spans to be deleted, if any */ 2025 s_mp->sbm_mlist = s_ml; 2026 s_mp->sbm_cm.sbdev_busy = 1; 2027 2028 c_mp->sbm_peer = s_mp; 2029 c_mp->sbm_flags |= SBD_MFLAG_TARGET; 2030 c_mp->sbm_del_mlist = t_ml; /* spans to be deleted */ 2031 c_mp->sbm_mlist = t_ml; 2032 c_mp->sbm_cm.sbdev_busy = 1; 2033 2034 s_mp->sbm_flags &= ~SBD_MFLAG_MEMRESIZE; 2035 if (c_mp->sbm_npages > s_mp->sbm_npages) { 2036 s_mp->sbm_flags |= SBD_MFLAG_MEMUPSIZE; 2037 PR_MEM("%s: upsize (source pgs 0x%lx < target pgs 0x%lx)\n", 2038 f, s_mp->sbm_npages, c_mp->sbm_npages); 2039 } else if (c_mp->sbm_npages < s_mp->sbm_npages) { 2040 s_mp->sbm_flags |= SBD_MFLAG_MEMDOWNSIZE; 2041 PR_MEM("%s: downsize (source pgs 0x%lx > target pgs 0x%lx)\n", 2042 f, s_mp->sbm_npages, c_mp->sbm_npages); 2043 } 2044 2045 return (0); 2046 } 2047 2048 int 2049 sbd_move_memory(sbd_handle_t *hp, sbd_board_t *s_bp, sbd_board_t *t_bp) 2050 { 2051 int ret; 2052 sbdp_handle_t *hdp; 2053 sbderror_t *ep = SBD_HD2ERR(hp); 2054 2055 hdp = sbd_get_sbdp_handle(s_bp, hp); 2056 2057 ret = sbdp_move_memory(hdp, t_bp->sb_num); 2058 if (ret != 0) 2059 SBD_GET_PERR(hdp->h_err, ep); 2060 2061 sbd_release_sbdp_handle(hdp); 2062 2063 return (ret); 2064 } 2065 2066 /* 2067 * Memlist support. 2068 */ 2069 void 2070 memlist_delete(struct memlist *mlist) 2071 { 2072 sbdp_handle_t *hdp; 2073 2074 hdp = sbd_get_sbdp_handle(NULL, NULL); 2075 2076 (void) sbdp_del_memlist(hdp, mlist); 2077 2078 sbd_release_sbdp_handle(hdp); 2079 } 2080 2081 struct memlist * 2082 memlist_dup(struct memlist *mlist) 2083 { 2084 struct memlist *hl, *prev; 2085 2086 if (mlist == NULL) 2087 return (NULL); 2088 2089 prev = NULL; 2090 hl = NULL; 2091 for (; mlist; mlist = mlist->ml_next) { 2092 struct memlist *mp; 2093 2094 mp = memlist_get_one(); 2095 if (mp == NULL) { 2096 if (hl != NULL) 2097 memlist_free_list(hl); 2098 hl = NULL; 2099 break; 2100 } 2101 mp->ml_address = mlist->ml_address; 2102 mp->ml_size = mlist->ml_size; 2103 mp->ml_next = NULL; 2104 mp->ml_prev = prev; 2105 2106 if (prev == NULL) 2107 hl = mp; 2108 else 2109 prev->ml_next = mp; 2110 prev = mp; 2111 } 2112 2113 return (hl); 2114 } 2115 2116 void 2117 memlist_dump(struct memlist *mlist) 2118 { 2119 register struct memlist *ml; 2120 2121 if (mlist == NULL) { 2122 PR_MEM("memlist> EMPTY\n"); 2123 } else { 2124 for (ml = mlist; ml; ml = ml->ml_next) 2125 PR_MEM("memlist> 0x%" PRIx64 " " 2126 "0x%" PRIx64 " \n", 2127 ml->ml_address, ml->ml_size); 2128 } 2129 } 2130 2131 int 2132 memlist_intersect(struct memlist *al, struct memlist *bl) 2133 { 2134 uint64_t astart, aend, bstart, bend; 2135 2136 if ((al == NULL) || (bl == NULL)) 2137 return (0); 2138 2139 aend = al->ml_address + al->ml_size; 2140 bstart = bl->ml_address; 2141 bend = bl->ml_address + bl->ml_size; 2142 2143 while (al && bl) { 2144 while (al && (aend <= bstart)) 2145 if ((al = al->ml_next) != NULL) 2146 aend = al->ml_address + al->ml_size; 2147 if (al == NULL) 2148 return (0); 2149 2150 if ((astart = al->ml_address) <= bstart) 2151 return (1); 2152 2153 while (bl && (bend <= astart)) 2154 if ((bl = bl->ml_next) != NULL) 2155 bend = bl->ml_address + bl->ml_size; 2156 if (bl == NULL) 2157 return (0); 2158 2159 if ((bstart = bl->ml_address) <= astart) 2160 return (1); 2161 } 2162 2163 return (0); 2164 } 2165 2166 /* 2167 * Determine whether the source memlist (s_mlist) will 2168 * fit into the target memlist (t_mlist) in terms of 2169 * size and holes (i.e. based on same relative base address). 2170 */ 2171 static int 2172 memlist_canfit(struct memlist *s_mlist, struct memlist *t_mlist) 2173 { 2174 int rv = 0; 2175 uint64_t s_basepa, t_basepa; 2176 struct memlist *s_ml, *t_ml; 2177 2178 if ((s_mlist == NULL) || (t_mlist == NULL)) 2179 return (0); 2180 2181 /* 2182 * Base both memlists on common base address (0). 2183 */ 2184 s_basepa = s_mlist->ml_address; 2185 t_basepa = t_mlist->ml_address; 2186 2187 for (s_ml = s_mlist; s_ml; s_ml = s_ml->ml_next) 2188 s_ml->ml_address -= s_basepa; 2189 2190 for (t_ml = t_mlist; t_ml; t_ml = t_ml->ml_next) 2191 t_ml->ml_address -= t_basepa; 2192 2193 s_ml = s_mlist; 2194 for (t_ml = t_mlist; t_ml && s_ml; t_ml = t_ml->ml_next) { 2195 uint64_t s_start, s_end; 2196 uint64_t t_start, t_end; 2197 2198 t_start = t_ml->ml_address; 2199 t_end = t_start + t_ml->ml_size; 2200 2201 for (; s_ml; s_ml = s_ml->ml_next) { 2202 s_start = s_ml->ml_address; 2203 s_end = s_start + s_ml->ml_size; 2204 2205 if ((s_start < t_start) || (s_end > t_end)) 2206 break; 2207 } 2208 } 2209 /* 2210 * If we ran out of source memlist chunks that mean 2211 * we found a home for all of them. 2212 */ 2213 if (s_ml == NULL) 2214 rv = 1; 2215 2216 /* 2217 * Need to add base addresses back since memlists 2218 * are probably in use by caller. 2219 */ 2220 for (s_ml = s_mlist; s_ml; s_ml = s_ml->ml_next) 2221 s_ml->ml_address += s_basepa; 2222 2223 for (t_ml = t_mlist; t_ml; t_ml = t_ml->ml_next) 2224 t_ml->ml_address += t_basepa; 2225 2226 return (rv); 2227 } 2228 2229 void 2230 sbd_attach_mem(sbd_handle_t *hp, sbderror_t *ep) 2231 { 2232 sbd_mem_unit_t *mp; 2233 dev_info_t *dip; 2234 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 2235 sbdp_handle_t *hdp; 2236 int err, unit; 2237 struct memlist *ml, *mc; 2238 static fn_t f = "sbd_attach_mem"; 2239 int i; 2240 2241 PR_MEM("%s...\n", f); 2242 2243 /* 2244 * all four cpus have to be attached before 2245 * configuring mem 2246 */ 2247 for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) { 2248 sbd_cpu_unit_t *cpup; 2249 struct cpu *cp; 2250 2251 if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, i)) 2252 continue; 2253 2254 if (!SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_CPU, i)) 2255 goto error; 2256 2257 cpup = SBD_GET_BOARD_CPUUNIT(sbp, i); 2258 2259 if (cpup == NULL) 2260 goto error; 2261 2262 mutex_enter(&cpu_lock); 2263 cp = cpu_get(cpup->sbc_cpu_id); 2264 if (cp == NULL) { 2265 mutex_exit(&cpu_lock); 2266 cmn_err(CE_WARN, 2267 "sbd:%s: cpu_get failed for cpu %d", 2268 f, cpup->sbc_cpu_id); 2269 goto error; 2270 } 2271 if (cpu_is_poweredoff(cp)) { 2272 mutex_exit(&cpu_lock); 2273 goto error; 2274 } 2275 mutex_exit(&cpu_lock); 2276 continue; 2277 2278 error: 2279 SBD_SET_ERR(ep, ESBD_CPUONLINE); 2280 SBD_SET_ERRSTR(ep, sbp->sb_mempath[i]); 2281 (void) sbd_set_err_in_hdl(hp, ep); 2282 return; 2283 } 2284 2285 dip = *(sbp->sb_devlist[NIX(SBD_COMP_MEM)]); 2286 2287 hdp = sbd_get_sbdp_handle(sbp, hp); 2288 unit = sbdp_get_unit_num(hdp, dip); 2289 if (unit < 0) { 2290 SBD_GET_PERR(hdp->h_err, ep); 2291 sbd_release_sbdp_handle(hdp); 2292 return; 2293 } 2294 2295 ASSERT(sbp->sb_mempath[unit] != NULL); 2296 ASSERT(e_ddi_branch_held(dip)); 2297 2298 (void) ddi_pathname(dip, sbp->sb_mempath[unit]); 2299 2300 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit); 2301 2302 ml = sbd_get_memlist(mp, ep); 2303 if (ml == NULL) { 2304 cmn_err(CE_WARN, 2305 "sbd:%s: failed to get memlist for " 2306 "board %d", f, sbp->sb_num); 2307 /* 2308 * Need to record an error and return. 2309 */ 2310 SBD_SET_ERR(ep, ESBD_MEMFAIL); 2311 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2312 sbd_release_sbdp_handle(hdp); 2313 return; 2314 } 2315 2316 SBD_MEMLIST_DUMP(ml); 2317 err = 0; 2318 for (mc = ml; mc; mc = mc->ml_next) { 2319 update_membounds_t umb; 2320 pfn_t base; 2321 pgcnt_t npgs; 2322 2323 base = (pfn_t)(mc->ml_address >> PAGESHIFT); 2324 npgs = (pgcnt_t)(mc->ml_size >> PAGESHIFT); 2325 2326 umb.u_board = sbp->sb_num; 2327 umb.u_base = (uint64_t)base << MMU_PAGESHIFT; 2328 umb.u_len = (uint64_t)npgs << MMU_PAGESHIFT; 2329 2330 lgrp_plat_config(LGRP_CONFIG_MEM_ADD, (uintptr_t)&umb); 2331 err = kphysm_add_memory_dynamic(base, npgs); 2332 2333 if (err != KPHYSM_OK) { 2334 cmn_err(CE_WARN, 2335 "%s: kphysm_add_memory_dynamic fail %d", f, err); 2336 2337 /* translate kphysm error */ 2338 switch (err) { 2339 case KPHYSM_ERESOURCE: 2340 err = ESBD_NOMEM; 2341 break; 2342 2343 case KPHYSM_EFAULT: 2344 err = ESBD_FAULT; 2345 break; 2346 2347 default: 2348 err = ESBD_INVAL; 2349 break; 2350 } 2351 break; 2352 } 2353 2354 err = kcage_range_add(base, npgs, KCAGE_DOWN); 2355 if (err != 0) { 2356 cmn_err(CE_WARN, 2357 "%s: kcage_range_add fail %d", f, err); 2358 2359 /* Translate kcage error. */ 2360 switch (err) { 2361 case ENOMEM: 2362 err = ESBD_NOMEM; 2363 break; 2364 default: 2365 err = ESBD_INVAL; 2366 break; 2367 } 2368 break; 2369 } 2370 (void) sbdp_mem_add_span(hdp, mc->ml_address, mc->ml_size); 2371 } 2372 2373 if (err != 0) { 2374 SBD_SET_ERR(ep, err); 2375 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2376 } 2377 2378 memlist_delete(ml); 2379 sbd_release_sbdp_handle(hdp); 2380 2381 /* 2382 * Now attach all mem devinfo nodes to the device tree. 2383 */ 2384 for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) { 2385 if (mp->sbm_dip[i] == NULL) 2386 continue; 2387 ASSERT(e_ddi_branch_held(mp->sbm_dip[i])); 2388 if (e_ddi_branch_configure(mp->sbm_dip[i], NULL, 0) && 2389 SBD_GET_ERR(ep) == 0) { 2390 SBD_SET_ERR(ep, ESBD_INVAL); 2391 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2392 } 2393 } 2394 } 2395 2396 typedef struct { 2397 kcondvar_t cond; 2398 kmutex_t lock; 2399 int error; 2400 int done; 2401 } sbd_release_mem_sync_t; 2402 2403 /* 2404 * When we reach here the memory being drained should have 2405 * already been reserved in sbd_pre_release_mem(). 2406 * Our only task here is to kick off the "drain". 2407 * Returns -1 when error encountered or zero for success. 2408 */ 2409 int 2410 sbd_release_mem(sbd_handle_t *hp, dev_info_t *dip, int unit) 2411 { 2412 memhandle_t mh; 2413 int err; 2414 int cancel_flag = 0; 2415 int e_code = 0; 2416 sbd_board_t *sbp = SBDH2BD(hp->h_sbd); 2417 sbd_release_mem_sync_t rms; 2418 static fn_t f = "sbd_release_mem"; 2419 2420 /* 2421 * If this node has a scheduled memory delete operation, 2422 * it will have a memhandle. If it does have a memhandle (the 2423 * return value of sbd_get_memhandle is zero when true), 2424 * then perform the delete. 2425 */ 2426 2427 if ((cancel_flag = sbd_get_memhandle(hp, dip, &mh)) != 0) { 2428 cmn_err(CE_WARN, "%s: couldn't get the memhandle\n", f); 2429 return (cancel_flag); 2430 } 2431 2432 bzero((void *) &rms, sizeof (rms)); 2433 2434 mutex_init(&rms.lock, NULL, MUTEX_DRIVER, NULL); 2435 cv_init(&rms.cond, NULL, CV_DRIVER, NULL); 2436 2437 mutex_enter(&rms.lock); 2438 err = kphysm_del_start(mh, sbd_release_memory_done, (void *) &rms); 2439 if (err == KPHYSM_OK) { 2440 /* wait for completion */ 2441 while (!rms.done) { 2442 if (cancel_flag) { 2443 /* previously canceled */ 2444 cv_wait(&rms.cond, &rms.lock); 2445 } else if (cv_wait_sig(&rms.cond, &rms.lock) == 0) { 2446 /* interrupted: cancel and wait */ 2447 cancel_flag = -1; 2448 (void) kphysm_del_cancel(mh); 2449 } 2450 } 2451 /* get the result of the memory delete operation */ 2452 err = rms.error; 2453 } else { 2454 (void) kphysm_del_release(mh); 2455 } 2456 2457 mutex_exit(&rms.lock); 2458 2459 cv_destroy(&rms.cond); 2460 mutex_destroy(&rms.lock); 2461 2462 if (err != KPHYSM_OK) { 2463 switch (err) { 2464 case KPHYSM_ENOWORK: 2465 e_code = ESBD_NOERROR; 2466 break; 2467 2468 case KPHYSM_EHANDLE: 2469 case KPHYSM_ESEQUENCE: 2470 e_code = ESBD_INTERNAL; 2471 break; 2472 2473 case KPHYSM_ENOTVIABLE: 2474 e_code = ESBD_MEM_NOTVIABLE; 2475 break; 2476 2477 case KPHYSM_EREFUSED: 2478 e_code = ESBD_MEM_REFUSED; 2479 break; 2480 2481 case KPHYSM_ENONRELOC: 2482 e_code = ESBD_MEM_NONRELOC; 2483 break; 2484 2485 case KPHYSM_ECANCELLED: 2486 e_code = ESBD_MEM_CANCELLED; 2487 break; 2488 2489 case KPHYSM_ERESOURCE: 2490 e_code = ESBD_MEMFAIL; 2491 break; 2492 2493 default: 2494 cmn_err(CE_WARN, "sbd:%s:" 2495 " unexpected kphysm error code %d," 2496 " dip 0x%p", 2497 f, err, (void *)dip); 2498 2499 e_code = ESBD_IO; 2500 break; 2501 } 2502 2503 if (e_code != 0) { 2504 cancel_flag = -1; 2505 SBD_SET_ERR(SBD_HD2ERR(hp), e_code); 2506 SBD_SET_ERRSTR(SBD_HD2ERR(hp), sbp->sb_mempath[unit]); 2507 } 2508 } 2509 2510 return (cancel_flag); 2511 } 2512 2513 /* 2514 * Memory has been logically removed by the time this routine is called. 2515 */ 2516 void 2517 sbd_release_memory_done(void *arg, int error) 2518 { 2519 sbd_release_mem_sync_t *ds = arg; 2520 2521 mutex_enter(&ds->lock); 2522 ds->error = error; 2523 ds->done = 1; 2524 cv_signal(&ds->cond); 2525 mutex_exit(&ds->lock); 2526 } 2527 2528 /* 2529 * If detaching node contains memory that is "non-permanent" 2530 * then the memory adr's are simply cleared. If the memory 2531 * is non-relocatable, then do a copy-rename. 2532 */ 2533 int 2534 sbd_detach_memory(sbd_handle_t *hp, sbderror_t *ep, sbd_mem_unit_t *s_mp, 2535 int unit) 2536 { 2537 int rv; 2538 sbd_mem_unit_t *t_mp; 2539 sbd_istate_t state; 2540 sbdp_handle_t *hdp; 2541 sbd_board_t *sbp = (sbd_board_t *)s_mp->sbm_cm.sbdev_sbp; 2542 sbd_board_t *tbp; 2543 static fn_t f = "sbd_detach_memory"; 2544 2545 PR_MEM("%s...\n", f); 2546 2547 /* lookup target mem unit and target board structure, if any */ 2548 if (s_mp->sbm_flags & SBD_MFLAG_SOURCE) { 2549 t_mp = s_mp->sbm_peer; 2550 ASSERT(t_mp != NULL); 2551 ASSERT(t_mp->sbm_peer == s_mp); 2552 tbp = (sbd_board_t *)t_mp->sbm_cm.sbdev_sbp; 2553 } else { 2554 t_mp = NULL; 2555 } 2556 2557 /* verify mem unit's state is UNREFERENCED */ 2558 state = s_mp->sbm_cm.sbdev_state; 2559 if (state != SBD_STATE_UNREFERENCED) { 2560 cmn_err(CE_WARN, "%s: invalid state transition for" 2561 " mem-unit (%d.%d)", 2562 f, 2563 sbp->sb_num, 2564 s_mp->sbm_cm.sbdev_unum); 2565 SBD_SET_ERR(ep, ESBD_STATE); 2566 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2567 return (-1); 2568 } 2569 2570 /* verify target mem unit's state is UNREFERENCED, if any */ 2571 if (t_mp != NULL) { 2572 state = t_mp->sbm_cm.sbdev_state; 2573 if (state != SBD_STATE_UNREFERENCED) { 2574 cmn_err(CE_WARN, "%s: invalid state transition for" 2575 " target mem-unit (%d.%d)", 2576 f, 2577 tbp->sb_num, 2578 t_mp->sbm_cm.sbdev_unum); 2579 SBD_SET_ERR(ep, ESBD_STATE); 2580 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2581 return (-1); 2582 } 2583 } 2584 2585 /* 2586 * Displacement flush all ecaches in the system. 2587 * That's the fastest way to remove all cache references 2588 * to the detaching memory. 2589 */ 2590 xc_all(sbd_flush_ecache, 0, 0); 2591 2592 hdp = sbd_get_sbdp_handle(sbp, hp); 2593 2594 /* 2595 * If there is no target board (no copy/rename was needed), then 2596 * we're done! 2597 */ 2598 if (t_mp == NULL) { 2599 /* 2600 * Reprogram interconnect hardware and disable 2601 * memory controllers for memory node that's going away. 2602 */ 2603 2604 rv = sbdphw_disable_memctrl(hdp, s_mp->sbm_cm.sbdev_dip); 2605 if (rv) { 2606 cmn_err(CE_WARN, 2607 "%s: failed to deprogram mem-unit (%d.%d)," 2608 " dip 0x%p", 2609 f, 2610 sbp->sb_num, 2611 s_mp->sbm_cm.sbdev_unum, 2612 (void *)s_mp->sbm_cm.sbdev_dip); 2613 /* 2614 * Make sure we don't rewrite an sbdp error 2615 */ 2616 if (SBD_GET_ERR(ep) != 0) { 2617 SBD_SET_ERR(ep, ESBD_HW_PROGRAM); 2618 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2619 } 2620 } 2621 } else { 2622 rv = sbd_move_memory(hp, sbp, tbp); 2623 if (rv) { 2624 int i; 2625 2626 cmn_err(CE_WARN, "%s: failed to move memory" 2627 " from board %d to board %d", 2628 f, 2629 sbp->sb_num, 2630 tbp->sb_num); 2631 /* 2632 * Make sure we don't rewrite an sbdp error 2633 */ 2634 if (SBD_GET_ERR(ep) != 0) { 2635 SBD_SET_ERR(ep, ESBD_INTERNAL); 2636 SBD_SET_ERRSTR(ep, sbp->sb_mempath[unit]); 2637 } 2638 /* 2639 * If we failed here, it means that the target board's 2640 * memory has been unconfigured. We need to configure 2641 * it back 2642 */ 2643 for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) { 2644 int unit; 2645 dev_info_t *dip; 2646 dev_info_t **devlist; 2647 2648 2649 devlist = tbp->sb_devlist[NIX(SBD_COMP_MEM)]; 2650 dip = devlist[i]; 2651 sbd_reset_error_sbdph(hdp); 2652 unit = sbdp_get_unit_num(hdp, dip); 2653 2654 /* 2655 * We already saved the error that created 2656 * this mess. If we fail, make sure not 2657 * to overwrite the original error 2658 */ 2659 if (unit == -1) { 2660 continue; 2661 } 2662 if (sbd_cancel_mem(hp, unit) != 0) 2663 continue; 2664 2665 t_mp->sbm_flags = 0; 2666 /* 2667 * clean up 2668 */ 2669 sbd_mem_cleanup(s_mp, t_mp, ep); 2670 if (s_mp->sbm_mlist) { 2671 memlist_delete(s_mp->sbm_mlist); 2672 s_mp->sbm_mlist = NULL; 2673 } 2674 2675 SBD_DEVICE_TRANSITION(tbp, SBD_COMP_MEM, 2676 unit, SBD_STATE_CONFIGURED); 2677 } 2678 } 2679 2680 PR_MEM("%s: %s memory COPY-RENAME (board %d -> %d)\n", 2681 f, 2682 rv ? "FAILED" : "COMPLETED", 2683 sbp->sb_num, 2684 tbp->sb_num); 2685 } 2686 2687 if (rv == 0) { 2688 update_membounds_t umb; 2689 2690 umb.u_board = sbp->sb_num; 2691 umb.u_base = (uint64_t)-1; 2692 umb.u_len = (uint64_t)-1; 2693 2694 lgrp_plat_config(LGRP_CONFIG_MEM_DEL, (uintptr_t)&umb); 2695 } 2696 2697 sbd_release_sbdp_handle(hdp); 2698 return (rv); 2699 } 2700 2701 /*ARGSUSED*/ 2702 static void 2703 sbd_flush_ecache(uint64_t a, uint64_t b) 2704 { 2705 cpu_flush_ecache(); 2706 } 2707