xnu-2782.20.48.tar.gz

[apple/xnu.git] / osfmk / default_pager / dp_memory_object.c

diff --git a/osfmk/default_pager/dp_memory_object.c b/osfmk/default_pager/dp_memory_object.c
index c85278056c2977fb35b1ff34f287e743e2f8aaf7..3ffa10e447a17a31aa5a3fb06cc7ddaa09136469 100644 (file)
--- a/osfmk/default_pager/dp_memory_object.c
+++ b/osfmk/default_pager/dp_memory_object.c
@@ -350,8 +350,8 @@ default_pager_add(
                pset = default_pager_external_set;
        }
 
                pset = default_pager_external_set;
        }
 

-       ipc_port_make_sonce(mem_obj);

        ip_lock(mem_obj);  /* unlocked in nsrequest below */
        ip_lock(mem_obj);  /* unlocked in nsrequest below */

+       ipc_port_make_sonce_locked(mem_obj);

        ipc_port_nsrequest(mem_obj, sync, mem_obj, &previous);
 }
 
        ipc_port_nsrequest(mem_obj, sync, mem_obj, &previous);
 }
 


@@ -369,6 +369,7 @@ const struct memory_object_pager_ops default_pager_ops = {
        dp_memory_object_synchronize,
        dp_memory_object_map,
        dp_memory_object_last_unmap,
        dp_memory_object_synchronize,
        dp_memory_object_map,
        dp_memory_object_last_unmap,

+       dp_memory_object_data_reclaim,

        "default pager"
 };
 
        "default pager"
 };
 


@@ -431,6 +432,34 @@ dp_memory_object_last_unmap(
        return KERN_FAILURE;
 }
 
        return KERN_FAILURE;
 }
 

+kern_return_t
+dp_memory_object_data_reclaim(
+       memory_object_t         mem_obj,
+       boolean_t               reclaim_backing_store)
+{
+       vstruct_t               vs;
+       kern_return_t           retval;
+
+       vs_lookup(mem_obj, vs);
+       for (;;) {
+               vs_lock(vs);
+               vs_async_wait(vs);
+               if (!vs->vs_xfer_pending) {
+                       break;
+               }
+       }
+       vs->vs_xfer_pending = TRUE;
+       vs_unlock(vs);
+
+       retval = ps_vstruct_reclaim(vs, TRUE, reclaim_backing_store);
+
+       vs_lock(vs);
+       vs->vs_xfer_pending = FALSE;
+       vs_unlock(vs);
+
+       return retval;
+}
+

 kern_return_t
 dp_memory_object_terminate(
        memory_object_t         mem_obj)
 kern_return_t
 dp_memory_object_terminate(
        memory_object_t         mem_obj)


@@ -748,6 +777,9 @@ dp_memory_object_data_return(
        vs_lookup(mem_obj, vs);
 
         default_pager_total++;
        vs_lookup(mem_obj, vs);
 
         default_pager_total++;

+
+       /* might be unreachable if VS_TRY_LOCK is, by definition, always true */
+       __unreachable_ok_push

        if(!VS_TRY_LOCK(vs)) {
                /* the call below will not be done by caller when we have */
                /* a synchronous interface */
        if(!VS_TRY_LOCK(vs)) {
                /* the call below will not be done by caller when we have */
                /* a synchronous interface */


@@ -764,6 +796,7 @@ dp_memory_object_data_return(
                upl_deallocate(upl);
                return KERN_SUCCESS;
        }
                upl_deallocate(upl);
                return KERN_SUCCESS;
        }

+       __unreachable_ok_pop

 
        if ((vs->vs_seqno != vs->vs_next_seqno++)
                        || (vs->vs_readers)
 
        if ((vs->vs_seqno != vs->vs_next_seqno++)
                        || (vs->vs_readers)


@@ -939,7 +972,8 @@ default_pager_objects(
        /*
         * Out out-of-line port arrays are simply kalloc'ed.
         */
        /*
         * Out out-of-line port arrays are simply kalloc'ed.
         */

-       psize = round_page(actual * sizeof (*pagers));
+       psize = vm_map_round_page(actual * sizeof (*pagers),
+                                 vm_map_page_mask(ipc_kernel_map));

        ppotential = (unsigned int) (psize / sizeof (*pagers));
        pagers = (memory_object_t *)kalloc(psize);
        if (0 == pagers)
        ppotential = (unsigned int) (psize / sizeof (*pagers));
        pagers = (memory_object_t *)kalloc(psize);
        if (0 == pagers)


@@ -951,7 +985,8 @@ default_pager_objects(
         * then "copied in" as if it had been sent by a
         * user process.
         */
         * then "copied in" as if it had been sent by a
         * user process.
         */

-       osize = round_page(actual * sizeof (*objects));
+       osize = vm_map_round_page(actual * sizeof (*objects),
+                                 vm_map_page_mask(ipc_kernel_map));

        opotential = (unsigned int) (osize / sizeof (*objects));
        kr = kmem_alloc(ipc_kernel_map, &oaddr, osize);
        if (KERN_SUCCESS != kr) {
        opotential = (unsigned int) (osize / sizeof (*objects));
        kr = kmem_alloc(ipc_kernel_map, &oaddr, osize);
        if (KERN_SUCCESS != kr) {


@@ -1037,8 +1072,12 @@ default_pager_objects(
                pagers[--ppotential] = MEMORY_OBJECT_NULL;
        }
 
                pagers[--ppotential] = MEMORY_OBJECT_NULL;
        }
 

-       kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(oaddr),
-                          vm_map_round_page(oaddr + osize), FALSE);
+       kr = vm_map_unwire(ipc_kernel_map,
+                          vm_map_trunc_page(oaddr,
+                                            vm_map_page_mask(ipc_kernel_map)),
+                          vm_map_round_page(oaddr + osize,
+                                            vm_map_page_mask(ipc_kernel_map)),
+                          FALSE);

        assert(KERN_SUCCESS == kr);
        kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)oaddr,
                           (vm_map_size_t)osize, TRUE, &pcopy);
        assert(KERN_SUCCESS == kr);
        kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)oaddr,
                           (vm_map_size_t)osize, TRUE, &pcopy);


@@ -1120,7 +1159,8 @@ default_pager_object_pages(
                if (0 != addr)
                        kmem_free(ipc_kernel_map, addr, size);
 
                if (0 != addr)
                        kmem_free(ipc_kernel_map, addr, size);
 

-               size = round_page(actual * sizeof (*pages));
+               size = vm_map_round_page(actual * sizeof (*pages),
+                                        vm_map_page_mask(ipc_kernel_map));

                kr = kmem_alloc(ipc_kernel_map, &addr, size);
                if (KERN_SUCCESS != kr)
                        return KERN_RESOURCE_SHORTAGE;
                kr = kmem_alloc(ipc_kernel_map, &addr, size);
                if (KERN_SUCCESS != kr)
                        return KERN_RESOURCE_SHORTAGE;


@@ -1135,8 +1175,12 @@ default_pager_object_pages(
        while (actual < potential)
                pages[--potential].dpp_offset = 0;
 
        while (actual < potential)
                pages[--potential].dpp_offset = 0;
 

-       kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(addr),
-                          vm_map_round_page(addr + size), FALSE);
+       kr = vm_map_unwire(ipc_kernel_map,
+                          vm_map_trunc_page(addr,
+                                            vm_map_page_mask(ipc_kernel_map)),
+                          vm_map_round_page(addr + size,
+                                            vm_map_page_mask(ipc_kernel_map)),
+                          FALSE);

        assert(KERN_SUCCESS == kr);
        kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr,
                           (vm_map_size_t)size, TRUE, &copy);
        assert(KERN_SUCCESS == kr);
        kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr,
                           (vm_map_size_t)size, TRUE, &copy);