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

/*
 * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */

/*
 *      Default Pager.
 *              Paging File Management.
 */

#include <mach/host_priv.h>
#include <mach/memory_object_control.h>
#include <mach/memory_object_server.h>
#include <mach/upl.h>
#include <default_pager/default_pager_internal.h>
#include <default_pager/default_pager_alerts.h>
#include <default_pager/default_pager_object_server.h>

#include <ipc/ipc_types.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_space.h>

#include <kern/kern_types.h>
#include <kern/host.h>
#include <kern/queue.h>
#include <kern/counters.h>
#include <kern/sched_prim.h>

#include <vm/vm_kern.h> 
#include <vm/vm_pageout.h>
#include <vm/vm_map.h>
#include <vm/vm_object.h>
#include <vm/vm_protos.h>


/* todo - need large internal object support */

/*
 * ALLOC_STRIDE... the maximum number of bytes allocated from
 * a swap file before moving on to the next swap file... if
 * all swap files reside on a single disk, this value should
 * be very large (this is the default assumption)... if the 
 * swap files are spread across multiple disks, than this value
 * should be small (128 * 1024)...
 *
 * This should be determined dynamically in the future
 */

#define ALLOC_STRIDE  (1024 * 1024 * 1024)
int physical_transfer_cluster_count = 0;

#define VM_SUPER_CLUSTER        0x40000
#define VM_SUPER_PAGES          (VM_SUPER_CLUSTER / PAGE_SIZE)

/*
 * 0 means no shift to pages, so == 1 page/cluster. 1 would mean
 * 2 pages/cluster, 2 means 4 pages/cluster, and so on.
 */
#define VSTRUCT_MIN_CLSHIFT     0

#define VSTRUCT_DEF_CLSHIFT     2
int default_pager_clsize = 0;

int vstruct_def_clshift = VSTRUCT_DEF_CLSHIFT;

/* statistics */
unsigned int clustered_writes[VM_SUPER_PAGES+1];
unsigned int clustered_reads[VM_SUPER_PAGES+1];

/*
 * Globals used for asynchronous paging operations:
 *      vs_async_list:  head of list of to-be-completed I/O ops
 *      async_num_queued: number of pages completed, but not yet
 *              processed by async thread.
 *      async_requests_out: number of pages of requests not completed.
 */

#if 0
struct vs_async *vs_async_list;
int     async_num_queued;
int     async_requests_out;
#endif


#define VS_ASYNC_REUSE 1
struct vs_async *vs_async_free_list;

lck_mtx_t       default_pager_async_lock;       /* Protects globals above */


int vs_alloc_async_failed = 0;                  /* statistics */
int vs_alloc_async_count = 0;                   /* statistics */
struct vs_async *vs_alloc_async(void);          /* forward */
void vs_free_async(struct vs_async *vsa);       /* forward */


#define VS_ALLOC_ASYNC()        vs_alloc_async()
#define VS_FREE_ASYNC(vsa)      vs_free_async(vsa)

#define VS_ASYNC_LOCK()         lck_mtx_lock(&default_pager_async_lock)
#define VS_ASYNC_UNLOCK()       lck_mtx_unlock(&default_pager_async_lock)
#define VS_ASYNC_LOCK_INIT()    lck_mtx_init(&default_pager_async_lock, &default_pager_lck_grp, &default_pager_lck_attr)
#define VS_ASYNC_LOCK_DESTROY() lck_mtx_destroy(&default_pager_async_lock, &default_pager_lck_grp)
#define VS_ASYNC_LOCK_ADDR()    (&default_pager_async_lock)
/*
 *  Paging Space Hysteresis triggers and the target notification port
 *
 */ 
unsigned int    dp_pages_free_drift_count = 0;
unsigned int    dp_pages_free_drifted_max = 0;
unsigned int    minimum_pages_remaining = 0;
unsigned int    maximum_pages_free = 0;
ipc_port_t      min_pages_trigger_port = NULL;
ipc_port_t      max_pages_trigger_port = NULL;

#if CONFIG_FREEZE
boolean_t       use_emergency_swap_file_first = TRUE;
#else
boolean_t       use_emergency_swap_file_first = FALSE;
#endif
boolean_t       bs_low = FALSE;
int             backing_store_release_trigger_disable = 0;
boolean_t       backing_store_stop_compaction = FALSE;
boolean_t       backing_store_abort_compaction = FALSE;

/* Have we decided if swap needs to be encrypted yet ? */
boolean_t       dp_encryption_inited = FALSE;
/* Should we encrypt swap ? */
boolean_t       dp_encryption = FALSE;

boolean_t       dp_isssd = FALSE;

/*
 * Object sizes are rounded up to the next power of 2,
 * unless they are bigger than a given maximum size.
 */
vm_size_t       max_doubled_size = 4 * 1024 * 1024;     /* 4 meg */

/*
 * List of all backing store and segments.
 */
MACH_PORT_FACE          emergency_segment_backing_store;
struct backing_store_list_head backing_store_list;
paging_segment_t        paging_segments[MAX_NUM_PAGING_SEGMENTS];
lck_mtx_t                       paging_segments_lock;
int                     paging_segment_max = 0;
int                     paging_segment_count = 0;
int ps_select_array[BS_MAXPRI+1] = { -1,-1,-1,-1,-1 };


/*
 * Total pages free in system
 * This differs from clusters committed/avail which is a measure of the
 * over commitment of paging segments to backing store.  An idea which is
 * likely to be deprecated.
 */
unsigned  int   dp_pages_free = 0;
unsigned  int   dp_pages_reserve = 0;
unsigned  int   cluster_transfer_minimum = 100;

/* 
 * Trim state 
 */
struct ps_vnode_trim_data {
        struct vnode *vp;
        dp_offset_t   offset;
        dp_size_t     length;
};

/* forward declarations */
kern_return_t ps_write_file(paging_segment_t, upl_t, upl_offset_t, dp_offset_t, unsigned int, int);     /* forward */
kern_return_t ps_read_file (paging_segment_t, upl_t, upl_offset_t, dp_offset_t, unsigned int, unsigned int *, int);     /* forward */
default_pager_thread_t *get_read_buffer( void );
kern_return_t ps_vstruct_transfer_from_segment(
        vstruct_t        vs,
        paging_segment_t segment,
        upl_t            upl);
kern_return_t ps_read_device(paging_segment_t, dp_offset_t, vm_offset_t *, unsigned int, unsigned int *, int);  /* forward */
kern_return_t ps_write_device(paging_segment_t, dp_offset_t, vm_offset_t, unsigned int, struct vs_async *);     /* forward */
kern_return_t vs_cluster_transfer(
        vstruct_t       vs,
        dp_offset_t     offset,
        dp_size_t       cnt,
        upl_t           upl);
vs_map_t vs_get_map_entry(
        vstruct_t       vs, 
        dp_offset_t     offset);

kern_return_t
default_pager_backing_store_delete_internal( MACH_PORT_FACE );

static inline void ps_vnode_trim_init(struct ps_vnode_trim_data *data);
static inline void ps_vnode_trim_now(struct ps_vnode_trim_data *data);
static inline void ps_vnode_trim_more(struct ps_vnode_trim_data *data, struct vs_map *map, unsigned int shift, dp_size_t length);

default_pager_thread_t *
get_read_buffer( void )
{
        int     i;

        DPT_LOCK(dpt_lock);
        while(TRUE) {
                for (i=0; i<default_pager_internal_count; i++) {
                        if(dpt_array[i]->checked_out == FALSE) {
                          dpt_array[i]->checked_out = TRUE;
                          DPT_UNLOCK(dpt_lock);
                          return  dpt_array[i];
                        }
                }
                DPT_SLEEP(dpt_lock, &dpt_array, THREAD_UNINT);
        }
}

void
bs_initialize(void)
{
        int i;

        /*
         * List of all backing store.
         */
        BSL_LOCK_INIT();
        queue_init(&backing_store_list.bsl_queue);
        PSL_LOCK_INIT();

        VS_ASYNC_LOCK_INIT();
#if     VS_ASYNC_REUSE
        vs_async_free_list = NULL;
#endif  /* VS_ASYNC_REUSE */

        for (i = 0; i < VM_SUPER_PAGES + 1; i++) {
                clustered_writes[i] = 0;
                clustered_reads[i] = 0;
        }

}

/*
 * When things do not quite workout...
 */
void bs_no_paging_space(boolean_t);     /* forward */

void
bs_no_paging_space(
        boolean_t out_of_memory)
{

        if (out_of_memory)
                dprintf(("*** OUT OF MEMORY ***\n"));
        panic("bs_no_paging_space: NOT ENOUGH PAGING SPACE");
}

void bs_more_space(int);        /* forward */
void bs_commit(int);            /* forward */

boolean_t       user_warned = FALSE;
unsigned int    clusters_committed = 0;
unsigned int    clusters_available = 0;
unsigned int    clusters_committed_peak = 0;

void
bs_more_space(
        int     nclusters)
{
        BSL_LOCK();
        /*
         * Account for new paging space.
         */
        clusters_available += nclusters;

        if (clusters_available >= clusters_committed) {
                if (verbose && user_warned) {
                        printf("%s%s - %d excess clusters now.\n",
                               my_name,
                               "paging space is OK now",
                               clusters_available - clusters_committed);
                        user_warned = FALSE;
                        clusters_committed_peak = 0;
                }
        } else {
                if (verbose && user_warned) {
                        printf("%s%s - still short of %d clusters.\n",
                               my_name,
                               "WARNING: paging space over-committed",
                               clusters_committed - clusters_available);
                        clusters_committed_peak -= nclusters;
                }
        }
        BSL_UNLOCK();

        return;
}

void
bs_commit(
        int     nclusters)
{
        BSL_LOCK();
        clusters_committed += nclusters;
        if (clusters_committed > clusters_available) {
                if (verbose && !user_warned) {
                        user_warned = TRUE;
                        printf("%s%s - short of %d clusters.\n",
                               my_name,
                               "WARNING: paging space over-committed",
                               clusters_committed - clusters_available);
                }
                if (clusters_committed > clusters_committed_peak) {
                        clusters_committed_peak = clusters_committed;
                }
        } else {
                if (verbose && user_warned) {
                        printf("%s%s - was short of up to %d clusters.\n",
                               my_name,
                               "paging space is OK now",
                               clusters_committed_peak - clusters_available);
                        user_warned = FALSE;
                        clusters_committed_peak = 0;
                }
        }
        BSL_UNLOCK();

        return;
}

int default_pager_info_verbose = 1;

void
bs_global_info(
        uint64_t        *totalp,
        uint64_t        *freep)
{
        uint64_t                pages_total, pages_free;
        paging_segment_t        ps;
        int                     i;

        PSL_LOCK();
        pages_total = pages_free = 0;
        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps == PAGING_SEGMENT_NULL) 
                        continue;

                /*
                 * no need to lock: by the time this data
                 * gets back to any remote requestor it
                 * will be obsolete anyways
                 */
                pages_total += ps->ps_pgnum;
                pages_free += ps->ps_clcount << ps->ps_clshift;
                DP_DEBUG(DEBUG_BS_INTERNAL,
                         ("segment #%d: %d total, %d free\n",
                          i, ps->ps_pgnum, ps->ps_clcount << ps->ps_clshift));
        }
        *totalp = pages_total;
        *freep = pages_free;
        if (verbose && user_warned && default_pager_info_verbose) {
                if (clusters_available < clusters_committed) {
                        printf("%s %d clusters committed, %d available.\n",
                               my_name,
                               clusters_committed,
                               clusters_available);
                }
        }
        PSL_UNLOCK();
}

backing_store_t backing_store_alloc(void);      /* forward */

backing_store_t
backing_store_alloc(void)
{
        backing_store_t bs;

        bs = (backing_store_t) kalloc(sizeof (struct backing_store));
        if (bs == BACKING_STORE_NULL)
                panic("backing_store_alloc: no memory");

        BS_LOCK_INIT(bs);
        bs->bs_port = MACH_PORT_NULL;
        bs->bs_priority = 0;
        bs->bs_clsize = 0;
        bs->bs_pages_total = 0;
        bs->bs_pages_in = 0;
        bs->bs_pages_in_fail = 0;
        bs->bs_pages_out = 0;
        bs->bs_pages_out_fail = 0;

        return bs;
}

backing_store_t backing_store_lookup(MACH_PORT_FACE);   /* forward */

/* Even in both the component space and external versions of this pager, */
/* backing_store_lookup will be called from tasks in the application space */
backing_store_t
backing_store_lookup(
        MACH_PORT_FACE port)
{
        backing_store_t bs;

/*
        port is currently backed with a vs structure in the alias field
        we could create an ISBS alias and a port_is_bs call but frankly
        I see no reason for the test, the bs->port == port check below
        will work properly on junk entries.

        if ((port == MACH_PORT_NULL) || port_is_vs(port))
*/
        if (port == MACH_PORT_NULL)
                return BACKING_STORE_NULL;

        BSL_LOCK();
        queue_iterate(&backing_store_list.bsl_queue, bs, backing_store_t,
                      bs_links) {
                BS_LOCK(bs);
                if (bs->bs_port == port) {
                        BSL_UNLOCK();
                        /* Success, return it locked. */
                        return bs;
                }
                BS_UNLOCK(bs);
        }
        BSL_UNLOCK();
        return BACKING_STORE_NULL;
}

void backing_store_add(backing_store_t);        /* forward */

void
backing_store_add(
        __unused backing_store_t bs)
{
//      MACH_PORT_FACE          port = bs->bs_port;
//      MACH_PORT_FACE          pset = default_pager_default_set;
        kern_return_t           kr = KERN_SUCCESS;

        if (kr != KERN_SUCCESS)
                panic("backing_store_add: add to set");

}

/*
 * Set up default page shift, but only if not already
 * set and argument is within range.
 */
boolean_t
bs_set_default_clsize(unsigned int npages)
{
        switch(npages){
            case 1:
            case 2:
            case 4:
            case 8:
                if (default_pager_clsize == 0)  /* if not yet set */
                        vstruct_def_clshift = local_log2(npages);
                return(TRUE);
        }
        return(FALSE);
}

int bs_get_global_clsize(int clsize);   /* forward */

int
bs_get_global_clsize(
        int     clsize)
{
        int                     i;
        memory_object_default_t dmm;
        kern_return_t           kr;

        /*
         * Only allow setting of cluster size once. If called
         * with no cluster size (default), we use the compiled-in default
         * for the duration. The same cluster size is used for all
         * paging segments.
         */
        if (default_pager_clsize == 0) {
                /*
                 * Keep cluster size in bit shift because it's quicker
                 * arithmetic, and easier to keep at a power of 2.
                 */
                if (clsize != NO_CLSIZE) {
                        for (i = 0; (1 << i) < clsize; i++);
                        if (i > MAX_CLUSTER_SHIFT)
                                i = MAX_CLUSTER_SHIFT;
                        vstruct_def_clshift = i;
                }
                default_pager_clsize = (1 << vstruct_def_clshift);

                /*
                 * Let the user know the new (and definitive) cluster size.
                 */
                if (verbose)
                        printf("%scluster size = %d page%s\n",
                                my_name, default_pager_clsize,
                                (default_pager_clsize == 1) ? "" : "s");

                /*
                 * Let the kernel know too, in case it hasn't used the
                 * default value provided in main() yet.
                 */
                dmm = default_pager_object;
                clsize = default_pager_clsize * vm_page_size;   /* in bytes */
                kr = host_default_memory_manager(host_priv_self(),
                                                 &dmm,
                                                 clsize);
                memory_object_default_deallocate(dmm);

                if (kr != KERN_SUCCESS) {
                   panic("bs_get_global_cl_size:host_default_memory_manager");
                }
                if (dmm != default_pager_object) {
                  panic("bs_get_global_cl_size:there is another default pager");
                }
        }
        ASSERT(default_pager_clsize > 0 &&
               (default_pager_clsize & (default_pager_clsize - 1)) == 0);

        return default_pager_clsize;
}

kern_return_t
default_pager_backing_store_create(
        memory_object_default_t pager,
        int                     priority,
        int                     clsize,         /* in bytes */
        MACH_PORT_FACE          *backing_store)
{
        backing_store_t bs;
        MACH_PORT_FACE  port;
//      kern_return_t   kr;
        struct vstruct_alias *alias_struct;

        if (pager != default_pager_object)
                return KERN_INVALID_ARGUMENT;

        bs = backing_store_alloc();
        port = ipc_port_alloc_kernel();
        ipc_port_make_send(port);
        assert (port != IP_NULL);

        DP_DEBUG(DEBUG_BS_EXTERNAL,
                 ("priority=%d clsize=%d bs_port=0x%x\n",
                  priority, clsize, (int) backing_store));

        alias_struct = (struct vstruct_alias *) 
                                kalloc(sizeof (struct vstruct_alias));
        if(alias_struct != NULL) {
                alias_struct->vs = (struct vstruct *)bs;
                alias_struct->name = &default_pager_ops;
                port->ip_alias = (uintptr_t) alias_struct;
        }
        else {
                ipc_port_dealloc_kernel((MACH_PORT_FACE)(port));

                BS_LOCK_DESTROY(bs);
                kfree(bs, sizeof (struct backing_store));

                return KERN_RESOURCE_SHORTAGE;
        }

        bs->bs_port = port;
        if (priority == DEFAULT_PAGER_BACKING_STORE_MAXPRI)
                priority = BS_MAXPRI;
        else if (priority == BS_NOPRI)
                priority = BS_MAXPRI;
        else
                priority = BS_MINPRI;
        bs->bs_priority = priority;

        bs->bs_clsize = bs_get_global_clsize(atop_32(clsize));

        BSL_LOCK();
        queue_enter(&backing_store_list.bsl_queue, bs, backing_store_t,
                    bs_links);
        BSL_UNLOCK();

        backing_store_add(bs);

        *backing_store = port;
        return KERN_SUCCESS;
}

kern_return_t
default_pager_backing_store_info(
        MACH_PORT_FACE          backing_store,
        backing_store_flavor_t  flavour,
        backing_store_info_t    info,
        mach_msg_type_number_t  *size)
{
        backing_store_t                 bs;
        backing_store_basic_info_t      basic;
        int                             i;
        paging_segment_t                ps;

        if (flavour != BACKING_STORE_BASIC_INFO ||
            *size < BACKING_STORE_BASIC_INFO_COUNT)
                return KERN_INVALID_ARGUMENT;

        basic = (backing_store_basic_info_t)info;
        *size = BACKING_STORE_BASIC_INFO_COUNT;

        VSTATS_LOCK(&global_stats.gs_lock);
        basic->pageout_calls    = global_stats.gs_pageout_calls;
        basic->pagein_calls     = global_stats.gs_pagein_calls;
        basic->pages_in         = global_stats.gs_pages_in;
        basic->pages_out        = global_stats.gs_pages_out;
        basic->pages_unavail    = global_stats.gs_pages_unavail;
        basic->pages_init       = global_stats.gs_pages_init;
        basic->pages_init_writes= global_stats.gs_pages_init_writes;
        VSTATS_UNLOCK(&global_stats.gs_lock);

        if ((bs = backing_store_lookup(backing_store)) == BACKING_STORE_NULL)
                return KERN_INVALID_ARGUMENT;

        basic->bs_pages_total   = bs->bs_pages_total;
        PSL_LOCK();
        bs->bs_pages_free = 0;
        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps != PAGING_SEGMENT_NULL && ps->ps_bs == bs) {
                        PS_LOCK(ps);
                        bs->bs_pages_free += ps->ps_clcount << ps->ps_clshift;
                        PS_UNLOCK(ps);
                }
        }
        PSL_UNLOCK();
        basic->bs_pages_free    = bs->bs_pages_free;
        basic->bs_pages_in      = bs->bs_pages_in;
        basic->bs_pages_in_fail = bs->bs_pages_in_fail;
        basic->bs_pages_out     = bs->bs_pages_out;
        basic->bs_pages_out_fail= bs->bs_pages_out_fail;

        basic->bs_priority      = bs->bs_priority;
        basic->bs_clsize        = ptoa_32(bs->bs_clsize);       /* in bytes */

        BS_UNLOCK(bs);

        return KERN_SUCCESS;
}

int ps_delete(paging_segment_t);        /* forward */
boolean_t current_thread_aborted(void);

int
ps_delete(
        paging_segment_t ps)
{
        vstruct_t       vs;
        kern_return_t   error = KERN_SUCCESS;
        int             vs_count;
        
        VSL_LOCK();             /* get the lock on the list of vs's      */

        /* The lock relationship and sequence is farily complicated      */
        /* this code looks at a live list, locking and unlocking the list */
        /* as it traverses it.  It depends on the locking behavior of    */
        /* default_pager_no_senders.  no_senders always locks the vstruct */
        /* targeted for removal before locking the vstruct list.  However */
        /* it will remove that member of the list without locking its    */
        /* neighbors.  We can be sure when we hold a lock on a vstruct   */
        /* it cannot be removed from the list but we must hold the list  */
        /* lock to be sure that its pointers to its neighbors are valid. */
        /* Also, we can hold off destruction of a vstruct when the list  */
        /* lock and the vs locks are not being held by bumping the       */
        /* vs_async_pending count.      */


        while(backing_store_release_trigger_disable != 0) {
                VSL_SLEEP(&backing_store_release_trigger_disable, THREAD_UNINT);
        }

        /* we will choose instead to hold a send right */
        vs_count = vstruct_list.vsl_count;
        vs = (vstruct_t) queue_first((queue_entry_t)&(vstruct_list.vsl_queue));
        if(vs == (vstruct_t)&vstruct_list)  {
                VSL_UNLOCK();
                return KERN_SUCCESS;
        }
        VS_LOCK(vs);
        vs_async_wait(vs);  /* wait for any pending async writes */
        if ((vs_count != 0) && (vs != NULL))
                vs->vs_async_pending += 1;  /* hold parties calling  */
                                            /* vs_async_wait */

        if (bs_low == FALSE)
                backing_store_abort_compaction = FALSE;

        VS_UNLOCK(vs);
        VSL_UNLOCK();
        while((vs_count != 0) && (vs != NULL)) {
                /* We take the count of AMO's before beginning the         */
                /* transfer of of the target segment.                      */
                /* We are guaranteed that the target segment cannot get    */
                /* more users.  We also know that queue entries are        */
                /* made at the back of the list.  If some of the entries   */
                /* we would check disappear while we are traversing the    */
                /* list then we will either check new entries which        */
                /* do not have any backing store in the target segment     */
                /* or re-check old entries.  This might not be optimal     */
                /* but it will always be correct. The alternative is to    */
                /* take a snapshot of the list.                            */
                vstruct_t       next_vs;
                
                if(dp_pages_free < cluster_transfer_minimum)
                        error = KERN_FAILURE;
                else {
                        vm_object_t     transfer_object;
                        unsigned int    count;
                        upl_t           upl;
                        int             upl_flags;

                        transfer_object = vm_object_allocate((vm_object_size_t)VM_SUPER_CLUSTER);
                        count = 0;
                        upl_flags = (UPL_NO_SYNC | UPL_CLEAN_IN_PLACE |
                                     UPL_SET_LITE | UPL_SET_INTERNAL);
                        if (dp_encryption) {
                                /* mark the pages as "encrypted" when they come in */
                                upl_flags |= UPL_ENCRYPT;
                        }
                        error = vm_object_upl_request(transfer_object, 
                                (vm_object_offset_t)0, VM_SUPER_CLUSTER,
                                &upl, NULL, &count, upl_flags);

                        if(error == KERN_SUCCESS) {
                                error = ps_vstruct_transfer_from_segment(
                                                        vs, ps, upl);
                                upl_commit(upl, NULL, 0);
                                upl_deallocate(upl);
                        } else {
                                error = KERN_FAILURE;
                        }
                        vm_object_deallocate(transfer_object);
                }
                if(error || current_thread_aborted()) {
                        VS_LOCK(vs);
                        vs->vs_async_pending -= 1;  /* release vs_async_wait */
                        if (vs->vs_async_pending == 0 && vs->vs_waiting_async) {
                                vs->vs_waiting_async = FALSE;
                                VS_UNLOCK(vs);
                                thread_wakeup(&vs->vs_async_pending);
                        } else {
                                VS_UNLOCK(vs);
                        }
                        return KERN_FAILURE;
                }

                VSL_LOCK(); 

                while(backing_store_release_trigger_disable != 0) {
                        VSL_SLEEP(&backing_store_release_trigger_disable,
                                  THREAD_UNINT);
                }

                next_vs = (vstruct_t) queue_next(&(vs->vs_links));
                if((next_vs != (vstruct_t)&vstruct_list) && 
                                (vs != next_vs) && (vs_count != 1)) {
                        VS_LOCK(next_vs);
                        vs_async_wait(next_vs);  /* wait for any  */
                                                 /* pending async writes */
                        next_vs->vs_async_pending += 1; /* hold parties  */
                                                /* calling vs_async_wait */
                        VS_UNLOCK(next_vs);
                }
                VSL_UNLOCK();
                VS_LOCK(vs);
                vs->vs_async_pending -= 1; 
                if (vs->vs_async_pending == 0 && vs->vs_waiting_async) {
                        vs->vs_waiting_async = FALSE;
                        VS_UNLOCK(vs);
                        thread_wakeup(&vs->vs_async_pending);
                } else {
                        VS_UNLOCK(vs);
                }
                if((vs == next_vs) || (next_vs == (vstruct_t)&vstruct_list))
                        vs = NULL;
                else
                        vs = next_vs;
                vs_count--;
        }
        return KERN_SUCCESS;
}


kern_return_t
default_pager_backing_store_delete_internal(
        MACH_PORT_FACE backing_store)
{
        backing_store_t         bs;
        int                     i;
        paging_segment_t        ps;
        int                     error;
        int                     interim_pages_removed = 0;
        boolean_t               dealing_with_emergency_segment = ( backing_store == emergency_segment_backing_store );

        if ((bs = backing_store_lookup(backing_store)) == BACKING_STORE_NULL)
                return KERN_INVALID_ARGUMENT;

restart:
        PSL_LOCK();
        error = KERN_SUCCESS;
        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps != PAGING_SEGMENT_NULL &&
                    ps->ps_bs == bs &&
                    ! IS_PS_GOING_AWAY(ps)) {
                        PS_LOCK(ps);
                        
                        if( IS_PS_GOING_AWAY(ps) || !IS_PS_OK_TO_USE(ps)) {
                        /* 
                         * Someone is already busy reclamining this paging segment.
                         * If it's the emergency segment we are looking at then check
                         * that someone has not already recovered it and set the right
                         * state i.e. online but not activated.
                         */
                                PS_UNLOCK(ps);
                                continue;
                        }

                        /* disable access to this segment */
                        ps->ps_state &= ~PS_CAN_USE;
                        ps->ps_state |= PS_GOING_AWAY;
                        PS_UNLOCK(ps);
                        /*
                         * The "ps" segment is "off-line" now,
                         * we can try and delete it...
                         */
                        if(dp_pages_free < (cluster_transfer_minimum
                                                        + ps->ps_pgcount)) {
                                error = KERN_FAILURE;
                                PSL_UNLOCK();
                        }
                        else {
                                /* remove all pages associated with the  */
                                /* segment from the list of free pages   */
                                /* when transfer is through, all target  */
                                /* segment pages will appear to be free  */
                                
                                dp_pages_free -=  ps->ps_pgcount;
                                interim_pages_removed += ps->ps_pgcount;
                                PSL_UNLOCK();
                                error = ps_delete(ps);
                        }
                        if (error != KERN_SUCCESS) {
                                /*
                                 * We couldn't delete the segment,
                                 * probably because there's not enough
                                 * virtual memory left.
                                 * Re-enable all the segments.
                                 */
                                PSL_LOCK();
                                break;
                        }
                        goto restart;
                }
        }

        if (error != KERN_SUCCESS) {
                for (i = 0; i <= paging_segment_max; i++) {
                        ps = paging_segments[i];
                        if (ps != PAGING_SEGMENT_NULL &&
                            ps->ps_bs == bs &&
                            IS_PS_GOING_AWAY(ps)) {
                                PS_LOCK(ps);
                                
                                if( !IS_PS_GOING_AWAY(ps)) {
                                        PS_UNLOCK(ps);
                                        continue;
                                }
                                /* Handle the special clusters that came in while we let go the lock*/  
                                if( ps->ps_special_clusters) {
                                        dp_pages_free += ps->ps_special_clusters << ps->ps_clshift;
                                        ps->ps_pgcount += ps->ps_special_clusters << ps->ps_clshift;
                                        ps->ps_clcount += ps->ps_special_clusters;
                                        if ( ps_select_array[ps->ps_bs->bs_priority] == BS_FULLPRI) {
                                                ps_select_array[ps->ps_bs->bs_priority] = 0;
                                        }
                                        ps->ps_special_clusters = 0;
                                }
                                /* re-enable access to this segment */
                                ps->ps_state &= ~PS_GOING_AWAY;
                                ps->ps_state |= PS_CAN_USE;
                                PS_UNLOCK(ps);
                        }
                }
                dp_pages_free += interim_pages_removed;
                PSL_UNLOCK();
                BS_UNLOCK(bs);
                return error;
        }

        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps != PAGING_SEGMENT_NULL &&
                    ps->ps_bs == bs) { 
                        if(IS_PS_GOING_AWAY(ps)) {
                                if(IS_PS_EMERGENCY_SEGMENT(ps)) {
                                        PS_LOCK(ps);
                                        ps->ps_state &= ~PS_GOING_AWAY;
                                        ps->ps_special_clusters = 0;
                                        ps->ps_pgcount = ps->ps_pgnum;
                                        ps->ps_clcount = ps->ps_ncls = ps->ps_pgcount >> ps->ps_clshift;
                                        dp_pages_reserve += ps->ps_pgcount;
                                        PS_UNLOCK(ps);
                                } else {
                                        paging_segments[i] = PAGING_SEGMENT_NULL;
                                        paging_segment_count--;
                                        PS_LOCK(ps);
                                        kfree(ps->ps_bmap, RMAPSIZE(ps->ps_ncls));
                                        kfree(ps, sizeof *ps);
                                }
                        }
                }
        }

        /* Scan the entire ps array separately to make certain we find the */
        /* proper paging_segment_max                                       */
        for (i = 0; i < MAX_NUM_PAGING_SEGMENTS; i++) {
                if(paging_segments[i] != PAGING_SEGMENT_NULL)
                   paging_segment_max = i;
        }

        PSL_UNLOCK();

        if( dealing_with_emergency_segment ) {
                BS_UNLOCK(bs);
                return KERN_SUCCESS;
        }

        /*
         * All the segments have been deleted.
         * We can remove the backing store.
         */

        /*
         * Disable lookups of this backing store.
         */
        if((void *)bs->bs_port->ip_alias != NULL)
                kfree((void *) bs->bs_port->ip_alias,
                      sizeof (struct vstruct_alias));
        ipc_port_dealloc_kernel((ipc_port_t) (bs->bs_port));
        bs->bs_port = MACH_PORT_NULL;
        BS_UNLOCK(bs);

        /*
         * Remove backing store from backing_store list.
         */
        BSL_LOCK();
        queue_remove(&backing_store_list.bsl_queue, bs, backing_store_t,
                     bs_links);
        BSL_UNLOCK();

        /*
         * Free the backing store structure.
         */
        BS_LOCK_DESTROY(bs);
        kfree(bs, sizeof *bs);

        return KERN_SUCCESS;
}

kern_return_t
default_pager_backing_store_delete(
        MACH_PORT_FACE backing_store) 
{
        if( backing_store != emergency_segment_backing_store ) {
                default_pager_backing_store_delete_internal(emergency_segment_backing_store);
        }
        return(default_pager_backing_store_delete_internal(backing_store));
}

int     ps_enter(paging_segment_t);     /* forward */

int
ps_enter(
        paging_segment_t ps)
{
        int i;

        PSL_LOCK();

        for (i = 0; i < MAX_NUM_PAGING_SEGMENTS; i++) {
                if (paging_segments[i] == PAGING_SEGMENT_NULL)
                        break;
        }

        if (i < MAX_NUM_PAGING_SEGMENTS) {
                paging_segments[i] = ps;
                if (i > paging_segment_max)
                        paging_segment_max = i;
                paging_segment_count++;
                if ((ps_select_array[ps->ps_bs->bs_priority] == BS_NOPRI) ||
                        (ps_select_array[ps->ps_bs->bs_priority] == BS_FULLPRI))
                        ps_select_array[ps->ps_bs->bs_priority] = 0;
                i = 0;
        } else {
                PSL_UNLOCK();
                return KERN_RESOURCE_SHORTAGE;
        }

        PSL_UNLOCK();
        return i;
}

#ifdef DEVICE_PAGING
kern_return_t
default_pager_add_segment(
        MACH_PORT_FACE  backing_store,
        MACH_PORT_FACE  device,
        recnum_t        offset,
        recnum_t        count,
        int             record_size)
{
        backing_store_t         bs;
        paging_segment_t        ps;
        int                     i;
        int                     error;

        if ((bs = backing_store_lookup(backing_store))
            == BACKING_STORE_NULL)
                return KERN_INVALID_ARGUMENT;

        PSL_LOCK();
        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps == PAGING_SEGMENT_NULL)
                        continue;

                /*
                 * Check for overlap on same device.
                 */
                if (!(ps->ps_device != device
                      || offset >= ps->ps_offset + ps->ps_recnum
                      || offset + count <= ps->ps_offset)) {
                        PSL_UNLOCK();
                        BS_UNLOCK(bs);
                        return KERN_INVALID_ARGUMENT;
                }
        }
        PSL_UNLOCK();

        /*
         * Set up the paging segment
         */
        ps = (paging_segment_t) kalloc(sizeof (struct paging_segment));
        if (ps == PAGING_SEGMENT_NULL) {
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }

        ps->ps_segtype = PS_PARTITION;
        ps->ps_device = device;
        ps->ps_offset = offset;
        ps->ps_record_shift = local_log2(vm_page_size / record_size);
        ps->ps_recnum = count;
        ps->ps_pgnum = count >> ps->ps_record_shift;

        ps->ps_pgcount = ps->ps_pgnum;
        ps->ps_clshift = local_log2(bs->bs_clsize);
        ps->ps_clcount = ps->ps_ncls = ps->ps_pgcount >> ps->ps_clshift;
        ps->ps_hint = 0;

        PS_LOCK_INIT(ps);
        ps->ps_bmap = (unsigned char *) kalloc(RMAPSIZE(ps->ps_ncls));
        if (!ps->ps_bmap) {
                PS_LOCK_DESTROY(ps);
                kfree(ps, sizeof *ps);
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }
        for (i = 0; i < ps->ps_ncls; i++) {
                clrbit(ps->ps_bmap, i);
        }

        if(paging_segment_count == 0) {
                ps->ps_state = PS_EMERGENCY_SEGMENT;
                if(use_emergency_swap_file_first) {
                        ps->ps_state |= PS_CAN_USE;
                }
        } else {
                ps->ps_state = PS_CAN_USE;
        }

        ps->ps_bs = bs;

        if ((error = ps_enter(ps)) != 0) {
                kfree(ps->ps_bmap, RMAPSIZE(ps->ps_ncls));

                PS_LOCK_DESTROY(ps);
                kfree(ps, sizeof *ps);
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }

        bs->bs_pages_free += ps->ps_clcount << ps->ps_clshift;
        bs->bs_pages_total += ps->ps_clcount << ps->ps_clshift;
        BS_UNLOCK(bs);

        PSL_LOCK();
        if(IS_PS_OK_TO_USE(ps)) {
                dp_pages_free += ps->ps_pgcount;
        } else {
                dp_pages_reserve += ps->ps_pgcount;
        }
        PSL_UNLOCK();

        bs_more_space(ps->ps_clcount);

        DP_DEBUG(DEBUG_BS_INTERNAL,
                 ("device=0x%x,offset=0x%x,count=0x%x,record_size=0x%x,shift=%d,total_size=0x%x\n",
                  device, offset, count, record_size,
                  ps->ps_record_shift, ps->ps_pgnum));

        return KERN_SUCCESS;
}

boolean_t
bs_add_device(
        char            *dev_name,
        MACH_PORT_FACE  master)
{
        security_token_t        null_security_token = {
                { 0, 0 }
        };
        MACH_PORT_FACE  device;
        int             info[DEV_GET_SIZE_COUNT];
        mach_msg_type_number_t info_count;
        MACH_PORT_FACE  bs = MACH_PORT_NULL;
        unsigned int    rec_size;
        recnum_t        count;
        int             clsize;
        MACH_PORT_FACE  reply_port;

        if (ds_device_open_sync(master, MACH_PORT_NULL, D_READ | D_WRITE,
                        null_security_token, dev_name, &device))
                return FALSE;

        info_count = DEV_GET_SIZE_COUNT;
        if (!ds_device_get_status(device, DEV_GET_SIZE, info, &info_count)) {
                rec_size = info[DEV_GET_SIZE_RECORD_SIZE];
                count = info[DEV_GET_SIZE_DEVICE_SIZE] /  rec_size;
                clsize = bs_get_global_clsize(0);
                if (!default_pager_backing_store_create(
                                        default_pager_object,
                                        DEFAULT_PAGER_BACKING_STORE_MAXPRI,
                                        (clsize * vm_page_size),
                                        &bs)) {
                        if (!default_pager_add_segment(bs, device,
                                                       0, count, rec_size)) {
                                return TRUE;
                        }
                        ipc_port_release_receive(bs);
                }
        }

        ipc_port_release_send(device);
        return FALSE;
}
#endif /* DEVICE_PAGING */

#if     VS_ASYNC_REUSE

struct vs_async *
vs_alloc_async(void)
{
        struct vs_async *vsa;
        MACH_PORT_FACE  reply_port;
//      kern_return_t   kr;

        VS_ASYNC_LOCK();
        if (vs_async_free_list == NULL) {
                VS_ASYNC_UNLOCK();
                vsa = (struct vs_async *) kalloc(sizeof (struct vs_async));
                if (vsa != NULL) {
                        /*
                         * Try allocating a reply port named after the
                         * address of the vs_async structure.
                         */
                        struct vstruct_alias    *alias_struct;

                        reply_port = ipc_port_alloc_kernel();
                        alias_struct = (struct vstruct_alias *) 
                                kalloc(sizeof (struct vstruct_alias));
                        if(alias_struct != NULL) {
                                alias_struct->vs = (struct vstruct *)vsa;
                                alias_struct->name = &default_pager_ops;
                                reply_port->ip_alias = (uintptr_t) alias_struct;
                                vsa->reply_port = reply_port;
                                vs_alloc_async_count++;
                        }
                        else {
                                vs_alloc_async_failed++;
                                ipc_port_dealloc_kernel((MACH_PORT_FACE) 
                                                                (reply_port));
                                kfree(vsa, sizeof (struct vs_async));
                                vsa = NULL;
                        }
                }
        } else {
                vsa = vs_async_free_list;
                vs_async_free_list = vs_async_free_list->vsa_next;
                VS_ASYNC_UNLOCK();
        }

        return vsa;
}

void
vs_free_async(
        struct vs_async *vsa)
{
        VS_ASYNC_LOCK();
        vsa->vsa_next = vs_async_free_list;
        vs_async_free_list = vsa;
        VS_ASYNC_UNLOCK();
}

#else   /* VS_ASYNC_REUSE */

struct vs_async *
vs_alloc_async(void)
{
        struct vs_async *vsa;
        MACH_PORT_FACE  reply_port;
        kern_return_t   kr;

        vsa = (struct vs_async *) kalloc(sizeof (struct vs_async));
        if (vsa != NULL) {
                /*
                 * Try allocating a reply port named after the
                 * address of the vs_async structure.
                 */
                        reply_port = ipc_port_alloc_kernel();
                        alias_struct = (vstruct_alias *) 
                                kalloc(sizeof (struct vstruct_alias));
                        if(alias_struct != NULL) {
                                alias_struct->vs = reply_port;
                                alias_struct->name = &default_pager_ops;
                                reply_port->defpager_importance.alias = (int) vsa;
                                vsa->reply_port = reply_port;
                                vs_alloc_async_count++;
                        }
                        else {
                                vs_alloc_async_failed++;
                                ipc_port_dealloc_kernel((MACH_PORT_FACE) 
                                                                (reply_port));
                                kfree(vsa, sizeof (struct vs_async));
                                vsa = NULL;
                        }
        }

        return vsa;
}

void
vs_free_async(
        struct vs_async *vsa)
{
        MACH_PORT_FACE  reply_port;
        kern_return_t   kr;

        reply_port = vsa->reply_port;
        kfree(reply_port->ip_alias, sizeof (struct vstuct_alias));
        kfree(vsa, sizeof (struct vs_async));
        ipc_port_dealloc_kernel((MACH_PORT_FACE) (reply_port));
#if 0
        VS_ASYNC_LOCK();
        vs_alloc_async_count--;
        VS_ASYNC_UNLOCK();
#endif
}

#endif  /* VS_ASYNC_REUSE */

zone_t  vstruct_zone;

vstruct_t
ps_vstruct_create(
        dp_size_t size)
{
        vstruct_t       vs;
        unsigned int    i;

        vs = (vstruct_t) zalloc(vstruct_zone);
        if (vs == VSTRUCT_NULL) {
                return VSTRUCT_NULL;
        }

        VS_LOCK_INIT(vs);

        /*
         * The following fields will be provided later.
         */
        vs->vs_pager_ops = NULL;
        vs->vs_control = MEMORY_OBJECT_CONTROL_NULL;
        vs->vs_references = 1;
        vs->vs_seqno = 0;

        vs->vs_waiting_seqno = FALSE;
        vs->vs_waiting_read = FALSE;
        vs->vs_waiting_write = FALSE;
        vs->vs_waiting_async = FALSE;

        vs->vs_readers = 0;
        vs->vs_writers = 0;

        vs->vs_errors = 0;

        vs->vs_clshift = local_log2(bs_get_global_clsize(0));
        vs->vs_size = ((atop_32(round_page_32(size)) - 1) >> vs->vs_clshift) + 1;
        vs->vs_async_pending = 0;

        /*
         * Allocate the pmap, either CLMAP_SIZE or INDIRECT_CLMAP_SIZE
         * depending on the size of the memory object.
         */
        if (INDIRECT_CLMAP(vs->vs_size)) {
                vs->vs_imap = (struct vs_map **)
                        kalloc(INDIRECT_CLMAP_SIZE(vs->vs_size));
                vs->vs_indirect = TRUE;
        } else {
                vs->vs_dmap = (struct vs_map *)
                        kalloc(CLMAP_SIZE(vs->vs_size));
                vs->vs_indirect = FALSE;
        }
        vs->vs_xfer_pending = FALSE;
        DP_DEBUG(DEBUG_VS_INTERNAL,
                 ("map=0x%x, indirect=%d\n", (int) vs->vs_dmap, vs->vs_indirect));

        /*
         * Check to see that we got the space.
         */
        if (!vs->vs_dmap) {
                kfree(vs, sizeof *vs);
                return VSTRUCT_NULL;
        }

        /*
         * Zero the indirect pointers, or clear the direct pointers.
         */
        if (vs->vs_indirect)
                memset(vs->vs_imap, 0,
                       INDIRECT_CLMAP_SIZE(vs->vs_size));
        else
                for (i = 0; i < vs->vs_size; i++) 
                        VSM_CLR(vs->vs_dmap[i]);

        VS_MAP_LOCK_INIT(vs);

        bs_commit(vs->vs_size);

        return vs;
}

paging_segment_t ps_select_segment(unsigned int, int *);        /* forward */

paging_segment_t
ps_select_segment(
        unsigned int    shift,
        int             *psindex)
{
        paging_segment_t        ps;
        int                     i;
        int                     j;

        /*
         * Optimize case where there's only one segment.
         * paging_segment_max will index the one and only segment.
         */

        PSL_LOCK();
        if (paging_segment_count == 1) {
                paging_segment_t lps = PAGING_SEGMENT_NULL;     /* used to avoid extra PS_UNLOCK */
                ipc_port_t trigger = IP_NULL;

                ps = paging_segments[paging_segment_max];
                *psindex = paging_segment_max;
                PS_LOCK(ps);
                if( !IS_PS_EMERGENCY_SEGMENT(ps) ) {
                        panic("Emergency paging segment missing\n");
                }
                ASSERT(ps->ps_clshift >= shift);
                if(IS_PS_OK_TO_USE(ps)) {
                        if (ps->ps_clcount) {
                                ps->ps_clcount--;
                                dp_pages_free -=  1 << ps->ps_clshift;
                                ps->ps_pgcount -=  1 << ps->ps_clshift;
                                if(min_pages_trigger_port && 
                                  (dp_pages_free < minimum_pages_remaining)) {
                                        trigger = min_pages_trigger_port;
                                        min_pages_trigger_port = NULL;
                                        bs_low = TRUE;
                                        backing_store_abort_compaction = TRUE;
                                }
                                lps = ps;
                        } 
                } 
                PS_UNLOCK(ps);
                
                if( lps == PAGING_SEGMENT_NULL ) {
                        if(dp_pages_free) {
                                dp_pages_free_drift_count++;
                                if(dp_pages_free > dp_pages_free_drifted_max) {
                                        dp_pages_free_drifted_max = dp_pages_free;
                                }
                                dprintf(("Emergency swap segment:dp_pages_free before zeroing out: %d\n",dp_pages_free));
                        }
                        dp_pages_free = 0;
                }

                PSL_UNLOCK();

                if (trigger != IP_NULL) {
                        dprintf(("ps_select_segment - send HI_WAT_ALERT\n"));

                        default_pager_space_alert(trigger, HI_WAT_ALERT);
                        ipc_port_release_send(trigger);
                }
                return lps;
        }

        if (paging_segment_count == 0) {
                if(dp_pages_free) {
                        dp_pages_free_drift_count++;
                        if(dp_pages_free > dp_pages_free_drifted_max) {
                                dp_pages_free_drifted_max = dp_pages_free;
                        }
                        dprintf(("No paging segments:dp_pages_free before zeroing out: %d\n",dp_pages_free));
                }
                dp_pages_free = 0;
                PSL_UNLOCK();
                return PAGING_SEGMENT_NULL;
        }

        for (i = BS_MAXPRI;
             i >= BS_MINPRI; i--) {
                int start_index;

                if ((ps_select_array[i] == BS_NOPRI) ||
                                (ps_select_array[i] == BS_FULLPRI))
                        continue;
                start_index = ps_select_array[i];

                if(!(paging_segments[start_index])) {
                        j = start_index+1;
                        physical_transfer_cluster_count = 0;
                }
                else if ((physical_transfer_cluster_count+1) == (ALLOC_STRIDE >> 
                                (((paging_segments[start_index])->ps_clshift)
                                + vm_page_shift))) {
                        physical_transfer_cluster_count = 0;
                        j = start_index + 1;
                } else {
                        physical_transfer_cluster_count+=1;
                        j = start_index;
                        if(start_index == 0)
                                start_index = paging_segment_max; 
                        else
                                start_index = start_index - 1;
                }

                while (1) {
                        if (j > paging_segment_max)
                                j = 0;
                        if ((ps = paging_segments[j]) &&
                            (ps->ps_bs->bs_priority == i)) {
                                /*
                                 * Force the ps cluster size to be
                                 * >= that of the vstruct.
                                 */
                                PS_LOCK(ps);
                                if (IS_PS_OK_TO_USE(ps)) {
                                        if ((ps->ps_clcount) &&
                                                   (ps->ps_clshift >= shift)) {
                                                ipc_port_t trigger = IP_NULL;

                                                ps->ps_clcount--;
                                                dp_pages_free -=  1 << ps->ps_clshift;
                                                ps->ps_pgcount -=  1 << ps->ps_clshift;
                                                if(min_pages_trigger_port && 
                                                        (dp_pages_free < 
                                                        minimum_pages_remaining)) {
                                                        trigger = min_pages_trigger_port;
                                                        min_pages_trigger_port = NULL;
                                                        bs_low = TRUE;
                                                        backing_store_abort_compaction = TRUE;
                                                }
                                                PS_UNLOCK(ps);
                                                /*
                                                 * found one, quit looking.
                                                 */
                                                ps_select_array[i] = j;
                                                PSL_UNLOCK();
                                                
                                                if (trigger != IP_NULL) {
                                                        dprintf(("ps_select_segment - send HI_WAT_ALERT\n"));

                                                        default_pager_space_alert(
                                                                trigger,
                                                                HI_WAT_ALERT);
                                                        ipc_port_release_send(trigger);
                                                }
                                                *psindex = j;
                                                return ps;
                                        }
                                }
                                PS_UNLOCK(ps);
                        }
                        if (j == start_index) {
                                /*
                                 * none at this priority -- mark it full
                                 */
                                ps_select_array[i] = BS_FULLPRI;
                                break;
                        }
                        j++;
                }
        }
        
        if(dp_pages_free) {
                dp_pages_free_drift_count++;
                if(dp_pages_free > dp_pages_free_drifted_max) {
                        dp_pages_free_drifted_max = dp_pages_free;
                }
                dprintf(("%d Paging Segments: dp_pages_free before zeroing out: %d\n",paging_segment_count,dp_pages_free));
        }
        dp_pages_free = 0;
        PSL_UNLOCK();
        return PAGING_SEGMENT_NULL;
}

dp_offset_t ps_allocate_cluster(vstruct_t, int *, paging_segment_t); /*forward*/

dp_offset_t
ps_allocate_cluster(
        vstruct_t               vs,
        int                     *psindex,
        paging_segment_t        use_ps)
{
        unsigned int            byte_num;
        int                     bit_num = 0;
        paging_segment_t        ps;
        dp_offset_t             cluster;
        ipc_port_t              trigger = IP_NULL;

        /*
         * Find best paging segment.
         * ps_select_segment will decrement cluster count on ps.
         * Must pass cluster shift to find the most appropriate segment.
         */
        /* NOTE:  The addition of paging segment delete capability threatened
         * to seriously complicate the treatment of paging segments in this
         * module and the ones that call it (notably ps_clmap), because of the
         * difficulty in assuring that the paging segment would continue to
         * exist between being unlocked and locked.   This was
         * avoided because all calls to this module are based in either
         * dp_memory_object calls which rely on the vs lock, or by
         * the transfer function which is part of the segment delete path.
         * The transfer function which is part of paging segment delete is 
         * protected from multiple callers by the backing store lock.  
         * The paging segment delete function treats mappings to a paging 
         * segment on a vstruct by vstruct basis, locking the vstruct targeted 
         * while data is transferred to the remaining segments.  This is in
         * line with the view that incomplete or in-transition mappings between
         * data, a vstruct, and backing store are protected by the vs lock. 
         * This and the ordering of the paging segment "going_away" bit setting
         * protects us.
         */
retry:
        if (use_ps != PAGING_SEGMENT_NULL) {
                ps = use_ps;
                PSL_LOCK();
                PS_LOCK(ps);

                ASSERT(ps->ps_clcount != 0);

                ps->ps_clcount--;
                dp_pages_free -=  1 << ps->ps_clshift;
                ps->ps_pgcount -=  1 << ps->ps_clshift;
                if(min_pages_trigger_port && 
                                (dp_pages_free < minimum_pages_remaining)) {
                        trigger = min_pages_trigger_port;
                        min_pages_trigger_port = NULL;
                        bs_low = TRUE;
                        backing_store_abort_compaction = TRUE;
                }
                PSL_UNLOCK();
                PS_UNLOCK(ps);
                if (trigger != IP_NULL) {
                        dprintf(("ps_allocate_cluster - send HI_WAT_ALERT\n"));

                        default_pager_space_alert(trigger, HI_WAT_ALERT);
                        ipc_port_release_send(trigger);
                }

        } else if ((ps = ps_select_segment(vs->vs_clshift, psindex)) ==
                   PAGING_SEGMENT_NULL) {
                static clock_sec_t lastnotify = 0;
                clock_sec_t now;
                clock_nsec_t nanoseconds_dummy;
                
                /* 
                 * Don't immediately jump to the emergency segment. Give the
                 * dynamic pager a chance to create it's first normal swap file.
                 * Unless, of course the very first normal swap file can't be 
                 * created due to some problem and we didn't expect that problem
                 * i.e. use_emergency_swap_file_first was never set to true initially.
                 * It then gets set in the swap file creation error handling.
                 */
                if(paging_segment_count > 1 || use_emergency_swap_file_first == TRUE) {
                        
                        ps = paging_segments[EMERGENCY_PSEG_INDEX];
                        if(IS_PS_EMERGENCY_SEGMENT(ps) && !IS_PS_GOING_AWAY(ps)) {
                                PSL_LOCK();
                                PS_LOCK(ps);
                                
                                if(IS_PS_GOING_AWAY(ps)) {
                                        /* Someone de-activated the emergency paging segment*/
                                        PS_UNLOCK(ps);
                                        PSL_UNLOCK();

                                } else if(dp_pages_free) {
                                        /* 
                                         * Someone has already activated the emergency paging segment 
                                         * OR
                                         * Between us having rec'd a NULL segment from ps_select_segment
                                         * and reaching here a new normal segment could have been added.
                                         * E.g. we get NULL segment and another thread just added the
                                         * new swap file. Hence check to see if we have more dp_pages_free
                                         * before activating the emergency segment.
                                         */
                                        PS_UNLOCK(ps);
                                        PSL_UNLOCK();
                                        goto retry;
                                
                                } else if(!IS_PS_OK_TO_USE(ps) && ps->ps_clcount) {
                                        /*
                                         * PS_CAN_USE is only reset from the emergency segment when it's
                                         * been successfully recovered. So it's legal to have an emergency
                                         * segment that has PS_CAN_USE but no clusters because it's recovery
                                         * failed.
                                         */
                                        backing_store_t bs = ps->ps_bs;
                                        ps->ps_state |= PS_CAN_USE;
                                        if(ps_select_array[bs->bs_priority] == BS_FULLPRI ||
                                                ps_select_array[bs->bs_priority] == BS_NOPRI) {
                                                ps_select_array[bs->bs_priority] = 0;
                                        }
                                        dp_pages_free += ps->ps_pgcount;
                                        dp_pages_reserve -= ps->ps_pgcount;
                                        PS_UNLOCK(ps);
                                        PSL_UNLOCK();
                                        dprintf(("Switching ON Emergency paging segment\n"));
                                        goto retry;
                                }

                                PS_UNLOCK(ps);
                                PSL_UNLOCK();
                        }
                }
                
                /*
                 * Emit a notification of the low-paging resource condition
                 * but don't issue it more than once every five seconds.  This
                 * prevents us from overflowing logs with thousands of
                 * repetitions of the message.
                 */
                clock_get_system_nanotime(&now, &nanoseconds_dummy);
                if (paging_segment_count > 1 && (now > lastnotify + 5)) {
                        /* With an activated emergency paging segment we still
                         * didn't get any clusters. This could mean that the 
                         * emergency paging segment is exhausted.
                         */
                        dprintf(("System is out of paging space.\n"));
                        lastnotify = now;
                }

                PSL_LOCK();
                
                if(min_pages_trigger_port) {
                        trigger = min_pages_trigger_port;
                        min_pages_trigger_port = NULL;
                        bs_low = TRUE;
                        backing_store_abort_compaction = TRUE;
                }
                PSL_UNLOCK();
                if (trigger != IP_NULL) {
                        dprintf(("ps_allocate_cluster - send HI_WAT_ALERT\n"));

                        default_pager_space_alert(trigger, HI_WAT_ALERT);
                        ipc_port_release_send(trigger);
                }
                return (dp_offset_t) -1;
        }

        /*
         * Look for an available cluster.  At the end of the loop,
         * byte_num is the byte offset and bit_num is the bit offset of the
         * first zero bit in the paging segment bitmap.
         */
        PS_LOCK(ps);
        byte_num = ps->ps_hint;
        for (; byte_num < howmany(ps->ps_ncls, NBBY); byte_num++) {
                if (*(ps->ps_bmap + byte_num) != BYTEMASK) {
                        for (bit_num = 0; bit_num < NBBY; bit_num++) {
                                if (isclr((ps->ps_bmap + byte_num), bit_num))
                                        break;
                        }
                        ASSERT(bit_num != NBBY);
                        break;
                }
        }
        ps->ps_hint = byte_num;
        cluster = (byte_num*NBBY) + bit_num;

        /* Space was reserved, so this must be true */
        ASSERT(cluster < ps->ps_ncls);

        setbit(ps->ps_bmap, cluster);
        PS_UNLOCK(ps);

        return cluster;
}

void ps_deallocate_cluster(paging_segment_t, dp_offset_t);      /* forward */

void
ps_deallocate_cluster(
        paging_segment_t        ps,
        dp_offset_t             cluster)
{

        if (cluster >= ps->ps_ncls)
                panic("ps_deallocate_cluster: Invalid cluster number");

        /*
         * Lock the paging segment, clear the cluster's bitmap and increment the
         * number of free cluster.
         */
        PSL_LOCK();
        PS_LOCK(ps);
        clrbit(ps->ps_bmap, cluster);
        if( IS_PS_OK_TO_USE(ps)) {
                ++ps->ps_clcount;
                ps->ps_pgcount +=  1 << ps->ps_clshift;
                dp_pages_free +=  1 << ps->ps_clshift;
        } else {
                ps->ps_special_clusters += 1;
        }

        /*
         * Move the hint down to the freed cluster if it is
         * less than the current hint.
         */
        if ((cluster/NBBY) < ps->ps_hint) {
                ps->ps_hint = (cluster/NBBY);
        }


        /*
         * If we're freeing space on a full priority, reset the array.
         */
        if ( IS_PS_OK_TO_USE(ps) && ps_select_array[ps->ps_bs->bs_priority] == BS_FULLPRI)
                ps_select_array[ps->ps_bs->bs_priority] = 0;
        PS_UNLOCK(ps);
        PSL_UNLOCK();

        return;
}

void ps_dealloc_vsmap(struct vs_map *, dp_size_t);      /* forward */

void
ps_dealloc_vsmap(
        struct vs_map   *vsmap,
        dp_size_t       size)
{
        unsigned int i;
        struct ps_vnode_trim_data trim_data;

        ps_vnode_trim_init(&trim_data);

        for (i = 0; i < size; i++) {
                if (!VSM_ISCLR(vsmap[i]) && !VSM_ISERR(vsmap[i])) {
                        ps_vnode_trim_more(&trim_data,
                                              &vsmap[i],
                                              VSM_PS(vsmap[i])->ps_clshift,
                                              vm_page_size << VSM_PS(vsmap[i])->ps_clshift);
                        ps_deallocate_cluster(VSM_PS(vsmap[i]),
                                              VSM_CLOFF(vsmap[i]));
                } else {
                        ps_vnode_trim_now(&trim_data);
                }
        }
        ps_vnode_trim_now(&trim_data);
}

void
ps_vstruct_dealloc(
        vstruct_t vs)
{
        unsigned int    i;
//      spl_t   s;

        VS_MAP_LOCK(vs);

        /*
         * If this is an indirect structure, then we walk through the valid
         * (non-zero) indirect pointers and deallocate the clusters
         * associated with each used map entry (via ps_dealloc_vsmap).
         * When all of the clusters in an indirect block have been
         * freed, we deallocate the block.  When all of the indirect
         * blocks have been deallocated we deallocate the memory
         * holding the indirect pointers.
         */
        if (vs->vs_indirect) {
                for (i = 0; i < INDIRECT_CLMAP_ENTRIES(vs->vs_size); i++) {
                        if (vs->vs_imap[i] != NULL) {
                                ps_dealloc_vsmap(vs->vs_imap[i], CLMAP_ENTRIES);
                                kfree(vs->vs_imap[i], CLMAP_THRESHOLD);
                        }
                }
                kfree(vs->vs_imap, INDIRECT_CLMAP_SIZE(vs->vs_size));
        } else {
                /*
                 * Direct map.  Free used clusters, then memory.
                 */
                ps_dealloc_vsmap(vs->vs_dmap, vs->vs_size);
                kfree(vs->vs_dmap, CLMAP_SIZE(vs->vs_size));
        }
        VS_MAP_UNLOCK(vs);

        bs_commit(- vs->vs_size);

        VS_MAP_LOCK_DESTROY(vs);

        zfree(vstruct_zone, vs);
}

kern_return_t
ps_vstruct_reclaim(
        vstruct_t vs,
        boolean_t return_to_vm,
        boolean_t reclaim_backing_store)
{
        unsigned int    i, j;
        struct vs_map   *vsmap;
        boolean_t       vsmap_all_clear, vsimap_all_clear;
        struct vm_object_fault_info fault_info;
        int             clmap_off;
        unsigned int    vsmap_size;
        kern_return_t   kr = KERN_SUCCESS;

        VS_MAP_LOCK(vs);

        fault_info.cluster_size = VM_SUPER_CLUSTER;
        fault_info.behavior = VM_BEHAVIOR_SEQUENTIAL;
        fault_info.user_tag = 0;
        fault_info.lo_offset = 0;
        fault_info.hi_offset = ptoa_32(vs->vs_size << vs->vs_clshift);
        fault_info.io_sync = reclaim_backing_store;
        fault_info.batch_pmap_op = FALSE;

        /*
         * If this is an indirect structure, then we walk through the valid
         * (non-zero) indirect pointers and deallocate the clusters
         * associated with each used map entry (via ps_dealloc_vsmap).
         * When all of the clusters in an indirect block have been
         * freed, we deallocate the block.  When all of the indirect
         * blocks have been deallocated we deallocate the memory
         * holding the indirect pointers.
         */
        if (vs->vs_indirect) {
                vsimap_all_clear = TRUE;
                for (i = 0; i < INDIRECT_CLMAP_ENTRIES(vs->vs_size); i++) {
                        vsmap = vs->vs_imap[i];
                        if (vsmap == NULL)
                                continue;
                        /* loop on clusters in this indirect map */
                        clmap_off = (vm_page_size * CLMAP_ENTRIES *
                                     VSCLSIZE(vs) * i);
                        if (i+1 == INDIRECT_CLMAP_ENTRIES(vs->vs_size))
                                vsmap_size = vs->vs_size - (CLMAP_ENTRIES * i);
                        else
                                vsmap_size = CLMAP_ENTRIES;
                        vsmap_all_clear = TRUE;
                        if (return_to_vm) {
                                for (j = 0; j < vsmap_size;) {
                                        if (VSM_ISCLR(vsmap[j]) ||
                                            VSM_ISERR(vsmap[j])) {
                                                j++;
                                                clmap_off += vm_page_size * VSCLSIZE(vs);
                                                continue;
                                        }
                                        VS_MAP_UNLOCK(vs);
                                        kr = pvs_cluster_read(
                                                vs,
                                                clmap_off,
                                                (dp_size_t) -1, /* read whole cluster */
                                                &fault_info);

                                        VS_MAP_LOCK(vs); /* XXX what if it changed ? */
                                        if (kr != KERN_SUCCESS) {
                                                vsmap_all_clear = FALSE;
                                                vsimap_all_clear = FALSE;

                                                kr = KERN_MEMORY_ERROR;
                                                goto out;
                                        }
                                }
                        }
                        if (vsmap_all_clear) {
                                ps_dealloc_vsmap(vsmap, CLMAP_ENTRIES);
                                kfree(vsmap, CLMAP_THRESHOLD);
                                vs->vs_imap[i] = NULL;
                        }
                }
                if (vsimap_all_clear) {
//                      kfree(vs->vs_imap, INDIRECT_CLMAP_SIZE(vs->vs_size));
                }
        } else {
                /*
                 * Direct map.  Free used clusters, then memory.
                 */
                vsmap = vs->vs_dmap;
                if (vsmap == NULL) {
                        goto out;
                }
                vsmap_all_clear = TRUE;
                /* loop on clusters in the direct map */
                if (return_to_vm) {
                        for (j = 0; j < vs->vs_size;) {
                                if (VSM_ISCLR(vsmap[j]) ||
                                    VSM_ISERR(vsmap[j])) {
                                        j++;
                                        continue;
                                }
                                clmap_off = vm_page_size * (j << vs->vs_clshift);
                                VS_MAP_UNLOCK(vs);
                                kr = pvs_cluster_read(
                                        vs,
                                        clmap_off,
                                        (dp_size_t) -1, /* read whole cluster */
                                        &fault_info);

                                VS_MAP_LOCK(vs); /* XXX what if it changed ? */
                                if (kr != KERN_SUCCESS) {
                                        vsmap_all_clear = FALSE;

                                        kr = KERN_MEMORY_ERROR;
                                        goto out;
                                } else {
//                                      VSM_CLR(vsmap[j]);
                                }
                        }
                }
                if (vsmap_all_clear) {
                        ps_dealloc_vsmap(vs->vs_dmap, vs->vs_size);
//                      kfree(vs->vs_dmap, CLMAP_SIZE(vs->vs_size));
                }
        }
out:
        VS_MAP_UNLOCK(vs);

        return kr;
}

int ps_map_extend(vstruct_t, unsigned int);     /* forward */

int ps_map_extend(
        vstruct_t       vs,
        unsigned int    new_size)
{
        struct vs_map   **new_imap;
        struct vs_map   *new_dmap = NULL;
        int             newdsize;
        int             i;
        void            *old_map = NULL;
        int             old_map_size = 0;

        if (vs->vs_size >= new_size) {
                /*
                 * Someone has already done the work.
                 */
                return 0;
        }

        /*
         * If the new size extends into the indirect range, then we have one
         * of two cases: we are going from indirect to indirect, or we are
         * going from direct to indirect.  If we are going from indirect to
         * indirect, then it is possible that the new size will fit in the old
         * indirect map.  If this is the case, then just reset the size of the
         * vstruct map and we are done.  If the new size will not
         * fit into the old indirect map, then we have to allocate a new
         * indirect map and copy the old map pointers into this new map.
         *
         * If we are going from direct to indirect, then we have to allocate a
         * new indirect map and copy the old direct pages into the first
         * indirect page of the new map.
         * NOTE: allocating memory here is dangerous, as we're in the
         * pageout path.
         */
        if (INDIRECT_CLMAP(new_size)) {
                int new_map_size = INDIRECT_CLMAP_SIZE(new_size);

                /*
                 * Get a new indirect map and zero it.
                 */
                old_map_size = INDIRECT_CLMAP_SIZE(vs->vs_size);
                if (vs->vs_indirect &&
                    (new_map_size == old_map_size)) {
                        bs_commit(new_size - vs->vs_size);
                        vs->vs_size = new_size;
                        return 0;
                }

                new_imap = (struct vs_map **)kalloc(new_map_size);
                if (new_imap == NULL) {
                        return -1;
                }
                memset(new_imap, 0, new_map_size);

                if (vs->vs_indirect) {
                        /* Copy old entries into new map */
                        memcpy(new_imap, vs->vs_imap, old_map_size);
                        /* Arrange to free the old map */
                        old_map = (void *) vs->vs_imap;
                        newdsize = 0;
                } else {        /* Old map was a direct map */
                        /* Allocate an indirect page */
                        if ((new_imap[0] = (struct vs_map *)
                             kalloc(CLMAP_THRESHOLD)) == NULL) {
                                kfree(new_imap, new_map_size);
                                return -1;
                        }
                        new_dmap = new_imap[0];
                        newdsize = CLMAP_ENTRIES;
                }
        } else {
                new_imap = NULL;
                newdsize = new_size;
                /*
                 * If the new map is a direct map, then the old map must
                 * also have been a direct map.  All we have to do is
                 * to allocate a new direct map, copy the old entries
                 * into it and free the old map.
                 */
                if ((new_dmap = (struct vs_map *)
                     kalloc(CLMAP_SIZE(new_size))) == NULL) {
                        return -1;
                }
        }
        if (newdsize) {

                /* Free the old map */
                old_map = (void *) vs->vs_dmap;
                old_map_size = CLMAP_SIZE(vs->vs_size);

                /* Copy info from the old map into the new map */
                memcpy(new_dmap, vs->vs_dmap, old_map_size);

                /* Initialize the rest of the new map */
                for (i = vs->vs_size; i < newdsize; i++)
                        VSM_CLR(new_dmap[i]);
        }
        if (new_imap) {
                vs->vs_imap = new_imap;
                vs->vs_indirect = TRUE;
        } else
                vs->vs_dmap = new_dmap;
        bs_commit(new_size - vs->vs_size);
        vs->vs_size = new_size;
        if (old_map)
                kfree(old_map, old_map_size);
        return 0;
}

dp_offset_t
ps_clmap(
        vstruct_t       vs,
        dp_offset_t     offset,
        struct clmap    *clmap,
        int             flag,
        dp_size_t       size,
        int             error)
{
        dp_offset_t     cluster;        /* The cluster of offset.       */
        dp_offset_t     newcl;          /* The new cluster allocated.   */
        dp_offset_t     newoff;
        unsigned int    i;
        struct vs_map   *vsmap;

        VS_MAP_LOCK(vs);

        ASSERT(vs->vs_dmap);
        cluster = atop_32(offset) >> vs->vs_clshift;

        /*
         * Initialize cluster error value
         */
        clmap->cl_error = 0;

        /*
         * If the object has grown, extend the page map.
         */
        if (cluster >= vs->vs_size) {
                if (flag == CL_FIND) {
                        /* Do not allocate if just doing a lookup */
                        VS_MAP_UNLOCK(vs);
                        return (dp_offset_t) -1;
                }
                if (ps_map_extend(vs, cluster + 1)) {
                        VS_MAP_UNLOCK(vs);
                        return (dp_offset_t) -1;
                }
        }

        /*
         * Look for the desired cluster.  If the map is indirect, then we
         * have a two level lookup.  First find the indirect block, then
         * find the actual cluster.  If the indirect block has not yet
         * been allocated, then do so.  If the cluster has not yet been
         * allocated, then do so.
         *
         * If any of the allocations fail, then return an error.
         * Don't allocate if just doing a lookup.
         */
        if (vs->vs_indirect) {
                long    ind_block = cluster/CLMAP_ENTRIES;

                /* Is the indirect block allocated? */
                vsmap = vs->vs_imap[ind_block];
                if (vsmap == NULL) {
                        if (flag == CL_FIND) {
                                VS_MAP_UNLOCK(vs);
                                return (dp_offset_t) -1;
                        }

                        /* Allocate the indirect block */
                        vsmap = (struct vs_map *) kalloc(CLMAP_THRESHOLD);
                        if (vsmap == NULL) {
                                VS_MAP_UNLOCK(vs);
                                return (dp_offset_t) -1;
                        }
                        /* Initialize the cluster offsets */
                        for (i = 0; i < CLMAP_ENTRIES; i++)
                                VSM_CLR(vsmap[i]);
                        vs->vs_imap[ind_block] = vsmap;
                }
        } else
                vsmap = vs->vs_dmap;

        ASSERT(vsmap);
        vsmap += cluster%CLMAP_ENTRIES;

        /*
         * At this point, vsmap points to the struct vs_map desired.
         *
         * Look in the map for the cluster, if there was an error on a
         * previous write, flag it and return.  If it is not yet
         * allocated, then allocate it, if we're writing; if we're
         * doing a lookup and the cluster's not allocated, return error.
         */
        if (VSM_ISERR(*vsmap)) {
                clmap->cl_error = VSM_GETERR(*vsmap);
                VS_MAP_UNLOCK(vs);
                return (dp_offset_t) -1;
        } else if (VSM_ISCLR(*vsmap)) {
                int psindex;

                if (flag == CL_FIND) {
                        /*
                         * If there's an error and the entry is clear, then
                         * we've run out of swap space.  Record the error
                         * here and return.
                         */
                        if (error) {
                                VSM_SETERR(*vsmap, error);
                        }
                        VS_MAP_UNLOCK(vs);
                        return (dp_offset_t) -1;
                } else {
                        /*
                         * Attempt to allocate a cluster from the paging segment
                         */
                        newcl = ps_allocate_cluster(vs, &psindex,
                                                    PAGING_SEGMENT_NULL);
                        if (newcl == (dp_offset_t) -1) {
                                VS_MAP_UNLOCK(vs);
                                return (dp_offset_t) -1;
                        }
                        VSM_CLR(*vsmap);
                        VSM_SETCLOFF(*vsmap, newcl);
                        VSM_SETPS(*vsmap, psindex);
                }
        } else
                newcl = VSM_CLOFF(*vsmap);

        /*
         * Fill in pertinent fields of the clmap
         */
        clmap->cl_ps = VSM_PS(*vsmap);
        clmap->cl_numpages = VSCLSIZE(vs);
        clmap->cl_bmap.clb_map = (unsigned int) VSM_BMAP(*vsmap);

        /*
         * Byte offset in paging segment is byte offset to cluster plus
         * byte offset within cluster.  It looks ugly, but should be
         * relatively quick.
         */
        ASSERT(trunc_page(offset) == offset);
        newcl = ptoa_32(newcl) << vs->vs_clshift;
        newoff = offset & ((1<<(vm_page_shift + vs->vs_clshift)) - 1);
        if (flag == CL_ALLOC) {
                /*
                 * set bits in the allocation bitmap according to which
                 * pages were requested.  size is in bytes.
                 */
                i = atop_32(newoff);
                while ((size > 0) && (i < VSCLSIZE(vs))) {
                        VSM_SETALLOC(*vsmap, i);
                        i++;
                        size -= vm_page_size;
                }
        }
        clmap->cl_alloc.clb_map = (unsigned int) VSM_ALLOC(*vsmap);
        if (newoff) {
                /*
                 * Offset is not cluster aligned, so number of pages
                 * and bitmaps must be adjusted
                 */
                clmap->cl_numpages -= atop_32(newoff);
                CLMAP_SHIFT(clmap, vs);
                CLMAP_SHIFTALLOC(clmap, vs);
        }

        /*
         *
         * The setting of valid bits and handling of write errors
         * must be done here, while we hold the lock on the map.
         * It logically should be done in ps_vs_write_complete().
         * The size and error information has been passed from
         * ps_vs_write_complete().  If the size parameter is non-zero,
         * then there is work to be done.  If error is also non-zero,
         * then the error number is recorded in the cluster and the
         * entire cluster is in error.
         */
        if (size && flag == CL_FIND) {
                dp_offset_t off = (dp_offset_t) 0;

                if (!error) {
                        for (i = VSCLSIZE(vs) - clmap->cl_numpages; size > 0;
                             i++) {
                                VSM_SETPG(*vsmap, i);
                                size -= vm_page_size;
                        }
                        ASSERT(i <= VSCLSIZE(vs));
                } else {
                        BS_STAT(clmap->cl_ps->ps_bs,
                                clmap->cl_ps->ps_bs->bs_pages_out_fail +=
                                        atop_32(size));
                        off = VSM_CLOFF(*vsmap);
                        VSM_SETERR(*vsmap, error);
                }
                /*
                 * Deallocate cluster if error, and no valid pages
                 * already present.
                 */
                if (off != (dp_offset_t) 0)
                        ps_deallocate_cluster(clmap->cl_ps, off);
                VS_MAP_UNLOCK(vs);
                return (dp_offset_t) 0;
        } else
                VS_MAP_UNLOCK(vs);

        DP_DEBUG(DEBUG_VS_INTERNAL,
                 ("returning 0x%X,vs=0x%X,vsmap=0x%X,flag=%d\n",
                  newcl+newoff, (int) vs, (int) vsmap, flag));
        DP_DEBUG(DEBUG_VS_INTERNAL,
                 ("     clmap->cl_ps=0x%X,cl_numpages=%d,clbmap=0x%x,cl_alloc=%x\n",
                  (int) clmap->cl_ps, clmap->cl_numpages,
                  (int) clmap->cl_bmap.clb_map, (int) clmap->cl_alloc.clb_map));

        return (newcl + newoff);
}

void ps_clunmap(vstruct_t, dp_offset_t, dp_size_t);     /* forward */

void
ps_clunmap(
        vstruct_t       vs,
        dp_offset_t     offset,
        dp_size_t       length)
{
        dp_offset_t             cluster; /* The cluster number of offset */
        struct vs_map           *vsmap;
        struct ps_vnode_trim_data trim_data;

        ps_vnode_trim_init(&trim_data);

        VS_MAP_LOCK(vs);

        /*
         * Loop through all clusters in this range, freeing paging segment
         * clusters and map entries as encountered.
         */
        while (length > 0) {
                dp_offset_t     newoff;
                unsigned int    i;

                cluster = atop_32(offset) >> vs->vs_clshift;
                if (vs->vs_indirect)    /* indirect map */
                        vsmap = vs->vs_imap[cluster/CLMAP_ENTRIES];
                else
                        vsmap = vs->vs_dmap;
                if (vsmap == NULL) {
                        ps_vnode_trim_now(&trim_data);
                        VS_MAP_UNLOCK(vs);
                        return;
                }
                vsmap += cluster%CLMAP_ENTRIES;
                if (VSM_ISCLR(*vsmap)) {
                        ps_vnode_trim_now(&trim_data);
                        length -= vm_page_size;
                        offset += vm_page_size;
                        continue;
                }
                /*
                 * We've got a valid mapping.  Clear it and deallocate
                 * paging segment cluster pages.
                 * Optimize for entire cluster cleraing.
                 */
                if ( (newoff = (offset&((1<<(vm_page_shift+vs->vs_clshift))-1))) ) {
                        /*
                         * Not cluster aligned.
                         */
                        ASSERT(trunc_page(newoff) == newoff);
                        i = atop_32(newoff);
                } else
                        i = 0;
                while ((i < VSCLSIZE(vs)) && (length > 0)) {
                        VSM_CLRPG(*vsmap, i);
                        VSM_CLRALLOC(*vsmap, i);
                        length -= vm_page_size;
                        offset += vm_page_size;
                        i++;
                }

                /*
                 * If map entry is empty, clear and deallocate cluster.
                 */
                if (!VSM_BMAP(*vsmap)) {
                        ps_vnode_trim_more(&trim_data, 
                                              vsmap,
                                              vs->vs_clshift,
                                              VSCLSIZE(vs) * vm_page_size);
                        ps_deallocate_cluster(VSM_PS(*vsmap),
                                              VSM_CLOFF(*vsmap));
                        VSM_CLR(*vsmap);
                } else {
                        ps_vnode_trim_now(&trim_data);
                }
        }
        ps_vnode_trim_now(&trim_data);

        VS_MAP_UNLOCK(vs);
}

void ps_vs_write_complete(vstruct_t, dp_offset_t, dp_size_t, int); /* forward */

void
ps_vs_write_complete(
        vstruct_t       vs,
        dp_offset_t     offset,
        dp_size_t       size,
        int             error)
{
        struct clmap    clmap;

        /*
         * Get the struct vsmap for this cluster.
         * Use READ, even though it was written, because the
         * cluster MUST be present, unless there was an error
         * in the original ps_clmap (e.g. no space), in which
         * case, nothing happens.
         *
         * Must pass enough information to ps_clmap to allow it
         * to set the vs_map structure bitmap under lock.
         */
        (void) ps_clmap(vs, offset, &clmap, CL_FIND, size, error);
}

void vs_cl_write_complete(vstruct_t, paging_segment_t, dp_offset_t, vm_offset_t, dp_size_t, boolean_t, int);    /* forward */

void
vs_cl_write_complete(
        vstruct_t                       vs,
        __unused paging_segment_t       ps,
        dp_offset_t                     offset,
        __unused vm_offset_t            addr,
        dp_size_t                       size,
        boolean_t                       async,
        int                             error)
{
//      kern_return_t   kr;

        if (error) {
                /*
                 * For internal objects, the error is recorded on a
                 * per-cluster basis by ps_clmap() which is called
                 * by ps_vs_write_complete() below.
                 */
                dprintf(("write failed error = 0x%x\n", error));
                /* add upl_abort code here */
        } else
                GSTAT(global_stats.gs_pages_out += atop_32(size));
        /*
         * Notify the vstruct mapping code, so it can do its accounting.
         */
        ps_vs_write_complete(vs, offset, size, error);

        if (async) {
                VS_LOCK(vs);
                ASSERT(vs->vs_async_pending > 0);
                vs->vs_async_pending -= size;
                if (vs->vs_async_pending == 0 && vs->vs_waiting_async) {
                        vs->vs_waiting_async = FALSE;
                        VS_UNLOCK(vs);
                        thread_wakeup(&vs->vs_async_pending);
                } else {
                        VS_UNLOCK(vs);
                }
        }
}

#ifdef DEVICE_PAGING
kern_return_t device_write_reply(MACH_PORT_FACE, kern_return_t, io_buf_len_t);

kern_return_t
device_write_reply(
        MACH_PORT_FACE  reply_port,
        kern_return_t   device_code,
        io_buf_len_t    bytes_written)
{
        struct vs_async *vsa;

        vsa = (struct vs_async *)
                ((struct vstruct_alias *)(reply_port->ip_alias))->vs;

        if (device_code == KERN_SUCCESS && bytes_written != vsa->vsa_size) {
                device_code = KERN_FAILURE;
        }

        vsa->vsa_error = device_code;


        ASSERT(vsa->vsa_vs != VSTRUCT_NULL);
        if(vsa->vsa_flags & VSA_TRANSFER) {
                /* revisit when async disk segments redone */
                if(vsa->vsa_error) {
                   /* need to consider error condition.  re-write data or */
                   /* throw it away here. */
                   vm_map_copy_discard((vm_map_copy_t)vsa->vsa_addr);
                }
                ps_vs_write_complete(vsa->vsa_vs, vsa->vsa_offset, 
                                                vsa->vsa_size, vsa->vsa_error);
        } else {
                vs_cl_write_complete(vsa->vsa_vs, vsa->vsa_ps, vsa->vsa_offset,
                             vsa->vsa_addr, vsa->vsa_size, TRUE,
                             vsa->vsa_error);
        }
        VS_FREE_ASYNC(vsa);

        return KERN_SUCCESS;
}

kern_return_t device_write_reply_inband(MACH_PORT_FACE, kern_return_t, io_buf_len_t);
kern_return_t
device_write_reply_inband(
        MACH_PORT_FACE          reply_port,
        kern_return_t           return_code,
        io_buf_len_t            bytes_written)
{
        panic("device_write_reply_inband: illegal");
        return KERN_SUCCESS;
}

kern_return_t device_read_reply(MACH_PORT_FACE, kern_return_t, io_buf_ptr_t, mach_msg_type_number_t);
kern_return_t
device_read_reply(
        MACH_PORT_FACE          reply_port,
        kern_return_t           return_code,
        io_buf_ptr_t            data,
        mach_msg_type_number_t  dataCnt)
{
        struct vs_async *vsa;
        vsa = (struct vs_async *)
                ((struct vstruct_alias *)(reply_port->defpager_importance.alias))->vs;
        vsa->vsa_addr = (vm_offset_t)data;
        vsa->vsa_size = (vm_size_t)dataCnt;
        vsa->vsa_error = return_code;
        thread_wakeup(&vsa);
        return KERN_SUCCESS;
}

kern_return_t device_read_reply_inband(MACH_PORT_FACE, kern_return_t, io_buf_ptr_inband_t, mach_msg_type_number_t);
kern_return_t
device_read_reply_inband(
        MACH_PORT_FACE          reply_port,
        kern_return_t           return_code,
        io_buf_ptr_inband_t     data,
        mach_msg_type_number_t  dataCnt)
{
        panic("device_read_reply_inband: illegal");
        return KERN_SUCCESS;
}

kern_return_t device_read_reply_overwrite(MACH_PORT_FACE, kern_return_t, io_buf_len_t);
kern_return_t
device_read_reply_overwrite(
        MACH_PORT_FACE          reply_port,
        kern_return_t           return_code,
        io_buf_len_t            bytes_read)
{
        panic("device_read_reply_overwrite: illegal\n");
        return KERN_SUCCESS;
}

kern_return_t device_open_reply(MACH_PORT_FACE, kern_return_t, MACH_PORT_FACE);
kern_return_t
device_open_reply(
        MACH_PORT_FACE          reply_port,
        kern_return_t           return_code,
        MACH_PORT_FACE          device_port)
{
        panic("device_open_reply: illegal\n");
        return KERN_SUCCESS;
}

kern_return_t
ps_read_device(
        paging_segment_t        ps,
        dp_offset_t             offset,
        vm_offset_t             *bufferp,
        unsigned int            size,
        unsigned int            *residualp,
        int                     flags)
{
        kern_return_t   kr;
        recnum_t        dev_offset;
        unsigned int    bytes_wanted;
        unsigned int    bytes_read;
        unsigned int    total_read;
        vm_offset_t     dev_buffer;
        vm_offset_t     buf_ptr;
        unsigned int    records_read;
        struct vs_async *vsa;   

        device_t        device;
        vm_map_copy_t   device_data = NULL;
        default_pager_thread_t *dpt = NULL;

        device = dev_port_lookup(ps->ps_device);
        clustered_reads[atop_32(size)]++;

        dev_offset = (ps->ps_offset +
                      (offset >> (vm_page_shift - ps->ps_record_shift)));
        bytes_wanted = size;
        total_read = 0;
        *bufferp = (vm_offset_t)NULL;
        
        do {
                vsa = VS_ALLOC_ASYNC();
                if (vsa) {
                        vsa->vsa_vs = NULL;
                        vsa->vsa_addr = 0;
                        vsa->vsa_offset = 0;
                        vsa->vsa_size = 0;
                        vsa->vsa_ps = NULL;
                }
                ip_lock(vsa->reply_port);
                vsa->reply_port->ip_sorights++;
                ip_reference(vsa->reply_port);
                ip_unlock(vsa->reply_port);
                kr = ds_device_read_common(device,
                                 vsa->reply_port,
                                 (mach_msg_type_name_t) 
                                        MACH_MSG_TYPE_MOVE_SEND_ONCE,
                                 (dev_mode_t) 0,
                                 dev_offset,
                                 bytes_wanted,
                                 (IO_READ | IO_CALL),
                                 (io_buf_ptr_t *) &dev_buffer,
                                 (mach_msg_type_number_t *) &bytes_read);
                if(kr == MIG_NO_REPLY) { 
                        assert_wait(&vsa, THREAD_UNINT);
                        thread_block(THREAD_CONTINUE_NULL);

                        dev_buffer = vsa->vsa_addr;
                        bytes_read = (unsigned int)vsa->vsa_size;
                        kr = vsa->vsa_error;
                } 
                VS_FREE_ASYNC(vsa);
                if (kr != KERN_SUCCESS || bytes_read == 0) {
                        break;
                }
                total_read += bytes_read;

                /*
                 * If we got the entire range, use the returned dev_buffer.
                 */
                if (bytes_read == size) {
                        *bufferp = (vm_offset_t)dev_buffer;
                        break;
                }

#if 1
                dprintf(("read only %d bytes out of %d\n",
                         bytes_read, bytes_wanted));
#endif
                if(dpt == NULL) {
                        dpt = get_read_buffer();
                        buf_ptr = dpt->dpt_buffer;
                        *bufferp = (vm_offset_t)buf_ptr;
                }
                /*
                 * Otherwise, copy the data into the provided buffer (*bufferp)
                 * and append the rest of the range as it comes in.
                 */
                memcpy((void *) buf_ptr, (void *) dev_buffer, bytes_read);
                buf_ptr += bytes_read;
                bytes_wanted -= bytes_read;
                records_read = (bytes_read >>
                                (vm_page_shift - ps->ps_record_shift));
                dev_offset += records_read;
                DP_DEBUG(DEBUG_VS_INTERNAL,
                         ("calling vm_deallocate(addr=0x%X,size=0x%X)\n",
                          dev_buffer, bytes_read));
                if (vm_deallocate(kernel_map, dev_buffer, bytes_read)
                    != KERN_SUCCESS)
                        Panic("dealloc buf");
        } while (bytes_wanted);

        *residualp = size - total_read;
        if((dev_buffer != *bufferp) && (total_read != 0)) {
                vm_offset_t temp_buffer;
                vm_allocate(kernel_map, &temp_buffer, total_read, VM_FLAGS_ANYWHERE);
                memcpy((void *) temp_buffer, (void *) *bufferp, total_read);
                if(vm_map_copyin_page_list(kernel_map, temp_buffer, total_read, 
                        VM_MAP_COPYIN_OPT_SRC_DESTROY | 
                        VM_MAP_COPYIN_OPT_STEAL_PAGES | 
                        VM_MAP_COPYIN_OPT_PMAP_ENTER,
                        (vm_map_copy_t *)&device_data, FALSE))
                                panic("ps_read_device: cannot copyin locally provided buffer\n");
        }
        else if((kr == KERN_SUCCESS) && (total_read != 0) && (dev_buffer != 0)){
                if(vm_map_copyin_page_list(kernel_map, dev_buffer, bytes_read, 
                        VM_MAP_COPYIN_OPT_SRC_DESTROY | 
                        VM_MAP_COPYIN_OPT_STEAL_PAGES | 
                        VM_MAP_COPYIN_OPT_PMAP_ENTER,
                        (vm_map_copy_t *)&device_data, FALSE))
                                panic("ps_read_device: cannot copyin backing store provided buffer\n");
        }
        else {
                device_data = NULL;
        }
        *bufferp = (vm_offset_t)device_data;

        if(dpt != NULL) {
                /* Free the receive buffer */
                dpt->checked_out = 0;   
                thread_wakeup(&dpt_array);
        }
        return KERN_SUCCESS;
}

kern_return_t
ps_write_device(
        paging_segment_t        ps,
        dp_offset_t             offset,
        vm_offset_t             addr,
        unsigned int            size,
        struct vs_async         *vsa)
{
        recnum_t        dev_offset;
        io_buf_len_t    bytes_to_write, bytes_written;
        recnum_t        records_written;
        kern_return_t   kr;
        MACH_PORT_FACE  reply_port;



        clustered_writes[atop_32(size)]++;

        dev_offset = (ps->ps_offset +
                      (offset >> (vm_page_shift - ps->ps_record_shift)));
        bytes_to_write = size;

        if (vsa) {
                /*
                 * Asynchronous write.
                 */
                reply_port = vsa->reply_port;
                ip_lock(reply_port);
                reply_port->ip_sorights++;
                ip_reference(reply_port);
                ip_unlock(reply_port);
                {
                device_t        device;
                device = dev_port_lookup(ps->ps_device);

                vsa->vsa_addr = addr;
                kr=ds_device_write_common(device,
                        reply_port,
                        (mach_msg_type_name_t) MACH_MSG_TYPE_MOVE_SEND_ONCE,
                        (dev_mode_t) 0,
                        dev_offset,
                        (io_buf_ptr_t)  addr,
                        size, 
                        (IO_WRITE | IO_CALL),
                        &bytes_written);
                }
                if ((kr != KERN_SUCCESS) && (kr != MIG_NO_REPLY)) {
                        if (verbose) 
                                dprintf(("%s0x%x, addr=0x%x,"
                                         "size=0x%x,offset=0x%x\n",
                                         "device_write_request returned ",
                                         kr, addr, size, offset));
                        BS_STAT(ps->ps_bs,
                                ps->ps_bs->bs_pages_out_fail += atop_32(size));
                        /* do the completion notification to free resources */
                        device_write_reply(reply_port, kr, 0);
                        return PAGER_ERROR;
                }
        } else do {
                /*
                 * Synchronous write.
                 */
                {
                device_t        device;
                device = dev_port_lookup(ps->ps_device);
                kr=ds_device_write_common(device,
                        IP_NULL, 0,
                        (dev_mode_t) 0,
                        dev_offset,
                        (io_buf_ptr_t)  addr,
                        size, 
                        (IO_WRITE | IO_SYNC | IO_KERNEL_BUF),
                        &bytes_written);
                }
                if (kr != KERN_SUCCESS) {
                        dprintf(("%s0x%x, addr=0x%x,size=0x%x,offset=0x%x\n",
                                 "device_write returned ",
                                 kr, addr, size, offset));
                        BS_STAT(ps->ps_bs,
                                ps->ps_bs->bs_pages_out_fail += atop_32(size));
                        return PAGER_ERROR;
                }
                if (bytes_written & ((vm_page_size >> ps->ps_record_shift) - 1))
                        Panic("fragmented write");
                records_written = (bytes_written >>
                                   (vm_page_shift - ps->ps_record_shift));
                dev_offset += records_written;
#if 1
                if (bytes_written != bytes_to_write) {
                        dprintf(("wrote only %d bytes out of %d\n",
                                 bytes_written, bytes_to_write));
                }
#endif
                bytes_to_write -= bytes_written;
                addr += bytes_written;
        } while (bytes_to_write > 0);

        return PAGER_SUCCESS;
}


#else /* !DEVICE_PAGING */

kern_return_t
ps_read_device(
        __unused paging_segment_t       ps,
        __unused dp_offset_t            offset,
        __unused vm_offset_t            *bufferp,
        __unused unsigned int           size,
        __unused unsigned int           *residualp,
        __unused int                            flags)
{
  panic("ps_read_device not supported");
  return KERN_FAILURE;
}

kern_return_t
ps_write_device(
        __unused paging_segment_t       ps,
        __unused dp_offset_t            offset,
        __unused vm_offset_t            addr,
        __unused unsigned int           size,
        __unused struct vs_async        *vsa)
{
  panic("ps_write_device not supported");
  return KERN_FAILURE;
}

#endif /* DEVICE_PAGING */
void pvs_object_data_provided(vstruct_t, upl_t, upl_offset_t, upl_size_t);      /* forward */

void
pvs_object_data_provided(
        __unused vstruct_t              vs,
        __unused upl_t                  upl,
        __unused upl_offset_t   offset,
        upl_size_t                              size)
{
#if     RECLAIM_SWAP
        boolean_t       empty;
#endif

        DP_DEBUG(DEBUG_VS_INTERNAL,
                 ("buffer=0x%x,offset=0x%x,size=0x%x\n",
                  upl, offset, size));

        ASSERT(size > 0);
        GSTAT(global_stats.gs_pages_in += atop_32(size));

/* check upl iosync flag instead of using RECLAIM_SWAP*/
#if     RECLAIM_SWAP
        if (size != upl->size) {
                if (size) {
                        ps_clunmap(vs, offset, size);
                        upl_commit_range(upl, 0, size, 0, NULL, 0, &empty);
                }
                upl_abort(upl, UPL_ABORT_ERROR);
                upl_deallocate(upl);
        } else {
                ps_clunmap(vs, offset, size);
                upl_commit(upl, NULL, 0);
                upl_deallocate(upl);
        }
#endif  /* RECLAIM_SWAP */

}

static memory_object_offset_t   last_start;
static vm_size_t                last_length;

/*
 * A "cnt" of 0 means that the caller just wants to check if the page at
 * offset "vs_offset" exists in the backing store.  That page hasn't been
 * prepared, so no need to release it.
 *
 * A "cnt" of -1 means that the caller wants to bring back from the backing
 * store all existing pages in the cluster containing "vs_offset".
 */
kern_return_t
pvs_cluster_read(
        vstruct_t       vs,
        dp_offset_t     vs_offset,
        dp_size_t       cnt,
        void            *fault_info)
{
        kern_return_t           error = KERN_SUCCESS;
        unsigned int            size;
        unsigned int            residual;
        unsigned int            request_flags;
        int                     io_flags = 0;
        int                     seg_index;
        int                     pages_in_cl;
        int                     cl_size;
        int                     cl_mask;
        int                     cl_index;
        unsigned int            xfer_size;
        dp_offset_t             orig_vs_offset;
        dp_offset_t       ps_offset[(VM_SUPER_CLUSTER / PAGE_SIZE) >> VSTRUCT_MIN_CLSHIFT];
        paging_segment_t        psp[(VM_SUPER_CLUSTER / PAGE_SIZE) >> VSTRUCT_MIN_CLSHIFT];
        struct clmap            clmap;
        upl_t                   upl;
        unsigned int            page_list_count;
        memory_object_offset_t  cluster_start;
        vm_size_t               cluster_length;
        uint32_t                io_streaming;
        int                     i;
        boolean_t               io_sync = FALSE;
        boolean_t               reclaim_all = FALSE;

        pages_in_cl = 1 << vs->vs_clshift;
        cl_size = pages_in_cl * vm_page_size;
        cl_mask = cl_size - 1;

        request_flags = UPL_NO_SYNC | UPL_RET_ONLY_ABSENT | UPL_SET_LITE;
        
        if (cnt == (dp_size_t) -1)
                reclaim_all = TRUE;

        if (reclaim_all == TRUE) {
                /*
                 * We've been called from ps_vstruct_reclaim() to move all
                 * the object's swapped pages back to VM pages.
                 * This can put memory pressure on the system, so we do want
                 * to wait for free pages, to avoid getting in the way of the
                 * vm_pageout_scan() thread.
                 * Let's not use UPL_NOBLOCK in this case.
                 */
                vs_offset &= ~cl_mask;
                i = pages_in_cl;
        } else {
                i = 1;

                /*
                 * if the I/O cluster size == PAGE_SIZE, we don't want to set
                 * the UPL_NOBLOCK since we may be trying to recover from a
                 * previous partial pagein I/O that occurred because we were low
                 * on memory and bailed early in order to honor the UPL_NOBLOCK...
                 * since we're only asking for a single page, we can block w/o fear
                 * of tying up pages while waiting for more to become available
                 */
                if (fault_info == NULL || ((vm_object_fault_info_t)fault_info)->cluster_size > PAGE_SIZE)
                        request_flags |= UPL_NOBLOCK;
        }

again:
        cl_index = (vs_offset & cl_mask) / vm_page_size;

        if ((ps_clmap(vs, vs_offset & ~cl_mask, &clmap, CL_FIND, 0, 0) == (dp_offset_t)-1) ||
            !CLMAP_ISSET(clmap, cl_index)) {
                /*
                 * the needed page doesn't exist in the backing store...
                 * we don't want to try to do any I/O, just abort the
                 * page and let the fault handler provide a zero-fill
                 */
                if (cnt == 0) {
                        /*
                         * The caller was just poking at us to see if
                         * the page has been paged out.  No need to 
                         * mess with the page at all.
                         * Just let the caller know we don't have that page.
                         */
                        return KERN_FAILURE;
                }
                if (reclaim_all == TRUE) {
                        i--;
                        if (i == 0) {
                                /* no more pages in this cluster */
                                return KERN_FAILURE;
                        }
                        /* try the next page in this cluster */
                        vs_offset += vm_page_size;
                        goto again;
                }

                page_list_count = 0;

                memory_object_super_upl_request(vs->vs_control, (memory_object_offset_t)vs_offset,
                                                PAGE_SIZE, PAGE_SIZE, 
                                                &upl, NULL, &page_list_count,
                                                request_flags  | UPL_SET_INTERNAL);
                upl_range_needed(upl, 0, 1);

                if (clmap.cl_error)
                        upl_abort(upl, UPL_ABORT_ERROR);
                else
                        upl_abort(upl, UPL_ABORT_UNAVAILABLE);
                upl_deallocate(upl);

                return KERN_SUCCESS;
        }

        if (cnt == 0) {
                /*
                 * The caller was just poking at us to see if
                 * the page has been paged out.  No need to 
                 * mess with the page at all.
                 * Just let the caller know we do have that page.
                 */
                return KERN_SUCCESS;
        }
        
        if(((vm_object_fault_info_t)fault_info)->io_sync == TRUE ) {
                io_sync = TRUE;
        } else {
#if RECLAIM_SWAP
                io_sync = TRUE;
#endif  /* RECLAIM_SWAP */
        }

        if( io_sync == TRUE ) {

                io_flags |= UPL_IOSYNC | UPL_NOCOMMIT;
#if USE_PRECIOUS
                request_flags |= UPL_PRECIOUS | UPL_CLEAN_IN_PLACE;
#else   /* USE_PRECIOUS */
                request_flags |= UPL_REQUEST_SET_DIRTY;
#endif  /* USE_PRECIOUS */
        }

        assert(dp_encryption_inited);
        if (dp_encryption) {
                /*
                 * ENCRYPTED SWAP:
                 * request that the UPL be prepared for
                 * decryption.
                 */
                request_flags |= UPL_ENCRYPT;
                io_flags |= UPL_PAGING_ENCRYPTED;
        }
        orig_vs_offset = vs_offset;

        assert(cnt != 0);
        cnt = VM_SUPER_CLUSTER;
        cluster_start = (memory_object_offset_t) vs_offset;
        cluster_length = (vm_size_t) cnt;
        io_streaming = 0;

        /*
         * determine how big a speculative I/O we should try for...
         */
        if (memory_object_cluster_size(vs->vs_control, &cluster_start, &cluster_length, &io_streaming, (memory_object_fault_info_t)fault_info) == KERN_SUCCESS) {
                assert(vs_offset >= (dp_offset_t) cluster_start &&
                       vs_offset < (dp_offset_t) (cluster_start + cluster_length));
                vs_offset = (dp_offset_t) cluster_start;
                cnt = (dp_size_t) cluster_length;
        } else {
                cluster_length = PAGE_SIZE;
                cnt = PAGE_SIZE;
        }

        if (io_streaming)
                io_flags |= UPL_IOSTREAMING;

        last_start = cluster_start;
        last_length = cluster_length;

        /*
         * This loop will be executed multiple times until the entire
         * range has been looked at or we issue an I/O... if the request spans cluster
         * boundaries, the clusters will be checked for logical continunity,
         * if contiguous the I/O request will span multiple clusters...
         * at most only 1 I/O will be issued... it will encompass the original offset
         */
        while (cnt && error == KERN_SUCCESS) {
                int     ps_info_valid;

                if ((vs_offset & cl_mask) && (cnt > (VM_SUPER_CLUSTER - (vs_offset & cl_mask)))) {
                        size = VM_SUPER_CLUSTER;
                        size -= vs_offset & cl_mask;
                } else if (cnt > VM_SUPER_CLUSTER)
                        size = VM_SUPER_CLUSTER;
                else
                        size = cnt;

                cnt -= size;

                ps_info_valid = 0;
                seg_index     = 0;

                while (size > 0 && error == KERN_SUCCESS) {
                        unsigned int  abort_size;
                        unsigned int  lsize;
                        int           failed_size;
                        int           beg_pseg;
                        int           beg_indx;
                        dp_offset_t   cur_offset;

                        if ( !ps_info_valid) {
                                ps_offset[seg_index] = ps_clmap(vs, vs_offset & ~cl_mask, &clmap, CL_FIND, 0, 0);
                                psp[seg_index]       = CLMAP_PS(clmap);
                                ps_info_valid = 1;
                        }
                        /*
                         * skip over unallocated physical segments 
                         */
                        if (ps_offset[seg_index] == (dp_offset_t) -1) {
                                abort_size = cl_size - (vs_offset & cl_mask);
                                abort_size = MIN(abort_size, size);

                                size      -= abort_size;
                                vs_offset += abort_size;

                                seg_index++;
                                ps_info_valid = 0;

                                continue;
                        }
                        cl_index = (vs_offset & cl_mask) / vm_page_size;

                        for (abort_size = 0; cl_index < pages_in_cl && abort_size < size; cl_index++) {
                                /*
                                 * skip over unallocated pages
                                 */
                                if (CLMAP_ISSET(clmap, cl_index))
                                        break;
                                abort_size += vm_page_size;
                        }
                        if (abort_size) {
                                size      -= abort_size;
                                vs_offset += abort_size;

                                if (cl_index == pages_in_cl) {
                                        /*
                                         * if we're at the end of this physical cluster
                                         * then bump to the next one and continue looking
                                         */
                                        seg_index++;
                                        ps_info_valid = 0;

                                        continue;
                                }
                                if (size == 0)
                                        break;
                        }
                        /*
                         * remember the starting point of the first allocated page 
                         * for the I/O we're about to issue
                         */
                        beg_pseg   = seg_index;
                        beg_indx   = cl_index;
                        cur_offset = vs_offset;

                        /*
                         * calculate the size of the I/O that we can do...
                         * this may span multiple physical segments if
                         * they are contiguous
                         */
                        for (xfer_size = 0; xfer_size < size; ) {

                                while (cl_index < pages_in_cl && xfer_size < size) {
                                        /*
                                         * accumulate allocated pages within 
                                         * a physical segment
                                         */
                                        if (CLMAP_ISSET(clmap, cl_index)) {
                                                xfer_size  += vm_page_size;
                                                cur_offset += vm_page_size;
                                                cl_index++;

                                                BS_STAT(psp[seg_index]->ps_bs,
                                                        psp[seg_index]->ps_bs->bs_pages_in++);
                                        } else
                                                break;
                                }
                                if (cl_index < pages_in_cl || xfer_size >= size) {
                                        /*
                                         * we've hit an unallocated page or 
                                         * the end of this request... see if
                                         * it's time to fire the I/O
                                         */
                                        break;
                                }
                                /*
                                 * we've hit the end of the current physical
                                 * segment and there's more to do, so try 
                                 * moving to the next one
                                 */
                                seg_index++;
                                  
                                ps_offset[seg_index] = ps_clmap(vs, cur_offset & ~cl_mask, &clmap, CL_FIND, 0, 0);
                                psp[seg_index] = CLMAP_PS(clmap);
                                ps_info_valid = 1;

                                if ((ps_offset[seg_index - 1] != (ps_offset[seg_index] - cl_size)) || (psp[seg_index - 1] != psp[seg_index])) {
                                        /*
                                         * if the physical segment we're about 
                                         * to step into is not contiguous to 
                                         * the one we're currently in, or it's 
                                         * in a different paging file, or
                                         * it hasn't been allocated....
                                         * we stop this run and go check
                                         * to see if it's time to fire the I/O
                                         */
                                        break;
                                }
                                /*
                                 * start with first page of the next physical
                                 * segment
                                 */
                                cl_index = 0;
                        }
                        if (xfer_size == 0) {
                                /*
                                 * no I/O to generate for this segment
                                 */
                                continue;
                        }
                        if (cur_offset <= orig_vs_offset) {
                                /*
                                 * we've hit a hole in our speculative cluster
                                 * before the offset that we're really after...
                                 * don't issue the I/O since it doesn't encompass
                                 * the original offset and we're looking to only
                                 * pull in the speculative pages if they can be
                                 * made part of a single I/O
                                 */
                                size      -= xfer_size;
                                vs_offset += xfer_size;

                                continue;
                        }
                        /*
                         * we have a contiguous range of allocated pages
                         * to read from that encompasses the original offset
                         */
                        page_list_count = 0;
                        memory_object_super_upl_request(vs->vs_control, (memory_object_offset_t)vs_offset,
                                                        xfer_size, xfer_size, 
                                                        &upl, NULL, &page_list_count,
                                                        request_flags | UPL_SET_INTERNAL);

                        error = ps_read_file(psp[beg_pseg], 
                                             upl, (upl_offset_t) 0, 
                                             ps_offset[beg_pseg] + (beg_indx * vm_page_size), 
                                             xfer_size, &residual, io_flags);


                        /*
                         * Adjust counts and send response to VM.  Optimize 
                         * for the common case, i.e. no error and/or partial
                         * data. If there was an error, then we need to error
                         * the entire range, even if some data was successfully
                         * read. If there was a partial read we may supply some
                         * data and may error some as well.  In all cases the
                         * VM must receive some notification for every page 
                         * in the range.
                         */
                        if ((error == KERN_SUCCESS) && (residual == 0)) {
                                /*
                                 * Got everything we asked for, supply the data
                                 * to the VM.  Note that as a side effect of 
                                 * supplying the data, the buffer holding the 
                                 * supplied data is deallocated from the pager's
                                 *  address space.
                                 */
                                lsize = xfer_size;
                                failed_size = 0;
                        } else {
                                lsize = 0;
                                failed_size = xfer_size;

                                if (error == KERN_SUCCESS) {
                                        if (residual == xfer_size) {
                                                /*
                                                 * If a read operation returns no error
                                                 * and no data moved, we turn it into
                                                 * an error, assuming we're reading at
                                                 * or beyong EOF.
                                                 * Fall through and error the entire range.
                                                 */
                                                error = KERN_FAILURE;
                                        } else {
                                                /*
                                                 * Otherwise, we have partial read. If
                                                 * the part read is a integral number
                                                 * of pages supply it. Otherwise round
                                                 * it up to a page boundary, zero fill
                                                 * the unread part, and supply it.
                                                 * Fall through and error the remainder
                                                 * of the range, if any.
                                                 */
                                                int fill;

                                                fill = residual & (vm_page_size - 1);
                                                lsize = (xfer_size - residual) + fill;

                                                if (lsize < xfer_size)
                                                        failed_size = xfer_size - lsize;

                                                if (reclaim_all == FALSE)
                                                        error = KERN_FAILURE;
                                        }
                                } 
                        }
                        pvs_object_data_provided(vs, upl, vs_offset, lsize);

                        if (failed_size) {
                                /*
                                 * There was an error in some part of the range, tell
                                 * the VM. Note that error is explicitly checked again
                                 * since it can be modified above.
                                 */
                                BS_STAT(psp[beg_pseg]->ps_bs,
                                        psp[beg_pseg]->ps_bs->bs_pages_in_fail += atop_32(failed_size));
                        }
                        /*
                         * we've issued a single I/O that encompassed the original offset
                         * at this point we either met our speculative request length or 
                         * we ran into a 'hole' (i.e. page not present in the cluster, cluster
                         * not present or not physically contiguous to the previous one), so
                         * we're done issuing I/O at this point
                         */
                        return (error);
                }
        }
        return error;
}

int vs_do_async_write = 1;

kern_return_t
vs_cluster_write(
        vstruct_t       vs,
        upl_t           internal_upl,
        upl_offset_t    offset,
        upl_size_t      cnt,
        boolean_t       dp_internal,
        int             flags)
{
        upl_size_t      transfer_size;
        int             error = 0;
        struct clmap    clmap;

        dp_offset_t     actual_offset;  /* Offset within paging segment */
        paging_segment_t ps;
        dp_offset_t     mobj_base_addr;
        dp_offset_t     mobj_target_addr;

        upl_t           upl;
        upl_page_info_t *pl;
        int             page_index;
        unsigned int    page_max_index;
        int             list_size;
        int             pages_in_cl;
        unsigned int    cl_size;
        int             base_index;
        unsigned int    seg_size;
        unsigned int    upl_offset_in_object;
        boolean_t       minimal_clustering = FALSE;
        boolean_t       found_dirty;

        if (!dp_encryption_inited) {
                /*
                 * ENCRYPTED SWAP:
                 * Once we've started using swap, we
                 * can't change our mind on whether
                 * it needs to be encrypted or
                 * not.
                 */
                dp_encryption_inited = TRUE;
        }
        if (dp_encryption) {
                /*
                 * ENCRYPTED SWAP:
                 * the UPL will need to be encrypted...
                 */
                flags |= UPL_PAGING_ENCRYPTED;
        }

        pages_in_cl = 1 << vs->vs_clshift;
        cl_size = pages_in_cl * vm_page_size;
        
#if CONFIG_FREEZE
        minimal_clustering = TRUE;
#else
        if (dp_isssd == TRUE)
                minimal_clustering = TRUE;
#endif
        if (!dp_internal) {
                unsigned int page_list_count;
                int          request_flags;
                unsigned int super_size;
                int          first_dirty;
                int          num_dirty;
                int          num_of_pages;
                int          seg_index;
                upl_offset_t  upl_offset;
                upl_offset_t  upl_offset_aligned;
                dp_offset_t  seg_offset;
                dp_offset_t  ps_offset[((VM_SUPER_CLUSTER / PAGE_SIZE) >> VSTRUCT_MIN_CLSHIFT) + 1];
                paging_segment_t   psp[((VM_SUPER_CLUSTER / PAGE_SIZE) >> VSTRUCT_MIN_CLSHIFT) + 1];


                if (bs_low)
                        super_size = cl_size;
                else
                        super_size = VM_SUPER_CLUSTER;

                request_flags = UPL_NOBLOCK | UPL_CLEAN_IN_PLACE |
                                UPL_RET_ONLY_DIRTY | UPL_COPYOUT_FROM | 
                                UPL_NO_SYNC | UPL_SET_INTERNAL | UPL_SET_LITE;

                if (dp_encryption) {
                        /*
                         * ENCRYPTED SWAP:
                         * request that the UPL be prepared for
                         * encryption.
                         */
                        request_flags |= UPL_ENCRYPT;
                        flags |= UPL_PAGING_ENCRYPTED;
                }

                page_list_count = 0;
                memory_object_super_upl_request(vs->vs_control,
                                (memory_object_offset_t)offset,
                                cnt, super_size, 
                                &upl, NULL, &page_list_count,
                                request_flags | UPL_FOR_PAGEOUT);

                /*
                 * The default pager does not handle objects larger than
                 * 4GB, so it does not deal with offset that don't fit in
                 * 32-bit.  Cast down upl->offset now and make sure we
                 * did not lose any valuable bits.
                 */
                upl_offset_in_object = (unsigned int) upl->offset;
                assert(upl->offset == upl_offset_in_object);

                pl = UPL_GET_INTERNAL_PAGE_LIST(upl);

                seg_size = cl_size - (upl_offset_in_object % cl_size);
                upl_offset_aligned = upl_offset_in_object & ~(cl_size - 1);
                page_index = 0;
                page_max_index = upl->size / PAGE_SIZE;
                found_dirty = TRUE;

                for (seg_index = 0, transfer_size = upl->size; transfer_size > 0; ) {

                        unsigned int    seg_pgcnt;

                        seg_pgcnt = seg_size / PAGE_SIZE;

                        if (minimal_clustering == TRUE) {
                                unsigned int    non_dirty;

                                non_dirty = 0;
                                found_dirty = FALSE;

                                for (; non_dirty < seg_pgcnt; non_dirty++) {
                                        if ((page_index + non_dirty) >= page_max_index)
                                                break;

                                        if (UPL_DIRTY_PAGE(pl, page_index + non_dirty) ||
                                            UPL_PRECIOUS_PAGE(pl, page_index + non_dirty)) {
                                                found_dirty = TRUE;
                                                break;
                                        }
                                }
                        }
                        if (found_dirty == TRUE) {
                                ps_offset[seg_index] = 
                                        ps_clmap(vs, 
                                                 upl_offset_aligned,
                                                 &clmap, CL_ALLOC, 
                                                 cl_size, 0); 

                                if (ps_offset[seg_index] == (dp_offset_t) -1) {
                                        upl_abort(upl, 0);
                                        upl_deallocate(upl);
                                
                                        return KERN_FAILURE;
                                }
                                psp[seg_index] = CLMAP_PS(clmap);
                        }
                        if (transfer_size > seg_size) {
                                page_index += seg_pgcnt;
                                transfer_size -= seg_size;
                                upl_offset_aligned += cl_size;
                                seg_size = cl_size;
                                seg_index++;
                        } else
                                transfer_size = 0;
                }
                /*
                 * Ignore any non-present pages at the end of the
                 * UPL.
                 */
                for (page_index = upl->size / vm_page_size; page_index > 0;)  {
                        if (UPL_PAGE_PRESENT(pl, --page_index)) {
                                page_index++;
                                break;
                        }
                }
                if (page_index == 0) {
                        /*
                         * no pages in the UPL
                         * abort and return
                         */
                        upl_abort(upl, 0);
                        upl_deallocate(upl);

                        return KERN_SUCCESS;
                }
                num_of_pages = page_index;

                base_index = (upl_offset_in_object % cl_size) / PAGE_SIZE;

                for (page_index = 0; page_index < num_of_pages; ) {
                        /*
                         * skip over non-dirty pages
                         */
                        for ( ; page_index < num_of_pages; page_index++) {
                                if (UPL_DIRTY_PAGE(pl, page_index) 
                                        || UPL_PRECIOUS_PAGE(pl, page_index))
                                        /*
                                         * this is a page we need to write
                                         * go see if we can buddy it up with 
                                         * others that are contiguous to it
                                         */
                                        break;
                                /*
                                 * if the page is not-dirty, but present we 
                                 * need to commit it...  This is an unusual 
                                 * case since we only asked for dirty pages
                                 */
                                if (UPL_PAGE_PRESENT(pl, page_index)) {
                                        boolean_t empty = FALSE;
                                        upl_commit_range(upl, 
                                                 page_index * vm_page_size,
                                                 vm_page_size, 
                                                 UPL_COMMIT_NOTIFY_EMPTY,
                                                 pl,
                                                 page_list_count,
                                                 &empty);
                                        if (empty) {
                                                assert(page_index == 
                                                       num_of_pages - 1);
                                                upl_deallocate(upl);
                                        }
                                }
                        }
                        if (page_index == num_of_pages)
                                /*
                                 * no more pages to look at, we're out of here
                                 */
                                break;

                        /*
                         * gather up contiguous dirty pages... we have at 
                         * least 1 * otherwise we would have bailed above
                         * make sure that each physical segment that we step
                         * into is contiguous to the one we're currently in
                         * if it's not, we have to stop and write what we have
                         */
                        for (first_dirty = page_index; 
                                        page_index < num_of_pages; ) {
                                if ( !UPL_DIRTY_PAGE(pl, page_index) 
                                        && !UPL_PRECIOUS_PAGE(pl, page_index))
                                        break;
                                page_index++;
                                /*
                                 * if we just looked at the last page in the UPL
                                 * we don't need to check for physical segment
                                 * continuity
                                 */
                                if (page_index < num_of_pages) {
                                        int cur_seg;
                                        int nxt_seg;

                                        cur_seg = (base_index + (page_index - 1))/pages_in_cl;
                                        nxt_seg = (base_index + page_index)/pages_in_cl;

                                        if (cur_seg != nxt_seg) {
                                                if ((ps_offset[cur_seg] != (ps_offset[nxt_seg] - cl_size)) || (psp[cur_seg] != psp[nxt_seg]))
                                                /*
                                                 * if the segment we're about 
                                                 * to step into is not 
                                                 * contiguous to the one we're 
                                                 * currently in, or it's in a 
                                                 * different paging file....
                                                 * we stop here and generate 
                                                 * the I/O
                                                 */
                                                        break;
                                        }
                                }
                        }
                        num_dirty = page_index - first_dirty;

                        if (num_dirty) {
                                upl_offset = first_dirty * vm_page_size;
                                transfer_size = num_dirty * vm_page_size;

                                while (transfer_size) {

                                        if ((seg_size = cl_size - 
                                                ((upl_offset_in_object +
                                                  upl_offset) % cl_size)) 
                                                        > transfer_size)
                                                seg_size = transfer_size;

                                        ps_vs_write_complete(
                                                vs, 
                                                (upl_offset_in_object +
                                                 upl_offset), 
                                                seg_size, error);

                                        transfer_size -= seg_size;
                                        upl_offset += seg_size;
                                }
                                upl_offset = first_dirty * vm_page_size;
                                transfer_size = num_dirty * vm_page_size;

                                seg_index  = (base_index + first_dirty) / pages_in_cl;
                                seg_offset = (upl_offset_in_object + upl_offset) % cl_size;

                                error = ps_write_file(psp[seg_index], 
                                                upl, upl_offset,
                                                ps_offset[seg_index] 
                                                                + seg_offset, 
                                                transfer_size, flags);
                        }
                }

        } else {
                assert(cnt <= (unsigned) (vm_page_size << vs->vs_clshift));
                list_size = cnt;

                page_index = 0;
                /* The caller provides a mapped_data which is derived  */
                /* from a temporary object.  The targeted pages are    */
                /* guaranteed to be set at offset 0 in the mapped_data */
                /* The actual offset however must still be derived     */
                /* from the offset in the vs in question               */
                mobj_base_addr = offset;
                mobj_target_addr = mobj_base_addr;

                for (transfer_size = list_size; transfer_size != 0;) {
                        actual_offset = ps_clmap(vs, mobj_target_addr, 
                                &clmap, CL_ALLOC, 
                                transfer_size < cl_size ? 
                                        transfer_size : cl_size, 0);
                        if(actual_offset == (dp_offset_t) -1) {
                                error = 1;
                                break;
                        }
                        cnt = MIN(transfer_size, 
                                  (unsigned) CLMAP_NPGS(clmap) * vm_page_size);
                        ps = CLMAP_PS(clmap);
                        /* Assume that the caller has given us contiguous */
                        /* pages */
                        if(cnt) {
                                ps_vs_write_complete(vs, mobj_target_addr, 
                                                                cnt, error);
                                error = ps_write_file(ps, internal_upl,
                                                0, actual_offset,
                                                cnt, flags);
                                if (error)
                                        break;
                           }
                        if (error)
                                break;
                        actual_offset += cnt;
                        mobj_target_addr += cnt;
                        transfer_size -= cnt;
                        cnt = 0;

                        if (error)
                                break;
                }
        }
        if(error)
                return KERN_FAILURE;
        else
                return KERN_SUCCESS;
}

vm_size_t
ps_vstruct_allocated_size(
        vstruct_t       vs)
{
        int             num_pages;
        struct vs_map   *vsmap;
        unsigned int    i, j, k;

        num_pages = 0;
        if (vs->vs_indirect) {
                /* loop on indirect maps */
                for (i = 0; i < INDIRECT_CLMAP_ENTRIES(vs->vs_size); i++) {
                        vsmap = vs->vs_imap[i];
                        if (vsmap == NULL)
                                continue;
                        /* loop on clusters in this indirect map */
                        for (j = 0; j < CLMAP_ENTRIES; j++) {
                                if (VSM_ISCLR(vsmap[j]) ||
                                    VSM_ISERR(vsmap[j]))
                                        continue;
                                /* loop on pages in this cluster */
                                for (k = 0; k < VSCLSIZE(vs); k++) {
                                        if ((VSM_BMAP(vsmap[j])) & (1 << k))
                                                num_pages++;
                                }
                        }
                }
        } else {
                vsmap = vs->vs_dmap;
                if (vsmap == NULL)
                        return 0;
                /* loop on clusters in the direct map */
                for (j = 0; j < CLMAP_ENTRIES; j++) {
                        if (VSM_ISCLR(vsmap[j]) ||
                            VSM_ISERR(vsmap[j])) 
                                continue;
                        /* loop on pages in this cluster */
                        for (k = 0; k < VSCLSIZE(vs); k++) {
                                if ((VSM_BMAP(vsmap[j])) & (1 << k))
                                        num_pages++;
                        }
                }
        }

        return ptoa_32(num_pages);
}

unsigned int
ps_vstruct_allocated_pages(
        vstruct_t               vs,
        default_pager_page_t    *pages,
        unsigned int            pages_size)
{
        unsigned int    num_pages;
        struct vs_map   *vsmap;
        dp_offset_t     offset;
        unsigned int    i, j, k;

        num_pages = 0;
        offset = 0;
        if (vs->vs_indirect) {
                /* loop on indirect maps */
                for (i = 0; i < INDIRECT_CLMAP_ENTRIES(vs->vs_size); i++) {
                        vsmap = vs->vs_imap[i];
                        if (vsmap == NULL) {
                                offset += (vm_page_size * CLMAP_ENTRIES *
                                           VSCLSIZE(vs));
                                continue;
                        }
                        /* loop on clusters in this indirect map */
                        for (j = 0; j < CLMAP_ENTRIES; j++) {
                                if (VSM_ISCLR(vsmap[j]) ||
                                    VSM_ISERR(vsmap[j])) {
                                        offset += vm_page_size * VSCLSIZE(vs);
                                        continue;
                                }
                                /* loop on pages in this cluster */
                                for (k = 0; k < VSCLSIZE(vs); k++) {
                                        if ((VSM_BMAP(vsmap[j])) & (1 << k)) {
                                                num_pages++;
                                                if (num_pages < pages_size)
                                                        pages++->dpp_offset =
                                                                offset;
                                        }
                                        offset += vm_page_size;
                                }
                        }
                }
        } else {
                vsmap = vs->vs_dmap;
                if (vsmap == NULL)
                        return 0;
                /* loop on clusters in the direct map */
                for (j = 0; j < CLMAP_ENTRIES; j++) {
                        if (VSM_ISCLR(vsmap[j]) ||
                            VSM_ISERR(vsmap[j])) {
                                offset += vm_page_size * VSCLSIZE(vs);
                                continue;
                        }
                        /* loop on pages in this cluster */
                        for (k = 0; k < VSCLSIZE(vs); k++) {
                                if ((VSM_BMAP(vsmap[j])) & (1 << k)) {
                                        num_pages++;
                                        if (num_pages < pages_size)
                                                pages++->dpp_offset = offset;
                                }
                                offset += vm_page_size;
                        }
                }
        }

        return num_pages;
}


kern_return_t
ps_vstruct_transfer_from_segment(
        vstruct_t        vs,
        paging_segment_t segment,
        upl_t            upl)
{
        struct vs_map   *vsmap;
//      struct vs_map   old_vsmap;
//      struct vs_map   new_vsmap;
        unsigned int    i, j;

        VS_LOCK(vs);    /* block all work on this vstruct */
                        /* can't allow the normal multiple write */
                        /* semantic because writes may conflict */
        vs->vs_xfer_pending = TRUE;
        vs_wait_for_sync_writers(vs);
        vs_start_write(vs);
        vs_wait_for_readers(vs);
        /* we will unlock the vs to allow other writes while transferring */
        /* and will be guaranteed of the persistance of the vs struct     */
        /* because the caller of  ps_vstruct_transfer_from_segment bumped */
        /* vs_async_pending */
        /* OK we now have guaranteed no other parties are accessing this */
        /* vs.  Now that we are also supporting simple lock versions of  */
        /* vs_lock we cannot hold onto VS_LOCK as we may block below.    */
        /* our purpose in holding it before was the multiple write case */
        /* we now use the boolean xfer_pending to do that.  We can use  */
        /* a boolean instead of a count because we have guaranteed single */
        /* file access to this code in its caller */
        VS_UNLOCK(vs);
vs_changed:
        if (vs->vs_indirect) {
                unsigned int    vsmap_size;
                int             clmap_off;
                /* loop on indirect maps */
                for (i = 0; i < INDIRECT_CLMAP_ENTRIES(vs->vs_size); i++) {
                        vsmap = vs->vs_imap[i];
                        if (vsmap == NULL)
                                continue;
                        /* loop on clusters in this indirect map */
                        clmap_off = (vm_page_size * CLMAP_ENTRIES *
                                           VSCLSIZE(vs) * i);
                        if(i+1 == INDIRECT_CLMAP_ENTRIES(vs->vs_size))
                                vsmap_size = vs->vs_size - (CLMAP_ENTRIES * i);
                        else
                                vsmap_size = CLMAP_ENTRIES;
                        for (j = 0; j < vsmap_size; j++) {
                                if (VSM_ISCLR(vsmap[j]) ||
                                    VSM_ISERR(vsmap[j]) ||
                                    (VSM_PS(vsmap[j]) != segment))
                                        continue;
                                if(vs_cluster_transfer(vs, 
                                        (vm_page_size * (j << vs->vs_clshift))
                                        + clmap_off, 
                                        vm_page_size << vs->vs_clshift,
                                        upl)
                                                != KERN_SUCCESS) {
                                   VS_LOCK(vs);
                                   vs->vs_xfer_pending = FALSE;
                                   VS_UNLOCK(vs);
                                   vs_finish_write(vs);
                                   return KERN_FAILURE;
                                }
                                /* allow other readers/writers during transfer*/
                                VS_LOCK(vs);
                                vs->vs_xfer_pending = FALSE;
                                VS_UNLOCK(vs);
                                vs_finish_write(vs);

                                if (backing_store_abort_compaction || backing_store_stop_compaction) {
                                        backing_store_abort_compaction = FALSE;
                                        dprintf(("ps_vstruct_transfer_from_segment - ABORTED\n"));
                                        return KERN_FAILURE;
                                }
                                vnode_pager_throttle();

                                VS_LOCK(vs);
                                vs->vs_xfer_pending = TRUE;
                                vs_wait_for_sync_writers(vs);
                                vs_start_write(vs);
                                vs_wait_for_readers(vs);
                                VS_UNLOCK(vs);
                                if (!(vs->vs_indirect)) {
                                        goto vs_changed;
                                }
                        }
                }
        } else {
                vsmap = vs->vs_dmap;
                if (vsmap == NULL) {
                        VS_LOCK(vs);
                        vs->vs_xfer_pending = FALSE;
                        VS_UNLOCK(vs);
                        vs_finish_write(vs);
                        return KERN_SUCCESS;
                }
                /* loop on clusters in the direct map */
                for (j = 0; j < vs->vs_size; j++) {
                        if (VSM_ISCLR(vsmap[j]) ||
                            VSM_ISERR(vsmap[j]) ||
                            (VSM_PS(vsmap[j]) != segment))
                                continue;
                        if(vs_cluster_transfer(vs, 
                                vm_page_size * (j << vs->vs_clshift), 
                                vm_page_size << vs->vs_clshift,
                                upl) != KERN_SUCCESS) {
                           VS_LOCK(vs);
                           vs->vs_xfer_pending = FALSE;
                           VS_UNLOCK(vs);
                           vs_finish_write(vs);
                           return KERN_FAILURE;
                        }
                        /* allow other readers/writers during transfer*/
                        VS_LOCK(vs);
                        vs->vs_xfer_pending = FALSE;
                        VS_UNLOCK(vs);
                        vs_finish_write(vs);
                        VS_LOCK(vs);
                        vs->vs_xfer_pending = TRUE;
                        vs_wait_for_sync_writers(vs);
                        vs_start_write(vs);
                        vs_wait_for_readers(vs);
                        VS_UNLOCK(vs);
                        if (vs->vs_indirect) {
                                goto vs_changed;
                        }
                }
        }

        VS_LOCK(vs);
        vs->vs_xfer_pending = FALSE;
        VS_UNLOCK(vs);
        vs_finish_write(vs);
        return KERN_SUCCESS;
}



vs_map_t
vs_get_map_entry(
        vstruct_t       vs, 
        dp_offset_t     offset)
{
        struct vs_map   *vsmap;
        dp_offset_t     cluster;

        cluster = atop_32(offset) >> vs->vs_clshift;
        if (vs->vs_indirect) {
                long    ind_block = cluster/CLMAP_ENTRIES;

                /* Is the indirect block allocated? */
                vsmap = vs->vs_imap[ind_block];
                if(vsmap == (vs_map_t) NULL)
                        return vsmap;
        } else
                vsmap = vs->vs_dmap;
        vsmap += cluster%CLMAP_ENTRIES;
        return vsmap;
}

kern_return_t
vs_cluster_transfer(
        vstruct_t       vs,
        dp_offset_t     offset,
        dp_size_t       cnt,
        upl_t           upl)
{
        dp_offset_t             actual_offset;
        paging_segment_t        ps;
        struct clmap            clmap;
        kern_return_t           error = KERN_SUCCESS;
        unsigned int            size, size_wanted;
        int                     i;
        unsigned int            residual = 0;
        unsigned int            unavail_size;
//      default_pager_thread_t  *dpt;
//      boolean_t               dealloc;
        struct  vs_map          *vsmap_ptr = NULL;
        struct  vs_map          read_vsmap;
        struct  vs_map          original_read_vsmap;
        struct  vs_map          write_vsmap;
//      upl_t                           sync_upl;
//      vm_offset_t                     ioaddr;

        /* vs_cluster_transfer reads in the pages of a cluster and
         * then writes these pages back to new backing store.  The
         * segment the pages are being read from is assumed to have
         * been taken off-line and is no longer considered for new
         * space requests.
         */

        /*
         * This loop will be executed once per cluster referenced.
         * Typically this means once, since it's unlikely that the
         * VM system will ask for anything spanning cluster boundaries.
         *
         * If there are holes in a cluster (in a paging segment), we stop
         * reading at the hole, then loop again, hoping to
         * find valid pages later in the cluster.  This continues until
         * the entire range has been examined, and read, if present.  The
         * pages are written as they are read.  If a failure occurs after
         * some pages are written the unmap call at the bottom of the loop
         * recovers the backing store and the old backing store remains
         * in effect.
         */

        VSM_CLR(write_vsmap);
        VSM_CLR(original_read_vsmap);
        /* grab the actual object's pages to sync with I/O */
        while (cnt && (error == KERN_SUCCESS)) {
                vsmap_ptr = vs_get_map_entry(vs, offset);
                actual_offset = ps_clmap(vs, offset, &clmap, CL_FIND, 0, 0);

                if (actual_offset == (dp_offset_t) -1) {

                        /*
                         * Nothing left to write in this cluster at least
                         * set write cluster information for any previous
                         * write, clear for next cluster, if there is one
                         */
                        unsigned int local_size, clmask, clsize;

                        clsize = vm_page_size << vs->vs_clshift;
                        clmask = clsize - 1;
                        local_size = clsize - (offset & clmask);
                        ASSERT(local_size);
                        local_size = MIN(local_size, cnt);

                        /* This cluster has no data in it beyond what may */
                        /* have been found on a previous iteration through */
                        /* the loop "write_vsmap" */
                        *vsmap_ptr = write_vsmap;
                        VSM_CLR(write_vsmap);
                        VSM_CLR(original_read_vsmap);

                        cnt -= local_size;
                        offset += local_size;
                        continue;
                }

                /*
                 * Count up contiguous available or unavailable
                 * pages.
                 */
                ps = CLMAP_PS(clmap);
                ASSERT(ps);
                size = 0;
                unavail_size = 0;
                for (i = 0;
                     (size < cnt) && (unavail_size < cnt) &&
                     (i < CLMAP_NPGS(clmap)); i++) {
                        if (CLMAP_ISSET(clmap, i)) {
                                if (unavail_size != 0)
                                        break;
                                size += vm_page_size;
                                BS_STAT(ps->ps_bs,
                                        ps->ps_bs->bs_pages_in++);
                        } else {
                                if (size != 0)
                                        break;
                                unavail_size += vm_page_size;
                        }
                }

                if (size == 0) {
                        ASSERT(unavail_size);
                        ps_clunmap(vs, offset, unavail_size);
                        cnt -= unavail_size;
                        offset += unavail_size;
                        if((offset & ((vm_page_size << vs->vs_clshift) - 1)) 
                                == 0) {
                                /* There is no more to transfer in this
                                   cluster
                                */
                                *vsmap_ptr = write_vsmap;
                                VSM_CLR(write_vsmap);
                                VSM_CLR(original_read_vsmap);
                        } 
                        continue;
                }

                if(VSM_ISCLR(original_read_vsmap))
                        original_read_vsmap = *vsmap_ptr;

                if(ps->ps_segtype == PS_PARTITION) {
                        panic("swap partition not supported\n");
                        /*NOTREACHED*/
                        error = KERN_FAILURE;
                        residual = size;
/*
                        NEED TO ISSUE WITH SYNC & NO COMMIT
                        error = ps_read_device(ps, actual_offset, &buffer,
                                       size, &residual, flags);
*/
                } else {
                        /* NEED TO ISSUE WITH SYNC & NO COMMIT */
                        error = ps_read_file(ps, upl, (upl_offset_t) 0, actual_offset, 
                                        size, &residual, 
                                        (UPL_IOSYNC | UPL_NOCOMMIT | (dp_encryption ? UPL_PAGING_ENCRYPTED : 0)));
                }

                read_vsmap = *vsmap_ptr;


                /*
                 * Adjust counts and put data in new BS.  Optimize for the
                 * common case, i.e. no error and/or partial data.
                 * If there was an error, then we need to error the entire
                 * range, even if some data was successfully read.
                 * 
                 */
                if ((error == KERN_SUCCESS) && (residual == 0)) {

                        /*
                         * Got everything we asked for, supply the data to
                         * the new BS.  Note that as a side effect of supplying
                         * the data, the buffer holding the supplied data is
                         * deallocated from the pager's address space unless
                         * the write is unsuccessful.
                         */

                        /* note buffer will be cleaned up in all cases by */
                        /* internal_cluster_write or if an error on write */
                        /* the vm_map_copy_page_discard call              */
                        *vsmap_ptr = write_vsmap;

                        if(vs_cluster_write(vs, upl, offset, 
                                        size, TRUE, UPL_IOSYNC | UPL_NOCOMMIT ) != KERN_SUCCESS) {
                                error = KERN_FAILURE;
                                if(!(VSM_ISCLR(*vsmap_ptr))) {
                                        /* unmap the new backing store object */
                                        ps_clunmap(vs, offset, size);
                                }
                                /* original vsmap */
                                *vsmap_ptr = original_read_vsmap;
                                VSM_CLR(write_vsmap);
                        } else {
                               if((offset + size) & 
                                        ((vm_page_size << vs->vs_clshift)
                                        - 1)) { 
                                        /* There is more to transfer in this
                                           cluster
                                        */
                                        write_vsmap = *vsmap_ptr;
                                        *vsmap_ptr = read_vsmap;
                                        ps_clunmap(vs, offset, size);
                                } else {
                                        /* discard the old backing object */
                                        write_vsmap = *vsmap_ptr;
                                        *vsmap_ptr = read_vsmap;
                                        ps_clunmap(vs, offset, size);
                                        *vsmap_ptr = write_vsmap;
                                        VSM_CLR(write_vsmap);
                                        VSM_CLR(original_read_vsmap);
                                }
                        }
                } else {
                        size_wanted = size;
                        if (error == KERN_SUCCESS) {
                                if (residual == size) {
                                        /*
                                         * If a read operation returns no error
                                         * and no data moved, we turn it into
                                         * an error, assuming we're reading at
                                         * or beyond EOF.
                                         * Fall through and error the entire
                                         * range.
                                         */
                                        error = KERN_FAILURE;
                                        *vsmap_ptr = write_vsmap;
                                        if(!(VSM_ISCLR(*vsmap_ptr))) {
                                        /* unmap the new backing store object */
                                        ps_clunmap(vs, offset, size);
                                        }
                                        *vsmap_ptr = original_read_vsmap;
                                        VSM_CLR(write_vsmap);
                                        continue;
                                } else {
                                        /*
                                         * Otherwise, we have partial read. 
                                         * This is also considered an error
                                         * for the purposes of cluster transfer
                                         */
                                        error = KERN_FAILURE;
                                        *vsmap_ptr = write_vsmap;
                                        if(!(VSM_ISCLR(*vsmap_ptr))) {
                                        /* unmap the new backing store object */
                                        ps_clunmap(vs, offset, size);
                                        }
                                        *vsmap_ptr = original_read_vsmap;
                                        VSM_CLR(write_vsmap);
                                        continue;
                                }
                        }

                }
                cnt -= size;
                offset += size;

        } /* END while (cnt && (error == 0)) */
        if(!VSM_ISCLR(write_vsmap))
                *vsmap_ptr = write_vsmap;

        return error;
}

kern_return_t
default_pager_add_file(
        MACH_PORT_FACE  backing_store,
        vnode_ptr_t     vp,
        int             record_size,
        vm_size_t       size)
{
        backing_store_t         bs;
        paging_segment_t        ps;
        int                     i;
        unsigned int            j;
        int                     error;

        if ((bs = backing_store_lookup(backing_store))
            == BACKING_STORE_NULL)
                return KERN_INVALID_ARGUMENT;

        PSL_LOCK();
        for (i = 0; i <= paging_segment_max; i++) {
                ps = paging_segments[i];
                if (ps == PAGING_SEGMENT_NULL)
                        continue;
                if (ps->ps_segtype != PS_FILE)
                        continue;

                /*
                 * Check for overlap on same device.
                 */
                if (ps->ps_vnode == (struct vnode *)vp) {
                        PSL_UNLOCK();
                        BS_UNLOCK(bs);
                        return KERN_INVALID_ARGUMENT;
                }
        }
        PSL_UNLOCK();

        /*
         * Set up the paging segment
         */
        ps = (paging_segment_t) kalloc(sizeof (struct paging_segment));
        if (ps == PAGING_SEGMENT_NULL) {
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }

        ps->ps_segtype = PS_FILE;
        ps->ps_vnode = (struct vnode *)vp;
        ps->ps_offset = 0;
        ps->ps_record_shift = local_log2(vm_page_size / record_size);
        assert((dp_size_t) size == size);
        ps->ps_recnum = (dp_size_t) size;
        ps->ps_pgnum = ((dp_size_t) size) >> ps->ps_record_shift;

        ps->ps_pgcount = ps->ps_pgnum;
        ps->ps_clshift = local_log2(bs->bs_clsize);
        ps->ps_clcount = ps->ps_ncls = ps->ps_pgcount >> ps->ps_clshift;
        ps->ps_special_clusters = 0;
        ps->ps_hint = 0;

        PS_LOCK_INIT(ps);
        ps->ps_bmap = (unsigned char *) kalloc(RMAPSIZE(ps->ps_ncls));
        if (!ps->ps_bmap) {
                PS_LOCK_DESTROY(ps);
                kfree(ps, sizeof *ps);
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }
        for (j = 0; j < ps->ps_ncls; j++) {
                clrbit(ps->ps_bmap, j);
        }

        if(paging_segment_count == 0) {
                ps->ps_state = PS_EMERGENCY_SEGMENT;
                if(use_emergency_swap_file_first) {
                        ps->ps_state |= PS_CAN_USE;
                }
                emergency_segment_backing_store = backing_store;
        } else {
                ps->ps_state = PS_CAN_USE;
        }
        
        ps->ps_bs = bs;

        if ((error = ps_enter(ps)) != 0) {
                kfree(ps->ps_bmap, RMAPSIZE(ps->ps_ncls));
                PS_LOCK_DESTROY(ps);
                kfree(ps, sizeof *ps);
                BS_UNLOCK(bs);
                return KERN_RESOURCE_SHORTAGE;
        }

        bs->bs_pages_free += ps->ps_clcount << ps->ps_clshift;
        bs->bs_pages_total += ps->ps_clcount << ps->ps_clshift;
        PSL_LOCK();
        if(IS_PS_OK_TO_USE(ps)) {
                dp_pages_free += ps->ps_pgcount;
        } else {
                dp_pages_reserve += ps->ps_pgcount;
        }
        PSL_UNLOCK();

        BS_UNLOCK(bs);

        bs_more_space(ps->ps_clcount);

        /*
         * If the paging segment being activated is not the emergency
         * segment and we notice that the emergency segment is being
         * used then we help recover it. If all goes well, the
         * emergency segment will be back to its original state of
         * online but not activated (till it's needed the next time).
         */
#if CONFIG_FREEZE
        if (!memorystatus_freeze_enabled)
#endif
        {
                ps = paging_segments[EMERGENCY_PSEG_INDEX];
                if(IS_PS_EMERGENCY_SEGMENT(ps) && IS_PS_OK_TO_USE(ps)) {
                        if(default_pager_backing_store_delete(emergency_segment_backing_store)) {
                                dprintf(("Failed to recover emergency paging segment\n"));
                        } else {
                                dprintf(("Recovered emergency paging segment\n"));
                        }
                }
        }
        
        DP_DEBUG(DEBUG_BS_INTERNAL,
                 ("device=0x%x,offset=0x%x,count=0x%x,record_size=0x%x,shift=%d,total_size=0x%x\n",
                  device, offset, (dp_size_t) size, record_size,
                  ps->ps_record_shift, ps->ps_pgnum));

        return KERN_SUCCESS;
}



kern_return_t
ps_read_file(
        paging_segment_t        ps,
        upl_t                   upl,
        upl_offset_t            upl_offset,
        dp_offset_t             offset,
        upl_size_t              size,
        unsigned int            *residualp,
        int                     flags)
{
        vm_object_offset_t      f_offset;
        int                     error = 0;
        int                     result;

        assert(dp_encryption_inited);

        clustered_reads[atop_32(size)]++;

        f_offset = (vm_object_offset_t)(ps->ps_offset + offset);
        
        /*
         * for transfer case we need to pass uploffset and flags
         */
        assert((upl_size_t) size == size);
        error = vnode_pagein(ps->ps_vnode, upl, upl_offset, f_offset, (upl_size_t)size, flags, NULL);

        /* The vnode_pagein semantic is somewhat at odds with the existing   */
        /* device_read semantic.  Partial reads are not experienced at this  */
        /* level.  It is up to the bit map code and cluster read code to     */
        /* check that requested data locations are actually backed, and the  */
        /* pagein code to either read all of the requested data or return an */
        /* error. */

        if (error)
                result = KERN_FAILURE;
        else {
                *residualp = 0;
                result = KERN_SUCCESS;
        }
        return result;
}

kern_return_t
ps_write_file(
        paging_segment_t        ps,
        upl_t                   upl,
        upl_offset_t            upl_offset,
        dp_offset_t             offset,
        unsigned int            size,
        int                     flags)
{
        vm_object_offset_t      f_offset;
        kern_return_t           result;

        assert(dp_encryption_inited);

        clustered_writes[atop_32(size)]++;
        f_offset = (vm_object_offset_t)(ps->ps_offset + offset);

        if (flags & UPL_PAGING_ENCRYPTED) {
                /*
                 * ENCRYPTED SWAP:
                 * encrypt all the pages that we're going
                 * to pageout.
                 */
                upl_encrypt(upl, upl_offset, size);
        }
        assert((upl_size_t) size == size);
        if (vnode_pageout(ps->ps_vnode, upl, upl_offset, f_offset, (upl_size_t)size, flags, NULL))
                result = KERN_FAILURE;
        else
                result = KERN_SUCCESS;

        return result;
}

static inline void ps_vnode_trim_init(struct ps_vnode_trim_data *data)
{
#pragma unused(data)
}

static inline void ps_vnode_trim_now(struct ps_vnode_trim_data *data)
{
#pragma unused(data)
}

static inline void ps_vnode_trim_more(struct ps_vnode_trim_data *data, struct vs_map *map, unsigned int shift, dp_size_t length)
{
#pragma unused(data, map, shift, length)
}

kern_return_t
default_pager_triggers( __unused MACH_PORT_FACE default_pager,
        int             hi_wat,
        int             lo_wat,
        int             flags,
        MACH_PORT_FACE  trigger_port)
{
        MACH_PORT_FACE release = IPC_PORT_NULL;
        kern_return_t kr;
        clock_sec_t now;
        clock_nsec_t nanoseconds_dummy;
        static clock_sec_t error_notify = 0;

        PSL_LOCK();
        if (flags == SWAP_ENCRYPT_ON) {
                /* ENCRYPTED SWAP: turn encryption on */
                release = trigger_port;
                if (!dp_encryption_inited) {
                        dp_encryption_inited = TRUE;
                        dp_encryption = TRUE;
                        kr = KERN_SUCCESS;
                } else {
                        kr = KERN_FAILURE;
                }
        } else if (flags == SWAP_ENCRYPT_OFF) {
                /* ENCRYPTED SWAP: turn encryption off */
                release = trigger_port;
                if (!dp_encryption_inited) {
                        dp_encryption_inited = TRUE;
                        dp_encryption = FALSE;
                        kr = KERN_SUCCESS;
                } else {
                        kr = KERN_FAILURE;
                }
        } else if (flags == HI_WAT_ALERT) {
                release = min_pages_trigger_port;
#if CONFIG_FREEZE
                /* High and low water signals aren't applicable when freeze is */
                /* enabled, so release the trigger ports here and return       */
                /* KERN_FAILURE.                                               */
                if (memorystatus_freeze_enabled) {
                        if (IP_VALID( trigger_port )){
                                ipc_port_release_send( trigger_port );
                        }
                        min_pages_trigger_port = IPC_PORT_NULL;
                        kr = KERN_FAILURE;
                }
                else
#endif
                {
                        min_pages_trigger_port = trigger_port;
                        minimum_pages_remaining = hi_wat/vm_page_size;
                        bs_low = FALSE;
                        kr = KERN_SUCCESS;
                }
        } else if (flags ==  LO_WAT_ALERT) {
                release = max_pages_trigger_port;
#if CONFIG_FREEZE
                if (memorystatus_freeze_enabled) {
                        if (IP_VALID( trigger_port )){
                                ipc_port_release_send( trigger_port );
                        }
                        max_pages_trigger_port = IPC_PORT_NULL;
                        kr = KERN_FAILURE;
                }
                else
#endif
                {
                        max_pages_trigger_port = trigger_port;
                        maximum_pages_free = lo_wat/vm_page_size;
                        kr = KERN_SUCCESS;
                }
        } else if (flags == USE_EMERGENCY_SWAP_FILE_FIRST) {
                use_emergency_swap_file_first = TRUE;
                release = trigger_port;
                kr = KERN_SUCCESS;
        } else if (flags == SWAP_FILE_CREATION_ERROR) {
                release = trigger_port;
                kr = KERN_SUCCESS;
                if( paging_segment_count == 1) {
                        use_emergency_swap_file_first = TRUE;
                }
                no_paging_space_action();
                clock_get_system_nanotime(&now, &nanoseconds_dummy);
                if (now > error_notify + 5) {
                        dprintf(("Swap File Error.\n"));
                        error_notify = now;
                }
        } else {
                release = trigger_port;
                kr =  KERN_INVALID_ARGUMENT;
        }
        PSL_UNLOCK();

        if (IP_VALID(release))
                ipc_port_release_send(release);
        
        return kr;
}

/*
 * Monitor the amount of available backing store vs. the amount of
 * required backing store, notify a listener (if present) when 
 * backing store may safely be removed.
 *
 * We attempt to avoid the situation where backing store is 
 * discarded en masse, as this can lead to thrashing as the
 * backing store is compacted.
 */

#define PF_INTERVAL     3       /* time between free level checks */
#define PF_LATENCY      10      /* number of intervals before release */

static int dp_pages_free_low_count = 0;
thread_call_t default_pager_backing_store_monitor_callout;

void
default_pager_backing_store_monitor(__unused thread_call_param_t p1,
                                                                        __unused thread_call_param_t p2)
{
//      unsigned long long      average;
        ipc_port_t              trigger;
        uint64_t                deadline;

        /*
         * We determine whether it will be safe to release some
         * backing store by watching the free page level.  If
         * it remains below the maximum_pages_free threshold for
         * at least PF_LATENCY checks (taken at PF_INTERVAL seconds)
         * then we deem it safe.
         *
         * Note that this establishes a maximum rate at which backing
         * store will be released, as each notification (currently)
         * only results in a single backing store object being
         * released.
         */
        if (dp_pages_free > maximum_pages_free) {
                dp_pages_free_low_count++;
        } else {
                dp_pages_free_low_count = 0;
        }

        /* decide whether to send notification */
        trigger = IP_NULL;
        if (max_pages_trigger_port &&
            (backing_store_release_trigger_disable == 0) &&
            (dp_pages_free_low_count > PF_LATENCY)) {
                trigger = max_pages_trigger_port;
                max_pages_trigger_port = NULL;
        }

        /* send notification */
        if (trigger != IP_NULL) {
                VSL_LOCK();
                if(backing_store_release_trigger_disable != 0) {
                        assert_wait((event_t) 
                                    &backing_store_release_trigger_disable, 
                                    THREAD_UNINT);
                        VSL_UNLOCK();
                        thread_block(THREAD_CONTINUE_NULL);
                } else {
                        VSL_UNLOCK();
                }
                dprintf(("default_pager_backing_store_monitor - send LO_WAT_ALERT\n"));

                default_pager_space_alert(trigger, LO_WAT_ALERT);
                ipc_port_release_send(trigger);
                dp_pages_free_low_count = 0;
        }

        clock_interval_to_deadline(PF_INTERVAL, NSEC_PER_SEC, &deadline);
        thread_call_enter_delayed(default_pager_backing_store_monitor_callout, deadline);
}

#if CONFIG_FREEZE
unsigned int default_pager_swap_pages_free() {
        return dp_pages_free;
}
#endif