1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/cmn_err.h> 28 #include <sys/ksynch.h> 29 #include <sys/kmem.h> 30 #include <sys/map.h> 31 #include <sys/errno.h> 32 #include <sys/ddi.h> 33 34 35 #define __NSC_GEN__ 36 #include "nsc_dev.h" 37 #include "nsc_gen.h" 38 #include "nsc_mem.h" 39 #include "../nsctl.h" 40 #ifdef DS_DDICT 41 #include "../contract.h" 42 #endif 43 44 45 static size_t _nsc_rm_size; 46 caddr_t _nsc_rm_base; 47 caddr_t _nsc_rm_nvmem_base; 48 size_t _nsc_rmhdr_size; 49 50 static kmutex_t _nsc_mem_lock; 51 static nsc_mem_t *_nsc_anon_mem; 52 static nsc_mem_t *_nsc_rmhdr_mem; 53 54 nsc_mem_t *_nsc_mem_top; 55 56 nsc_rmhdr_t *_nsc_rmhdr_ptr; 57 nsc_rmmap_t *_nsc_global_map; 58 nsc_mem_t *_nsc_local_mem; 59 60 static void *_nsc_mem_alloc(size_t *, int, nsc_mem_t *); 61 static void *_nsc_rm_alloc(size_t *, nsc_mem_t *); 62 static int _nsc_mem_free(void *, size_t); 63 static int _nsc_rm_free(void *, size_t); 64 static size_t _nsc_rm_avail(nsc_mem_t *); 65 66 extern void nscsetup(void); 67 extern void _nsc_mark_pages(caddr_t, size_t, int); 68 extern int _nsc_lock_all_rm(void); 69 extern void _nsc_unlock_all_rm(void); 70 extern void _nsc_set_max_devices(int); 71 72 /* 73 * void 74 * _nsc_init_mem (void) 75 * Initialise memory allocation system. 76 * 77 * Calling/Exit State: 78 * Called at driver initialisation time to allocate necessary 79 * data structures. 80 */ 81 void 82 _nsc_init_mem() 83 { 84 mutex_init(&_nsc_mem_lock, NULL, MUTEX_DRIVER, NULL); 85 86 _nsc_anon_mem = nsc_register_mem("anon:kmem", NSC_MEM_LOCAL, 0); 87 _nsc_local_mem = nsc_register_mem("nsctl:kmem", NSC_MEM_LOCAL, 0); 88 89 if (!_nsc_anon_mem) 90 cmn_err(CE_PANIC, "nsctl: nsc_init_mem"); 91 } 92 93 94 /* 95 * void 96 * _nsc_deinit_mem (void) 97 * De-initialise memory alloation system. 98 * 99 * Calling/Exit State: 100 * Called at driver unload time to de-allocate 101 * resources. 102 */ 103 104 105 void 106 _nsc_deinit_mem() 107 { 108 if (_nsc_rm_nvmem_base) 109 nsc_kmem_free(_nsc_rm_base, _nsc_rmhdr_size); 110 111 _nsc_rm_nvmem_base = NULL; 112 _nsc_rm_base = NULL; 113 } 114 115 /* 116 * int 117 * _nsc_clear_dirty(int force) 118 * mark the global area clean by clearing the header dirty bit number. 119 * 120 * returns 0 if successfully cleared, valid errno otherwise 121 * 122 * this function should only be called at system shutdown. 123 */ 124 /*ARGSUSED*/ 125 int 126 _nsc_clear_dirty(int force) 127 { 128 int rc = 0; 129 130 #ifdef DEBUG 131 ulong_t longzeros = 0; 132 if (force) { 133 if (_nsc_rm_nvmem_base) { 134 if (nsc_commit_mem((void *)&longzeros, 135 (void *)&((nsc_rmhdr_t *) 136 _nsc_rm_nvmem_base)->rh_dirty, 137 sizeof (ulong_t), nsc_cm_errhdlr) < 0) { 138 cmn_err(CE_WARN, 139 "!nsctl: _nsc_clear_magic: " 140 "hdr force clear failed 0x%p", 141 (void *)_nsc_rm_nvmem_base); 142 } else { 143 cmn_err(CE_WARN, 144 "!nsctl: _nsc_clear_magic: " 145 "hdr force cleared 0x%p", 146 (void *)_nsc_rm_nvmem_base); 147 _nsc_rmhdr_ptr->rh_dirty = 0; 148 } 149 150 return (0); 151 } else 152 return (EINVAL); 153 } 154 155 if (_nsc_rm_nvmem_base) { 156 if (_nsc_global_lock_init) { 157 mutex_enter(&_nsc_global_lock); 158 if (!_nsc_check_mapinuse()) { 159 if (nsc_commit_mem((void *)&longzeros, 160 (void *)&((nsc_rmhdr_t *) 161 _nsc_rm_nvmem_base)->rh_dirty, 162 sizeof (ulong_t), nsc_cm_errhdlr) < 0) { 163 cmn_err(CE_WARN, 164 "!nsctl: _nsc_clear_magic: " 165 "hdr clear failed 0x%p", 166 (void *)_nsc_rm_nvmem_base); 167 } else { 168 cmn_err(CE_WARN, 169 "!nsctl: _nsc_clear_magic: " 170 "hdr cleared 0x%p", 171 (void *)_nsc_rm_nvmem_base); 172 _nsc_rmhdr_ptr->rh_dirty = 0; 173 } 174 rc = 0; 175 } else { 176 cmn_err(CE_WARN, 177 "!nsctl: _nsc_clear_magic: " 178 "global area in use. cannot clear magic"); 179 rc = EBUSY; 180 } 181 mutex_exit(&_nsc_global_lock); 182 } else { 183 cmn_err(CE_WARN, 184 "!nsctl: _nsc_clear_magic: cannot clear magic"); 185 rc = EINVAL; 186 } 187 } else 188 rc = EINVAL; 189 #else 190 191 rc = ENOTTY; 192 193 #endif /* DEBUG */ 194 195 return (rc); 196 } 197 198 /* 199 * int 200 * _nsc_check_mapinuse() 201 * check if any global maps are still inuse; 202 * 203 * return 1 if any non-nsctl map is in use, 0 otherwise 204 * should be called with _nsc_global_lock held 205 * 206 * for nvmem support. if a client of nsctl is still 207 * using the global maps then the global area will not 208 * be marked clean. 209 */ 210 int 211 _nsc_check_mapinuse(void) 212 { 213 nsc_rmmap_t *rmap = _nsc_rmhdr_ptr->map; 214 nsc_rmmap_t *rmapend; 215 216 rmapend = (nsc_rmmap_t *) 217 ((char *)_nsc_rmhdr_ptr + _nsc_rmhdr_ptr->size); 218 219 for (; rmap < rmapend; ++rmap) 220 if ((rmap->inuse) && !(_nsc_is_nsctl_map(rmap->name))) 221 return (1); 222 223 return (0); 224 225 } 226 227 /* names of maps in the global area that belong to nsctl */ 228 static char *nsctl_mapnames[] = { 229 "nsc_global", 230 "nsc_lock" 231 }; 232 233 int 234 _nsc_is_nsctl_map(char *mapname) 235 { 236 int i; 237 238 for (i = 0; i < sizeof (nsctl_mapnames)/sizeof (char *); ++i) 239 if (strncmp(mapname, nsctl_mapnames[i], _NSC_MAXNAME) == 0) 240 return (1); 241 242 return (0); 243 } 244 245 246 /* 247 * nsc_mem_t * 248 * nsc_register_mem(char *name, int type, int flag) 249 * Register a category of memory usage. 250 * 251 * Calling/Exit State: 252 * Returns a token for use in future calls to nsc_kmem_alloc. 253 * type is NSC_MEM_LOCAL, or NSC_MEM_GLOBAL. 254 * flag is passed through to kmem_alloc on allocate. 255 * 256 * Description: 257 * The parameters associated with a category can be changed 258 * by making a subsequent call to nsc_register_mem. 259 */ 260 nsc_mem_t * 261 nsc_register_mem(char *name, int type, int flag) 262 { 263 nsc_mem_t *mp, *new; 264 265 new = kmem_zalloc(sizeof (*new), KM_NOSLEEP); 266 267 mutex_enter(&_nsc_mem_lock); 268 269 for (mp = _nsc_mem_top; mp; mp = mp->next) 270 if (strcmp(mp->name, name) == 0) 271 break; 272 273 if (!mp && !(mp = new)) { 274 mutex_exit(&_nsc_mem_lock); 275 return (NULL); 276 } 277 278 mp->type = type; 279 mp->flag = flag; 280 281 mp->hwm = mp->used; 282 mp->pagehwm = mp->pages; 283 mp->nalloc -= mp->nfree; 284 mp->nfree = 0; 285 286 if (!mp->name) { 287 mp->name = name; 288 mp->next = _nsc_mem_top; 289 _nsc_mem_top = mp; 290 } 291 292 mutex_exit(&_nsc_mem_lock); 293 294 if (new && mp != new) 295 kmem_free(new, sizeof (*new)); 296 297 return (mp); 298 } 299 300 301 /* 302 * void 303 * nsc_unregister_mem(nsc_mem_t *) 304 * Un-register a category of memory usage. 305 * 306 * Description: 307 * The specified category is un-registered. For correct 308 * operation this should only be called when all memory 309 * associated with the category has been free'd. 310 */ 311 void 312 nsc_unregister_mem(nsc_mem_t *mp) 313 { 314 nsc_mem_t **mpp; 315 316 if (!mp) 317 return; 318 319 mutex_enter(&_nsc_mem_lock); 320 321 for (mpp = &_nsc_mem_top; *mpp; mpp = &(*mpp)->next) 322 if (*mpp == mp) 323 break; 324 325 if (*mpp != NULL) { 326 *mpp = mp->next; 327 kmem_free(mp, sizeof (*mp)); 328 } 329 330 mutex_exit(&_nsc_mem_lock); 331 } 332 333 /* 334 * void 335 * _nsc_global_setup 336 * Setup global variables. 337 * 338 * Calling/Exit State: 339 * Called to setup the global header. 340 */ 341 void 342 _nsc_global_setup() 343 { 344 nsc_rmhdr_t *hdr = (void *)_nsc_rm_base; 345 size_t size; 346 347 if (!hdr || !_nsc_global_lock_init || _nsc_rmhdr_ptr) 348 return; 349 350 mutex_enter(&_nsc_global_lock); 351 352 if (!hdr->magic || (_nsc_rm_nvmem_base && !hdr->rh_dirty)) { 353 size = sizeof (nsc_rmhdr_t) + 354 (sizeof (nsc_rmmap_t) * (_NSC_GLSLOT - 1)); 355 356 size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN; 357 bzero(_nsc_rm_base, size); 358 359 hdr->magic = _NSCTL_HDRMAGIC; 360 hdr->ver = _NSCTL_HDRVER3; 361 hdr->size = size; 362 hdr->maxdev = nsc_max_devices(); 363 364 hdr->map[0].inuse = _NSC_GLSLOT; 365 if (_nsc_rm_nvmem_base) { 366 if (hdr->rh_dirty) { /* corrupted */ 367 cmn_err(CE_WARN, 368 "!nsctl: _nsc_global_setup: nv bad header"); 369 mutex_exit(&_nsc_global_lock); 370 return; 371 } 372 if (nsc_commit_mem((void *)_nsc_rm_base, 373 (void *)_nsc_rm_nvmem_base, 374 size, nsc_cm_errhdlr) < 0) 375 cmn_err(CE_WARN, "!_nsc_global_setup: " 376 "nvmem header not updated"); 377 } 378 } 379 380 _nsc_rmhdr_ptr = hdr; 381 mutex_exit(&_nsc_global_lock); 382 383 if (hdr->magic != _NSCTL_HDRMAGIC || (hdr->ver != _NSCTL_HDRVER && 384 hdr->ver != _NSCTL_HDRVER3)) { 385 cmn_err(CE_WARN, "!nsctl: _nsc_global_setup: bad header"); 386 return; 387 } 388 389 if (hdr->ver == _NSCTL_HDRVER3 && hdr->maxdev != nsc_max_devices()) { 390 _nsc_set_max_devices(hdr->maxdev); 391 cmn_err(CE_WARN, 392 "!nsctl: _nsc_global_setup: setting nsc_max_devices to %d", 393 hdr->maxdev); 394 } 395 396 if (!_nsc_rmmap_init(hdr->map, "nsc_global", _NSC_GLSLOT, 397 _nsc_rm_size - hdr->size, hdr->size)) { 398 cmn_err(CE_WARN, 399 "!nsctl: _nsc_global_setup: global map init failed"); 400 return; 401 } 402 403 _nsc_global_map = hdr->map; 404 405 (void) nsc_kmem_alloc(hdr->size, 0, _nsc_rmhdr_mem); 406 } 407 408 /* 409 * int 410 * _nsc_need_global_mem () 411 * Expected global memory usage. 412 * 413 * Calling/Exit State: 414 * Returns the amount of global memory expected to be 415 * used by internal data structures. 416 * 417 * Remarks: 418 * This is provided purely as a configuration aid to 419 * systems without global memory and as such is not 420 * declared in nsctl.h. 421 */ 422 int 423 _nsc_need_global_mem() 424 { 425 int size = sizeof (nsc_rmhdr_t) + 426 (sizeof (nsc_rmmap_t) * (_NSC_GLSLOT - 1)); 427 428 size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN; 429 return (size); 430 } 431 432 433 /* 434 * void * 435 * nsc_kmem_alloc (size_t size, int flag, nsc_mem_t *mem) 436 * Allocate memory of the specified type. 437 * 438 * Calling/Exit State: 439 * Returns a pointer to a word aligned area of memory. 440 * If mem is zero then an anonymous category is used. 441 * 442 * Description: 443 * Allocates the required memory and updates the usage 444 * statistics stored in mem. 445 * 446 * Remarks: 447 * VME memory is guaranteed to be eight byte aligned. 448 */ 449 void * 450 nsc_kmem_alloc(size_t size, int flag, nsc_mem_t *mem) 451 { 452 void *vp; 453 454 if (!mem) 455 mem = _nsc_anon_mem; 456 457 if ((vp = _nsc_mem_alloc(&size, flag, mem)) == NULL) 458 return (NULL); 459 460 mutex_enter(&_nsc_mem_lock); 461 462 mem->nalloc++; 463 mem->used += size; 464 mem->pages += btopr(size); 465 466 if (mem->used > mem->hwm) 467 mem->hwm = mem->used; 468 if (mem->pages > mem->pagehwm) 469 mem->pagehwm = mem->pages; 470 471 mutex_exit(&_nsc_mem_lock); 472 return (vp); 473 } 474 475 476 /* 477 * void * 478 * _nsc_mem_alloc (size_t *sizep, int flag, nsc_mem_t *mem) 479 * Allocate memory of the specified type. 480 * 481 * Calling/Exit State: 482 * Returns a pointer to a word aligned area of memory. 483 * 484 * Description: 485 * Uses the type field to determine whether to allocate RM, 486 * VME or kernel memory. For types other then RM a copy of 487 * mem is stored immediately prior to the returned area. 488 * size is updated to reflect the header. 489 * 490 * Remarks: 491 * A two word header is user for VME memory to ensure 492 * eight byte alignment. 493 */ 494 static void * 495 _nsc_mem_alloc(size_t *sizep, int flag, nsc_mem_t *mem) 496 { 497 size_t size = *sizep; 498 void *vp; 499 500 if (mem->type & NSC_MEM_GLOBAL) 501 return (_nsc_rm_alloc(sizep, mem)); 502 503 flag |= mem->flag; 504 size += sizeof (nsc_mem_t *); 505 506 if (flag & KM_NOSLEEP) 507 flag &= ~KM_SLEEP; 508 509 vp = kmem_alloc(size, flag); 510 if (!vp) 511 return (NULL); 512 513 *sizep = size; 514 515 *(nsc_mem_t **)vp = mem; 516 517 return (void *)((nsc_mem_t **)vp + 1); 518 } 519 520 521 /* 522 * void 523 * nsc_kmem_free (void *addr, size_t size) 524 * Free a previously allocated area of memory. 525 * 526 * Calling/Exit State: 527 * The memory specified by addr is returned to the free pool. 528 * 529 * Description: 530 * Updates the usage statistics appropriately. 531 */ 532 void 533 nsc_kmem_free(void *addr, size_t size) 534 { 535 caddr_t caddr = (caddr_t)addr; 536 caddr_t rm_base; 537 int rc; 538 539 if (_nsc_rm_nvmem_base) 540 rm_base = _nsc_rm_nvmem_base; 541 else 542 rm_base = _nsc_rm_base; 543 544 if (rm_base <= caddr && caddr < rm_base + _nsc_rm_size) 545 rc = _nsc_rm_free(addr, size); 546 else 547 rc = _nsc_mem_free(addr, size); 548 549 if (rc < 0) 550 cmn_err(CE_PANIC, "nsctl: nsc_kmem_free: invalid free"); 551 } 552 553 554 /* 555 * nsc_mem_t * 556 * _nsc_mem_free (void *addr, size_t size) 557 * Free a previously allocated area of memory. 558 * 559 * Calling/Exit State: 560 * Frees the VME or kernel memory at addr and updates 561 * the associated mem structure. 562 */ 563 static int 564 _nsc_mem_free(void *addr, size_t size) 565 { 566 nsc_mem_t *mp, *tp; 567 568 addr = (void *)((nsc_mem_t **)addr - 1); 569 size += sizeof (nsc_mem_t *); 570 571 mutex_enter(&_nsc_mem_lock); 572 573 mp = *(nsc_mem_t **)addr; 574 575 for (tp = _nsc_mem_top; tp; tp = tp->next) 576 if (tp == mp) 577 break; 578 579 if (tp == NULL) { 580 mutex_exit(&_nsc_mem_lock); 581 return (-1); 582 } 583 584 mp->nfree++; 585 mp->used -= size; 586 mp->pages -= btopr(size); 587 588 *(nsc_mem_t **)addr = NULL; 589 590 mutex_exit(&_nsc_mem_lock); 591 592 kmem_free(addr, size); 593 594 return (0); 595 } 596 597 598 /* 599 * void * 600 * nsc_kmem_zalloc(size_t size, int flags, nsc_mem_t *mem) 601 * Allocate and zero memory. 602 * 603 * Calling/Exit State: 604 * Same as nsc_kmem_alloc(), except that the memory is zeroed. 605 */ 606 void * 607 nsc_kmem_zalloc(size_t size, int flag, nsc_mem_t *mem) 608 { 609 void *vp = nsc_kmem_alloc(size, flag, mem); 610 611 if (vp) 612 bzero((char *)vp, size); 613 614 return (vp); 615 } 616 617 618 /* 619 * void 620 * nsc_mem_sizes (nsc_mem_t *mem, size_t *usedp, size_t *hwmp, size_t *reqp) 621 * Access size information for category. 622 * 623 * Calling/Exit State: 624 * If the corresponding pointer is non-zero returns 625 * respectively, the number of bytes currently allocated, the 626 * high water mark in bytes and an estimate of the number of 627 * bytes needed for the category assuming that each request 628 * is satisfied from a different page. 629 * 630 * Remarks: 631 * The reqp parameter is used to estimate the amount of special 632 * purpose memory needed to support the category. 633 */ 634 void 635 nsc_mem_sizes(nsc_mem_t *mem, size_t *usedp, size_t *hwmp, size_t *reqp) 636 { 637 if (!mem) 638 mem = _nsc_anon_mem; 639 640 if (usedp) 641 *usedp = mem->used; 642 if (hwmp) 643 *hwmp = mem->hwm; 644 if (reqp) 645 *reqp = (size_t)ptob(mem->pagehwm); 646 } 647 648 649 /* 650 * size_t 651 * nsc_mem_avail (nsc_mem_t *mem) 652 * Memory available for use by category. 653 * 654 * Calling/Exit State: 655 * Returns the number of bytes of memory currently 656 * available for use by the category. 657 * 658 * Remarks: 659 * Reduces the memory available to allow for one unit 660 * of allocation overhead. 661 * 662 * Only implemented for NSC_MEM_GLOBAL. 663 */ 664 size_t 665 nsc_mem_avail(nsc_mem_t *mem) 666 { 667 if (!mem) 668 mem = _nsc_anon_mem; 669 670 if (mem->type & NSC_MEM_GLOBAL) 671 return (_nsc_rm_avail(mem)); 672 673 #ifdef DEBUG 674 cmn_err(CE_WARN, "!nsc_mem_avail: called for non-global memory!"); 675 #endif 676 677 return (0); 678 } 679 680 681 /* 682 * void 683 * _nsc_global_zero (ulong_t offset, size_t size) 684 * Zero global memory. 685 * 686 * Description: 687 * Zeroes an area of global memory at the specified offset. 688 */ 689 690 #define ZSIZE 4096 691 static char _nsc_nvmem_zeroes[ZSIZE]; 692 693 static void 694 _nsc_global_zero(ulong_t offset, size_t size) 695 { 696 int i; 697 int rc; 698 int failed = 0; 699 700 if (_nsc_rm_nvmem_base) { 701 for (i = 0; i < (int)(size / ZSIZE); ++i) { 702 rc = nsc_commit_mem((void *)_nsc_nvmem_zeroes, 703 (void *)(_nsc_rm_nvmem_base + offset + 704 i * ZSIZE), 705 ZSIZE, nsc_cm_errhdlr); 706 707 if (rc < 0) 708 ++failed; 709 710 } 711 rc = nsc_commit_mem((void *)_nsc_nvmem_zeroes, 712 (void *)(_nsc_rm_nvmem_base + offset + i * ZSIZE), 713 size % ZSIZE, 714 nsc_cm_errhdlr); 715 if ((rc < 0) || failed) 716 cmn_err(CE_WARN, "!_nsc_global_zero: clear mem failed"); 717 return; 718 } 719 720 if (_nsc_rm_base) 721 bzero(_nsc_rm_base + offset, size); 722 } 723 724 725 /* 726 * void * 727 * _nsc_rm_alloc (size_t *sizep, nsc_mem_t *mem) 728 * Allocate next available section of RM. 729 * 730 * Calling/Exit State: 731 * Returns a pointer to an area of global memory. 732 * 733 * Description: 734 * Only one allocation request is allowed for each 735 * category of global memory. 736 */ 737 static void * 738 _nsc_rm_alloc(size_t *sizep, nsc_mem_t *mem) 739 { 740 size_t avail, size = (*sizep); 741 ulong_t offset = 0; 742 caddr_t retaddr; 743 744 if (!_nsc_global_map) { 745 cmn_err(CE_WARN, "!_nsc_rm_alloc: no map"); 746 return (NULL); 747 } 748 749 mutex_enter(&_nsc_mem_lock); 750 751 if (mem->base || mem->pend) { 752 mutex_exit(&_nsc_mem_lock); 753 cmn_err(CE_WARN, "!_nsc_rm_alloc: invalid alloc"); 754 return (NULL); 755 } 756 757 mem->pend = 1; 758 mutex_exit(&_nsc_mem_lock); 759 760 size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN; 761 762 /* CONSTCOND */ 763 764 while (1) { 765 if (strcmp(mem->name, "nsctl:rmhdr") == 0) 766 break; 767 768 offset = _nsc_rmmap_alloc(_nsc_global_map, 769 mem->name, size, _nsc_global_zero); 770 771 if (offset) 772 break; 773 774 if (mem->type & NSC_MEM_RESIZE) { 775 avail = _nsc_rmmap_size(_nsc_global_map, mem->name); 776 777 if (avail && avail != size) { 778 size = avail; 779 continue; 780 } 781 } 782 783 mem->pend = 0; 784 cmn_err(CE_WARN, 785 "!_nsc_rm_alloc: alloc %ld bytes - %ld available", 786 size, _nsc_rm_avail(mem)); 787 return (NULL); 788 } 789 790 _nsc_mark_pages(_nsc_rm_base + offset, size, 1); 791 792 if (_nsc_rm_nvmem_base) 793 retaddr = _nsc_rm_nvmem_base + offset; 794 else 795 retaddr = _nsc_rm_base + offset; 796 797 mutex_enter(&_nsc_mem_lock); 798 799 mem->base = retaddr; 800 mem->pend = 0; 801 802 mutex_exit(&_nsc_mem_lock); 803 804 (*sizep) = size; 805 return (retaddr); 806 } 807 808 809 /* 810 * nsc_mem_t * 811 * _nsc_rm_free (void *addr, size_t size) 812 * Free an area of RM. 813 * 814 * Calling/Exit State: 815 * Returns 0 on success, -1 on failure. 816 */ 817 static int 818 _nsc_rm_free(void *addr, size_t size) 819 { 820 caddr_t caddr = (caddr_t)addr; 821 nsc_mem_t *mp; 822 823 mutex_enter(&_nsc_mem_lock); 824 825 for (mp = _nsc_mem_top; mp; mp = mp->next) 826 if (mp->base == caddr) 827 break; 828 829 if (!mp) { 830 mutex_exit(&_nsc_mem_lock); 831 return (-1); 832 } 833 834 mp->nfree++; 835 mp->used -= size; 836 mp->pages -= btopr(size); 837 mp->pend = 1; 838 839 if (!mp->used) 840 mp->base = 0; 841 842 mutex_exit(&_nsc_mem_lock); 843 844 if (_nsc_global_map) 845 _nsc_rmmap_free(_nsc_global_map, mp->name, mp); 846 847 _nsc_mark_pages(addr, size, 0); 848 849 mp->pend = 0; 850 return (0); 851 } 852 853 854 /* 855 * static size_t 856 * _nsc_rm_avail (mem) 857 * Amount of RM available. 858 * 859 * Calling/Exit State: 860 * Returns 0 if the specified category has already been 861 * allocated. Returns the size of the region if it already 862 * exists, otherwise the number of bytes of global memory 863 * available. 864 */ 865 static size_t 866 _nsc_rm_avail(nsc_mem_t *mem) 867 { 868 size_t size; 869 870 if (!_nsc_global_map || mem->base || mem->pend) 871 return (0); 872 873 if ((size = _nsc_rmmap_size(_nsc_global_map, mem->name)) != 0) 874 return (size); 875 876 return (_nsc_rmmap_avail(_nsc_global_map)); 877 } 878 879 880 /* 881 * nvram support 882 * given a map address, return the address of the copy 883 * in nvram. 884 * Assumes that _nsc_rm_nvmem_base is valid. 885 */ 886 nsc_rmmap_t * 887 _nsc_global_nvmemmap_lookup(nsc_rmmap_t *hp) 888 { 889 size_t offset; 890 891 /* LINTED */ 892 offset = (caddr_t)hp - _nsc_rm_base; 893 return ((nsc_rmmap_t *)(_nsc_rm_nvmem_base + offset)); 894 } 895 896 int 897 _nsc_get_global_sizes(void *arg, int *rvp) 898 { 899 if (!_nsc_rmhdr_ptr) 900 return (EINVAL); 901 902 if (copyout(&_nsc_rmhdr_ptr->size, arg, 903 sizeof (_nsc_rmhdr_ptr->size)) < 0) 904 return (EFAULT); 905 906 *rvp = 0; 907 return (0); 908 } 909 910 int 911 _nsc_get_global_data(void *arg, int *rvp) 912 { 913 size_t size; 914 915 if (!_nsc_rmhdr_ptr) 916 return (EINVAL); 917 918 size = _nsc_rmhdr_ptr->size; 919 920 if (copyout(_nsc_rmhdr_ptr, arg, size) < 0) 921 return (EFAULT); 922 923 if (_nsc_rm_nvmem_base) { 924 char *taddr; 925 926 if ((taddr = kmem_alloc(size, KM_NOSLEEP)) == NULL) 927 return (ENOMEM); 928 929 if (copyout(taddr, (char *)arg + size, size) < 0) { 930 kmem_free(taddr, size); 931 return (EFAULT); 932 } 933 934 kmem_free(taddr, size); 935 } 936 937 *rvp = 0; 938 return (0); 939 } 940