--- /dev/null
+/*
+ * 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 = ®Char[offset];
+ void **funcPtr = (void**)func;
+ return funcPtr[0];
+}
+
+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);
+ }
+
+ // 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) _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;
+
+ 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;
+ 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;
+
+ 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;
+ 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 | UPL_COMMIT_INACTIVATE, 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 */
projects / apple / xnu.git / blobdiff