Deleted Added
sdiff udiff text old ( 254138 ) new ( 254141 )
full compact
vm_object.c (254138) vm_object.c (254141)
1/*-
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 49 unchanged lines hidden (view full) ---

58 * rights to redistribute these changes.
59 */
60
61/*
62 * Virtual memory object module.
63 */
64
65#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 49 unchanged lines hidden (view full) ---

58 * rights to redistribute these changes.
59 */
60
61/*
62 * Virtual memory object module.
63 */
64
65#include <sys/cdefs.h>
66__FBSDID("$FreeBSD: head/sys/vm/vm_object.c 254138 2013-08-09 11:11:11Z attilio $");
66__FBSDID("$FreeBSD: head/sys/vm/vm_object.c 254141 2013-08-09 11:28:55Z attilio $");
67
68#include "opt_vm.h"
69
70#include <sys/param.h>
71#include <sys/systm.h>
72#include <sys/lock.h>
73#include <sys/mman.h>
74#include <sys/mount.h>

--- 121 unchanged lines hidden (view full) ---

196 vm_object_t object;
197
198 object = (vm_object_t)mem;
199 bzero(&object->lock, sizeof(object->lock));
200 rw_init_flags(&object->lock, "vm object", RW_DUPOK);
201
202 /* These are true for any object that has been freed */
203 object->rtree.rt_root = 0;
67
68#include "opt_vm.h"
69
70#include <sys/param.h>
71#include <sys/systm.h>
72#include <sys/lock.h>
73#include <sys/mman.h>
74#include <sys/mount.h>

--- 121 unchanged lines hidden (view full) ---

196 vm_object_t object;
197
198 object = (vm_object_t)mem;
199 bzero(&object->lock, sizeof(object->lock));
200 rw_init_flags(&object->lock, "vm object", RW_DUPOK);
201
202 /* These are true for any object that has been freed */
203 object->rtree.rt_root = 0;
204 object->rtree.rt_flags = 0;
204 object->paging_in_progress = 0;
205 object->resident_page_count = 0;
206 object->shadow_count = 0;
207 object->cache.rt_root = 0;
205 object->paging_in_progress = 0;
206 object->resident_page_count = 0;
207 object->shadow_count = 0;
208 object->cache.rt_root = 0;
209 object->cache.rt_flags = 0;
208 return (0);
209}
210
211static void
212_vm_object_allocate(objtype_t type, vm_pindex_t size, vm_object_t object)
213{
214
215 TAILQ_INIT(&object->memq);

--- 1130 unchanged lines hidden (view full) ---

1346 VM_OBJECT_WUNLOCK(new_object);
1347 vm_page_lock(m);
1348 VM_OBJECT_WUNLOCK(orig_object);
1349 vm_page_busy_sleep(m, "spltwt");
1350 VM_OBJECT_WLOCK(orig_object);
1351 VM_OBJECT_WLOCK(new_object);
1352 goto retry;
1353 }
210 return (0);
211}
212
213static void
214_vm_object_allocate(objtype_t type, vm_pindex_t size, vm_object_t object)
215{
216
217 TAILQ_INIT(&object->memq);

--- 1130 unchanged lines hidden (view full) ---

1348 VM_OBJECT_WUNLOCK(new_object);
1349 vm_page_lock(m);
1350 VM_OBJECT_WUNLOCK(orig_object);
1351 vm_page_busy_sleep(m, "spltwt");
1352 VM_OBJECT_WLOCK(orig_object);
1353 VM_OBJECT_WLOCK(new_object);
1354 goto retry;
1355 }
1356
1357 /* vm_page_rename() will handle dirty and cache. */
1358 if (vm_page_rename(m, new_object, idx)) {
1359 VM_OBJECT_WUNLOCK(new_object);
1360 VM_OBJECT_WUNLOCK(orig_object);
1361 VM_WAIT;
1362 VM_OBJECT_WLOCK(orig_object);
1363 VM_OBJECT_WLOCK(new_object);
1364 goto retry;
1365 }
1354#if VM_NRESERVLEVEL > 0
1355 /*
1356 * If some of the reservation's allocated pages remain with
1357 * the original object, then transferring the reservation to
1358 * the new object is neither particularly beneficial nor
1359 * particularly harmful as compared to leaving the reservation
1360 * with the original object. If, however, all of the
1361 * reservation's allocated pages are transferred to the new
1362 * object, then transferring the reservation is typically
1363 * beneficial. Determining which of these two cases applies
1364 * would be more costly than unconditionally renaming the
1365 * reservation.
1366 */
1367 vm_reserv_rename(m, new_object, orig_object, offidxstart);
1368#endif
1366#if VM_NRESERVLEVEL > 0
1367 /*
1368 * If some of the reservation's allocated pages remain with
1369 * the original object, then transferring the reservation to
1370 * the new object is neither particularly beneficial nor
1371 * particularly harmful as compared to leaving the reservation
1372 * with the original object. If, however, all of the
1373 * reservation's allocated pages are transferred to the new
1374 * object, then transferring the reservation is typically
1375 * beneficial. Determining which of these two cases applies
1376 * would be more costly than unconditionally renaming the
1377 * reservation.
1378 */
1379 vm_reserv_rename(m, new_object, orig_object, offidxstart);
1380#endif
1369 vm_page_lock(m);
1370 vm_page_rename(m, new_object, idx);
1371 vm_page_unlock(m);
1372 /* page automatically made dirty by rename and cache handled */
1373 if (orig_object->type == OBJT_SWAP)
1374 vm_page_xbusy(m);
1375 }
1376 if (orig_object->type == OBJT_SWAP) {
1377 /*
1378 * swap_pager_copy() can sleep, in which case the orig_object's
1379 * and new_object's locks are released and reacquired.
1380 */

--- 139 unchanged lines hidden (view full) ---

1520 }
1521 }
1522
1523 KASSERT(
1524 p->object == backing_object,
1525 ("vm_object_backing_scan: object mismatch")
1526 );
1527
1381 if (orig_object->type == OBJT_SWAP)
1382 vm_page_xbusy(m);
1383 }
1384 if (orig_object->type == OBJT_SWAP) {
1385 /*
1386 * swap_pager_copy() can sleep, in which case the orig_object's
1387 * and new_object's locks are released and reacquired.
1388 */

--- 139 unchanged lines hidden (view full) ---

1528 }
1529 }
1530
1531 KASSERT(
1532 p->object == backing_object,
1533 ("vm_object_backing_scan: object mismatch")
1534 );
1535
1528 /*
1529 * Destroy any associated swap
1530 */
1531 if (backing_object->type == OBJT_SWAP) {
1532 swap_pager_freespace(
1533 backing_object,
1534 p->pindex,
1535 1
1536 );
1537 }
1538
1539 if (
1540 p->pindex < backing_offset_index ||
1541 new_pindex >= object->size
1542 ) {
1536 if (
1537 p->pindex < backing_offset_index ||
1538 new_pindex >= object->size
1539 ) {
1540 if (backing_object->type == OBJT_SWAP)
1541 swap_pager_freespace(backing_object,
1542 p->pindex, 1);
1543
1543 /*
1544 * Page is out of the parent object's range, we
1545 * can simply destroy it.
1546 */
1547 vm_page_lock(p);
1548 KASSERT(!pmap_page_is_mapped(p),
1549 ("freeing mapped page %p", p));
1550 if (p->wire_count == 0)

--- 5 unchanged lines hidden (view full) ---

1556 continue;
1557 }
1558
1559 pp = vm_page_lookup(object, new_pindex);
1560 if (
1561 (op & OBSC_COLLAPSE_NOWAIT) != 0 &&
1562 (pp != NULL && pp->valid == 0)
1563 ) {
1544 /*
1545 * Page is out of the parent object's range, we
1546 * can simply destroy it.
1547 */
1548 vm_page_lock(p);
1549 KASSERT(!pmap_page_is_mapped(p),
1550 ("freeing mapped page %p", p));
1551 if (p->wire_count == 0)

--- 5 unchanged lines hidden (view full) ---

1557 continue;
1558 }
1559
1560 pp = vm_page_lookup(object, new_pindex);
1561 if (
1562 (op & OBSC_COLLAPSE_NOWAIT) != 0 &&
1563 (pp != NULL && pp->valid == 0)
1564 ) {
1565 if (backing_object->type == OBJT_SWAP)
1566 swap_pager_freespace(backing_object,
1567 p->pindex, 1);
1568
1564 /*
1565 * The page in the parent is not (yet) valid.
1566 * We don't know anything about the state of
1567 * the original page. It might be mapped,
1568 * so we must avoid the next if here.
1569 *
1570 * This is due to a race in vm_fault() where
1571 * we must unbusy the original (backing_obj)
1572 * page before we can (re)lock the parent.
1573 * Hence we can get here.
1574 */
1575 p = next;
1576 continue;
1577 }
1578 if (
1579 pp != NULL ||
1580 vm_pager_has_page(object, new_pindex, NULL, NULL)
1581 ) {
1569 /*
1570 * The page in the parent is not (yet) valid.
1571 * We don't know anything about the state of
1572 * the original page. It might be mapped,
1573 * so we must avoid the next if here.
1574 *
1575 * This is due to a race in vm_fault() where
1576 * we must unbusy the original (backing_obj)
1577 * page before we can (re)lock the parent.
1578 * Hence we can get here.
1579 */
1580 p = next;
1581 continue;
1582 }
1583 if (
1584 pp != NULL ||
1585 vm_pager_has_page(object, new_pindex, NULL, NULL)
1586 ) {
1587 if (backing_object->type == OBJT_SWAP)
1588 swap_pager_freespace(backing_object,
1589 p->pindex, 1);
1590
1582 /*
1583 * page already exists in parent OR swap exists
1584 * for this location in the parent. Destroy
1585 * the original page from the backing object.
1586 *
1587 * Leave the parent's page alone
1588 */
1589 vm_page_lock(p);
1590 KASSERT(!pmap_page_is_mapped(p),
1591 ("freeing mapped page %p", p));
1592 if (p->wire_count == 0)
1593 vm_page_free(p);
1594 else
1595 vm_page_remove(p);
1596 vm_page_unlock(p);
1597 p = next;
1598 continue;
1599 }
1600
1591 /*
1592 * page already exists in parent OR swap exists
1593 * for this location in the parent. Destroy
1594 * the original page from the backing object.
1595 *
1596 * Leave the parent's page alone
1597 */
1598 vm_page_lock(p);
1599 KASSERT(!pmap_page_is_mapped(p),
1600 ("freeing mapped page %p", p));
1601 if (p->wire_count == 0)
1602 vm_page_free(p);
1603 else
1604 vm_page_remove(p);
1605 vm_page_unlock(p);
1606 p = next;
1607 continue;
1608 }
1609
1601#if VM_NRESERVLEVEL > 0
1602 /*
1610 /*
1603 * Rename the reservation.
1604 */
1605 vm_reserv_rename(p, object, backing_object,
1606 backing_offset_index);
1607#endif
1608
1609 /*
1610 * Page does not exist in parent, rename the
1611 * page from the backing object to the main object.
1612 *
1613 * If the page was mapped to a process, it can remain
1614 * mapped through the rename.
1611 * Page does not exist in parent, rename the
1612 * page from the backing object to the main object.
1613 *
1614 * If the page was mapped to a process, it can remain
1615 * mapped through the rename.
1616 * vm_page_rename() will handle dirty and cache.
1615 */
1617 */
1616 vm_page_lock(p);
1617 vm_page_rename(p, object, new_pindex);
1618 vm_page_unlock(p);
1619 /* page automatically made dirty by rename */
1618 if (vm_page_rename(p, object, new_pindex)) {
1619 if (op & OBSC_COLLAPSE_NOWAIT) {
1620 p = next;
1621 continue;
1622 }
1623 VM_OBJECT_WLOCK(backing_object);
1624 VM_OBJECT_WUNLOCK(object);
1625 VM_WAIT;
1626 VM_OBJECT_WLOCK(object);
1627 VM_OBJECT_WLOCK(backing_object);
1628 p = TAILQ_FIRST(&backing_object->memq);
1629 continue;
1630 }
1631 if (backing_object->type == OBJT_SWAP)
1632 swap_pager_freespace(backing_object, p->pindex,
1633 1);
1634
1635#if VM_NRESERVLEVEL > 0
1636 /*
1637 * Rename the reservation.
1638 */
1639 vm_reserv_rename(p, object, backing_object,
1640 backing_offset_index);
1641#endif
1620 }
1621 p = next;
1622 }
1623 return (r);
1624}
1625
1626
1627/*

--- 779 unchanged lines hidden --- 		1642 }
1643 p = next;
1644 }
1645 return (r);
1646}
1647
1648
1649/*

--- 779 unchanged lines hidden ---