sys/kern/subr_vmem.c

176 #define	bt_free(vm, bt)		free(bt)
245 	bt_t *bt;
257 		bt = LIST_FIRST(&vmem_btag_freelist);
258 		LIST_REMOVE(bt, bt_freelist);
259 		bt->bt_flags = 0;
260 		LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist);
271 		bt = pool_get(&vmem_btag_pool, PR_NOWAIT);
274 		if (bt == NULL)
276 		bt->bt_flags = 0;
277 		LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist);
310 	bt_t *bt;
333 	bt = LIST_FIRST(&vm->vm_freetags);
334 	LIST_REMOVE(bt, bt_freelist);
337 	return bt;
341 bt_free(vmem_t *vm, bt_t *bt)
346 	LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist);
353 	bt_t *bt, *next_bt;
360 	LIST_FOREACH_SAFE(bt, &vm->vm_freetags, bt_freelist, next_bt) {
364 		if (bt->bt_flags & BT_F_PRIVATE) {
367 		LIST_REMOVE(bt, bt_freelist);
369 		if (bt >= static_bts
370 		    && bt < &static_bts[STATIC_BT_COUNT]) {
372 			LIST_INSERT_HEAD(&vmem_btag_freelist, bt, bt_freelist);
377 			LIST_INSERT_HEAD(&tofree, bt, bt_freelist);
383 		bt = LIST_FIRST(&tofree);
384 		LIST_REMOVE(bt, bt_freelist);
385 		pool_put(&vmem_btag_pool, bt);
480 	bt_t *bt;
483 	LIST_FOREACH(bt, list, bt_hashlist) {
484 		if (bt->bt_start == addr) {
489 	return bt;
493 bt_rembusy(vmem_t *vm, bt_t *bt)
497 	vm->vm_inuse -= bt->bt_size;
499 	LIST_REMOVE(bt, bt_hashlist);
503 bt_insbusy(vmem_t *vm, bt_t *bt)
507 	KASSERT(bt->bt_type == BT_TYPE_BUSY);
509 	list = bt_hashhead(vm, bt->bt_start);
510 	LIST_INSERT_HEAD(list, bt, bt_hashlist);
514 	vm->vm_inuse += bt->bt_size;
520 bt_remseg(vmem_t *vm, bt_t *bt)
523 	TAILQ_REMOVE(&vm->vm_seglist, bt, bt_seglist);
527 bt_insseg(vmem_t *vm, bt_t *bt, bt_t *prev)
530 	TAILQ_INSERT_AFTER(&vm->vm_seglist, prev, bt, bt_seglist);
534 bt_insseg_tail(vmem_t *vm, bt_t *bt)
537 	TAILQ_INSERT_TAIL(&vm->vm_seglist, bt, bt_seglist);
541 bt_remfree(vmem_t *vm, bt_t *bt)
544 	KASSERT(bt->bt_type == BT_TYPE_FREE);
546 	LIST_REMOVE(bt, bt_freelist);
550 bt_insfree(vmem_t *vm, bt_t *bt)
554 	list = bt_freehead_tofree(vm, bt->bt_size);
555 	LIST_INSERT_HEAD(list, bt, bt_freelist);
704 		bt_t *bt = &static_bts[static_bt_count];
705 		LIST_INSERT_HEAD(&vmem_btag_freelist, bt, bt_freelist);
781 		bt_t *bt;
783 		while ((bt = LIST_FIRST(&vm->vm_hashlist[i])) != NULL) {
784 			KASSERT(bt->bt_type == BT_TYPE_SPAN_STATIC);
785 			LIST_REMOVE(bt, bt_hashlist);
786 			bt_free(vm, bt);
845 	bt_t *bt;
885 		while ((bt = LIST_FIRST(&oldhashlist[i])) != NULL) {
886 			bt_rembusy(vm, bt); /* XXX */
887 			bt_insbusy(vm, bt);
902  * vmem_fit: check if a bt can satisfy the given restrictions.
909 vmem_fit(const bt_t *bt, vmem_size_t size, vmem_size_t align,
917 	KASSERT(bt->bt_size >= size); /* caller's responsibility */
924 	start = bt->bt_start;
928 	end = BT_END(bt);
937 	if (start < bt->bt_start) {
949 		KASSERT(bt->bt_start <= start);
950 		KASSERT(BT_END(bt) - start >= size - 1);
1180 	bt_t *bt;
1232 	bt = NULL;
1243 			bt = LIST_FIRST(list);
1244 			if (bt != NULL) {
1245 				rc = vmem_fit(bt, size, align, phase,
1272 			LIST_FOREACH(bt, list, bt_freelist) {
1273 				if (bt->bt_size >= size) {
1274 					rc = vmem_fit(bt, size, align, phase,
1316 	KASSERT(bt->bt_type == BT_TYPE_FREE);
1317 	KASSERT(bt->bt_size >= size);
1318 	bt_remfree(vm, bt);
1320 	if (bt->bt_start != start) {
1322 		btnew2->bt_start = bt->bt_start;
1323 		btnew2->bt_size = start - bt->bt_start;
1324 		bt->bt_start = start;
1325 		bt->bt_size -= btnew2->bt_size;
1327 		bt_insseg(vm, btnew2, TAILQ_PREV(bt, vmem_seglist, bt_seglist));
1331 	KASSERT(bt->bt_start == start);
1332 	if (bt->bt_size != size && bt->bt_size - size > vm->vm_quantum_mask) {
1335 		btnew->bt_start = bt->bt_start;
1337 		bt->bt_start = bt->bt_start + size;
1338 		bt->bt_size -= size;
1339 		bt_insfree(vm, bt);
1340 		bt_insseg(vm, btnew, TAILQ_PREV(bt, vmem_seglist, bt_seglist));
1344 		bt->bt_type = BT_TYPE_BUSY;
1345 		bt_insbusy(vm, bt);
1348 		btnew = bt;
1394 	bt_t *bt;
1403 	bt = bt_lookupbusy(vm, addr);
1404 	KASSERTMSG(bt != NULL, "vmem %s addr 0x%jx size 0x%jx",
1406 	KASSERT(bt->bt_start == addr);
1407 	KASSERT(bt->bt_size == vmem_roundup_size(vm, size) ||
1408 	    bt->bt_size - vmem_roundup_size(vm, size) <= vm->vm_quantum_mask);
1411 	vmem_xfree_bt(vm, bt);
1417 	bt_t *bt;
1426 		TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
1427 			if (bt->bt_type == BT_TYPE_BUSY)
1430 		if (bt != NULL) {
1432 			vmem_xfree_bt(vm, bt);
1441 vmem_xfree_bt(vmem_t *vm, bt_t *bt)
1447 	KASSERT(bt->bt_type == BT_TYPE_BUSY);
1448 	bt_rembusy(vm, bt);
1449 	bt->bt_type = BT_TYPE_FREE;
1452 	t = TAILQ_NEXT(bt, bt_seglist);
1454 		KASSERT(BT_END(bt) < t->bt_start);	/* YYY */
1457 		bt->bt_size += t->bt_size;
1460 	t = TAILQ_PREV(bt, vmem_seglist, bt_seglist);
1462 		KASSERT(BT_END(t) < bt->bt_start);	/* YYY */
1465 		bt->bt_size += t->bt_size;
1466 		bt->bt_start = t->bt_start;
1470 	t = TAILQ_PREV(bt, vmem_seglist, bt_seglist);
1474 	    t->bt_size == bt->bt_size) {
1478 		KASSERT(t->bt_start == bt->bt_start);
1479 		spanaddr = bt->bt_start;
1480 		spansize = bt->bt_size;
1481 		bt_remseg(vm, bt);
1482 		bt_free(vm, bt);
1491 		bt_insfree(vm, bt);
1623 bt_dump(const bt_t *bt, void (*pr)(const char *, ...))
1627 	    bt, (uint64_t)bt->bt_start, (uint64_t)bt->bt_size,
1628 	    bt->bt_type, bt_type_string(bt->bt_type));
1634 	const bt_t *bt;
1638 	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
1639 		bt_dump(bt, pr);
1650 		LIST_FOREACH(bt, fl, bt_freelist) {
1651 			bt_dump(bt, pr);
1662 	bt_t *bt;
1664 	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
1665 		if (BT_ISSPAN_P(bt)) {
1668 		if (bt->bt_start <= addr && addr <= BT_END(bt)) {
1669 			return bt;
1682 		bt_t *bt;
1684 		bt = vmem_whatis_lookup(vm, addr);
1685 		if (bt == NULL) {
1689 		    (void *)addr, (void *)bt->bt_start,
1690 		    (size_t)(addr - bt->bt_start), vm->vm_name,
1691 		    (bt->bt_type == BT_TYPE_BUSY) ? "allocated" : "free");
1735 	const bt_t *bt, *bt2;
1739 	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
1740 		if (bt->bt_start > BT_END(bt)) {
1742 			bt_dump(bt, vmem_printf);
1746 	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
1748 			if (bt == bt2) {
1751 			if (BT_ISSPAN_P(bt) != BT_ISSPAN_P(bt2)) {
1754 			if (bt->bt_start <= BT_END(bt2) &&
1755 			    bt2->bt_start <= BT_END(bt)) {
1757 				bt_dump(bt, vmem_printf);