xnu-1699.32.7.tar.gz

[apple/xnu.git] / bsd / kern / decmpfs.c

/*
 * Copyright (c) 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@
 */
#if !HFS_COMPRESSION
/* we need these symbols even though compression is turned off */
char register_decmpfs_decompressor;
char unregister_decmpfs_decompressor;
#else /* HFS_COMPRESSION */
#include <sys/kernel.h>
#include <sys/vnode_internal.h>
#include <sys/file_internal.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <sys/xattr.h>
#include <sys/namei.h>
#include <sys/user.h>
#include <sys/mount_internal.h>
#include <sys/ubc.h>
#include <sys/decmpfs.h>
#include <sys/uio_internal.h>
#include <libkern/OSByteOrder.h>

#pragma mark --- debugging ---

#define COMPRESSION_DEBUG 0
#define COMPRESSION_DEBUG_VERBOSE 0
#define MALLOC_DEBUG 0

static const char *
baseName(const char *path)
{
    if (!path)
        return NULL;
    const char *ret = path;
    int i;
    for (i = 0; path[i] != 0; i++) {
        if (path[i] == '/')
            ret = &path[i + 1];
    }
    return ret;
}

#define ErrorLog(x, args...) printf("%s:%d:%s: " x, baseName(__FILE__), __LINE__, __FUNCTION__, ## args)

#if COMPRESSION_DEBUG
#define DebugLog ErrorLog
#else
#define DebugLog(x...) do { } while(0)
#endif

#if COMPRESSION_DEBUG_VERBOSE
#define VerboseLog ErrorLog
#else
#define VerboseLog(x...) do { } while(0)
#endif

#if MALLOC_DEBUG

static SInt32 totalAlloc;

typedef struct {
    uint32_t allocSz;
    uint32_t magic;
    const char *file;
    int line;
} allocated;

static void *
_malloc(uint32_t sz, __unused int type, __unused int flags, const char *file, int line)
{
    uint32_t allocSz = sz + 2 * sizeof(allocated);
    
    allocated *alloc = NULL;
    MALLOC(alloc, allocated *, allocSz, type, flags);
    if (!alloc) {
        ErrorLog("malloc failed\n");
        return NULL;
    }
    
    char *ret = (char*)&alloc[1];
    allocated *alloc2 = (allocated*)(ret + sz);
        
    alloc->allocSz = allocSz;
    alloc->magic = 0xdadadada;
    alloc->file = file;
    alloc->line = line;
    
    *alloc2 = *alloc;
    
    int s = OSAddAtomic(sz, &totalAlloc);
    ErrorLog("malloc(%d) -> %p, total allocations %d\n", sz, ret, s + sz);
    
    return ret;
}

static void
_free(char *ret, __unused int type, const char *file, int line)
{
    if (!ret) {
        ErrorLog("freeing null\n");
        return;
    }
    allocated *alloc = (allocated*)ret;
    alloc--;
    uint32_t sz = alloc->allocSz - 2 * sizeof(allocated);
    allocated *alloc2 = (allocated*)(ret + sz);
    
    if (alloc->magic != 0xdadadada) {
        panic("freeing bad pointer");
    }
        
    if (memcmp(alloc, alloc2, sizeof(*alloc)) != 0) {
        panic("clobbered data");
    }
    
    memset(ret, 0xce, sz);
    alloc2->file = file;
    alloc2->line = line;
    FREE(alloc, type);
    int s = OSAddAtomic(-sz, &totalAlloc);
    ErrorLog("free(%p,%d) -> total allocations %d\n", ret, sz, s - sz);
}

#undef MALLOC
#undef FREE
#define MALLOC(space, cast, size, type, flags) (space) = (cast)_malloc(size, type, flags, __FILE__, __LINE__)
#define FREE(addr, type) _free((void *)addr, type, __FILE__, __LINE__)

#endif /* MALLOC_DEBUG */

#pragma mark --- globals ---

static lck_grp_t *decmpfs_lockgrp;

static decmpfs_registration * decompressors[CMP_MAX]; /* the registered compressors */
static lck_rw_t * decompressorsLock;
static int decompress_channel; /* channel used by decompress_file to wake up waiters */
static lck_mtx_t *decompress_channel_mtx;

vfs_context_t decmpfs_ctx;

#pragma mark --- decmp_get_func ---

#define offsetof_func(func) ((uintptr_t)(&(((decmpfs_registration*)NULL)->func)))

static void *
_func_from_offset(uint32_t type, int offset)
{
    /* get the function at the given offset in the registration for the given type */
    decmpfs_registration *reg = decompressors[type];
    char *regChar = (char*)reg;
    char *func = &regChar[offset];
    void **funcPtr = (void**)func;
    return funcPtr[0];
}

extern void IOServicePublishResource( const char * property, boolean_t value );
extern boolean_t IOServiceWaitForMatchingResource( const char * property, uint64_t timeout );
extern boolean_t IOCatalogueMatchingDriversPresent( const char * property );

static void *
_decmp_get_func(uint32_t type, int offset)
{
        /*
         this function should be called while holding a shared lock to decompressorsLock,
         and will return with the lock held
         */
        
        if (type >= CMP_MAX)
                return NULL;
        
        if (decompressors[type] != NULL) {
                // the compressor has already registered but the function might be null
                return _func_from_offset(type, offset);
        }
        
    // does IOKit know about a kext that is supposed to provide this type?
    char providesName[80];
    snprintf(providesName, sizeof(providesName), "com.apple.AppleFSCompression.providesType%u", type);
    if (IOCatalogueMatchingDriversPresent(providesName)) {
        // there is a kext that says it will register for this type, so let's wait for it
        char resourceName[80];
        uint64_t delay = 10000000ULL; // 10 milliseconds.
        snprintf(resourceName, sizeof(resourceName), "com.apple.AppleFSCompression.Type%u", type);
        printf("waiting for %s\n", resourceName);
        while(decompressors[type] == NULL) {
            lck_rw_done(decompressorsLock); // we have to unlock to allow the kext to register
            if (IOServiceWaitForMatchingResource(resourceName, delay)) {
                break;
            }
            if (!IOCatalogueMatchingDriversPresent(providesName)) {
                // 
                printf("the kext with %s is no longer present\n", providesName);
                break;
            }
            printf("still waiting for %s\n", resourceName);
            delay *= 2;
            lck_rw_lock_shared(decompressorsLock);
        }
        // IOKit says the kext is loaded, so it should be registered too!
        if (decompressors[type] == NULL) {
            ErrorLog("we found %s, but the type still isn't registered\n", providesName);
            return NULL;
        }
        // it's now registered, so let's return the function
        return _func_from_offset(type, offset);
    }
    
        // the compressor hasn't registered, so it never will unless someone manually kextloads it
        ErrorLog("tried to access a compressed file of unregistered type %d\n", type);
        return NULL;
}

#define decmp_get_func(type, func) ((typeof(((decmpfs_registration*)NULL)->func))_decmp_get_func(type, offsetof_func(func)))

#pragma mark --- utilities ---

#if COMPRESSION_DEBUG
static char*
vnpath(vnode_t vp, char *path, int len)
{
    int origlen = len;
    path[0] = 0;
    vn_getpath(vp, path, &len);
    path[origlen - 1] = 0;
    return path;
}

static int
vnsize(vnode_t vp, uint64_t *size)
{
    struct vnode_attr va;
    VATTR_INIT(&va);
    VATTR_WANTED(&va, va_data_size);
        int error = vnode_getattr(vp, &va, decmpfs_ctx);
    if (error != 0) {
        ErrorLog("vnode_getattr err %d\n", error);
        return error;
    }
    *size = va.va_data_size;
    return 0;
}
#endif /* COMPRESSION_DEBUG */

#pragma mark --- cnode routines ---

void
decmpfs_cnode_init(decmpfs_cnode *cp)
{
    memset(cp, 0, sizeof(*cp));
        lck_rw_init(&cp->compressed_data_lock, decmpfs_lockgrp, NULL);
#if !DECMPFS_SUPPORTS_SWAP64
    lck_mtx_init(&cp->uncompressed_size_mtx, decmpfs_lockgrp, NULL);
#endif
}

void
decmpfs_cnode_destroy(decmpfs_cnode *cp)
{
        lck_rw_destroy(&cp->compressed_data_lock, decmpfs_lockgrp);
#if !DECMPFS_SUPPORTS_SWAP64
    lck_mtx_destroy(&cp->uncompressed_size_mtx, decmpfs_lockgrp);
#endif
}

boolean_t
decmpfs_trylock_compressed_data(decmpfs_cnode *cp, int exclusive)
{
        void *thread = current_thread();
        boolean_t retval = FALSE;

        if (cp->lockowner == thread) {
                /* this thread is already holding an exclusive lock, so bump the count */
                cp->lockcount++;
                retval = TRUE;
        } else if (exclusive) {
                if ((retval = lck_rw_try_lock_exclusive(&cp->compressed_data_lock))) {
                        cp->lockowner = thread;
                        cp->lockcount = 1;
                }
        } else {
                if ((retval = lck_rw_try_lock_shared(&cp->compressed_data_lock))) {
                        cp->lockowner = (void *)-1;
                }
        }
        return retval;
}

void
decmpfs_lock_compressed_data(decmpfs_cnode *cp, int exclusive)
{
        void *thread = current_thread();
        
        if (cp->lockowner == thread) {
                /* this thread is already holding an exclusive lock, so bump the count */
                cp->lockcount++;
        } else if (exclusive) {
                lck_rw_lock_exclusive(&cp->compressed_data_lock);
                cp->lockowner = thread;
                cp->lockcount = 1;
        } else {
                lck_rw_lock_shared(&cp->compressed_data_lock);
                cp->lockowner = (void *)-1;
        }
}

void
decmpfs_unlock_compressed_data(decmpfs_cnode *cp, __unused int exclusive)
{
        void *thread = current_thread();
        
        if (cp->lockowner == thread) {
                /* this thread is holding an exclusive lock, so decrement the count */
                if ((--cp->lockcount) > 0) {
                        /* the caller still has outstanding locks, so we're done */
                        return;
                }
                cp->lockowner = NULL;
        }
        
        lck_rw_done(&cp->compressed_data_lock);
}

uint32_t
decmpfs_cnode_get_vnode_state(decmpfs_cnode *cp)
{
    return cp->cmp_state;
}

void
decmpfs_cnode_set_vnode_state(decmpfs_cnode *cp, uint32_t state, int skiplock)
{
        if (!skiplock) decmpfs_lock_compressed_data(cp, 1);
        cp->cmp_state = state;
    if (state == FILE_TYPE_UNKNOWN) {
        /* clear out the compression type too */
        cp->cmp_type = 0;
    }
        if (!skiplock) decmpfs_unlock_compressed_data(cp, 1);
}

static void
decmpfs_cnode_set_vnode_cmp_type(decmpfs_cnode *cp, uint32_t cmp_type, int skiplock)
{
    if (!skiplock) decmpfs_lock_compressed_data(cp, 1);
    cp->cmp_type = cmp_type;
    if (!skiplock) decmpfs_unlock_compressed_data(cp, 1);
}

static void
decmpfs_cnode_set_vnode_minimal_xattr(decmpfs_cnode *cp, int minimal_xattr, int skiplock)
{
    if (!skiplock) decmpfs_lock_compressed_data(cp, 1);
    cp->cmp_minimal_xattr = minimal_xattr;
    if (!skiplock) decmpfs_unlock_compressed_data(cp, 1);
}

uint64_t
decmpfs_cnode_get_vnode_cached_size(decmpfs_cnode *cp)
{
#if DECMPFS_SUPPORTS_SWAP64
    return cp->uncompressed_size;
#else
    /*
     since this is a 64-bit field, we may not be able to access it atomically
     so lock access
     */
    
    lck_mtx_lock(&(cp->uncompressed_size_mtx));
    uint64_t ret = cp->uncompressed_size;
    lck_mtx_unlock(&(cp->uncompressed_size_mtx));
    return ret;
#endif
}

static void
decmpfs_cnode_set_vnode_cached_size(decmpfs_cnode *cp, uint64_t size)
{
#if DECMPFS_SUPPORTS_SWAP64
    while(1) {
        uint64_t old = cp->uncompressed_size;
        if (OSCompareAndSwap64(old, size, (UInt64*)&cp->uncompressed_size)) {
            return;
        } else {
            /* failed to write our value, so loop */
        }
    }
#else
    /*
     since this is a 64-bit field, we may not be able to access it atomically
     so lock access
     */
    
    lck_mtx_lock(&(cp->uncompressed_size_mtx));
    cp->uncompressed_size = size;
    lck_mtx_unlock(&(cp->uncompressed_size_mtx));
#endif
}

#pragma mark --- decmpfs state routines ---

static int
decmpfs_fetch_compressed_header(vnode_t vp, decmpfs_cnode *cp, decmpfs_header **hdrOut, int returnInvalid)
{
    /*
     fetches vp's compression xattr, converting it into a decmpfs_header; returns 0 or errno
     if returnInvalid == 1, returns the header even if the type was invalid (out of range),
     and return ERANGE in that case
     */
    
        size_t read_size             = 0;
        size_t attr_size             = 0;
    uio_t attr_uio               = NULL;
    int err                      = 0;
    char *data                   = NULL;
    decmpfs_header *hdr = NULL;
        char uio_buf[ UIO_SIZEOF(1) ];
    
    if ((cp != NULL) &&
        (cp->cmp_type != 0) &&
        (cp->cmp_minimal_xattr != 0)) {
        /* this file's xattr didn't have any extra data when we fetched it, so we can synthesize a header from the data in the cnode */
        
        MALLOC(data, char *, sizeof(decmpfs_header), M_TEMP, M_WAITOK);
        if (!data) {
            err = ENOMEM;
            goto out;
        }
        hdr = (decmpfs_header*)data;
        hdr->attr_size = sizeof(decmpfs_disk_header);
        hdr->compression_magic = DECMPFS_MAGIC;
        hdr->compression_type  = cp->cmp_type;
        hdr->uncompressed_size = decmpfs_cnode_get_vnode_cached_size(cp);
    } else {
        /* figure out how big the xattr is on disk */
        err = vn_getxattr(vp, DECMPFS_XATTR_NAME, NULL, &attr_size, XATTR_NOSECURITY, decmpfs_ctx);
        if (err != 0)
            goto out;
        
        if (attr_size < sizeof(decmpfs_disk_header) || attr_size > MAX_DECMPFS_XATTR_SIZE) {
            err = EINVAL;
            goto out;
        }
        
        /* allocation includes space for the extra attr_size field of a compressed_header */
        MALLOC(data, char *, attr_size + sizeof(hdr->attr_size), M_TEMP, M_WAITOK);
        if (!data) {
            err = ENOMEM;
            goto out;
        }
        
        /* read the xattr into our buffer, skipping over the attr_size field at the beginning */
        attr_uio = uio_createwithbuffer(1, 0, UIO_SYSSPACE, UIO_READ, &uio_buf[0], sizeof(uio_buf));
        uio_addiov(attr_uio, CAST_USER_ADDR_T(data + sizeof(hdr->attr_size)), attr_size);
        
        err = vn_getxattr(vp, DECMPFS_XATTR_NAME, attr_uio, &read_size, XATTR_NOSECURITY, decmpfs_ctx);
        if (err != 0)
            goto out;
        if (read_size != attr_size) {
            err = EINVAL;
            goto out;
        }
        hdr = (decmpfs_header*)data;
        hdr->attr_size = attr_size;
        /* swap the fields to native endian */
        hdr->compression_magic = OSSwapLittleToHostInt32(hdr->compression_magic);
        hdr->compression_type  = OSSwapLittleToHostInt32(hdr->compression_type);
        hdr->uncompressed_size = OSSwapLittleToHostInt64(hdr->uncompressed_size);
    }
    
    if (hdr->compression_magic != DECMPFS_MAGIC) {
        ErrorLog("invalid compression_magic 0x%08x, should be 0x%08x\n", hdr->compression_magic, DECMPFS_MAGIC);
        err = EINVAL;
                goto out;
    }
        
    if (hdr->compression_type >= CMP_MAX) {
        if (returnInvalid) {
            /* return the header even though the type is out of range */
            err = ERANGE;
        } else {
            ErrorLog("compression_type %d out of range\n", hdr->compression_type);
            err = EINVAL;
        }
                goto out;
    }
        
out:
    if (err && (err != ERANGE)) {
        DebugLog("err %d\n", err);
        if (data) FREE(data, M_TEMP);
        *hdrOut = NULL;
    } else {
        *hdrOut = hdr;
    }
    return err;
}

static int
decmpfs_fast_get_state(decmpfs_cnode *cp)
{
    /*
     return the cached state
     this should *only* be called when we know that decmpfs_file_is_compressed has already been called,
     because this implies that the cached state is valid
     */
    int cmp_state = decmpfs_cnode_get_vnode_state(cp);
        
    switch(cmp_state) {
        case FILE_IS_NOT_COMPRESSED:
        case FILE_IS_COMPRESSED:
        case FILE_IS_CONVERTING:
            return cmp_state;
        case FILE_TYPE_UNKNOWN:
            /*
             we should only get here if decmpfs_file_is_compressed was not called earlier on this vnode,
             which should not be possible
             */
            ErrorLog("decmpfs_fast_get_state called on unknown file\n");
            return FILE_IS_NOT_COMPRESSED;
        default:
            /* */
            ErrorLog("unknown cmp_state %d\n", cmp_state);
            return FILE_IS_NOT_COMPRESSED;
    }
}

static int
decmpfs_fast_file_is_compressed(decmpfs_cnode *cp)
{
    int cmp_state = decmpfs_cnode_get_vnode_state(cp);
        
    switch(cmp_state) {
        case FILE_IS_NOT_COMPRESSED:
                        return 0;
        case FILE_IS_COMPRESSED:
        case FILE_IS_CONVERTING:
            return 1;
        case FILE_TYPE_UNKNOWN:
            /*
             we should only get here if decmpfs_file_is_compressed was not called earlier on this vnode,
             which should not be possible
             */
            ErrorLog("decmpfs_fast_get_state called on unknown file\n");
            return 0;
        default:
            /* */
            ErrorLog("unknown cmp_state %d\n", cmp_state);
            return 0;
    }
}

errno_t
decmpfs_validate_compressed_file(vnode_t vp, decmpfs_cnode *cp)
{
    /* give a compressor a chance to indicate that a compressed file is invalid */
    
    decmpfs_header *hdr = NULL;
    errno_t err = decmpfs_fetch_compressed_header(vp, cp, &hdr, 0);
    if (err) {
        /* we couldn't get the header */
        if (decmpfs_fast_get_state(cp) == FILE_IS_NOT_COMPRESSED) {
            /* the file is no longer compressed, so return success */
            err = 0;
        }
        goto out;
    }
    
    lck_rw_lock_shared(decompressorsLock);
    decmpfs_validate_compressed_file_func validate = decmp_get_func(hdr->compression_type, validate);
    if (validate) {    /* make sure this validation function is valid */
        /* is the data okay? */
                err = validate(vp, decmpfs_ctx, hdr);
    } else if (decmp_get_func(hdr->compression_type, fetch) == NULL) {
        /* the type isn't registered */
        err = EIO;
    } else {
        /* no validate registered, so nothing to do */
        err = 0;
    }
    lck_rw_done(decompressorsLock);
out:
    if (hdr) FREE(hdr, M_TEMP);
#if COMPRESSION_DEBUG
    if (err) {
        DebugLog("decmpfs_validate_compressed_file ret %d, vp->v_flag %d\n", err, vp->v_flag);
    }
#endif
    return err;
}

int
decmpfs_file_is_compressed(vnode_t vp, decmpfs_cnode *cp)
{
    /*
     determines whether vp points to a compressed file
         
     to speed up this operation, we cache the result in the cnode, and do as little as possible
     in the case where the cnode already has a valid cached state
     
     */
    
    int ret = 0;
        int error = 0;
        uint32_t cmp_state;
        struct vnode_attr va_fetch;
    decmpfs_header *hdr = NULL;
    mount_t mp = NULL;
        int cnode_locked = 0;
    int saveInvalid = 0; // save the header data even though the type was out of range
        
    if (vnode_isnamedstream(vp)) {
        /*
         named streams can't be compressed
         since named streams of the same file share the same cnode,
         we don't want to get/set the state in the cnode, just return 0
         */
        return 0;
    }
    
    /* examine the cached a state in this cnode */    
    cmp_state = decmpfs_cnode_get_vnode_state(cp);
    switch(cmp_state) {
        case FILE_IS_NOT_COMPRESSED:
                        return 0;
        case FILE_IS_COMPRESSED:
                        return 1;
        case FILE_IS_CONVERTING:
            /* treat the file as compressed, because this gives us a way to block future reads until decompression is done */
            return 1;
        case FILE_TYPE_UNKNOWN:
            /* the first time we encountered this vnode, so we need to check it out */
            break;
        default:
            /* unknown state, assume file is not compressed */
            ErrorLog("unknown cmp_state %d\n", cmp_state);
            return 0;
    }
    
//    if (!vnode_isreg(vp)) {
//        /* only regular files can be compressed */
//        ret = FILE_IS_NOT_COMPRESSED;
//        goto done;
//    }
    
    mp = vnode_mount(vp); 
    if (mp == NULL) {
        /*
         this should only be true before we mount the root filesystem
         we short-cut this return to avoid the call to getattr below, which
         will fail before root is mounted
         */
        ret = FILE_IS_NOT_COMPRESSED;
        goto done;
    }
    if ((mp->mnt_flag & MNT_LOCAL) == 0) {
        /* compression only supported on local filesystems */
        ret = FILE_IS_NOT_COMPRESSED;
        goto done;
    }
    
        /* lock our cnode data so that another caller doesn't change the state under us */
        decmpfs_lock_compressed_data(cp, 1);
        cnode_locked = 1;
        
        VATTR_INIT(&va_fetch);
        VATTR_WANTED(&va_fetch, va_flags);
        error = vnode_getattr(vp, &va_fetch, decmpfs_ctx);
        if (error) {
        /* failed to get the bsd flags so the file is not compressed */
        ret = FILE_IS_NOT_COMPRESSED;
        goto done;
    }
        if (va_fetch.va_flags & UF_COMPRESSED) {
                /* UF_COMPRESSED is on, make sure the file has the DECMPFS_XATTR_NAME xattr */
        error = decmpfs_fetch_compressed_header(vp, cp, &hdr, 1);
        if ((hdr != NULL) && (error == ERANGE)) {
            saveInvalid = 1;
        }
        if (error) {
            /* failed to get the xattr so the file is not compressed */
            ret = FILE_IS_NOT_COMPRESSED;
            goto done;
        }
        /* we got the xattr, so the file is compressed */
        ret = FILE_IS_COMPRESSED;
        goto done;
        }
    /* UF_COMPRESSED isn't on, so the file isn't compressed */
    ret = FILE_IS_NOT_COMPRESSED;
    
done:
    if (((ret == FILE_IS_COMPRESSED) || saveInvalid) && hdr) {
                /*
                 cache the uncompressed size away in the cnode
                 */
                
                if (!cnode_locked) {
                        /*
                         we should never get here since the only place ret is set to FILE_IS_COMPRESSED
                         is after the call to decmpfs_lock_compressed_data above
                         */
                        decmpfs_lock_compressed_data(cp, 1);
                        cnode_locked = 1;
                }
                
        decmpfs_cnode_set_vnode_cached_size(cp, hdr->uncompressed_size);
                decmpfs_cnode_set_vnode_state(cp, ret, 1);
        decmpfs_cnode_set_vnode_cmp_type(cp, hdr->compression_type, 1);
        /* remember if the xattr's size was equal to the minimal xattr */
        if (hdr->attr_size == sizeof(decmpfs_disk_header)) {
            decmpfs_cnode_set_vnode_minimal_xattr(cp, 1, 1);
        }
        if (ret == FILE_IS_COMPRESSED) {
            /* update the ubc's size for this file */
            ubc_setsize(vp, hdr->uncompressed_size);
        }
        } else {
                /* we might have already taken the lock above; if so, skip taking it again by passing cnode_locked as the skiplock parameter */
                decmpfs_cnode_set_vnode_state(cp, ret, cnode_locked);
        }
        
        if (cnode_locked) decmpfs_unlock_compressed_data(cp, 1);
    
    if (hdr) FREE(hdr, M_TEMP);
        
        switch(ret) {
        case FILE_IS_NOT_COMPRESSED:
                        return 0;
        case FILE_IS_COMPRESSED:
        case FILE_IS_CONVERTING:
                        return 1;
        default:
            /* unknown state, assume file is not compressed */
            ErrorLog("unknown ret %d\n", ret);
            return 0;
    }
}

int
decmpfs_update_attributes(vnode_t vp, struct vnode_attr *vap)
{
    int error = 0;
    
    if (VATTR_IS_ACTIVE(vap, va_flags)) {
        /* the BSD flags are being updated */
        if (vap->va_flags & UF_COMPRESSED) {
            /* the compressed bit is being set, did it change? */
            struct vnode_attr va_fetch;
            int old_flags = 0;
            VATTR_INIT(&va_fetch);
            VATTR_WANTED(&va_fetch, va_flags);
                        error = vnode_getattr(vp, &va_fetch, decmpfs_ctx);
            if (error)
                return error;
            
            old_flags = va_fetch.va_flags;
            
            if (!(old_flags & UF_COMPRESSED)) {
                /*
                 * Compression bit was turned on, make sure the file has the DECMPFS_XATTR_NAME attribute.
                 * This precludes anyone from using the UF_COMPRESSED bit for anything else, and it enforces
                 * an order of operation -- you must first do the setxattr and then the chflags.
                 */
                                
                                if (VATTR_IS_ACTIVE(vap, va_data_size)) {
                                        /*
                                         * don't allow the caller to set the BSD flag and the size in the same call
                                         * since this doesn't really make sense
                                         */
                                        vap->va_flags &= ~UF_COMPRESSED;
                                        return 0;
                                }
                                
                decmpfs_header *hdr = NULL;
                error = decmpfs_fetch_compressed_header(vp, NULL, &hdr, 1);
                if (error == 0) {
                    /*
                     allow the flag to be set since the decmpfs attribute is present
                     in that case, we also want to truncate the data fork of the file
                     */
                    VATTR_SET_ACTIVE(vap, va_data_size);
                    vap->va_data_size = 0;
                } else if (error == ERANGE) {
                    /* the file had a decmpfs attribute but the type was out of range, so don't muck with the file's data size */
                } else {
                    /* no DECMPFS_XATTR_NAME attribute, so deny the update */
                                        vap->va_flags &= ~UF_COMPRESSED;
                }
                if (hdr) FREE(hdr, M_TEMP);
            }
        }
    }
    
    return 0;
}

static int
wait_for_decompress(decmpfs_cnode *cp)
{
    int state;
    lck_mtx_lock(decompress_channel_mtx);
    do {
        state = decmpfs_fast_get_state(cp);
        if (state != FILE_IS_CONVERTING) {
            /* file is not decompressing */
            lck_mtx_unlock(decompress_channel_mtx);
            return state;
        }
        msleep((caddr_t)&decompress_channel, decompress_channel_mtx, PINOD, "wait_for_decompress", NULL);
    } while(1);
}

#pragma mark --- decmpfs hide query routines ---

int
decmpfs_hides_rsrc(vfs_context_t ctx, decmpfs_cnode *cp)
{
        /*
         WARNING!!!
         callers may (and do) pass NULL for ctx, so we should only use it
         for this equality comparison
         
         This routine should only be called after a file has already been through decmpfs_file_is_compressed
         */
        
        if (ctx == decmpfs_ctx)
                return 0;
        
        if (!decmpfs_fast_file_is_compressed(cp))
                return 0;
        
        /* all compressed files hide their resource fork */
        return 1;
}

int
decmpfs_hides_xattr(vfs_context_t ctx, decmpfs_cnode *cp, const char *xattr)
{
        /*
         WARNING!!!
         callers may (and do) pass NULL for ctx, so we should only use it
         for this equality comparison
     
         This routine should only be called after a file has already been through decmpfs_file_is_compressed
         */
        
        if (ctx == decmpfs_ctx)
                return 0;
        if (strncmp(xattr, XATTR_RESOURCEFORK_NAME, 22) == 0)
                return decmpfs_hides_rsrc(ctx, cp);
        if (!decmpfs_fast_file_is_compressed(cp))
    /* file is not compressed, so don't hide this xattr */
                return 0;
        if (strncmp(xattr, DECMPFS_XATTR_NAME, 11) == 0)
    /* it's our xattr, so hide it */
                return 1;
        /* don't hide this xattr */
        return 0;
}

#pragma mark --- registration/validation routines ---

errno_t
register_decmpfs_decompressor(uint32_t compression_type, decmpfs_registration *registration)
{
    /* called by kexts to register decompressors */
    
    errno_t ret = 0;
    int locked = 0;
    char resourceName[80];
    
    if ((compression_type >= CMP_MAX) ||
        (!registration) ||
        (registration->decmpfs_registration != DECMPFS_REGISTRATION_VERSION)) {
        ret = EINVAL;
        goto out;
    }
    
    lck_rw_lock_exclusive(decompressorsLock); locked = 1;
        
    /* make sure the registration for this type is zero */
        if (decompressors[compression_type] != NULL) {
                ret = EEXIST;
                goto out;
        }
    decompressors[compression_type] = registration;
    snprintf(resourceName, sizeof(resourceName), "com.apple.AppleFSCompression.Type%u", compression_type);
    IOServicePublishResource(resourceName, TRUE);
    wakeup((caddr_t)&decompressors);
    
out:
    if (locked) lck_rw_done(decompressorsLock);
    return ret;
}

errno_t
unregister_decmpfs_decompressor(uint32_t compression_type, decmpfs_registration *registration)
{
    /* called by kexts to unregister decompressors */
    
    errno_t ret = 0;
    int locked = 0;
    char resourceName[80];

    if ((compression_type >= CMP_MAX) ||
        (!registration) ||
        (registration->decmpfs_registration != DECMPFS_REGISTRATION_VERSION)) {
        ret = EINVAL;
        goto out;
    }
    
    lck_rw_lock_exclusive(decompressorsLock); locked = 1;
    if (decompressors[compression_type] != registration) {
        ret = EEXIST;
        goto out;
    }
    decompressors[compression_type] = NULL;
    snprintf(resourceName, sizeof(resourceName), "com.apple.AppleFSCompression.Type%u", compression_type);
    IOServicePublishResource(resourceName, FALSE);
    wakeup((caddr_t)&decompressors);
    
out:
    if (locked) lck_rw_done(decompressorsLock);
    return ret;
}

static int
compression_type_valid(decmpfs_header *hdr)
{
    /* fast pre-check to determine if the given compressor has checked in */
    int ret = 0;
    
    /* every compressor must have at least a fetch function */
    lck_rw_lock_shared(decompressorsLock);
    if (decmp_get_func(hdr->compression_type, fetch) != NULL) {
        ret = 1;
    }
    lck_rw_done(decompressorsLock);
        
    return ret;
}

#pragma mark --- compression/decompression routines ---

static int
decmpfs_fetch_uncompressed_data(vnode_t vp, decmpfs_header *hdr, off_t offset, user_ssize_t size, int nvec, decmpfs_vector *vec, uint64_t *bytes_read)
{
    /* get the uncompressed bytes for the specified region of vp by calling out to the registered compressor */
    
    int err          = 0;
        
    *bytes_read = 0;
    
    if ((uint64_t)offset >= hdr->uncompressed_size) {
        /* reading past end of file; nothing to do */
        err = 0;
        goto out;
    }
    if (offset < 0) {
        /* tried to read from before start of file */
        err = EINVAL;
        goto out;
    }
    if ((uint64_t)(offset + size) > hdr->uncompressed_size) {
        /* adjust size so we don't read past the end of the file */
                size = hdr->uncompressed_size - offset;
        }
    if (size == 0) {
        /* nothing to read */
        err = 0;
        goto out;
    }
    
    lck_rw_lock_shared(decompressorsLock);
    decmpfs_fetch_uncompressed_data_func fetch = decmp_get_func(hdr->compression_type, fetch);
    if (fetch) {
                err = fetch(vp, decmpfs_ctx, hdr, offset, size, nvec, vec, bytes_read);
    } else {
        err = ENOTSUP;
    }
    lck_rw_done(decompressorsLock);
    
out:
    return err;
}

static kern_return_t
commit_upl(upl_t upl, upl_offset_t pl_offset, size_t uplSize, int flags, int abort)
{
    kern_return_t kr = 0;
    
    /* commit the upl pages */
    if (abort) {
        VerboseLog("aborting upl, flags 0x%08x\n", flags);
                kr = ubc_upl_abort_range(upl, pl_offset, uplSize, flags);
        if (kr != KERN_SUCCESS)
            ErrorLog("ubc_upl_commit_range error %d\n", (int)kr);
    } else {
        VerboseLog("committing upl, flags 0x%08x\n", flags | UPL_COMMIT_CLEAR_DIRTY);
                kr = ubc_upl_commit_range(upl, pl_offset, uplSize, flags | UPL_COMMIT_CLEAR_DIRTY);
        if (kr != KERN_SUCCESS)
            ErrorLog("ubc_upl_commit_range error %d\n", (int)kr);
    }
    return kr;
}

errno_t
decmpfs_pagein_compressed(struct vnop_pagein_args *ap, int *is_compressed, decmpfs_cnode *cp)
{
    /* handles a page-in request from vfs for a compressed file */
    
    int err                      = 0;
    struct vnode *vp             = ap->a_vp;
    upl_t pl                     = ap->a_pl;
        upl_offset_t pl_offset       = ap->a_pl_offset;
    off_t f_offset               = ap->a_f_offset;
    size_t size                  = ap->a_size;
        int flags                    = ap->a_flags;
    off_t uplPos                 = 0;
    user_ssize_t uplSize         = 0;
        void *data                   = NULL;
    decmpfs_header *hdr = NULL;
    int abort_pagein             = 0;
    uint64_t cachedSize          = 0;
        int cmpdata_locked           = 0;
        
    if(!decmpfs_trylock_compressed_data(cp, 0)) {
            return EAGAIN;
    }
    cmpdata_locked = 1;
    
        
        if (flags & ~(UPL_IOSYNC | UPL_NOCOMMIT | UPL_NORDAHEAD)) {
                DebugLog("pagein: unknown flags 0x%08x\n", (flags & ~(UPL_IOSYNC | UPL_NOCOMMIT | UPL_NORDAHEAD)));
        }
    
    err = decmpfs_fetch_compressed_header(vp, cp, &hdr, 0);
    if (err != 0) {
        goto out;
    }
        
    cachedSize = hdr->uncompressed_size;
    
    if (!compression_type_valid(hdr)) {
        /* compressor not registered */
        err = ENOTSUP;
        goto out;
    }
    
    /* map the upl so we can fetch into it */
        kern_return_t kr = ubc_upl_map(pl, (vm_offset_t*)&data);
        if ((kr != KERN_SUCCESS) || (data == NULL)) {
                goto out;
        }
    
    uplPos = f_offset;
    uplSize = size;
        
    /* clip the size to the size of the file */
    if ((uint64_t)uplPos + uplSize > cachedSize) {
        /* truncate the read to the size of the file */
        uplSize = cachedSize - uplPos;
    }
        
    /* do the fetch */
    decmpfs_vector vec;
    
decompress:
    /* the mapped data pointer points to the first page of the page list, so we want to start filling in at an offset of pl_offset */
    vec.buf = (char*)data + pl_offset;
    vec.size = size;
    
    uint64_t did_read = 0;
        if (decmpfs_fast_get_state(cp) == FILE_IS_CONVERTING) {
                ErrorLog("unexpected pagein during decompress\n");
                /*
                 if the file is converting, this must be a recursive call to pagein from underneath a call to decmpfs_decompress_file;
                 pretend that it succeeded but don't do anything since we're just going to write over the pages anyway
                 */
                err = 0;
                did_read = 0;
        } else {
        err = decmpfs_fetch_uncompressed_data(vp, hdr, uplPos, uplSize, 1, &vec, &did_read);
        }
    if (err) {
        DebugLog("decmpfs_fetch_uncompressed_data err %d\n", err);
        int cmp_state = decmpfs_fast_get_state(cp);
        if (cmp_state == FILE_IS_CONVERTING) {
            DebugLog("cmp_state == FILE_IS_CONVERTING\n");
            cmp_state = wait_for_decompress(cp);
            if (cmp_state == FILE_IS_COMPRESSED) {
                DebugLog("cmp_state == FILE_IS_COMPRESSED\n");
                /* a decompress was attempted but it failed, let's try calling fetch again */
                goto decompress;
            }
        }
        if (cmp_state == FILE_IS_NOT_COMPRESSED) {
            DebugLog("cmp_state == FILE_IS_NOT_COMPRESSED\n");
            /* the file was decompressed after we started reading it */
            abort_pagein = 1;   /* we're not going to commit our data */
            *is_compressed = 0; /* instruct caller to fall back to its normal path */
        }
    }
    
    /* zero out whatever we didn't read, and zero out the end of the last page(s) */
    uint64_t total_size = (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
    if (did_read < total_size) {
        memset((char*)vec.buf + did_read, 0, total_size - did_read);
    }
    
        kr = ubc_upl_unmap(pl); data = NULL; /* make sure to set data to NULL so we don't try to unmap again below */
    if (kr != KERN_SUCCESS)
        ErrorLog("ubc_upl_unmap error %d\n", (int)kr);
    else {
        if (!abort_pagein) {
            /* commit our pages */
                        kr = commit_upl(pl, pl_offset, total_size, UPL_COMMIT_FREE_ON_EMPTY, 0);
        }
    }
    
out:
        if (data) ubc_upl_unmap(pl);
    if (hdr) FREE(hdr, M_TEMP);
        if (cmpdata_locked) decmpfs_unlock_compressed_data(cp, 0);
    if (err)
        ErrorLog("err %d\n", err);
    
        return err;
}

errno_t 
decmpfs_read_compressed(struct vnop_read_args *ap, int *is_compressed, decmpfs_cnode *cp)
{
    /* handles a read request from vfs for a compressed file */
        
    uio_t uio                    = ap->a_uio;
    vnode_t vp                   = ap->a_vp;
    int err                      = 0;
    int countInt                 = 0;
    off_t uplPos                 = 0;
    user_ssize_t uplSize         = 0;
    user_ssize_t uplRemaining    = 0;
    off_t curUplPos              = 0;
    user_ssize_t curUplSize      = 0;
    kern_return_t kr             = KERN_SUCCESS;
    int abort_read               = 0;
    void *data                   = NULL;
    uint64_t did_read            = 0;
    upl_t upl                    = NULL;
    upl_page_info_t *pli         = NULL;
    decmpfs_header *hdr          = NULL;
    uint64_t cachedSize          = 0;
    off_t uioPos                 = 0;
    user_ssize_t uioRemaining    = 0;
        int cmpdata_locked           = 0;
        
        decmpfs_lock_compressed_data(cp, 0); cmpdata_locked = 1;
        
    uplPos = uio_offset(uio);
    uplSize = uio_resid(uio);
    VerboseLog("uplPos %lld uplSize %lld\n", uplPos, uplSize);
        
    cachedSize = decmpfs_cnode_get_vnode_cached_size(cp);
    
    if ((uint64_t)uplPos + uplSize > cachedSize) {
        /* truncate the read to the size of the file */
        uplSize = cachedSize - uplPos;
    }
    
    /* give the cluster layer a chance to fill in whatever it already has */
    countInt = (uplSize > INT_MAX) ? INT_MAX : uplSize;
    err = cluster_copy_ubc_data(vp, uio, &countInt, 0);
    if (err != 0)
        goto out;
        
    /* figure out what's left */
    uioPos = uio_offset(uio);
    uioRemaining = uio_resid(uio);
    if ((uint64_t)uioPos + uioRemaining > cachedSize) {
        /* truncate the read to the size of the file */
        uioRemaining = cachedSize - uioPos;
    }
    
    if (uioRemaining <= 0) {
        /* nothing left */
        goto out;
    }
    
    err = decmpfs_fetch_compressed_header(vp, cp, &hdr, 0);
    if (err != 0) {
        goto out;
    }
    if (!compression_type_valid(hdr)) {
        err = ENOTSUP;
        goto out;
    }
    
    uplPos = uioPos;
    uplSize = uioRemaining;
#if COMPRESSION_DEBUG
    char path[PATH_MAX];
    DebugLog("%s: uplPos %lld uplSize %lld\n", vnpath(vp, path, sizeof(path)), (uint64_t)uplPos, (uint64_t)uplSize);
#endif
        
    lck_rw_lock_shared(decompressorsLock);
    decmpfs_adjust_fetch_region_func adjust_fetch = decmp_get_func(hdr->compression_type, adjust_fetch);
    if (adjust_fetch) {
        /* give the compressor a chance to adjust the portion of the file that we read */
                adjust_fetch(vp, decmpfs_ctx, hdr, &uplPos, &uplSize);
        VerboseLog("adjusted uplPos %lld uplSize %lld\n", (uint64_t)uplPos, (uint64_t)uplSize);
    }
    lck_rw_done(decompressorsLock);
    
    /* clip the adjusted size to the size of the file */
    if ((uint64_t)uplPos + uplSize > cachedSize) {
        /* truncate the read to the size of the file */
        uplSize = cachedSize - uplPos;
    }
    
    if (uplSize <= 0) {
        /* nothing left */
        goto out;
    }
    
    /*
     since we're going to create a upl for the given region of the file,
     make sure we're on page boundaries
     */
    
    if (uplPos & (PAGE_SIZE - 1)) {
        /* round position down to page boundary */
        uplSize += (uplPos & (PAGE_SIZE - 1));
        uplPos &= ~(PAGE_SIZE - 1);
    }
    /* round size up to page multiple */
    uplSize = (uplSize + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
    
    VerboseLog("new uplPos %lld uplSize %lld\n", (uint64_t)uplPos, (uint64_t)uplSize);
    
    uplRemaining = uplSize;
    curUplPos = uplPos;
    curUplSize = 0;
    
    while(uplRemaining > 0) {
        /* start after the last upl */
        curUplPos += curUplSize;
        
        /* clip to max upl size */
        curUplSize = uplRemaining;
        if (curUplSize > MAX_UPL_SIZE * PAGE_SIZE) {
            curUplSize = MAX_UPL_SIZE * PAGE_SIZE;
        }
        
        /* create the upl */
        kr = ubc_create_upl(vp, curUplPos, curUplSize, &upl, &pli, UPL_SET_LITE);
        if (kr != KERN_SUCCESS) {
            ErrorLog("ubc_create_upl error %d\n", (int)kr);
            err = EINVAL;
            goto out;
        }
        VerboseLog("curUplPos %lld curUplSize %lld\n", (uint64_t)curUplPos, (uint64_t)curUplSize);
                
        /* map the upl */
        kr = ubc_upl_map(upl, (vm_offset_t*)&data);
        if (kr != KERN_SUCCESS) {
            ErrorLog("ubc_upl_map error %d\n", (int)kr);
            err = EINVAL;
            goto out;
        }
        
        /* make sure the map succeeded */
        if (!data) {
            ErrorLog("ubc_upl_map mapped null\n");
            err = EINVAL;
            goto out;
        }
        
        /* fetch uncompressed data into the mapped upl */
        decmpfs_vector vec;
    decompress:
        vec = (decmpfs_vector){ .buf = data, .size = curUplSize };
        err = decmpfs_fetch_uncompressed_data(vp, hdr, curUplPos, curUplSize, 1, &vec, &did_read);
        if (err) {
            ErrorLog("decmpfs_fetch_uncompressed_data err %d\n", err);
            
            /* maybe the file is converting to decompressed */
            int cmp_state = decmpfs_fast_get_state(cp);
            if (cmp_state == FILE_IS_CONVERTING) {
                ErrorLog("cmp_state == FILE_IS_CONVERTING\n");
                cmp_state = wait_for_decompress(cp);
                if (cmp_state == FILE_IS_COMPRESSED) {
                    ErrorLog("cmp_state == FILE_IS_COMPRESSED\n");
                    /* a decompress was attempted but it failed, let's try fetching again */
                    goto decompress;
                }
            }
            if (cmp_state == FILE_IS_NOT_COMPRESSED) {
                ErrorLog("cmp_state == FILE_IS_NOT_COMPRESSED\n");
                /* the file was decompressed after we started reading it */
                abort_read = 1;     /* we're not going to commit our data */
                *is_compressed = 0; /* instruct caller to fall back to its normal path */
            }
            kr = KERN_FAILURE;
            did_read = 0;
        }
        /* zero out the remainder of the last page */
        memset((char*)data + did_read, 0, curUplSize - did_read);
        kr = ubc_upl_unmap(upl);
        if (kr == KERN_SUCCESS) {
            if (abort_read) {
                                kr = commit_upl(upl, 0, curUplSize, UPL_ABORT_FREE_ON_EMPTY, 1);
            } else {
                VerboseLog("uioPos %lld uioRemaining %lld\n", (uint64_t)uioPos, (uint64_t)uioRemaining);
                if (uioRemaining) {
                    off_t uplOff = uioPos - curUplPos;
                    if (uplOff < 0) {
                        ErrorLog("uplOff %lld should never be negative\n", (int64_t)uplOff);
                        err = EINVAL;
                    } else {
                        off_t count = curUplPos + curUplSize - uioPos;
                        if (count < 0) {
                            /* this upl is entirely before the uio */
                        } else {
                            if (count > uioRemaining)
                                count = uioRemaining;
                            int io_resid = count;
                            err = cluster_copy_upl_data(uio, upl, uplOff, &io_resid);
                            int copied = count - io_resid;
                            VerboseLog("uplOff %lld count %lld copied %lld\n", (uint64_t)uplOff, (uint64_t)count, (uint64_t)copied);
                            if (err) {
                                ErrorLog("cluster_copy_upl_data err %d\n", err);
                            }
                            uioPos += copied;
                            uioRemaining -= copied;
                        }
                    }
                }
                                kr = commit_upl(upl, 0, curUplSize, UPL_COMMIT_FREE_ON_EMPTY | UPL_COMMIT_INACTIVATE, 0);
                if (err) {
                    goto out;
                }
            }
        } else {
            ErrorLog("ubc_upl_unmap error %d\n", (int)kr);
        }
        
        uplRemaining -= curUplSize;
    }
    
out:
    if (hdr) FREE(hdr, M_TEMP);
        if (cmpdata_locked) decmpfs_unlock_compressed_data(cp, 0);
    if (err) {/* something went wrong */
        ErrorLog("err %d\n", err);
        return err;
    }
        
#if COMPRESSION_DEBUG
    uplSize = uio_resid(uio);
    if (uplSize)
        VerboseLog("still %lld bytes to copy\n", uplSize);
#endif
    return 0;
}

int
decmpfs_free_compressed_data(vnode_t vp, decmpfs_cnode *cp)
{
    /*
     call out to the decompressor to free remove any data associated with this compressed file
     then delete the file's compression xattr
     */
    
    decmpfs_header *hdr = NULL;
    int err = decmpfs_fetch_compressed_header(vp, cp, &hdr, 0);
    if (err) {
        ErrorLog("decmpfs_fetch_compressed_header err %d\n", err);
    } else {
        lck_rw_lock_shared(decompressorsLock);
        decmpfs_free_compressed_data_func free_data = decmp_get_func(hdr->compression_type, free_data);
        if (free_data) {
                        err = free_data(vp, decmpfs_ctx, hdr);
        } else {
            /* nothing to do, so no error */
            err = 0;
        }
        lck_rw_done(decompressorsLock);
        
        if (err != 0) {
            ErrorLog("decompressor err %d\n", err);
        }
    }
    
    /* delete the xattr */
        err = vn_removexattr(vp, DECMPFS_XATTR_NAME, 0, decmpfs_ctx);
    if (err != 0) {
        goto out;
    }
    
out:
    if (hdr) FREE(hdr, M_TEMP);
    return err;
}

#pragma mark --- file conversion routines ---

static int
unset_compressed_flag(vnode_t vp)
{
    int err = 0;
    struct vnode_attr va;
    int new_bsdflags = 0;
    
    VATTR_INIT(&va);
    VATTR_WANTED(&va, va_flags);
        err = vnode_getattr(vp, &va, decmpfs_ctx);
    
    if (err != 0) {
        ErrorLog("vnode_getattr err %d\n", err);
    } else {
        new_bsdflags = va.va_flags & ~UF_COMPRESSED;
        
        VATTR_INIT(&va);
        VATTR_SET(&va, va_flags, new_bsdflags);
                err = vnode_setattr(vp, &va, decmpfs_ctx);
        if (err != 0) {
            ErrorLog("vnode_setattr err %d\n", err);
        }
    }
    return err;
}

int
decmpfs_decompress_file(vnode_t vp, decmpfs_cnode *cp, off_t toSize, int truncate_okay, int skiplock)
{
        /* convert a compressed file to an uncompressed file */
        
        int err                      = 0;
        char *data                   = NULL;
        uio_t uio_w                  = 0;
        off_t offset                 = 0;
        uint32_t old_state           = 0;
        uint32_t new_state           = 0;
        int update_file_state        = 0;
        int allocSize                = 0;
        decmpfs_header *hdr = NULL;
        int cmpdata_locked           = 0;
        off_t remaining              = 0;
        uint64_t uncompressed_size   = 0;
        
        if (!skiplock) {
                decmpfs_lock_compressed_data(cp, 1); cmpdata_locked = 1;
        }
        
decompress:
        old_state = decmpfs_fast_get_state(cp);
        
        switch(old_state) {
                case FILE_IS_NOT_COMPRESSED:
                {
                        /* someone else decompressed the file */
                        err = 0;
                        goto out;
                }
                        
                case FILE_TYPE_UNKNOWN:
                {
                        /* the file is in an unknown state, so update the state and retry */
                        (void)decmpfs_file_is_compressed(vp, cp);
                        
                        /* try again */
                        goto decompress;
                }
                        
                case FILE_IS_COMPRESSED:
                {
                        /* the file is compressed, so decompress it */
                        break;
                }
                        
                default:
                {
                        /*
                         this shouldn't happen since multiple calls to decmpfs_decompress_file lock each other out,
                         and when decmpfs_decompress_file returns, the state should be always be set back to
                         FILE_IS_NOT_COMPRESSED or FILE_IS_UNKNOWN
                         */
                        err = EINVAL;
                        goto out;
                }
        }
        
    err = decmpfs_fetch_compressed_header(vp, cp, &hdr, 0);
        if (err != 0) {
                goto out;
        }
        
        uncompressed_size = hdr->uncompressed_size;
        if (toSize == -1)
                toSize = hdr->uncompressed_size;
        
        if (toSize == 0) {
                /* special case truncating the file to zero bytes */
                goto nodecmp;
        } else if ((uint64_t)toSize > hdr->uncompressed_size) {
                /* the caller is trying to grow the file, so we should decompress all the data */
                toSize = hdr->uncompressed_size;
        }
        
        allocSize = MIN(64*1024, toSize);
        MALLOC(data, char *, allocSize, M_TEMP, M_WAITOK);
        if (!data) {
                err = ENOMEM;
                goto out;
        }
        
        uio_w = uio_create(1, 0LL, UIO_SYSSPACE, UIO_WRITE);
        if (!uio_w) {
                err = ENOMEM;
                goto out;
        }
        uio_w->uio_flags |= UIO_FLAGS_IS_COMPRESSED_FILE;
        
        remaining = toSize;
        
        /* tell the buffer cache that this is an empty file */
        ubc_setsize(vp, 0);
        
        /* if we got here, we need to decompress the file */
        decmpfs_cnode_set_vnode_state(cp, FILE_IS_CONVERTING, 1);
        
        while(remaining > 0) {
                /* loop decompressing data from the file and writing it into the data fork */
                
                uint64_t bytes_read = 0;
                decmpfs_vector vec = { .buf = data, .size = MIN(allocSize, remaining) };
                err = decmpfs_fetch_uncompressed_data(vp, hdr, offset, vec.size, 1, &vec, &bytes_read);
                if (err != 0) {
                        ErrorLog("decmpfs_fetch_uncompressed_data err %d\n", err);
                        goto out;
                }
                
                if (bytes_read == 0) {
                        /* we're done reading data */
                        break;
                }
                
                uio_reset(uio_w, offset, UIO_SYSSPACE, UIO_WRITE);
                err = uio_addiov(uio_w, CAST_USER_ADDR_T(data), bytes_read);
                if (err != 0) {
                        ErrorLog("uio_addiov err %d\n", err);
                        err = ENOMEM;
                        goto out;
                }
                
                err = VNOP_WRITE(vp, uio_w, 0, decmpfs_ctx);
                if (err != 0) {
                        /* if the write failed, truncate the file to zero bytes */
                        ErrorLog("VNOP_WRITE err %d\n", err);
                        break;
                }
                offset += bytes_read;
                remaining -= bytes_read;
        }
        
        if (err == 0) {
                if (offset != toSize) {
                        ErrorLog("file decompressed to %lld instead of %lld\n", offset, toSize);
                        err = EINVAL;
                        goto out;
                }
        }
        
        if (err == 0) {
                /* sync the data and metadata */
                err = VNOP_FSYNC(vp, MNT_WAIT, decmpfs_ctx);
                if (err != 0) {
                        ErrorLog("VNOP_FSYNC err %d\n", err);
                        goto out;
                }
        }
        
        if (err != 0) {
                /* write, setattr, or fsync failed */
                ErrorLog("aborting decompress, err %d\n", err);
                if (truncate_okay) {
                        /* truncate anything we might have written */
                        int error = vnode_setsize(vp, 0, 0, decmpfs_ctx);
                        ErrorLog("vnode_setsize err %d\n", error);
                }
                goto out;
        }
        
nodecmp:
        /* if we're truncating the file to zero bytes, we'll skip ahead to here */
        
        /* unset the compressed flag */
        unset_compressed_flag(vp);
        
        /* free the compressed data associated with this file */
        err = decmpfs_free_compressed_data(vp, cp);
        if (err != 0) {
                ErrorLog("decmpfs_free_compressed_data err %d\n", err);
        }
        
        /*
         even if free_compressed_data or vnode_getattr/vnode_setattr failed, return success
         since we succeeded in writing all of the file data to the data fork
         */
        err = 0;
        
        /* if we got this far, the file was successfully decompressed */
        update_file_state = 1;
        new_state = FILE_IS_NOT_COMPRESSED;
        
#if COMPRESSION_DEBUG
        {
                uint64_t filesize = 0;
                vnsize(vp, &filesize);
                DebugLog("new file size %lld\n", filesize);
        }
#endif
        
out:
        if (hdr) FREE(hdr, M_TEMP);
        if (data) FREE(data, M_TEMP);
        if (uio_w) uio_free(uio_w);
        
        if (err != 0) {
                /* if there was a failure, reset compression flags to unknown and clear the buffer cache data */
                update_file_state = 1;
                new_state = FILE_TYPE_UNKNOWN;
                if (uncompressed_size) {
                        ubc_setsize(vp, 0);
                        ubc_setsize(vp, uncompressed_size);
        }
        }
        
        if (update_file_state) {
                lck_mtx_lock(decompress_channel_mtx);
                decmpfs_cnode_set_vnode_state(cp, new_state, 1);
                wakeup((caddr_t)&decompress_channel); /* wake up anyone who might have been waiting for decompression */
                lck_mtx_unlock(decompress_channel_mtx);
        }
        
        if (cmpdata_locked) decmpfs_unlock_compressed_data(cp, 1);
        
        return err;
}

#pragma mark --- Type1 compressor ---

/*
 The "Type1" compressor stores the data fork directly in the compression xattr
 */

static int
decmpfs_validate_compressed_file_Type1(__unused vnode_t vp, __unused vfs_context_t ctx, decmpfs_header *hdr)
{
    int err          = 0;
    
    if (hdr->uncompressed_size + sizeof(decmpfs_disk_header) != (uint64_t)hdr->attr_size) {
        err = EINVAL;
        goto out;
    }
out:
    return err;    
}

static int
decmpfs_fetch_uncompressed_data_Type1(__unused vnode_t vp, __unused vfs_context_t ctx, decmpfs_header *hdr, off_t offset, user_ssize_t size, int nvec, decmpfs_vector *vec, uint64_t *bytes_read)
{
    int err          = 0;
    int i;
    user_ssize_t remaining;
    
    if (hdr->uncompressed_size + sizeof(decmpfs_disk_header) != (uint64_t)hdr->attr_size) {
        err = EINVAL;
        goto out;
    }
    
#if COMPRESSION_DEBUG
    static int dummy = 0; // prevent syslog from coalescing printfs
    char path[PATH_MAX];
    DebugLog("%s: %d memcpy %lld at %lld\n", vnpath(vp, path, sizeof(path)), dummy++, size, (uint64_t)offset);
#endif
    
    remaining = size;
    for (i = 0; (i < nvec) && (remaining > 0); i++) {
        user_ssize_t curCopy = vec[i].size;
        if (curCopy > remaining)
            curCopy = remaining;
        memcpy(vec[i].buf, hdr->attr_bytes + offset, curCopy);
        offset += curCopy;
        remaining -= curCopy;
    }
    
    if ((bytes_read) && (err == 0))
        *bytes_read = (size - remaining);
    
out:
    return err;
}

static decmpfs_registration Type1Reg =
{
    .decmpfs_registration = DECMPFS_REGISTRATION_VERSION,
    .validate          = decmpfs_validate_compressed_file_Type1,
    .adjust_fetch      = NULL, /* no adjust necessary */
    .fetch             = decmpfs_fetch_uncompressed_data_Type1,
    .free_data         = NULL  /* no free necessary */
};

#pragma mark --- decmpfs initialization ---

void decmpfs_init()
{
    static int done = 0;
    if (done) return;
    
        decmpfs_ctx = vfs_context_create(vfs_context_kernel());
        
    lck_grp_attr_t *attr = lck_grp_attr_alloc_init();
    decmpfs_lockgrp = lck_grp_alloc_init("VFSCOMP",  attr);
    decompressorsLock = lck_rw_alloc_init(decmpfs_lockgrp, NULL);
    decompress_channel_mtx = lck_mtx_alloc_init(decmpfs_lockgrp, NULL);
    
    register_decmpfs_decompressor(CMP_Type1, &Type1Reg);
    
    done = 1;
}
#endif /* HFS_COMPRESSION */